2018-05-06 21:58:06 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2017-04-24 09:51:27 +00:00
|
|
|
/*
|
|
|
|
|
* Copyright (C) 2017 Texas Instruments Incorporated - http://www.ti.com/
|
|
|
|
|
* Written by Jean-Jacques Hiblot <jjhiblot@ti.com>
|
|
|
|
|
*/
|
|
|
|
|
|
2021-04-27 09:02:19 +00:00
|
|
|
#define LOG_CATEGORY UCLASS_PHY
|
|
|
|
|
|
2017-04-24 09:51:27 +00:00
|
|
|
#include <common.h>
|
|
|
|
|
#include <dm.h>
|
2020-10-05 01:39:47 +00:00
|
|
|
#include <dm/device_compat.h>
|
2020-05-02 09:35:11 +00:00
|
|
|
#include <dm/devres.h>
|
2017-04-24 09:51:27 +00:00
|
|
|
#include <generic-phy.h>
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
#include <linux/list.h>
|
2023-09-15 00:21:46 +00:00
|
|
|
#include <linux/printk.h>
|
2023-05-15 09:59:47 +00:00
|
|
|
#include <power/regulator.h>
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct phy_counts - Init and power-on counts of a single PHY port
|
|
|
|
|
*
|
|
|
|
|
* This structure is used to keep track of PHY initialization and power
|
|
|
|
|
* state change requests, so that we don't power off and deinitialize a
|
|
|
|
|
* PHY instance until all of its users want it done. Otherwise, multiple
|
|
|
|
|
* consumers using the same PHY port can cause problems (e.g. one might
|
|
|
|
|
* call power_off() after another's exit() and hang indefinitely).
|
|
|
|
|
*
|
|
|
|
|
* @id: The PHY ID within a PHY provider
|
|
|
|
|
* @power_on_count: Times generic_phy_power_on() was called for this ID
|
|
|
|
|
* without a matching generic_phy_power_off() afterwards
|
|
|
|
|
* @init_count: Times generic_phy_init() was called for this ID
|
|
|
|
|
* without a matching generic_phy_exit() afterwards
|
|
|
|
|
* @list: Handle for a linked list of these structures corresponding to
|
|
|
|
|
* ports of the same PHY provider
|
2023-05-15 09:59:47 +00:00
|
|
|
* @supply: Handle to a phy-supply device
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
*/
|
|
|
|
|
struct phy_counts {
|
|
|
|
|
unsigned long id;
|
|
|
|
|
int power_on_count;
|
|
|
|
|
int init_count;
|
|
|
|
|
struct list_head list;
|
2023-05-15 09:59:47 +00:00
|
|
|
struct udevice *supply;
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
};
|
2017-04-24 09:51:27 +00:00
|
|
|
|
|
|
|
|
static inline struct phy_ops *phy_dev_ops(struct udevice *dev)
|
|
|
|
|
{
|
|
|
|
|
return (struct phy_ops *)dev->driver->ops;
|
|
|
|
|
}
|
|
|
|
|
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
static struct phy_counts *phy_get_counts(struct phy *phy)
|
|
|
|
|
{
|
|
|
|
|
struct list_head *uc_priv;
|
|
|
|
|
struct phy_counts *counts;
|
|
|
|
|
|
|
|
|
|
if (!generic_phy_valid(phy))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
uc_priv = dev_get_uclass_priv(phy->dev);
|
|
|
|
|
list_for_each_entry(counts, uc_priv, list)
|
|
|
|
|
if (counts->id == phy->id)
|
|
|
|
|
return counts;
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-15 09:59:47 +00:00
|
|
|
static int phy_alloc_counts(struct phy *phy, struct udevice *supply)
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
{
|
|
|
|
|
struct list_head *uc_priv;
|
|
|
|
|
struct phy_counts *counts;
|
|
|
|
|
|
|
|
|
|
if (!generic_phy_valid(phy))
|
|
|
|
|
return 0;
|
|
|
|
|
if (phy_get_counts(phy))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
uc_priv = dev_get_uclass_priv(phy->dev);
|
|
|
|
|
counts = kzalloc(sizeof(*counts), GFP_KERNEL);
|
|
|
|
|
if (!counts)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
counts->id = phy->id;
|
|
|
|
|
counts->power_on_count = 0;
|
|
|
|
|
counts->init_count = 0;
|
2023-05-15 09:59:47 +00:00
|
|
|
counts->supply = supply;
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
list_add(&counts->list, uc_priv);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int phy_uclass_pre_probe(struct udevice *dev)
|
|
|
|
|
{
|
|
|
|
|
struct list_head *uc_priv = dev_get_uclass_priv(dev);
|
|
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(uc_priv);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int phy_uclass_pre_remove(struct udevice *dev)
|
|
|
|
|
{
|
|
|
|
|
struct list_head *uc_priv = dev_get_uclass_priv(dev);
|
|
|
|
|
struct phy_counts *counts, *next;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry_safe(counts, next, uc_priv, list)
|
|
|
|
|
kfree(counts);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-24 09:51:27 +00:00
|
|
|
static int generic_phy_xlate_offs_flags(struct phy *phy,
|
2017-05-19 02:09:47 +00:00
|
|
|
struct ofnode_phandle_args *args)
|
2017-04-24 09:51:27 +00:00
|
|
|
{
|
|
|
|
|
debug("%s(phy=%p)\n", __func__, phy);
|
|
|
|
|
|
|
|
|
|
if (args->args_count > 1) {
|
2021-12-01 19:26:53 +00:00
|
|
|
debug("Invalid args_count: %d\n", args->args_count);
|
2017-04-24 09:51:27 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (args->args_count)
|
|
|
|
|
phy->id = args->args[0];
|
|
|
|
|
else
|
|
|
|
|
phy->id = 0;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-01 18:14:18 +00:00
|
|
|
int generic_phy_get_by_index_nodev(ofnode node, int index, struct phy *phy)
|
2017-04-24 09:51:27 +00:00
|
|
|
{
|
2017-05-19 02:09:47 +00:00
|
|
|
struct ofnode_phandle_args args;
|
2017-04-24 09:51:27 +00:00
|
|
|
struct phy_ops *ops;
|
2023-05-15 09:59:47 +00:00
|
|
|
struct udevice *phydev, *supply = NULL;
|
2018-06-27 09:55:42 +00:00
|
|
|
int i, ret;
|
2017-04-24 09:51:27 +00:00
|
|
|
|
2020-03-30 09:27:23 +00:00
|
|
|
debug("%s(node=%s, index=%d, phy=%p)\n",
|
|
|
|
|
__func__, ofnode_get_name(node), index, phy);
|
2017-04-24 09:51:27 +00:00
|
|
|
|
|
|
|
|
assert(phy);
|
2017-07-18 09:38:42 +00:00
|
|
|
phy->dev = NULL;
|
2020-03-30 09:27:23 +00:00
|
|
|
ret = ofnode_parse_phandle_with_args(node, "phys", "#phy-cells", 0,
|
|
|
|
|
index, &args);
|
2017-04-24 09:51:27 +00:00
|
|
|
if (ret) {
|
2017-05-19 02:09:47 +00:00
|
|
|
debug("%s: dev_read_phandle_with_args failed: err=%d\n",
|
2017-04-24 09:51:27 +00:00
|
|
|
__func__, ret);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-19 02:09:47 +00:00
|
|
|
ret = uclass_get_device_by_ofnode(UCLASS_PHY, args.node, &phydev);
|
2017-04-24 09:51:27 +00:00
|
|
|
if (ret) {
|
2017-05-19 02:09:47 +00:00
|
|
|
debug("%s: uclass_get_device_by_ofnode failed: err=%d\n",
|
2017-04-24 09:51:27 +00:00
|
|
|
__func__, ret);
|
2018-06-27 09:55:42 +00:00
|
|
|
|
|
|
|
|
/* Check if args.node's parent is a PHY provider */
|
|
|
|
|
ret = uclass_get_device_by_ofnode(UCLASS_PHY,
|
|
|
|
|
ofnode_get_parent(args.node),
|
|
|
|
|
&phydev);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
/* insert phy idx at first position into args array */
|
2018-08-07 10:24:35 +00:00
|
|
|
for (i = args.args_count; i >= 1 ; i--)
|
2018-06-27 09:55:42 +00:00
|
|
|
args.args[i] = args.args[i - 1];
|
|
|
|
|
|
|
|
|
|
args.args_count++;
|
|
|
|
|
args.args[0] = ofnode_read_u32_default(args.node, "reg", -1);
|
2017-04-24 09:51:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
phy->dev = phydev;
|
|
|
|
|
|
|
|
|
|
ops = phy_dev_ops(phydev);
|
|
|
|
|
|
|
|
|
|
if (ops->of_xlate)
|
|
|
|
|
ret = ops->of_xlate(phy, &args);
|
|
|
|
|
else
|
|
|
|
|
ret = generic_phy_xlate_offs_flags(phy, &args);
|
|
|
|
|
if (ret) {
|
|
|
|
|
debug("of_xlate() failed: %d\n", ret);
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-15 09:59:47 +00:00
|
|
|
if (CONFIG_IS_ENABLED(DM_REGULATOR)) {
|
|
|
|
|
ret = device_get_supply_regulator(phydev, "phy-supply",
|
|
|
|
|
&supply);
|
|
|
|
|
if (ret && ret != -ENOENT) {
|
|
|
|
|
debug("%s: device_get_supply_regulator failed: %d\n",
|
|
|
|
|
__func__, ret);
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = phy_alloc_counts(phy, supply);
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
if (ret) {
|
|
|
|
|
debug("phy_alloc_counts() failed: %d\n", ret);
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-24 09:51:27 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
err:
|
2023-08-31 22:16:35 +00:00
|
|
|
phy->dev = NULL;
|
2017-04-24 09:51:27 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-30 09:27:23 +00:00
|
|
|
int generic_phy_get_by_index(struct udevice *dev, int index,
|
|
|
|
|
struct phy *phy)
|
|
|
|
|
{
|
2020-05-01 18:14:18 +00:00
|
|
|
return generic_phy_get_by_index_nodev(dev_ofnode(dev), index, phy);
|
2020-03-30 09:27:23 +00:00
|
|
|
}
|
|
|
|
|
|
2017-04-24 09:51:27 +00:00
|
|
|
int generic_phy_get_by_name(struct udevice *dev, const char *phy_name,
|
|
|
|
|
struct phy *phy)
|
|
|
|
|
{
|
|
|
|
|
int index;
|
|
|
|
|
|
|
|
|
|
debug("%s(dev=%p, name=%s, phy=%p)\n", __func__, dev, phy_name, phy);
|
|
|
|
|
|
2023-08-31 22:16:33 +00:00
|
|
|
assert(phy);
|
|
|
|
|
phy->dev = NULL;
|
|
|
|
|
|
2017-05-19 02:09:47 +00:00
|
|
|
index = dev_read_stringlist_search(dev, "phy-names", phy_name);
|
2017-04-24 09:51:27 +00:00
|
|
|
if (index < 0) {
|
2017-05-19 02:09:47 +00:00
|
|
|
debug("dev_read_stringlist_search() failed: %d\n", index);
|
2017-04-24 09:51:27 +00:00
|
|
|
return index;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return generic_phy_get_by_index(dev, index, phy);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int generic_phy_init(struct phy *phy)
|
|
|
|
|
{
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
struct phy_counts *counts;
|
2019-10-01 12:03:26 +00:00
|
|
|
struct phy_ops const *ops;
|
2020-07-03 15:36:40 +00:00
|
|
|
int ret;
|
2019-10-01 12:03:26 +00:00
|
|
|
|
2020-05-20 17:05:41 +00:00
|
|
|
if (!generic_phy_valid(phy))
|
2019-10-01 12:03:26 +00:00
|
|
|
return 0;
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
counts = phy_get_counts(phy);
|
|
|
|
|
if (counts->init_count > 0) {
|
|
|
|
|
counts->init_count++;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-15 09:59:50 +00:00
|
|
|
ops = phy_dev_ops(phy->dev);
|
|
|
|
|
if (ops->init) {
|
|
|
|
|
ret = ops->init(phy);
|
|
|
|
|
if (ret) {
|
|
|
|
|
dev_err(phy->dev, "PHY: Failed to init %s: %d.\n",
|
|
|
|
|
phy->dev->name, ret);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
counts->init_count = 1;
|
2017-04-24 09:51:27 +00:00
|
|
|
|
2023-05-15 09:59:50 +00:00
|
|
|
return 0;
|
2017-04-24 09:51:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int generic_phy_reset(struct phy *phy)
|
|
|
|
|
{
|
2019-10-01 12:03:26 +00:00
|
|
|
struct phy_ops const *ops;
|
2020-07-03 15:36:40 +00:00
|
|
|
int ret;
|
2019-10-01 12:03:26 +00:00
|
|
|
|
2020-05-20 17:05:41 +00:00
|
|
|
if (!generic_phy_valid(phy))
|
2019-10-01 12:03:26 +00:00
|
|
|
return 0;
|
|
|
|
|
ops = phy_dev_ops(phy->dev);
|
2020-07-03 15:36:40 +00:00
|
|
|
if (!ops->reset)
|
|
|
|
|
return 0;
|
|
|
|
|
ret = ops->reset(phy);
|
|
|
|
|
if (ret)
|
|
|
|
|
dev_err(phy->dev, "PHY: Failed to reset %s: %d.\n",
|
|
|
|
|
phy->dev->name, ret);
|
2017-04-24 09:51:27 +00:00
|
|
|
|
2020-07-03 15:36:40 +00:00
|
|
|
return ret;
|
2017-04-24 09:51:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int generic_phy_exit(struct phy *phy)
|
|
|
|
|
{
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
struct phy_counts *counts;
|
2019-10-01 12:03:26 +00:00
|
|
|
struct phy_ops const *ops;
|
2020-07-03 15:36:40 +00:00
|
|
|
int ret;
|
2019-10-01 12:03:26 +00:00
|
|
|
|
2020-05-20 17:05:41 +00:00
|
|
|
if (!generic_phy_valid(phy))
|
2019-10-01 12:03:26 +00:00
|
|
|
return 0;
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
counts = phy_get_counts(phy);
|
|
|
|
|
if (counts->init_count == 0)
|
|
|
|
|
return 0;
|
|
|
|
|
if (counts->init_count > 1) {
|
|
|
|
|
counts->init_count--;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-15 09:59:50 +00:00
|
|
|
ops = phy_dev_ops(phy->dev);
|
|
|
|
|
if (ops->exit) {
|
|
|
|
|
ret = ops->exit(phy);
|
|
|
|
|
if (ret) {
|
|
|
|
|
dev_err(phy->dev, "PHY: Failed to exit %s: %d.\n",
|
|
|
|
|
phy->dev->name, ret);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
counts->init_count = 0;
|
2017-04-24 09:51:27 +00:00
|
|
|
|
2023-05-15 09:59:50 +00:00
|
|
|
return 0;
|
2017-04-24 09:51:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int generic_phy_power_on(struct phy *phy)
|
|
|
|
|
{
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
struct phy_counts *counts;
|
2019-10-01 12:03:26 +00:00
|
|
|
struct phy_ops const *ops;
|
2020-07-03 15:36:40 +00:00
|
|
|
int ret;
|
2019-10-01 12:03:26 +00:00
|
|
|
|
2020-05-20 17:05:41 +00:00
|
|
|
if (!generic_phy_valid(phy))
|
2019-10-01 12:03:26 +00:00
|
|
|
return 0;
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
counts = phy_get_counts(phy);
|
|
|
|
|
if (counts->power_on_count > 0) {
|
|
|
|
|
counts->power_on_count++;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-15 09:59:47 +00:00
|
|
|
ret = regulator_set_enable_if_allowed(counts->supply, true);
|
|
|
|
|
if (ret && ret != -ENOSYS) {
|
|
|
|
|
dev_err(phy->dev, "PHY: Failed to enable regulator %s: %d.\n",
|
|
|
|
|
counts->supply->name, ret);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-15 09:59:50 +00:00
|
|
|
ops = phy_dev_ops(phy->dev);
|
|
|
|
|
if (ops->power_on) {
|
|
|
|
|
ret = ops->power_on(phy);
|
|
|
|
|
if (ret) {
|
|
|
|
|
dev_err(phy->dev, "PHY: Failed to power on %s: %d.\n",
|
|
|
|
|
phy->dev->name, ret);
|
|
|
|
|
regulator_set_enable_if_allowed(counts->supply, false);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2023-05-15 09:59:47 +00:00
|
|
|
}
|
|
|
|
|
counts->power_on_count = 1;
|
2017-04-24 09:51:27 +00:00
|
|
|
|
2023-05-15 09:59:47 +00:00
|
|
|
return 0;
|
2017-04-24 09:51:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int generic_phy_power_off(struct phy *phy)
|
|
|
|
|
{
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
struct phy_counts *counts;
|
2019-10-01 12:03:26 +00:00
|
|
|
struct phy_ops const *ops;
|
2020-07-03 15:36:40 +00:00
|
|
|
int ret;
|
2019-10-01 12:03:26 +00:00
|
|
|
|
2020-05-20 17:05:41 +00:00
|
|
|
if (!generic_phy_valid(phy))
|
2019-10-01 12:03:26 +00:00
|
|
|
return 0;
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
counts = phy_get_counts(phy);
|
|
|
|
|
if (counts->power_on_count == 0)
|
|
|
|
|
return 0;
|
|
|
|
|
if (counts->power_on_count > 1) {
|
|
|
|
|
counts->power_on_count--;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-15 09:59:50 +00:00
|
|
|
ops = phy_dev_ops(phy->dev);
|
|
|
|
|
if (ops->power_off) {
|
|
|
|
|
ret = ops->power_off(phy);
|
|
|
|
|
if (ret) {
|
|
|
|
|
dev_err(phy->dev, "PHY: Failed to power off %s: %d.\n",
|
|
|
|
|
phy->dev->name, ret);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2023-05-15 09:59:47 +00:00
|
|
|
}
|
|
|
|
|
counts->power_on_count = 0;
|
2017-04-24 09:51:27 +00:00
|
|
|
|
2023-05-15 09:59:47 +00:00
|
|
|
ret = regulator_set_enable_if_allowed(counts->supply, false);
|
|
|
|
|
if (ret && ret != -ENOSYS)
|
|
|
|
|
dev_err(phy->dev, "PHY: Failed to disable regulator %s: %d.\n",
|
|
|
|
|
counts->supply->name, ret);
|
|
|
|
|
|
|
|
|
|
return 0;
|
2017-04-24 09:51:27 +00:00
|
|
|
}
|
|
|
|
|
|
2020-12-29 13:58:59 +00:00
|
|
|
int generic_phy_configure(struct phy *phy, void *params)
|
|
|
|
|
{
|
|
|
|
|
struct phy_ops const *ops;
|
|
|
|
|
|
|
|
|
|
if (!generic_phy_valid(phy))
|
|
|
|
|
return 0;
|
|
|
|
|
ops = phy_dev_ops(phy->dev);
|
|
|
|
|
|
|
|
|
|
return ops->configure ? ops->configure(phy, params) : 0;
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-19 17:09:42 +00:00
|
|
|
int generic_phy_set_mode(struct phy *phy, enum phy_mode mode, int submode)
|
|
|
|
|
{
|
|
|
|
|
struct phy_ops const *ops;
|
|
|
|
|
|
|
|
|
|
if (!generic_phy_valid(phy))
|
|
|
|
|
return 0;
|
|
|
|
|
ops = phy_dev_ops(phy->dev);
|
|
|
|
|
|
|
|
|
|
return ops->set_mode ? ops->set_mode(phy, mode, submode) : 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int generic_phy_set_speed(struct phy *phy, int speed)
|
|
|
|
|
{
|
|
|
|
|
struct phy_ops const *ops;
|
|
|
|
|
|
|
|
|
|
if (!generic_phy_valid(phy))
|
|
|
|
|
return 0;
|
|
|
|
|
ops = phy_dev_ops(phy->dev);
|
|
|
|
|
|
|
|
|
|
return ops->set_speed ? ops->set_speed(phy, speed) : 0;
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-02 09:35:11 +00:00
|
|
|
int generic_phy_get_bulk(struct udevice *dev, struct phy_bulk *bulk)
|
|
|
|
|
{
|
|
|
|
|
int i, ret, count;
|
2022-02-03 18:08:38 +00:00
|
|
|
struct udevice *phydev = dev;
|
2020-05-02 09:35:11 +00:00
|
|
|
|
|
|
|
|
bulk->count = 0;
|
|
|
|
|
|
|
|
|
|
/* Return if no phy declared */
|
2022-02-03 18:08:38 +00:00
|
|
|
if (!dev_read_prop(dev, "phys", NULL)) {
|
|
|
|
|
phydev = dev->parent;
|
|
|
|
|
if (!dev_read_prop(phydev, "phys", NULL)) {
|
|
|
|
|
pr_err("%s : no phys property\n", __func__);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-05-02 09:35:11 +00:00
|
|
|
|
2022-02-03 18:08:38 +00:00
|
|
|
count = dev_count_phandle_with_args(phydev, "phys", "#phy-cells", 0);
|
|
|
|
|
if (count < 1) {
|
|
|
|
|
pr_err("%s : no phys found %d\n", __func__, count);
|
2020-05-02 09:35:11 +00:00
|
|
|
return count;
|
2022-02-03 18:08:38 +00:00
|
|
|
}
|
2020-05-02 09:35:11 +00:00
|
|
|
|
2022-02-03 18:08:38 +00:00
|
|
|
bulk->phys = devm_kcalloc(phydev, count, sizeof(struct phy), GFP_KERNEL);
|
2020-05-02 09:35:11 +00:00
|
|
|
if (!bulk->phys)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
2022-02-03 18:08:38 +00:00
|
|
|
ret = generic_phy_get_by_index(phydev, i, &bulk->phys[i]);
|
2020-05-02 09:35:11 +00:00
|
|
|
if (ret) {
|
|
|
|
|
pr_err("Failed to get PHY%d for %s\n", i, dev->name);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
bulk->count++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int generic_phy_init_bulk(struct phy_bulk *bulk)
|
|
|
|
|
{
|
|
|
|
|
struct phy *phys = bulk->phys;
|
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < bulk->count; i++) {
|
|
|
|
|
ret = generic_phy_init(&phys[i]);
|
|
|
|
|
if (ret) {
|
|
|
|
|
pr_err("Can't init PHY%d\n", i);
|
|
|
|
|
goto phys_init_err;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
phys_init_err:
|
|
|
|
|
for (; i > 0; i--)
|
|
|
|
|
generic_phy_exit(&phys[i - 1]);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int generic_phy_exit_bulk(struct phy_bulk *bulk)
|
|
|
|
|
{
|
|
|
|
|
struct phy *phys = bulk->phys;
|
|
|
|
|
int i, ret = 0;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < bulk->count; i++)
|
|
|
|
|
ret |= generic_phy_exit(&phys[i]);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int generic_phy_power_on_bulk(struct phy_bulk *bulk)
|
|
|
|
|
{
|
|
|
|
|
struct phy *phys = bulk->phys;
|
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < bulk->count; i++) {
|
|
|
|
|
ret = generic_phy_power_on(&phys[i]);
|
|
|
|
|
if (ret) {
|
|
|
|
|
pr_err("Can't power on PHY%d\n", i);
|
|
|
|
|
goto phys_poweron_err;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
phys_poweron_err:
|
|
|
|
|
for (; i > 0; i--)
|
|
|
|
|
generic_phy_power_off(&phys[i - 1]);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int generic_phy_power_off_bulk(struct phy_bulk *bulk)
|
|
|
|
|
{
|
|
|
|
|
struct phy *phys = bulk->phys;
|
|
|
|
|
int i, ret = 0;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < bulk->count; i++)
|
|
|
|
|
ret |= generic_phy_power_off(&phys[i]);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2022-09-06 06:15:26 +00:00
|
|
|
int generic_setup_phy(struct udevice *dev, struct phy *phy, int index)
|
|
|
|
|
{
|
2023-08-31 23:07:11 +00:00
|
|
|
int ret;
|
2022-09-06 06:15:26 +00:00
|
|
|
|
|
|
|
|
ret = generic_phy_get_by_index(dev, index, phy);
|
2023-08-31 23:07:11 +00:00
|
|
|
if (ret)
|
|
|
|
|
return ret == -ENOENT ? 0 : ret;
|
2022-09-06 06:15:26 +00:00
|
|
|
|
2023-08-31 23:07:11 +00:00
|
|
|
ret = generic_phy_init(phy);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
ret = generic_phy_power_on(phy);
|
|
|
|
|
if (ret)
|
|
|
|
|
generic_phy_exit(phy);
|
2022-09-06 06:15:26 +00:00
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int generic_shutdown_phy(struct phy *phy)
|
|
|
|
|
{
|
2023-08-31 23:07:11 +00:00
|
|
|
int ret;
|
2022-09-06 06:15:26 +00:00
|
|
|
|
2023-08-31 23:07:11 +00:00
|
|
|
if (!generic_phy_valid(phy))
|
2022-09-06 06:15:26 +00:00
|
|
|
return 0;
|
|
|
|
|
|
2023-08-31 23:07:11 +00:00
|
|
|
ret = generic_phy_power_off(phy);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
2022-09-06 06:15:26 +00:00
|
|
|
|
2023-08-31 23:07:11 +00:00
|
|
|
return generic_phy_exit(phy);
|
2022-09-06 06:15:26 +00:00
|
|
|
}
|
|
|
|
|
|
2017-04-24 09:51:27 +00:00
|
|
|
UCLASS_DRIVER(phy) = {
|
|
|
|
|
.id = UCLASS_PHY,
|
|
|
|
|
.name = "phy",
|
phy: Track power-on and init counts in uclass
On boards using the RK3399 SoC, the USB OHCI and EHCI controllers share
the same PHY device instance. While these controllers are being stopped
they both attempt to power-off and deinitialize it, but trying to
power-off the deinitialized PHY device results in a hang. This usually
happens just before booting an OS, and can be explicitly triggered by
running "usb start; usb stop" in the U-Boot shell.
Implement a uclass-wide counting mechanism for PHY initialization and
power state change requests, so that we don't power-off/deinitialize a
PHY instance until all of its users want it done. The Allwinner A10 USB
PHY driver does this counting in-driver, remove those parts in favour of
this in-uclass implementation.
The sandbox PHY operations test needs some changes since the uclass will
no longer call into the drivers for actions matching its tracked state
(e.g. powering-off a powered-off PHY). Update that test, and add a new
one which simulates multiple users of a single PHY.
The major complication here is that PHY handles aren't deduplicated per
instance, so the obvious idea of putting the counts in the PHY handles
don't immediately work. It seems possible to bind a child udevice per
PHY instance to the PHY provider and deduplicate the handles in each
child's uclass-private areas, like in the CLK framework. An alternative
approach could be to use those bound child udevices themselves as the
PHY handles. Instead, to avoid the architectural changes those would
require, this patch solves things by dynamically allocating a list of
structs (one per instance) in the provider's uclass-private area.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Peter Robinson <pbrobinson@gmail.com> - Rock960
2021-12-30 19:36:51 +00:00
|
|
|
.pre_probe = phy_uclass_pre_probe,
|
|
|
|
|
.pre_remove = phy_uclass_pre_remove,
|
|
|
|
|
.per_device_auto = sizeof(struct list_head),
|
2017-04-24 09:51:27 +00:00
|
|
|
};
|
