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