spi_qsd: Add support for new QUPe controller.
The SPI driver is modified to support the new QUPe
controller (version 0x2). The SPI functionality of the
controller is very similar to the previous QUPe
controller (version 0x1). This change addresses
some cleanup along with register address modifications and
flow changes.
Change-Id: I15e7084dd54a1144bd85bf75efd7757b545d24f9
Signed-off-by: Harini Jayaraman <harinij@codeaurora.org>
diff --git a/drivers/spi/spi_qsd.c b/drivers/spi/spi_qsd.c
index aaeb790..17b9f0d 100644
--- a/drivers/spi/spi_qsd.c
+++ b/drivers/spi/spi_qsd.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2008-2011, Code Aurora Forum. All rights reserved.
+/* Copyright (c) 2008-2012, Code Aurora Forum. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -38,608 +38,49 @@
#include <linux/gpio.h>
#include <linux/remote_spinlock.h>
#include <linux/pm_qos_params.h>
+#include <linux/of.h>
+#include "spi_qsd.h"
-#define SPI_DRV_NAME "spi_qsd"
-#if defined(CONFIG_SPI_QSD) || defined(CONFIG_SPI_QSD_MODULE)
-
-#define QSD_REG(x) (x)
-#define QUP_REG(x)
-
-#define SPI_FIFO_WORD_CNT 0x0048
-
-#elif defined(CONFIG_SPI_QUP) || defined(CONFIG_SPI_QUP_MODULE)
-
-#define QSD_REG(x)
-#define QUP_REG(x) (x)
-
-#define QUP_CONFIG 0x0000 /* N & NO_INPUT/NO_OUPUT bits */
-#define QUP_ERROR_FLAGS 0x0308
-#define QUP_ERROR_FLAGS_EN 0x030C
-#define QUP_ERR_MASK 0x3
-#define SPI_OUTPUT_FIFO_WORD_CNT 0x010C
-#define SPI_INPUT_FIFO_WORD_CNT 0x0214
-#define QUP_MX_WRITE_COUNT 0x0150
-#define QUP_MX_WRITE_CNT_CURRENT 0x0154
-
-#define QUP_CONFIG_SPI_MODE 0x0100
-
-#define GSBI_CTRL_REG 0x0
-#define GSBI_SPI_CONFIG 0x30
-#endif
-
-#define SPI_CONFIG QSD_REG(0x0000) QUP_REG(0x0300)
-#define SPI_IO_CONTROL QSD_REG(0x0004) QUP_REG(0x0304)
-#define SPI_IO_MODES QSD_REG(0x0008) QUP_REG(0x0008)
-#define SPI_SW_RESET QSD_REG(0x000C) QUP_REG(0x000C)
-#define SPI_TIME_OUT QSD_REG(0x0010) QUP_REG(0x0010)
-#define SPI_TIME_OUT_CURRENT QSD_REG(0x0014) QUP_REG(0x0014)
-#define SPI_MX_OUTPUT_COUNT QSD_REG(0x0018) QUP_REG(0x0100)
-#define SPI_MX_OUTPUT_CNT_CURRENT QSD_REG(0x001C) QUP_REG(0x0104)
-#define SPI_MX_INPUT_COUNT QSD_REG(0x0020) QUP_REG(0x0200)
-#define SPI_MX_INPUT_CNT_CURRENT QSD_REG(0x0024) QUP_REG(0x0204)
-#define SPI_MX_READ_COUNT QSD_REG(0x0028) QUP_REG(0x0208)
-#define SPI_MX_READ_CNT_CURRENT QSD_REG(0x002C) QUP_REG(0x020C)
-#define SPI_OPERATIONAL QSD_REG(0x0030) QUP_REG(0x0018)
-#define SPI_ERROR_FLAGS QSD_REG(0x0034) QUP_REG(0x001C)
-#define SPI_ERROR_FLAGS_EN QSD_REG(0x0038) QUP_REG(0x0020)
-#define SPI_DEASSERT_WAIT QSD_REG(0x003C) QUP_REG(0x0310)
-#define SPI_OUTPUT_DEBUG QSD_REG(0x0040) QUP_REG(0x0108)
-#define SPI_INPUT_DEBUG QSD_REG(0x0044) QUP_REG(0x0210)
-#define SPI_TEST_CTRL QSD_REG(0x004C) QUP_REG(0x0024)
-#define SPI_OUTPUT_FIFO QSD_REG(0x0100) QUP_REG(0x0110)
-#define SPI_INPUT_FIFO QSD_REG(0x0200) QUP_REG(0x0218)
-#define SPI_STATE QSD_REG(SPI_OPERATIONAL) QUP_REG(0x0004)
-
-/* SPI_CONFIG fields */
-#define SPI_CFG_INPUT_FIRST 0x00000200
-#define SPI_NO_INPUT 0x00000080
-#define SPI_NO_OUTPUT 0x00000040
-#define SPI_CFG_LOOPBACK 0x00000100
-#define SPI_CFG_N 0x0000001F
-
-/* SPI_IO_CONTROL fields */
-#define SPI_IO_C_CLK_IDLE_HIGH 0x00000400
-#define SPI_IO_C_MX_CS_MODE 0x00000100
-#define SPI_IO_C_CS_N_POLARITY 0x000000F0
-#define SPI_IO_C_CS_N_POLARITY_0 0x00000010
-#define SPI_IO_C_CS_SELECT 0x0000000C
-#define SPI_IO_C_TRISTATE_CS 0x00000002
-#define SPI_IO_C_NO_TRI_STATE 0x00000001
-
-/* SPI_IO_MODES fields */
-#define SPI_IO_M_OUTPUT_BIT_SHIFT_EN QSD_REG(0x00004000) QUP_REG(0x00010000)
-#define SPI_IO_M_PACK_EN QSD_REG(0x00002000) QUP_REG(0x00008000)
-#define SPI_IO_M_UNPACK_EN QSD_REG(0x00001000) QUP_REG(0x00004000)
-#define SPI_IO_M_INPUT_MODE QSD_REG(0x00000C00) QUP_REG(0x00003000)
-#define SPI_IO_M_OUTPUT_MODE QSD_REG(0x00000300) QUP_REG(0x00000C00)
-#define SPI_IO_M_INPUT_FIFO_SIZE QSD_REG(0x000000C0) QUP_REG(0x00000380)
-#define SPI_IO_M_INPUT_BLOCK_SIZE QSD_REG(0x00000030) QUP_REG(0x00000060)
-#define SPI_IO_M_OUTPUT_FIFO_SIZE QSD_REG(0x0000000C) QUP_REG(0x0000001C)
-#define SPI_IO_M_OUTPUT_BLOCK_SIZE QSD_REG(0x00000003) QUP_REG(0x00000003)
-
-#define INPUT_BLOCK_SZ_SHIFT QSD_REG(4) QUP_REG(5)
-#define INPUT_FIFO_SZ_SHIFT QSD_REG(6) QUP_REG(7)
-#define OUTPUT_BLOCK_SZ_SHIFT QSD_REG(0) QUP_REG(0)
-#define OUTPUT_FIFO_SZ_SHIFT QSD_REG(2) QUP_REG(2)
-#define OUTPUT_MODE_SHIFT QSD_REG(8) QUP_REG(10)
-#define INPUT_MODE_SHIFT QSD_REG(10) QUP_REG(12)
-
-/* SPI_OPERATIONAL fields */
-#define SPI_OP_MAX_INPUT_DONE_FLAG 0x00000800
-#define SPI_OP_MAX_OUTPUT_DONE_FLAG 0x00000400
-#define SPI_OP_INPUT_SERVICE_FLAG 0x00000200
-#define SPI_OP_OUTPUT_SERVICE_FLAG 0x00000100
-#define SPI_OP_INPUT_FIFO_FULL 0x00000080
-#define SPI_OP_OUTPUT_FIFO_FULL 0x00000040
-#define SPI_OP_IP_FIFO_NOT_EMPTY 0x00000020
-#define SPI_OP_OP_FIFO_NOT_EMPTY 0x00000010
-#define SPI_OP_STATE_VALID 0x00000004
-#define SPI_OP_STATE 0x00000003
-
-#define SPI_OP_STATE_CLEAR_BITS 0x2
-enum msm_spi_state {
- SPI_OP_STATE_RESET = 0x00000000,
- SPI_OP_STATE_RUN = 0x00000001,
- SPI_OP_STATE_PAUSE = 0x00000003,
-};
-
-/* SPI_ERROR_FLAGS fields */
-#define SPI_ERR_OUTPUT_OVER_RUN_ERR 0x00000020
-#define SPI_ERR_INPUT_UNDER_RUN_ERR 0x00000010
-#define SPI_ERR_OUTPUT_UNDER_RUN_ERR 0x00000008
-#define SPI_ERR_INPUT_OVER_RUN_ERR 0x00000004
-#define SPI_ERR_CLK_OVER_RUN_ERR 0x00000002
-#define SPI_ERR_CLK_UNDER_RUN_ERR 0x00000001
-
-/* We don't allow transactions larger than 4K-64 or 64K-64 due to
- mx_input/output_cnt register size */
-#define SPI_MAX_TRANSFERS QSD_REG(0xFC0) QUP_REG(0xFC0)
-#define SPI_MAX_LEN (SPI_MAX_TRANSFERS * dd->bytes_per_word)
-
-#define SPI_NUM_CHIPSELECTS 4
-#define SPI_SUPPORTED_MODES (SPI_CPOL | SPI_CPHA | SPI_CS_HIGH | SPI_LOOP)
-
-#define SPI_DELAY_THRESHOLD 1
-/* Default timeout is 10 milliseconds */
-#define SPI_DEFAULT_TIMEOUT 10
-/* 250 microseconds */
-#define SPI_TRYLOCK_DELAY 250
-
-/* Data Mover burst size */
-#define DM_BURST_SIZE 16
-/* Data Mover commands should be aligned to 64 bit(8 bytes) */
-#define DM_BYTE_ALIGN 8
-
-static char const * const spi_rsrcs[] = {
- "spi_clk",
- "spi_miso",
- "spi_mosi"
-};
-
-static char const * const spi_cs_rsrcs[] = {
- "spi_cs",
- "spi_cs1",
- "spi_cs2",
- "spi_cs3",
-};
-
-enum msm_spi_mode {
- SPI_FIFO_MODE = 0x0, /* 00 */
- SPI_BLOCK_MODE = 0x1, /* 01 */
- SPI_DMOV_MODE = 0x2, /* 10 */
- SPI_MODE_NONE = 0xFF, /* invalid value */
-};
-
-/* Structure for SPI CS GPIOs */
-struct spi_cs_gpio {
- int gpio_num;
- bool valid;
-};
-
-/* Structures for Data Mover */
-struct spi_dmov_cmd {
- dmov_box box; /* data aligned to max(dm_burst_size, block_size)
- (<= fifo_size) */
- dmov_s single_pad; /* data unaligned to max(dm_burst_size, block_size)
- padded to fit */
- dma_addr_t cmd_ptr;
-};
-
-MODULE_LICENSE("GPL v2");
-MODULE_VERSION("0.3");
-MODULE_ALIAS("platform:"SPI_DRV_NAME);
-
-static struct pm_qos_request_list qos_req_list;
-
-#ifdef CONFIG_DEBUG_FS
-/* Used to create debugfs entries */
-static const struct {
- const char *name;
- mode_t mode;
- int offset;
-} debugfs_spi_regs[] = {
- {"config", S_IRUGO | S_IWUSR, SPI_CONFIG},
- {"io_control", S_IRUGO | S_IWUSR, SPI_IO_CONTROL},
- {"io_modes", S_IRUGO | S_IWUSR, SPI_IO_MODES},
- {"sw_reset", S_IWUSR, SPI_SW_RESET},
- {"time_out", S_IRUGO | S_IWUSR, SPI_TIME_OUT},
- {"time_out_current", S_IRUGO, SPI_TIME_OUT_CURRENT},
- {"mx_output_count", S_IRUGO | S_IWUSR, SPI_MX_OUTPUT_COUNT},
- {"mx_output_cnt_current", S_IRUGO, SPI_MX_OUTPUT_CNT_CURRENT},
- {"mx_input_count", S_IRUGO | S_IWUSR, SPI_MX_INPUT_COUNT},
- {"mx_input_cnt_current", S_IRUGO, SPI_MX_INPUT_CNT_CURRENT},
- {"mx_read_count", S_IRUGO | S_IWUSR, SPI_MX_READ_COUNT},
- {"mx_read_cnt_current", S_IRUGO, SPI_MX_READ_CNT_CURRENT},
- {"operational", S_IRUGO | S_IWUSR, SPI_OPERATIONAL},
- {"error_flags", S_IRUGO | S_IWUSR, SPI_ERROR_FLAGS},
- {"error_flags_en", S_IRUGO | S_IWUSR, SPI_ERROR_FLAGS_EN},
- {"deassert_wait", S_IRUGO | S_IWUSR, SPI_DEASSERT_WAIT},
- {"output_debug", S_IRUGO, SPI_OUTPUT_DEBUG},
- {"input_debug", S_IRUGO, SPI_INPUT_DEBUG},
- {"test_ctrl", S_IRUGO | S_IWUSR, SPI_TEST_CTRL},
- {"output_fifo", S_IWUSR, SPI_OUTPUT_FIFO},
- {"input_fifo" , S_IRUSR, SPI_INPUT_FIFO},
- {"spi_state", S_IRUGO | S_IWUSR, SPI_STATE},
-#if defined(CONFIG_SPI_QSD) || defined(CONFIG_SPI_QSD_MODULE)
- {"fifo_word_cnt", S_IRUGO, SPI_FIFO_WORD_CNT},
-#elif defined(CONFIG_SPI_QUP) || defined(CONFIG_SPI_QUP_MODULE)
- {"qup_config", S_IRUGO | S_IWUSR, QUP_CONFIG},
- {"qup_error_flags", S_IRUGO | S_IWUSR, QUP_ERROR_FLAGS},
- {"qup_error_flags_en", S_IRUGO | S_IWUSR, QUP_ERROR_FLAGS_EN},
- {"mx_write_cnt", S_IRUGO | S_IWUSR, QUP_MX_WRITE_COUNT},
- {"mx_write_cnt_current", S_IRUGO, QUP_MX_WRITE_CNT_CURRENT},
- {"output_fifo_word_cnt", S_IRUGO, SPI_OUTPUT_FIFO_WORD_CNT},
- {"input_fifo_word_cnt", S_IRUGO, SPI_INPUT_FIFO_WORD_CNT},
-#endif
-};
-#endif
-
-struct msm_spi {
- u8 *read_buf;
- const u8 *write_buf;
- void __iomem *base;
- void __iomem *gsbi_base;
- struct device *dev;
- spinlock_t queue_lock;
- struct mutex core_lock;
- struct list_head queue;
- struct workqueue_struct *workqueue;
- struct work_struct work_data;
- struct spi_message *cur_msg;
- struct spi_transfer *cur_transfer;
- struct completion transfer_complete;
- struct clk *clk;
- struct clk *pclk;
- unsigned long mem_phys_addr;
- size_t mem_size;
- unsigned long gsbi_mem_phys_addr;
- size_t gsbi_mem_size;
- int input_fifo_size;
- int output_fifo_size;
- u32 rx_bytes_remaining;
- u32 tx_bytes_remaining;
- u32 clock_speed;
- int irq_in;
- int read_xfr_cnt;
- int write_xfr_cnt;
- int write_len;
- int read_len;
-#if defined(CONFIG_SPI_QSD) || defined(CONFIG_SPI_QSD_MODULE)
- int irq_out;
- int irq_err;
-#endif
- int bytes_per_word;
- bool suspended;
- bool transfer_pending;
- wait_queue_head_t continue_suspend;
- /* DMA data */
- enum msm_spi_mode mode;
- bool use_dma;
- int tx_dma_chan;
- int tx_dma_crci;
- int rx_dma_chan;
- int rx_dma_crci;
- /* Data Mover Commands */
- struct spi_dmov_cmd *tx_dmov_cmd;
- struct spi_dmov_cmd *rx_dmov_cmd;
- /* Physical address of the tx dmov box command */
- dma_addr_t tx_dmov_cmd_dma;
- dma_addr_t rx_dmov_cmd_dma;
- struct msm_dmov_cmd tx_hdr;
- struct msm_dmov_cmd rx_hdr;
- int input_block_size;
- int output_block_size;
- int burst_size;
- atomic_t rx_irq_called;
- /* Used to pad messages unaligned to block size */
- u8 *tx_padding;
- dma_addr_t tx_padding_dma;
- u8 *rx_padding;
- dma_addr_t rx_padding_dma;
- u32 unaligned_len;
- /* DMA statistics */
- int stat_dmov_tx_err;
- int stat_dmov_rx_err;
- int stat_rx;
- int stat_dmov_rx;
- int stat_tx;
- int stat_dmov_tx;
-#ifdef CONFIG_DEBUG_FS
- struct dentry *dent_spi;
- struct dentry *debugfs_spi_regs[ARRAY_SIZE(debugfs_spi_regs)];
-#endif
- struct msm_spi_platform_data *pdata; /* Platform data */
- /* Remote Spinlock Data */
- bool use_rlock;
- remote_mutex_t r_lock;
- uint32_t pm_lat;
- /* When set indicates multiple transfers in a single message */
- bool multi_xfr;
- bool done;
- u32 cur_msg_len;
- /* Used in FIFO mode to keep track of the transfer being processed */
- struct spi_transfer *cur_tx_transfer;
- struct spi_transfer *cur_rx_transfer;
- /* Temporary buffer used for WR-WR or WR-RD transfers */
- u8 *temp_buf;
- /* GPIO pin numbers for SPI clk, miso and mosi */
- int spi_gpios[ARRAY_SIZE(spi_rsrcs)];
- /* SPI CS GPIOs for each slave */
- struct spi_cs_gpio cs_gpios[ARRAY_SIZE(spi_cs_rsrcs)];
-};
-
-/* Forward declaration */
-static irqreturn_t msm_spi_input_irq(int irq, void *dev_id);
-static irqreturn_t msm_spi_output_irq(int irq, void *dev_id);
-static irqreturn_t msm_spi_error_irq(int irq, void *dev_id);
-static inline int msm_spi_set_state(struct msm_spi *dd,
- enum msm_spi_state state);
-static void msm_spi_write_word_to_fifo(struct msm_spi *dd);
-static inline void msm_spi_write_rmn_to_fifo(struct msm_spi *dd);
-
-#if defined(CONFIG_SPI_QSD) || defined(CONFIG_SPI_QSD_MODULE)
-/* Interrupt Handling */
-static inline int msm_spi_get_irq_data(struct msm_spi *dd,
- struct platform_device *pdev)
-{
- dd->irq_in = platform_get_irq_byname(pdev, "spi_irq_in");
- dd->irq_out = platform_get_irq_byname(pdev, "spi_irq_out");
- dd->irq_err = platform_get_irq_byname(pdev, "spi_irq_err");
- if ((dd->irq_in < 0) || (dd->irq_out < 0) || (dd->irq_err < 0))
- return -1;
- return 0;
-}
-
-static inline int msm_spi_get_gsbi_resource(struct msm_spi *dd,
- struct platform_device *pdev)
-{
- return 0;
-}
-
-static inline int msm_spi_request_gsbi(struct msm_spi *dd) { return 0; }
-static inline void msm_spi_release_gsbi(struct msm_spi *dd) {}
-static inline void msm_spi_init_gsbi(struct msm_spi *dd) {}
-
-static inline void msm_spi_disable_irqs(struct msm_spi *dd)
-{
- disable_irq(dd->irq_in);
- disable_irq(dd->irq_out);
- disable_irq(dd->irq_err);
-}
-
-static inline void msm_spi_enable_irqs(struct msm_spi *dd)
-{
- enable_irq(dd->irq_in);
- enable_irq(dd->irq_out);
- enable_irq(dd->irq_err);
-}
-
-static inline int msm_spi_request_irq(struct msm_spi *dd,
- const char *name,
- struct spi_master *master)
-{
- int rc;
- rc = request_irq(dd->irq_in, msm_spi_input_irq, IRQF_TRIGGER_RISING,
- name, dd);
- if (rc)
- goto error_irq1;
- rc = request_irq(dd->irq_out, msm_spi_output_irq, IRQF_TRIGGER_RISING,
- name, dd);
- if (rc)
- goto error_irq2;
- rc = request_irq(dd->irq_err, msm_spi_error_irq, IRQF_TRIGGER_RISING,
- name, master);
- if (rc)
- goto error_irq3;
- return 0;
-
-error_irq3:
- free_irq(dd->irq_out, dd);
-error_irq2:
- free_irq(dd->irq_in, dd);
-error_irq1:
- return rc;
-}
-
-static inline void msm_spi_free_irq(struct msm_spi *dd,
- struct spi_master *master)
-{
- free_irq(dd->irq_err, master);
- free_irq(dd->irq_out, dd);
- free_irq(dd->irq_in, dd);
-}
-
-static inline void msm_spi_get_clk_err(struct msm_spi *dd, u32 *spi_err) {}
-static inline void msm_spi_ack_clk_err(struct msm_spi *dd) {}
-static inline void msm_spi_set_qup_config(struct msm_spi *dd, int bpw) {}
-
-static inline int msm_spi_prepare_for_write(struct msm_spi *dd) { return 0; }
-static inline void msm_spi_start_write(struct msm_spi *dd, u32 read_count)
-{
- msm_spi_write_word_to_fifo(dd);
-}
-static inline void msm_spi_set_write_count(struct msm_spi *dd, int val) {}
-
-static inline void msm_spi_complete(struct msm_spi *dd)
-{
- complete(&dd->transfer_complete);
-}
-
-static inline void msm_spi_enable_error_flags(struct msm_spi *dd)
-{
- writel_relaxed(0x0000007B, dd->base + SPI_ERROR_FLAGS_EN);
-}
-
-static inline void msm_spi_clear_error_flags(struct msm_spi *dd)
-{
- writel_relaxed(0x0000007F, dd->base + SPI_ERROR_FLAGS);
-}
-
-#elif defined(CONFIG_SPI_QUP) || defined(CONFIG_SPI_QUP_MODULE)
-
-/* Interrupt Handling */
-/* In QUP the same interrupt line is used for intput, output and error*/
-static inline int msm_spi_get_irq_data(struct msm_spi *dd,
- struct platform_device *pdev)
-{
- dd->irq_in = platform_get_irq_byname(pdev, "spi_irq_in");
- if (dd->irq_in < 0)
- return -1;
- return 0;
-}
-
-static inline int msm_spi_get_gsbi_resource(struct msm_spi *dd,
- struct platform_device *pdev)
+static inline int msm_spi_configure_gsbi(struct msm_spi *dd,
+ struct platform_device *pdev)
{
struct resource *resource;
+ unsigned long gsbi_mem_phys_addr;
+ size_t gsbi_mem_size;
+ void __iomem *gsbi_base;
- resource = platform_get_resource_byname(pdev,
- IORESOURCE_MEM, "gsbi_base");
+ resource = platform_get_resource(pdev, IORESOURCE_MEM, 1);
if (!resource)
+ return 0;
+
+ gsbi_mem_phys_addr = resource->start;
+ gsbi_mem_size = resource_size(resource);
+ if (!devm_request_mem_region(&pdev->dev, gsbi_mem_phys_addr,
+ gsbi_mem_size, SPI_DRV_NAME))
return -ENXIO;
- dd->gsbi_mem_phys_addr = resource->start;
- dd->gsbi_mem_size = resource_size(resource);
+
+ gsbi_base = devm_ioremap(&pdev->dev, gsbi_mem_phys_addr,
+ gsbi_mem_size);
+ if (!gsbi_base)
+ return -ENXIO;
+
+ /* Set GSBI to SPI mode */
+ writel_relaxed(GSBI_SPI_CONFIG, gsbi_base + GSBI_CTRL_REG);
return 0;
}
-static inline void msm_spi_release_gsbi(struct msm_spi *dd)
+static inline void msm_spi_register_init(struct msm_spi *dd)
{
- iounmap(dd->gsbi_base);
- release_mem_region(dd->gsbi_mem_phys_addr, dd->gsbi_mem_size);
+ writel_relaxed(0x00000001, dd->base + SPI_SW_RESET);
+ msm_spi_set_state(dd, SPI_OP_STATE_RESET);
+ writel_relaxed(0x00000000, dd->base + SPI_OPERATIONAL);
+ writel_relaxed(0x00000000, dd->base + SPI_CONFIG);
+ writel_relaxed(0x00000000, dd->base + SPI_IO_MODES);
+ if (dd->qup_ver)
+ writel_relaxed(0x00000000, dd->base + QUP_OPERATIONAL_MASK);
}
-static inline int msm_spi_request_gsbi(struct msm_spi *dd)
-{
- if (!request_mem_region(dd->gsbi_mem_phys_addr, dd->gsbi_mem_size,
- SPI_DRV_NAME)) {
- return -ENXIO;
- }
- dd->gsbi_base = ioremap(dd->gsbi_mem_phys_addr, dd->gsbi_mem_size);
- if (!dd->gsbi_base) {
- release_mem_region(dd->gsbi_mem_phys_addr, dd->gsbi_mem_size);
- return -ENXIO;
- }
- return 0;
-}
-
-static inline void msm_spi_init_gsbi(struct msm_spi *dd)
-{
- /* Set GSBI to SPI mode, and CRCI_MUX_CTRL to SPI CRCI ports */
- writel_relaxed(GSBI_SPI_CONFIG, dd->gsbi_base + GSBI_CTRL_REG);
-}
-
-/* Figure which irq occured and call the relevant functions */
-static irqreturn_t msm_spi_qup_irq(int irq, void *dev_id)
-{
- u32 op, ret = IRQ_NONE;
- struct msm_spi *dd = dev_id;
-
- if (readl_relaxed(dd->base + SPI_ERROR_FLAGS) ||
- readl_relaxed(dd->base + QUP_ERROR_FLAGS)) {
- struct spi_master *master = dev_get_drvdata(dd->dev);
- ret |= msm_spi_error_irq(irq, master);
- }
-
- op = readl_relaxed(dd->base + SPI_OPERATIONAL);
- if (op & SPI_OP_INPUT_SERVICE_FLAG) {
- writel_relaxed(SPI_OP_INPUT_SERVICE_FLAG,
- dd->base + SPI_OPERATIONAL);
- /*
- * Ensure service flag was cleared before further
- * processing of interrupt.
- */
- mb();
- ret |= msm_spi_input_irq(irq, dev_id);
- }
-
- if (op & SPI_OP_OUTPUT_SERVICE_FLAG) {
- writel_relaxed(SPI_OP_OUTPUT_SERVICE_FLAG,
- dd->base + SPI_OPERATIONAL);
- /*
- * Ensure service flag was cleared before further
- * processing of interrupt.
- */
- mb();
- ret |= msm_spi_output_irq(irq, dev_id);
- }
-
- if (dd->done) {
- complete(&dd->transfer_complete);
- dd->done = 0;
- }
- return ret;
-}
-
-static inline int msm_spi_request_irq(struct msm_spi *dd,
- const char *name,
- struct spi_master *master)
-{
- return request_irq(dd->irq_in, msm_spi_qup_irq, IRQF_TRIGGER_HIGH,
- name, dd);
-}
-
-static inline void msm_spi_free_irq(struct msm_spi *dd,
- struct spi_master *master)
-{
- free_irq(dd->irq_in, dd);
-}
-
-static inline void msm_spi_free_output_irq(struct msm_spi *dd) { }
-static inline void msm_spi_free_error_irq(struct msm_spi *dd,
- struct spi_master *master) { }
-
-static inline void msm_spi_disable_irqs(struct msm_spi *dd)
-{
- disable_irq(dd->irq_in);
-}
-
-static inline void msm_spi_enable_irqs(struct msm_spi *dd)
-{
- enable_irq(dd->irq_in);
-}
-
-static inline void msm_spi_get_clk_err(struct msm_spi *dd, u32 *spi_err)
-{
- *spi_err = readl_relaxed(dd->base + QUP_ERROR_FLAGS);
-}
-
-static inline void msm_spi_ack_clk_err(struct msm_spi *dd)
-{
- writel_relaxed(QUP_ERR_MASK, dd->base + QUP_ERROR_FLAGS);
-}
-
-static inline void msm_spi_add_configs(struct msm_spi *dd, u32 *config, int n);
-
-/* QUP has no_input, no_output, and N bits at QUP_CONFIG */
-static inline void msm_spi_set_qup_config(struct msm_spi *dd, int bpw)
-{
- u32 qup_config = readl_relaxed(dd->base + QUP_CONFIG);
-
- msm_spi_add_configs(dd, &qup_config, bpw-1);
- writel_relaxed(qup_config | QUP_CONFIG_SPI_MODE,
- dd->base + QUP_CONFIG);
-}
-
-static inline int msm_spi_prepare_for_write(struct msm_spi *dd)
-{
- if (msm_spi_set_state(dd, SPI_OP_STATE_RUN))
- return -1;
- if (msm_spi_set_state(dd, SPI_OP_STATE_PAUSE))
- return -1;
- return 0;
-}
-
-static inline void msm_spi_start_write(struct msm_spi *dd, u32 read_count)
-{
- if (read_count <= dd->input_fifo_size)
- msm_spi_write_rmn_to_fifo(dd);
- else
- msm_spi_write_word_to_fifo(dd);
-}
-
-static inline void msm_spi_set_write_count(struct msm_spi *dd, int val)
-{
- writel_relaxed(val, dd->base + QUP_MX_WRITE_COUNT);
-}
-
-static inline void msm_spi_complete(struct msm_spi *dd)
-{
- dd->done = 1;
-}
-
-static inline void msm_spi_enable_error_flags(struct msm_spi *dd)
-{
- writel_relaxed(0x00000078, dd->base + SPI_ERROR_FLAGS_EN);
-}
-
-static inline void msm_spi_clear_error_flags(struct msm_spi *dd)
-{
- writel_relaxed(0x0000007C, dd->base + SPI_ERROR_FLAGS);
-}
-
-#endif
-
static inline int msm_spi_request_gpios(struct msm_spi *dd)
{
int i;
@@ -710,8 +151,9 @@
words = 8; /* 32 bytes */
break;
default:
- return -1;
+ return -EINVAL;
}
+
switch (mult) {
case 0:
*fifo_size = words * 2;
@@ -726,8 +168,9 @@
*fifo_size = words * 16;
break;
default:
- return -1;
+ return -EINVAL;
}
+
*block_size = words * sizeof(u32); /* in bytes */
return 0;
}
@@ -781,8 +224,7 @@
fifo_size_err:
dd->use_dma = 0;
- printk(KERN_WARNING "%s: invalid FIFO size, SPI_IO_MODES=0x%x\n",
- __func__, spi_iom);
+ pr_err("%s: invalid FIFO size, SPI_IO_MODES=0x%x\n", __func__, spi_iom);
return;
}
@@ -812,6 +254,7 @@
else
dd->rx_bytes_remaining = 0;
}
+
dd->read_xfr_cnt++;
if (dd->multi_xfr) {
if (!dd->rx_bytes_remaining)
@@ -889,7 +332,7 @@
{
enum msm_spi_state cur_state;
if (msm_spi_wait_valid(dd))
- return -1;
+ return -EIO;
cur_state = readl_relaxed(dd->base + SPI_STATE);
/* Per spec:
For PAUSE_STATE to RESET_STATE, two writes of (10) are required */
@@ -902,7 +345,7 @@
dd->base + SPI_STATE);
}
if (msm_spi_wait_valid(dd))
- return -1;
+ return -EIO;
return 0;
}
@@ -1121,6 +564,48 @@
mb();
}
+/* Figure which irq occured and call the relevant functions */
+static inline irqreturn_t msm_spi_qup_irq(int irq, void *dev_id)
+{
+ u32 op, ret = IRQ_NONE;
+ struct msm_spi *dd = dev_id;
+
+ if (readl_relaxed(dd->base + SPI_ERROR_FLAGS) ||
+ readl_relaxed(dd->base + QUP_ERROR_FLAGS)) {
+ struct spi_master *master = dev_get_drvdata(dd->dev);
+ ret |= msm_spi_error_irq(irq, master);
+ }
+
+ op = readl_relaxed(dd->base + SPI_OPERATIONAL);
+ if (op & SPI_OP_INPUT_SERVICE_FLAG) {
+ writel_relaxed(SPI_OP_INPUT_SERVICE_FLAG,
+ dd->base + SPI_OPERATIONAL);
+ /*
+ * Ensure service flag was cleared before further
+ * processing of interrupt.
+ */
+ mb();
+ ret |= msm_spi_input_irq(irq, dev_id);
+ }
+
+ if (op & SPI_OP_OUTPUT_SERVICE_FLAG) {
+ writel_relaxed(SPI_OP_OUTPUT_SERVICE_FLAG,
+ dd->base + SPI_OPERATIONAL);
+ /*
+ * Ensure service flag was cleared before further
+ * processing of interrupt.
+ */
+ mb();
+ ret |= msm_spi_output_irq(irq, dev_id);
+ }
+
+ if (dd->done) {
+ complete(&dd->transfer_complete);
+ dd->done = 0;
+ }
+ return ret;
+}
+
static irqreturn_t msm_spi_input_irq(int irq, void *dev_id)
{
struct msm_spi *dd = dev_id;
@@ -1490,14 +975,14 @@
if (int_loopback && dd->multi_xfr &&
(read_count > dd->input_fifo_size)) {
if (dd->read_len && dd->write_len)
- printk(KERN_WARNING
- "%s:Internal Loopback does not support > fifo size\
- for write-then-read transactions\n",
+ pr_err(
+ "%s:Internal Loopback does not support > fifo size"
+ "for write-then-read transactions\n",
__func__);
else if (dd->write_len && !dd->read_len)
- printk(KERN_WARNING
- "%s:Internal Loopback does not support > fifo size\
- for write-then-write transactions\n",
+ pr_err(
+ "%s:Internal Loopback does not support > fifo size"
+ "for write-then-write transactions\n",
__func__);
return;
}
@@ -1692,43 +1177,84 @@
dd->cs_gpios[cs_num].valid = 1;
}
- dd->cur_transfer = list_first_entry(&dd->cur_msg->transfers,
- struct spi_transfer,
- transfer_list);
- get_transfer_length(dd);
- if (dd->multi_xfr && !dd->read_len && !dd->write_len) {
- /* Handling of multi-transfers. FIFO mode is used by default */
+ if (dd->qup_ver) {
list_for_each_entry(dd->cur_transfer,
- &dd->cur_msg->transfers,
- transfer_list) {
- if (!dd->cur_transfer->len)
- goto error;
- if (xfrs_grped) {
- xfrs_grped--;
- continue;
- } else {
- dd->read_len = dd->write_len = 0;
- xfrs_grped = combine_transfers(dd);
+ &dd->cur_msg->transfers,
+ transfer_list) {
+ u32 spi_ioc;
+ u32 spi_ioc_orig;
+ struct spi_transfer *t = dd->cur_transfer;
+ struct spi_transfer *nxt;
+
+ if (t->transfer_list.next != &dd->cur_msg->transfers) {
+ nxt = list_entry(t->transfer_list.next,
+ struct spi_transfer,
+ transfer_list);
+
+ spi_ioc = readl_relaxed(dd->base +
+ SPI_IO_CONTROL);
+ spi_ioc_orig = spi_ioc;
+ if (t->cs_change == nxt->cs_change)
+ spi_ioc |= SPI_IO_C_FORCE_CS;
+ else
+ spi_ioc &= ~SPI_IO_C_FORCE_CS;
+
+ if (spi_ioc != spi_ioc_orig) {
+ writel_relaxed(spi_ioc,
+ dd->base + SPI_IO_CONTROL);
+ }
}
+
+ dd->cur_msg_len = dd->cur_transfer->len;
+ msm_spi_process_transfer(dd);
+ }
+ } else {
+ dd->cur_transfer = list_first_entry(&dd->cur_msg->transfers,
+ struct spi_transfer,
+ transfer_list);
+ get_transfer_length(dd);
+ if (dd->multi_xfr && !dd->read_len && !dd->write_len) {
+ /*
+ * Handling of multi-transfers.
+ * FIFO mode is used by default
+ */
+ list_for_each_entry(dd->cur_transfer,
+ &dd->cur_msg->transfers,
+ transfer_list) {
+ if (!dd->cur_transfer->len)
+ goto error;
+ if (xfrs_grped) {
+ xfrs_grped--;
+ continue;
+ } else {
+ dd->read_len = dd->write_len = 0;
+ xfrs_grped = combine_transfers(dd);
+ }
+
+ dd->cur_tx_transfer = dd->cur_transfer;
+ dd->cur_rx_transfer = dd->cur_transfer;
+ msm_spi_process_transfer(dd);
+ xfrs_grped--;
+ }
+ } else {
+ /* Handling of a single transfer or
+ * WR-WR or WR-RD transfers
+ */
+ if ((!dd->cur_msg->is_dma_mapped) &&
+ (msm_use_dm(dd, dd->cur_transfer,
+ dd->cur_transfer->bits_per_word))) {
+ /* Mapping of DMA buffers */
+ int ret = msm_spi_map_dma_buffers(dd);
+ if (ret < 0) {
+ dd->cur_msg->status = ret;
+ goto error;
+ }
+ }
+
dd->cur_tx_transfer = dd->cur_transfer;
dd->cur_rx_transfer = dd->cur_transfer;
msm_spi_process_transfer(dd);
- xfrs_grped--;
}
- } else {
- /* Handling of a single transfer or WR-WR or WR-RD transfers */
- if ((!dd->cur_msg->is_dma_mapped) &&
- (msm_use_dm(dd, dd->cur_transfer,
- dd->cur_transfer->bits_per_word))) {
- /* Mapping of DMA buffers */
- int ret = msm_spi_map_dma_buffers(dd);
- if (ret < 0) {
- dd->cur_msg->status = ret;
- goto error;
- }
- }
- dd->cur_tx_transfer = dd->cur_rx_transfer = dd->cur_transfer;
- msm_spi_process_transfer(dd);
}
return;
@@ -1939,6 +1465,7 @@
dd->dent_spi = debugfs_create_dir(dev_name(dd->dev), NULL);
if (dd->dent_spi) {
int i;
+
for (i = 0; i < ARRAY_SIZE(debugfs_spi_regs); i++) {
dd->debugfs_spi_regs[i] =
debugfs_create_file(
@@ -1955,6 +1482,7 @@
{
if (dd->dent_spi) {
int i;
+
debugfs_remove_recursive(dd->dent_spi);
dd->dent_spi = NULL;
for (i = 0; i < ARRAY_SIZE(debugfs_spi_regs); i++)
@@ -2210,6 +1738,23 @@
return 0;
}
+struct msm_spi_platform_data *msm_spi_dt_to_pdata(struct platform_device *pdev)
+{
+ struct device_node *node = pdev->dev.of_node;
+ struct msm_spi_platform_data *pdata;
+
+ pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+ if (!pdata) {
+ pr_err("Unable to allocate platform data\n");
+ return NULL;
+ }
+
+ of_property_read_u32(node, "spi-max-frequency",
+ &pdata->max_clock_speed);
+
+ return pdata;
+}
+
static int __init msm_spi_probe(struct platform_device *pdev)
{
struct spi_master *master;
@@ -2220,7 +1765,7 @@
int i = 0;
int clk_enabled = 0;
int pclk_enabled = 0;
- struct msm_spi_platform_data *pdata = pdev->dev.platform_data;
+ struct msm_spi_platform_data *pdata;
master = spi_alloc_master(&pdev->dev, sizeof(struct msm_spi));
if (!master) {
@@ -2237,23 +1782,29 @@
platform_set_drvdata(pdev, master);
dd = spi_master_get_devdata(master);
+ if (pdev->dev.of_node) {
+ dd->qup_ver = SPI_QUP_VERSION_BFAM;
+ master->dev.of_node = pdev->dev.of_node;
+ pdata = msm_spi_dt_to_pdata(pdev);
+ if (!pdata) {
+ rc = -ENOMEM;
+ goto err_probe_exit;
+ }
+ } else {
+ pdata = pdev->dev.platform_data;
+ dd->qup_ver = SPI_QUP_VERSION_NONE;
+ }
+
dd->pdata = pdata;
- rc = msm_spi_get_irq_data(dd, pdev);
- if (rc)
- goto err_probe_res;
- resource = platform_get_resource_byname(pdev,
- IORESOURCE_MEM, "spi_base");
+ resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!resource) {
rc = -ENXIO;
goto err_probe_res;
}
+
dd->mem_phys_addr = resource->start;
dd->mem_size = resource_size(resource);
- rc = msm_spi_get_gsbi_resource(dd, pdev);
- if (rc)
- goto err_probe_res2;
-
if (pdata) {
if (pdata->dma_config) {
rc = pdata->dma_config();
@@ -2265,20 +1816,17 @@
goto skip_dma_resources;
}
}
- resource = platform_get_resource_byname(pdev,
- IORESOURCE_DMA,
- "spidm_channels");
+ resource = platform_get_resource(pdev, IORESOURCE_DMA, 0);
if (resource) {
dd->rx_dma_chan = resource->start;
dd->tx_dma_chan = resource->end;
-
- resource = platform_get_resource_byname(pdev,
- IORESOURCE_DMA,
- "spidm_crci");
+ resource = platform_get_resource(pdev, IORESOURCE_DMA,
+ 1);
if (!resource) {
rc = -ENXIO;
goto err_probe_res;
}
+
dd->rx_dma_crci = resource->start;
dd->tx_dma_crci = resource->end;
dd->use_dma = 1;
@@ -2298,14 +1846,13 @@
}
for (i = 0; i < ARRAY_SIZE(spi_rsrcs); ++i) {
- resource = platform_get_resource_byname(pdev, IORESOURCE_IO,
- spi_rsrcs[i]);
+ resource = platform_get_resource(pdev, IORESOURCE_IO, i);
dd->spi_gpios[i] = resource ? resource->start : -1;
}
for (i = 0; i < ARRAY_SIZE(spi_cs_rsrcs); ++i) {
- resource = platform_get_resource_byname(pdev, IORESOURCE_IO,
- spi_cs_rsrcs[i]);
+ resource = platform_get_resource(pdev, IORESOURCE_IO,
+ i + ARRAY_SIZE(spi_rsrcs));
dd->cs_gpios[i].gpio_num = resource ? resource->start : -1;
dd->cs_gpios[i].valid = 0;
}
@@ -2320,22 +1867,22 @@
INIT_WORK(&dd->work_data, msm_spi_workq);
init_waitqueue_head(&dd->continue_suspend);
dd->workqueue = create_singlethread_workqueue(
- dev_name(master->dev.parent));
+ dev_name(master->dev.parent));
if (!dd->workqueue)
goto err_probe_workq;
- if (!request_mem_region(dd->mem_phys_addr, dd->mem_size,
- SPI_DRV_NAME)) {
+ if (!devm_request_mem_region(&pdev->dev, dd->mem_phys_addr,
+ dd->mem_size, SPI_DRV_NAME)) {
rc = -ENXIO;
goto err_probe_reqmem;
}
- dd->base = ioremap(dd->mem_phys_addr, dd->mem_size);
- if (!dd->base)
- goto err_probe_ioremap;
- rc = msm_spi_request_gsbi(dd);
- if (rc)
- goto err_probe_ioremap2;
+ dd->base = devm_ioremap(&pdev->dev, dd->mem_phys_addr, dd->mem_size);
+ if (!dd->base) {
+ rc = -ENOMEM;
+ goto err_probe_reqmem;
+ }
+
if (pdata && pdata->rsl_id) {
struct remote_mutex_id rmid;
rmid.r_spinlock_id = pdata->rsl_id;
@@ -2348,16 +1895,18 @@
__func__, rc);
goto err_probe_rlock_init;
}
+
dd->use_rlock = 1;
dd->pm_lat = pdata->pm_lat;
pm_qos_add_request(&qos_req_list, PM_QOS_CPU_DMA_LATENCY,
PM_QOS_DEFAULT_VALUE);
}
+
mutex_lock(&dd->core_lock);
if (dd->use_rlock)
remote_mutex_lock(&dd->r_lock);
- locked = 1;
+ locked = 1;
dd->dev = &pdev->dev;
dd->clk = clk_get(&pdev->dev, "core_clk");
if (IS_ERR(dd->clk)) {
@@ -2382,16 +1931,20 @@
__func__);
goto err_probe_clk_enable;
}
- clk_enabled = 1;
+ clk_enabled = 1;
rc = clk_enable(dd->pclk);
if (rc) {
dev_err(&pdev->dev, "%s: unable to enable iface_clk\n",
__func__);
goto err_probe_pclk_enable;
}
+
pclk_enabled = 1;
- msm_spi_init_gsbi(dd);
+ rc = msm_spi_configure_gsbi(dd, pdev);
+ if (rc)
+ goto err_probe_gsbi;
+
msm_spi_calculate_fifo_size(dd);
if (dd->use_dma) {
rc = msm_spi_init_dma(dd);
@@ -2399,13 +1952,7 @@
goto err_probe_dma;
}
- /* Initialize registers */
- writel_relaxed(0x00000001, dd->base + SPI_SW_RESET);
- msm_spi_set_state(dd, SPI_OP_STATE_RESET);
-
- writel_relaxed(0x00000000, dd->base + SPI_OPERATIONAL);
- writel_relaxed(0x00000000, dd->base + SPI_CONFIG);
- writel_relaxed(0x00000000, dd->base + SPI_IO_MODES);
+ msm_spi_register_init(dd);
/*
* The SPI core generates a bogus input overrun error on some targets,
* when a transition from run to reset state occurs and if the FIFO has
@@ -2429,7 +1976,7 @@
dd->multi_xfr = 0;
dd->mode = SPI_MODE_NONE;
- rc = msm_spi_request_irq(dd, pdev->name, master);
+ rc = msm_spi_request_irq(dd, pdev, master);
if (rc)
goto err_probe_irq;
@@ -2451,16 +1998,16 @@
}
spi_debugfs_init(dd);
-
return 0;
err_attrs:
+ spi_unregister_master(master);
err_probe_reg_master:
- msm_spi_free_irq(dd, master);
err_probe_irq:
err_probe_state:
msm_spi_teardown_dma(dd);
err_probe_dma:
+err_probe_gsbi:
if (pclk_enabled)
clk_disable(dd->pclk);
err_probe_pclk_enable:
@@ -2474,14 +2021,10 @@
if (locked) {
if (dd->use_rlock)
remote_mutex_unlock(&dd->r_lock);
+
mutex_unlock(&dd->core_lock);
}
err_probe_rlock_init:
- msm_spi_release_gsbi(dd);
-err_probe_ioremap2:
- iounmap(dd->base);
-err_probe_ioremap:
- release_mem_region(dd->mem_phys_addr, dd->mem_size);
err_probe_reqmem:
destroy_workqueue(dd->workqueue);
err_probe_workq:
@@ -2489,7 +2032,6 @@
err_probe_gpio:
if (pdata && pdata->gpio_release)
pdata->gpio_release();
-err_probe_res2:
err_probe_res:
spi_master_put(master);
err_probe_exit:
@@ -2553,16 +2095,11 @@
spi_debugfs_exit(dd);
sysfs_remove_group(&pdev->dev.kobj, &dev_attr_grp);
- msm_spi_free_irq(dd, master);
msm_spi_teardown_dma(dd);
-
if (pdata && pdata->gpio_release)
pdata->gpio_release();
msm_spi_free_gpios(dd);
- iounmap(dd->base);
- release_mem_region(dd->mem_phys_addr, dd->mem_size);
- msm_spi_release_gsbi(dd);
clk_put(dd->clk);
clk_put(dd->pclk);
destroy_workqueue(dd->workqueue);
@@ -2573,10 +2110,18 @@
return 0;
}
+static struct of_device_id msm_spi_dt_match[] = {
+ {
+ .compatible = "qcom,spi-qup-v2",
+ },
+ {}
+};
+
static struct platform_driver msm_spi_driver = {
.driver = {
.name = SPI_DRV_NAME,
.owner = THIS_MODULE,
+ .of_match_table = msm_spi_dt_match,
},
.suspend = msm_spi_suspend,
.resume = msm_spi_resume,
@@ -2594,3 +2139,7 @@
platform_driver_unregister(&msm_spi_driver);
}
module_exit(msm_spi_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_VERSION("0.4");
+MODULE_ALIAS("platform:"SPI_DRV_NAME);