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/config.h>
  13 #include <linux/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/netdevice.h>
  16 #include <linux/etherdevice.h>
  17 #include <linux/init.h>
  18 #include <linux/moduleparam.h>
  19 #include <asm/arch/uengine.h>
  20 #include <asm/mach-types.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
  27 static int nds_count;
  28 static struct net_device **nds;
  29 static int nds_open;
  30 static void (*set_port_admin_status)(int port, int up);
  31
  32 static struct ixpdev_rx_desc * const rx_desc =
  33         (struct ixpdev_rx_desc *)(IXP2000_SRAM0_VIRT_BASE + RX_BUF_DESC_BASE);
  34 static struct ixpdev_tx_desc * const tx_desc =
  35         (struct ixpdev_tx_desc *)(IXP2000_SRAM0_VIRT_BASE + TX_BUF_DESC_BASE);
  36 static int tx_pointer;
  37
  38
  39 static int ixpdev_xmit(struct sk_buff *skb, struct net_device *dev)
  40 {
  41         struct ixpdev_priv *ip = netdev_priv(dev);
  42         struct ixpdev_tx_desc *desc;
  43         int entry;
  44
  45         if (unlikely(skb->len > PAGE_SIZE)) {
  46                 /* @@@ Count drops.  */
  47                 dev_kfree_skb(skb);
  48                 return 0;
  49         }
  50
  51         entry = tx_pointer;
  52         tx_pointer = (tx_pointer + 1) % TX_BUF_COUNT;
  53
  54         desc = tx_desc + entry;
  55         desc->pkt_length = skb->len;
  56         desc->channel = ip->channel;
  57
  58         skb_copy_and_csum_dev(skb, phys_to_virt(desc->buf_addr));
  59         dev_kfree_skb(skb);
  60
  61         ixp2000_reg_write(RING_TX_PENDING,
  62                 TX_BUF_DESC_BASE + (entry * sizeof(struct ixpdev_tx_desc)));
  63
  64         dev->trans_start = jiffies;
  65
  66         local_irq_disable();
  67         ip->tx_queue_entries++;
  68         if (ip->tx_queue_entries == TX_BUF_COUNT_PER_CHAN)
  69                 netif_stop_queue(dev);
  70         local_irq_enable();
  71
  72         return 0;
  73 }
  74
  75
  76 static int ixpdev_rx(struct net_device *dev, int *budget)
  77 {
  78         while (*budget > 0) {
  79                 struct ixpdev_rx_desc *desc;
  80                 struct sk_buff *skb;
  81                 void *buf;
  82                 u32 _desc;
  83
  84                 _desc = ixp2000_reg_read(RING_RX_DONE);
  85                 if (_desc == 0)
  86                         return 0;
  87
  88                 desc = rx_desc +
  89                         ((_desc - RX_BUF_DESC_BASE) / sizeof(struct ixpdev_rx_desc));
  90                 buf = phys_to_virt(desc->buf_addr);
  91
  92                 if (desc->pkt_length < 4 || desc->pkt_length > PAGE_SIZE) {
  93                         printk(KERN_ERR "ixp2000: rx err, length %d\n",
  94                                         desc->pkt_length);
  95                         goto err;
  96                 }
  97
  98                 if (desc->channel < 0 || desc->channel >= nds_count) {
  99                         printk(KERN_ERR "ixp2000: rx err, channel %d\n",
 100                                         desc->channel);
 101                         goto err;
 102                 }
 103
 104                 /* @@@ Make FCS stripping configurable.  */
 105                 desc->pkt_length -= 4;
 106
 107                 if (unlikely(!netif_running(nds[desc->channel])))
 108                         goto err;
 109
 110                 skb = dev_alloc_skb(desc->pkt_length + 2);
 111                 if (likely(skb != NULL)) {
 112                         skb->dev = nds[desc->channel];
 113                         skb_reserve(skb, 2);
 114                         eth_copy_and_sum(skb, buf, desc->pkt_length, 0);
 115                         skb_put(skb, desc->pkt_length);
 116                         skb->protocol = eth_type_trans(skb, skb->dev);
 117
 118                         skb->dev->last_rx = jiffies;
 119
 120                         netif_receive_skb(skb);
 121                 }
 122
 123 err:
 124                 ixp2000_reg_write(RING_RX_PENDING, _desc);
 125                 dev->quota--;
 126                 (*budget)--;
 127         }
 128
 129         return 1;
 130 }
 131
 132 /* dev always points to nds[0].  */
 133 static int ixpdev_poll(struct net_device *dev, int *budget)
 134 {
 135         /* @@@ Have to stop polling when nds[0] is administratively
 136          * downed while we are polling.  */
 137         do {
 138                 ixp2000_reg_write(IXP2000_IRQ_THD_RAW_STATUS_A_0, 0x00ff);
 139
 140                 if (ixpdev_rx(dev, budget))
 141                         return 1;
 142         } while (ixp2000_reg_read(IXP2000_IRQ_THD_RAW_STATUS_A_0) & 0x00ff);
 143
 144         netif_rx_complete(dev);
 145         ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_SET_A_0, 0x00ff);
 146
 147         return 0;
 148 }
 149
 150 static void ixpdev_tx_complete(void)
 151 {
 152         int channel;
 153         u32 wake;
 154
 155         wake = 0;
 156         while (1) {
 157                 struct ixpdev_priv *ip;
 158                 u32 desc;
 159                 int entry;
 160
 161                 desc = ixp2000_reg_read(RING_TX_DONE);
 162                 if (desc == 0)
 163                         break;
 164
 165                 /* @@@ Check whether entries come back in order.  */
 166                 entry = (desc - TX_BUF_DESC_BASE) / sizeof(struct ixpdev_tx_desc);
 167                 channel = tx_desc[entry].channel;
 168
 169                 if (channel < 0 || channel >= nds_count) {
 170                         printk(KERN_ERR "ixp2000: txcomp channel index "
 171                                         "out of bounds (%d, %.8i, %d)\n",
 172                                         channel, (unsigned int)desc, entry);
 173                         continue;
 174                 }
 175
 176                 ip = netdev_priv(nds[channel]);
 177                 if (ip->tx_queue_entries == TX_BUF_COUNT_PER_CHAN)
 178                         wake |= 1 << channel;
 179                 ip->tx_queue_entries--;
 180         }
 181
 182         for (channel = 0; wake != 0; channel++) {
 183                 if (wake & (1 << channel)) {
 184                         netif_wake_queue(nds[channel]);
 185                         wake &= ~(1 << channel);
 186                 }
 187         }
 188 }
 189
 190 static irqreturn_t ixpdev_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 191 {
 192         u32 status;
 193
 194         status = ixp2000_reg_read(IXP2000_IRQ_THD_STATUS_A_0);
 195         if (status == 0)
 196                 return IRQ_NONE;
 197
 198         /*
 199          * Any of the eight receive units signaled RX?
 200          */
 201         if (status & 0x00ff) {
 202                 ixp2000_reg_wrb(IXP2000_IRQ_THD_ENABLE_CLEAR_A_0, 0x00ff);
 203                 if (likely(netif_rx_schedule_test(nds[0]))) {
 204                         __netif_rx_schedule(nds[0]);
 205                 } else {
 206                         printk(KERN_CRIT "ixp2000: irq while polling!!\n");
 207                 }
 208         }
 209
 210         /*
 211          * Any of the eight transmit units signaled TXdone?
 212          */
 213         if (status & 0xff00) {
 214                 ixp2000_reg_wrb(IXP2000_IRQ_THD_RAW_STATUS_A_0, 0xff00);
 215                 ixpdev_tx_complete();
 216         }
 217
 218         return IRQ_HANDLED;
 219 }
 220
 221 static int ixpdev_open(struct net_device *dev)
 222 {
 223         struct ixpdev_priv *ip = netdev_priv(dev);
 224         int err;
 225
 226         if (!nds_open++) {
 227                 err = request_irq(IRQ_IXP2000_THDA0, ixpdev_interrupt,
 228                                         SA_SHIRQ, "ixp2000_eth", nds);
 229                 if (err) {
 230                         nds_open--;
 231                         return err;
 232                 }
 233
 234                 ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_SET_A_0, 0xffff);
 235         }
 236
 237         set_port_admin_status(ip->channel, 1);
 238         netif_start_queue(dev);
 239
 240         return 0;
 241 }
 242
 243 static int ixpdev_close(struct net_device *dev)
 244 {
 245         struct ixpdev_priv *ip = netdev_priv(dev);
 246
 247         netif_stop_queue(dev);
 248         set_port_admin_status(ip->channel, 0);
 249
 250         if (!--nds_open) {
 251                 ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_CLEAR_A_0, 0xffff);
 252                 free_irq(IRQ_IXP2000_THDA0, nds);
 253         }
 254
 255         return 0;
 256 }
 257
 258 struct net_device *ixpdev_alloc(int channel, int sizeof_priv)
 259 {
 260         struct net_device *dev;
 261         struct ixpdev_priv *ip;
 262
 263         dev = alloc_etherdev(sizeof_priv);
 264         if (dev == NULL)
 265                 return NULL;
 266
 267         dev->hard_start_xmit = ixpdev_xmit;
 268         dev->poll = ixpdev_poll;
 269         dev->open = ixpdev_open;
 270         dev->stop = ixpdev_close;
 271
 272         dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
 273         dev->weight = 64;
 274
 275         ip = netdev_priv(dev);
 276         ip->channel = channel;
 277         ip->tx_queue_entries = 0;
 278
 279         return dev;
 280 }
 281
 282 int ixpdev_init(int __nds_count, struct net_device **__nds,
 283                 void (*__set_port_admin_status)(int port, int up))
 284 {
 285         int i;
 286         int err;
 287
 288         if (RX_BUF_COUNT > 192 || TX_BUF_COUNT > 192) {
 289                 static void __too_many_rx_or_tx_buffers(void);
 290                 __too_many_rx_or_tx_buffers();
 291         }
 292
 293         nds_count = __nds_count;
 294         nds = __nds;
 295         set_port_admin_status = __set_port_admin_status;
 296
 297         for (i = 0; i < RX_BUF_COUNT; i++) {
 298                 void *buf;
 299
 300                 buf = (void *)get_zeroed_page(GFP_KERNEL);
 301                 if (buf == NULL) {
 302                         err = -ENOMEM;
 303                         while (--i >= 0)
 304                                 free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr));
 305                         goto err_out;
 306                 }
 307                 rx_desc[i].buf_addr = virt_to_phys(buf);
 308                 rx_desc[i].buf_length = PAGE_SIZE;
 309         }
 310
 311         /* @@@ Maybe we shouldn't be preallocating TX buffers.  */
 312         for (i = 0; i < TX_BUF_COUNT; i++) {
 313                 void *buf;
 314
 315                 buf = (void *)get_zeroed_page(GFP_KERNEL);
 316                 if (buf == NULL) {
 317                         err = -ENOMEM;
 318                         while (--i >= 0)
 319                                 free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr));
 320                         goto err_free_rx;
 321                 }
 322                 tx_desc[i].buf_addr = virt_to_phys(buf);
 323         }
 324
 325         /* 256 entries, ring status set means 'empty', base address 0x0000.  */
 326         ixp2000_reg_write(RING_RX_PENDING_BASE, 0x44000000);
 327         ixp2000_reg_write(RING_RX_PENDING_HEAD, 0x00000000);
 328         ixp2000_reg_write(RING_RX_PENDING_TAIL, 0x00000000);
 329
 330         /* 256 entries, ring status set means 'full', base address 0x0400.  */
 331         ixp2000_reg_write(RING_RX_DONE_BASE, 0x40000400);
 332         ixp2000_reg_write(RING_RX_DONE_HEAD, 0x00000000);
 333         ixp2000_reg_write(RING_RX_DONE_TAIL, 0x00000000);
 334
 335         for (i = 0; i < RX_BUF_COUNT; i++) {
 336                 ixp2000_reg_write(RING_RX_PENDING,
 337                         RX_BUF_DESC_BASE + (i * sizeof(struct ixpdev_rx_desc)));
 338         }
 339
 340         ixp2000_uengine_load(0, &ixp2400_rx);
 341         ixp2000_uengine_start_contexts(0, 0xff);
 342
 343         /* 256 entries, ring status set means 'empty', base address 0x0800.  */
 344         ixp2000_reg_write(RING_TX_PENDING_BASE, 0x44000800);
 345         ixp2000_reg_write(RING_TX_PENDING_HEAD, 0x00000000);
 346         ixp2000_reg_write(RING_TX_PENDING_TAIL, 0x00000000);
 347
 348         /* 256 entries, ring status set means 'full', base address 0x0c00.  */
 349         ixp2000_reg_write(RING_TX_DONE_BASE, 0x40000c00);
 350         ixp2000_reg_write(RING_TX_DONE_HEAD, 0x00000000);
 351         ixp2000_reg_write(RING_TX_DONE_TAIL, 0x00000000);
 352
 353         ixp2000_uengine_load(1, &ixp2400_tx);
 354         ixp2000_uengine_start_contexts(1, 0xff);
 355
 356         for (i = 0; i < nds_count; i++) {
 357                 err = register_netdev(nds[i]);
 358                 if (err) {
 359                         while (--i >= 0)
 360                                 unregister_netdev(nds[i]);
 361                         goto err_free_tx;
 362                 }
 363         }
 364
 365         for (i = 0; i < nds_count; i++) {
 366                 printk(KERN_INFO "%s: IXP2000 MSF ethernet (port %d), "
 367                         "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x.\n", nds[i]->name, i,
 368                         nds[i]->dev_addr[0], nds[i]->dev_addr[1],
 369                         nds[i]->dev_addr[2], nds[i]->dev_addr[3],
 370                         nds[i]->dev_addr[4], nds[i]->dev_addr[5]);
 371         }
 372
 373         return 0;
 374
 375 err_free_tx:
 376         for (i = 0; i < TX_BUF_COUNT; i++)
 377                 free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr));
 378
 379 err_free_rx:
 380         for (i = 0; i < RX_BUF_COUNT; i++)
 381                 free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr));
 382
 383 err_out:
 384         return err;
 385 }
 386
 387 void ixpdev_deinit(void)
 388 {
 389         int i;
 390
 391         /* @@@ Flush out pending packets.  */
 392
 393         for (i = 0; i < nds_count; i++)
 394                 unregister_netdev(nds[i]);
 395
 396         ixp2000_uengine_stop_contexts(1, 0xff);
 397         ixp2000_uengine_stop_contexts(0, 0xff);
 398         ixp2000_uengine_reset(0x3);
 399
 400         for (i = 0; i < TX_BUF_COUNT; i++)
 401                 free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr));
 402
 403         for (i = 0; i < RX_BUF_COUNT; i++)
 404                 free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr));
 405 }