drivers/net/mipsnet.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  */
   6
   7 #define DEBUG
   8
   9 #include <linux/init.h>
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/netdevice.h>
  13 #include <linux/etherdevice.h>
  14 #include <linux/platform_device.h>
  15 #include <asm/io.h>
  16 #include <asm/mips-boards/simint.h>
  17
  18 #include "mipsnet.h"            /* actual device IO mapping */
  19
  20 #define MIPSNET_VERSION "2005-06-20"
  21
  22 #define mipsnet_reg_address(dev, field) (dev->base_addr + field_offset(field))
  23
  24 struct mipsnet_priv {
  25         struct net_device_stats stats;
  26 };
  27
  28 static char mipsnet_string[] = "mipsnet";
  29
  30 /*
  31  * Copy data from the MIPSNET rx data port
  32  */
  33 static int ioiocpy_frommipsnet(struct net_device *dev, unsigned char *kdata,
  34                         int len)
  35 {
  36         uint32_t available_len = inl(mipsnet_reg_address(dev, rxDataCount));
  37         if (available_len < len)
  38                 return -EFAULT;
  39
  40         for (; len > 0; len--, kdata++) {
  41                 *kdata = inb(mipsnet_reg_address(dev, rxDataBuffer));
  42         }
  43
  44         return inl(mipsnet_reg_address(dev, rxDataCount));
  45 }
  46
  47 static inline ssize_t mipsnet_put_todevice(struct net_device *dev,
  48         struct sk_buff *skb)
  49 {
  50         int count_to_go = skb->len;
  51         char *buf_ptr = skb->data;
  52         struct mipsnet_priv *mp = netdev_priv(dev);
  53
  54         pr_debug("%s: %s(): telling MIPSNET txDataCount(%d)\n",
  55                  dev->name, __FUNCTION__, skb->len);
  56
  57         outl(skb->len, mipsnet_reg_address(dev, txDataCount));
  58
  59         pr_debug("%s: %s(): sending data to MIPSNET txDataBuffer(%d)\n",
  60                  dev->name, __FUNCTION__, skb->len);
  61
  62         for (; count_to_go; buf_ptr++, count_to_go--) {
  63                 outb(*buf_ptr, mipsnet_reg_address(dev, txDataBuffer));
  64         }
  65
  66         mp->stats.tx_packets++;
  67         mp->stats.tx_bytes += skb->len;
  68
  69         return skb->len;
  70 }
  71
  72 static int mipsnet_xmit(struct sk_buff *skb, struct net_device *dev)
  73 {
  74         pr_debug("%s:%s(): transmitting %d bytes\n",
  75                  dev->name, __FUNCTION__, skb->len);
  76
  77         /* Only one packet at a time. Once TXDONE interrupt is serviced, the
  78          * queue will be restarted.
  79          */
  80         netif_stop_queue(dev);
  81         mipsnet_put_todevice(dev, skb);
  82
  83         return 0;
  84 }
  85
  86 static inline ssize_t mipsnet_get_fromdev(struct net_device *dev, size_t count)
  87 {
  88         struct sk_buff *skb;
  89         size_t len = count;
  90         struct mipsnet_priv *mp = netdev_priv(dev);
  91
  92         if (!(skb = alloc_skb(len + 2, GFP_KERNEL))) {
  93                 mp->stats.rx_dropped++;
  94                 return -ENOMEM;
  95         }
  96
  97         skb_reserve(skb, 2);
  98         if (ioiocpy_frommipsnet(dev, skb_put(skb, len), len))
  99                 return -EFAULT;
 100
 101         skb->protocol = eth_type_trans(skb, dev);
 102         skb->ip_summed = CHECKSUM_UNNECESSARY;
 103
 104         pr_debug("%s:%s(): pushing RXed data to kernel\n",
 105                  dev->name, __FUNCTION__);
 106         netif_rx(skb);
 107
 108         mp->stats.rx_packets++;
 109         mp->stats.rx_bytes += len;
 110
 111         return count;
 112 }
 113
 114 static irqreturn_t mipsnet_interrupt(int irq, void *dev_id)
 115 {
 116         struct net_device *dev = dev_id;
 117
 118         irqreturn_t retval = IRQ_NONE;
 119         uint64_t interruptFlags;
 120
 121         if (irq == dev->irq) {
 122                 pr_debug("%s:%s(): irq %d for device\n",
 123                          dev->name, __FUNCTION__, irq);
 124
 125                 retval = IRQ_HANDLED;
 126
 127                 interruptFlags =
 128                     inl(mipsnet_reg_address(dev, interruptControl));
 129                 pr_debug("%s:%s(): intCtl=0x%016llx\n", dev->name,
 130                          __FUNCTION__, interruptFlags);
 131
 132                 if (interruptFlags & MIPSNET_INTCTL_TXDONE) {
 133                         pr_debug("%s:%s(): got TXDone\n",
 134                                  dev->name, __FUNCTION__);
 135                         outl(MIPSNET_INTCTL_TXDONE,
 136                              mipsnet_reg_address(dev, interruptControl));
 137                         // only one packet at a time, we are done.
 138                         netif_wake_queue(dev);
 139                 } else if (interruptFlags & MIPSNET_INTCTL_RXDONE) {
 140                         pr_debug("%s:%s(): got RX data\n",
 141                                  dev->name, __FUNCTION__);
 142                         mipsnet_get_fromdev(dev,
 143                                     inl(mipsnet_reg_address(dev, rxDataCount)));
 144                         pr_debug("%s:%s(): clearing RX int\n",
 145                                  dev->name, __FUNCTION__);
 146                         outl(MIPSNET_INTCTL_RXDONE,
 147                              mipsnet_reg_address(dev, interruptControl));
 148
 149                 } else if (interruptFlags & MIPSNET_INTCTL_TESTBIT) {
 150                         pr_debug("%s:%s(): got test interrupt\n",
 151                                  dev->name, __FUNCTION__);
 152                         // TESTBIT is cleared on read.
 153                         //    And takes effect after a write with 0
 154                         outl(0, mipsnet_reg_address(dev, interruptControl));
 155                 } else {
 156                         pr_debug("%s:%s(): no valid fags 0x%016llx\n",
 157                                  dev->name, __FUNCTION__, interruptFlags);
 158                         // Maybe shared IRQ, just ignore, no clearing.
 159                         retval = IRQ_NONE;
 160                 }
 161
 162         } else {
 163                 printk(KERN_INFO "%s: %s(): irq %d for unknown device\n",
 164                        dev->name, __FUNCTION__, irq);
 165                 retval = IRQ_NONE;
 166         }
 167         return retval;
 168 }                               //mipsnet_interrupt()
 169
 170 static int mipsnet_open(struct net_device *dev)
 171 {
 172         int err;
 173         pr_debug("%s: mipsnet_open\n", dev->name);
 174
 175         err = request_irq(dev->irq, &mipsnet_interrupt,
 176                           IRQF_SHARED, dev->name, (void *) dev);
 177
 178         if (err) {
 179                 pr_debug("%s: %s(): can't get irq %d\n",
 180                          dev->name, __FUNCTION__, dev->irq);
 181                 release_region(dev->base_addr, MIPSNET_IO_EXTENT);
 182                 return err;
 183         }
 184
 185         pr_debug("%s: %s(): got IO region at 0x%04lx and irq %d for dev.\n",
 186                  dev->name, __FUNCTION__, dev->base_addr, dev->irq);
 187
 188
 189         netif_start_queue(dev);
 190
 191         // test interrupt handler
 192         outl(MIPSNET_INTCTL_TESTBIT,
 193              mipsnet_reg_address(dev, interruptControl));
 194
 195
 196         return 0;
 197 }
 198
 199 static int mipsnet_close(struct net_device *dev)
 200 {
 201         pr_debug("%s: %s()\n", dev->name, __FUNCTION__);
 202         netif_stop_queue(dev);
 203         return 0;
 204 }
 205
 206 static struct net_device_stats *mipsnet_get_stats(struct net_device *dev)
 207 {
 208         struct mipsnet_priv *mp = netdev_priv(dev);
 209
 210         return &mp->stats;
 211 }
 212
 213 static void mipsnet_set_mclist(struct net_device *dev)
 214 {
 215         // we don't do anything
 216         return;
 217 }
 218
 219 static int __init mipsnet_probe(struct device *dev)
 220 {
 221         struct net_device *netdev;
 222         int err;
 223
 224         netdev = alloc_etherdev(sizeof(struct mipsnet_priv));
 225         if (!netdev) {
 226                 err = -ENOMEM;
 227                 goto out;
 228         }
 229
 230         dev_set_drvdata(dev, netdev);
 231
 232         netdev->open                    = mipsnet_open;
 233         netdev->stop                    = mipsnet_close;
 234         netdev->hard_start_xmit         = mipsnet_xmit;
 235         netdev->get_stats               = mipsnet_get_stats;
 236         netdev->set_multicast_list      = mipsnet_set_mclist;
 237
 238         /*
 239          * TODO: probe for these or load them from PARAM
 240          */
 241         netdev->base_addr = 0x4200;
 242         netdev->irq = MIPS_CPU_IRQ_BASE + MIPSCPU_INT_MB0 +
 243                       inl(mipsnet_reg_address(netdev, interruptInfo));
 244
 245         // Get the io region now, get irq on open()
 246         if (!request_region(netdev->base_addr, MIPSNET_IO_EXTENT, "mipsnet")) {
 247                 pr_debug("%s: %s(): IO region {start: 0x%04lux, len: %d} "
 248                          "for dev is not availble.\n", netdev->name,
 249                          __FUNCTION__, netdev->base_addr, MIPSNET_IO_EXTENT);
 250                 err = -EBUSY;
 251                 goto out_free_netdev;
 252         }
 253
 254         /*
 255          * Lacking any better mechanism to allocate a MAC address we use a
 256          * random one ...
 257          */
 258         random_ether_addr(netdev->dev_addr);
 259
 260         err = register_netdev(netdev);
 261         if (err) {
 262                 printk(KERN_ERR "MIPSNet: failed to register netdev.\n");
 263                 goto out_free_region;
 264         }
 265
 266         return 0;
 267
 268 out_free_region:
 269         release_region(netdev->base_addr, MIPSNET_IO_EXTENT);
 270
 271 out_free_netdev:
 272         free_netdev(netdev);
 273
 274 out:
 275         return err;
 276 }
 277
 278 static int __devexit mipsnet_device_remove(struct device *device)
 279 {
 280         struct net_device *dev = dev_get_drvdata(device);
 281
 282         unregister_netdev(dev);
 283         release_region(dev->base_addr, MIPSNET_IO_EXTENT);
 284         free_netdev(dev);
 285         dev_set_drvdata(device, NULL);
 286
 287         return 0;
 288 }
 289
 290 static struct device_driver mipsnet_driver = {
 291         .name   = mipsnet_string,
 292         .bus    = &platform_bus_type,
 293         .probe  = mipsnet_probe,
 294         .remove = __devexit_p(mipsnet_device_remove),
 295 };
 296
 297 static int __init mipsnet_init_module(void)
 298 {
 299         int err;
 300
 301         printk(KERN_INFO "MIPSNet Ethernet driver. Version: %s. "
 302                "(c)2005 MIPS Technologies, Inc.\n", MIPSNET_VERSION);
 303
 304         err = driver_register(&mipsnet_driver);
 305         if (err)
 306                 printk(KERN_ERR "Driver registration failed\n");
 307
 308         return err;
 309 }
 310
 311 static void __exit mipsnet_exit_module(void)
 312 {
 313         pr_debug("MIPSNet Ethernet driver exiting\n");
 314
 315         driver_unregister(&mipsnet_driver);
 316 }
 317
 318 module_init(mipsnet_init_module);
 319 module_exit(mipsnet_exit_module);