1 files changed, 208 insertions, 43 deletions

diff --git a/drivers/spi/spi-pl022.c b/drivers/spi/spi-pl022.c
index 6abbe23c39b4..919464102d33 100644
--- a/drivers/spi/spi-pl022.c
+++ b/drivers/spi/spi-pl022.c
@@ -1,7 +1,7 @@
 /*
  * A driver for the ARM PL022 PrimeCell SSP/SPI bus master.
  *
- * Copyright (C) 2008-2009 ST-Ericsson AB
+ * Copyright (C) 2008-2012 ST-Ericsson AB
  * Copyright (C) 2006 STMicroelectronics Pvt. Ltd.
  *
  * Author: Linus Walleij <linus.walleij@stericsson.com>
@@ -40,6 +40,9 @@
 #include <linux/dma-mapping.h>
 #include <linux/scatterlist.h>
 #include <linux/pm_runtime.h>
+#include <linux/gpio.h>
+#include <linux/of_gpio.h>
+#include <linux/pinctrl/consumer.h>
 
 /*
  * This macro is used to define some register default values.
@@ -356,6 +359,8 @@ struct vendor_data {
  * @sgt_rx: scattertable for the RX transfer
  * @sgt_tx: scattertable for the TX transfer
  * @dummypage: a dummy page used for driving data on the bus with DMA
+ * @cur_cs: current chip select (gpio)
+ * @chipselects: list of chipselects (gpios)
  */
 struct pl022 {
         struct amba_device              *adev;
@@ -363,6 +368,10 @@ struct pl022 {
         resource_size_t                 phybase;
         void __iomem                    *virtbase;
         struct clk                      *clk;
+        /* Two optional pin states - default & sleep */
+        struct pinctrl                  *pinctrl;
+        struct pinctrl_state            *pins_default;
+        struct pinctrl_state            *pins_sleep;
         struct spi_master               *master;
         struct pl022_ssp_controller     *master_info;
         /* Message per-transfer pump */
@@ -389,6 +398,8 @@ struct pl022 {
         char                            *dummypage;
         bool                            dma_running;
 #endif
+        int cur_cs;
+        int *chipselects;
 };
 
 /**
@@ -433,6 +444,14 @@ static void null_cs_control(u32 command)
         pr_debug("pl022: dummy chip select control, CS=0x%x\n", command);
 }
 
+static void pl022_cs_control(struct pl022 *pl022, u32 command)
+{
+        if (gpio_is_valid(pl022->cur_cs))
+                gpio_set_value(pl022->cur_cs, command);
+        else
+                pl022->cur_chip->cs_control(command);
+}
+
 /**
  * giveback - current spi_message is over, schedule next message and call
  * callback of this message. Assumes that caller already
@@ -479,7 +498,7 @@ static void giveback(struct pl022 *pl022)
                 if (next_msg && next_msg->spi != pl022->cur_msg->spi)
                         next_msg = NULL;
                 if (!next_msg || pl022->cur_msg->state == STATE_ERROR)
-                        pl022->cur_chip->cs_control(SSP_CHIP_DESELECT);
+                        pl022_cs_control(pl022, SSP_CHIP_DESELECT);
                 else
                         pl022->next_msg_cs_active = true;
 
@@ -818,8 +837,7 @@ static void dma_callback(void *data)
         /* Update total bytes transferred */
         msg->actual_length += pl022->cur_transfer->len;
         if (pl022->cur_transfer->cs_change)
-                pl022->cur_chip->
-                        cs_control(SSP_CHIP_DESELECT);
+                pl022_cs_control(pl022, SSP_CHIP_DESELECT);
 
         /* Move to next transfer */
         msg->state = next_transfer(pl022);
@@ -1252,8 +1270,7 @@ static irqreturn_t pl022_interrupt_handler(int irq, void *dev_id)
                 /* Update total bytes transferred */
                 msg->actual_length += pl022->cur_transfer->len;
                 if (pl022->cur_transfer->cs_change)
-                        pl022->cur_chip->
-                                cs_control(SSP_CHIP_DESELECT);
+                        pl022_cs_control(pl022, SSP_CHIP_DESELECT);
                 /* Move to next transfer */
                 msg->state = next_transfer(pl022);
                 tasklet_schedule(&pl022->pump_transfers);
@@ -1338,7 +1355,7 @@ static void pump_transfers(unsigned long data)
 
                 /* Reselect chip select only if cs_change was requested */
                 if (previous->cs_change)
-                        pl022->cur_chip->cs_control(SSP_CHIP_SELECT);
+                        pl022_cs_control(pl022, SSP_CHIP_SELECT);
         } else {
                 /* STATE_START */
                 message->state = STATE_RUNNING;
@@ -1377,7 +1394,7 @@ static void do_interrupt_dma_transfer(struct pl022 *pl022)
 
         /* Enable target chip, if not already active */
         if (!pl022->next_msg_cs_active)
-                pl022->cur_chip->cs_control(SSP_CHIP_SELECT);
+                pl022_cs_control(pl022, SSP_CHIP_SELECT);
 
         if (set_up_next_transfer(pl022, pl022->cur_transfer)) {
                 /* Error path */
@@ -1429,12 +1446,12 @@ static void do_polling_transfer(struct pl022 *pl022)
                         if (previous->delay_usecs)
                                 udelay(previous->delay_usecs);
                         if (previous->cs_change)
-                                pl022->cur_chip->cs_control(SSP_CHIP_SELECT);
+                                pl022_cs_control(pl022, SSP_CHIP_SELECT);
                 } else {
                         /* STATE_START */
                         message->state = STATE_RUNNING;
                         if (!pl022->next_msg_cs_active)
-                                pl022->cur_chip->cs_control(SSP_CHIP_SELECT);
+                                pl022_cs_control(pl022, SSP_CHIP_SELECT);
                 }
 
                 /* Configuration Changing Per Transfer */
@@ -1466,7 +1483,7 @@ static void do_polling_transfer(struct pl022 *pl022)
                 /* Update total byte transferred */
                 message->actual_length += pl022->cur_transfer->len;
                 if (pl022->cur_transfer->cs_change)
-                        pl022->cur_chip->cs_control(SSP_CHIP_DESELECT);
+                        pl022_cs_control(pl022, SSP_CHIP_DESELECT);
                 /* Move to next transfer */
                 message->state = next_transfer(pl022);
         }
@@ -1495,6 +1512,7 @@ static int pl022_transfer_one_message(struct spi_master *master,
 
         /* Setup the SPI using the per chip configuration */
         pl022->cur_chip = spi_get_ctldata(msg->spi);
+        pl022->cur_cs = pl022->chipselects[msg->spi->chip_select];
 
         restore_state(pl022);
         flush(pl022);
@@ -1766,12 +1784,14 @@ static const struct pl022_config_chip pl022_default_chip_info = {
 static int pl022_setup(struct spi_device *spi)
 {
         struct pl022_config_chip const *chip_info;
+        struct pl022_config_chip chip_info_dt;
         struct chip_data *chip;
         struct ssp_clock_params clk_freq = { .cpsdvsr = 0, .scr = 0};
         int status = 0;
         struct pl022 *pl022 = spi_master_get_devdata(spi->master);
         unsigned int bits = spi->bits_per_word;
         u32 tmp;
+        struct device_node *np = spi->dev.of_node;
 
         if (!spi->max_speed_hz)
                 return -EINVAL;
@@ -1794,10 +1814,32 @@ static int pl022_setup(struct spi_device *spi)
         chip_info = spi->controller_data;
 
         if (chip_info == NULL) {
-                chip_info = &pl022_default_chip_info;
-                /* spi_board_info.controller_data not is supplied */
-                dev_dbg(&spi->dev,
-                        "using default controller_data settings\n");
+                if (np) {
+                        chip_info_dt = pl022_default_chip_info;
+
+                        chip_info_dt.hierarchy = SSP_MASTER;
+                        of_property_read_u32(np, "pl022,interface",
+                                &chip_info_dt.iface);
+                        of_property_read_u32(np, "pl022,com-mode",
+                                &chip_info_dt.com_mode);
+                        of_property_read_u32(np, "pl022,rx-level-trig",
+                                &chip_info_dt.rx_lev_trig);
+                        of_property_read_u32(np, "pl022,tx-level-trig",
+                                &chip_info_dt.tx_lev_trig);
+                        of_property_read_u32(np, "pl022,ctrl-len",
+                                &chip_info_dt.ctrl_len);
+                        of_property_read_u32(np, "pl022,wait-state",
+                                &chip_info_dt.wait_state);
+                        of_property_read_u32(np, "pl022,duplex",
+                                &chip_info_dt.duplex);
+
+                        chip_info = &chip_info_dt;
+                } else {
+                        chip_info = &pl022_default_chip_info;
+                        /* spi_board_info.controller_data not is supplied */
+                        dev_dbg(&spi->dev,
+                                "using default controller_data settings\n");
+                }
         } else
                 dev_dbg(&spi->dev,
                         "using user supplied controller_data settings\n");
@@ -1840,8 +1882,9 @@ static int pl022_setup(struct spi_device *spi)
         chip->xfer_type = chip_info->com_mode;
         if (!chip_info->cs_control) {
                 chip->cs_control = null_cs_control;
-                dev_warn(&spi->dev,
-                         "chip select function is NULL for this chip\n");
+                if (!gpio_is_valid(pl022->chipselects[spi->chip_select]))
+                        dev_warn(&spi->dev,
+                                 "invalid chip select\n");
         } else
                 chip->cs_control = chip_info->cs_control;
 
@@ -1986,6 +2029,34 @@ static void pl022_cleanup(struct spi_device *spi)
         kfree(chip);
 }
 
+static struct pl022_ssp_controller *
+pl022_platform_data_dt_get(struct device *dev)
+{
+        struct device_node *np = dev->of_node;
+        struct pl022_ssp_controller *pd;
+        u32 tmp;
+
+        if (!np) {
+                dev_err(dev, "no dt node defined\n");
+                return NULL;
+        }
+
+        pd = devm_kzalloc(dev, sizeof(struct pl022_ssp_controller), GFP_KERNEL);
+        if (!pd) {
+                dev_err(dev, "cannot allocate platform data memory\n");
+                return NULL;
+        }
+
+        pd->bus_id = -1;
+        of_property_read_u32(np, "num-cs", &tmp);
+        pd->num_chipselect = tmp;
+        of_property_read_u32(np, "pl022,autosuspend-delay",
+                             &pd->autosuspend_delay);
+        pd->rt = of_property_read_bool(np, "pl022,rt");
+
+        return pd;
+}
+
 static int __devinit
 pl022_probe(struct amba_device *adev, const struct amba_id *id)
 {
@@ -1993,22 +2064,31 @@ pl022_probe(struct amba_device *adev, const struct amba_id *id)
         struct pl022_ssp_controller *platform_info = adev->dev.platform_data;
         struct spi_master *master;
         struct pl022 *pl022 = NULL;     /*Data for this driver */
-        int status = 0;
+        struct device_node *np = adev->dev.of_node;
+        int status = 0, i, num_cs;
 
         dev_info(&adev->dev,
                  "ARM PL022 driver, device ID: 0x%08x\n", adev->periphid);
-        if (platform_info == NULL) {
-                dev_err(&adev->dev, "probe - no platform data supplied\n");
-                status = -ENODEV;
-                goto err_no_pdata;
+        if (!platform_info && IS_ENABLED(CONFIG_OF))
+                platform_info = pl022_platform_data_dt_get(dev);
+
+        if (!platform_info) {
+                dev_err(dev, "probe: no platform data defined\n");
+                return -ENODEV;
+        }
+
+        if (platform_info->num_chipselect) {
+                num_cs = platform_info->num_chipselect;
+        } else {
+                dev_err(dev, "probe: no chip select defined\n");
+                return -ENODEV;
         }
 
         /* Allocate master with space for data */
         master = spi_alloc_master(dev, sizeof(struct pl022));
         if (master == NULL) {
                 dev_err(&adev->dev, "probe - cannot alloc SPI master\n");
-                status = -ENOMEM;
-                goto err_no_master;
+                return -ENOMEM;
         }
 
         pl022 = spi_master_get_devdata(master);
@@ -2016,19 +2096,71 @@ pl022_probe(struct amba_device *adev, const struct amba_id *id)
         pl022->master_info = platform_info;
         pl022->adev = adev;
         pl022->vendor = id->data;
+        pl022->chipselects = devm_kzalloc(dev, num_cs * sizeof(int),
+                                          GFP_KERNEL);
+
+        pl022->pinctrl = devm_pinctrl_get(dev);
+        if (IS_ERR(pl022->pinctrl)) {
+                status = PTR_ERR(pl022->pinctrl);
+                goto err_no_pinctrl;
+        }
+
+        pl022->pins_default = pinctrl_lookup_state(pl022->pinctrl,
+                                                 PINCTRL_STATE_DEFAULT);
+        /* enable pins to be muxed in and configured */
+        if (!IS_ERR(pl022->pins_default)) {
+                status = pinctrl_select_state(pl022->pinctrl,
+                                pl022->pins_default);
+                if (status)
+                        dev_err(dev, "could not set default pins\n");
+        } else
+                dev_err(dev, "could not get default pinstate\n");
+
+        pl022->pins_sleep = pinctrl_lookup_state(pl022->pinctrl,
+                                               PINCTRL_STATE_SLEEP);
+        if (IS_ERR(pl022->pins_sleep))
+                dev_dbg(dev, "could not get sleep pinstate\n");
 
         /*
          * Bus Number Which has been Assigned to this SSP controller
          * on this board
          */
         master->bus_num = platform_info->bus_id;
-        master->num_chipselect = platform_info->num_chipselect;
+        master->num_chipselect = num_cs;
         master->cleanup = pl022_cleanup;
         master->setup = pl022_setup;
         master->prepare_transfer_hardware = pl022_prepare_transfer_hardware;
         master->transfer_one_message = pl022_transfer_one_message;
         master->unprepare_transfer_hardware = pl022_unprepare_transfer_hardware;
         master->rt = platform_info->rt;
+        master->dev.of_node = dev->of_node;
+
+        if (platform_info->num_chipselect && platform_info->chipselects) {
+                for (i = 0; i < num_cs; i++)
+                        pl022->chipselects[i] = platform_info->chipselects[i];
+        } else if (IS_ENABLED(CONFIG_OF)) {
+                for (i = 0; i < num_cs; i++) {
+                        int cs_gpio = of_get_named_gpio(np, "cs-gpios", i);
+
+                        if (cs_gpio == -EPROBE_DEFER) {
+                                status = -EPROBE_DEFER;
+                                goto err_no_gpio;
+                        }
+
+                        pl022->chipselects[i] = cs_gpio;
+
+                        if (gpio_is_valid(cs_gpio)) {
+                                if (devm_gpio_request(dev, cs_gpio, "ssp-pl022"))
+                                        dev_err(&adev->dev,
+                                                "could not request %d gpio\n",
+                                                cs_gpio);
+                                else if (gpio_direction_output(cs_gpio, 1))
+                                        dev_err(&adev->dev,
+                                                "could set gpio %d as output\n",
+                                                cs_gpio);
+                        }
+                }
+        }
 
         /*
          * Supports mode 0-3, loopback, and active low CS. Transfers are
@@ -2045,7 +2177,8 @@ pl022_probe(struct amba_device *adev, const struct amba_id *id)
                 goto err_no_ioregion;
 
         pl022->phybase = adev->res.start;
-        pl022->virtbase = ioremap(adev->res.start, resource_size(&adev->res));
+        pl022->virtbase = devm_ioremap(dev, adev->res.start,
+                                       resource_size(&adev->res));
         if (pl022->virtbase == NULL) {
                 status = -ENOMEM;
                 goto err_no_ioremap;
@@ -2055,7 +2188,7 @@ pl022_probe(struct amba_device *adev, const struct amba_id *id)
 
         pm_runtime_resume(dev);
 
-        pl022->clk = clk_get(&adev->dev, NULL);
+        pl022->clk = devm_clk_get(&adev->dev, NULL);
         if (IS_ERR(pl022->clk)) {
                 status = PTR_ERR(pl022->clk);
                 dev_err(&adev->dev, "could not retrieve SSP/SPI bus clock\n");
@@ -2083,8 +2216,8 @@ pl022_probe(struct amba_device *adev, const struct amba_id *id)
                SSP_CR1(pl022->virtbase));
         load_ssp_default_config(pl022);
 
-        status = request_irq(adev->irq[0], pl022_interrupt_handler, 0, "pl022",
-                             pl022);
+        status = devm_request_irq(dev, adev->irq[0], pl022_interrupt_handler,
+                                  0, "pl022", pl022);
         if (status < 0) {
                 dev_err(&adev->dev, "probe - cannot get IRQ (%d)\n", status);
                 goto err_no_irq;
@@ -2124,22 +2257,18 @@ pl022_probe(struct amba_device *adev, const struct amba_id *id)
  err_spi_register:
         if (platform_info->enable_dma)
                 pl022_dma_remove(pl022);
-
-        free_irq(adev->irq[0], pl022);
  err_no_irq:
         clk_disable(pl022->clk);
  err_no_clk_en:
         clk_unprepare(pl022->clk);
  err_clk_prep:
-        clk_put(pl022->clk);
  err_no_clk:
-        iounmap(pl022->virtbase);
  err_no_ioremap:
         amba_release_regions(adev);
  err_no_ioregion:
+ err_no_gpio:
+ err_no_pinctrl:
         spi_master_put(master);
- err_no_master:
- err_no_pdata:
         return status;
 }
 
@@ -2161,20 +2290,55 @@ pl022_remove(struct amba_device *adev)
         if (pl022->master_info->enable_dma)
                 pl022_dma_remove(pl022);
 
-        free_irq(adev->irq[0], pl022);
         clk_disable(pl022->clk);
         clk_unprepare(pl022->clk);
-        clk_put(pl022->clk);
         pm_runtime_disable(&adev->dev);
-        iounmap(pl022->virtbase);
         amba_release_regions(adev);
         tasklet_disable(&pl022->pump_transfers);
         spi_unregister_master(pl022->master);
-        spi_master_put(pl022->master);
         amba_set_drvdata(adev, NULL);
         return 0;
 }
 
+#if defined(CONFIG_SUSPEND) || defined(CONFIG_PM_RUNTIME)
+/*
+ * These two functions are used from both suspend/resume and
+ * the runtime counterparts to handle external resources like
+ * clocks, pins and regulators when going to sleep.
+ */
+static void pl022_suspend_resources(struct pl022 *pl022)
+{
+        int ret;
+
+        clk_disable(pl022->clk);
+
+        /* Optionally let pins go into sleep states */
+        if (!IS_ERR(pl022->pins_sleep)) {
+                ret = pinctrl_select_state(pl022->pinctrl,
+                                           pl022->pins_sleep);
+                if (ret)
+                        dev_err(&pl022->adev->dev,
+                                "could not set pins to sleep state\n");
+        }
+}
+
+static void pl022_resume_resources(struct pl022 *pl022)
+{
+        int ret;
+
+        /* Optionaly enable pins to be muxed in and configured */
+        if (!IS_ERR(pl022->pins_default)) {
+                ret = pinctrl_select_state(pl022->pinctrl,
+                                           pl022->pins_default);
+                if (ret)
+                        dev_err(&pl022->adev->dev,
+                                "could not set default pins\n");
+        }
+
+        clk_enable(pl022->clk);
+}
+#endif
+
 #ifdef CONFIG_SUSPEND
 static int pl022_suspend(struct device *dev)
 {
@@ -2186,6 +2350,7 @@ static int pl022_suspend(struct device *dev)
                 dev_warn(dev, "cannot suspend master\n");
                 return ret;
         }
+        pl022_suspend_resources(pl022);
 
         dev_dbg(dev, "suspended\n");
         return 0;
@@ -2196,6 +2361,8 @@ static int pl022_resume(struct device *dev)
         struct pl022 *pl022 = dev_get_drvdata(dev);
         int ret;
 
+        pl022_resume_resources(pl022);
+
         /* Start the queue running */
         ret = spi_master_resume(pl022->master);
         if (ret)
@@ -2212,8 +2379,7 @@ static int pl022_runtime_suspend(struct device *dev)
 {
         struct pl022 *pl022 = dev_get_drvdata(dev);
 
-        clk_disable(pl022->clk);
-
+        pl022_suspend_resources(pl022);
         return 0;
 }
 
@@ -2221,8 +2387,7 @@ static int pl022_runtime_resume(struct device *dev)
 {
         struct pl022 *pl022 = dev_get_drvdata(dev);
 
-        clk_enable(pl022->clk);
-
+        pl022_resume_resources(pl022);
         return 0;
 }
 #endif