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