1 /* 2 * Driver for the MPC5200 Fast Ethernet Controller 3 * 4 * Originally written by Dale Farnsworth <dfarnsworth@mvista.com> and 5 * now maintained by Sylvain Munaut <tnt@246tNt.com> 6 * 7 * Copyright (C) 2007 Domen Puncer, Telargo, Inc. 8 * Copyright (C) 2007 Sylvain Munaut <tnt@246tNt.com> 9 * Copyright (C) 2003-2004 MontaVista, Software, Inc. 10 * 11 * This file is licensed under the terms of the GNU General Public License 12 * version 2. This program is licensed "as is" without any warranty of any 13 * kind, whether express or implied. 14 * 15 */ 16 17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 18 19 #include <linux/dma-mapping.h> 20 #include <linux/module.h> 21 22 #include <linux/kernel.h> 23 #include <linux/types.h> 24 #include <linux/spinlock.h> 25 #include <linux/slab.h> 26 #include <linux/errno.h> 27 #include <linux/init.h> 28 #include <linux/interrupt.h> 29 #include <linux/crc32.h> 30 #include <linux/hardirq.h> 31 #include <linux/delay.h> 32 #include <linux/of_address.h> 33 #include <linux/of_device.h> 34 #include <linux/of_irq.h> 35 #include <linux/of_mdio.h> 36 #include <linux/of_net.h> 37 #include <linux/of_platform.h> 38 39 #include <linux/netdevice.h> 40 #include <linux/etherdevice.h> 41 #include <linux/ethtool.h> 42 #include <linux/skbuff.h> 43 44 #include <asm/io.h> 45 #include <asm/delay.h> 46 #include <asm/mpc52xx.h> 47 48 #include <linux/fsl/bestcomm/bestcomm.h> 49 #include <linux/fsl/bestcomm/fec.h> 50 51 #include "fec_mpc52xx.h" 52 53 #define DRIVER_NAME "mpc52xx-fec" 54 55 /* Private driver data structure */ 56 struct mpc52xx_fec_priv { 57 struct net_device *ndev; 58 int duplex; 59 int speed; 60 int r_irq; 61 int t_irq; 62 struct mpc52xx_fec __iomem *fec; 63 struct bcom_task *rx_dmatsk; 64 struct bcom_task *tx_dmatsk; 65 spinlock_t lock; 66 int msg_enable; 67 68 /* MDIO link details */ 69 unsigned int mdio_speed; 70 struct device_node *phy_node; 71 enum phy_state link; 72 int seven_wire_mode; 73 }; 74 75 76 static irqreturn_t mpc52xx_fec_interrupt(int, void *); 77 static irqreturn_t mpc52xx_fec_rx_interrupt(int, void *); 78 static irqreturn_t mpc52xx_fec_tx_interrupt(int, void *); 79 static void mpc52xx_fec_stop(struct net_device *dev, bool may_sleep); 80 static void mpc52xx_fec_start(struct net_device *dev); 81 static void mpc52xx_fec_reset(struct net_device *dev); 82 83 #define MPC52xx_MESSAGES_DEFAULT ( NETIF_MSG_DRV | NETIF_MSG_PROBE | \ 84 NETIF_MSG_LINK | NETIF_MSG_IFDOWN | NETIF_MSG_IFUP) 85 static int debug = -1; /* the above default */ 86 module_param(debug, int, 0); 87 MODULE_PARM_DESC(debug, "debugging messages level"); 88 89 static void mpc52xx_fec_tx_timeout(struct net_device *dev, unsigned int txqueue) 90 { 91 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 92 unsigned long flags; 93 94 dev_warn(&dev->dev, "transmit timed out\n"); 95 96 spin_lock_irqsave(&priv->lock, flags); 97 mpc52xx_fec_reset(dev); 98 dev->stats.tx_errors++; 99 spin_unlock_irqrestore(&priv->lock, flags); 100 101 netif_wake_queue(dev); 102 } 103 104 static void mpc52xx_fec_set_paddr(struct net_device *dev, const u8 *mac) 105 { 106 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 107 struct mpc52xx_fec __iomem *fec = priv->fec; 108 109 out_be32(&fec->paddr1, *(const u32 *)(&mac[0])); 110 out_be32(&fec->paddr2, (*(const u16 *)(&mac[4]) << 16) | FEC_PADDR2_TYPE); 111 } 112 113 static int mpc52xx_fec_set_mac_address(struct net_device *dev, void *addr) 114 { 115 struct sockaddr *sock = addr; 116 117 eth_hw_addr_set(dev, sock->sa_data); 118 119 mpc52xx_fec_set_paddr(dev, sock->sa_data); 120 return 0; 121 } 122 123 static void mpc52xx_fec_free_rx_buffers(struct net_device *dev, struct bcom_task *s) 124 { 125 while (!bcom_queue_empty(s)) { 126 struct bcom_fec_bd *bd; 127 struct sk_buff *skb; 128 129 skb = bcom_retrieve_buffer(s, NULL, (struct bcom_bd **)&bd); 130 dma_unmap_single(dev->dev.parent, bd->skb_pa, skb->len, 131 DMA_FROM_DEVICE); 132 kfree_skb(skb); 133 } 134 } 135 136 static void 137 mpc52xx_fec_rx_submit(struct net_device *dev, struct sk_buff *rskb) 138 { 139 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 140 struct bcom_fec_bd *bd; 141 142 bd = (struct bcom_fec_bd *) bcom_prepare_next_buffer(priv->rx_dmatsk); 143 bd->status = FEC_RX_BUFFER_SIZE; 144 bd->skb_pa = dma_map_single(dev->dev.parent, rskb->data, 145 FEC_RX_BUFFER_SIZE, DMA_FROM_DEVICE); 146 bcom_submit_next_buffer(priv->rx_dmatsk, rskb); 147 } 148 149 static int mpc52xx_fec_alloc_rx_buffers(struct net_device *dev, struct bcom_task *rxtsk) 150 { 151 struct sk_buff *skb; 152 153 while (!bcom_queue_full(rxtsk)) { 154 skb = netdev_alloc_skb(dev, FEC_RX_BUFFER_SIZE); 155 if (!skb) 156 return -EAGAIN; 157 158 /* zero out the initial receive buffers to aid debugging */ 159 memset(skb->data, 0, FEC_RX_BUFFER_SIZE); 160 mpc52xx_fec_rx_submit(dev, skb); 161 } 162 return 0; 163 } 164 165 /* based on generic_adjust_link from fs_enet-main.c */ 166 static void mpc52xx_fec_adjust_link(struct net_device *dev) 167 { 168 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 169 struct phy_device *phydev = dev->phydev; 170 int new_state = 0; 171 172 if (phydev->link != PHY_DOWN) { 173 if (phydev->duplex != priv->duplex) { 174 struct mpc52xx_fec __iomem *fec = priv->fec; 175 u32 rcntrl; 176 u32 tcntrl; 177 178 new_state = 1; 179 priv->duplex = phydev->duplex; 180 181 rcntrl = in_be32(&fec->r_cntrl); 182 tcntrl = in_be32(&fec->x_cntrl); 183 184 rcntrl &= ~FEC_RCNTRL_DRT; 185 tcntrl &= ~FEC_TCNTRL_FDEN; 186 if (phydev->duplex == DUPLEX_FULL) 187 tcntrl |= FEC_TCNTRL_FDEN; /* FD enable */ 188 else 189 rcntrl |= FEC_RCNTRL_DRT; /* disable Rx on Tx (HD) */ 190 191 out_be32(&fec->r_cntrl, rcntrl); 192 out_be32(&fec->x_cntrl, tcntrl); 193 } 194 195 if (phydev->speed != priv->speed) { 196 new_state = 1; 197 priv->speed = phydev->speed; 198 } 199 200 if (priv->link == PHY_DOWN) { 201 new_state = 1; 202 priv->link = phydev->link; 203 } 204 205 } else if (priv->link) { 206 new_state = 1; 207 priv->link = PHY_DOWN; 208 priv->speed = 0; 209 priv->duplex = -1; 210 } 211 212 if (new_state && netif_msg_link(priv)) 213 phy_print_status(phydev); 214 } 215 216 static int mpc52xx_fec_open(struct net_device *dev) 217 { 218 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 219 struct phy_device *phydev = NULL; 220 int err = -EBUSY; 221 222 if (priv->phy_node) { 223 phydev = of_phy_connect(priv->ndev, priv->phy_node, 224 mpc52xx_fec_adjust_link, 0, 0); 225 if (!phydev) { 226 dev_err(&dev->dev, "of_phy_connect failed\n"); 227 return -ENODEV; 228 } 229 phy_start(phydev); 230 } 231 232 if (request_irq(dev->irq, mpc52xx_fec_interrupt, IRQF_SHARED, 233 DRIVER_NAME "_ctrl", dev)) { 234 dev_err(&dev->dev, "ctrl interrupt request failed\n"); 235 goto free_phy; 236 } 237 if (request_irq(priv->r_irq, mpc52xx_fec_rx_interrupt, 0, 238 DRIVER_NAME "_rx", dev)) { 239 dev_err(&dev->dev, "rx interrupt request failed\n"); 240 goto free_ctrl_irq; 241 } 242 if (request_irq(priv->t_irq, mpc52xx_fec_tx_interrupt, 0, 243 DRIVER_NAME "_tx", dev)) { 244 dev_err(&dev->dev, "tx interrupt request failed\n"); 245 goto free_2irqs; 246 } 247 248 bcom_fec_rx_reset(priv->rx_dmatsk); 249 bcom_fec_tx_reset(priv->tx_dmatsk); 250 251 err = mpc52xx_fec_alloc_rx_buffers(dev, priv->rx_dmatsk); 252 if (err) { 253 dev_err(&dev->dev, "mpc52xx_fec_alloc_rx_buffers failed\n"); 254 goto free_irqs; 255 } 256 257 bcom_enable(priv->rx_dmatsk); 258 bcom_enable(priv->tx_dmatsk); 259 260 mpc52xx_fec_start(dev); 261 262 netif_start_queue(dev); 263 264 return 0; 265 266 free_irqs: 267 free_irq(priv->t_irq, dev); 268 free_2irqs: 269 free_irq(priv->r_irq, dev); 270 free_ctrl_irq: 271 free_irq(dev->irq, dev); 272 free_phy: 273 if (phydev) { 274 phy_stop(phydev); 275 phy_disconnect(phydev); 276 } 277 278 return err; 279 } 280 281 static int mpc52xx_fec_close(struct net_device *dev) 282 { 283 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 284 struct phy_device *phydev = dev->phydev; 285 286 netif_stop_queue(dev); 287 288 mpc52xx_fec_stop(dev, true); 289 290 mpc52xx_fec_free_rx_buffers(dev, priv->rx_dmatsk); 291 292 free_irq(dev->irq, dev); 293 free_irq(priv->r_irq, dev); 294 free_irq(priv->t_irq, dev); 295 296 if (phydev) { 297 /* power down phy */ 298 phy_stop(phydev); 299 phy_disconnect(phydev); 300 } 301 302 return 0; 303 } 304 305 /* This will only be invoked if your driver is _not_ in XOFF state. 306 * What this means is that you need not check it, and that this 307 * invariant will hold if you make sure that the netif_*_queue() 308 * calls are done at the proper times. 309 */ 310 static netdev_tx_t 311 mpc52xx_fec_start_xmit(struct sk_buff *skb, struct net_device *dev) 312 { 313 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 314 struct bcom_fec_bd *bd; 315 unsigned long flags; 316 317 if (bcom_queue_full(priv->tx_dmatsk)) { 318 if (net_ratelimit()) 319 dev_err(&dev->dev, "transmit queue overrun\n"); 320 return NETDEV_TX_BUSY; 321 } 322 323 spin_lock_irqsave(&priv->lock, flags); 324 325 bd = (struct bcom_fec_bd *) 326 bcom_prepare_next_buffer(priv->tx_dmatsk); 327 328 bd->status = skb->len | BCOM_FEC_TX_BD_TFD | BCOM_FEC_TX_BD_TC; 329 bd->skb_pa = dma_map_single(dev->dev.parent, skb->data, skb->len, 330 DMA_TO_DEVICE); 331 332 skb_tx_timestamp(skb); 333 bcom_submit_next_buffer(priv->tx_dmatsk, skb); 334 spin_unlock_irqrestore(&priv->lock, flags); 335 336 if (bcom_queue_full(priv->tx_dmatsk)) { 337 netif_stop_queue(dev); 338 } 339 340 return NETDEV_TX_OK; 341 } 342 343 #ifdef CONFIG_NET_POLL_CONTROLLER 344 static void mpc52xx_fec_poll_controller(struct net_device *dev) 345 { 346 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 347 348 disable_irq(priv->t_irq); 349 mpc52xx_fec_tx_interrupt(priv->t_irq, dev); 350 enable_irq(priv->t_irq); 351 disable_irq(priv->r_irq); 352 mpc52xx_fec_rx_interrupt(priv->r_irq, dev); 353 enable_irq(priv->r_irq); 354 } 355 #endif 356 357 358 /* This handles BestComm transmit task interrupts 359 */ 360 static irqreturn_t mpc52xx_fec_tx_interrupt(int irq, void *dev_id) 361 { 362 struct net_device *dev = dev_id; 363 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 364 365 spin_lock(&priv->lock); 366 while (bcom_buffer_done(priv->tx_dmatsk)) { 367 struct sk_buff *skb; 368 struct bcom_fec_bd *bd; 369 skb = bcom_retrieve_buffer(priv->tx_dmatsk, NULL, 370 (struct bcom_bd **)&bd); 371 dma_unmap_single(dev->dev.parent, bd->skb_pa, skb->len, 372 DMA_TO_DEVICE); 373 374 dev_consume_skb_irq(skb); 375 } 376 spin_unlock(&priv->lock); 377 378 netif_wake_queue(dev); 379 380 return IRQ_HANDLED; 381 } 382 383 static irqreturn_t mpc52xx_fec_rx_interrupt(int irq, void *dev_id) 384 { 385 struct net_device *dev = dev_id; 386 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 387 struct sk_buff *rskb; /* received sk_buff */ 388 struct sk_buff *skb; /* new sk_buff to enqueue in its place */ 389 struct bcom_fec_bd *bd; 390 u32 status, physaddr; 391 int length; 392 393 spin_lock(&priv->lock); 394 395 while (bcom_buffer_done(priv->rx_dmatsk)) { 396 397 rskb = bcom_retrieve_buffer(priv->rx_dmatsk, &status, 398 (struct bcom_bd **)&bd); 399 physaddr = bd->skb_pa; 400 401 /* Test for errors in received frame */ 402 if (status & BCOM_FEC_RX_BD_ERRORS) { 403 /* Drop packet and reuse the buffer */ 404 mpc52xx_fec_rx_submit(dev, rskb); 405 dev->stats.rx_dropped++; 406 continue; 407 } 408 409 /* skbs are allocated on open, so now we allocate a new one, 410 * and remove the old (with the packet) */ 411 skb = netdev_alloc_skb(dev, FEC_RX_BUFFER_SIZE); 412 if (!skb) { 413 /* Can't get a new one : reuse the same & drop pkt */ 414 dev_notice(&dev->dev, "Low memory - dropped packet.\n"); 415 mpc52xx_fec_rx_submit(dev, rskb); 416 dev->stats.rx_dropped++; 417 continue; 418 } 419 420 /* Enqueue the new sk_buff back on the hardware */ 421 mpc52xx_fec_rx_submit(dev, skb); 422 423 /* Process the received skb - Drop the spin lock while 424 * calling into the network stack */ 425 spin_unlock(&priv->lock); 426 427 dma_unmap_single(dev->dev.parent, physaddr, rskb->len, 428 DMA_FROM_DEVICE); 429 length = status & BCOM_FEC_RX_BD_LEN_MASK; 430 skb_put(rskb, length - 4); /* length without CRC32 */ 431 rskb->protocol = eth_type_trans(rskb, dev); 432 if (!skb_defer_rx_timestamp(rskb)) 433 netif_rx(rskb); 434 435 spin_lock(&priv->lock); 436 } 437 438 spin_unlock(&priv->lock); 439 440 return IRQ_HANDLED; 441 } 442 443 static irqreturn_t mpc52xx_fec_interrupt(int irq, void *dev_id) 444 { 445 struct net_device *dev = dev_id; 446 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 447 struct mpc52xx_fec __iomem *fec = priv->fec; 448 u32 ievent; 449 450 ievent = in_be32(&fec->ievent); 451 452 ievent &= ~FEC_IEVENT_MII; /* mii is handled separately */ 453 if (!ievent) 454 return IRQ_NONE; 455 456 out_be32(&fec->ievent, ievent); /* clear pending events */ 457 458 /* on fifo error, soft-reset fec */ 459 if (ievent & (FEC_IEVENT_RFIFO_ERROR | FEC_IEVENT_XFIFO_ERROR)) { 460 461 if (net_ratelimit() && (ievent & FEC_IEVENT_RFIFO_ERROR)) 462 dev_warn(&dev->dev, "FEC_IEVENT_RFIFO_ERROR\n"); 463 if (net_ratelimit() && (ievent & FEC_IEVENT_XFIFO_ERROR)) 464 dev_warn(&dev->dev, "FEC_IEVENT_XFIFO_ERROR\n"); 465 466 spin_lock(&priv->lock); 467 mpc52xx_fec_reset(dev); 468 spin_unlock(&priv->lock); 469 470 return IRQ_HANDLED; 471 } 472 473 if (ievent & ~FEC_IEVENT_TFINT) 474 dev_dbg(&dev->dev, "ievent: %08x\n", ievent); 475 476 return IRQ_HANDLED; 477 } 478 479 /* 480 * Get the current statistics. 481 * This may be called with the card open or closed. 482 */ 483 static struct net_device_stats *mpc52xx_fec_get_stats(struct net_device *dev) 484 { 485 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 486 struct net_device_stats *stats = &dev->stats; 487 struct mpc52xx_fec __iomem *fec = priv->fec; 488 489 stats->rx_bytes = in_be32(&fec->rmon_r_octets); 490 stats->rx_packets = in_be32(&fec->rmon_r_packets); 491 stats->rx_errors = in_be32(&fec->rmon_r_crc_align) + 492 in_be32(&fec->rmon_r_undersize) + 493 in_be32(&fec->rmon_r_oversize) + 494 in_be32(&fec->rmon_r_frag) + 495 in_be32(&fec->rmon_r_jab); 496 497 stats->tx_bytes = in_be32(&fec->rmon_t_octets); 498 stats->tx_packets = in_be32(&fec->rmon_t_packets); 499 stats->tx_errors = in_be32(&fec->rmon_t_crc_align) + 500 in_be32(&fec->rmon_t_undersize) + 501 in_be32(&fec->rmon_t_oversize) + 502 in_be32(&fec->rmon_t_frag) + 503 in_be32(&fec->rmon_t_jab); 504 505 stats->multicast = in_be32(&fec->rmon_r_mc_pkt); 506 stats->collisions = in_be32(&fec->rmon_t_col); 507 508 /* detailed rx_errors: */ 509 stats->rx_length_errors = in_be32(&fec->rmon_r_undersize) 510 + in_be32(&fec->rmon_r_oversize) 511 + in_be32(&fec->rmon_r_frag) 512 + in_be32(&fec->rmon_r_jab); 513 stats->rx_over_errors = in_be32(&fec->r_macerr); 514 stats->rx_crc_errors = in_be32(&fec->ieee_r_crc); 515 stats->rx_frame_errors = in_be32(&fec->ieee_r_align); 516 stats->rx_fifo_errors = in_be32(&fec->rmon_r_drop); 517 stats->rx_missed_errors = in_be32(&fec->rmon_r_drop); 518 519 /* detailed tx_errors: */ 520 stats->tx_aborted_errors = 0; 521 stats->tx_carrier_errors = in_be32(&fec->ieee_t_cserr); 522 stats->tx_fifo_errors = in_be32(&fec->rmon_t_drop); 523 stats->tx_heartbeat_errors = in_be32(&fec->ieee_t_sqe); 524 stats->tx_window_errors = in_be32(&fec->ieee_t_lcol); 525 526 return stats; 527 } 528 529 /* 530 * Read MIB counters in order to reset them, 531 * then zero all the stats fields in memory 532 */ 533 static void mpc52xx_fec_reset_stats(struct net_device *dev) 534 { 535 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 536 struct mpc52xx_fec __iomem *fec = priv->fec; 537 538 out_be32(&fec->mib_control, FEC_MIB_DISABLE); 539 memset_io(&fec->rmon_t_drop, 0, 540 offsetof(struct mpc52xx_fec, reserved10) - 541 offsetof(struct mpc52xx_fec, rmon_t_drop)); 542 out_be32(&fec->mib_control, 0); 543 544 memset(&dev->stats, 0, sizeof(dev->stats)); 545 } 546 547 /* 548 * Set or clear the multicast filter for this adaptor. 549 */ 550 static void mpc52xx_fec_set_multicast_list(struct net_device *dev) 551 { 552 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 553 struct mpc52xx_fec __iomem *fec = priv->fec; 554 u32 rx_control; 555 556 rx_control = in_be32(&fec->r_cntrl); 557 558 if (dev->flags & IFF_PROMISC) { 559 rx_control |= FEC_RCNTRL_PROM; 560 out_be32(&fec->r_cntrl, rx_control); 561 } else { 562 rx_control &= ~FEC_RCNTRL_PROM; 563 out_be32(&fec->r_cntrl, rx_control); 564 565 if (dev->flags & IFF_ALLMULTI) { 566 out_be32(&fec->gaddr1, 0xffffffff); 567 out_be32(&fec->gaddr2, 0xffffffff); 568 } else { 569 u32 crc; 570 struct netdev_hw_addr *ha; 571 u32 gaddr1 = 0x00000000; 572 u32 gaddr2 = 0x00000000; 573 574 netdev_for_each_mc_addr(ha, dev) { 575 crc = ether_crc_le(6, ha->addr) >> 26; 576 if (crc >= 32) 577 gaddr1 |= 1 << (crc-32); 578 else 579 gaddr2 |= 1 << crc; 580 } 581 out_be32(&fec->gaddr1, gaddr1); 582 out_be32(&fec->gaddr2, gaddr2); 583 } 584 } 585 } 586 587 /** 588 * mpc52xx_fec_hw_init 589 * @dev: network device 590 * 591 * Setup various hardware setting, only needed once on start 592 */ 593 static void mpc52xx_fec_hw_init(struct net_device *dev) 594 { 595 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 596 struct mpc52xx_fec __iomem *fec = priv->fec; 597 int i; 598 599 /* Whack a reset. We should wait for this. */ 600 out_be32(&fec->ecntrl, FEC_ECNTRL_RESET); 601 for (i = 0; i < FEC_RESET_DELAY; ++i) { 602 if ((in_be32(&fec->ecntrl) & FEC_ECNTRL_RESET) == 0) 603 break; 604 udelay(1); 605 } 606 if (i == FEC_RESET_DELAY) 607 dev_err(&dev->dev, "FEC Reset timeout!\n"); 608 609 /* set pause to 0x20 frames */ 610 out_be32(&fec->op_pause, FEC_OP_PAUSE_OPCODE | 0x20); 611 612 /* high service request will be deasserted when there's < 7 bytes in fifo 613 * low service request will be deasserted when there's < 4*7 bytes in fifo 614 */ 615 out_be32(&fec->rfifo_cntrl, FEC_FIFO_CNTRL_FRAME | FEC_FIFO_CNTRL_LTG_7); 616 out_be32(&fec->tfifo_cntrl, FEC_FIFO_CNTRL_FRAME | FEC_FIFO_CNTRL_LTG_7); 617 618 /* alarm when <= x bytes in FIFO */ 619 out_be32(&fec->rfifo_alarm, 0x0000030c); 620 out_be32(&fec->tfifo_alarm, 0x00000100); 621 622 /* begin transmittion when 256 bytes are in FIFO (or EOF or FIFO full) */ 623 out_be32(&fec->x_wmrk, FEC_FIFO_WMRK_256B); 624 625 /* enable crc generation */ 626 out_be32(&fec->xmit_fsm, FEC_XMIT_FSM_APPEND_CRC | FEC_XMIT_FSM_ENABLE_CRC); 627 out_be32(&fec->iaddr1, 0x00000000); /* No individual filter */ 628 out_be32(&fec->iaddr2, 0x00000000); /* No individual filter */ 629 630 /* set phy speed. 631 * this can't be done in phy driver, since it needs to be called 632 * before fec stuff (even on resume) */ 633 out_be32(&fec->mii_speed, priv->mdio_speed); 634 } 635 636 /** 637 * mpc52xx_fec_start 638 * @dev: network device 639 * 640 * This function is called to start or restart the FEC during a link 641 * change. This happens on fifo errors or when switching between half 642 * and full duplex. 643 */ 644 static void mpc52xx_fec_start(struct net_device *dev) 645 { 646 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 647 struct mpc52xx_fec __iomem *fec = priv->fec; 648 u32 rcntrl; 649 u32 tcntrl; 650 u32 tmp; 651 652 /* clear sticky error bits */ 653 tmp = FEC_FIFO_STATUS_ERR | FEC_FIFO_STATUS_UF | FEC_FIFO_STATUS_OF; 654 out_be32(&fec->rfifo_status, in_be32(&fec->rfifo_status) & tmp); 655 out_be32(&fec->tfifo_status, in_be32(&fec->tfifo_status) & tmp); 656 657 /* FIFOs will reset on mpc52xx_fec_enable */ 658 out_be32(&fec->reset_cntrl, FEC_RESET_CNTRL_ENABLE_IS_RESET); 659 660 /* Set station address. */ 661 mpc52xx_fec_set_paddr(dev, dev->dev_addr); 662 663 mpc52xx_fec_set_multicast_list(dev); 664 665 /* set max frame len, enable flow control, select mii mode */ 666 rcntrl = FEC_RX_BUFFER_SIZE << 16; /* max frame length */ 667 rcntrl |= FEC_RCNTRL_FCE; 668 669 if (!priv->seven_wire_mode) 670 rcntrl |= FEC_RCNTRL_MII_MODE; 671 672 if (priv->duplex == DUPLEX_FULL) 673 tcntrl = FEC_TCNTRL_FDEN; /* FD enable */ 674 else { 675 rcntrl |= FEC_RCNTRL_DRT; /* disable Rx on Tx (HD) */ 676 tcntrl = 0; 677 } 678 out_be32(&fec->r_cntrl, rcntrl); 679 out_be32(&fec->x_cntrl, tcntrl); 680 681 /* Clear any outstanding interrupt. */ 682 out_be32(&fec->ievent, 0xffffffff); 683 684 /* Enable interrupts we wish to service. */ 685 out_be32(&fec->imask, FEC_IMASK_ENABLE); 686 687 /* And last, enable the transmit and receive processing. */ 688 out_be32(&fec->ecntrl, FEC_ECNTRL_ETHER_EN); 689 out_be32(&fec->r_des_active, 0x01000000); 690 } 691 692 /** 693 * mpc52xx_fec_stop 694 * @dev: network device 695 * 696 * stop all activity on fec and empty dma buffers 697 */ 698 static void mpc52xx_fec_stop(struct net_device *dev, bool may_sleep) 699 { 700 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 701 struct mpc52xx_fec __iomem *fec = priv->fec; 702 unsigned long timeout; 703 704 /* disable all interrupts */ 705 out_be32(&fec->imask, 0); 706 707 /* Disable the rx task. */ 708 bcom_disable(priv->rx_dmatsk); 709 710 /* Wait for tx queue to drain, but only if we're in process context */ 711 if (may_sleep) { 712 timeout = jiffies + msecs_to_jiffies(2000); 713 while (time_before(jiffies, timeout) && 714 !bcom_queue_empty(priv->tx_dmatsk)) 715 msleep(100); 716 717 if (time_after_eq(jiffies, timeout)) 718 dev_err(&dev->dev, "queues didn't drain\n"); 719 #if 1 720 if (time_after_eq(jiffies, timeout)) { 721 dev_err(&dev->dev, " tx: index: %i, outdex: %i\n", 722 priv->tx_dmatsk->index, 723 priv->tx_dmatsk->outdex); 724 dev_err(&dev->dev, " rx: index: %i, outdex: %i\n", 725 priv->rx_dmatsk->index, 726 priv->rx_dmatsk->outdex); 727 } 728 #endif 729 } 730 731 bcom_disable(priv->tx_dmatsk); 732 733 /* Stop FEC */ 734 out_be32(&fec->ecntrl, in_be32(&fec->ecntrl) & ~FEC_ECNTRL_ETHER_EN); 735 } 736 737 /* reset fec and bestcomm tasks */ 738 static void mpc52xx_fec_reset(struct net_device *dev) 739 { 740 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 741 struct mpc52xx_fec __iomem *fec = priv->fec; 742 743 mpc52xx_fec_stop(dev, false); 744 745 out_be32(&fec->rfifo_status, in_be32(&fec->rfifo_status)); 746 out_be32(&fec->reset_cntrl, FEC_RESET_CNTRL_RESET_FIFO); 747 748 mpc52xx_fec_free_rx_buffers(dev, priv->rx_dmatsk); 749 750 mpc52xx_fec_hw_init(dev); 751 752 bcom_fec_rx_reset(priv->rx_dmatsk); 753 bcom_fec_tx_reset(priv->tx_dmatsk); 754 755 mpc52xx_fec_alloc_rx_buffers(dev, priv->rx_dmatsk); 756 757 bcom_enable(priv->rx_dmatsk); 758 bcom_enable(priv->tx_dmatsk); 759 760 mpc52xx_fec_start(dev); 761 762 netif_wake_queue(dev); 763 } 764 765 766 /* ethtool interface */ 767 768 static u32 mpc52xx_fec_get_msglevel(struct net_device *dev) 769 { 770 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 771 return priv->msg_enable; 772 } 773 774 static void mpc52xx_fec_set_msglevel(struct net_device *dev, u32 level) 775 { 776 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 777 priv->msg_enable = level; 778 } 779 780 static const struct ethtool_ops mpc52xx_fec_ethtool_ops = { 781 .get_link = ethtool_op_get_link, 782 .get_msglevel = mpc52xx_fec_get_msglevel, 783 .set_msglevel = mpc52xx_fec_set_msglevel, 784 .get_ts_info = ethtool_op_get_ts_info, 785 .get_link_ksettings = phy_ethtool_get_link_ksettings, 786 .set_link_ksettings = phy_ethtool_set_link_ksettings, 787 }; 788 789 790 static const struct net_device_ops mpc52xx_fec_netdev_ops = { 791 .ndo_open = mpc52xx_fec_open, 792 .ndo_stop = mpc52xx_fec_close, 793 .ndo_start_xmit = mpc52xx_fec_start_xmit, 794 .ndo_set_rx_mode = mpc52xx_fec_set_multicast_list, 795 .ndo_set_mac_address = mpc52xx_fec_set_mac_address, 796 .ndo_validate_addr = eth_validate_addr, 797 .ndo_eth_ioctl = phy_do_ioctl, 798 .ndo_tx_timeout = mpc52xx_fec_tx_timeout, 799 .ndo_get_stats = mpc52xx_fec_get_stats, 800 #ifdef CONFIG_NET_POLL_CONTROLLER 801 .ndo_poll_controller = mpc52xx_fec_poll_controller, 802 #endif 803 }; 804 805 /* ======================================================================== */ 806 /* OF Driver */ 807 /* ======================================================================== */ 808 809 static int mpc52xx_fec_probe(struct platform_device *op) 810 { 811 int rv; 812 struct net_device *ndev; 813 struct mpc52xx_fec_priv *priv = NULL; 814 struct resource mem; 815 const u32 *prop; 816 int prop_size; 817 struct device_node *np = op->dev.of_node; 818 819 phys_addr_t rx_fifo; 820 phys_addr_t tx_fifo; 821 822 /* Get the ether ndev & it's private zone */ 823 ndev = alloc_etherdev(sizeof(struct mpc52xx_fec_priv)); 824 if (!ndev) 825 return -ENOMEM; 826 827 priv = netdev_priv(ndev); 828 priv->ndev = ndev; 829 830 /* Reserve FEC control zone */ 831 rv = of_address_to_resource(np, 0, &mem); 832 if (rv) { 833 pr_err("Error while parsing device node resource\n"); 834 goto err_netdev; 835 } 836 if (resource_size(&mem) < sizeof(struct mpc52xx_fec)) { 837 pr_err("invalid resource size (%lx < %x), check mpc52xx_devices.c\n", 838 (unsigned long)resource_size(&mem), 839 sizeof(struct mpc52xx_fec)); 840 rv = -EINVAL; 841 goto err_netdev; 842 } 843 844 if (!request_mem_region(mem.start, sizeof(struct mpc52xx_fec), 845 DRIVER_NAME)) { 846 rv = -EBUSY; 847 goto err_netdev; 848 } 849 850 /* Init ether ndev with what we have */ 851 ndev->netdev_ops = &mpc52xx_fec_netdev_ops; 852 ndev->ethtool_ops = &mpc52xx_fec_ethtool_ops; 853 ndev->watchdog_timeo = FEC_WATCHDOG_TIMEOUT; 854 ndev->base_addr = mem.start; 855 SET_NETDEV_DEV(ndev, &op->dev); 856 857 spin_lock_init(&priv->lock); 858 859 /* ioremap the zones */ 860 priv->fec = ioremap(mem.start, sizeof(struct mpc52xx_fec)); 861 862 if (!priv->fec) { 863 rv = -ENOMEM; 864 goto err_mem_region; 865 } 866 867 /* Bestcomm init */ 868 rx_fifo = ndev->base_addr + offsetof(struct mpc52xx_fec, rfifo_data); 869 tx_fifo = ndev->base_addr + offsetof(struct mpc52xx_fec, tfifo_data); 870 871 priv->rx_dmatsk = bcom_fec_rx_init(FEC_RX_NUM_BD, rx_fifo, FEC_RX_BUFFER_SIZE); 872 priv->tx_dmatsk = bcom_fec_tx_init(FEC_TX_NUM_BD, tx_fifo); 873 874 if (!priv->rx_dmatsk || !priv->tx_dmatsk) { 875 pr_err("Can not init SDMA tasks\n"); 876 rv = -ENOMEM; 877 goto err_rx_tx_dmatsk; 878 } 879 880 /* Get the IRQ we need one by one */ 881 /* Control */ 882 ndev->irq = irq_of_parse_and_map(np, 0); 883 884 /* RX */ 885 priv->r_irq = bcom_get_task_irq(priv->rx_dmatsk); 886 887 /* TX */ 888 priv->t_irq = bcom_get_task_irq(priv->tx_dmatsk); 889 890 /* 891 * MAC address init: 892 * 893 * First try to read MAC address from DT 894 */ 895 rv = of_get_ethdev_address(np, ndev); 896 if (rv) { 897 struct mpc52xx_fec __iomem *fec = priv->fec; 898 u8 addr[ETH_ALEN] __aligned(4); 899 900 /* 901 * If the MAC addresse is not provided via DT then read 902 * it back from the controller regs 903 */ 904 *(u32 *)(&addr[0]) = in_be32(&fec->paddr1); 905 *(u16 *)(&addr[4]) = in_be32(&fec->paddr2) >> 16; 906 eth_hw_addr_set(ndev, addr); 907 } 908 909 /* 910 * Check if the MAC address is valid, if not get a random one 911 */ 912 if (!is_valid_ether_addr(ndev->dev_addr)) { 913 eth_hw_addr_random(ndev); 914 dev_warn(&ndev->dev, "using random MAC address %pM\n", 915 ndev->dev_addr); 916 } 917 918 priv->msg_enable = netif_msg_init(debug, MPC52xx_MESSAGES_DEFAULT); 919 920 /* 921 * Link mode configuration 922 */ 923 924 /* Start with safe defaults for link connection */ 925 priv->speed = 100; 926 priv->duplex = DUPLEX_HALF; 927 priv->mdio_speed = ((mpc5xxx_get_bus_frequency(&op->dev) >> 20) / 5) << 1; 928 929 /* The current speed preconfigures the speed of the MII link */ 930 prop = of_get_property(np, "current-speed", &prop_size); 931 if (prop && (prop_size >= sizeof(u32) * 2)) { 932 priv->speed = prop[0]; 933 priv->duplex = prop[1] ? DUPLEX_FULL : DUPLEX_HALF; 934 } 935 936 /* If there is a phy handle, then get the PHY node */ 937 priv->phy_node = of_parse_phandle(np, "phy-handle", 0); 938 939 /* the 7-wire property means don't use MII mode */ 940 if (of_find_property(np, "fsl,7-wire-mode", NULL)) { 941 priv->seven_wire_mode = 1; 942 dev_info(&ndev->dev, "using 7-wire PHY mode\n"); 943 } 944 945 /* Hardware init */ 946 mpc52xx_fec_hw_init(ndev); 947 mpc52xx_fec_reset_stats(ndev); 948 949 rv = register_netdev(ndev); 950 if (rv < 0) 951 goto err_node; 952 953 /* We're done ! */ 954 platform_set_drvdata(op, ndev); 955 netdev_info(ndev, "%pOF MAC %pM\n", 956 op->dev.of_node, ndev->dev_addr); 957 958 return 0; 959 960 err_node: 961 of_node_put(priv->phy_node); 962 irq_dispose_mapping(ndev->irq); 963 err_rx_tx_dmatsk: 964 if (priv->rx_dmatsk) 965 bcom_fec_rx_release(priv->rx_dmatsk); 966 if (priv->tx_dmatsk) 967 bcom_fec_tx_release(priv->tx_dmatsk); 968 iounmap(priv->fec); 969 err_mem_region: 970 release_mem_region(mem.start, sizeof(struct mpc52xx_fec)); 971 err_netdev: 972 free_netdev(ndev); 973 974 return rv; 975 } 976 977 static int 978 mpc52xx_fec_remove(struct platform_device *op) 979 { 980 struct net_device *ndev; 981 struct mpc52xx_fec_priv *priv; 982 983 ndev = platform_get_drvdata(op); 984 priv = netdev_priv(ndev); 985 986 unregister_netdev(ndev); 987 988 of_node_put(priv->phy_node); 989 priv->phy_node = NULL; 990 991 irq_dispose_mapping(ndev->irq); 992 993 bcom_fec_rx_release(priv->rx_dmatsk); 994 bcom_fec_tx_release(priv->tx_dmatsk); 995 996 iounmap(priv->fec); 997 998 release_mem_region(ndev->base_addr, sizeof(struct mpc52xx_fec)); 999 1000 free_netdev(ndev); 1001 1002 return 0; 1003 } 1004 1005 #ifdef CONFIG_PM 1006 static int mpc52xx_fec_of_suspend(struct platform_device *op, pm_message_t state) 1007 { 1008 struct net_device *dev = platform_get_drvdata(op); 1009 1010 if (netif_running(dev)) 1011 mpc52xx_fec_close(dev); 1012 1013 return 0; 1014 } 1015 1016 static int mpc52xx_fec_of_resume(struct platform_device *op) 1017 { 1018 struct net_device *dev = platform_get_drvdata(op); 1019 1020 mpc52xx_fec_hw_init(dev); 1021 mpc52xx_fec_reset_stats(dev); 1022 1023 if (netif_running(dev)) 1024 mpc52xx_fec_open(dev); 1025 1026 return 0; 1027 } 1028 #endif 1029 1030 static const struct of_device_id mpc52xx_fec_match[] = { 1031 { .compatible = "fsl,mpc5200b-fec", }, 1032 { .compatible = "fsl,mpc5200-fec", }, 1033 { .compatible = "mpc5200-fec", }, 1034 { } 1035 }; 1036 1037 MODULE_DEVICE_TABLE(of, mpc52xx_fec_match); 1038 1039 static struct platform_driver mpc52xx_fec_driver = { 1040 .driver = { 1041 .name = DRIVER_NAME, 1042 .of_match_table = mpc52xx_fec_match, 1043 }, 1044 .probe = mpc52xx_fec_probe, 1045 .remove = mpc52xx_fec_remove, 1046 #ifdef CONFIG_PM 1047 .suspend = mpc52xx_fec_of_suspend, 1048 .resume = mpc52xx_fec_of_resume, 1049 #endif 1050 }; 1051 1052 1053 /* ======================================================================== */ 1054 /* Module */ 1055 /* ======================================================================== */ 1056 1057 static struct platform_driver * const drivers[] = { 1058 #ifdef CONFIG_FEC_MPC52xx_MDIO 1059 &mpc52xx_fec_mdio_driver, 1060 #endif 1061 &mpc52xx_fec_driver, 1062 }; 1063 1064 static int __init 1065 mpc52xx_fec_init(void) 1066 { 1067 return platform_register_drivers(drivers, ARRAY_SIZE(drivers)); 1068 } 1069 1070 static void __exit 1071 mpc52xx_fec_exit(void) 1072 { 1073 platform_unregister_drivers(drivers, ARRAY_SIZE(drivers)); 1074 } 1075 1076 1077 module_init(mpc52xx_fec_init); 1078 module_exit(mpc52xx_fec_exit); 1079 1080 MODULE_LICENSE("GPL"); 1081 MODULE_AUTHOR("Dale Farnsworth"); 1082 MODULE_DESCRIPTION("Ethernet driver for the Freescale MPC52xx FEC"); 1083