2018-05-06 21:58:06 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2017-04-24 09:51:28 +00:00
|
|
|
/*
|
2023-11-01 20:56:03 +00:00
|
|
|
* Copyright (C) 2017 Texas Instruments Incorporated - https://www.ti.com/
|
2017-04-24 09:51:28 +00:00
|
|
|
* Written by Jean-Jacques Hiblot <jjhiblot@ti.com>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <common.h>
|
|
|
|
|
#include <dm.h>
|
|
|
|
|
#include <generic-phy.h>
|
2020-05-10 17:40:05 +00:00
|
|
|
#include <log.h>
|
2017-04-24 09:51:28 +00:00
|
|
|
#include <dm/test.h>
|
2020-07-19 16:15:37 +00:00
|
|
|
#include <test/test.h>
|
2017-04-24 09:51:28 +00:00
|
|
|
#include <test/ut.h>
|
|
|
|
|
|
|
|
|
|
/* Base test of the phy uclass */
|
|
|
|
|
static int dm_test_phy_base(struct unit_test_state *uts)
|
|
|
|
|
{
|
|
|
|
|
struct udevice *dev;
|
|
|
|
|
struct phy phy1_method1;
|
|
|
|
|
struct phy phy1_method2;
|
|
|
|
|
struct phy phy2;
|
|
|
|
|
struct phy phy3;
|
|
|
|
|
struct udevice *parent;
|
|
|
|
|
|
|
|
|
|
/* Get the device using the phy device*/
|
|
|
|
|
ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
|
|
|
|
|
"gen_phy_user", &parent));
|
|
|
|
|
/*
|
|
|
|
|
* Get the same phy port in 2 different ways and compare.
|
|
|
|
|
*/
|
2023-03-10 03:33:13 +00:00
|
|
|
ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1_method1));
|
2023-08-31 22:16:33 +00:00
|
|
|
ut_assert(generic_phy_valid(&phy1_method1));
|
2023-03-10 03:33:13 +00:00
|
|
|
ut_assertok(generic_phy_get_by_index(parent, 0, &phy1_method2));
|
2023-08-31 22:16:33 +00:00
|
|
|
ut_assert(generic_phy_valid(&phy1_method2));
|
2017-04-24 09:51:28 +00:00
|
|
|
ut_asserteq(phy1_method1.id, phy1_method2.id);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Get the second phy port. Check that the same phy provider (device)
|
|
|
|
|
* provides this 2nd phy port, but that the IDs are different
|
|
|
|
|
*/
|
2023-03-10 03:33:13 +00:00
|
|
|
ut_assertok(generic_phy_get_by_name(parent, "phy2", &phy2));
|
2017-04-24 09:51:28 +00:00
|
|
|
ut_asserteq_ptr(phy1_method2.dev, phy2.dev);
|
|
|
|
|
ut_assert(phy1_method1.id != phy2.id);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Get the third phy port. Check that the phy provider is different
|
|
|
|
|
*/
|
2023-03-10 03:33:13 +00:00
|
|
|
ut_assertok(generic_phy_get_by_name(parent, "phy3", &phy3));
|
2017-04-24 09:51:28 +00:00
|
|
|
ut_assert(phy2.dev != phy3.dev);
|
|
|
|
|
|
|
|
|
|
/* Try to get a non-existing phy */
|
2023-08-31 22:16:35 +00:00
|
|
|
ut_asserteq(-ENODEV, uclass_get_device(UCLASS_PHY, 5, &dev));
|
2017-05-19 02:09:45 +00:00
|
|
|
ut_asserteq(-ENODATA, generic_phy_get_by_name(parent,
|
|
|
|
|
"phy_not_existing", &phy1_method1));
|
2023-08-31 22:16:33 +00:00
|
|
|
ut_assert(!generic_phy_valid(&phy1_method1));
|
|
|
|
|
ut_asserteq(-ENOENT, generic_phy_get_by_index(parent, 3,
|
|
|
|
|
&phy1_method2));
|
|
|
|
|
ut_assert(!generic_phy_valid(&phy1_method2));
|
2017-04-24 09:51:28 +00:00
|
|
|
|
2023-08-31 22:16:35 +00:00
|
|
|
/* Try to get a phy where of_xlate fail */
|
|
|
|
|
ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
|
|
|
|
|
"gen_phy_user2", &parent));
|
|
|
|
|
ut_asserteq(-EINVAL, generic_phy_get_by_name(parent, "phy1",
|
|
|
|
|
&phy1_method1));
|
|
|
|
|
ut_assert(!generic_phy_valid(&phy1_method1));
|
|
|
|
|
ut_asserteq(-EINVAL, generic_phy_get_by_index(parent, 0,
|
|
|
|
|
&phy1_method2));
|
|
|
|
|
ut_assert(!generic_phy_valid(&phy1_method2));
|
|
|
|
|
|
2017-04-24 09:51:28 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
2020-07-29 01:41:12 +00:00
|
|
|
DM_TEST(dm_test_phy_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
|
2017-04-24 09:51:28 +00:00
|
|
|
|
|
|
|
|
/* Test of the phy uclass using the sandbox phy driver operations */
|
|
|
|
|
static int dm_test_phy_ops(struct unit_test_state *uts)
|
|
|
|
|
{
|
|
|
|
|
struct phy phy1;
|
|
|
|
|
struct phy phy2;
|
|
|
|
|
struct phy phy3;
|
|
|
|
|
struct udevice *parent;
|
|
|
|
|
|
|
|
|
|
ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
|
|
|
|
|
"gen_phy_user", &parent));
|
|
|
|
|
|
|
|
|
|
ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1));
|
2017-05-19 02:09:45 +00:00
|
|
|
ut_asserteq(0, phy1.id);
|
2017-04-24 09:51:28 +00:00
|
|
|
ut_assertok(generic_phy_get_by_name(parent, "phy2", &phy2));
|
2017-05-19 02:09:45 +00:00
|
|
|
ut_asserteq(1, phy2.id);
|
2017-04-24 09:51:28 +00:00
|
|
|
ut_assertok(generic_phy_get_by_name(parent, "phy3", &phy3));
|
2017-05-19 02:09:45 +00:00
|
|
|
ut_asserteq(0, phy3.id);
|
2017-04-24 09:51:28 +00:00
|
|
|
|
|
|
|
|
/* test normal operations */
|
|
|
|
|
ut_assertok(generic_phy_init(&phy1));
|
|
|
|
|
ut_assertok(generic_phy_power_on(&phy1));
|
|
|
|
|
ut_assertok(generic_phy_power_off(&phy1));
|
|
|
|
|
|
|
|
|
|
/*
|
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
|
|
|
* Test power_on() failure after exit().
|
|
|
|
|
* The sandbox phy driver does not allow power-on/off after
|
|
|
|
|
* exit, but the uclass counts power-on/init calls and skips
|
|
|
|
|
* calling the driver's ops when e.g. powering off an already
|
|
|
|
|
* powered-off phy.
|
2017-04-24 09:51:28 +00:00
|
|
|
*/
|
|
|
|
|
ut_assertok(generic_phy_exit(&phy1));
|
|
|
|
|
ut_assert(generic_phy_power_on(&phy1) != 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
|
|
|
ut_assertok(generic_phy_power_off(&phy1));
|
2017-04-24 09:51:28 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* test normal operations again (after re-init)
|
|
|
|
|
*/
|
|
|
|
|
ut_assertok(generic_phy_init(&phy1));
|
|
|
|
|
ut_assertok(generic_phy_power_on(&phy1));
|
|
|
|
|
ut_assertok(generic_phy_power_off(&phy1));
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* test calling unimplemented feature.
|
|
|
|
|
* The call is expected to succeed
|
|
|
|
|
*/
|
|
|
|
|
ut_assertok(generic_phy_reset(&phy1));
|
|
|
|
|
|
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
|
|
|
/*
|
|
|
|
|
* Test power_off() failure after exit().
|
|
|
|
|
* For this we need to call exit() while the phy is powered-on,
|
|
|
|
|
* so that the uclass actually calls the driver's power-off()
|
|
|
|
|
* and reports the resulting failure.
|
|
|
|
|
*/
|
|
|
|
|
ut_assertok(generic_phy_power_on(&phy1));
|
|
|
|
|
ut_assertok(generic_phy_exit(&phy1));
|
|
|
|
|
ut_assert(generic_phy_power_off(&phy1) != 0);
|
|
|
|
|
ut_assertok(generic_phy_power_on(&phy1));
|
|
|
|
|
|
2017-04-24 09:51:28 +00:00
|
|
|
/* PHY2 has a known problem with power off */
|
|
|
|
|
ut_assertok(generic_phy_init(&phy2));
|
|
|
|
|
ut_assertok(generic_phy_power_on(&phy2));
|
2017-05-19 02:09:45 +00:00
|
|
|
ut_asserteq(-EIO, generic_phy_power_off(&phy2));
|
2017-04-24 09:51:28 +00:00
|
|
|
|
2017-05-19 02:09:45 +00:00
|
|
|
/* PHY3 has a known problem with power off and power on */
|
2017-04-24 09:51:28 +00:00
|
|
|
ut_assertok(generic_phy_init(&phy3));
|
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
|
|
|
ut_asserteq(-EIO, generic_phy_power_on(&phy3));
|
|
|
|
|
ut_assertok(generic_phy_power_off(&phy3));
|
2017-04-24 09:51:28 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2020-07-29 01:41:12 +00:00
|
|
|
DM_TEST(dm_test_phy_ops, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
|
2020-05-02 09:35:12 +00:00
|
|
|
|
|
|
|
|
static int dm_test_phy_bulk(struct unit_test_state *uts)
|
|
|
|
|
{
|
|
|
|
|
struct phy_bulk phys;
|
|
|
|
|
struct udevice *parent;
|
|
|
|
|
|
|
|
|
|
/* test normal operations */
|
|
|
|
|
ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
|
|
|
|
|
"gen_phy_user1", &parent));
|
|
|
|
|
|
|
|
|
|
ut_assertok(generic_phy_get_bulk(parent, &phys));
|
|
|
|
|
ut_asserteq(2, phys.count);
|
|
|
|
|
|
|
|
|
|
ut_asserteq(0, generic_phy_init_bulk(&phys));
|
|
|
|
|
ut_asserteq(0, generic_phy_power_on_bulk(&phys));
|
|
|
|
|
ut_asserteq(0, generic_phy_power_off_bulk(&phys));
|
|
|
|
|
ut_asserteq(0, generic_phy_exit_bulk(&phys));
|
|
|
|
|
|
|
|
|
|
/* has a known problem phy */
|
|
|
|
|
ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
|
|
|
|
|
"gen_phy_user", &parent));
|
|
|
|
|
|
|
|
|
|
ut_assertok(generic_phy_get_bulk(parent, &phys));
|
|
|
|
|
ut_asserteq(3, phys.count);
|
|
|
|
|
|
|
|
|
|
ut_asserteq(0, generic_phy_init_bulk(&phys));
|
|
|
|
|
ut_asserteq(-EIO, generic_phy_power_on_bulk(&phys));
|
|
|
|
|
ut_asserteq(-EIO, generic_phy_power_off_bulk(&phys));
|
|
|
|
|
ut_asserteq(0, generic_phy_exit_bulk(&phys));
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2020-07-29 01:41:12 +00:00
|
|
|
DM_TEST(dm_test_phy_bulk, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
|
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 int dm_test_phy_multi_exit(struct unit_test_state *uts)
|
|
|
|
|
{
|
|
|
|
|
struct phy phy1_method1;
|
|
|
|
|
struct phy phy1_method2;
|
|
|
|
|
struct phy phy1_method3;
|
|
|
|
|
struct udevice *parent;
|
|
|
|
|
|
|
|
|
|
/* Get the same phy instance in 3 different ways. */
|
|
|
|
|
ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
|
|
|
|
|
"gen_phy_user", &parent));
|
|
|
|
|
ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1_method1));
|
|
|
|
|
ut_asserteq(0, phy1_method1.id);
|
|
|
|
|
ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1_method2));
|
|
|
|
|
ut_asserteq(0, phy1_method2.id);
|
|
|
|
|
ut_asserteq_ptr(phy1_method1.dev, phy1_method1.dev);
|
|
|
|
|
|
|
|
|
|
ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
|
|
|
|
|
"gen_phy_user1", &parent));
|
|
|
|
|
ut_assertok(generic_phy_get_by_name(parent, "phy1", &phy1_method3));
|
|
|
|
|
ut_asserteq(0, phy1_method3.id);
|
|
|
|
|
ut_asserteq_ptr(phy1_method1.dev, phy1_method3.dev);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Test using the same PHY from different handles.
|
|
|
|
|
* In non-test code these could be in different drivers.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* These must only call the driver's ops at the first init()
|
|
|
|
|
* and power_on().
|
|
|
|
|
*/
|
|
|
|
|
ut_assertok(generic_phy_init(&phy1_method1));
|
|
|
|
|
ut_assertok(generic_phy_init(&phy1_method2));
|
|
|
|
|
ut_assertok(generic_phy_power_on(&phy1_method1));
|
|
|
|
|
ut_assertok(generic_phy_power_on(&phy1_method2));
|
|
|
|
|
ut_assertok(generic_phy_init(&phy1_method3));
|
|
|
|
|
ut_assertok(generic_phy_power_on(&phy1_method3));
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* These must not call the driver's ops as other handles still
|
|
|
|
|
* want the PHY powered-on and initialized.
|
|
|
|
|
*/
|
|
|
|
|
ut_assertok(generic_phy_power_off(&phy1_method3));
|
|
|
|
|
ut_assertok(generic_phy_exit(&phy1_method3));
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We would get an error here if the generic_phy_exit() above
|
|
|
|
|
* actually called the driver's exit(), as the sandbox driver
|
|
|
|
|
* doesn't allow power-off() after exit().
|
|
|
|
|
*/
|
|
|
|
|
ut_assertok(generic_phy_power_off(&phy1_method1));
|
|
|
|
|
ut_assertok(generic_phy_power_off(&phy1_method2));
|
|
|
|
|
ut_assertok(generic_phy_exit(&phy1_method1));
|
|
|
|
|
ut_assertok(generic_phy_exit(&phy1_method2));
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
DM_TEST(dm_test_phy_multi_exit, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
|
2023-08-31 23:07:08 +00:00
|
|
|
|
|
|
|
|
static int dm_test_phy_setup(struct unit_test_state *uts)
|
|
|
|
|
{
|
|
|
|
|
struct phy phy;
|
|
|
|
|
struct udevice *parent;
|
|
|
|
|
|
|
|
|
|
ut_assertok(uclass_get_device_by_name(UCLASS_SIMPLE_BUS,
|
|
|
|
|
"gen_phy_user", &parent));
|
|
|
|
|
|
|
|
|
|
/* normal */
|
|
|
|
|
ut_assertok(generic_setup_phy(parent, &phy, 0));
|
|
|
|
|
ut_assertok(generic_shutdown_phy(&phy));
|
|
|
|
|
|
|
|
|
|
/* power_off fail with -EIO */
|
|
|
|
|
ut_assertok(generic_setup_phy(parent, &phy, 1));
|
|
|
|
|
ut_asserteq(-EIO, generic_shutdown_phy(&phy));
|
|
|
|
|
|
|
|
|
|
/* power_on fail with -EIO */
|
|
|
|
|
ut_asserteq(-EIO, generic_setup_phy(parent, &phy, 2));
|
|
|
|
|
ut_assertok(generic_shutdown_phy(&phy));
|
|
|
|
|
|
2023-08-31 23:07:10 +00:00
|
|
|
/* generic_phy_get_by_index fail with -ENOENT */
|
|
|
|
|
ut_asserteq(-ENOENT, generic_phy_get_by_index(parent, 3, &phy));
|
|
|
|
|
ut_assertok(generic_setup_phy(parent, &phy, 3));
|
|
|
|
|
ut_assertok(generic_shutdown_phy(&phy));
|
|
|
|
|
|
2023-08-31 23:07:08 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
DM_TEST(dm_test_phy_setup, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
|
