Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b40bf2be authored by Andrew Lunn's avatar Andrew Lunn Committed by Anthony Mah
Browse files

mdio: Add support for mdio drivers. 



Not all devices on an MDIO bus are PHYs. Meaning not all MDIO drivers
are PHY drivers. Add support for generic MDIO drivers.

Change-Id: I65c7c8a497bbac9ef67b3d21c869818a09378e3c
Signed-off-by: default avatarAndrew Lunn <andrew@lunn.ch>
Reviewed-by: default avatarFlorian Fainelli <f.fainelli@gmail.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
Git-Commit: a9049e0c513c4521dbfaa302af8ed08b3366b41f
Git-repo: git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git


Signed-off-by: default avatarAnthony Mah <amah@codeaurora.org>
parent 3e17d59a

drivers/net/phy/mdio_device.c

0 → 100644
+171 −0
Original line number Diff line number Diff line 
/* 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->device_free = mdio_device_free;

	mdiodev->device_remove = mdio_device_remove;

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

include/linux/mdio.h

+47 −0
Original line number Diff line number Diff line
@@ -11,6 +11,53 @@ 


#include <uapi/linux/mdio.h>



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

	void (*device_free)(struct mdio_device *mdiodev);

	void (*device_remove)(struct mdio_device *mdiodev);



	/* Bus address of the MDIO device (0-31) */

	int addr;

	int flags;

};

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

{

include/linux/phy.h

+3 −0
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 


#include <linux/spinlock.h>

#include <linux/ethtool.h>

#include <linux/mdio.h>

#include <linux/mii.h>

#include <linux/module.h>

#include <linux/timer.h>
@@ -357,6 +358,8 @@ struct phy_c45_device_ids { 
 * handling, as well as handling shifts in PHY hardware state

 */

struct phy_device {

	struct mdio_device mdio;



	/* Information about the PHY type */

	/* And management functions */

	struct phy_driver *drv;