[linux-block.git] / include / linux / i3c / device.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (C) 2018 Cadence Design Systems Inc.
 *
 * Author: Boris Brezillon <boris.brezillon@bootlin.com>
 */

#ifndef I3C_DEV_H
#define I3C_DEV_H

#include <linux/bitops.h>
#include <linux/device.h>
#include <linux/i2c.h>
#include <linux/kconfig.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>

/**
 * enum i3c_error_code - I3C error codes
 *
 * These are the standard error codes as defined by the I3C specification.
 * When -EIO is returned by the i3c_device_do_priv_xfers() or
 * i3c_device_send_hdr_cmds() one can check the error code in
 * &struct_i3c_priv_xfer.err or &struct i3c_hdr_cmd.err to get a better idea of
 * what went wrong.
 *
 * @I3C_ERROR_UNKNOWN: unknown error, usually means the error is not I3C
 *		       related
 * @I3C_ERROR_M0: M0 error
 * @I3C_ERROR_M1: M1 error
 * @I3C_ERROR_M2: M2 error
 */
enum i3c_error_code {
	I3C_ERROR_UNKNOWN = 0,
	I3C_ERROR_M0 = 1,
	I3C_ERROR_M1,
	I3C_ERROR_M2,
};

/**
 * enum i3c_hdr_mode - HDR mode ids
 * @I3C_HDR_DDR: DDR mode
 * @I3C_HDR_TSP: TSP mode
 * @I3C_HDR_TSL: TSL mode
 */
enum i3c_hdr_mode {
	I3C_HDR_DDR,
	I3C_HDR_TSP,
	I3C_HDR_TSL,
};

/**
 * struct i3c_priv_xfer - I3C SDR private transfer
 * @rnw: encodes the transfer direction. true for a read, false for a write
 * @len: transfer length in bytes of the transfer
 * @data: input/output buffer
 * @data.in: input buffer. Must point to a DMA-able buffer
 * @data.out: output buffer. Must point to a DMA-able buffer
 * @err: I3C error code
 */
struct i3c_priv_xfer {
	u8 rnw;
	u16 len;
	union {
		void *in;
		const void *out;
	} data;
	enum i3c_error_code err;
};

/**
 * enum i3c_dcr - I3C DCR values
 * @I3C_DCR_GENERIC_DEVICE: generic I3C device
 */
enum i3c_dcr {
	I3C_DCR_GENERIC_DEVICE = 0,
};

#define I3C_PID_MANUF_ID(pid)		(((pid) & GENMASK_ULL(47, 33)) >> 33)
#define I3C_PID_RND_LOWER_32BITS(pid)	(!!((pid) & BIT_ULL(32)))
#define I3C_PID_RND_VAL(pid)		((pid) & GENMASK_ULL(31, 0))
#define I3C_PID_PART_ID(pid)		(((pid) & GENMASK_ULL(31, 16)) >> 16)
#define I3C_PID_INSTANCE_ID(pid)	(((pid) & GENMASK_ULL(15, 12)) >> 12)
#define I3C_PID_EXTRA_INFO(pid)		((pid) & GENMASK_ULL(11, 0))

#define I3C_BCR_DEVICE_ROLE(bcr)	((bcr) & GENMASK(7, 6))
#define I3C_BCR_I3C_SLAVE		(0 << 6)
#define I3C_BCR_I3C_MASTER		(1 << 6)
#define I3C_BCR_HDR_CAP			BIT(5)
#define I3C_BCR_BRIDGE			BIT(4)
#define I3C_BCR_OFFLINE_CAP		BIT(3)
#define I3C_BCR_IBI_PAYLOAD		BIT(2)
#define I3C_BCR_IBI_REQ_CAP		BIT(1)
#define I3C_BCR_MAX_DATA_SPEED_LIM	BIT(0)

/**
 * struct i3c_device_info - I3C device information
 * @pid: Provisional ID
 * @bcr: Bus Characteristic Register
 * @dcr: Device Characteristic Register
 * @static_addr: static/I2C address
 * @dyn_addr: dynamic address
 * @hdr_cap: supported HDR modes
 * @max_read_ds: max read speed information
 * @max_write_ds: max write speed information
 * @max_ibi_len: max IBI payload length
 * @max_read_turnaround: max read turn-around time in micro-seconds
 * @max_read_len: max private SDR read length in bytes
 * @max_write_len: max private SDR write length in bytes
 *
 * These are all basic information that should be advertised by an I3C device.
 * Some of them are optional depending on the device type and device
 * capabilities.
 * For each I3C slave attached to a master with
 * i3c_master_add_i3c_dev_locked(), the core will send the relevant CCC command
 * to retrieve these data.
 */
struct i3c_device_info {
	u64 pid;
	u8 bcr;
	u8 dcr;
	u8 static_addr;
	u8 dyn_addr;
	u8 hdr_cap;
	u8 max_read_ds;
	u8 max_write_ds;
	u8 max_ibi_len;
	u32 max_read_turnaround;
	u16 max_read_len;
	u16 max_write_len;
};

/*
 * I3C device internals are kept hidden from I3C device users. It's just
 * simpler to refactor things when everything goes through getter/setters, and
 * I3C device drivers should not have to worry about internal representation
 * anyway.
 */
struct i3c_device;

/* These macros should be used to i3c_device_id entries. */
#define I3C_MATCH_MANUF_AND_PART (I3C_MATCH_MANUF | I3C_MATCH_PART)

#define I3C_DEVICE(_manufid, _partid, _drvdata)				\
	{								\
		.match_flags = I3C_MATCH_MANUF_AND_PART,		\
		.manuf_id = _manufid,					\
		.part_id = _partid,					\
		.data = _drvdata,					\
	}

#define I3C_DEVICE_EXTRA_INFO(_manufid, _partid, _info, _drvdata)	\
	{								\
		.match_flags = I3C_MATCH_MANUF_AND_PART |		\
			       I3C_MATCH_EXTRA_INFO,			\
		.manuf_id = _manufid,					\
		.part_id = _partid,					\
		.extra_info = _info,					\
		.data = _drvdata,					\
	}

#define I3C_CLASS(_dcr, _drvdata)					\
	{								\
		.match_flags = I3C_MATCH_DCR,				\
		.dcr = _dcr,						\
	}

/**
 * struct i3c_driver - I3C device driver
 * @driver: inherit from device_driver
 * @probe: I3C device probe method
 * @remove: I3C device remove method
 * @id_table: I3C device match table. Will be used by the framework to decide
 *	      which device to bind to this driver
 */
struct i3c_driver {
	struct device_driver driver;
	int (*probe)(struct i3c_device *dev);
	void (*remove)(struct i3c_device *dev);
	const struct i3c_device_id *id_table;
};

static inline struct i3c_driver *drv_to_i3cdrv(struct device_driver *drv)
{
	return container_of(drv, struct i3c_driver, driver);
}

struct device *i3cdev_to_dev(struct i3c_device *i3cdev);
struct i3c_device *dev_to_i3cdev(struct device *dev);

const struct i3c_device_id *
i3c_device_match_id(struct i3c_device *i3cdev,
		    const struct i3c_device_id *id_table);

static inline void i3cdev_set_drvdata(struct i3c_device *i3cdev,
				      void *data)
{
	struct device *dev = i3cdev_to_dev(i3cdev);

	dev_set_drvdata(dev, data);
}

static inline void *i3cdev_get_drvdata(struct i3c_device *i3cdev)
{
	struct device *dev = i3cdev_to_dev(i3cdev);

	return dev_get_drvdata(dev);
}

int i3c_driver_register_with_owner(struct i3c_driver *drv,
				   struct module *owner);
void i3c_driver_unregister(struct i3c_driver *drv);

#define i3c_driver_register(__drv)		\
	i3c_driver_register_with_owner(__drv, THIS_MODULE)

/**
 * module_i3c_driver() - Register a module providing an I3C driver
 * @__drv: the I3C driver to register
 *
 * Provide generic init/exit functions that simply register/unregister an I3C
 * driver.
 * Should be used by any driver that does not require extra init/cleanup steps.
 */
#define module_i3c_driver(__drv)		\
	module_driver(__drv, i3c_driver_register, i3c_driver_unregister)

/**
 * i3c_i2c_driver_register() - Register an i2c and an i3c driver
 * @i3cdrv: the I3C driver to register
 * @i2cdrv: the I2C driver to register
 *
 * This function registers both @i2cdev and @i3cdev, and fails if one of these
 * registrations fails. This is mainly useful for devices that support both I2C
 * and I3C modes.
 * Note that when CONFIG_I3C is not enabled, this function only registers the
 * I2C driver.
 *
 * Return: 0 if both registrations succeeds, a negative error code otherwise.
 */
static inline int i3c_i2c_driver_register(struct i3c_driver *i3cdrv,
					  struct i2c_driver *i2cdrv)
{
	int ret;

	ret = i2c_add_driver(i2cdrv);
	if (ret || !IS_ENABLED(CONFIG_I3C))
		return ret;

	ret = i3c_driver_register(i3cdrv);
	if (ret)
		i2c_del_driver(i2cdrv);

	return ret;
}

/**
 * i3c_i2c_driver_unregister() - Unregister an i2c and an i3c driver
 * @i3cdrv: the I3C driver to register
 * @i2cdrv: the I2C driver to register
 *
 * This function unregisters both @i3cdrv and @i2cdrv.
 * Note that when CONFIG_I3C is not enabled, this function only unregisters the
 * @i2cdrv.
 */
static inline void i3c_i2c_driver_unregister(struct i3c_driver *i3cdrv,
					     struct i2c_driver *i2cdrv)
{
	if (IS_ENABLED(CONFIG_I3C))
		i3c_driver_unregister(i3cdrv);

	i2c_del_driver(i2cdrv);
}

/**
 * module_i3c_i2c_driver() - Register a module providing an I3C and an I2C
 *			     driver
 * @__i3cdrv: the I3C driver to register
 * @__i2cdrv: the I3C driver to register
 *
 * Provide generic init/exit functions that simply register/unregister an I3C
 * and an I2C driver.
 * This macro can be used even if CONFIG_I3C is disabled, in this case, only
 * the I2C driver will be registered.
 * Should be used by any driver that does not require extra init/cleanup steps.
 */
#define module_i3c_i2c_driver(__i3cdrv, __i2cdrv)	\
	module_driver(__i3cdrv,				\
		      i3c_i2c_driver_register,		\
		      i3c_i2c_driver_unregister,	\
		      __i2cdrv)

int i3c_device_do_priv_xfers(struct i3c_device *dev,
			     struct i3c_priv_xfer *xfers,
			     int nxfers);

void i3c_device_get_info(struct i3c_device *dev, struct i3c_device_info *info);

struct i3c_ibi_payload {
	unsigned int len;
	const void *data;
};

/**
 * struct i3c_ibi_setup - IBI setup object
 * @max_payload_len: maximum length of the payload associated to an IBI. If one
 *		     IBI appears to have a payload that is bigger than this
 *		     number, the IBI will be rejected.
 * @num_slots: number of pre-allocated IBI slots. This should be chosen so that
 *	       the system never runs out of IBI slots, otherwise you'll lose
 *	       IBIs.
 * @handler: IBI handler, every time an IBI is received. This handler is called
 *	     in a workqueue context. It is allowed to sleep and send new
 *	     messages on the bus, though it's recommended to keep the
 *	     processing done there as fast as possible to avoid delaying
 *	     processing of other queued on the same workqueue.
 *
 * Temporary structure used to pass information to i3c_device_request_ibi().
 * This object can be allocated on the stack since i3c_device_request_ibi()
 * copies every bit of information and do not use it after
 * i3c_device_request_ibi() has returned.
 */
struct i3c_ibi_setup {
	unsigned int max_payload_len;
	unsigned int num_slots;
	void (*handler)(struct i3c_device *dev,
			const struct i3c_ibi_payload *payload);
};

int i3c_device_request_ibi(struct i3c_device *dev,
			   const struct i3c_ibi_setup *setup);
void i3c_device_free_ibi(struct i3c_device *dev);
int i3c_device_enable_ibi(struct i3c_device *dev);
int i3c_device_disable_ibi(struct i3c_device *dev);

#endif /* I3C_DEV_H */
Commit	Line	Data
3a379bbc BB	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/*
	3	* Copyright (C) 2018 Cadence Design Systems Inc.
	4	*
	5	* Author: Boris Brezillon <boris.brezillon@bootlin.com>
	6	*/
	7
	8	#ifndef I3C_DEV_H
	9	#define I3C_DEV_H
	10
	11	#include <linux/bitops.h>
	12	#include <linux/device.h>
	13	#include <linux/i2c.h>
	14	#include <linux/kconfig.h>
	15	#include <linux/mod_devicetable.h>
	16	#include <linux/module.h>
	17
	18	/**
	19	* enum i3c_error_code - I3C error codes
	20	*
	21	* These are the standard error codes as defined by the I3C specification.
	22	* When -EIO is returned by the i3c_device_do_priv_xfers() or
	23	* i3c_device_send_hdr_cmds() one can check the error code in
	24	* &struct_i3c_priv_xfer.err or &struct i3c_hdr_cmd.err to get a better idea of
	25	* what went wrong.
	26	*
	27	* @I3C_ERROR_UNKNOWN: unknown error, usually means the error is not I3C
	28	* related
	29	* @I3C_ERROR_M0: M0 error
	30	* @I3C_ERROR_M1: M1 error
	31	* @I3C_ERROR_M2: M2 error
	32	*/
	33	enum i3c_error_code {
	34	I3C_ERROR_UNKNOWN = 0,
	35	I3C_ERROR_M0 = 1,
	36	I3C_ERROR_M1,
	37	I3C_ERROR_M2,
	38	};
	39
	40	/**
	41	* enum i3c_hdr_mode - HDR mode ids
	42	* @I3C_HDR_DDR: DDR mode
	43	* @I3C_HDR_TSP: TSP mode
	44	* @I3C_HDR_TSL: TSL mode
	45	*/
	46	enum i3c_hdr_mode {
	47	I3C_HDR_DDR,
	48	I3C_HDR_TSP,
	49	I3C_HDR_TSL,
	50	};
	51
	52	/**
	53	* struct i3c_priv_xfer - I3C SDR private transfer
	54	* @rnw: encodes the transfer direction. true for a read, false for a write
	55	* @len: transfer length in bytes of the transfer
	56	* @data: input/output buffer
	57	* @data.in: input buffer. Must point to a DMA-able buffer
	58	* @data.out: output buffer. Must point to a DMA-able buffer
	59	* @err: I3C error code
	60	*/
	61	struct i3c_priv_xfer {
	62	u8 rnw;
	63	u16 len;
	64	union {
65	void *in;
66	const void *out;
67	} data;
68	enum i3c_error_code err;
69	};
70
71	/**
72	* enum i3c_dcr - I3C DCR values
73	* @I3C_DCR_GENERIC_DEVICE: generic I3C device
74	*/
75	enum i3c_dcr {
76	I3C_DCR_GENERIC_DEVICE = 0,
77	};
78
79	#define I3C_PID_MANUF_ID(pid) (((pid) & GENMASK_ULL(47, 33)) >> 33)
80	#define I3C_PID_RND_LOWER_32BITS(pid) (!!((pid) & BIT_ULL(32)))
81	#define I3C_PID_RND_VAL(pid) ((pid) & GENMASK_ULL(31, 0))
82	#define I3C_PID_PART_ID(pid) (((pid) & GENMASK_ULL(31, 16)) >> 16)
83	#define I3C_PID_INSTANCE_ID(pid) (((pid) & GENMASK_ULL(15, 12)) >> 12)
84	#define I3C_PID_EXTRA_INFO(pid) ((pid) & GENMASK_ULL(11, 0))
85
86	#define I3C_BCR_DEVICE_ROLE(bcr) ((bcr) & GENMASK(7, 6))
87	#define I3C_BCR_I3C_SLAVE (0 << 6)
88	#define I3C_BCR_I3C_MASTER (1 << 6)
89	#define I3C_BCR_HDR_CAP BIT(5)
90	#define I3C_BCR_BRIDGE BIT(4)
91	#define I3C_BCR_OFFLINE_CAP BIT(3)
92	#define I3C_BCR_IBI_PAYLOAD BIT(2)
93	#define I3C_BCR_IBI_REQ_CAP BIT(1)
94	#define I3C_BCR_MAX_DATA_SPEED_LIM BIT(0)
95
96	/**
97	* struct i3c_device_info - I3C device information
98	* @pid: Provisional ID
99	* @bcr: Bus Characteristic Register
100	* @dcr: Device Characteristic Register
101	* @static_addr: static/I2C address
102	* @dyn_addr: dynamic address
103	* @hdr_cap: supported HDR modes
104	* @max_read_ds: max read speed information
105	* @max_write_ds: max write speed information
106	* @max_ibi_len: max IBI payload length
107	* @max_read_turnaround: max read turn-around time in micro-seconds
108	* @max_read_len: max private SDR read length in bytes
109	* @max_write_len: max private SDR write length in bytes
110	*
111	* These are all basic information that should be advertised by an I3C device.
112	* Some of them are optional depending on the device type and device
113	* capabilities.
114	* For each I3C slave attached to a master with
115	* i3c_master_add_i3c_dev_locked(), the core will send the relevant CCC command
116	* to retrieve these data.
117	*/
118	struct i3c_device_info {
119	u64 pid;
120	u8 bcr;
121	u8 dcr;
122	u8 static_addr;
123	u8 dyn_addr;
124	u8 hdr_cap;
125	u8 max_read_ds;
126	u8 max_write_ds;
127	u8 max_ibi_len;
128	u32 max_read_turnaround;
129	u16 max_read_len;
130	u16 max_write_len;
131	};
132
133	/*
134	* I3C device internals are kept hidden from I3C device users. It's just
135	* simpler to refactor things when everything goes through getter/setters, and
136	* I3C device drivers should not have to worry about internal representation
137	* anyway.
138	*/
139	struct i3c_device;
140
141	/* These macros should be used to i3c_device_id entries. */
142	#define I3C_MATCH_MANUF_AND_PART (I3C_MATCH_MANUF \| I3C_MATCH_PART)
143
144	#define I3C_DEVICE(_manufid, _partid, _drvdata) \
145	{ \
146	.match_flags = I3C_MATCH_MANUF_AND_PART, \
147	.manuf_id = _manufid, \
148	.part_id = _partid, \
149	.data = _drvdata, \
150	}
151
152	#define I3C_DEVICE_EXTRA_INFO(_manufid, _partid, _info, _drvdata) \
153	{ \
154	.match_flags = I3C_MATCH_MANUF_AND_PART \| \
155	I3C_MATCH_EXTRA_INFO, \
156	.manuf_id = _manufid, \
157	.part_id = _partid, \
158	.extra_info = _info, \
159	.data = _drvdata, \
160	}
161
162	#define I3C_CLASS(_dcr, _drvdata) \
163	{ \
164	.match_flags = I3C_MATCH_DCR, \
165	.dcr = _dcr, \
166	}
167
168	/**
169	* struct i3c_driver - I3C device driver
170	* @driver: inherit from device_driver
171	* @probe: I3C device probe method
172	* @remove: I3C device remove method
173	* @id_table: I3C device match table. Will be used by the framework to decide
174	* which device to bind to this driver
175	*/
176	struct i3c_driver {
177	struct device_driver driver;
178	int (probe)(struct i3c_device dev);
dd926703	179	void (remove)(struct i3c_device dev);
3a379bbc BB	180	const struct i3c_device_id *id_table;
	181	};
	182
	183	static inline struct i3c_driver drv_to_i3cdrv(struct device_driver drv)
	184	{
	185	return container_of(drv, struct i3c_driver, driver);
	186	}
	187
	188	struct device i3cdev_to_dev(struct i3c_device i3cdev);
	189	struct i3c_device dev_to_i3cdev(struct device dev);
	190
934d24a5 VS	191	const struct i3c_device_id *
	192	i3c_device_match_id(struct i3c_device *i3cdev,
	193	const struct i3c_device_id *id_table);
	194
3a379bbc BB	195	static inline void i3cdev_set_drvdata(struct i3c_device *i3cdev,
	196	void *data)
	197	{
	198	struct device *dev = i3cdev_to_dev(i3cdev);
	199
	200	dev_set_drvdata(dev, data);
	201	}
	202
	203	static inline void i3cdev_get_drvdata(struct i3c_device i3cdev)
	204	{
	205	struct device *dev = i3cdev_to_dev(i3cdev);
	206
	207	return dev_get_drvdata(dev);
	208	}
	209
	210	int i3c_driver_register_with_owner(struct i3c_driver *drv,
	211	struct module *owner);
	212	void i3c_driver_unregister(struct i3c_driver *drv);
	213
	214	#define i3c_driver_register(__drv) \
	215	i3c_driver_register_with_owner(__drv, THIS_MODULE)
	216
	217	/**
	218	* module_i3c_driver() - Register a module providing an I3C driver
	219	* @__drv: the I3C driver to register
	220	*
	221	* Provide generic init/exit functions that simply register/unregister an I3C
	222	* driver.
	223	* Should be used by any driver that does not require extra init/cleanup steps.
	224	*/
	225	#define module_i3c_driver(__drv) \
	226	module_driver(__drv, i3c_driver_register, i3c_driver_unregister)
	227
	228	/**
	229	* i3c_i2c_driver_register() - Register an i2c and an i3c driver
	230	* @i3cdrv: the I3C driver to register
	231	* @i2cdrv: the I2C driver to register
	232	*
	233	* This function registers both @i2cdev and @i3cdev, and fails if one of these
	234	* registrations fails. This is mainly useful for devices that support both I2C
	235	* and I3C modes.
	236	* Note that when CONFIG_I3C is not enabled, this function only registers the
	237	* I2C driver.
	238	*
	239	* Return: 0 if both registrations succeeds, a negative error code otherwise.
	240	*/
	241	static inline int i3c_i2c_driver_register(struct i3c_driver *i3cdrv,
	242	struct i2c_driver *i2cdrv)
	243	{
	244	int ret;
	245
	246	ret = i2c_add_driver(i2cdrv);
	247	if (ret \|\| !IS_ENABLED(CONFIG_I3C))
	248	return ret;
	249
	250	ret = i3c_driver_register(i3cdrv);
	251	if (ret)
	252	i2c_del_driver(i2cdrv);
	253
	254	return ret;
	255	}
	256
	257	/**
	258	* i3c_i2c_driver_unregister() - Unregister an i2c and an i3c driver
259	* @i3cdrv: the I3C driver to register
260	* @i2cdrv: the I2C driver to register
261	*
262	* This function unregisters both @i3cdrv and @i2cdrv.
263	* Note that when CONFIG_I3C is not enabled, this function only unregisters the
264	* @i2cdrv.
265	*/
266	static inline void i3c_i2c_driver_unregister(struct i3c_driver *i3cdrv,
267	struct i2c_driver *i2cdrv)
268	{
269	if (IS_ENABLED(CONFIG_I3C))
270	i3c_driver_unregister(i3cdrv);
271
272	i2c_del_driver(i2cdrv);
273	}
274
275	/**
276	* module_i3c_i2c_driver() - Register a module providing an I3C and an I2C
277	* driver
278	* @__i3cdrv: the I3C driver to register
279	* @__i2cdrv: the I3C driver to register
280	*
281	* Provide generic init/exit functions that simply register/unregister an I3C
282	* and an I2C driver.
283	* This macro can be used even if CONFIG_I3C is disabled, in this case, only
284	* the I2C driver will be registered.
285	* Should be used by any driver that does not require extra init/cleanup steps.
286	*/
287	#define module_i3c_i2c_driver(__i3cdrv, __i2cdrv) \
288	module_driver(__i3cdrv, \
289	i3c_i2c_driver_register, \
01744ce9 NKC	290	i3c_i2c_driver_unregister, \
01744ce9 NKC	291	__i2cdrv)
3a379bbc BB	292
	293	int i3c_device_do_priv_xfers(struct i3c_device *dev,
	294	struct i3c_priv_xfer *xfers,
	295	int nxfers);
	296
	297	void i3c_device_get_info(struct i3c_device dev, struct i3c_device_info info);
	298
	299	struct i3c_ibi_payload {
	300	unsigned int len;
	301	const void *data;
	302	};
	303
	304	/**
	305	* struct i3c_ibi_setup - IBI setup object
	306	* @max_payload_len: maximum length of the payload associated to an IBI. If one
	307	* IBI appears to have a payload that is bigger than this
	308	* number, the IBI will be rejected.
	309	* @num_slots: number of pre-allocated IBI slots. This should be chosen so that
	310	* the system never runs out of IBI slots, otherwise you'll lose
	311	* IBIs.
	312	* @handler: IBI handler, every time an IBI is received. This handler is called
	313	* in a workqueue context. It is allowed to sleep and send new
	314	* messages on the bus, though it's recommended to keep the
	315	* processing done there as fast as possible to avoid delaying
	316	* processing of other queued on the same workqueue.
	317	*
	318	* Temporary structure used to pass information to i3c_device_request_ibi().
	319	* This object can be allocated on the stack since i3c_device_request_ibi()
	320	* copies every bit of information and do not use it after
	321	* i3c_device_request_ibi() has returned.
	322	*/
	323	struct i3c_ibi_setup {
	324	unsigned int max_payload_len;
	325	unsigned int num_slots;
	326	void (handler)(struct i3c_device dev,
	327	const struct i3c_ibi_payload *payload);
	328	};
	329
	330	int i3c_device_request_ibi(struct i3c_device *dev,
	331	const struct i3c_ibi_setup *setup);
	332	void i3c_device_free_ibi(struct i3c_device *dev);
	333	int i3c_device_enable_ibi(struct i3c_device *dev);
	334	int i3c_device_disable_ibi(struct i3c_device *dev);
	335
	336	#endif /* I3C_DEV_H */