开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
i2c.h
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：21k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

i2c.h：源码内容
  1. /* ------------------------------------------------------------------------- */
  2. /*       */
  3. /* i2c.h - definitions for the i2c-bus interface      */
  4. /*       */
  5. /* ------------------------------------------------------------------------- */
  6. /*   Copyright (C) 1995-2000 Simon G. Vogl
  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.
  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.
  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. /* ------------------------------------------------------------------------- */
  23. /* With some changes from Ky鰏ti M鋖kki <kmalkki@cc.hut.fi> and
  24.    Frodo Looijaard <frodol@dds.nl> */
  26. /* $Id: i2c.h,v 1.46 2001/08/31 00:04:07 phil Exp $ */
  28. #ifndef I2C_H
  29. #define I2C_H
  31. #define I2C_DATE "20010830"
  32. #define I2C_VERSION "2.6.1"
  34. #include <linux/i2c-id.h> /* id values of adapters et. al.  */
  35. #include <linux/types.h>
  38. struct i2c_msg;
  41. #ifdef __KERNEL__
  43. /* --- Includes and compatibility declarations ------------------------ */
  45. #include <linux/version.h>
  46. #ifndef KERNEL_VERSION
  47. #define KERNEL_VERSION(a,b,c) (((a) << 16) | ((b) << 8) | (c))
  48. #endif
  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>
  58. /* --- General options ------------------------------------------------ */
  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
  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;
  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.  */
  80. extern int i2c_master_send(struct i2c_client *,const char* ,int);
  81. extern int i2c_master_recv(struct i2c_client *,char* ,int);
  83. /* Transfer num messages.
  84.  */
  85. extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],int num);
  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.  */
  91. extern int i2c_slave_send(struct i2c_client *,char*,int);
  92. extern int i2c_slave_recv(struct i2c_client *,char*,int);
  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. */
  101. extern 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);
  106. /* Now follow the 'nice' access routines. These also document the calling
  107.    conventions of smbus_access. */
  109. extern s32 i2c_smbus_write_quick(struct i2c_client * client, u8 value);
  110. extern s32 i2c_smbus_read_byte(struct i2c_client * client);
  111. extern s32 i2c_smbus_write_byte(struct i2c_client * client, u8 value);
  112. extern s32 i2c_smbus_read_byte_data(struct i2c_client * client, u8 command);
  113. extern s32 i2c_smbus_write_byte_data(struct i2c_client * client,
  114.                                      u8 command, u8 value);
  115. extern s32 i2c_smbus_read_word_data(struct i2c_client * client, u8 command);
  116. extern s32 i2c_smbus_write_word_data(struct i2c_client * client,
  117.                                      u8 command, u16 value);
  118. extern s32 i2c_smbus_process_call(struct i2c_client * client,
  119.                                   u8 command, u16 value);
  120. /* Returns the number of read bytes */
  121. extern s32 i2c_smbus_read_block_data(struct i2c_client * client,
  122.                                      u8 command, u8 *values);
  123. extern s32 i2c_smbus_write_block_data(struct i2c_client * client,
  124.                                       u8 command, u8 length,
  125.                                       u8 *values);
  126. extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client * client,
  127.                                           u8 command, u8 length,
  128.                                           u8 *values);
  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.  */
  137. struct i2c_driver {
  138. char name[32];
  139. int id;
  140. unsigned int flags; /* div., see below */
  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 *);
  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 *);
  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);
  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. };
  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.  */
  180. struct 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. };
  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.  */
  204. struct i2c_algorithm {
  205. char name[32]; /* textual description  */
  206. unsigned int id;
  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);
  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);
  222. /* --- ioctl like call to set div. parameters. */
  223. int (*algo_control)(struct i2c_adapter *, unsigned int, unsigned long);
  225. /* To determine what the adapter supports */
  226. u32 (*functionality) (struct i2c_adapter *);
  227. };
  229. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,29)
  230. struct proc_dir_entry;
  231. #endif
  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.  */
  237. struct 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;
  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 *);
  248. /* --- administration stuff. */
  249. int (*client_register)(struct i2c_client *);
  250. int (*client_unregister)(struct i2c_client *);
  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 */
  257. /* data fields that are valid for all devices */
  258. struct semaphore lock;  
  259. unsigned int flags;/* flags specifying div. data */
  261. struct i2c_client *clients[I2C_CLIENT_MAX];
  262. int client_count;
  264. int timeout;
  265. int retries;
  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. };
  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 */
  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 */
  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.  */
  289. struct 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. };
  299. /* Internal numbers to terminate lists */
  300. #define I2C_CLIENT_END 0xfffe
  302. /* The numbers to use to set I2C bus address */
  303. #define ANY_I2C_BUS 0xffff
  305. /* The length of the option lists */
  306. #define I2C_CLIENT_MAX_OPTS 48
  309. /* ----- functions exported by i2c.o */
  311. /* administration...
  312.  */
  313. extern int i2c_add_adapter(struct i2c_adapter *);
  314. extern int i2c_del_adapter(struct i2c_adapter *);
  316. extern int i2c_add_driver(struct i2c_driver *);
  317. extern int i2c_del_driver(struct i2c_driver *);
  319. extern int i2c_attach_client(struct i2c_client *);
  320. extern int i2c_detach_client(struct i2c_client *);
  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. */
  325. extern void i2c_inc_use_client(struct i2c_client *);
  326. extern void i2c_dec_use_client(struct i2c_client *);
  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. */
  332. extern struct i2c_client *i2c_get_client(int driver_id, int adapter_id, 
  333. struct i2c_client *prev);
  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 */
  342. extern int i2c_use_client(struct i2c_client *);
  343. extern int i2c_release_client(struct i2c_client *);
  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! */
  348. extern int i2c_check_addr (struct i2c_adapter *adapter, int addr);
  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.  */
  354. typedef int i2c_client_found_addr_proc (struct i2c_adapter *adapter,
  355.                                      int addr, unsigned short flags,int kind);
  357. extern int i2c_probe(struct i2c_adapter *adapter, 
  358. struct i2c_client_address_data *address_data,
  359. i2c_client_found_addr_proc *found_proc);
  361. /* An ioctl like call to set div. parameters of the adapter.
  362.  */
  363. extern int i2c_control(struct i2c_client *,unsigned int, unsigned long);
  365. /* This call returns a unique low identifier for each registered adapter,
  366.  * or -1 if the adapter was not registered. 
  367.  */
  368. extern int i2c_adapter_id(struct i2c_adapter *adap);
  372. /* Return the functionality mask */
  373. extern u32 i2c_get_functionality (struct i2c_adapter *adap);
  375. /* Return 1 if adapter supports everything we need, 0 if not. */
  376. extern int i2c_check_functionality (struct i2c_adapter *adap, u32 func);
  378. #endif /* __KERNEL__ */
  380. /*
  381.  * I2C Message - used for pure i2c transaction, also from /dev interface
  382.  */
  383. struct 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. };
  394. /* To determine what functionality is present */
  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 */
  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
  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
  430. /* 
  431.  * Data for SMBus Messages 
  432.  */
  433. union i2c_smbus_data {
  434. __u8 byte;
  435. __u16 word;
  436. __u8 block[33]; /* block[0] is used for length */
  437. };
  439. /* smbus_access read or write markers */
  440. #define I2C_SMBUS_READ 1
  441. #define I2C_SMBUS_WRITE 0
  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
  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  */
  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 */
  475. #define I2C_FUNCS 0x0705 /* Get the adapter functionality */
  476. #define I2C_RDWR 0x0707 /* Combined R/W transfer (one stop only)*/
  477. #if 0
  478. #define I2C_ACK_TEST 0x0710 /* See if a slave is at a specific address */
  479. #endif
  481. #define I2C_SMBUS 0x0720 /* SMBus-level access */
  483. /* ... algo-bit.c recognizes */
  484. #define I2C_UDELAY 0x0705 /* set delay in microsecs between each */
  485. /* written byte (except address) */
  486. #define I2C_MDELAY 0x0706 /* millisec delay between written bytes */
  488. /* ----- I2C-DEV: char device interface stuff ------------------------- */
  490. #define I2C_MAJOR 89 /* Device major number */
  492. #ifdef __KERNEL__
  494. #  ifndef NULL
  495. #    define NULL ( (void *) 0 )
  496. #  endif
  498. #  ifndef ENODEV
  499. #    include <asm/errno.h>
  500. #  endif
  502. /* These defines are used for probing i2c client addresses */
  503. /* Default fill of many variables */
  504. #define I2C_CLIENT_DEFAULTS {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.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  518.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  519.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END}
  521. /* This is ugly. We need to evaluate I2C_CLIENT_MAX_OPTS before it is 
  522.    stringified */
  523. #define I2C_CLIENT_MODPARM_AUX1(x) "1-" #x "h"
  524. #define I2C_CLIENT_MODPARM_AUX(x) I2C_CLIENT_MODPARM_AUX1(x)
  525. #define I2C_CLIENT_MODPARM I2C_CLIENT_MODPARM_AUX(I2C_CLIENT_MAX_OPTS)
  527. /* I2C_CLIENT_MODULE_PARM creates a module parameter, and puts it in the
  528.    module header */
  530. #define I2C_CLIENT_MODULE_PARM(var,desc) 
  531.   static unsigned short var[I2C_CLIENT_MAX_OPTS] = I2C_CLIENT_DEFAULTS; 
  532.   MODULE_PARM(var,I2C_CLIENT_MODPARM); 
  533.   MODULE_PARM_DESC(var,desc)
  535. /* This is the one you want to use in your own modules */
  536. #define I2C_CLIENT_INSMOD 
  537.   I2C_CLIENT_MODULE_PARM(probe, 
  538.                       "List of adapter,address pairs to scan additionally"); 
  539.   I2C_CLIENT_MODULE_PARM(probe_range, 
  540.                       "List of adapter,start-addr,end-addr triples to scan " 
  541.                       "additionally"); 
  542.   I2C_CLIENT_MODULE_PARM(ignore, 
  543.                       "List of adapter,address pairs not to scan"); 
  544.   I2C_CLIENT_MODULE_PARM(ignore_range, 
  545.                       "List of adapter,start-addr,end-addr triples not to " 
  546.                       "scan"); 
  547.   I2C_CLIENT_MODULE_PARM(force, 
  548.                       "List of adapter,address pairs to boldly assume " 
  549.                       "to be present"); 
  550.   static struct i2c_client_address_data addr_data = 
  551.                                        {normal_i2c, normal_i2c_range, 
  552.                                         probe, probe_range, 
  553.                                         ignore, ignore_range, 
  554.                                         force}
  556. /* Detect whether we are on the isa bus. If this returns true, all i2c
  557.    access will fail! */
  558. #define i2c_is_isa_client(clientptr) 
  559.         ((clientptr)->adapter->algo->id == I2C_ALGO_ISA)
  560. #define i2c_is_isa_adapter(adapptr) 
  561.         ((adapptr)->algo->id == I2C_ALGO_ISA)
  563. #endif /* def __KERNEL__ */
  564. #endif /* I2C_H */