Context Navigation

i2c.h @ 3737

Revision 3737, 23.7 KB (checked in by kmalkki, 10 years ago)

(Kyösti) Fix clock cycle high time when client device has pulled and

released SCL within the timeout period in sclhi().

Document I2C_M_IGNORE_NAK and I2C_M_NO_RD_ACK flags.
Fix I2C_M_NOSTART description and example.

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

Line
1	/* ------------------------------------------------------------------------- */
2	/* */
3	/* i2c.h - definitions for the i2c-bus interface */
4	/* */
5	/* ------------------------------------------------------------------------- */
6	/* Copyright (C) 1995-2000 Simon G. Vogl
7
8	This program is free software; you can redistribute it and/or modify
9	it under the terms of the GNU General Public License as published by
10	the Free Software Foundation; either version 2 of the License, or
11	(at your option) any later version.
12
13	This program is distributed in the hope that it will be useful,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.
17
18	You should have received a copy of the GNU General Public License
19	along with this program; if not, write to the Free Software
20	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21	/* ------------------------------------------------------------------------- */
22
23	/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and
24	Frodo Looijaard <frodol@dds.nl> */
25
26	/* $Id$ */
27
28	#ifndef I2C_H
29	#define I2C_H
30
31	#define I2C_DATE "20020915"
32	#define I2C_VERSION "2.6.5"
33
34	#include "i2c-id.h" /* id values of adapters et. al. */
35	#include <linux/types.h>
36
37
38	struct i2c_msg;
39
40
41	#ifdef __KERNEL__
42
43	/* --- Includes and compatibility declarations ------------------------ */
44
45	#include <linux/version.h>
46	#ifndef KERNEL_VERSION
47	#define KERNEL_VERSION(a,b,c) (((a) << 16) \| ((b) << 8) \| (c))
48	#endif
49
50	#include <asm/page.h> /* for 2.2.xx */
51	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,0,25)
52	#include <linux/sched.h>
53	#else
54	#include <asm/semaphore.h>
55	#endif
56	#include <linux/config.h>
57
58	/* --- General options ------------------------------------------------ */
59
60	#define I2C_ALGO_MAX 4 /* control memory consumption */
61	#define I2C_ADAP_MAX 16
62	#define I2C_DRIVER_MAX 16
63	#define I2C_CLIENT_MAX 32
64	#define I2C_DUMMY_MAX 4
65
66	struct i2c_algorithm;
67	struct i2c_adapter;
68	struct i2c_client;
69	struct i2c_driver;
70	struct i2c_client_address_data;
71	union i2c_smbus_data;
72
73	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,1)
74	#ifndef __exit
75	#define __exit
76	#endif
77	#endif
78
79	/*
80	* The master routines are the ones normally used to transmit data to devices
81	* on a bus (or read from them). Apart from two basic transfer functions to
82	* transmit one message at a time, a more complex version can be used to
83	* transmit an arbitrary number of messages without interruption.
84	*/
85	extern int i2c_master_send(struct i2c_client ,const char ,int);
86	extern int i2c_master_recv(struct i2c_client ,char ,int);
87
88	/* Transfer num messages.
89	*/
90	extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],int num);
91
92	/*
93	* Some adapter types (i.e. PCF 8584 based ones) may support slave behaviuor.
94	* This is not tested/implemented yet and will change in the future.
95	*/
96	extern int i2c_slave_send(struct i2c_client ,char,int);
97	extern int i2c_slave_recv(struct i2c_client ,char,int);
98
99
100
101	/* This is the very generalized SMBus access routine. You probably do not
102	want to use this, though; one of the functions below may be much easier,
103	and probably just as fast.
104	Note that we use i2c_adapter here, because you do not need a specific
105	smbus adapter to call this function. */
106	extern s32 i2c_smbus_xfer (struct i2c_adapter * adapter, u16 addr,
107	unsigned short flags,
108	char read_write, u8 command, int size,
109	union i2c_smbus_data * data);
110
111	/* Now follow the 'nice' access routines. These also document the calling
112	conventions of smbus_access. */
113
114	extern s32 i2c_smbus_write_quick(struct i2c_client * client, u8 value);
115	extern s32 i2c_smbus_read_byte(struct i2c_client * client);
116	extern s32 i2c_smbus_write_byte(struct i2c_client * client, u8 value);
117	extern s32 i2c_smbus_read_byte_data(struct i2c_client * client, u8 command);
118	extern s32 i2c_smbus_write_byte_data(struct i2c_client * client,
119	u8 command, u8 value);
120	extern s32 i2c_smbus_read_word_data(struct i2c_client * client, u8 command);
121	extern s32 i2c_smbus_write_word_data(struct i2c_client * client,
122	u8 command, u16 value);
123	extern s32 i2c_smbus_process_call(struct i2c_client * client,
124	u8 command, u16 value);
125	/* Returns the number of read bytes */
126	extern s32 i2c_smbus_read_block_data(struct i2c_client * client,
127	u8 command, u8 *values);
128	extern s32 i2c_smbus_write_block_data(struct i2c_client * client,
129	u8 command, u8 length,
130	u8 *values);
131	extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client * client,
132	u8 command, u8 *values);
133	extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client * client,
134	u8 command, u8 length,
135	u8 *values);
136
137
138	/*
139	* A driver is capable of handling one or more physical devices present on
140	* I2C adapters. This information is used to inform the driver of adapter
141	* events.
142	*/
143
144	struct i2c_driver {
145	char name[32];
146	int id;
147	unsigned int flags; /* div., see below */
148
149	/* Notifies the driver that a new bus has appeared. This routine
150	* can be used by the driver to test if the bus meets its conditions
151	* & seek for the presence of the chip(s) it supports. If found, it
152	* registers the client(s) that are on the bus to the i2c admin. via
153	* i2c_attach_client.
154	*/
155	int (attach_adapter)(struct i2c_adapter );
156
157	/* tells the driver that a client is about to be deleted & gives it
158	* the chance to remove its private data. Also, if the client struct
159	* has been dynamically allocated by the driver in the function above,
160	* it must be freed here.
161	*/
162	int (detach_client)(struct i2c_client );
163
164	/* a ioctl like command that can be used to perform specific functions
165	* with the device.
166	*/
167	int (command)(struct i2c_client client,unsigned int cmd, void *arg);
168
169	/* These two are mainly used for bookkeeping & dynamic unloading of
170	* kernel modules. inc_use tells the driver that a client is being
171	* used by another module & that it should increase its ref. counter.
172	* dec_use is the inverse operation.
173	* NB: Make sure you have no circular dependencies, or else you get a
174	* deadlock when trying to unload the modules.
175	* You should use the i2c_{inc,dec}_use_client functions instead of
176	* calling this function directly.
177	*/
178	void (inc_use)(struct i2c_client client);
179	void (dec_use)(struct i2c_client client);
180	};
181
182	/*
183	* i2c_client identifies a single device (i.e. chip) that is connected to an
184	* i2c bus. The behaviour is defined by the routines of the driver. This
185	* function is mainly used for lookup & other admin. functions.
186	*/
187	struct i2c_client {
188	char name[32];
189	int id;
190	unsigned int flags; /* div., see below */
191	unsigned int addr; /* chip address - NOTE: 7bit */
192	/* addresses are stored in the */
193	/* _LOWER_ 7 bits of this char */
194	/* addr: unsigned int to make lm_sensors i2c-isa adapter work
195	more cleanly. It does not take any more memory space, due to
196	alignment considerations */
197	struct i2c_adapter adapter; / the adapter we sit on */
198	struct i2c_driver driver; / and our access routines */
199	void data; / for the clients */
200	int usage_count; /* How many accesses currently */
201	/* to the client */
202	};
203
204
205	/*
206	* The following structs are for those who like to implement new bus drivers:
207	* i2c_algorithm is the interface to a class of hardware solutions which can
208	* be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584
209	* to name two of the most common.
210	*/
211	struct i2c_algorithm {
212	char name[32]; /* textual description */
213	unsigned int id;
214
215	/* If an adapter algorithm can't to I2C-level access, set master_xfer
216	to NULL. If an adapter algorithm can do SMBus access, set
217	smbus_xfer. If set to NULL, the SMBus protocol is simulated
218	using common I2C messages */
219	int (master_xfer)(struct i2c_adapter adap,struct i2c_msg msgs[],
220	int num);
221	int (smbus_xfer) (struct i2c_adapter adap, u16 addr,
222	unsigned short flags, char read_write,
223	u8 command, int size, union i2c_smbus_data * data);
224
225	/* --- these optional/future use for some adapter types.*/
226	int (slave_send)(struct i2c_adapter ,char*,int);
227	int (slave_recv)(struct i2c_adapter ,char*,int);
228
229	/* --- ioctl like call to set div. parameters. */
230	int (algo_control)(struct i2c_adapter , unsigned int, unsigned long);
231
232	/* To determine what the adapter supports */
233	u32 (functionality) (struct i2c_adapter );
234	};
235
236	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,29)
237	struct proc_dir_entry;
238	#endif
239
240	/*
241	* i2c_adapter is the structure used to identify a physical i2c bus along
242	* with the access algorithms necessary to access it.
243	*/
244	struct i2c_adapter {
245	char name[32]; /* some useful name to identify the adapter */
246	unsigned int id;/* == is algo->id \| hwdep.struct->id, */
247	/* for registered values see below */
248	struct i2c_algorithm algo;/ the algorithm to access the bus */
249	void *algo_data;
250
251	/* --- These may be NULL, but should increase the module use count */
252	void (inc_use)(struct i2c_adapter );
253	void (dec_use)(struct i2c_adapter );
254
255	/* --- administration stuff. */
256	int (client_register)(struct i2c_client );
257	int (client_unregister)(struct i2c_client );
258
259	void data; / private data for the adapter */
260	/* some data fields that are used by all types */
261	/* these data fields are readonly to the public */
262	/* and can be set via the i2c_ioctl call */
263
264	/* data fields that are valid for all devices */
265	struct semaphore lock;
266	unsigned int flags;/* flags specifying div. data */
267
268	struct i2c_client *clients[I2C_CLIENT_MAX];
269	int client_count;
270
271	int timeout;
272	int retries;
273
274	#ifdef CONFIG_PROC_FS
275	/* No need to set this when you initialize the adapter */
276	int inode;
277	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,29)
278	struct proc_dir_entry *proc_entry;
279	#endif
280	#endif /* def CONFIG_PROC_FS */
281	};
282
283	/flags for the driver struct: /
284	#define I2C_DF_NOTIFY 0x01 /* notify on bus (de/a)ttaches */
285	#define I2C_DF_DUMMY 0x02 /* do not connect any clients */
286
287	/flags for the client struct: /
288	#define I2C_CLIENT_ALLOW_USE 0x01 /* Client allows access */
289	#define I2C_CLIENT_ALLOW_MULTIPLE_USE 0x02 /* Allow multiple access-locks */
290	/* on an i2c_client */
291	#define I2C_CLIENT_PEC 0x04 /* Use Packet Error Checking */
292	#define I2C_CLIENT_TEN 0x10 /* we have a ten bit chip address */
293	/* Must equal I2C_M_TEN below */
294
295	/* i2c_client_address_data is the struct for holding default client
296	* addresses for a driver and for the parameters supplied on the
297	* command line
298	*/
299	struct i2c_client_address_data {
300	unsigned short *normal_i2c;
301	unsigned short *normal_i2c_range;
302	unsigned short *probe;
303	unsigned short *probe_range;
304	unsigned short *ignore;
305	unsigned short *ignore_range;
306	unsigned short *force;
307	};
308
309	/* Internal numbers to terminate lists */
310	#define I2C_CLIENT_END 0xfffe
311
312	/* The numbers to use to set I2C bus address */
313	#define ANY_I2C_BUS 0xffff
314
315	/* The length of the option lists */
316	#define I2C_CLIENT_MAX_OPTS 48
317
318
319	/* ----- functions exported by i2c.o */
320
321	/* administration...
322	*/
323	extern int i2c_add_adapter(struct i2c_adapter *);
324	extern int i2c_del_adapter(struct i2c_adapter *);
325
326	extern int i2c_add_driver(struct i2c_driver *);
327	extern int i2c_del_driver(struct i2c_driver *);
328
329	extern int i2c_attach_client(struct i2c_client *);
330	extern int i2c_detach_client(struct i2c_client *);
331
332	/* Only call these if you grab a resource that makes unloading the
333	client and the adapter it is on completely impossible. Like when a
334	/proc directory is entered. */
335	extern void i2c_inc_use_client(struct i2c_client *);
336	extern void i2c_dec_use_client(struct i2c_client *);
337
338	/* New function: This is to get an i2c_client-struct for controlling the
339	client either by using i2c_control-function or having the
340	client-module export functions that can be used with the i2c_client
341	-struct. */
342	extern struct i2c_client *i2c_get_client(int driver_id, int adapter_id,
343	struct i2c_client *prev);
344
345	/* Should be used with new function
346	extern struct i2c_client i2c_get_client(int,int,struct i2c_client );
347	to make sure that client-struct is valid and that it is okay to access
348	the i2c-client.
349	returns -EACCES if client doesn't allow use (default)
350	returns -EBUSY if client doesn't allow multiple use (default) and
351	usage_count >0 */
352	extern int i2c_use_client(struct i2c_client *);
353	extern int i2c_release_client(struct i2c_client *);
354
355	/* returns -EBUSY if address has been taken, 0 if not. Note that the only
356	other place at which this is called is within i2c_attach_client; so
357	you can cheat by simply not registering. Not recommended, of course! */
358	extern int i2c_check_addr (struct i2c_adapter *adapter, int addr);
359
360	/* Detect function. It iterates over all possible addresses itself.
361	* It will only call found_proc if some client is connected at the
362	* specific address (unless a 'force' matched);
363	*/
364	typedef int i2c_client_found_addr_proc (struct i2c_adapter *adapter,
365	int addr, unsigned short flags,int kind);
366
367	extern int i2c_probe(struct i2c_adapter *adapter,
368	struct i2c_client_address_data *address_data,
369	i2c_client_found_addr_proc *found_proc);
370
371	/* An ioctl like call to set div. parameters of the adapter.
372	*/
373	extern int i2c_control(struct i2c_client *,unsigned int, unsigned long);
374
375	/* This call returns a unique low identifier for each registered adapter,
376	* or -1 if the adapter was not registered.
377	*/
378	extern int i2c_adapter_id(struct i2c_adapter *adap);
379
380
381
382	/* Return the functionality mask */
383	extern u32 i2c_get_functionality (struct i2c_adapter *adap);
384
385	/* Return 1 if adapter supports everything we need, 0 if not. */
386	extern int i2c_check_functionality (struct i2c_adapter *adap, u32 func);
387
388	#endif /* __KERNEL__ */
389
390	/*
391	* I2C Message - used for pure i2c transaction, also from /dev interface
392	*/
393	struct i2c_msg {
394	__u16 addr; /* slave address */
395	unsigned short flags;
396	#define I2C_M_TEN 0x10 /* we have a ten bit chip address */
397	#define I2C_M_RD 0x01
398	#define I2C_M_NOSTART 0x4000
399	#define I2C_M_REV_DIR_ADDR 0x2000
400	#define I2C_M_IGNORE_NAK 0x1000
401	#define I2C_M_NO_RD_ACK 0x0800
402	short len; /* msg length */
403	char buf; / pointer to msg data */
404	};
405
406	/* To determine what functionality is present */
407
408	#define I2C_FUNC_I2C 0x00000001
409	#define I2C_FUNC_10BIT_ADDR 0x00000002
410	#define I2C_FUNC_PROTOCOL_MANGLING 0x00000004 /* I2C_M_{REV_DIR_ADDR,NOSTART,..} */
411	#define I2C_FUNC_SMBUS_HWPEC_CALC 0x00000008 /* SMBus 2.0 */
412	#define I2C_FUNC_SMBUS_READ_WORD_DATA_PEC 0x00000800 /* SMBus 2.0 */
413	#define I2C_FUNC_SMBUS_WRITE_WORD_DATA_PEC 0x00001000 /* SMBus 2.0 */
414	#define I2C_FUNC_SMBUS_PROC_CALL_PEC 0x00002000 /* SMBus 2.0 */
415	#define I2C_FUNC_SMBUS_BLOCK_PROC_CALL_PEC 0x00004000 /* SMBus 2.0 */
416	#define I2C_FUNC_SMBUS_BLOCK_PROC_CALL 0x00008000 /* SMBus 2.0 */
417	#define I2C_FUNC_SMBUS_QUICK 0x00010000
418	#define I2C_FUNC_SMBUS_READ_BYTE 0x00020000
419	#define I2C_FUNC_SMBUS_WRITE_BYTE 0x00040000
420	#define I2C_FUNC_SMBUS_READ_BYTE_DATA 0x00080000
421	#define I2C_FUNC_SMBUS_WRITE_BYTE_DATA 0x00100000
422	#define I2C_FUNC_SMBUS_READ_WORD_DATA 0x00200000
423	#define I2C_FUNC_SMBUS_WRITE_WORD_DATA 0x00400000
424	#define I2C_FUNC_SMBUS_PROC_CALL 0x00800000
425	#define I2C_FUNC_SMBUS_READ_BLOCK_DATA 0x01000000
426	#define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA 0x02000000
427	#define I2C_FUNC_SMBUS_READ_I2C_BLOCK 0x04000000 /* I2C-like block xfer */
428	#define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK 0x08000000 /* w/ 1-byte reg. addr. */
429	#define I2C_FUNC_SMBUS_READ_I2C_BLOCK_2 0x10000000 /* I2C-like block xfer */
430	#define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2 0x20000000 /* w/ 2-byte reg. addr. */
431	#define I2C_FUNC_SMBUS_READ_BLOCK_DATA_PEC 0x40000000 /* SMBus 2.0 */
432	#define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC 0x80000000 /* SMBus 2.0 */
433
434	#define I2C_FUNC_SMBUS_BYTE I2C_FUNC_SMBUS_READ_BYTE \| \
435	I2C_FUNC_SMBUS_WRITE_BYTE
436	#define I2C_FUNC_SMBUS_BYTE_DATA I2C_FUNC_SMBUS_READ_BYTE_DATA \| \
437	I2C_FUNC_SMBUS_WRITE_BYTE_DATA
438	#define I2C_FUNC_SMBUS_WORD_DATA I2C_FUNC_SMBUS_READ_WORD_DATA \| \
439	I2C_FUNC_SMBUS_WRITE_WORD_DATA
440	#define I2C_FUNC_SMBUS_BLOCK_DATA I2C_FUNC_SMBUS_READ_BLOCK_DATA \| \
441	I2C_FUNC_SMBUS_WRITE_BLOCK_DATA
442	#define I2C_FUNC_SMBUS_I2C_BLOCK I2C_FUNC_SMBUS_READ_I2C_BLOCK \| \
443	I2C_FUNC_SMBUS_WRITE_I2C_BLOCK
444	#define I2C_FUNC_SMBUS_I2C_BLOCK_2 I2C_FUNC_SMBUS_READ_I2C_BLOCK_2 \| \
445	I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2
446	#define I2C_FUNC_SMBUS_BLOCK_DATA_PEC I2C_FUNC_SMBUS_READ_BLOCK_DATA_PEC \| \
447	I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC
448	#define I2C_FUNC_SMBUS_WORD_DATA_PEC I2C_FUNC_SMBUS_READ_WORD_DATA_PEC \| \
449	I2C_FUNC_SMBUS_WRITE_WORD_DATA_PEC
450
451	#define I2C_FUNC_SMBUS_READ_BYTE_PEC I2C_FUNC_SMBUS_READ_BYTE_DATA
452	#define I2C_FUNC_SMBUS_WRITE_BYTE_PEC I2C_FUNC_SMBUS_WRITE_BYTE_DATA
453	#define I2C_FUNC_SMBUS_READ_BYTE_DATA_PEC I2C_FUNC_SMBUS_READ_WORD_DATA
454	#define I2C_FUNC_SMBUS_WRITE_BYTE_DATA_PEC I2C_FUNC_SMBUS_WRITE_WORD_DATA
455	#define I2C_FUNC_SMBUS_BYTE_PEC I2C_FUNC_SMBUS_BYTE_DATA
456	#define I2C_FUNC_SMBUS_BYTE_DATA_PEC I2C_FUNC_SMBUS_WORD_DATA
457
458	#define I2C_FUNC_SMBUS_EMUL I2C_FUNC_SMBUS_QUICK \| \
459	I2C_FUNC_SMBUS_BYTE \| \
460	I2C_FUNC_SMBUS_BYTE_DATA \| \
461	I2C_FUNC_SMBUS_WORD_DATA \| \
462	I2C_FUNC_SMBUS_PROC_CALL \| \
463	I2C_FUNC_SMBUS_WRITE_BLOCK_DATA \| \
464	I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC \| \
465	I2C_FUNC_SMBUS_I2C_BLOCK
466
467	/*
468	* Data for SMBus Messages
469	*/
470	#define I2C_SMBUS_BLOCK_MAX 32 /* As specified in SMBus standard */
471	#define I2C_SMBUS_I2C_BLOCK_MAX 32 /* Not specified but we use same structure */
472	union i2c_smbus_data {
473	__u8 byte;
474	__u16 word;
475	__u8 block[I2C_SMBUS_BLOCK_MAX + 3]; /* block[0] is used for length */
476	/* one more for read length in block process call */
477	/* and one more for PEC */
478	};
479
480	/* smbus_access read or write markers */
481	#define I2C_SMBUS_READ 1
482	#define I2C_SMBUS_WRITE 0
483
484	/* SMBus transaction types (size parameter in the above functions)
485	Note: these no longer correspond to the (arbitrary) PIIX4 internal codes! */
486	#define I2C_SMBUS_QUICK 0
487	#define I2C_SMBUS_BYTE 1
488	#define I2C_SMBUS_BYTE_DATA 2
489	#define I2C_SMBUS_WORD_DATA 3
490	#define I2C_SMBUS_PROC_CALL 4
491	#define I2C_SMBUS_BLOCK_DATA 5
492	#define I2C_SMBUS_I2C_BLOCK_DATA 6
493	#define I2C_SMBUS_BLOCK_PROC_CALL 7 /* SMBus 2.0 */
494	#define I2C_SMBUS_BLOCK_DATA_PEC 8 /* SMBus 2.0 */
495	#define I2C_SMBUS_PROC_CALL_PEC 9 /* SMBus 2.0 */
496	#define I2C_SMBUS_BLOCK_PROC_CALL_PEC 10 /* SMBus 2.0 */
497	#define I2C_SMBUS_WORD_DATA_PEC 11 /* SMBus 2.0 */
498
499
500	/* ----- commands for the ioctl like i2c_command call:
501	* note that additional calls are defined in the algorithm and hw
502	* dependent layers - these can be listed here, or see the
503	* corresponding header files.
504	*/
505	/* -> bit-adapter specific ioctls */
506	#define I2C_RETRIES 0x0701 /* number of times a device address */
507	/* should be polled when not */
508	/* acknowledging */
509	#define I2C_TIMEOUT 0x0702 /* set timeout - call with int */
510
511
512	/* this is for i2c-dev.c */
513	#define I2C_SLAVE 0x0703 /* Change slave address */
514	/* Attn.: Slave address is 7 or 10 bits */
515	#define I2C_SLAVE_FORCE 0x0706 /* Change slave address */
516	/* Attn.: Slave address is 7 or 10 bits */
517	/* This changes the address, even if it */
518	/* is already taken! */
519	#define I2C_TENBIT 0x0704 /* 0 for 7 bit addrs, != 0 for 10 bit */
520
521	#define I2C_FUNCS 0x0705 /* Get the adapter functionality */
522	#define I2C_RDWR 0x0707 /* Combined R/W transfer (one stop only)*/
523	#define I2C_PEC 0x0708 /* != 0 for SMBus PEC */
524	#if 0
525	#define I2C_ACK_TEST 0x0710 /* See if a slave is at a specific address */
526	#endif
527
528	#define I2C_SMBUS 0x0720 /* SMBus-level access */
529
530	/* ... algo-bit.c recognizes */
531	#define I2C_UDELAY 0x0705 /* set delay in microsecs between each */
532	/* written byte (except address) */
533	#define I2C_MDELAY 0x0706 /* millisec delay between written bytes */
534
535	/* ----- I2C-DEV: char device interface stuff ------------------------- */
536
537	#define I2C_MAJOR 89 /* Device major number */
538
539	#ifdef __KERNEL__
540
541	# ifndef NULL
542	# define NULL ( (void *) 0 )
543	# endif
544
545	# ifndef ENODEV
546	# include <asm/errno.h>
547	# endif
548
549	/* These defines are used for probing i2c client addresses */
550	/* Default fill of many variables */
551	#define I2C_CLIENT_DEFAULTS {I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
552	I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
553	I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
554	I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
555	I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
556	I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
557	I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
558	I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
559	I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
560	I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
561	I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
562	I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
563	I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
564	I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
565	I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
566	I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END}
567
568	/* This is ugly. We need to evaluate I2C_CLIENT_MAX_OPTS before it is
569	stringified */
570	#define I2C_CLIENT_MODPARM_AUX1(x) "1-" #x "h"
571	#define I2C_CLIENT_MODPARM_AUX(x) I2C_CLIENT_MODPARM_AUX1(x)
572	#define I2C_CLIENT_MODPARM I2C_CLIENT_MODPARM_AUX(I2C_CLIENT_MAX_OPTS)
573
574	/* I2C_CLIENT_MODULE_PARM creates a module parameter, and puts it in the
575	module header */
576
577	#define I2C_CLIENT_MODULE_PARM(var,desc) \
578	static unsigned short var[I2C_CLIENT_MAX_OPTS] = I2C_CLIENT_DEFAULTS; \
579	MODULE_PARM(var,I2C_CLIENT_MODPARM); \
580	MODULE_PARM_DESC(var,desc)
581
582	/* This is the one you want to use in your own modules */
583	#define I2C_CLIENT_INSMOD \
584	I2C_CLIENT_MODULE_PARM(probe, \
585	"List of adapter,address pairs to scan additionally"); \
586	I2C_CLIENT_MODULE_PARM(probe_range, \
587	"List of adapter,start-addr,end-addr triples to scan " \
588	"additionally"); \
589	I2C_CLIENT_MODULE_PARM(ignore, \
590	"List of adapter,address pairs not to scan"); \
591	I2C_CLIENT_MODULE_PARM(ignore_range, \
592	"List of adapter,start-addr,end-addr triples not to " \
593	"scan"); \
594	I2C_CLIENT_MODULE_PARM(force, \
595	"List of adapter,address pairs to boldly assume " \
596	"to be present"); \
597	static struct i2c_client_address_data addr_data = \
598	{normal_i2c, normal_i2c_range, \
599	probe, probe_range, \
600	ignore, ignore_range, \
601	force}
602
603	/* Detect whether we are on the isa bus. If this returns true, all i2c
604	access will fail! */
605	#define i2c_is_isa_client(clientptr) \
606	((clientptr)->adapter->algo->id == I2C_ALGO_ISA)
607	#define i2c_is_isa_adapter(adapptr) \
608	((adapptr)->algo->id == I2C_ALGO_ISA)
609
610	#endif /* def __KERNEL__ */
611	#endif /* I2C_H */

Note: See TracBrowser for help on using the browser.

Context Navigation

root/i2c/trunk/kernel/i2c.h @ 3737

Download in other formats: