f1bcc92a81d42c9c08e811cf6a94214f7a4269c0
[oweals/u-boot.git] / drivers / net / designware.c
1 /*
2  * (C) Copyright 2010
3  * Vipin Kumar, ST Micoelectronics, vipin.kumar@st.com.
4  *
5  * SPDX-License-Identifier:     GPL-2.0+
6  */
7
8 /*
9  * Designware ethernet IP driver for U-Boot
10  */
11
12 #include <common.h>
13 #include <dm.h>
14 #include <errno.h>
15 #include <miiphy.h>
16 #include <malloc.h>
17 #include <pci.h>
18 #include <linux/compiler.h>
19 #include <linux/err.h>
20 #include <asm/io.h>
21 #include "designware.h"
22
23 DECLARE_GLOBAL_DATA_PTR;
24
25 static int dw_mdio_read(struct mii_dev *bus, int addr, int devad, int reg)
26 {
27         struct eth_mac_regs *mac_p = bus->priv;
28         ulong start;
29         u16 miiaddr;
30         int timeout = CONFIG_MDIO_TIMEOUT;
31
32         miiaddr = ((addr << MIIADDRSHIFT) & MII_ADDRMSK) |
33                   ((reg << MIIREGSHIFT) & MII_REGMSK);
34
35         writel(miiaddr | MII_CLKRANGE_150_250M | MII_BUSY, &mac_p->miiaddr);
36
37         start = get_timer(0);
38         while (get_timer(start) < timeout) {
39                 if (!(readl(&mac_p->miiaddr) & MII_BUSY))
40                         return readl(&mac_p->miidata);
41                 udelay(10);
42         };
43
44         return -ETIMEDOUT;
45 }
46
47 static int dw_mdio_write(struct mii_dev *bus, int addr, int devad, int reg,
48                         u16 val)
49 {
50         struct eth_mac_regs *mac_p = bus->priv;
51         ulong start;
52         u16 miiaddr;
53         int ret = -ETIMEDOUT, timeout = CONFIG_MDIO_TIMEOUT;
54
55         writel(val, &mac_p->miidata);
56         miiaddr = ((addr << MIIADDRSHIFT) & MII_ADDRMSK) |
57                   ((reg << MIIREGSHIFT) & MII_REGMSK) | MII_WRITE;
58
59         writel(miiaddr | MII_CLKRANGE_150_250M | MII_BUSY, &mac_p->miiaddr);
60
61         start = get_timer(0);
62         while (get_timer(start) < timeout) {
63                 if (!(readl(&mac_p->miiaddr) & MII_BUSY)) {
64                         ret = 0;
65                         break;
66                 }
67                 udelay(10);
68         };
69
70         return ret;
71 }
72
73 static int dw_mdio_init(const char *name, struct eth_mac_regs *mac_regs_p)
74 {
75         struct mii_dev *bus = mdio_alloc();
76
77         if (!bus) {
78                 printf("Failed to allocate MDIO bus\n");
79                 return -ENOMEM;
80         }
81
82         bus->read = dw_mdio_read;
83         bus->write = dw_mdio_write;
84         snprintf(bus->name, sizeof(bus->name), name);
85
86         bus->priv = (void *)mac_regs_p;
87
88         return mdio_register(bus);
89 }
90
91 static void tx_descs_init(struct dw_eth_dev *priv)
92 {
93         struct eth_dma_regs *dma_p = priv->dma_regs_p;
94         struct dmamacdescr *desc_table_p = &priv->tx_mac_descrtable[0];
95         char *txbuffs = &priv->txbuffs[0];
96         struct dmamacdescr *desc_p;
97         u32 idx;
98
99         for (idx = 0; idx < CONFIG_TX_DESCR_NUM; idx++) {
100                 desc_p = &desc_table_p[idx];
101                 desc_p->dmamac_addr = &txbuffs[idx * CONFIG_ETH_BUFSIZE];
102                 desc_p->dmamac_next = &desc_table_p[idx + 1];
103
104 #if defined(CONFIG_DW_ALTDESCRIPTOR)
105                 desc_p->txrx_status &= ~(DESC_TXSTS_TXINT | DESC_TXSTS_TXLAST |
106                                 DESC_TXSTS_TXFIRST | DESC_TXSTS_TXCRCDIS |
107                                 DESC_TXSTS_TXCHECKINSCTRL |
108                                 DESC_TXSTS_TXRINGEND | DESC_TXSTS_TXPADDIS);
109
110                 desc_p->txrx_status |= DESC_TXSTS_TXCHAIN;
111                 desc_p->dmamac_cntl = 0;
112                 desc_p->txrx_status &= ~(DESC_TXSTS_MSK | DESC_TXSTS_OWNBYDMA);
113 #else
114                 desc_p->dmamac_cntl = DESC_TXCTRL_TXCHAIN;
115                 desc_p->txrx_status = 0;
116 #endif
117         }
118
119         /* Correcting the last pointer of the chain */
120         desc_p->dmamac_next = &desc_table_p[0];
121
122         /* Flush all Tx buffer descriptors at once */
123         flush_dcache_range((unsigned int)priv->tx_mac_descrtable,
124                            (unsigned int)priv->tx_mac_descrtable +
125                            sizeof(priv->tx_mac_descrtable));
126
127         writel((ulong)&desc_table_p[0], &dma_p->txdesclistaddr);
128         priv->tx_currdescnum = 0;
129 }
130
131 static void rx_descs_init(struct dw_eth_dev *priv)
132 {
133         struct eth_dma_regs *dma_p = priv->dma_regs_p;
134         struct dmamacdescr *desc_table_p = &priv->rx_mac_descrtable[0];
135         char *rxbuffs = &priv->rxbuffs[0];
136         struct dmamacdescr *desc_p;
137         u32 idx;
138
139         /* Before passing buffers to GMAC we need to make sure zeros
140          * written there right after "priv" structure allocation were
141          * flushed into RAM.
142          * Otherwise there's a chance to get some of them flushed in RAM when
143          * GMAC is already pushing data to RAM via DMA. This way incoming from
144          * GMAC data will be corrupted. */
145         flush_dcache_range((unsigned int)rxbuffs, (unsigned int)rxbuffs +
146                            RX_TOTAL_BUFSIZE);
147
148         for (idx = 0; idx < CONFIG_RX_DESCR_NUM; idx++) {
149                 desc_p = &desc_table_p[idx];
150                 desc_p->dmamac_addr = &rxbuffs[idx * CONFIG_ETH_BUFSIZE];
151                 desc_p->dmamac_next = &desc_table_p[idx + 1];
152
153                 desc_p->dmamac_cntl =
154                         (MAC_MAX_FRAME_SZ & DESC_RXCTRL_SIZE1MASK) |
155                                       DESC_RXCTRL_RXCHAIN;
156
157                 desc_p->txrx_status = DESC_RXSTS_OWNBYDMA;
158         }
159
160         /* Correcting the last pointer of the chain */
161         desc_p->dmamac_next = &desc_table_p[0];
162
163         /* Flush all Rx buffer descriptors at once */
164         flush_dcache_range((unsigned int)priv->rx_mac_descrtable,
165                            (unsigned int)priv->rx_mac_descrtable +
166                            sizeof(priv->rx_mac_descrtable));
167
168         writel((ulong)&desc_table_p[0], &dma_p->rxdesclistaddr);
169         priv->rx_currdescnum = 0;
170 }
171
172 static int _dw_write_hwaddr(struct dw_eth_dev *priv, u8 *mac_id)
173 {
174         struct eth_mac_regs *mac_p = priv->mac_regs_p;
175         u32 macid_lo, macid_hi;
176
177         macid_lo = mac_id[0] + (mac_id[1] << 8) + (mac_id[2] << 16) +
178                    (mac_id[3] << 24);
179         macid_hi = mac_id[4] + (mac_id[5] << 8);
180
181         writel(macid_hi, &mac_p->macaddr0hi);
182         writel(macid_lo, &mac_p->macaddr0lo);
183
184         return 0;
185 }
186
187 static void dw_adjust_link(struct eth_mac_regs *mac_p,
188                            struct phy_device *phydev)
189 {
190         u32 conf = readl(&mac_p->conf) | FRAMEBURSTENABLE | DISABLERXOWN;
191
192         if (!phydev->link) {
193                 printf("%s: No link.\n", phydev->dev->name);
194                 return;
195         }
196
197         if (phydev->speed != 1000)
198                 conf |= MII_PORTSELECT;
199         else
200                 conf &= ~MII_PORTSELECT;
201
202         if (phydev->speed == 100)
203                 conf |= FES_100;
204
205         if (phydev->duplex)
206                 conf |= FULLDPLXMODE;
207
208         writel(conf, &mac_p->conf);
209
210         printf("Speed: %d, %s duplex%s\n", phydev->speed,
211                (phydev->duplex) ? "full" : "half",
212                (phydev->port == PORT_FIBRE) ? ", fiber mode" : "");
213 }
214
215 static void _dw_eth_halt(struct dw_eth_dev *priv)
216 {
217         struct eth_mac_regs *mac_p = priv->mac_regs_p;
218         struct eth_dma_regs *dma_p = priv->dma_regs_p;
219
220         writel(readl(&mac_p->conf) & ~(RXENABLE | TXENABLE), &mac_p->conf);
221         writel(readl(&dma_p->opmode) & ~(RXSTART | TXSTART), &dma_p->opmode);
222
223         phy_shutdown(priv->phydev);
224 }
225
226 static int _dw_eth_init(struct dw_eth_dev *priv, u8 *enetaddr)
227 {
228         struct eth_mac_regs *mac_p = priv->mac_regs_p;
229         struct eth_dma_regs *dma_p = priv->dma_regs_p;
230         unsigned int start;
231         int ret;
232
233         writel(readl(&dma_p->busmode) | DMAMAC_SRST, &dma_p->busmode);
234
235         start = get_timer(0);
236         while (readl(&dma_p->busmode) & DMAMAC_SRST) {
237                 if (get_timer(start) >= CONFIG_MACRESET_TIMEOUT) {
238                         printf("DMA reset timeout\n");
239                         return -ETIMEDOUT;
240                 }
241
242                 mdelay(100);
243         };
244
245         /*
246          * Soft reset above clears HW address registers.
247          * So we have to set it here once again.
248          */
249         _dw_write_hwaddr(priv, enetaddr);
250
251         rx_descs_init(priv);
252         tx_descs_init(priv);
253
254         writel(FIXEDBURST | PRIORXTX_41 | DMA_PBL, &dma_p->busmode);
255
256 #ifndef CONFIG_DW_MAC_FORCE_THRESHOLD_MODE
257         writel(readl(&dma_p->opmode) | FLUSHTXFIFO | STOREFORWARD,
258                &dma_p->opmode);
259 #else
260         writel(readl(&dma_p->opmode) | FLUSHTXFIFO,
261                &dma_p->opmode);
262 #endif
263
264         writel(readl(&dma_p->opmode) | RXSTART | TXSTART, &dma_p->opmode);
265
266 #ifdef CONFIG_DW_AXI_BURST_LEN
267         writel((CONFIG_DW_AXI_BURST_LEN & 0x1FF >> 1), &dma_p->axibus);
268 #endif
269
270         /* Start up the PHY */
271         ret = phy_startup(priv->phydev);
272         if (ret) {
273                 printf("Could not initialize PHY %s\n",
274                        priv->phydev->dev->name);
275                 return ret;
276         }
277
278         dw_adjust_link(mac_p, priv->phydev);
279
280         if (!priv->phydev->link)
281                 return -EIO;
282
283         writel(readl(&mac_p->conf) | RXENABLE | TXENABLE, &mac_p->conf);
284
285         return 0;
286 }
287
288 static int _dw_eth_send(struct dw_eth_dev *priv, void *packet, int length)
289 {
290         struct eth_dma_regs *dma_p = priv->dma_regs_p;
291         u32 desc_num = priv->tx_currdescnum;
292         struct dmamacdescr *desc_p = &priv->tx_mac_descrtable[desc_num];
293         uint32_t desc_start = (uint32_t)desc_p;
294         uint32_t desc_end = desc_start +
295                 roundup(sizeof(*desc_p), ARCH_DMA_MINALIGN);
296         uint32_t data_start = (uint32_t)desc_p->dmamac_addr;
297         uint32_t data_end = data_start +
298                 roundup(length, ARCH_DMA_MINALIGN);
299         /*
300          * Strictly we only need to invalidate the "txrx_status" field
301          * for the following check, but on some platforms we cannot
302          * invalidate only 4 bytes, so we flush the entire descriptor,
303          * which is 16 bytes in total. This is safe because the
304          * individual descriptors in the array are each aligned to
305          * ARCH_DMA_MINALIGN and padded appropriately.
306          */
307         invalidate_dcache_range(desc_start, desc_end);
308
309         /* Check if the descriptor is owned by CPU */
310         if (desc_p->txrx_status & DESC_TXSTS_OWNBYDMA) {
311                 printf("CPU not owner of tx frame\n");
312                 return -EPERM;
313         }
314
315         memcpy(desc_p->dmamac_addr, packet, length);
316
317         /* Flush data to be sent */
318         flush_dcache_range(data_start, data_end);
319
320 #if defined(CONFIG_DW_ALTDESCRIPTOR)
321         desc_p->txrx_status |= DESC_TXSTS_TXFIRST | DESC_TXSTS_TXLAST;
322         desc_p->dmamac_cntl |= (length << DESC_TXCTRL_SIZE1SHFT) &
323                                DESC_TXCTRL_SIZE1MASK;
324
325         desc_p->txrx_status &= ~(DESC_TXSTS_MSK);
326         desc_p->txrx_status |= DESC_TXSTS_OWNBYDMA;
327 #else
328         desc_p->dmamac_cntl |= ((length << DESC_TXCTRL_SIZE1SHFT) &
329                                DESC_TXCTRL_SIZE1MASK) | DESC_TXCTRL_TXLAST |
330                                DESC_TXCTRL_TXFIRST;
331
332         desc_p->txrx_status = DESC_TXSTS_OWNBYDMA;
333 #endif
334
335         /* Flush modified buffer descriptor */
336         flush_dcache_range(desc_start, desc_end);
337
338         /* Test the wrap-around condition. */
339         if (++desc_num >= CONFIG_TX_DESCR_NUM)
340                 desc_num = 0;
341
342         priv->tx_currdescnum = desc_num;
343
344         /* Start the transmission */
345         writel(POLL_DATA, &dma_p->txpolldemand);
346
347         return 0;
348 }
349
350 static int _dw_eth_recv(struct dw_eth_dev *priv, uchar **packetp)
351 {
352         u32 status, desc_num = priv->rx_currdescnum;
353         struct dmamacdescr *desc_p = &priv->rx_mac_descrtable[desc_num];
354         int length = -EAGAIN;
355         uint32_t desc_start = (uint32_t)desc_p;
356         uint32_t desc_end = desc_start +
357                 roundup(sizeof(*desc_p), ARCH_DMA_MINALIGN);
358         uint32_t data_start = (uint32_t)desc_p->dmamac_addr;
359         uint32_t data_end;
360
361         /* Invalidate entire buffer descriptor */
362         invalidate_dcache_range(desc_start, desc_end);
363
364         status = desc_p->txrx_status;
365
366         /* Check  if the owner is the CPU */
367         if (!(status & DESC_RXSTS_OWNBYDMA)) {
368
369                 length = (status & DESC_RXSTS_FRMLENMSK) >>
370                          DESC_RXSTS_FRMLENSHFT;
371
372                 /* Invalidate received data */
373                 data_end = data_start + roundup(length, ARCH_DMA_MINALIGN);
374                 invalidate_dcache_range(data_start, data_end);
375                 *packetp = desc_p->dmamac_addr;
376         }
377
378         return length;
379 }
380
381 static int _dw_free_pkt(struct dw_eth_dev *priv)
382 {
383         u32 desc_num = priv->rx_currdescnum;
384         struct dmamacdescr *desc_p = &priv->rx_mac_descrtable[desc_num];
385         uint32_t desc_start = (uint32_t)desc_p;
386         uint32_t desc_end = desc_start +
387                 roundup(sizeof(*desc_p), ARCH_DMA_MINALIGN);
388
389         /*
390          * Make the current descriptor valid again and go to
391          * the next one
392          */
393         desc_p->txrx_status |= DESC_RXSTS_OWNBYDMA;
394
395         /* Flush only status field - others weren't changed */
396         flush_dcache_range(desc_start, desc_end);
397
398         /* Test the wrap-around condition. */
399         if (++desc_num >= CONFIG_RX_DESCR_NUM)
400                 desc_num = 0;
401         priv->rx_currdescnum = desc_num;
402
403         return 0;
404 }
405
406 static int dw_phy_init(struct dw_eth_dev *priv, void *dev)
407 {
408         struct phy_device *phydev;
409         int mask = 0xffffffff, ret;
410
411 #ifdef CONFIG_PHY_ADDR
412         mask = 1 << CONFIG_PHY_ADDR;
413 #endif
414
415         phydev = phy_find_by_mask(priv->bus, mask, priv->interface);
416         if (!phydev)
417                 return -ENODEV;
418
419         phy_connect_dev(phydev, dev);
420
421         phydev->supported &= PHY_GBIT_FEATURES;
422         if (priv->max_speed) {
423                 ret = phy_set_supported(phydev, priv->max_speed);
424                 if (ret)
425                         return ret;
426         }
427         phydev->advertising = phydev->supported;
428
429         priv->phydev = phydev;
430         phy_config(phydev);
431
432         return 0;
433 }
434
435 #ifndef CONFIG_DM_ETH
436 static int dw_eth_init(struct eth_device *dev, bd_t *bis)
437 {
438         return _dw_eth_init(dev->priv, dev->enetaddr);
439 }
440
441 static int dw_eth_send(struct eth_device *dev, void *packet, int length)
442 {
443         return _dw_eth_send(dev->priv, packet, length);
444 }
445
446 static int dw_eth_recv(struct eth_device *dev)
447 {
448         uchar *packet;
449         int length;
450
451         length = _dw_eth_recv(dev->priv, &packet);
452         if (length == -EAGAIN)
453                 return 0;
454         net_process_received_packet(packet, length);
455
456         _dw_free_pkt(dev->priv);
457
458         return 0;
459 }
460
461 static void dw_eth_halt(struct eth_device *dev)
462 {
463         return _dw_eth_halt(dev->priv);
464 }
465
466 static int dw_write_hwaddr(struct eth_device *dev)
467 {
468         return _dw_write_hwaddr(dev->priv, dev->enetaddr);
469 }
470
471 int designware_initialize(ulong base_addr, u32 interface)
472 {
473         struct eth_device *dev;
474         struct dw_eth_dev *priv;
475
476         dev = (struct eth_device *) malloc(sizeof(struct eth_device));
477         if (!dev)
478                 return -ENOMEM;
479
480         /*
481          * Since the priv structure contains the descriptors which need a strict
482          * buswidth alignment, memalign is used to allocate memory
483          */
484         priv = (struct dw_eth_dev *) memalign(ARCH_DMA_MINALIGN,
485                                               sizeof(struct dw_eth_dev));
486         if (!priv) {
487                 free(dev);
488                 return -ENOMEM;
489         }
490
491         memset(dev, 0, sizeof(struct eth_device));
492         memset(priv, 0, sizeof(struct dw_eth_dev));
493
494         sprintf(dev->name, "dwmac.%lx", base_addr);
495         dev->iobase = (int)base_addr;
496         dev->priv = priv;
497
498         priv->dev = dev;
499         priv->mac_regs_p = (struct eth_mac_regs *)base_addr;
500         priv->dma_regs_p = (struct eth_dma_regs *)(base_addr +
501                         DW_DMA_BASE_OFFSET);
502
503         dev->init = dw_eth_init;
504         dev->send = dw_eth_send;
505         dev->recv = dw_eth_recv;
506         dev->halt = dw_eth_halt;
507         dev->write_hwaddr = dw_write_hwaddr;
508
509         eth_register(dev);
510
511         priv->interface = interface;
512
513         dw_mdio_init(dev->name, priv->mac_regs_p);
514         priv->bus = miiphy_get_dev_by_name(dev->name);
515
516         return dw_phy_init(priv, dev);
517 }
518 #endif
519
520 #ifdef CONFIG_DM_ETH
521 static int designware_eth_start(struct udevice *dev)
522 {
523         struct eth_pdata *pdata = dev_get_platdata(dev);
524
525         return _dw_eth_init(dev->priv, pdata->enetaddr);
526 }
527
528 static int designware_eth_send(struct udevice *dev, void *packet, int length)
529 {
530         struct dw_eth_dev *priv = dev_get_priv(dev);
531
532         return _dw_eth_send(priv, packet, length);
533 }
534
535 static int designware_eth_recv(struct udevice *dev, int flags, uchar **packetp)
536 {
537         struct dw_eth_dev *priv = dev_get_priv(dev);
538
539         return _dw_eth_recv(priv, packetp);
540 }
541
542 static int designware_eth_free_pkt(struct udevice *dev, uchar *packet,
543                                    int length)
544 {
545         struct dw_eth_dev *priv = dev_get_priv(dev);
546
547         return _dw_free_pkt(priv);
548 }
549
550 static void designware_eth_stop(struct udevice *dev)
551 {
552         struct dw_eth_dev *priv = dev_get_priv(dev);
553
554         return _dw_eth_halt(priv);
555 }
556
557 static int designware_eth_write_hwaddr(struct udevice *dev)
558 {
559         struct eth_pdata *pdata = dev_get_platdata(dev);
560         struct dw_eth_dev *priv = dev_get_priv(dev);
561
562         return _dw_write_hwaddr(priv, pdata->enetaddr);
563 }
564
565 static int designware_eth_bind(struct udevice *dev)
566 {
567 #ifdef CONFIG_DM_PCI
568         static int num_cards;
569         char name[20];
570
571         /* Create a unique device name for PCI type devices */
572         if (device_is_on_pci_bus(dev)) {
573                 sprintf(name, "eth_designware#%u", num_cards++);
574                 device_set_name(dev, name);
575         }
576 #endif
577
578         return 0;
579 }
580
581 static int designware_eth_probe(struct udevice *dev)
582 {
583         struct eth_pdata *pdata = dev_get_platdata(dev);
584         struct dw_eth_dev *priv = dev_get_priv(dev);
585         u32 iobase = pdata->iobase;
586         int ret;
587
588 #ifdef CONFIG_DM_PCI
589         /*
590          * If we are on PCI bus, either directly attached to a PCI root port,
591          * or via a PCI bridge, fill in platdata before we probe the hardware.
592          */
593         if (device_is_on_pci_bus(dev)) {
594                 pci_dev_t bdf = dm_pci_get_bdf(dev);
595
596                 dm_pci_read_config32(dev, PCI_BASE_ADDRESS_0, &iobase);
597                 iobase &= PCI_BASE_ADDRESS_MEM_MASK;
598                 iobase = pci_mem_to_phys(bdf, iobase);
599
600                 pdata->iobase = iobase;
601                 pdata->phy_interface = PHY_INTERFACE_MODE_RMII;
602         }
603 #endif
604
605         debug("%s, iobase=%x, priv=%p\n", __func__, iobase, priv);
606         priv->mac_regs_p = (struct eth_mac_regs *)iobase;
607         priv->dma_regs_p = (struct eth_dma_regs *)(iobase + DW_DMA_BASE_OFFSET);
608         priv->interface = pdata->phy_interface;
609         priv->max_speed = pdata->max_speed;
610
611         dw_mdio_init(dev->name, priv->mac_regs_p);
612         priv->bus = miiphy_get_dev_by_name(dev->name);
613
614         ret = dw_phy_init(priv, dev);
615         debug("%s, ret=%d\n", __func__, ret);
616
617         return ret;
618 }
619
620 static int designware_eth_remove(struct udevice *dev)
621 {
622         struct dw_eth_dev *priv = dev_get_priv(dev);
623
624         free(priv->phydev);
625         mdio_unregister(priv->bus);
626         mdio_free(priv->bus);
627
628         return 0;
629 }
630
631 static const struct eth_ops designware_eth_ops = {
632         .start                  = designware_eth_start,
633         .send                   = designware_eth_send,
634         .recv                   = designware_eth_recv,
635         .free_pkt               = designware_eth_free_pkt,
636         .stop                   = designware_eth_stop,
637         .write_hwaddr           = designware_eth_write_hwaddr,
638 };
639
640 static int designware_eth_ofdata_to_platdata(struct udevice *dev)
641 {
642         struct eth_pdata *pdata = dev_get_platdata(dev);
643         const char *phy_mode;
644         const fdt32_t *cell;
645
646         pdata->iobase = dev_get_addr(dev);
647         pdata->phy_interface = -1;
648         phy_mode = fdt_getprop(gd->fdt_blob, dev->of_offset, "phy-mode", NULL);
649         if (phy_mode)
650                 pdata->phy_interface = phy_get_interface_by_name(phy_mode);
651         if (pdata->phy_interface == -1) {
652                 debug("%s: Invalid PHY interface '%s'\n", __func__, phy_mode);
653                 return -EINVAL;
654         }
655
656         pdata->max_speed = 0;
657         cell = fdt_getprop(gd->fdt_blob, dev->of_offset, "max-speed", NULL);
658         if (cell)
659                 pdata->max_speed = fdt32_to_cpu(*cell);
660
661         return 0;
662 }
663
664 static const struct udevice_id designware_eth_ids[] = {
665         { .compatible = "allwinner,sun7i-a20-gmac" },
666         { .compatible = "altr,socfpga-stmmac" },
667         { }
668 };
669
670 U_BOOT_DRIVER(eth_designware) = {
671         .name   = "eth_designware",
672         .id     = UCLASS_ETH,
673         .of_match = designware_eth_ids,
674         .ofdata_to_platdata = designware_eth_ofdata_to_platdata,
675         .bind   = designware_eth_bind,
676         .probe  = designware_eth_probe,
677         .remove = designware_eth_remove,
678         .ops    = &designware_eth_ops,
679         .priv_auto_alloc_size = sizeof(struct dw_eth_dev),
680         .platdata_auto_alloc_size = sizeof(struct eth_pdata),
681         .flags = DM_FLAG_ALLOC_PRIV_DMA,
682 };
683
684 static struct pci_device_id supported[] = {
685         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_QRK_EMAC) },
686         { }
687 };
688
689 U_BOOT_PCI_DEVICE(eth_designware, supported);
690 #endif