Blame view
drivers/net/fsl_pq_mdio.c
11.4 KB
1577ecef7
|
1 2 3 4 5 |
/* * Freescale PowerQUICC Ethernet Driver -- MIIM bus implementation * Provides Bus interface for MIIM regs * * Author: Andy Fleming <afleming@freescale.com> |
1d2397d74
|
6 |
* Modifier: Sandeep Gopalpet <sandeep.kumar@freescale.com> |
1577ecef7
|
7 |
* |
1d2397d74
|
8 |
* Copyright 2002-2004, 2008-2009 Freescale Semiconductor, Inc. |
1577ecef7
|
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
* * Based on gianfar_mii.c and ucc_geth_mii.c (Li Yang, Kim Phillips) * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the * Free Software Foundation; either version 2 of the License, or (at your * option) any later version. * */ #include <linux/kernel.h> #include <linux/string.h> #include <linux/errno.h> #include <linux/unistd.h> #include <linux/slab.h> #include <linux/interrupt.h> #include <linux/init.h> #include <linux/delay.h> #include <linux/netdevice.h> #include <linux/etherdevice.h> #include <linux/skbuff.h> #include <linux/spinlock.h> #include <linux/mm.h> #include <linux/module.h> #include <linux/platform_device.h> #include <linux/crc32.h> #include <linux/mii.h> #include <linux/phy.h> #include <linux/of.h> |
324931ba2
|
38 |
#include <linux/of_mdio.h> |
1577ecef7
|
39 40 41 42 43 44 45 46 47 |
#include <linux/of_platform.h> #include <asm/io.h> #include <asm/irq.h> #include <asm/uaccess.h> #include <asm/ucc.h> #include "gianfar.h" #include "fsl_pq_mdio.h" |
b3319b105
|
48 49 50 51 |
struct fsl_pq_mdio_priv { void __iomem *map; struct fsl_pq_mdio __iomem *regs; }; |
1577ecef7
|
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 |
/* * Write value to the PHY at mii_id at register regnum, * on the bus attached to the local interface, which may be different from the * generic mdio bus (tied to a single interface), waiting until the write is * done before returning. This is helpful in programming interfaces like * the TBI which control interfaces like onchip SERDES and are always tied to * the local mdio pins, which may not be the same as system mdio bus, used for * controlling the external PHYs, for example. */ int fsl_pq_local_mdio_write(struct fsl_pq_mdio __iomem *regs, int mii_id, int regnum, u16 value) { /* Set the PHY address and the register address we want to write */ out_be32(®s->miimadd, (mii_id << 8) | regnum); /* Write out the value we want */ out_be32(®s->miimcon, value); /* Wait for the transaction to finish */ while (in_be32(®s->miimind) & MIIMIND_BUSY) cpu_relax(); return 0; } /* * Read the bus for PHY at addr mii_id, register regnum, and * return the value. Clears miimcom first. All PHY operation * done on the bus attached to the local interface, * which may be different from the generic mdio bus * This is helpful in programming interfaces like * the TBI which, in turn, control interfaces like onchip SERDES * and are always tied to the local mdio pins, which may not be the * same as system mdio bus, used for controlling the external PHYs, for eg. */ int fsl_pq_local_mdio_read(struct fsl_pq_mdio __iomem *regs, int mii_id, int regnum) { u16 value; /* Set the PHY address and the register address we want to read */ out_be32(®s->miimadd, (mii_id << 8) | regnum); /* Clear miimcom, and then initiate a read */ out_be32(®s->miimcom, 0); out_be32(®s->miimcom, MII_READ_COMMAND); /* Wait for the transaction to finish */ while (in_be32(®s->miimind) & (MIIMIND_NOTVALID | MIIMIND_BUSY)) cpu_relax(); /* Grab the value of the register from miimstat */ value = in_be32(®s->miimstat); return value; } |
6748f60b9
|
108 109 |
static struct fsl_pq_mdio __iomem *fsl_pq_mdio_get_regs(struct mii_bus *bus) { |
b3319b105
|
110 111 112 |
struct fsl_pq_mdio_priv *priv = bus->priv; return priv->regs; |
6748f60b9
|
113 |
} |
1577ecef7
|
114 115 116 117 118 119 |
/* * Write value to the PHY at mii_id at register regnum, * on the bus, waiting until the write is done before returning. */ int fsl_pq_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value) { |
6748f60b9
|
120 |
struct fsl_pq_mdio __iomem *regs = fsl_pq_mdio_get_regs(bus); |
1577ecef7
|
121 122 123 124 125 126 127 128 129 130 131 |
/* Write to the local MII regs */ return(fsl_pq_local_mdio_write(regs, mii_id, regnum, value)); } /* * Read the bus for PHY at addr mii_id, register regnum, and * return the value. Clears miimcom first. */ int fsl_pq_mdio_read(struct mii_bus *bus, int mii_id, int regnum) { |
6748f60b9
|
132 |
struct fsl_pq_mdio __iomem *regs = fsl_pq_mdio_get_regs(bus); |
1577ecef7
|
133 134 135 136 137 138 139 140 |
/* Read the local MII regs */ return(fsl_pq_local_mdio_read(regs, mii_id, regnum)); } /* Reset the MIIM registers, and wait for the bus to free */ static int fsl_pq_mdio_reset(struct mii_bus *bus) { |
6748f60b9
|
141 |
struct fsl_pq_mdio __iomem *regs = fsl_pq_mdio_get_regs(bus); |
508827ff0
|
142 |
int timeout = PHY_INIT_TIMEOUT; |
1577ecef7
|
143 144 145 146 147 148 149 150 151 152 153 154 155 156 |
mutex_lock(&bus->mdio_lock); /* Reset the management interface */ out_be32(®s->miimcfg, MIIMCFG_RESET); /* Setup the MII Mgmt clock speed */ out_be32(®s->miimcfg, MIIMCFG_INIT_VALUE); /* Wait until the bus is free */ while ((in_be32(®s->miimind) & MIIMIND_BUSY) && timeout--) cpu_relax(); mutex_unlock(&bus->mdio_lock); |
508827ff0
|
157 |
if (timeout < 0) { |
1577ecef7
|
158 159 160 161 162 163 164 165 |
printk(KERN_ERR "%s: The MII Bus is stuck! ", bus->name); return -EBUSY; } return 0; } |
1577ecef7
|
166 167 |
void fsl_pq_mdio_bus_name(char *name, struct device_node *np) { |
18f27383d
|
168 169 |
const u32 *addr; u64 taddr = OF_BAD_ADDR; |
1577ecef7
|
170 |
|
18f27383d
|
171 172 173 |
addr = of_get_address(np, 0, NULL, NULL); if (addr) taddr = of_translate_address(np, addr); |
1577ecef7
|
174 |
|
18f27383d
|
175 176 |
snprintf(name, MII_BUS_ID_SIZE, "%s@%llx", np->name, (unsigned long long)taddr); |
1577ecef7
|
177 |
} |
b6bc978b3
|
178 |
EXPORT_SYMBOL_GPL(fsl_pq_mdio_bus_name); |
1577ecef7
|
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 |
/* Scan the bus in reverse, looking for an empty spot */ static int fsl_pq_mdio_find_free(struct mii_bus *new_bus) { int i; for (i = PHY_MAX_ADDR; i > 0; i--) { u32 phy_id; if (get_phy_id(new_bus, i, &phy_id)) return -1; if (phy_id == 0xffffffff) break; } return i; } |
e2a61fa31
|
197 |
#if defined(CONFIG_GIANFAR) || defined(CONFIG_GIANFAR_MODULE) |
1d2397d74
|
198 |
static u32 __iomem *get_gfar_tbipa(struct fsl_pq_mdio __iomem *regs, struct device_node *np) |
1577ecef7
|
199 200 |
{ struct gfar __iomem *enet_regs; |
1d2397d74
|
201 202 |
u32 __iomem *ioremap_tbipa; u64 addr, size; |
1577ecef7
|
203 204 205 206 207 208 |
/* * This is mildly evil, but so is our hardware for doing this. * Also, we have to cast back to struct gfar because of * definition weirdness done in gianfar.h. */ |
1d2397d74
|
209 210 211 212 213 214 215 216 217 218 219 220 |
if(of_device_is_compatible(np, "fsl,gianfar-mdio") || of_device_is_compatible(np, "fsl,gianfar-tbi") || of_device_is_compatible(np, "gianfar")) { enet_regs = (struct gfar __iomem *)regs; return &enet_regs->tbipa; } else if (of_device_is_compatible(np, "fsl,etsec2-mdio") || of_device_is_compatible(np, "fsl,etsec2-tbi")) { addr = of_translate_address(np, of_get_address(np, 1, &size, NULL)); ioremap_tbipa = ioremap(addr, size); return ioremap_tbipa; } else return NULL; |
1577ecef7
|
221 222 |
} #endif |
e2a61fa31
|
223 |
#if defined(CONFIG_UCC_GETH) || defined(CONFIG_UCC_GETH_MODULE) |
1577ecef7
|
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 |
static int get_ucc_id_for_range(u64 start, u64 end, u32 *ucc_id) { struct device_node *np = NULL; int err = 0; for_each_compatible_node(np, NULL, "ucc_geth") { struct resource tempres; err = of_address_to_resource(np, 0, &tempres); if (err) continue; /* if our mdio regs fall within this UCC regs range */ if ((start >= tempres.start) && (end <= tempres.end)) { /* Find the id of the UCC */ const u32 *id; id = of_get_property(np, "cell-index", NULL); if (!id) { id = of_get_property(np, "device-id", NULL); if (!id) continue; } *ucc_id = *id; return 0; } } if (err) return err; else return -EINVAL; } #endif static int fsl_pq_mdio_probe(struct of_device *ofdev, const struct of_device_id *match) { struct device_node *np = ofdev->node; struct device_node *tbi; |
b3319b105
|
267 |
struct fsl_pq_mdio_priv *priv; |
1d2397d74
|
268 |
struct fsl_pq_mdio __iomem *regs = NULL; |
2951d64e7
|
269 |
void __iomem *map; |
1577ecef7
|
270 271 272 |
u32 __iomem *tbipa; struct mii_bus *new_bus; int tbiaddr = -1; |
2951d64e7
|
273 |
u64 addr = 0, size = 0; |
1577ecef7
|
274 |
int err = 0; |
b3319b105
|
275 276 277 |
priv = kzalloc(sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; |
1577ecef7
|
278 279 |
new_bus = mdiobus_alloc(); if (NULL == new_bus) |
b3319b105
|
280 |
goto err_free_priv; |
1577ecef7
|
281 282 283 284 285 |
new_bus->name = "Freescale PowerQUICC MII Bus", new_bus->read = &fsl_pq_mdio_read, new_bus->write = &fsl_pq_mdio_write, new_bus->reset = &fsl_pq_mdio_reset, |
b3319b105
|
286 |
new_bus->priv = priv; |
1577ecef7
|
287 288 289 |
fsl_pq_mdio_bus_name(new_bus->id, np); /* Set the PHY base address */ |
2951d64e7
|
290 291 292 |
addr = of_translate_address(np, of_get_address(np, 0, &size, NULL)); map = ioremap(addr, size); if (!map) { |
1577ecef7
|
293 294 295 |
err = -ENOMEM; goto err_free_bus; } |
b3319b105
|
296 |
priv->map = map; |
1577ecef7
|
297 |
|
2951d64e7
|
298 299 300 301 302 303 |
if (of_device_is_compatible(np, "fsl,gianfar-mdio") || of_device_is_compatible(np, "fsl,gianfar-tbi") || of_device_is_compatible(np, "fsl,ucc-mdio") || of_device_is_compatible(np, "ucc_geth_phy")) map -= offsetof(struct fsl_pq_mdio, miimcfg); regs = map; |
b3319b105
|
304 |
priv->regs = regs; |
1577ecef7
|
305 |
|
324931ba2
|
306 |
new_bus->irq = kcalloc(PHY_MAX_ADDR, sizeof(int), GFP_KERNEL); |
1577ecef7
|
307 308 309 310 311 312 313 314 315 316 |
if (NULL == new_bus->irq) { err = -ENOMEM; goto err_unmap_regs; } new_bus->parent = &ofdev->dev; dev_set_drvdata(&ofdev->dev, new_bus); if (of_device_is_compatible(np, "fsl,gianfar-mdio") || |
301968451
|
317 |
of_device_is_compatible(np, "fsl,gianfar-tbi") || |
1d2397d74
|
318 319 |
of_device_is_compatible(np, "fsl,etsec2-mdio") || of_device_is_compatible(np, "fsl,etsec2-tbi") || |
1577ecef7
|
320 |
of_device_is_compatible(np, "gianfar")) { |
e2a61fa31
|
321 |
#if defined(CONFIG_GIANFAR) || defined(CONFIG_GIANFAR_MODULE) |
1d2397d74
|
322 323 324 325 326 |
tbipa = get_gfar_tbipa(regs, np); if (!tbipa) { err = -EINVAL; goto err_free_irqs; } |
1577ecef7
|
327 328 329 330 331 332 |
#else err = -ENODEV; goto err_free_irqs; #endif } else if (of_device_is_compatible(np, "fsl,ucc-mdio") || of_device_is_compatible(np, "ucc_geth_phy")) { |
e2a61fa31
|
333 |
#if defined(CONFIG_UCC_GETH) || defined(CONFIG_UCC_GETH_MODULE) |
1577ecef7
|
334 |
u32 id; |
fbcc0e2ce
|
335 |
static u32 mii_mng_master; |
1577ecef7
|
336 337 338 339 340 |
tbipa = ®s->utbipar; if ((err = get_ucc_id_for_range(addr, addr + size, &id))) goto err_free_irqs; |
fbcc0e2ce
|
341 342 343 344 |
if (!mii_mng_master) { mii_mng_master = id; ucc_set_qe_mux_mii_mng(id - 1); } |
1577ecef7
|
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 |
#else err = -ENODEV; goto err_free_irqs; #endif } else { err = -ENODEV; goto err_free_irqs; } for_each_child_of_node(np, tbi) { if (!strncmp(tbi->type, "tbi-phy", 8)) break; } if (tbi) { const u32 *prop = of_get_property(tbi, "reg", NULL); if (prop) tbiaddr = *prop; } if (tbiaddr == -1) { out_be32(tbipa, 0); tbiaddr = fsl_pq_mdio_find_free(new_bus); } /* * We define TBIPA at 0 to be illegal, opting to fail for boards that * have PHYs at 1-31, rather than change tbipa and rescan. */ if (tbiaddr == 0) { err = -EBUSY; goto err_free_irqs; } out_be32(tbipa, tbiaddr); |
324931ba2
|
383 |
err = of_mdiobus_register(new_bus, np); |
1577ecef7
|
384 385 386 387 388 389 390 391 392 393 394 395 |
if (err) { printk (KERN_ERR "%s: Cannot register as MDIO bus ", new_bus->name); goto err_free_irqs; } return 0; err_free_irqs: kfree(new_bus->irq); err_unmap_regs: |
b3319b105
|
396 |
iounmap(priv->map); |
1577ecef7
|
397 398 |
err_free_bus: kfree(new_bus); |
b3319b105
|
399 400 |
err_free_priv: kfree(priv); |
1577ecef7
|
401 402 403 404 405 406 407 408 |
return err; } static int fsl_pq_mdio_remove(struct of_device *ofdev) { struct device *device = &ofdev->dev; struct mii_bus *bus = dev_get_drvdata(device); |
b3319b105
|
409 |
struct fsl_pq_mdio_priv *priv = bus->priv; |
1577ecef7
|
410 411 412 413 |
mdiobus_unregister(bus); dev_set_drvdata(device, NULL); |
b3319b105
|
414 |
iounmap(priv->map); |
1577ecef7
|
415 416 |
bus->priv = NULL; mdiobus_free(bus); |
b3319b105
|
417 |
kfree(priv); |
1577ecef7
|
418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 |
return 0; } static struct of_device_id fsl_pq_mdio_match[] = { { .type = "mdio", .compatible = "ucc_geth_phy", }, { .type = "mdio", .compatible = "gianfar", }, { .compatible = "fsl,ucc-mdio", }, { .compatible = "fsl,gianfar-tbi", }, { .compatible = "fsl,gianfar-mdio", }, |
1d2397d74
|
440 441 442 443 444 445 |
{ .compatible = "fsl,etsec2-tbi", }, { .compatible = "fsl,etsec2-mdio", }, |
1577ecef7
|
446 447 |
{}, }; |
e72701acb
|
448 |
MODULE_DEVICE_TABLE(of, fsl_pq_mdio_match); |
1577ecef7
|
449 450 451 452 453 454 455 456 457 458 459 460 |
static struct of_platform_driver fsl_pq_mdio_driver = { .name = "fsl-pq_mdio", .probe = fsl_pq_mdio_probe, .remove = fsl_pq_mdio_remove, .match_table = fsl_pq_mdio_match, }; int __init fsl_pq_mdio_init(void) { return of_register_platform_driver(&fsl_pq_mdio_driver); } |
434e7b0d1
|
461 |
module_init(fsl_pq_mdio_init); |
1577ecef7
|
462 463 464 465 466 |
void fsl_pq_mdio_exit(void) { of_unregister_platform_driver(&fsl_pq_mdio_driver); } |
1577ecef7
|
467 |
module_exit(fsl_pq_mdio_exit); |
260628977
|
468 |
MODULE_LICENSE("GPL"); |