Merge tag 'mfd-for-linus-3.16' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd into next

Pull MFD updates from Lee Jones:
 "Changes to existing drivers:
   - increase DT coverage: arizona, mc13xxx, stmpe-i2c, syscon,
     sun6i-prcm
   - regmap use of and/or clean-up: tps65090, twl6040
   - basic renaming: max14577
   - use new cpufreq helpers: db8500-prcmu
   - increase regulator support: stmpe, arizona, wm5102
   - reduce legacy GPIO overhead: stmpe
   - provide necessary remove path: bcm590xx
   - expand sysfs presence: kempld
   - move driver specific code out to drivers: rtc-s5m, arizona
   - clk handling: twl6040
   - use managed (devm_*) resources: ipaq-micro
   - clean-up/remove unused/duplicated code: tps65218, sec, pm8921,
     abx500-core, db8500-prcmu, menelaus
   - build/boot/sematic bug fixes: rtsx_usb, stmpe, bcm590xx, abx500,
     mc13xxx, rdc321x-southbridge, mfd-core, sec, max14577, syscon,
     cros_ec_spi
   - constify stuff: sm501, tps65910, tps6507x, tps6586x, max77686,
     max8997, kempld, max77693, max8907, rtsx_usb, db8500-prcmu,
     max8998, wm8400, sec, lp3943, max14577, as3711, omap-usb-host,
     ipaq-micro

  Support for new devices:
   - add support for max77836 into max14577
   - add support for tps658640 into tps6586x
   - add support for cros-ec-i2c-tunnel into cros_ec
   - add new driver for rtsx_usb_sdmmc and rtsx_usb_ms
   - add new driver for axp20x
   - add new driver for sun6i-prcm
   - add new driver for ipaq-micro"

* tag 'mfd-for-linus-3.16' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd: (77 commits)
  mfd: wm5102: Correct default for LDO Control 2 register
  mfd: menelaus: Use module_i2c_driver
  mfd: tps65218: Terminate of match table
  mfd: db8500-prcmu: Remove check for CONFIG_DBX500_PRCMU_DEBUG
  mfd: ti-keystone-devctrl: Add bindings for device state control
  mfd: palmas: Format the header file
  mfd: abx500-core: Remove unused function abx500_dump_all_banks()
  mfd: arizona: Correct addresses of always-on trigger registers
  mfd: max14577: Cast to architecture agnostic data type
  i2c: ChromeOS EC tunnel driver
  mfd: cros_ec: Sync to the latest cros_ec_commands.h from EC sources
  mfd: cros_ec: spi: Increase cros_ec_spi deadline from 5ms to 100ms
  mfd: cros_ec: spi: Make the cros_ec_spi timeout more reliable
  mfd: cros_ec: spi: Add mutex to cros_ec_spi
  mfd: cros_ec: spi: Calculate delay between transfers correctly
  mfd: arizona: Correct error message for addition of main IRQ chip
  mfd: wm8997: Add registers for high power mode
  mfd: arizona: Add MICVDD to mapped regulators
  mfd: ipaq-micro: Make mfd_cell array const
  mfd: ipaq-micro: Use devm_ioremap_resource()
  ...

1 files changed, 50 insertions, 17 deletions

diff --git a/drivers/mfd/cros_ec_spi.c b/drivers/mfd/cros_ec_spi.c
index 84af8d7a4295..0b8d32829166 100644
--- a/drivers/mfd/cros_ec_spi.c
+++ b/drivers/mfd/cros_ec_spi.c
@@ -39,14 +39,22 @@
 #define EC_MSG_PREAMBLE_COUNT           32
 
 /*
-  * We must get a response from the EC in 5ms. This is a very long
-  * time, but the flash write command can take 2-3ms. The EC command
-  * processing is currently not very fast (about 500us). We could
-  * look at speeding this up and making the flash write command a
-  * 'slow' command, requiring a GET_STATUS wait loop, like flash
-  * erase.
-  */
-#define EC_MSG_DEADLINE_MS              5
+ * Allow for a long time for the EC to respond.  We support i2c
+ * tunneling and support fairly long messages for the tunnel (249
+ * bytes long at the moment).  If we're talking to a 100 kHz device
+ * on the other end and need to transfer ~256 bytes, then we need:
+ *  10 us/bit * ~10 bits/byte * ~256 bytes = ~25ms
+ *
+ * We'll wait 4 times that to handle clock stretching and other
+ * paranoia.
+ *
+ * It's pretty unlikely that we'll really see a 249 byte tunnel in
+ * anything other than testing.  If this was more common we might
+ * consider having slow commands like this require a GET_STATUS
+ * wait loop.  The 'flash write' command would be another candidate
+ * for this, clocking in at 2-3ms.
+ */
+#define EC_MSG_DEADLINE_MS              100
 
 /*
   * Time between raising the SPI chip select (for the end of a
@@ -65,11 +73,13 @@
  *      if no record
  * @end_of_msg_delay: used to set the delay_usecs on the spi_transfer that
  *      is sent when we want to turn off CS at the end of a transaction.
+ * @lock: mutex to ensure only one user of cros_ec_command_spi_xfer at a time
  */
 struct cros_ec_spi {
         struct spi_device *spi;
         s64 last_transfer_ns;
         unsigned int end_of_msg_delay;
+        struct mutex lock;
 };
 
 static void debug_packet(struct device *dev, const char *name, u8 *ptr,
@@ -111,7 +121,9 @@ static int cros_ec_spi_receive_response(struct cros_ec_device *ec_dev,
 
         /* Receive data until we see the header byte */
         deadline = jiffies + msecs_to_jiffies(EC_MSG_DEADLINE_MS);
-        do {
+        while (true) {
+                unsigned long start_jiffies = jiffies;
+
                 memset(&trans, 0, sizeof(trans));
                 trans.cs_change = 1;
                 trans.rx_buf = ptr = ec_dev->din;
@@ -132,12 +144,19 @@ static int cros_ec_spi_receive_response(struct cros_ec_device *ec_dev,
                                 break;
                         }
                 }
+                if (ptr != end)
+                        break;
 
-                if (time_after(jiffies, deadline)) {
+                /*
+                 * Use the time at the start of the loop as a timeout.  This
+                 * gives us one last shot at getting the transfer and is useful
+                 * in case we got context switched out for a while.
+                 */
+                if (time_after(start_jiffies, deadline)) {
                         dev_warn(ec_dev->dev, "EC failed to respond in time\n");
                         return -ETIMEDOUT;
                 }
-        } while (ptr == end);
+        }
 
         /*
          * ptr now points to the header byte. Copy any valid data to the
@@ -208,6 +227,13 @@ static int cros_ec_command_spi_xfer(struct cros_ec_device *ec_dev,
         int ret = 0, final_ret;
         struct timespec ts;
 
+        /*
+         * We have the shared ec_dev buffer plus we do lots of separate spi_sync
+         * calls, so we need to make sure only one person is using this at a
+         * time.
+         */
+        mutex_lock(&ec_spi->lock);
+
         len = cros_ec_prepare_tx(ec_dev, ec_msg);
         dev_dbg(ec_dev->dev, "prepared, len=%d\n", len);
 
@@ -219,7 +245,7 @@ static int cros_ec_command_spi_xfer(struct cros_ec_device *ec_dev,
                 ktime_get_ts(&ts);
                 delay = timespec_to_ns(&ts) - ec_spi->last_transfer_ns;
                 if (delay < EC_SPI_RECOVERY_TIME_NS)
-                        ndelay(delay);
+                        ndelay(EC_SPI_RECOVERY_TIME_NS - delay);
         }
 
         /* Transmit phase - send our message */
@@ -260,7 +286,7 @@ static int cros_ec_command_spi_xfer(struct cros_ec_device *ec_dev,
                 ret = final_ret;
         if (ret < 0) {
                 dev_err(ec_dev->dev, "spi transfer failed: %d\n", ret);
-                return ret;
+                goto exit;
         }
 
         /* check response error code */
@@ -269,14 +295,16 @@ static int cros_ec_command_spi_xfer(struct cros_ec_device *ec_dev,
                 dev_warn(ec_dev->dev, "command 0x%02x returned an error %d\n",
                          ec_msg->cmd, ptr[0]);
                 debug_packet(ec_dev->dev, "in_err", ptr, len);
-                return -EINVAL;
+                ret = -EINVAL;
+                goto exit;
         }
         len = ptr[1];
         sum = ptr[0] + ptr[1];
         if (len > ec_msg->in_len) {
                 dev_err(ec_dev->dev, "packet too long (%d bytes, expected %d)",
                         len, ec_msg->in_len);
-                return -ENOSPC;
+                ret = -ENOSPC;
+                goto exit;
         }
 
         /* copy response packet payload and compute checksum */
@@ -293,10 +321,14 @@ static int cros_ec_command_spi_xfer(struct cros_ec_device *ec_dev,
                 dev_err(ec_dev->dev,
                         "bad packet checksum, expected %02x, got %02x\n",
                         sum, ptr[len + 2]);
-                return -EBADMSG;
+                ret = -EBADMSG;
+                goto exit;
         }
 
-        return 0;
+        ret = 0;
+exit:
+        mutex_unlock(&ec_spi->lock);
+        return ret;
 }
 
 static void cros_ec_spi_dt_probe(struct cros_ec_spi *ec_spi, struct device *dev)
@@ -327,6 +359,7 @@ static int cros_ec_spi_probe(struct spi_device *spi)
         if (ec_spi == NULL)
                 return -ENOMEM;
         ec_spi->spi = spi;
+        mutex_init(&ec_spi->lock);
         ec_dev = devm_kzalloc(dev, sizeof(*ec_dev), GFP_KERNEL);
         if (!ec_dev)
                 return -ENOMEM;