blob: f3706e415b45323e8de205581b6ed4a57e8ea51b [file] [log] [blame]
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001/*
Andy Flemingbb40dcb2005-09-23 22:54:21 -04002 * drivers/net/gianfar_mii.c
3 *
4 * Gianfar Ethernet Driver -- MIIM bus implementation
5 * Provides Bus interface for MIIM regs
6 *
7 * Author: Andy Fleming
Kumar Gala4c8d3d92005-11-13 16:06:30 -08008 * Maintainer: Kumar Gala
Andy Flemingbb40dcb2005-09-23 22:54:21 -04009 *
10 * Copyright (c) 2002-2004 Freescale Semiconductor, Inc.
11 *
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.
16 *
17 */
18
Andy Flemingbb40dcb2005-09-23 22:54:21 -040019#include <linux/kernel.h>
Andy Flemingbb40dcb2005-09-23 22:54:21 -040020#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>
31#include <linux/mm.h>
32#include <linux/module.h>
Russell Kingd052d1b2005-10-29 19:07:23 +010033#include <linux/platform_device.h>
Andy Flemingbb40dcb2005-09-23 22:54:21 -040034#include <linux/crc32.h>
35#include <linux/mii.h>
36#include <linux/phy.h>
Andy Flemingb31a1d82008-12-16 15:29:15 -080037#include <linux/of.h>
38#include <linux/of_platform.h>
Andy Flemingbb40dcb2005-09-23 22:54:21 -040039
40#include <asm/io.h>
41#include <asm/irq.h>
42#include <asm/uaccess.h>
43
44#include "gianfar.h"
45#include "gianfar_mii.h"
46
Kapil Junejad3c12872007-05-11 18:25:11 -050047/*
48 * Write value to the PHY at mii_id at register regnum,
49 * on the bus attached to the local interface, which may be different from the
50 * generic mdio bus (tied to a single interface), waiting until the write is
51 * done before returning. This is helpful in programming interfaces like
52 * the TBI which control interfaces like onchip SERDES and are always tied to
53 * the local mdio pins, which may not be the same as system mdio bus, used for
54 * controlling the external PHYs, for example.
55 */
Al Virofdb26622008-02-13 03:58:36 +000056int gfar_local_mdio_write(struct gfar_mii __iomem *regs, int mii_id,
Kapil Junejad3c12872007-05-11 18:25:11 -050057 int regnum, u16 value)
Andy Flemingbb40dcb2005-09-23 22:54:21 -040058{
Andy Flemingbb40dcb2005-09-23 22:54:21 -040059 /* Set the PHY address and the register address we want to write */
60 gfar_write(&regs->miimadd, (mii_id << 8) | regnum);
61
62 /* Write out the value we want */
63 gfar_write(&regs->miimcon, value);
64
65 /* Wait for the transaction to finish */
66 while (gfar_read(&regs->miimind) & MIIMIND_BUSY)
67 cpu_relax();
68
69 return 0;
70}
71
Kapil Junejad3c12872007-05-11 18:25:11 -050072/*
73 * Read the bus for PHY at addr mii_id, register regnum, and
74 * return the value. Clears miimcom first. All PHY operation
75 * done on the bus attached to the local interface,
76 * which may be different from the generic mdio bus
77 * This is helpful in programming interfaces like
78 * the TBI which, inturn, control interfaces like onchip SERDES
79 * and are always tied to the local mdio pins, which may not be the
80 * same as system mdio bus, used for controlling the external PHYs, for eg.
81 */
Al Virofdb26622008-02-13 03:58:36 +000082int gfar_local_mdio_read(struct gfar_mii __iomem *regs, int mii_id, int regnum)
Andy Flemingbb40dcb2005-09-23 22:54:21 -040083{
Andy Flemingbb40dcb2005-09-23 22:54:21 -040084 u16 value;
85
86 /* Set the PHY address and the register address we want to read */
87 gfar_write(&regs->miimadd, (mii_id << 8) | regnum);
88
89 /* Clear miimcom, and then initiate a read */
90 gfar_write(&regs->miimcom, 0);
91 gfar_write(&regs->miimcom, MII_READ_COMMAND);
92
93 /* Wait for the transaction to finish */
94 while (gfar_read(&regs->miimind) & (MIIMIND_NOTVALID | MIIMIND_BUSY))
95 cpu_relax();
96
97 /* Grab the value of the register from miimstat */
98 value = gfar_read(&regs->miimstat);
99
100 return value;
101}
102
Kapil Junejad3c12872007-05-11 18:25:11 -0500103/* Write value to the PHY at mii_id at register regnum,
104 * on the bus, waiting until the write is done before returning.
105 * All PHY configuration is done through the TSEC1 MIIM regs */
106int gfar_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value)
107{
108 struct gfar_mii __iomem *regs = (void __iomem *)bus->priv;
109
110 /* Write to the local MII regs */
111 return(gfar_local_mdio_write(regs, mii_id, regnum, value));
112}
113
114/* Read the bus for PHY at addr mii_id, register regnum, and
115 * return the value. Clears miimcom first. All PHY
116 * configuration has to be done through the TSEC1 MIIM regs */
117int gfar_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
118{
119 struct gfar_mii __iomem *regs = (void __iomem *)bus->priv;
120
121 /* Read the local MII regs */
122 return(gfar_local_mdio_read(regs, mii_id, regnum));
123}
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400124
125/* Reset the MIIM registers, and wait for the bus to free */
Paul Gortmakerd0313582008-04-17 00:08:10 -0400126static int gfar_mdio_reset(struct mii_bus *bus)
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400127{
Kumar Galacc8c6e32006-02-01 15:18:03 -0600128 struct gfar_mii __iomem *regs = (void __iomem *)bus->priv;
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400129 unsigned int timeout = PHY_INIT_TIMEOUT;
130
Andy Fleming15cf6dd2008-02-05 16:35:30 -0600131 mutex_lock(&bus->mdio_lock);
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400132
133 /* Reset the management interface */
134 gfar_write(&regs->miimcfg, MIIMCFG_RESET);
135
136 /* Setup the MII Mgmt clock speed */
137 gfar_write(&regs->miimcfg, MIIMCFG_INIT_VALUE);
138
139 /* Wait until the bus is free */
140 while ((gfar_read(&regs->miimind) & MIIMIND_BUSY) &&
Trent Piephobaac03d2008-09-22 10:03:56 -0700141 --timeout)
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400142 cpu_relax();
143
Andy Fleming15cf6dd2008-02-05 16:35:30 -0600144 mutex_unlock(&bus->mdio_lock);
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400145
Trent Piephobaac03d2008-09-22 10:03:56 -0700146 if(timeout == 0) {
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400147 printk(KERN_ERR "%s: The MII Bus is stuck!\n",
148 bus->name);
149 return -EBUSY;
150 }
151
152 return 0;
153}
154
Andy Flemingb31a1d82008-12-16 15:29:15 -0800155/* Allocate an array which provides irq #s for each PHY on the given bus */
156static int *create_irq_map(struct device_node *np)
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400157{
Andy Flemingb31a1d82008-12-16 15:29:15 -0800158 int *irqs;
159 int i;
160 struct device_node *child = NULL;
161
162 irqs = kcalloc(PHY_MAX_ADDR, sizeof(int), GFP_KERNEL);
163
164 if (!irqs)
165 return NULL;
166
167 for (i = 0; i < PHY_MAX_ADDR; i++)
168 irqs[i] = PHY_POLL;
169
170 while ((child = of_get_next_child(np, child)) != NULL) {
171 int irq = irq_of_parse_and_map(child, 0);
172 const u32 *id;
173
174 if (irq == NO_IRQ)
175 continue;
176
177 id = of_get_property(child, "reg", NULL);
178
179 if (!id)
180 continue;
181
182 if (*id < PHY_MAX_ADDR && *id >= 0)
183 irqs[*id] = irq;
184 else
185 printk(KERN_WARNING "%s: "
186 "%d is not a valid PHY address\n",
187 np->full_name, *id);
188 }
189
190 return irqs;
191}
192
193
194void gfar_mdio_bus_name(char *name, struct device_node *np)
195{
196 const u32 *reg;
197
198 reg = of_get_property(np, "reg", NULL);
199
200 snprintf(name, MII_BUS_ID_SIZE, "%s@%x", np->name, reg ? *reg : 0);
201}
202
203/* Scan the bus in reverse, looking for an empty spot */
204static int gfar_mdio_find_free(struct mii_bus *new_bus)
205{
206 int i;
207
208 for (i = PHY_MAX_ADDR; i > 0; i--) {
209 u32 phy_id;
210
211 if (get_phy_id(new_bus, i, &phy_id))
212 return -1;
213
214 if (phy_id == 0xffffffff)
215 break;
216 }
217
218 return i;
219}
220
221static int gfar_mdio_probe(struct of_device *ofdev,
222 const struct of_device_id *match)
223{
Kumar Galacc8c6e32006-02-01 15:18:03 -0600224 struct gfar_mii __iomem *regs;
Paul Gortmakerd0313582008-04-17 00:08:10 -0400225 struct gfar __iomem *enet_regs;
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400226 struct mii_bus *new_bus;
Andy Flemingb31a1d82008-12-16 15:29:15 -0800227 int err = 0;
228 u64 addr, size;
229 struct device_node *np = ofdev->node;
230 struct device_node *tbi;
231 int tbiaddr = -1;
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400232
Lennert Buytenhek298cf9be2008-10-08 16:29:57 -0700233 new_bus = mdiobus_alloc();
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400234 if (NULL == new_bus)
235 return -ENOMEM;
236
237 new_bus->name = "Gianfar MII Bus",
238 new_bus->read = &gfar_mdio_read,
239 new_bus->write = &gfar_mdio_write,
240 new_bus->reset = &gfar_mdio_reset,
Andy Flemingb31a1d82008-12-16 15:29:15 -0800241 gfar_mdio_bus_name(new_bus->id, np);
Kumar Gala1d532672006-01-11 11:27:32 -0800242
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400243 /* Set the PHY base address */
Andy Flemingb31a1d82008-12-16 15:29:15 -0800244 addr = of_translate_address(np, of_get_address(np, 0, &size, NULL));
245 regs = ioremap(addr, size);
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400246
247 if (NULL == regs) {
248 err = -ENOMEM;
Andy Flemingb31a1d82008-12-16 15:29:15 -0800249 goto err_free_bus;
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400250 }
251
Kumar Galacc8c6e32006-02-01 15:18:03 -0600252 new_bus->priv = (void __force *)regs;
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400253
Andy Flemingb31a1d82008-12-16 15:29:15 -0800254 new_bus->irq = create_irq_map(np);
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400255
Andy Flemingb31a1d82008-12-16 15:29:15 -0800256 if (new_bus->irq == NULL) {
257 err = -ENOMEM;
258 goto err_unmap_regs;
259 }
260
261 new_bus->parent = &ofdev->dev;
262 dev_set_drvdata(&ofdev->dev, new_bus);
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400263
Paul Gortmakerd0313582008-04-17 00:08:10 -0400264 /*
265 * This is mildly evil, but so is our hardware for doing this.
266 * Also, we have to cast back to struct gfar_mii because of
267 * definition weirdness done in gianfar.h.
268 */
269 enet_regs = (struct gfar __iomem *)
270 ((char *)regs - offsetof(struct gfar, gfar_mii_regs));
271
Andy Flemingb31a1d82008-12-16 15:29:15 -0800272 for_each_child_of_node(np, tbi) {
273 if (!strncmp(tbi->type, "tbi-phy", 8))
Paul Gortmakerd0313582008-04-17 00:08:10 -0400274 break;
275 }
276
Andy Flemingb31a1d82008-12-16 15:29:15 -0800277 if (tbi) {
278 const u32 *prop = of_get_property(tbi, "reg", NULL);
Andy Flemingac7198b2008-09-22 14:10:25 -0700279
Andy Flemingb31a1d82008-12-16 15:29:15 -0800280 if (prop)
281 tbiaddr = *prop;
Andy Flemingac7198b2008-09-22 14:10:25 -0700282 }
Paul Gortmakerd0313582008-04-17 00:08:10 -0400283
Andy Flemingb31a1d82008-12-16 15:29:15 -0800284 if (tbiaddr == -1) {
285 gfar_write(&enet_regs->tbipa, 0);
286
287 tbiaddr = gfar_mdio_find_free(new_bus);
288 }
289
290 /*
291 * We define TBIPA at 0 to be illegal, opting to fail for boards that
292 * have PHYs at 1-31, rather than change tbipa and rescan.
293 */
294 if (tbiaddr == 0) {
295 err = -EBUSY;
296
297 goto err_free_irqs;
298 }
299
300 gfar_write(&enet_regs->tbipa, tbiaddr);
301
302 /*
303 * The TBIPHY-only buses will find PHYs at every address,
304 * so we mask them all but the TBI
305 */
306 if (!of_device_is_compatible(np, "fsl,gianfar-mdio"))
307 new_bus->phy_mask = ~(1 << tbiaddr);
Paul Gortmakerd0313582008-04-17 00:08:10 -0400308
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400309 err = mdiobus_register(new_bus);
310
Andy Flemingb31a1d82008-12-16 15:29:15 -0800311 if (err != 0) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400312 printk (KERN_ERR "%s: Cannot register as MDIO bus\n",
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400313 new_bus->name);
Andy Flemingb31a1d82008-12-16 15:29:15 -0800314 goto err_free_irqs;
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400315 }
316
317 return 0;
318
Andy Flemingb31a1d82008-12-16 15:29:15 -0800319err_free_irqs:
320 kfree(new_bus->irq);
321err_unmap_regs:
Kumar Galacc8c6e32006-02-01 15:18:03 -0600322 iounmap(regs);
Andy Flemingb31a1d82008-12-16 15:29:15 -0800323err_free_bus:
Lennert Buytenhek298cf9be2008-10-08 16:29:57 -0700324 mdiobus_free(new_bus);
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400325
326 return err;
327}
328
329
Andy Flemingb31a1d82008-12-16 15:29:15 -0800330static int gfar_mdio_remove(struct of_device *ofdev)
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400331{
Andy Flemingb31a1d82008-12-16 15:29:15 -0800332 struct mii_bus *bus = dev_get_drvdata(&ofdev->dev);
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400333
334 mdiobus_unregister(bus);
335
Andy Flemingb31a1d82008-12-16 15:29:15 -0800336 dev_set_drvdata(&ofdev->dev, NULL);
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400337
Kumar Galacc8c6e32006-02-01 15:18:03 -0600338 iounmap((void __iomem *)bus->priv);
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400339 bus->priv = NULL;
Andy Flemingb31a1d82008-12-16 15:29:15 -0800340 kfree(bus->irq);
Lennert Buytenhek298cf9be2008-10-08 16:29:57 -0700341 mdiobus_free(bus);
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400342
343 return 0;
344}
345
Andy Flemingb31a1d82008-12-16 15:29:15 -0800346static struct of_device_id gfar_mdio_match[] =
347{
348 {
349 .compatible = "fsl,gianfar-mdio",
350 },
351 {
352 .compatible = "fsl,gianfar-tbi",
353 },
354 {
355 .type = "mdio",
356 .compatible = "gianfar",
357 },
358 {},
359};
360
361static struct of_platform_driver gianfar_mdio_driver = {
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400362 .name = "fsl-gianfar_mdio",
Andy Flemingb31a1d82008-12-16 15:29:15 -0800363 .match_table = gfar_mdio_match,
364
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400365 .probe = gfar_mdio_probe,
366 .remove = gfar_mdio_remove,
367};
368
369int __init gfar_mdio_init(void)
370{
Andy Flemingb31a1d82008-12-16 15:29:15 -0800371 return of_register_platform_driver(&gianfar_mdio_driver);
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400372}
373
Kumar Galab9daf6c2007-07-26 00:52:34 -0500374void gfar_mdio_exit(void)
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400375{
Andy Flemingb31a1d82008-12-16 15:29:15 -0800376 of_unregister_platform_driver(&gianfar_mdio_driver);
Andy Flemingbb40dcb2005-09-23 22:54:21 -0400377}