1/* 2 * GPIO based MDIO bitbang driver. 3 * Supports OpenFirmware. 4 * 5 * Copyright (c) 2008 CSE Semaphore Belgium. 6 * by Laurent Pinchart <laurentp@cse-semaphore.com> 7 * 8 * Copyright (C) 2008, Paulius Zaleckas <paulius.zaleckas@teltonika.lt> 9 * 10 * Based on earlier work by 11 * 12 * Copyright (c) 2003 Intracom S.A. 13 * by Pantelis Antoniou <panto@intracom.gr> 14 * 15 * 2005 (c) MontaVista Software, Inc. 16 * Vitaly Bordug <vbordug@ru.mvista.com> 17 * 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. 21 */ 22 23#include <linux/module.h> 24#include <linux/slab.h> 25#include <linux/init.h> 26#include <linux/interrupt.h> 27#include <linux/platform_device.h> 28#include <linux/gpio.h> 29#include <linux/mdio-gpio.h> 30 31#ifdef CONFIG_OF_GPIO 32#include <linux/of_gpio.h> 33#include <linux/of_mdio.h> 34#include <linux/of_platform.h> 35#endif 36 37struct mdio_gpio_info { 38 struct mdiobb_ctrl ctrl; 39 int mdc, mdio; 40}; 41 42static void mdio_dir(struct mdiobb_ctrl *ctrl, int dir) 43{ 44 struct mdio_gpio_info *bitbang = 45 container_of(ctrl, struct mdio_gpio_info, ctrl); 46 47 if (dir) 48 gpio_direction_output(bitbang->mdio, 1); 49 else 50 gpio_direction_input(bitbang->mdio); 51} 52 53static int mdio_get(struct mdiobb_ctrl *ctrl) 54{ 55 struct mdio_gpio_info *bitbang = 56 container_of(ctrl, struct mdio_gpio_info, ctrl); 57 58 return gpio_get_value(bitbang->mdio); 59} 60 61static void mdio_set(struct mdiobb_ctrl *ctrl, int what) 62{ 63 struct mdio_gpio_info *bitbang = 64 container_of(ctrl, struct mdio_gpio_info, ctrl); 65 66 gpio_set_value(bitbang->mdio, what); 67} 68 69static void mdc_set(struct mdiobb_ctrl *ctrl, int what) 70{ 71 struct mdio_gpio_info *bitbang = 72 container_of(ctrl, struct mdio_gpio_info, ctrl); 73 74 gpio_set_value(bitbang->mdc, what); 75} 76 77static struct mdiobb_ops mdio_gpio_ops = { 78 .owner = THIS_MODULE, 79 .set_mdc = mdc_set, 80 .set_mdio_dir = mdio_dir, 81 .set_mdio_data = mdio_set, 82 .get_mdio_data = mdio_get, 83}; 84 85static struct mii_bus * __devinit mdio_gpio_bus_init(struct device *dev, 86 struct mdio_gpio_platform_data *pdata, 87 int bus_id) 88{ 89 struct mii_bus *new_bus; 90 struct mdio_gpio_info *bitbang; 91 int i; 92 93 bitbang = kzalloc(sizeof(*bitbang), GFP_KERNEL); 94 if (!bitbang) 95 goto out; 96 97 bitbang->ctrl.ops = &mdio_gpio_ops; 98 bitbang->mdc = pdata->mdc; 99 bitbang->mdio = pdata->mdio; 100 101 new_bus = alloc_mdio_bitbang(&bitbang->ctrl); 102 if (!new_bus) 103 goto out_free_bitbang; 104 105 new_bus->name = "GPIO Bitbanged MDIO", 106 107 new_bus->phy_mask = pdata->phy_mask; 108 new_bus->irq = pdata->irqs; 109 new_bus->parent = dev; 110 111 if (new_bus->phy_mask == ~0) 112 goto out_free_bus; 113 114 for (i = 0; i < PHY_MAX_ADDR; i++) 115 if (!new_bus->irq[i]) 116 new_bus->irq[i] = PHY_POLL; 117 118 snprintf(new_bus->id, MII_BUS_ID_SIZE, "%x", bus_id); 119 120 if (gpio_request(bitbang->mdc, "mdc")) 121 goto out_free_bus; 122 123 if (gpio_request(bitbang->mdio, "mdio")) 124 goto out_free_mdc; 125 126 gpio_direction_output(bitbang->mdc, 0); 127 128 dev_set_drvdata(dev, new_bus); 129 130 return new_bus; 131 132out_free_mdc: 133 gpio_free(bitbang->mdc); 134out_free_bus: 135 free_mdio_bitbang(new_bus); 136out_free_bitbang: 137 kfree(bitbang); 138out: 139 return NULL; 140} 141 142static void mdio_gpio_bus_deinit(struct device *dev) 143{ 144 struct mii_bus *bus = dev_get_drvdata(dev); 145 struct mdio_gpio_info *bitbang = bus->priv; 146 147 dev_set_drvdata(dev, NULL); 148 gpio_free(bitbang->mdio); 149 gpio_free(bitbang->mdc); 150 free_mdio_bitbang(bus); 151 kfree(bitbang); 152} 153 154static void __devexit mdio_gpio_bus_destroy(struct device *dev) 155{ 156 struct mii_bus *bus = dev_get_drvdata(dev); 157 158 mdiobus_unregister(bus); 159 mdio_gpio_bus_deinit(dev); 160} 161 162static int __devinit mdio_gpio_probe(struct platform_device *pdev) 163{ 164 struct mdio_gpio_platform_data *pdata = pdev->dev.platform_data; 165 struct mii_bus *new_bus; 166 int ret; 167 168 if (!pdata) 169 return -ENODEV; 170 171 new_bus = mdio_gpio_bus_init(&pdev->dev, pdata, pdev->id); 172 if (!new_bus) 173 return -ENODEV; 174 175 ret = mdiobus_register(new_bus); 176 if (ret) 177 mdio_gpio_bus_deinit(&pdev->dev); 178 179 return ret; 180} 181 182static int __devexit mdio_gpio_remove(struct platform_device *pdev) 183{ 184 mdio_gpio_bus_destroy(&pdev->dev); 185 186 return 0; 187} 188 189#ifdef CONFIG_OF_GPIO 190 191static int __devinit mdio_ofgpio_probe(struct platform_device *ofdev, 192 const struct of_device_id *match) 193{ 194 struct mdio_gpio_platform_data *pdata; 195 struct mii_bus *new_bus; 196 int ret; 197 198 pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); 199 if (!pdata) 200 return -ENOMEM; 201 202 ret = of_get_gpio(ofdev->dev.of_node, 0); 203 if (ret < 0) 204 goto out_free; 205 pdata->mdc = ret; 206 207 ret = of_get_gpio(ofdev->dev.of_node, 1); 208 if (ret < 0) 209 goto out_free; 210 pdata->mdio = ret; 211 212 new_bus = mdio_gpio_bus_init(&ofdev->dev, pdata, pdata->mdc); 213 if (!new_bus) 214 goto out_free; 215 216 ret = of_mdiobus_register(new_bus, ofdev->dev.of_node); 217 if (ret) 218 mdio_gpio_bus_deinit(&ofdev->dev); 219 220 return ret; 221 222out_free: 223 kfree(pdata); 224 return -ENODEV; 225} 226 227static int __devexit mdio_ofgpio_remove(struct platform_device *ofdev) 228{ 229 mdio_gpio_bus_destroy(&ofdev->dev); 230 kfree(ofdev->dev.platform_data); 231 232 return 0; 233} 234 235static struct of_device_id mdio_ofgpio_match[] = { 236 { 237 .compatible = "virtual,mdio-gpio", 238 }, 239 {}, 240}; 241MODULE_DEVICE_TABLE(of, mdio_ofgpio_match); 242 243static struct of_platform_driver mdio_ofgpio_driver = { 244 .driver = { 245 .name = "mdio-gpio", 246 .owner = THIS_MODULE, 247 .of_match_table = mdio_ofgpio_match, 248 }, 249 .probe = mdio_ofgpio_probe, 250 .remove = __devexit_p(mdio_ofgpio_remove), 251}; 252 253static inline int __init mdio_ofgpio_init(void) 254{ 255 return of_register_platform_driver(&mdio_ofgpio_driver); 256} 257 258static inline void __exit mdio_ofgpio_exit(void) 259{ 260 of_unregister_platform_driver(&mdio_ofgpio_driver); 261} 262#else 263static inline int __init mdio_ofgpio_init(void) { return 0; } 264static inline void __exit mdio_ofgpio_exit(void) { } 265#endif /* CONFIG_OF_GPIO */ 266 267static struct platform_driver mdio_gpio_driver = { 268 .probe = mdio_gpio_probe, 269 .remove = __devexit_p(mdio_gpio_remove), 270 .driver = { 271 .name = "mdio-gpio", 272 .owner = THIS_MODULE, 273 }, 274}; 275 276static int __init mdio_gpio_init(void) 277{ 278 int ret; 279 280 ret = mdio_ofgpio_init(); 281 if (ret) 282 return ret; 283 284 ret = platform_driver_register(&mdio_gpio_driver); 285 if (ret) 286 mdio_ofgpio_exit(); 287 288 return ret; 289} 290module_init(mdio_gpio_init); 291 292static void __exit mdio_gpio_exit(void) 293{ 294 platform_driver_unregister(&mdio_gpio_driver); 295 mdio_ofgpio_exit(); 296} 297module_exit(mdio_gpio_exit); 298 299MODULE_ALIAS("platform:mdio-gpio"); 300MODULE_AUTHOR("Laurent Pinchart, Paulius Zaleckas"); 301MODULE_LICENSE("GPL"); 302MODULE_DESCRIPTION("Generic driver for MDIO bus emulation using GPIO"); 303