arch/xtensa/platforms/iss/network.c

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