1 /* Framework for MDIO devices, other than PHYs. 2 * 3 * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch> 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License as published by the 7 * Free Software Foundation; either version 2 of the License, or (at your 8 * option) any later version. 9 * 10 */ 11 12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 14 #include <linux/errno.h> 15 #include <linux/gpio.h> 16 #include <linux/gpio/consumer.h> 17 #include <linux/init.h> 18 #include <linux/interrupt.h> 19 #include <linux/kernel.h> 20 #include <linux/mdio.h> 21 #include <linux/mii.h> 22 #include <linux/module.h> 23 #include <linux/phy.h> 24 #include <linux/slab.h> 25 #include <linux/string.h> 26 #include <linux/unistd.h> 27 #include <linux/delay.h> 28 29 void mdio_device_free(struct mdio_device *mdiodev) 30 { 31 put_device(&mdiodev->dev); 32 } 33 EXPORT_SYMBOL(mdio_device_free); 34 35 static void mdio_device_release(struct device *dev) 36 { 37 kfree(to_mdio_device(dev)); 38 } 39 40 int mdio_device_bus_match(struct device *dev, struct device_driver *drv) 41 { 42 struct mdio_device *mdiodev = to_mdio_device(dev); 43 struct mdio_driver *mdiodrv = to_mdio_driver(drv); 44 45 if (mdiodrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY) 46 return 0; 47 48 return strcmp(mdiodev->modalias, drv->name) == 0; 49 } 50 51 struct mdio_device *mdio_device_create(struct mii_bus *bus, int addr) 52 { 53 struct mdio_device *mdiodev; 54 55 /* We allocate the device, and initialize the default values */ 56 mdiodev = kzalloc(sizeof(*mdiodev), GFP_KERNEL); 57 if (!mdiodev) 58 return ERR_PTR(-ENOMEM); 59 60 mdiodev->dev.release = mdio_device_release; 61 mdiodev->dev.parent = &bus->dev; 62 mdiodev->dev.bus = &mdio_bus_type; 63 mdiodev->device_free = mdio_device_free; 64 mdiodev->device_remove = mdio_device_remove; 65 mdiodev->bus = bus; 66 mdiodev->addr = addr; 67 68 dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr); 69 70 device_initialize(&mdiodev->dev); 71 72 return mdiodev; 73 } 74 EXPORT_SYMBOL(mdio_device_create); 75 76 /** 77 * mdio_device_register - Register the mdio device on the MDIO bus 78 * @mdiodev: mdio_device structure to be added to the MDIO bus 79 */ 80 int mdio_device_register(struct mdio_device *mdiodev) 81 { 82 int err; 83 84 dev_dbg(&mdiodev->dev, "mdio_device_register\n"); 85 86 err = mdiobus_register_device(mdiodev); 87 if (err) 88 return err; 89 90 err = device_add(&mdiodev->dev); 91 if (err) { 92 pr_err("MDIO %d failed to add\n", mdiodev->addr); 93 goto out; 94 } 95 96 return 0; 97 98 out: 99 mdiobus_unregister_device(mdiodev); 100 return err; 101 } 102 EXPORT_SYMBOL(mdio_device_register); 103 104 /** 105 * mdio_device_remove - Remove a previously registered mdio device from the 106 * MDIO bus 107 * @mdiodev: mdio_device structure to remove 108 * 109 * This doesn't free the mdio_device itself, it merely reverses the effects 110 * of mdio_device_register(). Use mdio_device_free() to free the device 111 * after calling this function. 112 */ 113 void mdio_device_remove(struct mdio_device *mdiodev) 114 { 115 device_del(&mdiodev->dev); 116 mdiobus_unregister_device(mdiodev); 117 } 118 EXPORT_SYMBOL(mdio_device_remove); 119 120 void mdio_device_reset(struct mdio_device *mdiodev, int value) 121 { 122 unsigned int d; 123 124 if (!mdiodev->reset) 125 return; 126 127 gpiod_set_value(mdiodev->reset, value); 128 129 d = value ? mdiodev->reset_assert_delay : mdiodev->reset_deassert_delay; 130 if (d) 131 usleep_range(d, d + max_t(unsigned int, d / 10, 100)); 132 } 133 EXPORT_SYMBOL(mdio_device_reset); 134 135 /** 136 * mdio_probe - probe an MDIO device 137 * @dev: device to probe 138 * 139 * Description: Take care of setting up the mdio_device structure 140 * and calling the driver to probe the device. 141 */ 142 static int mdio_probe(struct device *dev) 143 { 144 struct mdio_device *mdiodev = to_mdio_device(dev); 145 struct device_driver *drv = mdiodev->dev.driver; 146 struct mdio_driver *mdiodrv = to_mdio_driver(drv); 147 int err = 0; 148 149 if (mdiodrv->probe) { 150 /* Deassert the reset signal */ 151 mdio_device_reset(mdiodev, 0); 152 153 err = mdiodrv->probe(mdiodev); 154 if (err) { 155 /* Assert the reset signal */ 156 mdio_device_reset(mdiodev, 1); 157 } 158 } 159 160 return err; 161 } 162 163 static int mdio_remove(struct device *dev) 164 { 165 struct mdio_device *mdiodev = to_mdio_device(dev); 166 struct device_driver *drv = mdiodev->dev.driver; 167 struct mdio_driver *mdiodrv = to_mdio_driver(drv); 168 169 if (mdiodrv->remove) { 170 mdiodrv->remove(mdiodev); 171 172 /* Assert the reset signal */ 173 mdio_device_reset(mdiodev, 1); 174 } 175 176 return 0; 177 } 178 179 /** 180 * mdio_driver_register - register an mdio_driver with the MDIO layer 181 * @new_driver: new mdio_driver to register 182 */ 183 int mdio_driver_register(struct mdio_driver *drv) 184 { 185 struct mdio_driver_common *mdiodrv = &drv->mdiodrv; 186 int retval; 187 188 pr_debug("mdio_driver_register: %s\n", mdiodrv->driver.name); 189 190 mdiodrv->driver.bus = &mdio_bus_type; 191 mdiodrv->driver.probe = mdio_probe; 192 mdiodrv->driver.remove = mdio_remove; 193 194 retval = driver_register(&mdiodrv->driver); 195 if (retval) { 196 pr_err("%s: Error %d in registering driver\n", 197 mdiodrv->driver.name, retval); 198 199 return retval; 200 } 201 202 return 0; 203 } 204 EXPORT_SYMBOL(mdio_driver_register); 205 206 void mdio_driver_unregister(struct mdio_driver *drv) 207 { 208 struct mdio_driver_common *mdiodrv = &drv->mdiodrv; 209 210 driver_unregister(&mdiodrv->driver); 211 } 212 EXPORT_SYMBOL(mdio_driver_unregister); 213