drivers/s390/net/qeth_l3_sys.c

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