cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

master.h (25520B)


      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_MASTER_H
      9#define I3C_MASTER_H
     10
     11#include <asm/bitsperlong.h>
     12
     13#include <linux/bitops.h>
     14#include <linux/i2c.h>
     15#include <linux/i3c/ccc.h>
     16#include <linux/i3c/device.h>
     17#include <linux/rwsem.h>
     18#include <linux/spinlock.h>
     19#include <linux/workqueue.h>
     20
     21#define I3C_HOT_JOIN_ADDR		0x2
     22#define I3C_BROADCAST_ADDR		0x7e
     23#define I3C_MAX_ADDR			GENMASK(6, 0)
     24
     25struct i3c_master_controller;
     26struct i3c_bus;
     27struct i2c_device;
     28struct i3c_device;
     29
     30/**
     31 * struct i3c_i2c_dev_desc - Common part of the I3C/I2C device descriptor
     32 * @node: node element used to insert the slot into the I2C or I3C device
     33 *	  list
     34 * @master: I3C master that instantiated this device. Will be used to do
     35 *	    I2C/I3C transfers
     36 * @master_priv: master private data assigned to the device. Can be used to
     37 *		 add master specific information
     38 *
     39 * This structure is describing common I3C/I2C dev information.
     40 */
     41struct i3c_i2c_dev_desc {
     42	struct list_head node;
     43	struct i3c_master_controller *master;
     44	void *master_priv;
     45};
     46
     47#define I3C_LVR_I2C_INDEX_MASK		GENMASK(7, 5)
     48#define I3C_LVR_I2C_INDEX(x)		((x) << 5)
     49#define I3C_LVR_I2C_FM_MODE		BIT(4)
     50
     51#define I2C_MAX_ADDR			GENMASK(6, 0)
     52
     53/**
     54 * struct i2c_dev_boardinfo - I2C device board information
     55 * @node: used to insert the boardinfo object in the I2C boardinfo list
     56 * @base: regular I2C board information
     57 * @lvr: LVR (Legacy Virtual Register) needed by the I3C core to know about
     58 *	 the I2C device limitations
     59 *
     60 * This structure is used to attach board-level information to an I2C device.
     61 * Each I2C device connected on the I3C bus should have one.
     62 */
     63struct i2c_dev_boardinfo {
     64	struct list_head node;
     65	struct i2c_board_info base;
     66	u8 lvr;
     67};
     68
     69/**
     70 * struct i2c_dev_desc - I2C device descriptor
     71 * @common: common part of the I2C device descriptor
     72 * @boardinfo: pointer to the boardinfo attached to this I2C device
     73 * @dev: I2C device object registered to the I2C framework
     74 * @addr: I2C device address
     75 * @lvr: LVR (Legacy Virtual Register) needed by the I3C core to know about
     76 *	 the I2C device limitations
     77 *
     78 * Each I2C device connected on the bus will have an i2c_dev_desc.
     79 * This object is created by the core and later attached to the controller
     80 * using &struct_i3c_master_controller->ops->attach_i2c_dev().
     81 *
     82 * &struct_i2c_dev_desc is the internal representation of an I2C device
     83 * connected on an I3C bus. This object is also passed to all
     84 * &struct_i3c_master_controller_ops hooks.
     85 */
     86struct i2c_dev_desc {
     87	struct i3c_i2c_dev_desc common;
     88	struct i2c_client *dev;
     89	u16 addr;
     90	u8 lvr;
     91};
     92
     93/**
     94 * struct i3c_ibi_slot - I3C IBI (In-Band Interrupt) slot
     95 * @work: work associated to this slot. The IBI handler will be called from
     96 *	  there
     97 * @dev: the I3C device that has generated this IBI
     98 * @len: length of the payload associated to this IBI
     99 * @data: payload buffer
    100 *
    101 * An IBI slot is an object pre-allocated by the controller and used when an
    102 * IBI comes in.
    103 * Every time an IBI comes in, the I3C master driver should find a free IBI
    104 * slot in its IBI slot pool, retrieve the IBI payload and queue the IBI using
    105 * i3c_master_queue_ibi().
    106 *
    107 * How IBI slots are allocated is left to the I3C master driver, though, for
    108 * simple kmalloc-based allocation, the generic IBI slot pool can be used.
    109 */
    110struct i3c_ibi_slot {
    111	struct work_struct work;
    112	struct i3c_dev_desc *dev;
    113	unsigned int len;
    114	void *data;
    115};
    116
    117/**
    118 * struct i3c_device_ibi_info - IBI information attached to a specific device
    119 * @all_ibis_handled: used to be informed when no more IBIs are waiting to be
    120 *		      processed. Used by i3c_device_disable_ibi() to wait for
    121 *		      all IBIs to be dequeued
    122 * @pending_ibis: count the number of pending IBIs. Each pending IBI has its
    123 *		  work element queued to the controller workqueue
    124 * @max_payload_len: maximum payload length for an IBI coming from this device.
    125 *		     this value is specified when calling
    126 *		     i3c_device_request_ibi() and should not change at run
    127 *		     time. All messages IBIs exceeding this limit should be
    128 *		     rejected by the master
    129 * @num_slots: number of IBI slots reserved for this device
    130 * @enabled: reflect the IBI status
    131 * @handler: IBI handler specified at i3c_device_request_ibi() call time. This
    132 *	     handler will be called from the controller workqueue, and as such
    133 *	     is allowed to sleep (though it is recommended to process the IBI
    134 *	     as fast as possible to not stall processing of other IBIs queued
    135 *	     on the same workqueue).
    136 *	     New I3C messages can be sent from the IBI handler
    137 *
    138 * The &struct_i3c_device_ibi_info object is allocated when
    139 * i3c_device_request_ibi() is called and attached to a specific device. This
    140 * object is here to manage IBIs coming from a specific I3C device.
    141 *
    142 * Note that this structure is the generic view of the IBI management
    143 * infrastructure. I3C master drivers may have their own internal
    144 * representation which they can associate to the device using
    145 * controller-private data.
    146 */
    147struct i3c_device_ibi_info {
    148	struct completion all_ibis_handled;
    149	atomic_t pending_ibis;
    150	unsigned int max_payload_len;
    151	unsigned int num_slots;
    152	unsigned int enabled;
    153	void (*handler)(struct i3c_device *dev,
    154			const struct i3c_ibi_payload *payload);
    155};
    156
    157/**
    158 * struct i3c_dev_boardinfo - I3C device board information
    159 * @node: used to insert the boardinfo object in the I3C boardinfo list
    160 * @init_dyn_addr: initial dynamic address requested by the FW. We provide no
    161 *		   guarantee that the device will end up using this address,
    162 *		   but try our best to assign this specific address to the
    163 *		   device
    164 * @static_addr: static address the I3C device listen on before it's been
    165 *		 assigned a dynamic address by the master. Will be used during
    166 *		 bus initialization to assign it a specific dynamic address
    167 *		 before starting DAA (Dynamic Address Assignment)
    168 * @pid: I3C Provisional ID exposed by the device. This is a unique identifier
    169 *	 that may be used to attach boardinfo to i3c_dev_desc when the device
    170 *	 does not have a static address
    171 * @of_node: optional DT node in case the device has been described in the DT
    172 *
    173 * This structure is used to attach board-level information to an I3C device.
    174 * Not all I3C devices connected on the bus will have a boardinfo. It's only
    175 * needed if you want to attach extra resources to a device or assign it a
    176 * specific dynamic address.
    177 */
    178struct i3c_dev_boardinfo {
    179	struct list_head node;
    180	u8 init_dyn_addr;
    181	u8 static_addr;
    182	u64 pid;
    183	struct device_node *of_node;
    184};
    185
    186/**
    187 * struct i3c_dev_desc - I3C device descriptor
    188 * @common: common part of the I3C device descriptor
    189 * @info: I3C device information. Will be automatically filled when you create
    190 *	  your device with i3c_master_add_i3c_dev_locked()
    191 * @ibi_lock: lock used to protect the &struct_i3c_device->ibi
    192 * @ibi: IBI info attached to a device. Should be NULL until
    193 *	 i3c_device_request_ibi() is called
    194 * @dev: pointer to the I3C device object exposed to I3C device drivers. This
    195 *	 should never be accessed from I3C master controller drivers. Only core
    196 *	 code should manipulate it in when updating the dev <-> desc link or
    197 *	 when propagating IBI events to the driver
    198 * @boardinfo: pointer to the boardinfo attached to this I3C device
    199 *
    200 * Internal representation of an I3C device. This object is only used by the
    201 * core and passed to I3C master controller drivers when they're requested to
    202 * do some operations on the device.
    203 * The core maintains the link between the internal I3C dev descriptor and the
    204 * object exposed to the I3C device drivers (&struct_i3c_device).
    205 */
    206struct i3c_dev_desc {
    207	struct i3c_i2c_dev_desc common;
    208	struct i3c_device_info info;
    209	struct mutex ibi_lock;
    210	struct i3c_device_ibi_info *ibi;
    211	struct i3c_device *dev;
    212	const struct i3c_dev_boardinfo *boardinfo;
    213};
    214
    215/**
    216 * struct i3c_device - I3C device object
    217 * @dev: device object to register the I3C dev to the device model
    218 * @desc: pointer to an i3c device descriptor object. This link is updated
    219 *	  every time the I3C device is rediscovered with a different dynamic
    220 *	  address assigned
    221 * @bus: I3C bus this device is attached to
    222 *
    223 * I3C device object exposed to I3C device drivers. The takes care of linking
    224 * this object to the relevant &struct_i3c_dev_desc one.
    225 * All I3C devs on the I3C bus are represented, including I3C masters. For each
    226 * of them, we have an instance of &struct i3c_device.
    227 */
    228struct i3c_device {
    229	struct device dev;
    230	struct i3c_dev_desc *desc;
    231	struct i3c_bus *bus;
    232};
    233
    234/*
    235 * The I3C specification says the maximum number of devices connected on the
    236 * bus is 11, but this number depends on external parameters like trace length,
    237 * capacitive load per Device, and the types of Devices present on the Bus.
    238 * I3C master can also have limitations, so this number is just here as a
    239 * reference and should be adjusted on a per-controller/per-board basis.
    240 */
    241#define I3C_BUS_MAX_DEVS		11
    242
    243#define I3C_BUS_MAX_I3C_SCL_RATE	12900000
    244#define I3C_BUS_TYP_I3C_SCL_RATE	12500000
    245#define I3C_BUS_I2C_FM_PLUS_SCL_RATE	1000000
    246#define I3C_BUS_I2C_FM_SCL_RATE		400000
    247#define I3C_BUS_TLOW_OD_MIN_NS		200
    248
    249/**
    250 * enum i3c_bus_mode - I3C bus mode
    251 * @I3C_BUS_MODE_PURE: only I3C devices are connected to the bus. No limitation
    252 *		       expected
    253 * @I3C_BUS_MODE_MIXED_FAST: I2C devices with 50ns spike filter are present on
    254 *			     the bus. The only impact in this mode is that the
    255 *			     high SCL pulse has to stay below 50ns to trick I2C
    256 *			     devices when transmitting I3C frames
    257 * @I3C_BUS_MODE_MIXED_LIMITED: I2C devices without 50ns spike filter are
    258 *				present on the bus. However they allow
    259 *				compliance up to the maximum SDR SCL clock
    260 *				frequency.
    261 * @I3C_BUS_MODE_MIXED_SLOW: I2C devices without 50ns spike filter are present
    262 *			     on the bus
    263 */
    264enum i3c_bus_mode {
    265	I3C_BUS_MODE_PURE,
    266	I3C_BUS_MODE_MIXED_FAST,
    267	I3C_BUS_MODE_MIXED_LIMITED,
    268	I3C_BUS_MODE_MIXED_SLOW,
    269};
    270
    271/**
    272 * enum i3c_addr_slot_status - I3C address slot status
    273 * @I3C_ADDR_SLOT_FREE: address is free
    274 * @I3C_ADDR_SLOT_RSVD: address is reserved
    275 * @I3C_ADDR_SLOT_I2C_DEV: address is assigned to an I2C device
    276 * @I3C_ADDR_SLOT_I3C_DEV: address is assigned to an I3C device
    277 * @I3C_ADDR_SLOT_STATUS_MASK: address slot mask
    278 *
    279 * On an I3C bus, addresses are assigned dynamically, and we need to know which
    280 * addresses are free to use and which ones are already assigned.
    281 *
    282 * Addresses marked as reserved are those reserved by the I3C protocol
    283 * (broadcast address, ...).
    284 */
    285enum i3c_addr_slot_status {
    286	I3C_ADDR_SLOT_FREE,
    287	I3C_ADDR_SLOT_RSVD,
    288	I3C_ADDR_SLOT_I2C_DEV,
    289	I3C_ADDR_SLOT_I3C_DEV,
    290	I3C_ADDR_SLOT_STATUS_MASK = 3,
    291};
    292
    293/**
    294 * struct i3c_bus - I3C bus object
    295 * @cur_master: I3C master currently driving the bus. Since I3C is multi-master
    296 *		this can change over the time. Will be used to let a master
    297 *		know whether it needs to request bus ownership before sending
    298 *		a frame or not
    299 * @id: bus ID. Assigned by the framework when register the bus
    300 * @addrslots: a bitmap with 2-bits per-slot to encode the address status and
    301 *	       ease the DAA (Dynamic Address Assignment) procedure (see
    302 *	       &enum i3c_addr_slot_status)
    303 * @mode: bus mode (see &enum i3c_bus_mode)
    304 * @scl_rate.i3c: maximum rate for the clock signal when doing I3C SDR/priv
    305 *		  transfers
    306 * @scl_rate.i2c: maximum rate for the clock signal when doing I2C transfers
    307 * @scl_rate: SCL signal rate for I3C and I2C mode
    308 * @devs.i3c: contains a list of I3C device descriptors representing I3C
    309 *	      devices connected on the bus and successfully attached to the
    310 *	      I3C master
    311 * @devs.i2c: contains a list of I2C device descriptors representing I2C
    312 *	      devices connected on the bus and successfully attached to the
    313 *	      I3C master
    314 * @devs: 2 lists containing all I3C/I2C devices connected to the bus
    315 * @lock: read/write lock on the bus. This is needed to protect against
    316 *	  operations that have an impact on the whole bus and the devices
    317 *	  connected to it. For example, when asking slaves to drop their
    318 *	  dynamic address (RSTDAA CCC), we need to make sure no one is trying
    319 *	  to send I3C frames to these devices.
    320 *	  Note that this lock does not protect against concurrency between
    321 *	  devices: several drivers can send different I3C/I2C frames through
    322 *	  the same master in parallel. This is the responsibility of the
    323 *	  master to guarantee that frames are actually sent sequentially and
    324 *	  not interlaced
    325 *
    326 * The I3C bus is represented with its own object and not implicitly described
    327 * by the I3C master to cope with the multi-master functionality, where one bus
    328 * can be shared amongst several masters, each of them requesting bus ownership
    329 * when they need to.
    330 */
    331struct i3c_bus {
    332	struct i3c_dev_desc *cur_master;
    333	int id;
    334	unsigned long addrslots[((I2C_MAX_ADDR + 1) * 2) / BITS_PER_LONG];
    335	enum i3c_bus_mode mode;
    336	struct {
    337		unsigned long i3c;
    338		unsigned long i2c;
    339	} scl_rate;
    340	struct {
    341		struct list_head i3c;
    342		struct list_head i2c;
    343	} devs;
    344	struct rw_semaphore lock;
    345};
    346
    347/**
    348 * struct i3c_master_controller_ops - I3C master methods
    349 * @bus_init: hook responsible for the I3C bus initialization. You should at
    350 *	      least call master_set_info() from there and set the bus mode.
    351 *	      You can also put controller specific initialization in there.
    352 *	      This method is mandatory.
    353 * @bus_cleanup: cleanup everything done in
    354 *		 &i3c_master_controller_ops->bus_init().
    355 *		 This method is optional.
    356 * @attach_i3c_dev: called every time an I3C device is attached to the bus. It
    357 *		    can be after a DAA or when a device is statically declared
    358 *		    by the FW, in which case it will only have a static address
    359 *		    and the dynamic address will be 0.
    360 *		    When this function is called, device information have not
    361 *		    been retrieved yet.
    362 *		    This is a good place to attach master controller specific
    363 *		    data to I3C devices.
    364 *		    This method is optional.
    365 * @reattach_i3c_dev: called every time an I3C device has its addressed
    366 *		      changed. It can be because the device has been powered
    367 *		      down and has lost its address, or it can happen when a
    368 *		      device had a static address and has been assigned a
    369 *		      dynamic address with SETDASA.
    370 *		      This method is optional.
    371 * @detach_i3c_dev: called when an I3C device is detached from the bus. Usually
    372 *		    happens when the master device is unregistered.
    373 *		    This method is optional.
    374 * @do_daa: do a DAA (Dynamic Address Assignment) procedure. This is procedure
    375 *	    should send an ENTDAA CCC command and then add all devices
    376 *	    discovered sure the DAA using i3c_master_add_i3c_dev_locked().
    377 *	    Add devices added with i3c_master_add_i3c_dev_locked() will then be
    378 *	    attached or re-attached to the controller.
    379 *	    This method is mandatory.
    380 * @supports_ccc_cmd: should return true if the CCC command is supported, false
    381 *		      otherwise.
    382 *		      This method is optional, if not provided the core assumes
    383 *		      all CCC commands are supported.
    384 * @send_ccc_cmd: send a CCC command
    385 *		  This method is mandatory.
    386 * @priv_xfers: do one or several private I3C SDR transfers
    387 *		This method is mandatory.
    388 * @attach_i2c_dev: called every time an I2C device is attached to the bus.
    389 *		    This is a good place to attach master controller specific
    390 *		    data to I2C devices.
    391 *		    This method is optional.
    392 * @detach_i2c_dev: called when an I2C device is detached from the bus. Usually
    393 *		    happens when the master device is unregistered.
    394 *		    This method is optional.
    395 * @i2c_xfers: do one or several I2C transfers. Note that, unlike i3c
    396 *	       transfers, the core does not guarantee that buffers attached to
    397 *	       the transfers are DMA-safe. If drivers want to have DMA-safe
    398 *	       buffers, they should use the i2c_get_dma_safe_msg_buf()
    399 *	       and i2c_put_dma_safe_msg_buf() helpers provided by the I2C
    400 *	       framework.
    401 *	       This method is mandatory.
    402 * @request_ibi: attach an IBI handler to an I3C device. This implies defining
    403 *		 an IBI handler and the constraints of the IBI (maximum payload
    404 *		 length and number of pre-allocated slots).
    405 *		 Some controllers support less IBI-capable devices than regular
    406 *		 devices, so this method might return -%EBUSY if there's no
    407 *		 more space for an extra IBI registration
    408 *		 This method is optional.
    409 * @free_ibi: free an IBI previously requested with ->request_ibi(). The IBI
    410 *	      should have been disabled with ->disable_irq() prior to that
    411 *	      This method is mandatory only if ->request_ibi is not NULL.
    412 * @enable_ibi: enable the IBI. Only valid if ->request_ibi() has been called
    413 *		prior to ->enable_ibi(). The controller should first enable
    414 *		the IBI on the controller end (for example, unmask the hardware
    415 *		IRQ) and then send the ENEC CCC command (with the IBI flag set)
    416 *		to the I3C device.
    417 *		This method is mandatory only if ->request_ibi is not NULL.
    418 * @disable_ibi: disable an IBI. First send the DISEC CCC command with the IBI
    419 *		 flag set and then deactivate the hardware IRQ on the
    420 *		 controller end.
    421 *		 This method is mandatory only if ->request_ibi is not NULL.
    422 * @recycle_ibi_slot: recycle an IBI slot. Called every time an IBI has been
    423 *		      processed by its handler. The IBI slot should be put back
    424 *		      in the IBI slot pool so that the controller can re-use it
    425 *		      for a future IBI
    426 *		      This method is mandatory only if ->request_ibi is not
    427 *		      NULL.
    428 */
    429struct i3c_master_controller_ops {
    430	int (*bus_init)(struct i3c_master_controller *master);
    431	void (*bus_cleanup)(struct i3c_master_controller *master);
    432	int (*attach_i3c_dev)(struct i3c_dev_desc *dev);
    433	int (*reattach_i3c_dev)(struct i3c_dev_desc *dev, u8 old_dyn_addr);
    434	void (*detach_i3c_dev)(struct i3c_dev_desc *dev);
    435	int (*do_daa)(struct i3c_master_controller *master);
    436	bool (*supports_ccc_cmd)(struct i3c_master_controller *master,
    437				 const struct i3c_ccc_cmd *cmd);
    438	int (*send_ccc_cmd)(struct i3c_master_controller *master,
    439			    struct i3c_ccc_cmd *cmd);
    440	int (*priv_xfers)(struct i3c_dev_desc *dev,
    441			  struct i3c_priv_xfer *xfers,
    442			  int nxfers);
    443	int (*attach_i2c_dev)(struct i2c_dev_desc *dev);
    444	void (*detach_i2c_dev)(struct i2c_dev_desc *dev);
    445	int (*i2c_xfers)(struct i2c_dev_desc *dev,
    446			 const struct i2c_msg *xfers, int nxfers);
    447	int (*request_ibi)(struct i3c_dev_desc *dev,
    448			   const struct i3c_ibi_setup *req);
    449	void (*free_ibi)(struct i3c_dev_desc *dev);
    450	int (*enable_ibi)(struct i3c_dev_desc *dev);
    451	int (*disable_ibi)(struct i3c_dev_desc *dev);
    452	void (*recycle_ibi_slot)(struct i3c_dev_desc *dev,
    453				 struct i3c_ibi_slot *slot);
    454};
    455
    456/**
    457 * struct i3c_master_controller - I3C master controller object
    458 * @dev: device to be registered to the device-model
    459 * @this: an I3C device object representing this master. This device will be
    460 *	  added to the list of I3C devs available on the bus
    461 * @i2c: I2C adapter used for backward compatibility. This adapter is
    462 *	 registered to the I2C subsystem to be as transparent as possible to
    463 *	 existing I2C drivers
    464 * @ops: master operations. See &struct i3c_master_controller_ops
    465 * @secondary: true if the master is a secondary master
    466 * @init_done: true when the bus initialization is done
    467 * @boardinfo.i3c: list of I3C  boardinfo objects
    468 * @boardinfo.i2c: list of I2C boardinfo objects
    469 * @boardinfo: board-level information attached to devices connected on the bus
    470 * @bus: I3C bus exposed by this master
    471 * @wq: workqueue used to execute IBI handlers. Can also be used by master
    472 *	drivers if they need to postpone operations that need to take place
    473 *	in a thread context. Typical examples are Hot Join processing which
    474 *	requires taking the bus lock in maintenance, which in turn, can only
    475 *	be done from a sleep-able context
    476 *
    477 * A &struct i3c_master_controller has to be registered to the I3C subsystem
    478 * through i3c_master_register(). None of &struct i3c_master_controller fields
    479 * should be set manually, just pass appropriate values to
    480 * i3c_master_register().
    481 */
    482struct i3c_master_controller {
    483	struct device dev;
    484	struct i3c_dev_desc *this;
    485	struct i2c_adapter i2c;
    486	const struct i3c_master_controller_ops *ops;
    487	unsigned int secondary : 1;
    488	unsigned int init_done : 1;
    489	struct {
    490		struct list_head i3c;
    491		struct list_head i2c;
    492	} boardinfo;
    493	struct i3c_bus bus;
    494	struct workqueue_struct *wq;
    495};
    496
    497/**
    498 * i3c_bus_for_each_i2cdev() - iterate over all I2C devices present on the bus
    499 * @bus: the I3C bus
    500 * @dev: an I2C device descriptor pointer updated to point to the current slot
    501 *	 at each iteration of the loop
    502 *
    503 * Iterate over all I2C devs present on the bus.
    504 */
    505#define i3c_bus_for_each_i2cdev(bus, dev)				\
    506	list_for_each_entry(dev, &(bus)->devs.i2c, common.node)
    507
    508/**
    509 * i3c_bus_for_each_i3cdev() - iterate over all I3C devices present on the bus
    510 * @bus: the I3C bus
    511 * @dev: and I3C device descriptor pointer updated to point to the current slot
    512 *	 at each iteration of the loop
    513 *
    514 * Iterate over all I3C devs present on the bus.
    515 */
    516#define i3c_bus_for_each_i3cdev(bus, dev)				\
    517	list_for_each_entry(dev, &(bus)->devs.i3c, common.node)
    518
    519int i3c_master_do_i2c_xfers(struct i3c_master_controller *master,
    520			    const struct i2c_msg *xfers,
    521			    int nxfers);
    522
    523int i3c_master_disec_locked(struct i3c_master_controller *master, u8 addr,
    524			    u8 evts);
    525int i3c_master_enec_locked(struct i3c_master_controller *master, u8 addr,
    526			   u8 evts);
    527int i3c_master_entdaa_locked(struct i3c_master_controller *master);
    528int i3c_master_defslvs_locked(struct i3c_master_controller *master);
    529
    530int i3c_master_get_free_addr(struct i3c_master_controller *master,
    531			     u8 start_addr);
    532
    533int i3c_master_add_i3c_dev_locked(struct i3c_master_controller *master,
    534				  u8 addr);
    535int i3c_master_do_daa(struct i3c_master_controller *master);
    536
    537int i3c_master_set_info(struct i3c_master_controller *master,
    538			const struct i3c_device_info *info);
    539
    540int i3c_master_register(struct i3c_master_controller *master,
    541			struct device *parent,
    542			const struct i3c_master_controller_ops *ops,
    543			bool secondary);
    544int i3c_master_unregister(struct i3c_master_controller *master);
    545
    546/**
    547 * i3c_dev_get_master_data() - get master private data attached to an I3C
    548 *			       device descriptor
    549 * @dev: the I3C device descriptor to get private data from
    550 *
    551 * Return: the private data previously attached with i3c_dev_set_master_data()
    552 *	   or NULL if no data has been attached to the device.
    553 */
    554static inline void *i3c_dev_get_master_data(const struct i3c_dev_desc *dev)
    555{
    556	return dev->common.master_priv;
    557}
    558
    559/**
    560 * i3c_dev_set_master_data() - attach master private data to an I3C device
    561 *			       descriptor
    562 * @dev: the I3C device descriptor to attach private data to
    563 * @data: private data
    564 *
    565 * This functions allows a master controller to attach per-device private data
    566 * which can then be retrieved with i3c_dev_get_master_data().
    567 */
    568static inline void i3c_dev_set_master_data(struct i3c_dev_desc *dev,
    569					   void *data)
    570{
    571	dev->common.master_priv = data;
    572}
    573
    574/**
    575 * i2c_dev_get_master_data() - get master private data attached to an I2C
    576 *			       device descriptor
    577 * @dev: the I2C device descriptor to get private data from
    578 *
    579 * Return: the private data previously attached with i2c_dev_set_master_data()
    580 *	   or NULL if no data has been attached to the device.
    581 */
    582static inline void *i2c_dev_get_master_data(const struct i2c_dev_desc *dev)
    583{
    584	return dev->common.master_priv;
    585}
    586
    587/**
    588 * i2c_dev_set_master_data() - attach master private data to an I2C device
    589 *			       descriptor
    590 * @dev: the I2C device descriptor to attach private data to
    591 * @data: private data
    592 *
    593 * This functions allows a master controller to attach per-device private data
    594 * which can then be retrieved with i2c_device_get_master_data().
    595 */
    596static inline void i2c_dev_set_master_data(struct i2c_dev_desc *dev,
    597					   void *data)
    598{
    599	dev->common.master_priv = data;
    600}
    601
    602/**
    603 * i3c_dev_get_master() - get master used to communicate with a device
    604 * @dev: I3C dev
    605 *
    606 * Return: the master controller driving @dev
    607 */
    608static inline struct i3c_master_controller *
    609i3c_dev_get_master(struct i3c_dev_desc *dev)
    610{
    611	return dev->common.master;
    612}
    613
    614/**
    615 * i2c_dev_get_master() - get master used to communicate with a device
    616 * @dev: I2C dev
    617 *
    618 * Return: the master controller driving @dev
    619 */
    620static inline struct i3c_master_controller *
    621i2c_dev_get_master(struct i2c_dev_desc *dev)
    622{
    623	return dev->common.master;
    624}
    625
    626/**
    627 * i3c_master_get_bus() - get the bus attached to a master
    628 * @master: master object
    629 *
    630 * Return: the I3C bus @master is connected to
    631 */
    632static inline struct i3c_bus *
    633i3c_master_get_bus(struct i3c_master_controller *master)
    634{
    635	return &master->bus;
    636}
    637
    638struct i3c_generic_ibi_pool;
    639
    640struct i3c_generic_ibi_pool *
    641i3c_generic_ibi_alloc_pool(struct i3c_dev_desc *dev,
    642			   const struct i3c_ibi_setup *req);
    643void i3c_generic_ibi_free_pool(struct i3c_generic_ibi_pool *pool);
    644
    645struct i3c_ibi_slot *
    646i3c_generic_ibi_get_free_slot(struct i3c_generic_ibi_pool *pool);
    647void i3c_generic_ibi_recycle_slot(struct i3c_generic_ibi_pool *pool,
    648				  struct i3c_ibi_slot *slot);
    649
    650void i3c_master_queue_ibi(struct i3c_dev_desc *dev, struct i3c_ibi_slot *slot);
    651
    652struct i3c_ibi_slot *i3c_master_get_free_ibi_slot(struct i3c_dev_desc *dev);
    653
    654#endif /* I3C_MASTER_H */