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 #include <linux/atomic.h> 9 #include <linux/bug.h> 10 #include <linux/completion.h> 11 #include <linux/device.h> 12 #include <linux/mutex.h> 13 #include <linux/slab.h> 14 15 #include "internals.h" 16 17 /** 18 * i3c_device_do_xfers() - do I3C transfers directed to a specific device 19 * 20 * @dev: device with which the transfers should be done 21 * @xfers: array of transfers 22 * @nxfers: number of transfers 23 * @mode: transfer mode 24 * 25 * Initiate one or several private SDR transfers with @dev. 26 * 27 * This function can sleep and thus cannot be called in atomic context. 28 * 29 * Return: 30 * * 0 in case of success, a negative error core otherwise. 31 * * -EAGAIN: controller lost address arbitration. Target (IBI, HJ or 32 * controller role request) win the bus. Client driver needs to resend the 33 * 'xfers' some time later. See I3C spec ver 1.1.1 09-Jun-2021. Section: 34 * 5.1.2.2.3. 35 */ 36 int i3c_device_do_xfers(struct i3c_device *dev, struct i3c_xfer *xfers, 37 int nxfers, enum i3c_xfer_mode mode) 38 { 39 int ret, i; 40 41 if (nxfers < 1) 42 return 0; 43 44 for (i = 0; i < nxfers; i++) { 45 if (!xfers[i].len || !xfers[i].data.in) 46 return -EINVAL; 47 } 48 49 i3c_bus_normaluse_lock(dev->bus); 50 ret = i3c_dev_do_xfers_locked(dev->desc, xfers, nxfers, mode); 51 i3c_bus_normaluse_unlock(dev->bus); 52 53 return ret; 54 } 55 EXPORT_SYMBOL_GPL(i3c_device_do_xfers); 56 57 /** 58 * i3c_device_do_setdasa() - do I3C dynamic address assignement with 59 * static address 60 * 61 * @dev: device with which the DAA should be done 62 * 63 * Return: 0 in case of success, a negative error core otherwise. 64 */ 65 int i3c_device_do_setdasa(struct i3c_device *dev) 66 { 67 int ret; 68 69 i3c_bus_normaluse_lock(dev->bus); 70 ret = i3c_dev_setdasa_locked(dev->desc); 71 i3c_bus_normaluse_unlock(dev->bus); 72 73 return ret; 74 } 75 EXPORT_SYMBOL_GPL(i3c_device_do_setdasa); 76 77 /** 78 * i3c_device_get_info() - get I3C device information 79 * 80 * @dev: device we want information on 81 * @info: the information object to fill in 82 * 83 * Retrieve I3C dev info. 84 */ 85 void i3c_device_get_info(const struct i3c_device *dev, 86 struct i3c_device_info *info) 87 { 88 if (!info) 89 return; 90 91 i3c_bus_normaluse_lock(dev->bus); 92 if (dev->desc) 93 *info = dev->desc->info; 94 i3c_bus_normaluse_unlock(dev->bus); 95 } 96 EXPORT_SYMBOL_GPL(i3c_device_get_info); 97 98 /** 99 * i3c_device_disable_ibi() - Disable IBIs coming from a specific device 100 * @dev: device on which IBIs should be disabled 101 * 102 * This function disable IBIs coming from a specific device and wait for 103 * all pending IBIs to be processed. 104 * 105 * Return: 0 in case of success, a negative error core otherwise. 106 */ 107 int i3c_device_disable_ibi(struct i3c_device *dev) 108 { 109 int ret = -ENOENT; 110 111 i3c_bus_normaluse_lock(dev->bus); 112 if (dev->desc) { 113 mutex_lock(&dev->desc->ibi_lock); 114 ret = i3c_dev_disable_ibi_locked(dev->desc); 115 mutex_unlock(&dev->desc->ibi_lock); 116 } 117 i3c_bus_normaluse_unlock(dev->bus); 118 119 return ret; 120 } 121 EXPORT_SYMBOL_GPL(i3c_device_disable_ibi); 122 123 /** 124 * i3c_device_enable_ibi() - Enable IBIs coming from a specific device 125 * @dev: device on which IBIs should be enabled 126 * 127 * This function enable IBIs coming from a specific device and wait for 128 * all pending IBIs to be processed. This should be called on a device 129 * where i3c_device_request_ibi() has succeeded. 130 * 131 * Note that IBIs from this device might be received before this function 132 * returns to its caller. 133 * 134 * Return: 0 in case of success, a negative error core otherwise. 135 */ 136 int i3c_device_enable_ibi(struct i3c_device *dev) 137 { 138 int ret = -ENOENT; 139 140 i3c_bus_normaluse_lock(dev->bus); 141 if (dev->desc) { 142 mutex_lock(&dev->desc->ibi_lock); 143 ret = i3c_dev_enable_ibi_locked(dev->desc); 144 mutex_unlock(&dev->desc->ibi_lock); 145 } 146 i3c_bus_normaluse_unlock(dev->bus); 147 148 return ret; 149 } 150 EXPORT_SYMBOL_GPL(i3c_device_enable_ibi); 151 152 /** 153 * i3c_device_request_ibi() - Request an IBI 154 * @dev: device for which we should enable IBIs 155 * @req: setup requested for this IBI 156 * 157 * This function is responsible for pre-allocating all resources needed to 158 * process IBIs coming from @dev. When this function returns, the IBI is not 159 * enabled until i3c_device_enable_ibi() is called. 160 * 161 * Return: 0 in case of success, a negative error core otherwise. 162 */ 163 int i3c_device_request_ibi(struct i3c_device *dev, 164 const struct i3c_ibi_setup *req) 165 { 166 int ret = -ENOENT; 167 168 if (!req->handler || !req->num_slots) 169 return -EINVAL; 170 171 i3c_bus_normaluse_lock(dev->bus); 172 if (dev->desc) { 173 mutex_lock(&dev->desc->ibi_lock); 174 ret = i3c_dev_request_ibi_locked(dev->desc, req); 175 mutex_unlock(&dev->desc->ibi_lock); 176 } 177 i3c_bus_normaluse_unlock(dev->bus); 178 179 return ret; 180 } 181 EXPORT_SYMBOL_GPL(i3c_device_request_ibi); 182 183 /** 184 * i3c_device_free_ibi() - Free all resources needed for IBI handling 185 * @dev: device on which you want to release IBI resources 186 * 187 * This function is responsible for de-allocating resources previously 188 * allocated by i3c_device_request_ibi(). It should be called after disabling 189 * IBIs with i3c_device_disable_ibi(). 190 */ 191 void i3c_device_free_ibi(struct i3c_device *dev) 192 { 193 i3c_bus_normaluse_lock(dev->bus); 194 if (dev->desc) { 195 mutex_lock(&dev->desc->ibi_lock); 196 i3c_dev_free_ibi_locked(dev->desc); 197 mutex_unlock(&dev->desc->ibi_lock); 198 } 199 i3c_bus_normaluse_unlock(dev->bus); 200 } 201 EXPORT_SYMBOL_GPL(i3c_device_free_ibi); 202 203 /** 204 * i3cdev_to_dev() - Returns the device embedded in @i3cdev 205 * @i3cdev: I3C device 206 * 207 * Return: a pointer to a device object. 208 */ 209 struct device *i3cdev_to_dev(struct i3c_device *i3cdev) 210 { 211 return &i3cdev->dev; 212 } 213 EXPORT_SYMBOL_GPL(i3cdev_to_dev); 214 215 /** 216 * i3c_device_match_id() - Returns the i3c_device_id entry matching @i3cdev 217 * @i3cdev: I3C device 218 * @id_table: I3C device match table 219 * 220 * Return: a pointer to an i3c_device_id object or NULL if there's no match. 221 */ 222 const struct i3c_device_id * 223 i3c_device_match_id(struct i3c_device *i3cdev, 224 const struct i3c_device_id *id_table) 225 { 226 struct i3c_device_info devinfo; 227 const struct i3c_device_id *id; 228 u16 manuf, part, ext_info; 229 bool rndpid; 230 231 i3c_device_get_info(i3cdev, &devinfo); 232 233 manuf = I3C_PID_MANUF_ID(devinfo.pid); 234 part = I3C_PID_PART_ID(devinfo.pid); 235 ext_info = I3C_PID_EXTRA_INFO(devinfo.pid); 236 rndpid = I3C_PID_RND_LOWER_32BITS(devinfo.pid); 237 238 for (id = id_table; id->match_flags != 0; id++) { 239 if ((id->match_flags & I3C_MATCH_DCR) && 240 id->dcr != devinfo.dcr) 241 continue; 242 243 if ((id->match_flags & I3C_MATCH_MANUF) && 244 id->manuf_id != manuf) 245 continue; 246 247 if ((id->match_flags & I3C_MATCH_PART) && 248 (rndpid || id->part_id != part)) 249 continue; 250 251 if ((id->match_flags & I3C_MATCH_EXTRA_INFO) && 252 (rndpid || id->extra_info != ext_info)) 253 continue; 254 255 return id; 256 } 257 258 return NULL; 259 } 260 EXPORT_SYMBOL_GPL(i3c_device_match_id); 261 262 /** 263 * i3c_device_get_supported_xfer_mode - Returns the supported transfer mode by 264 * connected master controller. 265 * @dev: I3C device 266 * 267 * Return: a bit mask, which supported transfer mode, bit position is defined at 268 * enum i3c_hdr_mode 269 */ 270 u32 i3c_device_get_supported_xfer_mode(struct i3c_device *dev) 271 { 272 return i3c_dev_get_master(dev->desc)->this->info.hdr_cap | BIT(I3C_SDR); 273 } 274 EXPORT_SYMBOL_GPL(i3c_device_get_supported_xfer_mode); 275 276 /** 277 * i3c_driver_register_with_owner() - register an I3C device driver 278 * 279 * @drv: driver to register 280 * @owner: module that owns this driver 281 * 282 * Register @drv to the core. 283 * 284 * Return: 0 in case of success, a negative error core otherwise. 285 */ 286 int i3c_driver_register_with_owner(struct i3c_driver *drv, struct module *owner) 287 { 288 drv->driver.owner = owner; 289 drv->driver.bus = &i3c_bus_type; 290 291 if (!drv->probe) { 292 pr_err("Trying to register an i3c driver without probe callback\n"); 293 return -EINVAL; 294 } 295 296 return driver_register(&drv->driver); 297 } 298 EXPORT_SYMBOL_GPL(i3c_driver_register_with_owner); 299 300 /** 301 * i3c_driver_unregister() - unregister an I3C device driver 302 * 303 * @drv: driver to unregister 304 * 305 * Unregister @drv. 306 */ 307 void i3c_driver_unregister(struct i3c_driver *drv) 308 { 309 driver_unregister(&drv->driver); 310 } 311 EXPORT_SYMBOL_GPL(i3c_driver_unregister); 312