← Back to branch summary

~ubuntu-branches/ubuntu/saucy/u-boot/saucy

« back to all changes in this revision

Viewing changes to drivers/net/xilinx_ll_temac.c

  • Committer: Package Import Robot
  • Author(s): Clint Adams
  • Date: 2012-05-01 18:07:19 UTC
  • mfrom: (16.1.23 sid)
  • Revision ID: package-import@ubuntu.com-20120501180719-rjntk3287im4a0ns
Tags: 2012.04.01-1
* New upstream version.
  - Update mipsel-native-endianness.diff.
  - Update no-error-on-set-but-unused-variables.diff (partially merged).
  - Drop kirkwood_spi-irq_mask.diff (merged).
  - Drop kirkwood-disable-l2c.diff (merged).

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
 
236
        printf("%s: Xilinx XPS LocalLink Tri-Mode Ether MAC #%d at 0x%08X.\n",
 
237
                dev->name, dev->index, dev->iobase);
 
238
 
 
239
        if (!ll_temac_setup_ctrl(dev))
 
240
                return -1;
 
241
 
 
242
        /* Start up the PHY */
 
243
        phy_startup(ll_temac->phydev);
 
244
 
 
245
        if (!ll_temac_adjust_link(dev)) {
 
246
                ll_temac_halt(dev);
 
247
                return -1;
 
248
        }
 
249
 
 
250
        /* If there's no link, fail */
 
251
        return ll_temac->phydev->link ? 0 : -1;
 
252
}
 
253
 
 
254
/*
 
255
 * Discover which PHY is attached to the device, and configure it
 
256
 * properly.  If the PHY is not recognized, then return 0
 
257
 * (failure).  Otherwise, return 1
 
258
 */
 
259
static int ll_temac_phy_init(struct eth_device *dev)
 
260
{
 
261
        struct ll_temac *ll_temac = dev->priv;
 
262
        struct phy_device *phydev;
 
263
        unsigned int supported = PHY_GBIT_FEATURES;
 
264
 
 
265
        /* interface - look at driver/net/tsec.c */
 
266
        phydev = phy_connect(ll_temac->bus, ll_temac->phyaddr,
 
267
                        dev, PHY_INTERFACE_MODE_NONE);
 
268
 
 
269
        phydev->supported &= supported;
 
270
        phydev->advertising = phydev->supported;
 
271
 
 
272
        ll_temac->phydev = phydev;
 
273
 
 
274
        phy_config(phydev);
 
275
 
 
276
        return 1;
 
277
}
 
278
 
 
279
/*
 
280
 * Initialize a single ll_temac devices
 
281
 *
 
282
 * Returns the result of ll_temac phy interface that were initialized
 
283
 */
 
284
int xilinx_ll_temac_initialize(bd_t *bis, struct ll_temac_info *devinf)
 
285
{
 
286
        struct eth_device *dev;
 
287
        struct ll_temac *ll_temac;
 
288
 
 
289
        dev = calloc(1, sizeof(*dev));
 
290
        if (dev == NULL)
 
291
                return 0;
 
292
 
 
293
        ll_temac = calloc(1, sizeof(struct ll_temac));
 
294
        if (ll_temac == NULL) {
 
295
                free(dev);
 
296
                return 0;
 
297
        }
 
298
 
 
299
        /* use given name or generate its own unique name */
 
300
        if (devinf->devname) {
 
301
                strncpy(dev->name, devinf->devname, sizeof(dev->name));
 
302
        } else {
 
303
                snprintf(dev->name, sizeof(dev->name), "lltemac.%lx", devinf->base_addr);
 
304
                devinf->devname = dev->name;
 
305
        }
 
306
 
 
307
        dev->iobase = devinf->base_addr;
 
308
 
 
309
        dev->priv = ll_temac;
 
310
        dev->init = ll_temac_init;
 
311
        dev->halt = ll_temac_halt;
 
312
        dev->write_hwaddr = ll_temac_setup_mac_addr;
 
313
 
 
314
        ll_temac->ctrladdr = devinf->ctrl_addr;
 
315
        if (devinf->flags & XILINX_LL_TEMAC_M_SDMA_PLB) {
 
316
#if defined(CONFIG_XILINX_440) || defined(CONFIG_XILINX_405)
 
317
                if (devinf->flags & XILINX_LL_TEMAC_M_SDMA_DCR) {
 
318
                        ll_temac_collect_xldcr_sdma_reg_addr(dev);
 
319
                        ll_temac->in32 = ll_temac_xldcr_in32;
 
320
                        ll_temac->out32 = ll_temac_xldcr_out32;
 
321
                } else
 
322
#endif
 
323
                {
 
324
                        ll_temac_collect_xlplb_sdma_reg_addr(dev);
 
325
                        ll_temac->in32 = ll_temac_xlplb_in32;
 
326
                        ll_temac->out32 = ll_temac_xlplb_out32;
 
327
                }
 
328
                ll_temac->ctrlinit = ll_temac_init_sdma;
 
329
                ll_temac->ctrlhalt = ll_temac_halt_sdma;
 
330
                ll_temac->ctrlreset = ll_temac_reset_sdma;
 
331
                dev->recv = ll_temac_recv_sdma;
 
332
                dev->send = ll_temac_send_sdma;
 
333
        } else {
 
334
                ll_temac->in32 = NULL;
 
335
                ll_temac->out32 = NULL;
 
336
                ll_temac->ctrlinit = NULL;
 
337
                ll_temac->ctrlhalt = NULL;
 
338
                ll_temac->ctrlreset = ll_temac_reset_fifo;
 
339
                dev->recv = ll_temac_recv_fifo;
 
340
                dev->send = ll_temac_send_fifo;
 
341
        }
 
342
 
 
343
        /* Link to specified MDIO bus */
 
344
        strncpy(ll_temac->mdio_busname, devinf->mdio_busname, MDIO_NAME_LEN);
 
345
        ll_temac->bus = miiphy_get_dev_by_name(ll_temac->mdio_busname);
 
346
 
 
347
        /* Looking for a valid PHY address if it is not yet set */
 
348
        if (devinf->phyaddr == -1)
 
349
                ll_temac->phyaddr = ll_temac_phy_addr(ll_temac->bus);
 
350
        else
 
351
                ll_temac->phyaddr = devinf->phyaddr;
 
352
 
 
353
        eth_register(dev);
 
354
 
 
355
        /* Try to initialize PHY here, and return */
 
356
        return ll_temac_phy_init(dev);
 
357
}
 
358
 
 
359
/*
 
360
 * Initialize a single ll_temac device with its mdio bus behind ll_temac
 
361
 *
 
362
 * Returns 1 if the ll_temac device and the mdio bus were initialized
 
363
 * otherwise returns 0
 
364
 */
 
365
int xilinx_ll_temac_eth_init(bd_t *bis, unsigned long base_addr, int flags,
 
366
                                                        unsigned long ctrl_addr)
 
367
{
 
368
        struct ll_temac_info devinf;
 
369
        struct ll_temac_mdio_info mdioinf;
 
370
        int ret;
 
371
 
 
372
        /* prepare the internal driver informations */
 
373
        devinf.flags = flags;
 
374
        devinf.base_addr = base_addr;
 
375
        devinf.ctrl_addr = ctrl_addr;
 
376
        devinf.devname = NULL;
 
377
        devinf.phyaddr = -1;
 
378
 
 
379
        mdioinf.name = devinf.mdio_busname = NULL;
 
380
        mdioinf.regs = (struct temac_reg *)devinf.base_addr;
 
381
 
 
382
        ret = xilinx_ll_temac_mdio_initialize(bis, &mdioinf);
 
383
        if (ret >= 0) {
 
384
 
 
385
                /*
 
386
                 * If there was no MDIO bus name then take over the
 
387
                 * new automaticaly generated by the MDIO init code.
 
388
                 */
 
389
                if (mdioinf.name != devinf.mdio_busname)
 
390
                        devinf.mdio_busname = mdioinf.name;
 
391
 
 
392
                ret = xilinx_ll_temac_initialize(bis, &devinf);
 
393
                if (ret > 0)
 
394
                        return 1;
 
395
 
 
396
        }
 
397
 
 
398
        return 0;
 
399
}