diff options
Diffstat (limited to 'drivers/net/ethernet/freescale/fsl_pq_mdio.c')
-rw-r--r-- | drivers/net/ethernet/freescale/fsl_pq_mdio.c | 549 |
1 files changed, 292 insertions, 257 deletions
diff --git a/drivers/net/ethernet/freescale/fsl_pq_mdio.c b/drivers/net/ethernet/freescale/fsl_pq_mdio.c index 9527b28d70d1..c93a05654b46 100644 --- a/drivers/net/ethernet/freescale/fsl_pq_mdio.c +++ b/drivers/net/ethernet/freescale/fsl_pq_mdio.c | |||
@@ -19,54 +19,90 @@ | |||
19 | #include <linux/kernel.h> | 19 | #include <linux/kernel.h> |
20 | #include <linux/string.h> | 20 | #include <linux/string.h> |
21 | #include <linux/errno.h> | 21 | #include <linux/errno.h> |
22 | #include <linux/unistd.h> | ||
23 | #include <linux/slab.h> | 22 | #include <linux/slab.h> |
24 | #include <linux/interrupt.h> | ||
25 | #include <linux/init.h> | 23 | #include <linux/init.h> |
26 | #include <linux/delay.h> | 24 | #include <linux/delay.h> |
27 | #include <linux/netdevice.h> | ||
28 | #include <linux/etherdevice.h> | ||
29 | #include <linux/skbuff.h> | ||
30 | #include <linux/spinlock.h> | ||
31 | #include <linux/mm.h> | ||
32 | #include <linux/module.h> | 25 | #include <linux/module.h> |
33 | #include <linux/platform_device.h> | ||
34 | #include <linux/crc32.h> | ||
35 | #include <linux/mii.h> | 26 | #include <linux/mii.h> |
36 | #include <linux/phy.h> | ||
37 | #include <linux/of.h> | ||
38 | #include <linux/of_address.h> | 27 | #include <linux/of_address.h> |
39 | #include <linux/of_mdio.h> | 28 | #include <linux/of_mdio.h> |
40 | #include <linux/of_platform.h> | 29 | #include <linux/of_device.h> |
41 | 30 | ||
42 | #include <asm/io.h> | 31 | #include <asm/io.h> |
43 | #include <asm/irq.h> | 32 | #include <asm/ucc.h> /* for ucc_set_qe_mux_mii_mng() */ |
44 | #include <asm/uaccess.h> | ||
45 | #include <asm/ucc.h> | ||
46 | 33 | ||
47 | #include "gianfar.h" | 34 | #include "gianfar.h" |
48 | #include "fsl_pq_mdio.h" | 35 | |
36 | #define MIIMIND_BUSY 0x00000001 | ||
37 | #define MIIMIND_NOTVALID 0x00000004 | ||
38 | #define MIIMCFG_INIT_VALUE 0x00000007 | ||
39 | #define MIIMCFG_RESET 0x80000000 | ||
40 | |||
41 | #define MII_READ_COMMAND 0x00000001 | ||
42 | |||
43 | struct fsl_pq_mii { | ||
44 | u32 miimcfg; /* MII management configuration reg */ | ||
45 | u32 miimcom; /* MII management command reg */ | ||
46 | u32 miimadd; /* MII management address reg */ | ||
47 | u32 miimcon; /* MII management control reg */ | ||
48 | u32 miimstat; /* MII management status reg */ | ||
49 | u32 miimind; /* MII management indication reg */ | ||
50 | }; | ||
51 | |||
52 | struct fsl_pq_mdio { | ||
53 | u8 res1[16]; | ||
54 | u32 ieventm; /* MDIO Interrupt event register (for etsec2)*/ | ||
55 | u32 imaskm; /* MDIO Interrupt mask register (for etsec2)*/ | ||
56 | u8 res2[4]; | ||
57 | u32 emapm; /* MDIO Event mapping register (for etsec2)*/ | ||
58 | u8 res3[1280]; | ||
59 | struct fsl_pq_mii mii; | ||
60 | u8 res4[28]; | ||
61 | u32 utbipar; /* TBI phy address reg (only on UCC) */ | ||
62 | u8 res5[2728]; | ||
63 | } __packed; | ||
49 | 64 | ||
50 | /* Number of microseconds to wait for an MII register to respond */ | 65 | /* Number of microseconds to wait for an MII register to respond */ |
51 | #define MII_TIMEOUT 1000 | 66 | #define MII_TIMEOUT 1000 |
52 | 67 | ||
53 | struct fsl_pq_mdio_priv { | 68 | struct fsl_pq_mdio_priv { |
54 | void __iomem *map; | 69 | void __iomem *map; |
55 | struct fsl_pq_mdio __iomem *regs; | 70 | struct fsl_pq_mii __iomem *regs; |
71 | int irqs[PHY_MAX_ADDR]; | ||
72 | }; | ||
73 | |||
74 | /* | ||
75 | * Per-device-type data. Each type of device tree node that we support gets | ||
76 | * one of these. | ||
77 | * | ||
78 | * @mii_offset: the offset of the MII registers within the memory map of the | ||
79 | * node. Some nodes define only the MII registers, and some define the whole | ||
80 | * MAC (which includes the MII registers). | ||
81 | * | ||
82 | * @get_tbipa: determines the address of the TBIPA register | ||
83 | * | ||
84 | * @ucc_configure: a special function for extra QE configuration | ||
85 | */ | ||
86 | struct fsl_pq_mdio_data { | ||
87 | unsigned int mii_offset; /* offset of the MII registers */ | ||
88 | uint32_t __iomem * (*get_tbipa)(void __iomem *p); | ||
89 | void (*ucc_configure)(phys_addr_t start, phys_addr_t end); | ||
56 | }; | 90 | }; |
57 | 91 | ||
58 | /* | 92 | /* |
59 | * Write value to the PHY at mii_id at register regnum, | 93 | * Write value to the PHY at mii_id at register regnum, on the bus attached |
60 | * on the bus attached to the local interface, which may be different from the | 94 | * to the local interface, which may be different from the generic mdio bus |
61 | * generic mdio bus (tied to a single interface), waiting until the write is | 95 | * (tied to a single interface), waiting until the write is done before |
62 | * done before returning. This is helpful in programming interfaces like | 96 | * returning. This is helpful in programming interfaces like the TBI which |
63 | * the TBI which control interfaces like onchip SERDES and are always tied to | 97 | * control interfaces like onchip SERDES and are always tied to the local |
64 | * the local mdio pins, which may not be the same as system mdio bus, used for | 98 | * mdio pins, which may not be the same as system mdio bus, used for |
65 | * controlling the external PHYs, for example. | 99 | * controlling the external PHYs, for example. |
66 | */ | 100 | */ |
67 | int fsl_pq_local_mdio_write(struct fsl_pq_mdio __iomem *regs, int mii_id, | 101 | static int fsl_pq_mdio_write(struct mii_bus *bus, int mii_id, int regnum, |
68 | int regnum, u16 value) | 102 | u16 value) |
69 | { | 103 | { |
104 | struct fsl_pq_mdio_priv *priv = bus->priv; | ||
105 | struct fsl_pq_mii __iomem *regs = priv->regs; | ||
70 | u32 status; | 106 | u32 status; |
71 | 107 | ||
72 | /* Set the PHY address and the register address we want to write */ | 108 | /* Set the PHY address and the register address we want to write */ |
@@ -83,20 +119,21 @@ int fsl_pq_local_mdio_write(struct fsl_pq_mdio __iomem *regs, int mii_id, | |||
83 | } | 119 | } |
84 | 120 | ||
85 | /* | 121 | /* |
86 | * Read the bus for PHY at addr mii_id, register regnum, and | 122 | * Read the bus for PHY at addr mii_id, register regnum, and return the value. |
87 | * return the value. Clears miimcom first. All PHY operation | 123 | * Clears miimcom first. |
88 | * done on the bus attached to the local interface, | 124 | * |
89 | * which may be different from the generic mdio bus | 125 | * All PHY operation done on the bus attached to the local interface, which |
90 | * This is helpful in programming interfaces like | 126 | * may be different from the generic mdio bus. This is helpful in programming |
91 | * the TBI which, in turn, control interfaces like onchip SERDES | 127 | * interfaces like the TBI which, in turn, control interfaces like on-chip |
92 | * and are always tied to the local mdio pins, which may not be the | 128 | * SERDES and are always tied to the local mdio pins, which may not be the |
93 | * same as system mdio bus, used for controlling the external PHYs, for eg. | 129 | * same as system mdio bus, used for controlling the external PHYs, for eg. |
94 | */ | 130 | */ |
95 | int fsl_pq_local_mdio_read(struct fsl_pq_mdio __iomem *regs, | 131 | static int fsl_pq_mdio_read(struct mii_bus *bus, int mii_id, int regnum) |
96 | int mii_id, int regnum) | ||
97 | { | 132 | { |
98 | u16 value; | 133 | struct fsl_pq_mdio_priv *priv = bus->priv; |
134 | struct fsl_pq_mii __iomem *regs = priv->regs; | ||
99 | u32 status; | 135 | u32 status; |
136 | u16 value; | ||
100 | 137 | ||
101 | /* Set the PHY address and the register address we want to read */ | 138 | /* Set the PHY address and the register address we want to read */ |
102 | out_be32(®s->miimadd, (mii_id << 8) | regnum); | 139 | out_be32(®s->miimadd, (mii_id << 8) | regnum); |
@@ -115,44 +152,15 @@ int fsl_pq_local_mdio_read(struct fsl_pq_mdio __iomem *regs, | |||
115 | /* Grab the value of the register from miimstat */ | 152 | /* Grab the value of the register from miimstat */ |
116 | value = in_be32(®s->miimstat); | 153 | value = in_be32(®s->miimstat); |
117 | 154 | ||
155 | dev_dbg(&bus->dev, "read %04x from address %x/%x\n", value, mii_id, regnum); | ||
118 | return value; | 156 | return value; |
119 | } | 157 | } |
120 | 158 | ||
121 | static struct fsl_pq_mdio __iomem *fsl_pq_mdio_get_regs(struct mii_bus *bus) | ||
122 | { | ||
123 | struct fsl_pq_mdio_priv *priv = bus->priv; | ||
124 | |||
125 | return priv->regs; | ||
126 | } | ||
127 | |||
128 | /* | ||
129 | * Write value to the PHY at mii_id at register regnum, | ||
130 | * on the bus, waiting until the write is done before returning. | ||
131 | */ | ||
132 | int fsl_pq_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value) | ||
133 | { | ||
134 | struct fsl_pq_mdio __iomem *regs = fsl_pq_mdio_get_regs(bus); | ||
135 | |||
136 | /* Write to the local MII regs */ | ||
137 | return fsl_pq_local_mdio_write(regs, mii_id, regnum, value); | ||
138 | } | ||
139 | |||
140 | /* | ||
141 | * Read the bus for PHY at addr mii_id, register regnum, and | ||
142 | * return the value. Clears miimcom first. | ||
143 | */ | ||
144 | int fsl_pq_mdio_read(struct mii_bus *bus, int mii_id, int regnum) | ||
145 | { | ||
146 | struct fsl_pq_mdio __iomem *regs = fsl_pq_mdio_get_regs(bus); | ||
147 | |||
148 | /* Read the local MII regs */ | ||
149 | return fsl_pq_local_mdio_read(regs, mii_id, regnum); | ||
150 | } | ||
151 | |||
152 | /* Reset the MIIM registers, and wait for the bus to free */ | 159 | /* Reset the MIIM registers, and wait for the bus to free */ |
153 | static int fsl_pq_mdio_reset(struct mii_bus *bus) | 160 | static int fsl_pq_mdio_reset(struct mii_bus *bus) |
154 | { | 161 | { |
155 | struct fsl_pq_mdio __iomem *regs = fsl_pq_mdio_get_regs(bus); | 162 | struct fsl_pq_mdio_priv *priv = bus->priv; |
163 | struct fsl_pq_mii __iomem *regs = priv->regs; | ||
156 | u32 status; | 164 | u32 status; |
157 | 165 | ||
158 | mutex_lock(&bus->mdio_lock); | 166 | mutex_lock(&bus->mdio_lock); |
@@ -170,234 +178,291 @@ static int fsl_pq_mdio_reset(struct mii_bus *bus) | |||
170 | mutex_unlock(&bus->mdio_lock); | 178 | mutex_unlock(&bus->mdio_lock); |
171 | 179 | ||
172 | if (!status) { | 180 | if (!status) { |
173 | printk(KERN_ERR "%s: The MII Bus is stuck!\n", | 181 | dev_err(&bus->dev, "timeout waiting for MII bus\n"); |
174 | bus->name); | ||
175 | return -EBUSY; | 182 | return -EBUSY; |
176 | } | 183 | } |
177 | 184 | ||
178 | return 0; | 185 | return 0; |
179 | } | 186 | } |
180 | 187 | ||
181 | void fsl_pq_mdio_bus_name(char *name, struct device_node *np) | 188 | #if defined(CONFIG_GIANFAR) || defined(CONFIG_GIANFAR_MODULE) |
189 | /* | ||
190 | * This is mildly evil, but so is our hardware for doing this. | ||
191 | * Also, we have to cast back to struct gfar because of | ||
192 | * definition weirdness done in gianfar.h. | ||
193 | */ | ||
194 | static uint32_t __iomem *get_gfar_tbipa(void __iomem *p) | ||
182 | { | 195 | { |
183 | const u32 *addr; | 196 | struct gfar __iomem *enet_regs = p; |
184 | u64 taddr = OF_BAD_ADDR; | ||
185 | |||
186 | addr = of_get_address(np, 0, NULL, NULL); | ||
187 | if (addr) | ||
188 | taddr = of_translate_address(np, addr); | ||
189 | 197 | ||
190 | snprintf(name, MII_BUS_ID_SIZE, "%s@%llx", np->name, | 198 | return &enet_regs->tbipa; |
191 | (unsigned long long)taddr); | ||
192 | } | 199 | } |
193 | EXPORT_SYMBOL_GPL(fsl_pq_mdio_bus_name); | ||
194 | 200 | ||
201 | /* | ||
202 | * Return the TBIPAR address for an eTSEC2 node | ||
203 | */ | ||
204 | static uint32_t __iomem *get_etsec_tbipa(void __iomem *p) | ||
205 | { | ||
206 | return p; | ||
207 | } | ||
208 | #endif | ||
195 | 209 | ||
196 | static u32 __iomem *get_gfar_tbipa(struct fsl_pq_mdio __iomem *regs, struct device_node *np) | 210 | #if defined(CONFIG_UCC_GETH) || defined(CONFIG_UCC_GETH_MODULE) |
211 | /* | ||
212 | * Return the TBIPAR address for a QE MDIO node | ||
213 | */ | ||
214 | static uint32_t __iomem *get_ucc_tbipa(void __iomem *p) | ||
197 | { | 215 | { |
198 | #if defined(CONFIG_GIANFAR) || defined(CONFIG_GIANFAR_MODULE) | 216 | struct fsl_pq_mdio __iomem *mdio = p; |
199 | struct gfar __iomem *enet_regs; | ||
200 | 217 | ||
201 | /* | 218 | return &mdio->utbipar; |
202 | * This is mildly evil, but so is our hardware for doing this. | ||
203 | * Also, we have to cast back to struct gfar because of | ||
204 | * definition weirdness done in gianfar.h. | ||
205 | */ | ||
206 | if(of_device_is_compatible(np, "fsl,gianfar-mdio") || | ||
207 | of_device_is_compatible(np, "fsl,gianfar-tbi") || | ||
208 | of_device_is_compatible(np, "gianfar")) { | ||
209 | enet_regs = (struct gfar __iomem *)regs; | ||
210 | return &enet_regs->tbipa; | ||
211 | } else if (of_device_is_compatible(np, "fsl,etsec2-mdio") || | ||
212 | of_device_is_compatible(np, "fsl,etsec2-tbi")) { | ||
213 | return of_iomap(np, 1); | ||
214 | } | ||
215 | #endif | ||
216 | return NULL; | ||
217 | } | 219 | } |
218 | 220 | ||
219 | 221 | /* | |
220 | static int get_ucc_id_for_range(u64 start, u64 end, u32 *ucc_id) | 222 | * Find the UCC node that controls the given MDIO node |
223 | * | ||
224 | * For some reason, the QE MDIO nodes are not children of the UCC devices | ||
225 | * that control them. Therefore, we need to scan all UCC nodes looking for | ||
226 | * the one that encompases the given MDIO node. We do this by comparing | ||
227 | * physical addresses. The 'start' and 'end' addresses of the MDIO node are | ||
228 | * passed, and the correct UCC node will cover the entire address range. | ||
229 | * | ||
230 | * This assumes that there is only one QE MDIO node in the entire device tree. | ||
231 | */ | ||
232 | static void ucc_configure(phys_addr_t start, phys_addr_t end) | ||
221 | { | 233 | { |
222 | #if defined(CONFIG_UCC_GETH) || defined(CONFIG_UCC_GETH_MODULE) | 234 | static bool found_mii_master; |
223 | struct device_node *np = NULL; | 235 | struct device_node *np = NULL; |
224 | int err = 0; | ||
225 | 236 | ||
226 | for_each_compatible_node(np, NULL, "ucc_geth") { | 237 | if (found_mii_master) |
227 | struct resource tempres; | 238 | return; |
228 | 239 | ||
229 | err = of_address_to_resource(np, 0, &tempres); | 240 | for_each_compatible_node(np, NULL, "ucc_geth") { |
230 | if (err) | 241 | struct resource res; |
242 | const uint32_t *iprop; | ||
243 | uint32_t id; | ||
244 | int ret; | ||
245 | |||
246 | ret = of_address_to_resource(np, 0, &res); | ||
247 | if (ret < 0) { | ||
248 | pr_debug("fsl-pq-mdio: no address range in node %s\n", | ||
249 | np->full_name); | ||
231 | continue; | 250 | continue; |
251 | } | ||
232 | 252 | ||
233 | /* if our mdio regs fall within this UCC regs range */ | 253 | /* if our mdio regs fall within this UCC regs range */ |
234 | if ((start >= tempres.start) && (end <= tempres.end)) { | 254 | if ((start < res.start) || (end > res.end)) |
235 | /* Find the id of the UCC */ | 255 | continue; |
236 | const u32 *id; | 256 | |
237 | 257 | iprop = of_get_property(np, "cell-index", NULL); | |
238 | id = of_get_property(np, "cell-index", NULL); | 258 | if (!iprop) { |
239 | if (!id) { | 259 | iprop = of_get_property(np, "device-id", NULL); |
240 | id = of_get_property(np, "device-id", NULL); | 260 | if (!iprop) { |
241 | if (!id) | 261 | pr_debug("fsl-pq-mdio: no UCC ID in node %s\n", |
242 | continue; | 262 | np->full_name); |
263 | continue; | ||
243 | } | 264 | } |
265 | } | ||
244 | 266 | ||
245 | *ucc_id = *id; | 267 | id = be32_to_cpup(iprop); |
246 | 268 | ||
247 | return 0; | 269 | /* |
270 | * cell-index and device-id for QE nodes are | ||
271 | * numbered from 1, not 0. | ||
272 | */ | ||
273 | if (ucc_set_qe_mux_mii_mng(id - 1) < 0) { | ||
274 | pr_debug("fsl-pq-mdio: invalid UCC ID in node %s\n", | ||
275 | np->full_name); | ||
276 | continue; | ||
248 | } | 277 | } |
278 | |||
279 | pr_debug("fsl-pq-mdio: setting node UCC%u to MII master\n", id); | ||
280 | found_mii_master = true; | ||
249 | } | 281 | } |
282 | } | ||
250 | 283 | ||
251 | if (err) | ||
252 | return err; | ||
253 | else | ||
254 | return -EINVAL; | ||
255 | #else | ||
256 | return -ENODEV; | ||
257 | #endif | 284 | #endif |
258 | } | ||
259 | 285 | ||
260 | static int fsl_pq_mdio_probe(struct platform_device *ofdev) | 286 | static struct of_device_id fsl_pq_mdio_match[] = { |
287 | #if defined(CONFIG_GIANFAR) || defined(CONFIG_GIANFAR_MODULE) | ||
288 | { | ||
289 | .compatible = "fsl,gianfar-tbi", | ||
290 | .data = &(struct fsl_pq_mdio_data) { | ||
291 | .mii_offset = 0, | ||
292 | .get_tbipa = get_gfar_tbipa, | ||
293 | }, | ||
294 | }, | ||
295 | { | ||
296 | .compatible = "fsl,gianfar-mdio", | ||
297 | .data = &(struct fsl_pq_mdio_data) { | ||
298 | .mii_offset = 0, | ||
299 | .get_tbipa = get_gfar_tbipa, | ||
300 | }, | ||
301 | }, | ||
302 | { | ||
303 | .type = "mdio", | ||
304 | .compatible = "gianfar", | ||
305 | .data = &(struct fsl_pq_mdio_data) { | ||
306 | .mii_offset = offsetof(struct fsl_pq_mdio, mii), | ||
307 | .get_tbipa = get_gfar_tbipa, | ||
308 | }, | ||
309 | }, | ||
310 | { | ||
311 | .compatible = "fsl,etsec2-tbi", | ||
312 | .data = &(struct fsl_pq_mdio_data) { | ||
313 | .mii_offset = offsetof(struct fsl_pq_mdio, mii), | ||
314 | .get_tbipa = get_etsec_tbipa, | ||
315 | }, | ||
316 | }, | ||
317 | { | ||
318 | .compatible = "fsl,etsec2-mdio", | ||
319 | .data = &(struct fsl_pq_mdio_data) { | ||
320 | .mii_offset = offsetof(struct fsl_pq_mdio, mii), | ||
321 | .get_tbipa = get_etsec_tbipa, | ||
322 | }, | ||
323 | }, | ||
324 | #endif | ||
325 | #if defined(CONFIG_UCC_GETH) || defined(CONFIG_UCC_GETH_MODULE) | ||
326 | { | ||
327 | .compatible = "fsl,ucc-mdio", | ||
328 | .data = &(struct fsl_pq_mdio_data) { | ||
329 | .mii_offset = 0, | ||
330 | .get_tbipa = get_ucc_tbipa, | ||
331 | .ucc_configure = ucc_configure, | ||
332 | }, | ||
333 | }, | ||
334 | { | ||
335 | /* Legacy UCC MDIO node */ | ||
336 | .type = "mdio", | ||
337 | .compatible = "ucc_geth_phy", | ||
338 | .data = &(struct fsl_pq_mdio_data) { | ||
339 | .mii_offset = 0, | ||
340 | .get_tbipa = get_ucc_tbipa, | ||
341 | .ucc_configure = ucc_configure, | ||
342 | }, | ||
343 | }, | ||
344 | #endif | ||
345 | /* No Kconfig option for Fman support yet */ | ||
346 | { | ||
347 | .compatible = "fsl,fman-mdio", | ||
348 | .data = &(struct fsl_pq_mdio_data) { | ||
349 | .mii_offset = 0, | ||
350 | /* Fman TBI operations are handled elsewhere */ | ||
351 | }, | ||
352 | }, | ||
353 | |||
354 | {}, | ||
355 | }; | ||
356 | MODULE_DEVICE_TABLE(of, fsl_pq_mdio_match); | ||
357 | |||
358 | static int fsl_pq_mdio_probe(struct platform_device *pdev) | ||
261 | { | 359 | { |
262 | struct device_node *np = ofdev->dev.of_node; | 360 | const struct of_device_id *id = |
361 | of_match_device(fsl_pq_mdio_match, &pdev->dev); | ||
362 | const struct fsl_pq_mdio_data *data = id->data; | ||
363 | struct device_node *np = pdev->dev.of_node; | ||
364 | struct resource res; | ||
263 | struct device_node *tbi; | 365 | struct device_node *tbi; |
264 | struct fsl_pq_mdio_priv *priv; | 366 | struct fsl_pq_mdio_priv *priv; |
265 | struct fsl_pq_mdio __iomem *regs = NULL; | ||
266 | void __iomem *map; | ||
267 | u32 __iomem *tbipa; | ||
268 | struct mii_bus *new_bus; | 367 | struct mii_bus *new_bus; |
269 | int tbiaddr = -1; | ||
270 | const u32 *addrp; | ||
271 | u64 addr = 0, size = 0; | ||
272 | int err; | 368 | int err; |
273 | 369 | ||
274 | priv = kzalloc(sizeof(*priv), GFP_KERNEL); | 370 | dev_dbg(&pdev->dev, "found %s compatible node\n", id->compatible); |
275 | if (!priv) | ||
276 | return -ENOMEM; | ||
277 | 371 | ||
278 | new_bus = mdiobus_alloc(); | 372 | new_bus = mdiobus_alloc_size(sizeof(*priv)); |
279 | if (!new_bus) { | 373 | if (!new_bus) |
280 | err = -ENOMEM; | 374 | return -ENOMEM; |
281 | goto err_free_priv; | ||
282 | } | ||
283 | 375 | ||
376 | priv = new_bus->priv; | ||
284 | new_bus->name = "Freescale PowerQUICC MII Bus", | 377 | new_bus->name = "Freescale PowerQUICC MII Bus", |
285 | new_bus->read = &fsl_pq_mdio_read, | 378 | new_bus->read = &fsl_pq_mdio_read; |
286 | new_bus->write = &fsl_pq_mdio_write, | 379 | new_bus->write = &fsl_pq_mdio_write; |
287 | new_bus->reset = &fsl_pq_mdio_reset, | 380 | new_bus->reset = &fsl_pq_mdio_reset; |
288 | new_bus->priv = priv; | 381 | new_bus->irq = priv->irqs; |
289 | fsl_pq_mdio_bus_name(new_bus->id, np); | 382 | |
290 | 383 | err = of_address_to_resource(np, 0, &res); | |
291 | addrp = of_get_address(np, 0, &size, NULL); | 384 | if (err < 0) { |
292 | if (!addrp) { | 385 | dev_err(&pdev->dev, "could not obtain address information\n"); |
293 | err = -EINVAL; | 386 | goto error; |
294 | goto err_free_bus; | ||
295 | } | 387 | } |
296 | 388 | ||
297 | /* Set the PHY base address */ | 389 | snprintf(new_bus->id, MII_BUS_ID_SIZE, "%s@%llx", np->name, |
298 | addr = of_translate_address(np, addrp); | 390 | (unsigned long long)res.start); |
299 | if (addr == OF_BAD_ADDR) { | ||
300 | err = -EINVAL; | ||
301 | goto err_free_bus; | ||
302 | } | ||
303 | 391 | ||
304 | map = ioremap(addr, size); | 392 | priv->map = of_iomap(np, 0); |
305 | if (!map) { | 393 | if (!priv->map) { |
306 | err = -ENOMEM; | 394 | err = -ENOMEM; |
307 | goto err_free_bus; | 395 | goto error; |
308 | } | 396 | } |
309 | priv->map = map; | ||
310 | |||
311 | if (of_device_is_compatible(np, "fsl,gianfar-mdio") || | ||
312 | of_device_is_compatible(np, "fsl,gianfar-tbi") || | ||
313 | of_device_is_compatible(np, "fsl,ucc-mdio") || | ||
314 | of_device_is_compatible(np, "ucc_geth_phy")) | ||
315 | map -= offsetof(struct fsl_pq_mdio, miimcfg); | ||
316 | regs = map; | ||
317 | priv->regs = regs; | ||
318 | |||
319 | new_bus->irq = kcalloc(PHY_MAX_ADDR, sizeof(int), GFP_KERNEL); | ||
320 | 397 | ||
321 | if (NULL == new_bus->irq) { | 398 | /* |
322 | err = -ENOMEM; | 399 | * Some device tree nodes represent only the MII registers, and |
323 | goto err_unmap_regs; | 400 | * others represent the MAC and MII registers. The 'mii_offset' field |
401 | * contains the offset of the MII registers inside the mapped register | ||
402 | * space. | ||
403 | */ | ||
404 | if (data->mii_offset > resource_size(&res)) { | ||
405 | dev_err(&pdev->dev, "invalid register map\n"); | ||
406 | err = -EINVAL; | ||
407 | goto error; | ||
324 | } | 408 | } |
409 | priv->regs = priv->map + data->mii_offset; | ||
325 | 410 | ||
326 | new_bus->parent = &ofdev->dev; | 411 | new_bus->parent = &pdev->dev; |
327 | dev_set_drvdata(&ofdev->dev, new_bus); | 412 | dev_set_drvdata(&pdev->dev, new_bus); |
328 | |||
329 | if (of_device_is_compatible(np, "fsl,gianfar-mdio") || | ||
330 | of_device_is_compatible(np, "fsl,gianfar-tbi") || | ||
331 | of_device_is_compatible(np, "fsl,etsec2-mdio") || | ||
332 | of_device_is_compatible(np, "fsl,etsec2-tbi") || | ||
333 | of_device_is_compatible(np, "gianfar")) { | ||
334 | tbipa = get_gfar_tbipa(regs, np); | ||
335 | if (!tbipa) { | ||
336 | err = -EINVAL; | ||
337 | goto err_free_irqs; | ||
338 | } | ||
339 | } else if (of_device_is_compatible(np, "fsl,ucc-mdio") || | ||
340 | of_device_is_compatible(np, "ucc_geth_phy")) { | ||
341 | u32 id; | ||
342 | static u32 mii_mng_master; | ||
343 | |||
344 | tbipa = ®s->utbipar; | ||
345 | |||
346 | if ((err = get_ucc_id_for_range(addr, addr + size, &id))) | ||
347 | goto err_free_irqs; | ||
348 | 413 | ||
349 | if (!mii_mng_master) { | 414 | if (data->get_tbipa) { |
350 | mii_mng_master = id; | 415 | for_each_child_of_node(np, tbi) { |
351 | ucc_set_qe_mux_mii_mng(id - 1); | 416 | if (strcmp(tbi->type, "tbi-phy") == 0) { |
417 | dev_dbg(&pdev->dev, "found TBI PHY node %s\n", | ||
418 | strrchr(tbi->full_name, '/') + 1); | ||
419 | break; | ||
420 | } | ||
352 | } | 421 | } |
353 | } else { | ||
354 | err = -ENODEV; | ||
355 | goto err_free_irqs; | ||
356 | } | ||
357 | 422 | ||
358 | for_each_child_of_node(np, tbi) { | 423 | if (tbi) { |
359 | if (!strncmp(tbi->type, "tbi-phy", 8)) | 424 | const u32 *prop = of_get_property(tbi, "reg", NULL); |
360 | break; | 425 | uint32_t __iomem *tbipa; |
361 | } | ||
362 | 426 | ||
363 | if (tbi) { | 427 | if (!prop) { |
364 | const u32 *prop = of_get_property(tbi, "reg", NULL); | 428 | dev_err(&pdev->dev, |
429 | "missing 'reg' property in node %s\n", | ||
430 | tbi->full_name); | ||
431 | err = -EBUSY; | ||
432 | goto error; | ||
433 | } | ||
365 | 434 | ||
366 | if (prop) | 435 | tbipa = data->get_tbipa(priv->map); |
367 | tbiaddr = *prop; | ||
368 | 436 | ||
369 | if (tbiaddr == -1) { | 437 | out_be32(tbipa, be32_to_cpup(prop)); |
370 | err = -EBUSY; | ||
371 | goto err_free_irqs; | ||
372 | } else { | ||
373 | out_be32(tbipa, tbiaddr); | ||
374 | } | 438 | } |
375 | } | 439 | } |
376 | 440 | ||
441 | if (data->ucc_configure) | ||
442 | data->ucc_configure(res.start, res.end); | ||
443 | |||
377 | err = of_mdiobus_register(new_bus, np); | 444 | err = of_mdiobus_register(new_bus, np); |
378 | if (err) { | 445 | if (err) { |
379 | printk (KERN_ERR "%s: Cannot register as MDIO bus\n", | 446 | dev_err(&pdev->dev, "cannot register %s as MDIO bus\n", |
380 | new_bus->name); | 447 | new_bus->name); |
381 | goto err_free_irqs; | 448 | goto error; |
382 | } | 449 | } |
383 | 450 | ||
384 | return 0; | 451 | return 0; |
385 | 452 | ||
386 | err_free_irqs: | 453 | error: |
387 | kfree(new_bus->irq); | 454 | if (priv->map) |
388 | err_unmap_regs: | 455 | iounmap(priv->map); |
389 | iounmap(priv->map); | 456 | |
390 | err_free_bus: | ||
391 | kfree(new_bus); | 457 | kfree(new_bus); |
392 | err_free_priv: | 458 | |
393 | kfree(priv); | ||
394 | return err; | 459 | return err; |
395 | } | 460 | } |
396 | 461 | ||
397 | 462 | ||
398 | static int fsl_pq_mdio_remove(struct platform_device *ofdev) | 463 | static int fsl_pq_mdio_remove(struct platform_device *pdev) |
399 | { | 464 | { |
400 | struct device *device = &ofdev->dev; | 465 | struct device *device = &pdev->dev; |
401 | struct mii_bus *bus = dev_get_drvdata(device); | 466 | struct mii_bus *bus = dev_get_drvdata(device); |
402 | struct fsl_pq_mdio_priv *priv = bus->priv; | 467 | struct fsl_pq_mdio_priv *priv = bus->priv; |
403 | 468 | ||
@@ -406,41 +471,11 @@ static int fsl_pq_mdio_remove(struct platform_device *ofdev) | |||
406 | dev_set_drvdata(device, NULL); | 471 | dev_set_drvdata(device, NULL); |
407 | 472 | ||
408 | iounmap(priv->map); | 473 | iounmap(priv->map); |
409 | bus->priv = NULL; | ||
410 | mdiobus_free(bus); | 474 | mdiobus_free(bus); |
411 | kfree(priv); | ||
412 | 475 | ||
413 | return 0; | 476 | return 0; |
414 | } | 477 | } |
415 | 478 | ||
416 | static struct of_device_id fsl_pq_mdio_match[] = { | ||
417 | { | ||
418 | .type = "mdio", | ||
419 | .compatible = "ucc_geth_phy", | ||
420 | }, | ||
421 | { | ||
422 | .type = "mdio", | ||
423 | .compatible = "gianfar", | ||
424 | }, | ||
425 | { | ||
426 | .compatible = "fsl,ucc-mdio", | ||
427 | }, | ||
428 | { | ||
429 | .compatible = "fsl,gianfar-tbi", | ||
430 | }, | ||
431 | { | ||
432 | .compatible = "fsl,gianfar-mdio", | ||
433 | }, | ||
434 | { | ||
435 | .compatible = "fsl,etsec2-tbi", | ||
436 | }, | ||
437 | { | ||
438 | .compatible = "fsl,etsec2-mdio", | ||
439 | }, | ||
440 | {}, | ||
441 | }; | ||
442 | MODULE_DEVICE_TABLE(of, fsl_pq_mdio_match); | ||
443 | |||
444 | static struct platform_driver fsl_pq_mdio_driver = { | 479 | static struct platform_driver fsl_pq_mdio_driver = { |
445 | .driver = { | 480 | .driver = { |
446 | .name = "fsl-pq_mdio", | 481 | .name = "fsl-pq_mdio", |