SAFE public projects git trees. - safe/jmp/linux-2.6/blob - arch/xtensa/platforms/iss/network.c

   1 /*
   2  *
   3  * arch/xtensa/platform-iss/network.c
   4  *
   5  * Platform specific initialization.
   6  *
   7  * Authors: Chris Zankel <chris@zankel.net>
   8  * Based on work form the UML team.
   9  *
  10  * Copyright 2005 Tensilica Inc.
  11  *
  12  * This program is free software; you can redistribute  it and/or modify it
  13  * under  the terms of  the GNU General  Public License as published by the
  14  * Free Software Foundation;  either version 2 of the  License, or (at your
  15  * option) any later version.
  16  *
  17  */
  18
  19 #include <linux/list.h>
  20 #include <linux/irq.h>
  21 #include <linux/spinlock.h>
  22 #include <linux/slab.h>
  23 #include <linux/timer.h>
  24 #include <linux/if_ether.h>
  25 #include <linux/inetdevice.h>
  26 #include <linux/init.h>
  27 #include <linux/if_tun.h>
  28 #include <linux/etherdevice.h>
  29 #include <linux/interrupt.h>
  30 #include <linux/ioctl.h>
  31 #include <linux/bootmem.h>
  32 #include <linux/ethtool.h>
  33 #include <linux/rtnetlink.h>
  34 #include <linux/platform_device.h>
  35
  36 #include <asm/platform/simcall.h>
  37
  38 #define DRIVER_NAME "iss-netdev"
  39 #define ETH_MAX_PACKET 1500
  40 #define ETH_HEADER_OTHER 14
  41 #define ISS_NET_TIMER_VALUE (2 * HZ)
  42
  43
  44 static DEFINE_SPINLOCK(opened_lock);
  45 static LIST_HEAD(opened);
  46
  47 static DEFINE_SPINLOCK(devices_lock);
  48 static LIST_HEAD(devices);
  49
  50 /* ------------------------------------------------------------------------- */
  51
  52 /* We currently only support the TUNTAP transport protocol. */
  53
  54 #define TRANSPORT_TUNTAP_NAME "tuntap"
  55 #define TRANSPORT_TUNTAP_MTU ETH_MAX_PACKET
  56
  57 struct tuntap_info {
  58         char dev_name[IFNAMSIZ];
  59         int fixed_config;
  60         unsigned char gw[ETH_ALEN];
  61         int fd;
  62 };
  63
  64 /* ------------------------------------------------------------------------- */
  65
  66
  67 /* This structure contains out private information for the driver. */
  68
  69 struct iss_net_private {
  70
  71         struct list_head device_list;
  72         struct list_head opened_list;
  73
  74         spinlock_t lock;
  75         struct net_device *dev;
  76         struct platform_device pdev;
  77         struct timer_list tl;
  78         struct net_device_stats stats;
  79
  80         struct timer_list timer;
  81         unsigned int timer_val;
  82
  83         int index;
  84         int mtu;
  85
  86         unsigned char mac[ETH_ALEN];
  87         int have_mac;
  88
  89         struct {
  90                 union {
  91                         struct tuntap_info tuntap;
  92                 } info;
  93
  94                 int (*open)(struct iss_net_private *lp);
  95                 void (*close)(struct iss_net_private *lp);
  96                 int (*read)(struct iss_net_private *lp, struct sk_buff **skb);
  97                 int (*write)(struct iss_net_private *lp, struct sk_buff **skb);
  98                 unsigned short (*protocol)(struct sk_buff *skb);
  99                 int (*poll)(struct iss_net_private *lp);
 100         } tp;
 101
 102 };
 103
 104 /* ======================= ISS SIMCALL INTERFACE =========================== */
 105
 106 /* Note: __simc must _not_ be declared inline! */
 107
 108 static int errno;
 109
 110 static int __simc (int a, int b, int c, int d, int e, int f)
 111 {
 112         int ret;
 113         __asm__ __volatile__ ("simcall\n"
 114                               "mov %0, a2\n"
 115                               "mov %1, a3\n" : "=a" (ret), "=a" (errno)
 116                               : : "a2", "a3");
 117         return ret;
 118 }
 119
 120 static int inline simc_open(char *file, int flags, int mode)
 121 {
 122         return __simc(SYS_open, (int) file, flags, mode, 0, 0);
 123 }
 124
 125 static int inline simc_close(int fd)
 126 {
 127         return __simc(SYS_close, fd, 0, 0, 0, 0);
 128 }
 129
 130 static int inline simc_ioctl(int fd, int request, void *arg)
 131 {
 132         return __simc(SYS_ioctl, fd, request, (int) arg, 0, 0);
 133 }
 134
 135 static int inline simc_read(int fd, void *buf, size_t count)
 136 {
 137         return __simc(SYS_read, fd, (int) buf, count, 0, 0);
 138 }
 139
 140 static int inline simc_write(int fd, void *buf, size_t count)
 141 {
 142         return __simc(SYS_write, fd, (int) buf, count, 0, 0);
 143 }
 144
 145 static int inline simc_poll(int fd)
 146 {
 147         struct timeval tv = { .tv_sec = 0, .tv_usec = 0 };
 148
 149         return __simc(SYS_select_one, fd, XTISS_SELECT_ONE_READ, (int)&tv,0,0);
 150 }
 151
 152 /* ================================ HELPERS ================================ */
 153
 154
 155 static char *split_if_spec(char *str, ...)
 156 {
 157         char **arg, *end;
 158         va_list ap;
 159
 160         va_start(ap, str);
 161         while ((arg = va_arg(ap, char**)) != NULL) {
 162                 if (*str == '\0')
 163                         return NULL;
 164                 end = strchr(str, ',');
 165                 if (end != str)
 166                         *arg = str;
 167                 if (end == NULL)
 168                         return NULL;
 169                 *end ++ = '\0';
 170                 str = end;
 171         }
 172         va_end(ap);
 173         return str;
 174 }
 175
 176
 177 #if 0
 178 /* Adjust SKB. */
 179
 180 struct sk_buff *ether_adjust_skb(struct sk_buff *skb, int extra)
 181 {
 182         if ((skb != NULL) && (skb_tailroom(skb) < extra)) {
 183                 struct sk_buff *skb2;
 184
 185                 skb2 = skb_copy_expand(skb, 0, extra, GFP_ATOMIC);
 186                 dev_kfree_skb(skb);
 187                 skb = skb2;
 188         }
 189         if (skb != NULL)
 190                 skb_put(skb, extra);
 191
 192         return skb;
 193 }
 194 #endif
 195
 196 /* Return the IP address as a string for a given device. */
 197
 198 static void dev_ip_addr(void *d, char *buf, char *bin_buf)
 199 {
 200         struct net_device *dev = d;
 201         struct in_device *ip = dev->ip_ptr;
 202         struct in_ifaddr *in;
 203         __be32 addr;
 204
 205         if ((ip == NULL) || ((in = ip->ifa_list) == NULL)) {
 206                 printk(KERN_WARNING "Device not assigned an IP address!\n");
 207                 return;
 208         }
 209
 210         addr = in->ifa_address;
 211         sprintf(buf, "%d.%d.%d.%d", addr & 0xff, (addr >> 8) & 0xff,
 212                 (addr >> 16) & 0xff, addr >> 24);
 213
 214         if (bin_buf) {
 215                 bin_buf[0] = addr & 0xff;
 216                 bin_buf[1] = (addr >> 8) & 0xff;
 217                 bin_buf[2] = (addr >> 16) & 0xff;
 218                 bin_buf[3] = addr >> 24;
 219         }
 220 }
 221
 222 /* Set Ethernet address of the specified device. */
 223
 224 static void inline set_ether_mac(void *d, unsigned char *addr)
 225 {
 226         struct net_device *dev = d;
 227         memcpy(dev->dev_addr, addr, ETH_ALEN);
 228 }
 229
 230
 231 /* ======================= TUNTAP TRANSPORT INTERFACE ====================== */
 232
 233 static int tuntap_open(struct iss_net_private *lp)
 234 {
 235         struct ifreq ifr;
 236         char *dev_name = lp->tp.info.tuntap.dev_name;
 237         int err = -EINVAL;
 238         int fd;
 239
 240         /* We currently only support a fixed configuration. */
 241
 242         if (!lp->tp.info.tuntap.fixed_config)
 243                 return -EINVAL;
 244
 245         if ((fd = simc_open("/dev/net/tun", 02, 0)) < 0) {      /* O_RDWR */
 246                 printk("Failed to open /dev/net/tun, returned %d "
 247                        "(errno = %d)\n", fd, errno);
 248                 return fd;
 249         }
 250
 251         memset(&ifr, 0, sizeof ifr);
 252         ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
 253         strlcpy(ifr.ifr_name, dev_name, sizeof ifr.ifr_name);
 254
 255         if ((err = simc_ioctl(fd, TUNSETIFF, (void*) &ifr)) < 0) {
 256                 printk("Failed to set interface, returned %d "
 257                        "(errno = %d)\n", err, errno);
 258                 simc_close(fd);
 259                 return err;
 260         }
 261
 262         lp->tp.info.tuntap.fd = fd;
 263         return err;
 264 }
 265
 266 static void tuntap_close(struct iss_net_private *lp)
 267 {
 268 #if 0
 269         if (lp->tp.info.tuntap.fixed_config)
 270                 iter_addresses(lp->tp.info.tuntap.dev, close_addr, lp->host.dev_name);
 271 #endif
 272         simc_close(lp->tp.info.tuntap.fd);
 273         lp->tp.info.tuntap.fd = -1;
 274 }
 275
 276 static int tuntap_read (struct iss_net_private *lp, struct sk_buff **skb)
 277 {
 278 #if 0
 279         *skb = ether_adjust_skb(*skb, ETH_HEADER_OTHER);
 280         if (*skb == NULL)
 281                 return -ENOMEM;
 282 #endif
 283
 284         return simc_read(lp->tp.info.tuntap.fd,
 285                         (*skb)->data, (*skb)->dev->mtu + ETH_HEADER_OTHER);
 286 }
 287
 288 static int tuntap_write (struct iss_net_private *lp, struct sk_buff **skb)
 289 {
 290         return simc_write(lp->tp.info.tuntap.fd, (*skb)->data, (*skb)->len);
 291 }
 292
 293 unsigned short tuntap_protocol(struct sk_buff *skb)
 294 {
 295         return eth_type_trans(skb, skb->dev);
 296 }
 297
 298 static int tuntap_poll(struct iss_net_private *lp)
 299 {
 300         return simc_poll(lp->tp.info.tuntap.fd);
 301 }
 302
 303 /*
 304  * Currently only a device name is supported.
 305  * ethX=tuntap[,[mac address][,[device name]]]
 306  */
 307
 308 static int tuntap_probe(struct iss_net_private *lp, int index, char *init)
 309 {
 310         const int len = strlen(TRANSPORT_TUNTAP_NAME);
 311         char *dev_name = NULL, *mac_str = NULL, *rem = NULL;
 312
 313         /* Transport should be 'tuntap': ethX=tuntap,mac,dev_name */
 314
 315         if (strncmp(init, TRANSPORT_TUNTAP_NAME, len))
 316                 return 0;
 317
 318         if (*(init += strlen(TRANSPORT_TUNTAP_NAME)) == ',') {
 319                 if ((rem=split_if_spec(init+1, &mac_str, &dev_name)) != NULL) {
 320                         printk("Extra garbage on specification : '%s'\n", rem);
 321                         return 0;
 322                 }
 323         } else if (*init != '\0') {
 324                 printk("Invalid argument: %s. Skipping device!\n", init);
 325                 return 0;
 326         }
 327
 328         if (dev_name) {
 329                 strncpy(lp->tp.info.tuntap.dev_name, dev_name,
 330                          sizeof lp->tp.info.tuntap.dev_name);
 331                 lp->tp.info.tuntap.fixed_config = 1;
 332         } else
 333                 strcpy(lp->tp.info.tuntap.dev_name, TRANSPORT_TUNTAP_NAME);
 334
 335
 336 #if 0
 337         if (setup_etheraddr(mac_str, lp->mac))
 338                 lp->have_mac = 1;
 339 #endif
 340         lp->mtu = TRANSPORT_TUNTAP_MTU;
 341
 342         //lp->info.tuntap.gate_addr = gate_addr;
 343
 344         lp->tp.info.tuntap.fd = -1;
 345
 346         lp->tp.open = tuntap_open;
 347         lp->tp.close = tuntap_close;
 348         lp->tp.read = tuntap_read;
 349         lp->tp.write = tuntap_write;
 350         lp->tp.protocol = tuntap_protocol;
 351         lp->tp.poll = tuntap_poll;
 352
 353         printk("TUN/TAP backend - ");
 354 #if 0
 355         if (lp->host.gate_addr != NULL)
 356                 printk("IP = %s", lp->host.gate_addr);
 357 #endif
 358         printk("\n");
 359
 360         return 1;
 361 }
 362
 363 /* ================================ ISS NET ================================ */
 364
 365 static int iss_net_rx(struct net_device *dev)
 366 {
 367         struct iss_net_private *lp = dev->priv;
 368         int pkt_len;
 369         struct sk_buff *skb;
 370
 371         /* Check if there is any new data. */
 372
 373         if (lp->tp.poll(lp) == 0)
 374                 return 0;
 375
 376         /* Try to allocate memory, if it fails, try again next round. */
 377
 378         if ((skb = dev_alloc_skb(dev->mtu + 2 + ETH_HEADER_OTHER)) == NULL) {
 379                 lp->stats.rx_dropped++;
 380                 return 0;
 381         }
 382
 383         skb_reserve(skb, 2);
 384
 385         /* Setup skb */
 386
 387         skb->dev = dev;
 388         skb_reset_mac_header(skb);
 389         pkt_len = lp->tp.read(lp, &skb);
 390         skb_put(skb, pkt_len);
 391
 392         if (pkt_len > 0) {
 393                 skb_trim(skb, pkt_len);
 394                 skb->protocol = lp->tp.protocol(skb);
 395
 396                 lp->stats.rx_bytes += skb->len;
 397                 lp->stats.rx_packets++;
 398         //      netif_rx(skb);
 399                 netif_rx_ni(skb);
 400                 return pkt_len;
 401         }
 402         kfree_skb(skb);
 403         return pkt_len;
 404 }
 405
 406 static int iss_net_poll(void)
 407 {
 408         struct list_head *ele;
 409         int err, ret = 0;
 410
 411         spin_lock(&opened_lock);
 412
 413         list_for_each(ele, &opened) {
 414                 struct iss_net_private *lp;
 415
 416                 lp = list_entry(ele, struct iss_net_private, opened_list);
 417
 418                 if (!netif_running(lp->dev))
 419                         break;
 420
 421                 spin_lock(&lp->lock);
 422
 423                 while ((err = iss_net_rx(lp->dev)) > 0)
 424                         ret++;
 425
 426                 spin_unlock(&lp->lock);
 427
 428                 if (err < 0) {
 429                         printk(KERN_ERR "Device '%s' read returned %d, "
 430                                "shutting it down\n", lp->dev->name, err);
 431                         dev_close(lp->dev);
 432                 } else {
 433                         // FIXME reactivate_fd(lp->fd, ISS_ETH_IRQ);
 434                 }
 435         }
 436
 437         spin_unlock(&opened_lock);
 438         return ret;
 439 }
 440
 441
 442 static void iss_net_timer(unsigned long priv)
 443 {
 444         struct iss_net_private* lp = (struct iss_net_private*) priv;
 445
 446         spin_lock(&lp->lock);
 447
 448         iss_net_poll();
 449
 450         mod_timer(&lp->timer, jiffies + lp->timer_val);
 451
 452         spin_unlock(&lp->lock);
 453 }
 454
 455
 456 static int iss_net_open(struct net_device *dev)
 457 {
 458         struct iss_net_private *lp = dev->priv;
 459         char addr[sizeof "255.255.255.255\0"];
 460         int err;
 461
 462         spin_lock(&lp->lock);
 463
 464         if ((err = lp->tp.open(lp)) < 0)
 465                 goto out;
 466
 467         if (!lp->have_mac) {
 468                 dev_ip_addr(dev, addr, &lp->mac[2]);
 469                 set_ether_mac(dev, lp->mac);
 470         }
 471
 472         netif_start_queue(dev);
 473
 474         /* clear buffer - it can happen that the host side of the interface
 475          * is full when we get here. In this case, new data is never queued,
 476          * SIGIOs never arrive, and the net never works.
 477          */
 478         while ((err = iss_net_rx(dev)) > 0)
 479                 ;
 480
 481         spin_lock(&opened_lock);
 482         list_add(&lp->opened_list, &opened);
 483         spin_unlock(&opened_lock);
 484
 485         init_timer(&lp->timer);
 486         lp->timer_val = ISS_NET_TIMER_VALUE;
 487         lp->timer.data = (unsigned long) lp;
 488         lp->timer.function = iss_net_timer;
 489         mod_timer(&lp->timer, jiffies + lp->timer_val);
 490
 491 out:
 492         spin_unlock(&lp->lock);
 493         return err;
 494 }
 495
 496 static int iss_net_close(struct net_device *dev)
 497 {
 498         struct iss_net_private *lp = dev->priv;
 499 printk("iss_net_close!\n");
 500         netif_stop_queue(dev);
 501         spin_lock(&lp->lock);
 502
 503         spin_lock(&opened_lock);
 504         list_del(&opened);
 505         spin_unlock(&opened_lock);
 506
 507         del_timer_sync(&lp->timer);
 508
 509         lp->tp.close(lp);
 510
 511         spin_unlock(&lp->lock);
 512         return 0;
 513 }
 514
 515 static int iss_net_start_xmit(struct sk_buff *skb, struct net_device *dev)
 516 {
 517         struct iss_net_private *lp = dev->priv;
 518         unsigned long flags;
 519         int len;
 520
 521         netif_stop_queue(dev);
 522         spin_lock_irqsave(&lp->lock, flags);
 523
 524         len = lp->tp.write(lp, &skb);
 525
 526         if (len == skb->len) {
 527                 lp->stats.tx_packets++;
 528                 lp->stats.tx_bytes += skb->len;
 529                 dev->trans_start = jiffies;
 530                 netif_start_queue(dev);
 531
 532                 /* this is normally done in the interrupt when tx finishes */
 533                 netif_wake_queue(dev);
 534
 535         } else if (len == 0) {
 536                 netif_start_queue(dev);
 537                 lp->stats.tx_dropped++;
 538
 539         } else {
 540                 netif_start_queue(dev);
 541                 printk(KERN_ERR "iss_net_start_xmit: failed(%d)\n", len);
 542         }
 543
 544         spin_unlock_irqrestore(&lp->lock, flags);
 545
 546         dev_kfree_skb(skb);
 547         return 0;
 548 }
 549
 550
 551 static struct net_device_stats *iss_net_get_stats(struct net_device *dev)
 552 {
 553         struct iss_net_private *lp = dev->priv;
 554         return &lp->stats;
 555 }
 556
 557 static void iss_net_set_multicast_list(struct net_device *dev)
 558 {
 559 #if 0
 560         if (dev->flags & IFF_PROMISC)
 561                 return;
 562         else if (dev->mc_count)
 563                 dev->flags |= IFF_ALLMULTI;
 564         else
 565                 dev->flags &= ~IFF_ALLMULTI;
 566 #endif
 567 }
 568
 569 static void iss_net_tx_timeout(struct net_device *dev)
 570 {
 571 #if 0
 572         dev->trans_start = jiffies;
 573         netif_wake_queue(dev);
 574 #endif
 575 }
 576
 577 static int iss_net_set_mac(struct net_device *dev, void *addr)
 578 {
 579 #if 0
 580         struct iss_net_private *lp = dev->priv;
 581         struct sockaddr *hwaddr = addr;
 582
 583         spin_lock(&lp->lock);
 584         memcpy(dev->dev_addr, hwaddr->sa_data, ETH_ALEN);
 585         spin_unlock(&lp->lock);
 586 #endif
 587
 588         return 0;
 589 }
 590
 591 static int iss_net_change_mtu(struct net_device *dev, int new_mtu)
 592 {
 593 #if 0
 594         struct iss_net_private *lp = dev->priv;
 595         int err = 0;
 596
 597         spin_lock(&lp->lock);
 598
 599         // FIXME not needed new_mtu = transport_set_mtu(new_mtu, &lp->user);
 600
 601         if (new_mtu < 0)
 602                 err = new_mtu;
 603         else
 604                 dev->mtu = new_mtu;
 605
 606         spin_unlock(&lp->lock);
 607         return err;
 608 #endif
 609         return -EINVAL;
 610 }
 611
 612 void iss_net_user_timer_expire(unsigned long _conn)
 613 {
 614 }
 615
 616
 617 static struct platform_driver iss_net_driver = {
 618         .driver = {
 619                 .name  = DRIVER_NAME,
 620         },
 621 };
 622
 623 static int driver_registered;
 624
 625 static int iss_net_configure(int index, char *init)
 626 {
 627         struct net_device *dev;
 628         struct iss_net_private *lp;
 629         int err;
 630
 631         if ((dev = alloc_etherdev(sizeof *lp)) == NULL) {
 632                 printk(KERN_ERR "eth_configure: failed to allocate device\n");
 633                 return 1;
 634         }
 635
 636         /* Initialize private element. */
 637
 638         lp = dev->priv;
 639         *lp = ((struct iss_net_private) {
 640                 .device_list            = LIST_HEAD_INIT(lp->device_list),
 641                 .opened_list            = LIST_HEAD_INIT(lp->opened_list),
 642                 .lock                   = SPIN_LOCK_UNLOCKED,
 643                 .dev                    = dev,
 644                 .index                  = index,
 645                 //.fd                   = -1,
 646                 .mac                    = { 0xfe, 0xfd, 0x0, 0x0, 0x0, 0x0 },
 647                 .have_mac               = 0,
 648                 });
 649
 650         /*
 651          * Try all transport protocols.
 652          * Note: more protocols can be added by adding '&& !X_init(lp, eth)'.
 653          */
 654
 655         if (!tuntap_probe(lp, index, init)) {
 656                 printk("Invalid arguments. Skipping device!\n");
 657                 goto errout;
 658         }
 659
 660         printk(KERN_INFO "Netdevice %d ", index);
 661         if (lp->have_mac)
 662                 printk("(%02x:%02x:%02x:%02x:%02x:%02x) ",
 663                                 lp->mac[0], lp->mac[1],
 664                                 lp->mac[2], lp->mac[3],
 665                                 lp->mac[4], lp->mac[5]);
 666         printk(": ");
 667
 668         /* sysfs register */
 669
 670         if (!driver_registered) {
 671                 platform_driver_register(&iss_net_driver);
 672                 driver_registered = 1;
 673         }
 674
 675         spin_lock(&devices_lock);
 676         list_add(&lp->device_list, &devices);
 677         spin_unlock(&devices_lock);
 678
 679         lp->pdev.id = index;
 680         lp->pdev.name = DRIVER_NAME;
 681         platform_device_register(&lp->pdev);
 682         SET_NETDEV_DEV(dev,&lp->pdev.dev);
 683
 684         /*
 685          * If this name ends up conflicting with an existing registered
 686          * netdevice, that is OK, register_netdev{,ice}() will notice this
 687          * and fail.
 688          */
 689         snprintf(dev->name, sizeof dev->name, "eth%d", index);
 690
 691         dev->mtu = lp->mtu;
 692         dev->open = iss_net_open;
 693         dev->hard_start_xmit = iss_net_start_xmit;
 694         dev->stop = iss_net_close;
 695         dev->get_stats = iss_net_get_stats;
 696         dev->set_multicast_list = iss_net_set_multicast_list;
 697         dev->tx_timeout = iss_net_tx_timeout;
 698         dev->set_mac_address = iss_net_set_mac;
 699         dev->change_mtu = iss_net_change_mtu;
 700         dev->watchdog_timeo = (HZ >> 1);
 701         dev->irq = -1;
 702
 703         rtnl_lock();
 704         err = register_netdevice(dev);
 705         rtnl_unlock();
 706
 707         if (err) {
 708                 printk("Error registering net device!\n");
 709                 /* XXX: should we call ->remove() here? */
 710                 free_netdev(dev);
 711                 return 1;
 712         }
 713
 714         init_timer(&lp->tl);
 715         lp->tl.function = iss_net_user_timer_expire;
 716
 717 #if 0
 718         if (lp->have_mac)
 719                 set_ether_mac(dev, lp->mac);
 720 #endif
 721         return 0;
 722
 723 errout:
 724         // FIXME: unregister; free, etc..
 725         return -EIO;
 726
 727 }
 728
 729 /* ------------------------------------------------------------------------- */
 730
 731 /* Filled in during early boot */
 732
 733 struct list_head eth_cmd_line = LIST_HEAD_INIT(eth_cmd_line);
 734
 735 struct iss_net_init {
 736         struct list_head list;
 737         char *init;             /* init string */
 738         int index;
 739 };
 740
 741 /*
 742  * Parse the command line and look for 'ethX=...' fields, and register all
 743  * those fields. They will be later initialized in iss_net_init.
 744  */
 745
 746 #define ERR KERN_ERR "iss_net_setup: "
 747
 748 static int iss_net_setup(char *str)
 749 {
 750         struct iss_net_private *device = NULL;
 751         struct iss_net_init *new;
 752         struct list_head *ele;
 753         char *end;
 754         int n;
 755
 756         n = simple_strtoul(str, &end, 0);
 757         if (end == str) {
 758                 printk(ERR "Failed to parse '%s'\n", str);
 759                 return 1;
 760         }
 761         if (n < 0) {
 762                 printk(ERR "Device %d is negative\n", n);
 763                 return 1;
 764         }
 765         if (*(str = end) != '=') {
 766                 printk(ERR "Expected '=' after device number\n");
 767                 return 1;
 768         }
 769
 770         spin_lock(&devices_lock);
 771
 772         list_for_each(ele, &devices) {
 773                 device = list_entry(ele, struct iss_net_private, device_list);
 774                 if (device->index == n)
 775                         break;
 776         }
 777
 778         spin_unlock(&devices_lock);
 779
 780         if (device && device->index == n) {
 781                 printk(ERR "Device %d already configured\n", n);
 782                 return 1;
 783         }
 784
 785         if ((new = alloc_bootmem(sizeof new)) == NULL) {
 786                 printk("Alloc_bootmem failed\n");
 787                 return 1;
 788         }
 789
 790         INIT_LIST_HEAD(&new->list);
 791         new->index = n;
 792         new->init = str + 1;
 793
 794         list_add_tail(&new->list, &eth_cmd_line);
 795         return 1;
 796 }
 797
 798 #undef ERR
 799
 800 __setup("eth=", iss_net_setup);
 801
 802 /*
 803  * Initialize all ISS Ethernet devices previously registered in iss_net_setup.
 804  */
 805
 806 static int iss_net_init(void)
 807 {
 808         struct list_head *ele, *next;
 809
 810         /* Walk through all Ethernet devices specified in the command line. */
 811
 812         list_for_each_safe(ele, next, &eth_cmd_line) {
 813                 struct iss_net_init *eth;
 814                 eth = list_entry(ele, struct iss_net_init, list);
 815                 iss_net_configure(eth->index, eth->init);
 816         }
 817
 818         return 1;
 819 }
 820
 821 module_init(iss_net_init);
 822