Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=9b766b814d6a5f31ca1e9da1ebc08164b9352941
Commit:     9b766b814d6a5f31ca1e9da1ebc08164b9352941
Parent:     0d227a7e724460bddcd603a1feb672267bcb0d6c
Author:     David Brownell <[EMAIL PROTECTED]>
AuthorDate: Sun Jan 27 18:14:51 2008 +0100
Committer:  Jean Delvare <[EMAIL PROTECTED]>
CommitDate: Sun Jan 27 18:14:51 2008 +0100

    i2c: Stop using the redundant client list
    
    The i2c_adapter.clients list of i2c_client nodes duplicates driver
    model state.  This patch starts removing that list, letting us remove
    most existing users of those i2c-core lists.
    
     * The core I2C code now iterates over the driver model's list instead
       of the i2c-internal one in some places where it's safe:
          - Passing a command/ioctl to each client, a mechanims
            used almost exclusively by DVB adapters;
          - Device address checking, in both i2c-core and i2c-dev.
    
     * Provide i2c_verify_client() to use with driver model iterators.
    
     * Flag the relevant i2c_adapter and i2c_client fields as deprecated,
       to help prevent new users from appearing.
    
    For the moment the list needs to stick around, since some issues show
    up when deleting devices created by legacy I2C drivers.  (They don't
    follow standard driver model rules.  Removing those devices can cause
    self-deadlocks.)
    
    Signed-off-by: David Brownell <[EMAIL PROTECTED]>
    Signed-off-by: Jean Delvare <[EMAIL PROTECTED]>
---
 drivers/i2c/i2c-core.c |   78 ++++++++++++++++++++++++++++-------------------
 drivers/i2c/i2c-dev.c  |   29 +++++++----------
 include/linux/i2c.h    |    8 +++--
 3 files changed, 63 insertions(+), 52 deletions(-)

diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index ddd1b83..c8bbd67 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -199,6 +199,25 @@ static struct bus_type i2c_bus_type = {
        .resume         = i2c_device_resume,
 };
 
+
+/**
+ * i2c_verify_client - return parameter as i2c_client, or NULL
+ * @dev: device, probably from some driver model iterator
+ *
+ * When traversing the driver model tree, perhaps using driver model
+ * iterators like @device_for_each_child(), you can't assume very much
+ * about the nodes you find.  Use this function to avoid oopses caused
+ * by wrongly treating some non-I2C device as an i2c_client.
+ */
+struct i2c_client *i2c_verify_client(struct device *dev)
+{
+       return (dev->bus == &i2c_bus_type)
+                       ? to_i2c_client(dev)
+                       : NULL;
+}
+EXPORT_SYMBOL(i2c_verify_client);
+
+
 /**
  * i2c_new_device - instantiate an i2c device for use with a new style driver
  * @adap: the adapter managing the device
@@ -670,28 +689,19 @@ EXPORT_SYMBOL(i2c_del_driver);
 
 /* ------------------------------------------------------------------------- */
 
-static int __i2c_check_addr(struct i2c_adapter *adapter, unsigned int addr)
+static int __i2c_check_addr(struct device *dev, void *addrp)
 {
-       struct list_head   *item;
-       struct i2c_client  *client;
+       struct i2c_client       *client = i2c_verify_client(dev);
+       int                     addr = *(int *)addrp;
 
-       list_for_each(item,&adapter->clients) {
-               client = list_entry(item, struct i2c_client, list);
-               if (client->addr == addr)
-                       return -EBUSY;
-       }
+       if (client && client->addr == addr)
+               return -EBUSY;
        return 0;
 }
 
 static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
 {
-       int rval;
-
-       mutex_lock(&adapter->clist_lock);
-       rval = __i2c_check_addr(adapter, addr);
-       mutex_unlock(&adapter->clist_lock);
-
-       return rval;
+       return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
 }
 
 int i2c_attach_client(struct i2c_client *client)
@@ -700,7 +710,7 @@ int i2c_attach_client(struct i2c_client *client)
        int res = 0;
 
        mutex_lock(&adapter->clist_lock);
-       if (__i2c_check_addr(client->adapter, client->addr)) {
+       if (i2c_check_addr(client->adapter, client->addr)) {
                res = -EBUSY;
                goto out_unlock;
        }
@@ -804,24 +814,28 @@ void i2c_release_client(struct i2c_client *client)
 }
 EXPORT_SYMBOL(i2c_release_client);
 
+struct i2c_cmd_arg {
+       unsigned        cmd;
+       void            *arg;
+};
+
+static int i2c_cmd(struct device *dev, void *_arg)
+{
+       struct i2c_client       *client = i2c_verify_client(dev);
+       struct i2c_cmd_arg      *arg = _arg;
+
+       if (client && client->driver && client->driver->command)
+               client->driver->command(client, arg->cmd, arg->arg);
+       return 0;
+}
+
 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
 {
-       struct list_head  *item;
-       struct i2c_client *client;
+       struct i2c_cmd_arg      cmd_arg;
 
-       mutex_lock(&adap->clist_lock);
-       list_for_each(item,&adap->clients) {
-               client = list_entry(item, struct i2c_client, list);
-               if (!try_module_get(client->driver->driver.owner))
-                       continue;
-               if (NULL != client->driver->command) {
-                       mutex_unlock(&adap->clist_lock);
-                       client->driver->command(client,cmd,arg);
-                       mutex_lock(&adap->clist_lock);
-               }
-               module_put(client->driver->driver.owner);
-       }
-       mutex_unlock(&adap->clist_lock);
+       cmd_arg.cmd = cmd;
+       cmd_arg.arg = arg;
+       device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
 }
 EXPORT_SYMBOL(i2c_clients_command);
 
@@ -1087,7 +1101,7 @@ i2c_new_probed_device(struct i2c_adapter *adap,
                }
 
                /* Check address availability */
-               if (__i2c_check_addr(adap, addr_list[i])) {
+               if (i2c_check_addr(adap, addr_list[i])) {
                        dev_dbg(&adap->dev, "Address 0x%02x already in "
                                "use, not probing\n", addr_list[i]);
                        continue;
diff --git a/drivers/i2c/i2c-dev.c b/drivers/i2c/i2c-dev.c
index df540d5..393e679 100644
--- a/drivers/i2c/i2c-dev.c
+++ b/drivers/i2c/i2c-dev.c
@@ -182,27 +182,22 @@ static ssize_t i2cdev_write (struct file *file, const 
char __user *buf, size_t c
        return ret;
 }
 
+static int i2cdev_check(struct device *dev, void *addrp)
+{
+       struct i2c_client *client = i2c_verify_client(dev);
+
+       if (!client || client->addr != *(unsigned int *)addrp)
+               return 0;
+
+       return dev->driver ? -EBUSY : 0;
+}
+
 /* This address checking function differs from the one in i2c-core
    in that it considers an address with a registered device, but no
-   bound driver, as NOT busy. */
+   driver bound to it, as NOT busy. */
 static int i2cdev_check_addr(struct i2c_adapter *adapter, unsigned int addr)
 {
-       struct list_head *item;
-       struct i2c_client *client;
-       int res = 0;
-
-       mutex_lock(&adapter->clist_lock);
-       list_for_each(item, &adapter->clients) {
-               client = list_entry(item, struct i2c_client, list);
-               if (client->addr == addr) {
-                       if (client->driver)
-                               res = -EBUSY;
-                       break;
-               }
-       }
-       mutex_unlock(&adapter->clist_lock);
-
-       return res;
+       return device_for_each_child(&adapter->dev, &addr, i2cdev_check);
 }
 
 static int i2cdev_ioctl(struct inode *inode, struct file *file,
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 0fc59ef..731928a 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -158,7 +158,7 @@ struct i2c_driver {
  * @irq: indicates the IRQ generated by this device (if any)
  * @driver_name: Identifies new-style driver used with this device; also
  *     used as the module name for hotplug/coldplug modprobe support.
- * @list: list of active/busy clients
+ * @list: list of active/busy clients (DEPRECATED)
  * @released: used to synchronize client releases & detaches and references
  *
  * An i2c_client identifies a single device (i.e. chip) connected to an
@@ -176,11 +176,13 @@ struct i2c_client {
        struct device dev;              /* the device structure         */
        int irq;                        /* irq issued by device (or -1) */
        char driver_name[KOBJ_NAME_LEN];
-       struct list_head list;
+       struct list_head list;          /* DEPRECATED */
        struct completion released;
 };
 #define to_i2c_client(d) container_of(d, struct i2c_client, dev)
 
+extern struct i2c_client *i2c_verify_client(struct device *dev);
+
 static inline struct i2c_client *kobj_to_i2c_client(struct kobject *kobj)
 {
        struct device * const dev = container_of(kobj, struct device, kobj);
@@ -315,7 +317,7 @@ struct i2c_adapter {
        struct device dev;              /* the adapter device */
 
        int nr;
-       struct list_head clients;
+       struct list_head clients;       /* DEPRECATED */
        char name[48];
        struct completion dev_released;
 };
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to