drivers/net/rionet.c

   1 /*
   2  * rionet - Ethernet driver over RapidIO messaging services
   3  *
   4  * Copyright 2005 MontaVista Software, Inc.
   5  * Matt Porter <mporter@kernel.crashing.org>
   6  *
   7  * This program is free software; you can redistribute  it and/or modify it
   8  * under  the terms of  the GNU General  Public License as published by the
   9  * Free Software Foundation;  either version 2 of the  License, or (at your
  10  * option) any later version.
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/dma-mapping.h>
  16 #include <linux/delay.h>
  17 #include <linux/rio.h>
  18 #include <linux/rio_drv.h>
  19 #include <linux/slab.h>
  20 #include <linux/rio_ids.h>
  21
  22 #include <linux/netdevice.h>
  23 #include <linux/etherdevice.h>
  24 #include <linux/skbuff.h>
  25 #include <linux/crc32.h>
  26 #include <linux/ethtool.h>
  27
  28 #define DRV_NAME        "rionet"
  29 #define DRV_VERSION     "0.2"
  30 #define DRV_AUTHOR      "Matt Porter <mporter@kernel.crashing.org>"
  31 #define DRV_DESC        "Ethernet over RapidIO"
  32
  33 MODULE_AUTHOR(DRV_AUTHOR);
  34 MODULE_DESCRIPTION(DRV_DESC);
  35 MODULE_LICENSE("GPL");
  36
  37 #define RIONET_DEFAULT_MSGLEVEL \
  38                         (NETIF_MSG_DRV          | \
  39                          NETIF_MSG_LINK         | \
  40                          NETIF_MSG_RX_ERR       | \
  41                          NETIF_MSG_TX_ERR)
  42
  43 #define RIONET_DOORBELL_JOIN    0x1000
  44 #define RIONET_DOORBELL_LEAVE   0x1001
  45
  46 #define RIONET_MAILBOX          0
  47
  48 #define RIONET_TX_RING_SIZE     CONFIG_RIONET_TX_SIZE
  49 #define RIONET_RX_RING_SIZE     CONFIG_RIONET_RX_SIZE
  50
  51 static LIST_HEAD(rionet_peers);
  52
  53 struct rionet_private {
  54         struct rio_mport *mport;
  55         struct sk_buff *rx_skb[RIONET_RX_RING_SIZE];
  56         struct sk_buff *tx_skb[RIONET_TX_RING_SIZE];
  57         int rx_slot;
  58         int tx_slot;
  59         int tx_cnt;
  60         int ack_slot;
  61         spinlock_t lock;
  62         spinlock_t tx_lock;
  63         u32 msg_enable;
  64 };
  65
  66 struct rionet_peer {
  67         struct list_head node;
  68         struct rio_dev *rdev;
  69         struct resource *res;
  70 };
  71
  72 static int rionet_check = 0;
  73 static int rionet_capable = 1;
  74
  75 /*
  76  * This is a fast lookup table for translating TX
  77  * Ethernet packets into a destination RIO device. It
  78  * could be made into a hash table to save memory depending
  79  * on system trade-offs.
  80  */
  81 static struct rio_dev **rionet_active;
  82 static int nact;        /* total number of active rionet peers */
  83
  84 #define is_rionet_capable(src_ops, dst_ops)                     \
  85                         ((src_ops & RIO_SRC_OPS_DATA_MSG) &&    \
  86                          (dst_ops & RIO_DST_OPS_DATA_MSG) &&    \
  87                          (src_ops & RIO_SRC_OPS_DOORBELL) &&    \
  88                          (dst_ops & RIO_DST_OPS_DOORBELL))
  89 #define dev_rionet_capable(dev) \
  90         is_rionet_capable(dev->src_ops, dev->dst_ops)
  91
  92 #define RIONET_MAC_MATCH(x)     (!memcmp((x), "\00\01\00\01", 4))
  93 #define RIONET_GET_DESTID(x)    ((*((u8 *)x + 4) << 8) | *((u8 *)x + 5))
  94
  95 static int rionet_rx_clean(struct net_device *ndev)
  96 {
  97         int i;
  98         int error = 0;
  99         struct rionet_private *rnet = netdev_priv(ndev);
 100         void *data;
 101
 102         i = rnet->rx_slot;
 103
 104         do {
 105                 if (!rnet->rx_skb[i])
 106                         continue;
 107
 108                 if (!(data = rio_get_inb_message(rnet->mport, RIONET_MAILBOX)))
 109                         break;
 110
 111                 rnet->rx_skb[i]->data = data;
 112                 skb_put(rnet->rx_skb[i], RIO_MAX_MSG_SIZE);
 113                 rnet->rx_skb[i]->protocol =
 114                     eth_type_trans(rnet->rx_skb[i], ndev);
 115                 error = netif_rx(rnet->rx_skb[i]);
 116
 117                 if (error == NET_RX_DROP) {
 118                         ndev->stats.rx_dropped++;
 119                 } else {
 120                         ndev->stats.rx_packets++;
 121                         ndev->stats.rx_bytes += RIO_MAX_MSG_SIZE;
 122                 }
 123
 124         } while ((i = (i + 1) % RIONET_RX_RING_SIZE) != rnet->rx_slot);
 125
 126         return i;
 127 }
 128
 129 static void rionet_rx_fill(struct net_device *ndev, int end)
 130 {
 131         int i;
 132         struct rionet_private *rnet = netdev_priv(ndev);
 133
 134         i = rnet->rx_slot;
 135         do {
 136                 rnet->rx_skb[i] = dev_alloc_skb(RIO_MAX_MSG_SIZE);
 137
 138                 if (!rnet->rx_skb[i])
 139                         break;
 140
 141                 rio_add_inb_buffer(rnet->mport, RIONET_MAILBOX,
 142                                    rnet->rx_skb[i]->data);
 143         } while ((i = (i + 1) % RIONET_RX_RING_SIZE) != end);
 144
 145         rnet->rx_slot = i;
 146 }
 147
 148 static int rionet_queue_tx_msg(struct sk_buff *skb, struct net_device *ndev,
 149                                struct rio_dev *rdev)
 150 {
 151         struct rionet_private *rnet = netdev_priv(ndev);
 152
 153         rio_add_outb_message(rnet->mport, rdev, 0, skb->data, skb->len);
 154         rnet->tx_skb[rnet->tx_slot] = skb;
 155
 156         ndev->stats.tx_packets++;
 157         ndev->stats.tx_bytes += skb->len;
 158
 159         if (++rnet->tx_cnt == RIONET_TX_RING_SIZE)
 160                 netif_stop_queue(ndev);
 161
 162         ++rnet->tx_slot;
 163         rnet->tx_slot &= (RIONET_TX_RING_SIZE - 1);
 164
 165         if (netif_msg_tx_queued(rnet))
 166                 printk(KERN_INFO "%s: queued skb len %8.8x\n", DRV_NAME,
 167                        skb->len);
 168
 169         return 0;
 170 }
 171
 172 static int rionet_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 173 {
 174         int i;
 175         struct rionet_private *rnet = netdev_priv(ndev);
 176         struct ethhdr *eth = (struct ethhdr *)skb->data;
 177         u16 destid;
 178         unsigned long flags;
 179         int add_num = 1;
 180
 181         local_irq_save(flags);
 182         if (!spin_trylock(&rnet->tx_lock)) {
 183                 local_irq_restore(flags);
 184                 return NETDEV_TX_LOCKED;
 185         }
 186
 187         if (is_multicast_ether_addr(eth->h_dest))
 188                 add_num = nact;
 189
 190         if ((rnet->tx_cnt + add_num) > RIONET_TX_RING_SIZE) {
 191                 netif_stop_queue(ndev);
 192                 spin_unlock_irqrestore(&rnet->tx_lock, flags);
 193                 printk(KERN_ERR "%s: BUG! Tx Ring full when queue awake!\n",
 194                        ndev->name);
 195                 return NETDEV_TX_BUSY;
 196         }
 197
 198         if (is_multicast_ether_addr(eth->h_dest)) {
 199                 int count = 0;
 200                 for (i = 0; i < RIO_MAX_ROUTE_ENTRIES(rnet->mport->sys_size);
 201                                 i++)
 202                         if (rionet_active[i]) {
 203                                 rionet_queue_tx_msg(skb, ndev,
 204                                                     rionet_active[i]);
 205                                 if (count)
 206                                         atomic_inc(&skb->users);
 207                                 count++;
 208                         }
 209         } else if (RIONET_MAC_MATCH(eth->h_dest)) {
 210                 destid = RIONET_GET_DESTID(eth->h_dest);
 211                 if (rionet_active[destid])
 212                         rionet_queue_tx_msg(skb, ndev, rionet_active[destid]);
 213         }
 214
 215         spin_unlock_irqrestore(&rnet->tx_lock, flags);
 216
 217         return NETDEV_TX_OK;
 218 }
 219
 220 static void rionet_dbell_event(struct rio_mport *mport, void *dev_id, u16 sid, u16 tid,
 221                                u16 info)
 222 {
 223         struct net_device *ndev = dev_id;
 224         struct rionet_private *rnet = netdev_priv(ndev);
 225         struct rionet_peer *peer;
 226
 227         if (netif_msg_intr(rnet))
 228                 printk(KERN_INFO "%s: doorbell sid %4.4x tid %4.4x info %4.4x",
 229                        DRV_NAME, sid, tid, info);
 230         if (info == RIONET_DOORBELL_JOIN) {
 231                 if (!rionet_active[sid]) {
 232                         list_for_each_entry(peer, &rionet_peers, node) {
 233                                 if (peer->rdev->destid == sid) {
 234                                         rionet_active[sid] = peer->rdev;
 235                                         nact++;
 236                                 }
 237                         }
 238                         rio_mport_send_doorbell(mport, sid,
 239                                                 RIONET_DOORBELL_JOIN);
 240                 }
 241         } else if (info == RIONET_DOORBELL_LEAVE) {
 242                 rionet_active[sid] = NULL;
 243                 nact--;
 244         } else {
 245                 if (netif_msg_intr(rnet))
 246                         printk(KERN_WARNING "%s: unhandled doorbell\n",
 247                                DRV_NAME);
 248         }
 249 }
 250
 251 static void rionet_inb_msg_event(struct rio_mport *mport, void *dev_id, int mbox, int slot)
 252 {
 253         int n;
 254         struct net_device *ndev = dev_id;
 255         struct rionet_private *rnet = netdev_priv(ndev);
 256
 257         if (netif_msg_intr(rnet))
 258                 printk(KERN_INFO "%s: inbound message event, mbox %d slot %d\n",
 259                        DRV_NAME, mbox, slot);
 260
 261         spin_lock(&rnet->lock);
 262         if ((n = rionet_rx_clean(ndev)) != rnet->rx_slot)
 263                 rionet_rx_fill(ndev, n);
 264         spin_unlock(&rnet->lock);
 265 }
 266
 267 static void rionet_outb_msg_event(struct rio_mport *mport, void *dev_id, int mbox, int slot)
 268 {
 269         struct net_device *ndev = dev_id;
 270         struct rionet_private *rnet = netdev_priv(ndev);
 271
 272         spin_lock(&rnet->lock);
 273
 274         if (netif_msg_intr(rnet))
 275                 printk(KERN_INFO
 276                        "%s: outbound message event, mbox %d slot %d\n",
 277                        DRV_NAME, mbox, slot);
 278
 279         while (rnet->tx_cnt && (rnet->ack_slot != slot)) {
 280                 /* dma unmap single */
 281                 dev_kfree_skb_irq(rnet->tx_skb[rnet->ack_slot]);
 282                 rnet->tx_skb[rnet->ack_slot] = NULL;
 283                 ++rnet->ack_slot;
 284                 rnet->ack_slot &= (RIONET_TX_RING_SIZE - 1);
 285                 rnet->tx_cnt--;
 286         }
 287
 288         if (rnet->tx_cnt < RIONET_TX_RING_SIZE)
 289                 netif_wake_queue(ndev);
 290
 291         spin_unlock(&rnet->lock);
 292 }
 293
 294 static int rionet_open(struct net_device *ndev)
 295 {
 296         int i, rc = 0;
 297         struct rionet_peer *peer, *tmp;
 298         struct rionet_private *rnet = netdev_priv(ndev);
 299
 300         if (netif_msg_ifup(rnet))
 301                 printk(KERN_INFO "%s: open\n", DRV_NAME);
 302
 303         if ((rc = rio_request_inb_dbell(rnet->mport,
 304                                         (void *)ndev,
 305                                         RIONET_DOORBELL_JOIN,
 306                                         RIONET_DOORBELL_LEAVE,
 307                                         rionet_dbell_event)) < 0)
 308                 goto out;
 309
 310         if ((rc = rio_request_inb_mbox(rnet->mport,
 311                                        (void *)ndev,
 312                                        RIONET_MAILBOX,
 313                                        RIONET_RX_RING_SIZE,
 314                                        rionet_inb_msg_event)) < 0)
 315                 goto out;
 316
 317         if ((rc = rio_request_outb_mbox(rnet->mport,
 318                                         (void *)ndev,
 319                                         RIONET_MAILBOX,
 320                                         RIONET_TX_RING_SIZE,
 321                                         rionet_outb_msg_event)) < 0)
 322                 goto out;
 323
 324         /* Initialize inbound message ring */
 325         for (i = 0; i < RIONET_RX_RING_SIZE; i++)
 326                 rnet->rx_skb[i] = NULL;
 327         rnet->rx_slot = 0;
 328         rionet_rx_fill(ndev, 0);
 329
 330         rnet->tx_slot = 0;
 331         rnet->tx_cnt = 0;
 332         rnet->ack_slot = 0;
 333
 334         netif_carrier_on(ndev);
 335         netif_start_queue(ndev);
 336
 337         list_for_each_entry_safe(peer, tmp, &rionet_peers, node) {
 338                 if (!(peer->res = rio_request_outb_dbell(peer->rdev,
 339                                                          RIONET_DOORBELL_JOIN,
 340                                                          RIONET_DOORBELL_LEAVE)))
 341                 {
 342                         printk(KERN_ERR "%s: error requesting doorbells\n",
 343                                DRV_NAME);
 344                         continue;
 345                 }
 346
 347                 /* Send a join message */
 348                 rio_send_doorbell(peer->rdev, RIONET_DOORBELL_JOIN);
 349         }
 350
 351       out:
 352         return rc;
 353 }
 354
 355 static int rionet_close(struct net_device *ndev)
 356 {
 357         struct rionet_private *rnet = netdev_priv(ndev);
 358         struct rionet_peer *peer, *tmp;
 359         int i;
 360
 361         if (netif_msg_ifup(rnet))
 362                 printk(KERN_INFO "%s: close\n", DRV_NAME);
 363
 364         netif_stop_queue(ndev);
 365         netif_carrier_off(ndev);
 366
 367         for (i = 0; i < RIONET_RX_RING_SIZE; i++)
 368                 kfree_skb(rnet->rx_skb[i]);
 369
 370         list_for_each_entry_safe(peer, tmp, &rionet_peers, node) {
 371                 if (rionet_active[peer->rdev->destid]) {
 372                         rio_send_doorbell(peer->rdev, RIONET_DOORBELL_LEAVE);
 373                         rionet_active[peer->rdev->destid] = NULL;
 374                 }
 375                 rio_release_outb_dbell(peer->rdev, peer->res);
 376         }
 377
 378         rio_release_inb_dbell(rnet->mport, RIONET_DOORBELL_JOIN,
 379                               RIONET_DOORBELL_LEAVE);
 380         rio_release_inb_mbox(rnet->mport, RIONET_MAILBOX);
 381         rio_release_outb_mbox(rnet->mport, RIONET_MAILBOX);
 382
 383         return 0;
 384 }
 385
 386 static void rionet_remove(struct rio_dev *rdev)
 387 {
 388         struct net_device *ndev = rio_get_drvdata(rdev);
 389         struct rionet_peer *peer, *tmp;
 390
 391         free_pages((unsigned long)rionet_active, rdev->net->hport->sys_size ?
 392                                         __fls(sizeof(void *)) + 4 : 0);
 393         unregister_netdev(ndev);
 394         free_netdev(ndev);
 395
 396         list_for_each_entry_safe(peer, tmp, &rionet_peers, node) {
 397                 list_del(&peer->node);
 398                 kfree(peer);
 399         }
 400 }
 401
 402 static void rionet_get_drvinfo(struct net_device *ndev,
 403                                struct ethtool_drvinfo *info)
 404 {
 405         struct rionet_private *rnet = netdev_priv(ndev);
 406
 407         strcpy(info->driver, DRV_NAME);
 408         strcpy(info->version, DRV_VERSION);
 409         strcpy(info->fw_version, "n/a");
 410         strcpy(info->bus_info, rnet->mport->name);
 411 }
 412
 413 static u32 rionet_get_msglevel(struct net_device *ndev)
 414 {
 415         struct rionet_private *rnet = netdev_priv(ndev);
 416
 417         return rnet->msg_enable;
 418 }
 419
 420 static void rionet_set_msglevel(struct net_device *ndev, u32 value)
 421 {
 422         struct rionet_private *rnet = netdev_priv(ndev);
 423
 424         rnet->msg_enable = value;
 425 }
 426
 427 static const struct ethtool_ops rionet_ethtool_ops = {
 428         .get_drvinfo = rionet_get_drvinfo,
 429         .get_msglevel = rionet_get_msglevel,
 430         .set_msglevel = rionet_set_msglevel,
 431         .get_link = ethtool_op_get_link,
 432 };
 433
 434 static const struct net_device_ops rionet_netdev_ops = {
 435         .ndo_open               = rionet_open,
 436         .ndo_stop               = rionet_close,
 437         .ndo_start_xmit         = rionet_start_xmit,
 438         .ndo_change_mtu         = eth_change_mtu,
 439         .ndo_validate_addr      = eth_validate_addr,
 440         .ndo_set_mac_address    = eth_mac_addr,
 441 };
 442
 443 static int rionet_setup_netdev(struct rio_mport *mport, struct net_device *ndev)
 444 {
 445         int rc = 0;
 446         struct rionet_private *rnet;
 447         u16 device_id;
 448
 449         rionet_active = (struct rio_dev **)__get_free_pages(GFP_KERNEL,
 450                         mport->sys_size ? __fls(sizeof(void *)) + 4 : 0);
 451         if (!rionet_active) {
 452                 rc = -ENOMEM;
 453                 goto out;
 454         }
 455         memset((void *)rionet_active, 0, sizeof(void *) *
 456                                 RIO_MAX_ROUTE_ENTRIES(mport->sys_size));
 457
 458         /* Set up private area */
 459         rnet = netdev_priv(ndev);
 460         rnet->mport = mport;
 461
 462         /* Set the default MAC address */
 463         device_id = rio_local_get_device_id(mport);
 464         ndev->dev_addr[0] = 0x00;
 465         ndev->dev_addr[1] = 0x01;
 466         ndev->dev_addr[2] = 0x00;
 467         ndev->dev_addr[3] = 0x01;
 468         ndev->dev_addr[4] = device_id >> 8;
 469         ndev->dev_addr[5] = device_id & 0xff;
 470
 471         ndev->netdev_ops = &rionet_netdev_ops;
 472         ndev->mtu = RIO_MAX_MSG_SIZE - 14;
 473         ndev->features = NETIF_F_LLTX;
 474         SET_ETHTOOL_OPS(ndev, &rionet_ethtool_ops);
 475
 476         spin_lock_init(&rnet->lock);
 477         spin_lock_init(&rnet->tx_lock);
 478
 479         rnet->msg_enable = RIONET_DEFAULT_MSGLEVEL;
 480
 481         rc = register_netdev(ndev);
 482         if (rc != 0)
 483                 goto out;
 484
 485         printk("%s: %s %s Version %s, MAC %pM\n",
 486                ndev->name,
 487                DRV_NAME,
 488                DRV_DESC,
 489                DRV_VERSION,
 490                ndev->dev_addr);
 491
 492       out:
 493         return rc;
 494 }
 495
 496 /*
 497  * XXX Make multi-net safe
 498  */
 499 static int rionet_probe(struct rio_dev *rdev, const struct rio_device_id *id)
 500 {
 501         int rc = -ENODEV;
 502         u32 lsrc_ops, ldst_ops;
 503         struct rionet_peer *peer;
 504         struct net_device *ndev = NULL;
 505
 506         /* If local device is not rionet capable, give up quickly */
 507         if (!rionet_capable)
 508                 goto out;
 509
 510         /* Allocate our net_device structure */
 511         ndev = alloc_etherdev(sizeof(struct rionet_private));
 512         if (ndev == NULL) {
 513                 printk(KERN_INFO "%s: could not allocate ethernet device.\n",
 514                        DRV_NAME);
 515                 rc = -ENOMEM;
 516                 goto out;
 517         }
 518
 519         /*
 520          * First time through, make sure local device is rionet
 521          * capable, setup netdev,  and set flags so this is skipped
 522          * on later probes
 523          */
 524         if (!rionet_check) {
 525                 rio_local_read_config_32(rdev->net->hport, RIO_SRC_OPS_CAR,
 526                                          &lsrc_ops);
 527                 rio_local_read_config_32(rdev->net->hport, RIO_DST_OPS_CAR,
 528                                          &ldst_ops);
 529                 if (!is_rionet_capable(lsrc_ops, ldst_ops)) {
 530                         printk(KERN_ERR
 531                                "%s: local device is not network capable\n",
 532                                DRV_NAME);
 533                         rionet_check = 1;
 534                         rionet_capable = 0;
 535                         goto out;
 536                 }
 537
 538                 rc = rionet_setup_netdev(rdev->net->hport, ndev);
 539                 rionet_check = 1;
 540                 nact = 0;
 541         }
 542
 543         /*
 544          * If the remote device has mailbox/doorbell capabilities,
 545          * add it to the peer list.
 546          */
 547         if (dev_rionet_capable(rdev)) {
 548                 if (!(peer = kmalloc(sizeof(struct rionet_peer), GFP_KERNEL))) {
 549                         rc = -ENOMEM;
 550                         goto out;
 551                 }
 552                 peer->rdev = rdev;
 553                 list_add_tail(&peer->node, &rionet_peers);
 554         }
 555
 556         rio_set_drvdata(rdev, ndev);
 557
 558       out:
 559         return rc;
 560 }
 561
 562 static struct rio_device_id rionet_id_table[] = {
 563         {RIO_DEVICE(RIO_ANY_ID, RIO_ANY_ID)}
 564 };
 565
 566 static struct rio_driver rionet_driver = {
 567         .name = "rionet",
 568         .id_table = rionet_id_table,
 569         .probe = rionet_probe,
 570         .remove = rionet_remove,
 571 };
 572
 573 static int __init rionet_init(void)
 574 {
 575         return rio_register_driver(&rionet_driver);
 576 }
 577
 578 static void __exit rionet_exit(void)
 579 {
 580         rio_unregister_driver(&rionet_driver);
 581 }
 582
 583 late_initcall(rionet_init);
 584 module_exit(rionet_exit);