1 /* 2 * drivers/s390/net/qeth_l3_sys.c 3 * 4 * Copyright IBM Corp. 2007 5 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>, 6 * Frank Pavlic <fpavlic@de.ibm.com>, 7 * Thomas Spatzier <tspat@de.ibm.com>, 8 * Frank Blaschka <frank.blaschka@de.ibm.com> 9 */ 10 11 #include "qeth_l3.h" 12 13 #define QETH_DEVICE_ATTR(_id, _name, _mode, _show, _store) \ 14 struct device_attribute dev_attr_##_id = __ATTR(_name, _mode, _show, _store) 15 16 static const char *qeth_l3_get_checksum_str(struct qeth_card *card) 17 { 18 if (card->options.checksum_type == SW_CHECKSUMMING) 19 return "sw"; 20 else if (card->options.checksum_type == HW_CHECKSUMMING) 21 return "hw"; 22 else 23 return "no"; 24 } 25 26 static ssize_t qeth_l3_dev_route_show(struct qeth_card *card, 27 struct qeth_routing_info *route, char *buf) 28 { 29 switch (route->type) { 30 case PRIMARY_ROUTER: 31 return sprintf(buf, "%s\n", "primary router"); 32 case SECONDARY_ROUTER: 33 return sprintf(buf, "%s\n", "secondary router"); 34 case MULTICAST_ROUTER: 35 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO) 36 return sprintf(buf, "%s\n", "multicast router+"); 37 else 38 return sprintf(buf, "%s\n", "multicast router"); 39 case PRIMARY_CONNECTOR: 40 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO) 41 return sprintf(buf, "%s\n", "primary connector+"); 42 else 43 return sprintf(buf, "%s\n", "primary connector"); 44 case SECONDARY_CONNECTOR: 45 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO) 46 return sprintf(buf, "%s\n", "secondary connector+"); 47 else 48 return sprintf(buf, "%s\n", "secondary connector"); 49 default: 50 return sprintf(buf, "%s\n", "no"); 51 } 52 } 53 54 static ssize_t qeth_l3_dev_route4_show(struct device *dev, 55 struct device_attribute *attr, char *buf) 56 { 57 struct qeth_card *card = dev_get_drvdata(dev); 58 59 if (!card) 60 return -EINVAL; 61 62 return qeth_l3_dev_route_show(card, &card->options.route4, buf); 63 } 64 65 static ssize_t qeth_l3_dev_route_store(struct qeth_card *card, 66 struct qeth_routing_info *route, enum qeth_prot_versions prot, 67 const char *buf, size_t count) 68 { 69 enum qeth_routing_types old_route_type = route->type; 70 char *tmp; 71 int rc; 72 73 tmp = strsep((char **) &buf, "\n"); 74 75 if (!strcmp(tmp, "no_router")) { 76 route->type = NO_ROUTER; 77 } else if (!strcmp(tmp, "primary_connector")) { 78 route->type = PRIMARY_CONNECTOR; 79 } else if (!strcmp(tmp, "secondary_connector")) { 80 route->type = SECONDARY_CONNECTOR; 81 } else if (!strcmp(tmp, "primary_router")) { 82 route->type = PRIMARY_ROUTER; 83 } else if (!strcmp(tmp, "secondary_router")) { 84 route->type = SECONDARY_ROUTER; 85 } else if (!strcmp(tmp, "multicast_router")) { 86 route->type = MULTICAST_ROUTER; 87 } else { 88 return -EINVAL; 89 } 90 if (((card->state == CARD_STATE_SOFTSETUP) || 91 (card->state == CARD_STATE_UP)) && 92 (old_route_type != route->type)) { 93 if (prot == QETH_PROT_IPV4) 94 rc = qeth_l3_setrouting_v4(card); 95 else if (prot == QETH_PROT_IPV6) 96 rc = qeth_l3_setrouting_v6(card); 97 } 98 return count; 99 } 100 101 static ssize_t qeth_l3_dev_route4_store(struct device *dev, 102 struct device_attribute *attr, const char *buf, size_t count) 103 { 104 struct qeth_card *card = dev_get_drvdata(dev); 105 106 if (!card) 107 return -EINVAL; 108 109 return qeth_l3_dev_route_store(card, &card->options.route4, 110 QETH_PROT_IPV4, buf, count); 111 } 112 113 static DEVICE_ATTR(route4, 0644, qeth_l3_dev_route4_show, 114 qeth_l3_dev_route4_store); 115 116 static ssize_t qeth_l3_dev_route6_show(struct device *dev, 117 struct device_attribute *attr, char *buf) 118 { 119 struct qeth_card *card = dev_get_drvdata(dev); 120 121 if (!card) 122 return -EINVAL; 123 124 return qeth_l3_dev_route_show(card, &card->options.route6, buf); 125 } 126 127 static ssize_t qeth_l3_dev_route6_store(struct device *dev, 128 struct device_attribute *attr, const char *buf, size_t count) 129 { 130 struct qeth_card *card = dev_get_drvdata(dev); 131 132 if (!card) 133 return -EINVAL; 134 135 return qeth_l3_dev_route_store(card, &card->options.route6, 136 QETH_PROT_IPV6, buf, count); 137 } 138 139 static DEVICE_ATTR(route6, 0644, qeth_l3_dev_route6_show, 140 qeth_l3_dev_route6_store); 141 142 static ssize_t qeth_l3_dev_fake_broadcast_show(struct device *dev, 143 struct device_attribute *attr, char *buf) 144 { 145 struct qeth_card *card = dev_get_drvdata(dev); 146 147 if (!card) 148 return -EINVAL; 149 150 return sprintf(buf, "%i\n", card->options.fake_broadcast? 1:0); 151 } 152 153 static ssize_t qeth_l3_dev_fake_broadcast_store(struct device *dev, 154 struct device_attribute *attr, const char *buf, size_t count) 155 { 156 struct qeth_card *card = dev_get_drvdata(dev); 157 char *tmp; 158 int i; 159 160 if (!card) 161 return -EINVAL; 162 163 if ((card->state != CARD_STATE_DOWN) && 164 (card->state != CARD_STATE_RECOVER)) 165 return -EPERM; 166 167 i = simple_strtoul(buf, &tmp, 16); 168 if ((i == 0) || (i == 1)) 169 card->options.fake_broadcast = i; 170 else { 171 return -EINVAL; 172 } 173 return count; 174 } 175 176 static DEVICE_ATTR(fake_broadcast, 0644, qeth_l3_dev_fake_broadcast_show, 177 qeth_l3_dev_fake_broadcast_store); 178 179 static ssize_t qeth_l3_dev_broadcast_mode_show(struct device *dev, 180 struct device_attribute *attr, char *buf) 181 { 182 struct qeth_card *card = dev_get_drvdata(dev); 183 184 if (!card) 185 return -EINVAL; 186 187 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) || 188 (card->info.link_type == QETH_LINK_TYPE_LANE_TR))) 189 return sprintf(buf, "n/a\n"); 190 191 return sprintf(buf, "%s\n", (card->options.broadcast_mode == 192 QETH_TR_BROADCAST_ALLRINGS)? 193 "all rings":"local"); 194 } 195 196 static ssize_t qeth_l3_dev_broadcast_mode_store(struct device *dev, 197 struct device_attribute *attr, const char *buf, size_t count) 198 { 199 struct qeth_card *card = dev_get_drvdata(dev); 200 char *tmp; 201 202 if (!card) 203 return -EINVAL; 204 205 if ((card->state != CARD_STATE_DOWN) && 206 (card->state != CARD_STATE_RECOVER)) 207 return -EPERM; 208 209 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) || 210 (card->info.link_type == QETH_LINK_TYPE_LANE_TR))) { 211 return -EINVAL; 212 } 213 214 tmp = strsep((char **) &buf, "\n"); 215 216 if (!strcmp(tmp, "local")) { 217 card->options.broadcast_mode = QETH_TR_BROADCAST_LOCAL; 218 return count; 219 } else if (!strcmp(tmp, "all_rings")) { 220 card->options.broadcast_mode = QETH_TR_BROADCAST_ALLRINGS; 221 return count; 222 } else { 223 return -EINVAL; 224 } 225 return count; 226 } 227 228 static DEVICE_ATTR(broadcast_mode, 0644, qeth_l3_dev_broadcast_mode_show, 229 qeth_l3_dev_broadcast_mode_store); 230 231 static ssize_t qeth_l3_dev_canonical_macaddr_show(struct device *dev, 232 struct device_attribute *attr, char *buf) 233 { 234 struct qeth_card *card = dev_get_drvdata(dev); 235 236 if (!card) 237 return -EINVAL; 238 239 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) || 240 (card->info.link_type == QETH_LINK_TYPE_LANE_TR))) 241 return sprintf(buf, "n/a\n"); 242 243 return sprintf(buf, "%i\n", (card->options.macaddr_mode == 244 QETH_TR_MACADDR_CANONICAL)? 1:0); 245 } 246 247 static ssize_t qeth_l3_dev_canonical_macaddr_store(struct device *dev, 248 struct device_attribute *attr, const char *buf, size_t count) 249 { 250 struct qeth_card *card = dev_get_drvdata(dev); 251 char *tmp; 252 int i; 253 254 if (!card) 255 return -EINVAL; 256 257 if ((card->state != CARD_STATE_DOWN) && 258 (card->state != CARD_STATE_RECOVER)) 259 return -EPERM; 260 261 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) || 262 (card->info.link_type == QETH_LINK_TYPE_LANE_TR))) { 263 return -EINVAL; 264 } 265 266 i = simple_strtoul(buf, &tmp, 16); 267 if ((i == 0) || (i == 1)) 268 card->options.macaddr_mode = i? 269 QETH_TR_MACADDR_CANONICAL : 270 QETH_TR_MACADDR_NONCANONICAL; 271 else { 272 return -EINVAL; 273 } 274 return count; 275 } 276 277 static DEVICE_ATTR(canonical_macaddr, 0644, qeth_l3_dev_canonical_macaddr_show, 278 qeth_l3_dev_canonical_macaddr_store); 279 280 static ssize_t qeth_l3_dev_checksum_show(struct device *dev, 281 struct device_attribute *attr, char *buf) 282 { 283 struct qeth_card *card = dev_get_drvdata(dev); 284 285 if (!card) 286 return -EINVAL; 287 288 return sprintf(buf, "%s checksumming\n", 289 qeth_l3_get_checksum_str(card)); 290 } 291 292 static ssize_t qeth_l3_dev_checksum_store(struct device *dev, 293 struct device_attribute *attr, const char *buf, size_t count) 294 { 295 struct qeth_card *card = dev_get_drvdata(dev); 296 enum qeth_checksum_types csum_type; 297 char *tmp; 298 int rc; 299 300 if (!card) 301 return -EINVAL; 302 303 tmp = strsep((char **) &buf, "\n"); 304 if (!strcmp(tmp, "sw_checksumming")) 305 csum_type = SW_CHECKSUMMING; 306 else if (!strcmp(tmp, "hw_checksumming")) 307 csum_type = HW_CHECKSUMMING; 308 else if (!strcmp(tmp, "no_checksumming")) 309 csum_type = NO_CHECKSUMMING; 310 else 311 return -EINVAL; 312 313 rc = qeth_l3_set_rx_csum(card, csum_type); 314 if (rc) 315 return rc; 316 return count; 317 } 318 319 static DEVICE_ATTR(checksumming, 0644, qeth_l3_dev_checksum_show, 320 qeth_l3_dev_checksum_store); 321 322 static ssize_t qeth_l3_dev_sniffer_show(struct device *dev, 323 struct device_attribute *attr, char *buf) 324 { 325 struct qeth_card *card = dev_get_drvdata(dev); 326 327 if (!card) 328 return -EINVAL; 329 330 return sprintf(buf, "%i\n", card->options.sniffer ? 1 : 0); 331 } 332 333 static ssize_t qeth_l3_dev_sniffer_store(struct device *dev, 334 struct device_attribute *attr, const char *buf, size_t count) 335 { 336 struct qeth_card *card = dev_get_drvdata(dev); 337 int ret; 338 unsigned long i; 339 340 if (!card) 341 return -EINVAL; 342 343 if (card->info.type != QETH_CARD_TYPE_IQD) 344 return -EPERM; 345 346 if ((card->state != CARD_STATE_DOWN) && 347 (card->state != CARD_STATE_RECOVER)) 348 return -EPERM; 349 350 ret = strict_strtoul(buf, 16, &i); 351 if (ret) 352 return -EINVAL; 353 switch (i) { 354 case 0: 355 card->options.sniffer = i; 356 break; 357 case 1: 358 ret = qdio_get_ssqd_desc(CARD_DDEV(card), &card->ssqd); 359 if (card->ssqd.qdioac2 & QETH_SNIFF_AVAIL) { 360 card->options.sniffer = i; 361 if (card->qdio.init_pool.buf_count != 362 QETH_IN_BUF_COUNT_MAX) 363 qeth_realloc_buffer_pool(card, 364 QETH_IN_BUF_COUNT_MAX); 365 break; 366 } else 367 return -EPERM; 368 default: /* fall through */ 369 return -EINVAL; 370 } 371 return count; 372 } 373 374 static DEVICE_ATTR(sniffer, 0644, qeth_l3_dev_sniffer_show, 375 qeth_l3_dev_sniffer_store); 376 377 static ssize_t qeth_l3_dev_large_send_show(struct device *dev, 378 struct device_attribute *attr, char *buf) 379 { 380 struct qeth_card *card = dev_get_drvdata(dev); 381 382 if (!card) 383 return -EINVAL; 384 385 switch (card->options.large_send) { 386 case QETH_LARGE_SEND_NO: 387 return sprintf(buf, "%s\n", "no"); 388 case QETH_LARGE_SEND_TSO: 389 return sprintf(buf, "%s\n", "TSO"); 390 default: 391 return sprintf(buf, "%s\n", "N/A"); 392 } 393 } 394 395 static ssize_t qeth_l3_dev_large_send_store(struct device *dev, 396 struct device_attribute *attr, const char *buf, size_t count) 397 { 398 struct qeth_card *card = dev_get_drvdata(dev); 399 enum qeth_large_send_types type; 400 int rc = 0; 401 char *tmp; 402 403 if (!card) 404 return -EINVAL; 405 tmp = strsep((char **) &buf, "\n"); 406 if (!strcmp(tmp, "no")) 407 type = QETH_LARGE_SEND_NO; 408 else if (!strcmp(tmp, "TSO")) 409 type = QETH_LARGE_SEND_TSO; 410 else 411 return -EINVAL; 412 413 if (card->options.large_send == type) 414 return count; 415 rc = qeth_l3_set_large_send(card, type); 416 if (rc) 417 return rc; 418 return count; 419 } 420 421 static DEVICE_ATTR(large_send, 0644, qeth_l3_dev_large_send_show, 422 qeth_l3_dev_large_send_store); 423 424 static struct attribute *qeth_l3_device_attrs[] = { 425 &dev_attr_route4.attr, 426 &dev_attr_route6.attr, 427 &dev_attr_fake_broadcast.attr, 428 &dev_attr_broadcast_mode.attr, 429 &dev_attr_canonical_macaddr.attr, 430 &dev_attr_checksumming.attr, 431 &dev_attr_sniffer.attr, 432 &dev_attr_large_send.attr, 433 NULL, 434 }; 435 436 static struct attribute_group qeth_l3_device_attr_group = { 437 .attrs = qeth_l3_device_attrs, 438 }; 439 440 static ssize_t qeth_l3_dev_ipato_enable_show(struct device *dev, 441 struct device_attribute *attr, char *buf) 442 { 443 struct qeth_card *card = dev_get_drvdata(dev); 444 445 if (!card) 446 return -EINVAL; 447 448 return sprintf(buf, "%i\n", card->ipato.enabled? 1:0); 449 } 450 451 static ssize_t qeth_l3_dev_ipato_enable_store(struct device *dev, 452 struct device_attribute *attr, const char *buf, size_t count) 453 { 454 struct qeth_card *card = dev_get_drvdata(dev); 455 char *tmp; 456 457 if (!card) 458 return -EINVAL; 459 460 if ((card->state != CARD_STATE_DOWN) && 461 (card->state != CARD_STATE_RECOVER)) 462 return -EPERM; 463 464 tmp = strsep((char **) &buf, "\n"); 465 if (!strcmp(tmp, "toggle")) { 466 card->ipato.enabled = (card->ipato.enabled)? 0 : 1; 467 } else if (!strcmp(tmp, "1")) { 468 card->ipato.enabled = 1; 469 } else if (!strcmp(tmp, "0")) { 470 card->ipato.enabled = 0; 471 } else { 472 return -EINVAL; 473 } 474 return count; 475 } 476 477 static QETH_DEVICE_ATTR(ipato_enable, enable, 0644, 478 qeth_l3_dev_ipato_enable_show, 479 qeth_l3_dev_ipato_enable_store); 480 481 static ssize_t qeth_l3_dev_ipato_invert4_show(struct device *dev, 482 struct device_attribute *attr, char *buf) 483 { 484 struct qeth_card *card = dev_get_drvdata(dev); 485 486 if (!card) 487 return -EINVAL; 488 489 return sprintf(buf, "%i\n", card->ipato.invert4? 1:0); 490 } 491 492 static ssize_t qeth_l3_dev_ipato_invert4_store(struct device *dev, 493 struct device_attribute *attr, 494 const char *buf, size_t count) 495 { 496 struct qeth_card *card = dev_get_drvdata(dev); 497 char *tmp; 498 499 if (!card) 500 return -EINVAL; 501 502 tmp = strsep((char **) &buf, "\n"); 503 if (!strcmp(tmp, "toggle")) { 504 card->ipato.invert4 = (card->ipato.invert4)? 0 : 1; 505 } else if (!strcmp(tmp, "1")) { 506 card->ipato.invert4 = 1; 507 } else if (!strcmp(tmp, "0")) { 508 card->ipato.invert4 = 0; 509 } else { 510 return -EINVAL; 511 } 512 return count; 513 } 514 515 static QETH_DEVICE_ATTR(ipato_invert4, invert4, 0644, 516 qeth_l3_dev_ipato_invert4_show, 517 qeth_l3_dev_ipato_invert4_store); 518 519 static ssize_t qeth_l3_dev_ipato_add_show(char *buf, struct qeth_card *card, 520 enum qeth_prot_versions proto) 521 { 522 struct qeth_ipato_entry *ipatoe; 523 unsigned long flags; 524 char addr_str[40]; 525 int entry_len; /* length of 1 entry string, differs between v4 and v6 */ 526 int i = 0; 527 528 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40; 529 /* add strlen for "/<mask>\n" */ 530 entry_len += (proto == QETH_PROT_IPV4)? 5 : 6; 531 spin_lock_irqsave(&card->ip_lock, flags); 532 list_for_each_entry(ipatoe, &card->ipato.entries, entry) { 533 if (ipatoe->proto != proto) 534 continue; 535 /* String must not be longer than PAGE_SIZE. So we check if 536 * string length gets near PAGE_SIZE. Then we can savely display 537 * the next IPv6 address (worst case, compared to IPv4) */ 538 if ((PAGE_SIZE - i) <= entry_len) 539 break; 540 qeth_l3_ipaddr_to_string(proto, ipatoe->addr, addr_str); 541 i += snprintf(buf + i, PAGE_SIZE - i, 542 "%s/%i\n", addr_str, ipatoe->mask_bits); 543 } 544 spin_unlock_irqrestore(&card->ip_lock, flags); 545 i += snprintf(buf + i, PAGE_SIZE - i, "\n"); 546 547 return i; 548 } 549 550 static ssize_t qeth_l3_dev_ipato_add4_show(struct device *dev, 551 struct device_attribute *attr, char *buf) 552 { 553 struct qeth_card *card = dev_get_drvdata(dev); 554 555 if (!card) 556 return -EINVAL; 557 558 return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV4); 559 } 560 561 static int qeth_l3_parse_ipatoe(const char *buf, enum qeth_prot_versions proto, 562 u8 *addr, int *mask_bits) 563 { 564 const char *start, *end; 565 char *tmp; 566 char buffer[40] = {0, }; 567 568 start = buf; 569 /* get address string */ 570 end = strchr(start, '/'); 571 if (!end || (end - start >= 40)) { 572 return -EINVAL; 573 } 574 strncpy(buffer, start, end - start); 575 if (qeth_l3_string_to_ipaddr(buffer, proto, addr)) { 576 return -EINVAL; 577 } 578 start = end + 1; 579 *mask_bits = simple_strtoul(start, &tmp, 10); 580 if (!strlen(start) || 581 (tmp == start) || 582 (*mask_bits > ((proto == QETH_PROT_IPV4) ? 32 : 128))) { 583 return -EINVAL; 584 } 585 return 0; 586 } 587 588 static ssize_t qeth_l3_dev_ipato_add_store(const char *buf, size_t count, 589 struct qeth_card *card, enum qeth_prot_versions proto) 590 { 591 struct qeth_ipato_entry *ipatoe; 592 u8 addr[16]; 593 int mask_bits; 594 int rc; 595 596 rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits); 597 if (rc) 598 return rc; 599 600 ipatoe = kzalloc(sizeof(struct qeth_ipato_entry), GFP_KERNEL); 601 if (!ipatoe) { 602 return -ENOMEM; 603 } 604 ipatoe->proto = proto; 605 memcpy(ipatoe->addr, addr, (proto == QETH_PROT_IPV4)? 4:16); 606 ipatoe->mask_bits = mask_bits; 607 608 rc = qeth_l3_add_ipato_entry(card, ipatoe); 609 if (rc) { 610 kfree(ipatoe); 611 return rc; 612 } 613 614 return count; 615 } 616 617 static ssize_t qeth_l3_dev_ipato_add4_store(struct device *dev, 618 struct device_attribute *attr, const char *buf, size_t count) 619 { 620 struct qeth_card *card = dev_get_drvdata(dev); 621 622 if (!card) 623 return -EINVAL; 624 625 return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV4); 626 } 627 628 static QETH_DEVICE_ATTR(ipato_add4, add4, 0644, 629 qeth_l3_dev_ipato_add4_show, 630 qeth_l3_dev_ipato_add4_store); 631 632 static ssize_t qeth_l3_dev_ipato_del_store(const char *buf, size_t count, 633 struct qeth_card *card, enum qeth_prot_versions proto) 634 { 635 u8 addr[16]; 636 int mask_bits; 637 int rc; 638 639 rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits); 640 if (rc) 641 return rc; 642 643 qeth_l3_del_ipato_entry(card, proto, addr, mask_bits); 644 645 return count; 646 } 647 648 static ssize_t qeth_l3_dev_ipato_del4_store(struct device *dev, 649 struct device_attribute *attr, const char *buf, size_t count) 650 { 651 struct qeth_card *card = dev_get_drvdata(dev); 652 653 if (!card) 654 return -EINVAL; 655 656 return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV4); 657 } 658 659 static QETH_DEVICE_ATTR(ipato_del4, del4, 0200, NULL, 660 qeth_l3_dev_ipato_del4_store); 661 662 static ssize_t qeth_l3_dev_ipato_invert6_show(struct device *dev, 663 struct device_attribute *attr, char *buf) 664 { 665 struct qeth_card *card = dev_get_drvdata(dev); 666 667 if (!card) 668 return -EINVAL; 669 670 return sprintf(buf, "%i\n", card->ipato.invert6? 1:0); 671 } 672 673 static ssize_t qeth_l3_dev_ipato_invert6_store(struct device *dev, 674 struct device_attribute *attr, const char *buf, size_t count) 675 { 676 struct qeth_card *card = dev_get_drvdata(dev); 677 char *tmp; 678 679 if (!card) 680 return -EINVAL; 681 682 tmp = strsep((char **) &buf, "\n"); 683 if (!strcmp(tmp, "toggle")) { 684 card->ipato.invert6 = (card->ipato.invert6)? 0 : 1; 685 } else if (!strcmp(tmp, "1")) { 686 card->ipato.invert6 = 1; 687 } else if (!strcmp(tmp, "0")) { 688 card->ipato.invert6 = 0; 689 } else { 690 return -EINVAL; 691 } 692 return count; 693 } 694 695 static QETH_DEVICE_ATTR(ipato_invert6, invert6, 0644, 696 qeth_l3_dev_ipato_invert6_show, 697 qeth_l3_dev_ipato_invert6_store); 698 699 700 static ssize_t qeth_l3_dev_ipato_add6_show(struct device *dev, 701 struct device_attribute *attr, char *buf) 702 { 703 struct qeth_card *card = dev_get_drvdata(dev); 704 705 if (!card) 706 return -EINVAL; 707 708 return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV6); 709 } 710 711 static ssize_t qeth_l3_dev_ipato_add6_store(struct device *dev, 712 struct device_attribute *attr, const char *buf, size_t count) 713 { 714 struct qeth_card *card = dev_get_drvdata(dev); 715 716 if (!card) 717 return -EINVAL; 718 719 return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV6); 720 } 721 722 static QETH_DEVICE_ATTR(ipato_add6, add6, 0644, 723 qeth_l3_dev_ipato_add6_show, 724 qeth_l3_dev_ipato_add6_store); 725 726 static ssize_t qeth_l3_dev_ipato_del6_store(struct device *dev, 727 struct device_attribute *attr, const char *buf, size_t count) 728 { 729 struct qeth_card *card = dev_get_drvdata(dev); 730 731 if (!card) 732 return -EINVAL; 733 734 return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV6); 735 } 736 737 static QETH_DEVICE_ATTR(ipato_del6, del6, 0200, NULL, 738 qeth_l3_dev_ipato_del6_store); 739 740 static struct attribute *qeth_ipato_device_attrs[] = { 741 &dev_attr_ipato_enable.attr, 742 &dev_attr_ipato_invert4.attr, 743 &dev_attr_ipato_add4.attr, 744 &dev_attr_ipato_del4.attr, 745 &dev_attr_ipato_invert6.attr, 746 &dev_attr_ipato_add6.attr, 747 &dev_attr_ipato_del6.attr, 748 NULL, 749 }; 750 751 static struct attribute_group qeth_device_ipato_group = { 752 .name = "ipa_takeover", 753 .attrs = qeth_ipato_device_attrs, 754 }; 755 756 static ssize_t qeth_l3_dev_vipa_add_show(char *buf, struct qeth_card *card, 757 enum qeth_prot_versions proto) 758 { 759 struct qeth_ipaddr *ipaddr; 760 char addr_str[40]; 761 int entry_len; /* length of 1 entry string, differs between v4 and v6 */ 762 unsigned long flags; 763 int i = 0; 764 765 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40; 766 entry_len += 2; /* \n + terminator */ 767 spin_lock_irqsave(&card->ip_lock, flags); 768 list_for_each_entry(ipaddr, &card->ip_list, entry) { 769 if (ipaddr->proto != proto) 770 continue; 771 if (ipaddr->type != QETH_IP_TYPE_VIPA) 772 continue; 773 /* String must not be longer than PAGE_SIZE. So we check if 774 * string length gets near PAGE_SIZE. Then we can savely display 775 * the next IPv6 address (worst case, compared to IPv4) */ 776 if ((PAGE_SIZE - i) <= entry_len) 777 break; 778 qeth_l3_ipaddr_to_string(proto, (const u8 *)&ipaddr->u, 779 addr_str); 780 i += snprintf(buf + i, PAGE_SIZE - i, "%s\n", addr_str); 781 } 782 spin_unlock_irqrestore(&card->ip_lock, flags); 783 i += snprintf(buf + i, PAGE_SIZE - i, "\n"); 784 785 return i; 786 } 787 788 static ssize_t qeth_l3_dev_vipa_add4_show(struct device *dev, 789 struct device_attribute *attr, char *buf) 790 { 791 struct qeth_card *card = dev_get_drvdata(dev); 792 793 if (!card) 794 return -EINVAL; 795 796 return qeth_l3_dev_vipa_add_show(buf, card, QETH_PROT_IPV4); 797 } 798 799 static int qeth_l3_parse_vipae(const char *buf, enum qeth_prot_versions proto, 800 u8 *addr) 801 { 802 if (qeth_l3_string_to_ipaddr(buf, proto, addr)) { 803 return -EINVAL; 804 } 805 return 0; 806 } 807 808 static ssize_t qeth_l3_dev_vipa_add_store(const char *buf, size_t count, 809 struct qeth_card *card, enum qeth_prot_versions proto) 810 { 811 u8 addr[16] = {0, }; 812 int rc; 813 814 rc = qeth_l3_parse_vipae(buf, proto, addr); 815 if (rc) 816 return rc; 817 818 rc = qeth_l3_add_vipa(card, proto, addr); 819 if (rc) 820 return rc; 821 822 return count; 823 } 824 825 static ssize_t qeth_l3_dev_vipa_add4_store(struct device *dev, 826 struct device_attribute *attr, const char *buf, size_t count) 827 { 828 struct qeth_card *card = dev_get_drvdata(dev); 829 830 if (!card) 831 return -EINVAL; 832 833 return qeth_l3_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV4); 834 } 835 836 static QETH_DEVICE_ATTR(vipa_add4, add4, 0644, 837 qeth_l3_dev_vipa_add4_show, 838 qeth_l3_dev_vipa_add4_store); 839 840 static ssize_t qeth_l3_dev_vipa_del_store(const char *buf, size_t count, 841 struct qeth_card *card, enum qeth_prot_versions proto) 842 { 843 u8 addr[16]; 844 int rc; 845 846 rc = qeth_l3_parse_vipae(buf, proto, addr); 847 if (rc) 848 return rc; 849 850 qeth_l3_del_vipa(card, proto, addr); 851 852 return count; 853 } 854 855 static ssize_t qeth_l3_dev_vipa_del4_store(struct device *dev, 856 struct device_attribute *attr, const char *buf, size_t count) 857 { 858 struct qeth_card *card = dev_get_drvdata(dev); 859 860 if (!card) 861 return -EINVAL; 862 863 return qeth_l3_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV4); 864 } 865 866 static QETH_DEVICE_ATTR(vipa_del4, del4, 0200, NULL, 867 qeth_l3_dev_vipa_del4_store); 868 869 static ssize_t qeth_l3_dev_vipa_add6_show(struct device *dev, 870 struct device_attribute *attr, char *buf) 871 { 872 struct qeth_card *card = dev_get_drvdata(dev); 873 874 if (!card) 875 return -EINVAL; 876 877 return qeth_l3_dev_vipa_add_show(buf, card, QETH_PROT_IPV6); 878 } 879 880 static ssize_t qeth_l3_dev_vipa_add6_store(struct device *dev, 881 struct device_attribute *attr, const char *buf, size_t count) 882 { 883 struct qeth_card *card = dev_get_drvdata(dev); 884 885 if (!card) 886 return -EINVAL; 887 888 return qeth_l3_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV6); 889 } 890 891 static QETH_DEVICE_ATTR(vipa_add6, add6, 0644, 892 qeth_l3_dev_vipa_add6_show, 893 qeth_l3_dev_vipa_add6_store); 894 895 static ssize_t qeth_l3_dev_vipa_del6_store(struct device *dev, 896 struct device_attribute *attr, const char *buf, size_t count) 897 { 898 struct qeth_card *card = dev_get_drvdata(dev); 899 900 if (!card) 901 return -EINVAL; 902 903 return qeth_l3_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV6); 904 } 905 906 static QETH_DEVICE_ATTR(vipa_del6, del6, 0200, NULL, 907 qeth_l3_dev_vipa_del6_store); 908 909 static struct attribute *qeth_vipa_device_attrs[] = { 910 &dev_attr_vipa_add4.attr, 911 &dev_attr_vipa_del4.attr, 912 &dev_attr_vipa_add6.attr, 913 &dev_attr_vipa_del6.attr, 914 NULL, 915 }; 916 917 static struct attribute_group qeth_device_vipa_group = { 918 .name = "vipa", 919 .attrs = qeth_vipa_device_attrs, 920 }; 921 922 static ssize_t qeth_l3_dev_rxip_add_show(char *buf, struct qeth_card *card, 923 enum qeth_prot_versions proto) 924 { 925 struct qeth_ipaddr *ipaddr; 926 char addr_str[40]; 927 int entry_len; /* length of 1 entry string, differs between v4 and v6 */ 928 unsigned long flags; 929 int i = 0; 930 931 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40; 932 entry_len += 2; /* \n + terminator */ 933 spin_lock_irqsave(&card->ip_lock, flags); 934 list_for_each_entry(ipaddr, &card->ip_list, entry) { 935 if (ipaddr->proto != proto) 936 continue; 937 if (ipaddr->type != QETH_IP_TYPE_RXIP) 938 continue; 939 /* String must not be longer than PAGE_SIZE. So we check if 940 * string length gets near PAGE_SIZE. Then we can savely display 941 * the next IPv6 address (worst case, compared to IPv4) */ 942 if ((PAGE_SIZE - i) <= entry_len) 943 break; 944 qeth_l3_ipaddr_to_string(proto, (const u8 *)&ipaddr->u, 945 addr_str); 946 i += snprintf(buf + i, PAGE_SIZE - i, "%s\n", addr_str); 947 } 948 spin_unlock_irqrestore(&card->ip_lock, flags); 949 i += snprintf(buf + i, PAGE_SIZE - i, "\n"); 950 951 return i; 952 } 953 954 static ssize_t qeth_l3_dev_rxip_add4_show(struct device *dev, 955 struct device_attribute *attr, char *buf) 956 { 957 struct qeth_card *card = dev_get_drvdata(dev); 958 959 if (!card) 960 return -EINVAL; 961 962 return qeth_l3_dev_rxip_add_show(buf, card, QETH_PROT_IPV4); 963 } 964 965 static int qeth_l3_parse_rxipe(const char *buf, enum qeth_prot_versions proto, 966 u8 *addr) 967 { 968 if (qeth_l3_string_to_ipaddr(buf, proto, addr)) { 969 return -EINVAL; 970 } 971 return 0; 972 } 973 974 static ssize_t qeth_l3_dev_rxip_add_store(const char *buf, size_t count, 975 struct qeth_card *card, enum qeth_prot_versions proto) 976 { 977 u8 addr[16] = {0, }; 978 int rc; 979 980 rc = qeth_l3_parse_rxipe(buf, proto, addr); 981 if (rc) 982 return rc; 983 984 rc = qeth_l3_add_rxip(card, proto, addr); 985 if (rc) 986 return rc; 987 988 return count; 989 } 990 991 static ssize_t qeth_l3_dev_rxip_add4_store(struct device *dev, 992 struct device_attribute *attr, const char *buf, size_t count) 993 { 994 struct qeth_card *card = dev_get_drvdata(dev); 995 996 if (!card) 997 return -EINVAL; 998 999 return qeth_l3_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV4); 1000 } 1001 1002 static QETH_DEVICE_ATTR(rxip_add4, add4, 0644, 1003 qeth_l3_dev_rxip_add4_show, 1004 qeth_l3_dev_rxip_add4_store); 1005 1006 static ssize_t qeth_l3_dev_rxip_del_store(const char *buf, size_t count, 1007 struct qeth_card *card, enum qeth_prot_versions proto) 1008 { 1009 u8 addr[16]; 1010 int rc; 1011 1012 rc = qeth_l3_parse_rxipe(buf, proto, addr); 1013 if (rc) 1014 return rc; 1015 1016 qeth_l3_del_rxip(card, proto, addr); 1017 1018 return count; 1019 } 1020 1021 static ssize_t qeth_l3_dev_rxip_del4_store(struct device *dev, 1022 struct device_attribute *attr, const char *buf, size_t count) 1023 { 1024 struct qeth_card *card = dev_get_drvdata(dev); 1025 1026 if (!card) 1027 return -EINVAL; 1028 1029 return qeth_l3_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV4); 1030 } 1031 1032 static QETH_DEVICE_ATTR(rxip_del4, del4, 0200, NULL, 1033 qeth_l3_dev_rxip_del4_store); 1034 1035 static ssize_t qeth_l3_dev_rxip_add6_show(struct device *dev, 1036 struct device_attribute *attr, char *buf) 1037 { 1038 struct qeth_card *card = dev_get_drvdata(dev); 1039 1040 if (!card) 1041 return -EINVAL; 1042 1043 return qeth_l3_dev_rxip_add_show(buf, card, QETH_PROT_IPV6); 1044 } 1045 1046 static ssize_t qeth_l3_dev_rxip_add6_store(struct device *dev, 1047 struct device_attribute *attr, const char *buf, size_t count) 1048 { 1049 struct qeth_card *card = dev_get_drvdata(dev); 1050 1051 if (!card) 1052 return -EINVAL; 1053 1054 return qeth_l3_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV6); 1055 } 1056 1057 static QETH_DEVICE_ATTR(rxip_add6, add6, 0644, 1058 qeth_l3_dev_rxip_add6_show, 1059 qeth_l3_dev_rxip_add6_store); 1060 1061 static ssize_t qeth_l3_dev_rxip_del6_store(struct device *dev, 1062 struct device_attribute *attr, const char *buf, size_t count) 1063 { 1064 struct qeth_card *card = dev_get_drvdata(dev); 1065 1066 if (!card) 1067 return -EINVAL; 1068 1069 return qeth_l3_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV6); 1070 } 1071 1072 static QETH_DEVICE_ATTR(rxip_del6, del6, 0200, NULL, 1073 qeth_l3_dev_rxip_del6_store); 1074 1075 static struct attribute *qeth_rxip_device_attrs[] = { 1076 &dev_attr_rxip_add4.attr, 1077 &dev_attr_rxip_del4.attr, 1078 &dev_attr_rxip_add6.attr, 1079 &dev_attr_rxip_del6.attr, 1080 NULL, 1081 }; 1082 1083 static struct attribute_group qeth_device_rxip_group = { 1084 .name = "rxip", 1085 .attrs = qeth_rxip_device_attrs, 1086 }; 1087 1088 int qeth_l3_create_device_attributes(struct device *dev) 1089 { 1090 int ret; 1091 1092 ret = sysfs_create_group(&dev->kobj, &qeth_l3_device_attr_group); 1093 if (ret) 1094 return ret; 1095 1096 ret = sysfs_create_group(&dev->kobj, &qeth_device_ipato_group); 1097 if (ret) { 1098 sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group); 1099 return ret; 1100 } 1101 1102 ret = sysfs_create_group(&dev->kobj, &qeth_device_vipa_group); 1103 if (ret) { 1104 sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group); 1105 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group); 1106 return ret; 1107 } 1108 1109 ret = sysfs_create_group(&dev->kobj, &qeth_device_rxip_group); 1110 if (ret) { 1111 sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group); 1112 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group); 1113 sysfs_remove_group(&dev->kobj, &qeth_device_vipa_group); 1114 return ret; 1115 } 1116 return 0; 1117 } 1118 1119 void qeth_l3_remove_device_attributes(struct device *dev) 1120 { 1121 sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group); 1122 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group); 1123 sysfs_remove_group(&dev->kobj, &qeth_device_vipa_group); 1124 sysfs_remove_group(&dev->kobj, &qeth_device_rxip_group); 1125 } 1126