3 * arch/xtensa/platforms/iss/network.c
5 * Platform specific initialization.
7 * Authors: Chris Zankel <chris@zankel.net>
8 * Based on work form the UML team.
10 * Copyright 2005 Tensilica Inc.
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.
19 #define pr_fmt(fmt) "%s: " fmt, __func__
21 #include <linux/list.h>
22 #include <linux/irq.h>
23 #include <linux/spinlock.h>
24 #include <linux/slab.h>
25 #include <linux/timer.h>
26 #include <linux/if_ether.h>
27 #include <linux/inetdevice.h>
28 #include <linux/init.h>
29 #include <linux/if_tun.h>
30 #include <linux/etherdevice.h>
31 #include <linux/interrupt.h>
32 #include <linux/ioctl.h>
33 #include <linux/bootmem.h>
34 #include <linux/ethtool.h>
35 #include <linux/rtnetlink.h>
36 #include <linux/platform_device.h>
38 #include <platform/simcall.h>
40 #define DRIVER_NAME "iss-netdev"
41 #define ETH_MAX_PACKET 1500
42 #define ETH_HEADER_OTHER 14
43 #define ISS_NET_TIMER_VALUE (HZ / 10)
46 static DEFINE_SPINLOCK(opened_lock);
47 static LIST_HEAD(opened);
49 static DEFINE_SPINLOCK(devices_lock);
50 static LIST_HEAD(devices);
52 /* ------------------------------------------------------------------------- */
54 /* We currently only support the TUNTAP transport protocol. */
56 #define TRANSPORT_TUNTAP_NAME "tuntap"
57 #define TRANSPORT_TUNTAP_MTU ETH_MAX_PACKET
60 char dev_name[IFNAMSIZ];
64 /* ------------------------------------------------------------------------- */
67 /* This structure contains out private information for the driver. */
69 struct iss_net_private {
70 struct list_head device_list;
71 struct list_head opened_list;
74 struct net_device *dev;
75 struct platform_device pdev;
77 struct net_device_stats stats;
79 struct timer_list timer;
80 unsigned int timer_val;
87 struct tuntap_info tuntap;
90 int (*open)(struct iss_net_private *lp);
91 void (*close)(struct iss_net_private *lp);
92 int (*read)(struct iss_net_private *lp, struct sk_buff **skb);
93 int (*write)(struct iss_net_private *lp, struct sk_buff **skb);
94 unsigned short (*protocol)(struct sk_buff *skb);
95 int (*poll)(struct iss_net_private *lp);
100 /* ================================ HELPERS ================================ */
103 static char *split_if_spec(char *str, ...)
109 while ((arg = va_arg(ap, char**)) != NULL) {
114 end = strchr(str, ',');
128 /* Set Ethernet address of the specified device. */
130 static void setup_etheraddr(struct net_device *dev, char *str)
132 unsigned char *addr = dev->dev_addr;
137 if (!mac_pton(str, addr)) {
138 pr_err("%s: failed to parse '%s' as an ethernet address\n",
142 if (is_multicast_ether_addr(addr)) {
143 pr_err("%s: attempt to assign a multicast ethernet address\n",
147 if (!is_valid_ether_addr(addr)) {
148 pr_err("%s: attempt to assign an invalid ethernet address\n",
152 if (!is_local_ether_addr(addr))
153 pr_warn("%s: assigning a globally valid ethernet address\n",
158 pr_info("%s: choosing a random ethernet address\n",
160 eth_hw_addr_random(dev);
163 /* ======================= TUNTAP TRANSPORT INTERFACE ====================== */
165 static int tuntap_open(struct iss_net_private *lp)
168 char *dev_name = lp->tp.info.tuntap.dev_name;
172 fd = simc_open("/dev/net/tun", 02, 0); /* O_RDWR */
174 pr_err("%s: failed to open /dev/net/tun, returned %d (errno = %d)\n",
175 lp->dev->name, fd, errno);
179 memset(&ifr, 0, sizeof(ifr));
180 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
181 strlcpy(ifr.ifr_name, dev_name, sizeof(ifr.ifr_name));
183 err = simc_ioctl(fd, TUNSETIFF, &ifr);
185 pr_err("%s: failed to set interface %s, returned %d (errno = %d)\n",
186 lp->dev->name, dev_name, err, errno);
191 lp->tp.info.tuntap.fd = fd;
195 static void tuntap_close(struct iss_net_private *lp)
197 simc_close(lp->tp.info.tuntap.fd);
198 lp->tp.info.tuntap.fd = -1;
201 static int tuntap_read(struct iss_net_private *lp, struct sk_buff **skb)
203 return simc_read(lp->tp.info.tuntap.fd,
204 (*skb)->data, (*skb)->dev->mtu + ETH_HEADER_OTHER);
207 static int tuntap_write(struct iss_net_private *lp, struct sk_buff **skb)
209 return simc_write(lp->tp.info.tuntap.fd, (*skb)->data, (*skb)->len);
212 unsigned short tuntap_protocol(struct sk_buff *skb)
214 return eth_type_trans(skb, skb->dev);
217 static int tuntap_poll(struct iss_net_private *lp)
219 return simc_poll(lp->tp.info.tuntap.fd);
223 * ethX=tuntap,[mac address],device name
226 static int tuntap_probe(struct iss_net_private *lp, int index, char *init)
228 struct net_device *dev = lp->dev;
229 char *dev_name = NULL, *mac_str = NULL, *rem = NULL;
231 /* Transport should be 'tuntap': ethX=tuntap,mac,dev_name */
233 if (strncmp(init, TRANSPORT_TUNTAP_NAME,
234 sizeof(TRANSPORT_TUNTAP_NAME) - 1))
237 init += sizeof(TRANSPORT_TUNTAP_NAME) - 1;
239 rem = split_if_spec(init + 1, &mac_str, &dev_name);
241 pr_err("%s: extra garbage on specification : '%s'\n",
245 } else if (*init != '\0') {
246 pr_err("%s: invalid argument: %s. Skipping device!\n",
252 pr_err("%s: missing tuntap device name\n", dev->name);
256 strlcpy(lp->tp.info.tuntap.dev_name, dev_name,
257 sizeof(lp->tp.info.tuntap.dev_name));
259 setup_etheraddr(dev, mac_str);
261 lp->mtu = TRANSPORT_TUNTAP_MTU;
263 lp->tp.info.tuntap.fd = -1;
265 lp->tp.open = tuntap_open;
266 lp->tp.close = tuntap_close;
267 lp->tp.read = tuntap_read;
268 lp->tp.write = tuntap_write;
269 lp->tp.protocol = tuntap_protocol;
270 lp->tp.poll = tuntap_poll;
275 /* ================================ ISS NET ================================ */
277 static int iss_net_rx(struct net_device *dev)
279 struct iss_net_private *lp = netdev_priv(dev);
283 /* Check if there is any new data. */
285 if (lp->tp.poll(lp) == 0)
288 /* Try to allocate memory, if it fails, try again next round. */
290 skb = dev_alloc_skb(dev->mtu + 2 + ETH_HEADER_OTHER);
292 lp->stats.rx_dropped++;
301 skb_reset_mac_header(skb);
302 pkt_len = lp->tp.read(lp, &skb);
303 skb_put(skb, pkt_len);
306 skb_trim(skb, pkt_len);
307 skb->protocol = lp->tp.protocol(skb);
309 lp->stats.rx_bytes += skb->len;
310 lp->stats.rx_packets++;
318 static int iss_net_poll(void)
320 struct list_head *ele;
323 spin_lock(&opened_lock);
325 list_for_each(ele, &opened) {
326 struct iss_net_private *lp;
328 lp = list_entry(ele, struct iss_net_private, opened_list);
330 if (!netif_running(lp->dev))
333 spin_lock(&lp->lock);
335 while ((err = iss_net_rx(lp->dev)) > 0)
338 spin_unlock(&lp->lock);
341 pr_err("Device '%s' read returned %d, shutting it down\n",
345 /* FIXME reactivate_fd(lp->fd, ISS_ETH_IRQ); */
349 spin_unlock(&opened_lock);
354 static void iss_net_timer(struct timer_list *t)
356 struct iss_net_private *lp = from_timer(lp, t, timer);
359 spin_lock(&lp->lock);
360 mod_timer(&lp->timer, jiffies + lp->timer_val);
361 spin_unlock(&lp->lock);
365 static int iss_net_open(struct net_device *dev)
367 struct iss_net_private *lp = netdev_priv(dev);
370 spin_lock_bh(&lp->lock);
372 err = lp->tp.open(lp);
376 netif_start_queue(dev);
378 /* clear buffer - it can happen that the host side of the interface
379 * is full when we get here. In this case, new data is never queued,
380 * SIGIOs never arrive, and the net never works.
382 while ((err = iss_net_rx(dev)) > 0)
385 spin_unlock_bh(&lp->lock);
386 spin_lock_bh(&opened_lock);
387 list_add(&lp->opened_list, &opened);
388 spin_unlock_bh(&opened_lock);
389 spin_lock_bh(&lp->lock);
391 timer_setup(&lp->timer, iss_net_timer, 0);
392 lp->timer_val = ISS_NET_TIMER_VALUE;
393 mod_timer(&lp->timer, jiffies + lp->timer_val);
396 spin_unlock_bh(&lp->lock);
400 static int iss_net_close(struct net_device *dev)
402 struct iss_net_private *lp = netdev_priv(dev);
403 netif_stop_queue(dev);
404 spin_lock_bh(&lp->lock);
406 spin_lock(&opened_lock);
408 spin_unlock(&opened_lock);
410 del_timer_sync(&lp->timer);
414 spin_unlock_bh(&lp->lock);
418 static int iss_net_start_xmit(struct sk_buff *skb, struct net_device *dev)
420 struct iss_net_private *lp = netdev_priv(dev);
423 netif_stop_queue(dev);
424 spin_lock_bh(&lp->lock);
426 len = lp->tp.write(lp, &skb);
428 if (len == skb->len) {
429 lp->stats.tx_packets++;
430 lp->stats.tx_bytes += skb->len;
431 netif_trans_update(dev);
432 netif_start_queue(dev);
434 /* this is normally done in the interrupt when tx finishes */
435 netif_wake_queue(dev);
437 } else if (len == 0) {
438 netif_start_queue(dev);
439 lp->stats.tx_dropped++;
442 netif_start_queue(dev);
443 pr_err("%s: %s failed(%d)\n", dev->name, __func__, len);
446 spin_unlock_bh(&lp->lock);
453 static struct net_device_stats *iss_net_get_stats(struct net_device *dev)
455 struct iss_net_private *lp = netdev_priv(dev);
459 static void iss_net_set_multicast_list(struct net_device *dev)
463 static void iss_net_tx_timeout(struct net_device *dev)
467 static int iss_net_set_mac(struct net_device *dev, void *addr)
469 struct iss_net_private *lp = netdev_priv(dev);
470 struct sockaddr *hwaddr = addr;
472 if (!is_valid_ether_addr(hwaddr->sa_data))
473 return -EADDRNOTAVAIL;
474 spin_lock_bh(&lp->lock);
475 memcpy(dev->dev_addr, hwaddr->sa_data, ETH_ALEN);
476 spin_unlock_bh(&lp->lock);
480 static int iss_net_change_mtu(struct net_device *dev, int new_mtu)
485 void iss_net_user_timer_expire(struct timer_list *unused)
490 static struct platform_driver iss_net_driver = {
496 static int driver_registered;
498 static const struct net_device_ops iss_netdev_ops = {
499 .ndo_open = iss_net_open,
500 .ndo_stop = iss_net_close,
501 .ndo_get_stats = iss_net_get_stats,
502 .ndo_start_xmit = iss_net_start_xmit,
503 .ndo_validate_addr = eth_validate_addr,
504 .ndo_change_mtu = iss_net_change_mtu,
505 .ndo_set_mac_address = iss_net_set_mac,
506 .ndo_tx_timeout = iss_net_tx_timeout,
507 .ndo_set_rx_mode = iss_net_set_multicast_list,
510 static int iss_net_configure(int index, char *init)
512 struct net_device *dev;
513 struct iss_net_private *lp;
516 dev = alloc_etherdev(sizeof(*lp));
518 pr_err("eth_configure: failed to allocate device\n");
522 /* Initialize private element. */
524 lp = netdev_priv(dev);
525 *lp = (struct iss_net_private) {
526 .device_list = LIST_HEAD_INIT(lp->device_list),
527 .opened_list = LIST_HEAD_INIT(lp->opened_list),
532 spin_lock_init(&lp->lock);
534 * If this name ends up conflicting with an existing registered
535 * netdevice, that is OK, register_netdev{,ice}() will notice this
538 snprintf(dev->name, sizeof(dev->name), "eth%d", index);
541 * Try all transport protocols.
542 * Note: more protocols can be added by adding '&& !X_init(lp, eth)'.
545 if (!tuntap_probe(lp, index, init)) {
546 pr_err("%s: invalid arguments. Skipping device!\n",
551 pr_info("Netdevice %d (%pM)\n", index, dev->dev_addr);
555 if (!driver_registered) {
556 platform_driver_register(&iss_net_driver);
557 driver_registered = 1;
560 spin_lock(&devices_lock);
561 list_add(&lp->device_list, &devices);
562 spin_unlock(&devices_lock);
565 lp->pdev.name = DRIVER_NAME;
566 platform_device_register(&lp->pdev);
567 SET_NETDEV_DEV(dev, &lp->pdev.dev);
569 dev->netdev_ops = &iss_netdev_ops;
571 dev->watchdog_timeo = (HZ >> 1);
575 err = register_netdevice(dev);
579 pr_err("%s: error registering net device!\n", dev->name);
580 /* XXX: should we call ->remove() here? */
585 timer_setup(&lp->tl, iss_net_user_timer_expire, 0);
590 /* FIXME: unregister; free, etc.. */
594 /* ------------------------------------------------------------------------- */
596 /* Filled in during early boot */
598 struct list_head eth_cmd_line = LIST_HEAD_INIT(eth_cmd_line);
600 struct iss_net_init {
601 struct list_head list;
602 char *init; /* init string */
607 * Parse the command line and look for 'ethX=...' fields, and register all
608 * those fields. They will be later initialized in iss_net_init.
611 static int __init iss_net_setup(char *str)
613 struct iss_net_private *device = NULL;
614 struct iss_net_init *new;
615 struct list_head *ele;
620 end = strchr(str, '=');
622 pr_err("Expected '=' after device number\n");
626 rc = kstrtouint(str, 0, &n);
629 pr_err("Failed to parse '%s'\n", str);
634 spin_lock(&devices_lock);
636 list_for_each(ele, &devices) {
637 device = list_entry(ele, struct iss_net_private, device_list);
638 if (device->index == n)
642 spin_unlock(&devices_lock);
644 if (device && device->index == n) {
645 pr_err("Device %u already configured\n", n);
649 new = alloc_bootmem(sizeof(*new));
651 pr_err("Alloc_bootmem failed\n");
655 INIT_LIST_HEAD(&new->list);
659 list_add_tail(&new->list, ð_cmd_line);
663 __setup("eth", iss_net_setup);
666 * Initialize all ISS Ethernet devices previously registered in iss_net_setup.
669 static int iss_net_init(void)
671 struct list_head *ele, *next;
673 /* Walk through all Ethernet devices specified in the command line. */
675 list_for_each_safe(ele, next, ð_cmd_line) {
676 struct iss_net_init *eth;
677 eth = list_entry(ele, struct iss_net_init, list);
678 iss_net_configure(eth->index, eth->init);
683 device_initcall(iss_net_init);