Based on kernel version 4.16.1. Page generated on 2018-04-09 11:53 EST.
1 This is a small guide for those who want to write kernel drivers for I2C 2 or SMBus devices, using Linux as the protocol host/master (not slave). 3 4 To set up a driver, you need to do several things. Some are optional, and 5 some things can be done slightly or completely different. Use this as a 6 guide, not as a rule book! 7 8 9 General remarks 10 =============== 11 12 Try to keep the kernel namespace as clean as possible. The best way to 13 do this is to use a unique prefix for all global symbols. This is 14 especially important for exported symbols, but it is a good idea to do 15 it for non-exported symbols too. We will use the prefix `foo_' in this 16 tutorial. 17 18 19 The driver structure 20 ==================== 21 22 Usually, you will implement a single driver structure, and instantiate 23 all clients from it. Remember, a driver structure contains general access 24 routines, and should be zero-initialized except for fields with data you 25 provide. A client structure holds device-specific information like the 26 driver model device node, and its I2C address. 27 28 static struct i2c_device_id foo_idtable[] = { 29 { "foo", my_id_for_foo }, 30 { "bar", my_id_for_bar }, 31 { } 32 }; 33 34 MODULE_DEVICE_TABLE(i2c, foo_idtable); 35 36 static struct i2c_driver foo_driver = { 37 .driver = { 38 .name = "foo", 39 .pm = &foo_pm_ops, /* optional */ 40 }, 41 42 .id_table = foo_idtable, 43 .probe = foo_probe, 44 .remove = foo_remove, 45 /* if device autodetection is needed: */ 46 .class = I2C_CLASS_SOMETHING, 47 .detect = foo_detect, 48 .address_list = normal_i2c, 49 50 .shutdown = foo_shutdown, /* optional */ 51 .command = foo_command, /* optional, deprecated */ 52 } 53 54 The name field is the driver name, and must not contain spaces. It 55 should match the module name (if the driver can be compiled as a module), 56 although you can use MODULE_ALIAS (passing "foo" in this example) to add 57 another name for the module. If the driver name doesn't match the module 58 name, the module won't be automatically loaded (hotplug/coldplug). 59 60 All other fields are for call-back functions which will be explained 61 below. 62 63 64 Extra client data 65 ================= 66 67 Each client structure has a special `data' field that can point to any 68 structure at all. You should use this to keep device-specific data. 69 70 /* store the value */ 71 void i2c_set_clientdata(struct i2c_client *client, void *data); 72 73 /* retrieve the value */ 74 void *i2c_get_clientdata(const struct i2c_client *client); 75 76 Note that starting with kernel 2.6.34, you don't have to set the `data' field 77 to NULL in remove() or if probe() failed anymore. The i2c-core does this 78 automatically on these occasions. Those are also the only times the core will 79 touch this field. 80 81 82 Accessing the client 83 ==================== 84 85 Let's say we have a valid client structure. At some time, we will need 86 to gather information from the client, or write new information to the 87 client. 88 89 I have found it useful to define foo_read and foo_write functions for this. 90 For some cases, it will be easier to call the i2c functions directly, 91 but many chips have some kind of register-value idea that can easily 92 be encapsulated. 93 94 The below functions are simple examples, and should not be copied 95 literally. 96 97 int foo_read_value(struct i2c_client *client, u8 reg) 98 { 99 if (reg < 0x10) /* byte-sized register */ 100 return i2c_smbus_read_byte_data(client, reg); 101 else /* word-sized register */ 102 return i2c_smbus_read_word_data(client, reg); 103 } 104 105 int foo_write_value(struct i2c_client *client, u8 reg, u16 value) 106 { 107 if (reg == 0x10) /* Impossible to write - driver error! */ 108 return -EINVAL; 109 else if (reg < 0x10) /* byte-sized register */ 110 return i2c_smbus_write_byte_data(client, reg, value); 111 else /* word-sized register */ 112 return i2c_smbus_write_word_data(client, reg, value); 113 } 114 115 116 Probing and attaching 117 ===================== 118 119 The Linux I2C stack was originally written to support access to hardware 120 monitoring chips on PC motherboards, and thus used to embed some assumptions 121 that were more appropriate to SMBus (and PCs) than to I2C. One of these 122 assumptions was that most adapters and devices drivers support the SMBUS_QUICK 123 protocol to probe device presence. Another was that devices and their drivers 124 can be sufficiently configured using only such probe primitives. 125 126 As Linux and its I2C stack became more widely used in embedded systems 127 and complex components such as DVB adapters, those assumptions became more 128 problematic. Drivers for I2C devices that issue interrupts need more (and 129 different) configuration information, as do drivers handling chip variants 130 that can't be distinguished by protocol probing, or which need some board 131 specific information to operate correctly. 132 133 134 Device/Driver Binding 135 --------------------- 136 137 System infrastructure, typically board-specific initialization code or 138 boot firmware, reports what I2C devices exist. For example, there may be 139 a table, in the kernel or from the boot loader, identifying I2C devices 140 and linking them to board-specific configuration information about IRQs 141 and other wiring artifacts, chip type, and so on. That could be used to 142 create i2c_client objects for each I2C device. 143 144 I2C device drivers using this binding model work just like any other 145 kind of driver in Linux: they provide a probe() method to bind to 146 those devices, and a remove() method to unbind. 147 148 static int foo_probe(struct i2c_client *client, 149 const struct i2c_device_id *id); 150 static int foo_remove(struct i2c_client *client); 151 152 Remember that the i2c_driver does not create those client handles. The 153 handle may be used during foo_probe(). If foo_probe() reports success 154 (zero not a negative status code) it may save the handle and use it until 155 foo_remove() returns. That binding model is used by most Linux drivers. 156 157 The probe function is called when an entry in the id_table name field 158 matches the device's name. It is passed the entry that was matched so 159 the driver knows which one in the table matched. 160 161 162 Device Creation 163 --------------- 164 165 If you know for a fact that an I2C device is connected to a given I2C bus, 166 you can instantiate that device by simply filling an i2c_board_info 167 structure with the device address and driver name, and calling 168 i2c_new_device(). This will create the device, then the driver core will 169 take care of finding the right driver and will call its probe() method. 170 If a driver supports different device types, you can specify the type you 171 want using the type field. You can also specify an IRQ and platform data 172 if needed. 173 174 Sometimes you know that a device is connected to a given I2C bus, but you 175 don't know the exact address it uses. This happens on TV adapters for 176 example, where the same driver supports dozens of slightly different 177 models, and I2C device addresses change from one model to the next. In 178 that case, you can use the i2c_new_probed_device() variant, which is 179 similar to i2c_new_device(), except that it takes an additional list of 180 possible I2C addresses to probe. A device is created for the first 181 responsive address in the list. If you expect more than one device to be 182 present in the address range, simply call i2c_new_probed_device() that 183 many times. 184 185 The call to i2c_new_device() or i2c_new_probed_device() typically happens 186 in the I2C bus driver. You may want to save the returned i2c_client 187 reference for later use. 188 189 190 Device Detection 191 ---------------- 192 193 Sometimes you do not know in advance which I2C devices are connected to 194 a given I2C bus. This is for example the case of hardware monitoring 195 devices on a PC's SMBus. In that case, you may want to let your driver 196 detect supported devices automatically. This is how the legacy model 197 was working, and is now available as an extension to the standard 198 driver model. 199 200 You simply have to define a detect callback which will attempt to 201 identify supported devices (returning 0 for supported ones and -ENODEV 202 for unsupported ones), a list of addresses to probe, and a device type 203 (or class) so that only I2C buses which may have that type of device 204 connected (and not otherwise enumerated) will be probed. For example, 205 a driver for a hardware monitoring chip for which auto-detection is 206 needed would set its class to I2C_CLASS_HWMON, and only I2C adapters 207 with a class including I2C_CLASS_HWMON would be probed by this driver. 208 Note that the absence of matching classes does not prevent the use of 209 a device of that type on the given I2C adapter. All it prevents is 210 auto-detection; explicit instantiation of devices is still possible. 211 212 Note that this mechanism is purely optional and not suitable for all 213 devices. You need some reliable way to identify the supported devices 214 (typically using device-specific, dedicated identification registers), 215 otherwise misdetections are likely to occur and things can get wrong 216 quickly. Keep in mind that the I2C protocol doesn't include any 217 standard way to detect the presence of a chip at a given address, let 218 alone a standard way to identify devices. Even worse is the lack of 219 semantics associated to bus transfers, which means that the same 220 transfer can be seen as a read operation by a chip and as a write 221 operation by another chip. For these reasons, explicit device 222 instantiation should always be preferred to auto-detection where 223 possible. 224 225 226 Device Deletion 227 --------------- 228 229 Each I2C device which has been created using i2c_new_device() or 230 i2c_new_probed_device() can be unregistered by calling 231 i2c_unregister_device(). If you don't call it explicitly, it will be 232 called automatically before the underlying I2C bus itself is removed, as a 233 device can't survive its parent in the device driver model. 234 235 236 Initializing the driver 237 ======================= 238 239 When the kernel is booted, or when your foo driver module is inserted, 240 you have to do some initializing. Fortunately, just registering the 241 driver module is usually enough. 242 243 static int __init foo_init(void) 244 { 245 return i2c_add_driver(&foo_driver); 246 } 247 module_init(foo_init); 248 249 static void __exit foo_cleanup(void) 250 { 251 i2c_del_driver(&foo_driver); 252 } 253 module_exit(foo_cleanup); 254 255 The module_i2c_driver() macro can be used to reduce above code. 256 257 module_i2c_driver(foo_driver); 258 259 Note that some functions are marked by `__init'. These functions can 260 be removed after kernel booting (or module loading) is completed. 261 Likewise, functions marked by `__exit' are dropped by the compiler when 262 the code is built into the kernel, as they would never be called. 263 264 265 Driver Information 266 ================== 267 268 /* Substitute your own name and email address */ 269 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>" 270 MODULE_DESCRIPTION("Driver for Barf Inc. Foo I2C devices"); 271 272 /* a few non-GPL license types are also allowed */ 273 MODULE_LICENSE("GPL"); 274 275 276 Power Management 277 ================ 278 279 If your I2C device needs special handling when entering a system low 280 power state -- like putting a transceiver into a low power mode, or 281 activating a system wakeup mechanism -- do that by implementing the 282 appropriate callbacks for the dev_pm_ops of the driver (like suspend 283 and resume). 284 285 These are standard driver model calls, and they work just like they 286 would for any other driver stack. The calls can sleep, and can use 287 I2C messaging to the device being suspended or resumed (since their 288 parent I2C adapter is active when these calls are issued, and IRQs 289 are still enabled). 290 291 292 System Shutdown 293 =============== 294 295 If your I2C device needs special handling when the system shuts down 296 or reboots (including kexec) -- like turning something off -- use a 297 shutdown() method. 298 299 Again, this is a standard driver model call, working just like it 300 would for any other driver stack: the calls can sleep, and can use 301 I2C messaging. 302 303 304 Command function 305 ================ 306 307 A generic ioctl-like function call back is supported. You will seldom 308 need this, and its use is deprecated anyway, so newer design should not 309 use it. 310 311 312 Sending and receiving 313 ===================== 314 315 If you want to communicate with your device, there are several functions 316 to do this. You can find all of them in <linux/i2c.h>. 317 318 If you can choose between plain I2C communication and SMBus level 319 communication, please use the latter. All adapters understand SMBus level 320 commands, but only some of them understand plain I2C! 321 322 323 Plain I2C communication 324 ----------------------- 325 326 int i2c_master_send(struct i2c_client *client, const char *buf, 327 int count); 328 int i2c_master_recv(struct i2c_client *client, char *buf, int count); 329 330 These routines read and write some bytes from/to a client. The client 331 contains the i2c address, so you do not have to include it. The second 332 parameter contains the bytes to read/write, the third the number of bytes 333 to read/write (must be less than the length of the buffer, also should be 334 less than 64k since msg.len is u16.) Returned is the actual number of bytes 335 read/written. 336 337 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msg, 338 int num); 339 340 This sends a series of messages. Each message can be a read or write, 341 and they can be mixed in any way. The transactions are combined: no 342 stop bit is sent between transaction. The i2c_msg structure contains 343 for each message the client address, the number of bytes of the message 344 and the message data itself. 345 346 You can read the file `i2c-protocol' for more information about the 347 actual I2C protocol. 348 349 350 SMBus communication 351 ------------------- 352 353 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, 354 unsigned short flags, char read_write, u8 command, 355 int size, union i2c_smbus_data *data); 356 357 This is the generic SMBus function. All functions below are implemented 358 in terms of it. Never use this function directly! 359 360 s32 i2c_smbus_read_byte(struct i2c_client *client); 361 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value); 362 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command); 363 s32 i2c_smbus_write_byte_data(struct i2c_client *client, 364 u8 command, u8 value); 365 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command); 366 s32 i2c_smbus_write_word_data(struct i2c_client *client, 367 u8 command, u16 value); 368 s32 i2c_smbus_read_block_data(struct i2c_client *client, 369 u8 command, u8 *values); 370 s32 i2c_smbus_write_block_data(struct i2c_client *client, 371 u8 command, u8 length, const u8 *values); 372 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, 373 u8 command, u8 length, u8 *values); 374 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, 375 u8 command, u8 length, 376 const u8 *values); 377 378 These ones were removed from i2c-core because they had no users, but could 379 be added back later if needed: 380 381 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value); 382 s32 i2c_smbus_process_call(struct i2c_client *client, 383 u8 command, u16 value); 384 s32 i2c_smbus_block_process_call(struct i2c_client *client, 385 u8 command, u8 length, u8 *values); 386 387 All these transactions return a negative errno value on failure. The 'write' 388 transactions return 0 on success; the 'read' transactions return the read 389 value, except for block transactions, which return the number of values 390 read. The block buffers need not be longer than 32 bytes. 391 392 You can read the file `smbus-protocol' for more information about the 393 actual SMBus protocol. 394 395 396 General purpose routines 397 ======================== 398 399 Below all general purpose routines are listed, that were not mentioned 400 before. 401 402 /* Return the adapter number for a specific adapter */ 403 int i2c_adapter_id(struct i2c_adapter *adap);