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