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