Merge branch 'next' into for-linus

1 files changed, 69 insertions, 62 deletions

diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index d231f683f576..f0bd5bcdf563 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -196,88 +196,60 @@ static int i2c_device_pm_suspend(struct device *dev)
 {
         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 
-        if (pm) {
-                if (pm_runtime_suspended(dev))
-                        return 0;
-                else
-                        return pm->suspend ? pm->suspend(dev) : 0;
-        }
-
-        return i2c_legacy_suspend(dev, PMSG_SUSPEND);
+        if (pm)
+                return pm_generic_suspend(dev);
+        else
+                return i2c_legacy_suspend(dev, PMSG_SUSPEND);
 }
 
 static int i2c_device_pm_resume(struct device *dev)
 {
         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
-        int ret;
 
         if (pm)
-                ret = pm->resume ? pm->resume(dev) : 0;
+                return pm_generic_resume(dev);
         else
-                ret = i2c_legacy_resume(dev);
-
-        return ret;
+                return i2c_legacy_resume(dev);
 }
 
 static int i2c_device_pm_freeze(struct device *dev)
 {
         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 
-        if (pm) {
-                if (pm_runtime_suspended(dev))
-                        return 0;
-                else
-                        return pm->freeze ? pm->freeze(dev) : 0;
-        }
-
-        return i2c_legacy_suspend(dev, PMSG_FREEZE);
+        if (pm)
+                return pm_generic_freeze(dev);
+        else
+                return i2c_legacy_suspend(dev, PMSG_FREEZE);
 }
 
 static int i2c_device_pm_thaw(struct device *dev)
 {
         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 
-        if (pm) {
-                if (pm_runtime_suspended(dev))
-                        return 0;
-                else
-                        return pm->thaw ? pm->thaw(dev) : 0;
-        }
-
-        return i2c_legacy_resume(dev);
+        if (pm)
+                return pm_generic_thaw(dev);
+        else
+                return i2c_legacy_resume(dev);
 }
 
 static int i2c_device_pm_poweroff(struct device *dev)
 {
         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 
-        if (pm) {
-                if (pm_runtime_suspended(dev))
-                        return 0;
-                else
-                        return pm->poweroff ? pm->poweroff(dev) : 0;
-        }
-
-        return i2c_legacy_suspend(dev, PMSG_HIBERNATE);
+        if (pm)
+                return pm_generic_poweroff(dev);
+        else
+                return i2c_legacy_suspend(dev, PMSG_HIBERNATE);
 }
 
 static int i2c_device_pm_restore(struct device *dev)
 {
         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
-        int ret;
 
         if (pm)
-                ret = pm->restore ? pm->restore(dev) : 0;
+                return pm_generic_restore(dev);
         else
-                ret = i2c_legacy_resume(dev);
-
-        if (!ret) {
-                pm_runtime_disable(dev);
-                pm_runtime_set_active(dev);
-                pm_runtime_enable(dev);
-        }
-
-        return ret;
+                return i2c_legacy_resume(dev);
 }
 #else /* !CONFIG_PM_SLEEP */
 #define i2c_device_pm_suspend   NULL
@@ -848,6 +820,18 @@ static int i2c_register_adapter(struct i2c_adapter *adap)
                 goto out_list;
         }
 
+        /* Sanity checks */
+        if (unlikely(adap->name[0] == '\0')) {
+                pr_err("i2c-core: Attempt to register an adapter with "
+                       "no name!\n");
+                return -EINVAL;
+        }
+        if (unlikely(!adap->algo)) {
+                pr_err("i2c-core: Attempt to register adapter '%s' with "
+                       "no algo!\n", adap->name);
+                return -EINVAL;
+        }
+
         rt_mutex_init(&adap->bus_lock);
         mutex_init(&adap->userspace_clients_lock);
         INIT_LIST_HEAD(&adap->userspace_clients);
@@ -1009,6 +993,14 @@ static int i2c_do_del_adapter(struct i2c_driver *driver,
 static int __unregister_client(struct device *dev, void *dummy)
 {
         struct i2c_client *client = i2c_verify_client(dev);
+        if (client && strcmp(client->name, "dummy"))
+                i2c_unregister_device(client);
+        return 0;
+}
+
+static int __unregister_dummy(struct device *dev, void *dummy)
+{
+        struct i2c_client *client = i2c_verify_client(dev);
         if (client)
                 i2c_unregister_device(client);
         return 0;
@@ -1063,8 +1055,12 @@ int i2c_del_adapter(struct i2c_adapter *adap)
         mutex_unlock(&adap->userspace_clients_lock);
 
         /* Detach any active clients. This can't fail, thus we do not
-           checking the returned value. */
+         * check the returned value. This is a two-pass process, because
+         * we can't remove the dummy devices during the first pass: they
+         * could have been instantiated by real devices wishing to clean
+         * them up properly, so we give them a chance to do that first. */
         res = device_for_each_child(&adap->dev, NULL, __unregister_client);
+        res = device_for_each_child(&adap->dev, NULL, __unregister_dummy);
 
 #ifdef CONFIG_I2C_COMPAT
         class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
@@ -1128,6 +1124,14 @@ int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
         if (res)
                 return res;
 
+        /* Drivers should switch to dev_pm_ops instead. */
+        if (driver->suspend)
+                pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
+                        driver->driver.name);
+        if (driver->resume)
+                pr_warn("i2c-core: driver [%s] using legacy resume method\n",
+                        driver->driver.name);
+
         pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
 
         INIT_LIST_HEAD(&driver->clients);
@@ -1350,7 +1354,7 @@ EXPORT_SYMBOL(i2c_transfer);
  *
  * Returns negative errno, or else the number of bytes written.
  */
-int i2c_master_send(struct i2c_client *client, const char *buf, int count)
+int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
 {
         int ret;
         struct i2c_adapter *adap = client->adapter;
@@ -1377,7 +1381,7 @@ EXPORT_SYMBOL(i2c_master_send);
  *
  * Returns negative errno, or else the number of bytes read.
  */
-int i2c_master_recv(struct i2c_client *client, char *buf, int count)
+int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
 {
         struct i2c_adapter *adap = client->adapter;
         struct i2c_msg msg;
@@ -1667,7 +1671,7 @@ static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
  * This executes the SMBus "receive byte" protocol, returning negative errno
  * else the byte received from the device.
  */
-s32 i2c_smbus_read_byte(struct i2c_client *client)
+s32 i2c_smbus_read_byte(const struct i2c_client *client)
 {
         union i2c_smbus_data data;
         int status;
@@ -1687,7 +1691,7 @@ EXPORT_SYMBOL(i2c_smbus_read_byte);
  * This executes the SMBus "send byte" protocol, returning negative errno
  * else zero on success.
  */
-s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
+s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
 {
         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
@@ -1702,7 +1706,7 @@ EXPORT_SYMBOL(i2c_smbus_write_byte);
  * This executes the SMBus "read byte" protocol, returning negative errno
  * else a data byte received from the device.
  */
-s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
+s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
 {
         union i2c_smbus_data data;
         int status;
@@ -1723,7 +1727,8 @@ EXPORT_SYMBOL(i2c_smbus_read_byte_data);
  * This executes the SMBus "write byte" protocol, returning negative errno
  * else zero on success.
  */
-s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
+s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
+                              u8 value)
 {
         union i2c_smbus_data data;
         data.byte = value;
@@ -1741,7 +1746,7 @@ EXPORT_SYMBOL(i2c_smbus_write_byte_data);
  * This executes the SMBus "read word" protocol, returning negative errno
  * else a 16-bit unsigned "word" received from the device.
  */
-s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
+s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
 {
         union i2c_smbus_data data;
         int status;
@@ -1762,7 +1767,8 @@ EXPORT_SYMBOL(i2c_smbus_read_word_data);
  * This executes the SMBus "write word" protocol, returning negative errno
  * else zero on success.
  */
-s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
+s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
+                              u16 value)
 {
         union i2c_smbus_data data;
         data.word = value;
@@ -1781,7 +1787,8 @@ EXPORT_SYMBOL(i2c_smbus_write_word_data);
  * This executes the SMBus "process call" protocol, returning negative errno
  * else a 16-bit unsigned "word" received from the device.
  */
-s32 i2c_smbus_process_call(struct i2c_client *client, u8 command, u16 value)
+s32 i2c_smbus_process_call(const struct i2c_client *client, u8 command,
+                           u16 value)
 {
         union i2c_smbus_data data;
         int status;
@@ -1809,7 +1816,7 @@ EXPORT_SYMBOL(i2c_smbus_process_call);
  * support this; its emulation through I2C messaging relies on a specific
  * mechanism (I2C_M_RECV_LEN) which may not be implemented.
  */
-s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
+s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
                               u8 *values)
 {
         union i2c_smbus_data data;
@@ -1836,7 +1843,7 @@ EXPORT_SYMBOL(i2c_smbus_read_block_data);
  * This executes the SMBus "block write" protocol, returning negative errno
  * else zero on success.
  */
-s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
+s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
                                u8 length, const u8 *values)
 {
         union i2c_smbus_data data;
@@ -1852,7 +1859,7 @@ s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
 EXPORT_SYMBOL(i2c_smbus_write_block_data);
 
 /* Returns the number of read bytes */
-s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
+s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
                                   u8 length, u8 *values)
 {
         union i2c_smbus_data data;
@@ -1872,7 +1879,7 @@ s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
 }
 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
 
-s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
+s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
                                    u8 length, const u8 *values)
 {
         union i2c_smbus_data data;