i2c.h 20.2 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
 * @attach_adapter: Callback for bus addition (deprecated)
128 129
 * @probe: Callback for device binding
 * @remove: Callback for device unbinding
130 131 132
 * @shutdown: Callback for device shutdown
 * @suspend: Callback for device suspend
 * @resume: Callback for device resume
R
Randy Dunlap 已提交
133
 * @alert: Alert callback, for example for the SMBus alert protocol
134 135 136
 * @command: Callback for bus-wide signaling (optional)
 * @driver: Device driver model driver
 * @id_table: List of I2C devices supported by this driver
137
 * @detect: Callback for device detection
138
 * @address_list: The I2C addresses to probe (for detect)
139
 * @clients: List of detected clients we created (for i2c-core use only)
140 141 142
 *
 * 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.
143
 *
144
 * For automatic device detection, both @detect and @address_list must
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
 * 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 已提交
160 161 162 163
 */
struct i2c_driver {
	unsigned int class;

L
Lars-Peter Clausen 已提交
164 165
	/* Notifies the driver that a new bus has appeared. You should avoid
	 * using this, it will be removed in a near future.
L
Linus Torvalds 已提交
166
	 */
167
	int (*attach_adapter)(struct i2c_adapter *) __deprecated;
L
Linus Torvalds 已提交
168

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

173 174 175 176 177
	/* 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 已提交
178 179 180 181 182 183 184
	/* 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 已提交
185 186 187
	/* a ioctl like command that can be used to perform specific functions
	 * with the device.
	 */
J
Jean Delvare 已提交
188
	int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
L
Linus Torvalds 已提交
189 190

	struct device_driver driver;
191
	const struct i2c_device_id *id_table;
192 193

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

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

232
extern struct i2c_client *i2c_verify_client(struct device *dev);
233
extern struct i2c_adapter *i2c_verify_adapter(struct device *dev);
234

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

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

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

251 252
/**
 * struct i2c_board_info - template for device creation
253
 * @type: chip type, to initialize i2c_client.name
254 255 256
 * @flags: to initialize i2c_client.flags
 * @addr: stored in i2c_client.addr
 * @platform_data: stored in i2c_client.dev.platform_data
A
Anton Vorontsov 已提交
257
 * @archdata: copied into i2c_client.dev.archdata
R
Randy Dunlap 已提交
258
 * @of_node: pointer to OpenFirmware device node
259
 * @acpi_node: ACPI device node
260
 * @irq: stored in i2c_client.irq
D
David Brownell 已提交
261
 *
262 263 264 265 266 267
 * 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
268 269 270 271
 * 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.
272 273 274 275 276 277
 */
struct i2c_board_info {
	char		type[I2C_NAME_SIZE];
	unsigned short	flags;
	unsigned short	addr;
	void		*platform_data;
A
Anton Vorontsov 已提交
278
	struct dev_archdata	*archdata;
279
	struct device_node *of_node;
280
	struct acpi_dev_node acpi_node;
281 282 283 284
	int		irq;
};

/**
285 286
 * I2C_BOARD_INFO - macro used to list an i2c device and its address
 * @dev_type: identifies the device type
287 288 289 290
 * @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
291 292
 * fields (such as associated irq, or device-specific platform_data)
 * are provided using conventional syntax.
293
 */
J
Jean Delvare 已提交
294
#define I2C_BOARD_INFO(dev_type, dev_addr) \
295
	.type = dev_type, .addr = (dev_addr)
296 297


298
#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
299 300 301 302 303 304 305
/* 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 已提交
306 307
/* 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
308 309 310
 * 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 已提交
311 312 313 314
 */
extern struct i2c_client *
i2c_new_probed_device(struct i2c_adapter *adap,
		      struct i2c_board_info *info,
315 316
		      unsigned short const *addr_list,
		      int (*probe)(struct i2c_adapter *, unsigned short addr));
J
Jean Delvare 已提交
317

318 319 320
/* Common custom probe functions */
extern int i2c_probe_func_quick_read(struct i2c_adapter *, unsigned short addr);

321 322 323 324
/* 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 已提交
325
i2c_new_dummy(struct i2c_adapter *adap, u16 address);
326

327
extern void i2c_unregister_device(struct i2c_client *);
328
#endif /* I2C */
329 330 331 332 333

/* 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.
 */
334
#ifdef CONFIG_I2C_BOARDINFO
335
extern int
J
Jean Delvare 已提交
336 337
i2c_register_board_info(int busnum, struct i2c_board_info const *info,
			unsigned n);
338 339
#else
static inline int
J
Jean Delvare 已提交
340 341
i2c_register_board_info(int busnum, struct i2c_board_info const *info,
			unsigned n)
342 343 344
{
	return 0;
}
345
#endif /* I2C_BOARDINFO */
346

L
Linus Torvalds 已提交
347 348 349 350 351 352 353 354
/*
 * 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 已提交
355
	   to NULL. If an adapter algorithm can do SMBus access, set
L
Linus Torvalds 已提交
356 357
	   smbus_xfer. If set to NULL, the SMBus protocol is simulated
	   using common I2C messages */
358 359
	/* master_xfer should return the number of messages successfully
	   processed, or a negative value on error */
J
Jean Delvare 已提交
360 361
	int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,
			   int num);
D
David Brownell 已提交
362
	int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,
J
Jean Delvare 已提交
363 364
			   unsigned short flags, char read_write,
			   u8 command, int size, union i2c_smbus_data *data);
L
Linus Torvalds 已提交
365 366 367 368 369

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

370 371 372 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
/**
 * 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 已提交
409 410 411 412 413 414
/*
 * 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;
415
	unsigned int class;		  /* classes to allow probing for */
416
	const struct i2c_algorithm *algo; /* the algorithm to access the bus */
L
Linus Torvalds 已提交
417 418 419
	void *algo_data;

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

422
	int timeout;			/* in jiffies */
L
Linus Torvalds 已提交
423 424 425 426
	int retries;
	struct device dev;		/* the adapter device */

	int nr;
D
David Brownell 已提交
427
	char name[48];
L
Linus Torvalds 已提交
428
	struct completion dev_released;
429

430
	struct mutex userspace_clients_lock;
431
	struct list_head userspace_clients;
432 433

	struct i2c_bus_recovery_info *bus_recovery_info;
L
Linus Torvalds 已提交
434
};
435
#define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
L
Linus Torvalds 已提交
436

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

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

447 448
static inline struct i2c_adapter *
i2c_parent_is_i2c_adapter(const struct i2c_adapter *adapter)
449
{
450
#if IS_ENABLED(I2C_MUX)
451 452 453 454 455
	struct device *parent = adapter->dev.parent;

	if (parent != NULL && parent->type == &i2c_adapter_type)
		return to_i2c_adapter(parent);
	else
456
#endif
457
		return NULL;
458 459
}

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

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

L
Linus Torvalds 已提交
466
/*flags for the client struct: */
467 468 469 470
#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 已提交
471 472
#define I2C_CLIENT_SCCB	0x9000		/* Use Omnivision SCCB protocol */
					/* Must match I2C_M_STOP|IGNORE_NAK */
L
Linus Torvalds 已提交
473 474 475

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

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

482 483 484 485
/* 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 已提交
486 487 488 489 490

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

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

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

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

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

/* 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);

511
extern struct i2c_adapter *i2c_get_adapter(int nr);
L
Linus Torvalds 已提交
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526
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 已提交
527
/* Return the adapter number for a specific adapter */
528 529 530 531
static inline int i2c_adapter_id(struct i2c_adapter *adap)
{
	return adap->nr;
}
532 533 534 535 536 537 538 539 540 541 542 543 544

/**
 * 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)

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

#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 已提交
553
#endif /* _LINUX_I2C_H */