Merge acpi-2.6.12 to-akpm
[linux-2.6] / arch / xtensa / platform-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/config.h>
20 #include <linux/list.h>
21 #include <linux/irq.h>
22 #include <linux/spinlock.h>
23 #include <linux/slab.h>
24 #include <linux/timer.h>
25 #include <linux/if_ether.h>
26 #include <linux/inetdevice.h>
27 #include <linux/init.h>
28 #include <linux/if_tun.h>
29 #include <linux/etherdevice.h>
30 #include <linux/interrupt.h>
31 #include <linux/ioctl.h>
32 #include <linux/bootmem.h>
33 #include <linux/ethtool.h>
34 #include <linux/rtnetlink.h>
35 #include <linux/timer.h>
36
37 #include <xtensa/simcall.h>
38
39 #define DRIVER_NAME "iss-netdev"
40 #define ETH_MAX_PACKET 1500
41 #define ETH_HEADER_OTHER 14
42 #define ISS_NET_TIMER_VALUE (2 * HZ)
43
44
45 static DEFINE_SPINLOCK(opened_lock);
46 static LIST_HEAD(opened);
47
48 static DEFINE_SPINLOCK(devices_lock);
49 static LIST_HEAD(devices);
50
51 /* ------------------------------------------------------------------------- */
52
53 /* We currently only support the TUNTAP transport protocol. */
54
55 #define TRANSPORT_TUNTAP_NAME "tuntap"
56 #define TRANSPORT_TUNTAP_MTU ETH_MAX_PACKET
57
58 struct tuntap_info {
59         char dev_name[IFNAMSIZ];
60         int fixed_config;
61         unsigned char gw[ETH_ALEN];
62         int fd;
63 };
64
65 /* ------------------------------------------------------------------------- */
66
67
68 /* This structure contains out private information for the driver. */
69
70 struct iss_net_private {
71
72         struct list_head device_list;
73         struct list_head opened_list;
74
75         spinlock_t lock;
76         struct net_device *dev;
77         struct platform_device pdev;
78         struct timer_list tl;
79         struct net_device_stats stats;
80
81         struct timer_list timer;
82         unsigned int timer_val;
83
84         int index;
85         int mtu;
86
87         unsigned char mac[ETH_ALEN];
88         int have_mac;
89
90         struct {
91                 union {
92                         struct tuntap_info tuntap;
93                 } info;
94
95                 int (*open)(struct iss_net_private *lp);
96                 void (*close)(struct iss_net_private *lp);
97                 int (*read)(struct iss_net_private *lp, struct sk_buff **skb);
98                 int (*write)(struct iss_net_private *lp, struct sk_buff **skb);
99                 unsigned short (*protocol)(struct sk_buff *skb);
100                 int (*poll)(struct iss_net_private *lp);
101         } tp;
102
103 };
104
105 /* ======================= ISS SIMCALL INTERFACE =========================== */
106
107 /* Note: __simc must _not_ be declared inline! */
108
109 static int errno;
110
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         u32 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 - 1);
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 = dev->priv;
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->mac.raw = skb->data;
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         //      netif_rx(skb);
397                 netif_rx_ni(skb);
398
399                 lp->stats.rx_bytes += skb->len;
400                 lp->stats.rx_packets++;
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 = dev->priv;
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 gethere. 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 = dev->priv;
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 = dev->priv;
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 0;
549 }
550
551
552 static struct net_device_stats *iss_net_get_stats(struct net_device *dev)
553 {
554         struct iss_net_private *lp = dev->priv;
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 (dev->mc_count)
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 = dev->priv;
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 = dev->priv;
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 static int iss_net_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
614 {
615 #if 0
616         static const struct ethtool_drvinfo info = {
617                 .cmd     = ETHTOOL_GDRVINFO,
618                 .driver  = DRIVER_NAME,
619                 .version = "42",
620         };
621         void *useraddr;
622         u32 ethcmd;
623
624         switch (cmd) {
625         case SIOCETHTOOL:
626                 useraddr = ifr->ifr_data;
627                 if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
628                         return -EFAULT;
629
630                 switch (ethcmd) {
631                         case ETHTOOL_GDRVINFO:
632                                 if (copy_to_user(useraddr, &info, sizeof(info)))
633                                         return -EFAULT;
634                                 return 0;
635                         default:
636                                 return -EOPNOTSUPP;
637                 }
638         default:
639                 return -EINVAL;
640         }
641 #endif
642         return -EINVAL;
643 }
644
645 void iss_net_user_timer_expire(unsigned long _conn)
646 {
647 }
648
649
650 static struct device_driver iss_net_driver = {
651         .name  = DRIVER_NAME,
652         .bus   = &platform_bus_type,
653 };
654
655 static int driver_registered;
656
657 static int iss_net_configure(int index, char *init)
658 {
659         struct net_device *dev;
660         struct iss_net_private *lp;
661         int err;
662
663         if ((dev = alloc_etherdev(sizeof *lp)) == NULL) {
664                 printk(KERN_ERR "eth_configure: failed to allocate device\n");
665                 return 1;
666         }
667
668         /* Initialize private element. */
669
670         lp = dev->priv;
671         *lp = ((struct iss_net_private) {
672                 .device_list            = LIST_HEAD_INIT(lp->device_list),
673                 .opened_list            = LIST_HEAD_INIT(lp->opened_list),
674                 .lock                   = SPIN_LOCK_UNLOCKED,
675                 .dev                    = dev,
676                 .index                  = index,
677                 //.fd                   = -1,
678                 .mac                    = { 0xfe, 0xfd, 0x0, 0x0, 0x0, 0x0 },
679                 .have_mac               = 0,
680                 });
681
682         /*
683          * Try all transport protocols.
684          * Note: more protocols can be added by adding '&& !X_init(lp, eth)'.
685          */
686
687         if (!tuntap_probe(lp, index, init)) {
688                 printk("Invalid arguments. Skipping device!\n");
689                 goto errout;
690         }
691
692         printk(KERN_INFO "Netdevice %d ", index);
693         if (lp->have_mac)
694                 printk("(%02x:%02x:%02x:%02x:%02x:%02x) ",
695                                 lp->mac[0], lp->mac[1],
696                                 lp->mac[2], lp->mac[3],
697                                 lp->mac[4], lp->mac[5]);
698         printk(": ");
699
700         /* sysfs register */
701
702         if (!driver_registered) {
703                 driver_register(&iss_net_driver);
704                 driver_registered = 1;
705         }
706
707         spin_lock(&devices_lock);
708         list_add(&lp->device_list, &devices);
709         spin_unlock(&devices_lock);
710
711         lp->pdev.id = index;
712         lp->pdev.name = DRIVER_NAME;
713         platform_device_register(&lp->pdev);
714         SET_NETDEV_DEV(dev,&lp->pdev.dev);
715
716         /*
717          * If this name ends up conflicting with an existing registered
718          * netdevice, that is OK, register_netdev{,ice}() will notice this
719          * and fail.
720          */
721         snprintf(dev->name, sizeof dev->name, "eth%d", index);
722
723         dev->mtu = lp->mtu;
724         dev->open = iss_net_open;
725         dev->hard_start_xmit = iss_net_start_xmit;
726         dev->stop = iss_net_close;
727         dev->get_stats = iss_net_get_stats;
728         dev->set_multicast_list = iss_net_set_multicast_list;
729         dev->tx_timeout = iss_net_tx_timeout;
730         dev->set_mac_address = iss_net_set_mac;
731         dev->change_mtu = iss_net_change_mtu;
732         dev->do_ioctl = iss_net_ioctl;
733         dev->watchdog_timeo = (HZ >> 1);
734         dev->irq = -1;
735
736         rtnl_lock();
737         err = register_netdevice(dev);
738         rtnl_unlock();
739
740         if (err) {
741                 printk("Error registering net device!\n");
742                 /* XXX: should we call ->remove() here? */
743                 free_netdev(dev);
744                 return 1;
745         }
746
747         init_timer(&lp->tl);
748         lp->tl.function = iss_net_user_timer_expire;
749
750 #if 0
751         if (lp->have_mac)
752                 set_ether_mac(dev, lp->mac);
753 #endif
754         return 0;
755
756 errout:
757         // FIXME: unregister; free, etc..
758         return -EIO;
759
760 }
761
762 /* ------------------------------------------------------------------------- */
763
764 /* Filled in during early boot */
765
766 struct list_head eth_cmd_line = LIST_HEAD_INIT(eth_cmd_line);
767
768 struct iss_net_init {
769         struct list_head list;
770         char *init;             /* init string */
771         int index;
772 };
773
774 /*
775  * Parse the command line and look for 'ethX=...' fields, and register all
776  * those fields. They will be later initialized in iss_net_init.
777  */
778
779 #define ERR KERN_ERR "iss_net_setup: "
780
781 static int iss_net_setup(char *str)
782 {
783         struct iss_net_private *device = NULL;
784         struct iss_net_init *new;
785         struct list_head *ele;
786         char *end;
787         int n;
788
789         n = simple_strtoul(str, &end, 0);
790         if (end == str) {
791                 printk(ERR "Failed to parse '%s'\n", str);
792                 return 1;
793         }
794         if (n < 0) {
795                 printk(ERR "Device %d is negative\n", n);
796                 return 1;
797         }
798         if (*(str = end) != '=') {
799                 printk(ERR "Expected '=' after device number\n");
800                 return 1;
801         }
802
803         spin_lock(&devices_lock);
804
805         list_for_each(ele, &devices) {
806                 device = list_entry(ele, struct iss_net_private, device_list);
807                 if (device->index == n)
808                         break;
809         }
810
811         spin_unlock(&devices_lock);
812
813         if (device && device->index == n) {
814                 printk(ERR "Device %d already configured\n", n);
815                 return 1;
816         }
817
818         if ((new = alloc_bootmem(sizeof new)) == NULL) {
819                 printk("Alloc_bootmem failed\n");
820                 return 1;
821         }
822
823         INIT_LIST_HEAD(&new->list);
824         new->index = n;
825         new->init = str + 1;
826
827         list_add_tail(&new->list, &eth_cmd_line);
828         return 1;
829 }
830
831 #undef ERR
832
833 __setup("eth", iss_net_setup);
834
835 /*
836  * Initialize all ISS Ethernet devices previously registered in iss_net_setup.
837  */
838
839 static int iss_net_init(void)
840 {
841         struct list_head *ele, *next;
842
843         /* Walk through all Ethernet devices specified in the command line. */
844
845         list_for_each_safe(ele, next, &eth_cmd_line) {
846                 struct iss_net_init *eth;
847                 eth = list_entry(ele, struct iss_net_init, list);
848                 iss_net_configure(eth->index, eth->init);
849         }
850
851         return 1;
852 }
853
854 module_init(iss_net_init);
855