i2c.h 20.3 KB
Newer Older
L
Linus Torvalds 已提交
1
/* ------------------------------------------------------------------------- */
D
David Brownell 已提交
2
/*									     */
L
Linus Torvalds 已提交
3
/* i2c.h - definitions for the i2c-bus interface			     */
D
David Brownell 已提交
4
/*									     */
L
Linus Torvalds 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/* ------------------------------------------------------------------------- */
/*   Copyright (C) 1995-2000 Simon G. Vogl

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
J
Jean Delvare 已提交
20 21
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
    MA 02110-1301 USA.							     */
L
Linus Torvalds 已提交
22 23
/* ------------------------------------------------------------------------- */

24
/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and
L
Linus Torvalds 已提交
25 26 27 28
   Frodo Looijaard <frodol@dds.nl> */
#ifndef _LINUX_I2C_H
#define _LINUX_I2C_H

29
#include <linux/mod_devicetable.h>
L
Linus Torvalds 已提交
30
#include <linux/device.h>	/* for struct device */
T
Tim Schmielau 已提交
31
#include <linux/sched.h>	/* for completion */
32
#include <linux/mutex.h>
33
#include <linux/of.h>		/* for struct device_node */
34
#include <linux/swab.h>		/* for swab16 */
35
#include <uapi/linux/i2c.h>
L
Linus Torvalds 已提交
36

J
Jon Smirl 已提交
37
extern struct bus_type i2c_bus_type;
38
extern struct device_type i2c_adapter_type;
J
Jon Smirl 已提交
39

L
Linus Torvalds 已提交
40 41 42 43 44 45 46 47
/* --- General options ------------------------------------------------	*/

struct i2c_msg;
struct i2c_algorithm;
struct i2c_adapter;
struct i2c_client;
struct i2c_driver;
union i2c_smbus_data;
48
struct i2c_board_info;
L
Linus Torvalds 已提交
49

50 51
struct module;

52
#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
L
Linus Torvalds 已提交
53 54
/*
 * The master routines are the ones normally used to transmit data to devices
D
David Brownell 已提交
55 56
 * on a bus (or read from them). Apart from two basic transfer functions to
 * transmit one message at a time, a more complex version can be used to
L
Linus Torvalds 已提交
57
 * transmit an arbitrary number of messages without interruption.
58
 * @count must be be less than 64k since msg.len is u16.
L
Linus Torvalds 已提交
59
 */
60 61 62
extern int i2c_master_send(const struct i2c_client *client, const char *buf,
			   int count);
extern int i2c_master_recv(const struct i2c_client *client, char *buf,
J
Jean Delvare 已提交
63
			   int count);
L
Linus Torvalds 已提交
64 65 66

/* Transfer num messages.
 */
J
Jean Delvare 已提交
67 68
extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
			int num);
69 70 71
/* Unlocked flavor */
extern int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
			  int num);
L
Linus Torvalds 已提交
72 73 74

/* This is the very generalized SMBus access routine. You probably do not
   want to use this, though; one of the functions below may be much easier,
D
David Brownell 已提交
75
   and probably just as fast.
L
Linus Torvalds 已提交
76 77
   Note that we use i2c_adapter here, because you do not need a specific
   smbus adapter to call this function. */
J
Jean Delvare 已提交
78 79 80
extern s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
			  unsigned short flags, char read_write, u8 command,
			  int size, union i2c_smbus_data *data);
L
Linus Torvalds 已提交
81 82

/* Now follow the 'nice' access routines. These also document the calling
83
   conventions of i2c_smbus_xfer. */
L
Linus Torvalds 已提交
84

85 86 87 88 89
extern s32 i2c_smbus_read_byte(const struct i2c_client *client);
extern s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value);
extern s32 i2c_smbus_read_byte_data(const struct i2c_client *client,
				    u8 command);
extern s32 i2c_smbus_write_byte_data(const struct i2c_client *client,
J
Jean Delvare 已提交
90
				     u8 command, u8 value);
91 92 93
extern s32 i2c_smbus_read_word_data(const struct i2c_client *client,
				    u8 command);
extern s32 i2c_smbus_write_word_data(const struct i2c_client *client,
J
Jean Delvare 已提交
94
				     u8 command, u16 value);
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110

static inline s32
i2c_smbus_read_word_swapped(const struct i2c_client *client, u8 command)
{
	s32 value = i2c_smbus_read_word_data(client, command);

	return (value < 0) ? value : swab16(value);
}

static inline s32
i2c_smbus_write_word_swapped(const struct i2c_client *client,
			     u8 command, u16 value)
{
	return i2c_smbus_write_word_data(client, command, swab16(value));
}

111
/* Returns the number of read bytes */
112
extern s32 i2c_smbus_read_block_data(const struct i2c_client *client,
113
				     u8 command, u8 *values);
114
extern s32 i2c_smbus_write_block_data(const struct i2c_client *client,
J
Jean Delvare 已提交
115
				      u8 command, u8 length, const u8 *values);
116
/* Returns the number of read bytes */
117
extern s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client,
118
					 u8 command, u8 length, u8 *values);
119
extern s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client,
120
					  u8 command, u8 length,
121
					  const u8 *values);
122
#endif /* I2C */
L
Linus Torvalds 已提交
123

124 125 126
/**
 * struct i2c_driver - represent an I2C device driver
 * @class: What kind of i2c device we instantiate (for detect)
127 128
 * @attach_adapter: Callback for bus addition (deprecated)
 * @detach_adapter: Callback for bus removal (deprecated)
129 130
 * @probe: Callback for device binding
 * @remove: Callback for device unbinding
131 132 133
 * @shutdown: Callback for device shutdown
 * @suspend: Callback for device suspend
 * @resume: Callback for device resume
R
Randy Dunlap 已提交
134
 * @alert: Alert callback, for example for the SMBus alert protocol
135 136 137
 * @command: Callback for bus-wide signaling (optional)
 * @driver: Device driver model driver
 * @id_table: List of I2C devices supported by this driver
138
 * @detect: Callback for device detection
139
 * @address_list: The I2C addresses to probe (for detect)
140
 * @clients: List of detected clients we created (for i2c-core use only)
141 142 143
 *
 * The driver.owner field should be set to the module owner of this driver.
 * The driver.name field should be set to the name of this driver.
144
 *
145
 * For automatic device detection, both @detect and @address_list must
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
 * be defined. @class should also be set, otherwise only devices forced
 * with module parameters will be created. The detect function must
 * fill at least the name field of the i2c_board_info structure it is
 * handed upon successful detection, and possibly also the flags field.
 *
 * If @detect is missing, the driver will still work fine for enumerated
 * devices. Detected devices simply won't be supported. This is expected
 * for the many I2C/SMBus devices which can't be detected reliably, and
 * the ones which can always be enumerated in practice.
 *
 * The i2c_client structure which is handed to the @detect callback is
 * not a real i2c_client. It is initialized just enough so that you can
 * call i2c_smbus_read_byte_data and friends on it. Don't do anything
 * else with it. In particular, calling dev_dbg and friends on it is
 * not allowed.
L
Linus Torvalds 已提交
161 162 163 164
 */
struct i2c_driver {
	unsigned int class;

165
	/* Notifies the driver that a new bus has appeared or is about to be
166 167
	 * removed. You should avoid using this, it will be removed in a
	 * near future.
L
Linus Torvalds 已提交
168
	 */
169 170
	int (*attach_adapter)(struct i2c_adapter *) __deprecated;
	int (*detach_adapter)(struct i2c_adapter *) __deprecated;
L
Linus Torvalds 已提交
171

172
	/* Standard driver model interfaces */
173
	int (*probe)(struct i2c_client *, const struct i2c_device_id *);
D
David Brownell 已提交
174
	int (*remove)(struct i2c_client *);
D
David Brownell 已提交
175

176 177 178 179 180
	/* driver model interfaces that don't relate to enumeration  */
	void (*shutdown)(struct i2c_client *);
	int (*suspend)(struct i2c_client *, pm_message_t mesg);
	int (*resume)(struct i2c_client *);

J
Jean Delvare 已提交
181 182 183 184 185 186 187
	/* Alert callback, for example for the SMBus alert protocol.
	 * The format and meaning of the data value depends on the protocol.
	 * For the SMBus alert protocol, there is a single bit of data passed
	 * as the alert response's low bit ("event flag").
	 */
	void (*alert)(struct i2c_client *, unsigned int data);

L
Linus Torvalds 已提交
188 189 190
	/* a ioctl like command that can be used to perform specific functions
	 * with the device.
	 */
J
Jean Delvare 已提交
191
	int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
L
Linus Torvalds 已提交
192 193

	struct device_driver driver;
194
	const struct i2c_device_id *id_table;
195 196

	/* Device detection callback for automatic device creation */
197
	int (*detect)(struct i2c_client *, struct i2c_board_info *);
198
	const unsigned short *address_list;
199
	struct list_head clients;
L
Linus Torvalds 已提交
200 201 202
};
#define to_i2c_driver(d) container_of(d, struct i2c_driver, driver)

D
David Brownell 已提交
203 204
/**
 * struct i2c_client - represent an I2C slave device
D
David Brownell 已提交
205 206
 * @flags: I2C_CLIENT_TEN indicates the device uses a ten bit chip address;
 *	I2C_CLIENT_PEC indicates it uses SMBus Packet Error Checking
D
David Brownell 已提交
207 208 209
 * @addr: Address used on the I2C bus connected to the parent adapter.
 * @name: Indicates the type of the device, usually a chip name that's
 *	generic enough to hide second-sourcing and compatible revisions.
D
David Brownell 已提交
210
 * @adapter: manages the bus segment hosting this I2C device
R
Randy Dunlap 已提交
211
 * @driver: device's driver, hence pointer to access routines
D
David Brownell 已提交
212
 * @dev: Driver model device node for the slave.
D
David Brownell 已提交
213
 * @irq: indicates the IRQ generated by this device (if any)
214 215
 * @detected: member of an i2c_driver.clients list or i2c-core's
 *	userspace_devices list
D
David Brownell 已提交
216 217
 *
 * An i2c_client identifies a single device (i.e. chip) connected to an
D
David Brownell 已提交
218 219
 * i2c bus. The behaviour exposed to Linux is defined by the driver
 * managing the device.
L
Linus Torvalds 已提交
220 221
 */
struct i2c_client {
D
David Brownell 已提交
222
	unsigned short flags;		/* div., see below		*/
D
David Brownell 已提交
223
	unsigned short addr;		/* chip address - NOTE: 7bit	*/
L
Linus Torvalds 已提交
224
					/* addresses are stored in the	*/
225
					/* _LOWER_ 7 bits		*/
D
David Brownell 已提交
226
	char name[I2C_NAME_SIZE];
L
Linus Torvalds 已提交
227 228 229
	struct i2c_adapter *adapter;	/* the adapter we sit on	*/
	struct i2c_driver *driver;	/* and our access routines	*/
	struct device dev;		/* the device structure		*/
230
	int irq;			/* irq issued by device		*/
231
	struct list_head detected;
L
Linus Torvalds 已提交
232 233 234
};
#define to_i2c_client(d) container_of(d, struct i2c_client, dev)

235
extern struct i2c_client *i2c_verify_client(struct device *dev);
236
extern struct i2c_adapter *i2c_verify_adapter(struct device *dev);
237

238 239
static inline struct i2c_client *kobj_to_i2c_client(struct kobject *kobj)
{
240 241
	struct device * const dev = container_of(kobj, struct device, kobj);
	return to_i2c_client(dev);
242 243
}

244
static inline void *i2c_get_clientdata(const struct i2c_client *dev)
L
Linus Torvalds 已提交
245
{
J
Jean Delvare 已提交
246
	return dev_get_drvdata(&dev->dev);
L
Linus Torvalds 已提交
247 248
}

J
Jean Delvare 已提交
249
static inline void i2c_set_clientdata(struct i2c_client *dev, void *data)
L
Linus Torvalds 已提交
250
{
J
Jean Delvare 已提交
251
	dev_set_drvdata(&dev->dev, data);
L
Linus Torvalds 已提交
252 253
}

254 255
/**
 * struct i2c_board_info - template for device creation
256
 * @type: chip type, to initialize i2c_client.name
257 258 259
 * @flags: to initialize i2c_client.flags
 * @addr: stored in i2c_client.addr
 * @platform_data: stored in i2c_client.dev.platform_data
A
Anton Vorontsov 已提交
260
 * @archdata: copied into i2c_client.dev.archdata
R
Randy Dunlap 已提交
261
 * @of_node: pointer to OpenFirmware device node
262
 * @acpi_node: ACPI device node
263
 * @irq: stored in i2c_client.irq
D
David Brownell 已提交
264
 *
265 266 267 268 269 270
 * I2C doesn't actually support hardware probing, although controllers and
 * devices may be able to use I2C_SMBUS_QUICK to tell whether or not there's
 * a device at a given address.  Drivers commonly need more information than
 * that, such as chip type, configuration, associated IRQ, and so on.
 *
 * i2c_board_info is used to build tables of information listing I2C devices
271 272 273 274
 * that are present.  This information is used to grow the driver model tree.
 * For mainboards this is done statically using i2c_register_board_info();
 * bus numbers identify adapters that aren't yet available.  For add-on boards,
 * i2c_new_device() does this dynamically with the adapter already known.
275 276 277 278 279 280
 */
struct i2c_board_info {
	char		type[I2C_NAME_SIZE];
	unsigned short	flags;
	unsigned short	addr;
	void		*platform_data;
A
Anton Vorontsov 已提交
281
	struct dev_archdata	*archdata;
282
	struct device_node *of_node;
283
	struct acpi_dev_node acpi_node;
284 285 286 287
	int		irq;
};

/**
288 289
 * I2C_BOARD_INFO - macro used to list an i2c device and its address
 * @dev_type: identifies the device type
290 291 292 293
 * @dev_addr: the device's address on the bus.
 *
 * This macro initializes essential fields of a struct i2c_board_info,
 * declaring what has been provided on a particular board.  Optional
294 295
 * fields (such as associated irq, or device-specific platform_data)
 * are provided using conventional syntax.
296
 */
J
Jean Delvare 已提交
297
#define I2C_BOARD_INFO(dev_type, dev_addr) \
298
	.type = dev_type, .addr = (dev_addr)
299 300


301
#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
302 303 304 305 306 307 308
/* Add-on boards should register/unregister their devices; e.g. a board
 * with integrated I2C, a config eeprom, sensors, and a codec that's
 * used in conjunction with the primary hardware.
 */
extern struct i2c_client *
i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info);

J
Jean Delvare 已提交
309 310
/* If you don't know the exact address of an I2C device, use this variant
 * instead, which can probe for device presence in a list of possible
311 312 313
 * addresses. The "probe" callback function is optional. If it is provided,
 * it must return 1 on successful probe, 0 otherwise. If it is not provided,
 * a default probing method is used.
J
Jean Delvare 已提交
314 315 316 317
 */
extern struct i2c_client *
i2c_new_probed_device(struct i2c_adapter *adap,
		      struct i2c_board_info *info,
318 319
		      unsigned short const *addr_list,
		      int (*probe)(struct i2c_adapter *, unsigned short addr));
J
Jean Delvare 已提交
320

321 322 323
/* Common custom probe functions */
extern int i2c_probe_func_quick_read(struct i2c_adapter *, unsigned short addr);

324 325 326 327
/* For devices that use several addresses, use i2c_new_dummy() to make
 * client handles for the extra addresses.
 */
extern struct i2c_client *
J
Jean Delvare 已提交
328
i2c_new_dummy(struct i2c_adapter *adap, u16 address);
329

330
extern void i2c_unregister_device(struct i2c_client *);
331
#endif /* I2C */
332 333 334 335 336

/* Mainboard arch_initcall() code should register all its I2C devices.
 * This is done at arch_initcall time, before declaring any i2c adapters.
 * Modules for add-on boards must use other calls.
 */
337
#ifdef CONFIG_I2C_BOARDINFO
338
extern int
J
Jean Delvare 已提交
339 340
i2c_register_board_info(int busnum, struct i2c_board_info const *info,
			unsigned n);
341 342
#else
static inline int
J
Jean Delvare 已提交
343 344
i2c_register_board_info(int busnum, struct i2c_board_info const *info,
			unsigned n)
345 346 347
{
	return 0;
}
348
#endif /* I2C_BOARDINFO */
349

L
Linus Torvalds 已提交
350 351 352 353 354 355 356 357
/*
 * The following structs are for those who like to implement new bus drivers:
 * i2c_algorithm is the interface to a class of hardware solutions which can
 * be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584
 * to name two of the most common.
 */
struct i2c_algorithm {
	/* If an adapter algorithm can't do I2C-level access, set master_xfer
D
David Brownell 已提交
358
	   to NULL. If an adapter algorithm can do SMBus access, set
L
Linus Torvalds 已提交
359 360
	   smbus_xfer. If set to NULL, the SMBus protocol is simulated
	   using common I2C messages */
361 362
	/* master_xfer should return the number of messages successfully
	   processed, or a negative value on error */
J
Jean Delvare 已提交
363 364
	int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,
			   int num);
D
David Brownell 已提交
365
	int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,
J
Jean Delvare 已提交
366 367
			   unsigned short flags, char read_write,
			   u8 command, int size, union i2c_smbus_data *data);
L
Linus Torvalds 已提交
368 369 370 371 372

	/* To determine what the adapter supports */
	u32 (*functionality) (struct i2c_adapter *);
};

373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
/**
 * struct i2c_bus_recovery_info - I2C bus recovery information
 * @recover_bus: Recover routine. Either pass driver's recover_bus() routine, or
 *	i2c_generic_scl_recovery() or i2c_generic_gpio_recovery().
 * @get_scl: This gets current value of SCL line. Mandatory for generic SCL
 *      recovery. Used internally for generic GPIO recovery.
 * @set_scl: This sets/clears SCL line. Mandatory for generic SCL recovery. Used
 *      internally for generic GPIO recovery.
 * @get_sda: This gets current value of SDA line. Optional for generic SCL
 *      recovery. Used internally, if sda_gpio is a valid GPIO, for generic GPIO
 *      recovery.
 * @prepare_recovery: This will be called before starting recovery. Platform may
 *	configure padmux here for SDA/SCL line or something else they want.
 * @unprepare_recovery: This will be called after completing recovery. Platform
 *	may configure padmux here for SDA/SCL line or something else they want.
 * @scl_gpio: gpio number of the SCL line. Only required for GPIO recovery.
 * @sda_gpio: gpio number of the SDA line. Only required for GPIO recovery.
 */
struct i2c_bus_recovery_info {
	int (*recover_bus)(struct i2c_adapter *);

	int (*get_scl)(struct i2c_adapter *);
	void (*set_scl)(struct i2c_adapter *, int val);
	int (*get_sda)(struct i2c_adapter *);

	void (*prepare_recovery)(struct i2c_bus_recovery_info *bri);
	void (*unprepare_recovery)(struct i2c_bus_recovery_info *bri);

	/* gpio recovery */
	int scl_gpio;
	int sda_gpio;
};

int i2c_recover_bus(struct i2c_adapter *adap);

/* Generic recovery routines */
int i2c_generic_gpio_recovery(struct i2c_adapter *adap);
int i2c_generic_scl_recovery(struct i2c_adapter *adap);

L
Linus Torvalds 已提交
412 413 414 415 416 417
/*
 * i2c_adapter is the structure used to identify a physical i2c bus along
 * with the access algorithms necessary to access it.
 */
struct i2c_adapter {
	struct module *owner;
418
	unsigned int class;		  /* classes to allow probing for */
419
	const struct i2c_algorithm *algo; /* the algorithm to access the bus */
L
Linus Torvalds 已提交
420 421 422
	void *algo_data;

	/* data fields that are valid for all devices	*/
423
	struct rt_mutex bus_lock;
L
Linus Torvalds 已提交
424

425
	int timeout;			/* in jiffies */
L
Linus Torvalds 已提交
426 427 428 429
	int retries;
	struct device dev;		/* the adapter device */

	int nr;
D
David Brownell 已提交
430
	char name[48];
L
Linus Torvalds 已提交
431
	struct completion dev_released;
432

433
	struct mutex userspace_clients_lock;
434
	struct list_head userspace_clients;
435 436

	struct i2c_bus_recovery_info *bus_recovery_info;
L
Linus Torvalds 已提交
437
};
438
#define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
L
Linus Torvalds 已提交
439

440
static inline void *i2c_get_adapdata(const struct i2c_adapter *dev)
L
Linus Torvalds 已提交
441
{
J
Jean Delvare 已提交
442
	return dev_get_drvdata(&dev->dev);
L
Linus Torvalds 已提交
443 444
}

J
Jean Delvare 已提交
445
static inline void i2c_set_adapdata(struct i2c_adapter *dev, void *data)
L
Linus Torvalds 已提交
446
{
J
Jean Delvare 已提交
447
	dev_set_drvdata(&dev->dev, data);
L
Linus Torvalds 已提交
448 449
}

450 451
static inline struct i2c_adapter *
i2c_parent_is_i2c_adapter(const struct i2c_adapter *adapter)
452
{
453 454 455 456 457 458
	struct device *parent = adapter->dev.parent;

	if (parent != NULL && parent->type == &i2c_adapter_type)
		return to_i2c_adapter(parent);
	else
		return NULL;
459 460
}

J
Jean Delvare 已提交
461 462
int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *));

463 464 465
/* Adapter locking functions, exported for shared pin cases */
void i2c_lock_adapter(struct i2c_adapter *);
void i2c_unlock_adapter(struct i2c_adapter *);
466

L
Linus Torvalds 已提交
467
/*flags for the client struct: */
468 469 470 471
#define I2C_CLIENT_PEC	0x04		/* Use Packet Error Checking */
#define I2C_CLIENT_TEN	0x10		/* we have a ten bit chip address */
					/* Must equal I2C_M_TEN below */
#define I2C_CLIENT_WAKE	0x80		/* for board_info; true iff can wake */
L
Laurent Pinchart 已提交
472 473
#define I2C_CLIENT_SCCB	0x9000		/* Use Omnivision SCCB protocol */
					/* Must match I2C_M_STOP|IGNORE_NAK */
L
Linus Torvalds 已提交
474 475 476

/* i2c adapter classes (bitmask) */
#define I2C_CLASS_HWMON		(1<<0)	/* lm_sensors, ... */
477
#define I2C_CLASS_DDC		(1<<3)	/* DDC bus on graphics adapters */
478
#define I2C_CLASS_SPD		(1<<7)	/* Memory modules */
L
Linus Torvalds 已提交
479 480 481 482

/* Internal numbers to terminate lists */
#define I2C_CLIENT_END		0xfffeU

483 484 485 486
/* Construct an I2C_CLIENT_END-terminated array of i2c addresses */
#define I2C_ADDRS(addr, addrs...) \
	((const unsigned short []){ addr, ## addrs, I2C_CLIENT_END })

L
Linus Torvalds 已提交
487 488 489 490 491

/* ----- functions exported by i2c.o */

/* administration...
 */
492
#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
L
Linus Torvalds 已提交
493 494
extern int i2c_add_adapter(struct i2c_adapter *);
extern int i2c_del_adapter(struct i2c_adapter *);
495
extern int i2c_add_numbered_adapter(struct i2c_adapter *);
L
Linus Torvalds 已提交
496

497
extern int i2c_register_driver(struct module *, struct i2c_driver *);
498
extern void i2c_del_driver(struct i2c_driver *);
L
Linus Torvalds 已提交
499

500 501 502
/* use a define to avoid include chaining to get THIS_MODULE */
#define i2c_add_driver(driver) \
	i2c_register_driver(THIS_MODULE, driver)
503

504 505
extern struct i2c_client *i2c_use_client(struct i2c_client *client);
extern void i2c_release_client(struct i2c_client *client);
L
Linus Torvalds 已提交
506 507 508 509 510 511

/* call the i2c_client->command() of all attached clients with
 * the given arguments */
extern void i2c_clients_command(struct i2c_adapter *adap,
				unsigned int cmd, void *arg);

512
extern struct i2c_adapter *i2c_get_adapter(int nr);
L
Linus Torvalds 已提交
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527
extern void i2c_put_adapter(struct i2c_adapter *adap);


/* Return the functionality mask */
static inline u32 i2c_get_functionality(struct i2c_adapter *adap)
{
	return adap->algo->functionality(adap);
}

/* Return 1 if adapter supports everything we need, 0 if not. */
static inline int i2c_check_functionality(struct i2c_adapter *adap, u32 func)
{
	return (func & i2c_get_functionality(adap)) == func;
}

J
Jean Delvare 已提交
528
/* Return the adapter number for a specific adapter */
529 530 531 532
static inline int i2c_adapter_id(struct i2c_adapter *adap)
{
	return adap->nr;
}
533 534 535 536 537 538 539 540 541 542 543 544 545

/**
 * module_i2c_driver() - Helper macro for registering a I2C driver
 * @__i2c_driver: i2c_driver struct
 *
 * Helper macro for I2C drivers which do not do anything special in module
 * init/exit. This eliminates a lot of boilerplate. Each module may only
 * use this macro once, and calling it replaces module_init() and module_exit()
 */
#define module_i2c_driver(__i2c_driver) \
	module_driver(__i2c_driver, i2c_add_driver, \
			i2c_del_driver)

546
#endif /* I2C */
547 548 549 550 551 552 553

#if IS_ENABLED(CONFIG_ACPI_I2C)
extern void acpi_i2c_register_devices(struct i2c_adapter *adap);
#else
static inline void acpi_i2c_register_devices(struct i2c_adapter *adap) {}
#endif

L
Linus Torvalds 已提交
554
#endif /* _LINUX_I2C_H */