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