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