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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
i2c.h
资源名称：arm_cross-3.4.4.tar.gz　[点击查看]
上传用户：szlgq88
上传日期：2009-04-28
资源大小：48287k
文件大小：27k
源码类别：

嵌入式Linux

开发平台：

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.68 2003/01/21 08:08:16 kmalkki Exp $ */
  28. #ifndef _LINUX_I2C_H
  29. #define _LINUX_I2C_H
  31. #include <linux/module.h>
  32. #include <linux/types.h>
  33. #include <linux/i2c-id.h>
  34. #include <linux/device.h> /* for struct device */
  35. #include <asm/semaphore.h>
  37. /* --- For i2c-isa ---------------------------------------------------- */
  39. extern void i2c_adapter_dev_release(struct device *dev);
  40. extern struct device_driver i2c_adapter_driver;
  41. extern struct class i2c_adapter_class;
  42. extern struct bus_type i2c_bus_type;
  44. /* --- General options ------------------------------------------------ */
  46. struct i2c_msg;
  47. struct i2c_algorithm;
  48. struct i2c_adapter;
  49. struct i2c_client;
  50. struct i2c_driver;
  51. union i2c_smbus_data;
  53. /*
  54.  * The master routines are the ones normally used to transmit data to devices
  55.  * on a bus (or read from them). Apart from two basic transfer functions to 
  56.  * transmit one message at a time, a more complex version can be used to 
  57.  * transmit an arbitrary number of messages without interruption.
  58.  */
  59. extern int i2c_master_send(struct i2c_client *,const char* ,int);
  60. extern int i2c_master_recv(struct i2c_client *,char* ,int);
  62. /* Transfer num messages.
  63.  */
  64. extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);
  66. /*
  67.  * Some adapter types (i.e. PCF 8584 based ones) may support slave behaviuor. 
  68.  * This is not tested/implemented yet and will change in the future.
  69.  */
  70. extern int i2c_slave_send(struct i2c_client *,char*,int);
  71. extern int i2c_slave_recv(struct i2c_client *,char*,int);
  75. /* This is the very generalized SMBus access routine. You probably do not
  76.    want to use this, though; one of the functions below may be much easier,
  77.    and probably just as fast. 
  78.    Note that we use i2c_adapter here, because you do not need a specific
  79.    smbus adapter to call this function. */
  80. extern s32 i2c_smbus_xfer (struct i2c_adapter * adapter, u16 addr, 
  81.                            unsigned short flags,
  82.                            char read_write, u8 command, int size,
  83.                            union i2c_smbus_data * data);
  85. /* Now follow the 'nice' access routines. These also document the calling
  86.    conventions of smbus_access. */
  88. extern s32 i2c_smbus_write_quick(struct i2c_client * client, u8 value);
  89. extern s32 i2c_smbus_read_byte(struct i2c_client * client);
  90. extern s32 i2c_smbus_write_byte(struct i2c_client * client, u8 value);
  91. extern s32 i2c_smbus_read_byte_data(struct i2c_client * client, u8 command);
  92. extern s32 i2c_smbus_write_byte_data(struct i2c_client * client,
  93.                                      u8 command, u8 value);
  94. extern s32 i2c_smbus_read_word_data(struct i2c_client * client, u8 command);
  95. extern s32 i2c_smbus_write_word_data(struct i2c_client * client,
  96.                                      u8 command, u16 value);
  97. /* Returns the number of bytes transferred */
  98. extern s32 i2c_smbus_write_block_data(struct i2c_client * client,
  99.       u8 command, u8 length,
  100.       u8 *values);
  101. extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client * client,
  102.  u8 command, u8 *values);
  104. /*
  105.  * A driver is capable of handling one or more physical devices present on
  106.  * I2C adapters. This information is used to inform the driver of adapter
  107.  * events.
  108.  */
  110. struct i2c_driver {
  111. struct module *owner;
  112. char name[32];
  113. int id;
  114. unsigned int class;
  115. unsigned int flags; /* div., see below */
  117. /* Notifies the driver that a new bus has appeared. This routine
  118.  * can be used by the driver to test if the bus meets its conditions
  119.  * & seek for the presence of the chip(s) it supports. If found, it 
  120.  * registers the client(s) that are on the bus to the i2c admin. via
  121.  * i2c_attach_client.
  122.  */
  123. int (*attach_adapter)(struct i2c_adapter *);
  124. int (*detach_adapter)(struct i2c_adapter *);
  126. /* tells the driver that a client is about to be deleted & gives it 
  127.  * the chance to remove its private data. Also, if the client struct
  128.  * has been dynamically allocated by the driver in the function above,
  129.  * it must be freed here.
  130.  */
  131. int (*detach_client)(struct i2c_client *);
  133. /* a ioctl like command that can be used to perform specific functions
  134.  * with the device.
  135.  */
  136. int (*command)(struct i2c_client *client,unsigned int cmd, void *arg);
  138. struct device_driver driver;
  139. struct list_head list;
  140. };
  141. #define to_i2c_driver(d) container_of(d, struct i2c_driver, driver)
  143. #define I2C_NAME_SIZE 50
  145. /*
  146.  * i2c_client identifies a single device (i.e. chip) that is connected to an 
  147.  * i2c bus. The behaviour is defined by the routines of the driver. This
  148.  * function is mainly used for lookup & other admin. functions.
  149.  */
  150. struct i2c_client {
  151. unsigned int flags; /* div., see below */
  152. unsigned short addr; /* chip address - NOTE: 7bit  */
  153. /* addresses are stored in the */
  154. /* _LOWER_ 7 bits */
  155. struct i2c_adapter *adapter; /* the adapter we sit on */
  156. struct i2c_driver *driver; /* and our access routines */
  157. int usage_count; /* How many accesses currently  */
  158. /* to the client */
  159. struct device dev; /* the device structure */
  160. struct list_head list;
  161. char name[I2C_NAME_SIZE];
  162. struct completion released;
  163. };
  164. #define to_i2c_client(d) container_of(d, struct i2c_client, dev)
  166. static inline struct i2c_client *kobj_to_i2c_client(struct kobject *kobj)
  167. {
  168. return to_i2c_client(container_of(kobj, struct device, kobj));
  169. }
  171. static inline void *i2c_get_clientdata (struct i2c_client *dev)
  172. {
  173. return dev_get_drvdata (&dev->dev);
  174. }
  176. static inline void i2c_set_clientdata (struct i2c_client *dev, void *data)
  177. {
  178. dev_set_drvdata (&dev->dev, data);
  179. }
  181. /*
  182.  * The following structs are for those who like to implement new bus drivers:
  183.  * i2c_algorithm is the interface to a class of hardware solutions which can
  184.  * be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584
  185.  * to name two of the most common.
  186.  */
  187. struct i2c_algorithm {
  188. /* If an adapter algorithm can't do I2C-level access, set master_xfer
  189.    to NULL. If an adapter algorithm can do SMBus access, set 
  190.    smbus_xfer. If set to NULL, the SMBus protocol is simulated
  191.    using common I2C messages */
  192. int (*master_xfer)(struct i2c_adapter *adap,struct i2c_msg *msgs, 
  193.                    int num);
  194. int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr, 
  195.                    unsigned short flags, char read_write,
  196.                    u8 command, int size, union i2c_smbus_data * data);
  198. /* --- these optional/future use for some adapter types.*/
  199. int (*slave_send)(struct i2c_adapter *,char*,int);
  200. int (*slave_recv)(struct i2c_adapter *,char*,int);
  202. /* --- ioctl like call to set div. parameters. */
  203. int (*algo_control)(struct i2c_adapter *, unsigned int, unsigned long);
  205. /* To determine what the adapter supports */
  206. u32 (*functionality) (struct i2c_adapter *);
  207. };
  209. /*
  210.  * i2c_adapter is the structure used to identify a physical i2c bus along
  211.  * with the access algorithms necessary to access it.
  212.  */
  213. struct i2c_adapter {
  214. struct module *owner;
  215. unsigned int id;
  216. unsigned int class;
  217. struct i2c_algorithm *algo;/* the algorithm to access the bus */
  218. void *algo_data;
  220. /* --- administration stuff. */
  221. int (*client_register)(struct i2c_client *);
  222. int (*client_unregister)(struct i2c_client *);
  224. /* data fields that are valid for all devices */
  225. struct semaphore bus_lock;
  226. struct semaphore clist_lock;
  228. int timeout;
  229. int retries;
  230. struct device dev; /* the adapter device */
  231. struct class_device class_dev; /* the class device */
  233. int nr;
  234. struct list_head clients;
  235. struct list_head list;
  236. char name[I2C_NAME_SIZE];
  237. struct completion dev_released;
  238. struct completion class_dev_released;
  239. };
  240. #define dev_to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
  241. #define class_dev_to_i2c_adapter(d) container_of(d, struct i2c_adapter, class_dev)
  243. static inline void *i2c_get_adapdata (struct i2c_adapter *dev)
  244. {
  245. return dev_get_drvdata (&dev->dev);
  246. }
  248. static inline void i2c_set_adapdata (struct i2c_adapter *dev, void *data)
  249. {
  250. dev_set_drvdata (&dev->dev, data);
  251. }
  253. /*flags for the driver struct: */
  254. #define I2C_DF_NOTIFY 0x01 /* notify on bus (de/a)ttaches  */
  255. #if 0
  256. /* this flag is gone -- there is a (optional) driver->detach_adapter
  257.  * callback now which can be used instead */
  258. # define I2C_DF_DUMMY 0x02
  259. #endif
  261. /*flags for the client struct: */
  262. #define I2C_CLIENT_ALLOW_USE 0x01 /* Client allows access */
  263. #define I2C_CLIENT_ALLOW_MULTIPLE_USE  0x02   /* Allow multiple access-locks */
  264. /* on an i2c_client */
  265. #define I2C_CLIENT_PEC  0x04 /* Use Packet Error Checking */
  266. #define I2C_CLIENT_TEN 0x10 /* we have a ten bit chip address */
  267. /* Must equal I2C_M_TEN below */
  269. /* i2c adapter classes (bitmask) */
  270. #define I2C_CLASS_HWMON (1<<0) /* lm_sensors, ... */
  271. #define I2C_CLASS_TV_ANALOG (1<<1) /* bttv + friends */
  272. #define I2C_CLASS_TV_DIGITAL (1<<2) /* dvb cards */
  273. #define I2C_CLASS_DDC (1<<3) /* i2c-matroxfb ? */
  274. #define I2C_CLASS_CAM_ANALOG (1<<4) /* camera with analog CCD */
  275. #define I2C_CLASS_CAM_DIGITAL (1<<5) /* most webcams */
  276. #define I2C_CLASS_SOUND (1<<6) /* sound devices */
  277. #define I2C_CLASS_ALL (UINT_MAX) /* all of the above */
  279. /* i2c_client_address_data is the struct for holding default client
  280.  * addresses for a driver and for the parameters supplied on the
  281.  * command line
  282.  */
  283. struct i2c_client_address_data {
  284. unsigned short *normal_i2c;
  285. unsigned short *probe;
  286. unsigned short *ignore;
  287. unsigned short **forces;
  288. };
  290. /* Internal numbers to terminate lists */
  291. #define I2C_CLIENT_END 0xfffeU
  293. /* The numbers to use to set I2C bus address */
  294. #define ANY_I2C_BUS 0xffff
  295. #define ANY_I2C_ISA_BUS 9191
  298. /* ----- functions exported by i2c.o */
  300. /* administration...
  301.  */
  302. extern int i2c_add_adapter(struct i2c_adapter *);
  303. extern int i2c_del_adapter(struct i2c_adapter *);
  305. extern int i2c_add_driver(struct i2c_driver *);
  306. extern int i2c_del_driver(struct i2c_driver *);
  308. extern int i2c_attach_client(struct i2c_client *);
  309. extern int i2c_detach_client(struct i2c_client *);
  311. /* New function: This is to get an i2c_client-struct for controlling the 
  312.    client either by using i2c_control-function or having the 
  313.    client-module export functions that can be used with the i2c_client
  314.    -struct. */
  315. extern struct i2c_client *i2c_get_client(int driver_id, int adapter_id, 
  316. struct i2c_client *prev);
  318. /* Should be used with new function
  319.    extern struct i2c_client *i2c_get_client(int,int,struct i2c_client *);
  320.    to make sure that client-struct is valid and that it is okay to access
  321.    the i2c-client. 
  322.    returns -EACCES if client doesn't allow use (default)
  323.    returns -EBUSY if client doesn't allow multiple use (default) and 
  324.    usage_count >0 */
  325. extern int i2c_use_client(struct i2c_client *);
  326. extern int i2c_release_client(struct i2c_client *);
  328. /* call the i2c_client->command() of all attached clients with
  329.  * the given arguments */
  330. extern void i2c_clients_command(struct i2c_adapter *adap,
  331. unsigned int cmd, void *arg);
  333. /* returns -EBUSY if address has been taken, 0 if not. Note that the only
  334.    other place at which this is called is within i2c_attach_client; so
  335.    you can cheat by simply not registering. Not recommended, of course! */
  336. extern int i2c_check_addr (struct i2c_adapter *adapter, int addr);
  338. /* Detect function. It iterates over all possible addresses itself.
  339.  * It will only call found_proc if some client is connected at the
  340.  * specific address (unless a 'force' matched);
  341.  */
  342. extern int i2c_probe(struct i2c_adapter *adapter, 
  343. struct i2c_client_address_data *address_data,
  344. int (*found_proc) (struct i2c_adapter *, int, int));
  346. /* An ioctl like call to set div. parameters of the adapter.
  347.  */
  348. extern int i2c_control(struct i2c_client *,unsigned int, unsigned long);
  350. extern struct i2c_adapter* i2c_get_adapter(int id);
  351. extern void i2c_put_adapter(struct i2c_adapter *adap);
  354. /* Return the functionality mask */
  355. static inline u32 i2c_get_functionality(struct i2c_adapter *adap)
  356. {
  357. return adap->algo->functionality(adap);
  358. }
  360. /* Return 1 if adapter supports everything we need, 0 if not. */
  361. static inline int i2c_check_functionality(struct i2c_adapter *adap, u32 func)
  362. {
  363. return (func & i2c_get_functionality(adap)) == func;
  364. }
  366. /* Return id number for a specific adapter */
  367. static inline int i2c_adapter_id(struct i2c_adapter *adap)
  368. {
  369. return adap->nr;
  370. }
  372. /*
  373.  * I2C Message - used for pure i2c transaction, also from /dev interface
  374.  */
  375. struct i2c_msg {
  376. __u16 addr; /* slave address */
  377.   __u16 flags;
  378. #define I2C_M_TEN 0x10 /* we have a ten bit chip address */
  379. #define I2C_M_RD 0x01
  380. #define I2C_M_NOSTART 0x4000
  381. #define I2C_M_REV_DIR_ADDR 0x2000
  382. #define I2C_M_IGNORE_NAK 0x1000
  383. #define I2C_M_NO_RD_ACK 0x0800
  384.   __u16 len; /* msg length */
  385.   __u8 *buf; /* pointer to msg data */
  386. };
  388. /* To determine what functionality is present */
  390. #define I2C_FUNC_I2C 0x00000001
  391. #define I2C_FUNC_10BIT_ADDR 0x00000002
  392. #define I2C_FUNC_PROTOCOL_MANGLING 0x00000004 /* I2C_M_{REV_DIR_ADDR,NOSTART,..} */
  393. #define I2C_FUNC_SMBUS_HWPEC_CALC 0x00000008 /* SMBus 2.0 */
  394. #define I2C_FUNC_SMBUS_READ_WORD_DATA_PEC  0x00000800 /* SMBus 2.0 */ 
  395. #define I2C_FUNC_SMBUS_WRITE_WORD_DATA_PEC 0x00001000 /* SMBus 2.0 */ 
  396. #define I2C_FUNC_SMBUS_PROC_CALL_PEC 0x00002000 /* SMBus 2.0 */
  397. #define I2C_FUNC_SMBUS_BLOCK_PROC_CALL_PEC 0x00004000 /* SMBus 2.0 */
  398. #define I2C_FUNC_SMBUS_BLOCK_PROC_CALL 0x00008000 /* SMBus 2.0 */
  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 /* I2C-like block xfer  */
  410. #define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK 0x08000000 /* w/ 1-byte reg. addr. */
  411. #define I2C_FUNC_SMBUS_READ_I2C_BLOCK_2  0x10000000 /* I2C-like block xfer  */
  412. #define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2 0x20000000 /* w/ 2-byte reg. addr. */
  413. #define I2C_FUNC_SMBUS_READ_BLOCK_DATA_PEC  0x40000000 /* SMBus 2.0 */
  414. #define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC 0x80000000 /* SMBus 2.0 */
  416. #define I2C_FUNC_SMBUS_BYTE (I2C_FUNC_SMBUS_READ_BYTE | 
  417.                              I2C_FUNC_SMBUS_WRITE_BYTE)
  418. #define I2C_FUNC_SMBUS_BYTE_DATA (I2C_FUNC_SMBUS_READ_BYTE_DATA | 
  419.                                   I2C_FUNC_SMBUS_WRITE_BYTE_DATA)
  420. #define I2C_FUNC_SMBUS_WORD_DATA (I2C_FUNC_SMBUS_READ_WORD_DATA | 
  421.                                   I2C_FUNC_SMBUS_WRITE_WORD_DATA)
  422. #define I2C_FUNC_SMBUS_BLOCK_DATA (I2C_FUNC_SMBUS_READ_BLOCK_DATA | 
  423.                                    I2C_FUNC_SMBUS_WRITE_BLOCK_DATA)
  424. #define I2C_FUNC_SMBUS_I2C_BLOCK (I2C_FUNC_SMBUS_READ_I2C_BLOCK | 
  425.                                   I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)
  426. #define I2C_FUNC_SMBUS_I2C_BLOCK_2 (I2C_FUNC_SMBUS_READ_I2C_BLOCK_2 | 
  427.                                     I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2)
  428. #define I2C_FUNC_SMBUS_BLOCK_DATA_PEC (I2C_FUNC_SMBUS_READ_BLOCK_DATA_PEC | 
  429.                                        I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC)
  430. #define I2C_FUNC_SMBUS_WORD_DATA_PEC  (I2C_FUNC_SMBUS_READ_WORD_DATA_PEC | 
  431.                                        I2C_FUNC_SMBUS_WRITE_WORD_DATA_PEC)
  433. #define I2C_FUNC_SMBUS_READ_BYTE_PEC I2C_FUNC_SMBUS_READ_BYTE_DATA
  434. #define I2C_FUNC_SMBUS_WRITE_BYTE_PEC I2C_FUNC_SMBUS_WRITE_BYTE_DATA
  435. #define I2C_FUNC_SMBUS_READ_BYTE_DATA_PEC I2C_FUNC_SMBUS_READ_WORD_DATA
  436. #define I2C_FUNC_SMBUS_WRITE_BYTE_DATA_PEC I2C_FUNC_SMBUS_WRITE_WORD_DATA
  437. #define I2C_FUNC_SMBUS_BYTE_PEC I2C_FUNC_SMBUS_BYTE_DATA
  438. #define I2C_FUNC_SMBUS_BYTE_DATA_PEC I2C_FUNC_SMBUS_WORD_DATA
  440. #define I2C_FUNC_SMBUS_EMUL (I2C_FUNC_SMBUS_QUICK | 
  441.                              I2C_FUNC_SMBUS_BYTE | 
  442.                              I2C_FUNC_SMBUS_BYTE_DATA | 
  443.                              I2C_FUNC_SMBUS_WORD_DATA | 
  444.                              I2C_FUNC_SMBUS_PROC_CALL | 
  445.                              I2C_FUNC_SMBUS_WRITE_BLOCK_DATA | 
  446.                              I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC | 
  447.                              I2C_FUNC_SMBUS_I2C_BLOCK)
  449. /* 
  450.  * Data for SMBus Messages 
  451.  */
  452. #define I2C_SMBUS_BLOCK_MAX 32 /* As specified in SMBus standard */
  453. #define I2C_SMBUS_I2C_BLOCK_MAX 32 /* Not specified but we use same structure */
  454. union i2c_smbus_data {
  455. __u8 byte;
  456. __u16 word;
  457. __u8 block[I2C_SMBUS_BLOCK_MAX + 3]; /* block[0] is used for length */
  458.                           /* one more for read length in block process call */
  459.                                             /* and one more for PEC */
  460. };
  462. /* smbus_access read or write markers */
  463. #define I2C_SMBUS_READ 1
  464. #define I2C_SMBUS_WRITE 0
  466. /* SMBus transaction types (size parameter in the above functions) 
  467.    Note: these no longer correspond to the (arbitrary) PIIX4 internal codes! */
  468. #define I2C_SMBUS_QUICK     0
  469. #define I2C_SMBUS_BYTE     1
  470. #define I2C_SMBUS_BYTE_DATA     2 
  471. #define I2C_SMBUS_WORD_DATA     3
  472. #define I2C_SMBUS_PROC_CALL     4
  473. #define I2C_SMBUS_BLOCK_DATA     5
  474. #define I2C_SMBUS_I2C_BLOCK_DATA    6
  475. #define I2C_SMBUS_BLOCK_PROC_CALL   7 /* SMBus 2.0 */
  476. #define I2C_SMBUS_BLOCK_DATA_PEC    8 /* SMBus 2.0 */
  477. #define I2C_SMBUS_PROC_CALL_PEC     9 /* SMBus 2.0 */
  478. #define I2C_SMBUS_BLOCK_PROC_CALL_PEC  10 /* SMBus 2.0 */
  479. #define I2C_SMBUS_WORD_DATA_PEC    11 /* SMBus 2.0 */
  482. /* ----- commands for the ioctl like i2c_command call:
  483.  * note that additional calls are defined in the algorithm and hw 
  484.  * dependent layers - these can be listed here, or see the 
  485.  * corresponding header files.
  486.  */
  487. /* -> bit-adapter specific ioctls */
  488. #define I2C_RETRIES 0x0701 /* number of times a device address      */
  489. /* should be polled when not            */
  490.                                 /* acknowledging  */
  491. #define I2C_TIMEOUT 0x0702 /* set timeout - call with int  */
  494. /* this is for i2c-dev.c */
  495. #define I2C_SLAVE 0x0703 /* Change slave address */
  496. /* Attn.: Slave address is 7 or 10 bits */
  497. #define I2C_SLAVE_FORCE 0x0706 /* Change slave address */
  498. /* Attn.: Slave address is 7 or 10 bits */
  499. /* This changes the address, even if it */
  500. /* is already taken! */
  501. #define I2C_TENBIT 0x0704 /* 0 for 7 bit addrs, != 0 for 10 bit */
  503. #define I2C_FUNCS 0x0705 /* Get the adapter functionality */
  504. #define I2C_RDWR 0x0707 /* Combined R/W transfer (one stop only)*/
  505. #define I2C_PEC 0x0708 /* != 0 for SMBus PEC                   */
  507. #define I2C_SMBUS 0x0720 /* SMBus-level access */
  509. /* ... algo-bit.c recognizes */
  510. #define I2C_UDELAY 0x0705 /* set delay in microsecs between each */
  511. /* written byte (except address) */
  512. #define I2C_MDELAY 0x0706 /* millisec delay between written bytes */
  514. /* ----- I2C-DEV: char device interface stuff ------------------------- */
  516. #define I2C_MAJOR 89 /* Device major number */
  518. /* These defines are used for probing i2c client addresses */
  519. /* The length of the option lists */
  520. #define I2C_CLIENT_MAX_OPTS 48
  522. /* Default fill of many variables */
  523. #define I2C_CLIENT_DEFAULTS {I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  524.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  525.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  526.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  527.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  528.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  529.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  530.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  531.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  532.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  533.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  534.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  535.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  536.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  537.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, 
  538.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END}
  540. /* I2C_CLIENT_MODULE_PARM creates a module parameter, and puts it in the
  541.    module header */
  543. #define I2C_CLIENT_MODULE_PARM(var,desc) 
  544.   static unsigned short var[I2C_CLIENT_MAX_OPTS] = I2C_CLIENT_DEFAULTS; 
  545.   static unsigned int var##_num; 
  546.   module_param_array(var, short, &var##_num, 0); 
  547.   MODULE_PARM_DESC(var,desc)
  549. #define I2C_CLIENT_MODULE_PARM_FORCE(name)
  550. I2C_CLIENT_MODULE_PARM(force_##name,
  551.        "List of adapter,address pairs which are "
  552.        "unquestionably assumed to contain a `"
  553.        # name "' chip")
  556. #define I2C_CLIENT_INSMOD_COMMON
  557. I2C_CLIENT_MODULE_PARM(probe, "List of adapter,address pairs to scan "
  558.        "additionally");
  559. I2C_CLIENT_MODULE_PARM(ignore, "List of adapter,address pairs not to "
  560.        "scan");
  561. static struct i2c_client_address_data addr_data = {
  562. .normal_i2c = normal_i2c,
  563. .probe = probe,
  564. .ignore = ignore,
  565. .forces = forces,
  566. }
  568. /* These are the ones you want to use in your own drivers. Pick the one
  569.    which matches the number of devices the driver differenciates between. */
  570. #define I2C_CLIENT_INSMOD 
  571.   I2C_CLIENT_MODULE_PARM(force, 
  572.                       "List of adapter,address pairs to boldly assume " 
  573.                       "to be present"); 
  574. static unsigned short *forces[] = {
  575. force,
  576. NULL
  577. };
  578. I2C_CLIENT_INSMOD_COMMON
  580. #define I2C_CLIENT_INSMOD_1(chip1)
  581. enum chips { any_chip, chip1 };
  582. I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to "
  583.        "boldly assume to be present");
  584. I2C_CLIENT_MODULE_PARM_FORCE(chip1);
  585. static unsigned short *forces[] = { force, force_##chip1, NULL };
  586. I2C_CLIENT_INSMOD_COMMON
  588. #define I2C_CLIENT_INSMOD_2(chip1, chip2)
  589. enum chips { any_chip, chip1, chip2 };
  590. I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to "
  591.        "boldly assume to be present");
  592. I2C_CLIENT_MODULE_PARM_FORCE(chip1);
  593. I2C_CLIENT_MODULE_PARM_FORCE(chip2);
  594. static unsigned short *forces[] = { force, force_##chip1,
  595.     force_##chip2, NULL };
  596. I2C_CLIENT_INSMOD_COMMON
  598. #define I2C_CLIENT_INSMOD_3(chip1, chip2, chip3)
  599. enum chips { any_chip, chip1, chip2, chip3 };
  600. I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to "
  601.        "boldly assume to be present");
  602. I2C_CLIENT_MODULE_PARM_FORCE(chip1);
  603. I2C_CLIENT_MODULE_PARM_FORCE(chip2);
  604. I2C_CLIENT_MODULE_PARM_FORCE(chip3);
  605. static unsigned short *forces[] = { force, force_##chip1,
  606.     force_##chip2, force_##chip3,
  607.     NULL };
  608. I2C_CLIENT_INSMOD_COMMON
  610. #define I2C_CLIENT_INSMOD_4(chip1, chip2, chip3, chip4)
  611. enum chips { any_chip, chip1, chip2, chip3, chip4 };
  612. I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to "
  613.        "boldly assume to be present");
  614. I2C_CLIENT_MODULE_PARM_FORCE(chip1);
  615. I2C_CLIENT_MODULE_PARM_FORCE(chip2);
  616. I2C_CLIENT_MODULE_PARM_FORCE(chip3);
  617. I2C_CLIENT_MODULE_PARM_FORCE(chip4);
  618. static unsigned short *forces[] = { force, force_##chip1,
  619.     force_##chip2, force_##chip3,
  620.     force_##chip4, NULL};
  621. I2C_CLIENT_INSMOD_COMMON
  623. #define I2C_CLIENT_INSMOD_5(chip1, chip2, chip3, chip4, chip5)
  624. enum chips { any_chip, chip1, chip2, chip3, chip4, chip5 };
  625. I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to "
  626.        "boldly assume to be present");
  627. I2C_CLIENT_MODULE_PARM_FORCE(chip1);
  628. I2C_CLIENT_MODULE_PARM_FORCE(chip2);
  629. I2C_CLIENT_MODULE_PARM_FORCE(chip3);
  630. I2C_CLIENT_MODULE_PARM_FORCE(chip4);
  631. I2C_CLIENT_MODULE_PARM_FORCE(chip5);
  632. static unsigned short *forces[] = { force, force_##chip1,
  633.     force_##chip2, force_##chip3,
  634.     force_##chip4, force_##chip5,
  635.     NULL };
  636. I2C_CLIENT_INSMOD_COMMON
  638. #define I2C_CLIENT_INSMOD_6(chip1, chip2, chip3, chip4, chip5, chip6)
  639. enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6 };
  640. I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to "
  641.        "boldly assume to be present");
  642. I2C_CLIENT_MODULE_PARM_FORCE(chip1);
  643. I2C_CLIENT_MODULE_PARM_FORCE(chip2);
  644. I2C_CLIENT_MODULE_PARM_FORCE(chip3);
  645. I2C_CLIENT_MODULE_PARM_FORCE(chip4);
  646. I2C_CLIENT_MODULE_PARM_FORCE(chip5);
  647. I2C_CLIENT_MODULE_PARM_FORCE(chip6);
  648. static unsigned short *forces[] = { force, force_##chip1,
  649.     force_##chip2, force_##chip3,
  650.     force_##chip4, force_##chip5,
  651.     force_##chip6, NULL };
  652. I2C_CLIENT_INSMOD_COMMON
  654. #define I2C_CLIENT_INSMOD_7(chip1, chip2, chip3, chip4, chip5, chip6, chip7) 
  655. enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6,
  656.      chip7 };
  657. I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to "
  658.        "boldly assume to be present");
  659. I2C_CLIENT_MODULE_PARM_FORCE(chip1);
  660. I2C_CLIENT_MODULE_PARM_FORCE(chip2);
  661. I2C_CLIENT_MODULE_PARM_FORCE(chip3);
  662. I2C_CLIENT_MODULE_PARM_FORCE(chip4);
  663. I2C_CLIENT_MODULE_PARM_FORCE(chip5);
  664. I2C_CLIENT_MODULE_PARM_FORCE(chip6);
  665. I2C_CLIENT_MODULE_PARM_FORCE(chip7);
  666. static unsigned short *forces[] = { force, force_##chip1,
  667.     force_##chip2, force_##chip3,
  668.     force_##chip4, force_##chip5,
  669.     force_##chip6, force_##chip7,
  670.     NULL };
  671. I2C_CLIENT_INSMOD_COMMON
  673. #define I2C_CLIENT_INSMOD_8(chip1, chip2, chip3, chip4, chip5, chip6, chip7, chip8) 
  674. enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6,
  675.      chip7, chip8 };
  676. I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to "
  677.        "boldly assume to be present");
  678. I2C_CLIENT_MODULE_PARM_FORCE(chip1);
  679. I2C_CLIENT_MODULE_PARM_FORCE(chip2);
  680. I2C_CLIENT_MODULE_PARM_FORCE(chip3);
  681. I2C_CLIENT_MODULE_PARM_FORCE(chip4);
  682. I2C_CLIENT_MODULE_PARM_FORCE(chip5);
  683. I2C_CLIENT_MODULE_PARM_FORCE(chip6);
  684. I2C_CLIENT_MODULE_PARM_FORCE(chip7);
  685. I2C_CLIENT_MODULE_PARM_FORCE(chip8);
  686. static unsigned short *forces[] = { force, force_##chip1,
  687.     force_##chip2, force_##chip3,
  688.     force_##chip4, force_##chip5,
  689.     force_##chip6, force_##chip7,
  690.     force_##chip8, NULL };
  691. I2C_CLIENT_INSMOD_COMMON
  693. #endif /* _LINUX_I2C_H */