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