405 lines · plain
1===============================2Implementing I2C device drivers3===============================4 5This is a small guide for those who want to write kernel drivers for I2C6or SMBus devices, using Linux as the protocol host/master (not slave).7 8To set up a driver, you need to do several things. Some are optional, and9some things can be done slightly or completely different. Use this as a10guide, not as a rule book!11 12 13General remarks14===============15 16Try to keep the kernel namespace as clean as possible. The best way to17do this is to use a unique prefix for all global symbols. This is18especially important for exported symbols, but it is a good idea to do19it for non-exported symbols too. We will use the prefix ``foo_`` in this20tutorial.21 22 23The driver structure24====================25 26Usually, you will implement a single driver structure, and instantiate27all clients from it. Remember, a driver structure contains general access28routines, and should be zero-initialized except for fields with data you29provide. A client structure holds device-specific information like the30driver model device node, and its I2C address.31 32::33 34 static struct i2c_device_id foo_idtable[] = {35 { "foo", my_id_for_foo },36 { "bar", my_id_for_bar },37 { }38 };39 40 MODULE_DEVICE_TABLE(i2c, foo_idtable);41 42 static struct i2c_driver foo_driver = {43 .driver = {44 .name = "foo",45 .pm = &foo_pm_ops, /* optional */46 },47 48 .id_table = foo_idtable,49 .probe = foo_probe,50 .remove = foo_remove,51 52 .shutdown = foo_shutdown, /* optional */53 .command = foo_command, /* optional, deprecated */54 }55 56The name field is the driver name, and must not contain spaces. It57should match the module name (if the driver can be compiled as a module),58although you can use MODULE_ALIAS (passing "foo" in this example) to add59another name for the module. If the driver name doesn't match the module60name, the module won't be automatically loaded (hotplug/coldplug).61 62All other fields are for call-back functions which will be explained63below.64 65 66Extra client data67=================68 69Each client structure has a special ``data`` field that can point to any70structure at all. You should use this to keep device-specific data.71 72::73 74 /* store the value */75 void i2c_set_clientdata(struct i2c_client *client, void *data);76 77 /* retrieve the value */78 void *i2c_get_clientdata(const struct i2c_client *client);79 80Note that starting with kernel 2.6.34, you don't have to set the ``data`` field81to NULL in remove() or if probe() failed anymore. The i2c-core does this82automatically on these occasions. Those are also the only times the core will83touch this field.84 85 86Accessing the client87====================88 89Let's say we have a valid client structure. At some time, we will need90to gather information from the client, or write new information to the91client.92 93I have found it useful to define foo_read and foo_write functions for this.94For some cases, it will be easier to call the I2C functions directly,95but many chips have some kind of register-value idea that can easily96be encapsulated.97 98The below functions are simple examples, and should not be copied99literally::100 101 int foo_read_value(struct i2c_client *client, u8 reg)102 {103 if (reg < 0x10) /* byte-sized register */104 return i2c_smbus_read_byte_data(client, reg);105 else /* word-sized register */106 return i2c_smbus_read_word_data(client, reg);107 }108 109 int foo_write_value(struct i2c_client *client, u8 reg, u16 value)110 {111 if (reg == 0x10) /* Impossible to write - driver error! */112 return -EINVAL;113 else if (reg < 0x10) /* byte-sized register */114 return i2c_smbus_write_byte_data(client, reg, value);115 else /* word-sized register */116 return i2c_smbus_write_word_data(client, reg, value);117 }118 119 120Probing and attaching121=====================122 123The Linux I2C stack was originally written to support access to hardware124monitoring chips on PC motherboards, and thus used to embed some assumptions125that were more appropriate to SMBus (and PCs) than to I2C. One of these126assumptions was that most adapters and devices drivers support the SMBUS_QUICK127protocol to probe device presence. Another was that devices and their drivers128can be sufficiently configured using only such probe primitives.129 130As Linux and its I2C stack became more widely used in embedded systems131and complex components such as DVB adapters, those assumptions became more132problematic. Drivers for I2C devices that issue interrupts need more (and133different) configuration information, as do drivers handling chip variants134that can't be distinguished by protocol probing, or which need some board135specific information to operate correctly.136 137 138Device/Driver Binding139---------------------140 141System infrastructure, typically board-specific initialization code or142boot firmware, reports what I2C devices exist. For example, there may be143a table, in the kernel or from the boot loader, identifying I2C devices144and linking them to board-specific configuration information about IRQs145and other wiring artifacts, chip type, and so on. That could be used to146create i2c_client objects for each I2C device.147 148I2C device drivers using this binding model work just like any other149kind of driver in Linux: they provide a probe() method to bind to150those devices, and a remove() method to unbind.151 152::153 154 static int foo_probe(struct i2c_client *client);155 static void foo_remove(struct i2c_client *client);156 157Remember that the i2c_driver does not create those client handles. The158handle may be used during foo_probe(). If foo_probe() reports success159(zero not a negative status code) it may save the handle and use it until160foo_remove() returns. That binding model is used by most Linux drivers.161 162The probe function is called when an entry in the id_table name field163matches the device's name. If the probe function needs that entry, it164can retrieve it using165 166::167 168 const struct i2c_device_id *id = i2c_match_id(foo_idtable, client);169 170 171Device Creation172---------------173 174If you know for a fact that an I2C device is connected to a given I2C bus,175you can instantiate that device by simply filling an i2c_board_info176structure with the device address and driver name, and calling177i2c_new_client_device(). This will create the device, then the driver core178will take care of finding the right driver and will call its probe() method.179If a driver supports different device types, you can specify the type you180want using the type field. You can also specify an IRQ and platform data181if needed.182 183Sometimes you know that a device is connected to a given I2C bus, but you184don't know the exact address it uses. This happens on TV adapters for185example, where the same driver supports dozens of slightly different186models, and I2C device addresses change from one model to the next. In187that case, you can use the i2c_new_scanned_device() variant, which is188similar to i2c_new_client_device(), except that it takes an additional list189of possible I2C addresses to probe. A device is created for the first190responsive address in the list. If you expect more than one device to be191present in the address range, simply call i2c_new_scanned_device() that192many times.193 194The call to i2c_new_client_device() or i2c_new_scanned_device() typically195happens in the I2C bus driver. You may want to save the returned i2c_client196reference for later use.197 198 199Device Detection200----------------201 202The device detection mechanism comes with a number of disadvantages.203You need some reliable way to identify the supported devices204(typically using device-specific, dedicated identification registers),205otherwise misdetections are likely to occur and things can get wrong206quickly. Keep in mind that the I2C protocol doesn't include any207standard way to detect the presence of a chip at a given address, let208alone a standard way to identify devices. Even worse is the lack of209semantics associated to bus transfers, which means that the same210transfer can be seen as a read operation by a chip and as a write211operation by another chip. For these reasons, device detection is212considered a legacy mechanism and shouldn't be used in new code.213 214 215Device Deletion216---------------217 218Each I2C device which has been created using i2c_new_client_device()219or i2c_new_scanned_device() can be unregistered by calling220i2c_unregister_device(). If you don't call it explicitly, it will be221called automatically before the underlying I2C bus itself is removed,222as a device can't survive its parent in the device driver model.223 224 225Initializing the driver226=======================227 228When the kernel is booted, or when your foo driver module is inserted,229you have to do some initializing. Fortunately, just registering the230driver module is usually enough.231 232::233 234 static int __init foo_init(void)235 {236 return i2c_add_driver(&foo_driver);237 }238 module_init(foo_init);239 240 static void __exit foo_cleanup(void)241 {242 i2c_del_driver(&foo_driver);243 }244 module_exit(foo_cleanup);245 246 The module_i2c_driver() macro can be used to reduce above code.247 248 module_i2c_driver(foo_driver);249 250Note that some functions are marked by ``__init``. These functions can251be removed after kernel booting (or module loading) is completed.252Likewise, functions marked by ``__exit`` are dropped by the compiler when253the code is built into the kernel, as they would never be called.254 255 256Driver Information257==================258 259::260 261 /* Substitute your own name and email address */262 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"263 MODULE_DESCRIPTION("Driver for Barf Inc. Foo I2C devices");264 265 /* a few non-GPL license types are also allowed */266 MODULE_LICENSE("GPL");267 268 269Power Management270================271 272If your I2C device needs special handling when entering a system low273power state -- like putting a transceiver into a low power mode, or274activating a system wakeup mechanism -- do that by implementing the275appropriate callbacks for the dev_pm_ops of the driver (like suspend276and resume).277 278These are standard driver model calls, and they work just like they279would for any other driver stack. The calls can sleep, and can use280I2C messaging to the device being suspended or resumed (since their281parent I2C adapter is active when these calls are issued, and IRQs282are still enabled).283 284 285System Shutdown286===============287 288If your I2C device needs special handling when the system shuts down289or reboots (including kexec) -- like turning something off -- use a290shutdown() method.291 292Again, this is a standard driver model call, working just like it293would for any other driver stack: the calls can sleep, and can use294I2C messaging.295 296 297Command function298================299 300A generic ioctl-like function call back is supported. You will seldom301need this, and its use is deprecated anyway, so newer design should not302use it.303 304 305Sending and receiving306=====================307 308If you want to communicate with your device, there are several functions309to do this. You can find all of them in <linux/i2c.h>.310 311If you can choose between plain I2C communication and SMBus level312communication, please use the latter. All adapters understand SMBus level313commands, but only some of them understand plain I2C!314 315 316Plain I2C communication317-----------------------318 319::320 321 int i2c_master_send(struct i2c_client *client, const char *buf,322 int count);323 int i2c_master_recv(struct i2c_client *client, char *buf, int count);324 325These routines read and write some bytes from/to a client. The client326contains the I2C address, so you do not have to include it. The second327parameter contains the bytes to read/write, the third the number of bytes328to read/write (must be less than the length of the buffer, also should be329less than 64k since msg.len is u16.) Returned is the actual number of bytes330read/written.331 332::333 334 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msg,335 int num);336 337This sends a series of messages. Each message can be a read or write,338and they can be mixed in any way. The transactions are combined: no339stop condition is issued between transaction. The i2c_msg structure340contains for each message the client address, the number of bytes of the341message and the message data itself.342 343You can read the file i2c-protocol.rst for more information about the344actual I2C protocol.345 346 347SMBus communication348-------------------349 350::351 352 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,353 unsigned short flags, char read_write, u8 command,354 int size, union i2c_smbus_data *data);355 356This is the generic SMBus function. All functions below are implemented357in terms of it. Never use this function directly!358 359::360 361 s32 i2c_smbus_read_byte(struct i2c_client *client);362 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value);363 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command);364 s32 i2c_smbus_write_byte_data(struct i2c_client *client,365 u8 command, u8 value);366 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command);367 s32 i2c_smbus_write_word_data(struct i2c_client *client,368 u8 command, u16 value);369 s32 i2c_smbus_read_block_data(struct i2c_client *client,370 u8 command, u8 *values);371 s32 i2c_smbus_write_block_data(struct i2c_client *client,372 u8 command, u8 length, const u8 *values);373 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client,374 u8 command, u8 length, u8 *values);375 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client,376 u8 command, u8 length,377 const u8 *values);378 379These ones were removed from i2c-core because they had no users, but could380be added back later if needed::381 382 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value);383 s32 i2c_smbus_process_call(struct i2c_client *client,384 u8 command, u16 value);385 s32 i2c_smbus_block_process_call(struct i2c_client *client,386 u8 command, u8 length, u8 *values);387 388All these transactions return a negative errno value on failure. The 'write'389transactions return 0 on success; the 'read' transactions return the read390value, except for block transactions, which return the number of values391read. The block buffers need not be longer than 32 bytes.392 393You can read the file smbus-protocol.rst for more information about the394actual SMBus protocol.395 396 397General purpose routines398========================399 400Below all general purpose routines are listed, that were not mentioned401before::402 403 /* Return the adapter number for a specific adapter */404 int i2c_adapter_id(struct i2c_adapter *adap);405