2 * Driver for the MDIO interface of Marvell network interfaces.
4 * Since the MDIO interface of Marvell network interfaces is shared
5 * between all network interfaces, having a single driver allows to
6 * handle concurrent accesses properly (you may have four Ethernet
7 * ports, but they in fact share the same SMI interface to access
8 * the MDIO bus). This driver is currently used by the mvneta and
11 * Copyright (C) 2012 Marvell
13 * Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
15 * This file is licensed under the terms of the GNU General Public
16 * License version 2. This program is licensed "as is" without any
17 * warranty of any kind, whether express or implied.
20 #include <linux/clk.h>
21 #include <linux/delay.h>
22 #include <linux/interrupt.h>
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/of_mdio.h>
27 #include <linux/phy.h>
28 #include <linux/platform_device.h>
29 #include <linux/sched.h>
30 #include <linux/wait.h>
32 #define MVMDIO_SMI_DATA_SHIFT 0
33 #define MVMDIO_SMI_PHY_ADDR_SHIFT 16
34 #define MVMDIO_SMI_PHY_REG_SHIFT 21
35 #define MVMDIO_SMI_READ_OPERATION BIT(26)
36 #define MVMDIO_SMI_WRITE_OPERATION 0
37 #define MVMDIO_SMI_READ_VALID BIT(27)
38 #define MVMDIO_SMI_BUSY BIT(28)
39 #define MVMDIO_ERR_INT_CAUSE 0x007C
40 #define MVMDIO_ERR_INT_SMI_DONE 0x00000010
41 #define MVMDIO_ERR_INT_MASK 0x0080
44 * SMI Timeout measurements:
45 * - Kirkwood 88F6281 (Globalscale Dreamplug): 45us to 95us (Interrupt)
46 * - Armada 370 (Globalscale Mirabox): 41us to 43us (Polled)
48 #define MVMDIO_SMI_TIMEOUT 1000 /* 1000us = 1ms */
49 #define MVMDIO_SMI_POLL_INTERVAL_MIN 45
50 #define MVMDIO_SMI_POLL_INTERVAL_MAX 55
52 struct orion_mdio_dev
{
56 * If we have access to the error interrupt pin (which is
57 * somewhat misnamed as it not only reflects internal errors
58 * but also reflects SMI completion), use that to wait for
59 * SMI access completion instead of polling the SMI busy bit.
62 wait_queue_head_t smi_busy_wait
;
65 struct orion_mdio_ops
{
66 int (*is_done
)(struct orion_mdio_dev
*);
67 unsigned int poll_interval_min
;
68 unsigned int poll_interval_max
;
71 /* Wait for the SMI unit to be ready for another operation
73 static int orion_mdio_wait_ready(const struct orion_mdio_ops
*ops
,
76 struct orion_mdio_dev
*dev
= bus
->priv
;
77 unsigned long timeout
= usecs_to_jiffies(MVMDIO_SMI_TIMEOUT
);
78 unsigned long end
= jiffies
+ timeout
;
82 if (ops
->is_done(dev
))
87 if (dev
->err_interrupt
<= 0) {
88 usleep_range(ops
->poll_interval_min
,
89 ops
->poll_interval_max
);
91 if (time_is_before_jiffies(end
))
94 /* wait_event_timeout does not guarantee a delay of at
95 * least one whole jiffie, so timeout must be no less
100 wait_event_timeout(dev
->smi_busy_wait
,
101 ops
->is_done(dev
), timeout
);
107 dev_err(bus
->parent
, "Timeout: SMI busy for too long\n");
111 static int orion_mdio_smi_is_done(struct orion_mdio_dev
*dev
)
113 return !(readl(dev
->regs
) & MVMDIO_SMI_BUSY
);
116 static const struct orion_mdio_ops orion_mdio_smi_ops
= {
117 .is_done
= orion_mdio_smi_is_done
,
118 .poll_interval_min
= MVMDIO_SMI_POLL_INTERVAL_MIN
,
119 .poll_interval_max
= MVMDIO_SMI_POLL_INTERVAL_MAX
,
122 static int orion_mdio_read(struct mii_bus
*bus
, int mii_id
,
125 struct orion_mdio_dev
*dev
= bus
->priv
;
129 if (regnum
& MII_ADDR_C45
)
132 ret
= orion_mdio_wait_ready(&orion_mdio_smi_ops
, bus
);
136 writel(((mii_id
<< MVMDIO_SMI_PHY_ADDR_SHIFT
) |
137 (regnum
<< MVMDIO_SMI_PHY_REG_SHIFT
) |
138 MVMDIO_SMI_READ_OPERATION
),
141 ret
= orion_mdio_wait_ready(&orion_mdio_smi_ops
, bus
);
145 val
= readl(dev
->regs
);
146 if (!(val
& MVMDIO_SMI_READ_VALID
)) {
147 dev_err(bus
->parent
, "SMI bus read not valid\n");
152 ret
= val
& GENMASK(15, 0);
157 static int orion_mdio_write(struct mii_bus
*bus
, int mii_id
,
158 int regnum
, u16 value
)
160 struct orion_mdio_dev
*dev
= bus
->priv
;
163 if (regnum
& MII_ADDR_C45
)
166 ret
= orion_mdio_wait_ready(&orion_mdio_smi_ops
, bus
);
170 writel(((mii_id
<< MVMDIO_SMI_PHY_ADDR_SHIFT
) |
171 (regnum
<< MVMDIO_SMI_PHY_REG_SHIFT
) |
172 MVMDIO_SMI_WRITE_OPERATION
|
173 (value
<< MVMDIO_SMI_DATA_SHIFT
)),
180 static irqreturn_t
orion_mdio_err_irq(int irq
, void *dev_id
)
182 struct orion_mdio_dev
*dev
= dev_id
;
184 if (readl(dev
->regs
+ MVMDIO_ERR_INT_CAUSE
) &
185 MVMDIO_ERR_INT_SMI_DONE
) {
186 writel(~MVMDIO_ERR_INT_SMI_DONE
,
187 dev
->regs
+ MVMDIO_ERR_INT_CAUSE
);
188 wake_up(&dev
->smi_busy_wait
);
195 static int orion_mdio_probe(struct platform_device
*pdev
)
199 struct orion_mdio_dev
*dev
;
202 r
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
204 dev_err(&pdev
->dev
, "No SMI register address given\n");
208 bus
= devm_mdiobus_alloc_size(&pdev
->dev
,
209 sizeof(struct orion_mdio_dev
));
213 bus
->name
= "orion_mdio_bus";
214 bus
->read
= orion_mdio_read
;
215 bus
->write
= orion_mdio_write
;
216 snprintf(bus
->id
, MII_BUS_ID_SIZE
, "%s-mii",
217 dev_name(&pdev
->dev
));
218 bus
->parent
= &pdev
->dev
;
221 dev
->regs
= devm_ioremap(&pdev
->dev
, r
->start
, resource_size(r
));
223 dev_err(&pdev
->dev
, "Unable to remap SMI register\n");
227 init_waitqueue_head(&dev
->smi_busy_wait
);
229 for (i
= 0; i
< ARRAY_SIZE(dev
->clk
); i
++) {
230 dev
->clk
[i
] = of_clk_get(pdev
->dev
.of_node
, i
);
231 if (IS_ERR(dev
->clk
[i
]))
233 clk_prepare_enable(dev
->clk
[i
]);
236 dev
->err_interrupt
= platform_get_irq(pdev
, 0);
237 if (dev
->err_interrupt
> 0 &&
238 resource_size(r
) < MVMDIO_ERR_INT_MASK
+ 4) {
240 "disabling interrupt, resource size is too small\n");
241 dev
->err_interrupt
= 0;
243 if (dev
->err_interrupt
> 0) {
244 ret
= devm_request_irq(&pdev
->dev
, dev
->err_interrupt
,
246 IRQF_SHARED
, pdev
->name
, dev
);
250 writel(MVMDIO_ERR_INT_SMI_DONE
,
251 dev
->regs
+ MVMDIO_ERR_INT_MASK
);
253 } else if (dev
->err_interrupt
== -EPROBE_DEFER
) {
254 return -EPROBE_DEFER
;
257 if (pdev
->dev
.of_node
)
258 ret
= of_mdiobus_register(bus
, pdev
->dev
.of_node
);
260 ret
= mdiobus_register(bus
);
262 dev_err(&pdev
->dev
, "Cannot register MDIO bus (%d)\n", ret
);
266 platform_set_drvdata(pdev
, bus
);
271 if (dev
->err_interrupt
> 0)
272 writel(0, dev
->regs
+ MVMDIO_ERR_INT_MASK
);
274 for (i
= 0; i
< ARRAY_SIZE(dev
->clk
); i
++) {
275 if (IS_ERR(dev
->clk
[i
]))
277 clk_disable_unprepare(dev
->clk
[i
]);
278 clk_put(dev
->clk
[i
]);
284 static int orion_mdio_remove(struct platform_device
*pdev
)
286 struct mii_bus
*bus
= platform_get_drvdata(pdev
);
287 struct orion_mdio_dev
*dev
= bus
->priv
;
290 if (dev
->err_interrupt
> 0)
291 writel(0, dev
->regs
+ MVMDIO_ERR_INT_MASK
);
292 mdiobus_unregister(bus
);
294 for (i
= 0; i
< ARRAY_SIZE(dev
->clk
); i
++) {
295 if (IS_ERR(dev
->clk
[i
]))
297 clk_disable_unprepare(dev
->clk
[i
]);
298 clk_put(dev
->clk
[i
]);
304 static const struct of_device_id orion_mdio_match
[] = {
305 { .compatible
= "marvell,orion-mdio" },
308 MODULE_DEVICE_TABLE(of
, orion_mdio_match
);
310 static struct platform_driver orion_mdio_driver
= {
311 .probe
= orion_mdio_probe
,
312 .remove
= orion_mdio_remove
,
314 .name
= "orion-mdio",
315 .of_match_table
= orion_mdio_match
,
319 module_platform_driver(orion_mdio_driver
);
321 MODULE_DESCRIPTION("Marvell MDIO interface driver");
322 MODULE_AUTHOR("Thomas Petazzoni <thomas.petazzoni@free-electrons.com>");
323 MODULE_LICENSE("GPL");
324 MODULE_ALIAS("platform:orion-mdio");