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 int mpc52xx_fec_start_xmit(struct sk_buff *skb, struct net_device *dev) 309 { 310 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 311 struct bcom_fec_bd *bd; 312 unsigned long flags; 313 314 if (bcom_queue_full(priv->tx_dmatsk)) { 315 if (net_ratelimit()) 316 dev_err(&dev->dev, "transmit queue overrun\n"); 317 return NETDEV_TX_BUSY; 318 } 319 320 spin_lock_irqsave(&priv->lock, flags); 321 322 bd = (struct bcom_fec_bd *) 323 bcom_prepare_next_buffer(priv->tx_dmatsk); 324 325 bd->status = skb->len | BCOM_FEC_TX_BD_TFD | BCOM_FEC_TX_BD_TC; 326 bd->skb_pa = dma_map_single(dev->dev.parent, skb->data, skb->len, 327 DMA_TO_DEVICE); 328 329 skb_tx_timestamp(skb); 330 bcom_submit_next_buffer(priv->tx_dmatsk, skb); 331 spin_unlock_irqrestore(&priv->lock, flags); 332 333 if (bcom_queue_full(priv->tx_dmatsk)) { 334 netif_stop_queue(dev); 335 } 336 337 return NETDEV_TX_OK; 338 } 339 340 #ifdef CONFIG_NET_POLL_CONTROLLER 341 static void mpc52xx_fec_poll_controller(struct net_device *dev) 342 { 343 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 344 345 disable_irq(priv->t_irq); 346 mpc52xx_fec_tx_interrupt(priv->t_irq, dev); 347 enable_irq(priv->t_irq); 348 disable_irq(priv->r_irq); 349 mpc52xx_fec_rx_interrupt(priv->r_irq, dev); 350 enable_irq(priv->r_irq); 351 } 352 #endif 353 354 355 /* This handles BestComm transmit task interrupts 356 */ 357 static irqreturn_t mpc52xx_fec_tx_interrupt(int irq, void *dev_id) 358 { 359 struct net_device *dev = dev_id; 360 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 361 362 spin_lock(&priv->lock); 363 while (bcom_buffer_done(priv->tx_dmatsk)) { 364 struct sk_buff *skb; 365 struct bcom_fec_bd *bd; 366 skb = bcom_retrieve_buffer(priv->tx_dmatsk, NULL, 367 (struct bcom_bd **)&bd); 368 dma_unmap_single(dev->dev.parent, bd->skb_pa, skb->len, 369 DMA_TO_DEVICE); 370 371 dev_kfree_skb_irq(skb); 372 } 373 spin_unlock(&priv->lock); 374 375 netif_wake_queue(dev); 376 377 return IRQ_HANDLED; 378 } 379 380 static irqreturn_t mpc52xx_fec_rx_interrupt(int irq, void *dev_id) 381 { 382 struct net_device *dev = dev_id; 383 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 384 struct sk_buff *rskb; /* received sk_buff */ 385 struct sk_buff *skb; /* new sk_buff to enqueue in its place */ 386 struct bcom_fec_bd *bd; 387 u32 status, physaddr; 388 int length; 389 390 spin_lock(&priv->lock); 391 392 while (bcom_buffer_done(priv->rx_dmatsk)) { 393 394 rskb = bcom_retrieve_buffer(priv->rx_dmatsk, &status, 395 (struct bcom_bd **)&bd); 396 physaddr = bd->skb_pa; 397 398 /* Test for errors in received frame */ 399 if (status & BCOM_FEC_RX_BD_ERRORS) { 400 /* Drop packet and reuse the buffer */ 401 mpc52xx_fec_rx_submit(dev, rskb); 402 dev->stats.rx_dropped++; 403 continue; 404 } 405 406 /* skbs are allocated on open, so now we allocate a new one, 407 * and remove the old (with the packet) */ 408 skb = netdev_alloc_skb(dev, FEC_RX_BUFFER_SIZE); 409 if (!skb) { 410 /* Can't get a new one : reuse the same & drop pkt */ 411 dev_notice(&dev->dev, "Low memory - dropped packet.\n"); 412 mpc52xx_fec_rx_submit(dev, rskb); 413 dev->stats.rx_dropped++; 414 continue; 415 } 416 417 /* Enqueue the new sk_buff back on the hardware */ 418 mpc52xx_fec_rx_submit(dev, skb); 419 420 /* Process the received skb - Drop the spin lock while 421 * calling into the network stack */ 422 spin_unlock(&priv->lock); 423 424 dma_unmap_single(dev->dev.parent, physaddr, rskb->len, 425 DMA_FROM_DEVICE); 426 length = status & BCOM_FEC_RX_BD_LEN_MASK; 427 skb_put(rskb, length - 4); /* length without CRC32 */ 428 rskb->protocol = eth_type_trans(rskb, dev); 429 if (!skb_defer_rx_timestamp(rskb)) 430 netif_rx(rskb); 431 432 spin_lock(&priv->lock); 433 } 434 435 spin_unlock(&priv->lock); 436 437 return IRQ_HANDLED; 438 } 439 440 static irqreturn_t mpc52xx_fec_interrupt(int irq, void *dev_id) 441 { 442 struct net_device *dev = dev_id; 443 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 444 struct mpc52xx_fec __iomem *fec = priv->fec; 445 u32 ievent; 446 447 ievent = in_be32(&fec->ievent); 448 449 ievent &= ~FEC_IEVENT_MII; /* mii is handled separately */ 450 if (!ievent) 451 return IRQ_NONE; 452 453 out_be32(&fec->ievent, ievent); /* clear pending events */ 454 455 /* on fifo error, soft-reset fec */ 456 if (ievent & (FEC_IEVENT_RFIFO_ERROR | FEC_IEVENT_XFIFO_ERROR)) { 457 458 if (net_ratelimit() && (ievent & FEC_IEVENT_RFIFO_ERROR)) 459 dev_warn(&dev->dev, "FEC_IEVENT_RFIFO_ERROR\n"); 460 if (net_ratelimit() && (ievent & FEC_IEVENT_XFIFO_ERROR)) 461 dev_warn(&dev->dev, "FEC_IEVENT_XFIFO_ERROR\n"); 462 463 spin_lock(&priv->lock); 464 mpc52xx_fec_reset(dev); 465 spin_unlock(&priv->lock); 466 467 return IRQ_HANDLED; 468 } 469 470 if (ievent & ~FEC_IEVENT_TFINT) 471 dev_dbg(&dev->dev, "ievent: %08x\n", ievent); 472 473 return IRQ_HANDLED; 474 } 475 476 /* 477 * Get the current statistics. 478 * This may be called with the card open or closed. 479 */ 480 static struct net_device_stats *mpc52xx_fec_get_stats(struct net_device *dev) 481 { 482 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 483 struct net_device_stats *stats = &dev->stats; 484 struct mpc52xx_fec __iomem *fec = priv->fec; 485 486 stats->rx_bytes = in_be32(&fec->rmon_r_octets); 487 stats->rx_packets = in_be32(&fec->rmon_r_packets); 488 stats->rx_errors = in_be32(&fec->rmon_r_crc_align) + 489 in_be32(&fec->rmon_r_undersize) + 490 in_be32(&fec->rmon_r_oversize) + 491 in_be32(&fec->rmon_r_frag) + 492 in_be32(&fec->rmon_r_jab); 493 494 stats->tx_bytes = in_be32(&fec->rmon_t_octets); 495 stats->tx_packets = in_be32(&fec->rmon_t_packets); 496 stats->tx_errors = in_be32(&fec->rmon_t_crc_align) + 497 in_be32(&fec->rmon_t_undersize) + 498 in_be32(&fec->rmon_t_oversize) + 499 in_be32(&fec->rmon_t_frag) + 500 in_be32(&fec->rmon_t_jab); 501 502 stats->multicast = in_be32(&fec->rmon_r_mc_pkt); 503 stats->collisions = in_be32(&fec->rmon_t_col); 504 505 /* detailed rx_errors: */ 506 stats->rx_length_errors = in_be32(&fec->rmon_r_undersize) 507 + in_be32(&fec->rmon_r_oversize) 508 + in_be32(&fec->rmon_r_frag) 509 + in_be32(&fec->rmon_r_jab); 510 stats->rx_over_errors = in_be32(&fec->r_macerr); 511 stats->rx_crc_errors = in_be32(&fec->ieee_r_crc); 512 stats->rx_frame_errors = in_be32(&fec->ieee_r_align); 513 stats->rx_fifo_errors = in_be32(&fec->rmon_r_drop); 514 stats->rx_missed_errors = in_be32(&fec->rmon_r_drop); 515 516 /* detailed tx_errors: */ 517 stats->tx_aborted_errors = 0; 518 stats->tx_carrier_errors = in_be32(&fec->ieee_t_cserr); 519 stats->tx_fifo_errors = in_be32(&fec->rmon_t_drop); 520 stats->tx_heartbeat_errors = in_be32(&fec->ieee_t_sqe); 521 stats->tx_window_errors = in_be32(&fec->ieee_t_lcol); 522 523 return stats; 524 } 525 526 /* 527 * Read MIB counters in order to reset them, 528 * then zero all the stats fields in memory 529 */ 530 static void mpc52xx_fec_reset_stats(struct net_device *dev) 531 { 532 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 533 struct mpc52xx_fec __iomem *fec = priv->fec; 534 535 out_be32(&fec->mib_control, FEC_MIB_DISABLE); 536 memset_io(&fec->rmon_t_drop, 0, 537 offsetof(struct mpc52xx_fec, reserved10) - 538 offsetof(struct mpc52xx_fec, rmon_t_drop)); 539 out_be32(&fec->mib_control, 0); 540 541 memset(&dev->stats, 0, sizeof(dev->stats)); 542 } 543 544 /* 545 * Set or clear the multicast filter for this adaptor. 546 */ 547 static void mpc52xx_fec_set_multicast_list(struct net_device *dev) 548 { 549 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 550 struct mpc52xx_fec __iomem *fec = priv->fec; 551 u32 rx_control; 552 553 rx_control = in_be32(&fec->r_cntrl); 554 555 if (dev->flags & IFF_PROMISC) { 556 rx_control |= FEC_RCNTRL_PROM; 557 out_be32(&fec->r_cntrl, rx_control); 558 } else { 559 rx_control &= ~FEC_RCNTRL_PROM; 560 out_be32(&fec->r_cntrl, rx_control); 561 562 if (dev->flags & IFF_ALLMULTI) { 563 out_be32(&fec->gaddr1, 0xffffffff); 564 out_be32(&fec->gaddr2, 0xffffffff); 565 } else { 566 u32 crc; 567 struct netdev_hw_addr *ha; 568 u32 gaddr1 = 0x00000000; 569 u32 gaddr2 = 0x00000000; 570 571 netdev_for_each_mc_addr(ha, dev) { 572 crc = ether_crc_le(6, ha->addr) >> 26; 573 if (crc >= 32) 574 gaddr1 |= 1 << (crc-32); 575 else 576 gaddr2 |= 1 << crc; 577 } 578 out_be32(&fec->gaddr1, gaddr1); 579 out_be32(&fec->gaddr2, gaddr2); 580 } 581 } 582 } 583 584 /** 585 * mpc52xx_fec_hw_init 586 * @dev: network device 587 * 588 * Setup various hardware setting, only needed once on start 589 */ 590 static void mpc52xx_fec_hw_init(struct net_device *dev) 591 { 592 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 593 struct mpc52xx_fec __iomem *fec = priv->fec; 594 int i; 595 596 /* Whack a reset. We should wait for this. */ 597 out_be32(&fec->ecntrl, FEC_ECNTRL_RESET); 598 for (i = 0; i < FEC_RESET_DELAY; ++i) { 599 if ((in_be32(&fec->ecntrl) & FEC_ECNTRL_RESET) == 0) 600 break; 601 udelay(1); 602 } 603 if (i == FEC_RESET_DELAY) 604 dev_err(&dev->dev, "FEC Reset timeout!\n"); 605 606 /* set pause to 0x20 frames */ 607 out_be32(&fec->op_pause, FEC_OP_PAUSE_OPCODE | 0x20); 608 609 /* high service request will be deasserted when there's < 7 bytes in fifo 610 * low service request will be deasserted when there's < 4*7 bytes in fifo 611 */ 612 out_be32(&fec->rfifo_cntrl, FEC_FIFO_CNTRL_FRAME | FEC_FIFO_CNTRL_LTG_7); 613 out_be32(&fec->tfifo_cntrl, FEC_FIFO_CNTRL_FRAME | FEC_FIFO_CNTRL_LTG_7); 614 615 /* alarm when <= x bytes in FIFO */ 616 out_be32(&fec->rfifo_alarm, 0x0000030c); 617 out_be32(&fec->tfifo_alarm, 0x00000100); 618 619 /* begin transmittion when 256 bytes are in FIFO (or EOF or FIFO full) */ 620 out_be32(&fec->x_wmrk, FEC_FIFO_WMRK_256B); 621 622 /* enable crc generation */ 623 out_be32(&fec->xmit_fsm, FEC_XMIT_FSM_APPEND_CRC | FEC_XMIT_FSM_ENABLE_CRC); 624 out_be32(&fec->iaddr1, 0x00000000); /* No individual filter */ 625 out_be32(&fec->iaddr2, 0x00000000); /* No individual filter */ 626 627 /* set phy speed. 628 * this can't be done in phy driver, since it needs to be called 629 * before fec stuff (even on resume) */ 630 out_be32(&fec->mii_speed, priv->mdio_speed); 631 } 632 633 /** 634 * mpc52xx_fec_start 635 * @dev: network device 636 * 637 * This function is called to start or restart the FEC during a link 638 * change. This happens on fifo errors or when switching between half 639 * and full duplex. 640 */ 641 static void mpc52xx_fec_start(struct net_device *dev) 642 { 643 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 644 struct mpc52xx_fec __iomem *fec = priv->fec; 645 u32 rcntrl; 646 u32 tcntrl; 647 u32 tmp; 648 649 /* clear sticky error bits */ 650 tmp = FEC_FIFO_STATUS_ERR | FEC_FIFO_STATUS_UF | FEC_FIFO_STATUS_OF; 651 out_be32(&fec->rfifo_status, in_be32(&fec->rfifo_status) & tmp); 652 out_be32(&fec->tfifo_status, in_be32(&fec->tfifo_status) & tmp); 653 654 /* FIFOs will reset on mpc52xx_fec_enable */ 655 out_be32(&fec->reset_cntrl, FEC_RESET_CNTRL_ENABLE_IS_RESET); 656 657 /* Set station address. */ 658 mpc52xx_fec_set_paddr(dev, dev->dev_addr); 659 660 mpc52xx_fec_set_multicast_list(dev); 661 662 /* set max frame len, enable flow control, select mii mode */ 663 rcntrl = FEC_RX_BUFFER_SIZE << 16; /* max frame length */ 664 rcntrl |= FEC_RCNTRL_FCE; 665 666 if (!priv->seven_wire_mode) 667 rcntrl |= FEC_RCNTRL_MII_MODE; 668 669 if (priv->duplex == DUPLEX_FULL) 670 tcntrl = FEC_TCNTRL_FDEN; /* FD enable */ 671 else { 672 rcntrl |= FEC_RCNTRL_DRT; /* disable Rx on Tx (HD) */ 673 tcntrl = 0; 674 } 675 out_be32(&fec->r_cntrl, rcntrl); 676 out_be32(&fec->x_cntrl, tcntrl); 677 678 /* Clear any outstanding interrupt. */ 679 out_be32(&fec->ievent, 0xffffffff); 680 681 /* Enable interrupts we wish to service. */ 682 out_be32(&fec->imask, FEC_IMASK_ENABLE); 683 684 /* And last, enable the transmit and receive processing. */ 685 out_be32(&fec->ecntrl, FEC_ECNTRL_ETHER_EN); 686 out_be32(&fec->r_des_active, 0x01000000); 687 } 688 689 /** 690 * mpc52xx_fec_stop 691 * @dev: network device 692 * 693 * stop all activity on fec and empty dma buffers 694 */ 695 static void mpc52xx_fec_stop(struct net_device *dev) 696 { 697 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 698 struct mpc52xx_fec __iomem *fec = priv->fec; 699 unsigned long timeout; 700 701 /* disable all interrupts */ 702 out_be32(&fec->imask, 0); 703 704 /* Disable the rx task. */ 705 bcom_disable(priv->rx_dmatsk); 706 707 /* Wait for tx queue to drain, but only if we're in process context */ 708 if (!in_interrupt()) { 709 timeout = jiffies + msecs_to_jiffies(2000); 710 while (time_before(jiffies, timeout) && 711 !bcom_queue_empty(priv->tx_dmatsk)) 712 msleep(100); 713 714 if (time_after_eq(jiffies, timeout)) 715 dev_err(&dev->dev, "queues didn't drain\n"); 716 #if 1 717 if (time_after_eq(jiffies, timeout)) { 718 dev_err(&dev->dev, " tx: index: %i, outdex: %i\n", 719 priv->tx_dmatsk->index, 720 priv->tx_dmatsk->outdex); 721 dev_err(&dev->dev, " rx: index: %i, outdex: %i\n", 722 priv->rx_dmatsk->index, 723 priv->rx_dmatsk->outdex); 724 } 725 #endif 726 } 727 728 bcom_disable(priv->tx_dmatsk); 729 730 /* Stop FEC */ 731 out_be32(&fec->ecntrl, in_be32(&fec->ecntrl) & ~FEC_ECNTRL_ETHER_EN); 732 } 733 734 /* reset fec and bestcomm tasks */ 735 static void mpc52xx_fec_reset(struct net_device *dev) 736 { 737 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 738 struct mpc52xx_fec __iomem *fec = priv->fec; 739 740 mpc52xx_fec_stop(dev); 741 742 out_be32(&fec->rfifo_status, in_be32(&fec->rfifo_status)); 743 out_be32(&fec->reset_cntrl, FEC_RESET_CNTRL_RESET_FIFO); 744 745 mpc52xx_fec_free_rx_buffers(dev, priv->rx_dmatsk); 746 747 mpc52xx_fec_hw_init(dev); 748 749 bcom_fec_rx_reset(priv->rx_dmatsk); 750 bcom_fec_tx_reset(priv->tx_dmatsk); 751 752 mpc52xx_fec_alloc_rx_buffers(dev, priv->rx_dmatsk); 753 754 bcom_enable(priv->rx_dmatsk); 755 bcom_enable(priv->tx_dmatsk); 756 757 mpc52xx_fec_start(dev); 758 759 netif_wake_queue(dev); 760 } 761 762 763 /* ethtool interface */ 764 765 static u32 mpc52xx_fec_get_msglevel(struct net_device *dev) 766 { 767 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 768 return priv->msg_enable; 769 } 770 771 static void mpc52xx_fec_set_msglevel(struct net_device *dev, u32 level) 772 { 773 struct mpc52xx_fec_priv *priv = netdev_priv(dev); 774 priv->msg_enable = level; 775 } 776 777 static const struct ethtool_ops mpc52xx_fec_ethtool_ops = { 778 .get_link = ethtool_op_get_link, 779 .get_msglevel = mpc52xx_fec_get_msglevel, 780 .set_msglevel = mpc52xx_fec_set_msglevel, 781 .get_ts_info = ethtool_op_get_ts_info, 782 .get_link_ksettings = phy_ethtool_get_link_ksettings, 783 .set_link_ksettings = phy_ethtool_set_link_ksettings, 784 }; 785 786 787 static int mpc52xx_fec_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 788 { 789 struct phy_device *phydev = dev->phydev; 790 791 if (!phydev) 792 return -ENOTSUPP; 793 794 return phy_mii_ioctl(phydev, rq, cmd); 795 } 796 797 static const struct net_device_ops mpc52xx_fec_netdev_ops = { 798 .ndo_open = mpc52xx_fec_open, 799 .ndo_stop = mpc52xx_fec_close, 800 .ndo_start_xmit = mpc52xx_fec_start_xmit, 801 .ndo_set_rx_mode = mpc52xx_fec_set_multicast_list, 802 .ndo_set_mac_address = mpc52xx_fec_set_mac_address, 803 .ndo_validate_addr = eth_validate_addr, 804 .ndo_do_ioctl = mpc52xx_fec_ioctl, 805 .ndo_tx_timeout = mpc52xx_fec_tx_timeout, 806 .ndo_get_stats = mpc52xx_fec_get_stats, 807 #ifdef CONFIG_NET_POLL_CONTROLLER 808 .ndo_poll_controller = mpc52xx_fec_poll_controller, 809 #endif 810 }; 811 812 /* ======================================================================== */ 813 /* OF Driver */ 814 /* ======================================================================== */ 815 816 static int mpc52xx_fec_probe(struct platform_device *op) 817 { 818 int rv; 819 struct net_device *ndev; 820 struct mpc52xx_fec_priv *priv = NULL; 821 struct resource mem; 822 const u32 *prop; 823 int prop_size; 824 struct device_node *np = op->dev.of_node; 825 const char *mac_addr; 826 827 phys_addr_t rx_fifo; 828 phys_addr_t tx_fifo; 829 830 /* Get the ether ndev & it's private zone */ 831 ndev = alloc_etherdev(sizeof(struct mpc52xx_fec_priv)); 832 if (!ndev) 833 return -ENOMEM; 834 835 priv = netdev_priv(ndev); 836 priv->ndev = ndev; 837 838 /* Reserve FEC control zone */ 839 rv = of_address_to_resource(np, 0, &mem); 840 if (rv) { 841 pr_err("Error while parsing device node resource\n"); 842 goto err_netdev; 843 } 844 if (resource_size(&mem) < sizeof(struct mpc52xx_fec)) { 845 pr_err("invalid resource size (%lx < %x), check mpc52xx_devices.c\n", 846 (unsigned long)resource_size(&mem), 847 sizeof(struct mpc52xx_fec)); 848 rv = -EINVAL; 849 goto err_netdev; 850 } 851 852 if (!request_mem_region(mem.start, sizeof(struct mpc52xx_fec), 853 DRIVER_NAME)) { 854 rv = -EBUSY; 855 goto err_netdev; 856 } 857 858 /* Init ether ndev with what we have */ 859 ndev->netdev_ops = &mpc52xx_fec_netdev_ops; 860 ndev->ethtool_ops = &mpc52xx_fec_ethtool_ops; 861 ndev->watchdog_timeo = FEC_WATCHDOG_TIMEOUT; 862 ndev->base_addr = mem.start; 863 SET_NETDEV_DEV(ndev, &op->dev); 864 865 spin_lock_init(&priv->lock); 866 867 /* ioremap the zones */ 868 priv->fec = ioremap(mem.start, sizeof(struct mpc52xx_fec)); 869 870 if (!priv->fec) { 871 rv = -ENOMEM; 872 goto err_mem_region; 873 } 874 875 /* Bestcomm init */ 876 rx_fifo = ndev->base_addr + offsetof(struct mpc52xx_fec, rfifo_data); 877 tx_fifo = ndev->base_addr + offsetof(struct mpc52xx_fec, tfifo_data); 878 879 priv->rx_dmatsk = bcom_fec_rx_init(FEC_RX_NUM_BD, rx_fifo, FEC_RX_BUFFER_SIZE); 880 priv->tx_dmatsk = bcom_fec_tx_init(FEC_TX_NUM_BD, tx_fifo); 881 882 if (!priv->rx_dmatsk || !priv->tx_dmatsk) { 883 pr_err("Can not init SDMA tasks\n"); 884 rv = -ENOMEM; 885 goto err_rx_tx_dmatsk; 886 } 887 888 /* Get the IRQ we need one by one */ 889 /* Control */ 890 ndev->irq = irq_of_parse_and_map(np, 0); 891 892 /* RX */ 893 priv->r_irq = bcom_get_task_irq(priv->rx_dmatsk); 894 895 /* TX */ 896 priv->t_irq = bcom_get_task_irq(priv->tx_dmatsk); 897 898 /* 899 * MAC address init: 900 * 901 * First try to read MAC address from DT 902 */ 903 mac_addr = of_get_mac_address(np); 904 if (mac_addr) { 905 memcpy(ndev->dev_addr, mac_addr, ETH_ALEN); 906 } else { 907 struct mpc52xx_fec __iomem *fec = priv->fec; 908 909 /* 910 * If the MAC addresse is not provided via DT then read 911 * it back from the controller regs 912 */ 913 *(u32 *)(&ndev->dev_addr[0]) = in_be32(&fec->paddr1); 914 *(u16 *)(&ndev->dev_addr[4]) = in_be32(&fec->paddr2) >> 16; 915 } 916 917 /* 918 * Check if the MAC address is valid, if not get a random one 919 */ 920 if (!is_valid_ether_addr(ndev->dev_addr)) { 921 eth_hw_addr_random(ndev); 922 dev_warn(&ndev->dev, "using random MAC address %pM\n", 923 ndev->dev_addr); 924 } 925 926 priv->msg_enable = netif_msg_init(debug, MPC52xx_MESSAGES_DEFAULT); 927 928 /* 929 * Link mode configuration 930 */ 931 932 /* Start with safe defaults for link connection */ 933 priv->speed = 100; 934 priv->duplex = DUPLEX_HALF; 935 priv->mdio_speed = ((mpc5xxx_get_bus_frequency(np) >> 20) / 5) << 1; 936 937 /* The current speed preconfigures the speed of the MII link */ 938 prop = of_get_property(np, "current-speed", &prop_size); 939 if (prop && (prop_size >= sizeof(u32) * 2)) { 940 priv->speed = prop[0]; 941 priv->duplex = prop[1] ? DUPLEX_FULL : DUPLEX_HALF; 942 } 943 944 /* If there is a phy handle, then get the PHY node */ 945 priv->phy_node = of_parse_phandle(np, "phy-handle", 0); 946 947 /* the 7-wire property means don't use MII mode */ 948 if (of_find_property(np, "fsl,7-wire-mode", NULL)) { 949 priv->seven_wire_mode = 1; 950 dev_info(&ndev->dev, "using 7-wire PHY mode\n"); 951 } 952 953 /* Hardware init */ 954 mpc52xx_fec_hw_init(ndev); 955 mpc52xx_fec_reset_stats(ndev); 956 957 rv = register_netdev(ndev); 958 if (rv < 0) 959 goto err_node; 960 961 /* We're done ! */ 962 platform_set_drvdata(op, ndev); 963 netdev_info(ndev, "%pOF MAC %pM\n", 964 op->dev.of_node, ndev->dev_addr); 965 966 return 0; 967 968 err_node: 969 of_node_put(priv->phy_node); 970 irq_dispose_mapping(ndev->irq); 971 err_rx_tx_dmatsk: 972 if (priv->rx_dmatsk) 973 bcom_fec_rx_release(priv->rx_dmatsk); 974 if (priv->tx_dmatsk) 975 bcom_fec_tx_release(priv->tx_dmatsk); 976 iounmap(priv->fec); 977 err_mem_region: 978 release_mem_region(mem.start, sizeof(struct mpc52xx_fec)); 979 err_netdev: 980 free_netdev(ndev); 981 982 return rv; 983 } 984 985 static int 986 mpc52xx_fec_remove(struct platform_device *op) 987 { 988 struct net_device *ndev; 989 struct mpc52xx_fec_priv *priv; 990 991 ndev = platform_get_drvdata(op); 992 priv = netdev_priv(ndev); 993 994 unregister_netdev(ndev); 995 996 of_node_put(priv->phy_node); 997 priv->phy_node = NULL; 998 999 irq_dispose_mapping(ndev->irq); 1000 1001 bcom_fec_rx_release(priv->rx_dmatsk); 1002 bcom_fec_tx_release(priv->tx_dmatsk); 1003 1004 iounmap(priv->fec); 1005 1006 release_mem_region(ndev->base_addr, sizeof(struct mpc52xx_fec)); 1007 1008 free_netdev(ndev); 1009 1010 return 0; 1011 } 1012 1013 #ifdef CONFIG_PM 1014 static int mpc52xx_fec_of_suspend(struct platform_device *op, pm_message_t state) 1015 { 1016 struct net_device *dev = platform_get_drvdata(op); 1017 1018 if (netif_running(dev)) 1019 mpc52xx_fec_close(dev); 1020 1021 return 0; 1022 } 1023 1024 static int mpc52xx_fec_of_resume(struct platform_device *op) 1025 { 1026 struct net_device *dev = platform_get_drvdata(op); 1027 1028 mpc52xx_fec_hw_init(dev); 1029 mpc52xx_fec_reset_stats(dev); 1030 1031 if (netif_running(dev)) 1032 mpc52xx_fec_open(dev); 1033 1034 return 0; 1035 } 1036 #endif 1037 1038 static const struct of_device_id mpc52xx_fec_match[] = { 1039 { .compatible = "fsl,mpc5200b-fec", }, 1040 { .compatible = "fsl,mpc5200-fec", }, 1041 { .compatible = "mpc5200-fec", }, 1042 { } 1043 }; 1044 1045 MODULE_DEVICE_TABLE(of, mpc52xx_fec_match); 1046 1047 static struct platform_driver mpc52xx_fec_driver = { 1048 .driver = { 1049 .name = DRIVER_NAME, 1050 .of_match_table = mpc52xx_fec_match, 1051 }, 1052 .probe = mpc52xx_fec_probe, 1053 .remove = mpc52xx_fec_remove, 1054 #ifdef CONFIG_PM 1055 .suspend = mpc52xx_fec_of_suspend, 1056 .resume = mpc52xx_fec_of_resume, 1057 #endif 1058 }; 1059 1060 1061 /* ======================================================================== */ 1062 /* Module */ 1063 /* ======================================================================== */ 1064 1065 static struct platform_driver * const drivers[] = { 1066 #ifdef CONFIG_FEC_MPC52xx_MDIO 1067 &mpc52xx_fec_mdio_driver, 1068 #endif 1069 &mpc52xx_fec_driver, 1070 }; 1071 1072 static int __init 1073 mpc52xx_fec_init(void) 1074 { 1075 return platform_register_drivers(drivers, ARRAY_SIZE(drivers)); 1076 } 1077 1078 static void __exit 1079 mpc52xx_fec_exit(void) 1080 { 1081 platform_unregister_drivers(drivers, ARRAY_SIZE(drivers)); 1082 } 1083 1084 1085 module_init(mpc52xx_fec_init); 1086 module_exit(mpc52xx_fec_exit); 1087 1088 MODULE_LICENSE("GPL"); 1089 MODULE_AUTHOR("Dale Farnsworth"); 1090 MODULE_DESCRIPTION("Ethernet driver for the Freescale MPC52xx FEC"); 1091