1 files changed, 186 insertions, 25 deletions

diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 84c2861d6f4d..19ee901577da 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -30,11 +30,14 @@
 #include <linux/slab.h>
 #include <linux/mod_devicetable.h>
 #include <linux/spi/spi.h>
+#include <linux/of_gpio.h>
 #include <linux/pm_runtime.h>
 #include <linux/export.h>
 #include <linux/sched.h>
 #include <linux/delay.h>
 #include <linux/kthread.h>
+#include <linux/ioport.h>
+#include <linux/acpi.h>
 
 static void spidev_release(struct device *dev)
 {
@@ -93,6 +96,10 @@ static int spi_match_device(struct device *dev, struct device_driver *drv)
         if (of_driver_match_device(dev, drv))
                 return 1;
 
+        /* Then try ACPI */
+        if (acpi_driver_match_device(dev, drv))
+                return 1;
+
         if (sdrv->id_table)
                 return !!spi_match_id(sdrv->id_table, spi);
 
@@ -327,6 +334,7 @@ struct spi_device *spi_alloc_device(struct spi_master *master)
         spi->dev.parent = &master->dev;
         spi->dev.bus = &spi_bus_type;
         spi->dev.release = spidev_release;
+        spi->cs_gpio = -EINVAL;
         device_initialize(&spi->dev);
         return spi;
 }
@@ -344,15 +352,16 @@ EXPORT_SYMBOL_GPL(spi_alloc_device);
 int spi_add_device(struct spi_device *spi)
 {
         static DEFINE_MUTEX(spi_add_lock);
-        struct device *dev = spi->master->dev.parent;
+        struct spi_master *master = spi->master;
+        struct device *dev = master->dev.parent;
         struct device *d;
         int status;
 
         /* Chipselects are numbered 0..max; validate. */
-        if (spi->chip_select >= spi->master->num_chipselect) {
+        if (spi->chip_select >= master->num_chipselect) {
                 dev_err(dev, "cs%d >= max %d\n",
                         spi->chip_select,
-                        spi->master->num_chipselect);
+                        master->num_chipselect);
                 return -EINVAL;
         }
 
@@ -376,6 +385,9 @@ int spi_add_device(struct spi_device *spi)
                 goto done;
         }
 
+        if (master->cs_gpios)
+                spi->cs_gpio = master->cs_gpios[spi->chip_select];
+
         /* Drivers may modify this initial i/o setup, but will
          * normally rely on the device being setup.  Devices
          * using SPI_CS_HIGH can't coexist well otherwise...
@@ -486,8 +498,7 @@ static void spi_match_master_to_boardinfo(struct spi_master *master,
  * The board info passed can safely be __initdata ... but be careful of
  * any embedded pointers (platform_data, etc), they're copied as-is.
  */
-int __devinit
-spi_register_board_info(struct spi_board_info const *info, unsigned n)
+int spi_register_board_info(struct spi_board_info const *info, unsigned n)
 {
         struct boardinfo *bi;
         int i;
@@ -800,7 +811,7 @@ err_init_queue:
 
 /*-------------------------------------------------------------------------*/
 
-#if defined(CONFIG_OF) && !defined(CONFIG_SPARC)
+#if defined(CONFIG_OF)
 /**
  * of_register_spi_devices() - Register child devices onto the SPI bus
  * @master:     Pointer to spi_master device
@@ -813,13 +824,14 @@ static void of_register_spi_devices(struct spi_master *master)
         struct spi_device *spi;
         struct device_node *nc;
         const __be32 *prop;
+        char modalias[SPI_NAME_SIZE + 4];
         int rc;
         int len;
 
         if (!master->dev.of_node)
                 return;
 
-        for_each_child_of_node(master->dev.of_node, nc) {
+        for_each_available_child_of_node(master->dev.of_node, nc) {
                 /* Alloc an spi_device */
                 spi = spi_alloc_device(master);
                 if (!spi) {
@@ -855,6 +867,8 @@ static void of_register_spi_devices(struct spi_master *master)
                         spi->mode |= SPI_CPOL;
                 if (of_find_property(nc, "spi-cs-high", NULL))
                         spi->mode |= SPI_CS_HIGH;
+                if (of_find_property(nc, "spi-3wire", NULL))
+                        spi->mode |= SPI_3WIRE;
 
                 /* Device speed */
                 prop = of_get_property(nc, "spi-max-frequency", &len);
@@ -874,7 +888,9 @@ static void of_register_spi_devices(struct spi_master *master)
                 spi->dev.of_node = nc;
 
                 /* Register the new device */
-                request_module(spi->modalias);
+                snprintf(modalias, sizeof(modalias), "%s%s", SPI_MODULE_PREFIX,
+                         spi->modalias);
+                request_module(modalias);
                 rc = spi_add_device(spi);
                 if (rc) {
                         dev_err(&master->dev, "spi_device register error %s\n",
@@ -888,6 +904,100 @@ static void of_register_spi_devices(struct spi_master *master)
 static void of_register_spi_devices(struct spi_master *master) { }
 #endif
 
+#ifdef CONFIG_ACPI
+static int acpi_spi_add_resource(struct acpi_resource *ares, void *data)
+{
+        struct spi_device *spi = data;
+
+        if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
+                struct acpi_resource_spi_serialbus *sb;
+
+                sb = &ares->data.spi_serial_bus;
+                if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_SPI) {
+                        spi->chip_select = sb->device_selection;
+                        spi->max_speed_hz = sb->connection_speed;
+
+                        if (sb->clock_phase == ACPI_SPI_SECOND_PHASE)
+                                spi->mode |= SPI_CPHA;
+                        if (sb->clock_polarity == ACPI_SPI_START_HIGH)
+                                spi->mode |= SPI_CPOL;
+                        if (sb->device_polarity == ACPI_SPI_ACTIVE_HIGH)
+                                spi->mode |= SPI_CS_HIGH;
+                }
+        } else if (spi->irq < 0) {
+                struct resource r;
+
+                if (acpi_dev_resource_interrupt(ares, 0, &r))
+                        spi->irq = r.start;
+        }
+
+        /* Always tell the ACPI core to skip this resource */
+        return 1;
+}
+
+static acpi_status acpi_spi_add_device(acpi_handle handle, u32 level,
+                                       void *data, void **return_value)
+{
+        struct spi_master *master = data;
+        struct list_head resource_list;
+        struct acpi_device *adev;
+        struct spi_device *spi;
+        int ret;
+
+        if (acpi_bus_get_device(handle, &adev))
+                return AE_OK;
+        if (acpi_bus_get_status(adev) || !adev->status.present)
+                return AE_OK;
+
+        spi = spi_alloc_device(master);
+        if (!spi) {
+                dev_err(&master->dev, "failed to allocate SPI device for %s\n",
+                        dev_name(&adev->dev));
+                return AE_NO_MEMORY;
+        }
+
+        ACPI_HANDLE_SET(&spi->dev, handle);
+        spi->irq = -1;
+
+        INIT_LIST_HEAD(&resource_list);
+        ret = acpi_dev_get_resources(adev, &resource_list,
+                                     acpi_spi_add_resource, spi);
+        acpi_dev_free_resource_list(&resource_list);
+
+        if (ret < 0 || !spi->max_speed_hz) {
+                spi_dev_put(spi);
+                return AE_OK;
+        }
+
+        strlcpy(spi->modalias, dev_name(&adev->dev), sizeof(spi->modalias));
+        if (spi_add_device(spi)) {
+                dev_err(&master->dev, "failed to add SPI device %s from ACPI\n",
+                        dev_name(&adev->dev));
+                spi_dev_put(spi);
+        }
+
+        return AE_OK;
+}
+
+static void acpi_register_spi_devices(struct spi_master *master)
+{
+        acpi_status status;
+        acpi_handle handle;
+
+        handle = ACPI_HANDLE(&master->dev);
+        if (!handle)
+                return;
+
+        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
+                                     acpi_spi_add_device, NULL,
+                                     master, NULL);
+        if (ACPI_FAILURE(status))
+                dev_warn(&master->dev, "failed to enumerate SPI slaves\n");
+}
+#else
+static inline void acpi_register_spi_devices(struct spi_master *master) {}
+#endif /* CONFIG_ACPI */
+
 static void spi_master_release(struct device *dev)
 {
         struct spi_master *master;
@@ -946,6 +1056,44 @@ struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
 }
 EXPORT_SYMBOL_GPL(spi_alloc_master);
 
+#ifdef CONFIG_OF
+static int of_spi_register_master(struct spi_master *master)
+{
+        u16 nb;
+        int i, *cs;
+        struct device_node *np = master->dev.of_node;
+
+        if (!np)
+                return 0;
+
+        nb = of_gpio_named_count(np, "cs-gpios");
+        master->num_chipselect = max(nb, master->num_chipselect);
+
+        if (nb < 1)
+                return 0;
+
+        cs = devm_kzalloc(&master->dev,
+                          sizeof(int) * master->num_chipselect,
+                          GFP_KERNEL);
+        master->cs_gpios = cs;
+
+        if (!master->cs_gpios)
+                return -ENOMEM;
+
+        memset(cs, -EINVAL, master->num_chipselect);
+
+        for (i = 0; i < nb; i++)
+                cs[i] = of_get_named_gpio(np, "cs-gpios", i);
+
+        return 0;
+}
+#else
+static int of_spi_register_master(struct spi_master *master)
+{
+        return 0;
+}
+#endif
+
 /**
  * spi_register_master - register SPI master controller
  * @master: initialized master, originally from spi_alloc_master()
@@ -977,6 +1125,10 @@ int spi_register_master(struct spi_master *master)
         if (!dev)
                 return -ENODEV;
 
+        status = of_spi_register_master(master);
+        if (status)
+                return status;
+
         /* even if it's just one always-selected device, there must
          * be at least one chipselect
          */
@@ -1023,8 +1175,9 @@ int spi_register_master(struct spi_master *master)
                 spi_match_master_to_boardinfo(master, &bi->board_info);
         mutex_unlock(&board_lock);
 
-        /* Register devices from the device tree */
+        /* Register devices from the device tree and ACPI */
         of_register_spi_devices(master);
+        acpi_register_spi_devices(master);
 done:
         return status;
 }
@@ -1156,7 +1309,7 @@ EXPORT_SYMBOL_GPL(spi_busnum_to_master);
 int spi_setup(struct spi_device *spi)
 {
         unsigned        bad_bits;
-        int             status;
+        int             status = 0;
 
         /* help drivers fail *cleanly* when they need options
          * that aren't supported with their current master
@@ -1171,7 +1324,8 @@ int spi_setup(struct spi_device *spi)
         if (!spi->bits_per_word)
                 spi->bits_per_word = 8;
 
-        status = spi->master->setup(spi);
+        if (spi->master->setup)
+                status = spi->master->setup(spi);
 
         dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s"
                                 "%u bits/w, %u Hz max --> %d\n",
@@ -1190,6 +1344,7 @@ EXPORT_SYMBOL_GPL(spi_setup);
 static int __spi_async(struct spi_device *spi, struct spi_message *message)
 {
         struct spi_master *master = spi->master;
+        struct spi_transfer *xfer;
 
         /* Half-duplex links include original MicroWire, and ones with
          * only one data pin like SPI_3WIRE (switches direction) or where
@@ -1198,7 +1353,6 @@ static int __spi_async(struct spi_device *spi, struct spi_message *message)
          */
         if ((master->flags & SPI_MASTER_HALF_DUPLEX)
                         || (spi->mode & SPI_3WIRE)) {
-                struct spi_transfer *xfer;
                 unsigned flags = master->flags;
 
                 list_for_each_entry(xfer, &message->transfers, transfer_list) {
@@ -1211,6 +1365,15 @@ static int __spi_async(struct spi_device *spi, struct spi_message *message)
                 }
         }
 
+        /**
+         * Set transfer bits_per_word as spi device default if it is not
+         * set for this transfer.
+         */
+        list_for_each_entry(xfer, &message->transfers, transfer_list) {
+                if (!xfer->bits_per_word)
+                        xfer->bits_per_word = spi->bits_per_word;
+        }
+
         message->spi = spi;
         message->status = -EINPROGRESS;
         return master->transfer(spi, message);
@@ -1487,12 +1650,18 @@ int spi_write_then_read(struct spi_device *spi,
         struct spi_transfer     x[2];
         u8                      *local_buf;
 
-        /* Use preallocated DMA-safe buffer.  We can't avoid copying here,
-         * (as a pure convenience thing), but we can keep heap costs
-         * out of the hot path ...
+        /* Use preallocated DMA-safe buffer if we can.  We can't avoid
+         * copying here, (as a pure convenience thing), but we can
+         * keep heap costs out of the hot path unless someone else is
+         * using the pre-allocated buffer or the transfer is too large.
          */
-        if ((n_tx + n_rx) > SPI_BUFSIZ)
-                return -EINVAL;
+        if ((n_tx + n_rx) > SPI_BUFSIZ || !mutex_trylock(&lock)) {
+                local_buf = kmalloc(max((unsigned)SPI_BUFSIZ, n_tx + n_rx), GFP_KERNEL);
+                if (!local_buf)
+                        return -ENOMEM;
+        } else {
+                local_buf = buf;
+        }
 
         spi_message_init(&message);
         memset(x, 0, sizeof x);
@@ -1505,14 +1674,6 @@ int spi_write_then_read(struct spi_device *spi,
                 spi_message_add_tail(&x[1], &message);
         }
 
-        /* ... unless someone else is using the pre-allocated buffer */
-        if (!mutex_trylock(&lock)) {
-                local_buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
-                if (!local_buf)
-                        return -ENOMEM;
-        } else
-                local_buf = buf;
-
         memcpy(local_buf, txbuf, n_tx);
         x[0].tx_buf = local_buf;
         x[1].rx_buf = local_buf + n_tx;