]> git.sur5r.net Git - u-boot/blob - drivers/net/xilinx_ll_temac.c
Merge branch 'master' of git://git.denx.de/u-boot-mpc85xx
[u-boot] / drivers / net / xilinx_ll_temac.c
1 /*
2  * Xilinx xps_ll_temac ethernet driver for u-boot
3  *
4  * supports SDMA or FIFO access and MDIO bus communication
5  *
6  * Copyright (C) 2011 - 2012 Stephan Linz <linz@li-pro.net>
7  * Copyright (C) 2008 - 2011 Michal Simek <monstr@monstr.eu>
8  * Copyright (C) 2008 - 2011 PetaLogix
9  *
10  * Based on Yoshio Kashiwagi kashiwagi@co-nss.co.jp driver
11  * Copyright (C) 2008 Nissin Systems Co.,Ltd.
12  * March 2008 created
13  *
14  * This program is free software; you can redistribute it and/or modify it
15  * under the terms of the GNU General Public License as published by the
16  * Free Software Foundation; either version 2 of the License, or (at your
17  * option) any later version.
18  *
19  * [0]: http://www.xilinx.com/support/documentation
20  *
21  * [S]: [0]/ip_documentation/xps_ll_temac.pdf
22  * [A]: [0]/application_notes/xapp1041.pdf
23  */
24
25 #include <config.h>
26 #include <common.h>
27 #include <net.h>
28 #include <netdev.h>
29 #include <malloc.h>
30 #include <asm/io.h>
31 #include <miiphy.h>
32
33 #include "xilinx_ll_temac.h"
34 #include "xilinx_ll_temac_fifo.h"
35 #include "xilinx_ll_temac_sdma.h"
36 #include "xilinx_ll_temac_mdio.h"
37
38 #if !defined(CONFIG_MII)
39 # error "LL_TEMAC requires MII -- missing CONFIG_MII"
40 #endif
41
42 #if !defined(CONFIG_PHYLIB)
43 # error "LL_TEMAC requires PHYLIB -- missing CONFIG_PHYLIB"
44 #endif
45
46 struct ll_temac_info {
47         int                     flags;
48         unsigned long           base_addr;
49         unsigned long           ctrl_addr;
50         char                    *devname;
51         unsigned int            phyaddr;
52         char                    *mdio_busname;
53 };
54
55 /* Ethernet interface ready status */
56 int ll_temac_check_status(struct temac_reg *regs, u32 mask)
57 {
58         unsigned timeout = 50;  /* 1usec * 50 = 50usec */
59
60         /*
61          * Quote from LL TEMAC documentation: The bits in the RDY
62          * register are asserted when there is no access in progress.
63          * When an access is in progress, a bit corresponding to the
64          * type of access is automatically de-asserted. The bit is
65          * automatically re-asserted when the access is complete.
66          */
67         while (timeout && (!(in_be32(&regs->rdy) & mask))) {
68                 timeout--;
69                 udelay(1);
70         }
71
72         if (!timeout) {
73                 printf("%s: Timeout on 0x%08x @%p\n", __func__,
74                                 mask, &regs->rdy);
75                 return 1;
76         }
77
78         return 0;
79 }
80
81 /*
82  * Indirect write to ll_temac.
83  *
84  * http://www.xilinx.com/support/documentation/ip_documentation/xps_ll_temac.pdf
85  * page 23, second paragraph, The use of CTL0 register or CTL1 register
86  */
87 int ll_temac_indirect_set(struct temac_reg *regs, u16 regn, u32 reg_data)
88 {
89         out_be32(&regs->lsw, (reg_data & MLSW_MASK));
90         out_be32(&regs->ctl, CTL_WEN | (regn & CTL_ADDR_MASK));
91
92         if (ll_temac_check_status(regs, RSE_CFG_WR))
93                 return 0;
94
95         return 1;
96 }
97
98 /*
99  * Indirect read from ll_temac.
100  *
101  * http://www.xilinx.com/support/documentation/ip_documentation/xps_ll_temac.pdf
102  * page 23, second paragraph, The use of CTL0 register or CTL1 register
103  */
104 int ll_temac_indirect_get(struct temac_reg *regs, u16 regn, u32* reg_data)
105 {
106         out_be32(&regs->ctl, (regn & CTL_ADDR_MASK));
107
108         if (ll_temac_check_status(regs, RSE_CFG_RR))
109                 return 0;
110
111         *reg_data = in_be32(&regs->lsw) & MLSW_MASK;
112         return 1;
113 }
114
115 /* setting sub-controller and ll_temac to proper setting */
116 static int ll_temac_setup_ctrl(struct eth_device *dev)
117 {
118         struct ll_temac *ll_temac = dev->priv;
119         struct temac_reg *regs = (struct temac_reg *)dev->iobase;
120
121         if (ll_temac->ctrlreset && ll_temac->ctrlreset(dev))
122                 return 0;
123
124         if (ll_temac->ctrlinit && ll_temac->ctrlinit(dev))
125                 return 0;
126
127         /* Promiscuous mode disable */
128         if (!ll_temac_indirect_set(regs, TEMAC_AFM, 0))
129                 return 0;
130
131         /* Enable Receiver - RX bit */
132         if (!ll_temac_indirect_set(regs, TEMAC_RCW1, RCW1_RX))
133                 return 0;
134
135         /* Enable Transmitter - TX bit */
136         if (!ll_temac_indirect_set(regs, TEMAC_TC, TC_TX))
137                 return 0;
138
139         return 1;
140 }
141
142 /*
143  * Configure ll_temac based on negotiated speed and duplex
144  * reported by PHY handling code
145  */
146 static int ll_temac_adjust_link(struct eth_device *dev)
147 {
148         unsigned int speed, emmc_reg;
149         struct temac_reg *regs = (struct temac_reg *)dev->iobase;
150         struct ll_temac *ll_temac = dev->priv;
151         struct phy_device *phydev = ll_temac->phydev;
152
153         if (!phydev->link) {
154                 printf("%s: No link.\n", phydev->dev->name);
155                 return 0;
156         }
157
158         switch (phydev->speed) {
159         case 1000:
160                 speed = EMMC_LSPD_1000;
161                 break;
162         case 100:
163                 speed = EMMC_LSPD_100;
164                 break;
165         case 10:
166                 speed = EMMC_LSPD_10;
167                 break;
168         default:
169                 return 0;
170         }
171
172         if (!ll_temac_indirect_get(regs, TEMAC_EMMC, &emmc_reg))
173                 return 0;
174
175         emmc_reg &= ~EMMC_LSPD_MASK;
176         emmc_reg |= speed;
177
178         if (!ll_temac_indirect_set(regs, TEMAC_EMMC, emmc_reg))
179                 return 0;
180
181         printf("%s: PHY is %s with %dbase%s, %s%s\n",
182                         dev->name, phydev->drv->name,
183                         phydev->speed, (phydev->port == PORT_TP) ? "T" : "X",
184                         (phydev->duplex) ? "FDX" : "HDX",
185                         (phydev->port == PORT_OTHER) ? ", unkown mode" : "");
186
187         return 1;
188 }
189
190 /* setup mac addr */
191 static int ll_temac_setup_mac_addr(struct eth_device *dev)
192 {
193         struct temac_reg *regs = (struct temac_reg *)dev->iobase;
194         u32 val;
195
196         /* set up unicast MAC address filter */
197         val = ((dev->enetaddr[3] << 24) | (dev->enetaddr[2] << 16) |
198                         (dev->enetaddr[1] << 8) | (dev->enetaddr[0]));
199         val &= UAW0_UADDR_MASK;
200
201         if (!ll_temac_indirect_set(regs, TEMAC_UAW0, val))
202                 return 1;
203
204         val = ((dev->enetaddr[5] << 8) | dev->enetaddr[4]);
205         val &= UAW1_UADDR_MASK;
206
207         if (!ll_temac_indirect_set(regs, TEMAC_UAW1, val))
208                 return 1;
209
210         return 0;
211 }
212
213 /* halt device */
214 static void ll_temac_halt(struct eth_device *dev)
215 {
216         struct ll_temac *ll_temac = dev->priv;
217         struct temac_reg *regs = (struct temac_reg *)dev->iobase;
218
219         /* Disable Receiver */
220         ll_temac_indirect_set(regs, TEMAC_RCW0, 0);
221
222         /* Disable Transmitter */
223         ll_temac_indirect_set(regs, TEMAC_TC, 0);
224
225         if (ll_temac->ctrlhalt)
226                 ll_temac->ctrlhalt(dev);
227
228         /* Shut down the PHY, as needed */
229         phy_shutdown(ll_temac->phydev);
230 }
231
232 static int ll_temac_init(struct eth_device *dev, bd_t *bis)
233 {
234         struct ll_temac *ll_temac = dev->priv;
235         int ret;
236
237         printf("%s: Xilinx XPS LocalLink Tri-Mode Ether MAC #%d at 0x%08X.\n",
238                 dev->name, dev->index, dev->iobase);
239
240         if (!ll_temac_setup_ctrl(dev))
241                 return -1;
242
243         /* Start up the PHY */
244         ret = phy_startup(ll_temac->phydev);
245         if (ret) {
246                 printf("%s: Could not initialize PHY %s\n",
247                        dev->name, ll_temac->phydev->dev->name);
248                 return ret;
249         }
250
251         if (!ll_temac_adjust_link(dev)) {
252                 ll_temac_halt(dev);
253                 return -1;
254         }
255
256         /* If there's no link, fail */
257         return ll_temac->phydev->link ? 0 : -1;
258 }
259
260 /*
261  * Discover which PHY is attached to the device, and configure it
262  * properly.  If the PHY is not recognized, then return 0
263  * (failure).  Otherwise, return 1
264  */
265 static int ll_temac_phy_init(struct eth_device *dev)
266 {
267         struct ll_temac *ll_temac = dev->priv;
268         struct phy_device *phydev;
269         unsigned int supported = PHY_GBIT_FEATURES;
270
271         /* interface - look at driver/net/tsec.c */
272         phydev = phy_connect(ll_temac->bus, ll_temac->phyaddr,
273                         dev, PHY_INTERFACE_MODE_NONE);
274
275         phydev->supported &= supported;
276         phydev->advertising = phydev->supported;
277
278         ll_temac->phydev = phydev;
279
280         phy_config(phydev);
281
282         return 1;
283 }
284
285 /*
286  * Initialize a single ll_temac devices
287  *
288  * Returns the result of ll_temac phy interface that were initialized
289  */
290 int xilinx_ll_temac_initialize(bd_t *bis, struct ll_temac_info *devinf)
291 {
292         struct eth_device *dev;
293         struct ll_temac *ll_temac;
294
295         dev = calloc(1, sizeof(*dev));
296         if (dev == NULL)
297                 return 0;
298
299         ll_temac = calloc(1, sizeof(struct ll_temac));
300         if (ll_temac == NULL) {
301                 free(dev);
302                 return 0;
303         }
304
305         /* use given name or generate its own unique name */
306         if (devinf->devname) {
307                 strncpy(dev->name, devinf->devname, sizeof(dev->name));
308         } else {
309                 snprintf(dev->name, sizeof(dev->name), "lltemac.%lx", devinf->base_addr);
310                 devinf->devname = dev->name;
311         }
312
313         dev->iobase = devinf->base_addr;
314
315         dev->priv = ll_temac;
316         dev->init = ll_temac_init;
317         dev->halt = ll_temac_halt;
318         dev->write_hwaddr = ll_temac_setup_mac_addr;
319
320         ll_temac->ctrladdr = devinf->ctrl_addr;
321         if (devinf->flags & XILINX_LL_TEMAC_M_SDMA_PLB) {
322 #if defined(CONFIG_XILINX_440) || defined(CONFIG_XILINX_405)
323                 if (devinf->flags & XILINX_LL_TEMAC_M_SDMA_DCR) {
324                         ll_temac_collect_xldcr_sdma_reg_addr(dev);
325                         ll_temac->in32 = ll_temac_xldcr_in32;
326                         ll_temac->out32 = ll_temac_xldcr_out32;
327                 } else
328 #endif
329                 {
330                         ll_temac_collect_xlplb_sdma_reg_addr(dev);
331                         ll_temac->in32 = ll_temac_xlplb_in32;
332                         ll_temac->out32 = ll_temac_xlplb_out32;
333                 }
334                 ll_temac->ctrlinit = ll_temac_init_sdma;
335                 ll_temac->ctrlhalt = ll_temac_halt_sdma;
336                 ll_temac->ctrlreset = ll_temac_reset_sdma;
337                 dev->recv = ll_temac_recv_sdma;
338                 dev->send = ll_temac_send_sdma;
339         } else {
340                 ll_temac->in32 = NULL;
341                 ll_temac->out32 = NULL;
342                 ll_temac->ctrlinit = NULL;
343                 ll_temac->ctrlhalt = NULL;
344                 ll_temac->ctrlreset = ll_temac_reset_fifo;
345                 dev->recv = ll_temac_recv_fifo;
346                 dev->send = ll_temac_send_fifo;
347         }
348
349         /* Link to specified MDIO bus */
350         strncpy(ll_temac->mdio_busname, devinf->mdio_busname, MDIO_NAME_LEN);
351         ll_temac->bus = miiphy_get_dev_by_name(ll_temac->mdio_busname);
352
353         /* Looking for a valid PHY address if it is not yet set */
354         if (devinf->phyaddr == -1)
355                 ll_temac->phyaddr = ll_temac_phy_addr(ll_temac->bus);
356         else
357                 ll_temac->phyaddr = devinf->phyaddr;
358
359         eth_register(dev);
360
361         /* Try to initialize PHY here, and return */
362         return ll_temac_phy_init(dev);
363 }
364
365 /*
366  * Initialize a single ll_temac device with its mdio bus behind ll_temac
367  *
368  * Returns 1 if the ll_temac device and the mdio bus were initialized
369  * otherwise returns 0
370  */
371 int xilinx_ll_temac_eth_init(bd_t *bis, unsigned long base_addr, int flags,
372                                                         unsigned long ctrl_addr)
373 {
374         struct ll_temac_info devinf;
375         struct ll_temac_mdio_info mdioinf;
376         int ret;
377
378         /* prepare the internal driver informations */
379         devinf.flags = flags;
380         devinf.base_addr = base_addr;
381         devinf.ctrl_addr = ctrl_addr;
382         devinf.devname = NULL;
383         devinf.phyaddr = -1;
384
385         mdioinf.name = devinf.mdio_busname = NULL;
386         mdioinf.regs = (struct temac_reg *)devinf.base_addr;
387
388         ret = xilinx_ll_temac_mdio_initialize(bis, &mdioinf);
389         if (ret >= 0) {
390
391                 /*
392                  * If there was no MDIO bus name then take over the
393                  * new automaticaly generated by the MDIO init code.
394                  */
395                 if (mdioinf.name != devinf.mdio_busname)
396                         devinf.mdio_busname = mdioinf.name;
397
398                 ret = xilinx_ll_temac_initialize(bis, &devinf);
399                 if (ret > 0)
400                         return 1;
401
402         }
403
404         return 0;
405 }