2 * Freescale PowerQUICC Ethernet Driver -- MIIM bus implementation
3 * Provides Bus interface for MIIM regs
5 * Author: Andy Fleming <afleming@freescale.com>
6 * Modifier: Sandeep Gopalpet <sandeep.kumar@freescale.com>
8 * Copyright 2002-2004, 2008-2009 Freescale Semiconductor, Inc.
10 * Based on gianfar_mii.c and ucc_geth_mii.c (Li Yang, Kim Phillips)
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2 of the License, or (at your
15 * option) any later version.
19 #include <linux/kernel.h>
20 #include <linux/string.h>
21 #include <linux/errno.h>
22 #include <linux/unistd.h>
23 #include <linux/slab.h>
24 #include <linux/interrupt.h>
25 #include <linux/init.h>
26 #include <linux/delay.h>
27 #include <linux/netdevice.h>
28 #include <linux/etherdevice.h>
29 #include <linux/skbuff.h>
30 #include <linux/spinlock.h>
32 #include <linux/module.h>
33 #include <linux/platform_device.h>
34 #include <linux/crc32.h>
35 #include <linux/mii.h>
36 #include <linux/phy.h>
38 #include <linux/of_mdio.h>
39 #include <linux/of_platform.h>
43 #include <asm/uaccess.h>
47 #include "fsl_pq_mdio.h"
49 struct fsl_pq_mdio_priv {
51 struct fsl_pq_mdio __iomem *regs;
55 * Write value to the PHY at mii_id at register regnum,
56 * on the bus attached to the local interface, which may be different from the
57 * generic mdio bus (tied to a single interface), waiting until the write is
58 * done before returning. This is helpful in programming interfaces like
59 * the TBI which control interfaces like onchip SERDES and are always tied to
60 * the local mdio pins, which may not be the same as system mdio bus, used for
61 * controlling the external PHYs, for example.
63 int fsl_pq_local_mdio_write(struct fsl_pq_mdio __iomem *regs, int mii_id,
64 int regnum, u16 value)
66 /* Set the PHY address and the register address we want to write */
67 out_be32(®s->miimadd, (mii_id << 8) | regnum);
69 /* Write out the value we want */
70 out_be32(®s->miimcon, value);
72 /* Wait for the transaction to finish */
73 while (in_be32(®s->miimind) & MIIMIND_BUSY)
80 * Read the bus for PHY at addr mii_id, register regnum, and
81 * return the value. Clears miimcom first. All PHY operation
82 * done on the bus attached to the local interface,
83 * which may be different from the generic mdio bus
84 * This is helpful in programming interfaces like
85 * the TBI which, in turn, control interfaces like onchip SERDES
86 * and are always tied to the local mdio pins, which may not be the
87 * same as system mdio bus, used for controlling the external PHYs, for eg.
89 int fsl_pq_local_mdio_read(struct fsl_pq_mdio __iomem *regs,
90 int mii_id, int regnum)
94 /* Set the PHY address and the register address we want to read */
95 out_be32(®s->miimadd, (mii_id << 8) | regnum);
97 /* Clear miimcom, and then initiate a read */
98 out_be32(®s->miimcom, 0);
99 out_be32(®s->miimcom, MII_READ_COMMAND);
101 /* Wait for the transaction to finish */
102 while (in_be32(®s->miimind) & (MIIMIND_NOTVALID | MIIMIND_BUSY))
105 /* Grab the value of the register from miimstat */
106 value = in_be32(®s->miimstat);
111 static struct fsl_pq_mdio __iomem *fsl_pq_mdio_get_regs(struct mii_bus *bus)
113 struct fsl_pq_mdio_priv *priv = bus->priv;
119 * Write value to the PHY at mii_id at register regnum,
120 * on the bus, waiting until the write is done before returning.
122 int fsl_pq_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value)
124 struct fsl_pq_mdio __iomem *regs = fsl_pq_mdio_get_regs(bus);
126 /* Write to the local MII regs */
127 return(fsl_pq_local_mdio_write(regs, mii_id, regnum, value));
131 * Read the bus for PHY at addr mii_id, register regnum, and
132 * return the value. Clears miimcom first.
134 int fsl_pq_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
136 struct fsl_pq_mdio __iomem *regs = fsl_pq_mdio_get_regs(bus);
138 /* Read the local MII regs */
139 return(fsl_pq_local_mdio_read(regs, mii_id, regnum));
142 /* Reset the MIIM registers, and wait for the bus to free */
143 static int fsl_pq_mdio_reset(struct mii_bus *bus)
145 struct fsl_pq_mdio __iomem *regs = fsl_pq_mdio_get_regs(bus);
146 int timeout = PHY_INIT_TIMEOUT;
148 mutex_lock(&bus->mdio_lock);
150 /* Reset the management interface */
151 out_be32(®s->miimcfg, MIIMCFG_RESET);
153 /* Setup the MII Mgmt clock speed */
154 out_be32(®s->miimcfg, MIIMCFG_INIT_VALUE);
156 /* Wait until the bus is free */
157 while ((in_be32(®s->miimind) & MIIMIND_BUSY) && timeout--)
160 mutex_unlock(&bus->mdio_lock);
163 printk(KERN_ERR "%s: The MII Bus is stuck!\n",
171 void fsl_pq_mdio_bus_name(char *name, struct device_node *np)
174 u64 taddr = OF_BAD_ADDR;
176 addr = of_get_address(np, 0, NULL, NULL);
178 taddr = of_translate_address(np, addr);
180 snprintf(name, MII_BUS_ID_SIZE, "%s@%llx", np->name,
181 (unsigned long long)taddr);
183 EXPORT_SYMBOL_GPL(fsl_pq_mdio_bus_name);
185 /* Scan the bus in reverse, looking for an empty spot */
186 static int fsl_pq_mdio_find_free(struct mii_bus *new_bus)
190 for (i = PHY_MAX_ADDR; i > 0; i--) {
193 if (get_phy_id(new_bus, i, &phy_id))
196 if (phy_id == 0xffffffff)
204 #if defined(CONFIG_GIANFAR) || defined(CONFIG_GIANFAR_MODULE)
205 static u32 __iomem *get_gfar_tbipa(struct fsl_pq_mdio __iomem *regs, struct device_node *np)
207 struct gfar __iomem *enet_regs;
210 * This is mildly evil, but so is our hardware for doing this.
211 * Also, we have to cast back to struct gfar because of
212 * definition weirdness done in gianfar.h.
214 if(of_device_is_compatible(np, "fsl,gianfar-mdio") ||
215 of_device_is_compatible(np, "fsl,gianfar-tbi") ||
216 of_device_is_compatible(np, "gianfar")) {
217 enet_regs = (struct gfar __iomem *)regs;
218 return &enet_regs->tbipa;
219 } else if (of_device_is_compatible(np, "fsl,etsec2-mdio") ||
220 of_device_is_compatible(np, "fsl,etsec2-tbi")) {
221 return of_iomap(np, 1);
228 #if defined(CONFIG_UCC_GETH) || defined(CONFIG_UCC_GETH_MODULE)
229 static int get_ucc_id_for_range(u64 start, u64 end, u32 *ucc_id)
231 struct device_node *np = NULL;
234 for_each_compatible_node(np, NULL, "ucc_geth") {
235 struct resource tempres;
237 err = of_address_to_resource(np, 0, &tempres);
241 /* if our mdio regs fall within this UCC regs range */
242 if ((start >= tempres.start) && (end <= tempres.end)) {
243 /* Find the id of the UCC */
246 id = of_get_property(np, "cell-index", NULL);
248 id = of_get_property(np, "device-id", NULL);
267 static int fsl_pq_mdio_probe(struct of_device *ofdev,
268 const struct of_device_id *match)
270 struct device_node *np = ofdev->node;
271 struct device_node *tbi;
272 struct fsl_pq_mdio_priv *priv;
273 struct fsl_pq_mdio __iomem *regs = NULL;
276 struct mii_bus *new_bus;
279 u64 addr = 0, size = 0;
282 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
286 new_bus = mdiobus_alloc();
290 new_bus->name = "Freescale PowerQUICC MII Bus",
291 new_bus->read = &fsl_pq_mdio_read,
292 new_bus->write = &fsl_pq_mdio_write,
293 new_bus->reset = &fsl_pq_mdio_reset,
294 new_bus->priv = priv;
295 fsl_pq_mdio_bus_name(new_bus->id, np);
297 addrp = of_get_address(np, 0, &size, NULL);
303 /* Set the PHY base address */
304 addr = of_translate_address(np, addrp);
305 if (addr == OF_BAD_ADDR) {
310 map = ioremap(addr, size);
317 if (of_device_is_compatible(np, "fsl,gianfar-mdio") ||
318 of_device_is_compatible(np, "fsl,gianfar-tbi") ||
319 of_device_is_compatible(np, "fsl,ucc-mdio") ||
320 of_device_is_compatible(np, "ucc_geth_phy"))
321 map -= offsetof(struct fsl_pq_mdio, miimcfg);
325 new_bus->irq = kcalloc(PHY_MAX_ADDR, sizeof(int), GFP_KERNEL);
327 if (NULL == new_bus->irq) {
332 new_bus->parent = &ofdev->dev;
333 dev_set_drvdata(&ofdev->dev, new_bus);
335 if (of_device_is_compatible(np, "fsl,gianfar-mdio") ||
336 of_device_is_compatible(np, "fsl,gianfar-tbi") ||
337 of_device_is_compatible(np, "fsl,etsec2-mdio") ||
338 of_device_is_compatible(np, "fsl,etsec2-tbi") ||
339 of_device_is_compatible(np, "gianfar")) {
340 #if defined(CONFIG_GIANFAR) || defined(CONFIG_GIANFAR_MODULE)
341 tbipa = get_gfar_tbipa(regs, np);
350 } else if (of_device_is_compatible(np, "fsl,ucc-mdio") ||
351 of_device_is_compatible(np, "ucc_geth_phy")) {
352 #if defined(CONFIG_UCC_GETH) || defined(CONFIG_UCC_GETH_MODULE)
354 static u32 mii_mng_master;
356 tbipa = ®s->utbipar;
358 if ((err = get_ucc_id_for_range(addr, addr + size, &id)))
361 if (!mii_mng_master) {
363 ucc_set_qe_mux_mii_mng(id - 1);
374 for_each_child_of_node(np, tbi) {
375 if (!strncmp(tbi->type, "tbi-phy", 8))
380 const u32 *prop = of_get_property(tbi, "reg", NULL);
389 tbiaddr = fsl_pq_mdio_find_free(new_bus);
393 * We define TBIPA at 0 to be illegal, opting to fail for boards that
394 * have PHYs at 1-31, rather than change tbipa and rescan.
402 out_be32(tbipa, tbiaddr);
404 err = of_mdiobus_register(new_bus, np);
406 printk (KERN_ERR "%s: Cannot register as MDIO bus\n",
425 static int fsl_pq_mdio_remove(struct of_device *ofdev)
427 struct device *device = &ofdev->dev;
428 struct mii_bus *bus = dev_get_drvdata(device);
429 struct fsl_pq_mdio_priv *priv = bus->priv;
431 mdiobus_unregister(bus);
433 dev_set_drvdata(device, NULL);
443 static struct of_device_id fsl_pq_mdio_match[] = {
446 .compatible = "ucc_geth_phy",
450 .compatible = "gianfar",
453 .compatible = "fsl,ucc-mdio",
456 .compatible = "fsl,gianfar-tbi",
459 .compatible = "fsl,gianfar-mdio",
462 .compatible = "fsl,etsec2-tbi",
465 .compatible = "fsl,etsec2-mdio",
469 MODULE_DEVICE_TABLE(of, fsl_pq_mdio_match);
471 static struct of_platform_driver fsl_pq_mdio_driver = {
472 .name = "fsl-pq_mdio",
473 .probe = fsl_pq_mdio_probe,
474 .remove = fsl_pq_mdio_remove,
475 .match_table = fsl_pq_mdio_match,
478 int __init fsl_pq_mdio_init(void)
480 return of_register_platform_driver(&fsl_pq_mdio_driver);
482 module_init(fsl_pq_mdio_init);
484 void fsl_pq_mdio_exit(void)
486 of_unregister_platform_driver(&fsl_pq_mdio_driver);
488 module_exit(fsl_pq_mdio_exit);
489 MODULE_LICENSE("GPL");