2 * GPIO based MDIO bitbang driver.
3 * Supports OpenFirmware.
5 * Copyright (c) 2008 CSE Semaphore Belgium.
6 * by Laurent Pinchart <laurentp@cse-semaphore.com>
8 * Copyright (C) 2008, Paulius Zaleckas <paulius.zaleckas@teltonika.lt>
10 * Based on earlier work by
12 * Copyright (c) 2003 Intracom S.A.
13 * by Pantelis Antoniou <panto@intracom.gr>
15 * 2005 (c) MontaVista Software, Inc.
16 * Vitaly Bordug <vbordug@ru.mvista.com>
18 * This file is licensed under the terms of the GNU General Public License
19 * version 2. This program is licensed "as is" without any warranty of any
20 * kind, whether express or implied.
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <linux/interrupt.h>
26 #include <linux/platform_device.h>
27 #include <linux/gpio.h>
28 #include <linux/platform_data/mdio-gpio.h>
30 #include <linux/of_gpio.h>
31 #include <linux/of_mdio.h>
33 struct mdio_gpio_info {
34 struct mdiobb_ctrl ctrl;
35 struct gpio_desc *mdc, *mdio, *mdo;
36 int mdc_active_low, mdio_active_low, mdo_active_low;
39 static void *mdio_gpio_of_get_data(struct platform_device *pdev)
41 struct device_node *np = pdev->dev.of_node;
42 struct mdio_gpio_platform_data *pdata;
43 enum of_gpio_flags flags;
46 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
50 ret = of_get_gpio_flags(np, 0, &flags);
55 pdata->mdc_active_low = flags & OF_GPIO_ACTIVE_LOW;
57 ret = of_get_gpio_flags(np, 1, &flags);
61 pdata->mdio_active_low = flags & OF_GPIO_ACTIVE_LOW;
63 ret = of_get_gpio_flags(np, 2, &flags);
66 pdata->mdo_active_low = flags & OF_GPIO_ACTIVE_LOW;
72 static void mdio_dir(struct mdiobb_ctrl *ctrl, int dir)
74 struct mdio_gpio_info *bitbang =
75 container_of(ctrl, struct mdio_gpio_info, ctrl);
78 /* Separate output pin. Always set its value to high
79 * when changing direction. If direction is input,
80 * assume the pin serves as pull-up. If direction is
81 * output, the default value is high.
83 gpiod_set_value(bitbang->mdo, 1 ^ bitbang->mdo_active_low);
88 gpiod_direction_output(bitbang->mdio,
89 1 ^ bitbang->mdio_active_low);
91 gpiod_direction_input(bitbang->mdio);
94 static int mdio_get(struct mdiobb_ctrl *ctrl)
96 struct mdio_gpio_info *bitbang =
97 container_of(ctrl, struct mdio_gpio_info, ctrl);
99 return gpiod_get_value(bitbang->mdio) ^ bitbang->mdio_active_low;
102 static void mdio_set(struct mdiobb_ctrl *ctrl, int what)
104 struct mdio_gpio_info *bitbang =
105 container_of(ctrl, struct mdio_gpio_info, ctrl);
108 gpiod_set_value(bitbang->mdo, what ^ bitbang->mdo_active_low);
110 gpiod_set_value(bitbang->mdio, what ^ bitbang->mdio_active_low);
113 static void mdc_set(struct mdiobb_ctrl *ctrl, int what)
115 struct mdio_gpio_info *bitbang =
116 container_of(ctrl, struct mdio_gpio_info, ctrl);
118 gpiod_set_value(bitbang->mdc, what ^ bitbang->mdc_active_low);
121 static struct mdiobb_ops mdio_gpio_ops = {
122 .owner = THIS_MODULE,
124 .set_mdio_dir = mdio_dir,
125 .set_mdio_data = mdio_set,
126 .get_mdio_data = mdio_get,
129 static struct mii_bus *mdio_gpio_bus_init(struct device *dev,
130 struct mdio_gpio_platform_data *pdata,
133 struct mii_bus *new_bus;
134 struct mdio_gpio_info *bitbang;
137 unsigned long mdc_flags = GPIOF_OUT_INIT_LOW;
138 unsigned long mdio_flags = GPIOF_DIR_IN;
139 unsigned long mdo_flags = GPIOF_OUT_INIT_HIGH;
141 bitbang = devm_kzalloc(dev, sizeof(*bitbang), GFP_KERNEL);
145 bitbang->ctrl.ops = &mdio_gpio_ops;
146 bitbang->ctrl.reset = pdata->reset;
148 bitbang->mdc = gpio_to_desc(mdc);
149 bitbang->mdc_active_low = pdata->mdc_active_low;
151 bitbang->mdio = gpio_to_desc(mdio);
152 bitbang->mdio_active_low = pdata->mdio_active_low;
155 bitbang->mdo = gpio_to_desc(mdo);
156 bitbang->mdo_active_low = pdata->mdo_active_low;
158 new_bus = alloc_mdio_bitbang(&bitbang->ctrl);
162 new_bus->name = "GPIO Bitbanged MDIO",
164 new_bus->phy_mask = pdata->phy_mask;
165 new_bus->phy_ignore_ta_mask = pdata->phy_ignore_ta_mask;
166 memcpy(new_bus->irq, pdata->irqs, sizeof(new_bus->irq));
167 new_bus->parent = dev;
169 if (new_bus->phy_mask == ~0)
172 for (i = 0; i < PHY_MAX_ADDR; i++)
173 if (!new_bus->irq[i])
174 new_bus->irq[i] = PHY_POLL;
177 snprintf(new_bus->id, MII_BUS_ID_SIZE, "gpio-%x", bus_id);
179 strncpy(new_bus->id, "gpio", MII_BUS_ID_SIZE);
181 if (devm_gpio_request_one(dev, mdc, mdc_flags, "mdc"))
184 if (devm_gpio_request_one(dev, mdio, mdio_flags, "mdio"))
187 if (mdo && devm_gpio_request_one(dev, mdo, mdo_flags, "mdo"))
190 dev_set_drvdata(dev, new_bus);
195 free_mdio_bitbang(new_bus);
200 static void mdio_gpio_bus_deinit(struct device *dev)
202 struct mii_bus *bus = dev_get_drvdata(dev);
204 free_mdio_bitbang(bus);
207 static void mdio_gpio_bus_destroy(struct device *dev)
209 struct mii_bus *bus = dev_get_drvdata(dev);
211 mdiobus_unregister(bus);
212 mdio_gpio_bus_deinit(dev);
215 static int mdio_gpio_probe(struct platform_device *pdev)
217 struct mdio_gpio_platform_data *pdata;
218 struct mii_bus *new_bus;
221 if (pdev->dev.of_node) {
222 pdata = mdio_gpio_of_get_data(pdev);
223 bus_id = of_alias_get_id(pdev->dev.of_node, "mdio-gpio");
225 dev_warn(&pdev->dev, "failed to get alias id\n");
229 pdata = dev_get_platdata(&pdev->dev);
236 new_bus = mdio_gpio_bus_init(&pdev->dev, pdata, bus_id);
240 if (pdev->dev.of_node)
241 ret = of_mdiobus_register(new_bus, pdev->dev.of_node);
243 ret = mdiobus_register(new_bus);
246 mdio_gpio_bus_deinit(&pdev->dev);
251 static int mdio_gpio_remove(struct platform_device *pdev)
253 mdio_gpio_bus_destroy(&pdev->dev);
258 static const struct of_device_id mdio_gpio_of_match[] = {
259 { .compatible = "virtual,mdio-gpio", },
262 MODULE_DEVICE_TABLE(of, mdio_gpio_of_match);
264 static struct platform_driver mdio_gpio_driver = {
265 .probe = mdio_gpio_probe,
266 .remove = mdio_gpio_remove,
269 .of_match_table = mdio_gpio_of_match,
273 module_platform_driver(mdio_gpio_driver);
275 MODULE_ALIAS("platform:mdio-gpio");
276 MODULE_AUTHOR("Laurent Pinchart, Paulius Zaleckas");
277 MODULE_LICENSE("GPL");
278 MODULE_DESCRIPTION("Generic driver for MDIO bus emulation using GPIO");