aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/devicetree/bindings/net/socionext,uniphier-ave4.txt48
-rw-r--r--drivers/net/ethernet/Kconfig1
-rw-r--r--drivers/net/ethernet/Makefile1
-rw-r--r--drivers/net/ethernet/socionext/Kconfig22
-rw-r--r--drivers/net/ethernet/socionext/Makefile5
-rw-r--r--drivers/net/ethernet/socionext/sni_ave.c1736
6 files changed, 1813 insertions, 0 deletions
diff --git a/Documentation/devicetree/bindings/net/socionext,uniphier-ave4.txt b/Documentation/devicetree/bindings/net/socionext,uniphier-ave4.txt
new file mode 100644
index 000000000000..270ea4efff13
--- /dev/null
+++ b/Documentation/devicetree/bindings/net/socionext,uniphier-ave4.txt
@@ -0,0 +1,48 @@
1* Socionext AVE ethernet controller
2
3This describes the devicetree bindings for AVE ethernet controller
4implemented on Socionext UniPhier SoCs.
5
6Required properties:
7 - compatible: Should be
8 - "socionext,uniphier-pro4-ave4" : for Pro4 SoC
9 - "socionext,uniphier-pxs2-ave4" : for PXs2 SoC
10 - "socionext,uniphier-ld11-ave4" : for LD11 SoC
11 - "socionext,uniphier-ld20-ave4" : for LD20 SoC
12 - reg: Address where registers are mapped and size of region.
13 - interrupts: Should contain the MAC interrupt.
14 - phy-mode: See ethernet.txt in the same directory. Allow to choose
15 "rgmii", "rmii", or "mii" according to the PHY.
16 - phy-handle: Should point to the external phy device.
17 See ethernet.txt file in the same directory.
18 - clocks: A phandle to the clock for the MAC.
19
20Optional properties:
21 - resets: A phandle to the reset control for the MAC.
22 - local-mac-address: See ethernet.txt in the same directory.
23
24Required subnode:
25 - mdio: A container for child nodes representing phy nodes.
26 See phy.txt in the same directory.
27
28Example:
29
30 ether: ethernet@65000000 {
31 compatible = "socionext,uniphier-ld20-ave4";
32 reg = <0x65000000 0x8500>;
33 interrupts = <0 66 4>;
34 phy-mode = "rgmii";
35 phy-handle = <&ethphy>;
36 clocks = <&sys_clk 6>;
37 resets = <&sys_rst 6>;
38 local-mac-address = [00 00 00 00 00 00];
39
40 mdio {
41 #address-cells = <1>;
42 #size-cells = <0>;
43
44 ethphy: ethphy@1 {
45 reg = <1>;
46 };
47 };
48 };
diff --git a/drivers/net/ethernet/Kconfig b/drivers/net/ethernet/Kconfig
index c60421339a98..d50519ed7549 100644
--- a/drivers/net/ethernet/Kconfig
+++ b/drivers/net/ethernet/Kconfig
@@ -170,6 +170,7 @@ source "drivers/net/ethernet/sis/Kconfig"
170source "drivers/net/ethernet/sfc/Kconfig" 170source "drivers/net/ethernet/sfc/Kconfig"
171source "drivers/net/ethernet/sgi/Kconfig" 171source "drivers/net/ethernet/sgi/Kconfig"
172source "drivers/net/ethernet/smsc/Kconfig" 172source "drivers/net/ethernet/smsc/Kconfig"
173source "drivers/net/ethernet/socionext/Kconfig"
173source "drivers/net/ethernet/stmicro/Kconfig" 174source "drivers/net/ethernet/stmicro/Kconfig"
174source "drivers/net/ethernet/sun/Kconfig" 175source "drivers/net/ethernet/sun/Kconfig"
175source "drivers/net/ethernet/tehuti/Kconfig" 176source "drivers/net/ethernet/tehuti/Kconfig"
diff --git a/drivers/net/ethernet/Makefile b/drivers/net/ethernet/Makefile
index 39f6273358ed..6cf5aded9423 100644
--- a/drivers/net/ethernet/Makefile
+++ b/drivers/net/ethernet/Makefile
@@ -82,6 +82,7 @@ obj-$(CONFIG_SFC) += sfc/
82obj-$(CONFIG_SFC_FALCON) += sfc/falcon/ 82obj-$(CONFIG_SFC_FALCON) += sfc/falcon/
83obj-$(CONFIG_NET_VENDOR_SGI) += sgi/ 83obj-$(CONFIG_NET_VENDOR_SGI) += sgi/
84obj-$(CONFIG_NET_VENDOR_SMSC) += smsc/ 84obj-$(CONFIG_NET_VENDOR_SMSC) += smsc/
85obj-$(CONFIG_NET_VENDOR_SOCIONEXT) += socionext/
85obj-$(CONFIG_NET_VENDOR_STMICRO) += stmicro/ 86obj-$(CONFIG_NET_VENDOR_STMICRO) += stmicro/
86obj-$(CONFIG_NET_VENDOR_SUN) += sun/ 87obj-$(CONFIG_NET_VENDOR_SUN) += sun/
87obj-$(CONFIG_NET_VENDOR_TEHUTI) += tehuti/ 88obj-$(CONFIG_NET_VENDOR_TEHUTI) += tehuti/
diff --git a/drivers/net/ethernet/socionext/Kconfig b/drivers/net/ethernet/socionext/Kconfig
new file mode 100644
index 000000000000..3a1829e59e24
--- /dev/null
+++ b/drivers/net/ethernet/socionext/Kconfig
@@ -0,0 +1,22 @@
1config NET_VENDOR_SOCIONEXT
2 bool "Socionext ethernet drivers"
3 default y
4 ---help---
5 Option to select ethernet drivers for Socionext platforms.
6
7 Note that the answer to this question doesn't directly affect the
8 kernel: saying N will just cause the configurator to skip all
9 the questions about Socionext devices. If you say Y, you will be asked
10 for your specific card in the following questions.
11
12if NET_VENDOR_SOCIONEXT
13
14config SNI_AVE
15 tristate "Socionext AVE ethernet support"
16 depends on (ARCH_UNIPHIER || COMPILE_TEST) && OF
17 select PHYLIB
18 ---help---
19 Driver for gigabit ethernet MACs, called AVE, in the
20 Socionext UniPhier family.
21
22endif #NET_VENDOR_SOCIONEXT
diff --git a/drivers/net/ethernet/socionext/Makefile b/drivers/net/ethernet/socionext/Makefile
new file mode 100644
index 000000000000..ab83df63b670
--- /dev/null
+++ b/drivers/net/ethernet/socionext/Makefile
@@ -0,0 +1,5 @@
1# SPDX-License-Identifier: GPL-2.0
2#
3# Makefile for all ethernet ip drivers on Socionext platforms
4#
5obj-$(CONFIG_SNI_AVE) += sni_ave.o
diff --git a/drivers/net/ethernet/socionext/sni_ave.c b/drivers/net/ethernet/socionext/sni_ave.c
new file mode 100644
index 000000000000..111e7ca9df56
--- /dev/null
+++ b/drivers/net/ethernet/socionext/sni_ave.c
@@ -0,0 +1,1736 @@
1// SPDX-License-Identifier: GPL-2.0
2/**
3 * sni_ave.c - Socionext UniPhier AVE ethernet driver
4 * Copyright 2014 Panasonic Corporation
5 * Copyright 2015-2017 Socionext Inc.
6 */
7
8#include <linux/bitops.h>
9#include <linux/clk.h>
10#include <linux/etherdevice.h>
11#include <linux/interrupt.h>
12#include <linux/io.h>
13#include <linux/iopoll.h>
14#include <linux/mii.h>
15#include <linux/module.h>
16#include <linux/netdevice.h>
17#include <linux/of_net.h>
18#include <linux/of_mdio.h>
19#include <linux/of_platform.h>
20#include <linux/phy.h>
21#include <linux/reset.h>
22#include <linux/types.h>
23#include <linux/u64_stats_sync.h>
24
25/* General Register Group */
26#define AVE_IDR 0x000 /* ID */
27#define AVE_VR 0x004 /* Version */
28#define AVE_GRR 0x008 /* Global Reset */
29#define AVE_CFGR 0x00c /* Configuration */
30
31/* Interrupt Register Group */
32#define AVE_GIMR 0x100 /* Global Interrupt Mask */
33#define AVE_GISR 0x104 /* Global Interrupt Status */
34
35/* MAC Register Group */
36#define AVE_TXCR 0x200 /* TX Setup */
37#define AVE_RXCR 0x204 /* RX Setup */
38#define AVE_RXMAC1R 0x208 /* MAC address (lower) */
39#define AVE_RXMAC2R 0x20c /* MAC address (upper) */
40#define AVE_MDIOCTR 0x214 /* MDIO Control */
41#define AVE_MDIOAR 0x218 /* MDIO Address */
42#define AVE_MDIOWDR 0x21c /* MDIO Data */
43#define AVE_MDIOSR 0x220 /* MDIO Status */
44#define AVE_MDIORDR 0x224 /* MDIO Rd Data */
45
46/* Descriptor Control Register Group */
47#define AVE_DESCC 0x300 /* Descriptor Control */
48#define AVE_TXDC 0x304 /* TX Descriptor Configuration */
49#define AVE_RXDC0 0x308 /* RX Descriptor Ring0 Configuration */
50#define AVE_IIRQC 0x34c /* Interval IRQ Control */
51
52/* Packet Filter Register Group */
53#define AVE_PKTF_BASE 0x800 /* PF Base Address */
54#define AVE_PFMBYTE_BASE 0xd00 /* PF Mask Byte Base Address */
55#define AVE_PFMBIT_BASE 0xe00 /* PF Mask Bit Base Address */
56#define AVE_PFSEL_BASE 0xf00 /* PF Selector Base Address */
57#define AVE_PFEN 0xffc /* Packet Filter Enable */
58#define AVE_PKTF(ent) (AVE_PKTF_BASE + (ent) * 0x40)
59#define AVE_PFMBYTE(ent) (AVE_PFMBYTE_BASE + (ent) * 8)
60#define AVE_PFMBIT(ent) (AVE_PFMBIT_BASE + (ent) * 4)
61#define AVE_PFSEL(ent) (AVE_PFSEL_BASE + (ent) * 4)
62
63/* 64bit descriptor memory */
64#define AVE_DESC_SIZE_64 12 /* Descriptor Size */
65
66#define AVE_TXDM_64 0x1000 /* Tx Descriptor Memory */
67#define AVE_RXDM_64 0x1c00 /* Rx Descriptor Memory */
68
69#define AVE_TXDM_SIZE_64 0x0ba0 /* Tx Descriptor Memory Size 3KB */
70#define AVE_RXDM_SIZE_64 0x6000 /* Rx Descriptor Memory Size 24KB */
71
72/* 32bit descriptor memory */
73#define AVE_DESC_SIZE_32 8 /* Descriptor Size */
74
75#define AVE_TXDM_32 0x1000 /* Tx Descriptor Memory */
76#define AVE_RXDM_32 0x1800 /* Rx Descriptor Memory */
77
78#define AVE_TXDM_SIZE_32 0x07c0 /* Tx Descriptor Memory Size 2KB */
79#define AVE_RXDM_SIZE_32 0x4000 /* Rx Descriptor Memory Size 16KB */
80
81/* RMII Bridge Register Group */
82#define AVE_RSTCTRL 0x8028 /* Reset control */
83#define AVE_RSTCTRL_RMIIRST BIT(16)
84#define AVE_LINKSEL 0x8034 /* Link speed setting */
85#define AVE_LINKSEL_100M BIT(0)
86
87/* AVE_GRR */
88#define AVE_GRR_RXFFR BIT(5) /* Reset RxFIFO */
89#define AVE_GRR_PHYRST BIT(4) /* Reset external PHY */
90#define AVE_GRR_GRST BIT(0) /* Reset all MAC */
91
92/* AVE_CFGR */
93#define AVE_CFGR_FLE BIT(31) /* Filter Function */
94#define AVE_CFGR_CHE BIT(30) /* Checksum Function */
95#define AVE_CFGR_MII BIT(27) /* Func mode (1:MII/RMII, 0:RGMII) */
96#define AVE_CFGR_IPFCEN BIT(24) /* IP fragment sum Enable */
97
98/* AVE_GISR (common with GIMR) */
99#define AVE_GI_PHY BIT(24) /* PHY interrupt */
100#define AVE_GI_TX BIT(16) /* Tx complete */
101#define AVE_GI_RXERR BIT(8) /* Receive frame more than max size */
102#define AVE_GI_RXOVF BIT(7) /* Overflow at the RxFIFO */
103#define AVE_GI_RXDROP BIT(6) /* Drop packet */
104#define AVE_GI_RXIINT BIT(5) /* Interval interrupt */
105
106/* AVE_TXCR */
107#define AVE_TXCR_FLOCTR BIT(18) /* Flow control */
108#define AVE_TXCR_TXSPD_1G BIT(17)
109#define AVE_TXCR_TXSPD_100 BIT(16)
110
111/* AVE_RXCR */
112#define AVE_RXCR_RXEN BIT(30) /* Rx enable */
113#define AVE_RXCR_FDUPEN BIT(22) /* Interface mode */
114#define AVE_RXCR_FLOCTR BIT(21) /* Flow control */
115#define AVE_RXCR_AFEN BIT(19) /* MAC address filter */
116#define AVE_RXCR_DRPEN BIT(18) /* Drop pause frame */
117#define AVE_RXCR_MPSIZ_MASK GENMASK(10, 0)
118
119/* AVE_MDIOCTR */
120#define AVE_MDIOCTR_RREQ BIT(3) /* Read request */
121#define AVE_MDIOCTR_WREQ BIT(2) /* Write request */
122
123/* AVE_MDIOSR */
124#define AVE_MDIOSR_STS BIT(0) /* access status */
125
126/* AVE_DESCC */
127#define AVE_DESCC_STATUS_MASK GENMASK(31, 16)
128#define AVE_DESCC_RD0 BIT(8) /* Enable Rx descriptor Ring0 */
129#define AVE_DESCC_RDSTP BIT(4) /* Pause Rx descriptor */
130#define AVE_DESCC_TD BIT(0) /* Enable Tx descriptor */
131
132/* AVE_TXDC */
133#define AVE_TXDC_SIZE GENMASK(27, 16) /* Size of Tx descriptor */
134#define AVE_TXDC_ADDR GENMASK(11, 0) /* Start address */
135#define AVE_TXDC_ADDR_START 0
136
137/* AVE_RXDC0 */
138#define AVE_RXDC0_SIZE GENMASK(30, 16) /* Size of Rx descriptor */
139#define AVE_RXDC0_ADDR GENMASK(14, 0) /* Start address */
140#define AVE_RXDC0_ADDR_START 0
141
142/* AVE_IIRQC */
143#define AVE_IIRQC_EN0 BIT(27) /* Enable interval interrupt Ring0 */
144#define AVE_IIRQC_BSCK GENMASK(15, 0) /* Interval count unit */
145
146/* Command status for descriptor */
147#define AVE_STS_OWN BIT(31) /* Descriptor ownership */
148#define AVE_STS_INTR BIT(29) /* Request for interrupt */
149#define AVE_STS_OK BIT(27) /* Normal transmit */
150/* TX */
151#define AVE_STS_NOCSUM BIT(28) /* No use HW checksum */
152#define AVE_STS_1ST BIT(26) /* Head of buffer chain */
153#define AVE_STS_LAST BIT(25) /* Tail of buffer chain */
154#define AVE_STS_OWC BIT(21) /* Out of window,Late Collision */
155#define AVE_STS_EC BIT(20) /* Excess collision occurred */
156#define AVE_STS_PKTLEN_TX_MASK GENMASK(15, 0)
157/* RX */
158#define AVE_STS_CSSV BIT(21) /* Checksum check performed */
159#define AVE_STS_CSER BIT(20) /* Checksum error detected */
160#define AVE_STS_PKTLEN_RX_MASK GENMASK(10, 0)
161
162/* Packet filter */
163#define AVE_PFMBYTE_MASK0 (GENMASK(31, 8) | GENMASK(5, 0))
164#define AVE_PFMBYTE_MASK1 GENMASK(25, 0)
165#define AVE_PFMBIT_MASK GENMASK(15, 0)
166
167#define AVE_PF_SIZE 17 /* Number of all packet filter */
168#define AVE_PF_MULTICAST_SIZE 7 /* Number of multicast filter */
169
170#define AVE_PFNUM_FILTER 0 /* No.0 */
171#define AVE_PFNUM_UNICAST 1 /* No.1 */
172#define AVE_PFNUM_BROADCAST 2 /* No.2 */
173#define AVE_PFNUM_MULTICAST 11 /* No.11-17 */
174
175/* NETIF Message control */
176#define AVE_DEFAULT_MSG_ENABLE (NETIF_MSG_DRV | \
177 NETIF_MSG_PROBE | \
178 NETIF_MSG_LINK | \
179 NETIF_MSG_TIMER | \
180 NETIF_MSG_IFDOWN | \
181 NETIF_MSG_IFUP | \
182 NETIF_MSG_RX_ERR | \
183 NETIF_MSG_TX_ERR)
184
185/* Parameter for descriptor */
186#define AVE_NR_TXDESC 32 /* Tx descriptor */
187#define AVE_NR_RXDESC 64 /* Rx descriptor */
188
189#define AVE_DESC_OFS_CMDSTS 0
190#define AVE_DESC_OFS_ADDRL 4
191#define AVE_DESC_OFS_ADDRU 8
192
193/* Parameter for ethernet frame */
194#define AVE_MAX_ETHFRAME 1518
195
196/* Parameter for interrupt */
197#define AVE_INTM_COUNT 20
198#define AVE_FORCE_TXINTCNT 1
199
200#define IS_DESC_64BIT(p) ((p)->data->is_desc_64bit)
201
202enum desc_id {
203 AVE_DESCID_RX,
204 AVE_DESCID_TX,
205};
206
207enum desc_state {
208 AVE_DESC_RX_PERMIT,
209 AVE_DESC_RX_SUSPEND,
210 AVE_DESC_START,
211 AVE_DESC_STOP,
212};
213
214struct ave_desc {
215 struct sk_buff *skbs;
216 dma_addr_t skbs_dma;
217 size_t skbs_dmalen;
218};
219
220struct ave_desc_info {
221 u32 ndesc; /* number of descriptor */
222 u32 daddr; /* start address of descriptor */
223 u32 proc_idx; /* index of processing packet */
224 u32 done_idx; /* index of processed packet */
225 struct ave_desc *desc; /* skb info related descriptor */
226};
227
228struct ave_soc_data {
229 bool is_desc_64bit;
230};
231
232struct ave_stats {
233 struct u64_stats_sync syncp;
234 u64 packets;
235 u64 bytes;
236 u64 errors;
237 u64 dropped;
238 u64 collisions;
239 u64 fifo_errors;
240};
241
242struct ave_private {
243 void __iomem *base;
244 int irq;
245 int phy_id;
246 unsigned int desc_size;
247 u32 msg_enable;
248 struct clk *clk;
249 struct reset_control *rst;
250 phy_interface_t phy_mode;
251 struct phy_device *phydev;
252 struct mii_bus *mdio;
253
254 /* stats */
255 struct ave_stats stats_rx;
256 struct ave_stats stats_tx;
257
258 /* NAPI support */
259 struct net_device *ndev;
260 struct napi_struct napi_rx;
261 struct napi_struct napi_tx;
262
263 /* descriptor */
264 struct ave_desc_info rx;
265 struct ave_desc_info tx;
266
267 /* flow control */
268 int pause_auto;
269 int pause_rx;
270 int pause_tx;
271
272 const struct ave_soc_data *data;
273};
274
275static u32 ave_desc_read(struct net_device *ndev, enum desc_id id, int entry,
276 int offset)
277{
278 struct ave_private *priv = netdev_priv(ndev);
279 u32 addr;
280
281 addr = ((id == AVE_DESCID_TX) ? priv->tx.daddr : priv->rx.daddr)
282 + entry * priv->desc_size + offset;
283
284 return readl(priv->base + addr);
285}
286
287static u32 ave_desc_read_cmdsts(struct net_device *ndev, enum desc_id id,
288 int entry)
289{
290 return ave_desc_read(ndev, id, entry, AVE_DESC_OFS_CMDSTS);
291}
292
293static void ave_desc_write(struct net_device *ndev, enum desc_id id,
294 int entry, int offset, u32 val)
295{
296 struct ave_private *priv = netdev_priv(ndev);
297 u32 addr;
298
299 addr = ((id == AVE_DESCID_TX) ? priv->tx.daddr : priv->rx.daddr)
300 + entry * priv->desc_size + offset;
301
302 writel(val, priv->base + addr);
303}
304
305static void ave_desc_write_cmdsts(struct net_device *ndev, enum desc_id id,
306 int entry, u32 val)
307{
308 ave_desc_write(ndev, id, entry, AVE_DESC_OFS_CMDSTS, val);
309}
310
311static void ave_desc_write_addr(struct net_device *ndev, enum desc_id id,
312 int entry, dma_addr_t paddr)
313{
314 struct ave_private *priv = netdev_priv(ndev);
315
316 ave_desc_write(ndev, id, entry, AVE_DESC_OFS_ADDRL,
317 lower_32_bits(paddr));
318 if (IS_DESC_64BIT(priv))
319 ave_desc_write(ndev, id,
320 entry, AVE_DESC_OFS_ADDRU,
321 upper_32_bits(paddr));
322}
323
324static u32 ave_irq_disable_all(struct net_device *ndev)
325{
326 struct ave_private *priv = netdev_priv(ndev);
327 u32 ret;
328
329 ret = readl(priv->base + AVE_GIMR);
330 writel(0, priv->base + AVE_GIMR);
331
332 return ret;
333}
334
335static void ave_irq_restore(struct net_device *ndev, u32 val)
336{
337 struct ave_private *priv = netdev_priv(ndev);
338
339 writel(val, priv->base + AVE_GIMR);
340}
341
342static void ave_irq_enable(struct net_device *ndev, u32 bitflag)
343{
344 struct ave_private *priv = netdev_priv(ndev);
345
346 writel(readl(priv->base + AVE_GIMR) | bitflag, priv->base + AVE_GIMR);
347 writel(bitflag, priv->base + AVE_GISR);
348}
349
350static void ave_hw_write_macaddr(struct net_device *ndev,
351 const unsigned char *mac_addr,
352 int reg1, int reg2)
353{
354 struct ave_private *priv = netdev_priv(ndev);
355
356 writel(mac_addr[0] | mac_addr[1] << 8 |
357 mac_addr[2] << 16 | mac_addr[3] << 24, priv->base + reg1);
358 writel(mac_addr[4] | mac_addr[5] << 8, priv->base + reg2);
359}
360
361static void ave_hw_read_version(struct net_device *ndev, char *buf, int len)
362{
363 struct ave_private *priv = netdev_priv(ndev);
364 u32 major, minor, vr;
365
366 vr = readl(priv->base + AVE_VR);
367 major = (vr & GENMASK(15, 8)) >> 8;
368 minor = (vr & GENMASK(7, 0));
369 snprintf(buf, len, "v%u.%u", major, minor);
370}
371
372static void ave_ethtool_get_drvinfo(struct net_device *ndev,
373 struct ethtool_drvinfo *info)
374{
375 struct device *dev = ndev->dev.parent;
376
377 strlcpy(info->driver, dev->driver->name, sizeof(info->driver));
378 strlcpy(info->bus_info, dev_name(dev), sizeof(info->bus_info));
379 ave_hw_read_version(ndev, info->fw_version, sizeof(info->fw_version));
380}
381
382static u32 ave_ethtool_get_msglevel(struct net_device *ndev)
383{
384 struct ave_private *priv = netdev_priv(ndev);
385
386 return priv->msg_enable;
387}
388
389static void ave_ethtool_set_msglevel(struct net_device *ndev, u32 val)
390{
391 struct ave_private *priv = netdev_priv(ndev);
392
393 priv->msg_enable = val;
394}
395
396static void ave_ethtool_get_wol(struct net_device *ndev,
397 struct ethtool_wolinfo *wol)
398{
399 wol->supported = 0;
400 wol->wolopts = 0;
401
402 if (ndev->phydev)
403 phy_ethtool_get_wol(ndev->phydev, wol);
404}
405
406static int ave_ethtool_set_wol(struct net_device *ndev,
407 struct ethtool_wolinfo *wol)
408{
409 int ret;
410
411 if (!ndev->phydev ||
412 (wol->wolopts & (WAKE_ARP | WAKE_MAGICSECURE)))
413 return -EOPNOTSUPP;
414
415 ret = phy_ethtool_set_wol(ndev->phydev, wol);
416 if (!ret)
417 device_set_wakeup_enable(&ndev->dev, !!wol->wolopts);
418
419 return ret;
420}
421
422static void ave_ethtool_get_pauseparam(struct net_device *ndev,
423 struct ethtool_pauseparam *pause)
424{
425 struct ave_private *priv = netdev_priv(ndev);
426
427 pause->autoneg = priv->pause_auto;
428 pause->rx_pause = priv->pause_rx;
429 pause->tx_pause = priv->pause_tx;
430}
431
432static int ave_ethtool_set_pauseparam(struct net_device *ndev,
433 struct ethtool_pauseparam *pause)
434{
435 struct ave_private *priv = netdev_priv(ndev);
436 struct phy_device *phydev = ndev->phydev;
437
438 if (!phydev)
439 return -EINVAL;
440
441 priv->pause_auto = pause->autoneg;
442 priv->pause_rx = pause->rx_pause;
443 priv->pause_tx = pause->tx_pause;
444
445 phydev->advertising &= ~(ADVERTISED_Pause | ADVERTISED_Asym_Pause);
446 if (pause->rx_pause)
447 phydev->advertising |= ADVERTISED_Pause | ADVERTISED_Asym_Pause;
448 if (pause->tx_pause)
449 phydev->advertising ^= ADVERTISED_Asym_Pause;
450
451 if (pause->autoneg) {
452 if (netif_running(ndev))
453 phy_start_aneg(phydev);
454 }
455
456 return 0;
457}
458
459static const struct ethtool_ops ave_ethtool_ops = {
460 .get_link_ksettings = phy_ethtool_get_link_ksettings,
461 .set_link_ksettings = phy_ethtool_set_link_ksettings,
462 .get_drvinfo = ave_ethtool_get_drvinfo,
463 .nway_reset = phy_ethtool_nway_reset,
464 .get_link = ethtool_op_get_link,
465 .get_msglevel = ave_ethtool_get_msglevel,
466 .set_msglevel = ave_ethtool_set_msglevel,
467 .get_wol = ave_ethtool_get_wol,
468 .set_wol = ave_ethtool_set_wol,
469 .get_pauseparam = ave_ethtool_get_pauseparam,
470 .set_pauseparam = ave_ethtool_set_pauseparam,
471};
472
473static int ave_mdiobus_read(struct mii_bus *bus, int phyid, int regnum)
474{
475 struct net_device *ndev = bus->priv;
476 struct ave_private *priv;
477 u32 mdioctl, mdiosr;
478 int ret;
479
480 priv = netdev_priv(ndev);
481
482 /* write address */
483 writel((phyid << 8) | regnum, priv->base + AVE_MDIOAR);
484
485 /* read request */
486 mdioctl = readl(priv->base + AVE_MDIOCTR);
487 writel((mdioctl | AVE_MDIOCTR_RREQ) & ~AVE_MDIOCTR_WREQ,
488 priv->base + AVE_MDIOCTR);
489
490 ret = readl_poll_timeout(priv->base + AVE_MDIOSR, mdiosr,
491 !(mdiosr & AVE_MDIOSR_STS), 20, 2000);
492 if (ret) {
493 netdev_err(ndev, "failed to read (phy:%d reg:%x)\n",
494 phyid, regnum);
495 return ret;
496 }
497
498 return readl(priv->base + AVE_MDIORDR) & GENMASK(15, 0);
499}
500
501static int ave_mdiobus_write(struct mii_bus *bus, int phyid, int regnum,
502 u16 val)
503{
504 struct net_device *ndev = bus->priv;
505 struct ave_private *priv;
506 u32 mdioctl, mdiosr;
507 int ret;
508
509 priv = netdev_priv(ndev);
510
511 /* write address */
512 writel((phyid << 8) | regnum, priv->base + AVE_MDIOAR);
513
514 /* write data */
515 writel(val, priv->base + AVE_MDIOWDR);
516
517 /* write request */
518 mdioctl = readl(priv->base + AVE_MDIOCTR);
519 writel((mdioctl | AVE_MDIOCTR_WREQ) & ~AVE_MDIOCTR_RREQ,
520 priv->base + AVE_MDIOCTR);
521
522 ret = readl_poll_timeout(priv->base + AVE_MDIOSR, mdiosr,
523 !(mdiosr & AVE_MDIOSR_STS), 20, 2000);
524 if (ret)
525 netdev_err(ndev, "failed to write (phy:%d reg:%x)\n",
526 phyid, regnum);
527
528 return ret;
529}
530
531static int ave_dma_map(struct net_device *ndev, struct ave_desc *desc,
532 void *ptr, size_t len, enum dma_data_direction dir,
533 dma_addr_t *paddr)
534{
535 dma_addr_t map_addr;
536
537 map_addr = dma_map_single(ndev->dev.parent, ptr, len, dir);
538 if (unlikely(dma_mapping_error(ndev->dev.parent, map_addr)))
539 return -ENOMEM;
540
541 desc->skbs_dma = map_addr;
542 desc->skbs_dmalen = len;
543 *paddr = map_addr;
544
545 return 0;
546}
547
548static void ave_dma_unmap(struct net_device *ndev, struct ave_desc *desc,
549 enum dma_data_direction dir)
550{
551 if (!desc->skbs_dma)
552 return;
553
554 dma_unmap_single(ndev->dev.parent,
555 desc->skbs_dma, desc->skbs_dmalen, dir);
556 desc->skbs_dma = 0;
557}
558
559/* Prepare Rx descriptor and memory */
560static int ave_rxdesc_prepare(struct net_device *ndev, int entry)
561{
562 struct ave_private *priv = netdev_priv(ndev);
563 struct sk_buff *skb;
564 dma_addr_t paddr;
565 int ret;
566
567 skb = priv->rx.desc[entry].skbs;
568 if (!skb) {
569 skb = netdev_alloc_skb_ip_align(ndev,
570 AVE_MAX_ETHFRAME);
571 if (!skb) {
572 netdev_err(ndev, "can't allocate skb for Rx\n");
573 return -ENOMEM;
574 }
575 }
576
577 /* set disable to cmdsts */
578 ave_desc_write_cmdsts(ndev, AVE_DESCID_RX, entry,
579 AVE_STS_INTR | AVE_STS_OWN);
580
581 /* map Rx buffer
582 * Rx buffer set to the Rx descriptor has two restrictions:
583 * - Rx buffer address is 4 byte aligned.
584 * - Rx buffer begins with 2 byte headroom, and data will be put from
585 * (buffer + 2).
586 * To satisfy this, specify the address to put back the buffer
587 * pointer advanced by NET_IP_ALIGN by netdev_alloc_skb_ip_align(),
588 * and expand the map size by NET_IP_ALIGN.
589 */
590 ret = ave_dma_map(ndev, &priv->rx.desc[entry],
591 skb->data - NET_IP_ALIGN,
592 AVE_MAX_ETHFRAME + NET_IP_ALIGN,
593 DMA_FROM_DEVICE, &paddr);
594 if (ret) {
595 netdev_err(ndev, "can't map skb for Rx\n");
596 dev_kfree_skb_any(skb);
597 return ret;
598 }
599 priv->rx.desc[entry].skbs = skb;
600
601 /* set buffer pointer */
602 ave_desc_write_addr(ndev, AVE_DESCID_RX, entry, paddr);
603
604 /* set enable to cmdsts */
605 ave_desc_write_cmdsts(ndev, AVE_DESCID_RX, entry,
606 AVE_STS_INTR | AVE_MAX_ETHFRAME);
607
608 return ret;
609}
610
611/* Switch state of descriptor */
612static int ave_desc_switch(struct net_device *ndev, enum desc_state state)
613{
614 struct ave_private *priv = netdev_priv(ndev);
615 int ret = 0;
616 u32 val;
617
618 switch (state) {
619 case AVE_DESC_START:
620 writel(AVE_DESCC_TD | AVE_DESCC_RD0, priv->base + AVE_DESCC);
621 break;
622
623 case AVE_DESC_STOP:
624 writel(0, priv->base + AVE_DESCC);
625 if (readl_poll_timeout(priv->base + AVE_DESCC, val, !val,
626 150, 15000)) {
627 netdev_err(ndev, "can't stop descriptor\n");
628 ret = -EBUSY;
629 }
630 break;
631
632 case AVE_DESC_RX_SUSPEND:
633 val = readl(priv->base + AVE_DESCC);
634 val |= AVE_DESCC_RDSTP;
635 val &= ~AVE_DESCC_STATUS_MASK;
636 writel(val, priv->base + AVE_DESCC);
637 if (readl_poll_timeout(priv->base + AVE_DESCC, val,
638 val & (AVE_DESCC_RDSTP << 16),
639 150, 150000)) {
640 netdev_err(ndev, "can't suspend descriptor\n");
641 ret = -EBUSY;
642 }
643 break;
644
645 case AVE_DESC_RX_PERMIT:
646 val = readl(priv->base + AVE_DESCC);
647 val &= ~AVE_DESCC_RDSTP;
648 val &= ~AVE_DESCC_STATUS_MASK;
649 writel(val, priv->base + AVE_DESCC);
650 break;
651
652 default:
653 ret = -EINVAL;
654 break;
655 }
656
657 return ret;
658}
659
660static int ave_tx_complete(struct net_device *ndev)
661{
662 struct ave_private *priv = netdev_priv(ndev);
663 u32 proc_idx, done_idx, ndesc, cmdsts;
664 unsigned int nr_freebuf = 0;
665 unsigned int tx_packets = 0;
666 unsigned int tx_bytes = 0;
667
668 proc_idx = priv->tx.proc_idx;
669 done_idx = priv->tx.done_idx;
670 ndesc = priv->tx.ndesc;
671
672 /* free pre-stored skb from done_idx to proc_idx */
673 while (proc_idx != done_idx) {
674 cmdsts = ave_desc_read_cmdsts(ndev, AVE_DESCID_TX, done_idx);
675
676 /* do nothing if owner is HW (==1 for Tx) */
677 if (cmdsts & AVE_STS_OWN)
678 break;
679
680 /* check Tx status and updates statistics */
681 if (cmdsts & AVE_STS_OK) {
682 tx_bytes += cmdsts & AVE_STS_PKTLEN_TX_MASK;
683 /* success */
684 if (cmdsts & AVE_STS_LAST)
685 tx_packets++;
686 } else {
687 /* error */
688 if (cmdsts & AVE_STS_LAST) {
689 priv->stats_tx.errors++;
690 if (cmdsts & (AVE_STS_OWC | AVE_STS_EC))
691 priv->stats_tx.collisions++;
692 }
693 }
694
695 /* release skb */
696 if (priv->tx.desc[done_idx].skbs) {
697 ave_dma_unmap(ndev, &priv->tx.desc[done_idx],
698 DMA_TO_DEVICE);
699 dev_consume_skb_any(priv->tx.desc[done_idx].skbs);
700 priv->tx.desc[done_idx].skbs = NULL;
701 nr_freebuf++;
702 }
703 done_idx = (done_idx + 1) % ndesc;
704 }
705
706 priv->tx.done_idx = done_idx;
707
708 /* update stats */
709 u64_stats_update_begin(&priv->stats_tx.syncp);
710 priv->stats_tx.packets += tx_packets;
711 priv->stats_tx.bytes += tx_bytes;
712 u64_stats_update_end(&priv->stats_tx.syncp);
713
714 /* wake queue for freeing buffer */
715 if (unlikely(netif_queue_stopped(ndev)) && nr_freebuf)
716 netif_wake_queue(ndev);
717
718 return nr_freebuf;
719}
720
721static int ave_rx_receive(struct net_device *ndev, int num)
722{
723 struct ave_private *priv = netdev_priv(ndev);
724 unsigned int rx_packets = 0;
725 unsigned int rx_bytes = 0;
726 u32 proc_idx, done_idx;
727 struct sk_buff *skb;
728 unsigned int pktlen;
729 int restpkt, npkts;
730 u32 ndesc, cmdsts;
731
732 proc_idx = priv->rx.proc_idx;
733 done_idx = priv->rx.done_idx;
734 ndesc = priv->rx.ndesc;
735 restpkt = ((proc_idx + ndesc - 1) - done_idx) % ndesc;
736
737 for (npkts = 0; npkts < num; npkts++) {
738 /* we can't receive more packet, so fill desc quickly */
739 if (--restpkt < 0)
740 break;
741
742 cmdsts = ave_desc_read_cmdsts(ndev, AVE_DESCID_RX, proc_idx);
743
744 /* do nothing if owner is HW (==0 for Rx) */
745 if (!(cmdsts & AVE_STS_OWN))
746 break;
747
748 if (!(cmdsts & AVE_STS_OK)) {
749 priv->stats_rx.errors++;
750 proc_idx = (proc_idx + 1) % ndesc;
751 continue;
752 }
753
754 pktlen = cmdsts & AVE_STS_PKTLEN_RX_MASK;
755
756 /* get skbuff for rx */
757 skb = priv->rx.desc[proc_idx].skbs;
758 priv->rx.desc[proc_idx].skbs = NULL;
759
760 ave_dma_unmap(ndev, &priv->rx.desc[proc_idx], DMA_FROM_DEVICE);
761
762 skb->dev = ndev;
763 skb_put(skb, pktlen);
764 skb->protocol = eth_type_trans(skb, ndev);
765
766 if ((cmdsts & AVE_STS_CSSV) && (!(cmdsts & AVE_STS_CSER)))
767 skb->ip_summed = CHECKSUM_UNNECESSARY;
768
769 rx_packets++;
770 rx_bytes += pktlen;
771
772 netif_receive_skb(skb);
773
774 proc_idx = (proc_idx + 1) % ndesc;
775 }
776
777 priv->rx.proc_idx = proc_idx;
778
779 /* update stats */
780 u64_stats_update_begin(&priv->stats_rx.syncp);
781 priv->stats_rx.packets += rx_packets;
782 priv->stats_rx.bytes += rx_bytes;
783 u64_stats_update_end(&priv->stats_rx.syncp);
784
785 /* refill the Rx buffers */
786 while (proc_idx != done_idx) {
787 if (ave_rxdesc_prepare(ndev, done_idx))
788 break;
789 done_idx = (done_idx + 1) % ndesc;
790 }
791
792 priv->rx.done_idx = done_idx;
793
794 return npkts;
795}
796
797static int ave_napi_poll_rx(struct napi_struct *napi, int budget)
798{
799 struct ave_private *priv;
800 struct net_device *ndev;
801 int num;
802
803 priv = container_of(napi, struct ave_private, napi_rx);
804 ndev = priv->ndev;
805
806 num = ave_rx_receive(ndev, budget);
807 if (num < budget) {
808 napi_complete_done(napi, num);
809
810 /* enable Rx interrupt when NAPI finishes */
811 ave_irq_enable(ndev, AVE_GI_RXIINT);
812 }
813
814 return num;
815}
816
817static int ave_napi_poll_tx(struct napi_struct *napi, int budget)
818{
819 struct ave_private *priv;
820 struct net_device *ndev;
821 int num;
822
823 priv = container_of(napi, struct ave_private, napi_tx);
824 ndev = priv->ndev;
825
826 num = ave_tx_complete(ndev);
827 napi_complete(napi);
828
829 /* enable Tx interrupt when NAPI finishes */
830 ave_irq_enable(ndev, AVE_GI_TX);
831
832 return num;
833}
834
835static void ave_global_reset(struct net_device *ndev)
836{
837 struct ave_private *priv = netdev_priv(ndev);
838 u32 val;
839
840 /* set config register */
841 val = AVE_CFGR_FLE | AVE_CFGR_IPFCEN | AVE_CFGR_CHE;
842 if (!phy_interface_mode_is_rgmii(priv->phy_mode))
843 val |= AVE_CFGR_MII;
844 writel(val, priv->base + AVE_CFGR);
845
846 /* reset RMII register */
847 val = readl(priv->base + AVE_RSTCTRL);
848 val &= ~AVE_RSTCTRL_RMIIRST;
849 writel(val, priv->base + AVE_RSTCTRL);
850
851 /* assert reset */
852 writel(AVE_GRR_GRST | AVE_GRR_PHYRST, priv->base + AVE_GRR);
853 msleep(20);
854
855 /* 1st, negate PHY reset only */
856 writel(AVE_GRR_GRST, priv->base + AVE_GRR);
857 msleep(40);
858
859 /* negate reset */
860 writel(0, priv->base + AVE_GRR);
861 msleep(40);
862
863 /* negate RMII register */
864 val = readl(priv->base + AVE_RSTCTRL);
865 val |= AVE_RSTCTRL_RMIIRST;
866 writel(val, priv->base + AVE_RSTCTRL);
867
868 ave_irq_disable_all(ndev);
869}
870
871static void ave_rxfifo_reset(struct net_device *ndev)
872{
873 struct ave_private *priv = netdev_priv(ndev);
874 u32 rxcr_org;
875
876 /* save and disable MAC receive op */
877 rxcr_org = readl(priv->base + AVE_RXCR);
878 writel(rxcr_org & (~AVE_RXCR_RXEN), priv->base + AVE_RXCR);
879
880 /* suspend Rx descriptor */
881 ave_desc_switch(ndev, AVE_DESC_RX_SUSPEND);
882
883 /* receive all packets before descriptor starts */
884 ave_rx_receive(ndev, priv->rx.ndesc);
885
886 /* assert reset */
887 writel(AVE_GRR_RXFFR, priv->base + AVE_GRR);
888 usleep_range(40, 50);
889
890 /* negate reset */
891 writel(0, priv->base + AVE_GRR);
892 usleep_range(10, 20);
893
894 /* negate interrupt status */
895 writel(AVE_GI_RXOVF, priv->base + AVE_GISR);
896
897 /* permit descriptor */
898 ave_desc_switch(ndev, AVE_DESC_RX_PERMIT);
899
900 /* restore MAC reccieve op */
901 writel(rxcr_org, priv->base + AVE_RXCR);
902}
903
904static irqreturn_t ave_irq_handler(int irq, void *netdev)
905{
906 struct net_device *ndev = (struct net_device *)netdev;
907 struct ave_private *priv = netdev_priv(ndev);
908 u32 gimr_val, gisr_val;
909
910 gimr_val = ave_irq_disable_all(ndev);
911
912 /* get interrupt status */
913 gisr_val = readl(priv->base + AVE_GISR);
914
915 /* PHY */
916 if (gisr_val & AVE_GI_PHY)
917 writel(AVE_GI_PHY, priv->base + AVE_GISR);
918
919 /* check exceeding packet */
920 if (gisr_val & AVE_GI_RXERR) {
921 writel(AVE_GI_RXERR, priv->base + AVE_GISR);
922 netdev_err(ndev, "receive a packet exceeding frame buffer\n");
923 }
924
925 gisr_val &= gimr_val;
926 if (!gisr_val)
927 goto exit_isr;
928
929 /* RxFIFO overflow */
930 if (gisr_val & AVE_GI_RXOVF) {
931 priv->stats_rx.fifo_errors++;
932 ave_rxfifo_reset(ndev);
933 goto exit_isr;
934 }
935
936 /* Rx drop */
937 if (gisr_val & AVE_GI_RXDROP) {
938 priv->stats_rx.dropped++;
939 writel(AVE_GI_RXDROP, priv->base + AVE_GISR);
940 }
941
942 /* Rx interval */
943 if (gisr_val & AVE_GI_RXIINT) {
944 napi_schedule(&priv->napi_rx);
945 /* still force to disable Rx interrupt until NAPI finishes */
946 gimr_val &= ~AVE_GI_RXIINT;
947 }
948
949 /* Tx completed */
950 if (gisr_val & AVE_GI_TX) {
951 napi_schedule(&priv->napi_tx);
952 /* still force to disable Tx interrupt until NAPI finishes */
953 gimr_val &= ~AVE_GI_TX;
954 }
955
956exit_isr:
957 ave_irq_restore(ndev, gimr_val);
958
959 return IRQ_HANDLED;
960}
961
962static int ave_pfsel_start(struct net_device *ndev, unsigned int entry)
963{
964 struct ave_private *priv = netdev_priv(ndev);
965 u32 val;
966
967 if (WARN_ON(entry > AVE_PF_SIZE))
968 return -EINVAL;
969
970 val = readl(priv->base + AVE_PFEN);
971 writel(val | BIT(entry), priv->base + AVE_PFEN);
972
973 return 0;
974}
975
976static int ave_pfsel_stop(struct net_device *ndev, unsigned int entry)
977{
978 struct ave_private *priv = netdev_priv(ndev);
979 u32 val;
980
981 if (WARN_ON(entry > AVE_PF_SIZE))
982 return -EINVAL;
983
984 val = readl(priv->base + AVE_PFEN);
985 writel(val & ~BIT(entry), priv->base + AVE_PFEN);
986
987 return 0;
988}
989
990static int ave_pfsel_set_macaddr(struct net_device *ndev,
991 unsigned int entry,
992 const unsigned char *mac_addr,
993 unsigned int set_size)
994{
995 struct ave_private *priv = netdev_priv(ndev);
996
997 if (WARN_ON(entry > AVE_PF_SIZE))
998 return -EINVAL;
999 if (WARN_ON(set_size > 6))
1000 return -EINVAL;
1001
1002 ave_pfsel_stop(ndev, entry);
1003
1004 /* set MAC address for the filter */
1005 ave_hw_write_macaddr(ndev, mac_addr,
1006 AVE_PKTF(entry), AVE_PKTF(entry) + 4);
1007
1008 /* set byte mask */
1009 writel(GENMASK(31, set_size) & AVE_PFMBYTE_MASK0,
1010 priv->base + AVE_PFMBYTE(entry));
1011 writel(AVE_PFMBYTE_MASK1, priv->base + AVE_PFMBYTE(entry) + 4);
1012
1013 /* set bit mask filter */
1014 writel(AVE_PFMBIT_MASK, priv->base + AVE_PFMBIT(entry));
1015
1016 /* set selector to ring 0 */
1017 writel(0, priv->base + AVE_PFSEL(entry));
1018
1019 /* restart filter */
1020 ave_pfsel_start(ndev, entry);
1021
1022 return 0;
1023}
1024
1025static void ave_pfsel_set_promisc(struct net_device *ndev,
1026 unsigned int entry, u32 rxring)
1027{
1028 struct ave_private *priv = netdev_priv(ndev);
1029
1030 if (WARN_ON(entry > AVE_PF_SIZE))
1031 return;
1032
1033 ave_pfsel_stop(ndev, entry);
1034
1035 /* set byte mask */
1036 writel(AVE_PFMBYTE_MASK0, priv->base + AVE_PFMBYTE(entry));
1037 writel(AVE_PFMBYTE_MASK1, priv->base + AVE_PFMBYTE(entry) + 4);
1038
1039 /* set bit mask filter */
1040 writel(AVE_PFMBIT_MASK, priv->base + AVE_PFMBIT(entry));
1041
1042 /* set selector to rxring */
1043 writel(rxring, priv->base + AVE_PFSEL(entry));
1044
1045 ave_pfsel_start(ndev, entry);
1046}
1047
1048static void ave_pfsel_init(struct net_device *ndev)
1049{
1050 unsigned char bcast_mac[ETH_ALEN];
1051 int i;
1052
1053 eth_broadcast_addr(bcast_mac);
1054
1055 for (i = 0; i < AVE_PF_SIZE; i++)
1056 ave_pfsel_stop(ndev, i);
1057
1058 /* promiscious entry, select ring 0 */
1059 ave_pfsel_set_promisc(ndev, AVE_PFNUM_FILTER, 0);
1060
1061 /* unicast entry */
1062 ave_pfsel_set_macaddr(ndev, AVE_PFNUM_UNICAST, ndev->dev_addr, 6);
1063
1064 /* broadcast entry */
1065 ave_pfsel_set_macaddr(ndev, AVE_PFNUM_BROADCAST, bcast_mac, 6);
1066}
1067
1068static void ave_phy_adjust_link(struct net_device *ndev)
1069{
1070 struct ave_private *priv = netdev_priv(ndev);
1071 struct phy_device *phydev = ndev->phydev;
1072 u32 val, txcr, rxcr, rxcr_org;
1073 u16 rmt_adv = 0, lcl_adv = 0;
1074 u8 cap;
1075
1076 /* set RGMII speed */
1077 val = readl(priv->base + AVE_TXCR);
1078 val &= ~(AVE_TXCR_TXSPD_100 | AVE_TXCR_TXSPD_1G);
1079
1080 if (phy_interface_is_rgmii(phydev) && phydev->speed == SPEED_1000)
1081 val |= AVE_TXCR_TXSPD_1G;
1082 else if (phydev->speed == SPEED_100)
1083 val |= AVE_TXCR_TXSPD_100;
1084
1085 writel(val, priv->base + AVE_TXCR);
1086
1087 /* set RMII speed (100M/10M only) */
1088 if (!phy_interface_is_rgmii(phydev)) {
1089 val = readl(priv->base + AVE_LINKSEL);
1090 if (phydev->speed == SPEED_10)
1091 val &= ~AVE_LINKSEL_100M;
1092 else
1093 val |= AVE_LINKSEL_100M;
1094 writel(val, priv->base + AVE_LINKSEL);
1095 }
1096
1097 /* check current RXCR/TXCR */
1098 rxcr = readl(priv->base + AVE_RXCR);
1099 txcr = readl(priv->base + AVE_TXCR);
1100 rxcr_org = rxcr;
1101
1102 if (phydev->duplex) {
1103 rxcr |= AVE_RXCR_FDUPEN;
1104
1105 if (phydev->pause)
1106 rmt_adv |= LPA_PAUSE_CAP;
1107 if (phydev->asym_pause)
1108 rmt_adv |= LPA_PAUSE_ASYM;
1109 if (phydev->advertising & ADVERTISED_Pause)
1110 lcl_adv |= ADVERTISE_PAUSE_CAP;
1111 if (phydev->advertising & ADVERTISED_Asym_Pause)
1112 lcl_adv |= ADVERTISE_PAUSE_ASYM;
1113
1114 cap = mii_resolve_flowctrl_fdx(lcl_adv, rmt_adv);
1115 if (cap & FLOW_CTRL_TX)
1116 txcr |= AVE_TXCR_FLOCTR;
1117 else
1118 txcr &= ~AVE_TXCR_FLOCTR;
1119 if (cap & FLOW_CTRL_RX)
1120 rxcr |= AVE_RXCR_FLOCTR;
1121 else
1122 rxcr &= ~AVE_RXCR_FLOCTR;
1123 } else {
1124 rxcr &= ~AVE_RXCR_FDUPEN;
1125 rxcr &= ~AVE_RXCR_FLOCTR;
1126 txcr &= ~AVE_TXCR_FLOCTR;
1127 }
1128
1129 if (rxcr_org != rxcr) {
1130 /* disable Rx mac */
1131 writel(rxcr & ~AVE_RXCR_RXEN, priv->base + AVE_RXCR);
1132 /* change and enable TX/Rx mac */
1133 writel(txcr, priv->base + AVE_TXCR);
1134 writel(rxcr, priv->base + AVE_RXCR);
1135 }
1136
1137 phy_print_status(phydev);
1138}
1139
1140static void ave_macaddr_init(struct net_device *ndev)
1141{
1142 ave_hw_write_macaddr(ndev, ndev->dev_addr, AVE_RXMAC1R, AVE_RXMAC2R);
1143
1144 /* pfsel unicast entry */
1145 ave_pfsel_set_macaddr(ndev, AVE_PFNUM_UNICAST, ndev->dev_addr, 6);
1146}
1147
1148static int ave_init(struct net_device *ndev)
1149{
1150 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
1151 struct ave_private *priv = netdev_priv(ndev);
1152 struct device *dev = ndev->dev.parent;
1153 struct device_node *np = dev->of_node;
1154 struct device_node *mdio_np;
1155 struct phy_device *phydev;
1156 int ret;
1157
1158 /* enable clk because of hw access until ndo_open */
1159 ret = clk_prepare_enable(priv->clk);
1160 if (ret) {
1161 dev_err(dev, "can't enable clock\n");
1162 return ret;
1163 }
1164 ret = reset_control_deassert(priv->rst);
1165 if (ret) {
1166 dev_err(dev, "can't deassert reset\n");
1167 goto out_clk_disable;
1168 }
1169
1170 ave_global_reset(ndev);
1171
1172 mdio_np = of_get_child_by_name(np, "mdio");
1173 if (!mdio_np) {
1174 dev_err(dev, "mdio node not found\n");
1175 ret = -EINVAL;
1176 goto out_reset_assert;
1177 }
1178 ret = of_mdiobus_register(priv->mdio, mdio_np);
1179 of_node_put(mdio_np);
1180 if (ret) {
1181 dev_err(dev, "failed to register mdiobus\n");
1182 goto out_reset_assert;
1183 }
1184
1185 phydev = of_phy_get_and_connect(ndev, np, ave_phy_adjust_link);
1186 if (!phydev) {
1187 dev_err(dev, "could not attach to PHY\n");
1188 ret = -ENODEV;
1189 goto out_mdio_unregister;
1190 }
1191
1192 priv->phydev = phydev;
1193
1194 phy_ethtool_get_wol(phydev, &wol);
1195 device_set_wakeup_capable(&ndev->dev, !!wol.supported);
1196
1197 if (!phy_interface_is_rgmii(phydev)) {
1198 phydev->supported &= ~PHY_GBIT_FEATURES;
1199 phydev->supported |= PHY_BASIC_FEATURES;
1200 }
1201 phydev->supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
1202
1203 phy_attached_info(phydev);
1204
1205 return 0;
1206
1207out_mdio_unregister:
1208 mdiobus_unregister(priv->mdio);
1209out_reset_assert:
1210 reset_control_assert(priv->rst);
1211out_clk_disable:
1212 clk_disable_unprepare(priv->clk);
1213
1214 return ret;
1215}
1216
1217static void ave_uninit(struct net_device *ndev)
1218{
1219 struct ave_private *priv = netdev_priv(ndev);
1220
1221 phy_disconnect(priv->phydev);
1222 mdiobus_unregister(priv->mdio);
1223
1224 /* disable clk because of hw access after ndo_stop */
1225 reset_control_assert(priv->rst);
1226 clk_disable_unprepare(priv->clk);
1227}
1228
1229static int ave_open(struct net_device *ndev)
1230{
1231 struct ave_private *priv = netdev_priv(ndev);
1232 int entry;
1233 int ret;
1234 u32 val;
1235
1236 ret = request_irq(priv->irq, ave_irq_handler, IRQF_SHARED, ndev->name,
1237 ndev);
1238 if (ret)
1239 return ret;
1240
1241 priv->tx.desc = kcalloc(priv->tx.ndesc, sizeof(*priv->tx.desc),
1242 GFP_KERNEL);
1243 if (!priv->tx.desc) {
1244 ret = -ENOMEM;
1245 goto out_free_irq;
1246 }
1247
1248 priv->rx.desc = kcalloc(priv->rx.ndesc, sizeof(*priv->rx.desc),
1249 GFP_KERNEL);
1250 if (!priv->rx.desc) {
1251 kfree(priv->tx.desc);
1252 ret = -ENOMEM;
1253 goto out_free_irq;
1254 }
1255
1256 /* initialize Tx work and descriptor */
1257 priv->tx.proc_idx = 0;
1258 priv->tx.done_idx = 0;
1259 for (entry = 0; entry < priv->tx.ndesc; entry++) {
1260 ave_desc_write_cmdsts(ndev, AVE_DESCID_TX, entry, 0);
1261 ave_desc_write_addr(ndev, AVE_DESCID_TX, entry, 0);
1262 }
1263 writel(AVE_TXDC_ADDR_START |
1264 (((priv->tx.ndesc * priv->desc_size) << 16) & AVE_TXDC_SIZE),
1265 priv->base + AVE_TXDC);
1266
1267 /* initialize Rx work and descriptor */
1268 priv->rx.proc_idx = 0;
1269 priv->rx.done_idx = 0;
1270 for (entry = 0; entry < priv->rx.ndesc; entry++) {
1271 if (ave_rxdesc_prepare(ndev, entry))
1272 break;
1273 }
1274 writel(AVE_RXDC0_ADDR_START |
1275 (((priv->rx.ndesc * priv->desc_size) << 16) & AVE_RXDC0_SIZE),
1276 priv->base + AVE_RXDC0);
1277
1278 ave_desc_switch(ndev, AVE_DESC_START);
1279
1280 ave_pfsel_init(ndev);
1281 ave_macaddr_init(ndev);
1282
1283 /* set Rx configuration */
1284 /* full duplex, enable pause drop, enalbe flow control */
1285 val = AVE_RXCR_RXEN | AVE_RXCR_FDUPEN | AVE_RXCR_DRPEN |
1286 AVE_RXCR_FLOCTR | (AVE_MAX_ETHFRAME & AVE_RXCR_MPSIZ_MASK);
1287 writel(val, priv->base + AVE_RXCR);
1288
1289 /* set Tx configuration */
1290 /* enable flow control, disable loopback */
1291 writel(AVE_TXCR_FLOCTR, priv->base + AVE_TXCR);
1292
1293 /* enable timer, clear EN,INTM, and mask interval unit(BSCK) */
1294 val = readl(priv->base + AVE_IIRQC) & AVE_IIRQC_BSCK;
1295 val |= AVE_IIRQC_EN0 | (AVE_INTM_COUNT << 16);
1296 writel(val, priv->base + AVE_IIRQC);
1297
1298 val = AVE_GI_RXIINT | AVE_GI_RXOVF | AVE_GI_TX;
1299 ave_irq_restore(ndev, val);
1300
1301 napi_enable(&priv->napi_rx);
1302 napi_enable(&priv->napi_tx);
1303
1304 phy_start(ndev->phydev);
1305 phy_start_aneg(ndev->phydev);
1306 netif_start_queue(ndev);
1307
1308 return 0;
1309
1310out_free_irq:
1311 disable_irq(priv->irq);
1312 free_irq(priv->irq, ndev);
1313
1314 return ret;
1315}
1316
1317static int ave_stop(struct net_device *ndev)
1318{
1319 struct ave_private *priv = netdev_priv(ndev);
1320 int entry;
1321
1322 ave_irq_disable_all(ndev);
1323 disable_irq(priv->irq);
1324 free_irq(priv->irq, ndev);
1325
1326 netif_tx_disable(ndev);
1327 phy_stop(ndev->phydev);
1328 napi_disable(&priv->napi_tx);
1329 napi_disable(&priv->napi_rx);
1330
1331 ave_desc_switch(ndev, AVE_DESC_STOP);
1332
1333 /* free Tx buffer */
1334 for (entry = 0; entry < priv->tx.ndesc; entry++) {
1335 if (!priv->tx.desc[entry].skbs)
1336 continue;
1337
1338 ave_dma_unmap(ndev, &priv->tx.desc[entry], DMA_TO_DEVICE);
1339 dev_kfree_skb_any(priv->tx.desc[entry].skbs);
1340 priv->tx.desc[entry].skbs = NULL;
1341 }
1342 priv->tx.proc_idx = 0;
1343 priv->tx.done_idx = 0;
1344
1345 /* free Rx buffer */
1346 for (entry = 0; entry < priv->rx.ndesc; entry++) {
1347 if (!priv->rx.desc[entry].skbs)
1348 continue;
1349
1350 ave_dma_unmap(ndev, &priv->rx.desc[entry], DMA_FROM_DEVICE);
1351 dev_kfree_skb_any(priv->rx.desc[entry].skbs);
1352 priv->rx.desc[entry].skbs = NULL;
1353 }
1354 priv->rx.proc_idx = 0;
1355 priv->rx.done_idx = 0;
1356
1357 kfree(priv->tx.desc);
1358 kfree(priv->rx.desc);
1359
1360 return 0;
1361}
1362
1363static int ave_start_xmit(struct sk_buff *skb, struct net_device *ndev)
1364{
1365 struct ave_private *priv = netdev_priv(ndev);
1366 u32 proc_idx, done_idx, ndesc, cmdsts;
1367 int ret, freepkt;
1368 dma_addr_t paddr;
1369
1370 proc_idx = priv->tx.proc_idx;
1371 done_idx = priv->tx.done_idx;
1372 ndesc = priv->tx.ndesc;
1373 freepkt = ((done_idx + ndesc - 1) - proc_idx) % ndesc;
1374
1375 /* stop queue when not enough entry */
1376 if (unlikely(freepkt < 1)) {
1377 netif_stop_queue(ndev);
1378 return NETDEV_TX_BUSY;
1379 }
1380
1381 /* add padding for short packet */
1382 if (skb_put_padto(skb, ETH_ZLEN)) {
1383 priv->stats_tx.dropped++;
1384 return NETDEV_TX_OK;
1385 }
1386
1387 /* map Tx buffer
1388 * Tx buffer set to the Tx descriptor doesn't have any restriction.
1389 */
1390 ret = ave_dma_map(ndev, &priv->tx.desc[proc_idx],
1391 skb->data, skb->len, DMA_TO_DEVICE, &paddr);
1392 if (ret) {
1393 dev_kfree_skb_any(skb);
1394 priv->stats_tx.dropped++;
1395 return NETDEV_TX_OK;
1396 }
1397
1398 priv->tx.desc[proc_idx].skbs = skb;
1399
1400 ave_desc_write_addr(ndev, AVE_DESCID_TX, proc_idx, paddr);
1401
1402 cmdsts = AVE_STS_OWN | AVE_STS_1ST | AVE_STS_LAST |
1403 (skb->len & AVE_STS_PKTLEN_TX_MASK);
1404
1405 /* set interrupt per AVE_FORCE_TXINTCNT or when queue is stopped */
1406 if (!(proc_idx % AVE_FORCE_TXINTCNT) || netif_queue_stopped(ndev))
1407 cmdsts |= AVE_STS_INTR;
1408
1409 /* disable checksum calculation when skb doesn't calurate checksum */
1410 if (skb->ip_summed == CHECKSUM_NONE ||
1411 skb->ip_summed == CHECKSUM_UNNECESSARY)
1412 cmdsts |= AVE_STS_NOCSUM;
1413
1414 ave_desc_write_cmdsts(ndev, AVE_DESCID_TX, proc_idx, cmdsts);
1415
1416 priv->tx.proc_idx = (proc_idx + 1) % ndesc;
1417
1418 return NETDEV_TX_OK;
1419}
1420
1421static int ave_ioctl(struct net_device *ndev, struct ifreq *ifr, int cmd)
1422{
1423 return phy_mii_ioctl(ndev->phydev, ifr, cmd);
1424}
1425
1426static const u8 v4multi_macadr[] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 };
1427static const u8 v6multi_macadr[] = { 0x33, 0x00, 0x00, 0x00, 0x00, 0x00 };
1428
1429static void ave_set_rx_mode(struct net_device *ndev)
1430{
1431 struct ave_private *priv = netdev_priv(ndev);
1432 struct netdev_hw_addr *hw_adr;
1433 int count, mc_cnt;
1434 u32 val;
1435
1436 /* MAC addr filter enable for promiscious mode */
1437 mc_cnt = netdev_mc_count(ndev);
1438 val = readl(priv->base + AVE_RXCR);
1439 if (ndev->flags & IFF_PROMISC || !mc_cnt)
1440 val &= ~AVE_RXCR_AFEN;
1441 else
1442 val |= AVE_RXCR_AFEN;
1443 writel(val, priv->base + AVE_RXCR);
1444
1445 /* set all multicast address */
1446 if ((ndev->flags & IFF_ALLMULTI) || mc_cnt > AVE_PF_MULTICAST_SIZE) {
1447 ave_pfsel_set_macaddr(ndev, AVE_PFNUM_MULTICAST,
1448 v4multi_macadr, 1);
1449 ave_pfsel_set_macaddr(ndev, AVE_PFNUM_MULTICAST + 1,
1450 v6multi_macadr, 1);
1451 } else {
1452 /* stop all multicast filter */
1453 for (count = 0; count < AVE_PF_MULTICAST_SIZE; count++)
1454 ave_pfsel_stop(ndev, AVE_PFNUM_MULTICAST + count);
1455
1456 /* set multicast addresses */
1457 count = 0;
1458 netdev_for_each_mc_addr(hw_adr, ndev) {
1459 if (count == mc_cnt)
1460 break;
1461 ave_pfsel_set_macaddr(ndev, AVE_PFNUM_MULTICAST + count,
1462 hw_adr->addr, 6);
1463 count++;
1464 }
1465 }
1466}
1467
1468static void ave_get_stats64(struct net_device *ndev,
1469 struct rtnl_link_stats64 *stats)
1470{
1471 struct ave_private *priv = netdev_priv(ndev);
1472 unsigned int start;
1473
1474 do {
1475 start = u64_stats_fetch_begin_irq(&priv->stats_rx.syncp);
1476 stats->rx_packets = priv->stats_rx.packets;
1477 stats->rx_bytes = priv->stats_rx.bytes;
1478 } while (u64_stats_fetch_retry_irq(&priv->stats_rx.syncp, start));
1479
1480 do {
1481 start = u64_stats_fetch_begin_irq(&priv->stats_tx.syncp);
1482 stats->tx_packets = priv->stats_tx.packets;
1483 stats->tx_bytes = priv->stats_tx.bytes;
1484 } while (u64_stats_fetch_retry_irq(&priv->stats_tx.syncp, start));
1485
1486 stats->rx_errors = priv->stats_rx.errors;
1487 stats->tx_errors = priv->stats_tx.errors;
1488 stats->rx_dropped = priv->stats_rx.dropped;
1489 stats->tx_dropped = priv->stats_tx.dropped;
1490 stats->rx_fifo_errors = priv->stats_rx.fifo_errors;
1491 stats->collisions = priv->stats_tx.collisions;
1492}
1493
1494static int ave_set_mac_address(struct net_device *ndev, void *p)
1495{
1496 int ret = eth_mac_addr(ndev, p);
1497
1498 if (ret)
1499 return ret;
1500
1501 ave_macaddr_init(ndev);
1502
1503 return 0;
1504}
1505
1506static const struct net_device_ops ave_netdev_ops = {
1507 .ndo_init = ave_init,
1508 .ndo_uninit = ave_uninit,
1509 .ndo_open = ave_open,
1510 .ndo_stop = ave_stop,
1511 .ndo_start_xmit = ave_start_xmit,
1512 .ndo_do_ioctl = ave_ioctl,
1513 .ndo_set_rx_mode = ave_set_rx_mode,
1514 .ndo_get_stats64 = ave_get_stats64,
1515 .ndo_set_mac_address = ave_set_mac_address,
1516};
1517
1518static int ave_probe(struct platform_device *pdev)
1519{
1520 const struct ave_soc_data *data;
1521 struct device *dev = &pdev->dev;
1522 char buf[ETHTOOL_FWVERS_LEN];
1523 phy_interface_t phy_mode;
1524 struct ave_private *priv;
1525 struct net_device *ndev;
1526 struct device_node *np;
1527 struct resource *res;
1528 const void *mac_addr;
1529 void __iomem *base;
1530 u64 dma_mask;
1531 int irq, ret;
1532 u32 ave_id;
1533
1534 data = of_device_get_match_data(dev);
1535 if (WARN_ON(!data))
1536 return -EINVAL;
1537
1538 np = dev->of_node;
1539 phy_mode = of_get_phy_mode(np);
1540 if (phy_mode < 0) {
1541 dev_err(dev, "phy-mode not found\n");
1542 return -EINVAL;
1543 }
1544 if ((!phy_interface_mode_is_rgmii(phy_mode)) &&
1545 phy_mode != PHY_INTERFACE_MODE_RMII &&
1546 phy_mode != PHY_INTERFACE_MODE_MII) {
1547 dev_err(dev, "phy-mode is invalid\n");
1548 return -EINVAL;
1549 }
1550
1551 irq = platform_get_irq(pdev, 0);
1552 if (irq < 0) {
1553 dev_err(dev, "IRQ not found\n");
1554 return irq;
1555 }
1556
1557 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1558 base = devm_ioremap_resource(dev, res);
1559 if (IS_ERR(base))
1560 return PTR_ERR(base);
1561
1562 ndev = alloc_etherdev(sizeof(struct ave_private));
1563 if (!ndev) {
1564 dev_err(dev, "can't allocate ethernet device\n");
1565 return -ENOMEM;
1566 }
1567
1568 ndev->netdev_ops = &ave_netdev_ops;
1569 ndev->ethtool_ops = &ave_ethtool_ops;
1570 SET_NETDEV_DEV(ndev, dev);
1571
1572 ndev->features |= (NETIF_F_IP_CSUM | NETIF_F_RXCSUM);
1573 ndev->hw_features |= (NETIF_F_IP_CSUM | NETIF_F_RXCSUM);
1574
1575 ndev->max_mtu = AVE_MAX_ETHFRAME - (ETH_HLEN + ETH_FCS_LEN);
1576
1577 mac_addr = of_get_mac_address(np);
1578 if (mac_addr)
1579 ether_addr_copy(ndev->dev_addr, mac_addr);
1580
1581 /* if the mac address is invalid, use random mac address */
1582 if (!is_valid_ether_addr(ndev->dev_addr)) {
1583 eth_hw_addr_random(ndev);
1584 dev_warn(dev, "Using random MAC address: %pM\n",
1585 ndev->dev_addr);
1586 }
1587
1588 priv = netdev_priv(ndev);
1589 priv->base = base;
1590 priv->irq = irq;
1591 priv->ndev = ndev;
1592 priv->msg_enable = netif_msg_init(-1, AVE_DEFAULT_MSG_ENABLE);
1593 priv->phy_mode = phy_mode;
1594 priv->data = data;
1595
1596 if (IS_DESC_64BIT(priv)) {
1597 priv->desc_size = AVE_DESC_SIZE_64;
1598 priv->tx.daddr = AVE_TXDM_64;
1599 priv->rx.daddr = AVE_RXDM_64;
1600 dma_mask = DMA_BIT_MASK(64);
1601 } else {
1602 priv->desc_size = AVE_DESC_SIZE_32;
1603 priv->tx.daddr = AVE_TXDM_32;
1604 priv->rx.daddr = AVE_RXDM_32;
1605 dma_mask = DMA_BIT_MASK(32);
1606 }
1607 ret = dma_set_mask(dev, dma_mask);
1608 if (ret)
1609 goto out_free_netdev;
1610
1611 priv->tx.ndesc = AVE_NR_TXDESC;
1612 priv->rx.ndesc = AVE_NR_RXDESC;
1613
1614 u64_stats_init(&priv->stats_tx.syncp);
1615 u64_stats_init(&priv->stats_rx.syncp);
1616
1617 priv->clk = devm_clk_get(dev, NULL);
1618 if (IS_ERR(priv->clk)) {
1619 ret = PTR_ERR(priv->clk);
1620 goto out_free_netdev;
1621 }
1622
1623 priv->rst = devm_reset_control_get_optional_shared(dev, NULL);
1624 if (IS_ERR(priv->rst)) {
1625 ret = PTR_ERR(priv->rst);
1626 goto out_free_netdev;
1627 }
1628
1629 priv->mdio = devm_mdiobus_alloc(dev);
1630 if (!priv->mdio) {
1631 ret = -ENOMEM;
1632 goto out_free_netdev;
1633 }
1634 priv->mdio->priv = ndev;
1635 priv->mdio->parent = dev;
1636 priv->mdio->read = ave_mdiobus_read;
1637 priv->mdio->write = ave_mdiobus_write;
1638 priv->mdio->name = "uniphier-mdio";
1639 snprintf(priv->mdio->id, MII_BUS_ID_SIZE, "%s-%x",
1640 pdev->name, pdev->id);
1641
1642 /* Register as a NAPI supported driver */
1643 netif_napi_add(ndev, &priv->napi_rx, ave_napi_poll_rx, priv->rx.ndesc);
1644 netif_tx_napi_add(ndev, &priv->napi_tx, ave_napi_poll_tx,
1645 priv->tx.ndesc);
1646
1647 platform_set_drvdata(pdev, ndev);
1648
1649 ret = register_netdev(ndev);
1650 if (ret) {
1651 dev_err(dev, "failed to register netdevice\n");
1652 goto out_del_napi;
1653 }
1654
1655 /* get ID and version */
1656 ave_id = readl(priv->base + AVE_IDR);
1657 ave_hw_read_version(ndev, buf, sizeof(buf));
1658
1659 dev_info(dev, "Socionext %c%c%c%c Ethernet IP %s (irq=%d, phy=%s)\n",
1660 (ave_id >> 24) & 0xff, (ave_id >> 16) & 0xff,
1661 (ave_id >> 8) & 0xff, (ave_id >> 0) & 0xff,
1662 buf, priv->irq, phy_modes(phy_mode));
1663
1664 return 0;
1665
1666out_del_napi:
1667 netif_napi_del(&priv->napi_rx);
1668 netif_napi_del(&priv->napi_tx);
1669out_free_netdev:
1670 free_netdev(ndev);
1671
1672 return ret;
1673}
1674
1675static int ave_remove(struct platform_device *pdev)
1676{
1677 struct net_device *ndev = platform_get_drvdata(pdev);
1678 struct ave_private *priv = netdev_priv(ndev);
1679
1680 unregister_netdev(ndev);
1681 netif_napi_del(&priv->napi_rx);
1682 netif_napi_del(&priv->napi_tx);
1683 free_netdev(ndev);
1684
1685 return 0;
1686}
1687
1688static const struct ave_soc_data ave_pro4_data = {
1689 .is_desc_64bit = false,
1690};
1691
1692static const struct ave_soc_data ave_pxs2_data = {
1693 .is_desc_64bit = false,
1694};
1695
1696static const struct ave_soc_data ave_ld11_data = {
1697 .is_desc_64bit = false,
1698};
1699
1700static const struct ave_soc_data ave_ld20_data = {
1701 .is_desc_64bit = true,
1702};
1703
1704static const struct of_device_id of_ave_match[] = {
1705 {
1706 .compatible = "socionext,uniphier-pro4-ave4",
1707 .data = &ave_pro4_data,
1708 },
1709 {
1710 .compatible = "socionext,uniphier-pxs2-ave4",
1711 .data = &ave_pxs2_data,
1712 },
1713 {
1714 .compatible = "socionext,uniphier-ld11-ave4",
1715 .data = &ave_ld11_data,
1716 },
1717 {
1718 .compatible = "socionext,uniphier-ld20-ave4",
1719 .data = &ave_ld20_data,
1720 },
1721 { /* Sentinel */ }
1722};
1723MODULE_DEVICE_TABLE(of, of_ave_match);
1724
1725static struct platform_driver ave_driver = {
1726 .probe = ave_probe,
1727 .remove = ave_remove,
1728 .driver = {
1729 .name = "ave",
1730 .of_match_table = of_ave_match,
1731 },
1732};
1733module_platform_driver(ave_driver);
1734
1735MODULE_DESCRIPTION("Socionext UniPhier AVE ethernet driver");
1736MODULE_LICENSE("GPL v2");
generated by cgit v1.2.2 (git 2.25.0) at 2025-12-26 13:51:45 -0500