arch/xtensa/platforms/iss/network.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *
   4  * arch/xtensa/platforms/iss/network.c
   5  *
   6  * Platform specific initialization.
   7  *
   8  * Authors: Chris Zankel <chris@zankel.net>
   9  * Based on work form the UML team.
  10  *
  11  * Copyright 2005 Tensilica Inc.
  12  */
  13
  14 #define pr_fmt(fmt) "%s: " fmt, __func__
  15
  16 #include <linux/list.h>
  17 #include <linux/irq.h>
  18 #include <linux/spinlock.h>
  19 #include <linux/slab.h>
  20 #include <linux/timer.h>
  21 #include <linux/if_ether.h>
  22 #include <linux/inetdevice.h>
  23 #include <linux/init.h>
  24 #include <linux/if_tun.h>
  25 #include <linux/etherdevice.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/ioctl.h>
  28 #include <linux/memblock.h>
  29 #include <linux/ethtool.h>
  30 #include <linux/rtnetlink.h>
  31 #include <linux/platform_device.h>
  32
  33 #include <platform/simcall.h>
  34
  35 #define DRIVER_NAME "iss-netdev"
  36 #define ETH_MAX_PACKET 1500
  37 #define ETH_HEADER_OTHER 14
  38 #define ISS_NET_TIMER_VALUE (HZ / 10)
  39
  40
  41 static DEFINE_SPINLOCK(devices_lock);
  42 static LIST_HEAD(devices);
  43
  44 /* ------------------------------------------------------------------------- */
  45
  46 /* We currently only support the TUNTAP transport protocol. */
  47
  48 #define TRANSPORT_TUNTAP_NAME "tuntap"
  49 #define TRANSPORT_TUNTAP_MTU ETH_MAX_PACKET
  50
  51 struct tuntap_info {
  52         char dev_name[IFNAMSIZ];
  53         int fd;
  54 };
  55
  56 /* ------------------------------------------------------------------------- */
  57
  58
  59 struct iss_net_private;
  60
  61 struct iss_net_ops {
  62         int (*open)(struct iss_net_private *lp);
  63         void (*close)(struct iss_net_private *lp);
  64         int (*read)(struct iss_net_private *lp, struct sk_buff **skb);
  65         int (*write)(struct iss_net_private *lp, struct sk_buff **skb);
  66         unsigned short (*protocol)(struct sk_buff *skb);
  67         int (*poll)(struct iss_net_private *lp);
  68 };
  69
  70 /* This structure contains out private information for the driver. */
  71
  72 struct iss_net_private {
  73         struct list_head device_list;
  74
  75         spinlock_t lock;
  76         struct net_device *dev;
  77         struct platform_device pdev;
  78         struct timer_list tl;
  79         struct rtnl_link_stats64 stats;
  80
  81         struct timer_list timer;
  82         unsigned int timer_val;
  83
  84         int index;
  85         int mtu;
  86
  87         struct {
  88                 union {
  89                         struct tuntap_info tuntap;
  90                 } info;
  91
  92                 const struct iss_net_ops *net_ops;
  93         } tp;
  94
  95 };
  96
  97 /* ================================ HELPERS ================================ */
  98
  99
 100 static char *split_if_spec(char *str, ...)
 101 {
 102         char **arg, *end;
 103         va_list ap;
 104
 105         va_start(ap, str);
 106         while ((arg = va_arg(ap, char**)) != NULL) {
 107                 if (*str == '\0') {
 108                         va_end(ap);
 109                         return NULL;
 110                 }
 111                 end = strchr(str, ',');
 112                 if (end != str)
 113                         *arg = str;
 114                 if (end == NULL) {
 115                         va_end(ap);
 116                         return NULL;
 117                 }
 118                 *end++ = '\0';
 119                 str = end;
 120         }
 121         va_end(ap);
 122         return str;
 123 }
 124
 125 /* Set Ethernet address of the specified device. */
 126
 127 static void setup_etheraddr(struct net_device *dev, char *str)
 128 {
 129         u8 addr[ETH_ALEN];
 130
 131         if (str == NULL)
 132                 goto random;
 133
 134         if (!mac_pton(str, addr)) {
 135                 pr_err("%s: failed to parse '%s' as an ethernet address\n",
 136                        dev->name, str);
 137                 goto random;
 138         }
 139         if (is_multicast_ether_addr(addr)) {
 140                 pr_err("%s: attempt to assign a multicast ethernet address\n",
 141                        dev->name);
 142                 goto random;
 143         }
 144         if (!is_valid_ether_addr(addr)) {
 145                 pr_err("%s: attempt to assign an invalid ethernet address\n",
 146                        dev->name);
 147                 goto random;
 148         }
 149         if (!is_local_ether_addr(addr))
 150                 pr_warn("%s: assigning a globally valid ethernet address\n",
 151                         dev->name);
 152         eth_hw_addr_set(dev, addr);
 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         strscpy(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 static const struct iss_net_ops tuntap_ops = {
 221         .open           = tuntap_open,
 222         .close          = tuntap_close,
 223         .read           = tuntap_read,
 224         .write          = tuntap_write,
 225         .protocol       = tuntap_protocol,
 226         .poll           = tuntap_poll,
 227 };
 228
 229 /*
 230  * ethX=tuntap,[mac address],device name
 231  */
 232
 233 static int tuntap_probe(struct iss_net_private *lp, int index, char *init)
 234 {
 235         struct net_device *dev = lp->dev;
 236         char *dev_name = NULL, *mac_str = NULL, *rem = NULL;
 237
 238         /* Transport should be 'tuntap': ethX=tuntap,mac,dev_name */
 239
 240         if (strncmp(init, TRANSPORT_TUNTAP_NAME,
 241                     sizeof(TRANSPORT_TUNTAP_NAME) - 1))
 242                 return 0;
 243
 244         init += sizeof(TRANSPORT_TUNTAP_NAME) - 1;
 245         if (*init == ',') {
 246                 rem = split_if_spec(init + 1, &mac_str, &dev_name);
 247                 if (rem != NULL) {
 248                         pr_err("%s: extra garbage on specification : '%s'\n",
 249                                dev->name, rem);
 250                         return 0;
 251                 }
 252         } else if (*init != '\0') {
 253                 pr_err("%s: invalid argument: %s. Skipping device!\n",
 254                        dev->name, init);
 255                 return 0;
 256         }
 257
 258         if (!dev_name) {
 259                 pr_err("%s: missing tuntap device name\n", dev->name);
 260                 return 0;
 261         }
 262
 263         strscpy(lp->tp.info.tuntap.dev_name, dev_name,
 264                 sizeof(lp->tp.info.tuntap.dev_name));
 265
 266         setup_etheraddr(dev, mac_str);
 267
 268         lp->mtu = TRANSPORT_TUNTAP_MTU;
 269
 270         lp->tp.info.tuntap.fd = -1;
 271         lp->tp.net_ops = &tuntap_ops;
 272
 273         return 1;
 274 }
 275
 276 /* ================================ ISS NET ================================ */
 277
 278 static int iss_net_rx(struct net_device *dev)
 279 {
 280         struct iss_net_private *lp = netdev_priv(dev);
 281         int pkt_len;
 282         struct sk_buff *skb;
 283
 284         /* Check if there is any new data. */
 285
 286         if (lp->tp.net_ops->poll(lp) == 0)
 287                 return 0;
 288
 289         /* Try to allocate memory, if it fails, try again next round. */
 290
 291         skb = dev_alloc_skb(dev->mtu + 2 + ETH_HEADER_OTHER);
 292         if (skb == NULL) {
 293                 spin_lock_bh(&lp->lock);
 294                 lp->stats.rx_dropped++;
 295                 spin_unlock_bh(&lp->lock);
 296                 return 0;
 297         }
 298
 299         skb_reserve(skb, 2);
 300
 301         /* Setup skb */
 302
 303         skb->dev = dev;
 304         skb_reset_mac_header(skb);
 305         pkt_len = lp->tp.net_ops->read(lp, &skb);
 306         skb_put(skb, pkt_len);
 307
 308         if (pkt_len > 0) {
 309                 skb_trim(skb, pkt_len);
 310                 skb->protocol = lp->tp.net_ops->protocol(skb);
 311
 312                 spin_lock_bh(&lp->lock);
 313                 lp->stats.rx_bytes += skb->len;
 314                 lp->stats.rx_packets++;
 315                 spin_unlock_bh(&lp->lock);
 316                 netif_rx(skb);
 317                 return pkt_len;
 318         }
 319         kfree_skb(skb);
 320         return pkt_len;
 321 }
 322
 323 static int iss_net_poll(struct iss_net_private *lp)
 324 {
 325         int err, ret = 0;
 326
 327         if (!netif_running(lp->dev))
 328                 return 0;
 329
 330         while ((err = iss_net_rx(lp->dev)) > 0)
 331                 ret++;
 332
 333         if (err < 0) {
 334                 pr_err("Device '%s' read returned %d, shutting it down\n",
 335                        lp->dev->name, err);
 336                 dev_close(lp->dev);
 337         } else {
 338                 /* FIXME reactivate_fd(lp->fd, ISS_ETH_IRQ); */
 339         }
 340
 341         return ret;
 342 }
 343
 344
 345 static void iss_net_timer(struct timer_list *t)
 346 {
 347         struct iss_net_private *lp = from_timer(lp, t, timer);
 348
 349         iss_net_poll(lp);
 350         mod_timer(&lp->timer, jiffies + lp->timer_val);
 351 }
 352
 353
 354 static int iss_net_open(struct net_device *dev)
 355 {
 356         struct iss_net_private *lp = netdev_priv(dev);
 357         int err;
 358
 359         err = lp->tp.net_ops->open(lp);
 360         if (err < 0)
 361                 return err;
 362
 363         netif_start_queue(dev);
 364
 365         /* clear buffer - it can happen that the host side of the interface
 366          * is full when we get here. In this case, new data is never queued,
 367          * SIGIOs never arrive, and the net never works.
 368          */
 369         while ((err = iss_net_rx(dev)) > 0)
 370                 ;
 371
 372         timer_setup(&lp->timer, iss_net_timer, 0);
 373         lp->timer_val = ISS_NET_TIMER_VALUE;
 374         mod_timer(&lp->timer, jiffies + lp->timer_val);
 375
 376         return err;
 377 }
 378
 379 static int iss_net_close(struct net_device *dev)
 380 {
 381         struct iss_net_private *lp = netdev_priv(dev);
 382
 383         netif_stop_queue(dev);
 384         del_timer_sync(&lp->timer);
 385         lp->tp.net_ops->close(lp);
 386
 387         return 0;
 388 }
 389
 390 static int iss_net_start_xmit(struct sk_buff *skb, struct net_device *dev)
 391 {
 392         struct iss_net_private *lp = netdev_priv(dev);
 393         int len;
 394
 395         netif_stop_queue(dev);
 396
 397         len = lp->tp.net_ops->write(lp, &skb);
 398
 399         if (len == skb->len) {
 400                 spin_lock_bh(&lp->lock);
 401                 lp->stats.tx_packets++;
 402                 lp->stats.tx_bytes += skb->len;
 403                 spin_unlock_bh(&lp->lock);
 404                 netif_trans_update(dev);
 405                 netif_start_queue(dev);
 406
 407                 /* this is normally done in the interrupt when tx finishes */
 408                 netif_wake_queue(dev);
 409
 410         } else if (len == 0) {
 411                 netif_start_queue(dev);
 412                 spin_lock_bh(&lp->lock);
 413                 lp->stats.tx_dropped++;
 414                 spin_unlock_bh(&lp->lock);
 415
 416         } else {
 417                 netif_start_queue(dev);
 418                 pr_err("%s: %s failed(%d)\n", dev->name, __func__, len);
 419         }
 420
 421
 422         dev_kfree_skb(skb);
 423         return NETDEV_TX_OK;
 424 }
 425
 426
 427 static void iss_net_get_stats64(struct net_device *dev,
 428                                 struct rtnl_link_stats64 *stats)
 429 {
 430         struct iss_net_private *lp = netdev_priv(dev);
 431
 432         spin_lock_bh(&lp->lock);
 433         *stats = lp->stats;
 434         spin_unlock_bh(&lp->lock);
 435 }
 436
 437 static void iss_net_set_multicast_list(struct net_device *dev)
 438 {
 439 }
 440
 441 static void iss_net_tx_timeout(struct net_device *dev, unsigned int txqueue)
 442 {
 443 }
 444
 445 static int iss_net_change_mtu(struct net_device *dev, int new_mtu)
 446 {
 447         return -EINVAL;
 448 }
 449
 450 void iss_net_user_timer_expire(struct timer_list *unused)
 451 {
 452 }
 453
 454
 455 static struct platform_driver iss_net_driver = {
 456         .driver = {
 457                 .name  = DRIVER_NAME,
 458         },
 459 };
 460
 461 static int driver_registered;
 462
 463 static const struct net_device_ops iss_netdev_ops = {
 464         .ndo_open               = iss_net_open,
 465         .ndo_stop               = iss_net_close,
 466         .ndo_get_stats64        = iss_net_get_stats64,
 467         .ndo_start_xmit         = iss_net_start_xmit,
 468         .ndo_validate_addr      = eth_validate_addr,
 469         .ndo_change_mtu         = iss_net_change_mtu,
 470         .ndo_set_mac_address    = eth_mac_addr,
 471         .ndo_tx_timeout         = iss_net_tx_timeout,
 472         .ndo_set_rx_mode        = iss_net_set_multicast_list,
 473 };
 474
 475 static int iss_net_configure(int index, char *init)
 476 {
 477         struct net_device *dev;
 478         struct iss_net_private *lp;
 479         int err;
 480
 481         dev = alloc_etherdev(sizeof(*lp));
 482         if (dev == NULL) {
 483                 pr_err("eth_configure: failed to allocate device\n");
 484                 return 1;
 485         }
 486
 487         /* Initialize private element. */
 488
 489         lp = netdev_priv(dev);
 490         *lp = (struct iss_net_private) {
 491                 .device_list            = LIST_HEAD_INIT(lp->device_list),
 492                 .dev                    = dev,
 493                 .index                  = index,
 494         };
 495
 496         spin_lock_init(&lp->lock);
 497         /*
 498          * If this name ends up conflicting with an existing registered
 499          * netdevice, that is OK, register_netdev{,ice}() will notice this
 500          * and fail.
 501          */
 502         snprintf(dev->name, sizeof(dev->name), "eth%d", index);
 503
 504         /*
 505          * Try all transport protocols.
 506          * Note: more protocols can be added by adding '&& !X_init(lp, eth)'.
 507          */
 508
 509         if (!tuntap_probe(lp, index, init)) {
 510                 pr_err("%s: invalid arguments. Skipping device!\n",
 511                        dev->name);
 512                 goto errout;
 513         }
 514
 515         pr_info("Netdevice %d (%pM)\n", index, dev->dev_addr);
 516
 517         /* sysfs register */
 518
 519         if (!driver_registered) {
 520                 platform_driver_register(&iss_net_driver);
 521                 driver_registered = 1;
 522         }
 523
 524         spin_lock(&devices_lock);
 525         list_add(&lp->device_list, &devices);
 526         spin_unlock(&devices_lock);
 527
 528         lp->pdev.id = index;
 529         lp->pdev.name = DRIVER_NAME;
 530         platform_device_register(&lp->pdev);
 531         SET_NETDEV_DEV(dev, &lp->pdev.dev);
 532
 533         dev->netdev_ops = &iss_netdev_ops;
 534         dev->mtu = lp->mtu;
 535         dev->watchdog_timeo = (HZ >> 1);
 536         dev->irq = -1;
 537
 538         rtnl_lock();
 539         err = register_netdevice(dev);
 540         rtnl_unlock();
 541
 542         if (err) {
 543                 pr_err("%s: error registering net device!\n", dev->name);
 544                 /* XXX: should we call ->remove() here? */
 545                 free_netdev(dev);
 546                 return 1;
 547         }
 548
 549         timer_setup(&lp->tl, iss_net_user_timer_expire, 0);
 550
 551         return 0;
 552
 553 errout:
 554         /* FIXME: unregister; free, etc.. */
 555         return -EIO;
 556 }
 557
 558 /* ------------------------------------------------------------------------- */
 559
 560 /* Filled in during early boot */
 561
 562 struct list_head eth_cmd_line = LIST_HEAD_INIT(eth_cmd_line);
 563
 564 struct iss_net_init {
 565         struct list_head list;
 566         char *init;             /* init string */
 567         int index;
 568 };
 569
 570 /*
 571  * Parse the command line and look for 'ethX=...' fields, and register all
 572  * those fields. They will be later initialized in iss_net_init.
 573  */
 574
 575 static int __init iss_net_setup(char *str)
 576 {
 577         struct iss_net_private *device = NULL;
 578         struct iss_net_init *new;
 579         struct list_head *ele;
 580         char *end;
 581         int rc;
 582         unsigned n;
 583
 584         end = strchr(str, '=');
 585         if (!end) {
 586                 pr_err("Expected '=' after device number\n");
 587                 return 1;
 588         }
 589         *end = 0;
 590         rc = kstrtouint(str, 0, &n);
 591         *end = '=';
 592         if (rc < 0) {
 593                 pr_err("Failed to parse '%s'\n", str);
 594                 return 1;
 595         }
 596         str = end;
 597
 598         spin_lock(&devices_lock);
 599
 600         list_for_each(ele, &devices) {
 601                 device = list_entry(ele, struct iss_net_private, device_list);
 602                 if (device->index == n)
 603                         break;
 604         }
 605
 606         spin_unlock(&devices_lock);
 607
 608         if (device && device->index == n) {
 609                 pr_err("Device %u already configured\n", n);
 610                 return 1;
 611         }
 612
 613         new = memblock_alloc(sizeof(*new), SMP_CACHE_BYTES);
 614         if (new == NULL) {
 615                 pr_err("Alloc_bootmem failed\n");
 616                 return 1;
 617         }
 618
 619         INIT_LIST_HEAD(&new->list);
 620         new->index = n;
 621         new->init = str + 1;
 622
 623         list_add_tail(&new->list, &eth_cmd_line);
 624         return 1;
 625 }
 626
 627 __setup("eth", iss_net_setup);
 628
 629 /*
 630  * Initialize all ISS Ethernet devices previously registered in iss_net_setup.
 631  */
 632
 633 static int iss_net_init(void)
 634 {
 635         struct list_head *ele, *next;
 636
 637         /* Walk through all Ethernet devices specified in the command line. */
 638
 639         list_for_each_safe(ele, next, &eth_cmd_line) {
 640                 struct iss_net_init *eth;
 641                 eth = list_entry(ele, struct iss_net_init, list);
 642                 iss_net_configure(eth->index, eth->init);
 643         }
 644
 645         return 1;
 646 }
 647 device_initcall(iss_net_init);