Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1/* ------------------------------------------------------------------------- */
2/* */
3/* i2c.h - definitions for the i2c-bus interface */
4/* */
5/* ------------------------------------------------------------------------- */
6/* Copyright (C) 1995-2000 Simon G. Vogl
7
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.
12
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.
17
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/* ------------------------------------------------------------------------- */
22
23/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and
24 Frodo Looijaard <frodol@dds.nl> */
25
26#ifndef _LINUX_I2C_H
27#define _LINUX_I2C_H
28
29#include <linux/types.h>
30#ifdef __KERNEL__
31#include <linux/module.h>
32#include <linux/i2c-id.h>
33#include <linux/mod_devicetable.h>
34#include <linux/device.h> /* for struct device */
35#include <linux/sched.h> /* for completion */
36#include <linux/mutex.h>
37
38/* --- For i2c-isa ---------------------------------------------------- */
39
40extern void i2c_adapter_dev_release(struct device *dev);
41extern struct device_driver i2c_adapter_driver;
42extern struct class i2c_adapter_class;
43extern struct bus_type i2c_bus_type;
44
45/* --- General options ------------------------------------------------ */
46
47struct i2c_msg;
48struct i2c_algorithm;
49struct i2c_adapter;
50struct i2c_client;
51struct i2c_driver;
52union i2c_smbus_data;
53
54/*
55 * The master routines are the ones normally used to transmit data to devices
56 * on a bus (or read from them). Apart from two basic transfer functions to
57 * transmit one message at a time, a more complex version can be used to
58 * transmit an arbitrary number of messages without interruption.
59 */
60extern int i2c_master_send(struct i2c_client *,const char* ,int);
61extern int i2c_master_recv(struct i2c_client *,char* ,int);
62
63/* Transfer num messages.
64 */
65extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);
66
67
68/* This is the very generalized SMBus access routine. You probably do not
69 want to use this, though; one of the functions below may be much easier,
70 and probably just as fast.
71 Note that we use i2c_adapter here, because you do not need a specific
72 smbus adapter to call this function. */
73extern s32 i2c_smbus_xfer (struct i2c_adapter * adapter, u16 addr,
74 unsigned short flags,
75 char read_write, u8 command, int size,
76 union i2c_smbus_data * data);
77
78/* Now follow the 'nice' access routines. These also document the calling
79 conventions of smbus_access. */
80
81extern s32 i2c_smbus_write_quick(struct i2c_client * client, u8 value);
82extern s32 i2c_smbus_read_byte(struct i2c_client * client);
83extern s32 i2c_smbus_write_byte(struct i2c_client * client, u8 value);
84extern s32 i2c_smbus_read_byte_data(struct i2c_client * client, u8 command);
85extern s32 i2c_smbus_write_byte_data(struct i2c_client * client,
86 u8 command, u8 value);
87extern s32 i2c_smbus_read_word_data(struct i2c_client * client, u8 command);
88extern s32 i2c_smbus_write_word_data(struct i2c_client * client,
89 u8 command, u16 value);
90extern s32 i2c_smbus_write_block_data(struct i2c_client * client,
91 u8 command, u8 length,
92 const u8 *values);
93/* Returns the number of read bytes */
94extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client * client,
95 u8 command, u8 *values);
96extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client * client,
97 u8 command, u8 length,
98 const u8 *values);
99
100/*
101 * A driver is capable of handling one or more physical devices present on
102 * I2C adapters. This information is used to inform the driver of adapter
103 * events.
104 *
105 * The driver.owner field should be set to the module owner of this driver.
106 * The driver.name field should be set to the name of this driver.
107 */
108
109struct i2c_driver {
110 int id;
111 unsigned int class;
112
113 /* Notifies the driver that a new bus has appeared. This routine
114 * can be used by the driver to test if the bus meets its conditions
115 * & seek for the presence of the chip(s) it supports. If found, it
116 * registers the client(s) that are on the bus to the i2c admin. via
117 * i2c_attach_client.
118 */
119 int (*attach_adapter)(struct i2c_adapter *);
120 int (*detach_adapter)(struct i2c_adapter *);
121
122 /* tells the driver that a client is about to be deleted & gives it
123 * the chance to remove its private data. Also, if the client struct
124 * has been dynamically allocated by the driver in the function above,
125 * it must be freed here.
126 */
127 int (*detach_client)(struct i2c_client *);
128
129 /* driver model interfaces that don't relate to enumeration */
130 void (*shutdown)(struct i2c_client *);
131 int (*suspend)(struct i2c_client *, pm_message_t mesg);
132 int (*resume)(struct i2c_client *);
133
134 /* a ioctl like command that can be used to perform specific functions
135 * with the device.
136 */
137 int (*command)(struct i2c_client *client,unsigned int cmd, void *arg);
138
139 struct device_driver driver;
140 struct list_head list;
141};
142#define to_i2c_driver(d) container_of(d, struct i2c_driver, driver)
143
144#define I2C_NAME_SIZE 50
145
146/*
147 * i2c_client identifies a single device (i.e. chip) that is connected to an
148 * i2c bus. The behaviour is defined by the routines of the driver. This
149 * function is mainly used for lookup & other admin. functions.
150 */
151struct i2c_client {
152 unsigned int flags; /* div., see below */
153 unsigned short addr; /* chip address - NOTE: 7bit */
154 /* addresses are stored in the */
155 /* _LOWER_ 7 bits */
156 struct i2c_adapter *adapter; /* the adapter we sit on */
157 struct i2c_driver *driver; /* and our access routines */
158 int usage_count; /* How many accesses currently */
159 /* to the client */
160 struct device dev; /* the device structure */
161 struct list_head list;
162 char name[I2C_NAME_SIZE];
163 struct completion released;
164};
165#define to_i2c_client(d) container_of(d, struct i2c_client, dev)
166
167static inline struct i2c_client *kobj_to_i2c_client(struct kobject *kobj)
168{
169 return to_i2c_client(container_of(kobj, struct device, kobj));
170}
171
172static inline void *i2c_get_clientdata (struct i2c_client *dev)
173{
174 return dev_get_drvdata (&dev->dev);
175}
176
177static inline void i2c_set_clientdata (struct i2c_client *dev, void *data)
178{
179 dev_set_drvdata (&dev->dev, data);
180}
181
182/*
183 * The following structs are for those who like to implement new bus drivers:
184 * i2c_algorithm is the interface to a class of hardware solutions which can
185 * be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584
186 * to name two of the most common.
187 */
188struct i2c_algorithm {
189 /* If an adapter algorithm can't do I2C-level access, set master_xfer
190 to NULL. If an adapter algorithm can do SMBus access, set
191 smbus_xfer. If set to NULL, the SMBus protocol is simulated
192 using common I2C messages */
193 /* master_xfer should return the number of messages successfully
194 processed, or a negative value on error */
195 int (*master_xfer)(struct i2c_adapter *adap,struct i2c_msg *msgs,
196 int num);
197 int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,
198 unsigned short flags, char read_write,
199 u8 command, int size, union i2c_smbus_data * data);
200
201 /* --- ioctl like call to set div. parameters. */
202 int (*algo_control)(struct i2c_adapter *, unsigned int, unsigned long);
203
204 /* To determine what the adapter supports */
205 u32 (*functionality) (struct i2c_adapter *);
206};
207
208/*
209 * i2c_adapter is the structure used to identify a physical i2c bus along
210 * with the access algorithms necessary to access it.
211 */
212struct i2c_adapter {
213 struct module *owner;
214 unsigned int id;
215 unsigned int class;
216 const struct i2c_algorithm *algo; /* the algorithm to access the bus */
217 void *algo_data;
218
219 /* --- administration stuff. */
220 int (*client_register)(struct i2c_client *);
221 int (*client_unregister)(struct i2c_client *);
222
223 /* data fields that are valid for all devices */
224 u8 level; /* nesting level for lockdep */
225 struct mutex bus_lock;
226 struct mutex clist_lock;
227
228 int timeout;
229 int retries;
230 struct device dev; /* the adapter device */
231 struct class_device class_dev; /* the class device */
232
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)
242
243static inline void *i2c_get_adapdata (struct i2c_adapter *dev)
244{
245 return dev_get_drvdata (&dev->dev);
246}
247
248static inline void i2c_set_adapdata (struct i2c_adapter *dev, void *data)
249{
250 dev_set_drvdata (&dev->dev, data);
251}
252
253/*flags for the client struct: */
254#define I2C_CLIENT_PEC 0x04 /* Use Packet Error Checking */
255#define I2C_CLIENT_TEN 0x10 /* we have a ten bit chip address */
256 /* Must equal I2C_M_TEN below */
257
258/* i2c adapter classes (bitmask) */
259#define I2C_CLASS_HWMON (1<<0) /* lm_sensors, ... */
260#define I2C_CLASS_TV_ANALOG (1<<1) /* bttv + friends */
261#define I2C_CLASS_TV_DIGITAL (1<<2) /* dvb cards */
262#define I2C_CLASS_DDC (1<<3) /* i2c-matroxfb ? */
263#define I2C_CLASS_CAM_ANALOG (1<<4) /* camera with analog CCD */
264#define I2C_CLASS_CAM_DIGITAL (1<<5) /* most webcams */
265#define I2C_CLASS_SOUND (1<<6) /* sound devices */
266#define I2C_CLASS_ALL (UINT_MAX) /* all of the above */
267
268/* i2c_client_address_data is the struct for holding default client
269 * addresses for a driver and for the parameters supplied on the
270 * command line
271 */
272struct i2c_client_address_data {
273 unsigned short *normal_i2c;
274 unsigned short *probe;
275 unsigned short *ignore;
276 unsigned short **forces;
277};
278
279/* Internal numbers to terminate lists */
280#define I2C_CLIENT_END 0xfffeU
281
282/* The numbers to use to set I2C bus address */
283#define ANY_I2C_BUS 0xffff
284#define ANY_I2C_ISA_BUS 9191
285
286
287/* ----- functions exported by i2c.o */
288
289/* administration...
290 */
291extern int i2c_add_adapter(struct i2c_adapter *);
292extern int i2c_del_adapter(struct i2c_adapter *);
293
294extern int i2c_register_driver(struct module *, struct i2c_driver *);
295extern int i2c_del_driver(struct i2c_driver *);
296
297static inline int i2c_add_driver(struct i2c_driver *driver)
298{
299 return i2c_register_driver(THIS_MODULE, driver);
300}
301
302extern int i2c_attach_client(struct i2c_client *);
303extern int i2c_detach_client(struct i2c_client *);
304
305/* Should be used to make sure that client-struct is valid and that it
306 is okay to access the i2c-client.
307 returns -ENODEV if client has gone in the meantime */
308extern int i2c_use_client(struct i2c_client *);
309extern int i2c_release_client(struct i2c_client *);
310
311/* call the i2c_client->command() of all attached clients with
312 * the given arguments */
313extern void i2c_clients_command(struct i2c_adapter *adap,
314 unsigned int cmd, void *arg);
315
316/* returns -EBUSY if address has been taken, 0 if not. Note that the only
317 other place at which this is called is within i2c_attach_client; so
318 you can cheat by simply not registering. Not recommended, of course! */
319extern int i2c_check_addr (struct i2c_adapter *adapter, int addr);
320
321/* Detect function. It iterates over all possible addresses itself.
322 * It will only call found_proc if some client is connected at the
323 * specific address (unless a 'force' matched);
324 */
325extern int i2c_probe(struct i2c_adapter *adapter,
326 struct i2c_client_address_data *address_data,
327 int (*found_proc) (struct i2c_adapter *, int, int));
328
329/* An ioctl like call to set div. parameters of the adapter.
330 */
331extern int i2c_control(struct i2c_client *,unsigned int, unsigned long);
332
333extern struct i2c_adapter* i2c_get_adapter(int id);
334extern void i2c_put_adapter(struct i2c_adapter *adap);
335
336
337/* Return the functionality mask */
338static inline u32 i2c_get_functionality(struct i2c_adapter *adap)
339{
340 return adap->algo->functionality(adap);
341}
342
343/* Return 1 if adapter supports everything we need, 0 if not. */
344static inline int i2c_check_functionality(struct i2c_adapter *adap, u32 func)
345{
346 return (func & i2c_get_functionality(adap)) == func;
347}
348
349/* Return id number for a specific adapter */
350static inline int i2c_adapter_id(struct i2c_adapter *adap)
351{
352 return adap->nr;
353}
354#endif /* __KERNEL__ */
355
356/*
357 * I2C Message - used for pure i2c transaction, also from /dev interface
358 */
359struct i2c_msg {
360 __u16 addr; /* slave address */
361 __u16 flags;
362#define I2C_M_TEN 0x10 /* we have a ten bit chip address */
363#define I2C_M_RD 0x01
364#define I2C_M_NOSTART 0x4000
365#define I2C_M_REV_DIR_ADDR 0x2000
366#define I2C_M_IGNORE_NAK 0x1000
367#define I2C_M_NO_RD_ACK 0x0800
368 __u16 len; /* msg length */
369 __u8 *buf; /* pointer to msg data */
370};
371
372/* To determine what functionality is present */
373
374#define I2C_FUNC_I2C 0x00000001
375#define I2C_FUNC_10BIT_ADDR 0x00000002
376#define I2C_FUNC_PROTOCOL_MANGLING 0x00000004 /* I2C_M_{REV_DIR_ADDR,NOSTART,..} */
377#define I2C_FUNC_SMBUS_HWPEC_CALC 0x00000008 /* SMBus 2.0 */
378#define I2C_FUNC_SMBUS_BLOCK_PROC_CALL 0x00008000 /* SMBus 2.0 */
379#define I2C_FUNC_SMBUS_QUICK 0x00010000
380#define I2C_FUNC_SMBUS_READ_BYTE 0x00020000
381#define I2C_FUNC_SMBUS_WRITE_BYTE 0x00040000
382#define I2C_FUNC_SMBUS_READ_BYTE_DATA 0x00080000
383#define I2C_FUNC_SMBUS_WRITE_BYTE_DATA 0x00100000
384#define I2C_FUNC_SMBUS_READ_WORD_DATA 0x00200000
385#define I2C_FUNC_SMBUS_WRITE_WORD_DATA 0x00400000
386#define I2C_FUNC_SMBUS_PROC_CALL 0x00800000
387#define I2C_FUNC_SMBUS_READ_BLOCK_DATA 0x01000000
388#define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA 0x02000000
389#define I2C_FUNC_SMBUS_READ_I2C_BLOCK 0x04000000 /* I2C-like block xfer */
390#define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK 0x08000000 /* w/ 1-byte reg. addr. */
391#define I2C_FUNC_SMBUS_READ_I2C_BLOCK_2 0x10000000 /* I2C-like block xfer */
392#define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2 0x20000000 /* w/ 2-byte reg. addr. */
393
394#define I2C_FUNC_SMBUS_BYTE (I2C_FUNC_SMBUS_READ_BYTE | \
395 I2C_FUNC_SMBUS_WRITE_BYTE)
396#define I2C_FUNC_SMBUS_BYTE_DATA (I2C_FUNC_SMBUS_READ_BYTE_DATA | \
397 I2C_FUNC_SMBUS_WRITE_BYTE_DATA)
398#define I2C_FUNC_SMBUS_WORD_DATA (I2C_FUNC_SMBUS_READ_WORD_DATA | \
399 I2C_FUNC_SMBUS_WRITE_WORD_DATA)
400#define I2C_FUNC_SMBUS_BLOCK_DATA (I2C_FUNC_SMBUS_READ_BLOCK_DATA | \
401 I2C_FUNC_SMBUS_WRITE_BLOCK_DATA)
402#define I2C_FUNC_SMBUS_I2C_BLOCK (I2C_FUNC_SMBUS_READ_I2C_BLOCK | \
403 I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)
404#define I2C_FUNC_SMBUS_I2C_BLOCK_2 (I2C_FUNC_SMBUS_READ_I2C_BLOCK_2 | \
405 I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2)
406
407#define I2C_FUNC_SMBUS_EMUL (I2C_FUNC_SMBUS_QUICK | \
408 I2C_FUNC_SMBUS_BYTE | \
409 I2C_FUNC_SMBUS_BYTE_DATA | \
410 I2C_FUNC_SMBUS_WORD_DATA | \
411 I2C_FUNC_SMBUS_PROC_CALL | \
412 I2C_FUNC_SMBUS_WRITE_BLOCK_DATA | \
413 I2C_FUNC_SMBUS_I2C_BLOCK)
414
415/*
416 * Data for SMBus Messages
417 */
418#define I2C_SMBUS_BLOCK_MAX 32 /* As specified in SMBus standard */
419union i2c_smbus_data {
420 __u8 byte;
421 __u16 word;
422 __u8 block[I2C_SMBUS_BLOCK_MAX + 2]; /* block[0] is used for length */
423 /* and one more for user-space compatibility */
424};
425
426/* smbus_access read or write markers */
427#define I2C_SMBUS_READ 1
428#define I2C_SMBUS_WRITE 0
429
430/* SMBus transaction types (size parameter in the above functions)
431 Note: these no longer correspond to the (arbitrary) PIIX4 internal codes! */
432#define I2C_SMBUS_QUICK 0
433#define I2C_SMBUS_BYTE 1
434#define I2C_SMBUS_BYTE_DATA 2
435#define I2C_SMBUS_WORD_DATA 3
436#define I2C_SMBUS_PROC_CALL 4
437#define I2C_SMBUS_BLOCK_DATA 5
438#define I2C_SMBUS_I2C_BLOCK_DATA 6
439#define I2C_SMBUS_BLOCK_PROC_CALL 7 /* SMBus 2.0 */
440
441
442/* ----- commands for the ioctl like i2c_command call:
443 * note that additional calls are defined in the algorithm and hw
444 * dependent layers - these can be listed here, or see the
445 * corresponding header files.
446 */
447 /* -> bit-adapter specific ioctls */
448#define I2C_RETRIES 0x0701 /* number of times a device address */
449 /* should be polled when not */
450 /* acknowledging */
451#define I2C_TIMEOUT 0x0702 /* set timeout - call with int */
452
453
454/* this is for i2c-dev.c */
455#define I2C_SLAVE 0x0703 /* Change slave address */
456 /* Attn.: Slave address is 7 or 10 bits */
457#define I2C_SLAVE_FORCE 0x0706 /* Change slave address */
458 /* Attn.: Slave address is 7 or 10 bits */
459 /* This changes the address, even if it */
460 /* is already taken! */
461#define I2C_TENBIT 0x0704 /* 0 for 7 bit addrs, != 0 for 10 bit */
462
463#define I2C_FUNCS 0x0705 /* Get the adapter functionality */
464#define I2C_RDWR 0x0707 /* Combined R/W transfer (one stop only)*/
465#define I2C_PEC 0x0708 /* != 0 for SMBus PEC */
466
467#define I2C_SMBUS 0x0720 /* SMBus-level access */
468
469/* ----- I2C-DEV: char device interface stuff ------------------------- */
470#ifdef __KERNEL__
471
472#define I2C_MAJOR 89 /* Device major number */
473
474/* These defines are used for probing i2c client addresses */
475/* The length of the option lists */
476#define I2C_CLIENT_MAX_OPTS 48
477
478/* Default fill of many variables */
479#define I2C_CLIENT_DEFAULTS {I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
480 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
481 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
482 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
483 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
484 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
485 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
486 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
487 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
488 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
489 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
490 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
491 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
492 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
493 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
494 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END}
495
496/* I2C_CLIENT_MODULE_PARM creates a module parameter, and puts it in the
497 module header */
498
499#define I2C_CLIENT_MODULE_PARM(var,desc) \
500 static unsigned short var[I2C_CLIENT_MAX_OPTS] = I2C_CLIENT_DEFAULTS; \
501 static unsigned int var##_num; \
502 module_param_array(var, short, &var##_num, 0); \
503 MODULE_PARM_DESC(var,desc)
504
505#define I2C_CLIENT_MODULE_PARM_FORCE(name) \
506I2C_CLIENT_MODULE_PARM(force_##name, \
507 "List of adapter,address pairs which are " \
508 "unquestionably assumed to contain a `" \
509 # name "' chip")
510
511
512#define I2C_CLIENT_INSMOD_COMMON \
513I2C_CLIENT_MODULE_PARM(probe, "List of adapter,address pairs to scan " \
514 "additionally"); \
515I2C_CLIENT_MODULE_PARM(ignore, "List of adapter,address pairs not to " \
516 "scan"); \
517static struct i2c_client_address_data addr_data = { \
518 .normal_i2c = normal_i2c, \
519 .probe = probe, \
520 .ignore = ignore, \
521 .forces = forces, \
522}
523
524/* These are the ones you want to use in your own drivers. Pick the one
525 which matches the number of devices the driver differenciates between. */
526#define I2C_CLIENT_INSMOD \
527 I2C_CLIENT_MODULE_PARM(force, \
528 "List of adapter,address pairs to boldly assume " \
529 "to be present"); \
530 static unsigned short *forces[] = { \
531 force, \
532 NULL \
533 }; \
534I2C_CLIENT_INSMOD_COMMON
535
536#define I2C_CLIENT_INSMOD_1(chip1) \
537enum chips { any_chip, chip1 }; \
538I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to " \
539 "boldly assume to be present"); \
540I2C_CLIENT_MODULE_PARM_FORCE(chip1); \
541static unsigned short *forces[] = { force, force_##chip1, NULL }; \
542I2C_CLIENT_INSMOD_COMMON
543
544#define I2C_CLIENT_INSMOD_2(chip1, chip2) \
545enum chips { any_chip, chip1, chip2 }; \
546I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to " \
547 "boldly assume to be present"); \
548I2C_CLIENT_MODULE_PARM_FORCE(chip1); \
549I2C_CLIENT_MODULE_PARM_FORCE(chip2); \
550static unsigned short *forces[] = { force, force_##chip1, \
551 force_##chip2, NULL }; \
552I2C_CLIENT_INSMOD_COMMON
553
554#define I2C_CLIENT_INSMOD_3(chip1, chip2, chip3) \
555enum chips { any_chip, chip1, chip2, chip3 }; \
556I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to " \
557 "boldly assume to be present"); \
558I2C_CLIENT_MODULE_PARM_FORCE(chip1); \
559I2C_CLIENT_MODULE_PARM_FORCE(chip2); \
560I2C_CLIENT_MODULE_PARM_FORCE(chip3); \
561static unsigned short *forces[] = { force, force_##chip1, \
562 force_##chip2, force_##chip3, \
563 NULL }; \
564I2C_CLIENT_INSMOD_COMMON
565
566#define I2C_CLIENT_INSMOD_4(chip1, chip2, chip3, chip4) \
567enum chips { any_chip, chip1, chip2, chip3, chip4 }; \
568I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to " \
569 "boldly assume to be present"); \
570I2C_CLIENT_MODULE_PARM_FORCE(chip1); \
571I2C_CLIENT_MODULE_PARM_FORCE(chip2); \
572I2C_CLIENT_MODULE_PARM_FORCE(chip3); \
573I2C_CLIENT_MODULE_PARM_FORCE(chip4); \
574static unsigned short *forces[] = { force, force_##chip1, \
575 force_##chip2, force_##chip3, \
576 force_##chip4, NULL}; \
577I2C_CLIENT_INSMOD_COMMON
578
579#define I2C_CLIENT_INSMOD_5(chip1, chip2, chip3, chip4, chip5) \
580enum chips { any_chip, chip1, chip2, chip3, chip4, chip5 }; \
581I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to " \
582 "boldly assume to be present"); \
583I2C_CLIENT_MODULE_PARM_FORCE(chip1); \
584I2C_CLIENT_MODULE_PARM_FORCE(chip2); \
585I2C_CLIENT_MODULE_PARM_FORCE(chip3); \
586I2C_CLIENT_MODULE_PARM_FORCE(chip4); \
587I2C_CLIENT_MODULE_PARM_FORCE(chip5); \
588static unsigned short *forces[] = { force, force_##chip1, \
589 force_##chip2, force_##chip3, \
590 force_##chip4, force_##chip5, \
591 NULL }; \
592I2C_CLIENT_INSMOD_COMMON
593
594#define I2C_CLIENT_INSMOD_6(chip1, chip2, chip3, chip4, chip5, chip6) \
595enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6 }; \
596I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to " \
597 "boldly assume to be present"); \
598I2C_CLIENT_MODULE_PARM_FORCE(chip1); \
599I2C_CLIENT_MODULE_PARM_FORCE(chip2); \
600I2C_CLIENT_MODULE_PARM_FORCE(chip3); \
601I2C_CLIENT_MODULE_PARM_FORCE(chip4); \
602I2C_CLIENT_MODULE_PARM_FORCE(chip5); \
603I2C_CLIENT_MODULE_PARM_FORCE(chip6); \
604static unsigned short *forces[] = { force, force_##chip1, \
605 force_##chip2, force_##chip3, \
606 force_##chip4, force_##chip5, \
607 force_##chip6, NULL }; \
608I2C_CLIENT_INSMOD_COMMON
609
610#define I2C_CLIENT_INSMOD_7(chip1, chip2, chip3, chip4, chip5, chip6, chip7) \
611enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6, \
612 chip7 }; \
613I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to " \
614 "boldly assume to be present"); \
615I2C_CLIENT_MODULE_PARM_FORCE(chip1); \
616I2C_CLIENT_MODULE_PARM_FORCE(chip2); \
617I2C_CLIENT_MODULE_PARM_FORCE(chip3); \
618I2C_CLIENT_MODULE_PARM_FORCE(chip4); \
619I2C_CLIENT_MODULE_PARM_FORCE(chip5); \
620I2C_CLIENT_MODULE_PARM_FORCE(chip6); \
621I2C_CLIENT_MODULE_PARM_FORCE(chip7); \
622static unsigned short *forces[] = { force, force_##chip1, \
623 force_##chip2, force_##chip3, \
624 force_##chip4, force_##chip5, \
625 force_##chip6, force_##chip7, \
626 NULL }; \
627I2C_CLIENT_INSMOD_COMMON
628
629#define I2C_CLIENT_INSMOD_8(chip1, chip2, chip3, chip4, chip5, chip6, chip7, chip8) \
630enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6, \
631 chip7, chip8 }; \
632I2C_CLIENT_MODULE_PARM(force, "List of adapter,address pairs to " \
633 "boldly assume to be present"); \
634I2C_CLIENT_MODULE_PARM_FORCE(chip1); \
635I2C_CLIENT_MODULE_PARM_FORCE(chip2); \
636I2C_CLIENT_MODULE_PARM_FORCE(chip3); \
637I2C_CLIENT_MODULE_PARM_FORCE(chip4); \
638I2C_CLIENT_MODULE_PARM_FORCE(chip5); \
639I2C_CLIENT_MODULE_PARM_FORCE(chip6); \
640I2C_CLIENT_MODULE_PARM_FORCE(chip7); \
641I2C_CLIENT_MODULE_PARM_FORCE(chip8); \
642static unsigned short *forces[] = { force, force_##chip1, \
643 force_##chip2, force_##chip3, \
644 force_##chip4, force_##chip5, \
645 force_##chip6, force_##chip7, \
646 force_##chip8, NULL }; \
647I2C_CLIENT_INSMOD_COMMON
648#endif /* __KERNEL__ */
649#endif /* _LINUX_I2C_H */