1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2004-2013 Synopsys, Inc. (www.synopsys.com) 4 * 5 * Driver for the ARC EMAC 10100 (hardware revision 5) 6 * 7 * Contributors: 8 * Amit Bhor 9 * Sameer Dhavale 10 * Vineet Gupta 11 */ 12 13 #include <linux/crc32.h> 14 #include <linux/etherdevice.h> 15 #include <linux/interrupt.h> 16 #include <linux/io.h> 17 #include <linux/module.h> 18 #include <linux/of.h> 19 #include <linux/of_address.h> 20 #include <linux/of_irq.h> 21 #include <linux/of_mdio.h> 22 #include <linux/of_net.h> 23 24 #include "emac.h" 25 26 static void arc_emac_restart(struct net_device *ndev); 27 28 /** 29 * arc_emac_tx_avail - Return the number of available slots in the tx ring. 30 * @priv: Pointer to ARC EMAC private data structure. 31 * 32 * returns: the number of slots available for transmission in tx the ring. 33 */ 34 static inline int arc_emac_tx_avail(struct arc_emac_priv *priv) 35 { 36 return (priv->txbd_dirty + TX_BD_NUM - priv->txbd_curr - 1) % TX_BD_NUM; 37 } 38 39 /** 40 * arc_emac_adjust_link - Adjust the PHY link duplex. 41 * @ndev: Pointer to the net_device structure. 42 * 43 * This function is called to change the duplex setting after auto negotiation 44 * is done by the PHY. 45 */ 46 static void arc_emac_adjust_link(struct net_device *ndev) 47 { 48 struct arc_emac_priv *priv = netdev_priv(ndev); 49 struct phy_device *phy_dev = ndev->phydev; 50 unsigned int reg, state_changed = 0; 51 52 if (priv->link != phy_dev->link) { 53 priv->link = phy_dev->link; 54 state_changed = 1; 55 } 56 57 if (priv->speed != phy_dev->speed) { 58 priv->speed = phy_dev->speed; 59 state_changed = 1; 60 if (priv->set_mac_speed) 61 priv->set_mac_speed(priv, priv->speed); 62 } 63 64 if (priv->duplex != phy_dev->duplex) { 65 reg = arc_reg_get(priv, R_CTRL); 66 67 if (phy_dev->duplex == DUPLEX_FULL) 68 reg |= ENFL_MASK; 69 else 70 reg &= ~ENFL_MASK; 71 72 arc_reg_set(priv, R_CTRL, reg); 73 priv->duplex = phy_dev->duplex; 74 state_changed = 1; 75 } 76 77 if (state_changed) 78 phy_print_status(phy_dev); 79 } 80 81 /** 82 * arc_emac_get_drvinfo - Get EMAC driver information. 83 * @ndev: Pointer to net_device structure. 84 * @info: Pointer to ethtool_drvinfo structure. 85 * 86 * This implements ethtool command for getting the driver information. 87 * Issue "ethtool -i ethX" under linux prompt to execute this function. 88 */ 89 static void arc_emac_get_drvinfo(struct net_device *ndev, 90 struct ethtool_drvinfo *info) 91 { 92 struct arc_emac_priv *priv = netdev_priv(ndev); 93 94 strscpy(info->driver, priv->drv_name, sizeof(info->driver)); 95 } 96 97 static const struct ethtool_ops arc_emac_ethtool_ops = { 98 .get_drvinfo = arc_emac_get_drvinfo, 99 .get_link = ethtool_op_get_link, 100 .get_link_ksettings = phy_ethtool_get_link_ksettings, 101 .set_link_ksettings = phy_ethtool_set_link_ksettings, 102 }; 103 104 #define FIRST_OR_LAST_MASK (FIRST_MASK | LAST_MASK) 105 106 /** 107 * arc_emac_tx_clean - clears processed by EMAC Tx BDs. 108 * @ndev: Pointer to the network device. 109 */ 110 static void arc_emac_tx_clean(struct net_device *ndev) 111 { 112 struct arc_emac_priv *priv = netdev_priv(ndev); 113 struct net_device_stats *stats = &ndev->stats; 114 struct device *dev = ndev->dev.parent; 115 unsigned int i; 116 117 for (i = 0; i < TX_BD_NUM; i++) { 118 unsigned int *txbd_dirty = &priv->txbd_dirty; 119 struct arc_emac_bd *txbd = &priv->txbd[*txbd_dirty]; 120 struct buffer_state *tx_buff = &priv->tx_buff[*txbd_dirty]; 121 struct sk_buff *skb = tx_buff->skb; 122 unsigned int info = le32_to_cpu(txbd->info); 123 124 if ((info & FOR_EMAC) || !txbd->data || !skb) 125 break; 126 127 if (unlikely(info & (DROP | DEFR | LTCL | UFLO))) { 128 stats->tx_errors++; 129 stats->tx_dropped++; 130 131 if (info & DEFR) 132 stats->tx_carrier_errors++; 133 134 if (info & LTCL) 135 stats->collisions++; 136 137 if (info & UFLO) 138 stats->tx_fifo_errors++; 139 } else if (likely(info & FIRST_OR_LAST_MASK)) { 140 stats->tx_packets++; 141 stats->tx_bytes += skb->len; 142 } 143 144 dma_unmap_single(dev, dma_unmap_addr(tx_buff, addr), 145 dma_unmap_len(tx_buff, len), DMA_TO_DEVICE); 146 147 /* return the sk_buff to system */ 148 dev_consume_skb_irq(skb); 149 150 txbd->data = 0; 151 txbd->info = 0; 152 tx_buff->skb = NULL; 153 154 *txbd_dirty = (*txbd_dirty + 1) % TX_BD_NUM; 155 } 156 157 /* Ensure that txbd_dirty is visible to tx() before checking 158 * for queue stopped. 159 */ 160 smp_mb(); 161 162 if (netif_queue_stopped(ndev) && arc_emac_tx_avail(priv)) 163 netif_wake_queue(ndev); 164 } 165 166 /** 167 * arc_emac_rx - processing of Rx packets. 168 * @ndev: Pointer to the network device. 169 * @budget: How many BDs to process on 1 call. 170 * 171 * returns: Number of processed BDs 172 * 173 * Iterate through Rx BDs and deliver received packages to upper layer. 174 */ 175 static int arc_emac_rx(struct net_device *ndev, int budget) 176 { 177 struct arc_emac_priv *priv = netdev_priv(ndev); 178 struct device *dev = ndev->dev.parent; 179 unsigned int work_done; 180 181 for (work_done = 0; work_done < budget; work_done++) { 182 unsigned int *last_rx_bd = &priv->last_rx_bd; 183 struct net_device_stats *stats = &ndev->stats; 184 struct buffer_state *rx_buff = &priv->rx_buff[*last_rx_bd]; 185 struct arc_emac_bd *rxbd = &priv->rxbd[*last_rx_bd]; 186 unsigned int pktlen, info = le32_to_cpu(rxbd->info); 187 struct sk_buff *skb; 188 dma_addr_t addr; 189 190 if (unlikely((info & OWN_MASK) == FOR_EMAC)) 191 break; 192 193 /* Make a note that we saw a packet at this BD. 194 * So next time, driver starts from this + 1 195 */ 196 *last_rx_bd = (*last_rx_bd + 1) % RX_BD_NUM; 197 198 if (unlikely((info & FIRST_OR_LAST_MASK) != 199 FIRST_OR_LAST_MASK)) { 200 /* We pre-allocate buffers of MTU size so incoming 201 * packets won't be split/chained. 202 */ 203 if (net_ratelimit()) 204 netdev_err(ndev, "incomplete packet received\n"); 205 206 /* Return ownership to EMAC */ 207 rxbd->info = cpu_to_le32(FOR_EMAC | EMAC_BUFFER_SIZE); 208 stats->rx_errors++; 209 stats->rx_length_errors++; 210 continue; 211 } 212 213 /* Prepare the BD for next cycle. netif_receive_skb() 214 * only if new skb was allocated and mapped to avoid holes 215 * in the RX fifo. 216 */ 217 skb = netdev_alloc_skb_ip_align(ndev, EMAC_BUFFER_SIZE); 218 if (unlikely(!skb)) { 219 if (net_ratelimit()) 220 netdev_err(ndev, "cannot allocate skb\n"); 221 /* Return ownership to EMAC */ 222 rxbd->info = cpu_to_le32(FOR_EMAC | EMAC_BUFFER_SIZE); 223 stats->rx_errors++; 224 stats->rx_dropped++; 225 continue; 226 } 227 228 addr = dma_map_single(dev, (void *)skb->data, 229 EMAC_BUFFER_SIZE, DMA_FROM_DEVICE); 230 if (dma_mapping_error(dev, addr)) { 231 if (net_ratelimit()) 232 netdev_err(ndev, "cannot map dma buffer\n"); 233 dev_kfree_skb(skb); 234 /* Return ownership to EMAC */ 235 rxbd->info = cpu_to_le32(FOR_EMAC | EMAC_BUFFER_SIZE); 236 stats->rx_errors++; 237 stats->rx_dropped++; 238 continue; 239 } 240 241 /* unmap previosly mapped skb */ 242 dma_unmap_single(dev, dma_unmap_addr(rx_buff, addr), 243 dma_unmap_len(rx_buff, len), DMA_FROM_DEVICE); 244 245 pktlen = info & LEN_MASK; 246 stats->rx_packets++; 247 stats->rx_bytes += pktlen; 248 skb_put(rx_buff->skb, pktlen); 249 rx_buff->skb->dev = ndev; 250 rx_buff->skb->protocol = eth_type_trans(rx_buff->skb, ndev); 251 252 netif_receive_skb(rx_buff->skb); 253 254 rx_buff->skb = skb; 255 dma_unmap_addr_set(rx_buff, addr, addr); 256 dma_unmap_len_set(rx_buff, len, EMAC_BUFFER_SIZE); 257 258 rxbd->data = cpu_to_le32(addr); 259 260 /* Make sure pointer to data buffer is set */ 261 wmb(); 262 263 /* Return ownership to EMAC */ 264 rxbd->info = cpu_to_le32(FOR_EMAC | EMAC_BUFFER_SIZE); 265 } 266 267 return work_done; 268 } 269 270 /** 271 * arc_emac_rx_miss_handle - handle R_MISS register 272 * @ndev: Pointer to the net_device structure. 273 */ 274 static void arc_emac_rx_miss_handle(struct net_device *ndev) 275 { 276 struct arc_emac_priv *priv = netdev_priv(ndev); 277 struct net_device_stats *stats = &ndev->stats; 278 unsigned int miss; 279 280 miss = arc_reg_get(priv, R_MISS); 281 if (miss) { 282 stats->rx_errors += miss; 283 stats->rx_missed_errors += miss; 284 priv->rx_missed_errors += miss; 285 } 286 } 287 288 /** 289 * arc_emac_rx_stall_check - check RX stall 290 * @ndev: Pointer to the net_device structure. 291 * @budget: How many BDs requested to process on 1 call. 292 * @work_done: How many BDs processed 293 * 294 * Under certain conditions EMAC stop reception of incoming packets and 295 * continuously increment R_MISS register instead of saving data into 296 * provided buffer. This function detect that condition and restart 297 * EMAC. 298 */ 299 static void arc_emac_rx_stall_check(struct net_device *ndev, 300 int budget, unsigned int work_done) 301 { 302 struct arc_emac_priv *priv = netdev_priv(ndev); 303 struct arc_emac_bd *rxbd; 304 305 if (work_done) 306 priv->rx_missed_errors = 0; 307 308 if (priv->rx_missed_errors && budget) { 309 rxbd = &priv->rxbd[priv->last_rx_bd]; 310 if (le32_to_cpu(rxbd->info) & FOR_EMAC) { 311 arc_emac_restart(ndev); 312 priv->rx_missed_errors = 0; 313 } 314 } 315 } 316 317 /** 318 * arc_emac_poll - NAPI poll handler. 319 * @napi: Pointer to napi_struct structure. 320 * @budget: How many BDs to process on 1 call. 321 * 322 * returns: Number of processed BDs 323 */ 324 static int arc_emac_poll(struct napi_struct *napi, int budget) 325 { 326 struct net_device *ndev = napi->dev; 327 struct arc_emac_priv *priv = netdev_priv(ndev); 328 unsigned int work_done; 329 330 arc_emac_tx_clean(ndev); 331 arc_emac_rx_miss_handle(ndev); 332 333 work_done = arc_emac_rx(ndev, budget); 334 if (work_done < budget) { 335 napi_complete_done(napi, work_done); 336 arc_reg_or(priv, R_ENABLE, RXINT_MASK | TXINT_MASK); 337 } 338 339 arc_emac_rx_stall_check(ndev, budget, work_done); 340 341 return work_done; 342 } 343 344 /** 345 * arc_emac_intr - Global interrupt handler for EMAC. 346 * @irq: irq number. 347 * @dev_instance: device instance. 348 * 349 * returns: IRQ_HANDLED for all cases. 350 * 351 * ARC EMAC has only 1 interrupt line, and depending on bits raised in 352 * STATUS register we may tell what is a reason for interrupt to fire. 353 */ 354 static irqreturn_t arc_emac_intr(int irq, void *dev_instance) 355 { 356 struct net_device *ndev = dev_instance; 357 struct arc_emac_priv *priv = netdev_priv(ndev); 358 struct net_device_stats *stats = &ndev->stats; 359 unsigned int status; 360 361 status = arc_reg_get(priv, R_STATUS); 362 status &= ~MDIO_MASK; 363 364 /* Reset all flags except "MDIO complete" */ 365 arc_reg_set(priv, R_STATUS, status); 366 367 if (status & (RXINT_MASK | TXINT_MASK)) { 368 if (likely(napi_schedule_prep(&priv->napi))) { 369 arc_reg_clr(priv, R_ENABLE, RXINT_MASK | TXINT_MASK); 370 __napi_schedule(&priv->napi); 371 } 372 } 373 374 if (status & ERR_MASK) { 375 /* MSER/RXCR/RXFR/RXFL interrupt fires on corresponding 376 * 8-bit error counter overrun. 377 */ 378 379 if (status & MSER_MASK) { 380 stats->rx_missed_errors += 0x100; 381 stats->rx_errors += 0x100; 382 priv->rx_missed_errors += 0x100; 383 napi_schedule(&priv->napi); 384 } 385 386 if (status & RXCR_MASK) { 387 stats->rx_crc_errors += 0x100; 388 stats->rx_errors += 0x100; 389 } 390 391 if (status & RXFR_MASK) { 392 stats->rx_frame_errors += 0x100; 393 stats->rx_errors += 0x100; 394 } 395 396 if (status & RXFL_MASK) { 397 stats->rx_over_errors += 0x100; 398 stats->rx_errors += 0x100; 399 } 400 } 401 402 return IRQ_HANDLED; 403 } 404 405 #ifdef CONFIG_NET_POLL_CONTROLLER 406 static void arc_emac_poll_controller(struct net_device *dev) 407 { 408 disable_irq(dev->irq); 409 arc_emac_intr(dev->irq, dev); 410 enable_irq(dev->irq); 411 } 412 #endif 413 414 /** 415 * arc_emac_open - Open the network device. 416 * @ndev: Pointer to the network device. 417 * 418 * returns: 0, on success or non-zero error value on failure. 419 * 420 * This function sets the MAC address, requests and enables an IRQ 421 * for the EMAC device and starts the Tx queue. 422 * It also connects to the phy device. 423 */ 424 static int arc_emac_open(struct net_device *ndev) 425 { 426 struct arc_emac_priv *priv = netdev_priv(ndev); 427 struct phy_device *phy_dev = ndev->phydev; 428 struct device *dev = ndev->dev.parent; 429 int i; 430 431 phy_dev->autoneg = AUTONEG_ENABLE; 432 phy_dev->speed = 0; 433 phy_dev->duplex = 0; 434 linkmode_and(phy_dev->advertising, phy_dev->advertising, 435 phy_dev->supported); 436 437 priv->last_rx_bd = 0; 438 439 /* Allocate and set buffers for Rx BD's */ 440 for (i = 0; i < RX_BD_NUM; i++) { 441 dma_addr_t addr; 442 unsigned int *last_rx_bd = &priv->last_rx_bd; 443 struct arc_emac_bd *rxbd = &priv->rxbd[*last_rx_bd]; 444 struct buffer_state *rx_buff = &priv->rx_buff[*last_rx_bd]; 445 446 rx_buff->skb = netdev_alloc_skb_ip_align(ndev, 447 EMAC_BUFFER_SIZE); 448 if (unlikely(!rx_buff->skb)) 449 return -ENOMEM; 450 451 addr = dma_map_single(dev, (void *)rx_buff->skb->data, 452 EMAC_BUFFER_SIZE, DMA_FROM_DEVICE); 453 if (dma_mapping_error(dev, addr)) { 454 netdev_err(ndev, "cannot dma map\n"); 455 dev_kfree_skb(rx_buff->skb); 456 return -ENOMEM; 457 } 458 dma_unmap_addr_set(rx_buff, addr, addr); 459 dma_unmap_len_set(rx_buff, len, EMAC_BUFFER_SIZE); 460 461 rxbd->data = cpu_to_le32(addr); 462 463 /* Make sure pointer to data buffer is set */ 464 wmb(); 465 466 /* Return ownership to EMAC */ 467 rxbd->info = cpu_to_le32(FOR_EMAC | EMAC_BUFFER_SIZE); 468 469 *last_rx_bd = (*last_rx_bd + 1) % RX_BD_NUM; 470 } 471 472 priv->txbd_curr = 0; 473 priv->txbd_dirty = 0; 474 475 /* Clean Tx BD's */ 476 memset(priv->txbd, 0, TX_RING_SZ); 477 478 /* Initialize logical address filter */ 479 arc_reg_set(priv, R_LAFL, 0); 480 arc_reg_set(priv, R_LAFH, 0); 481 482 /* Set BD ring pointers for device side */ 483 arc_reg_set(priv, R_RX_RING, (unsigned int)priv->rxbd_dma); 484 arc_reg_set(priv, R_TX_RING, (unsigned int)priv->txbd_dma); 485 486 /* Enable interrupts */ 487 arc_reg_set(priv, R_ENABLE, RXINT_MASK | TXINT_MASK | ERR_MASK); 488 489 /* Set CONTROL */ 490 arc_reg_set(priv, R_CTRL, 491 (RX_BD_NUM << 24) | /* RX BD table length */ 492 (TX_BD_NUM << 16) | /* TX BD table length */ 493 TXRN_MASK | RXRN_MASK); 494 495 napi_enable(&priv->napi); 496 497 /* Enable EMAC */ 498 arc_reg_or(priv, R_CTRL, EN_MASK); 499 500 phy_start(ndev->phydev); 501 502 netif_start_queue(ndev); 503 504 return 0; 505 } 506 507 /** 508 * arc_emac_set_rx_mode - Change the receive filtering mode. 509 * @ndev: Pointer to the network device. 510 * 511 * This function enables/disables promiscuous or all-multicast mode 512 * and updates the multicast filtering list of the network device. 513 */ 514 static void arc_emac_set_rx_mode(struct net_device *ndev) 515 { 516 struct arc_emac_priv *priv = netdev_priv(ndev); 517 518 if (ndev->flags & IFF_PROMISC) { 519 arc_reg_or(priv, R_CTRL, PROM_MASK); 520 } else { 521 arc_reg_clr(priv, R_CTRL, PROM_MASK); 522 523 if (ndev->flags & IFF_ALLMULTI) { 524 arc_reg_set(priv, R_LAFL, ~0); 525 arc_reg_set(priv, R_LAFH, ~0); 526 } else if (ndev->flags & IFF_MULTICAST) { 527 struct netdev_hw_addr *ha; 528 unsigned int filter[2] = { 0, 0 }; 529 int bit; 530 531 netdev_for_each_mc_addr(ha, ndev) { 532 bit = ether_crc_le(ETH_ALEN, ha->addr) >> 26; 533 filter[bit >> 5] |= 1 << (bit & 31); 534 } 535 536 arc_reg_set(priv, R_LAFL, filter[0]); 537 arc_reg_set(priv, R_LAFH, filter[1]); 538 } else { 539 arc_reg_set(priv, R_LAFL, 0); 540 arc_reg_set(priv, R_LAFH, 0); 541 } 542 } 543 } 544 545 /** 546 * arc_free_tx_queue - free skb from tx queue 547 * @ndev: Pointer to the network device. 548 * 549 * This function must be called while EMAC disable 550 */ 551 static void arc_free_tx_queue(struct net_device *ndev) 552 { 553 struct arc_emac_priv *priv = netdev_priv(ndev); 554 struct device *dev = ndev->dev.parent; 555 unsigned int i; 556 557 for (i = 0; i < TX_BD_NUM; i++) { 558 struct arc_emac_bd *txbd = &priv->txbd[i]; 559 struct buffer_state *tx_buff = &priv->tx_buff[i]; 560 561 if (tx_buff->skb) { 562 dma_unmap_single(dev, 563 dma_unmap_addr(tx_buff, addr), 564 dma_unmap_len(tx_buff, len), 565 DMA_TO_DEVICE); 566 567 /* return the sk_buff to system */ 568 dev_kfree_skb_irq(tx_buff->skb); 569 } 570 571 txbd->info = 0; 572 txbd->data = 0; 573 tx_buff->skb = NULL; 574 } 575 } 576 577 /** 578 * arc_free_rx_queue - free skb from rx queue 579 * @ndev: Pointer to the network device. 580 * 581 * This function must be called while EMAC disable 582 */ 583 static void arc_free_rx_queue(struct net_device *ndev) 584 { 585 struct arc_emac_priv *priv = netdev_priv(ndev); 586 struct device *dev = ndev->dev.parent; 587 unsigned int i; 588 589 for (i = 0; i < RX_BD_NUM; i++) { 590 struct arc_emac_bd *rxbd = &priv->rxbd[i]; 591 struct buffer_state *rx_buff = &priv->rx_buff[i]; 592 593 if (rx_buff->skb) { 594 dma_unmap_single(dev, 595 dma_unmap_addr(rx_buff, addr), 596 dma_unmap_len(rx_buff, len), 597 DMA_FROM_DEVICE); 598 599 /* return the sk_buff to system */ 600 dev_kfree_skb_irq(rx_buff->skb); 601 } 602 603 rxbd->info = 0; 604 rxbd->data = 0; 605 rx_buff->skb = NULL; 606 } 607 } 608 609 /** 610 * arc_emac_stop - Close the network device. 611 * @ndev: Pointer to the network device. 612 * 613 * This function stops the Tx queue, disables interrupts and frees the IRQ for 614 * the EMAC device. 615 * It also disconnects the PHY device associated with the EMAC device. 616 */ 617 static int arc_emac_stop(struct net_device *ndev) 618 { 619 struct arc_emac_priv *priv = netdev_priv(ndev); 620 621 napi_disable(&priv->napi); 622 netif_stop_queue(ndev); 623 624 phy_stop(ndev->phydev); 625 626 /* Disable interrupts */ 627 arc_reg_clr(priv, R_ENABLE, RXINT_MASK | TXINT_MASK | ERR_MASK); 628 629 /* Disable EMAC */ 630 arc_reg_clr(priv, R_CTRL, EN_MASK); 631 632 /* Return the sk_buff to system */ 633 arc_free_tx_queue(ndev); 634 arc_free_rx_queue(ndev); 635 636 return 0; 637 } 638 639 /** 640 * arc_emac_stats - Get system network statistics. 641 * @ndev: Pointer to net_device structure. 642 * 643 * Returns the address of the device statistics structure. 644 * Statistics are updated in interrupt handler. 645 */ 646 static struct net_device_stats *arc_emac_stats(struct net_device *ndev) 647 { 648 struct arc_emac_priv *priv = netdev_priv(ndev); 649 struct net_device_stats *stats = &ndev->stats; 650 unsigned long miss, rxerr; 651 u8 rxcrc, rxfram, rxoflow; 652 653 rxerr = arc_reg_get(priv, R_RXERR); 654 miss = arc_reg_get(priv, R_MISS); 655 656 rxcrc = rxerr; 657 rxfram = rxerr >> 8; 658 rxoflow = rxerr >> 16; 659 660 stats->rx_errors += miss; 661 stats->rx_errors += rxcrc + rxfram + rxoflow; 662 663 stats->rx_over_errors += rxoflow; 664 stats->rx_frame_errors += rxfram; 665 stats->rx_crc_errors += rxcrc; 666 stats->rx_missed_errors += miss; 667 668 return stats; 669 } 670 671 /** 672 * arc_emac_tx - Starts the data transmission. 673 * @skb: sk_buff pointer that contains data to be Transmitted. 674 * @ndev: Pointer to net_device structure. 675 * 676 * returns: NETDEV_TX_OK, on success 677 * NETDEV_TX_BUSY, if any of the descriptors are not free. 678 * 679 * This function is invoked from upper layers to initiate transmission. 680 */ 681 static netdev_tx_t arc_emac_tx(struct sk_buff *skb, struct net_device *ndev) 682 { 683 struct arc_emac_priv *priv = netdev_priv(ndev); 684 unsigned int len, *txbd_curr = &priv->txbd_curr; 685 struct net_device_stats *stats = &ndev->stats; 686 __le32 *info = &priv->txbd[*txbd_curr].info; 687 struct device *dev = ndev->dev.parent; 688 dma_addr_t addr; 689 690 if (skb_padto(skb, ETH_ZLEN)) 691 return NETDEV_TX_OK; 692 693 len = max_t(unsigned int, ETH_ZLEN, skb->len); 694 695 if (unlikely(!arc_emac_tx_avail(priv))) { 696 netif_stop_queue(ndev); 697 netdev_err(ndev, "BUG! Tx Ring full when queue awake!\n"); 698 return NETDEV_TX_BUSY; 699 } 700 701 addr = dma_map_single(dev, (void *)skb->data, len, DMA_TO_DEVICE); 702 703 if (unlikely(dma_mapping_error(dev, addr))) { 704 stats->tx_dropped++; 705 stats->tx_errors++; 706 dev_kfree_skb_any(skb); 707 return NETDEV_TX_OK; 708 } 709 dma_unmap_addr_set(&priv->tx_buff[*txbd_curr], addr, addr); 710 dma_unmap_len_set(&priv->tx_buff[*txbd_curr], len, len); 711 712 priv->txbd[*txbd_curr].data = cpu_to_le32(addr); 713 714 /* Make sure pointer to data buffer is set */ 715 wmb(); 716 717 skb_tx_timestamp(skb); 718 719 *info = cpu_to_le32(FOR_EMAC | FIRST_OR_LAST_MASK | len); 720 721 /* Make sure info word is set */ 722 wmb(); 723 724 priv->tx_buff[*txbd_curr].skb = skb; 725 726 /* Increment index to point to the next BD */ 727 *txbd_curr = (*txbd_curr + 1) % TX_BD_NUM; 728 729 /* Ensure that tx_clean() sees the new txbd_curr before 730 * checking the queue status. This prevents an unneeded wake 731 * of the queue in tx_clean(). 732 */ 733 smp_mb(); 734 735 if (!arc_emac_tx_avail(priv)) { 736 netif_stop_queue(ndev); 737 /* Refresh tx_dirty */ 738 smp_mb(); 739 if (arc_emac_tx_avail(priv)) 740 netif_start_queue(ndev); 741 } 742 743 arc_reg_set(priv, R_STATUS, TXPL_MASK); 744 745 return NETDEV_TX_OK; 746 } 747 748 static void arc_emac_set_address_internal(struct net_device *ndev) 749 { 750 struct arc_emac_priv *priv = netdev_priv(ndev); 751 unsigned int addr_low, addr_hi; 752 753 addr_low = le32_to_cpu(*(__le32 *)&ndev->dev_addr[0]); 754 addr_hi = le16_to_cpu(*(__le16 *)&ndev->dev_addr[4]); 755 756 arc_reg_set(priv, R_ADDRL, addr_low); 757 arc_reg_set(priv, R_ADDRH, addr_hi); 758 } 759 760 /** 761 * arc_emac_set_address - Set the MAC address for this device. 762 * @ndev: Pointer to net_device structure. 763 * @p: 6 byte Address to be written as MAC address. 764 * 765 * This function copies the HW address from the sockaddr structure to the 766 * net_device structure and updates the address in HW. 767 * 768 * returns: -EBUSY if the net device is busy or 0 if the address is set 769 * successfully. 770 */ 771 static int arc_emac_set_address(struct net_device *ndev, void *p) 772 { 773 struct sockaddr *addr = p; 774 775 if (netif_running(ndev)) 776 return -EBUSY; 777 778 if (!is_valid_ether_addr(addr->sa_data)) 779 return -EADDRNOTAVAIL; 780 781 eth_hw_addr_set(ndev, addr->sa_data); 782 783 arc_emac_set_address_internal(ndev); 784 785 return 0; 786 } 787 788 /** 789 * arc_emac_restart - Restart EMAC 790 * @ndev: Pointer to net_device structure. 791 * 792 * This function do hardware reset of EMAC in order to restore 793 * network packets reception. 794 */ 795 static void arc_emac_restart(struct net_device *ndev) 796 { 797 struct arc_emac_priv *priv = netdev_priv(ndev); 798 struct net_device_stats *stats = &ndev->stats; 799 int i; 800 801 if (net_ratelimit()) 802 netdev_warn(ndev, "restarting stalled EMAC\n"); 803 804 netif_stop_queue(ndev); 805 806 /* Disable interrupts */ 807 arc_reg_clr(priv, R_ENABLE, RXINT_MASK | TXINT_MASK | ERR_MASK); 808 809 /* Disable EMAC */ 810 arc_reg_clr(priv, R_CTRL, EN_MASK); 811 812 /* Return the sk_buff to system */ 813 arc_free_tx_queue(ndev); 814 815 /* Clean Tx BD's */ 816 priv->txbd_curr = 0; 817 priv->txbd_dirty = 0; 818 memset(priv->txbd, 0, TX_RING_SZ); 819 820 for (i = 0; i < RX_BD_NUM; i++) { 821 struct arc_emac_bd *rxbd = &priv->rxbd[i]; 822 unsigned int info = le32_to_cpu(rxbd->info); 823 824 if (!(info & FOR_EMAC)) { 825 stats->rx_errors++; 826 stats->rx_dropped++; 827 } 828 /* Return ownership to EMAC */ 829 rxbd->info = cpu_to_le32(FOR_EMAC | EMAC_BUFFER_SIZE); 830 } 831 priv->last_rx_bd = 0; 832 833 /* Make sure info is visible to EMAC before enable */ 834 wmb(); 835 836 /* Enable interrupts */ 837 arc_reg_set(priv, R_ENABLE, RXINT_MASK | TXINT_MASK | ERR_MASK); 838 839 /* Enable EMAC */ 840 arc_reg_or(priv, R_CTRL, EN_MASK); 841 842 netif_start_queue(ndev); 843 } 844 845 static const struct net_device_ops arc_emac_netdev_ops = { 846 .ndo_open = arc_emac_open, 847 .ndo_stop = arc_emac_stop, 848 .ndo_start_xmit = arc_emac_tx, 849 .ndo_set_mac_address = arc_emac_set_address, 850 .ndo_get_stats = arc_emac_stats, 851 .ndo_set_rx_mode = arc_emac_set_rx_mode, 852 .ndo_eth_ioctl = phy_do_ioctl_running, 853 #ifdef CONFIG_NET_POLL_CONTROLLER 854 .ndo_poll_controller = arc_emac_poll_controller, 855 #endif 856 }; 857 858 int arc_emac_probe(struct net_device *ndev, int interface) 859 { 860 struct device *dev = ndev->dev.parent; 861 struct resource res_regs; 862 struct device_node *phy_node; 863 struct phy_device *phydev = NULL; 864 struct arc_emac_priv *priv; 865 unsigned int id, clock_frequency, irq; 866 int err; 867 868 /* Get PHY from device tree */ 869 phy_node = of_parse_phandle(dev->of_node, "phy", 0); 870 if (!phy_node) { 871 dev_err(dev, "failed to retrieve phy description from device tree\n"); 872 return -ENODEV; 873 } 874 875 /* Get EMAC registers base address from device tree */ 876 err = of_address_to_resource(dev->of_node, 0, &res_regs); 877 if (err) { 878 dev_err(dev, "failed to retrieve registers base from device tree\n"); 879 err = -ENODEV; 880 goto out_put_node; 881 } 882 883 /* Get IRQ from device tree */ 884 irq = irq_of_parse_and_map(dev->of_node, 0); 885 if (!irq) { 886 dev_err(dev, "failed to retrieve <irq> value from device tree\n"); 887 err = -ENODEV; 888 goto out_put_node; 889 } 890 891 ndev->netdev_ops = &arc_emac_netdev_ops; 892 ndev->ethtool_ops = &arc_emac_ethtool_ops; 893 ndev->watchdog_timeo = TX_TIMEOUT; 894 895 priv = netdev_priv(ndev); 896 priv->dev = dev; 897 898 priv->regs = devm_ioremap_resource(dev, &res_regs); 899 if (IS_ERR(priv->regs)) { 900 err = PTR_ERR(priv->regs); 901 goto out_put_node; 902 } 903 904 dev_dbg(dev, "Registers base address is 0x%p\n", priv->regs); 905 906 if (priv->clk) { 907 err = clk_prepare_enable(priv->clk); 908 if (err) { 909 dev_err(dev, "failed to enable clock\n"); 910 goto out_put_node; 911 } 912 913 clock_frequency = clk_get_rate(priv->clk); 914 } else { 915 /* Get CPU clock frequency from device tree */ 916 if (of_property_read_u32(dev->of_node, "clock-frequency", 917 &clock_frequency)) { 918 dev_err(dev, "failed to retrieve <clock-frequency> from device tree\n"); 919 err = -EINVAL; 920 goto out_put_node; 921 } 922 } 923 924 id = arc_reg_get(priv, R_ID); 925 926 /* Check for EMAC revision 5 or 7, magic number */ 927 if (!(id == 0x0005fd02 || id == 0x0007fd02)) { 928 dev_err(dev, "ARC EMAC not detected, id=0x%x\n", id); 929 err = -ENODEV; 930 goto out_clken; 931 } 932 dev_info(dev, "ARC EMAC detected with id: 0x%x\n", id); 933 934 /* Set poll rate so that it polls every 1 ms */ 935 arc_reg_set(priv, R_POLLRATE, clock_frequency / 1000000); 936 937 ndev->irq = irq; 938 dev_info(dev, "IRQ is %d\n", ndev->irq); 939 940 /* Register interrupt handler for device */ 941 err = devm_request_irq(dev, ndev->irq, arc_emac_intr, 0, 942 ndev->name, ndev); 943 if (err) { 944 dev_err(dev, "could not allocate IRQ\n"); 945 goto out_clken; 946 } 947 948 /* Get MAC address from device tree */ 949 err = of_get_ethdev_address(dev->of_node, ndev); 950 if (err) 951 eth_hw_addr_random(ndev); 952 953 arc_emac_set_address_internal(ndev); 954 dev_info(dev, "MAC address is now %pM\n", ndev->dev_addr); 955 956 /* Do 1 allocation instead of 2 separate ones for Rx and Tx BD rings */ 957 priv->rxbd = dmam_alloc_coherent(dev, RX_RING_SZ + TX_RING_SZ, 958 &priv->rxbd_dma, GFP_KERNEL); 959 960 if (!priv->rxbd) { 961 dev_err(dev, "failed to allocate data buffers\n"); 962 err = -ENOMEM; 963 goto out_clken; 964 } 965 966 priv->txbd = priv->rxbd + RX_BD_NUM; 967 968 priv->txbd_dma = priv->rxbd_dma + RX_RING_SZ; 969 dev_dbg(dev, "EMAC Device addr: Rx Ring [0x%x], Tx Ring[%x]\n", 970 (unsigned int)priv->rxbd_dma, (unsigned int)priv->txbd_dma); 971 972 err = arc_mdio_probe(priv); 973 if (err) { 974 dev_err(dev, "failed to probe MII bus\n"); 975 goto out_clken; 976 } 977 978 phydev = of_phy_connect(ndev, phy_node, arc_emac_adjust_link, 0, 979 interface); 980 if (!phydev) { 981 dev_err(dev, "of_phy_connect() failed\n"); 982 err = -ENODEV; 983 goto out_mdio; 984 } 985 986 dev_info(dev, "connected to %s phy with id 0x%x\n", 987 phydev->drv->name, phydev->phy_id); 988 989 netif_napi_add_weight(ndev, &priv->napi, arc_emac_poll, 990 ARC_EMAC_NAPI_WEIGHT); 991 992 err = register_netdev(ndev); 993 if (err) { 994 dev_err(dev, "failed to register network device\n"); 995 goto out_netif_api; 996 } 997 998 of_node_put(phy_node); 999 return 0; 1000 1001 out_netif_api: 1002 netif_napi_del(&priv->napi); 1003 phy_disconnect(phydev); 1004 out_mdio: 1005 arc_mdio_remove(priv); 1006 out_clken: 1007 if (priv->clk) 1008 clk_disable_unprepare(priv->clk); 1009 out_put_node: 1010 of_node_put(phy_node); 1011 1012 return err; 1013 } 1014 EXPORT_SYMBOL_GPL(arc_emac_probe); 1015 1016 void arc_emac_remove(struct net_device *ndev) 1017 { 1018 struct arc_emac_priv *priv = netdev_priv(ndev); 1019 1020 phy_disconnect(ndev->phydev); 1021 arc_mdio_remove(priv); 1022 unregister_netdev(ndev); 1023 netif_napi_del(&priv->napi); 1024 1025 if (!IS_ERR(priv->clk)) 1026 clk_disable_unprepare(priv->clk); 1027 } 1028 EXPORT_SYMBOL_GPL(arc_emac_remove); 1029 1030 MODULE_AUTHOR("Alexey Brodkin <abrodkin@synopsys.com>"); 1031 MODULE_DESCRIPTION("ARC EMAC driver"); 1032 MODULE_LICENSE("GPL"); 1033