drivers/net/phy/mdio_device.c

   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);