blob: 3219ee0dbfef1eab9493253d6307acd7bb282019 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001This is a small guide for those who want to write kernel drivers for I2C
David Brownell4298cfc2007-05-01 23:26:31 +02002or SMBus devices, using Linux as the protocol host/master (not slave).
Linus Torvalds1da177e2005-04-16 15:20:36 -07003
4To set up a driver, you need to do several things. Some are optional, and
5some things can be done slightly or completely different. Use this as a
6guide, not as a rule book!
7
8
9General remarks
10===============
11
12Try to keep the kernel namespace as clean as possible. The best way to
Jean Delvare0e478582008-10-22 20:21:32 +020013do this is to use a unique prefix for all global symbols. This is
Linus Torvalds1da177e2005-04-16 15:20:36 -070014especially important for exported symbols, but it is a good idea to do
15it for non-exported symbols too. We will use the prefix `foo_' in this
Jean Delvare0e478582008-10-22 20:21:32 +020016tutorial.
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
18
19The driver structure
20====================
21
22Usually, you will implement a single driver structure, and instantiate
Jean Delvare0e478582008-10-22 20:21:32 +020023all clients from it. Remember, a driver structure contains general access
David Brownellf37dd802007-02-13 22:09:00 +010024routines, and should be zero-initialized except for fields with data you
25provide. A client structure holds device-specific information like the
26driver model device node, and its I2C address.
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
Ben Dooks2260e632008-07-01 22:38:18 +020028static struct i2c_device_id foo_idtable[] = {
29 { "foo", my_id_for_foo },
30 { "bar", my_id_for_bar },
31 { }
32};
33
34MODULE_DEVICE_TABLE(i2c, foo_idtable);
35
Linus Torvalds1da177e2005-04-16 15:20:36 -070036static struct i2c_driver foo_driver = {
Jean Delvared45d2042005-11-26 20:55:35 +010037 .driver = {
Jean Delvared45d2042005-11-26 20:55:35 +010038 .name = "foo",
39 },
David Brownell4298cfc2007-05-01 23:26:31 +020040
Ben Dooks2260e632008-07-01 22:38:18 +020041 .id_table = foo_ids,
David Brownell4298cfc2007-05-01 23:26:31 +020042 .probe = foo_probe,
43 .remove = foo_remove,
Jean Delvare4735c982008-07-14 22:38:36 +020044 /* if device autodetection is needed: */
45 .class = I2C_CLASS_SOMETHING,
46 .detect = foo_detect,
Jean Delvarec3813d62009-12-14 21:17:25 +010047 .address_list = normal_i2c,
David Brownell4298cfc2007-05-01 23:26:31 +020048
David Brownellf37dd802007-02-13 22:09:00 +010049 .shutdown = foo_shutdown, /* optional */
50 .suspend = foo_suspend, /* optional */
51 .resume = foo_resume, /* optional */
Jean Delvare0e478582008-10-22 20:21:32 +020052 .command = foo_command, /* optional, deprecated */
Linus Torvalds1da177e2005-04-16 15:20:36 -070053}
Jean Delvare0e478582008-10-22 20:21:32 +020054
David Brownellf37dd802007-02-13 22:09:00 +010055The name field is the driver name, and must not contain spaces. It
56should match the module name (if the driver can be compiled as a module),
57although you can use MODULE_ALIAS (passing "foo" in this example) to add
David Brownell4298cfc2007-05-01 23:26:31 +020058another name for the module. If the driver name doesn't match the module
59name, the module won't be automatically loaded (hotplug/coldplug).
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Jean Delvare0e478582008-10-22 20:21:32 +020061All other fields are for call-back functions which will be explained
Linus Torvalds1da177e2005-04-16 15:20:36 -070062below.
63
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
65Extra client data
66=================
67
David Brownellf37dd802007-02-13 22:09:00 +010068Each client structure has a special `data' field that can point to any
Jean Delvare0e478582008-10-22 20:21:32 +020069structure at all. You should use this to keep device-specific data.
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
David Brownellf37dd802007-02-13 22:09:00 +010071 /* store the value */
72 void i2c_set_clientdata(struct i2c_client *client, void *data);
73
74 /* retrieve the value */
Jean Delvare7d1d8992008-10-22 20:21:31 +020075 void *i2c_get_clientdata(const struct i2c_client *client);
David Brownellf37dd802007-02-13 22:09:00 +010076
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78Accessing the client
79====================
80
81Let's say we have a valid client structure. At some time, we will need
82to gather information from the client, or write new information to the
Jean Delvare0e478582008-10-22 20:21:32 +020083client.
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
Jean Delvare0e478582008-10-22 20:21:32 +020085I have found it useful to define foo_read and foo_write functions for this.
Linus Torvalds1da177e2005-04-16 15:20:36 -070086For some cases, it will be easier to call the i2c functions directly,
87but many chips have some kind of register-value idea that can easily
Jean Delvareeefcd752007-05-01 23:26:35 +020088be encapsulated.
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
90The below functions are simple examples, and should not be copied
91literally.
92
Jean Delvare0e478582008-10-22 20:21:32 +020093int foo_read_value(struct i2c_client *client, u8 reg)
94{
95 if (reg < 0x10) /* byte-sized register */
96 return i2c_smbus_read_byte_data(client, reg);
97 else /* word-sized register */
98 return i2c_smbus_read_word_data(client, reg);
99}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
Jean Delvare0e478582008-10-22 20:21:32 +0200101int foo_write_value(struct i2c_client *client, u8 reg, u16 value)
102{
103 if (reg == 0x10) /* Impossible to write - driver error! */
104 return -EINVAL;
105 else if (reg < 0x10) /* byte-sized register */
106 return i2c_smbus_write_byte_data(client, reg, value);
107 else /* word-sized register */
108 return i2c_smbus_write_word_data(client, reg, value);
109}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
112Probing and attaching
113=====================
114
David Brownell4298cfc2007-05-01 23:26:31 +0200115The Linux I2C stack was originally written to support access to hardware
Jean Delvaree3133532008-10-22 20:21:31 +0200116monitoring chips on PC motherboards, and thus used to embed some assumptions
117that were more appropriate to SMBus (and PCs) than to I2C. One of these
118assumptions was that most adapters and devices drivers support the SMBUS_QUICK
119protocol to probe device presence. Another was that devices and their drivers
David Brownell4298cfc2007-05-01 23:26:31 +0200120can be sufficiently configured using only such probe primitives.
121
122As Linux and its I2C stack became more widely used in embedded systems
123and complex components such as DVB adapters, those assumptions became more
124problematic. Drivers for I2C devices that issue interrupts need more (and
125different) configuration information, as do drivers handling chip variants
126that can't be distinguished by protocol probing, or which need some board
127specific information to operate correctly.
128
David Brownell4298cfc2007-05-01 23:26:31 +0200129
Jean Delvare729d6dd2009-06-19 16:58:18 +0200130Device/Driver Binding
131---------------------
David Brownell4298cfc2007-05-01 23:26:31 +0200132
133System infrastructure, typically board-specific initialization code or
134boot firmware, reports what I2C devices exist. For example, there may be
135a table, in the kernel or from the boot loader, identifying I2C devices
136and linking them to board-specific configuration information about IRQs
137and other wiring artifacts, chip type, and so on. That could be used to
138create i2c_client objects for each I2C device.
139
140I2C device drivers using this binding model work just like any other
141kind of driver in Linux: they provide a probe() method to bind to
142those devices, and a remove() method to unbind.
143
Jean Delvared2653e92008-04-29 23:11:39 +0200144 static int foo_probe(struct i2c_client *client,
145 const struct i2c_device_id *id);
David Brownell4298cfc2007-05-01 23:26:31 +0200146 static int foo_remove(struct i2c_client *client);
147
148Remember that the i2c_driver does not create those client handles. The
149handle may be used during foo_probe(). If foo_probe() reports success
150(zero not a negative status code) it may save the handle and use it until
151foo_remove() returns. That binding model is used by most Linux drivers.
152
Ben Dooks2260e632008-07-01 22:38:18 +0200153The probe function is called when an entry in the id_table name field
154matches the device's name. It is passed the entry that was matched so
155the driver knows which one in the table matched.
David Brownell4298cfc2007-05-01 23:26:31 +0200156
157
Jean Delvaree3133532008-10-22 20:21:31 +0200158Device Creation
159---------------
Jean Delvarece9e0792007-05-01 23:26:32 +0200160
161If you know for a fact that an I2C device is connected to a given I2C bus,
162you can instantiate that device by simply filling an i2c_board_info
163structure with the device address and driver name, and calling
164i2c_new_device(). This will create the device, then the driver core will
165take care of finding the right driver and will call its probe() method.
166If a driver supports different device types, you can specify the type you
167want using the type field. You can also specify an IRQ and platform data
168if needed.
169
170Sometimes you know that a device is connected to a given I2C bus, but you
171don't know the exact address it uses. This happens on TV adapters for
172example, where the same driver supports dozens of slightly different
173models, and I2C device addresses change from one model to the next. In
174that case, you can use the i2c_new_probed_device() variant, which is
175similar to i2c_new_device(), except that it takes an additional list of
176possible I2C addresses to probe. A device is created for the first
177responsive address in the list. If you expect more than one device to be
178present in the address range, simply call i2c_new_probed_device() that
179many times.
180
181The call to i2c_new_device() or i2c_new_probed_device() typically happens
182in the I2C bus driver. You may want to save the returned i2c_client
183reference for later use.
184
185
Jean Delvaree3133532008-10-22 20:21:31 +0200186Device Detection
187----------------
Jean Delvare4735c982008-07-14 22:38:36 +0200188
189Sometimes you do not know in advance which I2C devices are connected to
190a given I2C bus. This is for example the case of hardware monitoring
191devices on a PC's SMBus. In that case, you may want to let your driver
192detect supported devices automatically. This is how the legacy model
193was working, and is now available as an extension to the standard
Jean Delvare729d6dd2009-06-19 16:58:18 +0200194driver model.
Jean Delvare4735c982008-07-14 22:38:36 +0200195
196You simply have to define a detect callback which will attempt to
197identify supported devices (returning 0 for supported ones and -ENODEV
198for unsupported ones), a list of addresses to probe, and a device type
199(or class) so that only I2C buses which may have that type of device
Jean Delvare764c1692009-03-28 21:34:40 +0100200connected (and not otherwise enumerated) will be probed. For example,
201a driver for a hardware monitoring chip for which auto-detection is
202needed would set its class to I2C_CLASS_HWMON, and only I2C adapters
203with a class including I2C_CLASS_HWMON would be probed by this driver.
204Note that the absence of matching classes does not prevent the use of
205a device of that type on the given I2C adapter. All it prevents is
206auto-detection; explicit instantiation of devices is still possible.
Jean Delvare4735c982008-07-14 22:38:36 +0200207
208Note that this mechanism is purely optional and not suitable for all
209devices. You need some reliable way to identify the supported devices
210(typically using device-specific, dedicated identification registers),
211otherwise misdetections are likely to occur and things can get wrong
Jean Delvare764c1692009-03-28 21:34:40 +0100212quickly. Keep in mind that the I2C protocol doesn't include any
213standard way to detect the presence of a chip at a given address, let
214alone a standard way to identify devices. Even worse is the lack of
215semantics associated to bus transfers, which means that the same
216transfer can be seen as a read operation by a chip and as a write
217operation by another chip. For these reasons, explicit device
218instantiation should always be preferred to auto-detection where
219possible.
Jean Delvare4735c982008-07-14 22:38:36 +0200220
221
Jean Delvaree3133532008-10-22 20:21:31 +0200222Device Deletion
223---------------
Jean Delvarece9e0792007-05-01 23:26:32 +0200224
225Each I2C device which has been created using i2c_new_device() or
226i2c_new_probed_device() can be unregistered by calling
227i2c_unregister_device(). If you don't call it explicitly, it will be
228called automatically before the underlying I2C bus itself is removed, as a
229device can't survive its parent in the device driver model.
230
231
Jean Delvare0e478582008-10-22 20:21:32 +0200232Initializing the driver
233=======================
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234
Jean Delvare0e478582008-10-22 20:21:32 +0200235When the kernel is booted, or when your foo driver module is inserted,
236you have to do some initializing. Fortunately, just registering the
237driver module is usually enough.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
Jean Delvare0e478582008-10-22 20:21:32 +0200239static int __init foo_init(void)
240{
241 return i2c_add_driver(&foo_driver);
242}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
Jean Delvare0e478582008-10-22 20:21:32 +0200244static void __exit foo_cleanup(void)
245{
246 i2c_del_driver(&foo_driver);
247}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
Jean Delvare0e478582008-10-22 20:21:32 +0200249/* Substitute your own name and email address */
250MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"
251MODULE_DESCRIPTION("Driver for Barf Inc. Foo I2C devices");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
Jean Delvare0e478582008-10-22 20:21:32 +0200253/* a few non-GPL license types are also allowed */
254MODULE_LICENSE("GPL");
Jean Delvareeefcd752007-05-01 23:26:35 +0200255
Jean Delvare0e478582008-10-22 20:21:32 +0200256module_init(foo_init);
257module_exit(foo_cleanup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
Jean Delvare0e478582008-10-22 20:21:32 +0200259Note that some functions are marked by `__init'. These functions can
260be removed after kernel booting (or module loading) is completed.
261Likewise, functions marked by `__exit' are dropped by the compiler when
262the code is built into the kernel, as they would never be called.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
Jean Delvarefb687d72005-12-18 16:51:55 +0100264
David Brownellf37dd802007-02-13 22:09:00 +0100265Power Management
266================
267
268If your I2C device needs special handling when entering a system low
269power state -- like putting a transceiver into a low power mode, or
270activating a system wakeup mechanism -- do that in the suspend() method.
271The resume() method should reverse what the suspend() method does.
272
273These are standard driver model calls, and they work just like they
274would for any other driver stack. The calls can sleep, and can use
275I2C messaging to the device being suspended or resumed (since their
276parent I2C adapter is active when these calls are issued, and IRQs
277are still enabled).
278
279
280System Shutdown
281===============
282
283If your I2C device needs special handling when the system shuts down
284or reboots (including kexec) -- like turning something off -- use a
285shutdown() method.
286
287Again, this is a standard driver model call, working just like it
288would for any other driver stack: the calls can sleep, and can use
289I2C messaging.
290
291
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292Command function
293================
294
295A generic ioctl-like function call back is supported. You will seldom
Jean Delvarefb687d72005-12-18 16:51:55 +0100296need this, and its use is deprecated anyway, so newer design should not
Jean Delvare0e478582008-10-22 20:21:32 +0200297use it.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
299
300Sending and receiving
301=====================
302
303If you want to communicate with your device, there are several functions
Jean Delvare0e478582008-10-22 20:21:32 +0200304to do this. You can find all of them in <linux/i2c.h>.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
Jean Delvare0e478582008-10-22 20:21:32 +0200306If you can choose between plain I2C communication and SMBus level
307communication, please use the latter. All adapters understand SMBus level
308commands, but only some of them understand plain I2C!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309
310
Jean Delvare0e478582008-10-22 20:21:32 +0200311Plain I2C communication
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312-----------------------
313
Jean Delvare0e478582008-10-22 20:21:32 +0200314 int i2c_master_send(struct i2c_client *client, const char *buf,
315 int count);
316 int i2c_master_recv(struct i2c_client *client, char *buf, int count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
318These routines read and write some bytes from/to a client. The client
319contains the i2c address, so you do not have to include it. The second
Jean Delvare0e478582008-10-22 20:21:32 +0200320parameter contains the bytes to read/write, the third the number of bytes
Zhangfei Gao0c43ea52010-03-02 12:23:49 +0100321to read/write (must be less than the length of the buffer, also should be
322less than 64k since msg.len is u16.) Returned is the actual number of bytes
323read/written.
Jean Delvare0e478582008-10-22 20:21:32 +0200324
325 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msg,
326 int num);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
328This sends a series of messages. Each message can be a read or write,
329and they can be mixed in any way. The transactions are combined: no
330stop bit is sent between transaction. The i2c_msg structure contains
331for each message the client address, the number of bytes of the message
332and the message data itself.
333
334You can read the file `i2c-protocol' for more information about the
Jean Delvare0e478582008-10-22 20:21:32 +0200335actual I2C protocol.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
337
338SMBus communication
339-------------------
340
Jean Delvare0e478582008-10-22 20:21:32 +0200341 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
342 unsigned short flags, char read_write, u8 command,
343 int size, union i2c_smbus_data *data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
Jean Delvare0e478582008-10-22 20:21:32 +0200345This is the generic SMBus function. All functions below are implemented
346in terms of it. Never use this function directly!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
Jean Delvare0e478582008-10-22 20:21:32 +0200348 s32 i2c_smbus_read_byte(struct i2c_client *client);
349 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value);
350 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command);
351 s32 i2c_smbus_write_byte_data(struct i2c_client *client,
352 u8 command, u8 value);
353 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command);
354 s32 i2c_smbus_write_word_data(struct i2c_client *client,
355 u8 command, u16 value);
356 s32 i2c_smbus_process_call(struct i2c_client *client,
357 u8 command, u16 value);
358 s32 i2c_smbus_read_block_data(struct i2c_client *client,
359 u8 command, u8 *values);
360 s32 i2c_smbus_write_block_data(struct i2c_client *client,
361 u8 command, u8 length, const u8 *values);
362 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client,
363 u8 command, u8 length, u8 *values);
364 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client,
365 u8 command, u8 length,
366 const u8 *values);
Jean Delvare67c2e662008-07-14 22:38:23 +0200367
368These ones were removed from i2c-core because they had no users, but could
369be added back later if needed:
370
Jean Delvare0e478582008-10-22 20:21:32 +0200371 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value);
372 s32 i2c_smbus_block_process_call(struct i2c_client *client,
373 u8 command, u8 length, u8 *values);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
David Brownell24a5bb72008-07-14 22:38:23 +0200375All these transactions return a negative errno value on failure. The 'write'
376transactions return 0 on success; the 'read' transactions return the read
377value, except for block transactions, which return the number of values
378read. The block buffers need not be longer than 32 bytes.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
380You can read the file `smbus-protocol' for more information about the
381actual SMBus protocol.
382
383
384General purpose routines
385========================
386
387Below all general purpose routines are listed, that were not mentioned
388before.
389
Jean Delvare0e478582008-10-22 20:21:32 +0200390 /* Return the adapter number for a specific adapter */
391 int i2c_adapter_id(struct i2c_adapter *adap);