1 /* 2 * Allwinner EMAC Fast Ethernet driver for Linux. 3 * 4 * Copyright 2012-2013 Stefan Roese <sr@denx.de> 5 * Copyright 2013 Maxime Ripard <maxime.ripard@free-electrons.com> 6 * 7 * Based on the Linux driver provided by Allwinner: 8 * Copyright (C) 1997 Sten Wang 9 * 10 * This file is licensed under the terms of the GNU General Public 11 * License version 2. This program is licensed "as is" without any 12 * warranty of any kind, whether express or implied. 13 */ 14 15 #include <linux/clk.h> 16 #include <linux/etherdevice.h> 17 #include <linux/ethtool.h> 18 #include <linux/gpio.h> 19 #include <linux/interrupt.h> 20 #include <linux/irq.h> 21 #include <linux/mii.h> 22 #include <linux/module.h> 23 #include <linux/netdevice.h> 24 #include <linux/of_address.h> 25 #include <linux/of_irq.h> 26 #include <linux/of_mdio.h> 27 #include <linux/of_net.h> 28 #include <linux/of_platform.h> 29 #include <linux/platform_device.h> 30 #include <linux/phy.h> 31 32 #include "sun4i-emac.h" 33 34 #define DRV_NAME "sun4i-emac" 35 #define DRV_VERSION "1.02" 36 37 #define EMAC_MAX_FRAME_LEN 0x0600 38 39 /* Transmit timeout, default 5 seconds. */ 40 static int watchdog = 5000; 41 module_param(watchdog, int, 0400); 42 MODULE_PARM_DESC(watchdog, "transmit timeout in milliseconds"); 43 44 /* EMAC register address locking. 45 * 46 * The EMAC uses an address register to control where data written 47 * to the data register goes. This means that the address register 48 * must be preserved over interrupts or similar calls. 49 * 50 * During interrupt and other critical calls, a spinlock is used to 51 * protect the system, but the calls themselves save the address 52 * in the address register in case they are interrupting another 53 * access to the device. 54 * 55 * For general accesses a lock is provided so that calls which are 56 * allowed to sleep are serialised so that the address register does 57 * not need to be saved. This lock also serves to serialise access 58 * to the EEPROM and PHY access registers which are shared between 59 * these two devices. 60 */ 61 62 /* The driver supports the original EMACE, and now the two newer 63 * devices, EMACA and EMACB. 64 */ 65 66 struct emac_board_info { 67 struct clk *clk; 68 struct device *dev; 69 struct platform_device *pdev; 70 spinlock_t lock; 71 void __iomem *membase; 72 u32 msg_enable; 73 struct net_device *ndev; 74 struct sk_buff *skb_last; 75 u16 tx_fifo_stat; 76 77 int emacrx_completed_flag; 78 79 struct phy_device *phy_dev; 80 struct device_node *phy_node; 81 unsigned int link; 82 unsigned int speed; 83 unsigned int duplex; 84 85 phy_interface_t phy_interface; 86 }; 87 88 static void emac_update_speed(struct net_device *dev) 89 { 90 struct emac_board_info *db = netdev_priv(dev); 91 unsigned int reg_val; 92 93 /* set EMAC SPEED, depend on PHY */ 94 reg_val = readl(db->membase + EMAC_MAC_SUPP_REG); 95 reg_val &= ~(0x1 << 8); 96 if (db->speed == SPEED_100) 97 reg_val |= 1 << 8; 98 writel(reg_val, db->membase + EMAC_MAC_SUPP_REG); 99 } 100 101 static void emac_update_duplex(struct net_device *dev) 102 { 103 struct emac_board_info *db = netdev_priv(dev); 104 unsigned int reg_val; 105 106 /* set duplex depend on phy */ 107 reg_val = readl(db->membase + EMAC_MAC_CTL1_REG); 108 reg_val &= ~EMAC_MAC_CTL1_DUPLEX_EN; 109 if (db->duplex) 110 reg_val |= EMAC_MAC_CTL1_DUPLEX_EN; 111 writel(reg_val, db->membase + EMAC_MAC_CTL1_REG); 112 } 113 114 static void emac_handle_link_change(struct net_device *dev) 115 { 116 struct emac_board_info *db = netdev_priv(dev); 117 struct phy_device *phydev = db->phy_dev; 118 unsigned long flags; 119 int status_change = 0; 120 121 if (phydev->link) { 122 if (db->speed != phydev->speed) { 123 spin_lock_irqsave(&db->lock, flags); 124 db->speed = phydev->speed; 125 emac_update_speed(dev); 126 spin_unlock_irqrestore(&db->lock, flags); 127 status_change = 1; 128 } 129 130 if (db->duplex != phydev->duplex) { 131 spin_lock_irqsave(&db->lock, flags); 132 db->duplex = phydev->duplex; 133 emac_update_duplex(dev); 134 spin_unlock_irqrestore(&db->lock, flags); 135 status_change = 1; 136 } 137 } 138 139 if (phydev->link != db->link) { 140 if (!phydev->link) { 141 db->speed = 0; 142 db->duplex = -1; 143 } 144 db->link = phydev->link; 145 146 status_change = 1; 147 } 148 149 if (status_change) 150 phy_print_status(phydev); 151 } 152 153 static int emac_mdio_probe(struct net_device *dev) 154 { 155 struct emac_board_info *db = netdev_priv(dev); 156 157 /* to-do: PHY interrupts are currently not supported */ 158 159 /* attach the mac to the phy */ 160 db->phy_dev = of_phy_connect(db->ndev, db->phy_node, 161 &emac_handle_link_change, 0, 162 db->phy_interface); 163 if (!db->phy_dev) { 164 netdev_err(db->ndev, "could not find the PHY\n"); 165 return -ENODEV; 166 } 167 168 /* mask with MAC supported features */ 169 db->phy_dev->supported &= PHY_BASIC_FEATURES; 170 db->phy_dev->advertising = db->phy_dev->supported; 171 172 db->link = 0; 173 db->speed = 0; 174 db->duplex = -1; 175 176 return 0; 177 } 178 179 static void emac_mdio_remove(struct net_device *dev) 180 { 181 struct emac_board_info *db = netdev_priv(dev); 182 183 phy_disconnect(db->phy_dev); 184 db->phy_dev = NULL; 185 } 186 187 static void emac_reset(struct emac_board_info *db) 188 { 189 dev_dbg(db->dev, "resetting device\n"); 190 191 /* RESET device */ 192 writel(0, db->membase + EMAC_CTL_REG); 193 udelay(200); 194 writel(EMAC_CTL_RESET, db->membase + EMAC_CTL_REG); 195 udelay(200); 196 } 197 198 static void emac_outblk_32bit(void __iomem *reg, void *data, int count) 199 { 200 writesl(reg, data, round_up(count, 4) / 4); 201 } 202 203 static void emac_inblk_32bit(void __iomem *reg, void *data, int count) 204 { 205 readsl(reg, data, round_up(count, 4) / 4); 206 } 207 208 static int emac_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 209 { 210 struct emac_board_info *dm = netdev_priv(dev); 211 struct phy_device *phydev = dm->phy_dev; 212 213 if (!netif_running(dev)) 214 return -EINVAL; 215 216 if (!phydev) 217 return -ENODEV; 218 219 return phy_mii_ioctl(phydev, rq, cmd); 220 } 221 222 /* ethtool ops */ 223 static void emac_get_drvinfo(struct net_device *dev, 224 struct ethtool_drvinfo *info) 225 { 226 strlcpy(info->driver, DRV_NAME, sizeof(DRV_NAME)); 227 strlcpy(info->version, DRV_VERSION, sizeof(DRV_VERSION)); 228 strlcpy(info->bus_info, dev_name(&dev->dev), sizeof(info->bus_info)); 229 } 230 231 static int emac_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 232 { 233 struct emac_board_info *dm = netdev_priv(dev); 234 struct phy_device *phydev = dm->phy_dev; 235 236 if (!phydev) 237 return -ENODEV; 238 239 return phy_ethtool_gset(phydev, cmd); 240 } 241 242 static int emac_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) 243 { 244 struct emac_board_info *dm = netdev_priv(dev); 245 struct phy_device *phydev = dm->phy_dev; 246 247 if (!phydev) 248 return -ENODEV; 249 250 return phy_ethtool_sset(phydev, cmd); 251 } 252 253 static const struct ethtool_ops emac_ethtool_ops = { 254 .get_drvinfo = emac_get_drvinfo, 255 .get_settings = emac_get_settings, 256 .set_settings = emac_set_settings, 257 .get_link = ethtool_op_get_link, 258 }; 259 260 static unsigned int emac_setup(struct net_device *ndev) 261 { 262 struct emac_board_info *db = netdev_priv(ndev); 263 unsigned int reg_val; 264 265 /* set up TX */ 266 reg_val = readl(db->membase + EMAC_TX_MODE_REG); 267 268 writel(reg_val | EMAC_TX_MODE_ABORTED_FRAME_EN, 269 db->membase + EMAC_TX_MODE_REG); 270 271 /* set MAC */ 272 /* set MAC CTL0 */ 273 reg_val = readl(db->membase + EMAC_MAC_CTL0_REG); 274 writel(reg_val | EMAC_MAC_CTL0_RX_FLOW_CTL_EN | 275 EMAC_MAC_CTL0_TX_FLOW_CTL_EN, 276 db->membase + EMAC_MAC_CTL0_REG); 277 278 /* set MAC CTL1 */ 279 reg_val = readl(db->membase + EMAC_MAC_CTL1_REG); 280 reg_val |= EMAC_MAC_CTL1_LEN_CHECK_EN; 281 reg_val |= EMAC_MAC_CTL1_CRC_EN; 282 reg_val |= EMAC_MAC_CTL1_PAD_EN; 283 writel(reg_val, db->membase + EMAC_MAC_CTL1_REG); 284 285 /* set up IPGT */ 286 writel(EMAC_MAC_IPGT_FULL_DUPLEX, db->membase + EMAC_MAC_IPGT_REG); 287 288 /* set up IPGR */ 289 writel((EMAC_MAC_IPGR_IPG1 << 8) | EMAC_MAC_IPGR_IPG2, 290 db->membase + EMAC_MAC_IPGR_REG); 291 292 /* set up Collison window */ 293 writel((EMAC_MAC_CLRT_COLLISION_WINDOW << 8) | EMAC_MAC_CLRT_RM, 294 db->membase + EMAC_MAC_CLRT_REG); 295 296 /* set up Max Frame Length */ 297 writel(EMAC_MAX_FRAME_LEN, 298 db->membase + EMAC_MAC_MAXF_REG); 299 300 return 0; 301 } 302 303 static void emac_set_rx_mode(struct net_device *ndev) 304 { 305 struct emac_board_info *db = netdev_priv(ndev); 306 unsigned int reg_val; 307 308 /* set up RX */ 309 reg_val = readl(db->membase + EMAC_RX_CTL_REG); 310 311 if (ndev->flags & IFF_PROMISC) 312 reg_val |= EMAC_RX_CTL_PASS_ALL_EN; 313 else 314 reg_val &= ~EMAC_RX_CTL_PASS_ALL_EN; 315 316 writel(reg_val | EMAC_RX_CTL_PASS_LEN_OOR_EN | 317 EMAC_RX_CTL_ACCEPT_UNICAST_EN | EMAC_RX_CTL_DA_FILTER_EN | 318 EMAC_RX_CTL_ACCEPT_MULTICAST_EN | 319 EMAC_RX_CTL_ACCEPT_BROADCAST_EN, 320 db->membase + EMAC_RX_CTL_REG); 321 } 322 323 static unsigned int emac_powerup(struct net_device *ndev) 324 { 325 struct emac_board_info *db = netdev_priv(ndev); 326 unsigned int reg_val; 327 328 /* initial EMAC */ 329 /* flush RX FIFO */ 330 reg_val = readl(db->membase + EMAC_RX_CTL_REG); 331 reg_val |= 0x8; 332 writel(reg_val, db->membase + EMAC_RX_CTL_REG); 333 udelay(1); 334 335 /* initial MAC */ 336 /* soft reset MAC */ 337 reg_val = readl(db->membase + EMAC_MAC_CTL0_REG); 338 reg_val &= ~EMAC_MAC_CTL0_SOFT_RESET; 339 writel(reg_val, db->membase + EMAC_MAC_CTL0_REG); 340 341 /* set MII clock */ 342 reg_val = readl(db->membase + EMAC_MAC_MCFG_REG); 343 reg_val &= (~(0xf << 2)); 344 reg_val |= (0xD << 2); 345 writel(reg_val, db->membase + EMAC_MAC_MCFG_REG); 346 347 /* clear RX counter */ 348 writel(0x0, db->membase + EMAC_RX_FBC_REG); 349 350 /* disable all interrupt and clear interrupt status */ 351 writel(0, db->membase + EMAC_INT_CTL_REG); 352 reg_val = readl(db->membase + EMAC_INT_STA_REG); 353 writel(reg_val, db->membase + EMAC_INT_STA_REG); 354 355 udelay(1); 356 357 /* set up EMAC */ 358 emac_setup(ndev); 359 360 /* set mac_address to chip */ 361 writel(ndev->dev_addr[0] << 16 | ndev->dev_addr[1] << 8 | ndev-> 362 dev_addr[2], db->membase + EMAC_MAC_A1_REG); 363 writel(ndev->dev_addr[3] << 16 | ndev->dev_addr[4] << 8 | ndev-> 364 dev_addr[5], db->membase + EMAC_MAC_A0_REG); 365 366 mdelay(1); 367 368 return 0; 369 } 370 371 static int emac_set_mac_address(struct net_device *dev, void *p) 372 { 373 struct sockaddr *addr = p; 374 struct emac_board_info *db = netdev_priv(dev); 375 376 if (netif_running(dev)) 377 return -EBUSY; 378 379 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN); 380 381 writel(dev->dev_addr[0] << 16 | dev->dev_addr[1] << 8 | dev-> 382 dev_addr[2], db->membase + EMAC_MAC_A1_REG); 383 writel(dev->dev_addr[3] << 16 | dev->dev_addr[4] << 8 | dev-> 384 dev_addr[5], db->membase + EMAC_MAC_A0_REG); 385 386 return 0; 387 } 388 389 /* Initialize emac board */ 390 static void emac_init_device(struct net_device *dev) 391 { 392 struct emac_board_info *db = netdev_priv(dev); 393 unsigned long flags; 394 unsigned int reg_val; 395 396 spin_lock_irqsave(&db->lock, flags); 397 398 emac_update_speed(dev); 399 emac_update_duplex(dev); 400 401 /* enable RX/TX */ 402 reg_val = readl(db->membase + EMAC_CTL_REG); 403 writel(reg_val | EMAC_CTL_RESET | EMAC_CTL_TX_EN | EMAC_CTL_RX_EN, 404 db->membase + EMAC_CTL_REG); 405 406 /* enable RX/TX0/RX Hlevel interrup */ 407 reg_val = readl(db->membase + EMAC_INT_CTL_REG); 408 reg_val |= (0xf << 0) | (0x01 << 8); 409 writel(reg_val, db->membase + EMAC_INT_CTL_REG); 410 411 spin_unlock_irqrestore(&db->lock, flags); 412 } 413 414 /* Our watchdog timed out. Called by the networking layer */ 415 static void emac_timeout(struct net_device *dev) 416 { 417 struct emac_board_info *db = netdev_priv(dev); 418 unsigned long flags; 419 420 if (netif_msg_timer(db)) 421 dev_err(db->dev, "tx time out.\n"); 422 423 /* Save previous register address */ 424 spin_lock_irqsave(&db->lock, flags); 425 426 netif_stop_queue(dev); 427 emac_reset(db); 428 emac_init_device(dev); 429 /* We can accept TX packets again */ 430 dev->trans_start = jiffies; 431 netif_wake_queue(dev); 432 433 /* Restore previous register address */ 434 spin_unlock_irqrestore(&db->lock, flags); 435 } 436 437 /* Hardware start transmission. 438 * Send a packet to media from the upper layer. 439 */ 440 static int emac_start_xmit(struct sk_buff *skb, struct net_device *dev) 441 { 442 struct emac_board_info *db = netdev_priv(dev); 443 unsigned long channel; 444 unsigned long flags; 445 446 channel = db->tx_fifo_stat & 3; 447 if (channel == 3) 448 return 1; 449 450 channel = (channel == 1 ? 1 : 0); 451 452 spin_lock_irqsave(&db->lock, flags); 453 454 writel(channel, db->membase + EMAC_TX_INS_REG); 455 456 emac_outblk_32bit(db->membase + EMAC_TX_IO_DATA_REG, 457 skb->data, skb->len); 458 dev->stats.tx_bytes += skb->len; 459 460 db->tx_fifo_stat |= 1 << channel; 461 /* TX control: First packet immediately send, second packet queue */ 462 if (channel == 0) { 463 /* set TX len */ 464 writel(skb->len, db->membase + EMAC_TX_PL0_REG); 465 /* start translate from fifo to phy */ 466 writel(readl(db->membase + EMAC_TX_CTL0_REG) | 1, 467 db->membase + EMAC_TX_CTL0_REG); 468 469 /* save the time stamp */ 470 dev->trans_start = jiffies; 471 } else if (channel == 1) { 472 /* set TX len */ 473 writel(skb->len, db->membase + EMAC_TX_PL1_REG); 474 /* start translate from fifo to phy */ 475 writel(readl(db->membase + EMAC_TX_CTL1_REG) | 1, 476 db->membase + EMAC_TX_CTL1_REG); 477 478 /* save the time stamp */ 479 dev->trans_start = jiffies; 480 } 481 482 if ((db->tx_fifo_stat & 3) == 3) { 483 /* Second packet */ 484 netif_stop_queue(dev); 485 } 486 487 spin_unlock_irqrestore(&db->lock, flags); 488 489 /* free this SKB */ 490 dev_consume_skb_any(skb); 491 492 return NETDEV_TX_OK; 493 } 494 495 /* EMAC interrupt handler 496 * receive the packet to upper layer, free the transmitted packet 497 */ 498 static void emac_tx_done(struct net_device *dev, struct emac_board_info *db, 499 unsigned int tx_status) 500 { 501 /* One packet sent complete */ 502 db->tx_fifo_stat &= ~(tx_status & 3); 503 if (3 == (tx_status & 3)) 504 dev->stats.tx_packets += 2; 505 else 506 dev->stats.tx_packets++; 507 508 if (netif_msg_tx_done(db)) 509 dev_dbg(db->dev, "tx done, NSR %02x\n", tx_status); 510 511 netif_wake_queue(dev); 512 } 513 514 /* Received a packet and pass to upper layer 515 */ 516 static void emac_rx(struct net_device *dev) 517 { 518 struct emac_board_info *db = netdev_priv(dev); 519 struct sk_buff *skb; 520 u8 *rdptr; 521 bool good_packet; 522 static int rxlen_last; 523 unsigned int reg_val; 524 u32 rxhdr, rxstatus, rxcount, rxlen; 525 526 /* Check packet ready or not */ 527 while (1) { 528 /* race warning: the first packet might arrive with 529 * the interrupts disabled, but the second will fix 530 * it 531 */ 532 rxcount = readl(db->membase + EMAC_RX_FBC_REG); 533 534 if (netif_msg_rx_status(db)) 535 dev_dbg(db->dev, "RXCount: %x\n", rxcount); 536 537 if ((db->skb_last != NULL) && (rxlen_last > 0)) { 538 dev->stats.rx_bytes += rxlen_last; 539 540 /* Pass to upper layer */ 541 db->skb_last->protocol = eth_type_trans(db->skb_last, 542 dev); 543 netif_rx(db->skb_last); 544 dev->stats.rx_packets++; 545 db->skb_last = NULL; 546 rxlen_last = 0; 547 548 reg_val = readl(db->membase + EMAC_RX_CTL_REG); 549 reg_val &= ~EMAC_RX_CTL_DMA_EN; 550 writel(reg_val, db->membase + EMAC_RX_CTL_REG); 551 } 552 553 if (!rxcount) { 554 db->emacrx_completed_flag = 1; 555 reg_val = readl(db->membase + EMAC_INT_CTL_REG); 556 reg_val |= (0xf << 0) | (0x01 << 8); 557 writel(reg_val, db->membase + EMAC_INT_CTL_REG); 558 559 /* had one stuck? */ 560 rxcount = readl(db->membase + EMAC_RX_FBC_REG); 561 if (!rxcount) 562 return; 563 } 564 565 reg_val = readl(db->membase + EMAC_RX_IO_DATA_REG); 566 if (netif_msg_rx_status(db)) 567 dev_dbg(db->dev, "receive header: %x\n", reg_val); 568 if (reg_val != EMAC_UNDOCUMENTED_MAGIC) { 569 /* disable RX */ 570 reg_val = readl(db->membase + EMAC_CTL_REG); 571 writel(reg_val & ~EMAC_CTL_RX_EN, 572 db->membase + EMAC_CTL_REG); 573 574 /* Flush RX FIFO */ 575 reg_val = readl(db->membase + EMAC_RX_CTL_REG); 576 writel(reg_val | (1 << 3), 577 db->membase + EMAC_RX_CTL_REG); 578 579 do { 580 reg_val = readl(db->membase + EMAC_RX_CTL_REG); 581 } while (reg_val & (1 << 3)); 582 583 /* enable RX */ 584 reg_val = readl(db->membase + EMAC_CTL_REG); 585 writel(reg_val | EMAC_CTL_RX_EN, 586 db->membase + EMAC_CTL_REG); 587 reg_val = readl(db->membase + EMAC_INT_CTL_REG); 588 reg_val |= (0xf << 0) | (0x01 << 8); 589 writel(reg_val, db->membase + EMAC_INT_CTL_REG); 590 591 db->emacrx_completed_flag = 1; 592 593 return; 594 } 595 596 /* A packet ready now & Get status/length */ 597 good_packet = true; 598 599 emac_inblk_32bit(db->membase + EMAC_RX_IO_DATA_REG, 600 &rxhdr, sizeof(rxhdr)); 601 602 if (netif_msg_rx_status(db)) 603 dev_dbg(db->dev, "rxhdr: %x\n", *((int *)(&rxhdr))); 604 605 rxlen = EMAC_RX_IO_DATA_LEN(rxhdr); 606 rxstatus = EMAC_RX_IO_DATA_STATUS(rxhdr); 607 608 if (netif_msg_rx_status(db)) 609 dev_dbg(db->dev, "RX: status %02x, length %04x\n", 610 rxstatus, rxlen); 611 612 /* Packet Status check */ 613 if (rxlen < 0x40) { 614 good_packet = false; 615 if (netif_msg_rx_err(db)) 616 dev_dbg(db->dev, "RX: Bad Packet (runt)\n"); 617 } 618 619 if (unlikely(!(rxstatus & EMAC_RX_IO_DATA_STATUS_OK))) { 620 good_packet = false; 621 622 if (rxstatus & EMAC_RX_IO_DATA_STATUS_CRC_ERR) { 623 if (netif_msg_rx_err(db)) 624 dev_dbg(db->dev, "crc error\n"); 625 dev->stats.rx_crc_errors++; 626 } 627 628 if (rxstatus & EMAC_RX_IO_DATA_STATUS_LEN_ERR) { 629 if (netif_msg_rx_err(db)) 630 dev_dbg(db->dev, "length error\n"); 631 dev->stats.rx_length_errors++; 632 } 633 } 634 635 /* Move data from EMAC */ 636 skb = dev_alloc_skb(rxlen + 4); 637 if (good_packet && skb) { 638 skb_reserve(skb, 2); 639 rdptr = (u8 *) skb_put(skb, rxlen - 4); 640 641 /* Read received packet from RX SRAM */ 642 if (netif_msg_rx_status(db)) 643 dev_dbg(db->dev, "RxLen %x\n", rxlen); 644 645 emac_inblk_32bit(db->membase + EMAC_RX_IO_DATA_REG, 646 rdptr, rxlen); 647 dev->stats.rx_bytes += rxlen; 648 649 /* Pass to upper layer */ 650 skb->protocol = eth_type_trans(skb, dev); 651 netif_rx(skb); 652 dev->stats.rx_packets++; 653 } 654 } 655 } 656 657 static irqreturn_t emac_interrupt(int irq, void *dev_id) 658 { 659 struct net_device *dev = dev_id; 660 struct emac_board_info *db = netdev_priv(dev); 661 int int_status; 662 unsigned long flags; 663 unsigned int reg_val; 664 665 /* A real interrupt coming */ 666 667 /* holders of db->lock must always block IRQs */ 668 spin_lock_irqsave(&db->lock, flags); 669 670 /* Disable all interrupts */ 671 writel(0, db->membase + EMAC_INT_CTL_REG); 672 673 /* Got EMAC interrupt status */ 674 /* Got ISR */ 675 int_status = readl(db->membase + EMAC_INT_STA_REG); 676 /* Clear ISR status */ 677 writel(int_status, db->membase + EMAC_INT_STA_REG); 678 679 if (netif_msg_intr(db)) 680 dev_dbg(db->dev, "emac interrupt %02x\n", int_status); 681 682 /* Received the coming packet */ 683 if ((int_status & 0x100) && (db->emacrx_completed_flag == 1)) { 684 /* carrier lost */ 685 db->emacrx_completed_flag = 0; 686 emac_rx(dev); 687 } 688 689 /* Transmit Interrupt check */ 690 if (int_status & (0x01 | 0x02)) 691 emac_tx_done(dev, db, int_status); 692 693 if (int_status & (0x04 | 0x08)) 694 netdev_info(dev, " ab : %x\n", int_status); 695 696 /* Re-enable interrupt mask */ 697 if (db->emacrx_completed_flag == 1) { 698 reg_val = readl(db->membase + EMAC_INT_CTL_REG); 699 reg_val |= (0xf << 0) | (0x01 << 8); 700 writel(reg_val, db->membase + EMAC_INT_CTL_REG); 701 } 702 spin_unlock_irqrestore(&db->lock, flags); 703 704 return IRQ_HANDLED; 705 } 706 707 #ifdef CONFIG_NET_POLL_CONTROLLER 708 /* 709 * Used by netconsole 710 */ 711 static void emac_poll_controller(struct net_device *dev) 712 { 713 disable_irq(dev->irq); 714 emac_interrupt(dev->irq, dev); 715 enable_irq(dev->irq); 716 } 717 #endif 718 719 /* Open the interface. 720 * The interface is opened whenever "ifconfig" actives it. 721 */ 722 static int emac_open(struct net_device *dev) 723 { 724 struct emac_board_info *db = netdev_priv(dev); 725 int ret; 726 727 if (netif_msg_ifup(db)) 728 dev_dbg(db->dev, "enabling %s\n", dev->name); 729 730 if (request_irq(dev->irq, &emac_interrupt, 0, dev->name, dev)) 731 return -EAGAIN; 732 733 /* Initialize EMAC board */ 734 emac_reset(db); 735 emac_init_device(dev); 736 737 ret = emac_mdio_probe(dev); 738 if (ret < 0) { 739 free_irq(dev->irq, dev); 740 netdev_err(dev, "cannot probe MDIO bus\n"); 741 return ret; 742 } 743 744 phy_start(db->phy_dev); 745 netif_start_queue(dev); 746 747 return 0; 748 } 749 750 static void emac_shutdown(struct net_device *dev) 751 { 752 unsigned int reg_val; 753 struct emac_board_info *db = netdev_priv(dev); 754 755 /* Disable all interrupt */ 756 writel(0, db->membase + EMAC_INT_CTL_REG); 757 758 /* clear interupt status */ 759 reg_val = readl(db->membase + EMAC_INT_STA_REG); 760 writel(reg_val, db->membase + EMAC_INT_STA_REG); 761 762 /* Disable RX/TX */ 763 reg_val = readl(db->membase + EMAC_CTL_REG); 764 reg_val &= ~(EMAC_CTL_TX_EN | EMAC_CTL_RX_EN | EMAC_CTL_RESET); 765 writel(reg_val, db->membase + EMAC_CTL_REG); 766 } 767 768 /* Stop the interface. 769 * The interface is stopped when it is brought. 770 */ 771 static int emac_stop(struct net_device *ndev) 772 { 773 struct emac_board_info *db = netdev_priv(ndev); 774 775 if (netif_msg_ifdown(db)) 776 dev_dbg(db->dev, "shutting down %s\n", ndev->name); 777 778 netif_stop_queue(ndev); 779 netif_carrier_off(ndev); 780 781 phy_stop(db->phy_dev); 782 783 emac_mdio_remove(ndev); 784 785 emac_shutdown(ndev); 786 787 free_irq(ndev->irq, ndev); 788 789 return 0; 790 } 791 792 static const struct net_device_ops emac_netdev_ops = { 793 .ndo_open = emac_open, 794 .ndo_stop = emac_stop, 795 .ndo_start_xmit = emac_start_xmit, 796 .ndo_tx_timeout = emac_timeout, 797 .ndo_set_rx_mode = emac_set_rx_mode, 798 .ndo_do_ioctl = emac_ioctl, 799 .ndo_change_mtu = eth_change_mtu, 800 .ndo_validate_addr = eth_validate_addr, 801 .ndo_set_mac_address = emac_set_mac_address, 802 #ifdef CONFIG_NET_POLL_CONTROLLER 803 .ndo_poll_controller = emac_poll_controller, 804 #endif 805 }; 806 807 /* Search EMAC board, allocate space and register it 808 */ 809 static int emac_probe(struct platform_device *pdev) 810 { 811 struct device_node *np = pdev->dev.of_node; 812 struct emac_board_info *db; 813 struct net_device *ndev; 814 int ret = 0; 815 const char *mac_addr; 816 817 ndev = alloc_etherdev(sizeof(struct emac_board_info)); 818 if (!ndev) { 819 dev_err(&pdev->dev, "could not allocate device.\n"); 820 return -ENOMEM; 821 } 822 823 SET_NETDEV_DEV(ndev, &pdev->dev); 824 825 db = netdev_priv(ndev); 826 memset(db, 0, sizeof(*db)); 827 828 db->dev = &pdev->dev; 829 db->ndev = ndev; 830 db->pdev = pdev; 831 832 spin_lock_init(&db->lock); 833 834 db->membase = of_iomap(np, 0); 835 if (!db->membase) { 836 dev_err(&pdev->dev, "failed to remap registers\n"); 837 ret = -ENOMEM; 838 goto out; 839 } 840 841 /* fill in parameters for net-dev structure */ 842 ndev->base_addr = (unsigned long)db->membase; 843 ndev->irq = irq_of_parse_and_map(np, 0); 844 if (ndev->irq == -ENXIO) { 845 netdev_err(ndev, "No irq resource\n"); 846 ret = ndev->irq; 847 goto out; 848 } 849 850 db->clk = devm_clk_get(&pdev->dev, NULL); 851 if (IS_ERR(db->clk)) 852 goto out; 853 854 clk_prepare_enable(db->clk); 855 856 db->phy_node = of_parse_phandle(np, "phy", 0); 857 if (!db->phy_node) { 858 dev_err(&pdev->dev, "no associated PHY\n"); 859 ret = -ENODEV; 860 goto out; 861 } 862 863 /* Read MAC-address from DT */ 864 mac_addr = of_get_mac_address(np); 865 if (mac_addr) 866 memcpy(ndev->dev_addr, mac_addr, ETH_ALEN); 867 868 /* Check if the MAC address is valid, if not get a random one */ 869 if (!is_valid_ether_addr(ndev->dev_addr)) { 870 eth_hw_addr_random(ndev); 871 dev_warn(&pdev->dev, "using random MAC address %pM\n", 872 ndev->dev_addr); 873 } 874 875 db->emacrx_completed_flag = 1; 876 emac_powerup(ndev); 877 emac_reset(db); 878 879 ether_setup(ndev); 880 881 ndev->netdev_ops = &emac_netdev_ops; 882 ndev->watchdog_timeo = msecs_to_jiffies(watchdog); 883 ndev->ethtool_ops = &emac_ethtool_ops; 884 885 platform_set_drvdata(pdev, ndev); 886 887 /* Carrier starts down, phylib will bring it up */ 888 netif_carrier_off(ndev); 889 890 ret = register_netdev(ndev); 891 if (ret) { 892 dev_err(&pdev->dev, "Registering netdev failed!\n"); 893 ret = -ENODEV; 894 goto out; 895 } 896 897 dev_info(&pdev->dev, "%s: at %p, IRQ %d MAC: %pM\n", 898 ndev->name, db->membase, ndev->irq, ndev->dev_addr); 899 900 return 0; 901 902 out: 903 dev_err(db->dev, "not found (%d).\n", ret); 904 905 free_netdev(ndev); 906 907 return ret; 908 } 909 910 static int emac_remove(struct platform_device *pdev) 911 { 912 struct net_device *ndev = platform_get_drvdata(pdev); 913 914 unregister_netdev(ndev); 915 free_netdev(ndev); 916 917 dev_dbg(&pdev->dev, "released and freed device\n"); 918 return 0; 919 } 920 921 static int emac_suspend(struct platform_device *dev, pm_message_t state) 922 { 923 struct net_device *ndev = platform_get_drvdata(dev); 924 925 netif_carrier_off(ndev); 926 netif_device_detach(ndev); 927 emac_shutdown(ndev); 928 929 return 0; 930 } 931 932 static int emac_resume(struct platform_device *dev) 933 { 934 struct net_device *ndev = platform_get_drvdata(dev); 935 struct emac_board_info *db = netdev_priv(ndev); 936 937 emac_reset(db); 938 emac_init_device(ndev); 939 netif_device_attach(ndev); 940 941 return 0; 942 } 943 944 static const struct of_device_id emac_of_match[] = { 945 {.compatible = "allwinner,sun4i-a10-emac",}, 946 947 /* Deprecated */ 948 {.compatible = "allwinner,sun4i-emac",}, 949 {}, 950 }; 951 952 MODULE_DEVICE_TABLE(of, emac_of_match); 953 954 static struct platform_driver emac_driver = { 955 .driver = { 956 .name = "sun4i-emac", 957 .of_match_table = emac_of_match, 958 }, 959 .probe = emac_probe, 960 .remove = emac_remove, 961 .suspend = emac_suspend, 962 .resume = emac_resume, 963 }; 964 965 module_platform_driver(emac_driver); 966 967 MODULE_AUTHOR("Stefan Roese <sr@denx.de>"); 968 MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>"); 969 MODULE_DESCRIPTION("Allwinner A10 emac network driver"); 970 MODULE_LICENSE("GPL"); 971