[linux-block.git] / drivers / net / phy / mdio_devres.c

// SPDX-License-Identifier: GPL-2.0-or-later

#include <linux/device.h>
#include <linux/of_mdio.h>
#include <linux/phy.h>
#include <linux/stddef.h>

struct mdiobus_devres {
	struct mii_bus *mii;
};

static void devm_mdiobus_free(struct device *dev, void *this)
{
	struct mdiobus_devres *dr = this;

	mdiobus_free(dr->mii);
}

/**
 * devm_mdiobus_alloc_size - Resource-managed mdiobus_alloc_size()
 * @dev:		Device to allocate mii_bus for
 * @sizeof_priv:	Space to allocate for private structure
 *
 * Managed mdiobus_alloc_size. mii_bus allocated with this function is
 * automatically freed on driver detach.
 *
 * RETURNS:
 * Pointer to allocated mii_bus on success, NULL on out-of-memory error.
 */
struct mii_bus *devm_mdiobus_alloc_size(struct device *dev, int sizeof_priv)
{
	struct mdiobus_devres *dr;

	dr = devres_alloc(devm_mdiobus_free, sizeof(*dr), GFP_KERNEL);
	if (!dr)
		return NULL;

	dr->mii = mdiobus_alloc_size(sizeof_priv);
	if (!dr->mii) {
		devres_free(dr);
		return NULL;
	}

	devres_add(dev, dr);
	return dr->mii;
}
EXPORT_SYMBOL(devm_mdiobus_alloc_size);

static void devm_mdiobus_unregister(struct device *dev, void *this)
{
	struct mdiobus_devres *dr = this;

	mdiobus_unregister(dr->mii);
}

static int mdiobus_devres_match(struct device *dev,
				void *this, void *match_data)
{
	struct mdiobus_devres *res = this;
	struct mii_bus *mii = match_data;

	return mii == res->mii;
}

/**
 * __devm_mdiobus_register - Resource-managed variant of mdiobus_register()
 * @dev:	Device to register mii_bus for
 * @bus:	MII bus structure to register
 * @owner:	Owning module
 *
 * Returns 0 on success, negative error number on failure.
 */
int __devm_mdiobus_register(struct device *dev, struct mii_bus *bus,
			    struct module *owner)
{
	struct mdiobus_devres *dr;
	int ret;

	if (WARN_ON(!devres_find(dev, devm_mdiobus_free,
				 mdiobus_devres_match, bus)))
		return -EINVAL;

	dr = devres_alloc(devm_mdiobus_unregister, sizeof(*dr), GFP_KERNEL);
	if (!dr)
		return -ENOMEM;

	ret = __mdiobus_register(bus, owner);
	if (ret) {
		devres_free(dr);
		return ret;
	}

	dr->mii = bus;
	devres_add(dev, dr);
	return 0;
}
EXPORT_SYMBOL(__devm_mdiobus_register);

#if IS_ENABLED(CONFIG_OF_MDIO)
/**
 * devm_of_mdiobus_register - Resource managed variant of of_mdiobus_register()
 * @dev:	Device to register mii_bus for
 * @mdio:	MII bus structure to register
 * @np:		Device node to parse
 */
int devm_of_mdiobus_register(struct device *dev, struct mii_bus *mdio,
			     struct device_node *np)
{
	struct mdiobus_devres *dr;
	int ret;

	if (WARN_ON(!devres_find(dev, devm_mdiobus_free,
				 mdiobus_devres_match, mdio)))
		return -EINVAL;

	dr = devres_alloc(devm_mdiobus_unregister, sizeof(*dr), GFP_KERNEL);
	if (!dr)
		return -ENOMEM;

	ret = of_mdiobus_register(mdio, np);
	if (ret) {
		devres_free(dr);
		return ret;
	}

	dr->mii = mdio;
	devres_add(dev, dr);
	return 0;
}
EXPORT_SYMBOL(devm_of_mdiobus_register);
#endif /* CONFIG_OF_MDIO */

MODULE_LICENSE("GPL");
Commit	Line	Data
8b11c20a BG	1	// SPDX-License-Identifier: GPL-2.0-or-later
8b11c20a BG	2
ac3a68d5	3	#include <linux/device.h>
14eeb6e0	4	#include <linux/of_mdio.h>
8b11c20a	5	#include <linux/phy.h>
ac3a68d5 BG	6	#include <linux/stddef.h>
	7
	8	struct mdiobus_devres {
	9	struct mii_bus *mii;
	10	};
	11
	12	static 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	*/
	30	struct 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	}
	47	EXPORT_SYMBOL(devm_mdiobus_alloc_size);
	48
	49	static void devm_mdiobus_unregister(struct device dev, void this)
	50	{
	51	struct mdiobus_devres *dr = this;
	52
	53	mdiobus_unregister(dr->mii);
	54	}
	55
	56	static 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	}
8b11c20a	64
6a9a5723 BG	65	/**
6a9a5723 BG	66	* __devm_mdiobus_register - Resource-managed variant of mdiobus_register()
ac3a68d5	67	* @dev: Device to register mii_bus for
6a9a5723 BG	68	* @bus: MII bus structure to register
	69	* @owner: Owning module
	70	*
	71	* Returns 0 on success, negative error number on failure.
	72	*/
ac3a68d5 BG	73	int __devm_mdiobus_register(struct device dev, struct mii_bus bus,
ac3a68d5 BG	74	struct module *owner)
8b11c20a	75	{
ac3a68d5	76	struct mdiobus_devres *dr;
8b11c20a BG	77	int ret;
8b11c20a BG	78
ac3a68d5 BG	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;
8b11c20a BG	86
8b11c20a BG	87	ret = __mdiobus_register(bus, owner);
ac3a68d5 BG	88	if (ret) {
	89	devres_free(dr);
	90	return ret;
	91	}
8b11c20a	92
ac3a68d5 BG	93	dr->mii = bus;
	94	devres_add(dev, dr);
	95	return 0;
8b11c20a BG	96	}
8b11c20a BG	97	EXPORT_SYMBOL(__devm_mdiobus_register);
14eeb6e0 BG	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	*/
	106	int 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	}
	130	EXPORT_SYMBOL(devm_of_mdiobus_register);
	131	#endif /* CONFIG_OF_MDIO */
	132
	133	MODULE_LICENSE("GPL");