1 ===============================
2 Implementing I2C device drivers
3 ===============================
4
5 This is a small guide for those who want to wr
6 or SMBus devices, using Linux as the protocol
7
8 To set up a driver, you need to do several thi
9 some things can be done slightly or completely
10 guide, not as a rule book!
11
12
13 General remarks
14 ===============
15
16 Try to keep the kernel namespace as clean as p
17 do this is to use a unique prefix for all glob
18 especially important for exported symbols, but
19 it for non-exported symbols too. We will use t
20 tutorial.
21
22
23 The driver structure
24 ====================
25
26 Usually, you will implement a single driver st
27 all clients from it. Remember, a driver struct
28 routines, and should be zero-initialized excep
29 provide. A client structure holds device-spec
30 driver 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, /* opt
46 },
47
48 .id_table = foo_idtable,
49 .probe = foo_probe,
50 .remove = foo_remove,
51
52 .shutdown = foo_shutdown, /* opt
53 .command = foo_command, /* opt
54 }
55
56 The name field is the driver name, and must no
57 should match the module name (if the driver ca
58 although you can use MODULE_ALIAS (passing "fo
59 another name for the module. If the driver na
60 name, the module won't be automatically loaded
61
62 All other fields are for call-back functions w
63 below.
64
65
66 Extra client data
67 =================
68
69 Each client structure has a special ``data`` f
70 structure at all. You should use this to keep
71
72 ::
73
74 /* store the value */
75 void i2c_set_clientdata(struct i2c_cli
76
77 /* retrieve the value */
78 void *i2c_get_clientdata(const struct
79
80 Note that starting with kernel 2.6.34, you don
81 to NULL in remove() or if probe() failed anymo
82 automatically on these occasions. Those are al
83 touch this field.
84
85
86 Accessing the client
87 ====================
88
89 Let's say we have a valid client structure. At
90 to gather information from the client, or writ
91 client.
92
93 I have found it useful to define foo_read and
94 For some cases, it will be easier to call the
95 but many chips have some kind of register-valu
96 be encapsulated.
97
98 The below functions are simple examples, and s
99 literally::
100
101 int foo_read_value(struct i2c_client *client
102 {
103 if (reg < 0x10) /* byte-sized register
104 return i2c_smbus_read_byte_dat
105 else /* word-sized register
106 return i2c_smbus_read_word_dat
107 }
108
109 int foo_write_value(struct i2c_client *clien
110 {
111 if (reg == 0x10) /* Impossible
112 return -EINVAL;
113 else if (reg < 0x10) /* byte-sized
114 return i2c_smbus_write_byte_da
115 else /* word-sized
116 return i2c_smbus_write_word_da
117 }
118
119
120 Probing and attaching
121 =====================
122
123 The Linux I2C stack was originally written to
124 monitoring chips on PC motherboards, and thus
125 that were more appropriate to SMBus (and PCs)
126 assumptions was that most adapters and devices
127 protocol to probe device presence. Another wa
128 can be sufficiently configured using only such
129
130 As Linux and its I2C stack became more widely
131 and complex components such as DVB adapters, t
132 problematic. Drivers for I2C devices that iss
133 different) configuration information, as do dr
134 that can't be distinguished by protocol probin
135 specific information to operate correctly.
136
137
138 Device/Driver Binding
139 ---------------------
140
141 System infrastructure, typically board-specifi
142 boot firmware, reports what I2C devices exist.
143 a table, in the kernel or from the boot loader
144 and linking them to board-specific configurati
145 and other wiring artifacts, chip type, and so
146 create i2c_client objects for each I2C device.
147
148 I2C device drivers using this binding model wo
149 kind of driver in Linux: they provide a probe
150 those devices, and a remove() method to unbind
151
152 ::
153
154 static int foo_probe(struct i2c_client
155 static void foo_remove(struct i2c_clie
156
157 Remember that the i2c_driver does not create t
158 handle may be used during foo_probe(). If foo
159 (zero not a negative status code) it may save
160 foo_remove() returns. That binding model is u
161
162 The probe function is called when an entry in
163 matches the device's name. If the probe functi
164 can retrieve it using
165
166 ::
167
168 const struct i2c_device_id *id = i2c_m
169
170
171 Device Creation
172 ---------------
173
174 If you know for a fact that an I2C device is c
175 you can instantiate that device by simply fill
176 structure with the device address and driver n
177 i2c_new_client_device(). This will create the
178 will take care of finding the right driver and
179 If a driver supports different device types, y
180 want using the type field. You can also speci
181 if needed.
182
183 Sometimes you know that a device is connected
184 don't know the exact address it uses. This ha
185 example, where the same driver supports dozens
186 models, and I2C device addresses change from o
187 that case, you can use the i2c_new_scanned_dev
188 similar to i2c_new_client_device(), except tha
189 of possible I2C addresses to probe. A device
190 responsive address in the list. If you expect
191 present in the address range, simply call i2c_
192 many times.
193
194 The call to i2c_new_client_device() or i2c_new
195 happens in the I2C bus driver. You may want to
196 reference for later use.
197
198
199 Device Detection
200 ----------------
201
202 The device detection mechanism comes with a nu
203 You need some reliable way to identify the sup
204 (typically using device-specific, dedicated id
205 otherwise misdetections are likely to occur an
206 quickly. Keep in mind that the I2C protocol d
207 standard way to detect the presence of a chip
208 alone a standard way to identify devices. Eve
209 semantics associated to bus transfers, which m
210 transfer can be seen as a read operation by a
211 operation by another chip. For these reasons,
212 considered a legacy mechanism and shouldn't be
213
214
215 Device Deletion
216 ---------------
217
218 Each I2C device which has been created using i
219 or i2c_new_scanned_device() can be unregistere
220 i2c_unregister_device(). If you don't call it
221 called automatically before the underlying I2C
222 as a device can't survive its parent in the de
223
224
225 Initializing the driver
226 =======================
227
228 When the kernel is booted, or when your foo dr
229 you have to do some initializing. Fortunately,
230 driver 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
247
248 module_i2c_driver(foo_driver);
249
250 Note that some functions are marked by ``__ini
251 be removed after kernel booting (or module loa
252 Likewise, functions marked by ``__exit`` are d
253 the code is built into the kernel, as they wou
254
255
256 Driver Information
257 ==================
258
259 ::
260
261 /* Substitute your own name and email addres
262 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl
263 MODULE_DESCRIPTION("Driver for Barf Inc. Foo
264
265 /* a few non-GPL license types are also allo
266 MODULE_LICENSE("GPL");
267
268
269 Power Management
270 ================
271
272 If your I2C device needs special handling when
273 power state -- like putting a transceiver into
274 activating a system wakeup mechanism -- do tha
275 appropriate callbacks for the dev_pm_ops of th
276 and resume).
277
278 These are standard driver model calls, and the
279 would for any other driver stack. The calls c
280 I2C messaging to the device being suspended or
281 parent I2C adapter is active when these calls
282 are still enabled).
283
284
285 System Shutdown
286 ===============
287
288 If your I2C device needs special handling when
289 or reboots (including kexec) -- like turning s
290 shutdown() method.
291
292 Again, this is a standard driver model call, w
293 would for any other driver stack: the calls c
294 I2C messaging.
295
296
297 Command function
298 ================
299
300 A generic ioctl-like function call back is sup
301 need this, and its use is deprecated anyway, s
302 use it.
303
304
305 Sending and receiving
306 =====================
307
308 If you want to communicate with your device, t
309 to do this. You can find all of them in <linux
310
311 If you can choose between plain I2C communicat
312 communication, please use the latter. All adap
313 commands, but only some of them understand pla
314
315
316 Plain I2C communication
317 -----------------------
318
319 ::
320
321 int i2c_master_send(struct i2c_client
322 int count);
323 int i2c_master_recv(struct i2c_client
324
325 These routines read and write some bytes from/
326 contains the I2C address, so you do not have t
327 parameter contains the bytes to read/write, th
328 to read/write (must be less than the length of
329 less than 64k since msg.len is u16.) Returned
330 read/written.
331
332 ::
333
334 int i2c_transfer(struct i2c_adapter *a
335 int num);
336
337 This sends a series of messages. Each message
338 and they can be mixed in any way. The transact
339 stop condition is issued between transaction.
340 contains for each message the client address,
341 message and the message data itself.
342
343 You can read the file i2c-protocol.rst for mor
344 actual I2C protocol.
345
346
347 SMBus communication
348 -------------------
349
350 ::
351
352 s32 i2c_smbus_xfer(struct i2c_adapter
353 unsigned short flag
354 int size, union i2c
355
356 This is the generic SMBus function. All functi
357 in terms of it. Never use this function direct
358
359 ::
360
361 s32 i2c_smbus_read_byte(struct i2c_cli
362 s32 i2c_smbus_write_byte(struct i2c_cl
363 s32 i2c_smbus_read_byte_data(struct i2
364 s32 i2c_smbus_write_byte_data(struct i
365 u8 comma
366 s32 i2c_smbus_read_word_data(struct i2
367 s32 i2c_smbus_write_word_data(struct i
368 u8 comma
369 s32 i2c_smbus_read_block_data(struct i
370 u8 comma
371 s32 i2c_smbus_write_block_data(struct
372 u8 comm
373 s32 i2c_smbus_read_i2c_block_data(stru
374 u8 c
375 s32 i2c_smbus_write_i2c_block_data(str
376 u8
377 con
378
379 These ones were removed from i2c-core because
380 be added back later if needed::
381
382 s32 i2c_smbus_write_quick(struct i2c_c
383 s32 i2c_smbus_process_call(struct i2c_
384 u8 command,
385 s32 i2c_smbus_block_process_call(struc
386 u8 co
387
388 All these transactions return a negative errno
389 transactions return 0 on success; the 'read' t
390 value, except for block transactions, which re
391 read. The block buffers need not be longer tha
392
393 You can read the file smbus-protocol.rst for m
394 actual SMBus protocol.
395
396
397 General purpose routines
398 ========================
399
400 Below all general purpose routines are listed,
401 before::
402
403 /* Return the adapter number for a spe
404 int i2c_adapter_id(struct i2c_adapter
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.