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