1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright (c) 2013-2016, The Linux Foundation. All rights reserved.
5 /* Qualcomm Technologies, Inc. EMAC Gigabit Ethernet Driver */
7 #include <linux/if_ether.h>
8 #include <linux/if_vlan.h>
9 #include <linux/interrupt.h>
11 #include <linux/module.h>
13 #include <linux/of_net.h>
14 #include <linux/of_device.h>
15 #include <linux/phy.h>
16 #include <linux/platform_device.h>
17 #include <linux/acpi.h>
21 #include "emac-sgmii.h"
23 #define EMAC_MSG_DEFAULT (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK | \
24 NETIF_MSG_TIMER | NETIF_MSG_IFDOWN | NETIF_MSG_IFUP)
26 #define EMAC_RRD_SIZE 4
27 /* The RRD size if timestamping is enabled: */
28 #define EMAC_TS_RRD_SIZE 6
29 #define EMAC_TPD_SIZE 4
30 #define EMAC_RFD_SIZE 2
32 #define REG_MAC_RX_STATUS_BIN EMAC_RXMAC_STATC_REG0
33 #define REG_MAC_RX_STATUS_END EMAC_RXMAC_STATC_REG22
34 #define REG_MAC_TX_STATUS_BIN EMAC_TXMAC_STATC_REG0
35 #define REG_MAC_TX_STATUS_END EMAC_TXMAC_STATC_REG24
37 #define RXQ0_NUM_RFD_PREF_DEF 8
38 #define TXQ0_NUM_TPD_PREF_DEF 5
40 #define EMAC_PREAMBLE_DEF 7
42 #define DMAR_DLY_CNT_DEF 15
43 #define DMAW_DLY_CNT_DEF 4
45 #define IMR_NORMAL_MASK (ISR_ERROR | ISR_OVER | ISR_TX_PKT)
67 /* in sync with enum emac_clk_id */
68 static const char * const emac_clk_name
[] = {
69 "axi_clk", "cfg_ahb_clk", "high_speed_clk", "mdio_clk", "tx_clk",
73 void emac_reg_update32(void __iomem
*addr
, u32 mask
, u32 val
)
75 u32 data
= readl(addr
);
77 writel(((data
& ~mask
) | val
), addr
);
81 int emac_reinit_locked(struct emac_adapter
*adpt
)
85 mutex_lock(&adpt
->reset_lock
);
88 emac_sgmii_reset(adpt
);
89 ret
= emac_mac_up(adpt
);
91 mutex_unlock(&adpt
->reset_lock
);
97 static int emac_napi_rtx(struct napi_struct
*napi
, int budget
)
99 struct emac_rx_queue
*rx_q
=
100 container_of(napi
, struct emac_rx_queue
, napi
);
101 struct emac_adapter
*adpt
= netdev_priv(rx_q
->netdev
);
102 struct emac_irq
*irq
= rx_q
->irq
;
105 emac_mac_rx_process(adpt
, rx_q
, &work_done
, budget
);
107 if (work_done
< budget
) {
108 napi_complete_done(napi
, work_done
);
110 irq
->mask
|= rx_q
->intr
;
111 writel(irq
->mask
, adpt
->base
+ EMAC_INT_MASK
);
117 /* Transmit the packet */
118 static int emac_start_xmit(struct sk_buff
*skb
, struct net_device
*netdev
)
120 struct emac_adapter
*adpt
= netdev_priv(netdev
);
122 return emac_mac_tx_buf_send(adpt
, &adpt
->tx_q
, skb
);
125 static irqreturn_t
emac_isr(int _irq
, void *data
)
127 struct emac_irq
*irq
= data
;
128 struct emac_adapter
*adpt
=
129 container_of(irq
, struct emac_adapter
, irq
);
130 struct emac_rx_queue
*rx_q
= &adpt
->rx_q
;
133 /* disable the interrupt */
134 writel(0, adpt
->base
+ EMAC_INT_MASK
);
136 isr
= readl_relaxed(adpt
->base
+ EMAC_INT_STATUS
);
138 status
= isr
& irq
->mask
;
142 if (status
& ISR_ERROR
) {
143 net_err_ratelimited("%s: error interrupt 0x%lx\n",
144 adpt
->netdev
->name
, status
& ISR_ERROR
);
146 schedule_work(&adpt
->work_thread
);
149 /* Schedule the napi for receive queue with interrupt
152 if (status
& rx_q
->intr
) {
153 if (napi_schedule_prep(&rx_q
->napi
)) {
154 irq
->mask
&= ~rx_q
->intr
;
155 __napi_schedule(&rx_q
->napi
);
159 if (status
& TX_PKT_INT
)
160 emac_mac_tx_process(adpt
, &adpt
->tx_q
);
162 if (status
& ISR_OVER
)
163 net_warn_ratelimited("%s: TX/RX overflow interrupt\n",
167 /* enable the interrupt */
168 writel(irq
->mask
, adpt
->base
+ EMAC_INT_MASK
);
173 /* Configure VLAN tag strip/insert feature */
174 static int emac_set_features(struct net_device
*netdev
,
175 netdev_features_t features
)
177 netdev_features_t changed
= features
^ netdev
->features
;
178 struct emac_adapter
*adpt
= netdev_priv(netdev
);
180 /* We only need to reprogram the hardware if the VLAN tag features
181 * have changed, and if it's already running.
183 if (!(changed
& (NETIF_F_HW_VLAN_CTAG_TX
| NETIF_F_HW_VLAN_CTAG_RX
)))
186 if (!netif_running(netdev
))
189 /* emac_mac_mode_config() uses netdev->features to configure the EMAC,
190 * so make sure it's set first.
192 netdev
->features
= features
;
194 return emac_reinit_locked(adpt
);
197 /* Configure Multicast and Promiscuous modes */
198 static void emac_rx_mode_set(struct net_device
*netdev
)
200 struct emac_adapter
*adpt
= netdev_priv(netdev
);
201 struct netdev_hw_addr
*ha
;
203 emac_mac_mode_config(adpt
);
205 /* update multicast address filtering */
206 emac_mac_multicast_addr_clear(adpt
);
207 netdev_for_each_mc_addr(ha
, netdev
)
208 emac_mac_multicast_addr_set(adpt
, ha
->addr
);
211 /* Change the Maximum Transfer Unit (MTU) */
212 static int emac_change_mtu(struct net_device
*netdev
, int new_mtu
)
214 struct emac_adapter
*adpt
= netdev_priv(netdev
);
216 netif_dbg(adpt
, hw
, adpt
->netdev
,
217 "changing MTU from %d to %d\n", netdev
->mtu
,
219 netdev
->mtu
= new_mtu
;
221 if (netif_running(netdev
))
222 return emac_reinit_locked(adpt
);
227 /* Called when the network interface is made active */
228 static int emac_open(struct net_device
*netdev
)
230 struct emac_adapter
*adpt
= netdev_priv(netdev
);
231 struct emac_irq
*irq
= &adpt
->irq
;
234 ret
= request_irq(irq
->irq
, emac_isr
, 0, "emac-core0", irq
);
236 netdev_err(adpt
->netdev
, "could not request emac-core0 irq\n");
240 /* allocate rx/tx dma buffer & descriptors */
241 ret
= emac_mac_rx_tx_rings_alloc_all(adpt
);
243 netdev_err(adpt
->netdev
, "error allocating rx/tx rings\n");
244 free_irq(irq
->irq
, irq
);
248 ret
= emac_sgmii_open(adpt
);
250 emac_mac_rx_tx_rings_free_all(adpt
);
251 free_irq(irq
->irq
, irq
);
255 ret
= emac_mac_up(adpt
);
257 emac_mac_rx_tx_rings_free_all(adpt
);
258 free_irq(irq
->irq
, irq
);
259 emac_sgmii_close(adpt
);
266 /* Called when the network interface is disabled */
267 static int emac_close(struct net_device
*netdev
)
269 struct emac_adapter
*adpt
= netdev_priv(netdev
);
271 mutex_lock(&adpt
->reset_lock
);
273 emac_sgmii_close(adpt
);
275 emac_mac_rx_tx_rings_free_all(adpt
);
277 free_irq(adpt
->irq
.irq
, &adpt
->irq
);
279 mutex_unlock(&adpt
->reset_lock
);
284 /* Respond to a TX hang */
285 static void emac_tx_timeout(struct net_device
*netdev
)
287 struct emac_adapter
*adpt
= netdev_priv(netdev
);
289 schedule_work(&adpt
->work_thread
);
292 /* IOCTL support for the interface */
293 static int emac_ioctl(struct net_device
*netdev
, struct ifreq
*ifr
, int cmd
)
295 if (!netif_running(netdev
))
301 return phy_mii_ioctl(netdev
->phydev
, ifr
, cmd
);
305 * emac_update_hw_stats - read the EMAC stat registers
307 * Reads the stats registers and write the values to adpt->stats.
309 * adpt->stats.lock must be held while calling this function,
310 * and while reading from adpt->stats.
312 void emac_update_hw_stats(struct emac_adapter
*adpt
)
314 struct emac_stats
*stats
= &adpt
->stats
;
315 u64
*stats_itr
= &adpt
->stats
.rx_ok
;
316 void __iomem
*base
= adpt
->base
;
319 addr
= REG_MAC_RX_STATUS_BIN
;
320 while (addr
<= REG_MAC_RX_STATUS_END
) {
321 *stats_itr
+= readl_relaxed(base
+ addr
);
326 /* additional rx status */
327 stats
->rx_crc_align
+= readl_relaxed(base
+ EMAC_RXMAC_STATC_REG23
);
328 stats
->rx_jabbers
+= readl_relaxed(base
+ EMAC_RXMAC_STATC_REG24
);
330 /* update tx status */
331 addr
= REG_MAC_TX_STATUS_BIN
;
332 stats_itr
= &stats
->tx_ok
;
334 while (addr
<= REG_MAC_TX_STATUS_END
) {
335 *stats_itr
+= readl_relaxed(base
+ addr
);
340 /* additional tx status */
341 stats
->tx_col
+= readl_relaxed(base
+ EMAC_TXMAC_STATC_REG25
);
344 /* Provide network statistics info for the interface */
345 static void emac_get_stats64(struct net_device
*netdev
,
346 struct rtnl_link_stats64
*net_stats
)
348 struct emac_adapter
*adpt
= netdev_priv(netdev
);
349 struct emac_stats
*stats
= &adpt
->stats
;
351 spin_lock(&stats
->lock
);
353 emac_update_hw_stats(adpt
);
355 /* return parsed statistics */
356 net_stats
->rx_packets
= stats
->rx_ok
;
357 net_stats
->tx_packets
= stats
->tx_ok
;
358 net_stats
->rx_bytes
= stats
->rx_byte_cnt
;
359 net_stats
->tx_bytes
= stats
->tx_byte_cnt
;
360 net_stats
->multicast
= stats
->rx_mcast
;
361 net_stats
->collisions
= stats
->tx_1_col
+ stats
->tx_2_col
* 2 +
362 stats
->tx_late_col
+ stats
->tx_abort_col
;
364 net_stats
->rx_errors
= stats
->rx_frag
+ stats
->rx_fcs_err
+
365 stats
->rx_len_err
+ stats
->rx_sz_ov
+
367 net_stats
->rx_fifo_errors
= stats
->rx_rxf_ov
;
368 net_stats
->rx_length_errors
= stats
->rx_len_err
;
369 net_stats
->rx_crc_errors
= stats
->rx_fcs_err
;
370 net_stats
->rx_frame_errors
= stats
->rx_align_err
;
371 net_stats
->rx_over_errors
= stats
->rx_rxf_ov
;
372 net_stats
->rx_missed_errors
= stats
->rx_rxf_ov
;
374 net_stats
->tx_errors
= stats
->tx_late_col
+ stats
->tx_abort_col
+
375 stats
->tx_underrun
+ stats
->tx_trunc
;
376 net_stats
->tx_fifo_errors
= stats
->tx_underrun
;
377 net_stats
->tx_aborted_errors
= stats
->tx_abort_col
;
378 net_stats
->tx_window_errors
= stats
->tx_late_col
;
380 spin_unlock(&stats
->lock
);
383 static const struct net_device_ops emac_netdev_ops
= {
384 .ndo_open
= emac_open
,
385 .ndo_stop
= emac_close
,
386 .ndo_validate_addr
= eth_validate_addr
,
387 .ndo_start_xmit
= emac_start_xmit
,
388 .ndo_set_mac_address
= eth_mac_addr
,
389 .ndo_change_mtu
= emac_change_mtu
,
390 .ndo_do_ioctl
= emac_ioctl
,
391 .ndo_tx_timeout
= emac_tx_timeout
,
392 .ndo_get_stats64
= emac_get_stats64
,
393 .ndo_set_features
= emac_set_features
,
394 .ndo_set_rx_mode
= emac_rx_mode_set
,
397 /* Watchdog task routine, called to reinitialize the EMAC */
398 static void emac_work_thread(struct work_struct
*work
)
400 struct emac_adapter
*adpt
=
401 container_of(work
, struct emac_adapter
, work_thread
);
403 emac_reinit_locked(adpt
);
406 /* Initialize various data structures */
407 static void emac_init_adapter(struct emac_adapter
*adpt
)
411 adpt
->rrd_size
= EMAC_RRD_SIZE
;
412 adpt
->tpd_size
= EMAC_TPD_SIZE
;
413 adpt
->rfd_size
= EMAC_RFD_SIZE
;
416 adpt
->tx_desc_cnt
= EMAC_DEF_TX_DESCS
;
417 adpt
->rx_desc_cnt
= EMAC_DEF_RX_DESCS
;
420 adpt
->dma_order
= emac_dma_ord_out
;
421 adpt
->dmar_block
= emac_dma_req_4096
;
422 adpt
->dmaw_block
= emac_dma_req_128
;
423 adpt
->dmar_dly_cnt
= DMAR_DLY_CNT_DEF
;
424 adpt
->dmaw_dly_cnt
= DMAW_DLY_CNT_DEF
;
425 adpt
->tpd_burst
= TXQ0_NUM_TPD_PREF_DEF
;
426 adpt
->rfd_burst
= RXQ0_NUM_RFD_PREF_DEF
;
429 reg
= ((EMAC_DEF_RX_IRQ_MOD
>> 1) << IRQ_MODERATOR2_INIT_SHFT
) |
430 ((EMAC_DEF_TX_IRQ_MOD
>> 1) << IRQ_MODERATOR_INIT_SHFT
);
434 adpt
->preamble
= EMAC_PREAMBLE_DEF
;
436 /* default to automatic flow control */
437 adpt
->automatic
= true;
439 /* Disable single-pause-frame mode by default */
440 adpt
->single_pause_mode
= false;
444 static int emac_clks_get(struct platform_device
*pdev
,
445 struct emac_adapter
*adpt
)
449 for (i
= 0; i
< EMAC_CLK_CNT
; i
++) {
450 struct clk
*clk
= devm_clk_get(&pdev
->dev
, emac_clk_name
[i
]);
454 "could not claim clock %s (error=%li)\n",
455 emac_clk_name
[i
], PTR_ERR(clk
));
466 /* Initialize clocks */
467 static int emac_clks_phase1_init(struct platform_device
*pdev
,
468 struct emac_adapter
*adpt
)
472 /* On ACPI platforms, clocks are controlled by firmware and/or
473 * ACPI, not by drivers.
475 if (has_acpi_companion(&pdev
->dev
))
478 ret
= emac_clks_get(pdev
, adpt
);
482 ret
= clk_prepare_enable(adpt
->clk
[EMAC_CLK_AXI
]);
486 ret
= clk_prepare_enable(adpt
->clk
[EMAC_CLK_CFG_AHB
]);
490 ret
= clk_set_rate(adpt
->clk
[EMAC_CLK_HIGH_SPEED
], 19200000);
494 return clk_prepare_enable(adpt
->clk
[EMAC_CLK_HIGH_SPEED
]);
497 /* Enable clocks; needs emac_clks_phase1_init to be called before */
498 static int emac_clks_phase2_init(struct platform_device
*pdev
,
499 struct emac_adapter
*adpt
)
503 if (has_acpi_companion(&pdev
->dev
))
506 ret
= clk_set_rate(adpt
->clk
[EMAC_CLK_TX
], 125000000);
510 ret
= clk_prepare_enable(adpt
->clk
[EMAC_CLK_TX
]);
514 ret
= clk_set_rate(adpt
->clk
[EMAC_CLK_HIGH_SPEED
], 125000000);
518 ret
= clk_set_rate(adpt
->clk
[EMAC_CLK_MDIO
], 25000000);
522 ret
= clk_prepare_enable(adpt
->clk
[EMAC_CLK_MDIO
]);
526 ret
= clk_prepare_enable(adpt
->clk
[EMAC_CLK_RX
]);
530 return clk_prepare_enable(adpt
->clk
[EMAC_CLK_SYS
]);
533 static void emac_clks_teardown(struct emac_adapter
*adpt
)
538 for (i
= 0; i
< EMAC_CLK_CNT
; i
++)
539 clk_disable_unprepare(adpt
->clk
[i
]);
542 /* Get the resources */
543 static int emac_probe_resources(struct platform_device
*pdev
,
544 struct emac_adapter
*adpt
)
546 struct net_device
*netdev
= adpt
->netdev
;
547 char maddr
[ETH_ALEN
];
550 /* get mac address */
551 if (device_get_mac_address(&pdev
->dev
, maddr
, ETH_ALEN
))
552 ether_addr_copy(netdev
->dev_addr
, maddr
);
554 eth_hw_addr_random(netdev
);
556 /* Core 0 interrupt */
557 ret
= platform_get_irq(pdev
, 0);
562 /* base register address */
563 adpt
->base
= devm_platform_ioremap_resource(pdev
, 0);
564 if (IS_ERR(adpt
->base
))
565 return PTR_ERR(adpt
->base
);
567 /* CSR register address */
568 adpt
->csr
= devm_platform_ioremap_resource(pdev
, 1);
569 if (IS_ERR(adpt
->csr
))
570 return PTR_ERR(adpt
->csr
);
572 netdev
->base_addr
= (unsigned long)adpt
->base
;
577 static const struct of_device_id emac_dt_match
[] = {
579 .compatible
= "qcom,fsm9900-emac",
583 MODULE_DEVICE_TABLE(of
, emac_dt_match
);
585 #if IS_ENABLED(CONFIG_ACPI)
586 static const struct acpi_device_id emac_acpi_match
[] = {
592 MODULE_DEVICE_TABLE(acpi
, emac_acpi_match
);
595 static int emac_probe(struct platform_device
*pdev
)
597 struct net_device
*netdev
;
598 struct emac_adapter
*adpt
;
599 struct emac_sgmii
*phy
;
604 /* The TPD buffer address is limited to:
605 * 1. PTP: 45bits. (Driver doesn't support yet.)
606 * 2. NON-PTP: 46bits.
608 ret
= dma_set_mask_and_coherent(&pdev
->dev
, DMA_BIT_MASK(46));
610 dev_err(&pdev
->dev
, "could not set DMA mask\n");
614 netdev
= alloc_etherdev(sizeof(struct emac_adapter
));
618 dev_set_drvdata(&pdev
->dev
, netdev
);
619 SET_NETDEV_DEV(netdev
, &pdev
->dev
);
620 emac_set_ethtool_ops(netdev
);
622 adpt
= netdev_priv(netdev
);
623 adpt
->netdev
= netdev
;
624 adpt
->msg_enable
= EMAC_MSG_DEFAULT
;
627 atomic_set(&phy
->decode_error_count
, 0);
629 mutex_init(&adpt
->reset_lock
);
630 spin_lock_init(&adpt
->stats
.lock
);
632 adpt
->irq
.mask
= RX_PKT_INT0
| IMR_NORMAL_MASK
;
634 ret
= emac_probe_resources(pdev
, adpt
);
636 goto err_undo_netdev
;
638 /* initialize clocks */
639 ret
= emac_clks_phase1_init(pdev
, adpt
);
641 dev_err(&pdev
->dev
, "could not initialize clocks\n");
642 goto err_undo_netdev
;
645 netdev
->watchdog_timeo
= EMAC_WATCHDOG_TIME
;
646 netdev
->irq
= adpt
->irq
.irq
;
648 netdev
->netdev_ops
= &emac_netdev_ops
;
650 emac_init_adapter(adpt
);
652 /* init external phy */
653 ret
= emac_phy_config(pdev
, adpt
);
655 goto err_undo_clocks
;
657 /* init internal sgmii phy */
658 ret
= emac_sgmii_config(pdev
, adpt
);
660 goto err_undo_mdiobus
;
663 ret
= emac_clks_phase2_init(pdev
, adpt
);
665 dev_err(&pdev
->dev
, "could not initialize clocks\n");
666 goto err_undo_mdiobus
;
669 /* set hw features */
670 netdev
->features
= NETIF_F_SG
| NETIF_F_HW_CSUM
| NETIF_F_RXCSUM
|
671 NETIF_F_TSO
| NETIF_F_TSO6
| NETIF_F_HW_VLAN_CTAG_RX
|
672 NETIF_F_HW_VLAN_CTAG_TX
;
673 netdev
->hw_features
= netdev
->features
;
675 netdev
->vlan_features
|= NETIF_F_SG
| NETIF_F_HW_CSUM
|
676 NETIF_F_TSO
| NETIF_F_TSO6
;
678 /* MTU range: 46 - 9194 */
679 netdev
->min_mtu
= EMAC_MIN_ETH_FRAME_SIZE
-
680 (ETH_HLEN
+ ETH_FCS_LEN
+ VLAN_HLEN
);
681 netdev
->max_mtu
= EMAC_MAX_ETH_FRAME_SIZE
-
682 (ETH_HLEN
+ ETH_FCS_LEN
+ VLAN_HLEN
);
684 INIT_WORK(&adpt
->work_thread
, emac_work_thread
);
686 /* Initialize queues */
687 emac_mac_rx_tx_ring_init_all(pdev
, adpt
);
689 netif_napi_add(netdev
, &adpt
->rx_q
.napi
, emac_napi_rtx
,
692 ret
= register_netdev(netdev
);
694 dev_err(&pdev
->dev
, "could not register net device\n");
698 reg
= readl_relaxed(adpt
->base
+ EMAC_DMA_MAS_CTRL
);
699 devid
= (reg
& DEV_ID_NUM_BMSK
) >> DEV_ID_NUM_SHFT
;
700 revid
= (reg
& DEV_REV_NUM_BMSK
) >> DEV_REV_NUM_SHFT
;
701 reg
= readl_relaxed(adpt
->base
+ EMAC_CORE_HW_VERSION
);
703 netif_info(adpt
, probe
, netdev
,
704 "hardware id %d.%d, hardware version %d.%d.%d\n",
706 (reg
& MAJOR_BMSK
) >> MAJOR_SHFT
,
707 (reg
& MINOR_BMSK
) >> MINOR_SHFT
,
708 (reg
& STEP_BMSK
) >> STEP_SHFT
);
713 netif_napi_del(&adpt
->rx_q
.napi
);
715 put_device(&adpt
->phydev
->mdio
.dev
);
716 mdiobus_unregister(adpt
->mii_bus
);
718 emac_clks_teardown(adpt
);
725 static int emac_remove(struct platform_device
*pdev
)
727 struct net_device
*netdev
= dev_get_drvdata(&pdev
->dev
);
728 struct emac_adapter
*adpt
= netdev_priv(netdev
);
730 unregister_netdev(netdev
);
731 netif_napi_del(&adpt
->rx_q
.napi
);
733 emac_clks_teardown(adpt
);
735 put_device(&adpt
->phydev
->mdio
.dev
);
736 mdiobus_unregister(adpt
->mii_bus
);
739 if (adpt
->phy
.digital
)
740 iounmap(adpt
->phy
.digital
);
741 iounmap(adpt
->phy
.base
);
746 static void emac_shutdown(struct platform_device
*pdev
)
748 struct net_device
*netdev
= dev_get_drvdata(&pdev
->dev
);
749 struct emac_adapter
*adpt
= netdev_priv(netdev
);
751 if (netdev
->flags
& IFF_UP
) {
752 /* Closing the SGMII turns off its interrupts */
753 emac_sgmii_close(adpt
);
755 /* Resetting the MAC turns off all DMA and its interrupts */
756 emac_mac_reset(adpt
);
760 static struct platform_driver emac_platform_driver
= {
762 .remove
= emac_remove
,
765 .of_match_table
= emac_dt_match
,
766 .acpi_match_table
= ACPI_PTR(emac_acpi_match
),
768 .shutdown
= emac_shutdown
,
771 module_platform_driver(emac_platform_driver
);
773 MODULE_LICENSE("GPL v2");
774 MODULE_ALIAS("platform:qcom-emac");