Merge branch 'i2c/for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/wsa/linux

Pull i2c changes from Wolfram Sang:

 - an arbitration driver.  While the driver is quite simple, it caused
   discussion if we need additional arbitration on top of the one
   specified in the I2C standard.  Conclusion is that I accept a few
   generic mechanisms, but not very specific ones.

 - the core lost the detach_adapter() call.  It has no users anymore and
   was in the way for other cleanups.  attach_adapter() is sadly still
   there since there are users waiting to be converted.

 - the core gained a bus recovery infrastructure.  I2C defines a way to
   recover if the data line is stalled.  This mechanism is now in the
   core and drivers can now pass some data to make use of it.

 - bigger driver cleanups for designware, s3c2410

 - removing superfluous refcounting from drivers

 - removing Ben Dooks as second maintainer due to inactivity.  Thanks
   for all your work so far, Ben!

 - bugfixes, feature additions, devicetree fixups, simplifications...

* 'i2c/for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/wsa/linux: (38 commits)
  i2c: xiic: must always write 16-bit words to TX_FIFO
  i2c: octeon: use HZ in timeout value
  i2c: octeon: Fix i2c fail problem when a process is terminated by a signal
  i2c: designware-pci: drop superfluous {get|put}_device
  i2c: designware-plat: drop superfluous {get|put}_device
  i2c: davinci: drop superfluous {get|put}_device
  MAINTAINERS: Ben Dooks is inactive regarding I2C
  i2c: mux: Add i2c-arb-gpio-challenge 'mux' driver
  i2c: at91: convert to dma_request_slave_channel_compat()
  i2c: mxs: do error checking and handling in PIO mode
  i2c: mxs: remove races in PIO code
  i2c-designware: switch to use runtime PM autosuspend
  i2c-designware: use usleep_range() in the busy-loop
  i2c-designware: enable/disable the controller properly
  i2c-designware: use dynamic adapter numbering on Lynxpoint
  i2c-designware-pci: use managed functions pcim_* and devm_*
  i2c-designware-pci: use dev_err() instead of printk()
  i2c-designware: move to managed functions (devm_*)
  i2c: remove CONFIG_HOTPLUG ifdefs
  i2c: s3c2410: Add SMBus emulation for block read
  ...

1 files changed, 50 insertions, 25 deletions

diff --git a/drivers/i2c/busses/i2c-gpio.c b/drivers/i2c/busses/i2c-gpio.c
index f3fa4332bbdf..bc6e139c6e7f 100644
--- a/drivers/i2c/busses/i2c-gpio.c
+++ b/drivers/i2c/busses/i2c-gpio.c
@@ -85,23 +85,29 @@ static int i2c_gpio_getscl(void *data)
         return gpio_get_value(pdata->scl_pin);
 }
 
-static int of_i2c_gpio_probe(struct device_node *np,
-                             struct i2c_gpio_platform_data *pdata)
+static int of_i2c_gpio_get_pins(struct device_node *np,
+                                unsigned int *sda_pin, unsigned int *scl_pin)
 {
-        u32 reg;
-
         if (of_gpio_count(np) < 2)
                 return -ENODEV;
 
-        pdata->sda_pin = of_get_gpio(np, 0);
-        pdata->scl_pin = of_get_gpio(np, 1);
+        *sda_pin = of_get_gpio(np, 0);
+        *scl_pin = of_get_gpio(np, 1);
 
-        if (!gpio_is_valid(pdata->sda_pin) || !gpio_is_valid(pdata->scl_pin)) {
+        if (!gpio_is_valid(*sda_pin) || !gpio_is_valid(*scl_pin)) {
                 pr_err("%s: invalid GPIO pins, sda=%d/scl=%d\n",
-                       np->full_name, pdata->sda_pin, pdata->scl_pin);
+                       np->full_name, *sda_pin, *scl_pin);
                 return -ENODEV;
         }
 
+        return 0;
+}
+
+static void of_i2c_gpio_get_props(struct device_node *np,
+                                  struct i2c_gpio_platform_data *pdata)
+{
+        u32 reg;
+
         of_property_read_u32(np, "i2c-gpio,delay-us", &pdata->udelay);
 
         if (!of_property_read_u32(np, "i2c-gpio,timeout-ms", &reg))
@@ -113,8 +119,6 @@ static int of_i2c_gpio_probe(struct device_node *np,
                 of_property_read_bool(np, "i2c-gpio,scl-open-drain");
         pdata->scl_is_output_only =
                 of_property_read_bool(np, "i2c-gpio,scl-output-only");
-
-        return 0;
 }
 
 static int i2c_gpio_probe(struct platform_device *pdev)
@@ -123,31 +127,52 @@ static int i2c_gpio_probe(struct platform_device *pdev)
         struct i2c_gpio_platform_data *pdata;
         struct i2c_algo_bit_data *bit_data;
         struct i2c_adapter *adap;
+        unsigned int sda_pin, scl_pin;
         int ret;
 
-        priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
-        if (!priv)
-                return -ENOMEM;
-        adap = &priv->adap;
-        bit_data = &priv->bit_data;
-        pdata = &priv->pdata;
-
+        /* First get the GPIO pins; if it fails, we'll defer the probe. */
         if (pdev->dev.of_node) {
-                ret = of_i2c_gpio_probe(pdev->dev.of_node, pdata);
+                ret = of_i2c_gpio_get_pins(pdev->dev.of_node,
+                                           &sda_pin, &scl_pin);
                 if (ret)
                         return ret;
         } else {
                 if (!pdev->dev.platform_data)
                         return -ENXIO;
-                memcpy(pdata, pdev->dev.platform_data, sizeof(*pdata));
+                pdata = pdev->dev.platform_data;
+                sda_pin = pdata->sda_pin;
+                scl_pin = pdata->scl_pin;
         }
 
-        ret = gpio_request(pdata->sda_pin, "sda");
-        if (ret)
+        ret = gpio_request(sda_pin, "sda");
+        if (ret) {
+                if (ret == -EINVAL)
+                        ret = -EPROBE_DEFER;    /* Try again later */
                 goto err_request_sda;
-        ret = gpio_request(pdata->scl_pin, "scl");
-        if (ret)
+        }
+        ret = gpio_request(scl_pin, "scl");
+        if (ret) {
+                if (ret == -EINVAL)
+                        ret = -EPROBE_DEFER;    /* Try again later */
                 goto err_request_scl;
+        }
+
+        priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+        if (!priv) {
+                ret = -ENOMEM;
+                goto err_add_bus;
+        }
+        adap = &priv->adap;
+        bit_data = &priv->bit_data;
+        pdata = &priv->pdata;
+
+        if (pdev->dev.of_node) {
+                pdata->sda_pin = sda_pin;
+                pdata->scl_pin = scl_pin;
+                of_i2c_gpio_get_props(pdev->dev.of_node, pdata);
+        } else {
+                memcpy(pdata, pdev->dev.platform_data, sizeof(*pdata));
+        }
 
         if (pdata->sda_is_open_drain) {
                 gpio_direction_output(pdata->sda_pin, 1);
@@ -211,9 +236,9 @@ static int i2c_gpio_probe(struct platform_device *pdev)
         return 0;
 
 err_add_bus:
-        gpio_free(pdata->scl_pin);
+        gpio_free(scl_pin);
 err_request_scl:
-        gpio_free(pdata->sda_pin);
+        gpio_free(sda_pin);
 err_request_sda:
         return ret;
 }