1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * phy-core.c -- Generic Phy framework.
5 * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com
7 * Author: Kishon Vijay Abraham I <kishon@ti.com>
10 #include <linux/kernel.h>
11 #include <linux/export.h>
12 #include <linux/module.h>
13 #include <linux/err.h>
14 #include <linux/device.h>
15 #include <linux/slab.h>
17 #include <linux/phy/phy.h>
18 #include <linux/idr.h>
19 #include <linux/pm_runtime.h>
20 #include <linux/regulator/consumer.h>
22 static struct class *phy_class;
23 static DEFINE_MUTEX(phy_provider_mutex);
24 static LIST_HEAD(phy_provider_list);
25 static LIST_HEAD(phys);
26 static DEFINE_IDA(phy_ida);
28 static void devm_phy_release(struct device *dev, void *res)
30 struct phy *phy = *(struct phy **)res;
35 static void devm_phy_provider_release(struct device *dev, void *res)
37 struct phy_provider *phy_provider = *(struct phy_provider **)res;
39 of_phy_provider_unregister(phy_provider);
42 static void devm_phy_consume(struct device *dev, void *res)
44 struct phy *phy = *(struct phy **)res;
49 static int devm_phy_match(struct device *dev, void *res, void *match_data)
51 struct phy **phy = res;
53 return *phy == match_data;
57 * phy_create_lookup() - allocate and register PHY/device association
58 * @phy: the phy of the association
59 * @con_id: connection ID string on device
60 * @dev_id: the device of the association
62 * Creates and registers phy_lookup entry.
64 int phy_create_lookup(struct phy *phy, const char *con_id, const char *dev_id)
66 struct phy_lookup *pl;
68 if (!phy || !dev_id || !con_id)
71 pl = kzalloc(sizeof(*pl), GFP_KERNEL);
79 mutex_lock(&phy_provider_mutex);
80 list_add_tail(&pl->node, &phys);
81 mutex_unlock(&phy_provider_mutex);
85 EXPORT_SYMBOL_GPL(phy_create_lookup);
88 * phy_remove_lookup() - find and remove PHY/device association
89 * @phy: the phy of the association
90 * @con_id: connection ID string on device
91 * @dev_id: the device of the association
93 * Finds and unregisters phy_lookup entry that was created with
94 * phy_create_lookup().
96 void phy_remove_lookup(struct phy *phy, const char *con_id, const char *dev_id)
98 struct phy_lookup *pl;
100 if (!phy || !dev_id || !con_id)
103 mutex_lock(&phy_provider_mutex);
104 list_for_each_entry(pl, &phys, node)
105 if (pl->phy == phy && !strcmp(pl->dev_id, dev_id) &&
106 !strcmp(pl->con_id, con_id)) {
111 mutex_unlock(&phy_provider_mutex);
113 EXPORT_SYMBOL_GPL(phy_remove_lookup);
115 static struct phy *phy_find(struct device *dev, const char *con_id)
117 const char *dev_id = dev_name(dev);
118 struct phy_lookup *p, *pl = NULL;
120 mutex_lock(&phy_provider_mutex);
121 list_for_each_entry(p, &phys, node)
122 if (!strcmp(p->dev_id, dev_id) && !strcmp(p->con_id, con_id)) {
126 mutex_unlock(&phy_provider_mutex);
128 return pl ? pl->phy : ERR_PTR(-ENODEV);
131 static struct phy_provider *of_phy_provider_lookup(struct device_node *node)
133 struct phy_provider *phy_provider;
134 struct device_node *child;
136 list_for_each_entry(phy_provider, &phy_provider_list, list) {
137 if (phy_provider->dev->of_node == node)
140 for_each_child_of_node(phy_provider->children, child)
145 return ERR_PTR(-EPROBE_DEFER);
148 int phy_pm_runtime_get(struct phy *phy)
155 if (!pm_runtime_enabled(&phy->dev))
158 ret = pm_runtime_get(&phy->dev);
159 if (ret < 0 && ret != -EINPROGRESS)
160 pm_runtime_put_noidle(&phy->dev);
164 EXPORT_SYMBOL_GPL(phy_pm_runtime_get);
166 int phy_pm_runtime_get_sync(struct phy *phy)
173 if (!pm_runtime_enabled(&phy->dev))
176 ret = pm_runtime_get_sync(&phy->dev);
178 pm_runtime_put_sync(&phy->dev);
182 EXPORT_SYMBOL_GPL(phy_pm_runtime_get_sync);
184 int phy_pm_runtime_put(struct phy *phy)
189 if (!pm_runtime_enabled(&phy->dev))
192 return pm_runtime_put(&phy->dev);
194 EXPORT_SYMBOL_GPL(phy_pm_runtime_put);
196 int phy_pm_runtime_put_sync(struct phy *phy)
201 if (!pm_runtime_enabled(&phy->dev))
204 return pm_runtime_put_sync(&phy->dev);
206 EXPORT_SYMBOL_GPL(phy_pm_runtime_put_sync);
208 void phy_pm_runtime_allow(struct phy *phy)
213 if (!pm_runtime_enabled(&phy->dev))
216 pm_runtime_allow(&phy->dev);
218 EXPORT_SYMBOL_GPL(phy_pm_runtime_allow);
220 void phy_pm_runtime_forbid(struct phy *phy)
225 if (!pm_runtime_enabled(&phy->dev))
228 pm_runtime_forbid(&phy->dev);
230 EXPORT_SYMBOL_GPL(phy_pm_runtime_forbid);
232 int phy_init(struct phy *phy)
239 ret = phy_pm_runtime_get_sync(phy);
240 if (ret < 0 && ret != -ENOTSUPP)
242 ret = 0; /* Override possible ret == -ENOTSUPP */
244 mutex_lock(&phy->mutex);
245 if (phy->init_count == 0 && phy->ops->init) {
246 ret = phy->ops->init(phy);
248 dev_err(&phy->dev, "phy init failed --> %d\n", ret);
255 mutex_unlock(&phy->mutex);
256 phy_pm_runtime_put(phy);
259 EXPORT_SYMBOL_GPL(phy_init);
261 int phy_exit(struct phy *phy)
268 ret = phy_pm_runtime_get_sync(phy);
269 if (ret < 0 && ret != -ENOTSUPP)
271 ret = 0; /* Override possible ret == -ENOTSUPP */
273 mutex_lock(&phy->mutex);
274 if (phy->init_count == 1 && phy->ops->exit) {
275 ret = phy->ops->exit(phy);
277 dev_err(&phy->dev, "phy exit failed --> %d\n", ret);
284 mutex_unlock(&phy->mutex);
285 phy_pm_runtime_put(phy);
288 EXPORT_SYMBOL_GPL(phy_exit);
290 int phy_power_on(struct phy *phy)
298 ret = regulator_enable(phy->pwr);
303 ret = phy_pm_runtime_get_sync(phy);
304 if (ret < 0 && ret != -ENOTSUPP)
307 ret = 0; /* Override possible ret == -ENOTSUPP */
309 mutex_lock(&phy->mutex);
310 if (phy->power_count == 0 && phy->ops->power_on) {
311 ret = phy->ops->power_on(phy);
313 dev_err(&phy->dev, "phy poweron failed --> %d\n", ret);
318 mutex_unlock(&phy->mutex);
322 mutex_unlock(&phy->mutex);
323 phy_pm_runtime_put_sync(phy);
326 regulator_disable(phy->pwr);
330 EXPORT_SYMBOL_GPL(phy_power_on);
332 int phy_power_off(struct phy *phy)
339 mutex_lock(&phy->mutex);
340 if (phy->power_count == 1 && phy->ops->power_off) {
341 ret = phy->ops->power_off(phy);
343 dev_err(&phy->dev, "phy poweroff failed --> %d\n", ret);
344 mutex_unlock(&phy->mutex);
349 mutex_unlock(&phy->mutex);
350 phy_pm_runtime_put(phy);
353 regulator_disable(phy->pwr);
357 EXPORT_SYMBOL_GPL(phy_power_off);
359 int phy_set_mode_ext(struct phy *phy, enum phy_mode mode, int submode)
363 if (!phy || !phy->ops->set_mode)
366 mutex_lock(&phy->mutex);
367 ret = phy->ops->set_mode(phy, mode, submode);
369 phy->attrs.mode = mode;
370 mutex_unlock(&phy->mutex);
374 EXPORT_SYMBOL_GPL(phy_set_mode_ext);
376 int phy_reset(struct phy *phy)
380 if (!phy || !phy->ops->reset)
383 ret = phy_pm_runtime_get_sync(phy);
384 if (ret < 0 && ret != -ENOTSUPP)
387 mutex_lock(&phy->mutex);
388 ret = phy->ops->reset(phy);
389 mutex_unlock(&phy->mutex);
391 phy_pm_runtime_put(phy);
395 EXPORT_SYMBOL_GPL(phy_reset);
397 int phy_calibrate(struct phy *phy)
401 if (!phy || !phy->ops->calibrate)
404 mutex_lock(&phy->mutex);
405 ret = phy->ops->calibrate(phy);
406 mutex_unlock(&phy->mutex);
410 EXPORT_SYMBOL_GPL(phy_calibrate);
413 * phy_configure() - Changes the phy parameters
414 * @phy: the phy returned by phy_get()
415 * @opts: New configuration to apply
417 * Used to change the PHY parameters. phy_init() must have been called
418 * on the phy. The configuration will be applied on the current phy
419 * mode, that can be changed using phy_set_mode().
421 * Returns: 0 if successful, an negative error code otherwise
423 int phy_configure(struct phy *phy, union phy_configure_opts *opts)
430 if (!phy->ops->configure)
433 mutex_lock(&phy->mutex);
434 ret = phy->ops->configure(phy, opts);
435 mutex_unlock(&phy->mutex);
439 EXPORT_SYMBOL_GPL(phy_configure);
442 * phy_validate() - Checks the phy parameters
443 * @phy: the phy returned by phy_get()
444 * @mode: phy_mode the configuration is applicable to.
445 * @submode: PHY submode the configuration is applicable to.
446 * @opts: Configuration to check
448 * Used to check that the current set of parameters can be handled by
449 * the phy. Implementations are free to tune the parameters passed as
450 * arguments if needed by some implementation detail or
451 * constraints. It will not change any actual configuration of the
452 * PHY, so calling it as many times as deemed fit will have no side
455 * Returns: 0 if successful, an negative error code otherwise
457 int phy_validate(struct phy *phy, enum phy_mode mode, int submode,
458 union phy_configure_opts *opts)
465 if (!phy->ops->validate)
468 mutex_lock(&phy->mutex);
469 ret = phy->ops->validate(phy, mode, submode, opts);
470 mutex_unlock(&phy->mutex);
474 EXPORT_SYMBOL_GPL(phy_validate);
477 * _of_phy_get() - lookup and obtain a reference to a phy by phandle
478 * @np: device_node for which to get the phy
479 * @index: the index of the phy
481 * Returns the phy associated with the given phandle value,
482 * after getting a refcount to it or -ENODEV if there is no such phy or
483 * -EPROBE_DEFER if there is a phandle to the phy, but the device is
484 * not yet loaded. This function uses of_xlate call back function provided
485 * while registering the phy_provider to find the phy instance.
487 static struct phy *_of_phy_get(struct device_node *np, int index)
490 struct phy_provider *phy_provider;
491 struct phy *phy = NULL;
492 struct of_phandle_args args;
494 ret = of_parse_phandle_with_args(np, "phys", "#phy-cells",
497 return ERR_PTR(-ENODEV);
499 /* This phy type handled by the usb-phy subsystem for now */
500 if (of_device_is_compatible(args.np, "usb-nop-xceiv"))
501 return ERR_PTR(-ENODEV);
503 mutex_lock(&phy_provider_mutex);
504 phy_provider = of_phy_provider_lookup(args.np);
505 if (IS_ERR(phy_provider) || !try_module_get(phy_provider->owner)) {
506 phy = ERR_PTR(-EPROBE_DEFER);
510 if (!of_device_is_available(args.np)) {
511 dev_warn(phy_provider->dev, "Requested PHY is disabled\n");
512 phy = ERR_PTR(-ENODEV);
516 phy = phy_provider->of_xlate(phy_provider->dev, &args);
519 module_put(phy_provider->owner);
522 mutex_unlock(&phy_provider_mutex);
523 of_node_put(args.np);
529 * of_phy_get() - lookup and obtain a reference to a phy using a device_node.
530 * @np: device_node for which to get the phy
531 * @con_id: name of the phy from device's point of view
533 * Returns the phy driver, after getting a refcount to it; or
534 * -ENODEV if there is no such phy. The caller is responsible for
535 * calling phy_put() to release that count.
537 struct phy *of_phy_get(struct device_node *np, const char *con_id)
539 struct phy *phy = NULL;
543 index = of_property_match_string(np, "phy-names", con_id);
545 phy = _of_phy_get(np, index);
549 if (!try_module_get(phy->ops->owner))
550 return ERR_PTR(-EPROBE_DEFER);
552 get_device(&phy->dev);
556 EXPORT_SYMBOL_GPL(of_phy_get);
559 * phy_put() - release the PHY
560 * @phy: the phy returned by phy_get()
562 * Releases a refcount the caller received from phy_get().
564 void phy_put(struct phy *phy)
566 if (!phy || IS_ERR(phy))
569 mutex_lock(&phy->mutex);
570 if (phy->ops->release)
571 phy->ops->release(phy);
572 mutex_unlock(&phy->mutex);
574 module_put(phy->ops->owner);
575 put_device(&phy->dev);
577 EXPORT_SYMBOL_GPL(phy_put);
580 * devm_phy_put() - release the PHY
581 * @dev: device that wants to release this phy
582 * @phy: the phy returned by devm_phy_get()
584 * destroys the devres associated with this phy and invokes phy_put
585 * to release the phy.
587 void devm_phy_put(struct device *dev, struct phy *phy)
594 r = devres_destroy(dev, devm_phy_release, devm_phy_match, phy);
595 dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
597 EXPORT_SYMBOL_GPL(devm_phy_put);
600 * of_phy_simple_xlate() - returns the phy instance from phy provider
601 * @dev: the PHY provider device
602 * @args: of_phandle_args (not used here)
604 * Intended to be used by phy provider for the common case where #phy-cells is
605 * 0. For other cases where #phy-cells is greater than '0', the phy provider
606 * should provide a custom of_xlate function that reads the *args* and returns
607 * the appropriate phy.
609 struct phy *of_phy_simple_xlate(struct device *dev, struct of_phandle_args
613 struct class_dev_iter iter;
615 class_dev_iter_init(&iter, phy_class, NULL, NULL);
616 while ((dev = class_dev_iter_next(&iter))) {
618 if (args->np != phy->dev.of_node)
621 class_dev_iter_exit(&iter);
625 class_dev_iter_exit(&iter);
626 return ERR_PTR(-ENODEV);
628 EXPORT_SYMBOL_GPL(of_phy_simple_xlate);
631 * phy_get() - lookup and obtain a reference to a phy.
632 * @dev: device that requests this phy
633 * @string: the phy name as given in the dt data or the name of the controller
634 * port for non-dt case
636 * Returns the phy driver, after getting a refcount to it; or
637 * -ENODEV if there is no such phy. The caller is responsible for
638 * calling phy_put() to release that count.
640 struct phy *phy_get(struct device *dev, const char *string)
645 if (string == NULL) {
646 dev_WARN(dev, "missing string\n");
647 return ERR_PTR(-EINVAL);
651 index = of_property_match_string(dev->of_node, "phy-names",
653 phy = _of_phy_get(dev->of_node, index);
655 phy = phy_find(dev, string);
660 if (!try_module_get(phy->ops->owner))
661 return ERR_PTR(-EPROBE_DEFER);
663 get_device(&phy->dev);
667 EXPORT_SYMBOL_GPL(phy_get);
670 * phy_optional_get() - lookup and obtain a reference to an optional phy.
671 * @dev: device that requests this phy
672 * @string: the phy name as given in the dt data or the name of the controller
673 * port for non-dt case
675 * Returns the phy driver, after getting a refcount to it; or
676 * NULL if there is no such phy. The caller is responsible for
677 * calling phy_put() to release that count.
679 struct phy *phy_optional_get(struct device *dev, const char *string)
681 struct phy *phy = phy_get(dev, string);
683 if (IS_ERR(phy) && (PTR_ERR(phy) == -ENODEV))
688 EXPORT_SYMBOL_GPL(phy_optional_get);
691 * devm_phy_get() - lookup and obtain a reference to a phy.
692 * @dev: device that requests this phy
693 * @string: the phy name as given in the dt data or phy device name
696 * Gets the phy using phy_get(), and associates a device with it using
697 * devres. On driver detach, release function is invoked on the devres data,
698 * then, devres data is freed.
700 struct phy *devm_phy_get(struct device *dev, const char *string)
702 struct phy **ptr, *phy;
704 ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
706 return ERR_PTR(-ENOMEM);
708 phy = phy_get(dev, string);
711 devres_add(dev, ptr);
718 EXPORT_SYMBOL_GPL(devm_phy_get);
721 * devm_phy_optional_get() - lookup and obtain a reference to an optional phy.
722 * @dev: device that requests this phy
723 * @string: the phy name as given in the dt data or phy device name
726 * Gets the phy using phy_get(), and associates a device with it using
727 * devres. On driver detach, release function is invoked on the devres
728 * data, then, devres data is freed. This differs to devm_phy_get() in
729 * that if the phy does not exist, it is not considered an error and
730 * -ENODEV will not be returned. Instead the NULL phy is returned,
731 * which can be passed to all other phy consumer calls.
733 struct phy *devm_phy_optional_get(struct device *dev, const char *string)
735 struct phy *phy = devm_phy_get(dev, string);
737 if (IS_ERR(phy) && (PTR_ERR(phy) == -ENODEV))
742 EXPORT_SYMBOL_GPL(devm_phy_optional_get);
745 * devm_of_phy_get() - lookup and obtain a reference to a phy.
746 * @dev: device that requests this phy
747 * @np: node containing the phy
748 * @con_id: name of the phy from device's point of view
750 * Gets the phy using of_phy_get(), and associates a device with it using
751 * devres. On driver detach, release function is invoked on the devres data,
752 * then, devres data is freed.
754 struct phy *devm_of_phy_get(struct device *dev, struct device_node *np,
757 struct phy **ptr, *phy;
759 ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
761 return ERR_PTR(-ENOMEM);
763 phy = of_phy_get(np, con_id);
766 devres_add(dev, ptr);
773 EXPORT_SYMBOL_GPL(devm_of_phy_get);
776 * devm_of_phy_get_by_index() - lookup and obtain a reference to a phy by index.
777 * @dev: device that requests this phy
778 * @np: node containing the phy
779 * @index: index of the phy
781 * Gets the phy using _of_phy_get(), then gets a refcount to it,
782 * and associates a device with it using devres. On driver detach,
783 * release function is invoked on the devres data,
784 * then, devres data is freed.
787 struct phy *devm_of_phy_get_by_index(struct device *dev, struct device_node *np,
790 struct phy **ptr, *phy;
792 ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
794 return ERR_PTR(-ENOMEM);
796 phy = _of_phy_get(np, index);
802 if (!try_module_get(phy->ops->owner)) {
804 return ERR_PTR(-EPROBE_DEFER);
807 get_device(&phy->dev);
810 devres_add(dev, ptr);
814 EXPORT_SYMBOL_GPL(devm_of_phy_get_by_index);
817 * phy_create() - create a new phy
818 * @dev: device that is creating the new phy
819 * @node: device node of the phy
820 * @ops: function pointers for performing phy operations
822 * Called to create a phy using phy framework.
824 struct phy *phy_create(struct device *dev, struct device_node *node,
825 const struct phy_ops *ops)
832 return ERR_PTR(-EINVAL);
834 phy = kzalloc(sizeof(*phy), GFP_KERNEL);
836 return ERR_PTR(-ENOMEM);
838 id = ida_simple_get(&phy_ida, 0, 0, GFP_KERNEL);
840 dev_err(dev, "unable to get id\n");
845 device_initialize(&phy->dev);
846 mutex_init(&phy->mutex);
848 phy->dev.class = phy_class;
849 phy->dev.parent = dev;
850 phy->dev.of_node = node ?: dev->of_node;
854 ret = dev_set_name(&phy->dev, "phy-%s.%d", dev_name(dev), id);
859 phy->pwr = regulator_get_optional(&phy->dev, "phy");
860 if (IS_ERR(phy->pwr)) {
861 ret = PTR_ERR(phy->pwr);
862 if (ret == -EPROBE_DEFER)
868 ret = device_add(&phy->dev);
872 if (pm_runtime_enabled(dev)) {
873 pm_runtime_enable(&phy->dev);
874 pm_runtime_no_callbacks(&phy->dev);
880 put_device(&phy->dev); /* calls phy_release() which frees resources */
887 EXPORT_SYMBOL_GPL(phy_create);
890 * devm_phy_create() - create a new phy
891 * @dev: device that is creating the new phy
892 * @node: device node of the phy
893 * @ops: function pointers for performing phy operations
895 * Creates a new PHY device adding it to the PHY class.
896 * While at that, it also associates the device with the phy using devres.
897 * On driver detach, release function is invoked on the devres data,
898 * then, devres data is freed.
900 struct phy *devm_phy_create(struct device *dev, struct device_node *node,
901 const struct phy_ops *ops)
903 struct phy **ptr, *phy;
905 ptr = devres_alloc(devm_phy_consume, sizeof(*ptr), GFP_KERNEL);
907 return ERR_PTR(-ENOMEM);
909 phy = phy_create(dev, node, ops);
912 devres_add(dev, ptr);
919 EXPORT_SYMBOL_GPL(devm_phy_create);
922 * phy_destroy() - destroy the phy
923 * @phy: the phy to be destroyed
925 * Called to destroy the phy.
927 void phy_destroy(struct phy *phy)
929 pm_runtime_disable(&phy->dev);
930 device_unregister(&phy->dev);
932 EXPORT_SYMBOL_GPL(phy_destroy);
935 * devm_phy_destroy() - destroy the PHY
936 * @dev: device that wants to release this phy
937 * @phy: the phy returned by devm_phy_get()
939 * destroys the devres associated with this phy and invokes phy_destroy
940 * to destroy the phy.
942 void devm_phy_destroy(struct device *dev, struct phy *phy)
946 r = devres_destroy(dev, devm_phy_consume, devm_phy_match, phy);
947 dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
949 EXPORT_SYMBOL_GPL(devm_phy_destroy);
952 * __of_phy_provider_register() - create/register phy provider with the framework
953 * @dev: struct device of the phy provider
954 * @children: device node containing children (if different from dev->of_node)
955 * @owner: the module owner containing of_xlate
956 * @of_xlate: function pointer to obtain phy instance from phy provider
958 * Creates struct phy_provider from dev and of_xlate function pointer.
959 * This is used in the case of dt boot for finding the phy instance from
962 * If the PHY provider doesn't nest children directly but uses a separate
963 * child node to contain the individual children, the @children parameter
964 * can be used to override the default. If NULL, the default (dev->of_node)
965 * will be used. If non-NULL, the device node must be a child (or further
966 * descendant) of dev->of_node. Otherwise an ERR_PTR()-encoded -EINVAL
967 * error code is returned.
969 struct phy_provider *__of_phy_provider_register(struct device *dev,
970 struct device_node *children, struct module *owner,
971 struct phy * (*of_xlate)(struct device *dev,
972 struct of_phandle_args *args))
974 struct phy_provider *phy_provider;
977 * If specified, the device node containing the children must itself
978 * be the provider's device node or a child (or further descendant)
982 struct device_node *parent = of_node_get(children), *next;
985 if (parent == dev->of_node)
988 next = of_get_parent(parent);
994 return ERR_PTR(-EINVAL);
998 children = dev->of_node;
1001 phy_provider = kzalloc(sizeof(*phy_provider), GFP_KERNEL);
1003 return ERR_PTR(-ENOMEM);
1005 phy_provider->dev = dev;
1006 phy_provider->children = of_node_get(children);
1007 phy_provider->owner = owner;
1008 phy_provider->of_xlate = of_xlate;
1010 mutex_lock(&phy_provider_mutex);
1011 list_add_tail(&phy_provider->list, &phy_provider_list);
1012 mutex_unlock(&phy_provider_mutex);
1014 return phy_provider;
1016 EXPORT_SYMBOL_GPL(__of_phy_provider_register);
1019 * __devm_of_phy_provider_register() - create/register phy provider with the
1021 * @dev: struct device of the phy provider
1022 * @owner: the module owner containing of_xlate
1023 * @of_xlate: function pointer to obtain phy instance from phy provider
1025 * Creates struct phy_provider from dev and of_xlate function pointer.
1026 * This is used in the case of dt boot for finding the phy instance from
1027 * phy provider. While at that, it also associates the device with the
1028 * phy provider using devres. On driver detach, release function is invoked
1029 * on the devres data, then, devres data is freed.
1031 struct phy_provider *__devm_of_phy_provider_register(struct device *dev,
1032 struct device_node *children, struct module *owner,
1033 struct phy * (*of_xlate)(struct device *dev,
1034 struct of_phandle_args *args))
1036 struct phy_provider **ptr, *phy_provider;
1038 ptr = devres_alloc(devm_phy_provider_release, sizeof(*ptr), GFP_KERNEL);
1040 return ERR_PTR(-ENOMEM);
1042 phy_provider = __of_phy_provider_register(dev, children, owner,
1044 if (!IS_ERR(phy_provider)) {
1045 *ptr = phy_provider;
1046 devres_add(dev, ptr);
1051 return phy_provider;
1053 EXPORT_SYMBOL_GPL(__devm_of_phy_provider_register);
1056 * of_phy_provider_unregister() - unregister phy provider from the framework
1057 * @phy_provider: phy provider returned by of_phy_provider_register()
1059 * Removes the phy_provider created using of_phy_provider_register().
1061 void of_phy_provider_unregister(struct phy_provider *phy_provider)
1063 if (IS_ERR(phy_provider))
1066 mutex_lock(&phy_provider_mutex);
1067 list_del(&phy_provider->list);
1068 of_node_put(phy_provider->children);
1069 kfree(phy_provider);
1070 mutex_unlock(&phy_provider_mutex);
1072 EXPORT_SYMBOL_GPL(of_phy_provider_unregister);
1075 * devm_of_phy_provider_unregister() - remove phy provider from the framework
1076 * @dev: struct device of the phy provider
1078 * destroys the devres associated with this phy provider and invokes
1079 * of_phy_provider_unregister to unregister the phy provider.
1081 void devm_of_phy_provider_unregister(struct device *dev,
1082 struct phy_provider *phy_provider) {
1085 r = devres_destroy(dev, devm_phy_provider_release, devm_phy_match,
1087 dev_WARN_ONCE(dev, r, "couldn't find PHY provider device resource\n");
1089 EXPORT_SYMBOL_GPL(devm_of_phy_provider_unregister);
1092 * phy_release() - release the phy
1093 * @dev: the dev member within phy
1095 * When the last reference to the device is removed, it is called
1096 * from the embedded kobject as release method.
1098 static void phy_release(struct device *dev)
1103 dev_vdbg(dev, "releasing '%s'\n", dev_name(dev));
1104 regulator_put(phy->pwr);
1105 ida_simple_remove(&phy_ida, phy->id);
1109 static int __init phy_core_init(void)
1111 phy_class = class_create(THIS_MODULE, "phy");
1112 if (IS_ERR(phy_class)) {
1113 pr_err("failed to create phy class --> %ld\n",
1114 PTR_ERR(phy_class));
1115 return PTR_ERR(phy_class);
1118 phy_class->dev_release = phy_release;
1122 device_initcall(phy_core_init);