drivers/s390/net/qeth_l3_sys.c

   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         if (!qeth_is_supported(card, IPA_IPV6))
 125                 return sprintf(buf, "%s\n", "n/a");
 126
 127         return qeth_l3_dev_route_show(card, &card->options.route6, buf);
 128 }
 129
 130 static ssize_t qeth_l3_dev_route6_store(struct device *dev,
 131                 struct device_attribute *attr, const char *buf, size_t count)
 132 {
 133         struct qeth_card *card = dev_get_drvdata(dev);
 134
 135         if (!card)
 136                 return -EINVAL;
 137
 138         if (!qeth_is_supported(card, IPA_IPV6)) {
 139                 return -ENOTSUPP;
 140         }
 141
 142         return qeth_l3_dev_route_store(card, &card->options.route6,
 143                                 QETH_PROT_IPV6, buf, count);
 144 }
 145
 146 static DEVICE_ATTR(route6, 0644, qeth_l3_dev_route6_show,
 147                         qeth_l3_dev_route6_store);
 148
 149 static ssize_t qeth_l3_dev_fake_broadcast_show(struct device *dev,
 150                         struct device_attribute *attr, char *buf)
 151 {
 152         struct qeth_card *card = dev_get_drvdata(dev);
 153
 154         if (!card)
 155                 return -EINVAL;
 156
 157         return sprintf(buf, "%i\n", card->options.fake_broadcast? 1:0);
 158 }
 159
 160 static ssize_t qeth_l3_dev_fake_broadcast_store(struct device *dev,
 161                 struct device_attribute *attr, const char *buf, size_t count)
 162 {
 163         struct qeth_card *card = dev_get_drvdata(dev);
 164         char *tmp;
 165         int i;
 166
 167         if (!card)
 168                 return -EINVAL;
 169
 170         if ((card->state != CARD_STATE_DOWN) &&
 171             (card->state != CARD_STATE_RECOVER))
 172                 return -EPERM;
 173
 174         i = simple_strtoul(buf, &tmp, 16);
 175         if ((i == 0) || (i == 1))
 176                 card->options.fake_broadcast = i;
 177         else {
 178                 return -EINVAL;
 179         }
 180         return count;
 181 }
 182
 183 static DEVICE_ATTR(fake_broadcast, 0644, qeth_l3_dev_fake_broadcast_show,
 184                    qeth_l3_dev_fake_broadcast_store);
 185
 186 static ssize_t qeth_l3_dev_broadcast_mode_show(struct device *dev,
 187                                 struct device_attribute *attr, char *buf)
 188 {
 189         struct qeth_card *card = dev_get_drvdata(dev);
 190
 191         if (!card)
 192                 return -EINVAL;
 193
 194         if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
 195               (card->info.link_type == QETH_LINK_TYPE_LANE_TR)))
 196                 return sprintf(buf, "n/a\n");
 197
 198         return sprintf(buf, "%s\n", (card->options.broadcast_mode ==
 199                                      QETH_TR_BROADCAST_ALLRINGS)?
 200                        "all rings":"local");
 201 }
 202
 203 static ssize_t qeth_l3_dev_broadcast_mode_store(struct device *dev,
 204                 struct device_attribute *attr, const char *buf, size_t count)
 205 {
 206         struct qeth_card *card = dev_get_drvdata(dev);
 207         char *tmp;
 208
 209         if (!card)
 210                 return -EINVAL;
 211
 212         if ((card->state != CARD_STATE_DOWN) &&
 213             (card->state != CARD_STATE_RECOVER))
 214                 return -EPERM;
 215
 216         if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
 217               (card->info.link_type == QETH_LINK_TYPE_LANE_TR))) {
 218                 return -EINVAL;
 219         }
 220
 221         tmp = strsep((char **) &buf, "\n");
 222
 223         if (!strcmp(tmp, "local")) {
 224                 card->options.broadcast_mode = QETH_TR_BROADCAST_LOCAL;
 225                 return count;
 226         } else if (!strcmp(tmp, "all_rings")) {
 227                 card->options.broadcast_mode = QETH_TR_BROADCAST_ALLRINGS;
 228                 return count;
 229         } else {
 230                 return -EINVAL;
 231         }
 232         return count;
 233 }
 234
 235 static DEVICE_ATTR(broadcast_mode, 0644, qeth_l3_dev_broadcast_mode_show,
 236                    qeth_l3_dev_broadcast_mode_store);
 237
 238 static ssize_t qeth_l3_dev_canonical_macaddr_show(struct device *dev,
 239                                 struct device_attribute *attr, char *buf)
 240 {
 241         struct qeth_card *card = dev_get_drvdata(dev);
 242
 243         if (!card)
 244                 return -EINVAL;
 245
 246         if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
 247               (card->info.link_type == QETH_LINK_TYPE_LANE_TR)))
 248                 return sprintf(buf, "n/a\n");
 249
 250         return sprintf(buf, "%i\n", (card->options.macaddr_mode ==
 251                                      QETH_TR_MACADDR_CANONICAL)? 1:0);
 252 }
 253
 254 static ssize_t qeth_l3_dev_canonical_macaddr_store(struct device *dev,
 255                 struct device_attribute *attr, const char *buf, size_t count)
 256 {
 257         struct qeth_card *card = dev_get_drvdata(dev);
 258         char *tmp;
 259         int i;
 260
 261         if (!card)
 262                 return -EINVAL;
 263
 264         if ((card->state != CARD_STATE_DOWN) &&
 265             (card->state != CARD_STATE_RECOVER))
 266                 return -EPERM;
 267
 268         if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
 269               (card->info.link_type == QETH_LINK_TYPE_LANE_TR))) {
 270                 return -EINVAL;
 271         }
 272
 273         i = simple_strtoul(buf, &tmp, 16);
 274         if ((i == 0) || (i == 1))
 275                 card->options.macaddr_mode = i?
 276                         QETH_TR_MACADDR_CANONICAL :
 277                         QETH_TR_MACADDR_NONCANONICAL;
 278         else {
 279                 return -EINVAL;
 280         }
 281         return count;
 282 }
 283
 284 static DEVICE_ATTR(canonical_macaddr, 0644, qeth_l3_dev_canonical_macaddr_show,
 285                    qeth_l3_dev_canonical_macaddr_store);
 286
 287 static ssize_t qeth_l3_dev_checksum_show(struct device *dev,
 288                         struct device_attribute *attr, char *buf)
 289 {
 290         struct qeth_card *card = dev_get_drvdata(dev);
 291
 292         if (!card)
 293                 return -EINVAL;
 294
 295         return sprintf(buf, "%s checksumming\n",
 296                         qeth_l3_get_checksum_str(card));
 297 }
 298
 299 static ssize_t qeth_l3_dev_checksum_store(struct device *dev,
 300                 struct device_attribute *attr, const char *buf, size_t count)
 301 {
 302         struct qeth_card *card = dev_get_drvdata(dev);
 303         char *tmp;
 304
 305         if (!card)
 306                 return -EINVAL;
 307
 308         if ((card->state != CARD_STATE_DOWN) &&
 309             (card->state != CARD_STATE_RECOVER))
 310                 return -EPERM;
 311
 312         tmp = strsep((char **) &buf, "\n");
 313         if (!strcmp(tmp, "sw_checksumming"))
 314                 card->options.checksum_type = SW_CHECKSUMMING;
 315         else if (!strcmp(tmp, "hw_checksumming"))
 316                 card->options.checksum_type = HW_CHECKSUMMING;
 317         else if (!strcmp(tmp, "no_checksumming"))
 318                 card->options.checksum_type = NO_CHECKSUMMING;
 319         else {
 320                 return -EINVAL;
 321         }
 322         return count;
 323 }
 324
 325 static DEVICE_ATTR(checksumming, 0644, qeth_l3_dev_checksum_show,
 326                 qeth_l3_dev_checksum_store);
 327
 328 static struct attribute *qeth_l3_device_attrs[] = {
 329         &dev_attr_route4.attr,
 330         &dev_attr_route6.attr,
 331         &dev_attr_fake_broadcast.attr,
 332         &dev_attr_broadcast_mode.attr,
 333         &dev_attr_canonical_macaddr.attr,
 334         &dev_attr_checksumming.attr,
 335         NULL,
 336 };
 337
 338 static struct attribute_group qeth_l3_device_attr_group = {
 339         .attrs = qeth_l3_device_attrs,
 340 };
 341
 342 static ssize_t qeth_l3_dev_ipato_enable_show(struct device *dev,
 343                         struct device_attribute *attr, char *buf)
 344 {
 345         struct qeth_card *card = dev_get_drvdata(dev);
 346
 347         if (!card)
 348                 return -EINVAL;
 349
 350         return sprintf(buf, "%i\n", card->ipato.enabled? 1:0);
 351 }
 352
 353 static ssize_t qeth_l3_dev_ipato_enable_store(struct device *dev,
 354                 struct device_attribute *attr, const char *buf, size_t count)
 355 {
 356         struct qeth_card *card = dev_get_drvdata(dev);
 357         char *tmp;
 358
 359         if (!card)
 360                 return -EINVAL;
 361
 362         if ((card->state != CARD_STATE_DOWN) &&
 363             (card->state != CARD_STATE_RECOVER))
 364                 return -EPERM;
 365
 366         tmp = strsep((char **) &buf, "\n");
 367         if (!strcmp(tmp, "toggle")) {
 368                 card->ipato.enabled = (card->ipato.enabled)? 0 : 1;
 369         } else if (!strcmp(tmp, "1")) {
 370                 card->ipato.enabled = 1;
 371         } else if (!strcmp(tmp, "0")) {
 372                 card->ipato.enabled = 0;
 373         } else {
 374                 return -EINVAL;
 375         }
 376         return count;
 377 }
 378
 379 static QETH_DEVICE_ATTR(ipato_enable, enable, 0644,
 380                         qeth_l3_dev_ipato_enable_show,
 381                         qeth_l3_dev_ipato_enable_store);
 382
 383 static ssize_t qeth_l3_dev_ipato_invert4_show(struct device *dev,
 384                                 struct device_attribute *attr, char *buf)
 385 {
 386         struct qeth_card *card = dev_get_drvdata(dev);
 387
 388         if (!card)
 389                 return -EINVAL;
 390
 391         return sprintf(buf, "%i\n", card->ipato.invert4? 1:0);
 392 }
 393
 394 static ssize_t qeth_l3_dev_ipato_invert4_store(struct device *dev,
 395                                 struct device_attribute *attr,
 396                                 const char *buf, size_t count)
 397 {
 398         struct qeth_card *card = dev_get_drvdata(dev);
 399         char *tmp;
 400
 401         if (!card)
 402                 return -EINVAL;
 403
 404         tmp = strsep((char **) &buf, "\n");
 405         if (!strcmp(tmp, "toggle")) {
 406                 card->ipato.invert4 = (card->ipato.invert4)? 0 : 1;
 407         } else if (!strcmp(tmp, "1")) {
 408                 card->ipato.invert4 = 1;
 409         } else if (!strcmp(tmp, "0")) {
 410                 card->ipato.invert4 = 0;
 411         } else {
 412                 return -EINVAL;
 413         }
 414         return count;
 415 }
 416
 417 static QETH_DEVICE_ATTR(ipato_invert4, invert4, 0644,
 418                         qeth_l3_dev_ipato_invert4_show,
 419                         qeth_l3_dev_ipato_invert4_store);
 420
 421 static ssize_t qeth_l3_dev_ipato_add_show(char *buf, struct qeth_card *card,
 422                         enum qeth_prot_versions proto)
 423 {
 424         struct qeth_ipato_entry *ipatoe;
 425         unsigned long flags;
 426         char addr_str[40];
 427         int entry_len; /* length of 1 entry string, differs between v4 and v6 */
 428         int i = 0;
 429
 430         entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
 431         /* add strlen for "/<mask>\n" */
 432         entry_len += (proto == QETH_PROT_IPV4)? 5 : 6;
 433         spin_lock_irqsave(&card->ip_lock, flags);
 434         list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
 435                 if (ipatoe->proto != proto)
 436                         continue;
 437                 /* String must not be longer than PAGE_SIZE. So we check if
 438                  * string length gets near PAGE_SIZE. Then we can savely display
 439                  * the next IPv6 address (worst case, compared to IPv4) */
 440                 if ((PAGE_SIZE - i) <= entry_len)
 441                         break;
 442                 qeth_l3_ipaddr_to_string(proto, ipatoe->addr, addr_str);
 443                 i += snprintf(buf + i, PAGE_SIZE - i,
 444                               "%s/%i\n", addr_str, ipatoe->mask_bits);
 445         }
 446         spin_unlock_irqrestore(&card->ip_lock, flags);
 447         i += snprintf(buf + i, PAGE_SIZE - i, "\n");
 448
 449         return i;
 450 }
 451
 452 static ssize_t qeth_l3_dev_ipato_add4_show(struct device *dev,
 453                                 struct device_attribute *attr, char *buf)
 454 {
 455         struct qeth_card *card = dev_get_drvdata(dev);
 456
 457         if (!card)
 458                 return -EINVAL;
 459
 460         return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV4);
 461 }
 462
 463 static int qeth_l3_parse_ipatoe(const char *buf, enum qeth_prot_versions proto,
 464                   u8 *addr, int *mask_bits)
 465 {
 466         const char *start, *end;
 467         char *tmp;
 468         char buffer[40] = {0, };
 469
 470         start = buf;
 471         /* get address string */
 472         end = strchr(start, '/');
 473         if (!end || (end - start >= 40)) {
 474                 return -EINVAL;
 475         }
 476         strncpy(buffer, start, end - start);
 477         if (qeth_l3_string_to_ipaddr(buffer, proto, addr)) {
 478                 return -EINVAL;
 479         }
 480         start = end + 1;
 481         *mask_bits = simple_strtoul(start, &tmp, 10);
 482         if (!strlen(start) ||
 483             (tmp == start) ||
 484             (*mask_bits > ((proto == QETH_PROT_IPV4) ? 32 : 128))) {
 485                 return -EINVAL;
 486         }
 487         return 0;
 488 }
 489
 490 static ssize_t qeth_l3_dev_ipato_add_store(const char *buf, size_t count,
 491                          struct qeth_card *card, enum qeth_prot_versions proto)
 492 {
 493         struct qeth_ipato_entry *ipatoe;
 494         u8 addr[16];
 495         int mask_bits;
 496         int rc;
 497
 498         rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits);
 499         if (rc)
 500                 return rc;
 501
 502         ipatoe = kzalloc(sizeof(struct qeth_ipato_entry), GFP_KERNEL);
 503         if (!ipatoe) {
 504                 return -ENOMEM;
 505         }
 506         ipatoe->proto = proto;
 507         memcpy(ipatoe->addr, addr, (proto == QETH_PROT_IPV4)? 4:16);
 508         ipatoe->mask_bits = mask_bits;
 509
 510         rc = qeth_l3_add_ipato_entry(card, ipatoe);
 511         if (rc) {
 512                 kfree(ipatoe);
 513                 return rc;
 514         }
 515
 516         return count;
 517 }
 518
 519 static ssize_t qeth_l3_dev_ipato_add4_store(struct device *dev,
 520                 struct device_attribute *attr, const char *buf, size_t count)
 521 {
 522         struct qeth_card *card = dev_get_drvdata(dev);
 523
 524         if (!card)
 525                 return -EINVAL;
 526
 527         return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV4);
 528 }
 529
 530 static QETH_DEVICE_ATTR(ipato_add4, add4, 0644,
 531                         qeth_l3_dev_ipato_add4_show,
 532                         qeth_l3_dev_ipato_add4_store);
 533
 534 static ssize_t qeth_l3_dev_ipato_del_store(const char *buf, size_t count,
 535                          struct qeth_card *card, enum qeth_prot_versions proto)
 536 {
 537         u8 addr[16];
 538         int mask_bits;
 539         int rc;
 540
 541         rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits);
 542         if (rc)
 543                 return rc;
 544
 545         qeth_l3_del_ipato_entry(card, proto, addr, mask_bits);
 546
 547         return count;
 548 }
 549
 550 static ssize_t qeth_l3_dev_ipato_del4_store(struct device *dev,
 551                 struct device_attribute *attr, const char *buf, size_t count)
 552 {
 553         struct qeth_card *card = dev_get_drvdata(dev);
 554
 555         if (!card)
 556                 return -EINVAL;
 557
 558         return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV4);
 559 }
 560
 561 static QETH_DEVICE_ATTR(ipato_del4, del4, 0200, NULL,
 562                         qeth_l3_dev_ipato_del4_store);
 563
 564 static ssize_t qeth_l3_dev_ipato_invert6_show(struct device *dev,
 565                 struct device_attribute *attr, char *buf)
 566 {
 567         struct qeth_card *card = dev_get_drvdata(dev);
 568
 569         if (!card)
 570                 return -EINVAL;
 571
 572         return sprintf(buf, "%i\n", card->ipato.invert6? 1:0);
 573 }
 574
 575 static ssize_t qeth_l3_dev_ipato_invert6_store(struct device *dev,
 576                 struct device_attribute *attr, const char *buf, size_t count)
 577 {
 578         struct qeth_card *card = dev_get_drvdata(dev);
 579         char *tmp;
 580
 581         if (!card)
 582                 return -EINVAL;
 583
 584         tmp = strsep((char **) &buf, "\n");
 585         if (!strcmp(tmp, "toggle")) {
 586                 card->ipato.invert6 = (card->ipato.invert6)? 0 : 1;
 587         } else if (!strcmp(tmp, "1")) {
 588                 card->ipato.invert6 = 1;
 589         } else if (!strcmp(tmp, "0")) {
 590                 card->ipato.invert6 = 0;
 591         } else {
 592                 return -EINVAL;
 593         }
 594         return count;
 595 }
 596
 597 static QETH_DEVICE_ATTR(ipato_invert6, invert6, 0644,
 598                         qeth_l3_dev_ipato_invert6_show,
 599                         qeth_l3_dev_ipato_invert6_store);
 600
 601
 602 static ssize_t qeth_l3_dev_ipato_add6_show(struct device *dev,
 603                                 struct device_attribute *attr, char *buf)
 604 {
 605         struct qeth_card *card = dev_get_drvdata(dev);
 606
 607         if (!card)
 608                 return -EINVAL;
 609
 610         return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV6);
 611 }
 612
 613 static ssize_t qeth_l3_dev_ipato_add6_store(struct device *dev,
 614                 struct device_attribute *attr, const char *buf, size_t count)
 615 {
 616         struct qeth_card *card = dev_get_drvdata(dev);
 617
 618         if (!card)
 619                 return -EINVAL;
 620
 621         return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV6);
 622 }
 623
 624 static QETH_DEVICE_ATTR(ipato_add6, add6, 0644,
 625                         qeth_l3_dev_ipato_add6_show,
 626                         qeth_l3_dev_ipato_add6_store);
 627
 628 static ssize_t qeth_l3_dev_ipato_del6_store(struct device *dev,
 629                 struct device_attribute *attr, const char *buf, size_t count)
 630 {
 631         struct qeth_card *card = dev_get_drvdata(dev);
 632
 633         if (!card)
 634                 return -EINVAL;
 635
 636         return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV6);
 637 }
 638
 639 static QETH_DEVICE_ATTR(ipato_del6, del6, 0200, NULL,
 640                         qeth_l3_dev_ipato_del6_store);
 641
 642 static struct attribute *qeth_ipato_device_attrs[] = {
 643         &dev_attr_ipato_enable.attr,
 644         &dev_attr_ipato_invert4.attr,
 645         &dev_attr_ipato_add4.attr,
 646         &dev_attr_ipato_del4.attr,
 647         &dev_attr_ipato_invert6.attr,
 648         &dev_attr_ipato_add6.attr,
 649         &dev_attr_ipato_del6.attr,
 650         NULL,
 651 };
 652
 653 static struct attribute_group qeth_device_ipato_group = {
 654         .name = "ipa_takeover",
 655         .attrs = qeth_ipato_device_attrs,
 656 };
 657
 658 static ssize_t qeth_l3_dev_vipa_add_show(char *buf, struct qeth_card *card,
 659                         enum qeth_prot_versions proto)
 660 {
 661         struct qeth_ipaddr *ipaddr;
 662         char addr_str[40];
 663         int entry_len; /* length of 1 entry string, differs between v4 and v6 */
 664         unsigned long flags;
 665         int i = 0;
 666
 667         entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
 668         entry_len += 2; /* \n + terminator */
 669         spin_lock_irqsave(&card->ip_lock, flags);
 670         list_for_each_entry(ipaddr, &card->ip_list, entry) {
 671                 if (ipaddr->proto != proto)
 672                         continue;
 673                 if (ipaddr->type != QETH_IP_TYPE_VIPA)
 674                         continue;
 675                 /* String must not be longer than PAGE_SIZE. So we check if
 676                  * string length gets near PAGE_SIZE. Then we can savely display
 677                  * the next IPv6 address (worst case, compared to IPv4) */
 678                 if ((PAGE_SIZE - i) <= entry_len)
 679                         break;
 680                 qeth_l3_ipaddr_to_string(proto, (const u8 *)&ipaddr->u,
 681                         addr_str);
 682                 i += snprintf(buf + i, PAGE_SIZE - i, "%s\n", addr_str);
 683         }
 684         spin_unlock_irqrestore(&card->ip_lock, flags);
 685         i += snprintf(buf + i, PAGE_SIZE - i, "\n");
 686
 687         return i;
 688 }
 689
 690 static ssize_t qeth_l3_dev_vipa_add4_show(struct device *dev,
 691                         struct device_attribute *attr, char *buf)
 692 {
 693         struct qeth_card *card = dev_get_drvdata(dev);
 694
 695         if (!card)
 696                 return -EINVAL;
 697
 698         return qeth_l3_dev_vipa_add_show(buf, card, QETH_PROT_IPV4);
 699 }
 700
 701 static int qeth_l3_parse_vipae(const char *buf, enum qeth_prot_versions proto,
 702                  u8 *addr)
 703 {
 704         if (qeth_l3_string_to_ipaddr(buf, proto, addr)) {
 705                 return -EINVAL;
 706         }
 707         return 0;
 708 }
 709
 710 static ssize_t qeth_l3_dev_vipa_add_store(const char *buf, size_t count,
 711                         struct qeth_card *card, enum qeth_prot_versions proto)
 712 {
 713         u8 addr[16] = {0, };
 714         int rc;
 715
 716         rc = qeth_l3_parse_vipae(buf, proto, addr);
 717         if (rc)
 718                 return rc;
 719
 720         rc = qeth_l3_add_vipa(card, proto, addr);
 721         if (rc)
 722                 return rc;
 723
 724         return count;
 725 }
 726
 727 static ssize_t qeth_l3_dev_vipa_add4_store(struct device *dev,
 728                 struct device_attribute *attr, const char *buf, size_t count)
 729 {
 730         struct qeth_card *card = dev_get_drvdata(dev);
 731
 732         if (!card)
 733                 return -EINVAL;
 734
 735         return qeth_l3_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV4);
 736 }
 737
 738 static QETH_DEVICE_ATTR(vipa_add4, add4, 0644,
 739                         qeth_l3_dev_vipa_add4_show,
 740                         qeth_l3_dev_vipa_add4_store);
 741
 742 static ssize_t qeth_l3_dev_vipa_del_store(const char *buf, size_t count,
 743                          struct qeth_card *card, enum qeth_prot_versions proto)
 744 {
 745         u8 addr[16];
 746         int rc;
 747
 748         rc = qeth_l3_parse_vipae(buf, proto, addr);
 749         if (rc)
 750                 return rc;
 751
 752         qeth_l3_del_vipa(card, proto, addr);
 753
 754         return count;
 755 }
 756
 757 static ssize_t qeth_l3_dev_vipa_del4_store(struct device *dev,
 758                 struct device_attribute *attr, const char *buf, size_t count)
 759 {
 760         struct qeth_card *card = dev_get_drvdata(dev);
 761
 762         if (!card)
 763                 return -EINVAL;
 764
 765         return qeth_l3_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV4);
 766 }
 767
 768 static QETH_DEVICE_ATTR(vipa_del4, del4, 0200, NULL,
 769                         qeth_l3_dev_vipa_del4_store);
 770
 771 static ssize_t qeth_l3_dev_vipa_add6_show(struct device *dev,
 772                                 struct device_attribute *attr, char *buf)
 773 {
 774         struct qeth_card *card = dev_get_drvdata(dev);
 775
 776         if (!card)
 777                 return -EINVAL;
 778
 779         return qeth_l3_dev_vipa_add_show(buf, card, QETH_PROT_IPV6);
 780 }
 781
 782 static ssize_t qeth_l3_dev_vipa_add6_store(struct device *dev,
 783                 struct device_attribute *attr, const char *buf, size_t count)
 784 {
 785         struct qeth_card *card = dev_get_drvdata(dev);
 786
 787         if (!card)
 788                 return -EINVAL;
 789
 790         return qeth_l3_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV6);
 791 }
 792
 793 static QETH_DEVICE_ATTR(vipa_add6, add6, 0644,
 794                         qeth_l3_dev_vipa_add6_show,
 795                         qeth_l3_dev_vipa_add6_store);
 796
 797 static ssize_t qeth_l3_dev_vipa_del6_store(struct device *dev,
 798                 struct device_attribute *attr, const char *buf, size_t count)
 799 {
 800         struct qeth_card *card = dev_get_drvdata(dev);
 801
 802         if (!card)
 803                 return -EINVAL;
 804
 805         return qeth_l3_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV6);
 806 }
 807
 808 static QETH_DEVICE_ATTR(vipa_del6, del6, 0200, NULL,
 809                         qeth_l3_dev_vipa_del6_store);
 810
 811 static struct attribute *qeth_vipa_device_attrs[] = {
 812         &dev_attr_vipa_add4.attr,
 813         &dev_attr_vipa_del4.attr,
 814         &dev_attr_vipa_add6.attr,
 815         &dev_attr_vipa_del6.attr,
 816         NULL,
 817 };
 818
 819 static struct attribute_group qeth_device_vipa_group = {
 820         .name = "vipa",
 821         .attrs = qeth_vipa_device_attrs,
 822 };
 823
 824 static ssize_t qeth_l3_dev_rxip_add_show(char *buf, struct qeth_card *card,
 825                        enum qeth_prot_versions proto)
 826 {
 827         struct qeth_ipaddr *ipaddr;
 828         char addr_str[40];
 829         int entry_len; /* length of 1 entry string, differs between v4 and v6 */
 830         unsigned long flags;
 831         int i = 0;
 832
 833         entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
 834         entry_len += 2; /* \n + terminator */
 835         spin_lock_irqsave(&card->ip_lock, flags);
 836         list_for_each_entry(ipaddr, &card->ip_list, entry) {
 837                 if (ipaddr->proto != proto)
 838                         continue;
 839                 if (ipaddr->type != QETH_IP_TYPE_RXIP)
 840                         continue;
 841                 /* String must not be longer than PAGE_SIZE. So we check if
 842                  * string length gets near PAGE_SIZE. Then we can savely display
 843                  * the next IPv6 address (worst case, compared to IPv4) */
 844                 if ((PAGE_SIZE - i) <= entry_len)
 845                         break;
 846                 qeth_l3_ipaddr_to_string(proto, (const u8 *)&ipaddr->u,
 847                         addr_str);
 848                 i += snprintf(buf + i, PAGE_SIZE - i, "%s\n", addr_str);
 849         }
 850         spin_unlock_irqrestore(&card->ip_lock, flags);
 851         i += snprintf(buf + i, PAGE_SIZE - i, "\n");
 852
 853         return i;
 854 }
 855
 856 static ssize_t qeth_l3_dev_rxip_add4_show(struct device *dev,
 857                         struct device_attribute *attr, char *buf)
 858 {
 859         struct qeth_card *card = dev_get_drvdata(dev);
 860
 861         if (!card)
 862                 return -EINVAL;
 863
 864         return qeth_l3_dev_rxip_add_show(buf, card, QETH_PROT_IPV4);
 865 }
 866
 867 static int qeth_l3_parse_rxipe(const char *buf, enum qeth_prot_versions proto,
 868                  u8 *addr)
 869 {
 870         if (qeth_l3_string_to_ipaddr(buf, proto, addr)) {
 871                 return -EINVAL;
 872         }
 873         return 0;
 874 }
 875
 876 static ssize_t qeth_l3_dev_rxip_add_store(const char *buf, size_t count,
 877                         struct qeth_card *card, enum qeth_prot_versions proto)
 878 {
 879         u8 addr[16] = {0, };
 880         int rc;
 881
 882         rc = qeth_l3_parse_rxipe(buf, proto, addr);
 883         if (rc)
 884                 return rc;
 885
 886         rc = qeth_l3_add_rxip(card, proto, addr);
 887         if (rc)
 888                 return rc;
 889
 890         return count;
 891 }
 892
 893 static ssize_t qeth_l3_dev_rxip_add4_store(struct device *dev,
 894                 struct device_attribute *attr, const char *buf, size_t count)
 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_store(buf, count, card, QETH_PROT_IPV4);
 902 }
 903
 904 static QETH_DEVICE_ATTR(rxip_add4, add4, 0644,
 905                         qeth_l3_dev_rxip_add4_show,
 906                         qeth_l3_dev_rxip_add4_store);
 907
 908 static ssize_t qeth_l3_dev_rxip_del_store(const char *buf, size_t count,
 909                         struct qeth_card *card, enum qeth_prot_versions proto)
 910 {
 911         u8 addr[16];
 912         int rc;
 913
 914         rc = qeth_l3_parse_rxipe(buf, proto, addr);
 915         if (rc)
 916                 return rc;
 917
 918         qeth_l3_del_rxip(card, proto, addr);
 919
 920         return count;
 921 }
 922
 923 static ssize_t qeth_l3_dev_rxip_del4_store(struct device *dev,
 924                 struct device_attribute *attr, const char *buf, size_t count)
 925 {
 926         struct qeth_card *card = dev_get_drvdata(dev);
 927
 928         if (!card)
 929                 return -EINVAL;
 930
 931         return qeth_l3_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV4);
 932 }
 933
 934 static QETH_DEVICE_ATTR(rxip_del4, del4, 0200, NULL,
 935                         qeth_l3_dev_rxip_del4_store);
 936
 937 static ssize_t qeth_l3_dev_rxip_add6_show(struct device *dev,
 938                 struct device_attribute *attr, char *buf)
 939 {
 940         struct qeth_card *card = dev_get_drvdata(dev);
 941
 942         if (!card)
 943                 return -EINVAL;
 944
 945         return qeth_l3_dev_rxip_add_show(buf, card, QETH_PROT_IPV6);
 946 }
 947
 948 static ssize_t qeth_l3_dev_rxip_add6_store(struct device *dev,
 949                 struct device_attribute *attr, const char *buf, size_t count)
 950 {
 951         struct qeth_card *card = dev_get_drvdata(dev);
 952
 953         if (!card)
 954                 return -EINVAL;
 955
 956         return qeth_l3_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV6);
 957 }
 958
 959 static QETH_DEVICE_ATTR(rxip_add6, add6, 0644,
 960                         qeth_l3_dev_rxip_add6_show,
 961                         qeth_l3_dev_rxip_add6_store);
 962
 963 static ssize_t qeth_l3_dev_rxip_del6_store(struct device *dev,
 964                 struct device_attribute *attr, const char *buf, size_t count)
 965 {
 966         struct qeth_card *card = dev_get_drvdata(dev);
 967
 968         if (!card)
 969                 return -EINVAL;
 970
 971         return qeth_l3_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV6);
 972 }
 973
 974 static QETH_DEVICE_ATTR(rxip_del6, del6, 0200, NULL,
 975                         qeth_l3_dev_rxip_del6_store);
 976
 977 static struct attribute *qeth_rxip_device_attrs[] = {
 978         &dev_attr_rxip_add4.attr,
 979         &dev_attr_rxip_del4.attr,
 980         &dev_attr_rxip_add6.attr,
 981         &dev_attr_rxip_del6.attr,
 982         NULL,
 983 };
 984
 985 static struct attribute_group qeth_device_rxip_group = {
 986         .name = "rxip",
 987         .attrs = qeth_rxip_device_attrs,
 988 };
 989
 990 int qeth_l3_create_device_attributes(struct device *dev)
 991 {
 992         int ret;
 993
 994         ret = sysfs_create_group(&dev->kobj, &qeth_l3_device_attr_group);
 995         if (ret)
 996                 return ret;
 997
 998         ret = sysfs_create_group(&dev->kobj, &qeth_device_ipato_group);
 999         if (ret) {
1000                 sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group);
1001                 return ret;
1002         }
1003
1004         ret = sysfs_create_group(&dev->kobj, &qeth_device_vipa_group);
1005         if (ret) {
1006                 sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group);
1007                 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1008                 return ret;
1009         }
1010
1011         ret = sysfs_create_group(&dev->kobj, &qeth_device_rxip_group);
1012         if (ret) {
1013                 sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group);
1014                 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1015                 sysfs_remove_group(&dev->kobj, &qeth_device_vipa_group);
1016                 return ret;
1017         }
1018         return 0;
1019 }
1020
1021 void qeth_l3_remove_device_attributes(struct device *dev)
1022 {
1023         sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group);
1024         sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1025         sysfs_remove_group(&dev->kobj, &qeth_device_vipa_group);
1026         sysfs_remove_group(&dev->kobj, &qeth_device_rxip_group);
1027 }