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