Patched in Tegra support.

1 files changed, 426 insertions, 494 deletions

diff --git a/drivers/spi/spi-pl022.c b/drivers/spi/spi-pl022.c
index b0fe393c882..730b4a37b82 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-2012 ST-Ericsson AB
+ * Copyright (C) 2008-2009 ST-Ericsson AB
  * Copyright (C) 2006 STMicroelectronics Pvt. Ltd.
  *
  * Author: Linus Walleij <linus.walleij@stericsson.com>
@@ -29,6 +29,7 @@
 #include <linux/errno.h>
 #include <linux/interrupt.h>
 #include <linux/spi/spi.h>
+#include <linux/workqueue.h>
 #include <linux/delay.h>
 #include <linux/clk.h>
 #include <linux/err.h>
@@ -40,9 +41,6 @@
 #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.
@@ -115,6 +113,7 @@
 #define SSP_CR0_MASK_CSS_ST     (0x1FUL << 16)
 #define SSP_CR0_MASK_FRF_ST     (0x3UL << 21)
 
+
 /*
  * SSP Control Register 0  - SSP_CR1
  */
@@ -284,6 +283,7 @@
 
 #define SPI_POLLING_TIMEOUT 1000
 
+
 /*
  * The type of reading going on on this chip
  */
@@ -332,21 +332,16 @@ struct vendor_data {
  * @clk: outgoing clock "SPICLK" for the SPI bus
  * @master: SPI framework hookup
  * @master_info: controller-specific data from machine setup
- * @kworker: thread struct for message pump
- * @kworker_task: pointer to task for message pump kworker thread
- * @pump_messages: work struct for scheduling work to the message pump
+ * @workqueue: a workqueue on which any spi_message request is queued
+ * @pump_messages: work struct for scheduling work to the workqueue
  * @queue_lock: spinlock to syncronise access to message queue
  * @queue: message queue
- * @busy: message pump is busy
- * @running: message pump is running
+ * @busy: workqueue is busy
+ * @running: workqueue is running
  * @pump_transfers: Tasklet used in Interrupt Transfer mode
  * @cur_msg: Pointer to current spi_message being processed
  * @cur_transfer: Pointer to current spi_transfer
  * @cur_chip: pointer to current clients chip(assigned from controller_state)
- * @next_msg_cs_active: the next message in the queue has been examined
- *  and it was found that it uses the same chip select as the previous
- *  message, so we left it active after the previous transfer, and it's
- *  active already.
  * @tx: current position in TX buffer to be read
  * @tx_end: end position in TX buffer to be read
  * @rx: current position in RX buffer to be written
@@ -359,8 +354,6 @@ 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;
@@ -368,19 +361,20 @@ 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_idle;
-        struct pinctrl_state            *pins_sleep;
         struct spi_master               *master;
         struct pl022_ssp_controller     *master_info;
-        /* Message per-transfer pump */
+        /* Driver message queue */
+        struct workqueue_struct         *workqueue;
+        struct work_struct              pump_messages;
+        spinlock_t                      queue_lock;
+        struct list_head                queue;
+        bool                            busy;
+        bool                            running;
+        /* Message transfer pump */
         struct tasklet_struct           pump_transfers;
         struct spi_message              *cur_msg;
         struct spi_transfer             *cur_transfer;
         struct chip_data                *cur_chip;
-        bool                            next_msg_cs_active;
         void                            *tx;
         void                            *tx_end;
         void                            *rx;
@@ -397,10 +391,7 @@ struct pl022 {
         struct sg_table                 sgt_rx;
         struct sg_table                 sgt_tx;
         char                            *dummypage;
-        bool                            dma_running;
 #endif
-        int cur_cs;
-        int *chipselects;
 };
 
 /**
@@ -445,14 +436,6 @@ 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
@@ -462,9 +445,25 @@ static void pl022_cs_control(struct pl022 *pl022, u32 command)
 static void giveback(struct pl022 *pl022)
 {
         struct spi_transfer *last_transfer;
-        pl022->next_msg_cs_active = false;
+        unsigned long flags;
+        struct spi_message *msg;
+        void (*curr_cs_control) (u32 command);
+
+        /*
+         * This local reference to the chip select function
+         * is needed because we set curr_chip to NULL
+         * as a step toward termininating the message.
+         */
+        curr_cs_control = pl022->cur_chip->cs_control;
+        spin_lock_irqsave(&pl022->queue_lock, flags);
+        msg = pl022->cur_msg;
+        pl022->cur_msg = NULL;
+        pl022->cur_transfer = NULL;
+        pl022->cur_chip = NULL;
+        queue_work(pl022->workqueue, &pl022->pump_messages);
+        spin_unlock_irqrestore(&pl022->queue_lock, flags);
 
-        last_transfer = list_entry(pl022->cur_msg->transfers.prev,
+        last_transfer = list_entry(msg->transfers.prev,
                                         struct spi_transfer,
                                         transfer_list);
 
@@ -476,44 +475,50 @@ static void giveback(struct pl022 *pl022)
                  */
                 udelay(last_transfer->delay_usecs);
 
-        if (!last_transfer->cs_change) {
+        /*
+         * Drop chip select UNLESS cs_change is true or we are returning
+         * a message with an error, or next message is for another chip
+         */
+        if (!last_transfer->cs_change)
+                curr_cs_control(SSP_CHIP_DESELECT);
+        else {
                 struct spi_message *next_msg;
 
-                /*
-                 * cs_change was not set. We can keep the chip select
-                 * enabled if there is message in the queue and it is
-                 * for the same spi device.
+                /* Holding of cs was hinted, but we need to make sure
+                 * the next message is for the same chip.  Don't waste
+                 * time with the following tests unless this was hinted.
                  *
                  * We cannot postpone this until pump_messages, because
                  * after calling msg->complete (below) the driver that
                  * sent the current message could be unloaded, which
                  * could invalidate the cs_control() callback...
                  */
-                /* get a pointer to the next message, if any */
-                next_msg = spi_get_next_queued_message(pl022->master);
 
-                /*
-                 * see if the next and current messages point
-                 * to the same spi device.
-                 */
-                if (next_msg && next_msg->spi != pl022->cur_msg->spi)
+                /* get a pointer to the next message, if any */
+                spin_lock_irqsave(&pl022->queue_lock, flags);
+                if (list_empty(&pl022->queue))
                         next_msg = NULL;
-                if (!next_msg || pl022->cur_msg->state == STATE_ERROR)
-                        pl022_cs_control(pl022, SSP_CHIP_DESELECT);
                 else
-                        pl022->next_msg_cs_active = true;
+                        next_msg = list_entry(pl022->queue.next,
+                                        struct spi_message, queue);
+                spin_unlock_irqrestore(&pl022->queue_lock, flags);
 
+                /* see if the next and current messages point
+                 * to the same chip
+                 */
+                if (next_msg && next_msg->spi != msg->spi)
+                        next_msg = NULL;
+                if (!next_msg || msg->state == STATE_ERROR)
+                        curr_cs_control(SSP_CHIP_DESELECT);
         }
-
-        pl022->cur_msg = NULL;
-        pl022->cur_transfer = NULL;
-        pl022->cur_chip = NULL;
-        spi_finalize_current_message(pl022->master);
-
-        /* disable the SPI/SSP operation */
-        writew((readw(SSP_CR1(pl022->virtbase)) &
-                (~SSP_CR1_MASK_SSE)), SSP_CR1(pl022->virtbase));
-
+        msg->state = NULL;
+        if (msg->complete)
+                msg->complete(msg->context);
+        /* This message is completed, so let's turn off the clocks & power */
+        clk_disable(pl022->clk);
+        amba_pclk_disable(pl022->adev);
+        amba_vcore_disable(pl022->adev);
+        pm_runtime_put(&pl022->adev->dev);
 }
 
 /**
@@ -747,6 +752,7 @@ static void readwriter(struct pl022 *pl022)
          */
 }
 
+
 /**
  * next_transfer - Move to the Next transfer in the current spi message
  * @pl022: SSP driver private data structure
@@ -838,7 +844,8 @@ static void dma_callback(void *data)
         /* Update total bytes transferred */
         msg->actual_length += pl022->cur_transfer->len;
         if (pl022->cur_transfer->cs_change)
-                pl022_cs_control(pl022, SSP_CHIP_DESELECT);
+                pl022->cur_chip->
+                        cs_control(SSP_CHIP_DESELECT);
 
         /* Move to next transfer */
         msg->state = next_transfer(pl022);
@@ -903,13 +910,11 @@ static int configure_dma(struct pl022 *pl022)
 {
         struct dma_slave_config rx_conf = {
                 .src_addr = SSP_DR(pl022->phybase),
-                .direction = DMA_DEV_TO_MEM,
-                .device_fc = false,
+                .direction = DMA_FROM_DEVICE,
         };
         struct dma_slave_config tx_conf = {
                 .dst_addr = SSP_DR(pl022->phybase),
-                .direction = DMA_MEM_TO_DEV,
-                .device_fc = false,
+                .direction = DMA_TO_DEVICE,
         };
         unsigned int pages;
         int ret;
@@ -1014,14 +1019,14 @@ static int configure_dma(struct pl022 *pl022)
         dmaengine_slave_config(txchan, &tx_conf);
 
         /* Create sglists for the transfers */
-        pages = DIV_ROUND_UP(pl022->cur_transfer->len, PAGE_SIZE);
+        pages = (pl022->cur_transfer->len >> PAGE_SHIFT) + 1;
         dev_dbg(&pl022->adev->dev, "using %d pages for transfer\n", pages);
 
-        ret = sg_alloc_table(&pl022->sgt_rx, pages, GFP_ATOMIC);
+        ret = sg_alloc_table(&pl022->sgt_rx, pages, GFP_KERNEL);
         if (ret)
                 goto err_alloc_rx_sg;
 
-        ret = sg_alloc_table(&pl022->sgt_tx, pages, GFP_ATOMIC);
+        ret = sg_alloc_table(&pl022->sgt_tx, pages, GFP_KERNEL);
         if (ret)
                 goto err_alloc_tx_sg;
 
@@ -1043,18 +1048,18 @@ static int configure_dma(struct pl022 *pl022)
                 goto err_tx_sgmap;
 
         /* Send both scatterlists */
-        rxdesc = dmaengine_prep_slave_sg(rxchan,
+        rxdesc = rxchan->device->device_prep_slave_sg(rxchan,
                                       pl022->sgt_rx.sgl,
                                       rx_sglen,
-                                      DMA_DEV_TO_MEM,
+                                      DMA_FROM_DEVICE,
                                       DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
         if (!rxdesc)
                 goto err_rxdesc;
 
-        txdesc = dmaengine_prep_slave_sg(txchan,
+        txdesc = txchan->device->device_prep_slave_sg(txchan,
                                       pl022->sgt_tx.sgl,
                                       tx_sglen,
-                                      DMA_MEM_TO_DEV,
+                                      DMA_TO_DEVICE,
                                       DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
         if (!txdesc)
                 goto err_txdesc;
@@ -1068,7 +1073,6 @@ static int configure_dma(struct pl022 *pl022)
         dmaengine_submit(txdesc);
         dma_async_issue_pending(rxchan);
         dma_async_issue_pending(txchan);
-        pl022->dma_running = true;
 
         return 0;
 
@@ -1089,7 +1093,7 @@ err_alloc_rx_sg:
         return -ENOMEM;
 }
 
-static int pl022_dma_probe(struct pl022 *pl022)
+static int __init pl022_dma_probe(struct pl022 *pl022)
 {
         dma_cap_mask_t mask;
 
@@ -1147,12 +1151,11 @@ static void terminate_dma(struct pl022 *pl022)
         dmaengine_terminate_all(rxchan);
         dmaengine_terminate_all(txchan);
         unmap_free_dma_scatter(pl022);
-        pl022->dma_running = false;
 }
 
 static void pl022_dma_remove(struct pl022 *pl022)
 {
-        if (pl022->dma_running)
+        if (pl022->busy)
                 terminate_dma(pl022);
         if (pl022->dma_tx_channel)
                 dma_release_channel(pl022->dma_tx_channel);
@@ -1247,9 +1250,9 @@ static irqreturn_t pl022_interrupt_handler(int irq, void *dev_id)
 
         if ((pl022->tx == pl022->tx_end) && (flag == 0)) {
                 flag = 1;
-                /* Disable Transmit interrupt, enable receive interrupt */
-                writew((readw(SSP_IMSC(pl022->virtbase)) &
-                       ~SSP_IMSC_MASK_TXIM) | SSP_IMSC_MASK_RXIM,
+                /* Disable Transmit interrupt */
+                writew(readw(SSP_IMSC(pl022->virtbase)) &
+                       (~SSP_IMSC_MASK_TXIM),
                        SSP_IMSC(pl022->virtbase));
         }
 
@@ -1271,7 +1274,8 @@ 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_cs_control(pl022, SSP_CHIP_DESELECT);
+                        pl022->cur_chip->
+                                cs_control(SSP_CHIP_DESELECT);
                 /* Move to next transfer */
                 msg->state = next_transfer(pl022);
                 tasklet_schedule(&pl022->pump_transfers);
@@ -1354,9 +1358,9 @@ static void pump_transfers(unsigned long data)
                          */
                         udelay(previous->delay_usecs);
 
-                /* Reselect chip select only if cs_change was requested */
+                /* Drop chip select only if cs_change is requested */
                 if (previous->cs_change)
-                        pl022_cs_control(pl022, SSP_CHIP_SELECT);
+                        pl022->cur_chip->cs_control(SSP_CHIP_SELECT);
         } else {
                 /* STATE_START */
                 message->state = STATE_RUNNING;
@@ -1381,22 +1385,15 @@ static void pump_transfers(unsigned long data)
         }
 
 err_config_dma:
-        /* enable all interrupts except RX */
-        writew(ENABLE_ALL_INTERRUPTS & ~SSP_IMSC_MASK_RXIM, SSP_IMSC(pl022->virtbase));
+        writew(ENABLE_ALL_INTERRUPTS, SSP_IMSC(pl022->virtbase));
 }
 
 static void do_interrupt_dma_transfer(struct pl022 *pl022)
 {
-        /*
-         * Default is to enable all interrupts except RX -
-         * this will be enabled once TX is complete
-         */
-        u32 irqflags = ENABLE_ALL_INTERRUPTS & ~SSP_IMSC_MASK_RXIM;
-
-        /* Enable target chip, if not already active */
-        if (!pl022->next_msg_cs_active)
-                pl022_cs_control(pl022, SSP_CHIP_SELECT);
+        u32 irqflags = ENABLE_ALL_INTERRUPTS;
 
+        /* Enable target chip */
+        pl022->cur_chip->cs_control(SSP_CHIP_SELECT);
         if (set_up_next_transfer(pl022, pl022->cur_transfer)) {
                 /* Error path */
                 pl022->cur_msg->state = STATE_ERROR;
@@ -1447,12 +1444,11 @@ static void do_polling_transfer(struct pl022 *pl022)
                         if (previous->delay_usecs)
                                 udelay(previous->delay_usecs);
                         if (previous->cs_change)
-                                pl022_cs_control(pl022, SSP_CHIP_SELECT);
+                                pl022->cur_chip->cs_control(SSP_CHIP_SELECT);
                 } else {
                         /* STATE_START */
                         message->state = STATE_RUNNING;
-                        if (!pl022->next_msg_cs_active)
-                                pl022_cs_control(pl022, SSP_CHIP_SELECT);
+                        pl022->cur_chip->cs_control(SSP_CHIP_SELECT);
                 }
 
                 /* Configuration Changing Per Transfer */
@@ -1484,7 +1480,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_cs_control(pl022, SSP_CHIP_DESELECT);
+                        pl022->cur_chip->cs_control(SSP_CHIP_DESELECT);
                 /* Move to next transfer */
                 message->state = next_transfer(pl022);
         }
@@ -1499,22 +1495,59 @@ out:
         return;
 }
 
-static int pl022_transfer_one_message(struct spi_master *master,
-                                      struct spi_message *msg)
+/**
+ * pump_messages - Workqueue function which processes spi message queue
+ * @data: pointer to private data of SSP driver
+ *
+ * This function checks if there is any spi message in the queue that
+ * needs processing and delegate control to appropriate function
+ * do_polling_transfer()/do_interrupt_dma_transfer()
+ * based on the kind of the transfer
+ *
+ */
+static void pump_messages(struct work_struct *work)
 {
-        struct pl022 *pl022 = spi_master_get_devdata(master);
+        struct pl022 *pl022 =
+                container_of(work, struct pl022, pump_messages);
+        unsigned long flags;
+
+        /* Lock queue and check for queue work */
+        spin_lock_irqsave(&pl022->queue_lock, flags);
+        if (list_empty(&pl022->queue) || !pl022->running) {
+                pl022->busy = false;
+                spin_unlock_irqrestore(&pl022->queue_lock, flags);
+                return;
+        }
+        /* Make sure we are not already running a message */
+        if (pl022->cur_msg) {
+                spin_unlock_irqrestore(&pl022->queue_lock, flags);
+                return;
+        }
+        /* Extract head of queue */
+        pl022->cur_msg =
+            list_entry(pl022->queue.next, struct spi_message, queue);
 
-        /* Initial message state */
-        pl022->cur_msg = msg;
-        msg->state = STATE_START;
+        list_del_init(&pl022->cur_msg->queue);
+        pl022->busy = true;
+        spin_unlock_irqrestore(&pl022->queue_lock, flags);
 
-        pl022->cur_transfer = list_entry(msg->transfers.next,
-                                         struct spi_transfer, transfer_list);
+        /* Initial message state */
+        pl022->cur_msg->state = STATE_START;
+        pl022->cur_transfer = list_entry(pl022->cur_msg->transfers.next,
+                                            struct spi_transfer,
+                                            transfer_list);
 
         /* 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];
-
+        pl022->cur_chip = spi_get_ctldata(pl022->cur_msg->spi);
+        /*
+         * We enable the core voltage and clocks here, then the clocks
+         * and core will be disabled when giveback() is called in each method
+         * (poll/interrupt/DMA)
+         */
+        pm_runtime_get_sync(&pl022->adev->dev);
+        amba_vcore_enable(pl022->adev);
+        amba_pclk_enable(pl022->adev);
+        clk_enable(pl022->clk);
         restore_state(pl022);
         flush(pl022);
 
@@ -1522,37 +1555,97 @@ static int pl022_transfer_one_message(struct spi_master *master,
                 do_polling_transfer(pl022);
         else
                 do_interrupt_dma_transfer(pl022);
+}
+
+
+static int __init init_queue(struct pl022 *pl022)
+{
+        INIT_LIST_HEAD(&pl022->queue);
+        spin_lock_init(&pl022->queue_lock);
+
+        pl022->running = false;
+        pl022->busy = false;
+
+        tasklet_init(&pl022->pump_transfers,
+                        pump_transfers, (unsigned long)pl022);
+
+        INIT_WORK(&pl022->pump_messages, pump_messages);
+        pl022->workqueue = create_singlethread_workqueue(
+                                        dev_name(pl022->master->dev.parent));
+        if (pl022->workqueue == NULL)
+                return -EBUSY;
 
         return 0;
 }
 
-static int pl022_prepare_transfer_hardware(struct spi_master *master)
+
+static int start_queue(struct pl022 *pl022)
 {
-        struct pl022 *pl022 = spi_master_get_devdata(master);
+        unsigned long flags;
+
+        spin_lock_irqsave(&pl022->queue_lock, flags);
+
+        if (pl022->running || pl022->busy) {
+                spin_unlock_irqrestore(&pl022->queue_lock, flags);
+                return -EBUSY;
+        }
+
+        pl022->running = true;
+        pl022->cur_msg = NULL;
+        pl022->cur_transfer = NULL;
+        pl022->cur_chip = NULL;
+        spin_unlock_irqrestore(&pl022->queue_lock, flags);
+
+        queue_work(pl022->workqueue, &pl022->pump_messages);
 
-        /*
-         * Just make sure we have all we need to run the transfer by syncing
-         * with the runtime PM framework.
-         */
-        pm_runtime_get_sync(&pl022->adev->dev);
         return 0;
 }
 
-static int pl022_unprepare_transfer_hardware(struct spi_master *master)
+
+static int stop_queue(struct pl022 *pl022)
 {
-        struct pl022 *pl022 = spi_master_get_devdata(master);
+        unsigned long flags;
+        unsigned limit = 500;
+        int status = 0;
 
-        /* nothing more to do - disable spi/ssp and power off */
-        writew((readw(SSP_CR1(pl022->virtbase)) &
-                (~SSP_CR1_MASK_SSE)), SSP_CR1(pl022->virtbase));
+        spin_lock_irqsave(&pl022->queue_lock, flags);
 
-        if (pl022->master_info->autosuspend_delay > 0) {
-                pm_runtime_mark_last_busy(&pl022->adev->dev);
-                pm_runtime_put_autosuspend(&pl022->adev->dev);
-        } else {
-                pm_runtime_put(&pl022->adev->dev);
+        /* This is a bit lame, but is optimized for the common execution path.
+         * A wait_queue on the pl022->busy could be used, but then the common
+         * execution path (pump_messages) would be required to call wake_up or
+         * friends on every SPI message. Do this instead */
+        while ((!list_empty(&pl022->queue) || pl022->busy) && limit--) {
+                spin_unlock_irqrestore(&pl022->queue_lock, flags);
+                msleep(10);
+                spin_lock_irqsave(&pl022->queue_lock, flags);
         }
 
+        if (!list_empty(&pl022->queue) || pl022->busy)
+                status = -EBUSY;
+        else
+                pl022->running = false;
+
+        spin_unlock_irqrestore(&pl022->queue_lock, flags);
+
+        return status;
+}
+
+static int destroy_queue(struct pl022 *pl022)
+{
+        int status;
+
+        status = stop_queue(pl022);
+        /* we are unloading the module or failing to load (only two calls
+         * to this routine), and neither call can handle a return value.
+         * However, destroy_workqueue calls flush_workqueue, and that will
+         * block until all work is done.  If the reason that stop_queue
+         * timed out is that the work will never finish, then it does no
+         * good to call destroy_workqueue, so return anyway. */
+        if (status != 0)
+                return status;
+
+        destroy_workqueue(pl022->workqueue);
+
         return 0;
 }
 
@@ -1672,87 +1765,103 @@ static int verify_controller_parameters(struct pl022 *pl022,
         return 0;
 }
 
-static inline u32 spi_rate(u32 rate, u16 cpsdvsr, u16 scr)
+/**
+ * pl022_transfer - transfer function registered to SPI master framework
+ * @spi: spi device which is requesting transfer
+ * @msg: spi message which is to handled is queued to driver queue
+ *
+ * This function is registered to the SPI framework for this SPI master
+ * controller. It will queue the spi_message in the queue of driver if
+ * the queue is not stopped and return.
+ */
+static int pl022_transfer(struct spi_device *spi, struct spi_message *msg)
 {
-        return rate / (cpsdvsr * (1 + scr));
+        struct pl022 *pl022 = spi_master_get_devdata(spi->master);
+        unsigned long flags;
+
+        spin_lock_irqsave(&pl022->queue_lock, flags);
+
+        if (!pl022->running) {
+                spin_unlock_irqrestore(&pl022->queue_lock, flags);
+                return -ESHUTDOWN;
+        }
+        msg->actual_length = 0;
+        msg->status = -EINPROGRESS;
+        msg->state = STATE_START;
+
+        list_add_tail(&msg->queue, &pl022->queue);
+        if (pl022->running && !pl022->busy)
+                queue_work(pl022->workqueue, &pl022->pump_messages);
+
+        spin_unlock_irqrestore(&pl022->queue_lock, flags);
+        return 0;
 }
 
-static int calculate_effective_freq(struct pl022 *pl022, int freq, struct
-                                    ssp_clock_params * clk_freq)
+static int calculate_effective_freq(struct pl022 *pl022,
+                                    int freq,
+                                    struct ssp_clock_params *clk_freq)
 {
         /* Lets calculate the frequency parameters */
-        u16 cpsdvsr = CPSDVR_MIN, scr = SCR_MIN;
-        u32 rate, max_tclk, min_tclk, best_freq = 0, best_cpsdvsr = 0,
-                best_scr = 0, tmp, found = 0;
+        u16 cpsdvsr = 2;
+        u16 scr = 0;
+        bool freq_found = false;
+        u32 rate;
+        u32 max_tclk;
+        u32 min_tclk;
 
         rate = clk_get_rate(pl022->clk);
         /* cpsdvscr = 2 & scr 0 */
-        max_tclk = spi_rate(rate, CPSDVR_MIN, SCR_MIN);
+        max_tclk = (rate / (CPSDVR_MIN * (1 + SCR_MIN)));
         /* cpsdvsr = 254 & scr = 255 */
-        min_tclk = spi_rate(rate, CPSDVR_MAX, SCR_MAX);
-
-        if (freq > max_tclk)
-                dev_warn(&pl022->adev->dev,
-                        "Max speed that can be programmed is %d Hz, you requested %d\n",
-                        max_tclk, freq);
-
-        if (freq < min_tclk) {
-                dev_err(&pl022->adev->dev,
-                        "Requested frequency: %d Hz is less than minimum possible %d Hz\n",
-                        freq, min_tclk);
-                return -EINVAL;
-        }
-
-        /*
-         * best_freq will give closest possible available rate (<= requested
-         * freq) for all values of scr & cpsdvsr.
-         */
-        while ((cpsdvsr <= CPSDVR_MAX) && !found) {
-                while (scr <= SCR_MAX) {
-                        tmp = spi_rate(rate, cpsdvsr, scr);
-
-                        if (tmp > freq) {
-                                /* we need lower freq */
-                                scr++;
-                                continue;
+        min_tclk = (rate / (CPSDVR_MAX * (1 + SCR_MAX)));
+
+        if ((freq <= max_tclk) && (freq >= min_tclk)) {
+                while (cpsdvsr <= CPSDVR_MAX && !freq_found) {
+                        while (scr <= SCR_MAX && !freq_found) {
+                                if ((rate /
+                                     (cpsdvsr * (1 + scr))) > freq)
+                                        scr += 1;
+                                else {
+                                        /*
+                                         * This bool is made true when
+                                         * effective frequency >=
+                                         * target frequency is found
+                                         */
+                                        freq_found = true;
+                                        if ((rate /
+                                             (cpsdvsr * (1 + scr))) != freq) {
+                                                if (scr == SCR_MIN) {
+                                                        cpsdvsr -= 2;
+                                                        scr = SCR_MAX;
+                                                } else
+                                                        scr -= 1;
+                                        }
+                                }
                         }
-
-                        /*
-                         * If found exact value, mark found and break.
-                         * If found more closer value, update and break.
-                         */
-                        if (tmp > best_freq) {
-                                best_freq = tmp;
-                                best_cpsdvsr = cpsdvsr;
-                                best_scr = scr;
-
-                                if (tmp == freq)
-                                        found = 1;
+                        if (!freq_found) {
+                                cpsdvsr += 2;
+                                scr = SCR_MIN;
                         }
-                        /*
-                         * increased scr will give lower rates, which are not
-                         * required
-                         */
-                        break;
                 }
-                cpsdvsr += 2;
-                scr = SCR_MIN;
+                if (cpsdvsr != 0) {
+                        dev_dbg(&pl022->adev->dev,
+                                "SSP Effective Frequency is %u\n",
+                                (rate / (cpsdvsr * (1 + scr))));
+                        clk_freq->cpsdvsr = (u8) (cpsdvsr & 0xFF);
+                        clk_freq->scr = (u8) (scr & 0xFF);
+                        dev_dbg(&pl022->adev->dev,
+                                "SSP cpsdvsr = %d, scr = %d\n",
+                                clk_freq->cpsdvsr, clk_freq->scr);
+                }
+        } else {
+                dev_err(&pl022->adev->dev,
+                        "controller data is incorrect: out of range frequency");
+                return -EINVAL;
         }
-
-        WARN(!best_freq, "pl022: Matching cpsdvsr and scr not found for %d Hz rate \n",
-                        freq);
-
-        clk_freq->cpsdvsr = (u8) (best_cpsdvsr & 0xFF);
-        clk_freq->scr = (u8) (best_scr & 0xFF);
-        dev_dbg(&pl022->adev->dev,
-                "SSP Target Frequency is: %u, Effective Frequency is %u\n",
-                freq, best_freq);
-        dev_dbg(&pl022->adev->dev, "SSP cpsdvsr = %d, scr = %d\n",
-                clk_freq->cpsdvsr, clk_freq->scr);
-
         return 0;
 }
 
+
 /*
  * A piece of default chip info unless the platform
  * supplies it.
@@ -1770,6 +1879,7 @@ static const struct pl022_config_chip pl022_default_chip_info = {
         .cs_control = null_cs_control,
 };
 
+
 /**
  * pl022_setup - setup function registered to SPI master framework
  * @spi: spi device which is requesting setup
@@ -1785,14 +1895,12 @@ 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};
+        struct ssp_clock_params clk_freq = {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;
@@ -1815,32 +1923,10 @@ static int pl022_setup(struct spi_device *spi)
         chip_info = spi->controller_data;
 
         if (chip_info == NULL) {
-                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");
-                }
+                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");
@@ -1870,6 +1956,7 @@ static int pl022_setup(struct spi_device *spi)
                 goto err_config_params;
         }
 
+
         status = verify_controller_parameters(pl022, chip_info);
         if (status) {
                 dev_err(&spi->dev, "controller data is incorrect");
@@ -1883,18 +1970,14 @@ 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;
-                if (!gpio_is_valid(pl022->chipselects[spi->chip_select]))
-                        dev_warn(&spi->dev,
-                                 "invalid chip select\n");
+                dev_warn(&spi->dev,
+                         "chip select function is NULL for this chip\n");
         } else
                 chip->cs_control = chip_info->cs_control;
 
-        /* Check bits per word with vendor specific range */
-        if ((bits <= 3) || (bits > pl022->vendor->max_bpw)) {
+        if (bits <= 3) {
+                /* PL022 doesn't support less than 4-bits */
                 status = -ENOTSUPP;
-                dev_err(&spi->dev, "illegal data size for this controller!\n");
-                dev_err(&spi->dev, "This controller can only handle 4 <= n <= %d bit words\n",
-                                pl022->vendor->max_bpw);
                 goto err_config_params;
         } else if (bits <= 8) {
                 dev_dbg(&spi->dev, "4 <= n <=8 bits per word\n");
@@ -1907,10 +1990,20 @@ static int pl022_setup(struct spi_device *spi)
                 chip->read = READING_U16;
                 chip->write = WRITING_U16;
         } else {
-                dev_dbg(&spi->dev, "17 <= n <= 32 bits per word\n");
-                chip->n_bytes = 4;
-                chip->read = READING_U32;
-                chip->write = WRITING_U32;
+                if (pl022->vendor->max_bpw >= 32) {
+                        dev_dbg(&spi->dev, "17 <= n <= 32 bits per word\n");
+                        chip->n_bytes = 4;
+                        chip->read = READING_U32;
+                        chip->write = WRITING_U32;
+                } else {
+                        dev_err(&spi->dev,
+                                "illegal data size for this controller!\n");
+                        dev_err(&spi->dev,
+                                "a standard pl022 can only handle "
+                                "1 <= n <= 16 bit words\n");
+                        status = -ENOTSUPP;
+                        goto err_config_params;
+                }
         }
 
         /* Now Initialize all register settings required for this chip */
@@ -2003,8 +2096,7 @@ static int pl022_setup(struct spi_device *spi)
         }
         SSP_WRITE_BITS(chip->cr1, SSP_DISABLED, SSP_CR1_MASK_SSE, 1);
         SSP_WRITE_BITS(chip->cr1, chip_info->hierarchy, SSP_CR1_MASK_MS, 2);
-        SSP_WRITE_BITS(chip->cr1, chip_info->slave_tx_disable, SSP_CR1_MASK_SOD,
-                3);
+        SSP_WRITE_BITS(chip->cr1, chip_info->slave_tx_disable, SSP_CR1_MASK_SOD, 3);
 
         /* Save controller_state */
         spi_set_ctldata(spi, chip);
@@ -2030,65 +2122,30 @@ 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 pl022_probe(struct amba_device *adev, const struct amba_id *id)
+static int __devinit
+pl022_probe(struct amba_device *adev, const struct amba_id *id)
 {
         struct device *dev = &adev->dev;
         struct pl022_ssp_controller *platform_info = adev->dev.platform_data;
         struct spi_master *master;
         struct pl022 *pl022 = NULL;     /*Data for this driver */
-        struct device_node *np = adev->dev.of_node;
-        int status = 0, i, num_cs;
+        int status = 0;
 
         dev_info(&adev->dev,
                  "ARM PL022 driver, device ID: 0x%08x\n", adev->periphid);
-        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;
+        if (platform_info == NULL) {
+                dev_err(&adev->dev, "probe - no platform data supplied\n");
+                status = -ENODEV;
+                goto err_no_pdata;
         }
 
         /* 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");
-                return -ENOMEM;
+                status = -ENOMEM;
+                goto err_no_master;
         }
 
         pl022 = spi_master_get_devdata(master);
@@ -2096,76 +2153,16 @@ static int 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_idle = pinctrl_lookup_state(pl022->pinctrl,
-                                              PINCTRL_STATE_IDLE);
-        if (IS_ERR(pl022->pins_idle))
-                dev_dbg(dev, "could not get idle 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 = num_cs;
+        master->num_chipselect = platform_info->num_chipselect;
         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);
-                        }
-                }
-        }
+        master->transfer = pl022_transfer;
 
         /*
          * Supports mode 0-3, loopback, and active low CS. Transfers are
@@ -2182,45 +2179,30 @@ static int pl022_probe(struct amba_device *adev, const struct amba_id *id)
                 goto err_no_ioregion;
 
         pl022->phybase = adev->res.start;
-        pl022->virtbase = devm_ioremap(dev, adev->res.start,
-                                       resource_size(&adev->res));
+        pl022->virtbase = ioremap(adev->res.start, resource_size(&adev->res));
         if (pl022->virtbase == NULL) {
                 status = -ENOMEM;
                 goto err_no_ioremap;
         }
         printk(KERN_INFO "pl022: mapped registers from 0x%08x to %p\n",
                adev->res.start, pl022->virtbase);
+        pm_runtime_enable(dev);
+        pm_runtime_resume(dev);
 
-        pl022->clk = devm_clk_get(&adev->dev, NULL);
+        pl022->clk = 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");
                 goto err_no_clk;
         }
 
-        status = clk_prepare(pl022->clk);
-        if (status) {
-                dev_err(&adev->dev, "could not prepare SSP/SPI bus clock\n");
-                goto  err_clk_prep;
-        }
-
-        status = clk_enable(pl022->clk);
-        if (status) {
-                dev_err(&adev->dev, "could not enable SSP/SPI bus clock\n");
-                goto err_no_clk_en;
-        }
-
-        /* Initialize transfer pump */
-        tasklet_init(&pl022->pump_transfers, pump_transfers,
-                     (unsigned long)pl022);
-
         /* Disable SSP */
         writew((readw(SSP_CR1(pl022->virtbase)) & (~SSP_CR1_MASK_SSE)),
                SSP_CR1(pl022->virtbase));
         load_ssp_default_config(pl022);
 
-        status = devm_request_irq(dev, adev->irq[0], pl022_interrupt_handler,
-                                  0, "pl022", pl022);
+        status = request_irq(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;
@@ -2233,6 +2215,17 @@ static int pl022_probe(struct amba_device *adev, const struct amba_id *id)
                         platform_info->enable_dma = 0;
         }
 
+        /* Initialize and start queue */
+        status = init_queue(pl022);
+        if (status != 0) {
+                dev_err(&adev->dev, "probe - problem initializing queue\n");
+                goto err_init_queue;
+        }
+        status = start_queue(pl022);
+        if (status != 0) {
+                dev_err(&adev->dev, "probe - problem starting queue\n");
+                goto err_start_queue;
+        }
         /* Register with the SPI framework */
         amba_set_drvdata(adev, pl022);
         status = spi_register_master(master);
@@ -2242,39 +2235,35 @@ static int pl022_probe(struct amba_device *adev, const struct amba_id *id)
                 goto err_spi_register;
         }
         dev_dbg(dev, "probe succeeded\n");
-
-        /* let runtime pm put suspend */
-        if (platform_info->autosuspend_delay > 0) {
-                dev_info(&adev->dev,
-                        "will use autosuspend for runtime pm, delay %dms\n",
-                        platform_info->autosuspend_delay);
-                pm_runtime_set_autosuspend_delay(dev,
-                        platform_info->autosuspend_delay);
-                pm_runtime_use_autosuspend(dev);
-        }
-        pm_runtime_put(dev);
-
+        /*
+         * Disable the silicon block pclk and any voltage domain and just
+         * power it up and clock it when it's needed
+         */
+        amba_pclk_disable(adev);
+        amba_vcore_disable(adev);
         return 0;
 
  err_spi_register:
-        if (platform_info->enable_dma)
-                pl022_dma_remove(pl022);
+ err_start_queue:
+ err_init_queue:
+        destroy_queue(pl022);
+        pl022_dma_remove(pl022);
+        free_irq(adev->irq[0], pl022);
+        pm_runtime_disable(&adev->dev);
  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;
 }
 
-static int
+static int __devexit
 pl022_remove(struct amba_device *adev)
 {
         struct pl022 *pl022 = amba_get_drvdata(adev);
@@ -2282,137 +2271,63 @@ pl022_remove(struct amba_device *adev)
         if (!pl022)
                 return 0;
 
-        /*
-         * undo pm_runtime_put() in probe.  I assume that we're not
-         * accessing the primecell here.
-         */
-        pm_runtime_get_noresume(&adev->dev);
-
+        /* Remove the queue */
+        if (destroy_queue(pl022) != 0)
+                dev_err(&adev->dev, "queue remove failed\n");
         load_ssp_default_config(pl022);
-        if (pl022->master_info->enable_dma)
-                pl022_dma_remove(pl022);
-
+        pl022_dma_remove(pl022);
+        free_irq(adev->irq[0], pl022);
         clk_disable(pl022->clk);
-        clk_unprepare(pl022->clk);
+        clk_put(pl022->clk);
+        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, bool runtime)
+#ifdef CONFIG_PM
+static int pl022_suspend(struct amba_device *adev, pm_message_t state)
 {
-        int ret;
-        struct pinctrl_state *pins_state;
-
-        clk_disable(pl022->clk);
-
-        pins_state = runtime ? pl022->pins_idle : pl022->pins_sleep;
-        /* Optionally let pins go into sleep states */
-        if (!IS_ERR(pins_state)) {
-                ret = pinctrl_select_state(pl022->pinctrl, pins_state);
-                if (ret)
-                        dev_err(&pl022->adev->dev, "could not set %s pins\n",
-                                runtime ? "idle" : "sleep");
-        }
-}
-
-static void pl022_resume_resources(struct pl022 *pl022, bool runtime)
-{
-        int ret;
-
-        /* Optionaly enable pins to be muxed in and configured */
-        /* First go to the default state */
-        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");
-        }
-
-        if (!runtime) {
-                /* Then let's idle the pins until the next transfer happens */
-                if (!IS_ERR(pl022->pins_idle)) {
-                        ret = pinctrl_select_state(pl022->pinctrl,
-                                        pl022->pins_idle);
-                if (ret)
-                        dev_err(&pl022->adev->dev,
-                                "could not set idle pins\n");
-                }
-        }
-
-        clk_enable(pl022->clk);
-}
-#endif
-
-#ifdef CONFIG_SUSPEND
-static int pl022_suspend(struct device *dev)
-{
-        struct pl022 *pl022 = dev_get_drvdata(dev);
-        int ret;
+        struct pl022 *pl022 = amba_get_drvdata(adev);
+        int status = 0;
 
-        ret = spi_master_suspend(pl022->master);
-        if (ret) {
-                dev_warn(dev, "cannot suspend master\n");
-                return ret;
+        status = stop_queue(pl022);
+        if (status) {
+                dev_warn(&adev->dev, "suspend cannot stop queue\n");
+                return status;
         }
 
-        pm_runtime_get_sync(dev);
-        pl022_suspend_resources(pl022, false);
-
-        dev_dbg(dev, "suspended\n");
+        amba_vcore_enable(adev);
+        amba_pclk_enable(adev);
+        load_ssp_default_config(pl022);
+        amba_pclk_disable(adev);
+        amba_vcore_disable(adev);
+        dev_dbg(&adev->dev, "suspended\n");
         return 0;
 }
 
-static int pl022_resume(struct device *dev)
+static int pl022_resume(struct amba_device *adev)
 {
-        struct pl022 *pl022 = dev_get_drvdata(dev);
-        int ret;
-
-        pl022_resume_resources(pl022, false);
-        pm_runtime_put(dev);
+        struct pl022 *pl022 = amba_get_drvdata(adev);
+        int status = 0;
 
         /* Start the queue running */
-        ret = spi_master_resume(pl022->master);
-        if (ret)
-                dev_err(dev, "problem starting queue (%d)\n", ret);
+        status = start_queue(pl022);
+        if (status)
+                dev_err(&adev->dev, "problem starting queue (%d)\n", status);
         else
-                dev_dbg(dev, "resumed\n");
+                dev_dbg(&adev->dev, "resumed\n");
 
-        return ret;
+        return status;
 }
+#else
+#define pl022_suspend NULL
+#define pl022_resume NULL
 #endif  /* CONFIG_PM */
 
-#ifdef CONFIG_PM_RUNTIME
-static int pl022_runtime_suspend(struct device *dev)
-{
-        struct pl022 *pl022 = dev_get_drvdata(dev);
-
-        pl022_suspend_resources(pl022, true);
-        return 0;
-}
-
-static int pl022_runtime_resume(struct device *dev)
-{
-        struct pl022 *pl022 = dev_get_drvdata(dev);
-
-        pl022_resume_resources(pl022, true);
-        return 0;
-}
-#endif
-
-static const struct dev_pm_ops pl022_dev_pm_ops = {
-        SET_SYSTEM_SLEEP_PM_OPS(pl022_suspend, pl022_resume)
-        SET_RUNTIME_PM_OPS(pl022_runtime_suspend, pl022_runtime_resume, NULL)
-};
-
 static struct vendor_data vendor_arm = {
         .fifodepth = 8,
         .max_bpw = 16,
@@ -2422,6 +2337,7 @@ static struct vendor_data vendor_arm = {
         .loopback = true,
 };
 
+
 static struct vendor_data vendor_st = {
         .fifodepth = 32,
         .max_bpw = 32,
@@ -2440,6 +2356,15 @@ static struct vendor_data vendor_st_pl023 = {
         .loopback = false,
 };
 
+static struct vendor_data vendor_db5500_pl023 = {
+        .fifodepth = 32,
+        .max_bpw = 32,
+        .unidir = false,
+        .extended_cr = true,
+        .pl023 = true,
+        .loopback = true,
+};
+
 static struct amba_id pl022_ids[] = {
         {
                 /*
@@ -2467,35 +2392,42 @@ static struct amba_id pl022_ids[] = {
                  * and 32 locations deep TX/RX FIFO but no extended
                  * CR0/CR1 register
                  */
-                .id     = 0x00080023,
+                .id     = 0x00080023,
+                .mask   = 0xffffffff,
+                .data   = &vendor_st_pl023,
+        },
+        {
+                .id     = 0x10080023,
                 .mask   = 0xffffffff,
-                .data   = &vendor_st_pl023,
+                .data   = &vendor_db5500_pl023,
         },
         { 0, 0 },
 };
 
-MODULE_DEVICE_TABLE(amba, pl022_ids);
-
 static struct amba_driver pl022_driver = {
         .drv = {
                 .name   = "ssp-pl022",
-                .pm     = &pl022_dev_pm_ops,
         },
         .id_table       = pl022_ids,
         .probe          = pl022_probe,
-        .remove         = pl022_remove,
+        .remove         = __devexit_p(pl022_remove),
+        .suspend        = pl022_suspend,
+        .resume         = pl022_resume,
 };
 
+
 static int __init pl022_init(void)
 {
         return amba_driver_register(&pl022_driver);
 }
+
 subsys_initcall(pl022_init);
 
 static void __exit pl022_exit(void)
 {
         amba_driver_unregister(&pl022_driver);
 }
+
 module_exit(pl022_exit);
 
 MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");