Patched in Tegra support.

1 files changed, 165 insertions, 125 deletions

diff --git a/drivers/spi/spi-orion.c b/drivers/spi/spi-orion.c
index b7e718254b1..9421a390a5e 100644
--- a/drivers/spi/spi-orion.c
+++ b/drivers/spi/spi-orion.c
@@ -16,9 +16,7 @@
 #include <linux/err.h>
 #include <linux/io.h>
 #include <linux/spi/spi.h>
-#include <linux/module.h>
-#include <linux/of.h>
-#include <linux/clk.h>
+#include <linux/spi/orion_spi.h>
 #include <asm/unaligned.h>
 
 #define DRIVER_NAME                     "orion_spi"
@@ -32,21 +30,25 @@
 #define ORION_SPI_DATA_IN_REG           0x0c
 #define ORION_SPI_INT_CAUSE_REG         0x10
 
-#define ORION_SPI_MODE_CPOL             (1 << 11)
-#define ORION_SPI_MODE_CPHA             (1 << 12)
 #define ORION_SPI_IF_8_16_BIT_MODE      (1 << 5)
 #define ORION_SPI_CLK_PRESCALE_MASK     0x1F
-#define ORION_SPI_MODE_MASK             (ORION_SPI_MODE_CPOL | \
-                                         ORION_SPI_MODE_CPHA)
 
 struct orion_spi {
+        struct work_struct      work;
+
+        /* Lock access to transfer list.        */
+        spinlock_t              lock;
+
+        struct list_head        msg_queue;
         struct spi_master       *master;
         void __iomem            *base;
         unsigned int            max_speed;
         unsigned int            min_speed;
-        struct clk              *clk;
+        struct orion_spi_info   *spi_info;
 };
 
+static struct workqueue_struct *orion_spi_wq;
+
 static inline void __iomem *spi_reg(struct orion_spi *orion_spi, u32 reg)
 {
         return orion_spi->base + reg;
@@ -101,7 +103,7 @@ static int orion_spi_baudrate_set(struct spi_device *spi, unsigned int speed)
 
         orion_spi = spi_master_get_devdata(spi->master);
 
-        tclk_hz = clk_get_rate(orion_spi->clk);
+        tclk_hz = orion_spi->spi_info->tclk;
 
         /*
          * the supported rates are: 4,6,8...30
@@ -127,23 +129,6 @@ static int orion_spi_baudrate_set(struct spi_device *spi, unsigned int speed)
         return 0;
 }
 
-static void
-orion_spi_mode_set(struct spi_device *spi)
-{
-        u32 reg;
-        struct orion_spi *orion_spi;
-
-        orion_spi = spi_master_get_devdata(spi->master);
-
-        reg = readl(spi_reg(orion_spi, ORION_SPI_IF_CONFIG_REG));
-        reg &= ~ORION_SPI_MODE_MASK;
-        if (spi->mode & SPI_CPOL)
-                reg |= ORION_SPI_MODE_CPOL;
-        if (spi->mode & SPI_CPHA)
-                reg |= ORION_SPI_MODE_CPHA;
-        writel(reg, spi_reg(orion_spi, ORION_SPI_IF_CONFIG_REG));
-}
-
 /*
  * called only when no transfer is active on the bus
  */
@@ -163,8 +148,6 @@ orion_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
         if ((t != NULL) && t->bits_per_word)
                 bits_per_word = t->bits_per_word;
 
-        orion_spi_mode_set(spi);
-
         rc = orion_spi_baudrate_set(spi, speed);
         if (rc)
                 return rc;
@@ -292,78 +275,73 @@ out:
 }
 
 
-static int orion_spi_transfer_one_message(struct spi_master *master,
-                                           struct spi_message *m)
+static void orion_spi_work(struct work_struct *work)
 {
-        struct orion_spi *orion_spi = spi_master_get_devdata(master);
-        struct spi_device *spi = m->spi;
-        struct spi_transfer *t = NULL;
-        int par_override = 0;
-        int status = 0;
-        int cs_active = 0;
+        struct orion_spi *orion_spi =
+                container_of(work, struct orion_spi, work);
 
-        /* Load defaults */
-        status = orion_spi_setup_transfer(spi, NULL);
+        spin_lock_irq(&orion_spi->lock);
+        while (!list_empty(&orion_spi->msg_queue)) {
+                struct spi_message *m;
+                struct spi_device *spi;
+                struct spi_transfer *t = NULL;
+                int par_override = 0;
+                int status = 0;
+                int cs_active = 0;
 
-        if (status < 0)
-                goto msg_done;
+                m = container_of(orion_spi->msg_queue.next, struct spi_message,
+                                 queue);
 
-        list_for_each_entry(t, &m->transfers, transfer_list) {
-                /* make sure buffer length is even when working in 16
-                 * bit mode*/
-                if ((t->bits_per_word == 16) && (t->len & 1)) {
-                        dev_err(&spi->dev,
-                                "message rejected : "
-                                "odd data length %d while in 16 bit mode\n",
-                                t->len);
-                        status = -EIO;
-                        goto msg_done;
-                }
+                list_del_init(&m->queue);
+                spin_unlock_irq(&orion_spi->lock);
 
-                if (t->speed_hz && t->speed_hz < orion_spi->min_speed) {
-                        dev_err(&spi->dev,
-                                "message rejected : "
-                                "device min speed (%d Hz) exceeds "
-                                "required transfer speed (%d Hz)\n",
-                                orion_spi->min_speed, t->speed_hz);
-                        status = -EIO;
-                        goto msg_done;
-                }
+                spi = m->spi;
 
-                if (par_override || t->speed_hz || t->bits_per_word) {
-                        par_override = 1;
-                        status = orion_spi_setup_transfer(spi, t);
-                        if (status < 0)
-                                break;
-                        if (!t->speed_hz && !t->bits_per_word)
-                                par_override = 0;
-                }
+                /* Load defaults */
+                status = orion_spi_setup_transfer(spi, NULL);
 
-                if (!cs_active) {
-                        orion_spi_set_cs(orion_spi, 1);
-                        cs_active = 1;
-                }
-
-                if (t->len)
-                        m->actual_length += orion_spi_write_read(spi, t);
-
-                if (t->delay_usecs)
-                        udelay(t->delay_usecs);
+                if (status < 0)
+                        goto msg_done;
 
-                if (t->cs_change) {
-                        orion_spi_set_cs(orion_spi, 0);
-                        cs_active = 0;
+                list_for_each_entry(t, &m->transfers, transfer_list) {
+                        if (par_override || t->speed_hz || t->bits_per_word) {
+                                par_override = 1;
+                                status = orion_spi_setup_transfer(spi, t);
+                                if (status < 0)
+                                        break;
+                                if (!t->speed_hz && !t->bits_per_word)
+                                        par_override = 0;
+                        }
+
+                        if (!cs_active) {
+                                orion_spi_set_cs(orion_spi, 1);
+                                cs_active = 1;
+                        }
+
+                        if (t->len)
+                                m->actual_length +=
+                                        orion_spi_write_read(spi, t);
+
+                        if (t->delay_usecs)
+                                udelay(t->delay_usecs);
+
+                        if (t->cs_change) {
+                                orion_spi_set_cs(orion_spi, 0);
+                                cs_active = 0;
+                        }
                 }
-        }
 
 msg_done:
-        if (cs_active)
-                orion_spi_set_cs(orion_spi, 0);
+                if (cs_active)
+                        orion_spi_set_cs(orion_spi, 0);
 
-        m->status = status;
-        spi_finalize_current_message(master);
+                m->status = status;
+                m->complete(m->context);
 
-        return 0;
+                spin_lock_irq(&orion_spi->lock);
+        }
+
+        spin_unlock_irq(&orion_spi->lock);
 }
 
 static int __init orion_spi_reset(struct orion_spi *orion_spi)
@@ -380,6 +358,11 @@ static int orion_spi_setup(struct spi_device *spi)
 
         orion_spi = spi_master_get_devdata(spi->master);
 
+        /* Fix ac timing if required.   */
+        if (orion_spi->spi_info->enable_clock_fix)
+                orion_spi_setbits(orion_spi, ORION_SPI_IF_CONFIG_REG,
+                                  (1 << 14));
+
         if ((spi->max_speed_hz == 0)
                         || (spi->max_speed_hz > orion_spi->max_speed))
                 spi->max_speed_hz = orion_spi->max_speed;
@@ -396,15 +379,84 @@ static int orion_spi_setup(struct spi_device *spi)
         return 0;
 }
 
+static int orion_spi_transfer(struct spi_device *spi, struct spi_message *m)
+{
+        struct orion_spi *orion_spi;
+        struct spi_transfer *t = NULL;
+        unsigned long flags;
+
+        m->actual_length = 0;
+        m->status = 0;
+
+        /* reject invalid messages and transfers */
+        if (list_empty(&m->transfers) || !m->complete)
+                return -EINVAL;
+
+        orion_spi = spi_master_get_devdata(spi->master);
+
+        list_for_each_entry(t, &m->transfers, transfer_list) {
+                unsigned int bits_per_word = spi->bits_per_word;
+
+                if (t->tx_buf == NULL && t->rx_buf == NULL && t->len) {
+                        dev_err(&spi->dev,
+                                "message rejected : "
+                                "invalid transfer data buffers\n");
+                        goto msg_rejected;
+                }
+
+                if (t->bits_per_word)
+                        bits_per_word = t->bits_per_word;
+
+                if ((bits_per_word != 8) && (bits_per_word != 16)) {
+                        dev_err(&spi->dev,
+                                "message rejected : "
+                                "invalid transfer bits_per_word (%d bits)\n",
+                                bits_per_word);
+                        goto msg_rejected;
+                }
+                /*make sure buffer length is even when working in 16 bit mode*/
+                if ((t->bits_per_word == 16) && (t->len & 1)) {
+                        dev_err(&spi->dev,
+                                "message rejected : "
+                                "odd data length (%d) while in 16 bit mode\n",
+                                t->len);
+                        goto msg_rejected;
+                }
+
+                if (t->speed_hz && t->speed_hz < orion_spi->min_speed) {
+                        dev_err(&spi->dev,
+                                "message rejected : "
+                                "device min speed (%d Hz) exceeds "
+                                "required transfer speed (%d Hz)\n",
+                                orion_spi->min_speed, t->speed_hz);
+                        goto msg_rejected;
+                }
+        }
+
+
+        spin_lock_irqsave(&orion_spi->lock, flags);
+        list_add_tail(&m->queue, &orion_spi->msg_queue);
+        queue_work(orion_spi_wq, &orion_spi->work);
+        spin_unlock_irqrestore(&orion_spi->lock, flags);
+
+        return 0;
+msg_rejected:
+        /* Message rejected and not queued */
+        m->status = -EINVAL;
+        if (m->complete)
+                m->complete(m->context);
+        return -EINVAL;
+}
+
 static int __init orion_spi_probe(struct platform_device *pdev)
 {
         struct spi_master *master;
         struct orion_spi *spi;
         struct resource *r;
-        unsigned long tclk_hz;
+        struct orion_spi_info *spi_info;
         int status = 0;
-        const u32 *iprop;
-        int size;
+
+        spi_info = pdev->dev.platform_data;
 
         master = spi_alloc_master(&pdev->dev, sizeof *spi);
         if (master == NULL) {
@@ -414,54 +466,44 @@ static int __init orion_spi_probe(struct platform_device *pdev)
 
         if (pdev->id != -1)
                 master->bus_num = pdev->id;
-        if (pdev->dev.of_node) {
-                iprop = of_get_property(pdev->dev.of_node, "cell-index",
-                                        &size);
-                if (iprop && size == sizeof(*iprop))
-                        master->bus_num = *iprop;
-        }
 
         /* we support only mode 0, and no options */
-        master->mode_bits = SPI_CPHA | SPI_CPOL;
+        master->mode_bits = 0;
 
         master->setup = orion_spi_setup;
-        master->transfer_one_message = orion_spi_transfer_one_message;
+        master->transfer = orion_spi_transfer;
         master->num_chipselect = ORION_NUM_CHIPSELECTS;
 
         dev_set_drvdata(&pdev->dev, master);
 
         spi = spi_master_get_devdata(master);
         spi->master = master;
+        spi->spi_info = spi_info;
 
-        spi->clk = clk_get(&pdev->dev, NULL);
-        if (IS_ERR(spi->clk)) {
-                status = PTR_ERR(spi->clk);
-                goto out;
-        }
-
-        clk_prepare(spi->clk);
-        clk_enable(spi->clk);
-        tclk_hz = clk_get_rate(spi->clk);
-        spi->max_speed = DIV_ROUND_UP(tclk_hz, 4);
-        spi->min_speed = DIV_ROUND_UP(tclk_hz, 30);
+        spi->max_speed = DIV_ROUND_UP(spi_info->tclk, 4);
+        spi->min_speed = DIV_ROUND_UP(spi_info->tclk, 30);
 
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (r == NULL) {
                 status = -ENODEV;
-                goto out_rel_clk;
+                goto out;
         }
 
         if (!request_mem_region(r->start, resource_size(r),
                                 dev_name(&pdev->dev))) {
                 status = -EBUSY;
-                goto out_rel_clk;
+                goto out;
         }
         spi->base = ioremap(r->start, SZ_1K);
 
+        INIT_WORK(&spi->work, orion_spi_work);
+
+        spin_lock_init(&spi->lock);
+        INIT_LIST_HEAD(&spi->msg_queue);
+
         if (orion_spi_reset(spi) < 0)
                 goto out_rel_mem;
 
-        master->dev.of_node = pdev->dev.of_node;
         status = spi_register_master(master);
         if (status < 0)
                 goto out_rel_mem;
@@ -470,9 +512,7 @@ static int __init orion_spi_probe(struct platform_device *pdev)
 
 out_rel_mem:
         release_mem_region(r->start, resource_size(r));
-out_rel_clk:
-        clk_disable_unprepare(spi->clk);
-        clk_put(spi->clk);
+
 out:
         spi_master_put(master);
         return status;
@@ -482,14 +522,13 @@ out:
 static int __exit orion_spi_remove(struct platform_device *pdev)
 {
         struct spi_master *master;
-        struct resource *r;
         struct orion_spi *spi;
+        struct resource *r;
 
         master = dev_get_drvdata(&pdev->dev);
         spi = spi_master_get_devdata(master);
 
-        clk_disable_unprepare(spi->clk);
-        clk_put(spi->clk);
+        cancel_work_sync(&spi->work);
 
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         release_mem_region(r->start, resource_size(r));
@@ -501,30 +540,31 @@ static int __exit orion_spi_remove(struct platform_device *pdev)
 
 MODULE_ALIAS("platform:" DRIVER_NAME);
 
-static const struct of_device_id orion_spi_of_match_table[] = {
-        { .compatible = "marvell,orion-spi", },
-        {}
-};
-MODULE_DEVICE_TABLE(of, orion_spi_of_match_table);
-
 static struct platform_driver orion_spi_driver = {
         .driver = {
                 .name   = DRIVER_NAME,
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(orion_spi_of_match_table),
         },
         .remove         = __exit_p(orion_spi_remove),
 };
 
 static int __init orion_spi_init(void)
 {
+        orion_spi_wq = create_singlethread_workqueue(
+                                orion_spi_driver.driver.name);
+        if (orion_spi_wq == NULL)
+                return -ENOMEM;
+
         return platform_driver_probe(&orion_spi_driver, orion_spi_probe);
 }
 module_init(orion_spi_init);
 
 static void __exit orion_spi_exit(void)
 {
+        flush_workqueue(orion_spi_wq);
         platform_driver_unregister(&orion_spi_driver);
+
+        destroy_workqueue(orion_spi_wq);
 }
 module_exit(orion_spi_exit);