i2c.h 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620
  1. /* ------------------------------------------------------------------------- */
  2. /* */
  3. /* i2c.h - definitions for the i2c-bus interface */
  4. /* */
  5. /* ------------------------------------------------------------------------- */
  6. /* Copyright (C) 1995-2000 Simon G. Vogl
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. GNU General Public License for more details.
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  18. MA 02110-1301 USA. */
  19. /* ------------------------------------------------------------------------- */
  20. /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and
  21. Frodo Looijaard <frodol@dds.nl> */
  22. #ifndef _LINUX_I2C_H
  23. #define _LINUX_I2C_H
  24. #include <linux/types.h>
  25. #ifdef __KERNEL__
  26. #include <linux/mod_devicetable.h>
  27. #include <linux/device.h> /* for struct device */
  28. #include <linux/sched.h> /* for completion */
  29. #include <linux/mutex.h>
  30. #include <linux/of.h> /* for struct device_node */
  31. #include <linux/swab.h> /* for swab16 */
  32. extern struct bus_type i2c_bus_type;
  33. extern struct device_type i2c_adapter_type;
  34. /* --- General options ------------------------------------------------ */
  35. struct i2c_msg;
  36. struct i2c_algorithm;
  37. struct i2c_adapter;
  38. struct i2c_client;
  39. struct i2c_driver;
  40. union i2c_smbus_data;
  41. struct i2c_board_info;
  42. struct module;
  43. #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
  44. /*
  45. * The master routines are the ones normally used to transmit data to devices
  46. * on a bus (or read from them). Apart from two basic transfer functions to
  47. * transmit one message at a time, a more complex version can be used to
  48. * transmit an arbitrary number of messages without interruption.
  49. * @count must be be less than 64k since msg.len is u16.
  50. */
  51. extern int i2c_master_send(const struct i2c_client *client, const char *buf,
  52. int count);
  53. extern int i2c_master_recv(const struct i2c_client *client, char *buf,
  54. int count);
  55. /* Transfer num messages.
  56. */
  57. extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
  58. int num);
  59. /* This is the very generalized SMBus access routine. You probably do not
  60. want to use this, though; one of the functions below may be much easier,
  61. and probably just as fast.
  62. Note that we use i2c_adapter here, because you do not need a specific
  63. smbus adapter to call this function. */
  64. extern s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
  65. unsigned short flags, char read_write, u8 command,
  66. int size, union i2c_smbus_data *data);
  67. /* Now follow the 'nice' access routines. These also document the calling
  68. conventions of i2c_smbus_xfer. */
  69. extern s32 i2c_smbus_read_byte(const struct i2c_client *client);
  70. extern s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value);
  71. extern s32 i2c_smbus_read_byte_data(const struct i2c_client *client,
  72. u8 command);
  73. extern s32 i2c_smbus_write_byte_data(const struct i2c_client *client,
  74. u8 command, u8 value);
  75. extern s32 i2c_smbus_read_word_data(const struct i2c_client *client,
  76. u8 command);
  77. extern s32 i2c_smbus_write_word_data(const struct i2c_client *client,
  78. u8 command, u16 value);
  79. static inline s32
  80. i2c_smbus_read_word_swapped(const struct i2c_client *client, u8 command)
  81. {
  82. s32 value = i2c_smbus_read_word_data(client, command);
  83. return (value < 0) ? value : swab16(value);
  84. }
  85. static inline s32
  86. i2c_smbus_write_word_swapped(const struct i2c_client *client,
  87. u8 command, u16 value)
  88. {
  89. return i2c_smbus_write_word_data(client, command, swab16(value));
  90. }
  91. /* Returns the number of read bytes */
  92. extern s32 i2c_smbus_read_block_data(const struct i2c_client *client,
  93. u8 command, u8 *values);
  94. extern s32 i2c_smbus_write_block_data(const struct i2c_client *client,
  95. u8 command, u8 length, const u8 *values);
  96. /* Returns the number of read bytes */
  97. extern s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client,
  98. u8 command, u8 length, u8 *values);
  99. extern s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client,
  100. u8 command, u8 length,
  101. const u8 *values);
  102. #endif /* I2C */
  103. /**
  104. * struct i2c_driver - represent an I2C device driver
  105. * @class: What kind of i2c device we instantiate (for detect)
  106. * @attach_adapter: Callback for bus addition (deprecated)
  107. * @detach_adapter: Callback for bus removal (deprecated)
  108. * @probe: Callback for device binding
  109. * @remove: Callback for device unbinding
  110. * @shutdown: Callback for device shutdown
  111. * @suspend: Callback for device suspend
  112. * @resume: Callback for device resume
  113. * @alert: Alert callback, for example for the SMBus alert protocol
  114. * @command: Callback for bus-wide signaling (optional)
  115. * @driver: Device driver model driver
  116. * @id_table: List of I2C devices supported by this driver
  117. * @detect: Callback for device detection
  118. * @address_list: The I2C addresses to probe (for detect)
  119. * @clients: List of detected clients we created (for i2c-core use only)
  120. *
  121. * The driver.owner field should be set to the module owner of this driver.
  122. * The driver.name field should be set to the name of this driver.
  123. *
  124. * For automatic device detection, both @detect and @address_data must
  125. * be defined. @class should also be set, otherwise only devices forced
  126. * with module parameters will be created. The detect function must
  127. * fill at least the name field of the i2c_board_info structure it is
  128. * handed upon successful detection, and possibly also the flags field.
  129. *
  130. * If @detect is missing, the driver will still work fine for enumerated
  131. * devices. Detected devices simply won't be supported. This is expected
  132. * for the many I2C/SMBus devices which can't be detected reliably, and
  133. * the ones which can always be enumerated in practice.
  134. *
  135. * The i2c_client structure which is handed to the @detect callback is
  136. * not a real i2c_client. It is initialized just enough so that you can
  137. * call i2c_smbus_read_byte_data and friends on it. Don't do anything
  138. * else with it. In particular, calling dev_dbg and friends on it is
  139. * not allowed.
  140. */
  141. struct i2c_driver {
  142. unsigned int class;
  143. /* Notifies the driver that a new bus has appeared or is about to be
  144. * removed. You should avoid using this, it will be removed in a
  145. * near future.
  146. */
  147. int (*attach_adapter)(struct i2c_adapter *) __deprecated;
  148. int (*detach_adapter)(struct i2c_adapter *) __deprecated;
  149. /* Standard driver model interfaces */
  150. int (*probe)(struct i2c_client *, const struct i2c_device_id *);
  151. int (*remove)(struct i2c_client *);
  152. /* driver model interfaces that don't relate to enumeration */
  153. void (*shutdown)(struct i2c_client *);
  154. int (*suspend)(struct i2c_client *, pm_message_t mesg);
  155. int (*resume)(struct i2c_client *);
  156. /* Alert callback, for example for the SMBus alert protocol.
  157. * The format and meaning of the data value depends on the protocol.
  158. * For the SMBus alert protocol, there is a single bit of data passed
  159. * as the alert response's low bit ("event flag").
  160. */
  161. void (*alert)(struct i2c_client *, unsigned int data);
  162. /* a ioctl like command that can be used to perform specific functions
  163. * with the device.
  164. */
  165. int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
  166. struct device_driver driver;
  167. const struct i2c_device_id *id_table;
  168. /* Device detection callback for automatic device creation */
  169. int (*detect)(struct i2c_client *, struct i2c_board_info *);
  170. const unsigned short *address_list;
  171. struct list_head clients;
  172. };
  173. #define to_i2c_driver(d) container_of(d, struct i2c_driver, driver)
  174. /**
  175. * struct i2c_client - represent an I2C slave device
  176. * @flags: I2C_CLIENT_TEN indicates the device uses a ten bit chip address;
  177. * I2C_CLIENT_PEC indicates it uses SMBus Packet Error Checking
  178. * @addr: Address used on the I2C bus connected to the parent adapter.
  179. * @name: Indicates the type of the device, usually a chip name that's
  180. * generic enough to hide second-sourcing and compatible revisions.
  181. * @adapter: manages the bus segment hosting this I2C device
  182. * @driver: device's driver, hence pointer to access routines
  183. * @dev: Driver model device node for the slave.
  184. * @irq: indicates the IRQ generated by this device (if any)
  185. * @detected: member of an i2c_driver.clients list or i2c-core's
  186. * userspace_devices list
  187. *
  188. * An i2c_client identifies a single device (i.e. chip) connected to an
  189. * i2c bus. The behaviour exposed to Linux is defined by the driver
  190. * managing the device.
  191. */
  192. struct i2c_client {
  193. unsigned short flags; /* div., see below */
  194. unsigned short addr; /* chip address - NOTE: 7bit */
  195. /* addresses are stored in the */
  196. /* _LOWER_ 7 bits */
  197. char name[I2C_NAME_SIZE];
  198. struct i2c_adapter *adapter; /* the adapter we sit on */
  199. struct i2c_driver *driver; /* and our access routines */
  200. struct device dev; /* the device structure */
  201. int irq; /* irq issued by device */
  202. struct list_head detected;
  203. };
  204. #define to_i2c_client(d) container_of(d, struct i2c_client, dev)
  205. extern struct i2c_client *i2c_verify_client(struct device *dev);
  206. static inline struct i2c_client *kobj_to_i2c_client(struct kobject *kobj)
  207. {
  208. struct device * const dev = container_of(kobj, struct device, kobj);
  209. return to_i2c_client(dev);
  210. }
  211. static inline void *i2c_get_clientdata(const struct i2c_client *dev)
  212. {
  213. return dev_get_drvdata(&dev->dev);
  214. }
  215. static inline void i2c_set_clientdata(struct i2c_client *dev, void *data)
  216. {
  217. dev_set_drvdata(&dev->dev, data);
  218. }
  219. /**
  220. * struct i2c_board_info - template for device creation
  221. * @type: chip type, to initialize i2c_client.name
  222. * @flags: to initialize i2c_client.flags
  223. * @addr: stored in i2c_client.addr
  224. * @platform_data: stored in i2c_client.dev.platform_data
  225. * @archdata: copied into i2c_client.dev.archdata
  226. * @of_node: pointer to OpenFirmware device node
  227. * @irq: stored in i2c_client.irq
  228. *
  229. * I2C doesn't actually support hardware probing, although controllers and
  230. * devices may be able to use I2C_SMBUS_QUICK to tell whether or not there's
  231. * a device at a given address. Drivers commonly need more information than
  232. * that, such as chip type, configuration, associated IRQ, and so on.
  233. *
  234. * i2c_board_info is used to build tables of information listing I2C devices
  235. * that are present. This information is used to grow the driver model tree.
  236. * For mainboards this is done statically using i2c_register_board_info();
  237. * bus numbers identify adapters that aren't yet available. For add-on boards,
  238. * i2c_new_device() does this dynamically with the adapter already known.
  239. */
  240. struct i2c_board_info {
  241. char type[I2C_NAME_SIZE];
  242. unsigned short flags;
  243. unsigned short addr;
  244. void *platform_data;
  245. struct dev_archdata *archdata;
  246. struct device_node *of_node;
  247. int irq;
  248. };
  249. /**
  250. * I2C_BOARD_INFO - macro used to list an i2c device and its address
  251. * @dev_type: identifies the device type
  252. * @dev_addr: the device's address on the bus.
  253. *
  254. * This macro initializes essential fields of a struct i2c_board_info,
  255. * declaring what has been provided on a particular board. Optional
  256. * fields (such as associated irq, or device-specific platform_data)
  257. * are provided using conventional syntax.
  258. */
  259. #define I2C_BOARD_INFO(dev_type, dev_addr) \
  260. .type = dev_type, .addr = (dev_addr)
  261. #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
  262. /* Add-on boards should register/unregister their devices; e.g. a board
  263. * with integrated I2C, a config eeprom, sensors, and a codec that's
  264. * used in conjunction with the primary hardware.
  265. */
  266. extern struct i2c_client *
  267. i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info);
  268. /* If you don't know the exact address of an I2C device, use this variant
  269. * instead, which can probe for device presence in a list of possible
  270. * addresses. The "probe" callback function is optional. If it is provided,
  271. * it must return 1 on successful probe, 0 otherwise. If it is not provided,
  272. * a default probing method is used.
  273. */
  274. extern struct i2c_client *
  275. i2c_new_probed_device(struct i2c_adapter *adap,
  276. struct i2c_board_info *info,
  277. unsigned short const *addr_list,
  278. int (*probe)(struct i2c_adapter *, unsigned short addr));
  279. /* Common custom probe functions */
  280. extern int i2c_probe_func_quick_read(struct i2c_adapter *, unsigned short addr);
  281. /* For devices that use several addresses, use i2c_new_dummy() to make
  282. * client handles for the extra addresses.
  283. */
  284. extern struct i2c_client *
  285. i2c_new_dummy(struct i2c_adapter *adap, u16 address);
  286. extern void i2c_unregister_device(struct i2c_client *);
  287. #endif /* I2C */
  288. /* Mainboard arch_initcall() code should register all its I2C devices.
  289. * This is done at arch_initcall time, before declaring any i2c adapters.
  290. * Modules for add-on boards must use other calls.
  291. */
  292. #ifdef CONFIG_I2C_BOARDINFO
  293. extern int
  294. i2c_register_board_info(int busnum, struct i2c_board_info const *info,
  295. unsigned n);
  296. #else
  297. static inline int
  298. i2c_register_board_info(int busnum, struct i2c_board_info const *info,
  299. unsigned n)
  300. {
  301. return 0;
  302. }
  303. #endif /* I2C_BOARDINFO */
  304. /*
  305. * The following structs are for those who like to implement new bus drivers:
  306. * i2c_algorithm is the interface to a class of hardware solutions which can
  307. * be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584
  308. * to name two of the most common.
  309. */
  310. struct i2c_algorithm {
  311. /* If an adapter algorithm can't do I2C-level access, set master_xfer
  312. to NULL. If an adapter algorithm can do SMBus access, set
  313. smbus_xfer. If set to NULL, the SMBus protocol is simulated
  314. using common I2C messages */
  315. /* master_xfer should return the number of messages successfully
  316. processed, or a negative value on error */
  317. int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,
  318. int num);
  319. int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,
  320. unsigned short flags, char read_write,
  321. u8 command, int size, union i2c_smbus_data *data);
  322. /* To determine what the adapter supports */
  323. u32 (*functionality) (struct i2c_adapter *);
  324. };
  325. /*
  326. * i2c_adapter is the structure used to identify a physical i2c bus along
  327. * with the access algorithms necessary to access it.
  328. */
  329. struct i2c_adapter {
  330. struct module *owner;
  331. unsigned int class; /* classes to allow probing for */
  332. const struct i2c_algorithm *algo; /* the algorithm to access the bus */
  333. void *algo_data;
  334. /* data fields that are valid for all devices */
  335. struct rt_mutex bus_lock;
  336. int timeout; /* in jiffies */
  337. int retries;
  338. struct device dev; /* the adapter device */
  339. int nr;
  340. char name[48];
  341. struct completion dev_released;
  342. struct mutex userspace_clients_lock;
  343. struct list_head userspace_clients;
  344. };
  345. #define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
  346. static inline void *i2c_get_adapdata(const struct i2c_adapter *dev)
  347. {
  348. return dev_get_drvdata(&dev->dev);
  349. }
  350. static inline void i2c_set_adapdata(struct i2c_adapter *dev, void *data)
  351. {
  352. dev_set_drvdata(&dev->dev, data);
  353. }
  354. static inline struct i2c_adapter *
  355. i2c_parent_is_i2c_adapter(const struct i2c_adapter *adapter)
  356. {
  357. struct device *parent = adapter->dev.parent;
  358. if (parent != NULL && parent->type == &i2c_adapter_type)
  359. return to_i2c_adapter(parent);
  360. else
  361. return NULL;
  362. }
  363. int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *));
  364. /* Adapter locking functions, exported for shared pin cases */
  365. void i2c_lock_adapter(struct i2c_adapter *);
  366. void i2c_unlock_adapter(struct i2c_adapter *);
  367. /*flags for the client struct: */
  368. #define I2C_CLIENT_PEC 0x04 /* Use Packet Error Checking */
  369. #define I2C_CLIENT_TEN 0x10 /* we have a ten bit chip address */
  370. /* Must equal I2C_M_TEN below */
  371. #define I2C_CLIENT_WAKE 0x80 /* for board_info; true iff can wake */
  372. /* i2c adapter classes (bitmask) */
  373. #define I2C_CLASS_HWMON (1<<0) /* lm_sensors, ... */
  374. #define I2C_CLASS_DDC (1<<3) /* DDC bus on graphics adapters */
  375. #define I2C_CLASS_SPD (1<<7) /* Memory modules */
  376. /* Internal numbers to terminate lists */
  377. #define I2C_CLIENT_END 0xfffeU
  378. /* Construct an I2C_CLIENT_END-terminated array of i2c addresses */
  379. #define I2C_ADDRS(addr, addrs...) \
  380. ((const unsigned short []){ addr, ## addrs, I2C_CLIENT_END })
  381. /* ----- functions exported by i2c.o */
  382. /* administration...
  383. */
  384. #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
  385. extern int i2c_add_adapter(struct i2c_adapter *);
  386. extern int i2c_del_adapter(struct i2c_adapter *);
  387. extern int i2c_add_numbered_adapter(struct i2c_adapter *);
  388. extern int i2c_register_driver(struct module *, struct i2c_driver *);
  389. extern void i2c_del_driver(struct i2c_driver *);
  390. /* use a define to avoid include chaining to get THIS_MODULE */
  391. #define i2c_add_driver(driver) \
  392. i2c_register_driver(THIS_MODULE, driver)
  393. extern struct i2c_client *i2c_use_client(struct i2c_client *client);
  394. extern void i2c_release_client(struct i2c_client *client);
  395. /* call the i2c_client->command() of all attached clients with
  396. * the given arguments */
  397. extern void i2c_clients_command(struct i2c_adapter *adap,
  398. unsigned int cmd, void *arg);
  399. extern struct i2c_adapter *i2c_get_adapter(int nr);
  400. extern void i2c_put_adapter(struct i2c_adapter *adap);
  401. /* Return the functionality mask */
  402. static inline u32 i2c_get_functionality(struct i2c_adapter *adap)
  403. {
  404. return adap->algo->functionality(adap);
  405. }
  406. /* Return 1 if adapter supports everything we need, 0 if not. */
  407. static inline int i2c_check_functionality(struct i2c_adapter *adap, u32 func)
  408. {
  409. return (func & i2c_get_functionality(adap)) == func;
  410. }
  411. /* Return the adapter number for a specific adapter */
  412. static inline int i2c_adapter_id(struct i2c_adapter *adap)
  413. {
  414. return adap->nr;
  415. }
  416. /**
  417. * module_i2c_driver() - Helper macro for registering a I2C driver
  418. * @__i2c_driver: i2c_driver struct
  419. *
  420. * Helper macro for I2C drivers which do not do anything special in module
  421. * init/exit. This eliminates a lot of boilerplate. Each module may only
  422. * use this macro once, and calling it replaces module_init() and module_exit()
  423. */
  424. #define module_i2c_driver(__i2c_driver) \
  425. module_driver(__i2c_driver, i2c_add_driver, \
  426. i2c_del_driver)
  427. #endif /* I2C */
  428. #endif /* __KERNEL__ */
  429. /**
  430. * struct i2c_msg - an I2C transaction segment beginning with START
  431. * @addr: Slave address, either seven or ten bits. When this is a ten
  432. * bit address, I2C_M_TEN must be set in @flags and the adapter
  433. * must support I2C_FUNC_10BIT_ADDR.
  434. * @flags: I2C_M_RD is handled by all adapters. No other flags may be
  435. * provided unless the adapter exported the relevant I2C_FUNC_*
  436. * flags through i2c_check_functionality().
  437. * @len: Number of data bytes in @buf being read from or written to the
  438. * I2C slave address. For read transactions where I2C_M_RECV_LEN
  439. * is set, the caller guarantees that this buffer can hold up to
  440. * 32 bytes in addition to the initial length byte sent by the
  441. * slave (plus, if used, the SMBus PEC); and this value will be
  442. * incremented by the number of block data bytes received.
  443. * @buf: The buffer into which data is read, or from which it's written.
  444. *
  445. * An i2c_msg is the low level representation of one segment of an I2C
  446. * transaction. It is visible to drivers in the @i2c_transfer() procedure,
  447. * to userspace from i2c-dev, and to I2C adapter drivers through the
  448. * @i2c_adapter.@master_xfer() method.
  449. *
  450. * Except when I2C "protocol mangling" is used, all I2C adapters implement
  451. * the standard rules for I2C transactions. Each transaction begins with a
  452. * START. That is followed by the slave address, and a bit encoding read
  453. * versus write. Then follow all the data bytes, possibly including a byte
  454. * with SMBus PEC. The transfer terminates with a NAK, or when all those
  455. * bytes have been transferred and ACKed. If this is the last message in a
  456. * group, it is followed by a STOP. Otherwise it is followed by the next
  457. * @i2c_msg transaction segment, beginning with a (repeated) START.
  458. *
  459. * Alternatively, when the adapter supports I2C_FUNC_PROTOCOL_MANGLING then
  460. * passing certain @flags may have changed those standard protocol behaviors.
  461. * Those flags are only for use with broken/nonconforming slaves, and with
  462. * adapters which are known to support the specific mangling options they
  463. * need (one or more of IGNORE_NAK, NO_RD_ACK, NOSTART, and REV_DIR_ADDR).
  464. */
  465. struct i2c_msg {
  466. __u16 addr; /* slave address */
  467. __u16 flags;
  468. #define I2C_M_TEN 0x0010 /* this is a ten bit chip address */
  469. #define I2C_M_RD 0x0001 /* read data, from slave to master */
  470. #define I2C_M_NOSTART 0x4000 /* if I2C_FUNC_PROTOCOL_MANGLING */
  471. #define I2C_M_REV_DIR_ADDR 0x2000 /* if I2C_FUNC_PROTOCOL_MANGLING */
  472. #define I2C_M_IGNORE_NAK 0x1000 /* if I2C_FUNC_PROTOCOL_MANGLING */
  473. #define I2C_M_NO_RD_ACK 0x0800 /* if I2C_FUNC_PROTOCOL_MANGLING */
  474. #define I2C_M_RECV_LEN 0x0400 /* length will be first received byte */
  475. __u16 len; /* msg length */
  476. __u8 *buf; /* pointer to msg data */
  477. };
  478. /* To determine what functionality is present */
  479. #define I2C_FUNC_I2C 0x00000001
  480. #define I2C_FUNC_10BIT_ADDR 0x00000002
  481. #define I2C_FUNC_PROTOCOL_MANGLING 0x00000004 /* I2C_M_NOSTART etc. */
  482. #define I2C_FUNC_SMBUS_PEC 0x00000008
  483. #define I2C_FUNC_SMBUS_BLOCK_PROC_CALL 0x00008000 /* SMBus 2.0 */
  484. #define I2C_FUNC_SMBUS_QUICK 0x00010000
  485. #define I2C_FUNC_SMBUS_READ_BYTE 0x00020000
  486. #define I2C_FUNC_SMBUS_WRITE_BYTE 0x00040000
  487. #define I2C_FUNC_SMBUS_READ_BYTE_DATA 0x00080000
  488. #define I2C_FUNC_SMBUS_WRITE_BYTE_DATA 0x00100000
  489. #define I2C_FUNC_SMBUS_READ_WORD_DATA 0x00200000
  490. #define I2C_FUNC_SMBUS_WRITE_WORD_DATA 0x00400000
  491. #define I2C_FUNC_SMBUS_PROC_CALL 0x00800000
  492. #define I2C_FUNC_SMBUS_READ_BLOCK_DATA 0x01000000
  493. #define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA 0x02000000
  494. #define I2C_FUNC_SMBUS_READ_I2C_BLOCK 0x04000000 /* I2C-like block xfer */
  495. #define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK 0x08000000 /* w/ 1-byte reg. addr. */
  496. #define I2C_FUNC_SMBUS_BYTE (I2C_FUNC_SMBUS_READ_BYTE | \
  497. I2C_FUNC_SMBUS_WRITE_BYTE)
  498. #define I2C_FUNC_SMBUS_BYTE_DATA (I2C_FUNC_SMBUS_READ_BYTE_DATA | \
  499. I2C_FUNC_SMBUS_WRITE_BYTE_DATA)
  500. #define I2C_FUNC_SMBUS_WORD_DATA (I2C_FUNC_SMBUS_READ_WORD_DATA | \
  501. I2C_FUNC_SMBUS_WRITE_WORD_DATA)
  502. #define I2C_FUNC_SMBUS_BLOCK_DATA (I2C_FUNC_SMBUS_READ_BLOCK_DATA | \
  503. I2C_FUNC_SMBUS_WRITE_BLOCK_DATA)
  504. #define I2C_FUNC_SMBUS_I2C_BLOCK (I2C_FUNC_SMBUS_READ_I2C_BLOCK | \
  505. I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)
  506. #define I2C_FUNC_SMBUS_EMUL (I2C_FUNC_SMBUS_QUICK | \
  507. I2C_FUNC_SMBUS_BYTE | \
  508. I2C_FUNC_SMBUS_BYTE_DATA | \
  509. I2C_FUNC_SMBUS_WORD_DATA | \
  510. I2C_FUNC_SMBUS_PROC_CALL | \
  511. I2C_FUNC_SMBUS_WRITE_BLOCK_DATA | \
  512. I2C_FUNC_SMBUS_I2C_BLOCK | \
  513. I2C_FUNC_SMBUS_PEC)
  514. /*
  515. * Data for SMBus Messages
  516. */
  517. #define I2C_SMBUS_BLOCK_MAX 32 /* As specified in SMBus standard */
  518. union i2c_smbus_data {
  519. __u8 byte;
  520. __u16 word;
  521. __u8 block[I2C_SMBUS_BLOCK_MAX + 2]; /* block[0] is used for length */
  522. /* and one more for user-space compatibility */
  523. };
  524. /* i2c_smbus_xfer read or write markers */
  525. #define I2C_SMBUS_READ 1
  526. #define I2C_SMBUS_WRITE 0
  527. /* SMBus transaction types (size parameter in the above functions)
  528. Note: these no longer correspond to the (arbitrary) PIIX4 internal codes! */
  529. #define I2C_SMBUS_QUICK 0
  530. #define I2C_SMBUS_BYTE 1
  531. #define I2C_SMBUS_BYTE_DATA 2
  532. #define I2C_SMBUS_WORD_DATA 3
  533. #define I2C_SMBUS_PROC_CALL 4
  534. #define I2C_SMBUS_BLOCK_DATA 5
  535. #define I2C_SMBUS_I2C_BLOCK_BROKEN 6
  536. #define I2C_SMBUS_BLOCK_PROC_CALL 7 /* SMBus 2.0 */
  537. #define I2C_SMBUS_I2C_BLOCK_DATA 8
  538. #endif /* _LINUX_I2C_H */