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