/* * phy-core.c  --  Generic Phy framework. * * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com * * Author: Kishon Vijay Abraham I <kishon@ti.com> * * 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. */ #include <linux/kernel.h>#include <linux/export.h>#include <linux/module.h>#include <linux/err.h>#include <linux/device.h>#include <linux/slab.h>#include <linux/of.h>#include <linux/phy/phy.h>#include <linux/idr.h>#include <linux/pm_runtime.h>#include <linux/regulator/consumer.h> static struct class *phy_class;static DEFINE_MUTEX(phy_provider_mutex);static LIST_HEAD(phy_provider_list);static LIST_HEAD(phys);static DEFINE_IDA(phy_ida); static void devm_phy_release(struct device *dev, void *res){	struct phy *phy = *(struct phy **)res; 	phy_put(phy);} static void devm_phy_provider_release(struct device *dev, void *res){	struct phy_provider *phy_provider = *(struct phy_provider **)res; 	of_phy_provider_unregister(phy_provider);} static void devm_phy_consume(struct device *dev, void *res){	struct phy *phy = *(struct phy **)res; 	phy_destroy(phy);} static int devm_phy_match(struct device *dev, void *res, void *match_data){	struct phy **phy = res; 	return *phy == match_data;} /** * phy_create_lookup() - allocate and register PHY/device association * @phy: the phy of the association * @con_id: connection ID string on device * @dev_id: the device of the association * * Creates and registers phy_lookup entry. */int phy_create_lookup(struct phy *phy, const char *con_id, const char *dev_id){	struct phy_lookup *pl; 	if (!phy || !dev_id || !con_id)		return -EINVAL; 	pl = kzalloc(sizeof(*pl), GFP_KERNEL);	if (!pl)		return -ENOMEM; 	pl->dev_id = dev_id;	pl->con_id = con_id;	pl->phy = phy; 	mutex_lock(&phy_provider_mutex);	list_add_tail(&pl->node, &phys);	mutex_unlock(&phy_provider_mutex); 	return 0;}EXPORT_SYMBOL_GPL(phy_create_lookup); /** * phy_remove_lookup() - find and remove PHY/device association * @phy: the phy of the association * @con_id: connection ID string on device * @dev_id: the device of the association * * Finds and unregisters phy_lookup entry that was created with * phy_create_lookup(). */void phy_remove_lookup(struct phy *phy, const char *con_id, const char *dev_id){	struct phy_lookup *pl; 	if (!phy || !dev_id || !con_id)		return; 	mutex_lock(&phy_provider_mutex);	list_for_each_entry(pl, &phys, node)		if (pl->phy == phy && !strcmp(pl->dev_id, dev_id) &&		    !strcmp(pl->con_id, con_id)) {			list_del(&pl->node);			kfree(pl);			break;		}	mutex_unlock(&phy_provider_mutex);}EXPORT_SYMBOL_GPL(phy_remove_lookup); static struct phy *phy_find(struct device *dev, const char *con_id){	const char *dev_id = dev_name(dev);	struct phy_lookup *p, *pl = NULL; 	mutex_lock(&phy_provider_mutex);	list_for_each_entry(p, &phys, node)		if (!strcmp(p->dev_id, dev_id) && !strcmp(p->con_id, con_id)) {			pl = p;			break;		}	mutex_unlock(&phy_provider_mutex); 	return pl ? pl->phy : ERR_PTR(-ENODEV);} static struct phy_provider *of_phy_provider_lookup(struct device_node *node){	struct phy_provider *phy_provider;	struct device_node *child; 	list_for_each_entry(phy_provider, &phy_provider_list, list) {		if (phy_provider->dev->of_node == node)			return phy_provider; 		for_each_child_of_node(phy_provider->children, child)			if (child == node)				return phy_provider;	} 	return ERR_PTR(-EPROBE_DEFER);} int phy_pm_runtime_get(struct phy *phy){	int ret; 	if (!pm_runtime_enabled(&phy->dev))		return -ENOTSUPP; 	ret = pm_runtime_get(&phy->dev);	if (ret < 0 && ret != -EINPROGRESS)		pm_runtime_put_noidle(&phy->dev); 	return ret;}EXPORT_SYMBOL_GPL(phy_pm_runtime_get); int phy_pm_runtime_get_sync(struct phy *phy){	int ret; 	if (!pm_runtime_enabled(&phy->dev))		return -ENOTSUPP; 	ret = pm_runtime_get_sync(&phy->dev);	if (ret < 0)		pm_runtime_put_sync(&phy->dev); 	return ret;}EXPORT_SYMBOL_GPL(phy_pm_runtime_get_sync); int phy_pm_runtime_put(struct phy *phy){	if (!pm_runtime_enabled(&phy->dev))		return -ENOTSUPP; 	return pm_runtime_put(&phy->dev);}EXPORT_SYMBOL_GPL(phy_pm_runtime_put); int phy_pm_runtime_put_sync(struct phy *phy){	if (!pm_runtime_enabled(&phy->dev))		return -ENOTSUPP; 	return pm_runtime_put_sync(&phy->dev);}EXPORT_SYMBOL_GPL(phy_pm_runtime_put_sync); void phy_pm_runtime_allow(struct phy *phy){	if (!pm_runtime_enabled(&phy->dev))		return; 	pm_runtime_allow(&phy->dev);}EXPORT_SYMBOL_GPL(phy_pm_runtime_allow); void phy_pm_runtime_forbid(struct phy *phy){	if (!pm_runtime_enabled(&phy->dev))		return; 	pm_runtime_forbid(&phy->dev);}EXPORT_SYMBOL_GPL(phy_pm_runtime_forbid); int phy_init(struct phy *phy){	int ret; 	if (!phy)		return 0; 	ret = phy_pm_runtime_get_sync(phy);	if (ret < 0 && ret != -ENOTSUPP)		return ret;	ret = 0; /* Override possible ret == -ENOTSUPP */ 	mutex_lock(&phy->mutex);	if (phy->init_count == 0 && phy->ops->init) {		ret = phy->ops->init(phy);		if (ret < 0) {			dev_err(&phy->dev, "phy init failed --> %d\n", ret);			goto out;		}	}	++phy->init_count; out:	mutex_unlock(&phy->mutex);	phy_pm_runtime_put(phy);	return ret;}EXPORT_SYMBOL_GPL(phy_init); int phy_exit(struct phy *phy){	int ret; 	if (!phy)		return 0; 	ret = phy_pm_runtime_get_sync(phy);	if (ret < 0 && ret != -ENOTSUPP)		return ret;	ret = 0; /* Override possible ret == -ENOTSUPP */ 	mutex_lock(&phy->mutex);	if (phy->init_count == 1 && phy->ops->exit) {		ret = phy->ops->exit(phy);		if (ret < 0) {			dev_err(&phy->dev, "phy exit failed --> %d\n", ret);			goto out;		}	}	--phy->init_count; out:	mutex_unlock(&phy->mutex);	phy_pm_runtime_put(phy);	return ret;}EXPORT_SYMBOL_GPL(phy_exit); int phy_power_on(struct phy *phy){	int ret = 0; 	if (!phy)		goto out; 	if (phy->pwr) {		ret = regulator_enable(phy->pwr);		if (ret)			goto out;	} 	ret = phy_pm_runtime_get_sync(phy);	if (ret < 0 && ret != -ENOTSUPP)		goto err_pm_sync; 	ret = 0; /* Override possible ret == -ENOTSUPP */ 	mutex_lock(&phy->mutex);	if (phy->power_count == 0 && phy->ops->power_on) {		ret = phy->ops->power_on(phy);		if (ret < 0) {			dev_err(&phy->dev, "phy poweron failed --> %d\n", ret);			goto err_pwr_on;		}	}	++phy->power_count;	mutex_unlock(&phy->mutex);	return 0; err_pwr_on:	mutex_unlock(&phy->mutex);	phy_pm_runtime_put_sync(phy);err_pm_sync:	if (phy->pwr)		regulator_disable(phy->pwr);out:	return ret;}EXPORT_SYMBOL_GPL(phy_power_on); int phy_power_off(struct phy *phy){	int ret; 	if (!phy)		return 0; 	mutex_lock(&phy->mutex);	if (phy->power_count == 1 && phy->ops->power_off) {		ret =  phy->ops->power_off(phy);		if (ret < 0) {			dev_err(&phy->dev, "phy poweroff failed --> %d\n", ret);			mutex_unlock(&phy->mutex);			return ret;		}	}	--phy->power_count;	mutex_unlock(&phy->mutex);	phy_pm_runtime_put(phy); 	if (phy->pwr)		regulator_disable(phy->pwr); 	return 0;}EXPORT_SYMBOL_GPL(phy_power_off); int phy_set_mode(struct phy *phy, enum phy_mode mode){	int ret; 	if (!phy || !phy->ops->set_mode)		return 0; 	mutex_lock(&phy->mutex);	ret = phy->ops->set_mode(phy, mode);	mutex_unlock(&phy->mutex); 	return ret;}EXPORT_SYMBOL_GPL(phy_set_mode); int phy_reset(struct phy *phy){	int ret; 	if (!phy || !phy->ops->reset)		return 0; 	mutex_lock(&phy->mutex);	ret = phy->ops->reset(phy);	mutex_unlock(&phy->mutex); 	return ret;}EXPORT_SYMBOL_GPL(phy_reset); /** * _of_phy_get() - lookup and obtain a reference to a phy by phandle * @np: device_node for which to get the phy * @index: the index of the phy * * Returns the phy associated with the given phandle value, * after getting a refcount to it or -ENODEV if there is no such phy or * -EPROBE_DEFER if there is a phandle to the phy, but the device is * not yet loaded. This function uses of_xlate call back function provided * while registering the phy_provider to find the phy instance. */static struct phy *_of_phy_get(struct device_node *np, int index){	int ret;	struct phy_provider *phy_provider;	struct phy *phy = NULL;	struct of_phandle_args args; 	ret = of_parse_phandle_with_args(np, "phys", "#phy-cells",		index, &args);	if (ret)		return ERR_PTR(-ENODEV); 	mutex_lock(&phy_provider_mutex);	phy_provider = of_phy_provider_lookup(args.np);	if (IS_ERR(phy_provider) || !try_module_get(phy_provider->owner)) {		phy = ERR_PTR(-EPROBE_DEFER);		goto out_unlock;	} 	if (!of_device_is_available(args.np)) {		dev_warn(phy_provider->dev, "Requested PHY is disabled\n");		phy = ERR_PTR(-ENODEV);		goto out_put_module;	} 	phy = phy_provider->of_xlate(phy_provider->dev, &args); out_put_module:	module_put(phy_provider->owner); out_unlock:	mutex_unlock(&phy_provider_mutex);	of_node_put(args.np); 	return phy;} /** * of_phy_get() - lookup and obtain a reference to a phy using a device_node. * @np: device_node for which to get the phy * @con_id: name of the phy from device's point of view * * Returns the phy driver, after getting a refcount to it; or * -ENODEV if there is no such phy. The caller is responsible for * calling phy_put() to release that count. */struct phy *of_phy_get(struct device_node *np, const char *con_id){	struct phy *phy = NULL;	int index = 0; 	if (con_id)		index = of_property_match_string(np, "phy-names", con_id); 	phy = _of_phy_get(np, index);	if (IS_ERR(phy))		return phy; 	if (!try_module_get(phy->ops->owner))		return ERR_PTR(-EPROBE_DEFER); 	get_device(&phy->dev); 	return phy;}EXPORT_SYMBOL_GPL(of_phy_get); /** * phy_put() - release the PHY * @phy: the phy returned by phy_get() * * Releases a refcount the caller received from phy_get(). */void phy_put(struct phy *phy){	if (!phy || IS_ERR(phy))		return; 	module_put(phy->ops->owner);	put_device(&phy->dev);}EXPORT_SYMBOL_GPL(phy_put); /** * devm_phy_put() - release the PHY * @dev: device that wants to release this phy * @phy: the phy returned by devm_phy_get() * * destroys the devres associated with this phy and invokes phy_put * to release the phy. */void devm_phy_put(struct device *dev, struct phy *phy){	int r; 	if (!phy)		return; 	r = devres_destroy(dev, devm_phy_release, devm_phy_match, phy);	dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");}EXPORT_SYMBOL_GPL(devm_phy_put); /** * of_phy_simple_xlate() - returns the phy instance from phy provider * @dev: the PHY provider device * @args: of_phandle_args (not used here) * * Intended to be used by phy provider for the common case where #phy-cells is * 0. For other cases where #phy-cells is greater than '0', the phy provider * should provide a custom of_xlate function that reads the *args* and returns * the appropriate phy. */struct phy *of_phy_simple_xlate(struct device *dev, struct of_phandle_args	*args)

Lines 1–500 of 1022. Load more