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