]>
Commit | Line | Data |
---|---|---|
05316f8e TL |
1 | /* |
2 | * Copyright (C) 2004-2007 Freescale Semiconductor, Inc. | |
3 | * TsiChung Liew (Tsi-Chung.Liew@freescale.com) | |
4 | * | |
5 | * See file CREDITS for list of people who contributed to this | |
6 | * project. | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License as | |
10 | * published by the Free Software Foundation; either version 2 of | |
11 | * the License, or (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
21 | * MA 02111-1307 USA | |
22 | */ | |
23 | ||
24 | #include <common.h> | |
25 | #include <asm/fec.h> | |
26 | #include <asm/immap.h> | |
27 | ||
28 | #include <config.h> | |
29 | #include <net.h> | |
30 | ||
31 | DECLARE_GLOBAL_DATA_PTR; | |
32 | ||
33 | #if defined(CONFIG_CMD_NET) && defined(CONFIG_NET_MULTI) | |
34 | #undef MII_DEBUG | |
35 | #undef ET_DEBUG | |
36 | ||
37 | int fecpin_setclear(struct eth_device *dev, int setclear) | |
38 | { | |
39 | volatile gpio_t *gpio = (gpio_t *) MMAP_GPIO; | |
40 | struct fec_info_s *info = (struct fec_info_s *)dev->priv; | |
41 | ||
42 | if (setclear) { | |
43 | gpio->par_feci2c |= | |
44 | (GPIO_PAR_FECI2C_MDC0_MDC0 | GPIO_PAR_FECI2C_MDIO0_MDIO0); | |
45 | ||
6d0f6bcf | 46 | if (info->iobase == CONFIG_SYS_FEC0_IOBASE) |
05316f8e TL |
47 | gpio->par_fec |= GPIO_PAR_FEC_FEC0_RMII_GPIO; |
48 | else | |
49 | gpio->par_fec |= GPIO_PAR_FEC_FEC1_RMII_ATA; | |
50 | } else { | |
51 | gpio->par_feci2c &= | |
52 | ~(GPIO_PAR_FECI2C_MDC0_MDC0 | GPIO_PAR_FECI2C_MDIO0_MDIO0); | |
53 | ||
6d0f6bcf | 54 | if (info->iobase == CONFIG_SYS_FEC0_IOBASE) |
05316f8e TL |
55 | gpio->par_fec &= GPIO_PAR_FEC_FEC0_MASK; |
56 | else | |
57 | gpio->par_fec &= GPIO_PAR_FEC_FEC1_MASK; | |
58 | } | |
59 | return 0; | |
60 | } | |
61 | ||
6d0f6bcf | 62 | #if defined(CONFIG_SYS_DISCOVER_PHY) || defined(CONFIG_CMD_MII) |
05316f8e TL |
63 | #include <miiphy.h> |
64 | ||
65 | /* Make MII read/write commands for the FEC. */ | |
66 | #define mk_mii_read(ADDR, REG) (0x60020000 | ((ADDR << 23) | (REG & 0x1f) << 18)) | |
67 | ||
68 | #define mk_mii_write(ADDR, REG, VAL) (0x50020000 | ((ADDR << 23) | (REG & 0x1f) << 18) | (VAL & 0xffff)) | |
69 | ||
70 | /* PHY identification */ | |
71 | #define PHY_ID_KSZ8041NL 0x00221512 | |
72 | #define STR_ID_KSZ8041NL "KSZ8041NL" | |
73 | ||
74 | /**************************************************************************** | |
75 | * mii_init -- Initialize the MII for MII command without ethernet | |
76 | * This function is a subset of eth_init | |
77 | **************************************************************************** | |
78 | */ | |
79 | void mii_reset(struct fec_info_s *info) | |
80 | { | |
81 | volatile fec_t *fecp = (fec_t *) (info->miibase); | |
82 | struct eth_device *dev; | |
83 | int i, miispd; | |
84 | u16 rst = 0; | |
85 | ||
86 | dev = eth_get_dev(); | |
87 | ||
88 | miispd = (gd->bus_clk / 1000000) / 5; | |
89 | fecp->mscr = miispd << 1; | |
90 | ||
91 | miiphy_write(dev->name, info->phy_addr, PHY_BMCR, PHY_BMCR_RESET); | |
92 | for (i = 0; i < FEC_RESET_DELAY; ++i) { | |
93 | udelay(500); | |
94 | miiphy_read(dev->name, info->phy_addr, PHY_BMCR, &rst); | |
95 | if ((rst & PHY_BMCR_RESET) == 0) | |
96 | break; | |
97 | } | |
98 | if (i == FEC_RESET_DELAY) | |
99 | printf("Mii reset timeout %d\n", i); | |
100 | } | |
101 | ||
102 | /* send command to phy using mii, wait for result */ | |
103 | uint mii_send(uint mii_cmd) | |
104 | { | |
105 | struct fec_info_s *info; | |
106 | struct eth_device *dev; | |
107 | volatile fec_t *ep; | |
108 | uint mii_reply; | |
109 | int j = 0; | |
110 | ||
111 | /* retrieve from register structure */ | |
112 | dev = eth_get_dev(); | |
113 | info = dev->priv; | |
114 | ||
115 | ep = (fec_t *) info->miibase; | |
116 | ||
117 | ep->mmfr = mii_cmd; /* command to phy */ | |
118 | ||
119 | /* wait for mii complete */ | |
120 | while (!(ep->eir & FEC_EIR_MII) && (j < MCFFEC_TOUT_LOOP)) { | |
121 | udelay(1); | |
122 | j++; | |
123 | } | |
124 | if (j >= MCFFEC_TOUT_LOOP) { | |
125 | printf("MII not complete\n"); | |
126 | return -1; | |
127 | } | |
128 | ||
129 | mii_reply = ep->mmfr; /* result from phy */ | |
130 | ep->eir = FEC_EIR_MII; /* clear MII complete */ | |
131 | #ifdef ET_DEBUG | |
132 | printf("%s[%d] %s: sent=0x%8.8x, reply=0x%8.8x\n", | |
133 | __FILE__, __LINE__, __FUNCTION__, mii_cmd, mii_reply); | |
134 | #endif | |
135 | ||
136 | return (mii_reply & 0xffff); /* data read from phy */ | |
137 | } | |
6d0f6bcf | 138 | #endif /* CONFIG_SYS_DISCOVER_PHY || (CONFIG_MII) */ |
05316f8e | 139 | |
6d0f6bcf | 140 | #if defined(CONFIG_SYS_DISCOVER_PHY) |
05316f8e TL |
141 | int mii_discover_phy(struct eth_device *dev) |
142 | { | |
143 | #define MAX_PHY_PASSES 11 | |
144 | struct fec_info_s *info = dev->priv; | |
145 | int phyaddr, pass; | |
146 | uint phyno, phytype; | |
147 | ||
148 | if (info->phyname_init) | |
149 | return info->phy_addr; | |
150 | ||
151 | phyaddr = -1; /* didn't find a PHY yet */ | |
152 | for (pass = 1; pass <= MAX_PHY_PASSES && phyaddr < 0; ++pass) { | |
153 | if (pass > 1) { | |
154 | /* PHY may need more time to recover from reset. | |
155 | * The LXT970 needs 50ms typical, no maximum is | |
156 | * specified, so wait 10ms before try again. | |
157 | * With 11 passes this gives it 100ms to wake up. | |
158 | */ | |
159 | udelay(10000); /* wait 10ms */ | |
160 | } | |
161 | ||
162 | for (phyno = 0; phyno < 32 && phyaddr < 0; ++phyno) { | |
163 | ||
164 | phytype = mii_send(mk_mii_read(phyno, PHY_PHYIDR1)); | |
165 | #ifdef ET_DEBUG | |
166 | printf("PHY type 0x%x pass %d type\n", phytype, pass); | |
167 | #endif | |
168 | if (phytype != 0xffff) { | |
169 | phyaddr = phyno; | |
170 | phytype <<= 16; | |
171 | phytype |= | |
172 | mii_send(mk_mii_read(phyno, PHY_PHYIDR2)); | |
173 | ||
174 | switch (phytype & 0xffffffff) { | |
175 | case PHY_ID_KSZ8041NL: | |
176 | strcpy(info->phy_name, | |
177 | STR_ID_KSZ8041NL); | |
178 | info->phyname_init = 1; | |
179 | break; | |
180 | default: | |
181 | strcpy(info->phy_name, "unknown"); | |
182 | info->phyname_init = 1; | |
183 | break; | |
184 | } | |
185 | ||
186 | #ifdef ET_DEBUG | |
187 | printf("PHY @ 0x%x pass %d type ", phyno, pass); | |
188 | switch (phytype & 0xffffffff) { | |
189 | case PHY_ID_KSZ8041NL: | |
190 | printf(STR_ID_KSZ8041NL); | |
191 | break; | |
192 | default: | |
193 | printf("0x%08x\n", phytype); | |
194 | break; | |
195 | } | |
196 | #endif | |
197 | } | |
198 | } | |
199 | } | |
200 | if (phyaddr < 0) | |
201 | printf("No PHY device found.\n"); | |
202 | ||
203 | return phyaddr; | |
204 | } | |
6d0f6bcf | 205 | #endif /* CONFIG_SYS_DISCOVER_PHY */ |
05316f8e TL |
206 | |
207 | void mii_init(void) __attribute__ ((weak, alias("__mii_init"))); | |
208 | ||
209 | void __mii_init(void) | |
210 | { | |
211 | volatile fec_t *fecp; | |
212 | struct fec_info_s *info; | |
213 | struct eth_device *dev; | |
214 | int miispd = 0, i = 0; | |
215 | u16 autoneg = 0; | |
216 | ||
217 | /* retrieve from register structure */ | |
218 | dev = eth_get_dev(); | |
219 | info = dev->priv; | |
220 | ||
221 | fecp = (fec_t *) info->miibase; | |
222 | ||
223 | /* We use strictly polling mode only */ | |
224 | fecp->eimr = 0; | |
225 | ||
226 | /* Clear any pending interrupt */ | |
227 | fecp->eir = 0xffffffff; | |
228 | ||
229 | /* Set MII speed */ | |
230 | miispd = (gd->bus_clk / 1000000) / 5; | |
231 | fecp->mscr = miispd << 1; | |
232 | ||
233 | info->phy_addr = mii_discover_phy(dev); | |
234 | ||
235 | #define AUTONEGLINK (PHY_BMSR_AUTN_COMP | PHY_BMSR_LS) | |
236 | while (i < MCFFEC_TOUT_LOOP) { | |
237 | autoneg = 0; | |
238 | miiphy_read(dev->name, info->phy_addr, PHY_BMSR, &autoneg); | |
239 | i++; | |
240 | ||
241 | if ((autoneg & AUTONEGLINK) == AUTONEGLINK) | |
242 | break; | |
243 | ||
244 | udelay(500); | |
245 | } | |
246 | if (i >= MCFFEC_TOUT_LOOP) { | |
247 | printf("Auto Negotiation not complete\n"); | |
248 | } | |
249 | ||
250 | /* adapt to the half/full speed settings */ | |
251 | info->dup_spd = miiphy_duplex(dev->name, info->phy_addr) << 16; | |
252 | info->dup_spd |= miiphy_speed(dev->name, info->phy_addr); | |
253 | } | |
254 | ||
255 | /***************************************************************************** | |
256 | * Read and write a MII PHY register, routines used by MII Utilities | |
257 | * | |
258 | * FIXME: These routines are expected to return 0 on success, but mii_send | |
259 | * does _not_ return an error code. Maybe 0xFFFF means error, i.e. | |
260 | * no PHY connected... | |
261 | * For now always return 0. | |
262 | * FIXME: These routines only work after calling eth_init() at least once! | |
263 | * Otherwise they hang in mii_send() !!! Sorry! | |
264 | *****************************************************************************/ | |
265 | ||
266 | int mcffec_miiphy_read(char *devname, unsigned char addr, unsigned char reg, | |
267 | unsigned short *value) | |
268 | { | |
269 | short rdreg; /* register working value */ | |
270 | ||
271 | #ifdef MII_DEBUG | |
272 | printf("miiphy_read(0x%x) @ 0x%x = ", reg, addr); | |
273 | #endif | |
274 | rdreg = mii_send(mk_mii_read(addr, reg)); | |
275 | ||
276 | *value = rdreg; | |
277 | ||
278 | #ifdef MII_DEBUG | |
279 | printf("0x%04x\n", *value); | |
280 | #endif | |
281 | ||
282 | return 0; | |
283 | } | |
284 | ||
285 | int mcffec_miiphy_write(char *devname, unsigned char addr, unsigned char reg, | |
286 | unsigned short value) | |
287 | { | |
288 | short rdreg; /* register working value */ | |
289 | ||
290 | #ifdef MII_DEBUG | |
291 | printf("miiphy_write(0x%x) @ 0x%x = ", reg, addr); | |
292 | #endif | |
293 | ||
294 | rdreg = mii_send(mk_mii_write(addr, reg, value)); | |
295 | ||
296 | #ifdef MII_DEBUG | |
297 | printf("0x%04x\n", value); | |
298 | #endif | |
299 | ||
300 | return 0; | |
301 | } | |
302 | ||
303 | #endif /* CONFIG_CMD_NET, FEC_ENET & NET_MULTI */ |