2 * Copyright (C) 2004-2013 Synopsys, Inc. (www.synopsys.com)
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
8 * Driver for the ARC EMAC 10100 (hardware revision 5)
16 #include <linux/crc32.h>
17 #include <linux/etherdevice.h>
18 #include <linux/interrupt.h>
20 #include <linux/module.h>
21 #include <linux/of_address.h>
22 #include <linux/of_irq.h>
23 #include <linux/of_mdio.h>
24 #include <linux/of_net.h>
25 #include <linux/of_platform.h>
31 * arc_emac_tx_avail - Return the number of available slots in the tx ring.
32 * @priv: Pointer to ARC EMAC private data structure.
34 * returns: the number of slots available for transmission in tx the ring.
36 static inline int arc_emac_tx_avail(struct arc_emac_priv *priv)
38 return (priv->txbd_dirty + TX_BD_NUM - priv->txbd_curr - 1) % TX_BD_NUM;
42 * arc_emac_adjust_link - Adjust the PHY link duplex.
43 * @ndev: Pointer to the net_device structure.
45 * This function is called to change the duplex setting after auto negotiation
48 static void arc_emac_adjust_link(struct net_device *ndev)
50 struct arc_emac_priv *priv = netdev_priv(ndev);
51 struct phy_device *phy_dev = priv->phy_dev;
52 unsigned int reg, state_changed = 0;
54 if (priv->link != phy_dev->link) {
55 priv->link = phy_dev->link;
59 if (priv->speed != phy_dev->speed) {
60 priv->speed = phy_dev->speed;
62 if (priv->set_mac_speed)
63 priv->set_mac_speed(priv, priv->speed);
66 if (priv->duplex != phy_dev->duplex) {
67 reg = arc_reg_get(priv, R_CTRL);
69 if (DUPLEX_FULL == phy_dev->duplex)
74 arc_reg_set(priv, R_CTRL, reg);
75 priv->duplex = phy_dev->duplex;
80 phy_print_status(phy_dev);
84 * arc_emac_get_settings - Get PHY settings.
85 * @ndev: Pointer to net_device structure.
86 * @cmd: Pointer to ethtool_cmd structure.
88 * This implements ethtool command for getting PHY settings. If PHY could
89 * not be found, the function returns -ENODEV. This function calls the
90 * relevant PHY ethtool API to get the PHY settings.
91 * Issue "ethtool ethX" under linux prompt to execute this function.
93 static int arc_emac_get_settings(struct net_device *ndev,
94 struct ethtool_cmd *cmd)
96 struct arc_emac_priv *priv = netdev_priv(ndev);
98 return phy_ethtool_gset(priv->phy_dev, cmd);
102 * arc_emac_set_settings - Set PHY settings as passed in the argument.
103 * @ndev: Pointer to net_device structure.
104 * @cmd: Pointer to ethtool_cmd structure.
106 * This implements ethtool command for setting various PHY settings. If PHY
107 * could not be found, the function returns -ENODEV. This function calls the
108 * relevant PHY ethtool API to set the PHY.
109 * Issue e.g. "ethtool -s ethX speed 1000" under linux prompt to execute this
112 static int arc_emac_set_settings(struct net_device *ndev,
113 struct ethtool_cmd *cmd)
115 struct arc_emac_priv *priv = netdev_priv(ndev);
117 if (!capable(CAP_NET_ADMIN))
120 return phy_ethtool_sset(priv->phy_dev, cmd);
124 * arc_emac_get_drvinfo - Get EMAC driver information.
125 * @ndev: Pointer to net_device structure.
126 * @info: Pointer to ethtool_drvinfo structure.
128 * This implements ethtool command for getting the driver information.
129 * Issue "ethtool -i ethX" under linux prompt to execute this function.
131 static void arc_emac_get_drvinfo(struct net_device *ndev,
132 struct ethtool_drvinfo *info)
134 struct arc_emac_priv *priv = netdev_priv(ndev);
136 strlcpy(info->driver, priv->drv_name, sizeof(info->driver));
137 strlcpy(info->version, priv->drv_version, sizeof(info->version));
140 static const struct ethtool_ops arc_emac_ethtool_ops = {
141 .get_settings = arc_emac_get_settings,
142 .set_settings = arc_emac_set_settings,
143 .get_drvinfo = arc_emac_get_drvinfo,
144 .get_link = ethtool_op_get_link,
147 #define FIRST_OR_LAST_MASK (FIRST_MASK | LAST_MASK)
150 * arc_emac_tx_clean - clears processed by EMAC Tx BDs.
151 * @ndev: Pointer to the network device.
153 static void arc_emac_tx_clean(struct net_device *ndev)
155 struct arc_emac_priv *priv = netdev_priv(ndev);
156 struct net_device_stats *stats = &ndev->stats;
159 for (i = 0; i < TX_BD_NUM; i++) {
160 unsigned int *txbd_dirty = &priv->txbd_dirty;
161 struct arc_emac_bd *txbd = &priv->txbd[*txbd_dirty];
162 struct buffer_state *tx_buff = &priv->tx_buff[*txbd_dirty];
163 struct sk_buff *skb = tx_buff->skb;
164 unsigned int info = le32_to_cpu(txbd->info);
166 if ((info & FOR_EMAC) || !txbd->data)
169 if (unlikely(info & (DROP | DEFR | LTCL | UFLO))) {
174 stats->tx_carrier_errors++;
180 stats->tx_fifo_errors++;
181 } else if (likely(info & FIRST_OR_LAST_MASK)) {
183 stats->tx_bytes += skb->len;
186 dma_unmap_single(&ndev->dev, dma_unmap_addr(tx_buff, addr),
187 dma_unmap_len(tx_buff, len), DMA_TO_DEVICE);
189 /* return the sk_buff to system */
190 dev_kfree_skb_irq(skb);
195 *txbd_dirty = (*txbd_dirty + 1) % TX_BD_NUM;
198 /* Ensure that txbd_dirty is visible to tx() before checking
203 if (netif_queue_stopped(ndev) && arc_emac_tx_avail(priv))
204 netif_wake_queue(ndev);
208 * arc_emac_rx - processing of Rx packets.
209 * @ndev: Pointer to the network device.
210 * @budget: How many BDs to process on 1 call.
212 * returns: Number of processed BDs
214 * Iterate through Rx BDs and deliver received packages to upper layer.
216 static int arc_emac_rx(struct net_device *ndev, int budget)
218 struct arc_emac_priv *priv = netdev_priv(ndev);
219 unsigned int work_done;
221 for (work_done = 0; work_done < budget; work_done++) {
222 unsigned int *last_rx_bd = &priv->last_rx_bd;
223 struct net_device_stats *stats = &ndev->stats;
224 struct buffer_state *rx_buff = &priv->rx_buff[*last_rx_bd];
225 struct arc_emac_bd *rxbd = &priv->rxbd[*last_rx_bd];
226 unsigned int pktlen, info = le32_to_cpu(rxbd->info);
230 if (unlikely((info & OWN_MASK) == FOR_EMAC))
233 /* Make a note that we saw a packet at this BD.
234 * So next time, driver starts from this + 1
236 *last_rx_bd = (*last_rx_bd + 1) % RX_BD_NUM;
238 if (unlikely((info & FIRST_OR_LAST_MASK) !=
239 FIRST_OR_LAST_MASK)) {
240 /* We pre-allocate buffers of MTU size so incoming
241 * packets won't be split/chained.
244 netdev_err(ndev, "incomplete packet received\n");
246 /* Return ownership to EMAC */
247 rxbd->info = cpu_to_le32(FOR_EMAC | EMAC_BUFFER_SIZE);
249 stats->rx_length_errors++;
253 /* Prepare the BD for next cycle. netif_receive_skb()
254 * only if new skb was allocated and mapped to avoid holes
257 skb = netdev_alloc_skb_ip_align(ndev, EMAC_BUFFER_SIZE);
258 if (unlikely(!skb)) {
260 netdev_err(ndev, "cannot allocate skb\n");
261 /* Return ownership to EMAC */
262 rxbd->info = cpu_to_le32(FOR_EMAC | EMAC_BUFFER_SIZE);
268 addr = dma_map_single(&ndev->dev, (void *)skb->data,
269 EMAC_BUFFER_SIZE, DMA_FROM_DEVICE);
270 if (dma_mapping_error(&ndev->dev, addr)) {
272 netdev_err(ndev, "cannot map dma buffer\n");
274 /* Return ownership to EMAC */
275 rxbd->info = cpu_to_le32(FOR_EMAC | EMAC_BUFFER_SIZE);
281 /* unmap previosly mapped skb */
282 dma_unmap_single(&ndev->dev, dma_unmap_addr(rx_buff, addr),
283 dma_unmap_len(rx_buff, len), DMA_FROM_DEVICE);
285 pktlen = info & LEN_MASK;
287 stats->rx_bytes += pktlen;
288 skb_put(rx_buff->skb, pktlen);
289 rx_buff->skb->dev = ndev;
290 rx_buff->skb->protocol = eth_type_trans(rx_buff->skb, ndev);
292 netif_receive_skb(rx_buff->skb);
295 dma_unmap_addr_set(rx_buff, addr, addr);
296 dma_unmap_len_set(rx_buff, len, EMAC_BUFFER_SIZE);
298 rxbd->data = cpu_to_le32(addr);
300 /* Make sure pointer to data buffer is set */
303 /* Return ownership to EMAC */
304 rxbd->info = cpu_to_le32(FOR_EMAC | EMAC_BUFFER_SIZE);
311 * arc_emac_poll - NAPI poll handler.
312 * @napi: Pointer to napi_struct structure.
313 * @budget: How many BDs to process on 1 call.
315 * returns: Number of processed BDs
317 static int arc_emac_poll(struct napi_struct *napi, int budget)
319 struct net_device *ndev = napi->dev;
320 struct arc_emac_priv *priv = netdev_priv(ndev);
321 unsigned int work_done;
323 arc_emac_tx_clean(ndev);
325 work_done = arc_emac_rx(ndev, budget);
326 if (work_done < budget) {
328 arc_reg_or(priv, R_ENABLE, RXINT_MASK | TXINT_MASK);
335 * arc_emac_intr - Global interrupt handler for EMAC.
337 * @dev_instance: device instance.
339 * returns: IRQ_HANDLED for all cases.
341 * ARC EMAC has only 1 interrupt line, and depending on bits raised in
342 * STATUS register we may tell what is a reason for interrupt to fire.
344 static irqreturn_t arc_emac_intr(int irq, void *dev_instance)
346 struct net_device *ndev = dev_instance;
347 struct arc_emac_priv *priv = netdev_priv(ndev);
348 struct net_device_stats *stats = &ndev->stats;
351 status = arc_reg_get(priv, R_STATUS);
352 status &= ~MDIO_MASK;
354 /* Reset all flags except "MDIO complete" */
355 arc_reg_set(priv, R_STATUS, status);
357 if (status & (RXINT_MASK | TXINT_MASK)) {
358 if (likely(napi_schedule_prep(&priv->napi))) {
359 arc_reg_clr(priv, R_ENABLE, RXINT_MASK | TXINT_MASK);
360 __napi_schedule(&priv->napi);
364 if (status & ERR_MASK) {
365 /* MSER/RXCR/RXFR/RXFL interrupt fires on corresponding
366 * 8-bit error counter overrun.
369 if (status & MSER_MASK) {
370 stats->rx_missed_errors += 0x100;
371 stats->rx_errors += 0x100;
374 if (status & RXCR_MASK) {
375 stats->rx_crc_errors += 0x100;
376 stats->rx_errors += 0x100;
379 if (status & RXFR_MASK) {
380 stats->rx_frame_errors += 0x100;
381 stats->rx_errors += 0x100;
384 if (status & RXFL_MASK) {
385 stats->rx_over_errors += 0x100;
386 stats->rx_errors += 0x100;
393 #ifdef CONFIG_NET_POLL_CONTROLLER
394 static void arc_emac_poll_controller(struct net_device *dev)
396 disable_irq(dev->irq);
397 arc_emac_intr(dev->irq, dev);
398 enable_irq(dev->irq);
403 * arc_emac_open - Open the network device.
404 * @ndev: Pointer to the network device.
406 * returns: 0, on success or non-zero error value on failure.
408 * This function sets the MAC address, requests and enables an IRQ
409 * for the EMAC device and starts the Tx queue.
410 * It also connects to the phy device.
412 static int arc_emac_open(struct net_device *ndev)
414 struct arc_emac_priv *priv = netdev_priv(ndev);
415 struct phy_device *phy_dev = priv->phy_dev;
418 phy_dev->autoneg = AUTONEG_ENABLE;
421 phy_dev->advertising &= phy_dev->supported;
423 priv->last_rx_bd = 0;
425 /* Allocate and set buffers for Rx BD's */
426 for (i = 0; i < RX_BD_NUM; i++) {
428 unsigned int *last_rx_bd = &priv->last_rx_bd;
429 struct arc_emac_bd *rxbd = &priv->rxbd[*last_rx_bd];
430 struct buffer_state *rx_buff = &priv->rx_buff[*last_rx_bd];
432 rx_buff->skb = netdev_alloc_skb_ip_align(ndev,
434 if (unlikely(!rx_buff->skb))
437 addr = dma_map_single(&ndev->dev, (void *)rx_buff->skb->data,
438 EMAC_BUFFER_SIZE, DMA_FROM_DEVICE);
439 if (dma_mapping_error(&ndev->dev, addr)) {
440 netdev_err(ndev, "cannot dma map\n");
441 dev_kfree_skb(rx_buff->skb);
444 dma_unmap_addr_set(rx_buff, addr, addr);
445 dma_unmap_len_set(rx_buff, len, EMAC_BUFFER_SIZE);
447 rxbd->data = cpu_to_le32(addr);
449 /* Make sure pointer to data buffer is set */
452 /* Return ownership to EMAC */
453 rxbd->info = cpu_to_le32(FOR_EMAC | EMAC_BUFFER_SIZE);
455 *last_rx_bd = (*last_rx_bd + 1) % RX_BD_NUM;
459 memset(priv->txbd, 0, TX_RING_SZ);
461 /* Initialize logical address filter */
462 arc_reg_set(priv, R_LAFL, 0);
463 arc_reg_set(priv, R_LAFH, 0);
465 /* Set BD ring pointers for device side */
466 arc_reg_set(priv, R_RX_RING, (unsigned int)priv->rxbd_dma);
467 arc_reg_set(priv, R_TX_RING, (unsigned int)priv->txbd_dma);
469 /* Enable interrupts */
470 arc_reg_set(priv, R_ENABLE, RXINT_MASK | TXINT_MASK | ERR_MASK);
473 arc_reg_set(priv, R_CTRL,
474 (RX_BD_NUM << 24) | /* RX BD table length */
475 (TX_BD_NUM << 16) | /* TX BD table length */
476 TXRN_MASK | RXRN_MASK);
478 napi_enable(&priv->napi);
481 arc_reg_or(priv, R_CTRL, EN_MASK);
483 phy_start_aneg(priv->phy_dev);
485 netif_start_queue(ndev);
491 * arc_emac_set_rx_mode - Change the receive filtering mode.
492 * @ndev: Pointer to the network device.
494 * This function enables/disables promiscuous or all-multicast mode
495 * and updates the multicast filtering list of the network device.
497 static void arc_emac_set_rx_mode(struct net_device *ndev)
499 struct arc_emac_priv *priv = netdev_priv(ndev);
501 if (ndev->flags & IFF_PROMISC) {
502 arc_reg_or(priv, R_CTRL, PROM_MASK);
504 arc_reg_clr(priv, R_CTRL, PROM_MASK);
506 if (ndev->flags & IFF_ALLMULTI) {
507 arc_reg_set(priv, R_LAFL, ~0);
508 arc_reg_set(priv, R_LAFH, ~0);
510 struct netdev_hw_addr *ha;
511 unsigned int filter[2] = { 0, 0 };
514 netdev_for_each_mc_addr(ha, ndev) {
515 bit = ether_crc_le(ETH_ALEN, ha->addr) >> 26;
516 filter[bit >> 5] |= 1 << (bit & 31);
519 arc_reg_set(priv, R_LAFL, filter[0]);
520 arc_reg_set(priv, R_LAFH, filter[1]);
526 * arc_emac_stop - Close the network device.
527 * @ndev: Pointer to the network device.
529 * This function stops the Tx queue, disables interrupts and frees the IRQ for
531 * It also disconnects the PHY device associated with the EMAC device.
533 static int arc_emac_stop(struct net_device *ndev)
535 struct arc_emac_priv *priv = netdev_priv(ndev);
537 napi_disable(&priv->napi);
538 netif_stop_queue(ndev);
540 /* Disable interrupts */
541 arc_reg_clr(priv, R_ENABLE, RXINT_MASK | TXINT_MASK | ERR_MASK);
544 arc_reg_clr(priv, R_CTRL, EN_MASK);
550 * arc_emac_stats - Get system network statistics.
551 * @ndev: Pointer to net_device structure.
553 * Returns the address of the device statistics structure.
554 * Statistics are updated in interrupt handler.
556 static struct net_device_stats *arc_emac_stats(struct net_device *ndev)
558 struct arc_emac_priv *priv = netdev_priv(ndev);
559 struct net_device_stats *stats = &ndev->stats;
560 unsigned long miss, rxerr;
561 u8 rxcrc, rxfram, rxoflow;
563 rxerr = arc_reg_get(priv, R_RXERR);
564 miss = arc_reg_get(priv, R_MISS);
568 rxoflow = rxerr >> 16;
570 stats->rx_errors += miss;
571 stats->rx_errors += rxcrc + rxfram + rxoflow;
573 stats->rx_over_errors += rxoflow;
574 stats->rx_frame_errors += rxfram;
575 stats->rx_crc_errors += rxcrc;
576 stats->rx_missed_errors += miss;
582 * arc_emac_tx - Starts the data transmission.
583 * @skb: sk_buff pointer that contains data to be Transmitted.
584 * @ndev: Pointer to net_device structure.
586 * returns: NETDEV_TX_OK, on success
587 * NETDEV_TX_BUSY, if any of the descriptors are not free.
589 * This function is invoked from upper layers to initiate transmission.
591 static int arc_emac_tx(struct sk_buff *skb, struct net_device *ndev)
593 struct arc_emac_priv *priv = netdev_priv(ndev);
594 unsigned int len, *txbd_curr = &priv->txbd_curr;
595 struct net_device_stats *stats = &ndev->stats;
596 __le32 *info = &priv->txbd[*txbd_curr].info;
599 if (skb_padto(skb, ETH_ZLEN))
602 len = max_t(unsigned int, ETH_ZLEN, skb->len);
604 if (unlikely(!arc_emac_tx_avail(priv))) {
605 netif_stop_queue(ndev);
606 netdev_err(ndev, "BUG! Tx Ring full when queue awake!\n");
607 return NETDEV_TX_BUSY;
610 addr = dma_map_single(&ndev->dev, (void *)skb->data, len,
613 if (unlikely(dma_mapping_error(&ndev->dev, addr))) {
619 dma_unmap_addr_set(&priv->tx_buff[*txbd_curr], addr, addr);
620 dma_unmap_len_set(&priv->tx_buff[*txbd_curr], len, len);
622 priv->tx_buff[*txbd_curr].skb = skb;
623 priv->txbd[*txbd_curr].data = cpu_to_le32(addr);
625 /* Make sure pointer to data buffer is set */
628 skb_tx_timestamp(skb);
630 *info = cpu_to_le32(FOR_EMAC | FIRST_OR_LAST_MASK | len);
632 /* Increment index to point to the next BD */
633 *txbd_curr = (*txbd_curr + 1) % TX_BD_NUM;
635 /* Ensure that tx_clean() sees the new txbd_curr before
636 * checking the queue status. This prevents an unneeded wake
637 * of the queue in tx_clean().
641 if (!arc_emac_tx_avail(priv)) {
642 netif_stop_queue(ndev);
643 /* Refresh tx_dirty */
645 if (arc_emac_tx_avail(priv))
646 netif_start_queue(ndev);
649 arc_reg_set(priv, R_STATUS, TXPL_MASK);
654 static void arc_emac_set_address_internal(struct net_device *ndev)
656 struct arc_emac_priv *priv = netdev_priv(ndev);
657 unsigned int addr_low, addr_hi;
659 addr_low = le32_to_cpu(*(__le32 *) &ndev->dev_addr[0]);
660 addr_hi = le16_to_cpu(*(__le16 *) &ndev->dev_addr[4]);
662 arc_reg_set(priv, R_ADDRL, addr_low);
663 arc_reg_set(priv, R_ADDRH, addr_hi);
667 * arc_emac_set_address - Set the MAC address for this device.
668 * @ndev: Pointer to net_device structure.
669 * @p: 6 byte Address to be written as MAC address.
671 * This function copies the HW address from the sockaddr structure to the
672 * net_device structure and updates the address in HW.
674 * returns: -EBUSY if the net device is busy or 0 if the address is set
677 static int arc_emac_set_address(struct net_device *ndev, void *p)
679 struct sockaddr *addr = p;
681 if (netif_running(ndev))
684 if (!is_valid_ether_addr(addr->sa_data))
685 return -EADDRNOTAVAIL;
687 memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
689 arc_emac_set_address_internal(ndev);
694 static const struct net_device_ops arc_emac_netdev_ops = {
695 .ndo_open = arc_emac_open,
696 .ndo_stop = arc_emac_stop,
697 .ndo_start_xmit = arc_emac_tx,
698 .ndo_set_mac_address = arc_emac_set_address,
699 .ndo_get_stats = arc_emac_stats,
700 .ndo_set_rx_mode = arc_emac_set_rx_mode,
701 #ifdef CONFIG_NET_POLL_CONTROLLER
702 .ndo_poll_controller = arc_emac_poll_controller,
706 int arc_emac_probe(struct net_device *ndev, int interface)
708 struct device *dev = ndev->dev.parent;
709 struct resource res_regs;
710 struct device_node *phy_node;
711 struct arc_emac_priv *priv;
712 const char *mac_addr;
713 unsigned int id, clock_frequency, irq;
717 /* Get PHY from device tree */
718 phy_node = of_parse_phandle(dev->of_node, "phy", 0);
720 dev_err(dev, "failed to retrieve phy description from device tree\n");
724 /* Get EMAC registers base address from device tree */
725 err = of_address_to_resource(dev->of_node, 0, &res_regs);
727 dev_err(dev, "failed to retrieve registers base from device tree\n");
731 /* Get IRQ from device tree */
732 irq = irq_of_parse_and_map(dev->of_node, 0);
734 dev_err(dev, "failed to retrieve <irq> value from device tree\n");
739 ndev->netdev_ops = &arc_emac_netdev_ops;
740 ndev->ethtool_ops = &arc_emac_ethtool_ops;
741 ndev->watchdog_timeo = TX_TIMEOUT;
742 /* FIXME :: no multicast support yet */
743 ndev->flags &= ~IFF_MULTICAST;
745 priv = netdev_priv(ndev);
748 priv->regs = devm_ioremap_resource(dev, &res_regs);
749 if (IS_ERR(priv->regs)) {
750 return PTR_ERR(priv->regs);
752 dev_dbg(dev, "Registers base address is 0x%p\n", priv->regs);
755 err = clk_prepare_enable(priv->clk);
757 dev_err(dev, "failed to enable clock\n");
761 clock_frequency = clk_get_rate(priv->clk);
763 /* Get CPU clock frequency from device tree */
764 if (of_property_read_u32(dev->of_node, "clock-frequency",
766 dev_err(dev, "failed to retrieve <clock-frequency> from device tree\n");
771 id = arc_reg_get(priv, R_ID);
773 /* Check for EMAC revision 5 or 7, magic number */
774 if (!(id == 0x0005fd02 || id == 0x0007fd02)) {
775 dev_err(dev, "ARC EMAC not detected, id=0x%x\n", id);
779 dev_info(dev, "ARC EMAC detected with id: 0x%x\n", id);
781 /* Set poll rate so that it polls every 1 ms */
782 arc_reg_set(priv, R_POLLRATE, clock_frequency / 1000000);
785 dev_info(dev, "IRQ is %d\n", ndev->irq);
787 /* Register interrupt handler for device */
788 err = devm_request_irq(dev, ndev->irq, arc_emac_intr, 0,
791 dev_err(dev, "could not allocate IRQ\n");
795 /* Get MAC address from device tree */
796 mac_addr = of_get_mac_address(dev->of_node);
799 memcpy(ndev->dev_addr, mac_addr, ETH_ALEN);
801 eth_hw_addr_random(ndev);
803 arc_emac_set_address_internal(ndev);
804 dev_info(dev, "MAC address is now %pM\n", ndev->dev_addr);
806 /* Do 1 allocation instead of 2 separate ones for Rx and Tx BD rings */
807 priv->rxbd = dmam_alloc_coherent(dev, RX_RING_SZ + TX_RING_SZ,
808 &priv->rxbd_dma, GFP_KERNEL);
811 dev_err(dev, "failed to allocate data buffers\n");
816 priv->txbd = priv->rxbd + RX_BD_NUM;
818 priv->txbd_dma = priv->rxbd_dma + RX_RING_SZ;
819 dev_dbg(dev, "EMAC Device addr: Rx Ring [0x%x], Tx Ring[%x]\n",
820 (unsigned int)priv->rxbd_dma, (unsigned int)priv->txbd_dma);
822 err = arc_mdio_probe(priv);
824 dev_err(dev, "failed to probe MII bus\n");
828 priv->phy_dev = of_phy_connect(ndev, phy_node, arc_emac_adjust_link, 0,
830 if (!priv->phy_dev) {
831 dev_err(dev, "of_phy_connect() failed\n");
836 dev_info(dev, "connected to %s phy with id 0x%x\n",
837 priv->phy_dev->drv->name, priv->phy_dev->phy_id);
839 netif_napi_add(ndev, &priv->napi, arc_emac_poll, ARC_EMAC_NAPI_WEIGHT);
841 err = register_netdev(ndev);
843 dev_err(dev, "failed to register network device\n");
850 netif_napi_del(&priv->napi);
851 phy_disconnect(priv->phy_dev);
852 priv->phy_dev = NULL;
854 arc_mdio_remove(priv);
857 clk_disable_unprepare(priv->clk);
860 EXPORT_SYMBOL_GPL(arc_emac_probe);
862 int arc_emac_remove(struct net_device *ndev)
864 struct arc_emac_priv *priv = netdev_priv(ndev);
866 phy_disconnect(priv->phy_dev);
867 priv->phy_dev = NULL;
868 arc_mdio_remove(priv);
869 unregister_netdev(ndev);
870 netif_napi_del(&priv->napi);
872 if (!IS_ERR(priv->clk)) {
873 clk_disable_unprepare(priv->clk);
879 EXPORT_SYMBOL_GPL(arc_emac_remove);
881 MODULE_AUTHOR("Alexey Brodkin <abrodkin@synopsys.com>");
882 MODULE_DESCRIPTION("ARC EMAC driver");
883 MODULE_LICENSE("GPL");