#include <linux/i3c/device.h>
#include <linux/i3c/hub.h>
#include <linux/lockdep.h>
#include "internals.h"
struct i3c_hub_dev_data {
struct i3c_dev_desc parent_desc;
};
#define I3C_HUB_MAX_LOCK_DEPTH 8
static struct lock_class_key i3c_hub_bus_lock_keys[I3C_HUB_MAX_LOCK_DEPTH];
static struct lock_class_key i3c_hub_routing_lock_keys[I3C_HUB_MAX_LOCK_DEPTH];
static unsigned int
i3c_hub_controller_depth(struct i3c_master_controller *controller)
{
struct i3c_hub_controller *hub_controller;
unsigned int depth = 0;
while (controller && controller->ops == &i3c_hub_master_ops) {
hub_controller = dev_get_drvdata(&controller->dev);
if (!hub_controller)
break;
controller = hub_controller->parent;
depth++;
}
return depth;
}
static int i3c_hub_master_bus_init(struct i3c_master_controller *controller)
{
struct i3c_hub_controller *hub_controller;
struct i3c_hub *hub;
unsigned int depth;
hub_controller = dev_get_drvdata(&controller->dev);
if (!hub_controller || !hub_controller->hub)
return -ENODEV;
hub = hub_controller->hub;
if (!hub->hub_dev)
return -ENODEV;
depth = i3c_hub_controller_depth(controller);
if (depth >= 1 && depth <= I3C_HUB_MAX_LOCK_DEPTH)
lockdep_set_class(&controller->bus.lock,
&i3c_hub_bus_lock_keys[depth - 1]);
else
WARN_ONCE(1, "i3c-hub: nesting depth %u exceeds lockdep support\n",
depth);
controller->this = hub->hub_dev->desc;
return 0;
}
static void i3c_hub_master_bus_cleanup(struct i3c_master_controller *controller)
{
controller->this = NULL;
}
static int i3c_hub_attach_i3c_dev(struct i3c_dev_desc *dev)
{
struct i3c_master_controller *controller = i3c_dev_get_master(dev);
struct i3c_hub_controller *hub_controller;
struct i3c_hub_dev_data *data;
struct i3c_master_controller *parent;
struct i3c_hub *hub;
int ret;
hub_controller = dev_get_drvdata(&controller->dev);
if (!hub_controller || !hub_controller->hub)
return -ENODEV;
hub = hub_controller->hub;
if (!hub->hub_dev)
return -ENODEV;
parent = i3c_dev_get_master(hub->hub_dev->desc);
if (!parent)
return -ENODEV;
data = kzalloc_obj(*data);
if (!data)
return -ENOMEM;
INIT_LIST_HEAD(&data->parent_desc.common.node);
mutex_init(&data->parent_desc.ibi_lock);
data->parent_desc.common.master = parent;
data->parent_desc.info = dev->info;
i3c_bus_maintenance_lock(&parent->bus);
ret = i3c_master_attach_i3c_dev_controller_locked(&data->parent_desc);
i3c_bus_maintenance_unlock(&parent->bus);
if (ret) {
mutex_destroy(&data->parent_desc.ibi_lock);
kfree(data);
return ret;
}
i3c_dev_set_master_data(dev, data);
return 0;
}
static int i3c_hub_reattach_i3c_dev(struct i3c_dev_desc *dev,
u8 old_dyn_addr)
{
struct i3c_hub_dev_data *data = i3c_dev_get_master_data(dev);
struct i3c_master_controller *parent;
int ret;
if (!data)
return -ENODEV;
parent = i3c_dev_get_master(&data->parent_desc);
if (!parent)
return -ENODEV;
if (WARN_ON_ONCE(data->parent_desc.ibi))
return -EBUSY;
i3c_bus_maintenance_lock(&parent->bus);
data->parent_desc.info = dev->info;
ret = i3c_master_reattach_i3c_dev_controller_locked(&data->parent_desc,
old_dyn_addr);
i3c_bus_maintenance_unlock(&parent->bus);
return ret;
}
static void i3c_hub_detach_i3c_dev(struct i3c_dev_desc *dev)
{
struct i3c_hub_dev_data *data = i3c_dev_get_master_data(dev);
struct i3c_master_controller *parent;
if (!data)
return;
parent = i3c_dev_get_master(&data->parent_desc);
WARN_ON_ONCE(data->parent_desc.ibi);
if (parent) {
i3c_bus_maintenance_lock(&parent->bus);
i3c_master_detach_i3c_dev_controller_locked(&data->parent_desc);
i3c_bus_maintenance_unlock(&parent->bus);
}
i3c_dev_set_master_data(dev, NULL);
mutex_destroy(&data->parent_desc.ibi_lock);
kfree(data);
}
static int i3c_hub_do_daa(struct i3c_hub *hub,
struct i3c_master_controller *controller)
{
struct i3c_master_controller *parent;
int ret;
if (!hub || !hub->hub_dev)
return -ENODEV;
parent = i3c_dev_get_master(hub->hub_dev->desc);
if (!parent)
return -ENODEV;
mutex_lock(&hub->lock);
i3c_hub_enable_port(controller);
ret = i3c_master_do_daa(parent);
i3c_hub_disable_port(controller);
mutex_unlock(&hub->lock);
return ret;
}
static bool i3c_hub_supports_ccc_cmd(struct i3c_hub *hub,
const struct i3c_ccc_cmd *cmd)
{
struct i3c_master_controller *parent;
if (!hub || !hub->hub_dev)
return false;
parent = i3c_dev_get_master(hub->hub_dev->desc);
if (!parent)
return false;
return i3c_master_supports_ccc_cmd(parent, cmd);
}
static int i3c_hub_send_ccc_cmd(struct i3c_hub *hub,
struct i3c_master_controller *controller,
struct i3c_ccc_cmd *cmd)
{
struct i3c_master_controller *parent;
int ret;
if (!hub || !hub->hub_dev)
return -ENODEV;
parent = i3c_dev_get_master(hub->hub_dev->desc);
if (!parent)
return -ENODEV;
mutex_lock(&hub->lock);
i3c_hub_enable_port(controller);
ret = i3c_master_send_ccc_cmd(parent, cmd);
i3c_hub_disable_port(controller);
mutex_unlock(&hub->lock);
return ret;
}
static int i3c_hub_master_priv_xfers(struct i3c_dev_desc *dev,
struct i3c_xfer *xfers,
int nxfers,
enum i3c_xfer_mode mode)
{
struct i3c_master_controller *controller = i3c_dev_get_master(dev);
struct i3c_hub_controller *hub_controller;
struct i3c_master_controller *parent;
struct i3c_hub_dev_data *data;
struct i3c_hub *hub;
int ret;
hub_controller = dev_get_drvdata(&controller->dev);
if (!hub_controller || !hub_controller->hub)
return -ENODEV;
hub = hub_controller->hub;
data = i3c_dev_get_master_data(dev);
if (!data)
return -ENODEV;
parent = i3c_dev_get_master(&data->parent_desc);
if (!parent)
return -ENODEV;
mutex_lock(&hub->lock);
if (!data->parent_desc.ibi)
data->parent_desc.info = dev->info;
i3c_hub_enable_port(controller);
i3c_bus_normaluse_lock(&parent->bus);
ret = i3c_dev_do_xfers_locked(&data->parent_desc, xfers,
nxfers, mode);
i3c_bus_normaluse_unlock(&parent->bus);
i3c_hub_disable_port(controller);
mutex_unlock(&hub->lock);
return ret;
}
static int i3c_hub_attach_i2c_dev(struct i2c_dev_desc *dev)
{
return -EOPNOTSUPP;
}
static void i3c_hub_detach_i2c_dev(struct i2c_dev_desc *dev)
{
}
static int i3c_hub_i2c_xfers(struct i2c_dev_desc *dev,
struct i2c_msg *xfers, int nxfers)
{
return -EOPNOTSUPP;
}
static int i3c_hub_master_do_daa(struct i3c_master_controller *controller)
{
struct i3c_hub_controller *hub_controller;
struct i3c_hub *hub;
hub_controller = dev_get_drvdata(&controller->dev);
if (!hub_controller || !hub_controller->hub)
return -ENODEV;
hub = hub_controller->hub;
return i3c_hub_do_daa(hub, controller);
}
static int i3c_hub_master_send_ccc_cmd(struct i3c_master_controller *controller,
struct i3c_ccc_cmd *cmd)
{
struct i3c_hub_controller *hub_controller;
struct i3c_hub *hub;
hub_controller = dev_get_drvdata(&controller->dev);
if (!hub_controller || !hub_controller->hub)
return -ENODEV;
hub = hub_controller->hub;
if (!hub->hub_dev)
return -ENODEV;
if (cmd->id == I3C_CCC_RSTDAA(true))
return 0;
return i3c_hub_send_ccc_cmd(hub, controller, cmd);
}
static bool i3c_hub_master_supports_ccc_cmd(struct i3c_master_controller *controller,
const struct i3c_ccc_cmd *cmd)
{
struct i3c_hub_controller *hub_controller;
struct i3c_hub *hub;
hub_controller = dev_get_drvdata(&controller->dev);
if (!hub_controller || !hub_controller->hub)
return false;
hub = hub_controller->hub;
return i3c_hub_supports_ccc_cmd(hub, cmd);
}
static int i3c_hub_request_ibi(struct i3c_dev_desc *desc,
const struct i3c_ibi_setup *req)
{
struct i3c_master_controller *controller = i3c_dev_get_master(desc);
struct i3c_hub_controller *hub_controller;
struct i3c_master_controller *parent;
struct i3c_hub_dev_data *data;
struct i3c_hub *hub;
int ret;
hub_controller = dev_get_drvdata(&controller->dev);
if (!hub_controller || !hub_controller->hub)
return -ENODEV;
hub = hub_controller->hub;
data = i3c_dev_get_master_data(desc);
if (!data)
return -ENODEV;
parent = i3c_dev_get_master(&data->parent_desc);
if (!parent)
return -ENODEV;
mutex_lock(&hub->lock);
data->parent_desc.info = desc->info;
data->parent_desc.dev = desc->dev;
data->parent_desc.ibi = desc->ibi;
mutex_unlock(&hub->lock);
i3c_bus_normaluse_lock(&parent->bus);
ret = i3c_dev_request_ibi_controller_locked(&data->parent_desc, req);
i3c_bus_normaluse_unlock(&parent->bus);
if (ret) {
mutex_lock(&hub->lock);
data->parent_desc.ibi = NULL;
data->parent_desc.dev = NULL;
mutex_unlock(&hub->lock);
}
return ret;
}
static void i3c_hub_free_ibi(struct i3c_dev_desc *desc)
{
struct i3c_master_controller *controller = i3c_dev_get_master(desc);
struct i3c_hub_controller *hub_controller;
struct i3c_master_controller *parent;
struct i3c_hub_dev_data *data;
struct i3c_hub *hub;
hub_controller = dev_get_drvdata(&controller->dev);
if (!hub_controller || !hub_controller->hub)
return;
hub = hub_controller->hub;
data = i3c_dev_get_master_data(desc);
if (!data || !data->parent_desc.ibi)
return;
parent = i3c_dev_get_master(&data->parent_desc);
if (!parent)
return;
i3c_bus_normaluse_lock(&parent->bus);
i3c_dev_free_ibi_controller_locked(&data->parent_desc);
i3c_bus_normaluse_unlock(&parent->bus);
mutex_lock(&hub->lock);
data->parent_desc.ibi = NULL;
data->parent_desc.dev = NULL;
mutex_unlock(&hub->lock);
}
static int i3c_hub_enable_ibi(struct i3c_dev_desc *desc)
{
struct i3c_master_controller *controller = i3c_dev_get_master(desc);
struct i3c_hub_controller *hub_controller;
struct i3c_master_controller *parent;
struct i3c_hub_dev_data *data;
struct i3c_hub *hub;
int ret;
hub_controller = dev_get_drvdata(&controller->dev);
if (!hub_controller || !hub_controller->hub)
return -ENODEV;
hub = hub_controller->hub;
data = i3c_dev_get_master_data(desc);
if (!data || !data->parent_desc.ibi)
return -ENODEV;
parent = i3c_dev_get_master(&data->parent_desc);
if (!parent)
return -ENODEV;
mutex_lock(&hub->lock);
i3c_hub_enable_port(controller);
i3c_bus_maintenance_lock(&parent->bus);
ret = i3c_dev_enable_ibi_controller_locked(&data->parent_desc);
i3c_bus_maintenance_unlock(&parent->bus);
i3c_hub_disable_port(controller);
mutex_unlock(&hub->lock);
return ret;
}
static int i3c_hub_disable_ibi(struct i3c_dev_desc *desc)
{
struct i3c_master_controller *controller = i3c_dev_get_master(desc);
struct i3c_hub_controller *hub_controller;
struct i3c_master_controller *parent;
struct i3c_hub_dev_data *data;
struct i3c_hub *hub;
int ret;
hub_controller = dev_get_drvdata(&controller->dev);
if (!hub_controller || !hub_controller->hub)
return -ENODEV;
hub = hub_controller->hub;
data = i3c_dev_get_master_data(desc);
if (!data || !data->parent_desc.ibi)
return -ENODEV;
parent = i3c_dev_get_master(&data->parent_desc);
if (!parent)
return -ENODEV;
mutex_lock(&hub->lock);
i3c_hub_enable_port(controller);
i3c_bus_maintenance_lock(&parent->bus);
ret = i3c_dev_disable_ibi_controller_locked(&data->parent_desc);
i3c_bus_maintenance_unlock(&parent->bus);
i3c_hub_disable_port(controller);
mutex_unlock(&hub->lock);
return ret;
}
static void i3c_hub_recycle_ibi_slot(struct i3c_dev_desc *desc,
struct i3c_ibi_slot *slot)
{
struct i3c_hub_dev_data *data = i3c_dev_get_master_data(desc);
if (!data)
return;
i3c_dev_recycle_ibi_slot_controller(&data->parent_desc, slot);
}
const struct i3c_master_controller_ops i3c_hub_master_ops = {
.bus_init = i3c_hub_master_bus_init,
.bus_cleanup = i3c_hub_master_bus_cleanup,
.attach_i3c_dev = i3c_hub_attach_i3c_dev,
.reattach_i3c_dev = i3c_hub_reattach_i3c_dev,
.detach_i3c_dev = i3c_hub_detach_i3c_dev,
.do_daa = i3c_hub_master_do_daa,
.supports_ccc_cmd = i3c_hub_master_supports_ccc_cmd,
.send_ccc_cmd = i3c_hub_master_send_ccc_cmd,
.i3c_xfers = i3c_hub_master_priv_xfers,
.attach_i2c_dev = i3c_hub_attach_i2c_dev,
.detach_i2c_dev = i3c_hub_detach_i2c_dev,
.i2c_xfers = i3c_hub_i2c_xfers,
.request_ibi = i3c_hub_request_ibi,
.free_ibi = i3c_hub_free_ibi,
.enable_ibi = i3c_hub_enable_ibi,
.disable_ibi = i3c_hub_disable_ibi,
.recycle_ibi_slot = i3c_hub_recycle_ibi_slot,
};
EXPORT_SYMBOL_GPL(i3c_hub_master_ops);
static void i3c_hub_set_routing_lock_class(struct i3c_hub *hub)
{
struct i3c_master_controller *parent;
unsigned int depth;
if (!IS_ENABLED(CONFIG_LOCKDEP))
return;
parent = i3c_dev_get_master(hub->hub_dev->desc);
depth = i3c_hub_controller_depth(parent) + 1;
if (WARN_ONCE(depth > I3C_HUB_MAX_LOCK_DEPTH,
"i3c-hub: routing lock depth %u exceeds lockdep support\n",
depth))
depth = I3C_HUB_MAX_LOCK_DEPTH;
lockdep_set_class(&hub->lock, &i3c_hub_routing_lock_keys[depth - 1]);
}
void i3c_hub_init(struct i3c_hub *hub,
const struct i3c_hub_ops *ops,
struct i3c_device *hub_dev)
{
hub->ops = ops;
hub->hub_dev = hub_dev;
mutex_init(&hub->lock);
i3c_hub_set_routing_lock_class(hub);
}
EXPORT_SYMBOL_GPL(i3c_hub_init);
int i3c_hub_reserve_parent_addrslots_from_dt(struct i3c_hub_controller *hubc,
struct device_node *node)
{
struct i3c_master_controller *parent = hubc->parent;
enum i3c_addr_slot_status status;
u32 assigned_addr;
u32 reg[3];
int ret;
if (!parent || !node)
return -ENODEV;
for_each_available_child_of_node_scoped(node, child) {
ret = of_property_read_variable_u32_array(child, "reg", reg, 1, 3);
if (ret < 0)
continue;
ret = of_property_read_u32(child, "assigned-address", &assigned_addr);
if (ret)
continue;
if (!assigned_addr || assigned_addr > I3C_MAX_ADDR)
continue;
i3c_bus_maintenance_lock(&parent->bus);
status = i3c_bus_get_addr_slot_status(&parent->bus,
assigned_addr);
if (status == I3C_ADDR_SLOT_FREE)
i3c_bus_set_addr_slot_status(&parent->bus,
assigned_addr,
I3C_ADDR_SLOT_I3C_DEV);
i3c_bus_maintenance_unlock(&parent->bus);
}
return 0;
}
EXPORT_SYMBOL_GPL(i3c_hub_reserve_parent_addrslots_from_dt);
MODULE_AUTHOR("Aman Kumar Pandey <aman.kumarpandey@nxp.com>");
MODULE_AUTHOR("Vikash Bansal <vikash.bansal@nxp.com>");
MODULE_AUTHOR("Lakshay Piplani <lakshay.piplani@nxp.com>");
MODULE_DESCRIPTION("Generic I3C hub support");
MODULE_LICENSE("GPL"