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