1 // SPDX-License-Identifier: GPL-2.0
3 * sni_ave.c - Socionext UniPhier AVE ethernet driver
4 * Copyright 2014 Panasonic Corporation
5 * Copyright 2015-2017 Socionext Inc.
8 #include <linux/bitops.h>
10 #include <linux/etherdevice.h>
11 #include <linux/interrupt.h>
13 #include <linux/iopoll.h>
14 #include <linux/mfd/syscon.h>
15 #include <linux/mii.h>
16 #include <linux/module.h>
17 #include <linux/netdevice.h>
18 #include <linux/of_net.h>
19 #include <linux/of_mdio.h>
20 #include <linux/of_platform.h>
21 #include <linux/phy.h>
22 #include <linux/regmap.h>
23 #include <linux/reset.h>
24 #include <linux/types.h>
25 #include <linux/u64_stats_sync.h>
27 /* General Register Group */
28 #define AVE_IDR 0x000 /* ID */
29 #define AVE_VR 0x004 /* Version */
30 #define AVE_GRR 0x008 /* Global Reset */
31 #define AVE_CFGR 0x00c /* Configuration */
33 /* Interrupt Register Group */
34 #define AVE_GIMR 0x100 /* Global Interrupt Mask */
35 #define AVE_GISR 0x104 /* Global Interrupt Status */
37 /* MAC Register Group */
38 #define AVE_TXCR 0x200 /* TX Setup */
39 #define AVE_RXCR 0x204 /* RX Setup */
40 #define AVE_RXMAC1R 0x208 /* MAC address (lower) */
41 #define AVE_RXMAC2R 0x20c /* MAC address (upper) */
42 #define AVE_MDIOCTR 0x214 /* MDIO Control */
43 #define AVE_MDIOAR 0x218 /* MDIO Address */
44 #define AVE_MDIOWDR 0x21c /* MDIO Data */
45 #define AVE_MDIOSR 0x220 /* MDIO Status */
46 #define AVE_MDIORDR 0x224 /* MDIO Rd Data */
48 /* Descriptor Control Register Group */
49 #define AVE_DESCC 0x300 /* Descriptor Control */
50 #define AVE_TXDC 0x304 /* TX Descriptor Configuration */
51 #define AVE_RXDC0 0x308 /* RX Descriptor Ring0 Configuration */
52 #define AVE_IIRQC 0x34c /* Interval IRQ Control */
54 /* Packet Filter Register Group */
55 #define AVE_PKTF_BASE 0x800 /* PF Base Address */
56 #define AVE_PFMBYTE_BASE 0xd00 /* PF Mask Byte Base Address */
57 #define AVE_PFMBIT_BASE 0xe00 /* PF Mask Bit Base Address */
58 #define AVE_PFSEL_BASE 0xf00 /* PF Selector Base Address */
59 #define AVE_PFEN 0xffc /* Packet Filter Enable */
60 #define AVE_PKTF(ent) (AVE_PKTF_BASE + (ent) * 0x40)
61 #define AVE_PFMBYTE(ent) (AVE_PFMBYTE_BASE + (ent) * 8)
62 #define AVE_PFMBIT(ent) (AVE_PFMBIT_BASE + (ent) * 4)
63 #define AVE_PFSEL(ent) (AVE_PFSEL_BASE + (ent) * 4)
65 /* 64bit descriptor memory */
66 #define AVE_DESC_SIZE_64 12 /* Descriptor Size */
68 #define AVE_TXDM_64 0x1000 /* Tx Descriptor Memory */
69 #define AVE_RXDM_64 0x1c00 /* Rx Descriptor Memory */
71 #define AVE_TXDM_SIZE_64 0x0ba0 /* Tx Descriptor Memory Size 3KB */
72 #define AVE_RXDM_SIZE_64 0x6000 /* Rx Descriptor Memory Size 24KB */
74 /* 32bit descriptor memory */
75 #define AVE_DESC_SIZE_32 8 /* Descriptor Size */
77 #define AVE_TXDM_32 0x1000 /* Tx Descriptor Memory */
78 #define AVE_RXDM_32 0x1800 /* Rx Descriptor Memory */
80 #define AVE_TXDM_SIZE_32 0x07c0 /* Tx Descriptor Memory Size 2KB */
81 #define AVE_RXDM_SIZE_32 0x4000 /* Rx Descriptor Memory Size 16KB */
83 /* RMII Bridge Register Group */
84 #define AVE_RSTCTRL 0x8028 /* Reset control */
85 #define AVE_RSTCTRL_RMIIRST BIT(16)
86 #define AVE_LINKSEL 0x8034 /* Link speed setting */
87 #define AVE_LINKSEL_100M BIT(0)
90 #define AVE_GRR_RXFFR BIT(5) /* Reset RxFIFO */
91 #define AVE_GRR_PHYRST BIT(4) /* Reset external PHY */
92 #define AVE_GRR_GRST BIT(0) /* Reset all MAC */
95 #define AVE_CFGR_FLE BIT(31) /* Filter Function */
96 #define AVE_CFGR_CHE BIT(30) /* Checksum Function */
97 #define AVE_CFGR_MII BIT(27) /* Func mode (1:MII/RMII, 0:RGMII) */
98 #define AVE_CFGR_IPFCEN BIT(24) /* IP fragment sum Enable */
100 /* AVE_GISR (common with GIMR) */
101 #define AVE_GI_PHY BIT(24) /* PHY interrupt */
102 #define AVE_GI_TX BIT(16) /* Tx complete */
103 #define AVE_GI_RXERR BIT(8) /* Receive frame more than max size */
104 #define AVE_GI_RXOVF BIT(7) /* Overflow at the RxFIFO */
105 #define AVE_GI_RXDROP BIT(6) /* Drop packet */
106 #define AVE_GI_RXIINT BIT(5) /* Interval interrupt */
109 #define AVE_TXCR_FLOCTR BIT(18) /* Flow control */
110 #define AVE_TXCR_TXSPD_1G BIT(17)
111 #define AVE_TXCR_TXSPD_100 BIT(16)
114 #define AVE_RXCR_RXEN BIT(30) /* Rx enable */
115 #define AVE_RXCR_FDUPEN BIT(22) /* Interface mode */
116 #define AVE_RXCR_FLOCTR BIT(21) /* Flow control */
117 #define AVE_RXCR_AFEN BIT(19) /* MAC address filter */
118 #define AVE_RXCR_DRPEN BIT(18) /* Drop pause frame */
119 #define AVE_RXCR_MPSIZ_MASK GENMASK(10, 0)
122 #define AVE_MDIOCTR_RREQ BIT(3) /* Read request */
123 #define AVE_MDIOCTR_WREQ BIT(2) /* Write request */
126 #define AVE_MDIOSR_STS BIT(0) /* access status */
129 #define AVE_DESCC_STATUS_MASK GENMASK(31, 16)
130 #define AVE_DESCC_RD0 BIT(8) /* Enable Rx descriptor Ring0 */
131 #define AVE_DESCC_RDSTP BIT(4) /* Pause Rx descriptor */
132 #define AVE_DESCC_TD BIT(0) /* Enable Tx descriptor */
135 #define AVE_TXDC_SIZE GENMASK(27, 16) /* Size of Tx descriptor */
136 #define AVE_TXDC_ADDR GENMASK(11, 0) /* Start address */
137 #define AVE_TXDC_ADDR_START 0
140 #define AVE_RXDC0_SIZE GENMASK(30, 16) /* Size of Rx descriptor */
141 #define AVE_RXDC0_ADDR GENMASK(14, 0) /* Start address */
142 #define AVE_RXDC0_ADDR_START 0
145 #define AVE_IIRQC_EN0 BIT(27) /* Enable interval interrupt Ring0 */
146 #define AVE_IIRQC_BSCK GENMASK(15, 0) /* Interval count unit */
148 /* Command status for descriptor */
149 #define AVE_STS_OWN BIT(31) /* Descriptor ownership */
150 #define AVE_STS_INTR BIT(29) /* Request for interrupt */
151 #define AVE_STS_OK BIT(27) /* Normal transmit */
153 #define AVE_STS_NOCSUM BIT(28) /* No use HW checksum */
154 #define AVE_STS_1ST BIT(26) /* Head of buffer chain */
155 #define AVE_STS_LAST BIT(25) /* Tail of buffer chain */
156 #define AVE_STS_OWC BIT(21) /* Out of window,Late Collision */
157 #define AVE_STS_EC BIT(20) /* Excess collision occurred */
158 #define AVE_STS_PKTLEN_TX_MASK GENMASK(15, 0)
160 #define AVE_STS_CSSV BIT(21) /* Checksum check performed */
161 #define AVE_STS_CSER BIT(20) /* Checksum error detected */
162 #define AVE_STS_PKTLEN_RX_MASK GENMASK(10, 0)
165 #define AVE_PFMBYTE_MASK0 (GENMASK(31, 8) | GENMASK(5, 0))
166 #define AVE_PFMBYTE_MASK1 GENMASK(25, 0)
167 #define AVE_PFMBIT_MASK GENMASK(15, 0)
169 #define AVE_PF_SIZE 17 /* Number of all packet filter */
170 #define AVE_PF_MULTICAST_SIZE 7 /* Number of multicast filter */
172 #define AVE_PFNUM_FILTER 0 /* No.0 */
173 #define AVE_PFNUM_UNICAST 1 /* No.1 */
174 #define AVE_PFNUM_BROADCAST 2 /* No.2 */
175 #define AVE_PFNUM_MULTICAST 11 /* No.11-17 */
177 /* NETIF Message control */
178 #define AVE_DEFAULT_MSG_ENABLE (NETIF_MSG_DRV | \
187 /* Parameter for descriptor */
188 #define AVE_NR_TXDESC 64 /* Tx descriptor */
189 #define AVE_NR_RXDESC 256 /* Rx descriptor */
191 #define AVE_DESC_OFS_CMDSTS 0
192 #define AVE_DESC_OFS_ADDRL 4
193 #define AVE_DESC_OFS_ADDRU 8
195 /* Parameter for ethernet frame */
196 #define AVE_MAX_ETHFRAME 1518
197 #define AVE_FRAME_HEADROOM 2
199 /* Parameter for interrupt */
200 #define AVE_INTM_COUNT 20
201 #define AVE_FORCE_TXINTCNT 1
204 #define SG_ETPINMODE 0x540
205 #define SG_ETPINMODE_EXTPHY BIT(1) /* for LD11 */
206 #define SG_ETPINMODE_RMII(ins) BIT(ins)
208 #define IS_DESC_64BIT(p) ((p)->data->is_desc_64bit)
210 #define AVE_MAX_CLKS 4
211 #define AVE_MAX_RSTS 2
226 struct sk_buff
*skbs
;
231 struct ave_desc_info
{
232 u32 ndesc
; /* number of descriptor */
233 u32 daddr
; /* start address of descriptor */
234 u32 proc_idx
; /* index of processing packet */
235 u32 done_idx
; /* index of processed packet */
236 struct ave_desc
*desc
; /* skb info related descriptor */
240 struct u64_stats_sync syncp
;
253 unsigned int desc_size
;
256 struct clk
*clk
[AVE_MAX_CLKS
];
258 struct reset_control
*rst
[AVE_MAX_RSTS
];
259 phy_interface_t phy_mode
;
260 struct phy_device
*phydev
;
261 struct mii_bus
*mdio
;
262 struct regmap
*regmap
;
263 unsigned int pinmode_mask
;
264 unsigned int pinmode_val
;
268 struct ave_stats stats_rx
;
269 struct ave_stats stats_tx
;
272 struct net_device
*ndev
;
273 struct napi_struct napi_rx
;
274 struct napi_struct napi_tx
;
277 struct ave_desc_info rx
;
278 struct ave_desc_info tx
;
285 const struct ave_soc_data
*data
;
288 struct ave_soc_data
{
290 const char *clock_names
[AVE_MAX_CLKS
];
291 const char *reset_names
[AVE_MAX_RSTS
];
292 int (*get_pinmode
)(struct ave_private
*priv
,
293 phy_interface_t phy_mode
, u32 arg
);
296 static u32
ave_desc_read(struct net_device
*ndev
, enum desc_id id
, int entry
,
299 struct ave_private
*priv
= netdev_priv(ndev
);
302 addr
= ((id
== AVE_DESCID_TX
) ? priv
->tx
.daddr
: priv
->rx
.daddr
)
303 + entry
* priv
->desc_size
+ offset
;
305 return readl(priv
->base
+ addr
);
308 static u32
ave_desc_read_cmdsts(struct net_device
*ndev
, enum desc_id id
,
311 return ave_desc_read(ndev
, id
, entry
, AVE_DESC_OFS_CMDSTS
);
314 static void ave_desc_write(struct net_device
*ndev
, enum desc_id id
,
315 int entry
, int offset
, u32 val
)
317 struct ave_private
*priv
= netdev_priv(ndev
);
320 addr
= ((id
== AVE_DESCID_TX
) ? priv
->tx
.daddr
: priv
->rx
.daddr
)
321 + entry
* priv
->desc_size
+ offset
;
323 writel(val
, priv
->base
+ addr
);
326 static void ave_desc_write_cmdsts(struct net_device
*ndev
, enum desc_id id
,
329 ave_desc_write(ndev
, id
, entry
, AVE_DESC_OFS_CMDSTS
, val
);
332 static void ave_desc_write_addr(struct net_device
*ndev
, enum desc_id id
,
333 int entry
, dma_addr_t paddr
)
335 struct ave_private
*priv
= netdev_priv(ndev
);
337 ave_desc_write(ndev
, id
, entry
, AVE_DESC_OFS_ADDRL
,
338 lower_32_bits(paddr
));
339 if (IS_DESC_64BIT(priv
))
340 ave_desc_write(ndev
, id
,
341 entry
, AVE_DESC_OFS_ADDRU
,
342 upper_32_bits(paddr
));
345 static u32
ave_irq_disable_all(struct net_device
*ndev
)
347 struct ave_private
*priv
= netdev_priv(ndev
);
350 ret
= readl(priv
->base
+ AVE_GIMR
);
351 writel(0, priv
->base
+ AVE_GIMR
);
356 static void ave_irq_restore(struct net_device
*ndev
, u32 val
)
358 struct ave_private
*priv
= netdev_priv(ndev
);
360 writel(val
, priv
->base
+ AVE_GIMR
);
363 static void ave_irq_enable(struct net_device
*ndev
, u32 bitflag
)
365 struct ave_private
*priv
= netdev_priv(ndev
);
367 writel(readl(priv
->base
+ AVE_GIMR
) | bitflag
, priv
->base
+ AVE_GIMR
);
368 writel(bitflag
, priv
->base
+ AVE_GISR
);
371 static void ave_hw_write_macaddr(struct net_device
*ndev
,
372 const unsigned char *mac_addr
,
375 struct ave_private
*priv
= netdev_priv(ndev
);
377 writel(mac_addr
[0] | mac_addr
[1] << 8 |
378 mac_addr
[2] << 16 | mac_addr
[3] << 24, priv
->base
+ reg1
);
379 writel(mac_addr
[4] | mac_addr
[5] << 8, priv
->base
+ reg2
);
382 static void ave_hw_read_version(struct net_device
*ndev
, char *buf
, int len
)
384 struct ave_private
*priv
= netdev_priv(ndev
);
385 u32 major
, minor
, vr
;
387 vr
= readl(priv
->base
+ AVE_VR
);
388 major
= (vr
& GENMASK(15, 8)) >> 8;
389 minor
= (vr
& GENMASK(7, 0));
390 snprintf(buf
, len
, "v%u.%u", major
, minor
);
393 static void ave_ethtool_get_drvinfo(struct net_device
*ndev
,
394 struct ethtool_drvinfo
*info
)
396 struct device
*dev
= ndev
->dev
.parent
;
398 strlcpy(info
->driver
, dev
->driver
->name
, sizeof(info
->driver
));
399 strlcpy(info
->bus_info
, dev_name(dev
), sizeof(info
->bus_info
));
400 ave_hw_read_version(ndev
, info
->fw_version
, sizeof(info
->fw_version
));
403 static u32
ave_ethtool_get_msglevel(struct net_device
*ndev
)
405 struct ave_private
*priv
= netdev_priv(ndev
);
407 return priv
->msg_enable
;
410 static void ave_ethtool_set_msglevel(struct net_device
*ndev
, u32 val
)
412 struct ave_private
*priv
= netdev_priv(ndev
);
414 priv
->msg_enable
= val
;
417 static void ave_ethtool_get_wol(struct net_device
*ndev
,
418 struct ethtool_wolinfo
*wol
)
424 phy_ethtool_get_wol(ndev
->phydev
, wol
);
427 static int __ave_ethtool_set_wol(struct net_device
*ndev
,
428 struct ethtool_wolinfo
*wol
)
431 (wol
->wolopts
& (WAKE_ARP
| WAKE_MAGICSECURE
)))
434 return phy_ethtool_set_wol(ndev
->phydev
, wol
);
437 static int ave_ethtool_set_wol(struct net_device
*ndev
,
438 struct ethtool_wolinfo
*wol
)
442 ret
= __ave_ethtool_set_wol(ndev
, wol
);
444 device_set_wakeup_enable(&ndev
->dev
, !!wol
->wolopts
);
449 static void ave_ethtool_get_pauseparam(struct net_device
*ndev
,
450 struct ethtool_pauseparam
*pause
)
452 struct ave_private
*priv
= netdev_priv(ndev
);
454 pause
->autoneg
= priv
->pause_auto
;
455 pause
->rx_pause
= priv
->pause_rx
;
456 pause
->tx_pause
= priv
->pause_tx
;
459 static int ave_ethtool_set_pauseparam(struct net_device
*ndev
,
460 struct ethtool_pauseparam
*pause
)
462 struct ave_private
*priv
= netdev_priv(ndev
);
463 struct phy_device
*phydev
= ndev
->phydev
;
468 priv
->pause_auto
= pause
->autoneg
;
469 priv
->pause_rx
= pause
->rx_pause
;
470 priv
->pause_tx
= pause
->tx_pause
;
472 phy_set_asym_pause(phydev
, pause
->rx_pause
, pause
->tx_pause
);
477 static const struct ethtool_ops ave_ethtool_ops
= {
478 .get_link_ksettings
= phy_ethtool_get_link_ksettings
,
479 .set_link_ksettings
= phy_ethtool_set_link_ksettings
,
480 .get_drvinfo
= ave_ethtool_get_drvinfo
,
481 .nway_reset
= phy_ethtool_nway_reset
,
482 .get_link
= ethtool_op_get_link
,
483 .get_msglevel
= ave_ethtool_get_msglevel
,
484 .set_msglevel
= ave_ethtool_set_msglevel
,
485 .get_wol
= ave_ethtool_get_wol
,
486 .set_wol
= ave_ethtool_set_wol
,
487 .get_pauseparam
= ave_ethtool_get_pauseparam
,
488 .set_pauseparam
= ave_ethtool_set_pauseparam
,
491 static int ave_mdiobus_read(struct mii_bus
*bus
, int phyid
, int regnum
)
493 struct net_device
*ndev
= bus
->priv
;
494 struct ave_private
*priv
;
498 priv
= netdev_priv(ndev
);
501 writel((phyid
<< 8) | regnum
, priv
->base
+ AVE_MDIOAR
);
504 mdioctl
= readl(priv
->base
+ AVE_MDIOCTR
);
505 writel((mdioctl
| AVE_MDIOCTR_RREQ
) & ~AVE_MDIOCTR_WREQ
,
506 priv
->base
+ AVE_MDIOCTR
);
508 ret
= readl_poll_timeout(priv
->base
+ AVE_MDIOSR
, mdiosr
,
509 !(mdiosr
& AVE_MDIOSR_STS
), 20, 2000);
511 netdev_err(ndev
, "failed to read (phy:%d reg:%x)\n",
516 return readl(priv
->base
+ AVE_MDIORDR
) & GENMASK(15, 0);
519 static int ave_mdiobus_write(struct mii_bus
*bus
, int phyid
, int regnum
,
522 struct net_device
*ndev
= bus
->priv
;
523 struct ave_private
*priv
;
527 priv
= netdev_priv(ndev
);
530 writel((phyid
<< 8) | regnum
, priv
->base
+ AVE_MDIOAR
);
533 writel(val
, priv
->base
+ AVE_MDIOWDR
);
536 mdioctl
= readl(priv
->base
+ AVE_MDIOCTR
);
537 writel((mdioctl
| AVE_MDIOCTR_WREQ
) & ~AVE_MDIOCTR_RREQ
,
538 priv
->base
+ AVE_MDIOCTR
);
540 ret
= readl_poll_timeout(priv
->base
+ AVE_MDIOSR
, mdiosr
,
541 !(mdiosr
& AVE_MDIOSR_STS
), 20, 2000);
543 netdev_err(ndev
, "failed to write (phy:%d reg:%x)\n",
549 static int ave_dma_map(struct net_device
*ndev
, struct ave_desc
*desc
,
550 void *ptr
, size_t len
, enum dma_data_direction dir
,
555 map_addr
= dma_map_single(ndev
->dev
.parent
, ptr
, len
, dir
);
556 if (unlikely(dma_mapping_error(ndev
->dev
.parent
, map_addr
)))
559 desc
->skbs_dma
= map_addr
;
560 desc
->skbs_dmalen
= len
;
566 static void ave_dma_unmap(struct net_device
*ndev
, struct ave_desc
*desc
,
567 enum dma_data_direction dir
)
572 dma_unmap_single(ndev
->dev
.parent
,
573 desc
->skbs_dma
, desc
->skbs_dmalen
, dir
);
577 /* Prepare Rx descriptor and memory */
578 static int ave_rxdesc_prepare(struct net_device
*ndev
, int entry
)
580 struct ave_private
*priv
= netdev_priv(ndev
);
585 skb
= priv
->rx
.desc
[entry
].skbs
;
587 skb
= netdev_alloc_skb(ndev
, AVE_MAX_ETHFRAME
);
589 netdev_err(ndev
, "can't allocate skb for Rx\n");
592 skb
->data
+= AVE_FRAME_HEADROOM
;
593 skb
->tail
+= AVE_FRAME_HEADROOM
;
596 /* set disable to cmdsts */
597 ave_desc_write_cmdsts(ndev
, AVE_DESCID_RX
, entry
,
598 AVE_STS_INTR
| AVE_STS_OWN
);
601 * Rx buffer set to the Rx descriptor has two restrictions:
602 * - Rx buffer address is 4 byte aligned.
603 * - Rx buffer begins with 2 byte headroom, and data will be put from
605 * To satisfy this, specify the address to put back the buffer
606 * pointer advanced by AVE_FRAME_HEADROOM, and expand the map size
607 * by AVE_FRAME_HEADROOM.
609 ret
= ave_dma_map(ndev
, &priv
->rx
.desc
[entry
],
610 skb
->data
- AVE_FRAME_HEADROOM
,
611 AVE_MAX_ETHFRAME
+ AVE_FRAME_HEADROOM
,
612 DMA_FROM_DEVICE
, &paddr
);
614 netdev_err(ndev
, "can't map skb for Rx\n");
615 dev_kfree_skb_any(skb
);
618 priv
->rx
.desc
[entry
].skbs
= skb
;
620 /* set buffer pointer */
621 ave_desc_write_addr(ndev
, AVE_DESCID_RX
, entry
, paddr
);
623 /* set enable to cmdsts */
624 ave_desc_write_cmdsts(ndev
, AVE_DESCID_RX
, entry
,
625 AVE_STS_INTR
| AVE_MAX_ETHFRAME
);
630 /* Switch state of descriptor */
631 static int ave_desc_switch(struct net_device
*ndev
, enum desc_state state
)
633 struct ave_private
*priv
= netdev_priv(ndev
);
639 writel(AVE_DESCC_TD
| AVE_DESCC_RD0
, priv
->base
+ AVE_DESCC
);
643 writel(0, priv
->base
+ AVE_DESCC
);
644 if (readl_poll_timeout(priv
->base
+ AVE_DESCC
, val
, !val
,
646 netdev_err(ndev
, "can't stop descriptor\n");
651 case AVE_DESC_RX_SUSPEND
:
652 val
= readl(priv
->base
+ AVE_DESCC
);
653 val
|= AVE_DESCC_RDSTP
;
654 val
&= ~AVE_DESCC_STATUS_MASK
;
655 writel(val
, priv
->base
+ AVE_DESCC
);
656 if (readl_poll_timeout(priv
->base
+ AVE_DESCC
, val
,
657 val
& (AVE_DESCC_RDSTP
<< 16),
659 netdev_err(ndev
, "can't suspend descriptor\n");
664 case AVE_DESC_RX_PERMIT
:
665 val
= readl(priv
->base
+ AVE_DESCC
);
666 val
&= ~AVE_DESCC_RDSTP
;
667 val
&= ~AVE_DESCC_STATUS_MASK
;
668 writel(val
, priv
->base
+ AVE_DESCC
);
679 static int ave_tx_complete(struct net_device
*ndev
)
681 struct ave_private
*priv
= netdev_priv(ndev
);
682 u32 proc_idx
, done_idx
, ndesc
, cmdsts
;
683 unsigned int nr_freebuf
= 0;
684 unsigned int tx_packets
= 0;
685 unsigned int tx_bytes
= 0;
687 proc_idx
= priv
->tx
.proc_idx
;
688 done_idx
= priv
->tx
.done_idx
;
689 ndesc
= priv
->tx
.ndesc
;
691 /* free pre-stored skb from done_idx to proc_idx */
692 while (proc_idx
!= done_idx
) {
693 cmdsts
= ave_desc_read_cmdsts(ndev
, AVE_DESCID_TX
, done_idx
);
695 /* do nothing if owner is HW (==1 for Tx) */
696 if (cmdsts
& AVE_STS_OWN
)
699 /* check Tx status and updates statistics */
700 if (cmdsts
& AVE_STS_OK
) {
701 tx_bytes
+= cmdsts
& AVE_STS_PKTLEN_TX_MASK
;
703 if (cmdsts
& AVE_STS_LAST
)
707 if (cmdsts
& AVE_STS_LAST
) {
708 priv
->stats_tx
.errors
++;
709 if (cmdsts
& (AVE_STS_OWC
| AVE_STS_EC
))
710 priv
->stats_tx
.collisions
++;
715 if (priv
->tx
.desc
[done_idx
].skbs
) {
716 ave_dma_unmap(ndev
, &priv
->tx
.desc
[done_idx
],
718 dev_consume_skb_any(priv
->tx
.desc
[done_idx
].skbs
);
719 priv
->tx
.desc
[done_idx
].skbs
= NULL
;
722 done_idx
= (done_idx
+ 1) % ndesc
;
725 priv
->tx
.done_idx
= done_idx
;
728 u64_stats_update_begin(&priv
->stats_tx
.syncp
);
729 priv
->stats_tx
.packets
+= tx_packets
;
730 priv
->stats_tx
.bytes
+= tx_bytes
;
731 u64_stats_update_end(&priv
->stats_tx
.syncp
);
733 /* wake queue for freeing buffer */
734 if (unlikely(netif_queue_stopped(ndev
)) && nr_freebuf
)
735 netif_wake_queue(ndev
);
740 static int ave_rx_receive(struct net_device
*ndev
, int num
)
742 struct ave_private
*priv
= netdev_priv(ndev
);
743 unsigned int rx_packets
= 0;
744 unsigned int rx_bytes
= 0;
745 u32 proc_idx
, done_idx
;
751 proc_idx
= priv
->rx
.proc_idx
;
752 done_idx
= priv
->rx
.done_idx
;
753 ndesc
= priv
->rx
.ndesc
;
754 restpkt
= ((proc_idx
+ ndesc
- 1) - done_idx
) % ndesc
;
756 for (npkts
= 0; npkts
< num
; npkts
++) {
757 /* we can't receive more packet, so fill desc quickly */
761 cmdsts
= ave_desc_read_cmdsts(ndev
, AVE_DESCID_RX
, proc_idx
);
763 /* do nothing if owner is HW (==0 for Rx) */
764 if (!(cmdsts
& AVE_STS_OWN
))
767 if (!(cmdsts
& AVE_STS_OK
)) {
768 priv
->stats_rx
.errors
++;
769 proc_idx
= (proc_idx
+ 1) % ndesc
;
773 pktlen
= cmdsts
& AVE_STS_PKTLEN_RX_MASK
;
775 /* get skbuff for rx */
776 skb
= priv
->rx
.desc
[proc_idx
].skbs
;
777 priv
->rx
.desc
[proc_idx
].skbs
= NULL
;
779 ave_dma_unmap(ndev
, &priv
->rx
.desc
[proc_idx
], DMA_FROM_DEVICE
);
782 skb_put(skb
, pktlen
);
783 skb
->protocol
= eth_type_trans(skb
, ndev
);
785 if ((cmdsts
& AVE_STS_CSSV
) && (!(cmdsts
& AVE_STS_CSER
)))
786 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
791 netif_receive_skb(skb
);
793 proc_idx
= (proc_idx
+ 1) % ndesc
;
796 priv
->rx
.proc_idx
= proc_idx
;
799 u64_stats_update_begin(&priv
->stats_rx
.syncp
);
800 priv
->stats_rx
.packets
+= rx_packets
;
801 priv
->stats_rx
.bytes
+= rx_bytes
;
802 u64_stats_update_end(&priv
->stats_rx
.syncp
);
804 /* refill the Rx buffers */
805 while (proc_idx
!= done_idx
) {
806 if (ave_rxdesc_prepare(ndev
, done_idx
))
808 done_idx
= (done_idx
+ 1) % ndesc
;
811 priv
->rx
.done_idx
= done_idx
;
816 static int ave_napi_poll_rx(struct napi_struct
*napi
, int budget
)
818 struct ave_private
*priv
;
819 struct net_device
*ndev
;
822 priv
= container_of(napi
, struct ave_private
, napi_rx
);
825 num
= ave_rx_receive(ndev
, budget
);
827 napi_complete_done(napi
, num
);
829 /* enable Rx interrupt when NAPI finishes */
830 ave_irq_enable(ndev
, AVE_GI_RXIINT
);
836 static int ave_napi_poll_tx(struct napi_struct
*napi
, int budget
)
838 struct ave_private
*priv
;
839 struct net_device
*ndev
;
842 priv
= container_of(napi
, struct ave_private
, napi_tx
);
845 num
= ave_tx_complete(ndev
);
848 /* enable Tx interrupt when NAPI finishes */
849 ave_irq_enable(ndev
, AVE_GI_TX
);
854 static void ave_global_reset(struct net_device
*ndev
)
856 struct ave_private
*priv
= netdev_priv(ndev
);
859 /* set config register */
860 val
= AVE_CFGR_FLE
| AVE_CFGR_IPFCEN
| AVE_CFGR_CHE
;
861 if (!phy_interface_mode_is_rgmii(priv
->phy_mode
))
863 writel(val
, priv
->base
+ AVE_CFGR
);
865 /* reset RMII register */
866 val
= readl(priv
->base
+ AVE_RSTCTRL
);
867 val
&= ~AVE_RSTCTRL_RMIIRST
;
868 writel(val
, priv
->base
+ AVE_RSTCTRL
);
871 writel(AVE_GRR_GRST
| AVE_GRR_PHYRST
, priv
->base
+ AVE_GRR
);
874 /* 1st, negate PHY reset only */
875 writel(AVE_GRR_GRST
, priv
->base
+ AVE_GRR
);
879 writel(0, priv
->base
+ AVE_GRR
);
882 /* negate RMII register */
883 val
= readl(priv
->base
+ AVE_RSTCTRL
);
884 val
|= AVE_RSTCTRL_RMIIRST
;
885 writel(val
, priv
->base
+ AVE_RSTCTRL
);
887 ave_irq_disable_all(ndev
);
890 static void ave_rxfifo_reset(struct net_device
*ndev
)
892 struct ave_private
*priv
= netdev_priv(ndev
);
895 /* save and disable MAC receive op */
896 rxcr_org
= readl(priv
->base
+ AVE_RXCR
);
897 writel(rxcr_org
& (~AVE_RXCR_RXEN
), priv
->base
+ AVE_RXCR
);
899 /* suspend Rx descriptor */
900 ave_desc_switch(ndev
, AVE_DESC_RX_SUSPEND
);
902 /* receive all packets before descriptor starts */
903 ave_rx_receive(ndev
, priv
->rx
.ndesc
);
906 writel(AVE_GRR_RXFFR
, priv
->base
+ AVE_GRR
);
910 writel(0, priv
->base
+ AVE_GRR
);
913 /* negate interrupt status */
914 writel(AVE_GI_RXOVF
, priv
->base
+ AVE_GISR
);
916 /* permit descriptor */
917 ave_desc_switch(ndev
, AVE_DESC_RX_PERMIT
);
919 /* restore MAC reccieve op */
920 writel(rxcr_org
, priv
->base
+ AVE_RXCR
);
923 static irqreturn_t
ave_irq_handler(int irq
, void *netdev
)
925 struct net_device
*ndev
= (struct net_device
*)netdev
;
926 struct ave_private
*priv
= netdev_priv(ndev
);
927 u32 gimr_val
, gisr_val
;
929 gimr_val
= ave_irq_disable_all(ndev
);
931 /* get interrupt status */
932 gisr_val
= readl(priv
->base
+ AVE_GISR
);
935 if (gisr_val
& AVE_GI_PHY
)
936 writel(AVE_GI_PHY
, priv
->base
+ AVE_GISR
);
938 /* check exceeding packet */
939 if (gisr_val
& AVE_GI_RXERR
) {
940 writel(AVE_GI_RXERR
, priv
->base
+ AVE_GISR
);
941 netdev_err(ndev
, "receive a packet exceeding frame buffer\n");
944 gisr_val
&= gimr_val
;
948 /* RxFIFO overflow */
949 if (gisr_val
& AVE_GI_RXOVF
) {
950 priv
->stats_rx
.fifo_errors
++;
951 ave_rxfifo_reset(ndev
);
956 if (gisr_val
& AVE_GI_RXDROP
) {
957 priv
->stats_rx
.dropped
++;
958 writel(AVE_GI_RXDROP
, priv
->base
+ AVE_GISR
);
962 if (gisr_val
& AVE_GI_RXIINT
) {
963 napi_schedule(&priv
->napi_rx
);
964 /* still force to disable Rx interrupt until NAPI finishes */
965 gimr_val
&= ~AVE_GI_RXIINT
;
969 if (gisr_val
& AVE_GI_TX
) {
970 napi_schedule(&priv
->napi_tx
);
971 /* still force to disable Tx interrupt until NAPI finishes */
972 gimr_val
&= ~AVE_GI_TX
;
976 ave_irq_restore(ndev
, gimr_val
);
981 static int ave_pfsel_start(struct net_device
*ndev
, unsigned int entry
)
983 struct ave_private
*priv
= netdev_priv(ndev
);
986 if (WARN_ON(entry
> AVE_PF_SIZE
))
989 val
= readl(priv
->base
+ AVE_PFEN
);
990 writel(val
| BIT(entry
), priv
->base
+ AVE_PFEN
);
995 static int ave_pfsel_stop(struct net_device
*ndev
, unsigned int entry
)
997 struct ave_private
*priv
= netdev_priv(ndev
);
1000 if (WARN_ON(entry
> AVE_PF_SIZE
))
1003 val
= readl(priv
->base
+ AVE_PFEN
);
1004 writel(val
& ~BIT(entry
), priv
->base
+ AVE_PFEN
);
1009 static int ave_pfsel_set_macaddr(struct net_device
*ndev
,
1011 const unsigned char *mac_addr
,
1012 unsigned int set_size
)
1014 struct ave_private
*priv
= netdev_priv(ndev
);
1016 if (WARN_ON(entry
> AVE_PF_SIZE
))
1018 if (WARN_ON(set_size
> 6))
1021 ave_pfsel_stop(ndev
, entry
);
1023 /* set MAC address for the filter */
1024 ave_hw_write_macaddr(ndev
, mac_addr
,
1025 AVE_PKTF(entry
), AVE_PKTF(entry
) + 4);
1028 writel(GENMASK(31, set_size
) & AVE_PFMBYTE_MASK0
,
1029 priv
->base
+ AVE_PFMBYTE(entry
));
1030 writel(AVE_PFMBYTE_MASK1
, priv
->base
+ AVE_PFMBYTE(entry
) + 4);
1032 /* set bit mask filter */
1033 writel(AVE_PFMBIT_MASK
, priv
->base
+ AVE_PFMBIT(entry
));
1035 /* set selector to ring 0 */
1036 writel(0, priv
->base
+ AVE_PFSEL(entry
));
1038 /* restart filter */
1039 ave_pfsel_start(ndev
, entry
);
1044 static void ave_pfsel_set_promisc(struct net_device
*ndev
,
1045 unsigned int entry
, u32 rxring
)
1047 struct ave_private
*priv
= netdev_priv(ndev
);
1049 if (WARN_ON(entry
> AVE_PF_SIZE
))
1052 ave_pfsel_stop(ndev
, entry
);
1055 writel(AVE_PFMBYTE_MASK0
, priv
->base
+ AVE_PFMBYTE(entry
));
1056 writel(AVE_PFMBYTE_MASK1
, priv
->base
+ AVE_PFMBYTE(entry
) + 4);
1058 /* set bit mask filter */
1059 writel(AVE_PFMBIT_MASK
, priv
->base
+ AVE_PFMBIT(entry
));
1061 /* set selector to rxring */
1062 writel(rxring
, priv
->base
+ AVE_PFSEL(entry
));
1064 ave_pfsel_start(ndev
, entry
);
1067 static void ave_pfsel_init(struct net_device
*ndev
)
1069 unsigned char bcast_mac
[ETH_ALEN
];
1072 eth_broadcast_addr(bcast_mac
);
1074 for (i
= 0; i
< AVE_PF_SIZE
; i
++)
1075 ave_pfsel_stop(ndev
, i
);
1077 /* promiscious entry, select ring 0 */
1078 ave_pfsel_set_promisc(ndev
, AVE_PFNUM_FILTER
, 0);
1081 ave_pfsel_set_macaddr(ndev
, AVE_PFNUM_UNICAST
, ndev
->dev_addr
, 6);
1083 /* broadcast entry */
1084 ave_pfsel_set_macaddr(ndev
, AVE_PFNUM_BROADCAST
, bcast_mac
, 6);
1087 static void ave_phy_adjust_link(struct net_device
*ndev
)
1089 struct ave_private
*priv
= netdev_priv(ndev
);
1090 struct phy_device
*phydev
= ndev
->phydev
;
1091 u32 val
, txcr
, rxcr
, rxcr_org
;
1092 u16 rmt_adv
= 0, lcl_adv
= 0;
1095 /* set RGMII speed */
1096 val
= readl(priv
->base
+ AVE_TXCR
);
1097 val
&= ~(AVE_TXCR_TXSPD_100
| AVE_TXCR_TXSPD_1G
);
1099 if (phy_interface_is_rgmii(phydev
) && phydev
->speed
== SPEED_1000
)
1100 val
|= AVE_TXCR_TXSPD_1G
;
1101 else if (phydev
->speed
== SPEED_100
)
1102 val
|= AVE_TXCR_TXSPD_100
;
1104 writel(val
, priv
->base
+ AVE_TXCR
);
1106 /* set RMII speed (100M/10M only) */
1107 if (!phy_interface_is_rgmii(phydev
)) {
1108 val
= readl(priv
->base
+ AVE_LINKSEL
);
1109 if (phydev
->speed
== SPEED_10
)
1110 val
&= ~AVE_LINKSEL_100M
;
1112 val
|= AVE_LINKSEL_100M
;
1113 writel(val
, priv
->base
+ AVE_LINKSEL
);
1116 /* check current RXCR/TXCR */
1117 rxcr
= readl(priv
->base
+ AVE_RXCR
);
1118 txcr
= readl(priv
->base
+ AVE_TXCR
);
1121 if (phydev
->duplex
) {
1122 rxcr
|= AVE_RXCR_FDUPEN
;
1125 rmt_adv
|= LPA_PAUSE_CAP
;
1126 if (phydev
->asym_pause
)
1127 rmt_adv
|= LPA_PAUSE_ASYM
;
1129 lcl_adv
= linkmode_adv_to_lcl_adv_t(phydev
->advertising
);
1130 cap
= mii_resolve_flowctrl_fdx(lcl_adv
, rmt_adv
);
1131 if (cap
& FLOW_CTRL_TX
)
1132 txcr
|= AVE_TXCR_FLOCTR
;
1134 txcr
&= ~AVE_TXCR_FLOCTR
;
1135 if (cap
& FLOW_CTRL_RX
)
1136 rxcr
|= AVE_RXCR_FLOCTR
;
1138 rxcr
&= ~AVE_RXCR_FLOCTR
;
1140 rxcr
&= ~AVE_RXCR_FDUPEN
;
1141 rxcr
&= ~AVE_RXCR_FLOCTR
;
1142 txcr
&= ~AVE_TXCR_FLOCTR
;
1145 if (rxcr_org
!= rxcr
) {
1146 /* disable Rx mac */
1147 writel(rxcr
& ~AVE_RXCR_RXEN
, priv
->base
+ AVE_RXCR
);
1148 /* change and enable TX/Rx mac */
1149 writel(txcr
, priv
->base
+ AVE_TXCR
);
1150 writel(rxcr
, priv
->base
+ AVE_RXCR
);
1153 phy_print_status(phydev
);
1156 static void ave_macaddr_init(struct net_device
*ndev
)
1158 ave_hw_write_macaddr(ndev
, ndev
->dev_addr
, AVE_RXMAC1R
, AVE_RXMAC2R
);
1160 /* pfsel unicast entry */
1161 ave_pfsel_set_macaddr(ndev
, AVE_PFNUM_UNICAST
, ndev
->dev_addr
, 6);
1164 static int ave_init(struct net_device
*ndev
)
1166 struct ethtool_wolinfo wol
= { .cmd
= ETHTOOL_GWOL
};
1167 struct ave_private
*priv
= netdev_priv(ndev
);
1168 struct device
*dev
= ndev
->dev
.parent
;
1169 struct device_node
*np
= dev
->of_node
;
1170 struct device_node
*mdio_np
;
1171 struct phy_device
*phydev
;
1174 /* enable clk because of hw access until ndo_open */
1175 for (nc
= 0; nc
< priv
->nclks
; nc
++) {
1176 ret
= clk_prepare_enable(priv
->clk
[nc
]);
1178 dev_err(dev
, "can't enable clock\n");
1179 goto out_clk_disable
;
1183 for (nr
= 0; nr
< priv
->nrsts
; nr
++) {
1184 ret
= reset_control_deassert(priv
->rst
[nr
]);
1186 dev_err(dev
, "can't deassert reset\n");
1187 goto out_reset_assert
;
1191 ret
= regmap_update_bits(priv
->regmap
, SG_ETPINMODE
,
1192 priv
->pinmode_mask
, priv
->pinmode_val
);
1194 goto out_reset_assert
;
1196 ave_global_reset(ndev
);
1198 mdio_np
= of_get_child_by_name(np
, "mdio");
1200 dev_err(dev
, "mdio node not found\n");
1202 goto out_reset_assert
;
1204 ret
= of_mdiobus_register(priv
->mdio
, mdio_np
);
1205 of_node_put(mdio_np
);
1207 dev_err(dev
, "failed to register mdiobus\n");
1208 goto out_reset_assert
;
1211 phydev
= of_phy_get_and_connect(ndev
, np
, ave_phy_adjust_link
);
1213 dev_err(dev
, "could not attach to PHY\n");
1215 goto out_mdio_unregister
;
1218 priv
->phydev
= phydev
;
1220 ave_ethtool_get_wol(ndev
, &wol
);
1221 device_set_wakeup_capable(&ndev
->dev
, !!wol
.supported
);
1223 /* set wol initial state disabled */
1225 __ave_ethtool_set_wol(ndev
, &wol
);
1227 if (!phy_interface_is_rgmii(phydev
))
1228 phy_set_max_speed(phydev
, SPEED_100
);
1230 phy_support_asym_pause(phydev
);
1232 phy_attached_info(phydev
);
1236 out_mdio_unregister
:
1237 mdiobus_unregister(priv
->mdio
);
1240 reset_control_assert(priv
->rst
[nr
]);
1243 clk_disable_unprepare(priv
->clk
[nc
]);
1248 static void ave_uninit(struct net_device
*ndev
)
1250 struct ave_private
*priv
= netdev_priv(ndev
);
1253 phy_disconnect(priv
->phydev
);
1254 mdiobus_unregister(priv
->mdio
);
1256 /* disable clk because of hw access after ndo_stop */
1257 for (i
= 0; i
< priv
->nrsts
; i
++)
1258 reset_control_assert(priv
->rst
[i
]);
1259 for (i
= 0; i
< priv
->nclks
; i
++)
1260 clk_disable_unprepare(priv
->clk
[i
]);
1263 static int ave_open(struct net_device
*ndev
)
1265 struct ave_private
*priv
= netdev_priv(ndev
);
1270 ret
= request_irq(priv
->irq
, ave_irq_handler
, IRQF_SHARED
, ndev
->name
,
1275 priv
->tx
.desc
= kcalloc(priv
->tx
.ndesc
, sizeof(*priv
->tx
.desc
),
1277 if (!priv
->tx
.desc
) {
1282 priv
->rx
.desc
= kcalloc(priv
->rx
.ndesc
, sizeof(*priv
->rx
.desc
),
1284 if (!priv
->rx
.desc
) {
1285 kfree(priv
->tx
.desc
);
1290 /* initialize Tx work and descriptor */
1291 priv
->tx
.proc_idx
= 0;
1292 priv
->tx
.done_idx
= 0;
1293 for (entry
= 0; entry
< priv
->tx
.ndesc
; entry
++) {
1294 ave_desc_write_cmdsts(ndev
, AVE_DESCID_TX
, entry
, 0);
1295 ave_desc_write_addr(ndev
, AVE_DESCID_TX
, entry
, 0);
1297 writel(AVE_TXDC_ADDR_START
|
1298 (((priv
->tx
.ndesc
* priv
->desc_size
) << 16) & AVE_TXDC_SIZE
),
1299 priv
->base
+ AVE_TXDC
);
1301 /* initialize Rx work and descriptor */
1302 priv
->rx
.proc_idx
= 0;
1303 priv
->rx
.done_idx
= 0;
1304 for (entry
= 0; entry
< priv
->rx
.ndesc
; entry
++) {
1305 if (ave_rxdesc_prepare(ndev
, entry
))
1308 writel(AVE_RXDC0_ADDR_START
|
1309 (((priv
->rx
.ndesc
* priv
->desc_size
) << 16) & AVE_RXDC0_SIZE
),
1310 priv
->base
+ AVE_RXDC0
);
1312 ave_desc_switch(ndev
, AVE_DESC_START
);
1314 ave_pfsel_init(ndev
);
1315 ave_macaddr_init(ndev
);
1317 /* set Rx configuration */
1318 /* full duplex, enable pause drop, enalbe flow control */
1319 val
= AVE_RXCR_RXEN
| AVE_RXCR_FDUPEN
| AVE_RXCR_DRPEN
|
1320 AVE_RXCR_FLOCTR
| (AVE_MAX_ETHFRAME
& AVE_RXCR_MPSIZ_MASK
);
1321 writel(val
, priv
->base
+ AVE_RXCR
);
1323 /* set Tx configuration */
1324 /* enable flow control, disable loopback */
1325 writel(AVE_TXCR_FLOCTR
, priv
->base
+ AVE_TXCR
);
1327 /* enable timer, clear EN,INTM, and mask interval unit(BSCK) */
1328 val
= readl(priv
->base
+ AVE_IIRQC
) & AVE_IIRQC_BSCK
;
1329 val
|= AVE_IIRQC_EN0
| (AVE_INTM_COUNT
<< 16);
1330 writel(val
, priv
->base
+ AVE_IIRQC
);
1332 val
= AVE_GI_RXIINT
| AVE_GI_RXOVF
| AVE_GI_TX
| AVE_GI_RXDROP
;
1333 ave_irq_restore(ndev
, val
);
1335 napi_enable(&priv
->napi_rx
);
1336 napi_enable(&priv
->napi_tx
);
1338 phy_start(ndev
->phydev
);
1339 phy_start_aneg(ndev
->phydev
);
1340 netif_start_queue(ndev
);
1345 disable_irq(priv
->irq
);
1346 free_irq(priv
->irq
, ndev
);
1351 static int ave_stop(struct net_device
*ndev
)
1353 struct ave_private
*priv
= netdev_priv(ndev
);
1356 ave_irq_disable_all(ndev
);
1357 disable_irq(priv
->irq
);
1358 free_irq(priv
->irq
, ndev
);
1360 netif_tx_disable(ndev
);
1361 phy_stop(ndev
->phydev
);
1362 napi_disable(&priv
->napi_tx
);
1363 napi_disable(&priv
->napi_rx
);
1365 ave_desc_switch(ndev
, AVE_DESC_STOP
);
1367 /* free Tx buffer */
1368 for (entry
= 0; entry
< priv
->tx
.ndesc
; entry
++) {
1369 if (!priv
->tx
.desc
[entry
].skbs
)
1372 ave_dma_unmap(ndev
, &priv
->tx
.desc
[entry
], DMA_TO_DEVICE
);
1373 dev_kfree_skb_any(priv
->tx
.desc
[entry
].skbs
);
1374 priv
->tx
.desc
[entry
].skbs
= NULL
;
1376 priv
->tx
.proc_idx
= 0;
1377 priv
->tx
.done_idx
= 0;
1379 /* free Rx buffer */
1380 for (entry
= 0; entry
< priv
->rx
.ndesc
; entry
++) {
1381 if (!priv
->rx
.desc
[entry
].skbs
)
1384 ave_dma_unmap(ndev
, &priv
->rx
.desc
[entry
], DMA_FROM_DEVICE
);
1385 dev_kfree_skb_any(priv
->rx
.desc
[entry
].skbs
);
1386 priv
->rx
.desc
[entry
].skbs
= NULL
;
1388 priv
->rx
.proc_idx
= 0;
1389 priv
->rx
.done_idx
= 0;
1391 kfree(priv
->tx
.desc
);
1392 kfree(priv
->rx
.desc
);
1397 static netdev_tx_t
ave_start_xmit(struct sk_buff
*skb
, struct net_device
*ndev
)
1399 struct ave_private
*priv
= netdev_priv(ndev
);
1400 u32 proc_idx
, done_idx
, ndesc
, cmdsts
;
1404 proc_idx
= priv
->tx
.proc_idx
;
1405 done_idx
= priv
->tx
.done_idx
;
1406 ndesc
= priv
->tx
.ndesc
;
1407 freepkt
= ((done_idx
+ ndesc
- 1) - proc_idx
) % ndesc
;
1409 /* stop queue when not enough entry */
1410 if (unlikely(freepkt
< 1)) {
1411 netif_stop_queue(ndev
);
1412 return NETDEV_TX_BUSY
;
1415 /* add padding for short packet */
1416 if (skb_put_padto(skb
, ETH_ZLEN
)) {
1417 priv
->stats_tx
.dropped
++;
1418 return NETDEV_TX_OK
;
1422 * Tx buffer set to the Tx descriptor doesn't have any restriction.
1424 ret
= ave_dma_map(ndev
, &priv
->tx
.desc
[proc_idx
],
1425 skb
->data
, skb
->len
, DMA_TO_DEVICE
, &paddr
);
1427 dev_kfree_skb_any(skb
);
1428 priv
->stats_tx
.dropped
++;
1429 return NETDEV_TX_OK
;
1432 priv
->tx
.desc
[proc_idx
].skbs
= skb
;
1434 ave_desc_write_addr(ndev
, AVE_DESCID_TX
, proc_idx
, paddr
);
1436 cmdsts
= AVE_STS_OWN
| AVE_STS_1ST
| AVE_STS_LAST
|
1437 (skb
->len
& AVE_STS_PKTLEN_TX_MASK
);
1439 /* set interrupt per AVE_FORCE_TXINTCNT or when queue is stopped */
1440 if (!(proc_idx
% AVE_FORCE_TXINTCNT
) || netif_queue_stopped(ndev
))
1441 cmdsts
|= AVE_STS_INTR
;
1443 /* disable checksum calculation when skb doesn't calurate checksum */
1444 if (skb
->ip_summed
== CHECKSUM_NONE
||
1445 skb
->ip_summed
== CHECKSUM_UNNECESSARY
)
1446 cmdsts
|= AVE_STS_NOCSUM
;
1448 ave_desc_write_cmdsts(ndev
, AVE_DESCID_TX
, proc_idx
, cmdsts
);
1450 priv
->tx
.proc_idx
= (proc_idx
+ 1) % ndesc
;
1452 return NETDEV_TX_OK
;
1455 static int ave_ioctl(struct net_device
*ndev
, struct ifreq
*ifr
, int cmd
)
1457 return phy_mii_ioctl(ndev
->phydev
, ifr
, cmd
);
1460 static const u8 v4multi_macadr
[] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 };
1461 static const u8 v6multi_macadr
[] = { 0x33, 0x00, 0x00, 0x00, 0x00, 0x00 };
1463 static void ave_set_rx_mode(struct net_device
*ndev
)
1465 struct ave_private
*priv
= netdev_priv(ndev
);
1466 struct netdev_hw_addr
*hw_adr
;
1470 /* MAC addr filter enable for promiscious mode */
1471 mc_cnt
= netdev_mc_count(ndev
);
1472 val
= readl(priv
->base
+ AVE_RXCR
);
1473 if (ndev
->flags
& IFF_PROMISC
|| !mc_cnt
)
1474 val
&= ~AVE_RXCR_AFEN
;
1476 val
|= AVE_RXCR_AFEN
;
1477 writel(val
, priv
->base
+ AVE_RXCR
);
1479 /* set all multicast address */
1480 if ((ndev
->flags
& IFF_ALLMULTI
) || mc_cnt
> AVE_PF_MULTICAST_SIZE
) {
1481 ave_pfsel_set_macaddr(ndev
, AVE_PFNUM_MULTICAST
,
1483 ave_pfsel_set_macaddr(ndev
, AVE_PFNUM_MULTICAST
+ 1,
1486 /* stop all multicast filter */
1487 for (count
= 0; count
< AVE_PF_MULTICAST_SIZE
; count
++)
1488 ave_pfsel_stop(ndev
, AVE_PFNUM_MULTICAST
+ count
);
1490 /* set multicast addresses */
1492 netdev_for_each_mc_addr(hw_adr
, ndev
) {
1493 if (count
== mc_cnt
)
1495 ave_pfsel_set_macaddr(ndev
, AVE_PFNUM_MULTICAST
+ count
,
1502 static void ave_get_stats64(struct net_device
*ndev
,
1503 struct rtnl_link_stats64
*stats
)
1505 struct ave_private
*priv
= netdev_priv(ndev
);
1509 start
= u64_stats_fetch_begin_irq(&priv
->stats_rx
.syncp
);
1510 stats
->rx_packets
= priv
->stats_rx
.packets
;
1511 stats
->rx_bytes
= priv
->stats_rx
.bytes
;
1512 } while (u64_stats_fetch_retry_irq(&priv
->stats_rx
.syncp
, start
));
1515 start
= u64_stats_fetch_begin_irq(&priv
->stats_tx
.syncp
);
1516 stats
->tx_packets
= priv
->stats_tx
.packets
;
1517 stats
->tx_bytes
= priv
->stats_tx
.bytes
;
1518 } while (u64_stats_fetch_retry_irq(&priv
->stats_tx
.syncp
, start
));
1520 stats
->rx_errors
= priv
->stats_rx
.errors
;
1521 stats
->tx_errors
= priv
->stats_tx
.errors
;
1522 stats
->rx_dropped
= priv
->stats_rx
.dropped
;
1523 stats
->tx_dropped
= priv
->stats_tx
.dropped
;
1524 stats
->rx_fifo_errors
= priv
->stats_rx
.fifo_errors
;
1525 stats
->collisions
= priv
->stats_tx
.collisions
;
1528 static int ave_set_mac_address(struct net_device
*ndev
, void *p
)
1530 int ret
= eth_mac_addr(ndev
, p
);
1535 ave_macaddr_init(ndev
);
1540 static const struct net_device_ops ave_netdev_ops
= {
1541 .ndo_init
= ave_init
,
1542 .ndo_uninit
= ave_uninit
,
1543 .ndo_open
= ave_open
,
1544 .ndo_stop
= ave_stop
,
1545 .ndo_start_xmit
= ave_start_xmit
,
1546 .ndo_do_ioctl
= ave_ioctl
,
1547 .ndo_set_rx_mode
= ave_set_rx_mode
,
1548 .ndo_get_stats64
= ave_get_stats64
,
1549 .ndo_set_mac_address
= ave_set_mac_address
,
1552 static int ave_probe(struct platform_device
*pdev
)
1554 const struct ave_soc_data
*data
;
1555 struct device
*dev
= &pdev
->dev
;
1556 char buf
[ETHTOOL_FWVERS_LEN
];
1557 struct of_phandle_args args
;
1558 phy_interface_t phy_mode
;
1559 struct ave_private
*priv
;
1560 struct net_device
*ndev
;
1561 struct device_node
*np
;
1562 const void *mac_addr
;
1569 data
= of_device_get_match_data(dev
);
1574 ret
= of_get_phy_mode(np
, &phy_mode
);
1576 dev_err(dev
, "phy-mode not found\n");
1580 irq
= platform_get_irq(pdev
, 0);
1584 base
= devm_platform_ioremap_resource(pdev
, 0);
1586 return PTR_ERR(base
);
1588 ndev
= devm_alloc_etherdev(dev
, sizeof(struct ave_private
));
1590 dev_err(dev
, "can't allocate ethernet device\n");
1594 ndev
->netdev_ops
= &ave_netdev_ops
;
1595 ndev
->ethtool_ops
= &ave_ethtool_ops
;
1596 SET_NETDEV_DEV(ndev
, dev
);
1598 ndev
->features
|= (NETIF_F_IP_CSUM
| NETIF_F_RXCSUM
);
1599 ndev
->hw_features
|= (NETIF_F_IP_CSUM
| NETIF_F_RXCSUM
);
1601 ndev
->max_mtu
= AVE_MAX_ETHFRAME
- (ETH_HLEN
+ ETH_FCS_LEN
);
1603 mac_addr
= of_get_mac_address(np
);
1604 if (!IS_ERR(mac_addr
))
1605 ether_addr_copy(ndev
->dev_addr
, mac_addr
);
1607 /* if the mac address is invalid, use random mac address */
1608 if (!is_valid_ether_addr(ndev
->dev_addr
)) {
1609 eth_hw_addr_random(ndev
);
1610 dev_warn(dev
, "Using random MAC address: %pM\n",
1614 priv
= netdev_priv(ndev
);
1618 priv
->msg_enable
= netif_msg_init(-1, AVE_DEFAULT_MSG_ENABLE
);
1619 priv
->phy_mode
= phy_mode
;
1622 if (IS_DESC_64BIT(priv
)) {
1623 priv
->desc_size
= AVE_DESC_SIZE_64
;
1624 priv
->tx
.daddr
= AVE_TXDM_64
;
1625 priv
->rx
.daddr
= AVE_RXDM_64
;
1626 dma_mask
= DMA_BIT_MASK(64);
1628 priv
->desc_size
= AVE_DESC_SIZE_32
;
1629 priv
->tx
.daddr
= AVE_TXDM_32
;
1630 priv
->rx
.daddr
= AVE_RXDM_32
;
1631 dma_mask
= DMA_BIT_MASK(32);
1633 ret
= dma_set_mask(dev
, dma_mask
);
1637 priv
->tx
.ndesc
= AVE_NR_TXDESC
;
1638 priv
->rx
.ndesc
= AVE_NR_RXDESC
;
1640 u64_stats_init(&priv
->stats_tx
.syncp
);
1641 u64_stats_init(&priv
->stats_rx
.syncp
);
1643 for (i
= 0; i
< AVE_MAX_CLKS
; i
++) {
1644 name
= priv
->data
->clock_names
[i
];
1647 priv
->clk
[i
] = devm_clk_get(dev
, name
);
1648 if (IS_ERR(priv
->clk
[i
]))
1649 return PTR_ERR(priv
->clk
[i
]);
1653 for (i
= 0; i
< AVE_MAX_RSTS
; i
++) {
1654 name
= priv
->data
->reset_names
[i
];
1657 priv
->rst
[i
] = devm_reset_control_get_shared(dev
, name
);
1658 if (IS_ERR(priv
->rst
[i
]))
1659 return PTR_ERR(priv
->rst
[i
]);
1663 ret
= of_parse_phandle_with_fixed_args(np
,
1664 "socionext,syscon-phy-mode",
1667 dev_err(dev
, "can't get syscon-phy-mode property\n");
1670 priv
->regmap
= syscon_node_to_regmap(args
.np
);
1671 of_node_put(args
.np
);
1672 if (IS_ERR(priv
->regmap
)) {
1673 dev_err(dev
, "can't map syscon-phy-mode\n");
1674 return PTR_ERR(priv
->regmap
);
1676 ret
= priv
->data
->get_pinmode(priv
, phy_mode
, args
.args
[0]);
1678 dev_err(dev
, "invalid phy-mode setting\n");
1682 priv
->mdio
= devm_mdiobus_alloc(dev
);
1685 priv
->mdio
->priv
= ndev
;
1686 priv
->mdio
->parent
= dev
;
1687 priv
->mdio
->read
= ave_mdiobus_read
;
1688 priv
->mdio
->write
= ave_mdiobus_write
;
1689 priv
->mdio
->name
= "uniphier-mdio";
1690 snprintf(priv
->mdio
->id
, MII_BUS_ID_SIZE
, "%s-%x",
1691 pdev
->name
, pdev
->id
);
1693 /* Register as a NAPI supported driver */
1694 netif_napi_add(ndev
, &priv
->napi_rx
, ave_napi_poll_rx
,
1696 netif_tx_napi_add(ndev
, &priv
->napi_tx
, ave_napi_poll_tx
,
1699 platform_set_drvdata(pdev
, ndev
);
1701 ret
= register_netdev(ndev
);
1703 dev_err(dev
, "failed to register netdevice\n");
1707 /* get ID and version */
1708 ave_id
= readl(priv
->base
+ AVE_IDR
);
1709 ave_hw_read_version(ndev
, buf
, sizeof(buf
));
1711 dev_info(dev
, "Socionext %c%c%c%c Ethernet IP %s (irq=%d, phy=%s)\n",
1712 (ave_id
>> 24) & 0xff, (ave_id
>> 16) & 0xff,
1713 (ave_id
>> 8) & 0xff, (ave_id
>> 0) & 0xff,
1714 buf
, priv
->irq
, phy_modes(phy_mode
));
1719 netif_napi_del(&priv
->napi_rx
);
1720 netif_napi_del(&priv
->napi_tx
);
1725 static int ave_remove(struct platform_device
*pdev
)
1727 struct net_device
*ndev
= platform_get_drvdata(pdev
);
1728 struct ave_private
*priv
= netdev_priv(ndev
);
1730 unregister_netdev(ndev
);
1731 netif_napi_del(&priv
->napi_rx
);
1732 netif_napi_del(&priv
->napi_tx
);
1737 #ifdef CONFIG_PM_SLEEP
1738 static int ave_suspend(struct device
*dev
)
1740 struct ethtool_wolinfo wol
= { .cmd
= ETHTOOL_GWOL
};
1741 struct net_device
*ndev
= dev_get_drvdata(dev
);
1742 struct ave_private
*priv
= netdev_priv(ndev
);
1745 if (netif_running(ndev
)) {
1746 ret
= ave_stop(ndev
);
1747 netif_device_detach(ndev
);
1750 ave_ethtool_get_wol(ndev
, &wol
);
1751 priv
->wolopts
= wol
.wolopts
;
1756 static int ave_resume(struct device
*dev
)
1758 struct ethtool_wolinfo wol
= { .cmd
= ETHTOOL_GWOL
};
1759 struct net_device
*ndev
= dev_get_drvdata(dev
);
1760 struct ave_private
*priv
= netdev_priv(ndev
);
1763 ave_global_reset(ndev
);
1765 ave_ethtool_get_wol(ndev
, &wol
);
1766 wol
.wolopts
= priv
->wolopts
;
1767 __ave_ethtool_set_wol(ndev
, &wol
);
1770 ret
= phy_resume(ndev
->phydev
);
1775 if (netif_running(ndev
)) {
1776 ret
= ave_open(ndev
);
1777 netif_device_attach(ndev
);
1783 static SIMPLE_DEV_PM_OPS(ave_pm_ops
, ave_suspend
, ave_resume
);
1784 #define AVE_PM_OPS (&ave_pm_ops)
1786 #define AVE_PM_OPS NULL
1789 static int ave_pro4_get_pinmode(struct ave_private
*priv
,
1790 phy_interface_t phy_mode
, u32 arg
)
1795 priv
->pinmode_mask
= SG_ETPINMODE_RMII(0);
1798 case PHY_INTERFACE_MODE_RMII
:
1799 priv
->pinmode_val
= SG_ETPINMODE_RMII(0);
1801 case PHY_INTERFACE_MODE_MII
:
1802 case PHY_INTERFACE_MODE_RGMII
:
1803 case PHY_INTERFACE_MODE_RGMII_ID
:
1804 case PHY_INTERFACE_MODE_RGMII_RXID
:
1805 case PHY_INTERFACE_MODE_RGMII_TXID
:
1806 priv
->pinmode_val
= 0;
1815 static int ave_ld11_get_pinmode(struct ave_private
*priv
,
1816 phy_interface_t phy_mode
, u32 arg
)
1821 priv
->pinmode_mask
= SG_ETPINMODE_EXTPHY
| SG_ETPINMODE_RMII(0);
1824 case PHY_INTERFACE_MODE_INTERNAL
:
1825 priv
->pinmode_val
= 0;
1827 case PHY_INTERFACE_MODE_RMII
:
1828 priv
->pinmode_val
= SG_ETPINMODE_EXTPHY
| SG_ETPINMODE_RMII(0);
1837 static int ave_ld20_get_pinmode(struct ave_private
*priv
,
1838 phy_interface_t phy_mode
, u32 arg
)
1843 priv
->pinmode_mask
= SG_ETPINMODE_RMII(0);
1846 case PHY_INTERFACE_MODE_RMII
:
1847 priv
->pinmode_val
= SG_ETPINMODE_RMII(0);
1849 case PHY_INTERFACE_MODE_RGMII
:
1850 case PHY_INTERFACE_MODE_RGMII_ID
:
1851 case PHY_INTERFACE_MODE_RGMII_RXID
:
1852 case PHY_INTERFACE_MODE_RGMII_TXID
:
1853 priv
->pinmode_val
= 0;
1862 static int ave_pxs3_get_pinmode(struct ave_private
*priv
,
1863 phy_interface_t phy_mode
, u32 arg
)
1868 priv
->pinmode_mask
= SG_ETPINMODE_RMII(arg
);
1871 case PHY_INTERFACE_MODE_RMII
:
1872 priv
->pinmode_val
= SG_ETPINMODE_RMII(arg
);
1874 case PHY_INTERFACE_MODE_RGMII
:
1875 case PHY_INTERFACE_MODE_RGMII_ID
:
1876 case PHY_INTERFACE_MODE_RGMII_RXID
:
1877 case PHY_INTERFACE_MODE_RGMII_TXID
:
1878 priv
->pinmode_val
= 0;
1887 static const struct ave_soc_data ave_pro4_data
= {
1888 .is_desc_64bit
= false,
1890 "gio", "ether", "ether-gb", "ether-phy",
1895 .get_pinmode
= ave_pro4_get_pinmode
,
1898 static const struct ave_soc_data ave_pxs2_data
= {
1899 .is_desc_64bit
= false,
1906 .get_pinmode
= ave_pro4_get_pinmode
,
1909 static const struct ave_soc_data ave_ld11_data
= {
1910 .is_desc_64bit
= false,
1917 .get_pinmode
= ave_ld11_get_pinmode
,
1920 static const struct ave_soc_data ave_ld20_data
= {
1921 .is_desc_64bit
= true,
1928 .get_pinmode
= ave_ld20_get_pinmode
,
1931 static const struct ave_soc_data ave_pxs3_data
= {
1932 .is_desc_64bit
= false,
1939 .get_pinmode
= ave_pxs3_get_pinmode
,
1942 static const struct of_device_id of_ave_match
[] = {
1944 .compatible
= "socionext,uniphier-pro4-ave4",
1945 .data
= &ave_pro4_data
,
1948 .compatible
= "socionext,uniphier-pxs2-ave4",
1949 .data
= &ave_pxs2_data
,
1952 .compatible
= "socionext,uniphier-ld11-ave4",
1953 .data
= &ave_ld11_data
,
1956 .compatible
= "socionext,uniphier-ld20-ave4",
1957 .data
= &ave_ld20_data
,
1960 .compatible
= "socionext,uniphier-pxs3-ave4",
1961 .data
= &ave_pxs3_data
,
1965 MODULE_DEVICE_TABLE(of
, of_ave_match
);
1967 static struct platform_driver ave_driver
= {
1969 .remove
= ave_remove
,
1973 .of_match_table
= of_ave_match
,
1976 module_platform_driver(ave_driver
);
1978 MODULE_AUTHOR("Kunihiko Hayashi <hayashi.kunihiko@socionext.com>");
1979 MODULE_DESCRIPTION("Socionext UniPhier AVE ethernet driver");
1980 MODULE_LICENSE("GPL v2");