mdio: Add support for mdio drivers.
authorAndrew Lunn <andrew@lunn.ch>
Wed, 6 Jan 2016 19:11:26 +0000 (20:11 +0100)
committerDavid S. Miller <davem@davemloft.net>
Thu, 7 Jan 2016 19:31:27 +0000 (14:31 -0500)
Not all devices on an MDIO bus are PHYs. Meaning not all MDIO drivers
are PHY drivers. Add support for generic MDIO drivers.

Signed-off-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
drivers/net/phy/Makefile
drivers/net/phy/mdio_bus.c
drivers/net/phy/mdio_device.c [new file with mode: 0644]
drivers/net/phy/phy_device.c
drivers/of/of_mdio.c
include/linux/mdio.h
include/linux/phy.h

index f31a4e25cf151a58efd594daeb2ec09724c39279..680e88f9915af6990320ce5e607656f8770d8ddf 100644 (file)
@@ -1,6 +1,6 @@
 # Makefile for Linux PHY drivers
 
-libphy-objs                    := phy.o phy_device.o mdio_bus.o
+libphy-objs                    := phy.o phy_device.o mdio_bus.o mdio_device.o
 
 obj-$(CONFIG_PHYLIB)           += libphy.o
 obj-$(CONFIG_AQUANTIA_PHY)     += aquantia.o
index 6f9ca51446db3f3089a39ca6095909dea84003f8..0573cfd2116f746412259388bb4a9baf0878a52a 100644 (file)
@@ -357,16 +357,25 @@ EXPORT_SYMBOL(__mdiobus_register);
 
 void mdiobus_unregister(struct mii_bus *bus)
 {
+       struct mdio_device *mdiodev;
+       struct phy_device *phydev;
        int i;
 
        BUG_ON(bus->state != MDIOBUS_REGISTERED);
        bus->state = MDIOBUS_UNREGISTERED;
 
        for (i = 0; i < PHY_MAX_ADDR; i++) {
-               struct phy_device *phydev = mdiobus_get_phy(bus, i);
-               if (phydev) {
+               mdiodev = bus->mdio_map[i];
+               if (!mdiodev)
+                       continue;
+
+               if (!(mdiodev->flags & MDIO_DEVICE_FLAG_PHY)) {
+                       phydev = container_of(mdiodev, struct phy_device, mdio);
                        phy_device_remove(phydev);
                        phy_device_free(phydev);
+               } else {
+                       mdio_device_remove(mdiodev);
+                       mdio_device_free(mdiodev);
                }
        }
        device_del(&bus->dev);
diff --git a/drivers/net/phy/mdio_device.c b/drivers/net/phy/mdio_device.c
new file mode 100644 (file)
index 0000000..64e3777
--- /dev/null
@@ -0,0 +1,169 @@
+/* Framework for MDIO devices, other than PHYs.
+ *
+ * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/mdio.h>
+#include <linux/mii.h>
+#include <linux/module.h>
+#include <linux/phy.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/unistd.h>
+
+void mdio_device_free(struct mdio_device *mdiodev)
+{
+       put_device(&mdiodev->dev);
+}
+EXPORT_SYMBOL(mdio_device_free);
+
+static void mdio_device_release(struct device *dev)
+{
+       kfree(to_mdio_device(dev));
+}
+
+struct mdio_device *mdio_device_create(struct mii_bus *bus, int addr)
+{
+       struct mdio_device *mdiodev;
+
+       /* We allocate the device, and initialize the default values */
+       mdiodev = kzalloc(sizeof(*mdiodev), GFP_KERNEL);
+       if (!mdiodev)
+               return ERR_PTR(-ENOMEM);
+
+       mdiodev->dev.release = mdio_device_release;
+       mdiodev->dev.parent = &bus->dev;
+       mdiodev->dev.bus = &mdio_bus_type;
+       mdiodev->bus = bus;
+       mdiodev->addr = addr;
+
+       dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);
+
+       device_initialize(&mdiodev->dev);
+
+       return mdiodev;
+}
+EXPORT_SYMBOL(mdio_device_create);
+
+/**
+ * mdio_device_register - Register the mdio device on the MDIO bus
+ * @mdiodev: mdio_device structure to be added to the MDIO bus
+ */
+int mdio_device_register(struct mdio_device *mdiodev)
+{
+       int err;
+
+       dev_info(&mdiodev->dev, "mdio_device_register\n");
+
+       err = mdiobus_register_device(mdiodev);
+       if (err)
+               return err;
+
+       err = device_add(&mdiodev->dev);
+       if (err) {
+               pr_err("MDIO %d failed to add\n", mdiodev->addr);
+               goto out;
+       }
+
+       return 0;
+
+ out:
+       mdiobus_unregister_device(mdiodev);
+       return err;
+}
+EXPORT_SYMBOL(mdio_device_register);
+
+/**
+ * mdio_device_remove - Remove a previously registered mdio device from the
+ *                     MDIO bus
+ * @mdiodev: mdio_device structure to remove
+ *
+ * This doesn't free the mdio_device itself, it merely reverses the effects
+ * of mdio_device_register(). Use mdio_device_free() to free the device
+ * after calling this function.
+ */
+void mdio_device_remove(struct mdio_device *mdiodev)
+{
+       device_del(&mdiodev->dev);
+       mdiobus_unregister_device(mdiodev);
+}
+EXPORT_SYMBOL(mdio_device_remove);
+
+/**
+ * mdio_probe - probe an MDIO device
+ * @dev: device to probe
+ *
+ * Description: Take care of setting up the mdio_device structure
+ * and calling the driver to probe the device.
+ */
+static int mdio_probe(struct device *dev)
+{
+       struct mdio_device *mdiodev = to_mdio_device(dev);
+       struct device_driver *drv = mdiodev->dev.driver;
+       struct mdio_driver *mdiodrv = to_mdio_driver(drv);
+       int err = 0;
+
+       if (mdiodrv->probe)
+               err = mdiodrv->probe(mdiodev);
+
+       return err;
+}
+
+static int mdio_remove(struct device *dev)
+{
+       struct mdio_device *mdiodev = to_mdio_device(dev);
+       struct device_driver *drv = mdiodev->dev.driver;
+       struct mdio_driver *mdiodrv = to_mdio_driver(drv);
+
+       if (mdiodrv->remove)
+               mdiodrv->remove(mdiodev);
+
+       return 0;
+}
+
+/**
+ * mdio_driver_register - register an mdio_driver with the MDIO layer
+ * @new_driver: new mdio_driver to register
+ */
+int mdio_driver_register(struct mdio_driver *drv)
+{
+       struct mdio_driver_common *mdiodrv = &drv->mdiodrv;
+       int retval;
+
+       pr_info("mdio_driver_register: %s\n", mdiodrv->driver.name);
+
+       mdiodrv->driver.bus = &mdio_bus_type;
+       mdiodrv->driver.probe = mdio_probe;
+       mdiodrv->driver.remove = mdio_remove;
+
+       retval = driver_register(&mdiodrv->driver);
+       if (retval) {
+               pr_err("%s: Error %d in registering driver\n",
+                      mdiodrv->driver.name, retval);
+
+               return retval;
+       }
+
+       return 0;
+}
+EXPORT_SYMBOL(mdio_driver_register);
+
+void mdio_driver_unregister(struct mdio_driver *drv)
+{
+       struct mdio_driver_common *mdiodrv = &drv->mdiodrv;
+
+       driver_unregister(&mdiodrv->driver);
+}
+EXPORT_SYMBOL(mdio_driver_unregister);
index 78628428ee28db80afed44ad563e4a30b613e734..af6cb6556cf90050520b86683c91daf1aee7276f 100644 (file)
@@ -264,6 +264,9 @@ static int phy_bus_match(struct device *dev, struct device_driver *drv)
        const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
        int i;
 
+       if (!(phydrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY))
+               return 0;
+
        if (phydrv->match_phy_device)
                return phydrv->match_phy_device(phydev);
 
@@ -851,9 +854,11 @@ int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
         */
        if (!d->driver) {
                if (phydev->is_c45)
-                       d->driver = &genphy_driver[GENPHY_DRV_10G].driver;
+                       d->driver =
+                               &genphy_driver[GENPHY_DRV_10G].mdiodrv.driver;
                else
-                       d->driver = &genphy_driver[GENPHY_DRV_1G].driver;
+                       d->driver =
+                               &genphy_driver[GENPHY_DRV_1G].mdiodrv.driver;
 
                err = d->driver->probe(d);
                if (err >= 0)
@@ -954,7 +959,8 @@ void phy_detach(struct phy_device *phydev)
         * real driver could be loaded
         */
        for (i = 0; i < ARRAY_SIZE(genphy_driver); i++) {
-               if (phydev->mdio.dev.driver == &genphy_driver[i].driver) {
+               if (phydev->mdio.dev.driver ==
+                   &genphy_driver[i].mdiodrv.driver) {
                        device_release_driver(&phydev->mdio.dev);
                        break;
                }
@@ -1598,13 +1604,14 @@ int phy_driver_register(struct phy_driver *new_driver, struct module *owner)
 {
        int retval;
 
-       new_driver->driver.name = new_driver->name;
-       new_driver->driver.bus = &mdio_bus_type;
-       new_driver->driver.probe = phy_probe;
-       new_driver->driver.remove = phy_remove;
-       new_driver->driver.owner = owner;
+       new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY;
+       new_driver->mdiodrv.driver.name = new_driver->name;
+       new_driver->mdiodrv.driver.bus = &mdio_bus_type;
+       new_driver->mdiodrv.driver.probe = phy_probe;
+       new_driver->mdiodrv.driver.remove = phy_remove;
+       new_driver->mdiodrv.driver.owner = owner;
 
-       retval = driver_register(&new_driver->driver);
+       retval = driver_register(&new_driver->mdiodrv.driver);
        if (retval) {
                pr_err("%s: Error %d in registering driver\n",
                       new_driver->name, retval);
@@ -1637,7 +1644,7 @@ EXPORT_SYMBOL(phy_drivers_register);
 
 void phy_driver_unregister(struct phy_driver *drv)
 {
-       driver_unregister(&drv->driver);
+       driver_unregister(&drv->mdiodrv.driver);
 }
 EXPORT_SYMBOL(phy_driver_unregister);
 
index 6febe2df76f902a823bb8b94ca742c3299439a5a..c0a8f84d92db628abe1910b7e3fe0215997e24ef 100644 (file)
@@ -92,6 +92,37 @@ static int of_mdiobus_register_phy(struct mii_bus *mdio, struct device_node *chi
        return 0;
 }
 
+static int of_mdiobus_register_device(struct mii_bus *mdio,
+                                     struct device_node *child,
+                                     u32 addr)
+{
+       struct mdio_device *mdiodev;
+       int rc;
+
+       mdiodev = mdio_device_create(mdio, addr);
+       if (!mdiodev || IS_ERR(mdiodev))
+               return 1;
+
+       /* Associate the OF node with the device structure so it
+        * can be looked up later.
+        */
+       of_node_get(child);
+       mdiodev->dev.of_node = child;
+
+       /* All data is now stored in the mdiodev struct; register it. */
+       rc = mdio_device_register(mdiodev);
+       if (rc) {
+               mdio_device_free(mdiodev);
+               of_node_put(child);
+               return 1;
+       }
+
+       dev_dbg(&mdio->dev, "registered mdio device %s at address %i\n",
+               child->name, addr);
+
+       return 0;
+}
+
 int of_mdio_parse_addr(struct device *dev, const struct device_node *np)
 {
        u32 addr;
@@ -179,6 +210,8 @@ int of_mdiobus_register(struct mii_bus *mdio, struct device_node *np)
 
                if (of_mdiobus_child_is_phy(child))
                        of_mdiobus_register_phy(mdio, child, addr);
+               else
+                       of_mdiobus_register_device(mdio, child, addr);
        }
 
        if (!scanphys)
index 0690359e55a55ebf9016d54f32e84c4d99e8b7a6..75f7fad0af4f7ea081762980aaf8b4425300bffe 100644 (file)
@@ -15,6 +15,7 @@ struct mii_bus;
 
 struct mdio_device {
        struct device dev;
+
        const struct dev_pm_ops *pm_ops;
        struct mii_bus *bus;
        int (*bus_match)(struct device *dev, struct device_driver *drv);
@@ -24,7 +25,37 @@ struct mdio_device {
 };
 #define to_mdio_device(d) container_of(d, struct mdio_device, dev)
 
+/* struct mdio_driver_common: Common to all MDIO drivers */
+struct mdio_driver_common {
+       struct device_driver driver;
+       int flags;
+};
 #define MDIO_DEVICE_FLAG_PHY           1
+#define to_mdio_common_driver(d) \
+       container_of(d, struct mdio_driver_common, driver)
+
+/* struct mdio_driver: Generic MDIO driver */
+struct mdio_driver {
+       struct mdio_driver_common mdiodrv;
+
+       /*
+        * Called during discovery.  Used to set
+        * up device-specific structures, if any
+        */
+       int (*probe)(struct mdio_device *mdiodev);
+
+       /* Clears up any memory if needed */
+       void (*remove)(struct mdio_device *mdiodev);
+};
+#define to_mdio_driver(d)                                              \
+       container_of(to_mdio_common_driver(d), struct mdio_driver, mdiodrv)
+
+void mdio_device_free(struct mdio_device *mdiodev);
+struct mdio_device *mdio_device_create(struct mii_bus *bus, int addr);
+int mdio_device_register(struct mdio_device *mdiodev);
+void mdio_device_remove(struct mdio_device *mdiodev);
+int mdio_driver_register(struct mdio_driver *drv);
+void mdio_driver_unregister(struct mdio_driver *drv);
 
 static inline bool mdio_phy_id_is_c45(int phy_id)
 {
@@ -197,4 +228,23 @@ int mdiobus_unregister_device(struct mdio_device *mdiodev);
 bool mdiobus_is_registered_device(struct mii_bus *bus, int addr);
 struct phy_device *mdiobus_get_phy(struct mii_bus *bus, int addr);
 
+/**
+ * module_mdio_driver() - Helper macro for registering mdio drivers
+ *
+ * Helper macro for MDIO drivers which do not do anything special in module
+ * init/exit. Each module may only use this macro once, and calling it
+ * replaces module_init() and module_exit().
+ */
+#define mdio_module_driver(_mdio_driver)                               \
+static int __init mdio_module_init(void)                               \
+{                                                                      \
+       return mdio_driver_register(&_mdio_driver);                     \
+}                                                                      \
+module_init(mdio_module_init);                                         \
+static void __exit mdio_module_exit(void)                              \
+{                                                                      \
+       mdio_driver_unregister(&_mdio_driver);                          \
+}                                                                      \
+module_exit(mdio_module_exit)
+
 #endif /* __LINUX_MDIO_H__ */
index 49e4418822b3070b1d43d14b41eb4cee763d8c53..d6f3641e79332889ba121c1c684e7da1b40a27f8 100644 (file)
@@ -60,6 +60,7 @@
 #define PHY_HAS_INTERRUPT      0x00000001
 #define PHY_HAS_MAGICANEG      0x00000002
 #define PHY_IS_INTERNAL                0x00000004
+#define MDIO_DEVICE_IS_PHY     0x80000000
 
 /* Interface Mode definitions */
 typedef enum {
@@ -432,6 +433,7 @@ struct phy_device {
 
 /* struct phy_driver: Driver structure for a particular PHY type
  *
+ * driver_data: static driver data
  * phy_id: The result of reading the UID registers of this PHY
  *   type, and ANDing them with the phy_id_mask.  This driver
  *   only works for PHYs with IDs which match this field
@@ -441,7 +443,6 @@ struct phy_device {
  *   by this PHY
  * flags: A bitfield defining certain other features this PHY
  *   supports (like interrupts)
- * driver_data: static driver data
  *
  * The drivers must implement config_aneg and read_status.  All
  * other functions are optional. Note that none of these
@@ -452,6 +453,7 @@ struct phy_device {
  * supported in the driver).
  */
 struct phy_driver {
+       struct mdio_driver_common mdiodrv;
        u32 phy_id;
        char *name;
        unsigned int phy_id_mask;
@@ -587,10 +589,9 @@ struct phy_driver {
        void (*get_strings)(struct phy_device *dev, u8 *data);
        void (*get_stats)(struct phy_device *dev,
                          struct ethtool_stats *stats, u64 *data);
-
-       struct device_driver driver;
 };
-#define to_phy_driver(d) container_of(d, struct phy_driver, driver)
+#define to_phy_driver(d) container_of(to_mdio_common_driver(d),                \
+                                     struct phy_driver, mdiodrv)
 
 #define PHY_ANY_ID "MATCH ANY PHY"
 #define PHY_ANY_UID 0xffffffff