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