About Kernel Documentation Linux Kernel Contact Linux Resources Linux Blog

Documentation / i2c / writing-clients




Custom Search

Based on kernel version 3.16. Page generated on 2014-08-06 21:39 EST.

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

Information is copyright its respective author. All material is available from the Linux Kernel Source distributed under a GPL License. This page is provided as a free service by mjmwired.net.