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); 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) 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); 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) 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 (!in_interrupt()) { 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); 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 int mpc52xx_fec_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 789 { 790 struct phy_device *phydev = dev->phydev; 791 792 if (!phydev) 793 return -ENOTSUPP; 794 795 return phy_mii_ioctl(phydev, rq, cmd); 796 } 797 798 static const struct net_device_ops mpc52xx_fec_netdev_ops = { 799 .ndo_open = mpc52xx_fec_open, 800 .ndo_stop = mpc52xx_fec_close, 801 .ndo_start_xmit = mpc52xx_fec_start_xmit, 802 .ndo_set_rx_mode = mpc52xx_fec_set_multicast_list, 803 .ndo_set_mac_address = mpc52xx_fec_set_mac_address, 804 .ndo_validate_addr = eth_validate_addr, 805 .ndo_do_ioctl = mpc52xx_fec_ioctl, 806 .ndo_tx_timeout = mpc52xx_fec_tx_timeout, 807 .ndo_get_stats = mpc52xx_fec_get_stats, 808 #ifdef CONFIG_NET_POLL_CONTROLLER 809 .ndo_poll_controller = mpc52xx_fec_poll_controller, 810 #endif 811 }; 812 813 /* ======================================================================== */ 814 /* OF Driver */ 815 /* ======================================================================== */ 816 817 static int mpc52xx_fec_probe(struct platform_device *op) 818 { 819 int rv; 820 struct net_device *ndev; 821 struct mpc52xx_fec_priv *priv = NULL; 822 struct resource mem; 823 const u32 *prop; 824 int prop_size; 825 struct device_node *np = op->dev.of_node; 826 const char *mac_addr; 827 828 phys_addr_t rx_fifo; 829 phys_addr_t tx_fifo; 830 831 /* Get the ether ndev & it's private zone */ 832 ndev = alloc_etherdev(sizeof(struct mpc52xx_fec_priv)); 833 if (!ndev) 834 return -ENOMEM; 835 836 priv = netdev_priv(ndev); 837 priv->ndev = ndev; 838 839 /* Reserve FEC control zone */ 840 rv = of_address_to_resource(np, 0, &mem); 841 if (rv) { 842 pr_err("Error while parsing device node resource\n"); 843 goto err_netdev; 844 } 845 if (resource_size(&mem) < sizeof(struct mpc52xx_fec)) { 846 pr_err("invalid resource size (%lx < %x), check mpc52xx_devices.c\n", 847 (unsigned long)resource_size(&mem), 848 sizeof(struct mpc52xx_fec)); 849 rv = -EINVAL; 850 goto err_netdev; 851 } 852 853 if (!request_mem_region(mem.start, sizeof(struct mpc52xx_fec), 854 DRIVER_NAME)) { 855 rv = -EBUSY; 856 goto err_netdev; 857 } 858 859 /* Init ether ndev with what we have */ 860 ndev->netdev_ops = &mpc52xx_fec_netdev_ops; 861 ndev->ethtool_ops = &mpc52xx_fec_ethtool_ops; 862 ndev->watchdog_timeo = FEC_WATCHDOG_TIMEOUT; 863 ndev->base_addr = mem.start; 864 SET_NETDEV_DEV(ndev, &op->dev); 865 866 spin_lock_init(&priv->lock); 867 868 /* ioremap the zones */ 869 priv->fec = ioremap(mem.start, sizeof(struct mpc52xx_fec)); 870 871 if (!priv->fec) { 872 rv = -ENOMEM; 873 goto err_mem_region; 874 } 875 876 /* Bestcomm init */ 877 rx_fifo = ndev->base_addr + offsetof(struct mpc52xx_fec, rfifo_data); 878 tx_fifo = ndev->base_addr + offsetof(struct mpc52xx_fec, tfifo_data); 879 880 priv->rx_dmatsk = bcom_fec_rx_init(FEC_RX_NUM_BD, rx_fifo, FEC_RX_BUFFER_SIZE); 881 priv->tx_dmatsk = bcom_fec_tx_init(FEC_TX_NUM_BD, tx_fifo); 882 883 if (!priv->rx_dmatsk || !priv->tx_dmatsk) { 884 pr_err("Can not init SDMA tasks\n"); 885 rv = -ENOMEM; 886 goto err_rx_tx_dmatsk; 887 } 888 889 /* Get the IRQ we need one by one */ 890 /* Control */ 891 ndev->irq = irq_of_parse_and_map(np, 0); 892 893 /* RX */ 894 priv->r_irq = bcom_get_task_irq(priv->rx_dmatsk); 895 896 /* TX */ 897 priv->t_irq = bcom_get_task_irq(priv->tx_dmatsk); 898 899 /* 900 * MAC address init: 901 * 902 * First try to read MAC address from DT 903 */ 904 mac_addr = of_get_mac_address(np); 905 if (mac_addr) { 906 memcpy(ndev->dev_addr, mac_addr, ETH_ALEN); 907 } else { 908 struct mpc52xx_fec __iomem *fec = priv->fec; 909 910 /* 911 * If the MAC addresse is not provided via DT then read 912 * it back from the controller regs 913 */ 914 *(u32 *)(&ndev->dev_addr[0]) = in_be32(&fec->paddr1); 915 *(u16 *)(&ndev->dev_addr[4]) = in_be32(&fec->paddr2) >> 16; 916 } 917 918 /* 919 * Check if the MAC address is valid, if not get a random one 920 */ 921 if (!is_valid_ether_addr(ndev->dev_addr)) { 922 eth_hw_addr_random(ndev); 923 dev_warn(&ndev->dev, "using random MAC address %pM\n", 924 ndev->dev_addr); 925 } 926 927 priv->msg_enable = netif_msg_init(debug, MPC52xx_MESSAGES_DEFAULT); 928 929 /* 930 * Link mode configuration 931 */ 932 933 /* Start with safe defaults for link connection */ 934 priv->speed = 100; 935 priv->duplex = DUPLEX_HALF; 936 priv->mdio_speed = ((mpc5xxx_get_bus_frequency(np) >> 20) / 5) << 1; 937 938 /* The current speed preconfigures the speed of the MII link */ 939 prop = of_get_property(np, "current-speed", &prop_size); 940 if (prop && (prop_size >= sizeof(u32) * 2)) { 941 priv->speed = prop[0]; 942 priv->duplex = prop[1] ? DUPLEX_FULL : DUPLEX_HALF; 943 } 944 945 /* If there is a phy handle, then get the PHY node */ 946 priv->phy_node = of_parse_phandle(np, "phy-handle", 0); 947 948 /* the 7-wire property means don't use MII mode */ 949 if (of_find_property(np, "fsl,7-wire-mode", NULL)) { 950 priv->seven_wire_mode = 1; 951 dev_info(&ndev->dev, "using 7-wire PHY mode\n"); 952 } 953 954 /* Hardware init */ 955 mpc52xx_fec_hw_init(ndev); 956 mpc52xx_fec_reset_stats(ndev); 957 958 rv = register_netdev(ndev); 959 if (rv < 0) 960 goto err_node; 961 962 /* We're done ! */ 963 platform_set_drvdata(op, ndev); 964 netdev_info(ndev, "%pOF MAC %pM\n", 965 op->dev.of_node, ndev->dev_addr); 966 967 return 0; 968 969 err_node: 970 of_node_put(priv->phy_node); 971 irq_dispose_mapping(ndev->irq); 972 err_rx_tx_dmatsk: 973 if (priv->rx_dmatsk) 974 bcom_fec_rx_release(priv->rx_dmatsk); 975 if (priv->tx_dmatsk) 976 bcom_fec_tx_release(priv->tx_dmatsk); 977 iounmap(priv->fec); 978 err_mem_region: 979 release_mem_region(mem.start, sizeof(struct mpc52xx_fec)); 980 err_netdev: 981 free_netdev(ndev); 982 983 return rv; 984 } 985 986 static int 987 mpc52xx_fec_remove(struct platform_device *op) 988 { 989 struct net_device *ndev; 990 struct mpc52xx_fec_priv *priv; 991 992 ndev = platform_get_drvdata(op); 993 priv = netdev_priv(ndev); 994 995 unregister_netdev(ndev); 996 997 of_node_put(priv->phy_node); 998 priv->phy_node = NULL; 999 1000 irq_dispose_mapping(ndev->irq); 1001 1002 bcom_fec_rx_release(priv->rx_dmatsk); 1003 bcom_fec_tx_release(priv->tx_dmatsk); 1004 1005 iounmap(priv->fec); 1006 1007 release_mem_region(ndev->base_addr, sizeof(struct mpc52xx_fec)); 1008 1009 free_netdev(ndev); 1010 1011 return 0; 1012 } 1013 1014 #ifdef CONFIG_PM 1015 static int mpc52xx_fec_of_suspend(struct platform_device *op, pm_message_t state) 1016 { 1017 struct net_device *dev = platform_get_drvdata(op); 1018 1019 if (netif_running(dev)) 1020 mpc52xx_fec_close(dev); 1021 1022 return 0; 1023 } 1024 1025 static int mpc52xx_fec_of_resume(struct platform_device *op) 1026 { 1027 struct net_device *dev = platform_get_drvdata(op); 1028 1029 mpc52xx_fec_hw_init(dev); 1030 mpc52xx_fec_reset_stats(dev); 1031 1032 if (netif_running(dev)) 1033 mpc52xx_fec_open(dev); 1034 1035 return 0; 1036 } 1037 #endif 1038 1039 static const struct of_device_id mpc52xx_fec_match[] = { 1040 { .compatible = "fsl,mpc5200b-fec", }, 1041 { .compatible = "fsl,mpc5200-fec", }, 1042 { .compatible = "mpc5200-fec", }, 1043 { } 1044 }; 1045 1046 MODULE_DEVICE_TABLE(of, mpc52xx_fec_match); 1047 1048 static struct platform_driver mpc52xx_fec_driver = { 1049 .driver = { 1050 .name = DRIVER_NAME, 1051 .of_match_table = mpc52xx_fec_match, 1052 }, 1053 .probe = mpc52xx_fec_probe, 1054 .remove = mpc52xx_fec_remove, 1055 #ifdef CONFIG_PM 1056 .suspend = mpc52xx_fec_of_suspend, 1057 .resume = mpc52xx_fec_of_resume, 1058 #endif 1059 }; 1060 1061 1062 /* ======================================================================== */ 1063 /* Module */ 1064 /* ======================================================================== */ 1065 1066 static struct platform_driver * const drivers[] = { 1067 #ifdef CONFIG_FEC_MPC52xx_MDIO 1068 &mpc52xx_fec_mdio_driver, 1069 #endif 1070 &mpc52xx_fec_driver, 1071 }; 1072 1073 static int __init 1074 mpc52xx_fec_init(void) 1075 { 1076 return platform_register_drivers(drivers, ARRAY_SIZE(drivers)); 1077 } 1078 1079 static void __exit 1080 mpc52xx_fec_exit(void) 1081 { 1082 platform_unregister_drivers(drivers, ARRAY_SIZE(drivers)); 1083 } 1084 1085 1086 module_init(mpc52xx_fec_init); 1087 module_exit(mpc52xx_fec_exit); 1088 1089 MODULE_LICENSE("GPL"); 1090 MODULE_AUTHOR("Dale Farnsworth"); 1091 MODULE_DESCRIPTION("Ethernet driver for the Freescale MPC52xx FEC"); 1092