cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

mdio_device.c (5331B)


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