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