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 (HZ / 10) 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 fd; 60 }; 61 62 /* ------------------------------------------------------------------------- */ 63 64 65 /* This structure contains out private information for the driver. */ 66 67 struct iss_net_private { 68 struct list_head device_list; 69 struct list_head opened_list; 70 71 spinlock_t lock; 72 struct net_device *dev; 73 struct platform_device pdev; 74 struct timer_list tl; 75 struct net_device_stats stats; 76 77 struct timer_list timer; 78 unsigned int timer_val; 79 80 int index; 81 int mtu; 82 83 struct { 84 union { 85 struct tuntap_info tuntap; 86 } info; 87 88 int (*open)(struct iss_net_private *lp); 89 void (*close)(struct iss_net_private *lp); 90 int (*read)(struct iss_net_private *lp, struct sk_buff **skb); 91 int (*write)(struct iss_net_private *lp, struct sk_buff **skb); 92 unsigned short (*protocol)(struct sk_buff *skb); 93 int (*poll)(struct iss_net_private *lp); 94 } tp; 95 96 }; 97 98 /* ================================ HELPERS ================================ */ 99 100 101 static char *split_if_spec(char *str, ...) 102 { 103 char **arg, *end; 104 va_list ap; 105 106 va_start(ap, str); 107 while ((arg = va_arg(ap, char**)) != NULL) { 108 if (*str == '\0') 109 return NULL; 110 end = strchr(str, ','); 111 if (end != str) 112 *arg = str; 113 if (end == NULL) 114 return NULL; 115 *end++ = '\0'; 116 str = end; 117 } 118 va_end(ap); 119 return str; 120 } 121 122 /* Set Ethernet address of the specified device. */ 123 124 static void setup_etheraddr(struct net_device *dev, char *str) 125 { 126 unsigned char *addr = dev->dev_addr; 127 128 if (str == NULL) 129 goto random; 130 131 if (!mac_pton(str, addr)) { 132 pr_err("%s: failed to parse '%s' as an ethernet address\n", 133 dev->name, str); 134 goto random; 135 } 136 if (is_multicast_ether_addr(addr)) { 137 pr_err("%s: attempt to assign a multicast ethernet address\n", 138 dev->name); 139 goto random; 140 } 141 if (!is_valid_ether_addr(addr)) { 142 pr_err("%s: attempt to assign an invalid ethernet address\n", 143 dev->name); 144 goto random; 145 } 146 if (!is_local_ether_addr(addr)) 147 pr_warn("%s: assigning a globally valid ethernet address\n", 148 dev->name); 149 return; 150 151 random: 152 pr_info("%s: choosing a random ethernet address\n", 153 dev->name); 154 eth_hw_addr_random(dev); 155 } 156 157 /* ======================= TUNTAP TRANSPORT INTERFACE ====================== */ 158 159 static int tuntap_open(struct iss_net_private *lp) 160 { 161 struct ifreq ifr; 162 char *dev_name = lp->tp.info.tuntap.dev_name; 163 int err = -EINVAL; 164 int fd; 165 166 fd = simc_open("/dev/net/tun", 02, 0); /* O_RDWR */ 167 if (fd < 0) { 168 pr_err("%s: failed to open /dev/net/tun, returned %d (errno = %d)\n", 169 lp->dev->name, fd, errno); 170 return fd; 171 } 172 173 memset(&ifr, 0, sizeof(ifr)); 174 ifr.ifr_flags = IFF_TAP | IFF_NO_PI; 175 strlcpy(ifr.ifr_name, dev_name, sizeof(ifr.ifr_name)); 176 177 err = simc_ioctl(fd, TUNSETIFF, &ifr); 178 if (err < 0) { 179 pr_err("%s: failed to set interface %s, returned %d (errno = %d)\n", 180 lp->dev->name, dev_name, err, errno); 181 simc_close(fd); 182 return err; 183 } 184 185 lp->tp.info.tuntap.fd = fd; 186 return err; 187 } 188 189 static void tuntap_close(struct iss_net_private *lp) 190 { 191 simc_close(lp->tp.info.tuntap.fd); 192 lp->tp.info.tuntap.fd = -1; 193 } 194 195 static int tuntap_read(struct iss_net_private *lp, struct sk_buff **skb) 196 { 197 return simc_read(lp->tp.info.tuntap.fd, 198 (*skb)->data, (*skb)->dev->mtu + ETH_HEADER_OTHER); 199 } 200 201 static int tuntap_write(struct iss_net_private *lp, struct sk_buff **skb) 202 { 203 return simc_write(lp->tp.info.tuntap.fd, (*skb)->data, (*skb)->len); 204 } 205 206 unsigned short tuntap_protocol(struct sk_buff *skb) 207 { 208 return eth_type_trans(skb, skb->dev); 209 } 210 211 static int tuntap_poll(struct iss_net_private *lp) 212 { 213 return simc_poll(lp->tp.info.tuntap.fd); 214 } 215 216 /* 217 * ethX=tuntap,[mac address],device name 218 */ 219 220 static int tuntap_probe(struct iss_net_private *lp, int index, char *init) 221 { 222 struct net_device *dev = lp->dev; 223 char *dev_name = NULL, *mac_str = NULL, *rem = NULL; 224 225 /* Transport should be 'tuntap': ethX=tuntap,mac,dev_name */ 226 227 if (strncmp(init, TRANSPORT_TUNTAP_NAME, 228 sizeof(TRANSPORT_TUNTAP_NAME) - 1)) 229 return 0; 230 231 init += sizeof(TRANSPORT_TUNTAP_NAME) - 1; 232 if (*init == ',') { 233 rem = split_if_spec(init + 1, &mac_str, &dev_name); 234 if (rem != NULL) { 235 pr_err("%s: extra garbage on specification : '%s'\n", 236 dev->name, rem); 237 return 0; 238 } 239 } else if (*init != '\0') { 240 pr_err("%s: invalid argument: %s. Skipping device!\n", 241 dev->name, init); 242 return 0; 243 } 244 245 if (!dev_name) { 246 pr_err("%s: missing tuntap device name\n", dev->name); 247 return 0; 248 } 249 250 strlcpy(lp->tp.info.tuntap.dev_name, dev_name, 251 sizeof(lp->tp.info.tuntap.dev_name)); 252 253 setup_etheraddr(dev, mac_str); 254 255 lp->mtu = TRANSPORT_TUNTAP_MTU; 256 257 lp->tp.info.tuntap.fd = -1; 258 259 lp->tp.open = tuntap_open; 260 lp->tp.close = tuntap_close; 261 lp->tp.read = tuntap_read; 262 lp->tp.write = tuntap_write; 263 lp->tp.protocol = tuntap_protocol; 264 lp->tp.poll = tuntap_poll; 265 266 return 1; 267 } 268 269 /* ================================ ISS NET ================================ */ 270 271 static int iss_net_rx(struct net_device *dev) 272 { 273 struct iss_net_private *lp = netdev_priv(dev); 274 int pkt_len; 275 struct sk_buff *skb; 276 277 /* Check if there is any new data. */ 278 279 if (lp->tp.poll(lp) == 0) 280 return 0; 281 282 /* Try to allocate memory, if it fails, try again next round. */ 283 284 skb = dev_alloc_skb(dev->mtu + 2 + ETH_HEADER_OTHER); 285 if (skb == NULL) { 286 lp->stats.rx_dropped++; 287 return 0; 288 } 289 290 skb_reserve(skb, 2); 291 292 /* Setup skb */ 293 294 skb->dev = dev; 295 skb_reset_mac_header(skb); 296 pkt_len = lp->tp.read(lp, &skb); 297 skb_put(skb, pkt_len); 298 299 if (pkt_len > 0) { 300 skb_trim(skb, pkt_len); 301 skb->protocol = lp->tp.protocol(skb); 302 303 lp->stats.rx_bytes += skb->len; 304 lp->stats.rx_packets++; 305 netif_rx_ni(skb); 306 return pkt_len; 307 } 308 kfree_skb(skb); 309 return pkt_len; 310 } 311 312 static int iss_net_poll(void) 313 { 314 struct list_head *ele; 315 int err, ret = 0; 316 317 spin_lock(&opened_lock); 318 319 list_for_each(ele, &opened) { 320 struct iss_net_private *lp; 321 322 lp = list_entry(ele, struct iss_net_private, opened_list); 323 324 if (!netif_running(lp->dev)) 325 break; 326 327 spin_lock(&lp->lock); 328 329 while ((err = iss_net_rx(lp->dev)) > 0) 330 ret++; 331 332 spin_unlock(&lp->lock); 333 334 if (err < 0) { 335 pr_err("Device '%s' read returned %d, shutting it down\n", 336 lp->dev->name, err); 337 dev_close(lp->dev); 338 } else { 339 /* FIXME reactivate_fd(lp->fd, ISS_ETH_IRQ); */ 340 } 341 } 342 343 spin_unlock(&opened_lock); 344 return ret; 345 } 346 347 348 static void iss_net_timer(unsigned long priv) 349 { 350 struct iss_net_private *lp = (struct iss_net_private *)priv; 351 352 iss_net_poll(); 353 spin_lock(&lp->lock); 354 mod_timer(&lp->timer, jiffies + lp->timer_val); 355 spin_unlock(&lp->lock); 356 } 357 358 359 static int iss_net_open(struct net_device *dev) 360 { 361 struct iss_net_private *lp = netdev_priv(dev); 362 int err; 363 364 spin_lock_bh(&lp->lock); 365 366 err = lp->tp.open(lp); 367 if (err < 0) 368 goto out; 369 370 netif_start_queue(dev); 371 372 /* clear buffer - it can happen that the host side of the interface 373 * is full when we get here. In this case, new data is never queued, 374 * SIGIOs never arrive, and the net never works. 375 */ 376 while ((err = iss_net_rx(dev)) > 0) 377 ; 378 379 spin_unlock_bh(&lp->lock); 380 spin_lock_bh(&opened_lock); 381 list_add(&lp->opened_list, &opened); 382 spin_unlock_bh(&opened_lock); 383 spin_lock_bh(&lp->lock); 384 385 init_timer(&lp->timer); 386 lp->timer_val = ISS_NET_TIMER_VALUE; 387 lp->timer.data = (unsigned long) lp; 388 lp->timer.function = iss_net_timer; 389 mod_timer(&lp->timer, jiffies + lp->timer_val); 390 391 out: 392 spin_unlock_bh(&lp->lock); 393 return err; 394 } 395 396 static int iss_net_close(struct net_device *dev) 397 { 398 struct iss_net_private *lp = netdev_priv(dev); 399 netif_stop_queue(dev); 400 spin_lock_bh(&lp->lock); 401 402 spin_lock(&opened_lock); 403 list_del(&opened); 404 spin_unlock(&opened_lock); 405 406 del_timer_sync(&lp->timer); 407 408 lp->tp.close(lp); 409 410 spin_unlock_bh(&lp->lock); 411 return 0; 412 } 413 414 static int iss_net_start_xmit(struct sk_buff *skb, struct net_device *dev) 415 { 416 struct iss_net_private *lp = netdev_priv(dev); 417 int len; 418 419 netif_stop_queue(dev); 420 spin_lock_bh(&lp->lock); 421 422 len = lp->tp.write(lp, &skb); 423 424 if (len == skb->len) { 425 lp->stats.tx_packets++; 426 lp->stats.tx_bytes += skb->len; 427 dev->trans_start = jiffies; 428 netif_start_queue(dev); 429 430 /* this is normally done in the interrupt when tx finishes */ 431 netif_wake_queue(dev); 432 433 } else if (len == 0) { 434 netif_start_queue(dev); 435 lp->stats.tx_dropped++; 436 437 } else { 438 netif_start_queue(dev); 439 pr_err("%s: %s failed(%d)\n", dev->name, __func__, len); 440 } 441 442 spin_unlock_bh(&lp->lock); 443 444 dev_kfree_skb(skb); 445 return NETDEV_TX_OK; 446 } 447 448 449 static struct net_device_stats *iss_net_get_stats(struct net_device *dev) 450 { 451 struct iss_net_private *lp = netdev_priv(dev); 452 return &lp->stats; 453 } 454 455 static void iss_net_set_multicast_list(struct net_device *dev) 456 { 457 } 458 459 static void iss_net_tx_timeout(struct net_device *dev) 460 { 461 } 462 463 static int iss_net_set_mac(struct net_device *dev, void *addr) 464 { 465 struct iss_net_private *lp = netdev_priv(dev); 466 struct sockaddr *hwaddr = addr; 467 468 if (!is_valid_ether_addr(hwaddr->sa_data)) 469 return -EADDRNOTAVAIL; 470 spin_lock_bh(&lp->lock); 471 memcpy(dev->dev_addr, hwaddr->sa_data, ETH_ALEN); 472 spin_unlock_bh(&lp->lock); 473 return 0; 474 } 475 476 static int iss_net_change_mtu(struct net_device *dev, int new_mtu) 477 { 478 return -EINVAL; 479 } 480 481 void iss_net_user_timer_expire(unsigned long _conn) 482 { 483 } 484 485 486 static struct platform_driver iss_net_driver = { 487 .driver = { 488 .name = DRIVER_NAME, 489 }, 490 }; 491 492 static int driver_registered; 493 494 static const struct net_device_ops iss_netdev_ops = { 495 .ndo_open = iss_net_open, 496 .ndo_stop = iss_net_close, 497 .ndo_get_stats = iss_net_get_stats, 498 .ndo_start_xmit = iss_net_start_xmit, 499 .ndo_validate_addr = eth_validate_addr, 500 .ndo_change_mtu = iss_net_change_mtu, 501 .ndo_set_mac_address = iss_net_set_mac, 502 .ndo_tx_timeout = iss_net_tx_timeout, 503 .ndo_set_rx_mode = iss_net_set_multicast_list, 504 }; 505 506 static int iss_net_configure(int index, char *init) 507 { 508 struct net_device *dev; 509 struct iss_net_private *lp; 510 int err; 511 512 dev = alloc_etherdev(sizeof(*lp)); 513 if (dev == NULL) { 514 pr_err("eth_configure: failed to allocate device\n"); 515 return 1; 516 } 517 518 /* Initialize private element. */ 519 520 lp = netdev_priv(dev); 521 *lp = (struct iss_net_private) { 522 .device_list = LIST_HEAD_INIT(lp->device_list), 523 .opened_list = LIST_HEAD_INIT(lp->opened_list), 524 .dev = dev, 525 .index = index, 526 }; 527 528 spin_lock_init(&lp->lock); 529 /* 530 * If this name ends up conflicting with an existing registered 531 * netdevice, that is OK, register_netdev{,ice}() will notice this 532 * and fail. 533 */ 534 snprintf(dev->name, sizeof(dev->name), "eth%d", index); 535 536 /* 537 * Try all transport protocols. 538 * Note: more protocols can be added by adding '&& !X_init(lp, eth)'. 539 */ 540 541 if (!tuntap_probe(lp, index, init)) { 542 pr_err("%s: invalid arguments. Skipping device!\n", 543 dev->name); 544 goto errout; 545 } 546 547 pr_info("Netdevice %d (%pM)\n", index, dev->dev_addr); 548 549 /* sysfs register */ 550 551 if (!driver_registered) { 552 platform_driver_register(&iss_net_driver); 553 driver_registered = 1; 554 } 555 556 spin_lock(&devices_lock); 557 list_add(&lp->device_list, &devices); 558 spin_unlock(&devices_lock); 559 560 lp->pdev.id = index; 561 lp->pdev.name = DRIVER_NAME; 562 platform_device_register(&lp->pdev); 563 SET_NETDEV_DEV(dev, &lp->pdev.dev); 564 565 dev->netdev_ops = &iss_netdev_ops; 566 dev->mtu = lp->mtu; 567 dev->watchdog_timeo = (HZ >> 1); 568 dev->irq = -1; 569 570 rtnl_lock(); 571 err = register_netdevice(dev); 572 rtnl_unlock(); 573 574 if (err) { 575 pr_err("%s: error registering net device!\n", dev->name); 576 /* XXX: should we call ->remove() here? */ 577 free_netdev(dev); 578 return 1; 579 } 580 581 init_timer(&lp->tl); 582 lp->tl.function = iss_net_user_timer_expire; 583 584 return 0; 585 586 errout: 587 /* FIXME: unregister; free, etc.. */ 588 return -EIO; 589 } 590 591 /* ------------------------------------------------------------------------- */ 592 593 /* Filled in during early boot */ 594 595 struct list_head eth_cmd_line = LIST_HEAD_INIT(eth_cmd_line); 596 597 struct iss_net_init { 598 struct list_head list; 599 char *init; /* init string */ 600 int index; 601 }; 602 603 /* 604 * Parse the command line and look for 'ethX=...' fields, and register all 605 * those fields. They will be later initialized in iss_net_init. 606 */ 607 608 #define ERR KERN_ERR "iss_net_setup: " 609 610 static int __init iss_net_setup(char *str) 611 { 612 struct iss_net_private *device = NULL; 613 struct iss_net_init *new; 614 struct list_head *ele; 615 char *end; 616 int rc; 617 unsigned n; 618 619 end = strchr(str, '='); 620 if (!end) { 621 printk(ERR "Expected '=' after device number\n"); 622 return 1; 623 } 624 *end = 0; 625 rc = kstrtouint(str, 0, &n); 626 *end = '='; 627 if (rc < 0) { 628 printk(ERR "Failed to parse '%s'\n", str); 629 return 1; 630 } 631 str = end; 632 633 spin_lock(&devices_lock); 634 635 list_for_each(ele, &devices) { 636 device = list_entry(ele, struct iss_net_private, device_list); 637 if (device->index == n) 638 break; 639 } 640 641 spin_unlock(&devices_lock); 642 643 if (device && device->index == n) { 644 printk(ERR "Device %u already configured\n", n); 645 return 1; 646 } 647 648 new = alloc_bootmem(sizeof(*new)); 649 if (new == NULL) { 650 printk(ERR "Alloc_bootmem failed\n"); 651 return 1; 652 } 653 654 INIT_LIST_HEAD(&new->list); 655 new->index = n; 656 new->init = str + 1; 657 658 list_add_tail(&new->list, ð_cmd_line); 659 return 1; 660 } 661 662 #undef ERR 663 664 __setup("eth", iss_net_setup); 665 666 /* 667 * Initialize all ISS Ethernet devices previously registered in iss_net_setup. 668 */ 669 670 static int iss_net_init(void) 671 { 672 struct list_head *ele, *next; 673 674 /* Walk through all Ethernet devices specified in the command line. */ 675 676 list_for_each_safe(ele, next, ð_cmd_line) { 677 struct iss_net_init *eth; 678 eth = list_entry(ele, struct iss_net_init, list); 679 iss_net_configure(eth->index, eth->init); 680 } 681 682 return 1; 683 } 684 685 module_init(iss_net_init); 686 687