leandrof/u-boot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch '2020-10-28-mux-driver-framework'

Browse Source 
- Add a framework for mux drivers
This commit is contained in:
Tom Rini 2020-10-28 14:50:09 -04:00
commit 4f1d3079b9
21 changed files with 1461 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Kconfig
View File

@ -196,7 +196,7 @@ config SYS_MALLOC_F_LEN
hex "Size of malloc() pool before relocation"
depends on SYS_MALLOC_F
default 0x1000 if AM33XX
default 0x2800 if SANDBOX
default 0x4000 if SANDBOX
default 0x2000 if (ARCH_IMX8 || ARCH_IMX8M || ARCH_MX7 || \
ARCH_MX7ULP || ARCH_MX6 || ARCH_MX5 || \
ARCH_LS1012A || ARCH_LS1021A || ARCH_LS1043A || \

33
arch/sandbox/dts/test.dts
View File

@ -3,6 +3,7 @@
#include <dt-bindings/gpio/gpio.h>
#include <dt-bindings/gpio/sandbox-gpio.h>
#include <dt-bindings/pinctrl/sandbox-pinmux.h>
#include <dt-bindings/mux/mux.h>
/ {
model = "sandbox";
@ -133,6 +134,12 @@
interrupts-extended = <&irq 3 0>;
acpi,name = "GHIJ";
phandle-value = <&gpio_c 10>, <0xFFFFFFFF 20>, <&gpio_a 30>;
mux-controls = <&muxcontroller0 0>, <&muxcontroller0 1>,
<&muxcontroller0 2>, <&muxcontroller0 3>,
<&muxcontroller1>;
mux-control-names = "mux0", "mux1", "mux2", "mux3", "mux4";
mux-syscon = <&syscon3>;
};
junk {
@ -170,6 +177,9 @@
compatible = "denx,u-boot-fdt-test";
ping-expect = <3>;
ping-add = <3>;
mux-controls = <&muxcontroller0 0>;
mux-control-names = "mux0";
};
phy_provider0: gen_phy@0 {
@ -884,6 +894,29 @@
0x58 8>;
};
syscon3: syscon@3 {
compatible = "simple-mfd", "syscon";
reg = <0x000100 0x10>;
muxcontroller0: a-mux-controller {
compatible = "mmio-mux";
#mux-control-cells = <1>;
mux-reg-masks = <0x0 0x30>, /* 0: reg 0x0, bits 5:4 */
<0xc 0x1E>, /* 1: reg 0xc, bits 4:1 */
<0x4 0xFF>; /* 2: reg 0x4, bits 7:0 */
idle-states = <MUX_IDLE_AS_IS>, <0x02>, <0x73>;
u-boot,mux-autoprobe;
};
};
muxcontroller1: emul-mux-controller {
compatible = "mux-emul";
#mux-control-cells = <0>;
u-boot,mux-autoprobe;
idle-state = <0xabcd>;
};
timer@0 {
compatible = "sandbox,timer";
clock-frequency = <1000000>;

6
cmd/Kconfig
View File

@ -1081,6 +1081,12 @@ config CMD_MTD
help
MTD commands support.
config CMD_MUX
bool "mux"
depends on MULTIPLEXER
help
List, select, and deselect mux controllers on the fly.
config CMD_NAND
bool "nand"
default y if NAND_SUNXI

1
cmd/Makefile
View File

@ -105,6 +105,7 @@ obj-$(CONFIG_CMD_CLONE) += clone.o
ifneq ($(CONFIG_CMD_NAND)$(CONFIG_CMD_SF),)
obj-y += legacy-mtd-utils.o
endif
obj-$(CONFIG_CMD_MUX) += mux.o
obj-$(CONFIG_CMD_NAND) += nand.o
obj-$(CONFIG_CMD_NET) += net.o
obj-$(CONFIG_CMD_NVEDIT_EFI) += nvedit_efi.o

184
cmd/mux.c Normal file
View File

@ -0,0 +1,184 @@
// SPDX-License-Identifier: GPL-2.0
/*
* List, select, and deselect mux controllers on the fly.
*
* Copyright (c) 2020 Texas Instruments Inc.
* Author: Pratyush Yadav <p.yadav@ti.com>
*/
#include <common.h>
#include <command.h>
#include <errno.h>
#include <dm.h>
#include <dm/device_compat.h>
#include <mux.h>
#include <mux-internal.h>
#include <linux/err.h>
#include <dt-bindings/mux/mux.h>
#define COLUMN_SIZE 16
/*
* Print a member of a column. The total size of the text printed, including
* trailing whitespace, will always be COLUMN_SIZE.
*/
#define PRINT_COLUMN(fmt, args...) do { \
char buf[COLUMN_SIZE + 1]; \
snprintf(buf, COLUMN_SIZE + 1, fmt, ##args); \
printf("%-*s", COLUMN_SIZE, buf); \
} while (0)
/*
* Find a mux based on its device name in argv[1] and index in the chip in
* argv[2].
*/
static struct mux_control *cmd_mux_find(char *const argv[])
{
struct udevice *dev;
struct mux_chip *chip;
int ret;
unsigned long id;
ret = strict_strtoul(argv[2], 10, &id);
if (ret)
return ERR_PTR(ret);
ret = uclass_get_device_by_name(UCLASS_MUX, argv[1], &dev);
if (ret)
return ERR_PTR(ret);
chip = dev_get_uclass_priv(dev);
if (!chip)
return ERR_PTR(ret);
if (id >= chip->controllers)
return ERR_PTR(-EINVAL);
return &chip->mux[id];
}
/*
* Print the details of a mux. The columns printed correspond to: "Selected",
* "Current State", "Idle State", and "Num States".
*/
static void print_mux(struct mux_control *mux)
{
PRINT_COLUMN("%s", mux->in_use ? "yes" : "no");
if (mux->cached_state == MUX_IDLE_AS_IS)
PRINT_COLUMN("%s", "unknown");
else
PRINT_COLUMN("0x%x", mux->cached_state);
if (mux->idle_state == MUX_IDLE_AS_IS)
PRINT_COLUMN("%s", "as-is");
else if (mux->idle_state == MUX_IDLE_DISCONNECT)
PRINT_COLUMN("%s", "disconnect");
else
PRINT_COLUMN("0x%x", mux->idle_state);
PRINT_COLUMN("0x%x", mux->states);
printf("\n");
}
static int do_mux_list(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
struct udevice *dev;
struct mux_chip *chip;
int j;
for (uclass_first_device(UCLASS_MUX, &dev);
dev;
uclass_next_device(&dev)) {
chip = dev_get_uclass_priv(dev);
if (!chip) {
dev_err(dev, "can't find mux chip\n");
continue;
}
printf("%s:\n", dev->name);
printf(" ");
PRINT_COLUMN("ID");
PRINT_COLUMN("Selected");
PRINT_COLUMN("Current State");
PRINT_COLUMN("Idle State");
PRINT_COLUMN("Num States");
printf("\n");
for (j = 0; j < chip->controllers; j++) {
printf(" ");
PRINT_COLUMN("%d", j);
print_mux(&chip->mux[j]);
}
printf("\n");
}
return 0;
}
static int do_mux_select(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
struct mux_control *mux;
int ret;
unsigned long state;
if (argc != 4)
return CMD_RET_USAGE;
mux = cmd_mux_find(argv);
if (IS_ERR_OR_NULL(mux)) {
printf("Failed to find the specified mux\n");
return CMD_RET_FAILURE;
}
ret = strict_strtoul(argv[3], 16, &state);
if (ret) {
printf("Invalid state\n");
return CMD_RET_FAILURE;
}
ret = mux_control_select(mux, state);
if (ret) {
printf("Failed to select requested state\n");
return CMD_RET_FAILURE;
}
return CMD_RET_SUCCESS;
}
static int do_mux_deselect(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
struct mux_control *mux;
int ret;
if (argc != 3)
return CMD_RET_USAGE;
mux = cmd_mux_find(argv);
if (IS_ERR_OR_NULL(mux)) {
printf("Failed to find the specified mux\n");
return CMD_RET_FAILURE;
}
ret = mux_control_deselect(mux);
if (ret) {
printf("Failed to deselect mux\n");
return CMD_RET_FAILURE;
}
return CMD_RET_SUCCESS;
}
static char mux_help_text[] =
"list - List all Muxes and their states\n"
"select <chip> <id> <state> - Select the given mux state\n"
"deselect <chip> <id> - Deselect the given mux and reset it to its idle state";
U_BOOT_CMD_WITH_SUBCMDS(mux, "List, select, and deselect muxes", mux_help_text,
U_BOOT_SUBCMD_MKENT(list, 1, 1, do_mux_list),
U_BOOT_SUBCMD_MKENT(select, 4, 0, do_mux_select),
U_BOOT_SUBCMD_MKENT(deselect, 3, 0, do_mux_deselect));

12
common/board_r.c
View File

@ -46,6 +46,7 @@
#include <miiphy.h>
#endif
#include <mmc.h>
#include <mux.h>
#include <nand.h>
#include <of_live.h>
#include <onenand_uboot.h>
@ -341,6 +342,17 @@ static int initr_dm_devices(void)
return ret;
}
if (IS_ENABLED(CONFIG_MULTIPLEXER)) {
/*
* Initialize the multiplexer controls to their default state.
* This must be done early as other drivers may unknowingly
* rely on it.
*/
ret = dm_mux_init();
if (ret)
return ret;
}
return 0;
}

3
configs/sandbox_defconfig
View File

@ -55,6 +55,7 @@ CONFIG_CMD_GPT_RENAME=y
CONFIG_CMD_IDE=y
CONFIG_CMD_I2C=y
CONFIG_CMD_LSBLK=y
CONFIG_CMD_MUX=y
CONFIG_CMD_OSD=y
CONFIG_CMD_PCI=y
CONFIG_CMD_READ=y
@ -179,6 +180,8 @@ CONFIG_SPI_FLASH_SPANSION=y
CONFIG_SPI_FLASH_STMICRO=y
CONFIG_SPI_FLASH_SST=y
CONFIG_SPI_FLASH_WINBOND=y
CONFIG_MULTIPLEXER=y
CONFIG_MUX_MMIO=y
CONFIG_DM_ETH=y
CONFIG_NVME=y
CONFIG_PCI=y

2
drivers/Kconfig
View File

@ -64,6 +64,8 @@ source "drivers/mmc/Kconfig"
source "drivers/mtd/Kconfig"
source "drivers/mux/Kconfig"
source "drivers/net/Kconfig"
source "drivers/nvme/Kconfig"

1
drivers/Makefile
View File

@ -14,6 +14,7 @@ obj-$(CONFIG_$(SPL_TPL_)INPUT) += input/
obj-$(CONFIG_$(SPL_TPL_)LED) += led/
obj-$(CONFIG_$(SPL_TPL_)MMC_SUPPORT) += mmc/
obj-y += mtd/
obj-$(CONFIG_$(SPL_)MULTIPLEXER) += mux/
obj-$(CONFIG_$(SPL_TPL_)PCH_SUPPORT) += pch/
obj-$(CONFIG_$(SPL_TPL_)PCI) += pci/
obj-$(CONFIG_$(SPL_TPL_)PHY) += phy/

25
drivers/mux/Kconfig Normal file
View File

@ -0,0 +1,25 @@
menu "Multiplexer drivers"
config MULTIPLEXER
bool "Multiplexer Support"
depends on DM
help
The mux framework is a minimalistic subsystem that handles multiplexer
controllers. It provides the same API as Linux and mux drivers should
be portable with a minimum effort.
if MULTIPLEXER
config MUX_MMIO
bool "MMIO register bitfield-controlled Multiplexer"
depends on MULTIPLEXER && SYSCON
help
MMIO register bitfield-controlled Multiplexer controller.
The driver builds multiplexer controllers for bitfields in a syscon
register. For N bit wide bitfields, there will be 2^N possible
multiplexer states.
endif
endmenu

7
drivers/mux/Makefile Normal file
View File

@ -0,0 +1,7 @@
# SPDX-License-Identifier: GPL-2.0+
#
# (C) Copyright 2019
# Jean-Jacques Hiblot <jjhiblot@ti.com>
obj-$(CONFIG_$(SPL_)MULTIPLEXER) += mux-uclass.o
obj-$(CONFIG_$(SPL_)MUX_MMIO) += mmio.o

142
drivers/mux/mmio.c Normal file
View File

@ -0,0 +1,142 @@
// SPDX-License-Identifier: GPL-2.0
/*
* MMIO register bitfield-controlled multiplexer driver
* Based on the linux mmio multiplexer driver
*
* Copyright (C) 2017 Pengutronix, Philipp Zabel <kernel@pengutronix.de>
* Copyright (C) 2019 Texas Instrument, Jean-jacques Hiblot <jjhiblot@ti.com>
*/
#include <common.h>
#include <dm.h>
#include <mux-internal.h>
#include <regmap.h>
#include <syscon.h>
#include <dm/device.h>
#include <dm/device_compat.h>
#include <dm/read.h>
#include <dm/devres.h>
#include <dt-bindings/mux/mux.h>
#include <linux/bitops.h>
static int mux_mmio_set(struct mux_control *mux, int state)
{
struct regmap_field **fields = dev_get_priv(mux->dev);
return regmap_field_write(fields[mux_control_get_index(mux)], state);
}
static const struct mux_control_ops mux_mmio_ops = {
.set = mux_mmio_set,
};
static const struct udevice_id mmio_mux_of_match[] = {
{ .compatible = "mmio-mux" },
{ /* sentinel */ },
};
static int mmio_mux_probe(struct udevice *dev)
{
struct regmap_field **fields;
struct mux_chip *mux_chip = dev_get_uclass_priv(dev);
struct regmap *regmap;
u32 *mux_reg_masks;
u32 *idle_states;
int num_fields;
int ret;
int i;
regmap = syscon_node_to_regmap(dev_ofnode(dev->parent));
if (IS_ERR(regmap)) {
ret = PTR_ERR(regmap);
dev_err(dev, "failed to get regmap: %d\n", ret);
return ret;
}
num_fields = dev_read_size(dev, "mux-reg-masks");
if (num_fields < 0)
return log_msg_ret("mux-reg-masks missing", -EINVAL);
num_fields /= sizeof(u32);
if (num_fields == 0 || num_fields % 2)
ret = -EINVAL;
num_fields = num_fields / 2;
ret = mux_alloc_controllers(dev, num_fields);
if (ret < 0)
return log_msg_ret("mux_alloc_controllers", ret);
fields = devm_kmalloc(dev, num_fields * sizeof(*fields), __GFP_ZERO);
if (!fields)
return -ENOMEM;
dev->priv = fields;
mux_reg_masks = devm_kmalloc(dev, num_fields * 2 * sizeof(u32),
__GFP_ZERO);
if (!mux_reg_masks)
return -ENOMEM;
ret = dev_read_u32_array(dev, "mux-reg-masks", mux_reg_masks,
num_fields * 2);
if (ret < 0)
return log_msg_ret("mux-reg-masks read", ret);
idle_states = devm_kmalloc(dev, num_fields * sizeof(u32), __GFP_ZERO);
if (!idle_states)
return -ENOMEM;
ret = dev_read_u32_array(dev, "idle-states", idle_states, num_fields);
if (ret < 0) {
log_err("idle-states");
devm_kfree(dev, idle_states);
idle_states = NULL;
}
for (i = 0; i < num_fields; i++) {
struct mux_control *mux = &mux_chip->mux[i];
struct reg_field field;
u32 reg, mask;
int bits;
reg = mux_reg_masks[2 * i];
mask = mux_reg_masks[2 * i + 1];
field.reg = reg;
field.msb = fls(mask) - 1;
field.lsb = ffs(mask) - 1;
if (mask != GENMASK(field.msb, field.lsb))
return log_msg_ret("invalid mask", -EINVAL);
fields[i] = devm_regmap_field_alloc(dev, regmap, field);
if (IS_ERR(fields[i])) {
ret = PTR_ERR(fields[i]);
return log_msg_ret("regmap_field_alloc", ret);
}
bits = 1 + field.msb - field.lsb;
mux->states = 1 << bits;
if (!idle_states)
continue;
if (idle_states[i] != MUX_IDLE_AS_IS &&
idle_states[i] >= mux->states)
return log_msg_ret("idle-states range", -EINVAL);
mux->idle_state = idle_states[i];
}
devm_kfree(dev, mux_reg_masks);
if (idle_states)
devm_kfree(dev, idle_states);
return 0;
}
U_BOOT_DRIVER(mmio_mux) = {
.name = "mmio-mux",
.id = UCLASS_MUX,
.of_match = mmio_mux_of_match,
.probe = mmio_mux_probe,
.ops = &mux_mmio_ops,
};

335
drivers/mux/mux-uclass.c Normal file
View File

@ -0,0 +1,335 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Multiplexer subsystem
*
* Based on the linux multiplexer framework
*
* Copyright (C) 2017 Axentia Technologies AB
* Author: Peter Rosin <peda@axentia.se>
*
* Copyright (C) 2017-2018 Texas Instruments Incorporated - http://www.ti.com/
* Jean-Jacques Hiblot <jjhiblot@ti.com>
*/
#include <common.h>
#include <dm.h>
#include <mux-internal.h>
#include <dm/device-internal.h>
#include <dm/device_compat.h>
#include <dm/devres.h>
#include <dt-bindings/mux/mux.h>
#include <linux/bug.h>
/*
* The idle-as-is "state" is not an actual state that may be selected, it
* only implies that the state should not be changed. So, use that state
* as indication that the cached state of the multiplexer is unknown.
*/
#define MUX_CACHE_UNKNOWN MUX_IDLE_AS_IS
/**
* mux_control_ops() - Get the mux_control ops.
* @dev: The client device.
*
* Return: A pointer to the 'mux_control_ops' of the device.
*/
static inline const struct mux_control_ops *mux_dev_ops(struct udevice *dev)
{
return (const struct mux_control_ops *)dev->driver->ops;
}
/**
* mux_control_set() - Set the state of the given mux controller.
* @mux: A multiplexer control
* @state: The new requested state.
*
* Return: 0 if OK, or a negative error code.
*/
static int mux_control_set(struct mux_control *mux, int state)
{
int ret = mux_dev_ops(mux->dev)->set(mux, state);
mux->cached_state = ret < 0 ? MUX_CACHE_UNKNOWN : state;
return ret;
}
unsigned int mux_control_states(struct mux_control *mux)
{
return mux->states;
}
/**
* __mux_control_select() - Select the given multiplexer state.
* @mux: The mux-control to request a change of state from.
* @state: The new requested state.
*
* Try to set the mux to the requested state. If not, try to revert if
* appropriate.
*/
static int __mux_control_select(struct mux_control *mux, int state)
{
int ret;
if (WARN_ON(state < 0 || state >= mux->states))
return -EINVAL;
if (mux->cached_state == state)
return 0;
ret = mux_control_set(mux, state);
if (ret >= 0)
return 0;
/* The mux update failed, try to revert if appropriate... */
if (mux->idle_state != MUX_IDLE_AS_IS)
mux_control_set(mux, mux->idle_state);
return ret;
}
int mux_control_select(struct mux_control *mux, unsigned int state)
{
int ret;
if (mux->in_use)
return -EBUSY;
ret = __mux_control_select(mux, state);
if (ret < 0)
return ret;
mux->in_use = true;
return 0;
}
int mux_control_deselect(struct mux_control *mux)
{
int ret = 0;
if (mux->idle_state != MUX_IDLE_AS_IS &&
mux->idle_state != mux->cached_state)
ret = mux_control_set(mux, mux->idle_state);
mux->in_use = false;
return ret;
}
static int mux_of_xlate_default(struct mux_chip *mux_chip,
struct ofnode_phandle_args *args,
struct mux_control **muxp)
{
struct mux_control *mux;
int id;
log_debug("%s(muxp=%p)\n", __func__, muxp);
if (args->args_count > 1) {
debug("Invaild args_count: %d\n", args->args_count);
return -EINVAL;
}
if (args->args_count)
id = args->args[0];
else
id = 0;
if (id >= mux_chip->controllers) {
pr_err("bad mux controller %u specified in %s\n",
id, ofnode_get_name(args->node));
return -ERANGE;
}
mux = &mux_chip->mux[id];
mux->id = id;
*muxp = mux;
return 0;
}
/**
* mux_get_by_indexed_prop() - Get a mux control by integer index
* @dev: The client device.
* @prop_name: Name of the device tree property.
* @index: The index of the mux to get
* @mux: A pointer to the 'mux_control' struct to initialize.
*
* Return: 0 of OK, -errno otherwise.
*/
static int mux_get_by_indexed_prop(struct udevice *dev, const char *prop_name,
int index, struct mux_control **mux)
{
int ret;
struct ofnode_phandle_args args;
struct udevice *dev_mux;
const struct mux_control_ops *ops;
struct mux_chip *mux_chip;
log_debug("%s(dev=%p, index=%d, mux=%p)\n", __func__, dev, index, mux);
ret = dev_read_phandle_with_args(dev, prop_name, "#mux-control-cells",
0, index, &args);
if (ret) {
debug("%s: fdtdec_parse_phandle_with_args failed: err=%d\n",
__func__, ret);
return ret;
}
ret = uclass_get_device_by_ofnode(UCLASS_MUX, args.node, &dev_mux);
if (ret) {
debug("%s: uclass_get_device_by_ofnode failed: err=%d\n",
__func__, ret);
return ret;
}
mux_chip = dev_get_uclass_priv(dev_mux);
ops = mux_dev_ops(dev_mux);
if (ops->of_xlate)
ret = ops->of_xlate(mux_chip, &args, mux);
else
ret = mux_of_xlate_default(mux_chip, &args, mux);
if (ret) {
debug("of_xlate() failed: %d\n", ret);
return ret;
}
(*mux)->dev = dev_mux;
return 0;
}
int mux_get_by_index(struct udevice *dev, int index, struct mux_control **mux)
{
return mux_get_by_indexed_prop(dev, "mux-controls", index, mux);
}
int mux_control_get(struct udevice *dev, const char *name,
struct mux_control **mux)
{
int index;
debug("%s(dev=%p, name=%s, mux=%p)\n", __func__, dev, name, mux);
index = dev_read_stringlist_search(dev, "mux-control-names", name);
if (index < 0) {
debug("fdt_stringlist_search() failed: %d\n", index);
return index;
}
return mux_get_by_index(dev, index, mux);
}
void mux_control_put(struct mux_control *mux)
{
mux_control_deselect(mux);
}
/**
* devm_mux_control_release() - Release the given managed mux.
* @dev: The client device.
* @res: Pointer to the mux to be released.
*
* This function is called by devres to release the mux. It reverses the
* effects of mux_control_get().
*/
static void devm_mux_control_release(struct udevice *dev, void *res)
{
mux_control_put(*(struct mux_control **)res);
}
struct mux_control *devm_mux_control_get(struct udevice *dev, const char *id)
{
int rc;
struct mux_control **mux;
mux = devres_alloc(devm_mux_control_release,
sizeof(struct mux_control *), __GFP_ZERO);
if (unlikely(!mux))
return ERR_PTR(-ENOMEM);
rc = mux_control_get(dev, id, mux);
if (rc)
return ERR_PTR(rc);
devres_add(dev, mux);
return *mux;
}
int mux_alloc_controllers(struct udevice *dev, unsigned int controllers)
{
int i;
struct mux_chip *mux_chip = dev_get_uclass_priv(dev);
mux_chip->mux = devm_kmalloc(dev,
sizeof(struct mux_control) * controllers,
__GFP_ZERO);
if (!mux_chip->mux)
return -ENOMEM;
mux_chip->controllers = controllers;
for (i = 0; i < mux_chip->controllers; ++i) {
struct mux_control *mux = &mux_chip->mux[i];
mux->dev = dev;
mux->cached_state = MUX_CACHE_UNKNOWN;
mux->idle_state = MUX_IDLE_AS_IS;
mux->in_use = false;
mux->id = i;
}
return 0;
}
static int mux_uclass_post_probe(struct udevice *dev)
{
int i, ret;
struct mux_chip *mux_chip = dev_get_uclass_priv(dev);
/* Set all mux controllers to their idle state. */
for (i = 0; i < mux_chip->controllers; ++i) {
struct mux_control *mux = &mux_chip->mux[i];
if (mux->idle_state == mux->cached_state)
continue;
ret = mux_control_set(mux, mux->idle_state);
if (ret < 0) {
dev_err(dev, "unable to set idle state\n");
return ret;
}
}
return 0;
}
int dm_mux_init(void)
{
struct uclass *uc;
struct udevice *dev;
int ret;
ret = uclass_get(UCLASS_MUX, &uc);
if (ret < 0) {
log_debug("unable to get MUX uclass\n");
return ret;
}
uclass_foreach_dev(dev, uc) {
if (dev_read_bool(dev, "u-boot,mux-autoprobe")) {
ret = device_probe(dev);
if (ret)
log_debug("unable to probe device %s\n",
dev->name);
}
}
return 0;
}
UCLASS_DRIVER(mux) = {
.id = UCLASS_MUX,
.name = "mux",
.post_probe = mux_uclass_post_probe,
.per_device_auto_alloc_size = sizeof(struct mux_chip),
};

1
include/dm/uclass-id.h
View File

@ -71,6 +71,7 @@ enum uclass_id {
UCLASS_MMC, /* SD / MMC card or chip */
UCLASS_MOD_EXP, /* RSA Mod Exp device */
UCLASS_MTD, /* Memory Technology Device (MTD) device */
UCLASS_MUX, /* Multiplexer device */
UCLASS_NOP, /* No-op devices */
UCLASS_NORTHBRIDGE, /* Intel Northbridge / SDRAM controller */
UCLASS_NVME, /* NVM Express device */

17
include/dt-bindings/mux/mux.h Normal file
View File

@ -0,0 +1,17 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* This header provides constants for most Multiplexer bindings.
*
* Most Multiplexer bindings specify an idle state. In most cases, the
* the multiplexer can be left as is when idle, and in some cases it can
* disconnect the input/output and leave the multiplexer in a high
* impedance state.
*/
#ifndef _DT_BINDINGS_MUX_MUX_H
#define _DT_BINDINGS_MUX_MUX_H
#define MUX_IDLE_AS_IS (-1)
#define MUX_IDLE_DISCONNECT (-2)
#endif

109
include/mux-internal.h Normal file
View File

@ -0,0 +1,109 @@
/* SPDX-License-Identifier: GPL-2.0+ */
/*
* Based on the linux multiplexer framework
*
* Copyright (C) 2017 Axentia Technologies AB
* Author: Peter Rosin <peda@axentia.se>
*
* Copyright (C) 2017-2018 Texas Instruments Incorporated - http://www.ti.com/
* Jean-Jacques Hiblot <jjhiblot@ti.com>
*/
#ifndef _MUX_INTERNAL_H
#define _MUX_INTERNAL_H
/* See mux.h for background documentation. */
struct ofnode_phandle_args;
/**
* struct mux_chip - Represents a chip holding mux controllers.
* @controllers: Number of mux controllers handled by the chip.
* @mux: Array of mux controllers that are handled.
*
* This a per-device uclass-private data.
*/
struct mux_chip {
unsigned int controllers;
struct mux_control *mux;
};
/**
* struct mux_control_ops - Mux controller operations for a mux chip.
* @set: Set the state of the given mux controller.
*/
struct mux_control_ops {
/**
* set - Apply a state to a multiplexer control
*
* @mux: A multiplexer control
* @return 0 if OK, or a negative error code.
*/
int (*set)(struct mux_control *mux, int state);
/**
* of_xlate - Translate a client's device-tree (OF) multiplexer
* specifier.
*
* If this function pointer is set to NULL, the multiplexer core will
* use a default implementation, which assumes #mux-control-cells = <1>
* and that the DT cell contains a simple integer channel ID.
*
* @dev_mux: The multiplexer device. A single device may handle
* several multiplexer controls.
* @args: The multiplexer specifier values from device tree.
* @muxp: (out) A multiplexer control
* @return 0 if OK, or a negative error code.
*/
int (*of_xlate)(struct mux_chip *dev_mux,
struct ofnode_phandle_args *args,
struct mux_control **muxp);
};
/**
* struct mux_control - Represents a mux controller.
* @in_use: Whether the mux controller is in use or not.
* @dev: The client device.
* @cached_state: The current mux controller state, or -1 if none.
* @states: The number of mux controller states.
* @idle_state: The mux controller state to use when inactive, or one
* of MUX_IDLE_AS_IS and MUX_IDLE_DISCONNECT.
* @id: The index of the mux controller within the mux chip
* it is a part of.
*
* Mux drivers may only change @states and @idle_state, and may only do so
* between allocation and registration of the mux controller. Specifically,
* @cached_state is internal to the mux core and should never be written by
* mux drivers.
*/
struct mux_control {
bool in_use;
struct udevice *dev;
int cached_state;
unsigned int states;
int idle_state;
int id;
};
/**
* mux_control_get_index() - Get the index of the given mux controller
* @mux: The mux-control to get the index for.
*
* Return: The index of the mux controller within the mux chip the mux
* controller is a part of.
*/
static inline unsigned int mux_control_get_index(struct mux_control *mux)
{
return mux->id;
}
/**
* mux_alloc_controllers() - Allocate the given number of mux controllers.
* @dev: The client device.
* controllers: Number of controllers to allocate.
*
* Return: 0 of OK, -errno otherwise.
*/
int mux_alloc_controllers(struct udevice *dev, unsigned int controllers);
#endif

159
include/mux.h Normal file
View File

@ -0,0 +1,159 @@
/* SPDX-License-Identifier: GPL-2.0+ */
/*
* Based on the linux multiplexer framework
*
* At its core, a multiplexer (or mux), also known as a data selector, is a
* device that selects between several analog or digital input signals and
* forwards it to a single output line. This notion can be extended to work
* with buses, like a I2C bus multiplexer for example.
*
* Copyright (C) 2017 Axentia Technologies AB
* Author: Peter Rosin <peda@axentia.se>
*
* Copyright (C) 2017-2018 Texas Instruments Incorporated - http://www.ti.com/
* Jean-Jacques Hiblot <jjhiblot@ti.com>
*/
#ifndef _MUX_H_
#define _MUX_H_
#include <linux/errno.h>
#include <linux/types.h>
struct udevice;
struct mux_control;
#if CONFIG_IS_ENABLED(MULTIPLEXER)
/**
* mux_control_states() - Query the number of multiplexer states.
* @mux: The mux-control to query.
*
* Return: The number of multiplexer states.
*/
unsigned int mux_control_states(struct mux_control *mux);
/**
* mux_control_select() - Select the given multiplexer state.
* @mux: The mux-control to request a change of state from.
* @state: The new requested state.
*
* On successfully selecting the mux-control state, it will be locked until
* there is a call to mux_control_deselect(). If the mux-control is already
* selected when mux_control_select() is called, the function will indicate
* -EBUSY
*
* Therefore, make sure to call mux_control_deselect() when the operation is
* complete and the mux-control is free for others to use, but do not call
* mux_control_deselect() if mux_control_select() fails.
*
* Return: 0 when the mux-control state has the requested state or a negative
* errno on error.
*/
int __must_check mux_control_select(struct mux_control *mux,
unsigned int state);
#define mux_control_try_select(mux) mux_control_select(mux)
/**
* mux_control_deselect() - Deselect the previously selected multiplexer state.
* @mux: The mux-control to deselect.
*
* It is required that a single call is made to mux_control_deselect() for
* each and every successful call made to either of mux_control_select() or
* mux_control_try_select().
*
* Return: 0 on success and a negative errno on error. An error can only
* occur if the mux has an idle state. Note that even if an error occurs, the
* mux-control is unlocked and is thus free for the next access.
*/
int mux_control_deselect(struct mux_control *mux);
/**
* mux_get_by_index() = Get a mux by integer index.
* @dev: The client device.
* @index: The index of the mux to get.
* @mux: A pointer to the 'mux_control' struct to initialize.
*
* This looks up and initializes a mux. The index is relative to the client
* device.
*
* Return: 0 if OK, or a negative error code.
*/
int mux_get_by_index(struct udevice *dev, int index, struct mux_control **mux);
/**
* mux_control_get() - Get the mux-control for a device.
* @dev: The device that needs a mux-control.
* @mux_name: The name identifying the mux-control.
* @mux: A pointer to the mux-control pointer.
*
* Return: 0 of OK, or a negative error code.
*/
int mux_control_get(struct udevice *dev, const char *name,
struct mux_control **mux);
/**
* mux_control_put() - Put away the mux-control for good.
* @mux: The mux-control to put away.
*
* mux_control_put() reverses the effects of mux_control_get().
*/
void mux_control_put(struct mux_control *mux);
/**
* devm_mux_control_get() - Get the mux-control for a device, with resource
* management.
* @dev: The device that needs a mux-control.
* @mux_name: The name identifying the mux-control.
*
* Return: Pointer to the mux-control, or an ERR_PTR with a negative errno.
*/
struct mux_control *devm_mux_control_get(struct udevice *dev,
const char *mux_name);
/**
* dm_mux_init() - Initialize the multiplexer controls to their default state.
*
* Return: 0 if OK, -errno otherwise.
*/
int dm_mux_init(void);
#else
unsigned int mux_control_states(struct mux_control *mux)
{
return -ENOSYS;
}
int __must_check mux_control_select(struct mux_control *mux,
unsigned int state)
{
return -ENOSYS;
}
#define mux_control_try_select(mux) mux_control_select(mux)
int mux_control_deselect(struct mux_control *mux)
{
return -ENOSYS;
}
struct mux_control *mux_control_get(struct udevice *dev, const char *mux_name)
{
return NULL;
}
void mux_control_put(struct mux_control *mux)
{
}
struct mux_control *devm_mux_control_get(struct udevice *dev,
const char *mux_name)
{
return NULL;
}
int dm_mux_init(void)
{
return -ENOSYS;
}
#endif
#endif

3
test/dm/Makefile
View File

@ -34,6 +34,7 @@ obj-y += irq.o
obj-$(CONFIG_LED) += led.o
obj-$(CONFIG_DM_MAILBOX) += mailbox.o
obj-$(CONFIG_DM_MMC) += mmc.o
obj-$(CONFIG_CMD_MUX) += mux-cmd.o
obj-y += fdtdec.o
obj-y += ofnode.o
obj-y += ofread.o
@ -57,6 +58,8 @@ obj-$(CONFIG_DM_SPI_FLASH) += sf.o
obj-$(CONFIG_SMEM) += smem.o
obj-$(CONFIG_DM_SPI) += spi.o
obj-y += syscon.o
obj-$(CONFIG_MUX_MMIO) += mux-mmio.o
obj-$(CONFIG_MULTIPLEXER) += mux-emul.o
obj-$(CONFIG_DM_USB) += usb.o
obj-$(CONFIG_DM_PMIC) += pmic.o
obj-$(CONFIG_DM_REGULATOR) += regulator.o

177
test/dm/mux-cmd.c Normal file
View File

@ -0,0 +1,177 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2020 Texas Instruments Inc.
* Pratyush Yadav <p.yadav@ti.com>
*/
#include <common.h>
#include <dm.h>
#include <mux.h>
#include <mux-internal.h>
#include <dt-bindings/mux/mux.h>
#include <asm/test.h>
#include <dm/test.h>
#include <test/ut.h>
#include <console.h>
#include <rand.h>
#define BUF_SIZE 256
/* Test 'mux list' */
static int dm_test_cmd_mux_list(struct unit_test_state *uts)
{
char str[BUF_SIZE], *tok;
struct udevice *dev;
struct mux_chip *chip;
struct mux_control *mux;
int i;
unsigned long val;
sandbox_set_enable_memio(true);
ut_assertok(uclass_get_device_by_name(UCLASS_MUX, "a-mux-controller",
&dev));
chip = dev_get_uclass_priv(dev);
ut_assertnonnull(chip);
run_command("mux list", 0);
ut_assert_nextline("a-mux-controller:");
/*
* Check the table header to make sure we are not out of sync with the
* code in the command. If we are, catch it early.
*/
console_record_readline(str, BUF_SIZE);
tok = strtok(str, " ");
ut_asserteq_str("ID", tok);
tok = strtok(NULL, " ");
ut_asserteq_str("Selected", tok);
tok = strtok(NULL, " ");
ut_asserteq_str("Current", tok);
tok = strtok(NULL, " ");
ut_asserteq_str("State", tok);
tok = strtok(NULL, " ");
ut_asserteq_str("Idle", tok);
tok = strtok(NULL, " ");
ut_asserteq_str("State", tok);
tok = strtok(NULL, " ");
ut_asserteq_str("Num", tok);
tok = strtok(NULL, " ");
ut_asserteq_str("States", tok);
for (i = 0; i < chip->controllers; i++) {
mux = &chip->mux[i];
console_record_readline(str, BUF_SIZE);
/*
* Check if the ID printed matches with the ID of the chip we
* have.
*/
tok = strtok(str, " ");
ut_assertok(strict_strtoul(tok, 10, &val));
ut_asserteq(i, val);
/* Check if mux selection state matches. */
tok = strtok(NULL, " ");
if (mux->in_use) {
ut_asserteq_str("yes", tok);
} else {
ut_asserteq_str("no", tok);
}
/* Check if the current state matches. */
tok = strtok(NULL, " ");
if (mux->cached_state == MUX_IDLE_AS_IS) {
ut_asserteq_str("unknown", tok);
} else {
ut_assertok(strict_strtoul(tok, 16, &val));
ut_asserteq(mux->cached_state, val);
}
/* Check if the idle state matches */
tok = strtok(NULL, " ");
if (mux->idle_state == MUX_IDLE_AS_IS) {
ut_asserteq_str("as-is", tok);
} else {
ut_assertok(strict_strtoul(tok, 16, &val));
ut_asserteq(mux->idle_state, val);
}
/* Check if the number of states matches */
tok = strtok(NULL, " ");
ut_assertok(strict_strtoul(tok, 16, &val));
ut_asserteq(mux->states, val);
}
return 0;
}
DM_TEST(dm_test_cmd_mux_list, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_cmd_mux_select(struct unit_test_state *uts)
{
struct udevice *dev;
struct mux_chip *chip;
struct mux_control *mux;
char cmd[BUF_SIZE];
unsigned int i, state;
sandbox_set_enable_memio(true);
ut_assertok(uclass_get_device_by_name(UCLASS_MUX, "a-mux-controller",
&dev));
chip = dev_get_uclass_priv(dev);
ut_assertnonnull(chip);
srand(get_ticks() + rand());
for (i = 0; i < chip->controllers; i++) {
mux = &chip->mux[i];
state = rand() % mux->states;
snprintf(cmd, BUF_SIZE, "mux select a-mux-controller %x %x", i,
state);
run_command(cmd, 0);
ut_asserteq(!!mux->in_use, true);
ut_asserteq(state, mux->cached_state);
ut_assertok(mux_control_deselect(mux));
}
return 0;
}
DM_TEST(dm_test_cmd_mux_select, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_cmd_mux_deselect(struct unit_test_state *uts)
{
struct udevice *dev;
struct mux_chip *chip;
struct mux_control *mux;
char cmd[BUF_SIZE];
unsigned int i, state;
sandbox_set_enable_memio(true);
ut_assertok(uclass_get_device_by_name(UCLASS_MUX, "a-mux-controller",
&dev));
chip = dev_get_uclass_priv(dev);
ut_assertnonnull(chip);
srand(get_ticks() + rand());
for (i = 0; i < chip->controllers; i++) {
mux = &chip->mux[i];
state = rand() % mux->states;
ut_assertok(mux_control_select(mux, state));
snprintf(cmd, BUF_SIZE, "mux deselect a-mux-controller %d", i);
run_command(cmd, 0);
ut_asserteq(!!mux->in_use, false);
}
return 0;
}
DM_TEST(dm_test_cmd_mux_deselect, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

105
test/dm/mux-emul.c Normal file
View File

@ -0,0 +1,105 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (C) 2020 Texas Instruments Incorporated - http://www.ti.com/
* Pratyush Yadav <p.yadav@ti.com>
*/
#include <common.h>
#include <dm.h>
#include <mux.h>
#include <mux-internal.h>
#include <dm/test.h>
#include <test/ut.h>
struct mux_emul_priv {
u32 state;
};
static int mux_emul_set(struct mux_control *mux, int state)
{
struct mux_emul_priv *priv = dev_get_priv(mux->dev);
priv->state = state;
return 0;
}
static int mux_emul_probe(struct udevice *dev)
{
struct mux_chip *mux_chip = dev_get_uclass_priv(dev);
struct mux_control *mux;
u32 idle_state;
int ret;
ret = mux_alloc_controllers(dev, 1);
if (ret < 0)
return ret;
mux = &mux_chip->mux[0];
ret = dev_read_u32(dev, "idle-state", &idle_state);
if (ret)
return ret;
mux->idle_state = idle_state;
mux->states = 0x100000;
return 0;
}
static const struct mux_control_ops mux_emul_ops = {
.set = mux_emul_set,
};
static const struct udevice_id mux_emul_of_match[] = {
{ .compatible = "mux-emul" },
{ /* sentinel */ },
};
U_BOOT_DRIVER(emul_mux) = {
.name = "mux-emul",
.id = UCLASS_MUX,
.of_match = mux_emul_of_match,
.ops = &mux_emul_ops,
.probe = mux_emul_probe,
.priv_auto_alloc_size = sizeof(struct mux_emul_priv),
};
static int dm_test_mux_emul_default_state(struct unit_test_state *uts)
{
struct udevice *dev;
struct mux_control *mux;
struct mux_emul_priv *priv;
ut_assertok(uclass_get_device_by_name(UCLASS_TEST_FDT, "a-test",
&dev));
ut_assertok(mux_control_get(dev, "mux4", &mux));
priv = dev_get_priv(mux->dev);
ut_asserteq(0xabcd, priv->state);
return 0;
}
DM_TEST(dm_test_mux_emul_default_state, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_mux_emul_select_deselect(struct unit_test_state *uts)
{
struct udevice *dev;
struct mux_control *mux;
struct mux_emul_priv *priv;
gd->flags &= ~(GD_FLG_SILENT | GD_FLG_RECORD);
ut_assertok(uclass_get_device_by_name(UCLASS_TEST_FDT, "a-test",
&dev));
ut_assertok(mux_control_get(dev, "mux4", &mux));
priv = dev_get_priv(mux->dev);
ut_assertok(mux_control_select(mux, 0x1234));
ut_asserteq(priv->state, 0x1234);
ut_assertok(mux_control_deselect(mux));
ut_asserteq(priv->state, 0xabcd);
return 0;
}
DM_TEST(dm_test_mux_emul_select_deselect, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

138
test/dm/mux-mmio.c Normal file
View File

@ -0,0 +1,138 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (C) 2017-2018 Texas Instruments Incorporated - http://www.ti.com/
* Jean-Jacques Hiblot <jjhiblot@ti.com>
*/
#include <common.h>
#include <dm.h>
#include <mux.h>
#include <regmap.h>
#include <syscon.h>
#include <asm/test.h>
#include <dm/test.h>
#include <dm/device-internal.h>
#include <test/ut.h>
static int dm_test_mux_mmio_select(struct unit_test_state *uts)
{
struct udevice *dev, *dev_b;
struct regmap *map;
struct mux_control *ctl0_a, *ctl0_b;
struct mux_control *ctl1;
struct mux_control *ctl_err;
u32 val;
int i;
sandbox_set_enable_memio(true);
ut_assertok(uclass_get_device_by_name(UCLASS_TEST_FDT, "a-test",
&dev));
ut_assertok(uclass_get_device_by_name(UCLASS_TEST_FDT, "b-test",
&dev_b));
map = syscon_regmap_lookup_by_phandle(dev, "mux-syscon");
ut_assertok_ptr(map);
ut_assert(map);
ut_assertok(mux_control_get(dev, "mux0", &ctl0_a));
ut_assertok(mux_control_get(dev, "mux1", &ctl1));
ut_asserteq(-ERANGE, mux_control_get(dev, "mux3", &ctl_err));
ut_asserteq(-ENODATA, mux_control_get(dev, "dummy", &ctl_err));
ut_assertok(mux_control_get(dev_b, "mux0", &ctl0_b));
for (i = 0; i < mux_control_states(ctl0_a); i++) {
/* Select a new state and verify the value in the regmap. */
ut_assertok(mux_control_select(ctl0_a, i));
ut_assertok(regmap_read(map, 0, &val));
ut_asserteq(i, (val & 0x30) >> 4);
/*
* Deselect the mux and verify that the value in the regmap
* reflects the idle state (fixed to MUX_IDLE_AS_IS).
*/
ut_assertok(mux_control_deselect(ctl0_a));
ut_assertok(regmap_read(map, 0, &val));
ut_asserteq(i, (val & 0x30) >> 4);
}
for (i = 0; i < mux_control_states(ctl1); i++) {
/* Select a new state and verify the value in the regmap. */
ut_assertok(mux_control_select(ctl1, i));
ut_assertok(regmap_read(map, 0xc, &val));
ut_asserteq(i, (val & 0x1E) >> 1);
/*
* Deselect the mux and verify that the value in the regmap
* reflects the idle state (fixed to 2).
*/
ut_assertok(mux_control_deselect(ctl1));
ut_assertok(regmap_read(map, 0xc, &val));
ut_asserteq(2, (val & 0x1E) >> 1);
}
/* Try unbalanced selection/deselection. */
ut_assertok(mux_control_select(ctl0_a, 0));
ut_asserteq(-EBUSY, mux_control_select(ctl0_a, 1));
ut_asserteq(-EBUSY, mux_control_select(ctl0_a, 0));
ut_assertok(mux_control_deselect(ctl0_a));
/* Try concurrent selection. */
ut_assertok(mux_control_select(ctl0_a, 0));
ut_assert(mux_control_select(ctl0_b, 0));
ut_assertok(mux_control_deselect(ctl0_a));
ut_assertok(mux_control_select(ctl0_b, 0));
ut_assert(mux_control_select(ctl0_a, 0));
ut_assertok(mux_control_deselect(ctl0_b));
ut_assertok(mux_control_select(ctl0_a, 0));
ut_assertok(mux_control_deselect(ctl0_a));
return 0;
}
DM_TEST(dm_test_mux_mmio_select, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that managed API for mux work correctly */
static int dm_test_devm_mux_mmio(struct unit_test_state *uts)
{
struct udevice *dev, *dev_b;
struct mux_control *ctl0_a, *ctl0_b;
struct mux_control *ctl1;
struct mux_control *ctl_err;
sandbox_set_enable_memio(true);
ut_assertok(uclass_get_device_by_name(UCLASS_TEST_FDT, "a-test",
&dev));
ut_assertok(uclass_get_device_by_name(UCLASS_TEST_FDT, "b-test",
&dev_b));
ctl0_a = devm_mux_control_get(dev, "mux0");
ut_assertok_ptr(ctl0_a);
ut_assert(ctl0_a);
ctl1 = devm_mux_control_get(dev, "mux1");
ut_assertok_ptr(ctl1);
ut_assert(ctl1);
ctl_err = devm_mux_control_get(dev, "mux3");
ut_asserteq(-ERANGE, PTR_ERR(ctl_err));
ctl_err = devm_mux_control_get(dev, "dummy");
ut_asserteq(-ENODATA, PTR_ERR(ctl_err));
ctl0_b = devm_mux_control_get(dev_b, "mux0");
ut_assertok_ptr(ctl0_b);
ut_assert(ctl0_b);
/* Try concurrent selection. */
ut_assertok(mux_control_select(ctl0_a, 0));
ut_assert(mux_control_select(ctl0_b, 0));
ut_assertok(mux_control_deselect(ctl0_a));
ut_assertok(mux_control_select(ctl0_b, 0));
ut_assert(mux_control_select(ctl0_a, 0));
ut_assertok(mux_control_deselect(ctl0_b));
/* Remove one device and check that the mux is released. */
ut_assertok(mux_control_select(ctl0_a, 0));
ut_assert(mux_control_select(ctl0_b, 0));
device_remove(dev, DM_REMOVE_NORMAL);
ut_assertok(mux_control_select(ctl0_b, 0));
device_remove(dev_b, DM_REMOVE_NORMAL);
return 0;
}
DM_TEST(dm_test_devm_mux_mmio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);