1 files changed, 137 insertions, 56 deletions

diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index b5a78a1f4421..2e13a14bba3f 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -28,12 +28,8 @@
 #include <linux/mod_devicetable.h>
 #include <linux/spi/spi.h>
 #include <linux/of_spi.h>
+#include <linux/pm_runtime.h>
 
-
-/* SPI bustype and spi_master class are registered after board init code
- * provides the SPI device tables, ensuring that both are present by the
- * time controller driver registration causes spi_devices to "enumerate".
- */
 static void spidev_release(struct device *dev)
 {
         struct spi_device       *spi = to_spi_device(dev);
@@ -105,9 +101,8 @@ static int spi_uevent(struct device *dev, struct kobj_uevent_env *env)
         return 0;
 }
 
-#ifdef  CONFIG_PM
-
-static int spi_suspend(struct device *dev, pm_message_t message)
+#ifdef CONFIG_PM_SLEEP
+static int spi_legacy_suspend(struct device *dev, pm_message_t message)
 {
         int                     value = 0;
         struct spi_driver       *drv = to_spi_driver(dev->driver);
@@ -122,7 +117,7 @@ static int spi_suspend(struct device *dev, pm_message_t message)
         return value;
 }
 
-static int spi_resume(struct device *dev)
+static int spi_legacy_resume(struct device *dev)
 {
         int                     value = 0;
         struct spi_driver       *drv = to_spi_driver(dev->driver);
@@ -137,18 +132,94 @@ static int spi_resume(struct device *dev)
         return value;
 }
 
+static int spi_pm_suspend(struct device *dev)
+{
+        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
+
+        if (pm)
+                return pm_generic_suspend(dev);
+        else
+                return spi_legacy_suspend(dev, PMSG_SUSPEND);
+}
+
+static int spi_pm_resume(struct device *dev)
+{
+        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
+
+        if (pm)
+                return pm_generic_resume(dev);
+        else
+                return spi_legacy_resume(dev);
+}
+
+static int spi_pm_freeze(struct device *dev)
+{
+        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
+
+        if (pm)
+                return pm_generic_freeze(dev);
+        else
+                return spi_legacy_suspend(dev, PMSG_FREEZE);
+}
+
+static int spi_pm_thaw(struct device *dev)
+{
+        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
+
+        if (pm)
+                return pm_generic_thaw(dev);
+        else
+                return spi_legacy_resume(dev);
+}
+
+static int spi_pm_poweroff(struct device *dev)
+{
+        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
+
+        if (pm)
+                return pm_generic_poweroff(dev);
+        else
+                return spi_legacy_suspend(dev, PMSG_HIBERNATE);
+}
+
+static int spi_pm_restore(struct device *dev)
+{
+        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
+
+        if (pm)
+                return pm_generic_restore(dev);
+        else
+                return spi_legacy_resume(dev);
+}
 #else
-#define spi_suspend     NULL
-#define spi_resume      NULL
+#define spi_pm_suspend  NULL
+#define spi_pm_resume   NULL
+#define spi_pm_freeze   NULL
+#define spi_pm_thaw     NULL
+#define spi_pm_poweroff NULL
+#define spi_pm_restore  NULL
 #endif
 
+static const struct dev_pm_ops spi_pm = {
+        .suspend = spi_pm_suspend,
+        .resume = spi_pm_resume,
+        .freeze = spi_pm_freeze,
+        .thaw = spi_pm_thaw,
+        .poweroff = spi_pm_poweroff,
+        .restore = spi_pm_restore,
+        SET_RUNTIME_PM_OPS(
+                pm_generic_runtime_suspend,
+                pm_generic_runtime_resume,
+                pm_generic_runtime_idle
+        )
+};
+
 struct bus_type spi_bus_type = {
         .name           = "spi",
         .dev_attrs      = spi_dev_attrs,
         .match          = spi_match_device,
         .uevent         = spi_uevent,
-        .suspend        = spi_suspend,
-        .resume         = spi_resume,
+        .pm             = &spi_pm,
 };
 EXPORT_SYMBOL_GPL(spi_bus_type);
 
@@ -202,11 +273,16 @@ EXPORT_SYMBOL_GPL(spi_register_driver);
 
 struct boardinfo {
         struct list_head        list;
-        unsigned                n_board_info;
-        struct spi_board_info   board_info[0];
+        struct spi_board_info   board_info;
 };
 
 static LIST_HEAD(board_list);
+static LIST_HEAD(spi_master_list);
+
+/*
+ * Used to protect add/del opertion for board_info list and
+ * spi_master list, and their matching process
+ */
 static DEFINE_MUTEX(board_lock);
 
 /**
@@ -300,16 +376,16 @@ int spi_add_device(struct spi_device *spi)
          */
         status = spi_setup(spi);
         if (status < 0) {
-                dev_err(dev, "can't %s %s, status %d\n",
-                                "setup", dev_name(&spi->dev), status);
+                dev_err(dev, "can't setup %s, status %d\n",
+                                dev_name(&spi->dev), status);
                 goto done;
         }
 
         /* Device may be bound to an active driver when this returns */
         status = device_add(&spi->dev);
         if (status < 0)
-                dev_err(dev, "can't %s %s, status %d\n",
-                                "add", dev_name(&spi->dev), status);
+                dev_err(dev, "can't add %s, status %d\n",
+                                dev_name(&spi->dev), status);
         else
                 dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));
 
@@ -371,6 +447,20 @@ struct spi_device *spi_new_device(struct spi_master *master,
 }
 EXPORT_SYMBOL_GPL(spi_new_device);
 
+static void spi_match_master_to_boardinfo(struct spi_master *master,
+                                struct spi_board_info *bi)
+{
+        struct spi_device *dev;
+
+        if (master->bus_num != bi->bus_num)
+                return;
+
+        dev = spi_new_device(master, bi);
+        if (!dev)
+                dev_err(master->dev.parent, "can't create new device for %s\n",
+                        bi->modalias);
+}
+
 /**
  * spi_register_board_info - register SPI devices for a given board
  * @info: array of chip descriptors
@@ -393,43 +483,25 @@ EXPORT_SYMBOL_GPL(spi_new_device);
 int __init
 spi_register_board_info(struct spi_board_info const *info, unsigned n)
 {
-        struct boardinfo        *bi;
+        struct boardinfo *bi;
+        int i;
 
-        bi = kmalloc(sizeof(*bi) + n * sizeof *info, GFP_KERNEL);
+        bi = kzalloc(n * sizeof(*bi), GFP_KERNEL);
         if (!bi)
                 return -ENOMEM;
-        bi->n_board_info = n;
-        memcpy(bi->board_info, info, n * sizeof *info);
-
-        mutex_lock(&board_lock);
-        list_add_tail(&bi->list, &board_list);
-        mutex_unlock(&board_lock);
-        return 0;
-}
 
-/* FIXME someone should add support for a __setup("spi", ...) that
- * creates board info from kernel command lines
- */
-
-static void scan_boardinfo(struct spi_master *master)
-{
-        struct boardinfo        *bi;
+        for (i = 0; i < n; i++, bi++, info++) {
+                struct spi_master *master;
 
-        mutex_lock(&board_lock);
-        list_for_each_entry(bi, &board_list, list) {
-                struct spi_board_info   *chip = bi->board_info;
-                unsigned                n;
-
-                for (n = bi->n_board_info; n > 0; n--, chip++) {
-                        if (chip->bus_num != master->bus_num)
-                                continue;
-                        /* NOTE: this relies on spi_new_device to
-                         * issue diagnostics when given bogus inputs
-                         */
-                        (void) spi_new_device(master, chip);
-                }
+                memcpy(&bi->board_info, info, sizeof(*info));
+                mutex_lock(&board_lock);
+                list_add_tail(&bi->list, &board_list);
+                list_for_each_entry(master, &spi_master_list, list)
+                        spi_match_master_to_boardinfo(master, &bi->board_info);
+                mutex_unlock(&board_lock);
         }
-        mutex_unlock(&board_lock);
+
+        return 0;
 }
 
 /*-------------------------------------------------------------------------*/
@@ -512,6 +584,7 @@ int spi_register_master(struct spi_master *master)
 {
         static atomic_t         dyn_bus_id = ATOMIC_INIT((1<<15) - 1);
         struct device           *dev = master->dev.parent;
+        struct boardinfo        *bi;
         int                     status = -ENODEV;
         int                     dynamic = 0;
 
@@ -547,8 +620,12 @@ int spi_register_master(struct spi_master *master)
         dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev),
                         dynamic ? " (dynamic)" : "");
 
-        /* populate children from any spi device tables */
-        scan_boardinfo(master);
+        mutex_lock(&board_lock);
+        list_add_tail(&master->list, &spi_master_list);
+        list_for_each_entry(bi, &board_list, list)
+                spi_match_master_to_boardinfo(master, &bi->board_info);
+        mutex_unlock(&board_lock);
+
         status = 0;
 
         /* Register devices from the device tree */
@@ -579,6 +656,10 @@ void spi_unregister_master(struct spi_master *master)
 {
         int dummy;
 
+        mutex_lock(&board_lock);
+        list_del(&master->list);
+        mutex_unlock(&board_lock);
+
         dummy = device_for_each_child(&master->dev, NULL, __unregister);
         device_unregister(&master->dev);
 }
@@ -652,7 +733,7 @@ int spi_setup(struct spi_device *spi)
          */
         bad_bits = spi->mode & ~spi->master->mode_bits;
         if (bad_bits) {
-                dev_dbg(&spi->dev, "setup: unsupported mode bits %x\n",
+                dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
                         bad_bits);
                 return -EINVAL;
         }
@@ -876,7 +957,7 @@ EXPORT_SYMBOL_GPL(spi_sync);
  * drivers may DMA directly into and out of the message buffers.
  *
  * This call should be used by drivers that require exclusive access to the
- * SPI bus. It has to be preceeded by a spi_bus_lock call. The SPI bus must
+ * SPI bus. It has to be preceded by a spi_bus_lock call. The SPI bus must
  * be released by a spi_bus_unlock call when the exclusive access is over.
  *
  * It returns zero on success, else a negative error code.
@@ -966,8 +1047,8 @@ static u8	*buf;
  * spi_{async,sync}() calls with dma-safe buffers.
  */
 int spi_write_then_read(struct spi_device *spi,
-                const u8 *txbuf, unsigned n_tx,
-                u8 *rxbuf, unsigned n_rx)
+                const void *txbuf, unsigned n_tx,
+                void *rxbuf, unsigned n_rx)
 {
         static DEFINE_MUTEX(lock);