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