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