Root/Documentation/i2c/writing-clients

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

Archive Download this file



interactive