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                 qeth_l3_delete_ip(card, addr);
 301                 kfree(addr);
 302         }
 303
 304         if (strlen(tmp) == 0) {
 305                 /* delete ip address only */
 306                 card->options.hsuid[0] = '\0';
 307                 if (card->dev)
 308                         memcpy(card->dev->perm_addr, card->options.hsuid, 9);
 309                 qeth_configure_cq(card, QETH_CQ_DISABLED);
 310                 return count;
 311         }
 312
 313         if (qeth_configure_cq(card, QETH_CQ_ENABLED))
 314                 return -EPERM;
 315
 316         snprintf(card->options.hsuid, sizeof(card->options.hsuid),
 317                  "%-8s", tmp);
 318         ASCEBC(card->options.hsuid, 8);
 319         if (card->dev)
 320                 memcpy(card->dev->perm_addr, card->options.hsuid, 9);
 321
 322         addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
 323         if (addr != NULL) {
 324                 addr->u.a6.addr.s6_addr32[0] = 0xfe800000;
 325                 addr->u.a6.addr.s6_addr32[1] = 0x00000000;
 326                 for (i = 8; i < 16; i++)
 327                         addr->u.a6.addr.s6_addr[i] = card->options.hsuid[i - 8];
 328                 addr->u.a6.pfxlen = 0;
 329                 addr->type = QETH_IP_TYPE_NORMAL;
 330         } else
 331                 return -ENOMEM;
 332         qeth_l3_add_ip(card, addr);
 333         kfree(addr);
 334
 335         return count;
 336 }
 337
 338 static DEVICE_ATTR(hsuid, 0644, qeth_l3_dev_hsuid_show,
 339                    qeth_l3_dev_hsuid_store);
 340
 341
 342 static struct attribute *qeth_l3_device_attrs[] = {
 343         &dev_attr_route4.attr,
 344         &dev_attr_route6.attr,
 345         &dev_attr_fake_broadcast.attr,
 346         &dev_attr_sniffer.attr,
 347         &dev_attr_hsuid.attr,
 348         NULL,
 349 };
 350
 351 static struct attribute_group qeth_l3_device_attr_group = {
 352         .attrs = qeth_l3_device_attrs,
 353 };
 354
 355 static ssize_t qeth_l3_dev_ipato_enable_show(struct device *dev,
 356                         struct device_attribute *attr, char *buf)
 357 {
 358         struct qeth_card *card = dev_get_drvdata(dev);
 359
 360         if (!card)
 361                 return -EINVAL;
 362
 363         return sprintf(buf, "%i\n", card->ipato.enabled? 1:0);
 364 }
 365
 366 static ssize_t qeth_l3_dev_ipato_enable_store(struct device *dev,
 367                 struct device_attribute *attr, const char *buf, size_t count)
 368 {
 369         struct qeth_card *card = dev_get_drvdata(dev);
 370         struct qeth_ipaddr *addr;
 371         int i, rc = 0;
 372
 373         if (!card)
 374                 return -EINVAL;
 375
 376         mutex_lock(&card->conf_mutex);
 377         if ((card->state != CARD_STATE_DOWN) &&
 378             (card->state != CARD_STATE_RECOVER)) {
 379                 rc = -EPERM;
 380                 goto out;
 381         }
 382
 383         if (sysfs_streq(buf, "toggle")) {
 384                 card->ipato.enabled = (card->ipato.enabled)? 0 : 1;
 385         } else if (sysfs_streq(buf, "1")) {
 386                 card->ipato.enabled = 1;
 387                 hash_for_each(card->ip_htable, i, addr, hnode) {
 388                                 if ((addr->type == QETH_IP_TYPE_NORMAL) &&
 389                                 qeth_l3_is_addr_covered_by_ipato(card, addr))
 390                                         addr->set_flags |=
 391                                         QETH_IPA_SETIP_TAKEOVER_FLAG;
 392                         }
 393         } else if (sysfs_streq(buf, "0")) {
 394                 card->ipato.enabled = 0;
 395                 hash_for_each(card->ip_htable, i, addr, hnode) {
 396                         if (addr->set_flags &
 397                         QETH_IPA_SETIP_TAKEOVER_FLAG)
 398                                 addr->set_flags &=
 399                                 ~QETH_IPA_SETIP_TAKEOVER_FLAG;
 400                         }
 401         } else
 402                 rc = -EINVAL;
 403 out:
 404         mutex_unlock(&card->conf_mutex);
 405         return rc ? rc : count;
 406 }
 407
 408 static QETH_DEVICE_ATTR(ipato_enable, enable, 0644,
 409                         qeth_l3_dev_ipato_enable_show,
 410                         qeth_l3_dev_ipato_enable_store);
 411
 412 static ssize_t qeth_l3_dev_ipato_invert4_show(struct device *dev,
 413                                 struct device_attribute *attr, char *buf)
 414 {
 415         struct qeth_card *card = dev_get_drvdata(dev);
 416
 417         if (!card)
 418                 return -EINVAL;
 419
 420         return sprintf(buf, "%i\n", card->ipato.invert4? 1:0);
 421 }
 422
 423 static ssize_t qeth_l3_dev_ipato_invert4_store(struct device *dev,
 424                                 struct device_attribute *attr,
 425                                 const char *buf, size_t count)
 426 {
 427         struct qeth_card *card = dev_get_drvdata(dev);
 428         int rc = 0;
 429
 430         if (!card)
 431                 return -EINVAL;
 432
 433         mutex_lock(&card->conf_mutex);
 434         if (sysfs_streq(buf, "toggle"))
 435                 card->ipato.invert4 = (card->ipato.invert4)? 0 : 1;
 436         else if (sysfs_streq(buf, "1"))
 437                 card->ipato.invert4 = 1;
 438         else if (sysfs_streq(buf, "0"))
 439                 card->ipato.invert4 = 0;
 440         else
 441                 rc = -EINVAL;
 442         mutex_unlock(&card->conf_mutex);
 443         return rc ? rc : count;
 444 }
 445
 446 static QETH_DEVICE_ATTR(ipato_invert4, invert4, 0644,
 447                         qeth_l3_dev_ipato_invert4_show,
 448                         qeth_l3_dev_ipato_invert4_store);
 449
 450 static ssize_t qeth_l3_dev_ipato_add_show(char *buf, struct qeth_card *card,
 451                         enum qeth_prot_versions proto)
 452 {
 453         struct qeth_ipato_entry *ipatoe;
 454         char addr_str[40];
 455         int entry_len; /* length of 1 entry string, differs between v4 and v6 */
 456         int i = 0;
 457
 458         entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
 459         /* add strlen for "/<mask>\n" */
 460         entry_len += (proto == QETH_PROT_IPV4)? 5 : 6;
 461         spin_lock_bh(&card->ip_lock);
 462         list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
 463                 if (ipatoe->proto != proto)
 464                         continue;
 465                 /* String must not be longer than PAGE_SIZE. So we check if
 466                  * string length gets near PAGE_SIZE. Then we can savely display
 467                  * the next IPv6 address (worst case, compared to IPv4) */
 468                 if ((PAGE_SIZE - i) <= entry_len)
 469                         break;
 470                 qeth_l3_ipaddr_to_string(proto, ipatoe->addr, addr_str);
 471                 i += snprintf(buf + i, PAGE_SIZE - i,
 472                               "%s/%i\n", addr_str, ipatoe->mask_bits);
 473         }
 474         spin_unlock_bh(&card->ip_lock);
 475         i += snprintf(buf + i, PAGE_SIZE - i, "\n");
 476
 477         return i;
 478 }
 479
 480 static ssize_t qeth_l3_dev_ipato_add4_show(struct device *dev,
 481                                 struct device_attribute *attr, char *buf)
 482 {
 483         struct qeth_card *card = dev_get_drvdata(dev);
 484
 485         if (!card)
 486                 return -EINVAL;
 487
 488         return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV4);
 489 }
 490
 491 static int qeth_l3_parse_ipatoe(const char *buf, enum qeth_prot_versions proto,
 492                   u8 *addr, int *mask_bits)
 493 {
 494         const char *start, *end;
 495         char *tmp;
 496         char buffer[40] = {0, };
 497
 498         start = buf;
 499         /* get address string */
 500         end = strchr(start, '/');
 501         if (!end || (end - start >= 40)) {
 502                 return -EINVAL;
 503         }
 504         strncpy(buffer, start, end - start);
 505         if (qeth_l3_string_to_ipaddr(buffer, proto, addr)) {
 506                 return -EINVAL;
 507         }
 508         start = end + 1;
 509         *mask_bits = simple_strtoul(start, &tmp, 10);
 510         if (!strlen(start) ||
 511             (tmp == start) ||
 512             (*mask_bits > ((proto == QETH_PROT_IPV4) ? 32 : 128))) {
 513                 return -EINVAL;
 514         }
 515         return 0;
 516 }
 517
 518 static ssize_t qeth_l3_dev_ipato_add_store(const char *buf, size_t count,
 519                          struct qeth_card *card, enum qeth_prot_versions proto)
 520 {
 521         struct qeth_ipato_entry *ipatoe;
 522         u8 addr[16];
 523         int mask_bits;
 524         int rc = 0;
 525
 526         mutex_lock(&card->conf_mutex);
 527         rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits);
 528         if (rc)
 529                 goto out;
 530
 531         ipatoe = kzalloc(sizeof(struct qeth_ipato_entry), GFP_KERNEL);
 532         if (!ipatoe) {
 533                 rc = -ENOMEM;
 534                 goto out;
 535         }
 536         ipatoe->proto = proto;
 537         memcpy(ipatoe->addr, addr, (proto == QETH_PROT_IPV4)? 4:16);
 538         ipatoe->mask_bits = mask_bits;
 539
 540         rc = qeth_l3_add_ipato_entry(card, ipatoe);
 541         if (rc)
 542                 kfree(ipatoe);
 543 out:
 544         mutex_unlock(&card->conf_mutex);
 545         return rc ? rc : count;
 546 }
 547
 548 static ssize_t qeth_l3_dev_ipato_add4_store(struct device *dev,
 549                 struct device_attribute *attr, const char *buf, size_t count)
 550 {
 551         struct qeth_card *card = dev_get_drvdata(dev);
 552
 553         if (!card)
 554                 return -EINVAL;
 555
 556         return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV4);
 557 }
 558
 559 static QETH_DEVICE_ATTR(ipato_add4, add4, 0644,
 560                         qeth_l3_dev_ipato_add4_show,
 561                         qeth_l3_dev_ipato_add4_store);
 562
 563 static ssize_t qeth_l3_dev_ipato_del_store(const char *buf, size_t count,
 564                          struct qeth_card *card, enum qeth_prot_versions proto)
 565 {
 566         u8 addr[16];
 567         int mask_bits;
 568         int rc = 0;
 569
 570         mutex_lock(&card->conf_mutex);
 571         rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits);
 572         if (!rc)
 573                 qeth_l3_del_ipato_entry(card, proto, addr, mask_bits);
 574         mutex_unlock(&card->conf_mutex);
 575         return rc ? rc : count;
 576 }
 577
 578 static ssize_t qeth_l3_dev_ipato_del4_store(struct device *dev,
 579                 struct device_attribute *attr, const char *buf, size_t count)
 580 {
 581         struct qeth_card *card = dev_get_drvdata(dev);
 582
 583         if (!card)
 584                 return -EINVAL;
 585
 586         return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV4);
 587 }
 588
 589 static QETH_DEVICE_ATTR(ipato_del4, del4, 0200, NULL,
 590                         qeth_l3_dev_ipato_del4_store);
 591
 592 static ssize_t qeth_l3_dev_ipato_invert6_show(struct device *dev,
 593                 struct device_attribute *attr, char *buf)
 594 {
 595         struct qeth_card *card = dev_get_drvdata(dev);
 596
 597         if (!card)
 598                 return -EINVAL;
 599
 600         return sprintf(buf, "%i\n", card->ipato.invert6? 1:0);
 601 }
 602
 603 static ssize_t qeth_l3_dev_ipato_invert6_store(struct device *dev,
 604                 struct device_attribute *attr, const char *buf, size_t count)
 605 {
 606         struct qeth_card *card = dev_get_drvdata(dev);
 607         int rc = 0;
 608
 609         if (!card)
 610                 return -EINVAL;
 611
 612         mutex_lock(&card->conf_mutex);
 613         if (sysfs_streq(buf, "toggle"))
 614                 card->ipato.invert6 = (card->ipato.invert6)? 0 : 1;
 615         else if (sysfs_streq(buf, "1"))
 616                 card->ipato.invert6 = 1;
 617         else if (sysfs_streq(buf, "0"))
 618                 card->ipato.invert6 = 0;
 619         else
 620                 rc = -EINVAL;
 621         mutex_unlock(&card->conf_mutex);
 622         return rc ? rc : count;
 623 }
 624
 625 static QETH_DEVICE_ATTR(ipato_invert6, invert6, 0644,
 626                         qeth_l3_dev_ipato_invert6_show,
 627                         qeth_l3_dev_ipato_invert6_store);
 628
 629
 630 static ssize_t qeth_l3_dev_ipato_add6_show(struct device *dev,
 631                                 struct device_attribute *attr, char *buf)
 632 {
 633         struct qeth_card *card = dev_get_drvdata(dev);
 634
 635         if (!card)
 636                 return -EINVAL;
 637
 638         return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV6);
 639 }
 640
 641 static ssize_t qeth_l3_dev_ipato_add6_store(struct device *dev,
 642                 struct device_attribute *attr, const char *buf, size_t count)
 643 {
 644         struct qeth_card *card = dev_get_drvdata(dev);
 645
 646         if (!card)
 647                 return -EINVAL;
 648
 649         return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV6);
 650 }
 651
 652 static QETH_DEVICE_ATTR(ipato_add6, add6, 0644,
 653                         qeth_l3_dev_ipato_add6_show,
 654                         qeth_l3_dev_ipato_add6_store);
 655
 656 static ssize_t qeth_l3_dev_ipato_del6_store(struct device *dev,
 657                 struct device_attribute *attr, const char *buf, size_t count)
 658 {
 659         struct qeth_card *card = dev_get_drvdata(dev);
 660
 661         if (!card)
 662                 return -EINVAL;
 663
 664         return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV6);
 665 }
 666
 667 static QETH_DEVICE_ATTR(ipato_del6, del6, 0200, NULL,
 668                         qeth_l3_dev_ipato_del6_store);
 669
 670 static struct attribute *qeth_ipato_device_attrs[] = {
 671         &dev_attr_ipato_enable.attr,
 672         &dev_attr_ipato_invert4.attr,
 673         &dev_attr_ipato_add4.attr,
 674         &dev_attr_ipato_del4.attr,
 675         &dev_attr_ipato_invert6.attr,
 676         &dev_attr_ipato_add6.attr,
 677         &dev_attr_ipato_del6.attr,
 678         NULL,
 679 };
 680
 681 static struct attribute_group qeth_device_ipato_group = {
 682         .name = "ipa_takeover",
 683         .attrs = qeth_ipato_device_attrs,
 684 };
 685
 686 static ssize_t qeth_l3_dev_vipa_add_show(char *buf, struct qeth_card *card,
 687                         enum qeth_prot_versions proto)
 688 {
 689         struct qeth_ipaddr *ipaddr;
 690         struct hlist_node  *tmp;
 691         char addr_str[40];
 692         int entry_len; /* length of 1 entry string, differs between v4 and v6 */
 693         int i = 0;
 694
 695         entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
 696         entry_len += 2; /* \n + terminator */
 697         spin_lock_bh(&card->ip_lock);
 698         hash_for_each_safe(card->ip_htable, i, tmp, ipaddr, hnode) {
 699                 if (ipaddr->proto != proto)
 700                         continue;
 701                 if (ipaddr->type != QETH_IP_TYPE_VIPA)
 702                         continue;
 703                 /* String must not be longer than PAGE_SIZE. So we check if
 704                  * string length gets near PAGE_SIZE. Then we can savely display
 705                  * the next IPv6 address (worst case, compared to IPv4) */
 706                 if ((PAGE_SIZE - i) <= entry_len)
 707                         break;
 708                 qeth_l3_ipaddr_to_string(proto, (const u8 *)&ipaddr->u,
 709                         addr_str);
 710                 i += snprintf(buf + i, PAGE_SIZE - i, "%s\n", addr_str);
 711         }
 712         spin_unlock_bh(&card->ip_lock);
 713         i += snprintf(buf + i, PAGE_SIZE - i, "\n");
 714
 715         return i;
 716 }
 717
 718 static ssize_t qeth_l3_dev_vipa_add4_show(struct device *dev,
 719                         struct device_attribute *attr, char *buf)
 720 {
 721         struct qeth_card *card = dev_get_drvdata(dev);
 722
 723         if (!card)
 724                 return -EINVAL;
 725
 726         return qeth_l3_dev_vipa_add_show(buf, card, QETH_PROT_IPV4);
 727 }
 728
 729 static int qeth_l3_parse_vipae(const char *buf, enum qeth_prot_versions proto,
 730                  u8 *addr)
 731 {
 732         if (qeth_l3_string_to_ipaddr(buf, proto, addr)) {
 733                 return -EINVAL;
 734         }
 735         return 0;
 736 }
 737
 738 static ssize_t qeth_l3_dev_vipa_add_store(const char *buf, size_t count,
 739                         struct qeth_card *card, enum qeth_prot_versions proto)
 740 {
 741         u8 addr[16] = {0, };
 742         int rc;
 743
 744         mutex_lock(&card->conf_mutex);
 745         rc = qeth_l3_parse_vipae(buf, proto, addr);
 746         if (!rc)
 747                 rc = qeth_l3_add_vipa(card, proto, addr);
 748         mutex_unlock(&card->conf_mutex);
 749         return rc ? rc : count;
 750 }
 751
 752 static ssize_t qeth_l3_dev_vipa_add4_store(struct device *dev,
 753                 struct device_attribute *attr, const char *buf, size_t count)
 754 {
 755         struct qeth_card *card = dev_get_drvdata(dev);
 756
 757         if (!card)
 758                 return -EINVAL;
 759
 760         return qeth_l3_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV4);
 761 }
 762
 763 static QETH_DEVICE_ATTR(vipa_add4, add4, 0644,
 764                         qeth_l3_dev_vipa_add4_show,
 765                         qeth_l3_dev_vipa_add4_store);
 766
 767 static ssize_t qeth_l3_dev_vipa_del_store(const char *buf, size_t count,
 768                          struct qeth_card *card, enum qeth_prot_versions proto)
 769 {
 770         u8 addr[16];
 771         int rc;
 772
 773         mutex_lock(&card->conf_mutex);
 774         rc = qeth_l3_parse_vipae(buf, proto, addr);
 775         if (!rc)
 776                 qeth_l3_del_vipa(card, proto, addr);
 777         mutex_unlock(&card->conf_mutex);
 778         return rc ? rc : count;
 779 }
 780
 781 static ssize_t qeth_l3_dev_vipa_del4_store(struct device *dev,
 782                 struct device_attribute *attr, const char *buf, size_t count)
 783 {
 784         struct qeth_card *card = dev_get_drvdata(dev);
 785
 786         if (!card)
 787                 return -EINVAL;
 788
 789         return qeth_l3_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV4);
 790 }
 791
 792 static QETH_DEVICE_ATTR(vipa_del4, del4, 0200, NULL,
 793                         qeth_l3_dev_vipa_del4_store);
 794
 795 static ssize_t qeth_l3_dev_vipa_add6_show(struct device *dev,
 796                                 struct device_attribute *attr, char *buf)
 797 {
 798         struct qeth_card *card = dev_get_drvdata(dev);
 799
 800         if (!card)
 801                 return -EINVAL;
 802
 803         return qeth_l3_dev_vipa_add_show(buf, card, QETH_PROT_IPV6);
 804 }
 805
 806 static ssize_t qeth_l3_dev_vipa_add6_store(struct device *dev,
 807                 struct device_attribute *attr, const char *buf, size_t count)
 808 {
 809         struct qeth_card *card = dev_get_drvdata(dev);
 810
 811         if (!card)
 812                 return -EINVAL;
 813
 814         return qeth_l3_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV6);
 815 }
 816
 817 static QETH_DEVICE_ATTR(vipa_add6, add6, 0644,
 818                         qeth_l3_dev_vipa_add6_show,
 819                         qeth_l3_dev_vipa_add6_store);
 820
 821 static ssize_t qeth_l3_dev_vipa_del6_store(struct device *dev,
 822                 struct device_attribute *attr, const char *buf, size_t count)
 823 {
 824         struct qeth_card *card = dev_get_drvdata(dev);
 825
 826         if (!card)
 827                 return -EINVAL;
 828
 829         return qeth_l3_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV6);
 830 }
 831
 832 static QETH_DEVICE_ATTR(vipa_del6, del6, 0200, NULL,
 833                         qeth_l3_dev_vipa_del6_store);
 834
 835 static struct attribute *qeth_vipa_device_attrs[] = {
 836         &dev_attr_vipa_add4.attr,
 837         &dev_attr_vipa_del4.attr,
 838         &dev_attr_vipa_add6.attr,
 839         &dev_attr_vipa_del6.attr,
 840         NULL,
 841 };
 842
 843 static struct attribute_group qeth_device_vipa_group = {
 844         .name = "vipa",
 845         .attrs = qeth_vipa_device_attrs,
 846 };
 847
 848 static ssize_t qeth_l3_dev_rxip_add_show(char *buf, struct qeth_card *card,
 849                        enum qeth_prot_versions proto)
 850 {
 851         struct qeth_ipaddr *ipaddr;
 852         struct hlist_node *tmp;
 853         char addr_str[40];
 854         int entry_len; /* length of 1 entry string, differs between v4 and v6 */
 855         int i = 0;
 856
 857         entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
 858         entry_len += 2; /* \n + terminator */
 859         spin_lock_bh(&card->ip_lock);
 860         hash_for_each_safe(card->ip_htable, i, tmp, ipaddr, hnode) {
 861                 if (ipaddr->proto != proto)
 862                         continue;
 863                 if (ipaddr->type != QETH_IP_TYPE_RXIP)
 864                         continue;
 865                 /* String must not be longer than PAGE_SIZE. So we check if
 866                  * string length gets near PAGE_SIZE. Then we can savely display
 867                  * the next IPv6 address (worst case, compared to IPv4) */
 868                 if ((PAGE_SIZE - i) <= entry_len)
 869                         break;
 870                 qeth_l3_ipaddr_to_string(proto, (const u8 *)&ipaddr->u,
 871                         addr_str);
 872                 i += snprintf(buf + i, PAGE_SIZE - i, "%s\n", addr_str);
 873         }
 874         spin_unlock_bh(&card->ip_lock);
 875         i += snprintf(buf + i, PAGE_SIZE - i, "\n");
 876
 877         return i;
 878 }
 879
 880 static ssize_t qeth_l3_dev_rxip_add4_show(struct device *dev,
 881                         struct device_attribute *attr, char *buf)
 882 {
 883         struct qeth_card *card = dev_get_drvdata(dev);
 884
 885         if (!card)
 886                 return -EINVAL;
 887
 888         return qeth_l3_dev_rxip_add_show(buf, card, QETH_PROT_IPV4);
 889 }
 890
 891 static int qeth_l3_parse_rxipe(const char *buf, enum qeth_prot_versions proto,
 892                  u8 *addr)
 893 {
 894         if (qeth_l3_string_to_ipaddr(buf, proto, addr)) {
 895                 return -EINVAL;
 896         }
 897         return 0;
 898 }
 899
 900 static ssize_t qeth_l3_dev_rxip_add_store(const char *buf, size_t count,
 901                         struct qeth_card *card, enum qeth_prot_versions proto)
 902 {
 903         u8 addr[16] = {0, };
 904         int rc;
 905
 906         mutex_lock(&card->conf_mutex);
 907         rc = qeth_l3_parse_rxipe(buf, proto, addr);
 908         if (!rc)
 909                 rc = qeth_l3_add_rxip(card, proto, addr);
 910         mutex_unlock(&card->conf_mutex);
 911         return rc ? rc : count;
 912 }
 913
 914 static ssize_t qeth_l3_dev_rxip_add4_store(struct device *dev,
 915                 struct device_attribute *attr, const char *buf, size_t count)
 916 {
 917         struct qeth_card *card = dev_get_drvdata(dev);
 918
 919         if (!card)
 920                 return -EINVAL;
 921
 922         return qeth_l3_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV4);
 923 }
 924
 925 static QETH_DEVICE_ATTR(rxip_add4, add4, 0644,
 926                         qeth_l3_dev_rxip_add4_show,
 927                         qeth_l3_dev_rxip_add4_store);
 928
 929 static ssize_t qeth_l3_dev_rxip_del_store(const char *buf, size_t count,
 930                         struct qeth_card *card, enum qeth_prot_versions proto)
 931 {
 932         u8 addr[16];
 933         int rc;
 934
 935         mutex_lock(&card->conf_mutex);
 936         rc = qeth_l3_parse_rxipe(buf, proto, addr);
 937         if (!rc)
 938                 qeth_l3_del_rxip(card, proto, addr);
 939         mutex_unlock(&card->conf_mutex);
 940         return rc ? rc : count;
 941 }
 942
 943 static ssize_t qeth_l3_dev_rxip_del4_store(struct device *dev,
 944                 struct device_attribute *attr, const char *buf, size_t count)
 945 {
 946         struct qeth_card *card = dev_get_drvdata(dev);
 947
 948         if (!card)
 949                 return -EINVAL;
 950
 951         return qeth_l3_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV4);
 952 }
 953
 954 static QETH_DEVICE_ATTR(rxip_del4, del4, 0200, NULL,
 955                         qeth_l3_dev_rxip_del4_store);
 956
 957 static ssize_t qeth_l3_dev_rxip_add6_show(struct device *dev,
 958                 struct device_attribute *attr, char *buf)
 959 {
 960         struct qeth_card *card = dev_get_drvdata(dev);
 961
 962         if (!card)
 963                 return -EINVAL;
 964
 965         return qeth_l3_dev_rxip_add_show(buf, card, QETH_PROT_IPV6);
 966 }
 967
 968 static ssize_t qeth_l3_dev_rxip_add6_store(struct device *dev,
 969                 struct device_attribute *attr, const char *buf, size_t count)
 970 {
 971         struct qeth_card *card = dev_get_drvdata(dev);
 972
 973         if (!card)
 974                 return -EINVAL;
 975
 976         return qeth_l3_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV6);
 977 }
 978
 979 static QETH_DEVICE_ATTR(rxip_add6, add6, 0644,
 980                         qeth_l3_dev_rxip_add6_show,
 981                         qeth_l3_dev_rxip_add6_store);
 982
 983 static ssize_t qeth_l3_dev_rxip_del6_store(struct device *dev,
 984                 struct device_attribute *attr, const char *buf, size_t count)
 985 {
 986         struct qeth_card *card = dev_get_drvdata(dev);
 987
 988         if (!card)
 989                 return -EINVAL;
 990
 991         return qeth_l3_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV6);
 992 }
 993
 994 static QETH_DEVICE_ATTR(rxip_del6, del6, 0200, NULL,
 995                         qeth_l3_dev_rxip_del6_store);
 996
 997 static struct attribute *qeth_rxip_device_attrs[] = {
 998         &dev_attr_rxip_add4.attr,
 999         &dev_attr_rxip_del4.attr,
1000         &dev_attr_rxip_add6.attr,
1001         &dev_attr_rxip_del6.attr,
1002         NULL,
1003 };
1004
1005 static struct attribute_group qeth_device_rxip_group = {
1006         .name = "rxip",
1007         .attrs = qeth_rxip_device_attrs,
1008 };
1009
1010 int qeth_l3_create_device_attributes(struct device *dev)
1011 {
1012         int ret;
1013
1014         ret = sysfs_create_group(&dev->kobj, &qeth_l3_device_attr_group);
1015         if (ret)
1016                 return ret;
1017
1018         ret = sysfs_create_group(&dev->kobj, &qeth_device_ipato_group);
1019         if (ret) {
1020                 sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group);
1021                 return ret;
1022         }
1023
1024         ret = sysfs_create_group(&dev->kobj, &qeth_device_vipa_group);
1025         if (ret) {
1026                 sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group);
1027                 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1028                 return ret;
1029         }
1030
1031         ret = sysfs_create_group(&dev->kobj, &qeth_device_rxip_group);
1032         if (ret) {
1033                 sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group);
1034                 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1035                 sysfs_remove_group(&dev->kobj, &qeth_device_vipa_group);
1036                 return ret;
1037         }
1038         return 0;
1039 }
1040
1041 void qeth_l3_remove_device_attributes(struct device *dev)
1042 {
1043         sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group);
1044         sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1045         sysfs_remove_group(&dev->kobj, &qeth_device_vipa_group);
1046         sysfs_remove_group(&dev->kobj, &qeth_device_rxip_group);
1047 }