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