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/etherdevice.h>
17 #include <linux/interrupt.h>
19 #include <linux/module.h>
20 #include <linux/of_address.h>
21 #include <linux/of_irq.h>
22 #include <linux/of_mdio.h>
23 #include <linux/of_net.h>
24 #include <linux/of_platform.h>
28 #define DRV_NAME "arc_emac"
29 #define DRV_VERSION "1.0"
32 * arc_emac_adjust_link - Adjust the PHY link duplex.
33 * @ndev: Pointer to the net_device structure.
35 * This function is called to change the duplex setting after auto negotiation
38 static void arc_emac_adjust_link(struct net_device
*ndev
)
40 struct arc_emac_priv
*priv
= netdev_priv(ndev
);
41 struct phy_device
*phy_dev
= priv
->phy_dev
;
42 unsigned int reg
, state_changed
= 0;
44 if (priv
->link
!= phy_dev
->link
) {
45 priv
->link
= phy_dev
->link
;
49 if (priv
->speed
!= phy_dev
->speed
) {
50 priv
->speed
= phy_dev
->speed
;
54 if (priv
->duplex
!= phy_dev
->duplex
) {
55 reg
= arc_reg_get(priv
, R_CTRL
);
57 if (DUPLEX_FULL
== phy_dev
->duplex
)
62 arc_reg_set(priv
, R_CTRL
, reg
);
63 priv
->duplex
= phy_dev
->duplex
;
68 phy_print_status(phy_dev
);
72 * arc_emac_get_settings - Get PHY settings.
73 * @ndev: Pointer to net_device structure.
74 * @cmd: Pointer to ethtool_cmd structure.
76 * This implements ethtool command for getting PHY settings. If PHY could
77 * not be found, the function returns -ENODEV. This function calls the
78 * relevant PHY ethtool API to get the PHY settings.
79 * Issue "ethtool ethX" under linux prompt to execute this function.
81 static int arc_emac_get_settings(struct net_device
*ndev
,
82 struct ethtool_cmd
*cmd
)
84 struct arc_emac_priv
*priv
= netdev_priv(ndev
);
86 return phy_ethtool_gset(priv
->phy_dev
, cmd
);
90 * arc_emac_set_settings - Set PHY settings as passed in the argument.
91 * @ndev: Pointer to net_device structure.
92 * @cmd: Pointer to ethtool_cmd structure.
94 * This implements ethtool command for setting various PHY settings. If PHY
95 * could not be found, the function returns -ENODEV. This function calls the
96 * relevant PHY ethtool API to set the PHY.
97 * Issue e.g. "ethtool -s ethX speed 1000" under linux prompt to execute this
100 static int arc_emac_set_settings(struct net_device
*ndev
,
101 struct ethtool_cmd
*cmd
)
103 struct arc_emac_priv
*priv
= netdev_priv(ndev
);
105 if (!capable(CAP_NET_ADMIN
))
108 return phy_ethtool_sset(priv
->phy_dev
, cmd
);
112 * arc_emac_get_drvinfo - Get EMAC driver information.
113 * @ndev: Pointer to net_device structure.
114 * @info: Pointer to ethtool_drvinfo structure.
116 * This implements ethtool command for getting the driver information.
117 * Issue "ethtool -i ethX" under linux prompt to execute this function.
119 static void arc_emac_get_drvinfo(struct net_device
*ndev
,
120 struct ethtool_drvinfo
*info
)
122 strlcpy(info
->driver
, DRV_NAME
, sizeof(info
->driver
));
123 strlcpy(info
->version
, DRV_VERSION
, sizeof(info
->version
));
126 static const struct ethtool_ops arc_emac_ethtool_ops
= {
127 .get_settings
= arc_emac_get_settings
,
128 .set_settings
= arc_emac_set_settings
,
129 .get_drvinfo
= arc_emac_get_drvinfo
,
130 .get_link
= ethtool_op_get_link
,
133 #define FIRST_OR_LAST_MASK (FIRST_MASK | LAST_MASK)
136 * arc_emac_tx_clean - clears processed by EMAC Tx BDs.
137 * @ndev: Pointer to the network device.
139 static void arc_emac_tx_clean(struct net_device
*ndev
)
141 struct arc_emac_priv
*priv
= netdev_priv(ndev
);
142 struct net_device_stats
*stats
= &priv
->stats
;
145 for (i
= 0; i
< TX_BD_NUM
; i
++) {
146 unsigned int *txbd_dirty
= &priv
->txbd_dirty
;
147 struct arc_emac_bd
*txbd
= &priv
->txbd
[*txbd_dirty
];
148 struct buffer_state
*tx_buff
= &priv
->tx_buff
[*txbd_dirty
];
149 struct sk_buff
*skb
= tx_buff
->skb
;
150 unsigned int info
= le32_to_cpu(txbd
->info
);
152 *txbd_dirty
= (*txbd_dirty
+ 1) % TX_BD_NUM
;
154 if ((info
& FOR_EMAC
) || !txbd
->data
)
157 if (unlikely(info
& (DROP
| DEFR
| LTCL
| UFLO
))) {
162 stats
->tx_carrier_errors
++;
168 stats
->tx_fifo_errors
++;
169 } else if (likely(info
& FIRST_OR_LAST_MASK
)) {
171 stats
->tx_bytes
+= skb
->len
;
174 dma_unmap_single(&ndev
->dev
, dma_unmap_addr(tx_buff
, addr
),
175 dma_unmap_len(tx_buff
, len
), DMA_TO_DEVICE
);
177 /* return the sk_buff to system */
178 dev_kfree_skb_irq(skb
);
183 if (netif_queue_stopped(ndev
))
184 netif_wake_queue(ndev
);
189 * arc_emac_rx - processing of Rx packets.
190 * @ndev: Pointer to the network device.
191 * @budget: How many BDs to process on 1 call.
193 * returns: Number of processed BDs
195 * Iterate through Rx BDs and deliver received packages to upper layer.
197 static int arc_emac_rx(struct net_device
*ndev
, int budget
)
199 struct arc_emac_priv
*priv
= netdev_priv(ndev
);
200 unsigned int work_done
;
202 for (work_done
= 0; work_done
<= budget
; work_done
++) {
203 unsigned int *last_rx_bd
= &priv
->last_rx_bd
;
204 struct net_device_stats
*stats
= &priv
->stats
;
205 struct buffer_state
*rx_buff
= &priv
->rx_buff
[*last_rx_bd
];
206 struct arc_emac_bd
*rxbd
= &priv
->rxbd
[*last_rx_bd
];
207 unsigned int pktlen
, info
= le32_to_cpu(rxbd
->info
);
211 if (unlikely((info
& OWN_MASK
) == FOR_EMAC
))
214 /* Make a note that we saw a packet at this BD.
215 * So next time, driver starts from this + 1
217 *last_rx_bd
= (*last_rx_bd
+ 1) % RX_BD_NUM
;
219 if (unlikely((info
& FIRST_OR_LAST_MASK
) !=
220 FIRST_OR_LAST_MASK
)) {
221 /* We pre-allocate buffers of MTU size so incoming
222 * packets won't be split/chained.
225 netdev_err(ndev
, "incomplete packet received\n");
227 /* Return ownership to EMAC */
228 rxbd
->info
= cpu_to_le32(FOR_EMAC
| EMAC_BUFFER_SIZE
);
230 stats
->rx_length_errors
++;
234 pktlen
= info
& LEN_MASK
;
236 stats
->rx_bytes
+= pktlen
;
238 skb_put(skb
, pktlen
);
240 skb
->protocol
= eth_type_trans(skb
, ndev
);
242 dma_unmap_single(&ndev
->dev
, dma_unmap_addr(rx_buff
, addr
),
243 dma_unmap_len(rx_buff
, len
), DMA_FROM_DEVICE
);
245 /* Prepare the BD for next cycle */
246 rx_buff
->skb
= netdev_alloc_skb_ip_align(ndev
,
248 if (unlikely(!rx_buff
->skb
)) {
250 /* Because receive_skb is below, increment rx_dropped */
255 /* receive_skb only if new skb was allocated to avoid holes */
256 netif_receive_skb(skb
);
258 addr
= dma_map_single(&ndev
->dev
, (void *)rx_buff
->skb
->data
,
259 EMAC_BUFFER_SIZE
, DMA_FROM_DEVICE
);
260 if (dma_mapping_error(&ndev
->dev
, addr
)) {
262 netdev_err(ndev
, "cannot dma map\n");
263 dev_kfree_skb(rx_buff
->skb
);
267 dma_unmap_addr_set(rx_buff
, addr
, addr
);
268 dma_unmap_len_set(rx_buff
, len
, EMAC_BUFFER_SIZE
);
270 rxbd
->data
= cpu_to_le32(addr
);
272 /* Make sure pointer to data buffer is set */
275 /* Return ownership to EMAC */
276 rxbd
->info
= cpu_to_le32(FOR_EMAC
| EMAC_BUFFER_SIZE
);
283 * arc_emac_poll - NAPI poll handler.
284 * @napi: Pointer to napi_struct structure.
285 * @budget: How many BDs to process on 1 call.
287 * returns: Number of processed BDs
289 static int arc_emac_poll(struct napi_struct
*napi
, int budget
)
291 struct net_device
*ndev
= napi
->dev
;
292 struct arc_emac_priv
*priv
= netdev_priv(ndev
);
293 unsigned int work_done
;
295 arc_emac_tx_clean(ndev
);
297 work_done
= arc_emac_rx(ndev
, budget
);
298 if (work_done
< budget
) {
300 arc_reg_or(priv
, R_ENABLE
, RXINT_MASK
);
307 * arc_emac_intr - Global interrupt handler for EMAC.
309 * @dev_instance: device instance.
311 * returns: IRQ_HANDLED for all cases.
313 * ARC EMAC has only 1 interrupt line, and depending on bits raised in
314 * STATUS register we may tell what is a reason for interrupt to fire.
316 static irqreturn_t
arc_emac_intr(int irq
, void *dev_instance
)
318 struct net_device
*ndev
= dev_instance
;
319 struct arc_emac_priv
*priv
= netdev_priv(ndev
);
320 struct net_device_stats
*stats
= &priv
->stats
;
323 status
= arc_reg_get(priv
, R_STATUS
);
324 status
&= ~MDIO_MASK
;
326 /* Reset all flags except "MDIO complete" */
327 arc_reg_set(priv
, R_STATUS
, status
);
329 if (status
& RXINT_MASK
) {
330 if (likely(napi_schedule_prep(&priv
->napi
))) {
331 arc_reg_clr(priv
, R_ENABLE
, RXINT_MASK
);
332 __napi_schedule(&priv
->napi
);
336 if (status
& ERR_MASK
) {
337 /* MSER/RXCR/RXFR/RXFL interrupt fires on corresponding
338 * 8-bit error counter overrun.
341 if (status
& MSER_MASK
) {
342 stats
->rx_missed_errors
+= 0x100;
343 stats
->rx_errors
+= 0x100;
346 if (status
& RXCR_MASK
) {
347 stats
->rx_crc_errors
+= 0x100;
348 stats
->rx_errors
+= 0x100;
351 if (status
& RXFR_MASK
) {
352 stats
->rx_frame_errors
+= 0x100;
353 stats
->rx_errors
+= 0x100;
356 if (status
& RXFL_MASK
) {
357 stats
->rx_over_errors
+= 0x100;
358 stats
->rx_errors
+= 0x100;
366 * arc_emac_open - Open the network device.
367 * @ndev: Pointer to the network device.
369 * returns: 0, on success or non-zero error value on failure.
371 * This function sets the MAC address, requests and enables an IRQ
372 * for the EMAC device and starts the Tx queue.
373 * It also connects to the phy device.
375 static int arc_emac_open(struct net_device
*ndev
)
377 struct arc_emac_priv
*priv
= netdev_priv(ndev
);
378 struct phy_device
*phy_dev
= priv
->phy_dev
;
381 phy_dev
->autoneg
= AUTONEG_ENABLE
;
384 phy_dev
->advertising
= phy_dev
->supported
;
386 if (priv
->max_speed
> 100) {
387 phy_dev
->advertising
&= PHY_GBIT_FEATURES
;
388 } else if (priv
->max_speed
<= 100) {
389 phy_dev
->advertising
&= PHY_BASIC_FEATURES
;
390 if (priv
->max_speed
<= 10) {
391 phy_dev
->advertising
&= ~SUPPORTED_100baseT_Half
;
392 phy_dev
->advertising
&= ~SUPPORTED_100baseT_Full
;
396 priv
->last_rx_bd
= 0;
398 /* Allocate and set buffers for Rx BD's */
399 for (i
= 0; i
< RX_BD_NUM
; i
++) {
401 unsigned int *last_rx_bd
= &priv
->last_rx_bd
;
402 struct arc_emac_bd
*rxbd
= &priv
->rxbd
[*last_rx_bd
];
403 struct buffer_state
*rx_buff
= &priv
->rx_buff
[*last_rx_bd
];
405 rx_buff
->skb
= netdev_alloc_skb_ip_align(ndev
,
407 if (unlikely(!rx_buff
->skb
))
410 addr
= dma_map_single(&ndev
->dev
, (void *)rx_buff
->skb
->data
,
411 EMAC_BUFFER_SIZE
, DMA_FROM_DEVICE
);
412 if (dma_mapping_error(&ndev
->dev
, addr
)) {
413 netdev_err(ndev
, "cannot dma map\n");
414 dev_kfree_skb(rx_buff
->skb
);
417 dma_unmap_addr_set(rx_buff
, addr
, addr
);
418 dma_unmap_len_set(rx_buff
, len
, EMAC_BUFFER_SIZE
);
420 rxbd
->data
= cpu_to_le32(addr
);
422 /* Make sure pointer to data buffer is set */
425 /* Return ownership to EMAC */
426 rxbd
->info
= cpu_to_le32(FOR_EMAC
| EMAC_BUFFER_SIZE
);
428 *last_rx_bd
= (*last_rx_bd
+ 1) % RX_BD_NUM
;
432 memset(priv
->txbd
, 0, TX_RING_SZ
);
434 /* Initialize logical address filter */
435 arc_reg_set(priv
, R_LAFL
, 0);
436 arc_reg_set(priv
, R_LAFH
, 0);
438 /* Set BD ring pointers for device side */
439 arc_reg_set(priv
, R_RX_RING
, (unsigned int)priv
->rxbd_dma
);
440 arc_reg_set(priv
, R_TX_RING
, (unsigned int)priv
->txbd_dma
);
442 /* Enable interrupts */
443 arc_reg_set(priv
, R_ENABLE
, RXINT_MASK
| ERR_MASK
);
446 arc_reg_set(priv
, R_CTRL
,
447 (RX_BD_NUM
<< 24) | /* RX BD table length */
448 (TX_BD_NUM
<< 16) | /* TX BD table length */
449 TXRN_MASK
| RXRN_MASK
);
451 napi_enable(&priv
->napi
);
454 arc_reg_or(priv
, R_CTRL
, EN_MASK
);
456 phy_start_aneg(priv
->phy_dev
);
458 netif_start_queue(ndev
);
464 * arc_emac_stop - Close the network device.
465 * @ndev: Pointer to the network device.
467 * This function stops the Tx queue, disables interrupts and frees the IRQ for
469 * It also disconnects the PHY device associated with the EMAC device.
471 static int arc_emac_stop(struct net_device
*ndev
)
473 struct arc_emac_priv
*priv
= netdev_priv(ndev
);
475 napi_disable(&priv
->napi
);
476 netif_stop_queue(ndev
);
478 /* Disable interrupts */
479 arc_reg_clr(priv
, R_ENABLE
, RXINT_MASK
| ERR_MASK
);
482 arc_reg_clr(priv
, R_CTRL
, EN_MASK
);
488 * arc_emac_stats - Get system network statistics.
489 * @ndev: Pointer to net_device structure.
491 * Returns the address of the device statistics structure.
492 * Statistics are updated in interrupt handler.
494 static struct net_device_stats
*arc_emac_stats(struct net_device
*ndev
)
496 struct arc_emac_priv
*priv
= netdev_priv(ndev
);
497 struct net_device_stats
*stats
= &priv
->stats
;
498 unsigned long miss
, rxerr
;
499 u8 rxcrc
, rxfram
, rxoflow
;
501 rxerr
= arc_reg_get(priv
, R_RXERR
);
502 miss
= arc_reg_get(priv
, R_MISS
);
506 rxoflow
= rxerr
>> 16;
508 stats
->rx_errors
+= miss
;
509 stats
->rx_errors
+= rxcrc
+ rxfram
+ rxoflow
;
511 stats
->rx_over_errors
+= rxoflow
;
512 stats
->rx_frame_errors
+= rxfram
;
513 stats
->rx_crc_errors
+= rxcrc
;
514 stats
->rx_missed_errors
+= miss
;
520 * arc_emac_tx - Starts the data transmission.
521 * @skb: sk_buff pointer that contains data to be Transmitted.
522 * @ndev: Pointer to net_device structure.
524 * returns: NETDEV_TX_OK, on success
525 * NETDEV_TX_BUSY, if any of the descriptors are not free.
527 * This function is invoked from upper layers to initiate transmission.
529 static int arc_emac_tx(struct sk_buff
*skb
, struct net_device
*ndev
)
531 struct arc_emac_priv
*priv
= netdev_priv(ndev
);
532 unsigned int len
, *txbd_curr
= &priv
->txbd_curr
;
533 struct net_device_stats
*stats
= &priv
->stats
;
534 __le32
*info
= &priv
->txbd
[*txbd_curr
].info
;
537 if (skb_padto(skb
, ETH_ZLEN
))
540 len
= max_t(unsigned int, ETH_ZLEN
, skb
->len
);
542 /* EMAC still holds this buffer in its possession.
543 * CPU must not modify this buffer descriptor
545 if (unlikely((le32_to_cpu(*info
) & OWN_MASK
) == FOR_EMAC
)) {
546 netif_stop_queue(ndev
);
547 return NETDEV_TX_BUSY
;
550 addr
= dma_map_single(&ndev
->dev
, (void *)skb
->data
, len
,
553 if (unlikely(dma_mapping_error(&ndev
->dev
, addr
))) {
559 dma_unmap_addr_set(&priv
->tx_buff
[*txbd_curr
], addr
, addr
);
560 dma_unmap_len_set(&priv
->tx_buff
[*txbd_curr
], len
, len
);
562 priv
->tx_buff
[*txbd_curr
].skb
= skb
;
563 priv
->txbd
[*txbd_curr
].data
= cpu_to_le32(addr
);
565 /* Make sure pointer to data buffer is set */
568 *info
= cpu_to_le32(FOR_EMAC
| FIRST_OR_LAST_MASK
| len
);
570 /* Increment index to point to the next BD */
571 *txbd_curr
= (*txbd_curr
+ 1) % TX_BD_NUM
;
573 /* Get "info" of the next BD */
574 info
= &priv
->txbd
[*txbd_curr
].info
;
576 /* Check if if Tx BD ring is full - next BD is still owned by EMAC */
577 if (unlikely((le32_to_cpu(*info
) & OWN_MASK
) == FOR_EMAC
))
578 netif_stop_queue(ndev
);
580 arc_reg_set(priv
, R_STATUS
, TXPL_MASK
);
582 skb_tx_timestamp(skb
);
588 * arc_emac_set_address - Set the MAC address for this device.
589 * @ndev: Pointer to net_device structure.
590 * @p: 6 byte Address to be written as MAC address.
592 * This function copies the HW address from the sockaddr structure to the
593 * net_device structure and updates the address in HW.
595 * returns: -EBUSY if the net device is busy or 0 if the address is set
598 static int arc_emac_set_address(struct net_device
*ndev
, void *p
)
600 struct arc_emac_priv
*priv
= netdev_priv(ndev
);
601 struct sockaddr
*addr
= p
;
602 unsigned int addr_low
, addr_hi
;
604 if (netif_running(ndev
))
607 if (!is_valid_ether_addr(addr
->sa_data
))
608 return -EADDRNOTAVAIL
;
610 memcpy(ndev
->dev_addr
, addr
->sa_data
, ndev
->addr_len
);
612 addr_low
= le32_to_cpu(*(__le32
*) &ndev
->dev_addr
[0]);
613 addr_hi
= le16_to_cpu(*(__le16
*) &ndev
->dev_addr
[4]);
615 arc_reg_set(priv
, R_ADDRL
, addr_low
);
616 arc_reg_set(priv
, R_ADDRH
, addr_hi
);
621 static const struct net_device_ops arc_emac_netdev_ops
= {
622 .ndo_open
= arc_emac_open
,
623 .ndo_stop
= arc_emac_stop
,
624 .ndo_start_xmit
= arc_emac_tx
,
625 .ndo_set_mac_address
= arc_emac_set_address
,
626 .ndo_get_stats
= arc_emac_stats
,
629 static int arc_emac_probe(struct platform_device
*pdev
)
631 struct resource res_regs
, res_irq
;
632 struct device_node
*phy_node
;
633 struct arc_emac_priv
*priv
;
634 struct net_device
*ndev
;
635 const char *mac_addr
;
636 unsigned int id
, clock_frequency
;
639 if (!pdev
->dev
.of_node
)
642 /* Get PHY from device tree */
643 phy_node
= of_parse_phandle(pdev
->dev
.of_node
, "phy", 0);
645 dev_err(&pdev
->dev
, "failed to retrieve phy description from device tree\n");
649 /* Get EMAC registers base address from device tree */
650 err
= of_address_to_resource(pdev
->dev
.of_node
, 0, &res_regs
);
652 dev_err(&pdev
->dev
, "failed to retrieve registers base from device tree\n");
656 /* Get CPU clock frequency from device tree */
657 if (of_property_read_u32(pdev
->dev
.of_node
, "clock-frequency",
659 dev_err(&pdev
->dev
, "failed to retrieve <clock-frequency> from device tree\n");
663 /* Get IRQ from device tree */
664 err
= of_irq_to_resource(pdev
->dev
.of_node
, 0, &res_irq
);
666 dev_err(&pdev
->dev
, "failed to retrieve <irq> value from device tree\n");
670 ndev
= alloc_etherdev(sizeof(struct arc_emac_priv
));
674 SET_NETDEV_DEV(ndev
, &pdev
->dev
);
676 ndev
->netdev_ops
= &arc_emac_netdev_ops
;
677 ndev
->ethtool_ops
= &arc_emac_ethtool_ops
;
678 ndev
->watchdog_timeo
= TX_TIMEOUT
;
679 /* FIXME :: no multicast support yet */
680 ndev
->flags
&= ~IFF_MULTICAST
;
682 priv
= netdev_priv(ndev
);
683 priv
->dev
= &pdev
->dev
;
686 priv
->regs
= devm_ioremap_resource(&pdev
->dev
, &res_regs
);
687 if (IS_ERR(priv
->regs
)) {
688 err
= PTR_ERR(priv
->regs
);
691 dev_dbg(&pdev
->dev
, "Registers base address is 0x%p\n", priv
->regs
);
693 id
= arc_reg_get(priv
, R_ID
);
695 /* Check for EMAC revision 5 or 7, magic number */
696 if (!(id
== 0x0005fd02 || id
== 0x0007fd02)) {
697 dev_err(&pdev
->dev
, "ARC EMAC not detected, id=0x%x\n", id
);
701 dev_info(&pdev
->dev
, "ARC EMAC detected with id: 0x%x\n", id
);
703 /* Set poll rate so that it polls every 1 ms */
704 arc_reg_set(priv
, R_POLLRATE
, clock_frequency
/ 1000000);
706 /* Get max speed of operation from device tree */
707 if (of_property_read_u32(pdev
->dev
.of_node
, "max-speed",
709 dev_err(&pdev
->dev
, "failed to retrieve <max-speed> from device tree\n");
714 ndev
->irq
= res_irq
.start
;
715 dev_info(&pdev
->dev
, "IRQ is %d\n", ndev
->irq
);
717 /* Register interrupt handler for device */
718 err
= devm_request_irq(&pdev
->dev
, ndev
->irq
, arc_emac_intr
, 0,
721 dev_err(&pdev
->dev
, "could not allocate IRQ\n");
725 /* Get MAC address from device tree */
726 mac_addr
= of_get_mac_address(pdev
->dev
.of_node
);
728 if (!mac_addr
|| !is_valid_ether_addr(mac_addr
))
729 eth_hw_addr_random(ndev
);
731 memcpy(ndev
->dev_addr
, mac_addr
, ETH_ALEN
);
733 dev_info(&pdev
->dev
, "MAC address is now %pM\n", ndev
->dev_addr
);
735 /* Do 1 allocation instead of 2 separate ones for Rx and Tx BD rings */
736 priv
->rxbd
= dmam_alloc_coherent(&pdev
->dev
, RX_RING_SZ
+ TX_RING_SZ
,
737 &priv
->rxbd_dma
, GFP_KERNEL
);
740 dev_err(&pdev
->dev
, "failed to allocate data buffers\n");
745 priv
->txbd
= priv
->rxbd
+ RX_BD_NUM
;
747 priv
->txbd_dma
= priv
->rxbd_dma
+ RX_RING_SZ
;
748 dev_dbg(&pdev
->dev
, "EMAC Device addr: Rx Ring [0x%x], Tx Ring[%x]\n",
749 (unsigned int)priv
->rxbd_dma
, (unsigned int)priv
->txbd_dma
);
751 err
= arc_mdio_probe(pdev
, priv
);
753 dev_err(&pdev
->dev
, "failed to probe MII bus\n");
757 priv
->phy_dev
= of_phy_connect(ndev
, phy_node
, arc_emac_adjust_link
, 0,
758 PHY_INTERFACE_MODE_MII
);
759 if (!priv
->phy_dev
) {
760 dev_err(&pdev
->dev
, "of_phy_connect() failed\n");
765 dev_info(&pdev
->dev
, "connected to %s phy with id 0x%x\n",
766 priv
->phy_dev
->drv
->name
, priv
->phy_dev
->phy_id
);
768 netif_napi_add(ndev
, &priv
->napi
, arc_emac_poll
, ARC_EMAC_NAPI_WEIGHT
);
770 err
= register_netdev(ndev
);
772 netif_napi_del(&priv
->napi
);
773 dev_err(&pdev
->dev
, "failed to register network device\n");
784 static int arc_emac_remove(struct platform_device
*pdev
)
786 struct net_device
*ndev
= platform_get_drvdata(pdev
);
787 struct arc_emac_priv
*priv
= netdev_priv(ndev
);
789 phy_disconnect(priv
->phy_dev
);
790 priv
->phy_dev
= NULL
;
791 arc_mdio_remove(priv
);
792 unregister_netdev(ndev
);
793 netif_napi_del(&priv
->napi
);
799 static const struct of_device_id arc_emac_dt_ids
[] = {
800 { .compatible
= "snps,arc-emac" },
803 MODULE_DEVICE_TABLE(of
, arc_emac_dt_ids
);
805 static struct platform_driver arc_emac_driver
= {
806 .probe
= arc_emac_probe
,
807 .remove
= arc_emac_remove
,
810 .owner
= THIS_MODULE
,
811 .of_match_table
= arc_emac_dt_ids
,
815 module_platform_driver(arc_emac_driver
);
817 MODULE_AUTHOR("Alexey Brodkin <abrodkin@synopsys.com>");
818 MODULE_DESCRIPTION("ARC EMAC driver");
819 MODULE_LICENSE("GPL");