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_devres.c (2987B)

      1// SPDX-License-Identifier: GPL-2.0-or-later
      2
      3#include <linux/device.h>
      4#include <linux/of_mdio.h>
      5#include <linux/phy.h>
      6#include <linux/stddef.h>
      7
      8struct mdiobus_devres {
      9	struct mii_bus *mii;
     10};
     11
     12static void devm_mdiobus_free(struct device *dev, void *this)
     13{
     14	struct mdiobus_devres *dr = this;
     15
     16	mdiobus_free(dr->mii);
     17}
     18
     19/**
     20 * devm_mdiobus_alloc_size - Resource-managed mdiobus_alloc_size()
     21 * @dev:		Device to allocate mii_bus for
     22 * @sizeof_priv:	Space to allocate for private structure
     23 *
     24 * Managed mdiobus_alloc_size. mii_bus allocated with this function is
     25 * automatically freed on driver detach.
     26 *
     27 * RETURNS:
     28 * Pointer to allocated mii_bus on success, NULL on out-of-memory error.
     29 */
     30struct mii_bus *devm_mdiobus_alloc_size(struct device *dev, int sizeof_priv)
     31{
     32	struct mdiobus_devres *dr;
     33
     34	dr = devres_alloc(devm_mdiobus_free, sizeof(*dr), GFP_KERNEL);
     35	if (!dr)
     36		return NULL;
     37
     38	dr->mii = mdiobus_alloc_size(sizeof_priv);
     39	if (!dr->mii) {
     40		devres_free(dr);
     41		return NULL;
     42	}
     43
     44	devres_add(dev, dr);
     45	return dr->mii;
     46}
     47EXPORT_SYMBOL(devm_mdiobus_alloc_size);
     48
     49static void devm_mdiobus_unregister(struct device *dev, void *this)
     50{
     51	struct mdiobus_devres *dr = this;
     52
     53	mdiobus_unregister(dr->mii);
     54}
     55
     56static int mdiobus_devres_match(struct device *dev,
     57				void *this, void *match_data)
     58{
     59	struct mdiobus_devres *res = this;
     60	struct mii_bus *mii = match_data;
     61
     62	return mii == res->mii;
     63}
     64
     65/**
     66 * __devm_mdiobus_register - Resource-managed variant of mdiobus_register()
     67 * @dev:	Device to register mii_bus for
     68 * @bus:	MII bus structure to register
     69 * @owner:	Owning module
     70 *
     71 * Returns 0 on success, negative error number on failure.
     72 */
     73int __devm_mdiobus_register(struct device *dev, struct mii_bus *bus,
     74			    struct module *owner)
     75{
     76	struct mdiobus_devres *dr;
     77	int ret;
     78
     79	if (WARN_ON(!devres_find(dev, devm_mdiobus_free,
     80				 mdiobus_devres_match, bus)))
     81		return -EINVAL;
     82
     83	dr = devres_alloc(devm_mdiobus_unregister, sizeof(*dr), GFP_KERNEL);
     84	if (!dr)
     85		return -ENOMEM;
     86
     87	ret = __mdiobus_register(bus, owner);
     88	if (ret) {
     89		devres_free(dr);
     90		return ret;
     91	}
     92
     93	dr->mii = bus;
     94	devres_add(dev, dr);
     95	return 0;
     96}
     97EXPORT_SYMBOL(__devm_mdiobus_register);
     98
     99#if IS_ENABLED(CONFIG_OF_MDIO)
    100/**
    101 * devm_of_mdiobus_register - Resource managed variant of of_mdiobus_register()
    102 * @dev:	Device to register mii_bus for
    103 * @mdio:	MII bus structure to register
    104 * @np:		Device node to parse
    105 */
    106int devm_of_mdiobus_register(struct device *dev, struct mii_bus *mdio,
    107			     struct device_node *np)
    108{
    109	struct mdiobus_devres *dr;
    110	int ret;
    111
    112	if (WARN_ON(!devres_find(dev, devm_mdiobus_free,
    113				 mdiobus_devres_match, mdio)))
    114		return -EINVAL;
    115
    116	dr = devres_alloc(devm_mdiobus_unregister, sizeof(*dr), GFP_KERNEL);
    117	if (!dr)
    118		return -ENOMEM;
    119
    120	ret = of_mdiobus_register(mdio, np);
    121	if (ret) {
    122		devres_free(dr);
    123		return ret;
    124	}
    125
    126	dr->mii = mdio;
    127	devres_add(dev, dr);
    128	return 0;
    129}
    130EXPORT_SYMBOL(devm_of_mdiobus_register);
    131#endif /* CONFIG_OF_MDIO */
    132
    133MODULE_LICENSE("GPL");