Contributors: 23
| Author |
Tokens |
Token Proportion |
Commits |
Commit Proportion |
| Andrew Lunn |
451 |
50.85% |
8 |
21.05% |
| Andy Fleming |
130 |
14.66% |
1 |
2.63% |
| Sergei Shtylyov |
77 |
8.68% |
3 |
7.89% |
| David Bauer |
47 |
5.30% |
2 |
5.26% |
| Florian Fainelli |
38 |
4.28% |
4 |
10.53% |
| Richard Leitner |
30 |
3.38% |
2 |
5.26% |
| Vladimir Oltean |
21 |
2.37% |
1 |
2.63% |
| Andrew Halaney |
16 |
1.80% |
1 |
2.63% |
| Zeng Heng |
10 |
1.13% |
1 |
2.63% |
| Daniel Mack |
10 |
1.13% |
2 |
5.26% |
| Grygorii Strashko |
8 |
0.90% |
1 |
2.63% |
| Joe Perches |
8 |
0.90% |
1 |
2.63% |
| Wenpeng Liang |
6 |
0.68% |
1 |
2.63% |
| Anton Vorontsov |
6 |
0.68% |
1 |
2.63% |
| Roger Quadros |
6 |
0.68% |
1 |
2.63% |
| Maciej W. Rozycki |
5 |
0.56% |
1 |
2.63% |
| Vitaly Bordug |
5 |
0.56% |
1 |
2.63% |
| Grant C. Likely |
4 |
0.45% |
1 |
2.63% |
| Christian Hohnstaedt |
3 |
0.34% |
1 |
2.63% |
| Petr Malat |
3 |
0.34% |
1 |
2.63% |
| Robert P. J. Day |
1 |
0.11% |
1 |
2.63% |
| Andrea Merello |
1 |
0.11% |
1 |
2.63% |
| Bruno Thomsen |
1 |
0.11% |
1 |
2.63% |
| Total |
887 |
|
38 |
|
// SPDX-License-Identifier: GPL-2.0+
/* Framework for MDIO devices, other than PHYs.
*
* Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch>
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/gpio/consumer.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/reset.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/unistd.h>
#include <linux/property.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)
{
fwnode_handle_put(dev->fwnode);
kfree(to_mdio_device(dev));
}
int mdio_device_bus_match(struct device *dev, struct device_driver *drv)
{
struct mdio_device *mdiodev = to_mdio_device(dev);
struct mdio_driver *mdiodrv = to_mdio_driver(drv);
if (mdiodrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY)
return 0;
return strcmp(mdiodev->modalias, drv->name) == 0;
}
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;
mdiodev->reset_state = -1;
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_dbg(&mdiodev->dev, "%s\n", __func__);
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);
void mdio_device_reset(struct mdio_device *mdiodev, int value)
{
unsigned int d;
if (!mdiodev->reset_gpio && !mdiodev->reset_ctrl)
return;
if (mdiodev->reset_state == value)
return;
if (mdiodev->reset_gpio)
gpiod_set_value_cansleep(mdiodev->reset_gpio, value);
if (mdiodev->reset_ctrl) {
if (value)
reset_control_assert(mdiodev->reset_ctrl);
else
reset_control_deassert(mdiodev->reset_ctrl);
}
d = value ? mdiodev->reset_assert_delay : mdiodev->reset_deassert_delay;
if (d)
fsleep(d);
mdiodev->reset_state = value;
}
EXPORT_SYMBOL(mdio_device_reset);
/**
* 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;
/* Deassert the reset signal */
mdio_device_reset(mdiodev, 0);
if (mdiodrv->probe) {
err = mdiodrv->probe(mdiodev);
if (err) {
/* Assert the reset signal */
mdio_device_reset(mdiodev, 1);
}
}
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);
/* Assert the reset signal */
mdio_device_reset(mdiodev, 1);
return 0;
}
static void mdio_shutdown(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->shutdown)
mdiodrv->shutdown(mdiodev);
}
/**
* mdio_driver_register - register an mdio_driver with the MDIO layer
* @drv: new mdio_driver to register
*/
int mdio_driver_register(struct mdio_driver *drv)
{
struct mdio_driver_common *mdiodrv = &drv->mdiodrv;
int retval;
pr_debug("%s: %s\n", __func__, mdiodrv->driver.name);
mdiodrv->driver.bus = &mdio_bus_type;
mdiodrv->driver.probe = mdio_probe;
mdiodrv->driver.remove = mdio_remove;
mdiodrv->driver.shutdown = mdio_shutdown;
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);