drivers/s390/net/qeth_l3_sys.c

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