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