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 */