net: phy: motorcomm: Optimize phy speed mask to be compatible to YT8821
[J-u-boot.git] / drivers / net / sun8i_emac.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * (C) Copyright 2016
4  * Author: Amit Singh Tomar, amittomer25@gmail.com
5  *
6  * Ethernet driver for H3/A64/A83T based SoC's
7  *
8  * It is derived from the work done by
9  * LABBE Corentin & Chen-Yu Tsai for Linux, THANKS!
10  *
11 */
12
13 #include <cpu_func.h>
14 #include <log.h>
15 #include <asm/cache.h>
16 #include <asm/global_data.h>
17 #include <asm/gpio.h>
18 #include <asm/io.h>
19 #include <clk.h>
20 #include <dm.h>
21 #include <fdt_support.h>
22 #include <dm/device_compat.h>
23 #include <linux/bitops.h>
24 #include <linux/delay.h>
25 #include <linux/err.h>
26 #include <malloc.h>
27 #include <miiphy.h>
28 #include <net.h>
29 #include <reset.h>
30 #include <wait_bit.h>
31 #include <power/regulator.h>
32
33 #define MDIO_CMD_MII_BUSY               BIT(0)
34 #define MDIO_CMD_MII_WRITE              BIT(1)
35
36 #define MDIO_CMD_MII_PHY_REG_ADDR_MASK  0x000001f0
37 #define MDIO_CMD_MII_PHY_REG_ADDR_SHIFT 4
38 #define MDIO_CMD_MII_PHY_ADDR_MASK      0x0001f000
39 #define MDIO_CMD_MII_PHY_ADDR_SHIFT     12
40 #define MDIO_CMD_MII_CLK_CSR_DIV_16     0x0
41 #define MDIO_CMD_MII_CLK_CSR_DIV_32     0x1
42 #define MDIO_CMD_MII_CLK_CSR_DIV_64     0x2
43 #define MDIO_CMD_MII_CLK_CSR_DIV_128    0x3
44 #define MDIO_CMD_MII_CLK_CSR_SHIFT      20
45
46 #define CFG_TX_DESCR_NUM        32
47 #define CFG_RX_DESCR_NUM        32
48 #define CFG_ETH_BUFSIZE 2048 /* Note must be dma aligned */
49
50 /*
51  * The datasheet says that each descriptor can transfers up to 4096 bytes
52  * But later, the register documentation reduces that value to 2048,
53  * using 2048 cause strange behaviours and even BSP driver use 2047
54  */
55 #define CFG_ETH_RXSIZE  2044 /* Note must fit in ETH_BUFSIZE */
56
57 #define TX_TOTAL_BUFSIZE        (CFG_ETH_BUFSIZE * CFG_TX_DESCR_NUM)
58 #define RX_TOTAL_BUFSIZE        (CFG_ETH_BUFSIZE * CFG_RX_DESCR_NUM)
59
60 #define H3_EPHY_DEFAULT_VALUE   0x58000
61 #define H3_EPHY_DEFAULT_MASK    GENMASK(31, 15)
62 #define H3_EPHY_ADDR_SHIFT      20
63 #define REG_PHY_ADDR_MASK       GENMASK(4, 0)
64 #define H3_EPHY_LED_POL         BIT(17) /* 1: active low, 0: active high */
65 #define H3_EPHY_SHUTDOWN        BIT(16) /* 1: shutdown, 0: power up */
66 #define H3_EPHY_SELECT          BIT(15) /* 1: internal PHY, 0: external PHY */
67
68 #define SC_RMII_EN              BIT(13)
69 #define SC_EPIT                 BIT(2) /* 1: RGMII, 0: MII */
70 #define SC_ETCS_MASK            GENMASK(1, 0)
71 #define SC_ETCS_EXT_GMII        0x1
72 #define SC_ETCS_INT_GMII        0x2
73 #define SC_ETXDC_MASK           GENMASK(12, 10)
74 #define SC_ETXDC_OFFSET         10
75 #define SC_ERXDC_MASK           GENMASK(9, 5)
76 #define SC_ERXDC_OFFSET         5
77
78 #define CFG_MDIO_TIMEOUT        (3 * CONFIG_SYS_HZ)
79
80 #define AHB_GATE_OFFSET_EPHY    0
81
82 /* H3/A64 EMAC Register's offset */
83 #define EMAC_CTL0               0x00
84 #define EMAC_CTL0_FULL_DUPLEX           BIT(0)
85 #define EMAC_CTL0_SPEED_MASK            GENMASK(3, 2)
86 #define EMAC_CTL0_SPEED_10              (0x2 << 2)
87 #define EMAC_CTL0_SPEED_100             (0x3 << 2)
88 #define EMAC_CTL0_SPEED_1000            (0x0 << 2)
89 #define EMAC_CTL1               0x04
90 #define EMAC_CTL1_SOFT_RST              BIT(0)
91 #define EMAC_CTL1_BURST_LEN_SHIFT       24
92 #define EMAC_INT_STA            0x08
93 #define EMAC_INT_EN             0x0c
94 #define EMAC_TX_CTL0            0x10
95 #define EMAC_TX_CTL0_TX_EN              BIT(31)
96 #define EMAC_TX_CTL1            0x14
97 #define EMAC_TX_CTL1_TX_MD              BIT(1)
98 #define EMAC_TX_CTL1_TX_DMA_EN          BIT(30)
99 #define EMAC_TX_CTL1_TX_DMA_START       BIT(31)
100 #define EMAC_TX_FLOW_CTL        0x1c
101 #define EMAC_TX_DMA_DESC        0x20
102 #define EMAC_RX_CTL0            0x24
103 #define EMAC_RX_CTL0_RX_EN              BIT(31)
104 #define EMAC_RX_CTL1            0x28
105 #define EMAC_RX_CTL1_RX_MD              BIT(1)
106 #define EMAC_RX_CTL1_RX_RUNT_FRM        BIT(2)
107 #define EMAC_RX_CTL1_RX_ERR_FRM         BIT(3)
108 #define EMAC_RX_CTL1_RX_DMA_EN          BIT(30)
109 #define EMAC_RX_CTL1_RX_DMA_START       BIT(31)
110 #define EMAC_RX_DMA_DESC        0x34
111 #define EMAC_MII_CMD            0x48
112 #define EMAC_MII_DATA           0x4c
113 #define EMAC_ADDR0_HIGH         0x50
114 #define EMAC_ADDR0_LOW          0x54
115 #define EMAC_TX_DMA_STA         0xb0
116 #define EMAC_TX_CUR_DESC        0xb4
117 #define EMAC_TX_CUR_BUF         0xb8
118 #define EMAC_RX_DMA_STA         0xc0
119 #define EMAC_RX_CUR_DESC        0xc4
120
121 #define EMAC_DESC_OWN_DMA       BIT(31)
122 #define EMAC_DESC_LAST_DESC     BIT(30)
123 #define EMAC_DESC_FIRST_DESC    BIT(29)
124 #define EMAC_DESC_CHAIN_SECOND  BIT(24)
125
126 #define EMAC_DESC_RX_ERROR_MASK 0x400068db
127
128 DECLARE_GLOBAL_DATA_PTR;
129
130 struct emac_variant {
131         uint                    syscon_offset;
132         bool                    soc_has_internal_phy;
133         bool                    support_rmii;
134 };
135
136 struct emac_dma_desc {
137         u32 status;
138         u32 ctl_size;
139         u32 buf_addr;
140         u32 next;
141 } __aligned(ARCH_DMA_MINALIGN);
142
143 struct emac_eth_dev {
144         struct emac_dma_desc rx_chain[CFG_TX_DESCR_NUM];
145         struct emac_dma_desc tx_chain[CFG_RX_DESCR_NUM];
146         char rxbuffer[RX_TOTAL_BUFSIZE] __aligned(ARCH_DMA_MINALIGN);
147         char txbuffer[TX_TOTAL_BUFSIZE] __aligned(ARCH_DMA_MINALIGN);
148
149         u32 interface;
150         u32 phyaddr;
151         u32 link;
152         u32 speed;
153         u32 duplex;
154         u32 phy_configured;
155         u32 tx_currdescnum;
156         u32 rx_currdescnum;
157         u32 addr;
158         u32 tx_slot;
159         bool use_internal_phy;
160
161         const struct emac_variant *variant;
162         void *mac_reg;
163         void *sysctl_reg;
164         struct phy_device *phydev;
165         struct mii_dev *bus;
166         struct clk tx_clk;
167         struct clk ephy_clk;
168         struct reset_ctl tx_rst;
169         struct reset_ctl ephy_rst;
170         struct gpio_desc reset_gpio;
171         struct udevice *phy_reg;
172 };
173
174 struct sun8i_eth_pdata {
175         struct eth_pdata eth_pdata;
176         u32 reset_delays[3];
177         int tx_delay_ps;
178         int rx_delay_ps;
179 };
180
181 static int sun8i_mdio_read(struct mii_dev *bus, int addr, int devad, int reg)
182 {
183         struct udevice *dev = bus->priv;
184         struct emac_eth_dev *priv = dev_get_priv(dev);
185         u32 mii_cmd;
186         int ret;
187
188         mii_cmd = (reg << MDIO_CMD_MII_PHY_REG_ADDR_SHIFT) &
189                 MDIO_CMD_MII_PHY_REG_ADDR_MASK;
190         mii_cmd |= (addr << MDIO_CMD_MII_PHY_ADDR_SHIFT) &
191                 MDIO_CMD_MII_PHY_ADDR_MASK;
192
193         /*
194          * The EMAC clock is either 200 or 300 MHz, so we need a divider
195          * of 128 to get the MDIO frequency below the required 2.5 MHz.
196          */
197         if (!priv->use_internal_phy)
198                 mii_cmd |= MDIO_CMD_MII_CLK_CSR_DIV_128 <<
199                            MDIO_CMD_MII_CLK_CSR_SHIFT;
200
201         mii_cmd |= MDIO_CMD_MII_BUSY;
202
203         writel(mii_cmd, priv->mac_reg + EMAC_MII_CMD);
204
205         ret = wait_for_bit_le32(priv->mac_reg + EMAC_MII_CMD,
206                                 MDIO_CMD_MII_BUSY, false,
207                                 CFG_MDIO_TIMEOUT, true);
208         if (ret < 0)
209                 return ret;
210
211         return readl(priv->mac_reg + EMAC_MII_DATA);
212 }
213
214 static int sun8i_mdio_write(struct mii_dev *bus, int addr, int devad, int reg,
215                             u16 val)
216 {
217         struct udevice *dev = bus->priv;
218         struct emac_eth_dev *priv = dev_get_priv(dev);
219         u32 mii_cmd;
220
221         mii_cmd = (reg << MDIO_CMD_MII_PHY_REG_ADDR_SHIFT) &
222                 MDIO_CMD_MII_PHY_REG_ADDR_MASK;
223         mii_cmd |= (addr << MDIO_CMD_MII_PHY_ADDR_SHIFT) &
224                 MDIO_CMD_MII_PHY_ADDR_MASK;
225
226         /*
227          * The EMAC clock is either 200 or 300 MHz, so we need a divider
228          * of 128 to get the MDIO frequency below the required 2.5 MHz.
229          */
230         if (!priv->use_internal_phy)
231                 mii_cmd |= MDIO_CMD_MII_CLK_CSR_DIV_128 <<
232                            MDIO_CMD_MII_CLK_CSR_SHIFT;
233
234         mii_cmd |= MDIO_CMD_MII_WRITE;
235         mii_cmd |= MDIO_CMD_MII_BUSY;
236
237         writel(val, priv->mac_reg + EMAC_MII_DATA);
238         writel(mii_cmd, priv->mac_reg + EMAC_MII_CMD);
239
240         return wait_for_bit_le32(priv->mac_reg + EMAC_MII_CMD,
241                                  MDIO_CMD_MII_BUSY, false,
242                                  CFG_MDIO_TIMEOUT, true);
243 }
244
245 static int sun8i_eth_write_hwaddr(struct udevice *dev)
246 {
247         struct emac_eth_dev *priv = dev_get_priv(dev);
248         struct eth_pdata *pdata = dev_get_plat(dev);
249         uchar *mac_id = pdata->enetaddr;
250         u32 macid_lo, macid_hi;
251
252         macid_lo = mac_id[0] + (mac_id[1] << 8) + (mac_id[2] << 16) +
253                 (mac_id[3] << 24);
254         macid_hi = mac_id[4] + (mac_id[5] << 8);
255
256         writel(macid_hi, priv->mac_reg + EMAC_ADDR0_HIGH);
257         writel(macid_lo, priv->mac_reg + EMAC_ADDR0_LOW);
258
259         return 0;
260 }
261
262 static void sun8i_adjust_link(struct emac_eth_dev *priv,
263                               struct phy_device *phydev)
264 {
265         u32 v;
266
267         v = readl(priv->mac_reg + EMAC_CTL0);
268
269         if (phydev->duplex)
270                 v |= EMAC_CTL0_FULL_DUPLEX;
271         else
272                 v &= ~EMAC_CTL0_FULL_DUPLEX;
273
274         v &= ~EMAC_CTL0_SPEED_MASK;
275
276         switch (phydev->speed) {
277         case 1000:
278                 v |= EMAC_CTL0_SPEED_1000;
279                 break;
280         case 100:
281                 v |= EMAC_CTL0_SPEED_100;
282                 break;
283         case 10:
284                 v |= EMAC_CTL0_SPEED_10;
285                 break;
286         }
287         writel(v, priv->mac_reg + EMAC_CTL0);
288 }
289
290 static u32 sun8i_emac_set_syscon_ephy(struct emac_eth_dev *priv, u32 reg)
291 {
292         if (priv->use_internal_phy) {
293                 /* H3 based SoC's that has an Internal 100MBit PHY
294                  * needs to be configured and powered up before use
295                 */
296                 reg &= ~H3_EPHY_DEFAULT_MASK;
297                 reg |=  H3_EPHY_DEFAULT_VALUE;
298                 reg |= priv->phyaddr << H3_EPHY_ADDR_SHIFT;
299                 reg &= ~H3_EPHY_SHUTDOWN;
300                 return reg | H3_EPHY_SELECT;
301         }
302
303         /* This is to select External Gigabit PHY on those boards with
304          * an internal PHY. Does not hurt on other SoCs. Linux does
305          * it as well.
306          */
307         return reg & ~H3_EPHY_SELECT;
308 }
309
310 static int sun8i_emac_set_syscon(struct sun8i_eth_pdata *pdata,
311                                  struct emac_eth_dev *priv)
312 {
313         u32 reg;
314
315         reg = readl(priv->sysctl_reg);
316
317         reg = sun8i_emac_set_syscon_ephy(priv, reg);
318
319         reg &= ~(SC_ETCS_MASK | SC_EPIT);
320         if (priv->variant->support_rmii)
321                 reg &= ~SC_RMII_EN;
322
323         switch (priv->interface) {
324         case PHY_INTERFACE_MODE_MII:
325                 /* default */
326                 break;
327         case PHY_INTERFACE_MODE_RGMII:
328         case PHY_INTERFACE_MODE_RGMII_ID:
329         case PHY_INTERFACE_MODE_RGMII_RXID:
330         case PHY_INTERFACE_MODE_RGMII_TXID:
331                 reg |= SC_EPIT | SC_ETCS_INT_GMII;
332                 break;
333         case PHY_INTERFACE_MODE_RMII:
334                 if (priv->variant->support_rmii) {
335                         reg |= SC_RMII_EN | SC_ETCS_EXT_GMII;
336                         break;
337                 }
338         default:
339                 debug("%s: Invalid PHY interface\n", __func__);
340                 return -EINVAL;
341         }
342
343         if (pdata->tx_delay_ps)
344                 reg |= ((pdata->tx_delay_ps / 100) << SC_ETXDC_OFFSET)
345                          & SC_ETXDC_MASK;
346
347         if (pdata->rx_delay_ps)
348                 reg |= ((pdata->rx_delay_ps / 100) << SC_ERXDC_OFFSET)
349                          & SC_ERXDC_MASK;
350
351         writel(reg, priv->sysctl_reg);
352
353         return 0;
354 }
355
356 static int sun8i_phy_init(struct emac_eth_dev *priv, void *dev)
357 {
358         struct phy_device *phydev;
359
360         phydev = phy_connect(priv->bus, priv->phyaddr, dev, priv->interface);
361         if (!phydev)
362                 return -ENODEV;
363
364         priv->phydev = phydev;
365         phy_config(priv->phydev);
366
367         return 0;
368 }
369
370 #define cache_clean_descriptor(desc)                                    \
371         flush_dcache_range((uintptr_t)(desc),                           \
372                            (uintptr_t)(desc) + sizeof(struct emac_dma_desc))
373
374 #define cache_inv_descriptor(desc)                                      \
375         invalidate_dcache_range((uintptr_t)(desc),                      \
376                                (uintptr_t)(desc) + sizeof(struct emac_dma_desc))
377
378 static void rx_descs_init(struct emac_eth_dev *priv)
379 {
380         struct emac_dma_desc *desc_table_p = &priv->rx_chain[0];
381         char *rxbuffs = &priv->rxbuffer[0];
382         struct emac_dma_desc *desc_p;
383         int i;
384
385         /*
386          * Make sure we don't have dirty cache lines around, which could
387          * be cleaned to DRAM *after* the MAC has already written data to it.
388          */
389         invalidate_dcache_range((uintptr_t)desc_table_p,
390                               (uintptr_t)desc_table_p + sizeof(priv->rx_chain));
391         invalidate_dcache_range((uintptr_t)rxbuffs,
392                                 (uintptr_t)rxbuffs + sizeof(priv->rxbuffer));
393
394         for (i = 0; i < CFG_RX_DESCR_NUM; i++) {
395                 desc_p = &desc_table_p[i];
396                 desc_p->buf_addr = (uintptr_t)&rxbuffs[i * CFG_ETH_BUFSIZE];
397                 desc_p->next = (uintptr_t)&desc_table_p[i + 1];
398                 desc_p->ctl_size = CFG_ETH_RXSIZE;
399                 desc_p->status = EMAC_DESC_OWN_DMA;
400         }
401
402         /* Correcting the last pointer of the chain */
403         desc_p->next = (uintptr_t)&desc_table_p[0];
404
405         flush_dcache_range((uintptr_t)priv->rx_chain,
406                            (uintptr_t)priv->rx_chain +
407                         sizeof(priv->rx_chain));
408
409         writel((uintptr_t)&desc_table_p[0], (priv->mac_reg + EMAC_RX_DMA_DESC));
410         priv->rx_currdescnum = 0;
411 }
412
413 static void tx_descs_init(struct emac_eth_dev *priv)
414 {
415         struct emac_dma_desc *desc_table_p = &priv->tx_chain[0];
416         char *txbuffs = &priv->txbuffer[0];
417         struct emac_dma_desc *desc_p;
418         int i;
419
420         for (i = 0; i < CFG_TX_DESCR_NUM; i++) {
421                 desc_p = &desc_table_p[i];
422                 desc_p->buf_addr = (uintptr_t)&txbuffs[i * CFG_ETH_BUFSIZE];
423                 desc_p->next = (uintptr_t)&desc_table_p[i + 1];
424                 desc_p->ctl_size = 0;
425                 desc_p->status = 0;
426         }
427
428         /* Correcting the last pointer of the chain */
429         desc_p->next =  (uintptr_t)&desc_table_p[0];
430
431         /* Flush the first TX buffer descriptor we will tell the MAC about. */
432         cache_clean_descriptor(desc_table_p);
433
434         writel((uintptr_t)&desc_table_p[0], priv->mac_reg + EMAC_TX_DMA_DESC);
435         priv->tx_currdescnum = 0;
436 }
437
438 static int sun8i_emac_eth_start(struct udevice *dev)
439 {
440         struct emac_eth_dev *priv = dev_get_priv(dev);
441         int ret;
442
443         /* Soft reset MAC */
444         writel(EMAC_CTL1_SOFT_RST, priv->mac_reg + EMAC_CTL1);
445         ret = wait_for_bit_le32(priv->mac_reg + EMAC_CTL1,
446                                 EMAC_CTL1_SOFT_RST, false, 10, true);
447         if (ret) {
448                 printf("%s: Timeout\n", __func__);
449                 return ret;
450         }
451
452         /* Rewrite mac address after reset */
453         sun8i_eth_write_hwaddr(dev);
454
455         /* transmission starts after the full frame arrived in TX DMA FIFO */
456         setbits_le32(priv->mac_reg + EMAC_TX_CTL1, EMAC_TX_CTL1_TX_MD);
457
458         /*
459          * RX DMA reads data from RX DMA FIFO to host memory after a
460          * complete frame has been written to RX DMA FIFO
461          */
462         setbits_le32(priv->mac_reg + EMAC_RX_CTL1, EMAC_RX_CTL1_RX_MD);
463
464         /* DMA burst length */
465         writel(8 << EMAC_CTL1_BURST_LEN_SHIFT, priv->mac_reg + EMAC_CTL1);
466
467         /* Initialize rx/tx descriptors */
468         rx_descs_init(priv);
469         tx_descs_init(priv);
470
471         /* PHY Start Up */
472         ret = phy_startup(priv->phydev);
473         if (ret)
474                 return ret;
475
476         sun8i_adjust_link(priv, priv->phydev);
477
478         /* Start RX/TX DMA */
479         setbits_le32(priv->mac_reg + EMAC_RX_CTL1, EMAC_RX_CTL1_RX_DMA_EN |
480                      EMAC_RX_CTL1_RX_ERR_FRM | EMAC_RX_CTL1_RX_RUNT_FRM);
481         setbits_le32(priv->mac_reg + EMAC_TX_CTL1, EMAC_TX_CTL1_TX_DMA_EN);
482
483         /* Enable RX/TX */
484         setbits_le32(priv->mac_reg + EMAC_RX_CTL0, EMAC_RX_CTL0_RX_EN);
485         setbits_le32(priv->mac_reg + EMAC_TX_CTL0, EMAC_TX_CTL0_TX_EN);
486
487         return 0;
488 }
489
490 static int sun8i_emac_eth_recv(struct udevice *dev, int flags, uchar **packetp)
491 {
492         struct emac_eth_dev *priv = dev_get_priv(dev);
493         u32 status, desc_num = priv->rx_currdescnum;
494         struct emac_dma_desc *desc_p = &priv->rx_chain[desc_num];
495         uintptr_t data_start = (uintptr_t)desc_p->buf_addr;
496         int length;
497
498         /* Invalidate entire buffer descriptor */
499         cache_inv_descriptor(desc_p);
500
501         status = desc_p->status;
502
503         /* Check for DMA own bit */
504         if (status & EMAC_DESC_OWN_DMA)
505                 return -EAGAIN;
506
507         length = (status >> 16) & 0x3fff;
508
509         /* make sure we read from DRAM, not our cache */
510         invalidate_dcache_range(data_start,
511                                 data_start + roundup(length, ARCH_DMA_MINALIGN));
512
513         if (status & EMAC_DESC_RX_ERROR_MASK) {
514                 debug("RX: packet error: 0x%x\n",
515                       status & EMAC_DESC_RX_ERROR_MASK);
516                 return 0;
517         }
518         if (length < 0x40) {
519                 debug("RX: Bad Packet (runt)\n");
520                 return 0;
521         }
522
523         if (length > CFG_ETH_RXSIZE) {
524                 debug("RX: Too large packet (%d bytes)\n", length);
525                 return 0;
526         }
527
528         *packetp = (uchar *)(ulong)desc_p->buf_addr;
529
530         return length;
531 }
532
533 static int sun8i_emac_eth_send(struct udevice *dev, void *packet, int length)
534 {
535         struct emac_eth_dev *priv = dev_get_priv(dev);
536         u32 desc_num = priv->tx_currdescnum;
537         struct emac_dma_desc *desc_p = &priv->tx_chain[desc_num];
538         uintptr_t data_start = (uintptr_t)desc_p->buf_addr;
539         uintptr_t data_end = data_start +
540                 roundup(length, ARCH_DMA_MINALIGN);
541
542         desc_p->ctl_size = length | EMAC_DESC_CHAIN_SECOND;
543
544         memcpy((void *)data_start, packet, length);
545
546         /* Flush data to be sent */
547         flush_dcache_range(data_start, data_end);
548
549         /* frame begin and end */
550         desc_p->ctl_size |= EMAC_DESC_LAST_DESC | EMAC_DESC_FIRST_DESC;
551         desc_p->status = EMAC_DESC_OWN_DMA;
552
553         /* make sure the MAC reads the actual data from DRAM */
554         cache_clean_descriptor(desc_p);
555
556         /* Move to next Descriptor and wrap around */
557         if (++desc_num >= CFG_TX_DESCR_NUM)
558                 desc_num = 0;
559         priv->tx_currdescnum = desc_num;
560
561         /* Start the DMA */
562         setbits_le32(priv->mac_reg + EMAC_TX_CTL1, EMAC_TX_CTL1_TX_DMA_START);
563
564         /*
565          * Since we copied the data above, we return here without waiting
566          * for the packet to be actually send out.
567          */
568
569         return 0;
570 }
571
572 static int sun8i_emac_board_setup(struct udevice *dev,
573                                   struct emac_eth_dev *priv)
574 {
575         int ret;
576
577         ret = clk_enable(&priv->tx_clk);
578         if (ret) {
579                 dev_err(dev, "failed to enable TX clock\n");
580                 return ret;
581         }
582
583         if (reset_valid(&priv->tx_rst)) {
584                 ret = reset_deassert(&priv->tx_rst);
585                 if (ret) {
586                         dev_err(dev, "failed to deassert TX reset\n");
587                         goto err_tx_clk;
588                 }
589         }
590
591         /* Only H3/H5 have clock controls for internal EPHY */
592         if (clk_valid(&priv->ephy_clk)) {
593                 ret = clk_enable(&priv->ephy_clk);
594                 if (ret) {
595                         dev_err(dev, "failed to enable EPHY TX clock\n");
596                         return ret;
597                 }
598         }
599
600         if (reset_valid(&priv->ephy_rst)) {
601                 ret = reset_deassert(&priv->ephy_rst);
602                 if (ret) {
603                         dev_err(dev, "failed to deassert EPHY TX clock\n");
604                         return ret;
605                 }
606         }
607
608         return 0;
609
610 err_tx_clk:
611         clk_disable(&priv->tx_clk);
612         return ret;
613 }
614
615 static int sun8i_mdio_reset(struct mii_dev *bus)
616 {
617         struct udevice *dev = bus->priv;
618         struct emac_eth_dev *priv = dev_get_priv(dev);
619         struct sun8i_eth_pdata *pdata = dev_get_plat(dev);
620         int ret;
621
622         if (!dm_gpio_is_valid(&priv->reset_gpio))
623                 return 0;
624
625         /* reset the phy */
626         ret = dm_gpio_set_value(&priv->reset_gpio, 0);
627         if (ret)
628                 return ret;
629
630         udelay(pdata->reset_delays[0]);
631
632         ret = dm_gpio_set_value(&priv->reset_gpio, 1);
633         if (ret)
634                 return ret;
635
636         udelay(pdata->reset_delays[1]);
637
638         ret = dm_gpio_set_value(&priv->reset_gpio, 0);
639         if (ret)
640                 return ret;
641
642         udelay(pdata->reset_delays[2]);
643
644         return 0;
645 }
646
647 static int sun8i_mdio_init(const char *name, struct udevice *priv)
648 {
649         struct mii_dev *bus = mdio_alloc();
650
651         if (!bus) {
652                 debug("Failed to allocate MDIO bus\n");
653                 return -ENOMEM;
654         }
655
656         bus->read = sun8i_mdio_read;
657         bus->write = sun8i_mdio_write;
658         snprintf(bus->name, sizeof(bus->name), name);
659         bus->priv = (void *)priv;
660         bus->reset = sun8i_mdio_reset;
661
662         return  mdio_register(bus);
663 }
664
665 static int sun8i_eth_free_pkt(struct udevice *dev, uchar *packet,
666                               int length)
667 {
668         struct emac_eth_dev *priv = dev_get_priv(dev);
669         u32 desc_num = priv->rx_currdescnum;
670         struct emac_dma_desc *desc_p = &priv->rx_chain[desc_num];
671
672         /* give the current descriptor back to the MAC */
673         desc_p->status |= EMAC_DESC_OWN_DMA;
674
675         /* Flush Status field of descriptor */
676         cache_clean_descriptor(desc_p);
677
678         /* Move to next desc and wrap-around condition. */
679         if (++desc_num >= CFG_RX_DESCR_NUM)
680                 desc_num = 0;
681         priv->rx_currdescnum = desc_num;
682
683         return 0;
684 }
685
686 static void sun8i_emac_eth_stop(struct udevice *dev)
687 {
688         struct emac_eth_dev *priv = dev_get_priv(dev);
689
690         /* Stop Rx/Tx transmitter */
691         clrbits_le32(priv->mac_reg + EMAC_RX_CTL0, EMAC_RX_CTL0_RX_EN);
692         clrbits_le32(priv->mac_reg + EMAC_TX_CTL0, EMAC_TX_CTL0_TX_EN);
693
694         /* Stop RX/TX DMA */
695         clrbits_le32(priv->mac_reg + EMAC_TX_CTL1, EMAC_TX_CTL1_TX_DMA_EN);
696         clrbits_le32(priv->mac_reg + EMAC_RX_CTL1, EMAC_RX_CTL1_RX_DMA_EN);
697
698         phy_shutdown(priv->phydev);
699 }
700
701 static int sun8i_emac_eth_probe(struct udevice *dev)
702 {
703         struct sun8i_eth_pdata *sun8i_pdata = dev_get_plat(dev);
704         struct eth_pdata *pdata = &sun8i_pdata->eth_pdata;
705         struct emac_eth_dev *priv = dev_get_priv(dev);
706         int ret;
707
708         priv->mac_reg = (void *)pdata->iobase;
709
710         ret = sun8i_emac_board_setup(dev, priv);
711         if (ret)
712                 return ret;
713
714         sun8i_emac_set_syscon(sun8i_pdata, priv);
715
716         if (priv->phy_reg)
717                 regulator_set_enable(priv->phy_reg, true);
718
719         sun8i_mdio_init(dev->name, dev);
720         priv->bus = miiphy_get_dev_by_name(dev->name);
721
722         return sun8i_phy_init(priv, dev);
723 }
724
725 static const struct eth_ops sun8i_emac_eth_ops = {
726         .start                  = sun8i_emac_eth_start,
727         .write_hwaddr           = sun8i_eth_write_hwaddr,
728         .send                   = sun8i_emac_eth_send,
729         .recv                   = sun8i_emac_eth_recv,
730         .free_pkt               = sun8i_eth_free_pkt,
731         .stop                   = sun8i_emac_eth_stop,
732 };
733
734 static int sun8i_handle_internal_phy(struct udevice *dev, struct emac_eth_dev *priv)
735 {
736         struct ofnode_phandle_args phandle;
737         int ret;
738
739         ret = ofnode_parse_phandle_with_args(dev_ofnode(dev), "phy-handle",
740                                              NULL, 0, 0, &phandle);
741         if (ret)
742                 return ret;
743
744         /* If the PHY node is not a child of the internal MDIO bus, we are
745          * using some external PHY.
746          */
747         if (!ofnode_device_is_compatible(ofnode_get_parent(phandle.node),
748                                          "allwinner,sun8i-h3-mdio-internal"))
749                 return 0;
750
751         ret = clk_get_by_index_nodev(phandle.node, 0, &priv->ephy_clk);
752         if (ret) {
753                 dev_err(dev, "failed to get EPHY TX clock\n");
754                 return ret;
755         }
756
757         ret = reset_get_by_index_nodev(phandle.node, 0, &priv->ephy_rst);
758         if (ret) {
759                 dev_err(dev, "failed to get EPHY TX reset\n");
760                 return ret;
761         }
762
763         priv->use_internal_phy = true;
764
765         return 0;
766 }
767
768 static int sun8i_emac_eth_of_to_plat(struct udevice *dev)
769 {
770         struct sun8i_eth_pdata *sun8i_pdata = dev_get_plat(dev);
771         struct eth_pdata *pdata = &sun8i_pdata->eth_pdata;
772         struct emac_eth_dev *priv = dev_get_priv(dev);
773         phys_addr_t syscon_base;
774         const fdt32_t *reg;
775         int node = dev_of_offset(dev);
776         int offset = 0;
777         int reset_flags = GPIOD_IS_OUT;
778         int ret;
779
780         pdata->iobase = dev_read_addr(dev);
781         if (pdata->iobase == FDT_ADDR_T_NONE) {
782                 debug("%s: Cannot find MAC base address\n", __func__);
783                 return -EINVAL;
784         }
785
786         priv->variant = (const void *)dev_get_driver_data(dev);
787
788         if (!priv->variant) {
789                 printf("%s: Missing variant\n", __func__);
790                 return -EINVAL;
791         }
792
793         ret = clk_get_by_name(dev, "stmmaceth", &priv->tx_clk);
794         if (ret) {
795                 dev_err(dev, "failed to get TX clock\n");
796                 return ret;
797         }
798
799         ret = reset_get_by_name(dev, "stmmaceth", &priv->tx_rst);
800         if (ret && ret != -ENOENT) {
801                 dev_err(dev, "failed to get TX reset\n");
802                 return ret;
803         }
804
805         offset = fdtdec_lookup_phandle(gd->fdt_blob, node, "syscon");
806         if (offset < 0) {
807                 debug("%s: cannot find syscon node\n", __func__);
808                 return -EINVAL;
809         }
810
811         reg = fdt_getprop(gd->fdt_blob, offset, "reg", NULL);
812         if (!reg) {
813                 debug("%s: cannot find reg property in syscon node\n",
814                       __func__);
815                 return -EINVAL;
816         }
817
818         syscon_base = fdt_translate_address((void *)gd->fdt_blob, offset, reg);
819         if (syscon_base == FDT_ADDR_T_NONE) {
820                 debug("%s: Cannot find syscon base address\n", __func__);
821                 return -EINVAL;
822         }
823
824         priv->sysctl_reg = (void *)syscon_base + priv->variant->syscon_offset;
825
826         device_get_supply_regulator(dev, "phy-supply", &priv->phy_reg);
827
828         pdata->phy_interface = -1;
829         priv->phyaddr = -1;
830         priv->use_internal_phy = false;
831
832         offset = fdtdec_lookup_phandle(gd->fdt_blob, node, "phy-handle");
833         if (offset >= 0)
834                 priv->phyaddr = fdtdec_get_int(gd->fdt_blob, offset, "reg", -1);
835
836         pdata->phy_interface = dev_read_phy_mode(dev);
837         debug("phy interface %d\n", pdata->phy_interface);
838         if (pdata->phy_interface == PHY_INTERFACE_MODE_NA)
839                 return -EINVAL;
840
841         if (priv->variant->soc_has_internal_phy) {
842                 ret = sun8i_handle_internal_phy(dev, priv);
843                 if (ret)
844                         return ret;
845         }
846
847         priv->interface = pdata->phy_interface;
848
849         sun8i_pdata->tx_delay_ps = fdtdec_get_int(gd->fdt_blob, node,
850                                                   "allwinner,tx-delay-ps", 0);
851         if (sun8i_pdata->tx_delay_ps < 0 || sun8i_pdata->tx_delay_ps > 700)
852                 printf("%s: Invalid TX delay value %d\n", __func__,
853                        sun8i_pdata->tx_delay_ps);
854
855         sun8i_pdata->rx_delay_ps = fdtdec_get_int(gd->fdt_blob, node,
856                                                   "allwinner,rx-delay-ps", 0);
857         if (sun8i_pdata->rx_delay_ps < 0 || sun8i_pdata->rx_delay_ps > 3100)
858                 printf("%s: Invalid RX delay value %d\n", __func__,
859                        sun8i_pdata->rx_delay_ps);
860
861         if (fdtdec_get_bool(gd->fdt_blob, dev_of_offset(dev),
862                             "snps,reset-active-low"))
863                 reset_flags |= GPIOD_ACTIVE_LOW;
864
865         ret = gpio_request_by_name(dev, "snps,reset-gpio", 0,
866                                    &priv->reset_gpio, reset_flags);
867
868         if (ret == 0) {
869                 ret = fdtdec_get_int_array(gd->fdt_blob, dev_of_offset(dev),
870                                            "snps,reset-delays-us",
871                                            sun8i_pdata->reset_delays, 3);
872         } else if (ret == -ENOENT) {
873                 ret = 0;
874         }
875
876         return 0;
877 }
878
879 static const struct emac_variant emac_variant_a83t = {
880         .syscon_offset          = 0x30,
881 };
882
883 static const struct emac_variant emac_variant_h3 = {
884         .syscon_offset          = 0x30,
885         .soc_has_internal_phy   = true,
886         .support_rmii           = true,
887 };
888
889 static const struct emac_variant emac_variant_r40 = {
890         .syscon_offset          = 0x164,
891 };
892
893 static const struct emac_variant emac_variant_v3s = {
894         .syscon_offset          = 0x30,
895         .soc_has_internal_phy   = true,
896 };
897
898 static const struct emac_variant emac_variant_a64 = {
899         .syscon_offset          = 0x30,
900         .support_rmii           = true,
901 };
902
903 static const struct emac_variant emac_variant_h6 = {
904         .syscon_offset          = 0x30,
905         .support_rmii           = true,
906 };
907
908 static const struct udevice_id sun8i_emac_eth_ids[] = {
909         { .compatible = "allwinner,sun8i-a83t-emac",
910           .data = (ulong)&emac_variant_a83t },
911         { .compatible = "allwinner,sun8i-h3-emac",
912           .data = (ulong)&emac_variant_h3 },
913         { .compatible = "allwinner,sun8i-r40-gmac",
914           .data = (ulong)&emac_variant_r40 },
915         { .compatible = "allwinner,sun8i-v3s-emac",
916           .data = (ulong)&emac_variant_v3s },
917         { .compatible = "allwinner,sun50i-a64-emac",
918           .data = (ulong)&emac_variant_a64 },
919         { .compatible = "allwinner,sun50i-h6-emac",
920           .data = (ulong)&emac_variant_h6 },
921         { }
922 };
923
924 U_BOOT_DRIVER(eth_sun8i_emac) = {
925         .name   = "eth_sun8i_emac",
926         .id     = UCLASS_ETH,
927         .of_match = sun8i_emac_eth_ids,
928         .of_to_plat = sun8i_emac_eth_of_to_plat,
929         .probe  = sun8i_emac_eth_probe,
930         .ops    = &sun8i_emac_eth_ops,
931         .priv_auto      = sizeof(struct emac_eth_dev),
932         .plat_auto      = sizeof(struct sun8i_eth_pdata),
933         .flags = DM_FLAG_ALLOC_PRIV_DMA,
934 };
This page took 0.081599 seconds and 4 git commands to generate.