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