drivers/net/ethernet/micrel/ks8851.c

   1 /* drivers/net/ethernet/micrel/ks8851.c
   2  *
   3  * Copyright 2009 Simtec Electronics
   4  *      http://www.simtec.co.uk/
   5  *      Ben Dooks <ben@simtec.co.uk>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  13
  14 #define DEBUG
  15
  16 #include <linux/interrupt.h>
  17 #include <linux/module.h>
  18 #include <linux/kernel.h>
  19 #include <linux/netdevice.h>
  20 #include <linux/etherdevice.h>
  21 #include <linux/ethtool.h>
  22 #include <linux/cache.h>
  23 #include <linux/crc32.h>
  24 #include <linux/mii.h>
  25 #include <linux/eeprom_93cx6.h>
  26 #include <linux/regulator/consumer.h>
  27
  28 #include <linux/spi/spi.h>
  29 #include <linux/gpio.h>
  30 #include <linux/of_gpio.h>
  31
  32 #include "ks8851.h"
  33
  34 /**
  35  * struct ks8851_rxctrl - KS8851 driver rx control
  36  * @mchash: Multicast hash-table data.
  37  * @rxcr1: KS_RXCR1 register setting
  38  * @rxcr2: KS_RXCR2 register setting
  39  *
  40  * Representation of the settings needs to control the receive filtering
  41  * such as the multicast hash-filter and the receive register settings. This
  42  * is used to make the job of working out if the receive settings change and
  43  * then issuing the new settings to the worker that will send the necessary
  44  * commands.
  45  */
  46 struct ks8851_rxctrl {
  47         u16     mchash[4];
  48         u16     rxcr1;
  49         u16     rxcr2;
  50 };
  51
  52 /**
  53  * union ks8851_tx_hdr - tx header data
  54  * @txb: The header as bytes
  55  * @txw: The header as 16bit, little-endian words
  56  *
  57  * A dual representation of the tx header data to allow
  58  * access to individual bytes, and to allow 16bit accesses
  59  * with 16bit alignment.
  60  */
  61 union ks8851_tx_hdr {
  62         u8      txb[6];
  63         __le16  txw[3];
  64 };
  65
  66 /**
  67  * struct ks8851_net - KS8851 driver private data
  68  * @netdev: The network device we're bound to
  69  * @spidev: The spi device we're bound to.
  70  * @lock: Lock to ensure that the device is not accessed when busy.
  71  * @statelock: Lock on this structure for tx list.
  72  * @mii: The MII state information for the mii calls.
  73  * @rxctrl: RX settings for @rxctrl_work.
  74  * @tx_work: Work queue for tx packets
  75  * @rxctrl_work: Work queue for updating RX mode and multicast lists
  76  * @txq: Queue of packets for transmission.
  77  * @spi_msg1: pre-setup SPI transfer with one message, @spi_xfer1.
  78  * @spi_msg2: pre-setup SPI transfer with two messages, @spi_xfer2.
  79  * @txh: Space for generating packet TX header in DMA-able data
  80  * @rxd: Space for receiving SPI data, in DMA-able space.
  81  * @txd: Space for transmitting SPI data, in DMA-able space.
  82  * @msg_enable: The message flags controlling driver output (see ethtool).
  83  * @fid: Incrementing frame id tag.
  84  * @rc_ier: Cached copy of KS_IER.
  85  * @rc_ccr: Cached copy of KS_CCR.
  86  * @rc_rxqcr: Cached copy of KS_RXQCR.
  87  * @eeprom_size: Companion eeprom size in Bytes, 0 if no eeprom
  88  * @eeprom: 93CX6 EEPROM state for accessing on-board EEPROM.
  89  * @vdd_reg:    Optional regulator supplying the chip
  90  * @vdd_io: Optional digital power supply for IO
  91  * @gpio: Optional reset_n gpio
  92  *
  93  * The @lock ensures that the chip is protected when certain operations are
  94  * in progress. When the read or write packet transfer is in progress, most
  95  * of the chip registers are not ccessible until the transfer is finished and
  96  * the DMA has been de-asserted.
  97  *
  98  * The @statelock is used to protect information in the structure which may
  99  * need to be accessed via several sources, such as the network driver layer
 100  * or one of the work queues.
 101  *
 102  * We align the buffers we may use for rx/tx to ensure that if the SPI driver
 103  * wants to DMA map them, it will not have any problems with data the driver
 104  * modifies.
 105  */
 106 struct ks8851_net {
 107         struct net_device       *netdev;
 108         struct spi_device       *spidev;
 109         struct mutex            lock;
 110         spinlock_t              statelock;
 111
 112         union ks8851_tx_hdr     txh ____cacheline_aligned;
 113         u8                      rxd[8];
 114         u8                      txd[8];
 115
 116         u32                     msg_enable ____cacheline_aligned;
 117         u16                     tx_space;
 118         u8                      fid;
 119
 120         u16                     rc_ier;
 121         u16                     rc_rxqcr;
 122         u16                     rc_ccr;
 123         u16                     eeprom_size;
 124
 125         struct mii_if_info      mii;
 126         struct ks8851_rxctrl    rxctrl;
 127
 128         struct work_struct      tx_work;
 129         struct work_struct      rxctrl_work;
 130
 131         struct sk_buff_head     txq;
 132
 133         struct spi_message      spi_msg1;
 134         struct spi_message      spi_msg2;
 135         struct spi_transfer     spi_xfer1;
 136         struct spi_transfer     spi_xfer2[2];
 137
 138         struct eeprom_93cx6     eeprom;
 139         struct regulator        *vdd_reg;
 140         struct regulator        *vdd_io;
 141         int                     gpio;
 142 };
 143
 144 static int msg_enable;
 145
 146 /* shift for byte-enable data */
 147 #define BYTE_EN(_x)     ((_x) << 2)
 148
 149 /* turn register number and byte-enable mask into data for start of packet */
 150 #define MK_OP(_byteen, _reg) (BYTE_EN(_byteen) | (_reg)  << (8+2) | (_reg) >> 6)
 151
 152 /* SPI register read/write calls.
 153  *
 154  * All these calls issue SPI transactions to access the chip's registers. They
 155  * all require that the necessary lock is held to prevent accesses when the
 156  * chip is busy transferring packet data (RX/TX FIFO accesses).
 157  */
 158
 159 /**
 160  * ks8851_wrreg16 - write 16bit register value to chip
 161  * @ks: The chip state
 162  * @reg: The register address
 163  * @val: The value to write
 164  *
 165  * Issue a write to put the value @val into the register specified in @reg.
 166  */
 167 static void ks8851_wrreg16(struct ks8851_net *ks, unsigned reg, unsigned val)
 168 {
 169         struct spi_transfer *xfer = &ks->spi_xfer1;
 170         struct spi_message *msg = &ks->spi_msg1;
 171         __le16 txb[2];
 172         int ret;
 173
 174         txb[0] = cpu_to_le16(MK_OP(reg & 2 ? 0xC : 0x03, reg) | KS_SPIOP_WR);
 175         txb[1] = cpu_to_le16(val);
 176
 177         xfer->tx_buf = txb;
 178         xfer->rx_buf = NULL;
 179         xfer->len = 4;
 180
 181         ret = spi_sync(ks->spidev, msg);
 182         if (ret < 0)
 183                 netdev_err(ks->netdev, "spi_sync() failed\n");
 184 }
 185
 186 /**
 187  * ks8851_wrreg8 - write 8bit register value to chip
 188  * @ks: The chip state
 189  * @reg: The register address
 190  * @val: The value to write
 191  *
 192  * Issue a write to put the value @val into the register specified in @reg.
 193  */
 194 static void ks8851_wrreg8(struct ks8851_net *ks, unsigned reg, unsigned val)
 195 {
 196         struct spi_transfer *xfer = &ks->spi_xfer1;
 197         struct spi_message *msg = &ks->spi_msg1;
 198         __le16 txb[2];
 199         int ret;
 200         int bit;
 201
 202         bit = 1 << (reg & 3);
 203
 204         txb[0] = cpu_to_le16(MK_OP(bit, reg) | KS_SPIOP_WR);
 205         txb[1] = val;
 206
 207         xfer->tx_buf = txb;
 208         xfer->rx_buf = NULL;
 209         xfer->len = 3;
 210
 211         ret = spi_sync(ks->spidev, msg);
 212         if (ret < 0)
 213                 netdev_err(ks->netdev, "spi_sync() failed\n");
 214 }
 215
 216 /**
 217  * ks8851_rx_1msg - select whether to use one or two messages for spi read
 218  * @ks: The device structure
 219  *
 220  * Return whether to generate a single message with a tx and rx buffer
 221  * supplied to spi_sync(), or alternatively send the tx and rx buffers
 222  * as separate messages.
 223  *
 224  * Depending on the hardware in use, a single message may be more efficient
 225  * on interrupts or work done by the driver.
 226  *
 227  * This currently always returns true until we add some per-device data passed
 228  * from the platform code to specify which mode is better.
 229  */
 230 static inline bool ks8851_rx_1msg(struct ks8851_net *ks)
 231 {
 232         return true;
 233 }
 234
 235 /**
 236  * ks8851_rdreg - issue read register command and return the data
 237  * @ks: The device state
 238  * @op: The register address and byte enables in message format.
 239  * @rxb: The RX buffer to return the result into
 240  * @rxl: The length of data expected.
 241  *
 242  * This is the low level read call that issues the necessary spi message(s)
 243  * to read data from the register specified in @op.
 244  */
 245 static void ks8851_rdreg(struct ks8851_net *ks, unsigned op,
 246                          u8 *rxb, unsigned rxl)
 247 {
 248         struct spi_transfer *xfer;
 249         struct spi_message *msg;
 250         __le16 *txb = (__le16 *)ks->txd;
 251         u8 *trx = ks->rxd;
 252         int ret;
 253
 254         txb[0] = cpu_to_le16(op | KS_SPIOP_RD);
 255
 256         if (ks8851_rx_1msg(ks)) {
 257                 msg = &ks->spi_msg1;
 258                 xfer = &ks->spi_xfer1;
 259
 260                 xfer->tx_buf = txb;
 261                 xfer->rx_buf = trx;
 262                 xfer->len = rxl + 2;
 263         } else {
 264                 msg = &ks->spi_msg2;
 265                 xfer = ks->spi_xfer2;
 266
 267                 xfer->tx_buf = txb;
 268                 xfer->rx_buf = NULL;
 269                 xfer->len = 2;
 270
 271                 xfer++;
 272                 xfer->tx_buf = NULL;
 273                 xfer->rx_buf = trx;
 274                 xfer->len = rxl;
 275         }
 276
 277         ret = spi_sync(ks->spidev, msg);
 278         if (ret < 0)
 279                 netdev_err(ks->netdev, "read: spi_sync() failed\n");
 280         else if (ks8851_rx_1msg(ks))
 281                 memcpy(rxb, trx + 2, rxl);
 282         else
 283                 memcpy(rxb, trx, rxl);
 284 }
 285
 286 /**
 287  * ks8851_rdreg8 - read 8 bit register from device
 288  * @ks: The chip information
 289  * @reg: The register address
 290  *
 291  * Read a 8bit register from the chip, returning the result
 292 */
 293 static unsigned ks8851_rdreg8(struct ks8851_net *ks, unsigned reg)
 294 {
 295         u8 rxb[1];
 296
 297         ks8851_rdreg(ks, MK_OP(1 << (reg & 3), reg), rxb, 1);
 298         return rxb[0];
 299 }
 300
 301 /**
 302  * ks8851_rdreg16 - read 16 bit register from device
 303  * @ks: The chip information
 304  * @reg: The register address
 305  *
 306  * Read a 16bit register from the chip, returning the result
 307 */
 308 static unsigned ks8851_rdreg16(struct ks8851_net *ks, unsigned reg)
 309 {
 310         __le16 rx = 0;
 311
 312         ks8851_rdreg(ks, MK_OP(reg & 2 ? 0xC : 0x3, reg), (u8 *)&rx, 2);
 313         return le16_to_cpu(rx);
 314 }
 315
 316 /**
 317  * ks8851_rdreg32 - read 32 bit register from device
 318  * @ks: The chip information
 319  * @reg: The register address
 320  *
 321  * Read a 32bit register from the chip.
 322  *
 323  * Note, this read requires the address be aligned to 4 bytes.
 324 */
 325 static unsigned ks8851_rdreg32(struct ks8851_net *ks, unsigned reg)
 326 {
 327         __le32 rx = 0;
 328
 329         WARN_ON(reg & 3);
 330
 331         ks8851_rdreg(ks, MK_OP(0xf, reg), (u8 *)&rx, 4);
 332         return le32_to_cpu(rx);
 333 }
 334
 335 /**
 336  * ks8851_soft_reset - issue one of the soft reset to the device
 337  * @ks: The device state.
 338  * @op: The bit(s) to set in the GRR
 339  *
 340  * Issue the relevant soft-reset command to the device's GRR register
 341  * specified by @op.
 342  *
 343  * Note, the delays are in there as a caution to ensure that the reset
 344  * has time to take effect and then complete. Since the datasheet does
 345  * not currently specify the exact sequence, we have chosen something
 346  * that seems to work with our device.
 347  */
 348 static void ks8851_soft_reset(struct ks8851_net *ks, unsigned op)
 349 {
 350         ks8851_wrreg16(ks, KS_GRR, op);
 351         mdelay(1);      /* wait a short time to effect reset */
 352         ks8851_wrreg16(ks, KS_GRR, 0);
 353         mdelay(1);      /* wait for condition to clear */
 354 }
 355
 356 /**
 357  * ks8851_set_powermode - set power mode of the device
 358  * @ks: The device state
 359  * @pwrmode: The power mode value to write to KS_PMECR.
 360  *
 361  * Change the power mode of the chip.
 362  */
 363 static void ks8851_set_powermode(struct ks8851_net *ks, unsigned pwrmode)
 364 {
 365         unsigned pmecr;
 366
 367         netif_dbg(ks, hw, ks->netdev, "setting power mode %d\n", pwrmode);
 368
 369         pmecr = ks8851_rdreg16(ks, KS_PMECR);
 370         pmecr &= ~PMECR_PM_MASK;
 371         pmecr |= pwrmode;
 372
 373         ks8851_wrreg16(ks, KS_PMECR, pmecr);
 374 }
 375
 376 /**
 377  * ks8851_write_mac_addr - write mac address to device registers
 378  * @dev: The network device
 379  *
 380  * Update the KS8851 MAC address registers from the address in @dev.
 381  *
 382  * This call assumes that the chip is not running, so there is no need to
 383  * shutdown the RXQ process whilst setting this.
 384 */
 385 static int ks8851_write_mac_addr(struct net_device *dev)
 386 {
 387         struct ks8851_net *ks = netdev_priv(dev);
 388         int i;
 389
 390         mutex_lock(&ks->lock);
 391
 392         /*
 393          * Wake up chip in case it was powered off when stopped; otherwise,
 394          * the first write to the MAC address does not take effect.
 395          */
 396         ks8851_set_powermode(ks, PMECR_PM_NORMAL);
 397         for (i = 0; i < ETH_ALEN; i++)
 398                 ks8851_wrreg8(ks, KS_MAR(i), dev->dev_addr[i]);
 399         if (!netif_running(dev))
 400                 ks8851_set_powermode(ks, PMECR_PM_SOFTDOWN);
 401
 402         mutex_unlock(&ks->lock);
 403
 404         return 0;
 405 }
 406
 407 /**
 408  * ks8851_read_mac_addr - read mac address from device registers
 409  * @dev: The network device
 410  *
 411  * Update our copy of the KS8851 MAC address from the registers of @dev.
 412 */
 413 static void ks8851_read_mac_addr(struct net_device *dev)
 414 {
 415         struct ks8851_net *ks = netdev_priv(dev);
 416         int i;
 417
 418         mutex_lock(&ks->lock);
 419
 420         for (i = 0; i < ETH_ALEN; i++)
 421                 dev->dev_addr[i] = ks8851_rdreg8(ks, KS_MAR(i));
 422
 423         mutex_unlock(&ks->lock);
 424 }
 425
 426 /**
 427  * ks8851_init_mac - initialise the mac address
 428  * @ks: The device structure
 429  *
 430  * Get or create the initial mac address for the device and then set that
 431  * into the station address register. If there is an EEPROM present, then
 432  * we try that. If no valid mac address is found we use eth_random_addr()
 433  * to create a new one.
 434  */
 435 static void ks8851_init_mac(struct ks8851_net *ks)
 436 {
 437         struct net_device *dev = ks->netdev;
 438
 439         /* first, try reading what we've got already */
 440         if (ks->rc_ccr & CCR_EEPROM) {
 441                 ks8851_read_mac_addr(dev);
 442                 if (is_valid_ether_addr(dev->dev_addr))
 443                         return;
 444
 445                 netdev_err(ks->netdev, "invalid mac address read %pM\n",
 446                                 dev->dev_addr);
 447         }
 448
 449         eth_hw_addr_random(dev);
 450         ks8851_write_mac_addr(dev);
 451 }
 452
 453 /**
 454  * ks8851_rdfifo - read data from the receive fifo
 455  * @ks: The device state.
 456  * @buff: The buffer address
 457  * @len: The length of the data to read
 458  *
 459  * Issue an RXQ FIFO read command and read the @len amount of data from
 460  * the FIFO into the buffer specified by @buff.
 461  */
 462 static void ks8851_rdfifo(struct ks8851_net *ks, u8 *buff, unsigned len)
 463 {
 464         struct spi_transfer *xfer = ks->spi_xfer2;
 465         struct spi_message *msg = &ks->spi_msg2;
 466         u8 txb[1];
 467         int ret;
 468
 469         netif_dbg(ks, rx_status, ks->netdev,
 470                   "%s: %d@%p\n", __func__, len, buff);
 471
 472         /* set the operation we're issuing */
 473         txb[0] = KS_SPIOP_RXFIFO;
 474
 475         xfer->tx_buf = txb;
 476         xfer->rx_buf = NULL;
 477         xfer->len = 1;
 478
 479         xfer++;
 480         xfer->rx_buf = buff;
 481         xfer->tx_buf = NULL;
 482         xfer->len = len;
 483
 484         ret = spi_sync(ks->spidev, msg);
 485         if (ret < 0)
 486                 netdev_err(ks->netdev, "%s: spi_sync() failed\n", __func__);
 487 }
 488
 489 /**
 490  * ks8851_dbg_dumpkkt - dump initial packet contents to debug
 491  * @ks: The device state
 492  * @rxpkt: The data for the received packet
 493  *
 494  * Dump the initial data from the packet to dev_dbg().
 495 */
 496 static void ks8851_dbg_dumpkkt(struct ks8851_net *ks, u8 *rxpkt)
 497 {
 498         netdev_dbg(ks->netdev,
 499                    "pkt %02x%02x%02x%02x %02x%02x%02x%02x %02x%02x%02x%02x\n",
 500                    rxpkt[4], rxpkt[5], rxpkt[6], rxpkt[7],
 501                    rxpkt[8], rxpkt[9], rxpkt[10], rxpkt[11],
 502                    rxpkt[12], rxpkt[13], rxpkt[14], rxpkt[15]);
 503 }
 504
 505 /**
 506  * ks8851_rx_pkts - receive packets from the host
 507  * @ks: The device information.
 508  *
 509  * This is called from the IRQ work queue when the system detects that there
 510  * are packets in the receive queue. Find out how many packets there are and
 511  * read them from the FIFO.
 512  */
 513 static void ks8851_rx_pkts(struct ks8851_net *ks)
 514 {
 515         struct sk_buff *skb;
 516         unsigned rxfc;
 517         unsigned rxlen;
 518         unsigned rxstat;
 519         u32 rxh;
 520         u8 *rxpkt;
 521
 522         rxfc = ks8851_rdreg8(ks, KS_RXFC);
 523
 524         netif_dbg(ks, rx_status, ks->netdev,
 525                   "%s: %d packets\n", __func__, rxfc);
 526
 527         /* Currently we're issuing a read per packet, but we could possibly
 528          * improve the code by issuing a single read, getting the receive
 529          * header, allocating the packet and then reading the packet data
 530          * out in one go.
 531          *
 532          * This form of operation would require us to hold the SPI bus'
 533          * chipselect low during the entie transaction to avoid any
 534          * reset to the data stream coming from the chip.
 535          */
 536
 537         for (; rxfc != 0; rxfc--) {
 538                 rxh = ks8851_rdreg32(ks, KS_RXFHSR);
 539                 rxstat = rxh & 0xffff;
 540                 rxlen = (rxh >> 16) & 0xfff;
 541
 542                 netif_dbg(ks, rx_status, ks->netdev,
 543                           "rx: stat 0x%04x, len 0x%04x\n", rxstat, rxlen);
 544
 545                 /* the length of the packet includes the 32bit CRC */
 546
 547                 /* set dma read address */
 548                 ks8851_wrreg16(ks, KS_RXFDPR, RXFDPR_RXFPAI | 0x00);
 549
 550                 /* start the packet dma process, and set auto-dequeue rx */
 551                 ks8851_wrreg16(ks, KS_RXQCR,
 552                                ks->rc_rxqcr | RXQCR_SDA | RXQCR_ADRFE);
 553
 554                 if (rxlen > 4) {
 555                         unsigned int rxalign;
 556
 557                         rxlen -= 4;
 558                         rxalign = ALIGN(rxlen, 4);
 559                         skb = netdev_alloc_skb_ip_align(ks->netdev, rxalign);
 560                         if (skb) {
 561
 562                                 /* 4 bytes of status header + 4 bytes of
 563                                  * garbage: we put them before ethernet
 564                                  * header, so that they are copied,
 565                                  * but ignored.
 566                                  */
 567
 568                                 rxpkt = skb_put(skb, rxlen) - 8;
 569
 570                                 ks8851_rdfifo(ks, rxpkt, rxalign + 8);
 571
 572                                 if (netif_msg_pktdata(ks))
 573                                         ks8851_dbg_dumpkkt(ks, rxpkt);
 574
 575                                 skb->protocol = eth_type_trans(skb, ks->netdev);
 576                                 netif_rx_ni(skb);
 577
 578                                 ks->netdev->stats.rx_packets++;
 579                                 ks->netdev->stats.rx_bytes += rxlen;
 580                         }
 581                 }
 582
 583                 ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr);
 584         }
 585 }
 586
 587 /**
 588  * ks8851_irq - IRQ handler for dealing with interrupt requests
 589  * @irq: IRQ number
 590  * @_ks: cookie
 591  *
 592  * This handler is invoked when the IRQ line asserts to find out what happened.
 593  * As we cannot allow ourselves to sleep in HARDIRQ context, this handler runs
 594  * in thread context.
 595  *
 596  * Read the interrupt status, work out what needs to be done and then clear
 597  * any of the interrupts that are not needed.
 598  */
 599 static irqreturn_t ks8851_irq(int irq, void *_ks)
 600 {
 601         struct ks8851_net *ks = _ks;
 602         unsigned status;
 603         unsigned handled = 0;
 604
 605         mutex_lock(&ks->lock);
 606
 607         status = ks8851_rdreg16(ks, KS_ISR);
 608
 609         netif_dbg(ks, intr, ks->netdev,
 610                   "%s: status 0x%04x\n", __func__, status);
 611
 612         if (status & IRQ_LCI)
 613                 handled |= IRQ_LCI;
 614
 615         if (status & IRQ_LDI) {
 616                 u16 pmecr = ks8851_rdreg16(ks, KS_PMECR);
 617                 pmecr &= ~PMECR_WKEVT_MASK;
 618                 ks8851_wrreg16(ks, KS_PMECR, pmecr | PMECR_WKEVT_LINK);
 619
 620                 handled |= IRQ_LDI;
 621         }
 622
 623         if (status & IRQ_RXPSI)
 624                 handled |= IRQ_RXPSI;
 625
 626         if (status & IRQ_TXI) {
 627                 handled |= IRQ_TXI;
 628
 629                 /* no lock here, tx queue should have been stopped */
 630
 631                 /* update our idea of how much tx space is available to the
 632                  * system */
 633                 ks->tx_space = ks8851_rdreg16(ks, KS_TXMIR);
 634
 635                 netif_dbg(ks, intr, ks->netdev,
 636                           "%s: txspace %d\n", __func__, ks->tx_space);
 637         }
 638
 639         if (status & IRQ_RXI)
 640                 handled |= IRQ_RXI;
 641
 642         if (status & IRQ_SPIBEI) {
 643                 dev_err(&ks->spidev->dev, "%s: spi bus error\n", __func__);
 644                 handled |= IRQ_SPIBEI;
 645         }
 646
 647         ks8851_wrreg16(ks, KS_ISR, handled);
 648
 649         if (status & IRQ_RXI) {
 650                 /* the datasheet says to disable the rx interrupt during
 651                  * packet read-out, however we're masking the interrupt
 652                  * from the device so do not bother masking just the RX
 653                  * from the device. */
 654
 655                 ks8851_rx_pkts(ks);
 656         }
 657
 658         /* if something stopped the rx process, probably due to wanting
 659          * to change the rx settings, then do something about restarting
 660          * it. */
 661         if (status & IRQ_RXPSI) {
 662                 struct ks8851_rxctrl *rxc = &ks->rxctrl;
 663
 664                 /* update the multicast hash table */
 665                 ks8851_wrreg16(ks, KS_MAHTR0, rxc->mchash[0]);
 666                 ks8851_wrreg16(ks, KS_MAHTR1, rxc->mchash[1]);
 667                 ks8851_wrreg16(ks, KS_MAHTR2, rxc->mchash[2]);
 668                 ks8851_wrreg16(ks, KS_MAHTR3, rxc->mchash[3]);
 669
 670                 ks8851_wrreg16(ks, KS_RXCR2, rxc->rxcr2);
 671                 ks8851_wrreg16(ks, KS_RXCR1, rxc->rxcr1);
 672         }
 673
 674         mutex_unlock(&ks->lock);
 675
 676         if (status & IRQ_LCI)
 677                 mii_check_link(&ks->mii);
 678
 679         if (status & IRQ_TXI)
 680                 netif_wake_queue(ks->netdev);
 681
 682         return IRQ_HANDLED;
 683 }
 684
 685 /**
 686  * calc_txlen - calculate size of message to send packet
 687  * @len: Length of data
 688  *
 689  * Returns the size of the TXFIFO message needed to send
 690  * this packet.
 691  */
 692 static inline unsigned calc_txlen(unsigned len)
 693 {
 694         return ALIGN(len + 4, 4);
 695 }
 696
 697 /**
 698  * ks8851_wrpkt - write packet to TX FIFO
 699  * @ks: The device state.
 700  * @txp: The sk_buff to transmit.
 701  * @irq: IRQ on completion of the packet.
 702  *
 703  * Send the @txp to the chip. This means creating the relevant packet header
 704  * specifying the length of the packet and the other information the chip
 705  * needs, such as IRQ on completion. Send the header and the packet data to
 706  * the device.
 707  */
 708 static void ks8851_wrpkt(struct ks8851_net *ks, struct sk_buff *txp, bool irq)
 709 {
 710         struct spi_transfer *xfer = ks->spi_xfer2;
 711         struct spi_message *msg = &ks->spi_msg2;
 712         unsigned fid = 0;
 713         int ret;
 714
 715         netif_dbg(ks, tx_queued, ks->netdev, "%s: skb %p, %d@%p, irq %d\n",
 716                   __func__, txp, txp->len, txp->data, irq);
 717
 718         fid = ks->fid++;
 719         fid &= TXFR_TXFID_MASK;
 720
 721         if (irq)
 722                 fid |= TXFR_TXIC;       /* irq on completion */
 723
 724         /* start header at txb[1] to align txw entries */
 725         ks->txh.txb[1] = KS_SPIOP_TXFIFO;
 726         ks->txh.txw[1] = cpu_to_le16(fid);
 727         ks->txh.txw[2] = cpu_to_le16(txp->len);
 728
 729         xfer->tx_buf = &ks->txh.txb[1];
 730         xfer->rx_buf = NULL;
 731         xfer->len = 5;
 732
 733         xfer++;
 734         xfer->tx_buf = txp->data;
 735         xfer->rx_buf = NULL;
 736         xfer->len = ALIGN(txp->len, 4);
 737
 738         ret = spi_sync(ks->spidev, msg);
 739         if (ret < 0)
 740                 netdev_err(ks->netdev, "%s: spi_sync() failed\n", __func__);
 741 }
 742
 743 /**
 744  * ks8851_done_tx - update and then free skbuff after transmitting
 745  * @ks: The device state
 746  * @txb: The buffer transmitted
 747  */
 748 static void ks8851_done_tx(struct ks8851_net *ks, struct sk_buff *txb)
 749 {
 750         struct net_device *dev = ks->netdev;
 751
 752         dev->stats.tx_bytes += txb->len;
 753         dev->stats.tx_packets++;
 754
 755         dev_kfree_skb(txb);
 756 }
 757
 758 /**
 759  * ks8851_tx_work - process tx packet(s)
 760  * @work: The work strucutre what was scheduled.
 761  *
 762  * This is called when a number of packets have been scheduled for
 763  * transmission and need to be sent to the device.
 764  */
 765 static void ks8851_tx_work(struct work_struct *work)
 766 {
 767         struct ks8851_net *ks = container_of(work, struct ks8851_net, tx_work);
 768         struct sk_buff *txb;
 769         bool last = skb_queue_empty(&ks->txq);
 770
 771         mutex_lock(&ks->lock);
 772
 773         while (!last) {
 774                 txb = skb_dequeue(&ks->txq);
 775                 last = skb_queue_empty(&ks->txq);
 776
 777                 if (txb != NULL) {
 778                         ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr | RXQCR_SDA);
 779                         ks8851_wrpkt(ks, txb, last);
 780                         ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr);
 781                         ks8851_wrreg16(ks, KS_TXQCR, TXQCR_METFE);
 782
 783                         ks8851_done_tx(ks, txb);
 784                 }
 785         }
 786
 787         mutex_unlock(&ks->lock);
 788 }
 789
 790 /**
 791  * ks8851_net_open - open network device
 792  * @dev: The network device being opened.
 793  *
 794  * Called when the network device is marked active, such as a user executing
 795  * 'ifconfig up' on the device.
 796  */
 797 static int ks8851_net_open(struct net_device *dev)
 798 {
 799         struct ks8851_net *ks = netdev_priv(dev);
 800
 801         /* lock the card, even if we may not actually be doing anything
 802          * else at the moment */
 803         mutex_lock(&ks->lock);
 804
 805         netif_dbg(ks, ifup, ks->netdev, "opening\n");
 806
 807         /* bring chip out of any power saving mode it was in */
 808         ks8851_set_powermode(ks, PMECR_PM_NORMAL);
 809
 810         /* issue a soft reset to the RX/TX QMU to put it into a known
 811          * state. */
 812         ks8851_soft_reset(ks, GRR_QMU);
 813
 814         /* setup transmission parameters */
 815
 816         ks8851_wrreg16(ks, KS_TXCR, (TXCR_TXE | /* enable transmit process */
 817                                      TXCR_TXPE | /* pad to min length */
 818                                      TXCR_TXCRC | /* add CRC */
 819                                      TXCR_TXFCE)); /* enable flow control */
 820
 821         /* auto-increment tx data, reset tx pointer */
 822         ks8851_wrreg16(ks, KS_TXFDPR, TXFDPR_TXFPAI);
 823
 824         /* setup receiver control */
 825
 826         ks8851_wrreg16(ks, KS_RXCR1, (RXCR1_RXPAFMA | /*  from mac filter */
 827                                       RXCR1_RXFCE | /* enable flow control */
 828                                       RXCR1_RXBE | /* broadcast enable */
 829                                       RXCR1_RXUE | /* unicast enable */
 830                                       RXCR1_RXE)); /* enable rx block */
 831
 832         /* transfer entire frames out in one go */
 833         ks8851_wrreg16(ks, KS_RXCR2, RXCR2_SRDBL_FRAME);
 834
 835         /* set receive counter timeouts */
 836         ks8851_wrreg16(ks, KS_RXDTTR, 1000); /* 1ms after first frame to IRQ */
 837         ks8851_wrreg16(ks, KS_RXDBCTR, 4096); /* >4Kbytes in buffer to IRQ */
 838         ks8851_wrreg16(ks, KS_RXFCTR, 10);  /* 10 frames to IRQ */
 839
 840         ks->rc_rxqcr = (RXQCR_RXFCTE |  /* IRQ on frame count exceeded */
 841                         RXQCR_RXDBCTE | /* IRQ on byte count exceeded */
 842                         RXQCR_RXDTTE);  /* IRQ on time exceeded */
 843
 844         ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr);
 845
 846         /* clear then enable interrupts */
 847
 848 #define STD_IRQ (IRQ_LCI |      /* Link Change */       \
 849                  IRQ_TXI |      /* TX done */           \
 850                  IRQ_RXI |      /* RX done */           \
 851                  IRQ_SPIBEI |   /* SPI bus error */     \
 852                  IRQ_TXPSI |    /* TX process stop */   \
 853                  IRQ_RXPSI)     /* RX process stop */
 854
 855         ks->rc_ier = STD_IRQ;
 856         ks8851_wrreg16(ks, KS_ISR, STD_IRQ);
 857         ks8851_wrreg16(ks, KS_IER, STD_IRQ);
 858
 859         netif_start_queue(ks->netdev);
 860
 861         netif_dbg(ks, ifup, ks->netdev, "network device up\n");
 862
 863         mutex_unlock(&ks->lock);
 864         return 0;
 865 }
 866
 867 /**
 868  * ks8851_net_stop - close network device
 869  * @dev: The device being closed.
 870  *
 871  * Called to close down a network device which has been active. Cancell any
 872  * work, shutdown the RX and TX process and then place the chip into a low
 873  * power state whilst it is not being used.
 874  */
 875 static int ks8851_net_stop(struct net_device *dev)
 876 {
 877         struct ks8851_net *ks = netdev_priv(dev);
 878
 879         netif_info(ks, ifdown, dev, "shutting down\n");
 880
 881         netif_stop_queue(dev);
 882
 883         mutex_lock(&ks->lock);
 884         /* turn off the IRQs and ack any outstanding */
 885         ks8851_wrreg16(ks, KS_IER, 0x0000);
 886         ks8851_wrreg16(ks, KS_ISR, 0xffff);
 887         mutex_unlock(&ks->lock);
 888
 889         /* stop any outstanding work */
 890         flush_work(&ks->tx_work);
 891         flush_work(&ks->rxctrl_work);
 892
 893         mutex_lock(&ks->lock);
 894         /* shutdown RX process */
 895         ks8851_wrreg16(ks, KS_RXCR1, 0x0000);
 896
 897         /* shutdown TX process */
 898         ks8851_wrreg16(ks, KS_TXCR, 0x0000);
 899
 900         /* set powermode to soft power down to save power */
 901         ks8851_set_powermode(ks, PMECR_PM_SOFTDOWN);
 902         mutex_unlock(&ks->lock);
 903
 904         /* ensure any queued tx buffers are dumped */
 905         while (!skb_queue_empty(&ks->txq)) {
 906                 struct sk_buff *txb = skb_dequeue(&ks->txq);
 907
 908                 netif_dbg(ks, ifdown, ks->netdev,
 909                           "%s: freeing txb %p\n", __func__, txb);
 910
 911                 dev_kfree_skb(txb);
 912         }
 913
 914         return 0;
 915 }
 916
 917 /**
 918  * ks8851_start_xmit - transmit packet
 919  * @skb: The buffer to transmit
 920  * @dev: The device used to transmit the packet.
 921  *
 922  * Called by the network layer to transmit the @skb. Queue the packet for
 923  * the device and schedule the necessary work to transmit the packet when
 924  * it is free.
 925  *
 926  * We do this to firstly avoid sleeping with the network device locked,
 927  * and secondly so we can round up more than one packet to transmit which
 928  * means we can try and avoid generating too many transmit done interrupts.
 929  */
 930 static netdev_tx_t ks8851_start_xmit(struct sk_buff *skb,
 931                                      struct net_device *dev)
 932 {
 933         struct ks8851_net *ks = netdev_priv(dev);
 934         unsigned needed = calc_txlen(skb->len);
 935         netdev_tx_t ret = NETDEV_TX_OK;
 936
 937         netif_dbg(ks, tx_queued, ks->netdev,
 938                   "%s: skb %p, %d@%p\n", __func__, skb, skb->len, skb->data);
 939
 940         spin_lock(&ks->statelock);
 941
 942         if (needed > ks->tx_space) {
 943                 netif_stop_queue(dev);
 944                 ret = NETDEV_TX_BUSY;
 945         } else {
 946                 ks->tx_space -= needed;
 947                 skb_queue_tail(&ks->txq, skb);
 948         }
 949
 950         spin_unlock(&ks->statelock);
 951         schedule_work(&ks->tx_work);
 952
 953         return ret;
 954 }
 955
 956 /**
 957  * ks8851_rxctrl_work - work handler to change rx mode
 958  * @work: The work structure this belongs to.
 959  *
 960  * Lock the device and issue the necessary changes to the receive mode from
 961  * the network device layer. This is done so that we can do this without
 962  * having to sleep whilst holding the network device lock.
 963  *
 964  * Since the recommendation from Micrel is that the RXQ is shutdown whilst the
 965  * receive parameters are programmed, we issue a write to disable the RXQ and
 966  * then wait for the interrupt handler to be triggered once the RXQ shutdown is
 967  * complete. The interrupt handler then writes the new values into the chip.
 968  */
 969 static void ks8851_rxctrl_work(struct work_struct *work)
 970 {
 971         struct ks8851_net *ks = container_of(work, struct ks8851_net, rxctrl_work);
 972
 973         mutex_lock(&ks->lock);
 974
 975         /* need to shutdown RXQ before modifying filter parameters */
 976         ks8851_wrreg16(ks, KS_RXCR1, 0x00);
 977
 978         mutex_unlock(&ks->lock);
 979 }
 980
 981 static void ks8851_set_rx_mode(struct net_device *dev)
 982 {
 983         struct ks8851_net *ks = netdev_priv(dev);
 984         struct ks8851_rxctrl rxctrl;
 985
 986         memset(&rxctrl, 0, sizeof(rxctrl));
 987
 988         if (dev->flags & IFF_PROMISC) {
 989                 /* interface to receive everything */
 990
 991                 rxctrl.rxcr1 = RXCR1_RXAE | RXCR1_RXINVF;
 992         } else if (dev->flags & IFF_ALLMULTI) {
 993                 /* accept all multicast packets */
 994
 995                 rxctrl.rxcr1 = (RXCR1_RXME | RXCR1_RXAE |
 996                                 RXCR1_RXPAFMA | RXCR1_RXMAFMA);
 997         } else if (dev->flags & IFF_MULTICAST && !netdev_mc_empty(dev)) {
 998                 struct netdev_hw_addr *ha;
 999                 u32 crc;
1000
1001                 /* accept some multicast */
1002
1003                 netdev_for_each_mc_addr(ha, dev) {
1004                         crc = ether_crc(ETH_ALEN, ha->addr);
1005                         crc >>= (32 - 6);  /* get top six bits */
1006
1007                         rxctrl.mchash[crc >> 4] |= (1 << (crc & 0xf));
1008                 }
1009
1010                 rxctrl.rxcr1 = RXCR1_RXME | RXCR1_RXPAFMA;
1011         } else {
1012                 /* just accept broadcast / unicast */
1013                 rxctrl.rxcr1 = RXCR1_RXPAFMA;
1014         }
1015
1016         rxctrl.rxcr1 |= (RXCR1_RXUE | /* unicast enable */
1017                          RXCR1_RXBE | /* broadcast enable */
1018                          RXCR1_RXE | /* RX process enable */
1019                          RXCR1_RXFCE); /* enable flow control */
1020
1021         rxctrl.rxcr2 |= RXCR2_SRDBL_FRAME;
1022
1023         /* schedule work to do the actual set of the data if needed */
1024
1025         spin_lock(&ks->statelock);
1026
1027         if (memcmp(&rxctrl, &ks->rxctrl, sizeof(rxctrl)) != 0) {
1028                 memcpy(&ks->rxctrl, &rxctrl, sizeof(ks->rxctrl));
1029                 schedule_work(&ks->rxctrl_work);
1030         }
1031
1032         spin_unlock(&ks->statelock);
1033 }
1034
1035 static int ks8851_set_mac_address(struct net_device *dev, void *addr)
1036 {
1037         struct sockaddr *sa = addr;
1038
1039         if (netif_running(dev))
1040                 return -EBUSY;
1041
1042         if (!is_valid_ether_addr(sa->sa_data))
1043                 return -EADDRNOTAVAIL;
1044
1045         memcpy(dev->dev_addr, sa->sa_data, ETH_ALEN);
1046         return ks8851_write_mac_addr(dev);
1047 }
1048
1049 static int ks8851_net_ioctl(struct net_device *dev, struct ifreq *req, int cmd)
1050 {
1051         struct ks8851_net *ks = netdev_priv(dev);
1052
1053         if (!netif_running(dev))
1054                 return -EINVAL;
1055
1056         return generic_mii_ioctl(&ks->mii, if_mii(req), cmd, NULL);
1057 }
1058
1059 static const struct net_device_ops ks8851_netdev_ops = {
1060         .ndo_open               = ks8851_net_open,
1061         .ndo_stop               = ks8851_net_stop,
1062         .ndo_do_ioctl           = ks8851_net_ioctl,
1063         .ndo_start_xmit         = ks8851_start_xmit,
1064         .ndo_set_mac_address    = ks8851_set_mac_address,
1065         .ndo_set_rx_mode        = ks8851_set_rx_mode,
1066         .ndo_change_mtu         = eth_change_mtu,
1067         .ndo_validate_addr      = eth_validate_addr,
1068 };
1069
1070 /* ethtool support */
1071
1072 static void ks8851_get_drvinfo(struct net_device *dev,
1073                                struct ethtool_drvinfo *di)
1074 {
1075         strlcpy(di->driver, "KS8851", sizeof(di->driver));
1076         strlcpy(di->version, "1.00", sizeof(di->version));
1077         strlcpy(di->bus_info, dev_name(dev->dev.parent), sizeof(di->bus_info));
1078 }
1079
1080 static u32 ks8851_get_msglevel(struct net_device *dev)
1081 {
1082         struct ks8851_net *ks = netdev_priv(dev);
1083         return ks->msg_enable;
1084 }
1085
1086 static void ks8851_set_msglevel(struct net_device *dev, u32 to)
1087 {
1088         struct ks8851_net *ks = netdev_priv(dev);
1089         ks->msg_enable = to;
1090 }
1091
1092 static int ks8851_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1093 {
1094         struct ks8851_net *ks = netdev_priv(dev);
1095         return mii_ethtool_gset(&ks->mii, cmd);
1096 }
1097
1098 static int ks8851_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1099 {
1100         struct ks8851_net *ks = netdev_priv(dev);
1101         return mii_ethtool_sset(&ks->mii, cmd);
1102 }
1103
1104 static u32 ks8851_get_link(struct net_device *dev)
1105 {
1106         struct ks8851_net *ks = netdev_priv(dev);
1107         return mii_link_ok(&ks->mii);
1108 }
1109
1110 static int ks8851_nway_reset(struct net_device *dev)
1111 {
1112         struct ks8851_net *ks = netdev_priv(dev);
1113         return mii_nway_restart(&ks->mii);
1114 }
1115
1116 /* EEPROM support */
1117
1118 static void ks8851_eeprom_regread(struct eeprom_93cx6 *ee)
1119 {
1120         struct ks8851_net *ks = ee->data;
1121         unsigned val;
1122
1123         val = ks8851_rdreg16(ks, KS_EEPCR);
1124
1125         ee->reg_data_out = (val & EEPCR_EESB) ? 1 : 0;
1126         ee->reg_data_clock = (val & EEPCR_EESCK) ? 1 : 0;
1127         ee->reg_chip_select = (val & EEPCR_EECS) ? 1 : 0;
1128 }
1129
1130 static void ks8851_eeprom_regwrite(struct eeprom_93cx6 *ee)
1131 {
1132         struct ks8851_net *ks = ee->data;
1133         unsigned val = EEPCR_EESA;      /* default - eeprom access on */
1134
1135         if (ee->drive_data)
1136                 val |= EEPCR_EESRWA;
1137         if (ee->reg_data_in)
1138                 val |= EEPCR_EEDO;
1139         if (ee->reg_data_clock)
1140                 val |= EEPCR_EESCK;
1141         if (ee->reg_chip_select)
1142                 val |= EEPCR_EECS;
1143
1144         ks8851_wrreg16(ks, KS_EEPCR, val);
1145 }
1146
1147 /**
1148  * ks8851_eeprom_claim - claim device EEPROM and activate the interface
1149  * @ks: The network device state.
1150  *
1151  * Check for the presence of an EEPROM, and then activate software access
1152  * to the device.
1153  */
1154 static int ks8851_eeprom_claim(struct ks8851_net *ks)
1155 {
1156         if (!(ks->rc_ccr & CCR_EEPROM))
1157                 return -ENOENT;
1158
1159         mutex_lock(&ks->lock);
1160
1161         /* start with clock low, cs high */
1162         ks8851_wrreg16(ks, KS_EEPCR, EEPCR_EESA | EEPCR_EECS);
1163         return 0;
1164 }
1165
1166 /**
1167  * ks8851_eeprom_release - release the EEPROM interface
1168  * @ks: The device state
1169  *
1170  * Release the software access to the device EEPROM
1171  */
1172 static void ks8851_eeprom_release(struct ks8851_net *ks)
1173 {
1174         unsigned val = ks8851_rdreg16(ks, KS_EEPCR);
1175
1176         ks8851_wrreg16(ks, KS_EEPCR, val & ~EEPCR_EESA);
1177         mutex_unlock(&ks->lock);
1178 }
1179
1180 #define KS_EEPROM_MAGIC (0x00008851)
1181
1182 static int ks8851_set_eeprom(struct net_device *dev,
1183                              struct ethtool_eeprom *ee, u8 *data)
1184 {
1185         struct ks8851_net *ks = netdev_priv(dev);
1186         int offset = ee->offset;
1187         int len = ee->len;
1188         u16 tmp;
1189
1190         /* currently only support byte writing */
1191         if (len != 1)
1192                 return -EINVAL;
1193
1194         if (ee->magic != KS_EEPROM_MAGIC)
1195                 return -EINVAL;
1196
1197         if (ks8851_eeprom_claim(ks))
1198                 return -ENOENT;
1199
1200         eeprom_93cx6_wren(&ks->eeprom, true);
1201
1202         /* ethtool currently only supports writing bytes, which means
1203          * we have to read/modify/write our 16bit EEPROMs */
1204
1205         eeprom_93cx6_read(&ks->eeprom, offset/2, &tmp);
1206
1207         if (offset & 1) {
1208                 tmp &= 0xff;
1209                 tmp |= *data << 8;
1210         } else {
1211                 tmp &= 0xff00;
1212                 tmp |= *data;
1213         }
1214
1215         eeprom_93cx6_write(&ks->eeprom, offset/2, tmp);
1216         eeprom_93cx6_wren(&ks->eeprom, false);
1217
1218         ks8851_eeprom_release(ks);
1219
1220         return 0;
1221 }
1222
1223 static int ks8851_get_eeprom(struct net_device *dev,
1224                              struct ethtool_eeprom *ee, u8 *data)
1225 {
1226         struct ks8851_net *ks = netdev_priv(dev);
1227         int offset = ee->offset;
1228         int len = ee->len;
1229
1230         /* must be 2 byte aligned */
1231         if (len & 1 || offset & 1)
1232                 return -EINVAL;
1233
1234         if (ks8851_eeprom_claim(ks))
1235                 return -ENOENT;
1236
1237         ee->magic = KS_EEPROM_MAGIC;
1238
1239         eeprom_93cx6_multiread(&ks->eeprom, offset/2, (__le16 *)data, len/2);
1240         ks8851_eeprom_release(ks);
1241
1242         return 0;
1243 }
1244
1245 static int ks8851_get_eeprom_len(struct net_device *dev)
1246 {
1247         struct ks8851_net *ks = netdev_priv(dev);
1248
1249         /* currently, we assume it is an 93C46 attached, so return 128 */
1250         return ks->rc_ccr & CCR_EEPROM ? 128 : 0;
1251 }
1252
1253 static const struct ethtool_ops ks8851_ethtool_ops = {
1254         .get_drvinfo    = ks8851_get_drvinfo,
1255         .get_msglevel   = ks8851_get_msglevel,
1256         .set_msglevel   = ks8851_set_msglevel,
1257         .get_settings   = ks8851_get_settings,
1258         .set_settings   = ks8851_set_settings,
1259         .get_link       = ks8851_get_link,
1260         .nway_reset     = ks8851_nway_reset,
1261         .get_eeprom_len = ks8851_get_eeprom_len,
1262         .get_eeprom     = ks8851_get_eeprom,
1263         .set_eeprom     = ks8851_set_eeprom,
1264 };
1265
1266 /* MII interface controls */
1267
1268 /**
1269  * ks8851_phy_reg - convert MII register into a KS8851 register
1270  * @reg: MII register number.
1271  *
1272  * Return the KS8851 register number for the corresponding MII PHY register
1273  * if possible. Return zero if the MII register has no direct mapping to the
1274  * KS8851 register set.
1275  */
1276 static int ks8851_phy_reg(int reg)
1277 {
1278         switch (reg) {
1279         case MII_BMCR:
1280                 return KS_P1MBCR;
1281         case MII_BMSR:
1282                 return KS_P1MBSR;
1283         case MII_PHYSID1:
1284                 return KS_PHY1ILR;
1285         case MII_PHYSID2:
1286                 return KS_PHY1IHR;
1287         case MII_ADVERTISE:
1288                 return KS_P1ANAR;
1289         case MII_LPA:
1290                 return KS_P1ANLPR;
1291         }
1292
1293         return 0x0;
1294 }
1295
1296 /**
1297  * ks8851_phy_read - MII interface PHY register read.
1298  * @dev: The network device the PHY is on.
1299  * @phy_addr: Address of PHY (ignored as we only have one)
1300  * @reg: The register to read.
1301  *
1302  * This call reads data from the PHY register specified in @reg. Since the
1303  * device does not support all the MII registers, the non-existent values
1304  * are always returned as zero.
1305  *
1306  * We return zero for unsupported registers as the MII code does not check
1307  * the value returned for any error status, and simply returns it to the
1308  * caller. The mii-tool that the driver was tested with takes any -ve error
1309  * as real PHY capabilities, thus displaying incorrect data to the user.
1310  */
1311 static int ks8851_phy_read(struct net_device *dev, int phy_addr, int reg)
1312 {
1313         struct ks8851_net *ks = netdev_priv(dev);
1314         int ksreg;
1315         int result;
1316
1317         ksreg = ks8851_phy_reg(reg);
1318         if (!ksreg)
1319                 return 0x0;     /* no error return allowed, so use zero */
1320
1321         mutex_lock(&ks->lock);
1322         result = ks8851_rdreg16(ks, ksreg);
1323         mutex_unlock(&ks->lock);
1324
1325         return result;
1326 }
1327
1328 static void ks8851_phy_write(struct net_device *dev,
1329                              int phy, int reg, int value)
1330 {
1331         struct ks8851_net *ks = netdev_priv(dev);
1332         int ksreg;
1333
1334         ksreg = ks8851_phy_reg(reg);
1335         if (ksreg) {
1336                 mutex_lock(&ks->lock);
1337                 ks8851_wrreg16(ks, ksreg, value);
1338                 mutex_unlock(&ks->lock);
1339         }
1340 }
1341
1342 /**
1343  * ks8851_read_selftest - read the selftest memory info.
1344  * @ks: The device state
1345  *
1346  * Read and check the TX/RX memory selftest information.
1347  */
1348 static int ks8851_read_selftest(struct ks8851_net *ks)
1349 {
1350         unsigned both_done = MBIR_TXMBF | MBIR_RXMBF;
1351         int ret = 0;
1352         unsigned rd;
1353
1354         rd = ks8851_rdreg16(ks, KS_MBIR);
1355
1356         if ((rd & both_done) != both_done) {
1357                 netdev_warn(ks->netdev, "Memory selftest not finished\n");
1358                 return 0;
1359         }
1360
1361         if (rd & MBIR_TXMBFA) {
1362                 netdev_err(ks->netdev, "TX memory selftest fail\n");
1363                 ret |= 1;
1364         }
1365
1366         if (rd & MBIR_RXMBFA) {
1367                 netdev_err(ks->netdev, "RX memory selftest fail\n");
1368                 ret |= 2;
1369         }
1370
1371         return 0;
1372 }
1373
1374 /* driver bus management functions */
1375
1376 #ifdef CONFIG_PM_SLEEP
1377
1378 static int ks8851_suspend(struct device *dev)
1379 {
1380         struct ks8851_net *ks = dev_get_drvdata(dev);
1381         struct net_device *netdev = ks->netdev;
1382
1383         if (netif_running(netdev)) {
1384                 netif_device_detach(netdev);
1385                 ks8851_net_stop(netdev);
1386         }
1387
1388         return 0;
1389 }
1390
1391 static int ks8851_resume(struct device *dev)
1392 {
1393         struct ks8851_net *ks = dev_get_drvdata(dev);
1394         struct net_device *netdev = ks->netdev;
1395
1396         if (netif_running(netdev)) {
1397                 ks8851_net_open(netdev);
1398                 netif_device_attach(netdev);
1399         }
1400
1401         return 0;
1402 }
1403 #endif
1404
1405 static SIMPLE_DEV_PM_OPS(ks8851_pm_ops, ks8851_suspend, ks8851_resume);
1406
1407 static int ks8851_probe(struct spi_device *spi)
1408 {
1409         struct net_device *ndev;
1410         struct ks8851_net *ks;
1411         int ret;
1412         unsigned cider;
1413         int gpio;
1414
1415         ndev = alloc_etherdev(sizeof(struct ks8851_net));
1416         if (!ndev)
1417                 return -ENOMEM;
1418
1419         spi->bits_per_word = 8;
1420
1421         ks = netdev_priv(ndev);
1422
1423         ks->netdev = ndev;
1424         ks->spidev = spi;
1425         ks->tx_space = 6144;
1426
1427         gpio = of_get_named_gpio_flags(spi->dev.of_node, "reset-gpios",
1428                                        0, NULL);
1429         if (gpio == -EPROBE_DEFER) {
1430                 ret = gpio;
1431                 goto err_gpio;
1432         }
1433
1434         ks->gpio = gpio;
1435         if (gpio_is_valid(gpio)) {
1436                 ret = devm_gpio_request_one(&spi->dev, gpio,
1437                                             GPIOF_OUT_INIT_LOW, "ks8851_rst_n");
1438                 if (ret) {
1439                         dev_err(&spi->dev, "reset gpio request failed\n");
1440                         goto err_gpio;
1441                 }
1442         }
1443
1444         ks->vdd_io = devm_regulator_get(&spi->dev, "vdd-io");
1445         if (IS_ERR(ks->vdd_io)) {
1446                 ret = PTR_ERR(ks->vdd_io);
1447                 goto err_reg_io;
1448         }
1449
1450         ret = regulator_enable(ks->vdd_io);
1451         if (ret) {
1452                 dev_err(&spi->dev, "regulator vdd_io enable fail: %d\n",
1453                         ret);
1454                 goto err_reg_io;
1455         }
1456
1457         ks->vdd_reg = devm_regulator_get(&spi->dev, "vdd");
1458         if (IS_ERR(ks->vdd_reg)) {
1459                 ret = PTR_ERR(ks->vdd_reg);
1460                 goto err_reg;
1461         }
1462
1463         ret = regulator_enable(ks->vdd_reg);
1464         if (ret) {
1465                 dev_err(&spi->dev, "regulator vdd enable fail: %d\n",
1466                         ret);
1467                 goto err_reg;
1468         }
1469
1470         if (gpio_is_valid(gpio)) {
1471                 usleep_range(10000, 11000);
1472                 gpio_set_value(gpio, 1);
1473         }
1474
1475         mutex_init(&ks->lock);
1476         spin_lock_init(&ks->statelock);
1477
1478         INIT_WORK(&ks->tx_work, ks8851_tx_work);
1479         INIT_WORK(&ks->rxctrl_work, ks8851_rxctrl_work);
1480
1481         /* initialise pre-made spi transfer messages */
1482
1483         spi_message_init(&ks->spi_msg1);
1484         spi_message_add_tail(&ks->spi_xfer1, &ks->spi_msg1);
1485
1486         spi_message_init(&ks->spi_msg2);
1487         spi_message_add_tail(&ks->spi_xfer2[0], &ks->spi_msg2);
1488         spi_message_add_tail(&ks->spi_xfer2[1], &ks->spi_msg2);
1489
1490         /* setup EEPROM state */
1491
1492         ks->eeprom.data = ks;
1493         ks->eeprom.width = PCI_EEPROM_WIDTH_93C46;
1494         ks->eeprom.register_read = ks8851_eeprom_regread;
1495         ks->eeprom.register_write = ks8851_eeprom_regwrite;
1496
1497         /* setup mii state */
1498         ks->mii.dev             = ndev;
1499         ks->mii.phy_id          = 1,
1500         ks->mii.phy_id_mask     = 1;
1501         ks->mii.reg_num_mask    = 0xf;
1502         ks->mii.mdio_read       = ks8851_phy_read;
1503         ks->mii.mdio_write      = ks8851_phy_write;
1504
1505         dev_info(&spi->dev, "message enable is %d\n", msg_enable);
1506
1507         /* set the default message enable */
1508         ks->msg_enable = netif_msg_init(msg_enable, (NETIF_MSG_DRV |
1509                                                      NETIF_MSG_PROBE |
1510                                                      NETIF_MSG_LINK));
1511
1512         skb_queue_head_init(&ks->txq);
1513
1514         ndev->ethtool_ops = &ks8851_ethtool_ops;
1515         SET_NETDEV_DEV(ndev, &spi->dev);
1516
1517         spi_set_drvdata(spi, ks);
1518
1519         ndev->if_port = IF_PORT_100BASET;
1520         ndev->netdev_ops = &ks8851_netdev_ops;
1521         ndev->irq = spi->irq;
1522
1523         /* issue a global soft reset to reset the device. */
1524         ks8851_soft_reset(ks, GRR_GSR);
1525
1526         /* simple check for a valid chip being connected to the bus */
1527         cider = ks8851_rdreg16(ks, KS_CIDER);
1528         if ((cider & ~CIDER_REV_MASK) != CIDER_ID) {
1529                 dev_err(&spi->dev, "failed to read device ID\n");
1530                 ret = -ENODEV;
1531                 goto err_id;
1532         }
1533
1534         /* cache the contents of the CCR register for EEPROM, etc. */
1535         ks->rc_ccr = ks8851_rdreg16(ks, KS_CCR);
1536
1537         if (ks->rc_ccr & CCR_EEPROM)
1538                 ks->eeprom_size = 128;
1539         else
1540                 ks->eeprom_size = 0;
1541
1542         ks8851_read_selftest(ks);
1543         ks8851_init_mac(ks);
1544
1545         ret = request_threaded_irq(spi->irq, NULL, ks8851_irq,
1546                                    IRQF_TRIGGER_LOW | IRQF_ONESHOT,
1547                                    ndev->name, ks);
1548         if (ret < 0) {
1549                 dev_err(&spi->dev, "failed to get irq\n");
1550                 goto err_irq;
1551         }
1552
1553         ret = register_netdev(ndev);
1554         if (ret) {
1555                 dev_err(&spi->dev, "failed to register network device\n");
1556                 goto err_netdev;
1557         }
1558
1559         netdev_info(ndev, "revision %d, MAC %pM, IRQ %d, %s EEPROM\n",
1560                     CIDER_REV_GET(cider), ndev->dev_addr, ndev->irq,
1561                     ks->rc_ccr & CCR_EEPROM ? "has" : "no");
1562
1563         return 0;
1564
1565
1566 err_netdev:
1567         free_irq(ndev->irq, ks);
1568
1569 err_irq:
1570         if (gpio_is_valid(gpio))
1571                 gpio_set_value(gpio, 0);
1572 err_id:
1573         regulator_disable(ks->vdd_reg);
1574 err_reg:
1575         regulator_disable(ks->vdd_io);
1576 err_reg_io:
1577 err_gpio:
1578         free_netdev(ndev);
1579         return ret;
1580 }
1581
1582 static int ks8851_remove(struct spi_device *spi)
1583 {
1584         struct ks8851_net *priv = spi_get_drvdata(spi);
1585
1586         if (netif_msg_drv(priv))
1587                 dev_info(&spi->dev, "remove\n");
1588
1589         unregister_netdev(priv->netdev);
1590         free_irq(spi->irq, priv);
1591         if (gpio_is_valid(priv->gpio))
1592                 gpio_set_value(priv->gpio, 0);
1593         regulator_disable(priv->vdd_reg);
1594         regulator_disable(priv->vdd_io);
1595         free_netdev(priv->netdev);
1596
1597         return 0;
1598 }
1599
1600 static const struct of_device_id ks8851_match_table[] = {
1601         { .compatible = "micrel,ks8851" },
1602         { }
1603 };
1604 MODULE_DEVICE_TABLE(of, ks8851_match_table);
1605
1606 static struct spi_driver ks8851_driver = {
1607         .driver = {
1608                 .name = "ks8851",
1609                 .of_match_table = ks8851_match_table,
1610                 .owner = THIS_MODULE,
1611                 .pm = &ks8851_pm_ops,
1612         },
1613         .probe = ks8851_probe,
1614         .remove = ks8851_remove,
1615 };
1616 module_spi_driver(ks8851_driver);
1617
1618 MODULE_DESCRIPTION("KS8851 Network driver");
1619 MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
1620 MODULE_LICENSE("GPL");
1621
1622 module_param_named(message, msg_enable, int, 0);
1623 MODULE_PARM_DESC(message, "Message verbosity level (0=none, 31=all)");
1624 MODULE_ALIAS("spi:ks8851");