power: smb349: add callback to update charger
[linux-2.6.git] / include / linux / i2c.h
index b3f4606..0bd9ea2 100644 (file)
 #include <linux/types.h>
 #ifdef __KERNEL__
 #include <linux/module.h>
-#include <linux/i2c-id.h>
 #include <linux/mod_devicetable.h>
 #include <linux/device.h>      /* for struct device */
 #include <linux/sched.h>       /* for completion */
 #include <linux/mutex.h>
+#include <linux/of.h>          /* for struct device_node */
 
 extern struct bus_type i2c_bus_type;
+extern struct device_type i2c_adapter_type;
 
 /* --- General options ------------------------------------------------        */
 
@@ -47,15 +48,18 @@ struct i2c_driver;
 union i2c_smbus_data;
 struct i2c_board_info;
 
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 /*
  * The master routines are the ones normally used to transmit data to devices
  * 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
  * transmit an arbitrary number of messages without interruption.
+ * @count must be be less than 64k since msg.len is u16.
  */
-extern int i2c_master_send(struct i2c_client *client, const char *buf,
+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,
                           int count);
-extern int i2c_master_recv(struct i2c_client *client, char *buf, int count);
 
 /* Transfer num messages.
  */
@@ -74,43 +78,45 @@ extern s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
 /* Now follow the 'nice' access routines. These also document the calling
    conventions of i2c_smbus_xfer. */
 
-extern s32 i2c_smbus_read_byte(struct i2c_client *client);
-extern s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value);
-extern s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command);
-extern s32 i2c_smbus_write_byte_data(struct i2c_client *client,
+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,
                                     u8 command, u8 value);
-extern s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command);
-extern s32 i2c_smbus_write_word_data(struct i2c_client *client,
+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,
                                     u8 command, u16 value);
 /* Returns the number of read bytes */
-extern s32 i2c_smbus_read_block_data(struct i2c_client *client,
+extern s32 i2c_smbus_read_block_data(const struct i2c_client *client,
                                     u8 command, u8 *values);
-extern s32 i2c_smbus_write_block_data(struct i2c_client *client,
+extern s32 i2c_smbus_write_block_data(const struct i2c_client *client,
                                      u8 command, u8 length, const u8 *values);
 /* Returns the number of read bytes */
-extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client,
+extern s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client,
                                         u8 command, u8 length, u8 *values);
-extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client,
+extern s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client,
                                          u8 command, u8 length,
                                          const u8 *values);
+#endif /* I2C */
 
 /**
  * struct i2c_driver - represent an I2C device driver
- * @id: Unique driver ID (optional)
  * @class: What kind of i2c device we instantiate (for detect)
- * @attach_adapter: Callback for bus addition (for legacy drivers)
- * @detach_adapter: Callback for bus removal (for legacy drivers)
- * @detach_client: Callback for device removal (for legacy drivers)
- * @probe: Callback for device binding (new-style drivers)
- * @remove: Callback for device unbinding (new-style drivers)
+ * @attach_adapter: Callback for bus addition (deprecated)
+ * @detach_adapter: Callback for bus removal (deprecated)
+ * @probe: Callback for device binding
+ * @remove: Callback for device unbinding
  * @shutdown: Callback for device shutdown
  * @suspend: Callback for device suspend
  * @resume: Callback for device resume
+ * @alert: Alert callback, for example for the SMBus alert protocol
  * @command: Callback for bus-wide signaling (optional)
  * @driver: Device driver model driver
  * @id_table: List of I2C devices supported by this driver
  * @detect: Callback for device detection
- * @address_data: The I2C addresses to probe, ignore or force (for detect)
+ * @address_list: The I2C addresses to probe (for detect)
  * @clients: List of detected clients we created (for i2c-core use only)
  *
  * The driver.owner field should be set to the module owner of this driver.
@@ -134,29 +140,16 @@ extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client,
  * not allowed.
  */
 struct i2c_driver {
-       int id;
        unsigned int class;
 
-       /* Notifies the driver that a new bus has appeared. This routine
-        * can be used by the driver to test if the bus meets its conditions
-        * & seek for the presence of the chip(s) it supports. If found, it
-        * registers the client(s) that are on the bus to the i2c admin. via
-        * i2c_attach_client.  (LEGACY I2C DRIVERS ONLY)
-        */
-       int (*attach_adapter)(struct i2c_adapter *);
-       int (*detach_adapter)(struct i2c_adapter *);
-
-       /* tells the driver that a client is about to be deleted & gives it
-        * the chance to remove its private data. Also, if the client struct
-        * has been dynamically allocated by the driver in the function above,
-        * it must be freed here.  (LEGACY I2C DRIVERS ONLY)
+       /* Notifies the driver that a new bus has appeared or is about to be
+        * removed. You should avoid using this, it will be removed in a
+        * near future.
         */
-       int (*detach_client)(struct i2c_client *) __deprecated;
+       int (*attach_adapter)(struct i2c_adapter *) __deprecated;
+       int (*detach_adapter)(struct i2c_adapter *) __deprecated;
 
-       /* Standard driver model interfaces, for "new style" i2c drivers.
-        * With the driver model, device enumeration is NEVER done by drivers;
-        * it's done by infrastructure.  (NEW STYLE DRIVERS ONLY)
-        */
+       /* Standard driver model interfaces */
        int (*probe)(struct i2c_client *, const struct i2c_device_id *);
        int (*remove)(struct i2c_client *);
 
@@ -165,6 +158,13 @@ struct i2c_driver {
        int (*suspend)(struct i2c_client *, pm_message_t mesg);
        int (*resume)(struct i2c_client *);
 
+       /* 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);
+
        /* a ioctl like command that can be used to perform specific functions
         * with the device.
         */
@@ -174,8 +174,8 @@ struct i2c_driver {
        const struct i2c_device_id *id_table;
 
        /* Device detection callback for automatic device creation */
-       int (*detect)(struct i2c_client *, int kind, struct i2c_board_info *);
-       const struct i2c_client_address_data *address_data;
+       int (*detect)(struct i2c_client *, struct i2c_board_info *);
+       const unsigned short *address_list;
        struct list_head clients;
 };
 #define to_i2c_driver(d) container_of(d, struct i2c_driver, driver)
@@ -191,9 +191,8 @@ struct i2c_driver {
  * @driver: device's driver, hence pointer to access routines
  * @dev: Driver model device node for the slave.
  * @irq: indicates the IRQ generated by this device (if any)
- * @list: list of active/busy clients (DEPRECATED)
- * @detected: member of an i2c_driver.clients list
- * @released: used to synchronize client releases & detaches and references
+ * @detected: member of an i2c_driver.clients list or i2c-core's
+ *     userspace_devices list
  *
  * An i2c_client identifies a single device (i.e. chip) connected to an
  * i2c bus. The behaviour exposed to Linux is defined by the driver
@@ -209,9 +208,7 @@ struct i2c_client {
        struct i2c_driver *driver;      /* and our access routines      */
        struct device dev;              /* the device structure         */
        int irq;                        /* irq issued by device         */
-       struct list_head list;          /* DEPRECATED */
        struct list_head detected;
-       struct completion released;
 };
 #define to_i2c_client(d) container_of(d, struct i2c_client, dev)
 
@@ -240,6 +237,7 @@ static inline void i2c_set_clientdata(struct i2c_client *dev, void *data)
  * @addr: stored in i2c_client.addr
  * @platform_data: stored in i2c_client.dev.platform_data
  * @archdata: copied into i2c_client.dev.archdata
+ * @of_node: pointer to OpenFirmware device node
  * @irq: stored in i2c_client.irq
  *
  * I2C doesn't actually support hardware probing, although controllers and
@@ -248,11 +246,10 @@ static inline void i2c_set_clientdata(struct i2c_client *dev, void *data)
  * that, such as chip type, configuration, associated IRQ, and so on.
  *
  * i2c_board_info is used to build tables of information listing I2C devices
- * that are present.  This information is used to grow the driver model tree
- * for "new style" I2C drivers.  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.
+ * 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.
  */
 struct i2c_board_info {
        char            type[I2C_NAME_SIZE];
@@ -260,6 +257,7 @@ struct i2c_board_info {
        unsigned short  addr;
        void            *platform_data;
        struct dev_archdata     *archdata;
+       struct device_node *of_node;
        int             irq;
 };
 
@@ -277,6 +275,7 @@ struct i2c_board_info {
        .type = dev_type, .addr = (dev_addr)
 
 
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 /* 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.
@@ -286,12 +285,18 @@ i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info);
 
 /* 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
- * addresses.
+ * 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.
  */
 extern struct i2c_client *
 i2c_new_probed_device(struct i2c_adapter *adap,
                      struct i2c_board_info *info,
-                     unsigned short const *addr_list);
+                     unsigned short const *addr_list,
+                     int (*probe)(struct i2c_adapter *, unsigned short addr));
+
+/* Common custom probe functions */
+extern int i2c_probe_func_quick_read(struct i2c_adapter *, unsigned short addr);
 
 /* For devices that use several addresses, use i2c_new_dummy() to make
  * client handles for the extra addresses.
@@ -300,6 +305,7 @@ extern struct i2c_client *
 i2c_new_dummy(struct i2c_adapter *adap, u16 address);
 
 extern void i2c_unregister_device(struct i2c_client *);
+#endif /* I2C */
 
 /* Mainboard arch_initcall() code should register all its I2C devices.
  * This is done at arch_initcall time, before declaring any i2c adapters.
@@ -316,7 +322,7 @@ i2c_register_board_info(int busnum, struct i2c_board_info const *info,
 {
        return 0;
 }
-#endif
+#endif /* I2C_BOARDINFO */
 
 /*
  * The following structs are for those who like to implement new bus drivers:
@@ -347,24 +353,23 @@ struct i2c_algorithm {
  */
 struct i2c_adapter {
        struct module *owner;
-       unsigned int id;
        unsigned int class;               /* classes to allow probing for */
        const struct i2c_algorithm *algo; /* the algorithm to access the bus */
        void *algo_data;
 
        /* data fields that are valid for all devices   */
-       u8 level;                       /* nesting level for lockdep */
-       struct mutex bus_lock;
-       struct mutex clist_lock;
+       struct rt_mutex bus_lock;
 
        int timeout;                    /* in jiffies */
        int retries;
        struct device dev;              /* the adapter device */
 
        int nr;
-       struct list_head clients;       /* DEPRECATED */
        char name[48];
        struct completion dev_released;
+
+       struct mutex userspace_clients_lock;
+       struct list_head userspace_clients;
 };
 #define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
 
@@ -378,6 +383,23 @@ static inline void i2c_set_adapdata(struct i2c_adapter *dev, void *data)
        dev_set_drvdata(&dev->dev, data);
 }
 
+static inline struct i2c_adapter *
+i2c_parent_is_i2c_adapter(const struct i2c_adapter *adapter)
+{
+       struct device *parent = adapter->dev.parent;
+
+       if (parent != NULL && parent->type == &i2c_adapter_type)
+               return to_i2c_adapter(parent);
+       else
+               return NULL;
+}
+
+int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *));
+
+/* Adapter locking functions, exported for shared pin cases */
+void i2c_lock_adapter(struct i2c_adapter *);
+void i2c_unlock_adapter(struct i2c_adapter *);
+
 /*flags for the client struct: */
 #define I2C_CLIENT_PEC 0x04            /* Use Packet Error Checking */
 #define I2C_CLIENT_TEN 0x10            /* we have a ten bit chip address */
@@ -386,21 +408,8 @@ static inline void i2c_set_adapdata(struct i2c_adapter *dev, void *data)
 
 /* i2c adapter classes (bitmask) */
 #define I2C_CLASS_HWMON                (1<<0)  /* lm_sensors, ... */
-#define I2C_CLASS_TV_ANALOG    (1<<1)  /* bttv + friends */
-#define I2C_CLASS_TV_DIGITAL   (1<<2)  /* dvb cards */
 #define I2C_CLASS_DDC          (1<<3)  /* DDC bus on graphics adapters */
-#define I2C_CLASS_SPD          (1<<7)  /* SPD EEPROMs and similar */
-
-/* i2c_client_address_data is the struct for holding default client
- * addresses for a driver and for the parameters supplied on the
- * command line
- */
-struct i2c_client_address_data {
-       const unsigned short *normal_i2c;
-       const unsigned short *probe;
-       const unsigned short *ignore;
-       const unsigned short * const *forces;
-};
+#define I2C_CLASS_SPD          (1<<7)  /* Memory modules */
 
 /* Internal numbers to terminate lists */
 #define I2C_CLIENT_END         0xfffeU
@@ -408,11 +417,16 @@ struct i2c_client_address_data {
 /* The numbers to use to set I2C bus address */
 #define ANY_I2C_BUS            0xffff
 
+/* Construct an I2C_CLIENT_END-terminated array of i2c addresses */
+#define I2C_ADDRS(addr, addrs...) \
+       ((const unsigned short []){ addr, ## addrs, I2C_CLIENT_END })
+
 
 /* ----- functions exported by i2c.o */
 
 /* administration...
  */
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 extern int i2c_add_adapter(struct i2c_adapter *);
 extern int i2c_del_adapter(struct i2c_adapter *);
 extern int i2c_add_numbered_adapter(struct i2c_adapter *);
@@ -425,11 +439,6 @@ static inline int i2c_add_driver(struct i2c_driver *driver)
        return i2c_register_driver(THIS_MODULE, driver);
 }
 
-/* These are deprecated, your driver should use the standard .probe()
- * and .remove() methods instead. */
-extern int __deprecated i2c_attach_client(struct i2c_client *);
-extern int __deprecated i2c_detach_client(struct i2c_client *);
-
 extern struct i2c_client *i2c_use_client(struct i2c_client *client);
 extern void i2c_release_client(struct i2c_client *client);
 
@@ -438,15 +447,7 @@ extern void i2c_release_client(struct i2c_client *client);
 extern void i2c_clients_command(struct i2c_adapter *adap,
                                unsigned int cmd, void *arg);
 
-/* Detect function. It iterates over all possible addresses itself.
- * It will only call found_proc if some client is connected at the
- * specific address (unless a 'force' matched);
- */
-extern int i2c_probe(struct i2c_adapter *adapter,
-               const struct i2c_client_address_data *address_data,
-               int (*found_proc) (struct i2c_adapter *, int, int));
-
-extern struct i2c_adapter *i2c_get_adapter(int id);
+extern struct i2c_adapter *i2c_get_adapter(int nr);
 extern void i2c_put_adapter(struct i2c_adapter *adap);
 
 
@@ -467,6 +468,7 @@ static inline int i2c_adapter_id(struct i2c_adapter *adap)
 {
        return adap->nr;
 }
+#endif /* I2C */
 #endif /* __KERNEL__ */
 
 /**
@@ -538,6 +540,7 @@ struct i2c_msg {
 #define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA 0x02000000
 #define I2C_FUNC_SMBUS_READ_I2C_BLOCK  0x04000000 /* I2C-like block xfer  */
 #define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK 0x08000000 /* w/ 1-byte reg. addr. */
+#define I2C_FUNC_I2C_SLAVE_SUPPORT     0x10000000 /* i2c slave support */
 
 #define I2C_FUNC_SMBUS_BYTE            (I2C_FUNC_SMBUS_READ_BYTE | \
                                         I2C_FUNC_SMBUS_WRITE_BYTE)
@@ -586,168 +589,4 @@ union i2c_smbus_data {
 #define I2C_SMBUS_BLOCK_PROC_CALL   7          /* SMBus 2.0 */
 #define I2C_SMBUS_I2C_BLOCK_DATA    8
 
-
-#ifdef __KERNEL__
-
-/* These defines are used for probing i2c client addresses */
-/* The length of the option lists */
-#define I2C_CLIENT_MAX_OPTS 48
-
-/* Default fill of many variables */
-#define I2C_CLIENT_DEFAULTS {I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
-                            I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
-                            I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
-                            I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
-                            I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
-                            I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
-                            I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
-                            I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
-                            I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
-                            I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
-                            I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
-                            I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
-                            I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
-                            I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
-                            I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
-                            I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END}
-
-/* I2C_CLIENT_MODULE_PARM creates a module parameter, and puts it in the
-   module header */
-
-#define I2C_CLIENT_MODULE_PARM(var,desc) \
-  static unsigned short var[I2C_CLIENT_MAX_OPTS] = I2C_CLIENT_DEFAULTS; \
-  static unsigned int var##_num; \
-  module_param_array(var, short, &var##_num, 0); \
-  MODULE_PARM_DESC(var, desc)
-
-#define I2C_CLIENT_MODULE_PARM_FORCE(name)                             \
-I2C_CLIENT_MODULE_PARM(force_##name,                                   \
-                      "List of adapter,address pairs which are "       \
-                      "unquestionably assumed to contain a `"          \
-                      # name "' chip")
-
-
-#define I2C_CLIENT_INSMOD_COMMON                                       \
-I2C_CLIENT_MODULE_PARM(probe, "List of adapter,address pairs to scan " \
-                      "additionally");                                 \
-I2C_CLIENT_MODULE_PARM(ignore, "List of adapter,address pairs not to " \
-                      "scan");                                         \
-static const struct i2c_client_address_data addr_data = {              \
-       .normal_i2c     = normal_i2c,                                   \
-       .probe          = probe,                                        \
-       .ignore         = ignore,                                       \
-       .forces         = forces,                                       \
-}
-
-#define I2C_CLIENT_FORCE_TEXT \
-       "List of adapter,address pairs to boldly assume to be present"
-
-/* These are the ones you want to use in your own drivers. Pick the one
-   which matches the number of devices the driver differenciates between. */
-#define I2C_CLIENT_INSMOD                                              \
-I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);                  \
-static const unsigned short * const forces[] = { force, NULL };                \
-I2C_CLIENT_INSMOD_COMMON
-
-#define I2C_CLIENT_INSMOD_1(chip1)                                     \
-enum chips { any_chip, chip1 };                                                \
-I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);                  \
-I2C_CLIENT_MODULE_PARM_FORCE(chip1);                                   \
-static const unsigned short * const forces[] = { force,                \
-       force_##chip1, NULL };                                          \
-I2C_CLIENT_INSMOD_COMMON
-
-#define I2C_CLIENT_INSMOD_2(chip1, chip2)                              \
-enum chips { any_chip, chip1, chip2 };                                 \
-I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);                  \
-I2C_CLIENT_MODULE_PARM_FORCE(chip1);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip2);                                   \
-static const unsigned short * const forces[] = { force,                \
-       force_##chip1, force_##chip2, NULL };                           \
-I2C_CLIENT_INSMOD_COMMON
-
-#define I2C_CLIENT_INSMOD_3(chip1, chip2, chip3)                       \
-enum chips { any_chip, chip1, chip2, chip3 };                          \
-I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);                  \
-I2C_CLIENT_MODULE_PARM_FORCE(chip1);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip2);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip3);                                   \
-static const unsigned short * const forces[] = { force,                \
-       force_##chip1, force_##chip2, force_##chip3, NULL };            \
-I2C_CLIENT_INSMOD_COMMON
-
-#define I2C_CLIENT_INSMOD_4(chip1, chip2, chip3, chip4)                        \
-enum chips { any_chip, chip1, chip2, chip3, chip4 };                   \
-I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);                  \
-I2C_CLIENT_MODULE_PARM_FORCE(chip1);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip2);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip3);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip4);                                   \
-static const unsigned short * const forces[] = { force,                \
-       force_##chip1, force_##chip2, force_##chip3,                    \
-       force_##chip4, NULL};                                           \
-I2C_CLIENT_INSMOD_COMMON
-
-#define I2C_CLIENT_INSMOD_5(chip1, chip2, chip3, chip4, chip5)         \
-enum chips { any_chip, chip1, chip2, chip3, chip4, chip5 };            \
-I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);                  \
-I2C_CLIENT_MODULE_PARM_FORCE(chip1);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip2);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip3);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip4);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip5);                                   \
-static const unsigned short * const forces[] = { force,                        \
-       force_##chip1, force_##chip2, force_##chip3,                    \
-       force_##chip4, force_##chip5, NULL };                           \
-I2C_CLIENT_INSMOD_COMMON
-
-#define I2C_CLIENT_INSMOD_6(chip1, chip2, chip3, chip4, chip5, chip6)  \
-enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6 };     \
-I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);                  \
-I2C_CLIENT_MODULE_PARM_FORCE(chip1);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip2);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip3);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip4);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip5);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip6);                                   \
-static const unsigned short * const forces[] = { force,                        \
-       force_##chip1, force_##chip2, force_##chip3,                    \
-       force_##chip4, force_##chip5, force_##chip6, NULL };            \
-I2C_CLIENT_INSMOD_COMMON
-
-#define I2C_CLIENT_INSMOD_7(chip1, chip2, chip3, chip4, chip5, chip6, chip7) \
-enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6,       \
-            chip7 };                                                   \
-I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);                  \
-I2C_CLIENT_MODULE_PARM_FORCE(chip1);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip2);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip3);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip4);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip5);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip6);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip7);                                   \
-static const unsigned short * const forces[] = { force,                        \
-       force_##chip1, force_##chip2, force_##chip3,                    \
-       force_##chip4, force_##chip5, force_##chip6,                    \
-       force_##chip7, NULL };                                          \
-I2C_CLIENT_INSMOD_COMMON
-
-#define I2C_CLIENT_INSMOD_8(chip1, chip2, chip3, chip4, chip5, chip6, chip7, chip8) \
-enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6,       \
-            chip7, chip8 };                                            \
-I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);                  \
-I2C_CLIENT_MODULE_PARM_FORCE(chip1);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip2);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip3);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip4);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip5);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip6);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip7);                                   \
-I2C_CLIENT_MODULE_PARM_FORCE(chip8);                                   \
-static const unsigned short * const forces[] = { force,                        \
-       force_##chip1, force_##chip2, force_##chip3,                    \
-       force_##chip4, force_##chip5, force_##chip6,                    \
-       force_##chip7, force_##chip8, NULL };                           \
-I2C_CLIENT_INSMOD_COMMON
-#endif /* __KERNEL__ */
 #endif /* _LINUX_I2C_H */