drivers/net/ethernet/wiznet/w5100.c

   1 /*
   2  * Ethernet driver for the WIZnet W5100 chip.
   3  *
   4  * Copyright (C) 2006-2008 WIZnet Co.,Ltd.
   5  * Copyright (C) 2012 Mike Sinkovsky <msink@permonline.ru>
   6  *
   7  * Licensed under the GPL-2 or later.
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/kconfig.h>
  13 #include <linux/netdevice.h>
  14 #include <linux/etherdevice.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/platform_data/wiznet.h>
  17 #include <linux/ethtool.h>
  18 #include <linux/skbuff.h>
  19 #include <linux/types.h>
  20 #include <linux/errno.h>
  21 #include <linux/delay.h>
  22 #include <linux/slab.h>
  23 #include <linux/spinlock.h>
  24 #include <linux/io.h>
  25 #include <linux/ioport.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/irq.h>
  28 #include <linux/gpio.h>
  29
  30 #include "w5100.h"
  31
  32 #define DRV_NAME        "w5100"
  33 #define DRV_VERSION     "2012-04-04"
  34
  35 MODULE_DESCRIPTION("WIZnet W5100 Ethernet driver v"DRV_VERSION);
  36 MODULE_AUTHOR("Mike Sinkovsky <msink@permonline.ru>");
  37 MODULE_ALIAS("platform:"DRV_NAME);
  38 MODULE_LICENSE("GPL");
  39
  40 /*
  41  * Registers
  42  */
  43 #define W5100_COMMON_REGS       0x0000
  44 #define W5100_MR                0x0000 /* Mode Register */
  45 #define   MR_RST                  0x80 /* S/W reset */
  46 #define   MR_PB                   0x10 /* Ping block */
  47 #define   MR_AI                   0x02 /* Address Auto-Increment */
  48 #define   MR_IND                  0x01 /* Indirect mode */
  49 #define W5100_SHAR              0x0009 /* Source MAC address */
  50 #define W5100_IR                0x0015 /* Interrupt Register */
  51 #define W5100_IMR               0x0016 /* Interrupt Mask Register */
  52 #define   IR_S0                   0x01 /* S0 interrupt */
  53 #define W5100_RTR               0x0017 /* Retry Time-value Register */
  54 #define   RTR_DEFAULT             2000 /* =0x07d0 (2000) */
  55 #define W5100_RMSR              0x001a /* Receive Memory Size */
  56 #define W5100_TMSR              0x001b /* Transmit Memory Size */
  57 #define W5100_COMMON_REGS_LEN   0x0040
  58
  59 #define W5100_S0_REGS           0x0400
  60 #define W5100_S0_MR             0x0400 /* S0 Mode Register */
  61 #define   S0_MR_MACRAW            0x04 /* MAC RAW mode (promiscuous) */
  62 #define   S0_MR_MACRAW_MF         0x44 /* MAC RAW mode (filtered) */
  63 #define W5100_S0_CR             0x0401 /* S0 Command Register */
  64 #define   S0_CR_OPEN              0x01 /* OPEN command */
  65 #define   S0_CR_CLOSE             0x10 /* CLOSE command */
  66 #define   S0_CR_SEND              0x20 /* SEND command */
  67 #define   S0_CR_RECV              0x40 /* RECV command */
  68 #define W5100_S0_IR             0x0402 /* S0 Interrupt Register */
  69 #define   S0_IR_SENDOK            0x10 /* complete sending */
  70 #define   S0_IR_RECV              0x04 /* receiving data */
  71 #define W5100_S0_SR             0x0403 /* S0 Status Register */
  72 #define   S0_SR_MACRAW            0x42 /* mac raw mode */
  73 #define W5100_S0_TX_FSR         0x0420 /* S0 Transmit free memory size */
  74 #define W5100_S0_TX_RD          0x0422 /* S0 Transmit memory read pointer */
  75 #define W5100_S0_TX_WR          0x0424 /* S0 Transmit memory write pointer */
  76 #define W5100_S0_RX_RSR         0x0426 /* S0 Receive free memory size */
  77 #define W5100_S0_RX_RD          0x0428 /* S0 Receive memory read pointer */
  78 #define W5100_S0_REGS_LEN       0x0040
  79
  80 #define W5100_TX_MEM_START      0x4000
  81 #define W5100_TX_MEM_SIZE       0x2000
  82 #define W5100_RX_MEM_START      0x6000
  83 #define W5100_RX_MEM_SIZE       0x2000
  84
  85 /*
  86  * Device driver private data structure
  87  */
  88
  89 struct w5100_priv {
  90         const struct w5100_ops *ops;
  91         int irq;
  92         int link_irq;
  93         int link_gpio;
  94
  95         struct napi_struct napi;
  96         struct net_device *ndev;
  97         bool promisc;
  98         u32 msg_enable;
  99
 100         struct workqueue_struct *xfer_wq;
 101         struct work_struct rx_work;
 102         struct sk_buff *tx_skb;
 103         struct work_struct tx_work;
 104         struct work_struct setrx_work;
 105         struct work_struct restart_work;
 106 };
 107
 108 /************************************************************************
 109  *
 110  *  Lowlevel I/O functions
 111  *
 112  ***********************************************************************/
 113
 114 struct w5100_mmio_priv {
 115         void __iomem *base;
 116         /* Serialize access in indirect address mode */
 117         spinlock_t reg_lock;
 118 };
 119
 120 static inline struct w5100_mmio_priv *w5100_mmio_priv(struct net_device *dev)
 121 {
 122         return w5100_ops_priv(dev);
 123 }
 124
 125 static inline void __iomem *w5100_mmio(struct net_device *ndev)
 126 {
 127         struct w5100_mmio_priv *mmio_priv = w5100_mmio_priv(ndev);
 128
 129         return mmio_priv->base;
 130 }
 131
 132 /*
 133  * In direct address mode host system can directly access W5100 registers
 134  * after mapping to Memory-Mapped I/O space.
 135  *
 136  * 0x8000 bytes are required for memory space.
 137  */
 138 static inline int w5100_read_direct(struct net_device *ndev, u16 addr)
 139 {
 140         return ioread8(w5100_mmio(ndev) + (addr << CONFIG_WIZNET_BUS_SHIFT));
 141 }
 142
 143 static inline int __w5100_write_direct(struct net_device *ndev, u16 addr,
 144                                        u8 data)
 145 {
 146         iowrite8(data, w5100_mmio(ndev) + (addr << CONFIG_WIZNET_BUS_SHIFT));
 147
 148         return 0;
 149 }
 150
 151 static inline int w5100_write_direct(struct net_device *ndev, u16 addr, u8 data)
 152 {
 153         __w5100_write_direct(ndev, addr, data);
 154         mmiowb();
 155
 156         return 0;
 157 }
 158
 159 static int w5100_read16_direct(struct net_device *ndev, u16 addr)
 160 {
 161         u16 data;
 162         data  = w5100_read_direct(ndev, addr) << 8;
 163         data |= w5100_read_direct(ndev, addr + 1);
 164         return data;
 165 }
 166
 167 static int w5100_write16_direct(struct net_device *ndev, u16 addr, u16 data)
 168 {
 169         __w5100_write_direct(ndev, addr, data >> 8);
 170         __w5100_write_direct(ndev, addr + 1, data);
 171         mmiowb();
 172
 173         return 0;
 174 }
 175
 176 static int w5100_readbulk_direct(struct net_device *ndev, u16 addr, u8 *buf,
 177                                  int len)
 178 {
 179         int i;
 180
 181         for (i = 0; i < len; i++, addr++)
 182                 *buf++ = w5100_read_direct(ndev, addr);
 183
 184         return 0;
 185 }
 186
 187 static int w5100_writebulk_direct(struct net_device *ndev, u16 addr,
 188                                   const u8 *buf, int len)
 189 {
 190         int i;
 191
 192         for (i = 0; i < len; i++, addr++)
 193                 __w5100_write_direct(ndev, addr, *buf++);
 194
 195         mmiowb();
 196
 197         return 0;
 198 }
 199
 200 static int w5100_mmio_init(struct net_device *ndev)
 201 {
 202         struct platform_device *pdev = to_platform_device(ndev->dev.parent);
 203         struct w5100_priv *priv = netdev_priv(ndev);
 204         struct w5100_mmio_priv *mmio_priv = w5100_mmio_priv(ndev);
 205         struct resource *mem;
 206
 207         spin_lock_init(&mmio_priv->reg_lock);
 208
 209         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 210         mmio_priv->base = devm_ioremap_resource(&pdev->dev, mem);
 211         if (IS_ERR(mmio_priv->base))
 212                 return PTR_ERR(mmio_priv->base);
 213
 214         netdev_info(ndev, "at 0x%llx irq %d\n", (u64)mem->start, priv->irq);
 215
 216         return 0;
 217 }
 218
 219 static const struct w5100_ops w5100_mmio_direct_ops = {
 220         .read = w5100_read_direct,
 221         .write = w5100_write_direct,
 222         .read16 = w5100_read16_direct,
 223         .write16 = w5100_write16_direct,
 224         .readbulk = w5100_readbulk_direct,
 225         .writebulk = w5100_writebulk_direct,
 226         .init = w5100_mmio_init,
 227 };
 228
 229 /*
 230  * In indirect address mode host system indirectly accesses registers by
 231  * using Indirect Mode Address Register (IDM_AR) and Indirect Mode Data
 232  * Register (IDM_DR), which are directly mapped to Memory-Mapped I/O space.
 233  * Mode Register (MR) is directly accessible.
 234  *
 235  * Only 0x04 bytes are required for memory space.
 236  */
 237 #define W5100_IDM_AR            0x01   /* Indirect Mode Address Register */
 238 #define W5100_IDM_DR            0x03   /* Indirect Mode Data Register */
 239
 240 static int w5100_read_indirect(struct net_device *ndev, u16 addr)
 241 {
 242         struct w5100_mmio_priv *mmio_priv = w5100_mmio_priv(ndev);
 243         unsigned long flags;
 244         u8 data;
 245
 246         spin_lock_irqsave(&mmio_priv->reg_lock, flags);
 247         w5100_write16_direct(ndev, W5100_IDM_AR, addr);
 248         data = w5100_read_direct(ndev, W5100_IDM_DR);
 249         spin_unlock_irqrestore(&mmio_priv->reg_lock, flags);
 250
 251         return data;
 252 }
 253
 254 static int w5100_write_indirect(struct net_device *ndev, u16 addr, u8 data)
 255 {
 256         struct w5100_mmio_priv *mmio_priv = w5100_mmio_priv(ndev);
 257         unsigned long flags;
 258
 259         spin_lock_irqsave(&mmio_priv->reg_lock, flags);
 260         w5100_write16_direct(ndev, W5100_IDM_AR, addr);
 261         w5100_write_direct(ndev, W5100_IDM_DR, data);
 262         spin_unlock_irqrestore(&mmio_priv->reg_lock, flags);
 263
 264         return 0;
 265 }
 266
 267 static int w5100_read16_indirect(struct net_device *ndev, u16 addr)
 268 {
 269         struct w5100_mmio_priv *mmio_priv = w5100_mmio_priv(ndev);
 270         unsigned long flags;
 271         u16 data;
 272
 273         spin_lock_irqsave(&mmio_priv->reg_lock, flags);
 274         w5100_write16_direct(ndev, W5100_IDM_AR, addr);
 275         data  = w5100_read_direct(ndev, W5100_IDM_DR) << 8;
 276         data |= w5100_read_direct(ndev, W5100_IDM_DR);
 277         spin_unlock_irqrestore(&mmio_priv->reg_lock, flags);
 278
 279         return data;
 280 }
 281
 282 static int w5100_write16_indirect(struct net_device *ndev, u16 addr, u16 data)
 283 {
 284         struct w5100_mmio_priv *mmio_priv = w5100_mmio_priv(ndev);
 285         unsigned long flags;
 286
 287         spin_lock_irqsave(&mmio_priv->reg_lock, flags);
 288         w5100_write16_direct(ndev, W5100_IDM_AR, addr);
 289         __w5100_write_direct(ndev, W5100_IDM_DR, data >> 8);
 290         w5100_write_direct(ndev, W5100_IDM_DR, data);
 291         spin_unlock_irqrestore(&mmio_priv->reg_lock, flags);
 292
 293         return 0;
 294 }
 295
 296 static int w5100_readbulk_indirect(struct net_device *ndev, u16 addr, u8 *buf,
 297                                    int len)
 298 {
 299         struct w5100_mmio_priv *mmio_priv = w5100_mmio_priv(ndev);
 300         unsigned long flags;
 301         int i;
 302
 303         spin_lock_irqsave(&mmio_priv->reg_lock, flags);
 304         w5100_write16_direct(ndev, W5100_IDM_AR, addr);
 305
 306         for (i = 0; i < len; i++)
 307                 *buf++ = w5100_read_direct(ndev, W5100_IDM_DR);
 308
 309         mmiowb();
 310         spin_unlock_irqrestore(&mmio_priv->reg_lock, flags);
 311
 312         return 0;
 313 }
 314
 315 static int w5100_writebulk_indirect(struct net_device *ndev, u16 addr,
 316                                     const u8 *buf, int len)
 317 {
 318         struct w5100_mmio_priv *mmio_priv = w5100_mmio_priv(ndev);
 319         unsigned long flags;
 320         int i;
 321
 322         spin_lock_irqsave(&mmio_priv->reg_lock, flags);
 323         w5100_write16_direct(ndev, W5100_IDM_AR, addr);
 324
 325         for (i = 0; i < len; i++)
 326                 __w5100_write_direct(ndev, W5100_IDM_DR, *buf++);
 327
 328         mmiowb();
 329         spin_unlock_irqrestore(&mmio_priv->reg_lock, flags);
 330
 331         return 0;
 332 }
 333
 334 static int w5100_reset_indirect(struct net_device *ndev)
 335 {
 336         w5100_write_direct(ndev, W5100_MR, MR_RST);
 337         mdelay(5);
 338         w5100_write_direct(ndev, W5100_MR, MR_PB | MR_AI | MR_IND);
 339
 340         return 0;
 341 }
 342
 343 static const struct w5100_ops w5100_mmio_indirect_ops = {
 344         .read = w5100_read_indirect,
 345         .write = w5100_write_indirect,
 346         .read16 = w5100_read16_indirect,
 347         .write16 = w5100_write16_indirect,
 348         .readbulk = w5100_readbulk_indirect,
 349         .writebulk = w5100_writebulk_indirect,
 350         .init = w5100_mmio_init,
 351         .reset = w5100_reset_indirect,
 352 };
 353
 354 #if defined(CONFIG_WIZNET_BUS_DIRECT)
 355
 356 static int w5100_read(struct w5100_priv *priv, u16 addr)
 357 {
 358         return w5100_read_direct(priv->ndev, addr);
 359 }
 360
 361 static int w5100_write(struct w5100_priv *priv, u16 addr, u8 data)
 362 {
 363         return w5100_write_direct(priv->ndev, addr, data);
 364 }
 365
 366 static int w5100_read16(struct w5100_priv *priv, u16 addr)
 367 {
 368         return w5100_read16_direct(priv->ndev, addr);
 369 }
 370
 371 static int w5100_write16(struct w5100_priv *priv, u16 addr, u16 data)
 372 {
 373         return w5100_write16_direct(priv->ndev, addr, data);
 374 }
 375
 376 static int w5100_readbulk(struct w5100_priv *priv, u16 addr, u8 *buf, int len)
 377 {
 378         return w5100_readbulk_direct(priv->ndev, addr, buf, len);
 379 }
 380
 381 static int w5100_writebulk(struct w5100_priv *priv, u16 addr, const u8 *buf,
 382                            int len)
 383 {
 384         return w5100_writebulk_direct(priv->ndev, addr, buf, len);
 385 }
 386
 387 #elif defined(CONFIG_WIZNET_BUS_INDIRECT)
 388
 389 static int w5100_read(struct w5100_priv *priv, u16 addr)
 390 {
 391         return w5100_read_indirect(priv->ndev, addr);
 392 }
 393
 394 static int w5100_write(struct w5100_priv *priv, u16 addr, u8 data)
 395 {
 396         return w5100_write_indirect(priv->ndev, addr, data);
 397 }
 398
 399 static int w5100_read16(struct w5100_priv *priv, u16 addr)
 400 {
 401         return w5100_read16_indirect(priv->ndev, addr);
 402 }
 403
 404 static int w5100_write16(struct w5100_priv *priv, u16 addr, u16 data)
 405 {
 406         return w5100_write16_indirect(priv->ndev, addr, data);
 407 }
 408
 409 static int w5100_readbulk(struct w5100_priv *priv, u16 addr, u8 *buf, int len)
 410 {
 411         return w5100_readbulk_indirect(priv->ndev, addr, buf, len);
 412 }
 413
 414 static int w5100_writebulk(struct w5100_priv *priv, u16 addr, const u8 *buf,
 415                            int len)
 416 {
 417         return w5100_writebulk_indirect(priv->ndev, addr, buf, len);
 418 }
 419
 420 #else /* CONFIG_WIZNET_BUS_ANY */
 421
 422 static int w5100_read(struct w5100_priv *priv, u16 addr)
 423 {
 424         return priv->ops->read(priv->ndev, addr);
 425 }
 426
 427 static int w5100_write(struct w5100_priv *priv, u16 addr, u8 data)
 428 {
 429         return priv->ops->write(priv->ndev, addr, data);
 430 }
 431
 432 static int w5100_read16(struct w5100_priv *priv, u16 addr)
 433 {
 434         return priv->ops->read16(priv->ndev, addr);
 435 }
 436
 437 static int w5100_write16(struct w5100_priv *priv, u16 addr, u16 data)
 438 {
 439         return priv->ops->write16(priv->ndev, addr, data);
 440 }
 441
 442 static int w5100_readbulk(struct w5100_priv *priv, u16 addr, u8 *buf, int len)
 443 {
 444         return priv->ops->readbulk(priv->ndev, addr, buf, len);
 445 }
 446
 447 static int w5100_writebulk(struct w5100_priv *priv, u16 addr, const u8 *buf,
 448                            int len)
 449 {
 450         return priv->ops->writebulk(priv->ndev, addr, buf, len);
 451 }
 452
 453 #endif
 454
 455 static int w5100_readbuf(struct w5100_priv *priv, u16 offset, u8 *buf, int len)
 456 {
 457         u16 addr;
 458         int remain = 0;
 459         int ret;
 460
 461         offset %= W5100_RX_MEM_SIZE;
 462         addr = W5100_RX_MEM_START + offset;
 463
 464         if (offset + len > W5100_RX_MEM_SIZE) {
 465                 remain = (offset + len) % W5100_RX_MEM_SIZE;
 466                 len = W5100_RX_MEM_SIZE - offset;
 467         }
 468
 469         ret = w5100_readbulk(priv, addr, buf, len);
 470         if (ret || !remain)
 471                 return ret;
 472
 473         return w5100_readbulk(priv, W5100_RX_MEM_START, buf + len, remain);
 474 }
 475
 476 static int w5100_writebuf(struct w5100_priv *priv, u16 offset, const u8 *buf,
 477                           int len)
 478 {
 479         u16 addr;
 480         int ret;
 481         int remain = 0;
 482
 483         offset %= W5100_TX_MEM_SIZE;
 484         addr = W5100_TX_MEM_START + offset;
 485
 486         if (offset + len > W5100_TX_MEM_SIZE) {
 487                 remain = (offset + len) % W5100_TX_MEM_SIZE;
 488                 len = W5100_TX_MEM_SIZE - offset;
 489         }
 490
 491         ret = w5100_writebulk(priv, addr, buf, len);
 492         if (ret || !remain)
 493                 return ret;
 494
 495         return w5100_writebulk(priv, W5100_TX_MEM_START, buf + len, remain);
 496 }
 497
 498 static int w5100_reset(struct w5100_priv *priv)
 499 {
 500         if (priv->ops->reset)
 501                 return priv->ops->reset(priv->ndev);
 502
 503         w5100_write(priv, W5100_MR, MR_RST);
 504         mdelay(5);
 505         w5100_write(priv, W5100_MR, MR_PB);
 506
 507         return 0;
 508 }
 509
 510 static int w5100_command(struct w5100_priv *priv, u16 cmd)
 511 {
 512         unsigned long timeout;
 513
 514         w5100_write(priv, W5100_S0_CR, cmd);
 515
 516         timeout = jiffies + msecs_to_jiffies(100);
 517
 518         while (w5100_read(priv, W5100_S0_CR) != 0) {
 519                 if (time_after(jiffies, timeout))
 520                         return -EIO;
 521                 cpu_relax();
 522         }
 523
 524         return 0;
 525 }
 526
 527 static void w5100_write_macaddr(struct w5100_priv *priv)
 528 {
 529         struct net_device *ndev = priv->ndev;
 530
 531         w5100_writebulk(priv, W5100_SHAR, ndev->dev_addr, ETH_ALEN);
 532 }
 533
 534 static void w5100_hw_reset(struct w5100_priv *priv)
 535 {
 536         w5100_reset(priv);
 537
 538         w5100_write(priv, W5100_IMR, 0);
 539         w5100_write_macaddr(priv);
 540
 541         /* Configure 16K of internal memory
 542          * as 8K RX buffer and 8K TX buffer
 543          */
 544         w5100_write(priv, W5100_RMSR, 0x03);
 545         w5100_write(priv, W5100_TMSR, 0x03);
 546 }
 547
 548 static void w5100_hw_start(struct w5100_priv *priv)
 549 {
 550         w5100_write(priv, W5100_S0_MR, priv->promisc ?
 551                           S0_MR_MACRAW : S0_MR_MACRAW_MF);
 552         w5100_command(priv, S0_CR_OPEN);
 553         w5100_write(priv, W5100_IMR, IR_S0);
 554 }
 555
 556 static void w5100_hw_close(struct w5100_priv *priv)
 557 {
 558         w5100_write(priv, W5100_IMR, 0);
 559         w5100_command(priv, S0_CR_CLOSE);
 560 }
 561
 562 /***********************************************************************
 563  *
 564  *   Device driver functions / callbacks
 565  *
 566  ***********************************************************************/
 567
 568 static void w5100_get_drvinfo(struct net_device *ndev,
 569                               struct ethtool_drvinfo *info)
 570 {
 571         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
 572         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
 573         strlcpy(info->bus_info, dev_name(ndev->dev.parent),
 574                 sizeof(info->bus_info));
 575 }
 576
 577 static u32 w5100_get_link(struct net_device *ndev)
 578 {
 579         struct w5100_priv *priv = netdev_priv(ndev);
 580
 581         if (gpio_is_valid(priv->link_gpio))
 582                 return !!gpio_get_value(priv->link_gpio);
 583
 584         return 1;
 585 }
 586
 587 static u32 w5100_get_msglevel(struct net_device *ndev)
 588 {
 589         struct w5100_priv *priv = netdev_priv(ndev);
 590
 591         return priv->msg_enable;
 592 }
 593
 594 static void w5100_set_msglevel(struct net_device *ndev, u32 value)
 595 {
 596         struct w5100_priv *priv = netdev_priv(ndev);
 597
 598         priv->msg_enable = value;
 599 }
 600
 601 static int w5100_get_regs_len(struct net_device *ndev)
 602 {
 603         return W5100_COMMON_REGS_LEN + W5100_S0_REGS_LEN;
 604 }
 605
 606 static void w5100_get_regs(struct net_device *ndev,
 607                            struct ethtool_regs *regs, void *buf)
 608 {
 609         struct w5100_priv *priv = netdev_priv(ndev);
 610
 611         regs->version = 1;
 612         w5100_readbulk(priv, W5100_COMMON_REGS, buf, W5100_COMMON_REGS_LEN);
 613         buf += W5100_COMMON_REGS_LEN;
 614         w5100_readbulk(priv, W5100_S0_REGS, buf, W5100_S0_REGS_LEN);
 615 }
 616
 617 static void w5100_restart(struct net_device *ndev)
 618 {
 619         struct w5100_priv *priv = netdev_priv(ndev);
 620
 621         netif_stop_queue(ndev);
 622         w5100_hw_reset(priv);
 623         w5100_hw_start(priv);
 624         ndev->stats.tx_errors++;
 625         ndev->trans_start = jiffies;
 626         netif_wake_queue(ndev);
 627 }
 628
 629 static void w5100_restart_work(struct work_struct *work)
 630 {
 631         struct w5100_priv *priv = container_of(work, struct w5100_priv,
 632                                                restart_work);
 633
 634         w5100_restart(priv->ndev);
 635 }
 636
 637 static void w5100_tx_timeout(struct net_device *ndev)
 638 {
 639         struct w5100_priv *priv = netdev_priv(ndev);
 640
 641         if (priv->ops->may_sleep)
 642                 schedule_work(&priv->restart_work);
 643         else
 644                 w5100_restart(ndev);
 645 }
 646
 647 static void w5100_tx_skb(struct net_device *ndev, struct sk_buff *skb)
 648 {
 649         struct w5100_priv *priv = netdev_priv(ndev);
 650         u16 offset;
 651
 652         offset = w5100_read16(priv, W5100_S0_TX_WR);
 653         w5100_writebuf(priv, offset, skb->data, skb->len);
 654         w5100_write16(priv, W5100_S0_TX_WR, offset + skb->len);
 655         ndev->stats.tx_bytes += skb->len;
 656         ndev->stats.tx_packets++;
 657         dev_kfree_skb(skb);
 658
 659         w5100_command(priv, S0_CR_SEND);
 660 }
 661
 662 static void w5100_tx_work(struct work_struct *work)
 663 {
 664         struct w5100_priv *priv = container_of(work, struct w5100_priv,
 665                                                tx_work);
 666         struct sk_buff *skb = priv->tx_skb;
 667
 668         priv->tx_skb = NULL;
 669
 670         if (WARN_ON(!skb))
 671                 return;
 672         w5100_tx_skb(priv->ndev, skb);
 673 }
 674
 675 static int w5100_start_tx(struct sk_buff *skb, struct net_device *ndev)
 676 {
 677         struct w5100_priv *priv = netdev_priv(ndev);
 678
 679         netif_stop_queue(ndev);
 680
 681         if (priv->ops->may_sleep) {
 682                 WARN_ON(priv->tx_skb);
 683                 priv->tx_skb = skb;
 684                 queue_work(priv->xfer_wq, &priv->tx_work);
 685         } else {
 686                 w5100_tx_skb(ndev, skb);
 687         }
 688
 689         return NETDEV_TX_OK;
 690 }
 691
 692 static struct sk_buff *w5100_rx_skb(struct net_device *ndev)
 693 {
 694         struct w5100_priv *priv = netdev_priv(ndev);
 695         struct sk_buff *skb;
 696         u16 rx_len;
 697         u16 offset;
 698         u8 header[2];
 699         u16 rx_buf_len = w5100_read16(priv, W5100_S0_RX_RSR);
 700
 701         if (rx_buf_len == 0)
 702                 return NULL;
 703
 704         offset = w5100_read16(priv, W5100_S0_RX_RD);
 705         w5100_readbuf(priv, offset, header, 2);
 706         rx_len = get_unaligned_be16(header) - 2;
 707
 708         skb = netdev_alloc_skb_ip_align(ndev, rx_len);
 709         if (unlikely(!skb)) {
 710                 w5100_write16(priv, W5100_S0_RX_RD, offset + rx_buf_len);
 711                 w5100_command(priv, S0_CR_RECV);
 712                 ndev->stats.rx_dropped++;
 713                 return NULL;
 714         }
 715
 716         skb_put(skb, rx_len);
 717         w5100_readbuf(priv, offset + 2, skb->data, rx_len);
 718         w5100_write16(priv, W5100_S0_RX_RD, offset + 2 + rx_len);
 719         w5100_command(priv, S0_CR_RECV);
 720         skb->protocol = eth_type_trans(skb, ndev);
 721
 722         ndev->stats.rx_packets++;
 723         ndev->stats.rx_bytes += rx_len;
 724
 725         return skb;
 726 }
 727
 728 static void w5100_rx_work(struct work_struct *work)
 729 {
 730         struct w5100_priv *priv = container_of(work, struct w5100_priv,
 731                                                rx_work);
 732         struct sk_buff *skb;
 733
 734         while ((skb = w5100_rx_skb(priv->ndev)))
 735                 netif_rx_ni(skb);
 736
 737         w5100_write(priv, W5100_IMR, IR_S0);
 738 }
 739
 740 static int w5100_napi_poll(struct napi_struct *napi, int budget)
 741 {
 742         struct w5100_priv *priv = container_of(napi, struct w5100_priv, napi);
 743         int rx_count;
 744
 745         for (rx_count = 0; rx_count < budget; rx_count++) {
 746                 struct sk_buff *skb = w5100_rx_skb(priv->ndev);
 747
 748                 if (skb)
 749                         netif_receive_skb(skb);
 750                 else
 751                         break;
 752         }
 753
 754         if (rx_count < budget) {
 755                 napi_complete(napi);
 756                 w5100_write(priv, W5100_IMR, IR_S0);
 757         }
 758
 759         return rx_count;
 760 }
 761
 762 static irqreturn_t w5100_interrupt(int irq, void *ndev_instance)
 763 {
 764         struct net_device *ndev = ndev_instance;
 765         struct w5100_priv *priv = netdev_priv(ndev);
 766
 767         int ir = w5100_read(priv, W5100_S0_IR);
 768         if (!ir)
 769                 return IRQ_NONE;
 770         w5100_write(priv, W5100_S0_IR, ir);
 771
 772         if (ir & S0_IR_SENDOK) {
 773                 netif_dbg(priv, tx_done, ndev, "tx done\n");
 774                 netif_wake_queue(ndev);
 775         }
 776
 777         if (ir & S0_IR_RECV) {
 778                 w5100_write(priv, W5100_IMR, 0);
 779
 780                 if (priv->ops->may_sleep)
 781                         queue_work(priv->xfer_wq, &priv->rx_work);
 782                 else if (napi_schedule_prep(&priv->napi))
 783                         __napi_schedule(&priv->napi);
 784         }
 785
 786         return IRQ_HANDLED;
 787 }
 788
 789 static irqreturn_t w5100_detect_link(int irq, void *ndev_instance)
 790 {
 791         struct net_device *ndev = ndev_instance;
 792         struct w5100_priv *priv = netdev_priv(ndev);
 793
 794         if (netif_running(ndev)) {
 795                 if (gpio_get_value(priv->link_gpio) != 0) {
 796                         netif_info(priv, link, ndev, "link is up\n");
 797                         netif_carrier_on(ndev);
 798                 } else {
 799                         netif_info(priv, link, ndev, "link is down\n");
 800                         netif_carrier_off(ndev);
 801                 }
 802         }
 803
 804         return IRQ_HANDLED;
 805 }
 806
 807 static void w5100_setrx_work(struct work_struct *work)
 808 {
 809         struct w5100_priv *priv = container_of(work, struct w5100_priv,
 810                                                setrx_work);
 811
 812         w5100_hw_start(priv);
 813 }
 814
 815 static void w5100_set_rx_mode(struct net_device *ndev)
 816 {
 817         struct w5100_priv *priv = netdev_priv(ndev);
 818         bool set_promisc = (ndev->flags & IFF_PROMISC) != 0;
 819
 820         if (priv->promisc != set_promisc) {
 821                 priv->promisc = set_promisc;
 822
 823                 if (priv->ops->may_sleep)
 824                         schedule_work(&priv->setrx_work);
 825                 else
 826                         w5100_hw_start(priv);
 827         }
 828 }
 829
 830 static int w5100_set_macaddr(struct net_device *ndev, void *addr)
 831 {
 832         struct w5100_priv *priv = netdev_priv(ndev);
 833         struct sockaddr *sock_addr = addr;
 834
 835         if (!is_valid_ether_addr(sock_addr->sa_data))
 836                 return -EADDRNOTAVAIL;
 837         memcpy(ndev->dev_addr, sock_addr->sa_data, ETH_ALEN);
 838         w5100_write_macaddr(priv);
 839         return 0;
 840 }
 841
 842 static int w5100_open(struct net_device *ndev)
 843 {
 844         struct w5100_priv *priv = netdev_priv(ndev);
 845
 846         netif_info(priv, ifup, ndev, "enabling\n");
 847         w5100_hw_start(priv);
 848         napi_enable(&priv->napi);
 849         netif_start_queue(ndev);
 850         if (!gpio_is_valid(priv->link_gpio) ||
 851             gpio_get_value(priv->link_gpio) != 0)
 852                 netif_carrier_on(ndev);
 853         return 0;
 854 }
 855
 856 static int w5100_stop(struct net_device *ndev)
 857 {
 858         struct w5100_priv *priv = netdev_priv(ndev);
 859
 860         netif_info(priv, ifdown, ndev, "shutting down\n");
 861         w5100_hw_close(priv);
 862         netif_carrier_off(ndev);
 863         netif_stop_queue(ndev);
 864         napi_disable(&priv->napi);
 865         return 0;
 866 }
 867
 868 static const struct ethtool_ops w5100_ethtool_ops = {
 869         .get_drvinfo            = w5100_get_drvinfo,
 870         .get_msglevel           = w5100_get_msglevel,
 871         .set_msglevel           = w5100_set_msglevel,
 872         .get_link               = w5100_get_link,
 873         .get_regs_len           = w5100_get_regs_len,
 874         .get_regs               = w5100_get_regs,
 875 };
 876
 877 static const struct net_device_ops w5100_netdev_ops = {
 878         .ndo_open               = w5100_open,
 879         .ndo_stop               = w5100_stop,
 880         .ndo_start_xmit         = w5100_start_tx,
 881         .ndo_tx_timeout         = w5100_tx_timeout,
 882         .ndo_set_rx_mode        = w5100_set_rx_mode,
 883         .ndo_set_mac_address    = w5100_set_macaddr,
 884         .ndo_validate_addr      = eth_validate_addr,
 885         .ndo_change_mtu         = eth_change_mtu,
 886 };
 887
 888 static int w5100_mmio_probe(struct platform_device *pdev)
 889 {
 890         struct wiznet_platform_data *data = dev_get_platdata(&pdev->dev);
 891         u8 *mac_addr = NULL;
 892         struct resource *mem;
 893         const struct w5100_ops *ops;
 894         int irq;
 895
 896         if (data && is_valid_ether_addr(data->mac_addr))
 897                 mac_addr = data->mac_addr;
 898
 899         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 900         if (resource_size(mem) < W5100_BUS_DIRECT_SIZE)
 901                 ops = &w5100_mmio_indirect_ops;
 902         else
 903                 ops = &w5100_mmio_direct_ops;
 904
 905         irq = platform_get_irq(pdev, 0);
 906         if (irq < 0)
 907                 return irq;
 908
 909         return w5100_probe(&pdev->dev, ops, sizeof(struct w5100_mmio_priv),
 910                            mac_addr, irq, data ? data->link_gpio : -EINVAL);
 911 }
 912
 913 static int w5100_mmio_remove(struct platform_device *pdev)
 914 {
 915         return w5100_remove(&pdev->dev);
 916 }
 917
 918 void *w5100_ops_priv(const struct net_device *ndev)
 919 {
 920         return netdev_priv(ndev) +
 921                ALIGN(sizeof(struct w5100_priv), NETDEV_ALIGN);
 922 }
 923 EXPORT_SYMBOL_GPL(w5100_ops_priv);
 924
 925 int w5100_probe(struct device *dev, const struct w5100_ops *ops,
 926                 int sizeof_ops_priv, u8 *mac_addr, int irq, int link_gpio)
 927 {
 928         struct w5100_priv *priv;
 929         struct net_device *ndev;
 930         int err;
 931         size_t alloc_size;
 932
 933         alloc_size = sizeof(*priv);
 934         if (sizeof_ops_priv) {
 935                 alloc_size = ALIGN(alloc_size, NETDEV_ALIGN);
 936                 alloc_size += sizeof_ops_priv;
 937         }
 938         alloc_size += NETDEV_ALIGN - 1;
 939
 940         ndev = alloc_etherdev(alloc_size);
 941         if (!ndev)
 942                 return -ENOMEM;
 943         SET_NETDEV_DEV(ndev, dev);
 944         dev_set_drvdata(dev, ndev);
 945         priv = netdev_priv(ndev);
 946         priv->ndev = ndev;
 947         priv->ops = ops;
 948         priv->irq = irq;
 949         priv->link_gpio = link_gpio;
 950
 951         ndev->netdev_ops = &w5100_netdev_ops;
 952         ndev->ethtool_ops = &w5100_ethtool_ops;
 953         ndev->watchdog_timeo = HZ;
 954         netif_napi_add(ndev, &priv->napi, w5100_napi_poll, 16);
 955
 956         /* This chip doesn't support VLAN packets with normal MTU,
 957          * so disable VLAN for this device.
 958          */
 959         ndev->features |= NETIF_F_VLAN_CHALLENGED;
 960
 961         err = register_netdev(ndev);
 962         if (err < 0)
 963                 goto err_register;
 964
 965         priv->xfer_wq = create_workqueue(netdev_name(ndev));
 966         if (!priv->xfer_wq) {
 967                 err = -ENOMEM;
 968                 goto err_wq;
 969         }
 970
 971         INIT_WORK(&priv->rx_work, w5100_rx_work);
 972         INIT_WORK(&priv->tx_work, w5100_tx_work);
 973         INIT_WORK(&priv->setrx_work, w5100_setrx_work);
 974         INIT_WORK(&priv->restart_work, w5100_restart_work);
 975
 976         if (mac_addr)
 977                 memcpy(ndev->dev_addr, mac_addr, ETH_ALEN);
 978         else
 979                 eth_hw_addr_random(ndev);
 980
 981         if (priv->ops->init) {
 982                 err = priv->ops->init(priv->ndev);
 983                 if (err)
 984                         goto err_hw;
 985         }
 986
 987         w5100_hw_reset(priv);
 988         if (w5100_read16(priv, W5100_RTR) != RTR_DEFAULT) {
 989                 err = -ENODEV;
 990                 goto err_hw;
 991         }
 992
 993         if (ops->may_sleep) {
 994                 err = request_threaded_irq(priv->irq, NULL, w5100_interrupt,
 995                                            IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 996                                            netdev_name(ndev), ndev);
 997         } else {
 998                 err = request_irq(priv->irq, w5100_interrupt,
 999                                   IRQF_TRIGGER_LOW, netdev_name(ndev), ndev);
1000         }
1001         if (err)
1002                 goto err_hw;
1003
1004         if (gpio_is_valid(priv->link_gpio)) {
1005                 char *link_name = devm_kzalloc(dev, 16, GFP_KERNEL);
1006
1007                 if (!link_name) {
1008                         err = -ENOMEM;
1009                         goto err_gpio;
1010                 }
1011                 snprintf(link_name, 16, "%s-link", netdev_name(ndev));
1012                 priv->link_irq = gpio_to_irq(priv->link_gpio);
1013                 if (request_any_context_irq(priv->link_irq, w5100_detect_link,
1014                                             IRQF_TRIGGER_RISING |
1015                                             IRQF_TRIGGER_FALLING,
1016                                             link_name, priv->ndev) < 0)
1017                         priv->link_gpio = -EINVAL;
1018         }
1019
1020         return 0;
1021
1022 err_gpio:
1023         free_irq(priv->irq, ndev);
1024 err_hw:
1025         destroy_workqueue(priv->xfer_wq);
1026 err_wq:
1027         unregister_netdev(ndev);
1028 err_register:
1029         free_netdev(ndev);
1030         return err;
1031 }
1032 EXPORT_SYMBOL_GPL(w5100_probe);
1033
1034 int w5100_remove(struct device *dev)
1035 {
1036         struct net_device *ndev = dev_get_drvdata(dev);
1037         struct w5100_priv *priv = netdev_priv(ndev);
1038
1039         w5100_hw_reset(priv);
1040         free_irq(priv->irq, ndev);
1041         if (gpio_is_valid(priv->link_gpio))
1042                 free_irq(priv->link_irq, ndev);
1043
1044         flush_work(&priv->setrx_work);
1045         flush_work(&priv->restart_work);
1046         flush_workqueue(priv->xfer_wq);
1047         destroy_workqueue(priv->xfer_wq);
1048
1049         unregister_netdev(ndev);
1050         free_netdev(ndev);
1051         return 0;
1052 }
1053 EXPORT_SYMBOL_GPL(w5100_remove);
1054
1055 #ifdef CONFIG_PM_SLEEP
1056 static int w5100_suspend(struct device *dev)
1057 {
1058         struct net_device *ndev = dev_get_drvdata(dev);
1059         struct w5100_priv *priv = netdev_priv(ndev);
1060
1061         if (netif_running(ndev)) {
1062                 netif_carrier_off(ndev);
1063                 netif_device_detach(ndev);
1064
1065                 w5100_hw_close(priv);
1066         }
1067         return 0;
1068 }
1069
1070 static int w5100_resume(struct device *dev)
1071 {
1072         struct net_device *ndev = dev_get_drvdata(dev);
1073         struct w5100_priv *priv = netdev_priv(ndev);
1074
1075         if (netif_running(ndev)) {
1076                 w5100_hw_reset(priv);
1077                 w5100_hw_start(priv);
1078
1079                 netif_device_attach(ndev);
1080                 if (!gpio_is_valid(priv->link_gpio) ||
1081                     gpio_get_value(priv->link_gpio) != 0)
1082                         netif_carrier_on(ndev);
1083         }
1084         return 0;
1085 }
1086 #endif /* CONFIG_PM_SLEEP */
1087
1088 SIMPLE_DEV_PM_OPS(w5100_pm_ops, w5100_suspend, w5100_resume);
1089 EXPORT_SYMBOL_GPL(w5100_pm_ops);
1090
1091 static struct platform_driver w5100_mmio_driver = {
1092         .driver         = {
1093                 .name   = DRV_NAME,
1094                 .pm     = &w5100_pm_ops,
1095         },
1096         .probe          = w5100_mmio_probe,
1097         .remove         = w5100_mmio_remove,
1098 };
1099 module_platform_driver(w5100_mmio_driver);