drivers/net/ethernet/micrel/ks8851_common.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* drivers/net/ethernet/micrel/ks8851.c
   3  *
   4  * Copyright 2009 Simtec Electronics
   5  *      http://www.simtec.co.uk/
   6  *      Ben Dooks <[email protected]>
   7  */
   8
   9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  10
  11 #include <linux/interrupt.h>
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/netdevice.h>
  15 #include <linux/etherdevice.h>
  16 #include <linux/ethtool.h>
  17 #include <linux/cache.h>
  18 #include <linux/crc32.h>
  19 #include <linux/mii.h>
  20 #include <linux/gpio/consumer.h>
  21 #include <linux/regulator/consumer.h>
  22
  23 #include <linux/of_mdio.h>
  24 #include <linux/of_net.h>
  25
  26 #include "ks8851.h"
  27
  28 /**
  29  * ks8851_lock - register access lock
  30  * @ks: The chip state
  31  * @flags: Spinlock flags
  32  *
  33  * Claim chip register access lock
  34  */
  35 static void ks8851_lock(struct ks8851_net *ks, unsigned long *flags)
  36 {
  37         ks->lock(ks, flags);
  38 }
  39
  40 /**
  41  * ks8851_unlock - register access unlock
  42  * @ks: The chip state
  43  * @flags: Spinlock flags
  44  *
  45  * Release chip register access lock
  46  */
  47 static void ks8851_unlock(struct ks8851_net *ks, unsigned long *flags)
  48 {
  49         ks->unlock(ks, flags);
  50 }
  51
  52 /**
  53  * ks8851_wrreg16 - write 16bit register value to chip
  54  * @ks: The chip state
  55  * @reg: The register address
  56  * @val: The value to write
  57  *
  58  * Issue a write to put the value @val into the register specified in @reg.
  59  */
  60 static void ks8851_wrreg16(struct ks8851_net *ks, unsigned int reg,
  61                            unsigned int val)
  62 {
  63         ks->wrreg16(ks, reg, val);
  64 }
  65
  66 /**
  67  * ks8851_rdreg16 - read 16 bit register from device
  68  * @ks: The chip information
  69  * @reg: The register address
  70  *
  71  * Read a 16bit register from the chip, returning the result
  72  */
  73 static unsigned int ks8851_rdreg16(struct ks8851_net *ks,
  74                                    unsigned int reg)
  75 {
  76         return ks->rdreg16(ks, reg);
  77 }
  78
  79 /**
  80  * ks8851_soft_reset - issue one of the soft reset to the device
  81  * @ks: The device state.
  82  * @op: The bit(s) to set in the GRR
  83  *
  84  * Issue the relevant soft-reset command to the device's GRR register
  85  * specified by @op.
  86  *
  87  * Note, the delays are in there as a caution to ensure that the reset
  88  * has time to take effect and then complete. Since the datasheet does
  89  * not currently specify the exact sequence, we have chosen something
  90  * that seems to work with our device.
  91  */
  92 static void ks8851_soft_reset(struct ks8851_net *ks, unsigned op)
  93 {
  94         ks8851_wrreg16(ks, KS_GRR, op);
  95         mdelay(1);      /* wait a short time to effect reset */
  96         ks8851_wrreg16(ks, KS_GRR, 0);
  97         mdelay(1);      /* wait for condition to clear */
  98 }
  99
 100 /**
 101  * ks8851_set_powermode - set power mode of the device
 102  * @ks: The device state
 103  * @pwrmode: The power mode value to write to KS_PMECR.
 104  *
 105  * Change the power mode of the chip.
 106  */
 107 static void ks8851_set_powermode(struct ks8851_net *ks, unsigned pwrmode)
 108 {
 109         unsigned pmecr;
 110
 111         netif_dbg(ks, hw, ks->netdev, "setting power mode %d\n", pwrmode);
 112
 113         pmecr = ks8851_rdreg16(ks, KS_PMECR);
 114         pmecr &= ~PMECR_PM_MASK;
 115         pmecr |= pwrmode;
 116
 117         ks8851_wrreg16(ks, KS_PMECR, pmecr);
 118 }
 119
 120 /**
 121  * ks8851_write_mac_addr - write mac address to device registers
 122  * @dev: The network device
 123  *
 124  * Update the KS8851 MAC address registers from the address in @dev.
 125  *
 126  * This call assumes that the chip is not running, so there is no need to
 127  * shutdown the RXQ process whilst setting this.
 128 */
 129 static int ks8851_write_mac_addr(struct net_device *dev)
 130 {
 131         struct ks8851_net *ks = netdev_priv(dev);
 132         unsigned long flags;
 133         u16 val;
 134         int i;
 135
 136         ks8851_lock(ks, &flags);
 137
 138         /*
 139          * Wake up chip in case it was powered off when stopped; otherwise,
 140          * the first write to the MAC address does not take effect.
 141          */
 142         ks8851_set_powermode(ks, PMECR_PM_NORMAL);
 143
 144         for (i = 0; i < ETH_ALEN; i += 2) {
 145                 val = (dev->dev_addr[i] << 8) | dev->dev_addr[i + 1];
 146                 ks8851_wrreg16(ks, KS_MAR(i), val);
 147         }
 148
 149         if (!netif_running(dev))
 150                 ks8851_set_powermode(ks, PMECR_PM_SOFTDOWN);
 151
 152         ks8851_unlock(ks, &flags);
 153
 154         return 0;
 155 }
 156
 157 /**
 158  * ks8851_read_mac_addr - read mac address from device registers
 159  * @dev: The network device
 160  *
 161  * Update our copy of the KS8851 MAC address from the registers of @dev.
 162 */
 163 static void ks8851_read_mac_addr(struct net_device *dev)
 164 {
 165         struct ks8851_net *ks = netdev_priv(dev);
 166         unsigned long flags;
 167         u8 addr[ETH_ALEN];
 168         u16 reg;
 169         int i;
 170
 171         ks8851_lock(ks, &flags);
 172
 173         for (i = 0; i < ETH_ALEN; i += 2) {
 174                 reg = ks8851_rdreg16(ks, KS_MAR(i));
 175                 addr[i] = reg >> 8;
 176                 addr[i + 1] = reg & 0xff;
 177         }
 178         eth_hw_addr_set(dev, addr);
 179
 180         ks8851_unlock(ks, &flags);
 181 }
 182
 183 /**
 184  * ks8851_init_mac - initialise the mac address
 185  * @ks: The device structure
 186  * @np: The device node pointer
 187  *
 188  * Get or create the initial mac address for the device and then set that
 189  * into the station address register. A mac address supplied in the device
 190  * tree takes precedence. Otherwise, if there is an EEPROM present, then
 191  * we try that. If no valid mac address is found we use eth_random_addr()
 192  * to create a new one.
 193  */
 194 static void ks8851_init_mac(struct ks8851_net *ks, struct device_node *np)
 195 {
 196         struct net_device *dev = ks->netdev;
 197         int ret;
 198
 199         ret = of_get_ethdev_address(np, dev);
 200         if (!ret) {
 201                 ks8851_write_mac_addr(dev);
 202                 return;
 203         }
 204
 205         if (ks->rc_ccr & CCR_EEPROM) {
 206                 ks8851_read_mac_addr(dev);
 207                 if (is_valid_ether_addr(dev->dev_addr))
 208                         return;
 209
 210                 netdev_err(ks->netdev, "invalid mac address read %pM\n",
 211                                 dev->dev_addr);
 212         }
 213
 214         eth_hw_addr_random(dev);
 215         ks8851_write_mac_addr(dev);
 216 }
 217
 218 /**
 219  * ks8851_dbg_dumpkkt - dump initial packet contents to debug
 220  * @ks: The device state
 221  * @rxpkt: The data for the received packet
 222  *
 223  * Dump the initial data from the packet to dev_dbg().
 224  */
 225 static void ks8851_dbg_dumpkkt(struct ks8851_net *ks, u8 *rxpkt)
 226 {
 227         netdev_dbg(ks->netdev,
 228                    "pkt %02x%02x%02x%02x %02x%02x%02x%02x %02x%02x%02x%02x\n",
 229                    rxpkt[4], rxpkt[5], rxpkt[6], rxpkt[7],
 230                    rxpkt[8], rxpkt[9], rxpkt[10], rxpkt[11],
 231                    rxpkt[12], rxpkt[13], rxpkt[14], rxpkt[15]);
 232 }
 233
 234 /**
 235  * ks8851_rx_pkts - receive packets from the host
 236  * @ks: The device information.
 237  * @rxq: Queue of packets received in this function.
 238  *
 239  * This is called from the IRQ work queue when the system detects that there
 240  * are packets in the receive queue. Find out how many packets there are and
 241  * read them from the FIFO.
 242  */
 243 static void ks8851_rx_pkts(struct ks8851_net *ks, struct sk_buff_head *rxq)
 244 {
 245         struct sk_buff *skb;
 246         unsigned rxfc;
 247         unsigned rxlen;
 248         unsigned rxstat;
 249         u8 *rxpkt;
 250
 251         rxfc = (ks8851_rdreg16(ks, KS_RXFCTR) >> 8) & 0xff;
 252
 253         netif_dbg(ks, rx_status, ks->netdev,
 254                   "%s: %d packets\n", __func__, rxfc);
 255
 256         /* Currently we're issuing a read per packet, but we could possibly
 257          * improve the code by issuing a single read, getting the receive
 258          * header, allocating the packet and then reading the packet data
 259          * out in one go.
 260          *
 261          * This form of operation would require us to hold the SPI bus'
 262          * chipselect low during the entie transaction to avoid any
 263          * reset to the data stream coming from the chip.
 264          */
 265
 266         for (; rxfc != 0; rxfc--) {
 267                 rxstat = ks8851_rdreg16(ks, KS_RXFHSR);
 268                 rxlen = ks8851_rdreg16(ks, KS_RXFHBCR) & RXFHBCR_CNT_MASK;
 269
 270                 netif_dbg(ks, rx_status, ks->netdev,
 271                           "rx: stat 0x%04x, len 0x%04x\n", rxstat, rxlen);
 272
 273                 /* the length of the packet includes the 32bit CRC */
 274
 275                 /* set dma read address */
 276                 ks8851_wrreg16(ks, KS_RXFDPR, RXFDPR_RXFPAI | 0x00);
 277
 278                 /* start DMA access */
 279                 ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr | RXQCR_SDA);
 280
 281                 if (rxlen > 4) {
 282                         unsigned int rxalign;
 283
 284                         rxlen -= 4;
 285                         rxalign = ALIGN(rxlen, 4);
 286                         skb = netdev_alloc_skb_ip_align(ks->netdev, rxalign);
 287                         if (skb) {
 288
 289                                 /* 4 bytes of status header + 4 bytes of
 290                                  * garbage: we put them before ethernet
 291                                  * header, so that they are copied,
 292                                  * but ignored.
 293                                  */
 294
 295                                 rxpkt = skb_put(skb, rxlen) - 8;
 296
 297                                 ks->rdfifo(ks, rxpkt, rxalign + 8);
 298
 299                                 if (netif_msg_pktdata(ks))
 300                                         ks8851_dbg_dumpkkt(ks, rxpkt);
 301
 302                                 skb->protocol = eth_type_trans(skb, ks->netdev);
 303                                 __skb_queue_tail(rxq, skb);
 304
 305                                 ks->netdev->stats.rx_packets++;
 306                                 ks->netdev->stats.rx_bytes += rxlen;
 307                         }
 308                 }
 309
 310                 /* end DMA access and dequeue packet */
 311                 ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr | RXQCR_RRXEF);
 312         }
 313 }
 314
 315 /**
 316  * ks8851_irq - IRQ handler for dealing with interrupt requests
 317  * @irq: IRQ number
 318  * @_ks: cookie
 319  *
 320  * This handler is invoked when the IRQ line asserts to find out what happened.
 321  * As we cannot allow ourselves to sleep in HARDIRQ context, this handler runs
 322  * in thread context.
 323  *
 324  * Read the interrupt status, work out what needs to be done and then clear
 325  * any of the interrupts that are not needed.
 326  */
 327 static irqreturn_t ks8851_irq(int irq, void *_ks)
 328 {
 329         struct ks8851_net *ks = _ks;
 330         struct sk_buff_head rxq;
 331         unsigned long flags;
 332         unsigned int status;
 333         struct sk_buff *skb;
 334
 335         ks8851_lock(ks, &flags);
 336
 337         status = ks8851_rdreg16(ks, KS_ISR);
 338         ks8851_wrreg16(ks, KS_ISR, status);
 339
 340         netif_dbg(ks, intr, ks->netdev,
 341                   "%s: status 0x%04x\n", __func__, status);
 342
 343         if (status & IRQ_LDI) {
 344                 u16 pmecr = ks8851_rdreg16(ks, KS_PMECR);
 345                 pmecr &= ~PMECR_WKEVT_MASK;
 346                 ks8851_wrreg16(ks, KS_PMECR, pmecr | PMECR_WKEVT_LINK);
 347         }
 348
 349         if (status & IRQ_TXI) {
 350                 unsigned short tx_space = ks8851_rdreg16(ks, KS_TXMIR);
 351
 352                 netif_dbg(ks, intr, ks->netdev,
 353                           "%s: txspace %d\n", __func__, tx_space);
 354
 355                 spin_lock_bh(&ks->statelock);
 356                 ks->tx_space = tx_space;
 357                 if (netif_queue_stopped(ks->netdev))
 358                         netif_wake_queue(ks->netdev);
 359                 spin_unlock_bh(&ks->statelock);
 360         }
 361
 362         if (status & IRQ_SPIBEI) {
 363                 netdev_err(ks->netdev, "%s: spi bus error\n", __func__);
 364         }
 365
 366         if (status & IRQ_RXI) {
 367                 /* the datasheet says to disable the rx interrupt during
 368                  * packet read-out, however we're masking the interrupt
 369                  * from the device so do not bother masking just the RX
 370                  * from the device. */
 371
 372                 __skb_queue_head_init(&rxq);
 373                 ks8851_rx_pkts(ks, &rxq);
 374         }
 375
 376         /* if something stopped the rx process, probably due to wanting
 377          * to change the rx settings, then do something about restarting
 378          * it. */
 379         if (status & IRQ_RXPSI) {
 380                 struct ks8851_rxctrl *rxc = &ks->rxctrl;
 381
 382                 /* update the multicast hash table */
 383                 ks8851_wrreg16(ks, KS_MAHTR0, rxc->mchash[0]);
 384                 ks8851_wrreg16(ks, KS_MAHTR1, rxc->mchash[1]);
 385                 ks8851_wrreg16(ks, KS_MAHTR2, rxc->mchash[2]);
 386                 ks8851_wrreg16(ks, KS_MAHTR3, rxc->mchash[3]);
 387
 388                 ks8851_wrreg16(ks, KS_RXCR2, rxc->rxcr2);
 389                 ks8851_wrreg16(ks, KS_RXCR1, rxc->rxcr1);
 390         }
 391
 392         ks8851_unlock(ks, &flags);
 393
 394         if (status & IRQ_LCI)
 395                 mii_check_link(&ks->mii);
 396
 397         if (status & IRQ_RXI)
 398                 while ((skb = __skb_dequeue(&rxq)))
 399                         netif_rx(skb);
 400
 401         return IRQ_HANDLED;
 402 }
 403
 404 /**
 405  * ks8851_flush_tx_work - flush outstanding TX work
 406  * @ks: The device state
 407  */
 408 static void ks8851_flush_tx_work(struct ks8851_net *ks)
 409 {
 410         if (ks->flush_tx_work)
 411                 ks->flush_tx_work(ks);
 412 }
 413
 414 /**
 415  * ks8851_net_open - open network device
 416  * @dev: The network device being opened.
 417  *
 418  * Called when the network device is marked active, such as a user executing
 419  * 'ifconfig up' on the device.
 420  */
 421 static int ks8851_net_open(struct net_device *dev)
 422 {
 423         struct ks8851_net *ks = netdev_priv(dev);
 424         unsigned long flags;
 425         int ret;
 426
 427         ret = request_threaded_irq(dev->irq, NULL, ks8851_irq,
 428                                    IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 429                                    dev->name, ks);
 430         if (ret < 0) {
 431                 netdev_err(dev, "failed to get irq\n");
 432                 return ret;
 433         }
 434
 435         /* lock the card, even if we may not actually be doing anything
 436          * else at the moment */
 437         ks8851_lock(ks, &flags);
 438
 439         netif_dbg(ks, ifup, ks->netdev, "opening\n");
 440
 441         /* bring chip out of any power saving mode it was in */
 442         ks8851_set_powermode(ks, PMECR_PM_NORMAL);
 443
 444         /* issue a soft reset to the RX/TX QMU to put it into a known
 445          * state. */
 446         ks8851_soft_reset(ks, GRR_QMU);
 447
 448         /* setup transmission parameters */
 449
 450         ks8851_wrreg16(ks, KS_TXCR, (TXCR_TXE | /* enable transmit process */
 451                                      TXCR_TXPE | /* pad to min length */
 452                                      TXCR_TXCRC | /* add CRC */
 453                                      TXCR_TXFCE)); /* enable flow control */
 454
 455         /* auto-increment tx data, reset tx pointer */
 456         ks8851_wrreg16(ks, KS_TXFDPR, TXFDPR_TXFPAI);
 457
 458         /* setup receiver control */
 459
 460         ks8851_wrreg16(ks, KS_RXCR1, (RXCR1_RXPAFMA | /*  from mac filter */
 461                                       RXCR1_RXFCE | /* enable flow control */
 462                                       RXCR1_RXBE | /* broadcast enable */
 463                                       RXCR1_RXUE | /* unicast enable */
 464                                       RXCR1_RXE)); /* enable rx block */
 465
 466         /* transfer entire frames out in one go */
 467         ks8851_wrreg16(ks, KS_RXCR2, RXCR2_SRDBL_FRAME);
 468
 469         /* set receive counter timeouts */
 470         ks8851_wrreg16(ks, KS_RXDTTR, 1000); /* 1ms after first frame to IRQ */
 471         ks8851_wrreg16(ks, KS_RXDBCTR, 4096); /* >4Kbytes in buffer to IRQ */
 472         ks8851_wrreg16(ks, KS_RXFCTR, 10);  /* 10 frames to IRQ */
 473
 474         ks->rc_rxqcr = (RXQCR_RXFCTE |  /* IRQ on frame count exceeded */
 475                         RXQCR_RXDBCTE | /* IRQ on byte count exceeded */
 476                         RXQCR_RXDTTE);  /* IRQ on time exceeded */
 477
 478         ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr);
 479
 480         /* clear then enable interrupts */
 481         ks8851_wrreg16(ks, KS_ISR, ks->rc_ier);
 482         ks8851_wrreg16(ks, KS_IER, ks->rc_ier);
 483
 484         ks->queued_len = 0;
 485         ks->tx_space = ks8851_rdreg16(ks, KS_TXMIR);
 486         netif_start_queue(ks->netdev);
 487
 488         netif_dbg(ks, ifup, ks->netdev, "network device up\n");
 489
 490         ks8851_unlock(ks, &flags);
 491         mii_check_link(&ks->mii);
 492         return 0;
 493 }
 494
 495 /**
 496  * ks8851_net_stop - close network device
 497  * @dev: The device being closed.
 498  *
 499  * Called to close down a network device which has been active. Cancell any
 500  * work, shutdown the RX and TX process and then place the chip into a low
 501  * power state whilst it is not being used.
 502  */
 503 static int ks8851_net_stop(struct net_device *dev)
 504 {
 505         struct ks8851_net *ks = netdev_priv(dev);
 506         unsigned long flags;
 507
 508         netif_info(ks, ifdown, dev, "shutting down\n");
 509
 510         netif_stop_queue(dev);
 511
 512         ks8851_lock(ks, &flags);
 513         /* turn off the IRQs and ack any outstanding */
 514         ks8851_wrreg16(ks, KS_IER, 0x0000);
 515         ks8851_wrreg16(ks, KS_ISR, 0xffff);
 516         ks8851_unlock(ks, &flags);
 517
 518         /* stop any outstanding work */
 519         ks8851_flush_tx_work(ks);
 520         flush_work(&ks->rxctrl_work);
 521
 522         ks8851_lock(ks, &flags);
 523         /* shutdown RX process */
 524         ks8851_wrreg16(ks, KS_RXCR1, 0x0000);
 525
 526         /* shutdown TX process */
 527         ks8851_wrreg16(ks, KS_TXCR, 0x0000);
 528
 529         /* set powermode to soft power down to save power */
 530         ks8851_set_powermode(ks, PMECR_PM_SOFTDOWN);
 531         ks8851_unlock(ks, &flags);
 532
 533         /* ensure any queued tx buffers are dumped */
 534         while (!skb_queue_empty(&ks->txq)) {
 535                 struct sk_buff *txb = skb_dequeue(&ks->txq);
 536
 537                 netif_dbg(ks, ifdown, ks->netdev,
 538                           "%s: freeing txb %p\n", __func__, txb);
 539
 540                 dev_kfree_skb(txb);
 541         }
 542
 543         free_irq(dev->irq, ks);
 544
 545         return 0;
 546 }
 547
 548 /**
 549  * ks8851_start_xmit - transmit packet
 550  * @skb: The buffer to transmit
 551  * @dev: The device used to transmit the packet.
 552  *
 553  * Called by the network layer to transmit the @skb. Queue the packet for
 554  * the device and schedule the necessary work to transmit the packet when
 555  * it is free.
 556  *
 557  * We do this to firstly avoid sleeping with the network device locked,
 558  * and secondly so we can round up more than one packet to transmit which
 559  * means we can try and avoid generating too many transmit done interrupts.
 560  */
 561 static netdev_tx_t ks8851_start_xmit(struct sk_buff *skb,
 562                                      struct net_device *dev)
 563 {
 564         struct ks8851_net *ks = netdev_priv(dev);
 565
 566         return ks->start_xmit(skb, dev);
 567 }
 568
 569 /**
 570  * ks8851_rxctrl_work - work handler to change rx mode
 571  * @work: The work structure this belongs to.
 572  *
 573  * Lock the device and issue the necessary changes to the receive mode from
 574  * the network device layer. This is done so that we can do this without
 575  * having to sleep whilst holding the network device lock.
 576  *
 577  * Since the recommendation from Micrel is that the RXQ is shutdown whilst the
 578  * receive parameters are programmed, we issue a write to disable the RXQ and
 579  * then wait for the interrupt handler to be triggered once the RXQ shutdown is
 580  * complete. The interrupt handler then writes the new values into the chip.
 581  */
 582 static void ks8851_rxctrl_work(struct work_struct *work)
 583 {
 584         struct ks8851_net *ks = container_of(work, struct ks8851_net, rxctrl_work);
 585         unsigned long flags;
 586
 587         ks8851_lock(ks, &flags);
 588
 589         /* need to shutdown RXQ before modifying filter parameters */
 590         ks8851_wrreg16(ks, KS_RXCR1, 0x00);
 591
 592         ks8851_unlock(ks, &flags);
 593 }
 594
 595 static void ks8851_set_rx_mode(struct net_device *dev)
 596 {
 597         struct ks8851_net *ks = netdev_priv(dev);
 598         struct ks8851_rxctrl rxctrl;
 599
 600         memset(&rxctrl, 0, sizeof(rxctrl));
 601
 602         if (dev->flags & IFF_PROMISC) {
 603                 /* interface to receive everything */
 604
 605                 rxctrl.rxcr1 = RXCR1_RXAE | RXCR1_RXINVF;
 606         } else if (dev->flags & IFF_ALLMULTI) {
 607                 /* accept all multicast packets */
 608
 609                 rxctrl.rxcr1 = (RXCR1_RXME | RXCR1_RXAE |
 610                                 RXCR1_RXPAFMA | RXCR1_RXMAFMA);
 611         } else if (dev->flags & IFF_MULTICAST && !netdev_mc_empty(dev)) {
 612                 struct netdev_hw_addr *ha;
 613                 u32 crc;
 614
 615                 /* accept some multicast */
 616
 617                 netdev_for_each_mc_addr(ha, dev) {
 618                         crc = ether_crc(ETH_ALEN, ha->addr);
 619                         crc >>= (32 - 6);  /* get top six bits */
 620
 621                         rxctrl.mchash[crc >> 4] |= (1 << (crc & 0xf));
 622                 }
 623
 624                 rxctrl.rxcr1 = RXCR1_RXME | RXCR1_RXPAFMA;
 625         } else {
 626                 /* just accept broadcast / unicast */
 627                 rxctrl.rxcr1 = RXCR1_RXPAFMA;
 628         }
 629
 630         rxctrl.rxcr1 |= (RXCR1_RXUE | /* unicast enable */
 631                          RXCR1_RXBE | /* broadcast enable */
 632                          RXCR1_RXE | /* RX process enable */
 633                          RXCR1_RXFCE); /* enable flow control */
 634
 635         rxctrl.rxcr2 |= RXCR2_SRDBL_FRAME;
 636
 637         /* schedule work to do the actual set of the data if needed */
 638
 639         spin_lock_bh(&ks->statelock);
 640
 641         if (memcmp(&rxctrl, &ks->rxctrl, sizeof(rxctrl)) != 0) {
 642                 memcpy(&ks->rxctrl, &rxctrl, sizeof(ks->rxctrl));
 643                 schedule_work(&ks->rxctrl_work);
 644         }
 645
 646         spin_unlock_bh(&ks->statelock);
 647 }
 648
 649 static int ks8851_set_mac_address(struct net_device *dev, void *addr)
 650 {
 651         struct sockaddr *sa = addr;
 652
 653         if (netif_running(dev))
 654                 return -EBUSY;
 655
 656         if (!is_valid_ether_addr(sa->sa_data))
 657                 return -EADDRNOTAVAIL;
 658
 659         eth_hw_addr_set(dev, sa->sa_data);
 660         return ks8851_write_mac_addr(dev);
 661 }
 662
 663 static int ks8851_net_ioctl(struct net_device *dev, struct ifreq *req, int cmd)
 664 {
 665         struct ks8851_net *ks = netdev_priv(dev);
 666
 667         if (!netif_running(dev))
 668                 return -EINVAL;
 669
 670         return generic_mii_ioctl(&ks->mii, if_mii(req), cmd, NULL);
 671 }
 672
 673 static const struct net_device_ops ks8851_netdev_ops = {
 674         .ndo_open               = ks8851_net_open,
 675         .ndo_stop               = ks8851_net_stop,
 676         .ndo_eth_ioctl          = ks8851_net_ioctl,
 677         .ndo_start_xmit         = ks8851_start_xmit,
 678         .ndo_set_mac_address    = ks8851_set_mac_address,
 679         .ndo_set_rx_mode        = ks8851_set_rx_mode,
 680         .ndo_validate_addr      = eth_validate_addr,
 681 };
 682
 683 /* ethtool support */
 684
 685 static void ks8851_get_drvinfo(struct net_device *dev,
 686                                struct ethtool_drvinfo *di)
 687 {
 688         strscpy(di->driver, "KS8851", sizeof(di->driver));
 689         strscpy(di->version, "1.00", sizeof(di->version));
 690         strscpy(di->bus_info, dev_name(dev->dev.parent), sizeof(di->bus_info));
 691 }
 692
 693 static u32 ks8851_get_msglevel(struct net_device *dev)
 694 {
 695         struct ks8851_net *ks = netdev_priv(dev);
 696         return ks->msg_enable;
 697 }
 698
 699 static void ks8851_set_msglevel(struct net_device *dev, u32 to)
 700 {
 701         struct ks8851_net *ks = netdev_priv(dev);
 702         ks->msg_enable = to;
 703 }
 704
 705 static int ks8851_get_link_ksettings(struct net_device *dev,
 706                                      struct ethtool_link_ksettings *cmd)
 707 {
 708         struct ks8851_net *ks = netdev_priv(dev);
 709
 710         mii_ethtool_get_link_ksettings(&ks->mii, cmd);
 711
 712         return 0;
 713 }
 714
 715 static int ks8851_set_link_ksettings(struct net_device *dev,
 716                                      const struct ethtool_link_ksettings *cmd)
 717 {
 718         struct ks8851_net *ks = netdev_priv(dev);
 719         return mii_ethtool_set_link_ksettings(&ks->mii, cmd);
 720 }
 721
 722 static u32 ks8851_get_link(struct net_device *dev)
 723 {
 724         struct ks8851_net *ks = netdev_priv(dev);
 725         return mii_link_ok(&ks->mii);
 726 }
 727
 728 static int ks8851_nway_reset(struct net_device *dev)
 729 {
 730         struct ks8851_net *ks = netdev_priv(dev);
 731         return mii_nway_restart(&ks->mii);
 732 }
 733
 734 /* EEPROM support */
 735
 736 static void ks8851_eeprom_regread(struct eeprom_93cx6 *ee)
 737 {
 738         struct ks8851_net *ks = ee->data;
 739         unsigned val;
 740
 741         val = ks8851_rdreg16(ks, KS_EEPCR);
 742
 743         ee->reg_data_out = (val & EEPCR_EESB) ? 1 : 0;
 744         ee->reg_data_clock = (val & EEPCR_EESCK) ? 1 : 0;
 745         ee->reg_chip_select = (val & EEPCR_EECS) ? 1 : 0;
 746 }
 747
 748 static void ks8851_eeprom_regwrite(struct eeprom_93cx6 *ee)
 749 {
 750         struct ks8851_net *ks = ee->data;
 751         unsigned val = EEPCR_EESA;      /* default - eeprom access on */
 752
 753         if (ee->drive_data)
 754                 val |= EEPCR_EESRWA;
 755         if (ee->reg_data_in)
 756                 val |= EEPCR_EEDO;
 757         if (ee->reg_data_clock)
 758                 val |= EEPCR_EESCK;
 759         if (ee->reg_chip_select)
 760                 val |= EEPCR_EECS;
 761
 762         ks8851_wrreg16(ks, KS_EEPCR, val);
 763 }
 764
 765 /**
 766  * ks8851_eeprom_claim - claim device EEPROM and activate the interface
 767  * @ks: The network device state.
 768  *
 769  * Check for the presence of an EEPROM, and then activate software access
 770  * to the device.
 771  */
 772 static int ks8851_eeprom_claim(struct ks8851_net *ks)
 773 {
 774         /* start with clock low, cs high */
 775         ks8851_wrreg16(ks, KS_EEPCR, EEPCR_EESA | EEPCR_EECS);
 776         return 0;
 777 }
 778
 779 /**
 780  * ks8851_eeprom_release - release the EEPROM interface
 781  * @ks: The device state
 782  *
 783  * Release the software access to the device EEPROM
 784  */
 785 static void ks8851_eeprom_release(struct ks8851_net *ks)
 786 {
 787         unsigned val = ks8851_rdreg16(ks, KS_EEPCR);
 788
 789         ks8851_wrreg16(ks, KS_EEPCR, val & ~EEPCR_EESA);
 790 }
 791
 792 #define KS_EEPROM_MAGIC (0x00008851)
 793
 794 static int ks8851_set_eeprom(struct net_device *dev,
 795                              struct ethtool_eeprom *ee, u8 *data)
 796 {
 797         struct ks8851_net *ks = netdev_priv(dev);
 798         int offset = ee->offset;
 799         unsigned long flags;
 800         int len = ee->len;
 801         u16 tmp;
 802
 803         /* currently only support byte writing */
 804         if (len != 1)
 805                 return -EINVAL;
 806
 807         if (ee->magic != KS_EEPROM_MAGIC)
 808                 return -EINVAL;
 809
 810         if (!(ks->rc_ccr & CCR_EEPROM))
 811                 return -ENOENT;
 812
 813         ks8851_lock(ks, &flags);
 814
 815         ks8851_eeprom_claim(ks);
 816
 817         eeprom_93cx6_wren(&ks->eeprom, true);
 818
 819         /* ethtool currently only supports writing bytes, which means
 820          * we have to read/modify/write our 16bit EEPROMs */
 821
 822         eeprom_93cx6_read(&ks->eeprom, offset/2, &tmp);
 823
 824         if (offset & 1) {
 825                 tmp &= 0xff;
 826                 tmp |= *data << 8;
 827         } else {
 828                 tmp &= 0xff00;
 829                 tmp |= *data;
 830         }
 831
 832         eeprom_93cx6_write(&ks->eeprom, offset/2, tmp);
 833         eeprom_93cx6_wren(&ks->eeprom, false);
 834
 835         ks8851_eeprom_release(ks);
 836         ks8851_unlock(ks, &flags);
 837
 838         return 0;
 839 }
 840
 841 static int ks8851_get_eeprom(struct net_device *dev,
 842                              struct ethtool_eeprom *ee, u8 *data)
 843 {
 844         struct ks8851_net *ks = netdev_priv(dev);
 845         int offset = ee->offset;
 846         unsigned long flags;
 847         int len = ee->len;
 848
 849         /* must be 2 byte aligned */
 850         if (len & 1 || offset & 1)
 851                 return -EINVAL;
 852
 853         if (!(ks->rc_ccr & CCR_EEPROM))
 854                 return -ENOENT;
 855
 856         ks8851_lock(ks, &flags);
 857
 858         ks8851_eeprom_claim(ks);
 859
 860         ee->magic = KS_EEPROM_MAGIC;
 861
 862         eeprom_93cx6_multiread(&ks->eeprom, offset/2, (__le16 *)data, len/2);
 863         ks8851_eeprom_release(ks);
 864         ks8851_unlock(ks, &flags);
 865
 866         return 0;
 867 }
 868
 869 static int ks8851_get_eeprom_len(struct net_device *dev)
 870 {
 871         struct ks8851_net *ks = netdev_priv(dev);
 872
 873         /* currently, we assume it is an 93C46 attached, so return 128 */
 874         return ks->rc_ccr & CCR_EEPROM ? 128 : 0;
 875 }
 876
 877 static const struct ethtool_ops ks8851_ethtool_ops = {
 878         .get_drvinfo    = ks8851_get_drvinfo,
 879         .get_msglevel   = ks8851_get_msglevel,
 880         .set_msglevel   = ks8851_set_msglevel,
 881         .get_link       = ks8851_get_link,
 882         .nway_reset     = ks8851_nway_reset,
 883         .get_eeprom_len = ks8851_get_eeprom_len,
 884         .get_eeprom     = ks8851_get_eeprom,
 885         .set_eeprom     = ks8851_set_eeprom,
 886         .get_link_ksettings = ks8851_get_link_ksettings,
 887         .set_link_ksettings = ks8851_set_link_ksettings,
 888 };
 889
 890 /* MII interface controls */
 891
 892 /**
 893  * ks8851_phy_reg - convert MII register into a KS8851 register
 894  * @reg: MII register number.
 895  *
 896  * Return the KS8851 register number for the corresponding MII PHY register
 897  * if possible. Return zero if the MII register has no direct mapping to the
 898  * KS8851 register set.
 899  */
 900 static int ks8851_phy_reg(int reg)
 901 {
 902         switch (reg) {
 903         case MII_BMCR:
 904                 return KS_P1MBCR;
 905         case MII_BMSR:
 906                 return KS_P1MBSR;
 907         case MII_PHYSID1:
 908                 return KS_PHY1ILR;
 909         case MII_PHYSID2:
 910                 return KS_PHY1IHR;
 911         case MII_ADVERTISE:
 912                 return KS_P1ANAR;
 913         case MII_LPA:
 914                 return KS_P1ANLPR;
 915         }
 916
 917         return -EOPNOTSUPP;
 918 }
 919
 920 static int ks8851_phy_read_common(struct net_device *dev, int phy_addr, int reg)
 921 {
 922         struct ks8851_net *ks = netdev_priv(dev);
 923         unsigned long flags;
 924         int result;
 925         int ksreg;
 926
 927         ksreg = ks8851_phy_reg(reg);
 928         if (ksreg < 0)
 929                 return ksreg;
 930
 931         ks8851_lock(ks, &flags);
 932         result = ks8851_rdreg16(ks, ksreg);
 933         ks8851_unlock(ks, &flags);
 934
 935         return result;
 936 }
 937
 938 /**
 939  * ks8851_phy_read - MII interface PHY register read.
 940  * @dev: The network device the PHY is on.
 941  * @phy_addr: Address of PHY (ignored as we only have one)
 942  * @reg: The register to read.
 943  *
 944  * This call reads data from the PHY register specified in @reg. Since the
 945  * device does not support all the MII registers, the non-existent values
 946  * are always returned as zero.
 947  *
 948  * We return zero for unsupported registers as the MII code does not check
 949  * the value returned for any error status, and simply returns it to the
 950  * caller. The mii-tool that the driver was tested with takes any -ve error
 951  * as real PHY capabilities, thus displaying incorrect data to the user.
 952  */
 953 static int ks8851_phy_read(struct net_device *dev, int phy_addr, int reg)
 954 {
 955         int ret;
 956
 957         ret = ks8851_phy_read_common(dev, phy_addr, reg);
 958         if (ret < 0)
 959                 return 0x0;     /* no error return allowed, so use zero */
 960
 961         return ret;
 962 }
 963
 964 static void ks8851_phy_write(struct net_device *dev,
 965                              int phy, int reg, int value)
 966 {
 967         struct ks8851_net *ks = netdev_priv(dev);
 968         unsigned long flags;
 969         int ksreg;
 970
 971         ksreg = ks8851_phy_reg(reg);
 972         if (ksreg >= 0) {
 973                 ks8851_lock(ks, &flags);
 974                 ks8851_wrreg16(ks, ksreg, value);
 975                 ks8851_unlock(ks, &flags);
 976         }
 977 }
 978
 979 static int ks8851_mdio_read(struct mii_bus *bus, int phy_id, int reg)
 980 {
 981         struct ks8851_net *ks = bus->priv;
 982
 983         if (phy_id != 0)
 984                 return -EOPNOTSUPP;
 985
 986         /* KS8851 PHY ID registers are swapped in HW, swap them back. */
 987         if (reg == MII_PHYSID1)
 988                 reg = MII_PHYSID2;
 989         else if (reg == MII_PHYSID2)
 990                 reg = MII_PHYSID1;
 991
 992         return ks8851_phy_read_common(ks->netdev, phy_id, reg);
 993 }
 994
 995 static int ks8851_mdio_write(struct mii_bus *bus, int phy_id, int reg, u16 val)
 996 {
 997         struct ks8851_net *ks = bus->priv;
 998
 999         ks8851_phy_write(ks->netdev, phy_id, reg, val);
1000         return 0;
1001 }
1002
1003 /**
1004  * ks8851_read_selftest - read the selftest memory info.
1005  * @ks: The device state
1006  *
1007  * Read and check the TX/RX memory selftest information.
1008  */
1009 static void ks8851_read_selftest(struct ks8851_net *ks)
1010 {
1011         unsigned both_done = MBIR_TXMBF | MBIR_RXMBF;
1012         unsigned rd;
1013
1014         rd = ks8851_rdreg16(ks, KS_MBIR);
1015
1016         if ((rd & both_done) != both_done) {
1017                 netdev_warn(ks->netdev, "Memory selftest not finished\n");
1018                 return;
1019         }
1020
1021         if (rd & MBIR_TXMBFA)
1022                 netdev_err(ks->netdev, "TX memory selftest fail\n");
1023
1024         if (rd & MBIR_RXMBFA)
1025                 netdev_err(ks->netdev, "RX memory selftest fail\n");
1026 }
1027
1028 /* driver bus management functions */
1029
1030 #ifdef CONFIG_PM_SLEEP
1031
1032 int ks8851_suspend(struct device *dev)
1033 {
1034         struct ks8851_net *ks = dev_get_drvdata(dev);
1035         struct net_device *netdev = ks->netdev;
1036
1037         if (netif_running(netdev)) {
1038                 netif_device_detach(netdev);
1039                 ks8851_net_stop(netdev);
1040         }
1041
1042         return 0;
1043 }
1044 EXPORT_SYMBOL_GPL(ks8851_suspend);
1045
1046 int ks8851_resume(struct device *dev)
1047 {
1048         struct ks8851_net *ks = dev_get_drvdata(dev);
1049         struct net_device *netdev = ks->netdev;
1050
1051         if (netif_running(netdev)) {
1052                 ks8851_net_open(netdev);
1053                 netif_device_attach(netdev);
1054         }
1055
1056         return 0;
1057 }
1058 EXPORT_SYMBOL_GPL(ks8851_resume);
1059 #endif
1060
1061 static int ks8851_register_mdiobus(struct ks8851_net *ks, struct device *dev)
1062 {
1063         struct mii_bus *mii_bus;
1064         int ret;
1065
1066         mii_bus = mdiobus_alloc();
1067         if (!mii_bus)
1068                 return -ENOMEM;
1069
1070         mii_bus->name = "ks8851_eth_mii";
1071         mii_bus->read = ks8851_mdio_read;
1072         mii_bus->write = ks8851_mdio_write;
1073         mii_bus->priv = ks;
1074         mii_bus->parent = dev;
1075         mii_bus->phy_mask = ~((u32)BIT(0));
1076         snprintf(mii_bus->id, MII_BUS_ID_SIZE, "%s", dev_name(dev));
1077
1078         ret = mdiobus_register(mii_bus);
1079         if (ret)
1080                 goto err_mdiobus_register;
1081
1082         ks->mii_bus = mii_bus;
1083
1084         return 0;
1085
1086 err_mdiobus_register:
1087         mdiobus_free(mii_bus);
1088         return ret;
1089 }
1090
1091 static void ks8851_unregister_mdiobus(struct ks8851_net *ks)
1092 {
1093         mdiobus_unregister(ks->mii_bus);
1094         mdiobus_free(ks->mii_bus);
1095 }
1096
1097 int ks8851_probe_common(struct net_device *netdev, struct device *dev,
1098                         int msg_en)
1099 {
1100         struct ks8851_net *ks = netdev_priv(netdev);
1101         unsigned cider;
1102         int ret;
1103
1104         ks->netdev = netdev;
1105
1106         ks->gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
1107         ret = PTR_ERR_OR_ZERO(ks->gpio);
1108         if (ret) {
1109                 if (ret != -EPROBE_DEFER)
1110                         dev_err(dev, "reset gpio request failed: %d\n", ret);
1111                 return ret;
1112         }
1113
1114         ret = gpiod_set_consumer_name(ks->gpio, "ks8851_rst_n");
1115         if (ret) {
1116                 dev_err(dev, "failed to set reset gpio name: %d\n", ret);
1117                 return ret;
1118         }
1119
1120         ks->vdd_io = devm_regulator_get(dev, "vdd-io");
1121         if (IS_ERR(ks->vdd_io)) {
1122                 ret = PTR_ERR(ks->vdd_io);
1123                 goto err_reg_io;
1124         }
1125
1126         ret = regulator_enable(ks->vdd_io);
1127         if (ret) {
1128                 dev_err(dev, "regulator vdd_io enable fail: %d\n", ret);
1129                 goto err_reg_io;
1130         }
1131
1132         ks->vdd_reg = devm_regulator_get(dev, "vdd");
1133         if (IS_ERR(ks->vdd_reg)) {
1134                 ret = PTR_ERR(ks->vdd_reg);
1135                 goto err_reg;
1136         }
1137
1138         ret = regulator_enable(ks->vdd_reg);
1139         if (ret) {
1140                 dev_err(dev, "regulator vdd enable fail: %d\n", ret);
1141                 goto err_reg;
1142         }
1143
1144         if (ks->gpio) {
1145                 usleep_range(10000, 11000);
1146                 gpiod_set_value_cansleep(ks->gpio, 0);
1147         }
1148
1149         spin_lock_init(&ks->statelock);
1150
1151         INIT_WORK(&ks->rxctrl_work, ks8851_rxctrl_work);
1152
1153         SET_NETDEV_DEV(netdev, dev);
1154
1155         /* setup EEPROM state */
1156         ks->eeprom.data = ks;
1157         ks->eeprom.width = PCI_EEPROM_WIDTH_93C46;
1158         ks->eeprom.register_read = ks8851_eeprom_regread;
1159         ks->eeprom.register_write = ks8851_eeprom_regwrite;
1160
1161         /* setup mii state */
1162         ks->mii.dev             = netdev;
1163         ks->mii.phy_id          = 1;
1164         ks->mii.phy_id_mask     = 1;
1165         ks->mii.reg_num_mask    = 0xf;
1166         ks->mii.mdio_read       = ks8851_phy_read;
1167         ks->mii.mdio_write      = ks8851_phy_write;
1168
1169         dev_info(dev, "message enable is %d\n", msg_en);
1170
1171         ret = ks8851_register_mdiobus(ks, dev);
1172         if (ret)
1173                 goto err_mdio;
1174
1175         /* set the default message enable */
1176         ks->msg_enable = netif_msg_init(msg_en, NETIF_MSG_DRV |
1177                                                 NETIF_MSG_PROBE |
1178                                                 NETIF_MSG_LINK);
1179
1180         skb_queue_head_init(&ks->txq);
1181
1182         netdev->ethtool_ops = &ks8851_ethtool_ops;
1183
1184         dev_set_drvdata(dev, ks);
1185
1186         netif_carrier_off(ks->netdev);
1187         netdev->if_port = IF_PORT_100BASET;
1188         netdev->netdev_ops = &ks8851_netdev_ops;
1189
1190         /* issue a global soft reset to reset the device. */
1191         ks8851_soft_reset(ks, GRR_GSR);
1192
1193         /* simple check for a valid chip being connected to the bus */
1194         cider = ks8851_rdreg16(ks, KS_CIDER);
1195         if ((cider & ~CIDER_REV_MASK) != CIDER_ID) {
1196                 dev_err(dev, "failed to read device ID\n");
1197                 ret = -ENODEV;
1198                 goto err_id;
1199         }
1200
1201         /* cache the contents of the CCR register for EEPROM, etc. */
1202         ks->rc_ccr = ks8851_rdreg16(ks, KS_CCR);
1203
1204         ks8851_read_selftest(ks);
1205         ks8851_init_mac(ks, dev->of_node);
1206
1207         ret = register_netdev(netdev);
1208         if (ret) {
1209                 dev_err(dev, "failed to register network device\n");
1210                 goto err_id;
1211         }
1212
1213         netdev_info(netdev, "revision %d, MAC %pM, IRQ %d, %s EEPROM\n",
1214                     CIDER_REV_GET(cider), netdev->dev_addr, netdev->irq,
1215                     ks->rc_ccr & CCR_EEPROM ? "has" : "no");
1216
1217         return 0;
1218
1219 err_id:
1220         ks8851_unregister_mdiobus(ks);
1221 err_mdio:
1222         if (ks->gpio)
1223                 gpiod_set_value_cansleep(ks->gpio, 1);
1224         regulator_disable(ks->vdd_reg);
1225 err_reg:
1226         regulator_disable(ks->vdd_io);
1227 err_reg_io:
1228         return ret;
1229 }
1230 EXPORT_SYMBOL_GPL(ks8851_probe_common);
1231
1232 void ks8851_remove_common(struct device *dev)
1233 {
1234         struct ks8851_net *priv = dev_get_drvdata(dev);
1235
1236         ks8851_unregister_mdiobus(priv);
1237
1238         if (netif_msg_drv(priv))
1239                 dev_info(dev, "remove\n");
1240
1241         unregister_netdev(priv->netdev);
1242         if (priv->gpio)
1243                 gpiod_set_value_cansleep(priv->gpio, 1);
1244         regulator_disable(priv->vdd_reg);
1245         regulator_disable(priv->vdd_io);
1246 }
1247 EXPORT_SYMBOL_GPL(ks8851_remove_common);
1248
1249 MODULE_DESCRIPTION("KS8851 Network driver");
1250 MODULE_AUTHOR("Ben Dooks <[email protected]>");
1251 MODULE_LICENSE("GPL");