• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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__));
__simc(int a,int b,int c,int d,int e,int f)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 
simc_open(char * file,int flags,int mode)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 
simc_close(int fd)126 static int inline simc_close(int fd)
127 {
128 	return __simc(SYS_close, fd, 0, 0, 0, 0);
129 }
130 
simc_ioctl(int fd,int request,void * arg)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 
simc_read(int fd,void * buf,size_t count)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 
simc_write(int fd,void * buf,size_t count)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 
simc_poll(int fd)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 
split_if_spec(char * str,...)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 
dev_ip_addr(void * d,char * buf,char * bin_buf)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 
set_ether_mac(void * d,unsigned char * addr)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 
tuntap_open(struct iss_net_private * lp)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 
tuntap_close(struct iss_net_private * lp)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 
tuntap_read(struct iss_net_private * lp,struct sk_buff ** skb)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 
tuntap_write(struct iss_net_private * lp,struct sk_buff ** skb)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 
tuntap_protocol(struct sk_buff * skb)294 unsigned short tuntap_protocol(struct sk_buff *skb)
295 {
296 	return eth_type_trans(skb, skb->dev);
297 }
298 
tuntap_poll(struct iss_net_private * lp)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 
tuntap_probe(struct iss_net_private * lp,int index,char * init)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 
iss_net_rx(struct net_device * dev)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 
iss_net_poll(void)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 
iss_net_timer(unsigned long priv)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 
iss_net_open(struct net_device * dev)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 
iss_net_close(struct net_device * dev)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 
iss_net_start_xmit(struct sk_buff * skb,struct net_device * dev)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 
iss_net_get_stats(struct net_device * dev)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 
iss_net_set_multicast_list(struct net_device * dev)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 
iss_net_tx_timeout(struct net_device * dev)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 
iss_net_set_mac(struct net_device * dev,void * addr)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 
iss_net_change_mtu(struct net_device * dev,int new_mtu)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 
iss_net_user_timer_expire(unsigned long _conn)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_rx_mode	= iss_net_set_multicast_list,
637 };
638 
iss_net_configure(int index,char * init)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 
iss_net_setup(char * str)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 
iss_net_init(void)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 
827