drivers/net/ixp2000/ixpdev.c

   1 /*
   2  * IXP2000 MSF network device driver
   3  * Copyright (C) 2004, 2005 Lennert Buytenhek <buytenh@wantstofly.org>
   4  * Dedicated to Marija Kulikova.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/netdevice.h>
  15 #include <linux/etherdevice.h>
  16 #include <linux/init.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/moduleparam.h>
  19 #include <linux/gfp.h>
  20 #include <asm/hardware/uengine.h>
  21 #include <asm/io.h>
  22 #include "ixp2400_rx.ucode"
  23 #include "ixp2400_tx.ucode"
  24 #include "ixpdev_priv.h"
  25 #include "ixpdev.h"
  26 #include "pm3386.h"
  27
  28 #define DRV_MODULE_VERSION      "0.2"
  29
  30 static int nds_count;
  31 static struct net_device **nds;
  32 static int nds_open;
  33 static void (*set_port_admin_status)(int port, int up);
  34
  35 static struct ixpdev_rx_desc * const rx_desc =
  36         (struct ixpdev_rx_desc *)(IXP2000_SRAM0_VIRT_BASE + RX_BUF_DESC_BASE);
  37 static struct ixpdev_tx_desc * const tx_desc =
  38         (struct ixpdev_tx_desc *)(IXP2000_SRAM0_VIRT_BASE + TX_BUF_DESC_BASE);
  39 static int tx_pointer;
  40
  41
  42 static int ixpdev_xmit(struct sk_buff *skb, struct net_device *dev)
  43 {
  44         struct ixpdev_priv *ip = netdev_priv(dev);
  45         struct ixpdev_tx_desc *desc;
  46         int entry;
  47         unsigned long flags;
  48
  49         if (unlikely(skb->len > PAGE_SIZE)) {
  50                 /* @@@ Count drops.  */
  51                 dev_kfree_skb(skb);
  52                 return NETDEV_TX_OK;
  53         }
  54
  55         entry = tx_pointer;
  56         tx_pointer = (tx_pointer + 1) % TX_BUF_COUNT;
  57
  58         desc = tx_desc + entry;
  59         desc->pkt_length = skb->len;
  60         desc->channel = ip->channel;
  61
  62         skb_copy_and_csum_dev(skb, phys_to_virt(desc->buf_addr));
  63         dev_kfree_skb(skb);
  64
  65         ixp2000_reg_write(RING_TX_PENDING,
  66                 TX_BUF_DESC_BASE + (entry * sizeof(struct ixpdev_tx_desc)));
  67
  68         local_irq_save(flags);
  69         ip->tx_queue_entries++;
  70         if (ip->tx_queue_entries == TX_BUF_COUNT_PER_CHAN)
  71                 netif_stop_queue(dev);
  72         local_irq_restore(flags);
  73
  74         return NETDEV_TX_OK;
  75 }
  76
  77
  78 static int ixpdev_rx(struct net_device *dev, int processed, int budget)
  79 {
  80         while (processed < budget) {
  81                 struct ixpdev_rx_desc *desc;
  82                 struct sk_buff *skb;
  83                 void *buf;
  84                 u32 _desc;
  85
  86                 _desc = ixp2000_reg_read(RING_RX_DONE);
  87                 if (_desc == 0)
  88                         return 0;
  89
  90                 desc = rx_desc +
  91                         ((_desc - RX_BUF_DESC_BASE) / sizeof(struct ixpdev_rx_desc));
  92                 buf = phys_to_virt(desc->buf_addr);
  93
  94                 if (desc->pkt_length < 4 || desc->pkt_length > PAGE_SIZE) {
  95                         printk(KERN_ERR "ixp2000: rx err, length %d\n",
  96                                         desc->pkt_length);
  97                         goto err;
  98                 }
  99
 100                 if (desc->channel < 0 || desc->channel >= nds_count) {
 101                         printk(KERN_ERR "ixp2000: rx err, channel %d\n",
 102                                         desc->channel);
 103                         goto err;
 104                 }
 105
 106                 /* @@@ Make FCS stripping configurable.  */
 107                 desc->pkt_length -= 4;
 108
 109                 if (unlikely(!netif_running(nds[desc->channel])))
 110                         goto err;
 111
 112                 skb = netdev_alloc_skb_ip_align(dev, desc->pkt_length);
 113                 if (likely(skb != NULL)) {
 114                         skb_copy_to_linear_data(skb, buf, desc->pkt_length);
 115                         skb_put(skb, desc->pkt_length);
 116                         skb->protocol = eth_type_trans(skb, nds[desc->channel]);
 117
 118                         netif_receive_skb(skb);
 119                 }
 120
 121 err:
 122                 ixp2000_reg_write(RING_RX_PENDING, _desc);
 123                 processed++;
 124         }
 125
 126         return processed;
 127 }
 128
 129 /* dev always points to nds[0].  */
 130 static int ixpdev_poll(struct napi_struct *napi, int budget)
 131 {
 132         struct ixpdev_priv *ip = container_of(napi, struct ixpdev_priv, napi);
 133         struct net_device *dev = ip->dev;
 134         int rx;
 135
 136         rx = 0;
 137         do {
 138                 ixp2000_reg_write(IXP2000_IRQ_THD_RAW_STATUS_A_0, 0x00ff);
 139
 140                 rx = ixpdev_rx(dev, rx, budget);
 141                 if (rx >= budget)
 142                         break;
 143         } while (ixp2000_reg_read(IXP2000_IRQ_THD_RAW_STATUS_A_0) & 0x00ff);
 144
 145         napi_complete(napi);
 146         ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_SET_A_0, 0x00ff);
 147
 148         return rx;
 149 }
 150
 151 static void ixpdev_tx_complete(void)
 152 {
 153         int channel;
 154         u32 wake;
 155
 156         wake = 0;
 157         while (1) {
 158                 struct ixpdev_priv *ip;
 159                 u32 desc;
 160                 int entry;
 161
 162                 desc = ixp2000_reg_read(RING_TX_DONE);
 163                 if (desc == 0)
 164                         break;
 165
 166                 /* @@@ Check whether entries come back in order.  */
 167                 entry = (desc - TX_BUF_DESC_BASE) / sizeof(struct ixpdev_tx_desc);
 168                 channel = tx_desc[entry].channel;
 169
 170                 if (channel < 0 || channel >= nds_count) {
 171                         printk(KERN_ERR "ixp2000: txcomp channel index "
 172                                         "out of bounds (%d, %.8i, %d)\n",
 173                                         channel, (unsigned int)desc, entry);
 174                         continue;
 175                 }
 176
 177                 ip = netdev_priv(nds[channel]);
 178                 if (ip->tx_queue_entries == TX_BUF_COUNT_PER_CHAN)
 179                         wake |= 1 << channel;
 180                 ip->tx_queue_entries--;
 181         }
 182
 183         for (channel = 0; wake != 0; channel++) {
 184                 if (wake & (1 << channel)) {
 185                         netif_wake_queue(nds[channel]);
 186                         wake &= ~(1 << channel);
 187                 }
 188         }
 189 }
 190
 191 static irqreturn_t ixpdev_interrupt(int irq, void *dev_id)
 192 {
 193         u32 status;
 194
 195         status = ixp2000_reg_read(IXP2000_IRQ_THD_STATUS_A_0);
 196         if (status == 0)
 197                 return IRQ_NONE;
 198
 199         /*
 200          * Any of the eight receive units signaled RX?
 201          */
 202         if (status & 0x00ff) {
 203                 struct net_device *dev = nds[0];
 204                 struct ixpdev_priv *ip = netdev_priv(dev);
 205
 206                 ixp2000_reg_wrb(IXP2000_IRQ_THD_ENABLE_CLEAR_A_0, 0x00ff);
 207                 if (likely(napi_schedule_prep(&ip->napi))) {
 208                         __napi_schedule(&ip->napi);
 209                 } else {
 210                         printk(KERN_CRIT "ixp2000: irq while polling!!\n");
 211                 }
 212         }
 213
 214         /*
 215          * Any of the eight transmit units signaled TXdone?
 216          */
 217         if (status & 0xff00) {
 218                 ixp2000_reg_wrb(IXP2000_IRQ_THD_RAW_STATUS_A_0, 0xff00);
 219                 ixpdev_tx_complete();
 220         }
 221
 222         return IRQ_HANDLED;
 223 }
 224
 225 #ifdef CONFIG_NET_POLL_CONTROLLER
 226 static void ixpdev_poll_controller(struct net_device *dev)
 227 {
 228         disable_irq(IRQ_IXP2000_THDA0);
 229         ixpdev_interrupt(IRQ_IXP2000_THDA0, dev);
 230         enable_irq(IRQ_IXP2000_THDA0);
 231 }
 232 #endif
 233
 234 static int ixpdev_open(struct net_device *dev)
 235 {
 236         struct ixpdev_priv *ip = netdev_priv(dev);
 237         int err;
 238
 239         napi_enable(&ip->napi);
 240         if (!nds_open++) {
 241                 err = request_irq(IRQ_IXP2000_THDA0, ixpdev_interrupt,
 242                                         IRQF_SHARED, "ixp2000_eth", nds);
 243                 if (err) {
 244                         nds_open--;
 245                         napi_disable(&ip->napi);
 246                         return err;
 247                 }
 248
 249                 ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_SET_A_0, 0xffff);
 250         }
 251
 252         set_port_admin_status(ip->channel, 1);
 253         netif_start_queue(dev);
 254
 255         return 0;
 256 }
 257
 258 static int ixpdev_close(struct net_device *dev)
 259 {
 260         struct ixpdev_priv *ip = netdev_priv(dev);
 261
 262         netif_stop_queue(dev);
 263         napi_disable(&ip->napi);
 264         set_port_admin_status(ip->channel, 0);
 265
 266         if (!--nds_open) {
 267                 ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_CLEAR_A_0, 0xffff);
 268                 free_irq(IRQ_IXP2000_THDA0, nds);
 269         }
 270
 271         return 0;
 272 }
 273
 274 static struct net_device_stats *ixpdev_get_stats(struct net_device *dev)
 275 {
 276         struct ixpdev_priv *ip = netdev_priv(dev);
 277
 278         pm3386_get_stats(ip->channel, &(dev->stats));
 279
 280         return &(dev->stats);
 281 }
 282
 283 static const struct net_device_ops ixpdev_netdev_ops = {
 284         .ndo_open               = ixpdev_open,
 285         .ndo_stop               = ixpdev_close,
 286         .ndo_start_xmit         = ixpdev_xmit,
 287         .ndo_change_mtu         = eth_change_mtu,
 288         .ndo_validate_addr      = eth_validate_addr,
 289         .ndo_set_mac_address    = eth_mac_addr,
 290         .ndo_get_stats          = ixpdev_get_stats,
 291 #ifdef CONFIG_NET_POLL_CONTROLLER
 292         .ndo_poll_controller    = ixpdev_poll_controller,
 293 #endif
 294 };
 295
 296 struct net_device *ixpdev_alloc(int channel, int sizeof_priv)
 297 {
 298         struct net_device *dev;
 299         struct ixpdev_priv *ip;
 300
 301         dev = alloc_etherdev(sizeof_priv);
 302         if (dev == NULL)
 303                 return NULL;
 304
 305         dev->netdev_ops = &ixpdev_netdev_ops;
 306
 307         dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
 308
 309         ip = netdev_priv(dev);
 310         ip->dev = dev;
 311         netif_napi_add(dev, &ip->napi, ixpdev_poll, 64);
 312         ip->channel = channel;
 313         ip->tx_queue_entries = 0;
 314
 315         return dev;
 316 }
 317
 318 int ixpdev_init(int __nds_count, struct net_device **__nds,
 319                 void (*__set_port_admin_status)(int port, int up))
 320 {
 321         int i;
 322         int err;
 323
 324         BUILD_BUG_ON(RX_BUF_COUNT > 192 || TX_BUF_COUNT > 192);
 325
 326         printk(KERN_INFO "IXP2000 MSF ethernet driver %s\n", DRV_MODULE_VERSION);
 327
 328         nds_count = __nds_count;
 329         nds = __nds;
 330         set_port_admin_status = __set_port_admin_status;
 331
 332         for (i = 0; i < RX_BUF_COUNT; i++) {
 333                 void *buf;
 334
 335                 buf = (void *)get_zeroed_page(GFP_KERNEL);
 336                 if (buf == NULL) {
 337                         err = -ENOMEM;
 338                         while (--i >= 0)
 339                                 free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr));
 340                         goto err_out;
 341                 }
 342                 rx_desc[i].buf_addr = virt_to_phys(buf);
 343                 rx_desc[i].buf_length = PAGE_SIZE;
 344         }
 345
 346         /* @@@ Maybe we shouldn't be preallocating TX buffers.  */
 347         for (i = 0; i < TX_BUF_COUNT; i++) {
 348                 void *buf;
 349
 350                 buf = (void *)get_zeroed_page(GFP_KERNEL);
 351                 if (buf == NULL) {
 352                         err = -ENOMEM;
 353                         while (--i >= 0)
 354                                 free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr));
 355                         goto err_free_rx;
 356                 }
 357                 tx_desc[i].buf_addr = virt_to_phys(buf);
 358         }
 359
 360         /* 256 entries, ring status set means 'empty', base address 0x0000.  */
 361         ixp2000_reg_write(RING_RX_PENDING_BASE, 0x44000000);
 362         ixp2000_reg_write(RING_RX_PENDING_HEAD, 0x00000000);
 363         ixp2000_reg_write(RING_RX_PENDING_TAIL, 0x00000000);
 364
 365         /* 256 entries, ring status set means 'full', base address 0x0400.  */
 366         ixp2000_reg_write(RING_RX_DONE_BASE, 0x40000400);
 367         ixp2000_reg_write(RING_RX_DONE_HEAD, 0x00000000);
 368         ixp2000_reg_write(RING_RX_DONE_TAIL, 0x00000000);
 369
 370         for (i = 0; i < RX_BUF_COUNT; i++) {
 371                 ixp2000_reg_write(RING_RX_PENDING,
 372                         RX_BUF_DESC_BASE + (i * sizeof(struct ixpdev_rx_desc)));
 373         }
 374
 375         ixp2000_uengine_load(0, &ixp2400_rx);
 376         ixp2000_uengine_start_contexts(0, 0xff);
 377
 378         /* 256 entries, ring status set means 'empty', base address 0x0800.  */
 379         ixp2000_reg_write(RING_TX_PENDING_BASE, 0x44000800);
 380         ixp2000_reg_write(RING_TX_PENDING_HEAD, 0x00000000);
 381         ixp2000_reg_write(RING_TX_PENDING_TAIL, 0x00000000);
 382
 383         /* 256 entries, ring status set means 'full', base address 0x0c00.  */
 384         ixp2000_reg_write(RING_TX_DONE_BASE, 0x40000c00);
 385         ixp2000_reg_write(RING_TX_DONE_HEAD, 0x00000000);
 386         ixp2000_reg_write(RING_TX_DONE_TAIL, 0x00000000);
 387
 388         ixp2000_uengine_load(1, &ixp2400_tx);
 389         ixp2000_uengine_start_contexts(1, 0xff);
 390
 391         for (i = 0; i < nds_count; i++) {
 392                 err = register_netdev(nds[i]);
 393                 if (err) {
 394                         while (--i >= 0)
 395                                 unregister_netdev(nds[i]);
 396                         goto err_free_tx;
 397                 }
 398         }
 399
 400         for (i = 0; i < nds_count; i++) {
 401                 printk(KERN_INFO "%s: IXP2000 MSF ethernet (port %d), "
 402                         "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x.\n", nds[i]->name, i,
 403                         nds[i]->dev_addr[0], nds[i]->dev_addr[1],
 404                         nds[i]->dev_addr[2], nds[i]->dev_addr[3],
 405                         nds[i]->dev_addr[4], nds[i]->dev_addr[5]);
 406         }
 407
 408         return 0;
 409
 410 err_free_tx:
 411         for (i = 0; i < TX_BUF_COUNT; i++)
 412                 free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr));
 413
 414 err_free_rx:
 415         for (i = 0; i < RX_BUF_COUNT; i++)
 416                 free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr));
 417
 418 err_out:
 419         return err;
 420 }
 421
 422 void ixpdev_deinit(void)
 423 {
 424         int i;
 425
 426         /* @@@ Flush out pending packets.  */
 427
 428         for (i = 0; i < nds_count; i++)
 429                 unregister_netdev(nds[i]);
 430
 431         ixp2000_uengine_stop_contexts(1, 0xff);
 432         ixp2000_uengine_stop_contexts(0, 0xff);
 433         ixp2000_uengine_reset(0x3);
 434
 435         for (i = 0; i < TX_BUF_COUNT; i++)
 436                 free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr));
 437
 438         for (i = 0; i < RX_BUF_COUNT; i++)
 439                 free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr));
 440 }