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