[Feature][T106_eSDK]T106-V2.01.01.02P56U06.AP.15.05_CAP.15.05(SDK4.4)diff_15.11
Only Configure: No
Affected branch: master
Affected module: unknow
Is it affected on both ZXIC and MTK: only ZXIC
Self-test: Yes
Doc Update: No
Change-Id: Ief12bb341bd859dd73c7a8c5fa3d25e5ba7e1c6d
diff --git a/upstream/linux-5.10/drivers/spi/spi-zx29.c b/upstream/linux-5.10/drivers/spi/spi-zx29.c
new file mode 100755
index 0000000..d570db1
--- /dev/null
+++ b/upstream/linux-5.10/drivers/spi/spi-zx29.c
@@ -0,0 +1,3681 @@
+/*******************************************************************************
+* Copyright (C) 2016-2021, ZTE Corporation.
+*
+* File Name:spi-zx29.c
+* File Mark:
+* Description:
+* Others:
+* Version: 1.0
+* Author: ZTE
+* Date:
+* modify
+********************************************************************************/
+
+/****************************************************************************
+* Include files
+****************************************************************************/
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/err.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
+#include <linux/dmaengine.h>
+#include <linux/dma-mapping.h>
+#include <linux/scatterlist.h>
+#include <linux/pm_runtime.h>
+#include <linux/semaphore.h>
+//#include <linux/wakelock.h> //qhf
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
+#include <linux/dma/zx-dma.h>
+#include <linux/dma-direct.h>
+#include <asm/memory.h>
+#include <linux/debugfs.h>
+#include <linux/spi/spi.h>
+//#include <linux/soc/zte/pm/drv_idle.h>
+
+#include "spi-zx29.h"
+#include "pub_debug_info.h"
+/* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck start */
+#include <linux/wait.h>
+#include <linux/suspend.h>
+/* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck end */
+
+struct zx29_ssp_device_of_data {
+ enum zx29_ssp_device_mode mode;
+};
+static const struct of_device_id zx29_spi_of_match[];
+
+/****************************************************************************
+* Local Macros
+****************************************************************************/
+
+#define CONFIG_SPI_DMA_ENGINE
+#define SPI_PSM_CONTROL (0) //(1)//qhf
+
+/*
+ * This macro is used to define some register default values.
+ * reg is masked with mask, the OR:ed with an (again masked)
+ * val shifted sb steps to the left.
+ */
+#define SPI_WRITE_BITS(reg, val, mask, sb) \
+ ((reg) = (((reg) & ~(mask)) | (((val)<<(sb)) & (mask))))
+
+/*
+ * This macro is also used to define some default values.
+ * It will just shift val by sb steps to the left and mask
+ * the result with mask.
+ */
+#define GEN_MASK_BITS(val, mask, sb) \
+ (((val)<<(sb)) & (mask))
+
+
+#define SPI_GPIO_HIGH 1
+#define SPI_GPIO_LOW 0
+
+#define ZX29_CS_ACTIVE 1 /* normally nCS, active low */
+#define ZX29_CS_INACTIVE 0
+
+#define DRIVE_TX 0
+#define DO_NOT_DRIVE_TX 1
+
+#define DO_NOT_QUEUE_DMA 0
+#define QUEUE_DMA 1
+
+#define RX_TRANSFER BIT(0)
+#define TX_TRANSFER BIT(1)
+
+/* registers */
+#define SPI_VER_REG_OFFSET (0x00)
+#define SPI_COM_CTRL_OFFSET (0x04)
+#define SPI_FMT_CTRL_OFFSET (0x08)
+#define SPI_DR_OFFSET (0x0C)
+#define SPI_FIFO_CTRL_OFFSET (0x10)
+#define SPI_FIFO_SR_OFFSET (0x14)
+#define SPI_INTR_EN_OFFSET (0x18)
+#define SPI_INTR_SR_OFFSET (0x1C)
+#define SPI_TIMING_OFFSET (0x20)
+
+/*
+ * SPI Version Register - SPI_VER_REG
+ */
+#define SPI_VER_REG_MASK_Y (0xFFUL << 16)
+#define SPI_VER_REG_MASK_X (0xFFUL << 24)
+
+/*
+ * SPI Common Control Register - SPI_COM_CTRL
+ */
+#define SPI_COM_CTRL_MASK_LBM (0x1UL << 0)
+#define SPI_COM_CTRL_MASK_SSPE (0x1UL << 1)
+#define SPI_COM_CTRL_MASK_MS (0x1UL << 2)
+#define SPI_COM_CTRL_MASK_SOD (0x1UL << 3)
+#define SPI_COM_CTRL_MASK_SSPE_BACK (0x1UL << 4)
+
+/*
+ * SPI Format Control Register - SPI_FMT_CTRL
+ */
+#define SPI_FMT_CTRL_MASK_FRF (0x3UL << 0)
+#define SPI_FMT_CTRL_MASK_POL (0x1UL << 2)
+#define SPI_FMT_CTRL_MASK_PHA (0x1UL << 3)
+#define SPI_FMT_CTRL_MASK_DSS (0x1FUL << 4)
+
+/*
+ * SPI FIFO Control Register - SPI_FIFO_CTRL
+ */
+#define SPI_FIFO_CTRL_MASK_RX_DMA_EN (0x1UL << 2)
+#define SPI_FIFO_CTRL_MASK_TX_DMA_EN (0x1UL << 3)
+#define SPI_FIFO_CTRL_MASK_RX_FIFO_THRES (0xFUL << 4)
+#define SPI_FIFO_CTRL_MASK_TX_FIFO_THRES (0xFUL << 8)
+/*
+ * SPI FIFO Status Register - SPI_FIFO_SR
+ */
+
+#define SPI_FIFO_SR_MASK_RX_BEYOND_THRES (0x1UL << 0)
+#define SPI_FIFO_SR_MASK_TX_BEYOND_THRES (0x1UL << 1)
+#define SPI_FIFO_SR_MASK_RX_FIFO_FULL (0x1UL << 2)
+#define SPI_FIFO_SR_MASK_TX_FIFO_EMPTY (0x1UL << 3)
+#define SPI_FIFO_SR_MASK_BUSY (0x1UL << 4)
+#define SPI_FIFO_SR_SHIFT_RX_CNT 5
+
+#define SPI_FIFO_SR_MASK_RX_FIFO_CNTR (0x1fUL << SPI_FIFO_SR_SHIFT_RX_CNT)
+#define SPI_FIFO_SR_SHIFT_TX_CNT 10
+#define SPI_FIFO_SR_MASK_TX_FIFO_CNTR (0x1fUL << SPI_FIFO_SR_SHIFT_TX_CNT)
+
+/*
+ * SPI Interrupt Enable Register - SPI_INTR_EN
+ */
+#define SPI_INTR_EN_MASK_RX_OVERRUN_IE (0x1UL << 0)
+#define SPI_INTR_EN_MASK_TX_UNDERRUN_IE (0x1UL << 1)
+#define SPI_INTR_EN_MASK_RX_FULL_IE (0x1UL << 2)
+#define SPI_INTR_EN_MASK_TX_EMPTY_IE (0x1UL << 3)
+#define SPI_INTR_EN_MASK_RX_THRES_IE (0x1UL << 4)
+#define SPI_INTR_EN_MASK_TX_THRES_IE (0x1UL << 5)
+//yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme.
+#define SPI_INTR_EN_MASK_MST_EOT_IE (0x1UL << 6)
+
+/*
+ * SPI Interrupt Status Register OR Interrupt Clear Register - SPI_INTR_SR_SCLR
+ */
+
+#define SPI_INTR_SR_SCLR_MASK_RX_OVERRUN_INTR (0x1UL << 0)
+#define SPI_INTR_SR_SCLR_MASK_TX_UNDERRUN_INTR (0x1UL << 1)
+#define SPI_INTR_SR_SCLR_MASK_RX_FULL_INTR (0x1UL << 2)
+#define SPI_INTR_SR_SCLR_MASK_TX_EMPTY_INTR (0x1UL << 3)
+#define SPI_INTR_SR_SCLR_MASK_RX_THRES_INTR (0x1UL << 4)
+#define SPI_INTR_SR_SCLR_MASK_TX_THRES_INTR (0x1UL << 5)
+
+/*
+ * SPI TIMING Register
+ */
+#define SPI_TIMING_MASK_T_CS_DESEL 0xFUL
+
+/* SPI WCLK Freqency */
+#define SPI_SPICLK_FREQ_26M (26*1000*1000)
+#define SPI_SPICLK_FREQ_104M (104*1000*1000)
+#define SPI_SPICLK_FREQ_156M (156*1000*1000)
+
+#define CLEAR_ALL_INTERRUPTS 0x3FUL
+#define ENABLE_ALL_INTERRUPTS 0x3FUL
+#define ENABLE_INTERRUPTS 0x03UL
+#define DISABLE_ALL_INTERRUPTS 0x0UL
+/*
+ * Message State
+ * we use the spi_message.state (void *) pointer to
+ * hold a single state value, that's why all this
+ * (void *) casting is done here.
+ */
+
+enum zx29_spi_state {
+ STATE_START,
+ STATE_RUNNING,
+ STATE_DONE,
+ STATE_ERROR
+};
+
+/*
+ * SPI State - Whether Enabled or Disabled
+ */
+#define SPI_DISABLED (0)
+#define SPI_ENABLED (1)
+
+/*
+ * SPI DMA State - Whether DMA Enabled or Disabled
+ */
+#define SPI_DMA_DISABLED (0)
+#define SPI_DMA_ENABLED (1)
+
+/*
+ * SPI SOD State - Whether SOD Enabled or Disabled
+ */
+#define SPI_SOD_DISABLED (1)
+#define SPI_SOD_ENABLED (0)
+#define SPI_SLAVE_MODE (1)
+#define SPI_MASTER_MODE (0)
+
+
+/*
+ * SPI TRANSFER DELAY CFG
+ * DELAY TIME ≈ (1 / Buad_Rate) * 8 + (SPI_TIMING_T_CS_DESEL + 1) / Buad_Rate;
+ */
+
+
+enum spi_fifo_threshold_level {
+ SPI_FIFO_THRES_1,
+ SPI_FIFO_THRES_2,
+ SPI_FIFO_THRES_3,
+ SPI_FIFO_THRES_4,
+ SPI_FIFO_THRES_5,
+ SPI_FIFO_THRES_6,
+ SPI_FIFO_THRES_7,
+ SPI_FIFO_THRES_8,
+ SPI_FIFO_THRES_9,
+ SPI_FIFO_THRES_10,
+ SPI_FIFO_THRES_11,
+ SPI_FIFO_THRES_12,
+ SPI_FIFO_THRES_13,
+ SPI_FIFO_THRES_14,
+ SPI_FIFO_THRES_15,
+ SPI_FIFO_THRES_16
+
+};
+
+/*
+ * SPI Clock Parameter ranges
+ */
+#define DIV_MIN 0x00
+#define DIV_MAX 0x0F
+
+#define SPI_POLLING_TIMEOUT 1000
+
+/*
+ * The type of reading going on on this chip
+ */
+enum spi_reading {
+ READING_NULL,
+ READING_U8,
+ READING_U16,
+ READING_U32
+};
+
+/**
+ * The type of writing going on on this chip
+ */
+enum spi_writing {
+ WRITING_NULL,
+ WRITING_U8,
+ WRITING_U16,
+ WRITING_U32
+};
+
+/**
+ * struct vendor_data - vendor-specific config parameters
+ * for PL022 derivates
+ * @fifodepth: depth of FIFOs (both)
+ * @max_bpw: maximum number of bits per word
+ * @unidir: supports unidirection transfers
+ * @extended_cr: 32 bit wide control register 0 with extra
+ * features and extra features in CR1 as found in the ST variants
+ * @pl023: supports a subset of the ST extensions called "PL023"
+ */
+struct vendor_data {
+ int fifodepth;
+ int max_bpw;
+ bool loopback;
+};
+
+struct zx29_ssp_pins
+{
+ struct device *dev;
+
+ struct pinctrl *pctrl;
+ struct pinctrl_state *pfunc;
+ struct pinctrl_state *pgpio;
+ struct pinctrl_state *pcs_gpio_active;
+ struct pinctrl_state *pcs_func;
+ struct pinctrl_state *pcs_gpio_sleep;
+ int gpio_cs;
+ int gpio_clk;
+ int gpio_tx;
+ int gpio_rx;
+};
+struct zx29_ssp_pins ssp_pins[4];
+
+/**
+ * struct spi-zx29 - This is the private SSP driver data structure
+ * @adev: AMBA device model hookup
+ * @vendor: vendor data for the IP block
+ * @phybase: the physical memory where the SSP device resides
+ * @virtbase: the virtual memory where the SSP is mapped
+ * @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
+ * @queue_lock: spinlock to syncronise access to message queue
+ * @queue: message queue
+ * @busy: message pump is busy
+ * @running: message pump 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
+ * @rx_end: end position in RX buffer to be written
+ * @read: the type of read currently going on
+ * @write: the type of write currently going on
+ * @exp_fifo_level: expected FIFO level
+ * @dma_rx_channel: optional channel for RX DMA
+ * @dma_tx_channel: optional channel for TX DMA
+ * @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
+ */
+struct zx29_spi {
+ char name[16];
+ struct platform_device *pdev;
+ struct vendor_data *vendor;
+ resource_size_t phybase;
+ void __iomem *virtbase;
+ unsigned int irq;
+ struct clk *pclk;/* spi controller work clock */
+ struct clk *spi_clk;/* spi clk line clock */
+ u32 clkfreq;
+ struct spi_master *master;
+ struct zx29_spi_controller *master_info;
+ /* Message per-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;
+ void *rx_end;
+ enum spi_reading read;
+ enum spi_writing write;
+ u32 exp_fifo_level;
+ enum spi_rx_level_trig rx_lev_trig;
+ enum spi_tx_level_trig tx_lev_trig;
+ /* DMA settings */
+#ifdef CONFIG_SPI_DMA_ENGINE
+ struct dma_chan *dma_rx_channel;
+ struct dma_chan *dma_tx_channel;
+ struct sg_table sgt_rx;
+ struct sg_table sgt_tx;
+ char *dummypage;
+ unsigned int dma_running;
+// struct mutex spi_lock;
+#endif
+#if defined(CONFIG_DEBUG_FS)
+ struct dentry * spi_root;
+ struct debugfs_regset32 spi_regset;
+ u32 spi_poll_cnt;
+ u32 spi_dma_cnt;
+#endif
+#if SPI_PSM_CONTROL
+ struct wake_lock psm_lock;
+#endif
+ struct semaphore sema_dma;
+/* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck start */
+ wait_queue_head_t wait;
+ int trans_done;
+/* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck end */
+
+ u8 iface_mode;
+#define SPI_MOTO_FORMAT 0x00
+#define SPI_TI_FORMAT 0x01
+#define SPI_ISI_FORMAT 0x02
+ enum zx29_ssp_device_mode mode;
+ int (*zx29_flush_rxfifo) (struct zx29_spi *zx29spi,void *buf);
+
+};
+
+/**
+ * struct chip_data - To maintain runtime state of SSP for each client chip
+ * @cr0: Value of control register CR0 of SSP - on later ST variants this
+ * register is 32 bits wide rather than just 16
+ * @cr1: Value of control register CR1 of SSP
+ * @dmacr: Value of DMA control Register of SSP
+ * @cpsr: Value of Clock prescale register
+ * @cs: Value of cs register
+ * @n_bytes: how many bytes(power of 2) reqd for a given data width of client
+ * @enable_dma: Whether to enable DMA or not
+ * @read: function ptr to be used to read when doing xfer for this chip
+ * @write: function ptr to be used to write when doing xfer for this chip
+ * @cs_control: chip select callback provided by chip
+ * @xfer_type: polling/interrupt/DMA
+ *
+ * Runtime state of the SSP controller, maintained per chip,
+ * This would be set according to the current message that would be served
+ */
+struct chip_data {
+ u32 ver_reg;
+ u32 com_ctrl;
+ u32 fmt_ctrl;
+ u32 fifo_ctrl;
+ u32 timing;
+// u32 intr_en;
+ u8 n_bytes;
+ u8 clk_div;/* spi clk divider */
+ bool enable_dma;
+ bool enable_trans_gap;
+ enum spi_reading read;
+ enum spi_writing write;
+ void (*cs_control) (int dev_id,u32 command);
+ int xfer_type;
+};
+//struct semaphore g_SpiTransferSemaphore;
+
+struct zx29_spi *g_zx29_spi[4];
+
+#if SPI_PSM_CONTROL
+static volatile unsigned int spi_active_count = 0;
+
+static void zx29_spi_set_active(struct wake_lock *lock)
+{
+ unsigned long flags;
+
+ local_irq_save(flags);
+
+ if(spi_active_count == 0)
+ {
+ zx_cpuidle_set_busy(IDLE_FLAG_SPI);
+ }
+ spi_active_count++;
+
+ local_irq_restore(flags);
+
+ wake_lock(lock);
+}
+
+static void zx29_spi_set_idle(struct wake_lock *lock)
+{
+ unsigned long flags;
+
+ local_irq_save(flags);
+#if 0 //qhf
+ spi_active_count--;
+ if(spi_active_count == 0)
+ {
+ zx_cpuidle_set_free(IDLE_FLAG_SPI);
+ }
+#endif
+ local_irq_restore(flags);
+
+ wake_unlock(lock);
+}
+#endif
+
+static int zx29_do_interrupt_dma_transfer(struct zx29_spi *zx29spi);
+/**
+ * default_cs_control - Dummy chip select function
+ * @command: select/delect the chip
+ *
+ * If no chip select function is provided by client this is used as dummy
+ * chip select
+ */
+
+static void default_cs_control(int dev_id,u32 command)
+{
+ gpio_set_value(ssp_pins[dev_id].gpio_cs, !command);
+}
+
+/**
+ * flush - flush the FIFO to reach a clean state
+ * SSP driver private data structure
+ */
+static int flush(struct zx29_spi *zx29spi)
+{
+ unsigned long limit = loops_per_jiffy << 1;
+ uint32_t rx_fifo_cnt_msk = SPI_FIFO_SR_MASK_RX_FIFO_CNTR;
+
+ dev_dbg(&zx29spi->pdev->dev, "flush\n");
+ /* Flushing FIFO by software cannot clear RX DMA Request. */
+ do {
+ if(0 == strcmp(zx29spi->pdev->name,"140a000.ssp")) {
+ while (readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)) & rx_fifo_cnt_msk)
+ readl((SPI_DR_OFFSET+zx29spi->virtbase));
+ }else {
+ while ((readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase))>>SPI_FIFO_SR_SHIFT_RX_CNT)&0x7F)
+ readl((SPI_DR_OFFSET+zx29spi->virtbase));
+ }
+ } while ((readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)) & SPI_FIFO_SR_MASK_BUSY) && limit--);
+
+ zx29spi->exp_fifo_level = 0;
+
+ return limit;
+}
+
+/**
+ * restore_state - Load configuration of current chip
+ * SSP driver private data structure
+ */
+static void restore_state(struct zx29_spi *zx29spi)
+{
+ struct chip_data *chip = zx29spi->cur_chip;
+
+ /* disable all interrupts */
+ writel(ENABLE_INTERRUPTS, (SPI_INTR_EN_OFFSET+zx29spi->virtbase));
+ writel(CLEAR_ALL_INTERRUPTS, (SPI_INTR_SR_OFFSET+zx29spi->virtbase));
+
+ writel(chip->fmt_ctrl, (SPI_FMT_CTRL_OFFSET+zx29spi->virtbase));
+ writel(chip->fifo_ctrl, (SPI_FIFO_CTRL_OFFSET+zx29spi->virtbase));
+// writel(chip->intr_en, SPI_INTR_EN(zx297520v2spi->virtbase));
+ if(zx29spi->mode == ZX29_SSP_SLAVE_TYPE)
+ chip->com_ctrl |= GEN_MASK_BITS(SPI_SLAVE, SPI_COM_CTRL_MASK_MS, 2)|GEN_MASK_BITS(SPI_ENABLED, SPI_COM_CTRL_MASK_SSPE, 1);
+ writel(chip->com_ctrl, (SPI_COM_CTRL_OFFSET + zx29spi->virtbase));
+ writel(chip->timing, (SPI_TIMING_OFFSET + zx29spi->virtbase));
+}
+
+/*
+ * Default spi Register Values
+ */
+#define DEFAULT_SPI_COM_CTRL ( \
+ GEN_MASK_BITS(LOOPBACK_DISABLED, SPI_COM_CTRL_MASK_LBM, 0) | \
+ GEN_MASK_BITS(SPI_DISABLED, SPI_COM_CTRL_MASK_SSPE, 1) | \
+ GEN_MASK_BITS(SPI_MASTER, SPI_COM_CTRL_MASK_MS, 2) \
+)
+
+/*
+ * Default spi Register Values
+ */
+#define DEFAULT_SPI_SLAVE_COM_CTRL ( \
+ GEN_MASK_BITS(LOOPBACK_DISABLED, SPI_COM_CTRL_MASK_LBM, 0) | \
+ GEN_MASK_BITS(SPI_DISABLED, SPI_COM_CTRL_MASK_SSPE, 1) | \
+ GEN_MASK_BITS(SPI_SLAVE, SPI_COM_CTRL_MASK_MS, 2) \
+)
+
+
+#define DEFAULT_SPI_FMT_CTRL ( \
+ GEN_MASK_BITS(SPI_INTERFACE_MOTOROLA_SPI, SPI_FMT_CTRL_MASK_FRF, 0) | \
+ GEN_MASK_BITS(SPI_CLK_POL_IDLE_LOW, SPI_FMT_CTRL_MASK_POL, 2) | \
+ GEN_MASK_BITS(SPI_CLK_FIRST_EDGE, SPI_FMT_CTRL_MASK_PHA, 3) | \
+ GEN_MASK_BITS(SPI_DATA_BITS_8, SPI_FMT_CTRL_MASK_DSS, 4) \
+)
+
+#define DEFAULT_SPI_FIFO_CTRL ( \
+ GEN_MASK_BITS(SPI_DMA_DISABLED, SPI_FIFO_CTRL_MASK_RX_DMA_EN, 2) | \
+ GEN_MASK_BITS(SPI_DMA_DISABLED, SPI_FIFO_CTRL_MASK_TX_DMA_EN, 3) | \
+ GEN_MASK_BITS(SPI_FIFO_THRES_8, SPI_FIFO_CTRL_MASK_RX_FIFO_THRES, 4) | \
+ GEN_MASK_BITS(SPI_FIFO_THRES_8, SPI_FIFO_CTRL_MASK_TX_FIFO_THRES, 8) \
+)
+
+
+/**
+ * load_ssp_default_config - Load default configuration for SSP
+ * SSP driver private data structure
+ */
+static void load_spi_default_config(struct zx29_spi *zx29spi)
+{
+ writel(CLEAR_ALL_INTERRUPTS, (SPI_INTR_SR_OFFSET+zx29spi->virtbase));
+ writel(ENABLE_INTERRUPTS, (SPI_INTR_EN_OFFSET+zx29spi->virtbase));
+
+ writel(DEFAULT_SPI_FMT_CTRL, (SPI_FMT_CTRL_OFFSET+zx29spi->virtbase));
+ writel(DEFAULT_SPI_FIFO_CTRL, (SPI_FIFO_CTRL_OFFSET+zx29spi->virtbase));
+
+ if(zx29spi->mode == ZX29_SSP_MASTER_TYPE) {
+ writel(DEFAULT_SPI_COM_CTRL, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+ }
+ else {
+ writel(DEFAULT_SPI_SLAVE_COM_CTRL, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+ }
+}
+
+
+static unsigned reader(struct zx29_spi *zx29spi)
+{
+ uint32_t fifo_sr = 0,rd_max = 0;
+ unsigned len = 0;
+ uint32_t rx_fifo_cnt_msk = SPI_FIFO_SR_MASK_RX_FIFO_CNTR;
+ /*
+ * The FIFO depth is different between primecell variants.
+ * I believe filling in too much in the FIFO might cause
+ * errons in 8bit wide transfers on ARM variants (just 8 words
+ * FIFO, means only 8x8 = 64 bits in FIFO) at least.
+ *
+ * To prevent this issue, the TX FIFO is only filled to the
+ * unused RX FIFO fill length, regardless of what the TX
+ * FIFO status flag indicates.
+ */
+
+ fifo_sr = readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase));
+ if(!strcmp(zx29spi->pdev->name,"140a000.ssp")) {
+ rd_max = (fifo_sr & rx_fifo_cnt_msk) >> SPI_FIFO_SR_SHIFT_RX_CNT;
+ }else {
+ rd_max = (fifo_sr>>SPI_FIFO_SR_SHIFT_RX_CNT)&0x7f;
+ }
+ //read rx fifo to empty first
+ while ((zx29spi->rx < zx29spi->rx_end) && rd_max--) {
+ switch (zx29spi->read) {
+ case READING_NULL:
+ readw((SPI_DR_OFFSET+zx29spi->virtbase));
+ break;
+ case READING_U8:
+ *(u8 *) (zx29spi->rx) =
+ readw((SPI_DR_OFFSET+zx29spi->virtbase)) & 0xFFU;
+ break;
+ case READING_U16:
+ *(u16 *) (zx29spi->rx) =
+ (u16) readw((SPI_DR_OFFSET+zx29spi->virtbase));
+ break;
+ case READING_U32:
+ *(u32 *) (zx29spi->rx) =
+ readl((SPI_DR_OFFSET+zx29spi->virtbase));
+ break;
+ }
+ len += zx29spi->cur_chip->n_bytes;
+ zx29spi->rx += (zx29spi->cur_chip->n_bytes);
+ zx29spi->exp_fifo_level--;
+ }
+ return len;
+
+}
+
+static unsigned writer(struct zx29_spi *zx29spi)
+{
+ uint32_t fifo_sr;
+ uint32_t wr_max;
+ uint32_t tx_fifo_cnt_msk = SPI_FIFO_SR_MASK_TX_FIFO_CNTR;
+ uint32_t tx_fifo_cnt_pos = SPI_FIFO_SR_SHIFT_TX_CNT;
+ unsigned len = 0;
+ /*
+ * The FIFO depth is different between primecell variants.
+ * I believe filling in too much in the FIFO might cause
+ * errons in 8bit wide transfers on ARM variants (just 8 words
+ * FIFO, means only 8x8 = 64 bits in FIFO) at least.
+ *
+ * To prevent this issue, the TX FIFO is only filled to the
+ * unused RX FIFO fill length, regardless of what the TX
+ * FIFO status flag indicates.
+ */
+
+ fifo_sr = readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase));
+ if(!strcmp(zx29spi->pdev->name,"140a000.ssp")) {
+ wr_max = (fifo_sr & tx_fifo_cnt_msk) >> tx_fifo_cnt_pos;
+ }else {
+ wr_max = (fifo_sr>>12)&0x1f;
+ }
+
+ if ((fifo_sr & SPI_FIFO_SR_MASK_BUSY) && wr_max) {
+ wr_max--;
+ }
+
+ while ((zx29spi->tx < zx29spi->tx_end) && wr_max--) {
+ switch (zx29spi->write) {
+ case WRITING_NULL:
+ writew(0x0, (SPI_DR_OFFSET+zx29spi->virtbase));
+ break;
+ case WRITING_U8:
+ writew(*(u8 *) (zx29spi->tx), (SPI_DR_OFFSET+zx29spi->virtbase));
+ break;
+ case WRITING_U16:
+ writew((*(u16 *) (zx29spi->tx)), (SPI_DR_OFFSET+zx29spi->virtbase));
+ break;
+ case WRITING_U32:
+ writel(*(u32 *) (zx29spi->tx), (SPI_DR_OFFSET+zx29spi->virtbase));
+ break;
+ }
+ len += zx29spi->cur_chip->n_bytes;
+ zx29spi->tx += (zx29spi->cur_chip->n_bytes);
+ zx29spi->exp_fifo_level++;
+ }
+ return len;
+}
+
+
+/**
+ * This will write to TX and read from RX according to the parameters.
+ */
+
+static void readwriter(struct zx29_spi *zx29spi)
+{
+ uint32_t fifo_sr;
+ uint32_t rd_max, wr_max;
+ uint32_t rx_fifo_cnt_msk;
+ uint32_t tx_fifo_cnt_msk;
+ uint32_t tx_fifo_cnt_pos;
+ ktime_t k_time_start = 0;
+ ktime_t diff_ns = 0;
+
+ rx_fifo_cnt_msk = SPI_FIFO_SR_MASK_RX_FIFO_CNTR;
+ tx_fifo_cnt_msk = SPI_FIFO_SR_MASK_TX_FIFO_CNTR;
+ tx_fifo_cnt_pos = SPI_FIFO_SR_SHIFT_TX_CNT;
+
+ /*
+ * The FIFO depth is different between primecell variants.
+ * I believe filling in too much in the FIFO might cause
+ * errons in 8bit wide transfers on ARM variants (just 8 words
+ * FIFO, means only 8x8 = 64 bits in FIFO) at least.
+ *
+ * To prevent this issue, the TX FIFO is only filled to the
+ * unused RX FIFO fill length, regardless of what the TX
+ * FIFO status flag indicates.
+ */
+
+ fifo_sr = readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase));
+ if(!strcmp(zx29spi->pdev->name,"140a000.ssp")) {
+ rd_max = (fifo_sr & rx_fifo_cnt_msk) >> SPI_FIFO_SR_SHIFT_RX_CNT;
+ wr_max = (fifo_sr & tx_fifo_cnt_msk) >> tx_fifo_cnt_pos;
+ }else {
+ rd_max = (fifo_sr>>SPI_FIFO_SR_SHIFT_RX_CNT)&0x7f;
+ wr_max = (fifo_sr>>12)&0x1f;
+ }
+
+ if ((fifo_sr & SPI_FIFO_SR_MASK_BUSY) && wr_max) {
+ wr_max--;
+ }
+ //read rx fifo to empty first
+ while ((zx29spi->rx < zx29spi->rx_end) && rd_max--) {
+ switch (zx29spi->read) {
+ case READING_NULL:
+ readw((SPI_DR_OFFSET+zx29spi->virtbase));
+ break;
+ case READING_U8:
+ *(u8 *) (zx29spi->rx) =
+ readw((SPI_DR_OFFSET+zx29spi->virtbase)) & 0xFFU;
+ break;
+ case READING_U16:
+ *(u16 *) (zx29spi->rx) =
+ (u16) readw((SPI_DR_OFFSET+zx29spi->virtbase));
+ break;
+ case READING_U32:
+ *(u32 *) (zx29spi->rx) =
+ readl((SPI_DR_OFFSET+zx29spi->virtbase));
+ break;
+ }
+ zx29spi->rx += (zx29spi->cur_chip->n_bytes);
+ zx29spi->exp_fifo_level--;
+ }
+
+ //write
+ while ((zx29spi->tx < zx29spi->tx_end) && wr_max--) {
+ switch (zx29spi->write) {
+ case WRITING_NULL:
+ writew(0x0, (SPI_DR_OFFSET+zx29spi->virtbase));
+ break;
+ case WRITING_U8:
+ writew(*(u8 *) (zx29spi->tx), (SPI_DR_OFFSET+zx29spi->virtbase));
+ break;
+ case WRITING_U16:
+ writew((*(u16 *) (zx29spi->tx)), (SPI_DR_OFFSET+zx29spi->virtbase));
+ break;
+ case WRITING_U32:
+ writel(*(u32 *) (zx29spi->tx), (SPI_DR_OFFSET+zx29spi->virtbase));
+ break;
+ }
+ zx29spi->tx += (zx29spi->cur_chip->n_bytes);
+ zx29spi->exp_fifo_level++;
+
+ if(zx29spi->cur_chip->enable_trans_gap) {
+
+ k_time_start = ktime_get();
+ do {
+ diff_ns = ktime_sub(ktime_get(),k_time_start);
+ fifo_sr = readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)) & SPI_FIFO_SR_MASK_BUSY;
+ cpu_relax();
+ }
+ while (fifo_sr && diff_ns < 10000000); //10ms
+ if(diff_ns >= 10000000) {
+ fifo_sr = readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)) & SPI_FIFO_SR_MASK_BUSY;
+ if(fifo_sr)
+ dev_info(&zx29spi->pdev->dev, "bus busy time_start=%lld diff_ns=%lld \n",k_time_start,diff_ns);
+ }
+ }
+ }
+
+ if(!zx29spi->cur_chip->enable_trans_gap) {
+
+ k_time_start = ktime_get();
+ do {
+ diff_ns = ktime_sub(ktime_get(),k_time_start);
+ fifo_sr = readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)) & SPI_FIFO_SR_MASK_BUSY;
+ cpu_relax();
+ }while (fifo_sr && diff_ns < 100000000); //100ms
+ if(diff_ns >= 100000000) {
+ fifo_sr = readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)) & SPI_FIFO_SR_MASK_BUSY;
+ if(fifo_sr)
+ dev_info(&zx29spi->pdev->dev, "bus busy.. time_start=%lld diff_ns=%lld \n",k_time_start,diff_ns);
+ }
+ }
+ /*
+ * When we exit here the TX FIFO should be full and the RX FIFO
+ * should be empty
+ */
+}
+
+/*
+ * This DMA functionality is only compiled in if we have
+ * access to the generic DMA devices/DMA engine.
+ */
+#ifdef CONFIG_SPI_DMA_ENGINE
+
+static void zx29_fill_txfifo(struct zx29_spi *zx29spi)
+{
+ uint32_t fifo_sr;
+ int32_t rd_max, wr_max;
+ uint32_t rx_fifo_cnt_msk;
+ uint32_t tx_fifo_cnt_msk;
+ uint32_t tx_fifo_cnt_pos;
+ unsigned cur_transfer_len;
+ rx_fifo_cnt_msk = SPI_FIFO_SR_MASK_RX_FIFO_CNTR;
+ tx_fifo_cnt_msk = SPI_FIFO_SR_MASK_TX_FIFO_CNTR;
+ tx_fifo_cnt_pos = SPI_FIFO_SR_SHIFT_TX_CNT;
+
+ if(!zx29spi) {
+ printk("zx29spi err! \r\n");
+ return;
+ }
+ cur_transfer_len = zx29spi->cur_transfer->len;
+ while (zx29spi->tx < zx29spi->tx_end && cur_transfer_len) {
+ fifo_sr = readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase));
+#if 0
+ rd_max = (fifo_sr & rx_fifo_cnt_msk) >> SPI_FIFO_SR_SHIFT_RX_CNT;
+ wr_max = (fifo_sr & tx_fifo_cnt_msk) >> tx_fifo_cnt_pos;
+#else
+ if(!strcmp(zx29spi->pdev->name,"140a000.ssp")) {
+ rd_max = (fifo_sr & rx_fifo_cnt_msk) >> SPI_FIFO_SR_SHIFT_RX_CNT;
+ wr_max = (fifo_sr & tx_fifo_cnt_msk) >> tx_fifo_cnt_pos;
+ }else {
+ rd_max = (fifo_sr>>SPI_FIFO_SR_SHIFT_RX_CNT)&0x7f;
+ wr_max = (fifo_sr>>12)&0x1f;
+ }
+#endif
+ if (fifo_sr & SPI_FIFO_SR_MASK_BUSY) {
+ wr_max--;
+ }
+ wr_max -= rd_max;
+ wr_max = (wr_max > 0) ? wr_max : 0;
+
+ //write
+ while ((zx29spi->tx < zx29spi->tx_end) && wr_max--) {
+ writew(0x0, (SPI_DR_OFFSET+zx29spi->virtbase));
+ zx29spi->tx += (zx29spi->cur_chip->n_bytes);
+ cur_transfer_len -= zx29spi->cur_chip->n_bytes;
+ }
+
+ cpu_relax();
+ }
+}
+
+static void dma_callback(void *data)
+{
+ struct zx29_spi *zx29spi = (struct zx29_spi *)data;
+ //printk(KERN_INFO "spi:dma transfer complete. %X-%X-%x\n", zx29spi->dma_running, readl((SPI_INTR_SR_OFFSET+zx29spi->virtbase)),readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)));
+ /* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck start */
+ //up(&zx29spi->sema_dma);
+ if(zx29spi->master->slave == true){
+ wake_up(&zx29spi->wait);
+ zx29spi->trans_done = true;
+ }else{
+ up(&zx29spi->sema_dma);
+ }
+ /* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck end */
+}
+
+/*
+static void dma_callback_tx(void *data)
+{
+ struct zx29_spi *zx29spi = (struct zx29_spi *)data;
+ // printk(KERN_INFO "spi:dma transfer complete tx\n");
+ printk("%s",__func__);
+ printk("COM=0x%x,FMT=0x%x,FIFO_CTL=0x%x,FIFO_SR=0x%x\n",readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)),readl((SPI_FMT_CTRL_OFFSET+zx29spi->virtbase)),readl((SPI_FIFO_CTRL_OFFSET+zx29spi->virtbase)),readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)));
+
+ //up(&g_SpiTransferSemaphore);
+}
+*/
+
+/**
+ * configure_dma - configures the channels for the next transfer
+ * SSP driver's private data structure
+ */
+
+static int configure_dma(struct zx29_spi *zx29spi)
+{
+// unsigned int pages;
+// int ret;
+// int rx_sglen, tx_sglen;
+ dma_channel_def rx_conf;
+ dma_channel_def tx_conf;
+ struct dma_chan *rxchan = zx29spi->dma_rx_channel;
+ struct dma_chan *txchan = zx29spi->dma_tx_channel;
+ struct dma_async_tx_descriptor *rxdesc;
+ struct dma_async_tx_descriptor *txdesc;
+ struct spi_transfer *transfer = zx29spi->cur_transfer;
+
+ rx_conf.src_addr = (SPI_DR_OFFSET+zx29spi->phybase);
+ rx_conf.dest_addr = (unsigned int)zx29spi->rx;
+ rx_conf.dma_control.tran_mode = TRAN_PERI_TO_MEM;
+ rx_conf.dma_control.irq_mode = DMA_ALL_IRQ_ENABLE;
+ rx_conf.link_addr = 0;
+
+ tx_conf.src_addr = (unsigned int)zx29spi->tx;
+ tx_conf.dest_addr = (SPI_DR_OFFSET+zx29spi->phybase);
+ tx_conf.dma_control.tran_mode = TRAN_MEM_TO_PERI;
+ tx_conf.dma_control.irq_mode = DMA_ALL_IRQ_ENABLE;
+ tx_conf.link_addr = 0;
+
+
+ /* Check that the channels are available */
+ if (!rxchan || !txchan)
+ return -ENODEV;
+
+ /*
+ * If supplied, the DMA burstsize should equal the FIFO trigger level.
+ * Notice that the DMA engine uses one-to-one mapping. Since we can
+ * not trigger on 2 elements this needs explicit mapping rather than
+ * calculation.
+ */
+
+ switch (zx29spi->rx_lev_trig) {
+ case SPI_RX_1_OR_MORE_ELEM:
+ rx_conf.dma_control.src_burst_len = DMA_BURST_LEN_1;
+ rx_conf.dma_control.dest_burst_len = DMA_BURST_LEN_1;
+ break;
+ case SPI_RX_4_OR_MORE_ELEM:
+ rx_conf.dma_control.src_burst_len = DMA_BURST_LEN_4;
+ rx_conf.dma_control.dest_burst_len = DMA_BURST_LEN_4;
+ break;
+ case SPI_RX_8_OR_MORE_ELEM:
+ rx_conf.dma_control.src_burst_len = DMA_BURST_LEN_8;
+ rx_conf.dma_control.dest_burst_len = DMA_BURST_LEN_8;
+ break;
+ case SPI_RX_16_OR_MORE_ELEM:
+ rx_conf.dma_control.src_burst_len = DMA_BURST_LEN_16;
+ rx_conf.dma_control.dest_burst_len = DMA_BURST_LEN_16;
+ break;
+ case SPI_RX_32_OR_MORE_ELEM:
+ rx_conf.dma_control.src_burst_len = DMA_BURST_LEN_ALL;
+ rx_conf.dma_control.dest_burst_len = DMA_BURST_LEN_ALL;
+ break;
+ default:
+ rx_conf.dma_control.src_burst_len = zx29spi->vendor->fifodepth >> 1;
+ rx_conf.dma_control.dest_burst_len = zx29spi->vendor->fifodepth >> 1;
+ break;
+ }
+
+ switch (zx29spi->tx_lev_trig) {
+ case SPI_TX_1_OR_MORE_EMPTY_LOC:
+ tx_conf.dma_control.src_burst_len = DMA_BURST_LEN_1;
+ tx_conf.dma_control.dest_burst_len = DMA_BURST_LEN_1;
+ break;
+ case SPI_TX_4_OR_MORE_EMPTY_LOC:
+ tx_conf.dma_control.src_burst_len = DMA_BURST_LEN_4;
+ tx_conf.dma_control.dest_burst_len = DMA_BURST_LEN_4;
+ break;
+ case SPI_TX_8_OR_MORE_EMPTY_LOC:
+ tx_conf.dma_control.src_burst_len = DMA_BURST_LEN_8;
+ tx_conf.dma_control.dest_burst_len = DMA_BURST_LEN_8;
+ break;
+ case SPI_TX_16_OR_MORE_EMPTY_LOC:
+ tx_conf.dma_control.src_burst_len = DMA_BURST_LEN_16;
+ tx_conf.dma_control.dest_burst_len = DMA_BURST_LEN_16;
+ break;
+ case SPI_TX_32_OR_MORE_EMPTY_LOC:
+ tx_conf.dma_control.src_burst_len = DMA_BURST_LEN_ALL;
+ tx_conf.dma_control.dest_burst_len = DMA_BURST_LEN_ALL;
+ break;
+ default:
+ tx_conf.dma_control.src_burst_len = zx29spi->vendor->fifodepth >> 1;
+ tx_conf.dma_control.dest_burst_len = zx29spi->vendor->fifodepth >> 1;
+ break;
+ }
+
+ switch (zx29spi->read) {
+ case READING_NULL:
+ /* Use the same as for writing */
+ rx_conf.dma_control.src_burst_size = DMA_BURST_SIZE_8BIT;
+ rx_conf.dma_control.dest_burst_size = DMA_BURST_SIZE_8BIT;
+ rx_conf.count = zx29spi->cur_transfer->len;
+ break;
+ case READING_U8:
+ rx_conf.dma_control.src_burst_size = DMA_BURST_SIZE_8BIT;
+ rx_conf.dma_control.dest_burst_size = DMA_BURST_SIZE_8BIT;
+ rx_conf.count = zx29spi->cur_transfer->len;
+ break;
+ case READING_U16:
+ rx_conf.dma_control.src_burst_size = DMA_BURST_SIZE_16BIT;
+ rx_conf.dma_control.dest_burst_size = DMA_BURST_SIZE_16BIT;
+ rx_conf.count = zx29spi->cur_transfer->len;
+ break;
+ case READING_U32:
+ rx_conf.dma_control.src_burst_size = DMA_BURST_SIZE_32BIT;
+ rx_conf.dma_control.dest_burst_size = DMA_BURST_SIZE_32BIT;
+ rx_conf.count = zx29spi->cur_transfer->len;
+ break;
+ }
+
+ switch (zx29spi->write) {
+ case WRITING_NULL:
+ /* Use the same as for reading */
+ tx_conf.dma_control.src_burst_size = DMA_BURST_SIZE_8BIT;
+ tx_conf.dma_control.dest_burst_size = DMA_BURST_SIZE_8BIT;
+ tx_conf.count = zx29spi->cur_transfer->len;
+ break;
+ case WRITING_U8:
+ tx_conf.dma_control.src_burst_size = DMA_BURST_SIZE_8BIT;
+ tx_conf.dma_control.dest_burst_size = DMA_BURST_SIZE_8BIT;
+ tx_conf.count = zx29spi->cur_transfer->len;
+ break;
+ case WRITING_U16:
+ tx_conf.dma_control.src_burst_size = DMA_BURST_SIZE_16BIT;
+ tx_conf.dma_control.dest_burst_size = DMA_BURST_SIZE_16BIT;
+ tx_conf.count = zx29spi->cur_transfer->len;
+ break;
+ case WRITING_U32:
+ tx_conf.dma_control.src_burst_size = DMA_BURST_SIZE_32BIT;
+ tx_conf.dma_control.dest_burst_size = DMA_BURST_SIZE_32BIT;
+ tx_conf.count = zx29spi->cur_transfer->len;
+ break;
+ }
+
+ dmaengine_slave_config(rxchan,(struct dma_slave_config*)&rx_conf);
+ dmaengine_slave_config(txchan,(struct dma_slave_config*)&tx_conf);
+
+ /* Submit and fire RX and TX with TX last so we're ready to read! */
+ if (zx29spi->rx) {
+ //printk("%s,tx=%p,rx=%p,len=%d\n",__func__,zx29spi->tx,zx29spi->rx,zx29spi->cur_transfer->len);
+ //printk("tx_conf:sb_len=%d,db_len=%d, sb_size=%d,db_size=%d\n",tx_conf.dma_control.src_burst_len, tx_conf.dma_control.dest_burst_len, tx_conf.dma_control.src_burst_size, tx_conf.dma_control.dest_burst_size);
+ //printk("rx_conf:sb_len=%d,db_len=%d, sb_size=%d,db_size=%d\n",rx_conf.dma_control.src_burst_len, rx_conf.dma_control.dest_burst_len, rx_conf.dma_control.src_burst_size, rx_conf.dma_control.dest_burst_size);
+
+ rxdesc= rxchan->device->device_prep_interleaved_dma(rxchan,NULL,0);
+ txdesc= txchan->device->device_prep_interleaved_dma(txchan,NULL,0);
+ /* Put the callback on the RX transfer only, that should finish last */
+ rxdesc->callback = dma_callback;
+ rxdesc->callback_param = zx29spi;
+ // txdesc->callback = dma_callback_tx;
+ // txdesc->callback_param = zx29spi;
+
+ dmaengine_submit(rxdesc);
+ dma_async_issue_pending(rxchan);
+ if (transfer->tx_dma) {
+ /* SPI RX buffer may overflow in DMA busy situation. */
+ dmaengine_submit(txdesc);
+ dma_async_issue_pending(txchan);
+ zx29spi->dma_running = TX_TRANSFER | RX_TRANSFER;
+ enable_irq(zx29spi->irq); /* detect overflow through interrupt */
+ } else {
+ if(zx29spi->mode == ZX29_SSP_MASTER_TYPE)
+ zx29_fill_txfifo(zx29spi);
+ zx29spi->dma_running = RX_TRANSFER;
+ }
+ }
+ else if (zx29spi->tx){
+ txdesc = txchan->device->device_prep_interleaved_dma(txchan,NULL,0);
+ txdesc->callback = dma_callback;
+ txdesc->callback_param = zx29spi;
+ dmaengine_submit(txdesc);
+ dma_async_issue_pending(txchan);
+ zx29spi->dma_running = TX_TRANSFER;
+ }
+
+ return 0;
+}
+
+#if 0
+static bool zx29_dma_filter_fn(struct dma_chan *chan, void *param)
+{
+ dma_peripheral_id peri_id = (dma_peripheral_id) param;
+#if 0
+ if ((chan->chan_id == (unsigned int)peri_id) && \
+ (strcmp(dev_name(chan->device->dev), "a1200000.dma") == 0))
+ return true;
+
+ chan->private = param;
+
+ return false;
+#endif
+ if (chan->chan_id == (unsigned int)peri_id)
+ return true;
+
+ chan->private = param;
+
+ return false;
+
+}
+#endif
+extern bool zx29_dma_filter_fn(struct dma_chan *chan, void *param);
+static int zx29_dma_probe(struct zx29_spi *zx29spi)
+{
+ dma_cap_mask_t mask;
+
+ /* Try to acquire a generic DMA engine slave channel */
+ dma_cap_zero(mask);
+ dma_cap_set(DMA_SLAVE, mask);
+ /*
+ * We need both RX and TX channels to do DMA, else do none
+ * of them.
+ */
+ zx29spi->dma_rx_channel = dma_request_channel(mask,
+ zx29_dma_filter_fn,
+ zx29spi->master_info->dma_rx_param);
+ if (!zx29spi->dma_rx_channel) {
+ dev_dbg(&zx29spi->pdev->dev, "no RX DMA channel!\n");
+ dev_err(&zx29spi->pdev->dev, "no RX DMA channel!,dma_rx_param=:%d\n",zx29spi->master_info->dma_rx_param);
+ goto err_no_rxchan;
+ }
+
+ zx29spi->dma_tx_channel = dma_request_channel(mask,
+ zx29_dma_filter_fn,
+ zx29spi->master_info->dma_tx_param);
+ if (!zx29spi->dma_tx_channel) {
+ dev_dbg(&zx29spi->pdev->dev, "no TX DMA channel!\n");
+ dev_err(&zx29spi->pdev->dev, "no TX DMA channel!\n");
+ goto err_no_txchan;
+ }
+
+ zx29spi->dummypage = kmalloc(PAGE_SIZE, GFP_KERNEL);
+ if (!zx29spi->dummypage) {
+ dev_dbg(&zx29spi->pdev->dev, "no DMA dummypage!\n");
+ dev_err(&zx29spi->pdev->dev, "no DMA dummypage!\n");
+ goto err_no_dummypage;
+ }
+
+ dev_info(&zx29spi->pdev->dev, "setup for DMA on RX %s, TX %s\n",
+ dma_chan_name(zx29spi->dma_rx_channel),
+ dma_chan_name(zx29spi->dma_tx_channel));
+
+ return 0;
+
+err_no_dummypage:
+ dma_release_channel(zx29spi->dma_tx_channel);
+err_no_txchan:
+ dma_release_channel(zx29spi->dma_rx_channel);
+ zx29spi->dma_rx_channel = NULL;
+err_no_rxchan:
+ dev_err(&zx29spi->pdev->dev,
+ "Failed to work in dma mode, work without dma!\n");
+ dev_dbg(&zx29spi->pdev->dev,
+ "Failed to work in dma mode, work without dma!\n");
+ return -ENODEV;
+}
+
+static void terminate_dma(struct zx29_spi *zx29spi)
+{
+ struct dma_chan *rxchan = zx29spi->dma_rx_channel;
+ struct dma_chan *txchan = zx29spi->dma_tx_channel;
+
+ dmaengine_terminate_all(rxchan);
+ dmaengine_terminate_all(txchan);
+// unmap_free_dma_scatter(zx29spi);
+ zx29spi->dma_running = 0;
+}
+
+static void zx29_dma_remove(struct zx29_spi *zx29spi)
+{
+ if (zx29spi->dma_running)
+ terminate_dma(zx29spi);
+ if (zx29spi->dma_tx_channel)
+ dma_release_channel(zx29spi->dma_tx_channel);
+ if (zx29spi->dma_rx_channel)
+ dma_release_channel(zx29spi->dma_rx_channel);
+ kfree(zx29spi->dummypage);
+}
+
+#endif
+
+static irqreturn_t zx29_spi_irq(int irqno, void *dev_id)
+{
+ struct zx29_spi *zx29spi = dev_id;
+
+ disable_irq_nosync(zx29spi->irq);
+ up(&zx29spi->sema_dma);
+
+ //pr_info("spi_irq %X-%X\n", zx29spi->dma_running, readl((SPI_INTR_SR_OFFSET+zx29spi->virtbase)));
+ return IRQ_HANDLED;
+}
+
+static void print_info_data(void * data, int len) {
+ int i = 0;
+ unsigned char *p = data;
+
+ if(p) {
+
+ for(i = 0;i <= (len-8);i+=8) {
+ printk("%02x %02x %02x %02x %02x %02x %02x %02x \r\n",p[i],p[i+1],p[i+2],p[i+3],p[i+4],p[i+5],p[i+6],p[i+7]);
+ }
+ printk("\n");
+ }
+
+}
+
+static int zx29_flush_rxfifo(struct zx29_spi *zx29spi,void *buf)
+{
+ int ret = 0;
+ struct spi_transfer transfer;
+ unsigned char data[64] = {0};
+ uint32_t fifo_sr = 0;
+ uint32_t rd_max = 0;
+ uint32_t rx_fifo_cnt_msk= SPI_FIFO_SR_MASK_RX_FIFO_CNTR;
+
+ transfer.tx_buf = 0;
+ transfer.rx_buf = data;
+ transfer.len = 0;
+
+ fifo_sr = readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase));
+ if(!strcmp(zx29spi->pdev->name,"140a000.ssp")) {
+ rd_max = (fifo_sr & rx_fifo_cnt_msk) >> SPI_FIFO_SR_SHIFT_RX_CNT;
+ }else {
+ rd_max = (fifo_sr>>SPI_FIFO_SR_SHIFT_RX_CNT)&0x7f;
+ }
+ while(rd_max--) {
+ *(u8 *) transfer.rx_buf =
+ readw((SPI_DR_OFFSET+zx29spi->virtbase)) & 0xFFU;
+ transfer.rx_buf++;
+ transfer.len++;
+ }
+ memcpy(buf,data,transfer.len);
+ //dev_info(&zx29spi->pdev->dev,"spi_fifo_sr = %d transfer.len=%d \n",fifo_sr,transfer.len);
+ //print_info_data(data,transfer.len);
+ return transfer.len;
+
+}
+
+int get_spi_rx_fifo(struct spi_device *spi,unsigned char *buf)
+{
+
+ struct zx29_spi *zx29spi = spi_master_get_devdata(spi->master);
+ int ret = 0;
+
+ if(!spi || !buf || !zx29spi)
+ return ret;
+ if(!zx29spi->zx29_flush_rxfifo)
+ return ret;
+ return zx29spi->zx29_flush_rxfifo(zx29spi,buf);
+}
+
+
+void set_spi_timing(struct spi_device *spi,unsigned int param)
+{
+ struct zx29_spi *zx29spi = spi_master_get_devdata(spi->master);
+
+ printk("val set before: 0x%x \n",readl((SPI_TIMING_OFFSET+zx29spi->virtbase)));
+ writel(param, (SPI_TIMING_OFFSET+zx29spi->virtbase));
+ printk("val set after: 0x%x \n",readl((SPI_TIMING_OFFSET+zx29spi->virtbase)));
+}
+
+
+void slave_mode_set(struct spi_device *spi,unsigned int mode)
+{
+ unsigned int regval = 0;
+ ktime_t k_time_start = 0;
+ ktime_t diff_ns = 0;
+ struct zx29_spi *zx29spi = spi_master_get_devdata(spi->master);
+
+ regval = readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) & (~SPI_COM_CTRL_MASK_SSPE);
+ writel(regval, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+
+ regval = readl((SPI_FMT_CTRL_OFFSET+zx29spi->virtbase)) & (~(SPI_FMT_CTRL_MASK_POL|SPI_FMT_CTRL_MASK_PHA));
+ printk("val set before: 0x%x \n",regval);
+ switch(mode){
+ case 0:
+ break;
+ case 1:
+ regval |= SPI_FMT_CTRL_MASK_PHA;
+ break;
+ case 2:
+ regval |= SPI_FMT_CTRL_MASK_POL;
+ break;
+ case 3:
+ regval |= (SPI_FMT_CTRL_MASK_POL|SPI_FMT_CTRL_MASK_PHA);
+ break;
+ default:
+ break;
+ }
+ writel(regval, (SPI_FMT_CTRL_OFFSET+zx29spi->virtbase));
+
+ writel(readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) | SPI_COM_CTRL_MASK_SSPE, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+ //while(((readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase))>> 4)&0x1) == 0);
+ k_time_start = ktime_get();
+ do {
+ diff_ns = ktime_sub(ktime_get(),k_time_start);
+ regval = readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase))>> 4 & 0x1;
+ cpu_relax();
+ }
+ while (!regval && diff_ns < 100000000); //100ms
+ if(diff_ns >= 100000000)
+ dev_info(&zx29spi->pdev->dev, "wait sspe timeout, slave_mode_set failed! diff_ns= 0x%x \n",diff_ns);
+ else
+ printk("val set after: 0x%x \n",readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)));
+ return;
+}
+
+/* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck start */
+#define SSP0_PARA_BASE_ADDR 0x1400030
+#define SSP1_PARA_BASE_ADDR 0x1400048
+#define SSP_MASK_SW_WRST (0x1L << 9)
+#define SSP_MASK_SW_PRST (0x1L << 8)
+static int zx29_slave_ctrl_reset(struct zx29_spi *zx29spi)
+{
+ void __iomem *addr = NULL;
+ ktime_t k_time_start = 0;
+ ktime_t diff_ns = 0;
+ volatile unsigned int val = 0;
+
+ if(!strcmp(zx29spi->pdev->name,"1410000.ssp")) {
+ addr = ioremap(SSP1_PARA_BASE_ADDR, 0x1000);
+ }else{
+ addr = ioremap(SSP0_PARA_BASE_ADDR, 0x1000);
+ }
+
+ if(addr){
+ val = *(volatile unsigned int *)addr;
+ //dev_info(&zx29spi->pdev->dev, "val = 0x%x 0x%x\n",val,(~(SSP_MASK_SW_WRST|SSP_MASK_SW_PRST)));
+ *(volatile unsigned int *)addr = val & (~(SSP_MASK_SW_WRST|SSP_MASK_SW_PRST));
+
+ k_time_start = ktime_get();
+ do {
+ diff_ns = ktime_sub(ktime_get(),k_time_start);
+ val = readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase))>> 1 & 0x1;
+ cpu_relax();
+ }while(val && diff_ns < 100000000); //100ms
+
+ if(diff_ns >= 100000000)
+ dev_info(&zx29spi->pdev->dev, "zx29_slave_assert_ctrl failed!!! \n");
+ else
+ dev_info(&zx29spi->pdev->dev, "zx29_slave_assert_ctrl success! \n");
+
+
+ val = *(volatile unsigned int *)addr;
+ *(volatile unsigned int *)addr = val|(SSP_MASK_SW_WRST|SSP_MASK_SW_PRST);
+ udelay(500);
+
+ iounmap(addr);
+ }
+
+ return 0;
+}
+
+static int zx29_slave_ctrl_reinit(struct zx29_spi *zx29spi)
+{
+ volatile unsigned int regval;
+ ktime_t k_time_start = 0;
+ ktime_t diff_ns = 0;
+
+ zx29_slave_ctrl_reset(zx29spi);
+
+ /* Disable SPI */
+ regval = readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) & (~SPI_COM_CTRL_MASK_SSPE);
+ writel(regval, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+
+ load_spi_default_config(zx29spi);
+ writel(0, (SPI_TIMING_OFFSET + zx29spi->virtbase));
+
+ if(!strcmp(zx29spi->pdev->name,"1410000.ssp")) {
+ regval = readl((SPI_FMT_CTRL_OFFSET+zx29spi->virtbase))&(~(0x1<<12));
+ writel(regval, (SPI_FMT_CTRL_OFFSET+zx29spi->virtbase));
+ dev_info(&zx29spi->pdev->dev," %s set non-camera mode regval:0x%x \n",zx29spi->pdev->name,regval);
+ }
+
+ writel(readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) | SPI_COM_CTRL_MASK_SSPE, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+ k_time_start = ktime_get();
+ do{
+ diff_ns = ktime_sub(ktime_get(),k_time_start);
+ regval = ((readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase))>> 4)&0x1);
+ cpu_relax();
+ }while((regval == 0) && diff_ns < 100000000);
+
+ if(diff_ns >= 100000000)
+ dev_info(&zx29spi->pdev->dev, "wait sspen timeout!!! \n");
+ else
+ dev_info(&zx29spi->pdev->dev,"ssp enabled \n",regval);
+
+ return 0;
+}
+/* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck end */
+
+static int zx29_slave_do_interrupt_dma_transfer(struct zx29_spi *zx29spi)
+{
+ struct spi_transfer *transfer = zx29spi->cur_transfer;
+ int ret = 0;
+ ktime_t k_time_start = 0;
+ ktime_t diff_ns = 0;
+ unsigned int fifo_sr = 0;
+ if((void *)transfer->tx_dma != NULL){
+ zx29spi->tx = (void *)transfer->tx_dma;
+ zx29spi->tx_end = zx29spi->tx + zx29spi->cur_transfer->len;
+ }
+ if((void *)transfer->rx_dma != NULL){
+ zx29spi->rx = (void *)transfer->rx_dma;
+ zx29spi->rx_end = zx29spi->rx + zx29spi->cur_transfer->len;
+
+ /*if tx is null, use rx buffer as a dummy tx buffer.*/
+ if((void *)transfer->tx_dma == NULL){
+ zx29spi->tx = (void *)transfer->rx_dma;
+ zx29spi->tx_end = zx29spi->tx + zx29spi->cur_transfer->len;
+ }
+ }
+
+ zx29spi->write = zx29spi->tx ? zx29spi->cur_chip->write : WRITING_NULL;
+ zx29spi->read = zx29spi->rx ? zx29spi->cur_chip->read : READING_NULL;
+
+ /* If we're using DMA, set up DMA here */
+ if (zx29spi->cur_chip->enable_dma) {
+ /* Configure DMA transfer */
+ zx29spi->trans_done = false; //yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck
+ ret = configure_dma(zx29spi);
+ if (ret) {
+ dev_err(&zx29spi->pdev->dev, "configuration of DMA failed, fall back to interrupt mode\n");
+ goto err_config_dma;
+ }
+ }
+
+ if (zx29spi->cur_chip->enable_dma)
+ {
+ extern void spi_dev_send_dma_cfg_down(struct spi_device *spi);
+ struct spi_device *spi = zx29spi->cur_msg->spi;
+ spi_dev_send_dma_cfg_down(spi);
+ /* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck start */
+ //down(&zx29spi->sema_dma);
+ ret = wait_event_freezable(zx29spi->wait, zx29spi->trans_done);
+ if(ret){
+ terminate_dma(zx29spi);
+ disable_irq_nosync(zx29spi->irq);
+ zx29spi->dma_running = 0;
+ zx29_slave_ctrl_reinit(zx29spi);
+ goto err_config_dma;
+
+ }
+ /* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck end */
+ //printk("COM=0x%x,FMT=0x%x,FIFO_CTL=0x%x,FIFO_SR=0x%x\n",readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)),readl((SPI_FMT_CTRL_OFFSET+zx29spi->virtbase)),readl((SPI_FIFO_CTRL_OFFSET+zx29spi->virtbase)),readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)));
+
+
+ k_time_start = ktime_get();
+ do {
+ diff_ns = ktime_sub(ktime_get(),k_time_start);
+ fifo_sr = readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)) & SPI_FIFO_SR_MASK_BUSY;
+ cpu_relax();
+ }
+ while (fifo_sr && diff_ns < 100000000); //100ms
+
+ if(diff_ns >= 100000000) {
+ fifo_sr = readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)) & SPI_FIFO_SR_MASK_BUSY;
+ if(fifo_sr)
+ dev_info(&zx29spi->pdev->dev, "bus busy... time_start=%lld diff_ns=%lld \n",k_time_start,diff_ns);
+ }
+ if (zx29spi->dma_running == (TX_TRANSFER | RX_TRANSFER)) {
+ u32 intr_status;
+ intr_status = readl((SPI_INTR_SR_OFFSET+zx29spi->virtbase));
+ if (intr_status & SPI_INTR_SR_SCLR_MASK_RX_OVERRUN_INTR) {
+ terminate_dma(zx29spi);
+ dev_err(&zx29spi->cur_msg->spi->dev, "spi rx fifo overflow status = %X!!\n", intr_status);
+ ret = -EIO;
+ } else
+ disable_irq_nosync(zx29spi->irq);
+ }
+ zx29spi->dma_running = 0;
+ }
+
+err_config_dma:
+ if(ret)
+ {
+ dev_err(&zx29spi->pdev->dev, "down_interruptible, ret=%d\n",ret);
+ }
+ return ret;
+}
+
+
+static int zx29_do_interrupt_dma_transfer(struct zx29_spi *zx29spi)
+{
+ u32 irqflags = ENABLE_ALL_INTERRUPTS;
+ struct spi_transfer *transfer = zx29spi->cur_transfer;
+ int ret = 0;
+ static int sc_debug_info_record_cnt[4] ={0};
+ ktime_t k_time_start = 0;
+ ktime_t diff_ns = 0;
+ unsigned int fifo_sr = 0;
+
+ if((void *)transfer->tx_dma != NULL){
+ zx29spi->tx = (void *)transfer->tx_dma;
+ zx29spi->tx_end = zx29spi->tx + zx29spi->cur_transfer->len;
+ }
+ if((void *)transfer->rx_dma != NULL){
+ zx29spi->rx = (void *)transfer->rx_dma;
+ zx29spi->rx_end = zx29spi->rx + zx29spi->cur_transfer->len;
+
+ /*if tx is null, use rx buffer as a dummy tx buffer.*/
+ if((void *)transfer->tx_dma == NULL){
+ zx29spi->tx = (void *)transfer->rx_dma;
+ zx29spi->tx_end = zx29spi->tx + zx29spi->cur_transfer->len;
+ }
+ }
+
+ zx29spi->write = zx29spi->tx ? zx29spi->cur_chip->write : WRITING_NULL;
+ zx29spi->read = zx29spi->rx ? zx29spi->cur_chip->read : READING_NULL;
+ //printk("zx29spi->cur_chip->enable_dma= 0x%x transfer->tx_dma=0x%x transfer->rx_dma=0x%x\n",zx29spi->cur_chip->enable_dma,transfer->tx_dma,transfer->rx_dma);
+ /* If we're using DMA, set up DMA here */
+ if (zx29spi->cur_chip->enable_dma) {
+ /* Configure DMA transfer */
+ ret = configure_dma(zx29spi);
+ if (ret) {
+ dev_err(&zx29spi->pdev->dev, "configuration of DMA failed, fall back to interrupt mode\n");
+ goto err_config_dma;
+ }
+ /* Disable interrupts in DMA mode, IRQ from DMA controller */
+ irqflags = DISABLE_ALL_INTERRUPTS;
+ }
+
+ /* config interrupts */
+ /* writel(irqflags, (SPI_INTR_EN_OFFSET+zx29spi->virtbase)); //spi interrupt mode is not supported. */
+
+ /* Enable SSP, turn on interrupts */
+// writel(readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) | SPI_COM_CTRL_MASK_SSPE, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+
+ if (zx29spi->cur_chip->enable_dma)
+ {
+ ret = down_timeout(&zx29spi->sema_dma, msecs_to_jiffies(1500));
+ //printk("COM=0x%x,FMT=0x%x,FIFO_CTL=0x%x,FIFO_SR=0x%x\n",readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)),readl((SPI_FMT_CTRL_OFFSET+zx29spi->virtbase)),readl((SPI_FIFO_CTRL_OFFSET+zx29spi->virtbase)),readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)));
+ if (ret < 0) {
+ panic("spi transfer timeout,times(%d)\n",sc_debug_info_record_cnt[zx29spi->pdev->id]);
+ if(sc_debug_info_record_cnt[zx29spi->pdev->id] < 5) {
+ sc_debug_info_record(MODULE_ID_CAP_SPI, "%s transfer timeout:0x%x 0x%x 0x%x \n",zx29spi->pdev->name,readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)),
+ readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)),readl((SPI_INTR_SR_OFFSET+zx29spi->virtbase)));
+ }
+ sc_debug_info_record_cnt[zx29spi->pdev->id]++;
+ }
+
+ k_time_start = ktime_get();
+ do {
+ diff_ns = ktime_sub(ktime_get(),k_time_start);
+ fifo_sr = readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)) & SPI_FIFO_SR_MASK_BUSY;
+ cpu_relax();
+ }
+ while (fifo_sr && diff_ns < 100000000); //100ms
+
+ if(diff_ns >= 100000000) {
+ fifo_sr = readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)) & SPI_FIFO_SR_MASK_BUSY;
+ if(fifo_sr)
+ dev_info(&zx29spi->pdev->dev, "bus busy.... time_start=%lld diff_ns=%lld \n",k_time_start,diff_ns);
+ }
+
+ if (zx29spi->dma_running == (TX_TRANSFER | RX_TRANSFER)) {
+ u32 intr_status;
+ intr_status = readl((SPI_INTR_SR_OFFSET+zx29spi->virtbase));
+ if (intr_status & SPI_INTR_SR_SCLR_MASK_RX_OVERRUN_INTR) {
+ terminate_dma(zx29spi);
+ dev_err(&zx29spi->cur_msg->spi->dev, "spi rx fifo overflow status = %X!!\n", intr_status);
+ ret = -EIO;
+ } else
+ disable_irq_nosync(zx29spi->irq);
+ }
+ zx29spi->dma_running = 0;
+ }
+
+err_config_dma:
+ if(ret)
+ {
+ dev_err(&zx29spi->pdev->dev, "down_interruptible, ret=%d\n",ret);
+ }
+// writel(readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) & ~ SPI_COM_CTRL_MASK_SSPE, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+ return ret;
+}
+
+
+static int zx29_do_polling_transfer(struct zx29_spi *zx29spi)
+{
+ struct spi_transfer *transfer = zx29spi->cur_transfer;
+ int ret = 0;
+ unsigned int fifo_sr = 0;
+ ktime_t k_time_start = 0;
+ ktime_t diff_ns = 0;
+
+ dev_dbg(&zx29spi->pdev->dev, "polling transfer ongoing ...\n");
+
+ if (!zx29spi->tx && !zx29spi->rx) {
+ return ret;
+ }
+
+ k_time_start = ktime_get();
+ /*read and write*/
+ while ((zx29spi->tx < zx29spi->tx_end) || (zx29spi->rx < zx29spi->rx_end)) {
+ readwriter(zx29spi);
+ diff_ns = ktime_sub(ktime_get(),k_time_start);
+ if(diff_ns >= 1000000000) /*1s*/{
+ dev_info(&zx29spi->pdev->dev, "do_polling time out,diff_ns=%lld len=0x%x tx=0x%x tx_end=0x%x rx=0x%x rx_end=0x%x \n",
+ diff_ns,zx29spi->cur_transfer->len,zx29spi->tx,zx29spi->tx_end,zx29spi->rx,zx29spi->rx_end);
+ ret = -EIO;
+ break;
+ }
+ }
+
+ k_time_start = ktime_get();
+ do {
+ diff_ns = ktime_sub(ktime_get(),k_time_start);
+ fifo_sr = readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)) & SPI_FIFO_SR_MASK_BUSY;
+ cpu_relax();
+
+ }while (fifo_sr && diff_ns < 100000000); //100ms
+
+ if(diff_ns >= 100000000) {
+ fifo_sr = readl((SPI_FIFO_SR_OFFSET+zx29spi->virtbase)) & SPI_FIFO_SR_MASK_BUSY;
+ if(fifo_sr) {
+ dev_info(&zx29spi->pdev->dev, "bus busy.. time_start=%lld diff_ns=%lld \n",k_time_start,diff_ns);
+ ret = -EIO;
+ }
+ }
+ return ret;
+}
+
+static int zx29_spi_map_mssg(struct zx29_spi *zx29spi,
+ struct spi_message *msg)
+{
+ struct device *dev;
+ struct spi_transfer *transfer;
+ int ret = 0;
+ static int sc_debug_info_record_tx_cnt[4] ={0};
+ static int sc_debug_info_record_rx_cnt[4] ={0};
+
+ if(!zx29spi || !msg)
+ return -EFAULT;
+
+ if (msg->is_dma_mapped || !msg->spi->dma_used || !zx29spi->master_info->enable_dma) {
+ return 0;
+ }
+ dev = &zx29spi->pdev->dev;
+ /* Map until end or first fail */
+ list_for_each_entry(transfer, &msg->transfers, transfer_list) {
+
+ if (/*transfer->len <= zx29spi->vendor->fifodepth ||*/ transfer->tx_dma || transfer->rx_dma )
+ continue;
+
+ if (transfer->tx_buf != NULL) {
+ transfer->tx_dma = dma_map_single(dev,(void *)transfer->tx_buf, transfer->len, DMA_TO_DEVICE);
+ if (dma_mapping_error(dev, transfer->tx_dma)) {
+ dev_err(dev, "dma_map_single spi Tx failed,times(%d)\n",sc_debug_info_record_tx_cnt[zx29spi->pdev->id]);
+ if(sc_debug_info_record_tx_cnt[zx29spi->pdev->id] < 5)
+ sc_debug_info_record(MODULE_ID_CAP_SPI, "%s tx_dma_map failed \n",zx29spi->pdev->name);
+ transfer->tx_dma = 0;
+ ret |= -ENOMEM;
+ sc_debug_info_record_tx_cnt[zx29spi->pdev->id]++;
+ }
+ }
+
+ if (transfer->rx_buf != NULL) {
+ transfer->rx_dma = dma_map_single(dev, transfer->rx_buf, transfer->len, DMA_FROM_DEVICE);
+ if (dma_mapping_error(dev, transfer->rx_dma)) {
+ dev_err(dev, "dma_map_single spi Rx failed,times(%d)\n",sc_debug_info_record_rx_cnt[zx29spi->pdev->id]);
+ if(sc_debug_info_record_rx_cnt[zx29spi->pdev->id] < 5)
+ sc_debug_info_record(MODULE_ID_CAP_SPI, "%s rx_dma_map failed \n",zx29spi->pdev->name);
+ transfer->rx_dma = 0;
+ ret |= -ENOMEM;
+ sc_debug_info_record_rx_cnt[zx29spi->pdev->id]++;
+ }
+
+ if (!transfer->rx_dma && transfer->tx_dma && transfer->tx_buf) {
+ dma_unmap_single(dev, transfer->tx_dma, transfer->len, DMA_TO_DEVICE);
+ transfer->tx_dma = 0;
+ }
+ }
+ }
+
+
+ return ret;
+}
+
+static void zx29_spi_unmap_mssg(struct zx29_spi *zx29spi,
+ struct spi_message *msg)
+{
+ struct device *dev = &zx29spi->pdev->dev;
+ struct spi_transfer *transfer;
+
+ if (msg->is_dma_mapped || !msg->spi->dma_used || !zx29spi->master_info->enable_dma)
+ return;
+
+ list_for_each_entry(transfer, &msg->transfers, transfer_list) {
+
+ if ( (!transfer->tx_buf && transfer->tx_dma) || (! transfer->rx_buf && transfer->rx_dma) )
+ continue;
+
+ if (transfer->rx_buf != NULL && transfer->rx_dma)
+ dma_unmap_single(dev, transfer->rx_dma, transfer->len, DMA_FROM_DEVICE);
+
+ if (transfer->tx_buf != NULL && transfer->tx_dma)
+ dma_unmap_single(dev, transfer->tx_dma, transfer->len, DMA_TO_DEVICE);
+ }
+}
+
+static int zx29_slave_transfer_one_message(struct spi_master *master,
+ struct spi_message *msg)
+{
+ struct zx29_spi *zx29spi = spi_master_get_devdata(master);
+ struct spi_device *spi = msg->spi;
+ struct spi_transfer *transfer;
+ unsigned cs_change = 1;
+ const int nsecs = 100;
+ int ret = 0;
+
+ zx29spi->cur_msg = msg;
+
+ /* Setup the SPI using the per chip configuration */
+ zx29spi->cur_chip = spi_get_ctldata(msg->spi);
+ ret = zx29_spi_map_mssg(zx29spi, msg);
+ /* continue with polling mode */
+ if(ret){
+ dev_info(&zx29spi->pdev->dev, "ret = %d\n",ret);
+ goto out;
+ }
+ //restore_state(zx29spi);
+ list_for_each_entry(transfer, &msg->transfers, transfer_list) {
+
+ zx29spi->cur_transfer = transfer;
+ if((void *)transfer->tx_buf != NULL){
+ zx29spi->tx = (void *)transfer->tx_buf;
+ zx29spi->tx_end = zx29spi->tx + zx29spi->cur_transfer->len;
+ }
+ else
+ zx29spi->tx = zx29spi->tx_end = NULL;
+
+ if((void *)transfer->rx_buf != NULL){
+ zx29spi->rx = (void *)transfer->rx_buf;
+ zx29spi->rx_end = zx29spi->rx + zx29spi->cur_transfer->len;
+#if 0
+ /*if tx is null, use rx buffer as a dummy tx buffer.*/
+ if((void *)transfer->tx_buf == NULL){
+ zx29spi->tx = (void *)transfer->rx_buf;
+ zx29spi->tx_end = zx29spi->tx + zx29spi->cur_transfer->len;
+ }
+#endif
+ }
+ else
+ zx29spi->rx = zx29spi->rx_end = NULL;
+
+ zx29spi->write = zx29spi->tx ? zx29spi->cur_chip->write : WRITING_NULL;
+ zx29spi->read = zx29spi->rx ? zx29spi->cur_chip->read : READING_NULL;
+
+ if (/*transfer->rx_buf || */transfer->rx_dma)
+ flush(zx29spi);
+
+ writel(CLEAR_ALL_INTERRUPTS, (SPI_INTR_SR_OFFSET+zx29spi->virtbase));
+
+ if (zx29spi->cur_chip->xfer_type == POLLING_TRANSFER || (!transfer->tx_dma && !transfer->rx_dma)) {
+ if (zx29spi->tx < zx29spi->tx_end)
+ zx29spi->cur_transfer->len = writer(zx29spi);
+ if(zx29spi->rx < zx29spi->rx_end)
+ zx29spi->cur_transfer->len = reader(zx29spi);
+#if defined(CONFIG_DEBUG_FS)
+ zx29spi->spi_poll_cnt ++;
+#endif
+ } else {
+ struct chip_data *chip = zx29spi->cur_chip;
+ if (transfer->rx_buf || transfer->rx_dma) {
+ writel((chip->fifo_ctrl | (SPI_FIFO_CTRL_MASK_RX_DMA_EN | SPI_FIFO_CTRL_MASK_TX_DMA_EN)),
+ (SPI_FIFO_CTRL_OFFSET+zx29spi->virtbase));
+ } else {
+ writel((chip->fifo_ctrl | SPI_FIFO_CTRL_MASK_TX_DMA_EN), (SPI_FIFO_CTRL_OFFSET+zx29spi->virtbase));
+ }
+ ret = zx29_slave_do_interrupt_dma_transfer(zx29spi);
+#if defined(CONFIG_DEBUG_FS)
+ zx29spi->spi_dma_cnt ++;
+#endif
+
+ /* clear TX/RX DMA Enable */
+ writel(chip->fifo_ctrl, (SPI_FIFO_CTRL_OFFSET+zx29spi->virtbase));
+ }
+
+ if (ret) {
+ pr_info("ssp:transfer error,transfer=%p\n", transfer);
+ break;
+ }
+
+ /* Update total byte transferred */
+ msg->actual_length += zx29spi->cur_transfer->len;
+
+ if (transfer->delay_usecs)
+ udelay(transfer->delay_usecs);
+ }
+out:
+ zx29_spi_unmap_mssg(zx29spi, msg);
+ msg->status = ret;
+ spi_finalize_current_message(master);
+
+#if SPI_PSM_CONTROL
+ zx29_spi_set_idle(&zx29spi->psm_lock);
+#endif
+
+ return ret;
+}
+
+static int zx29_transfer_one_message(struct spi_master *master,
+ struct spi_message *msg)
+{
+ struct zx29_spi *zx29spi = spi_master_get_devdata(master);
+ struct spi_device *spi = msg->spi;
+ struct spi_transfer *transfer;
+ unsigned cs_change = 1;
+ const int nsecs = 100;
+ int ret = 0;
+ ktime_t k_time_start = 0;
+ ktime_t diff_ns = 0;
+ unsigned int reg_val = 0;
+
+ pm_stay_awake(&zx29spi->pdev->dev);
+ //printk(KERN_INFO "ssp:in function %s \n", __FUNCTION__);
+#if SPI_PSM_CONTROL
+ zx29_spi_set_active(&zx29spi->psm_lock);
+#endif
+ //mutex_lock(&zx29spi->spi_lock);
+ //printk(KERN_INFO "ssp:lock \n");
+ /* Initial message state */
+ zx29spi->cur_msg = msg;
+ /* Setup the SPI using the per chip configuration */
+ zx29spi->cur_chip = spi_get_ctldata(msg->spi);
+
+ if ((clk_get_rate(zx29spi->spi_clk) / 2) != spi->max_speed_hz) {
+ clk_set_rate(zx29spi->spi_clk, spi->max_speed_hz * 2);
+ }
+
+ restore_state(zx29spi);
+
+ ret = zx29_spi_map_mssg(zx29spi, msg);
+ /* continue with polling mode */
+ if(ret){
+ dev_info(&zx29spi->pdev->dev, "ret = %d\n",ret);
+ goto out;
+ }
+
+
+ //while (readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) & SPI_COM_CTRL_MASK_SSPE_BACK);
+ k_time_start = ktime_get();
+ do {
+ diff_ns = ktime_sub(ktime_get(),k_time_start);
+ reg_val = readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) & SPI_COM_CTRL_MASK_SSPE_BACK;
+ cpu_relax();
+ }
+ while (reg_val && diff_ns < 100000000); //100ms
+
+ if(diff_ns >= 100000000) {
+ reg_val = readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) & SPI_COM_CTRL_MASK_SSPE_BACK;
+ if(reg_val) {
+ dev_info(&zx29spi->pdev->dev, "wait sspe back time_out diff_ns=%lld \n",diff_ns);
+ goto out;
+ }
+ }
+
+ writel(readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) | SPI_COM_CTRL_MASK_SSPE, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+
+ list_for_each_entry(transfer, &msg->transfers, transfer_list) {
+
+ zx29spi->cur_transfer = transfer;
+ //if (transfer->bits_per_word || transfer->speed_hz)
+ // dev_warn(&msg->spi->dev, "ignore bits & speed setting in transfer.");
+
+ if((void *)transfer->tx_buf != NULL){
+ zx29spi->tx = (void *)transfer->tx_buf;
+ zx29spi->tx_end = zx29spi->tx + zx29spi->cur_transfer->len;
+ }
+ else
+ zx29spi->tx = zx29spi->tx_end = NULL;
+
+ if((void *)transfer->rx_buf != NULL){
+ zx29spi->rx = (void *)transfer->rx_buf;
+ zx29spi->rx_end = zx29spi->rx + zx29spi->cur_transfer->len;
+
+ /*if tx is null, use rx buffer as a dummy tx buffer.*/
+ if((void *)transfer->tx_buf == NULL){
+ zx29spi->tx = (void *)transfer->rx_buf;
+ zx29spi->tx_end = zx29spi->tx + zx29spi->cur_transfer->len;
+ }
+ }
+ else
+ zx29spi->rx = zx29spi->rx_end = NULL;
+
+ zx29spi->write = zx29spi->tx ? zx29spi->cur_chip->write : WRITING_NULL;
+ zx29spi->read = zx29spi->rx ? zx29spi->cur_chip->read : READING_NULL;
+
+ if (transfer->rx_buf || transfer->rx_dma)
+ flush(zx29spi);
+
+ writel(CLEAR_ALL_INTERRUPTS, (SPI_INTR_SR_OFFSET+zx29spi->virtbase));
+ if (cs_change) {
+ zx29spi->cur_chip->cs_control(zx29spi->pdev->id,ZX29_CS_ACTIVE);
+ }
+
+ cs_change = transfer->cs_change;
+
+ if (zx29spi->cur_chip->xfer_type == POLLING_TRANSFER || (!transfer->tx_dma && !transfer->rx_dma)) {
+
+ ret = zx29_do_polling_transfer(zx29spi);
+ #if defined(CONFIG_DEBUG_FS)
+ zx29spi->spi_poll_cnt ++;
+ #endif
+ } else {
+ struct chip_data *chip = zx29spi->cur_chip;
+
+ if (transfer->rx_buf || transfer->rx_dma) {
+ writel((chip->fifo_ctrl | (SPI_FIFO_CTRL_MASK_RX_DMA_EN | SPI_FIFO_CTRL_MASK_TX_DMA_EN)),
+ (SPI_FIFO_CTRL_OFFSET+zx29spi->virtbase));
+ } else {
+ writel((chip->fifo_ctrl | SPI_FIFO_CTRL_MASK_TX_DMA_EN), (SPI_FIFO_CTRL_OFFSET+zx29spi->virtbase));
+ }
+
+ ret = zx29_do_interrupt_dma_transfer(zx29spi);
+ #if defined(CONFIG_DEBUG_FS)
+ zx29spi->spi_dma_cnt ++;
+ #endif
+
+ /* clear TX/RX DMA Enable */
+ writel(chip->fifo_ctrl, (SPI_FIFO_CTRL_OFFSET+zx29spi->virtbase));
+ }
+
+ if (ret) {
+ pr_info("ssp:transfer error,transfer=%p\n", transfer);
+ break;
+ }
+
+ /* Update total byte transferred */
+ msg->actual_length += zx29spi->cur_transfer->len;
+
+ if (transfer->delay_usecs)
+ udelay(transfer->delay_usecs);
+
+ if (cs_change) {
+ zx29spi->cur_chip->cs_control(zx29spi->pdev->id,ZX29_CS_INACTIVE);
+ ndelay(nsecs);
+ }
+ }
+ if (ret || !cs_change) {
+ zx29spi->cur_chip->cs_control(zx29spi->pdev->id,ZX29_CS_INACTIVE);
+ }
+ //while (~ readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) & SPI_COM_CTRL_MASK_SSPE_BACK);
+ k_time_start = ktime_get();
+ do {
+ diff_ns = ktime_sub(ktime_get(),k_time_start);
+ reg_val = readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) & SPI_COM_CTRL_MASK_SSPE_BACK;
+ cpu_relax();
+ }
+ while (!reg_val && diff_ns < 100000000); //100ms
+
+ if(diff_ns >= 100000000) {
+ reg_val = readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) & SPI_COM_CTRL_MASK_SSPE_BACK;
+ if(!reg_val) {
+ dev_info(&zx29spi->pdev->dev, "wait sspe back time_out diff_ns=%lld \n",diff_ns);
+ goto out;
+ }
+ }
+ writel(readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) & ~ SPI_COM_CTRL_MASK_SSPE, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+
+out:
+ zx29_spi_unmap_mssg(zx29spi, msg);
+ //mutex_unlock(&zx29spi->spi_lock);
+ //printk(KERN_INFO "ssp:unlock \n");
+
+ msg->status = ret;
+ spi_finalize_current_message(master);
+
+#if SPI_PSM_CONTROL
+ zx29_spi_set_idle(&zx29spi->psm_lock);
+#endif
+ pm_relax(&zx29spi->pdev->dev);
+ return ret;
+}
+
+/* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme start */
+#define SPI_SLVAE_RX_BUFF_SIZE 4096
+#define SPI_SLVAE_RX_MAX_PACK_NUM 15
+#define SPI_SLVAE_RX_PACK_LEN 146
+#define SPI_SLVAE_RX_LIST_BUFF_LEN (SPI_SLVAE_RX_MAX_PACK_NUM*SPI_SLVAE_RX_PACK_LEN)
+static dma_channel_def slave_rx_conf[SPI_SLVAE_RX_MAX_PACK_NUM] = {0};
+//yu.dong@20240617 [T106BUG-641] SPI packet loss issue, increase kernel buffer and read all cached data away, no data loss.
+#define SPI_MAGIC 0x55555555
+static bool rxbuf_is_free_space(struct spi_device *spi)
+{
+ if (spi->recv_pos < spi->rd_pos) {
+ if ((spi->rd_pos - spi->recv_pos) > SPI_SLVAE_RX_PACK_LEN)
+ return 1;
+ else
+ return 0;
+ }
+ else {
+ if ((SPI_SLVAE_RX_BUFF_SIZE - spi->recv_pos + spi->rd_pos ) > SPI_SLVAE_RX_PACK_LEN)
+ return 1;
+ else
+ return 0;
+ }
+}
+
+/* yu.dong@20240617 [T106BUG-641] SPI packet loss issue, increase kernel buffer and read all cached data away, no data loss start */
+static void dma_cyclic_callback(void *data)
+{
+ struct spi_device *spi = (struct spi_device *)data;
+ struct zx29_spi *zx29spi = NULL;
+ int index = 0;
+ unsigned int end = 0;
+
+ zx29spi = spi_master_get_devdata(spi->master);
+ zx29spi->spi_poll_cnt++;
+ end = *(volatile unsigned int *)(spi->cyc_buf +spi->cyc_index * SPI_SLVAE_RX_PACK_LEN + SPI_SLVAE_RX_PACK_LEN - 4);
+ while((end != SPI_MAGIC) && index < SPI_SLVAE_RX_MAX_PACK_NUM) {
+ if(!rxbuf_is_free_space(spi)) {
+ printk("rx_buff not enough space!!!!!");
+ zx29spi->spi_dma_cnt++;
+ break;
+ }else {
+ if((spi->recv_pos + SPI_SLVAE_RX_PACK_LEN) <= SPI_SLVAE_RX_BUFF_SIZE) {
+ memcpy(spi->rx_buf + spi->recv_pos,spi->cyc_buf + spi->cyc_index * SPI_SLVAE_RX_PACK_LEN,SPI_SLVAE_RX_PACK_LEN);
+ }else {
+ memcpy(spi->rx_buf + spi->recv_pos,spi->cyc_buf + spi->cyc_index * SPI_SLVAE_RX_PACK_LEN,SPI_SLVAE_RX_BUFF_SIZE - spi->recv_pos);
+ memcpy(spi->rx_buf,spi->cyc_buf + spi->cyc_index * SPI_SLVAE_RX_PACK_LEN + (SPI_SLVAE_RX_BUFF_SIZE - spi->recv_pos),SPI_SLVAE_RX_PACK_LEN-(SPI_SLVAE_RX_BUFF_SIZE-spi->recv_pos));
+ }
+ *(volatile unsigned int *)(spi->cyc_buf +spi->cyc_index * SPI_SLVAE_RX_PACK_LEN + SPI_SLVAE_RX_PACK_LEN - 4) = SPI_MAGIC;
+ spi->recv_pos = (spi->recv_pos + SPI_SLVAE_RX_PACK_LEN)%SPI_SLVAE_RX_BUFF_SIZE;
+ spi->cyc_index = (spi->cyc_index + 1)%SPI_SLVAE_RX_MAX_PACK_NUM;
+
+ zx29spi->spi_dma_cnt++;
+ index++;
+ end = *(volatile unsigned int *)(spi->cyc_buf +spi->cyc_index * SPI_SLVAE_RX_PACK_LEN + SPI_SLVAE_RX_PACK_LEN - 4);
+ }
+
+ if(spi->is_rd_waiting == true && spi->recv_done == 0) {
+ wake_up(&spi->rd_wait);
+ spi->recv_done = 1;
+ }
+ }
+ if((end != SPI_MAGIC) && index == SPI_SLVAE_RX_MAX_PACK_NUM)
+ printk("cyc_buf be covered!!!!!");
+ return;
+}
+/* yu.dong@20240617 [T106BUG-641] SPI packet loss issue, increase kernel buffer and read all cached data away, no data loss end */
+
+static int zx29_slave_config_dma(struct zx29_spi *zx29spi,struct spi_device *spi)
+{
+ struct chip_data *chip = NULL;
+ struct dma_chan *rxchan = NULL;
+ struct dma_async_tx_descriptor *rxdesc;
+ unsigned short transfer_len = SPI_SLVAE_RX_PACK_LEN;
+ int i;
+
+ chip = zx29spi->cur_chip = spi->controller_state;
+
+ if (spi->rx_dma)
+ flush(zx29spi);
+ writel(CLEAR_ALL_INTERRUPTS, (SPI_INTR_SR_OFFSET+zx29spi->virtbase));
+ writel((chip->fifo_ctrl | SPI_FIFO_CTRL_MASK_RX_DMA_EN), (SPI_FIFO_CTRL_OFFSET+zx29spi->virtbase));
+
+ zx29spi->write = zx29spi->tx ? zx29spi->cur_chip->write : WRITING_NULL;
+ zx29spi->read = zx29spi->rx ? zx29spi->cur_chip->read : READING_NULL;
+ rxchan = zx29spi->dma_rx_channel;
+ /* Check that the channels are available */
+ if (!rxchan)
+ return -ENODEV;
+
+ /*
+ * If supplied, the DMA burstsize should equal the FIFO trigger level.
+ * Notice that the DMA engine uses one-to-one mapping. Since we can
+ * not trigger on 2 elements this needs explicit mapping rather than
+ * calculation.
+ */
+ for(i = 0;i < SPI_SLVAE_RX_MAX_PACK_NUM;i++) {
+ switch (zx29spi->rx_lev_trig) {
+ case SPI_RX_1_OR_MORE_ELEM:
+ slave_rx_conf[i].dma_control.src_burst_len = DMA_BURST_LEN_1;
+ slave_rx_conf[i].dma_control.dest_burst_len = DMA_BURST_LEN_1;
+ break;
+ case SPI_RX_4_OR_MORE_ELEM:
+ slave_rx_conf[i].dma_control.src_burst_len = DMA_BURST_LEN_4;
+ slave_rx_conf[i].dma_control.dest_burst_len = DMA_BURST_LEN_4;
+ break;
+ case SPI_RX_8_OR_MORE_ELEM:
+ slave_rx_conf[i].dma_control.src_burst_len = DMA_BURST_LEN_8;
+ slave_rx_conf[i].dma_control.dest_burst_len = DMA_BURST_LEN_8;
+ break;
+ case SPI_RX_16_OR_MORE_ELEM:
+ slave_rx_conf[i].dma_control.src_burst_len = DMA_BURST_LEN_16;
+ slave_rx_conf[i].dma_control.dest_burst_len = DMA_BURST_LEN_16;
+ break;
+ case SPI_RX_32_OR_MORE_ELEM:
+ slave_rx_conf[i].dma_control.src_burst_len = DMA_BURST_LEN_ALL;
+ slave_rx_conf[i].dma_control.dest_burst_len = DMA_BURST_LEN_ALL;
+ break;
+ default:
+ slave_rx_conf[i].dma_control.src_burst_len = zx29spi->vendor->fifodepth >> 1;
+ slave_rx_conf[i].dma_control.dest_burst_len = zx29spi->vendor->fifodepth >> 1;
+ break;
+ }
+
+ switch (zx29spi->read) {
+ case READING_NULL:
+ /* Use the same as for writing */
+ slave_rx_conf[i].dma_control.src_burst_size = DMA_BURST_SIZE_8BIT;
+ slave_rx_conf[i].dma_control.dest_burst_size = DMA_BURST_SIZE_8BIT;
+ slave_rx_conf[i].count = transfer_len;
+ break;
+ case READING_U8:
+ slave_rx_conf[i].dma_control.src_burst_size = DMA_BURST_SIZE_8BIT;
+ slave_rx_conf[i].dma_control.dest_burst_size = DMA_BURST_SIZE_8BIT;
+ slave_rx_conf[i].count = transfer_len;
+ break;
+ case READING_U16:
+ slave_rx_conf[i].dma_control.src_burst_size = DMA_BURST_SIZE_16BIT;
+ slave_rx_conf[i].dma_control.dest_burst_size = DMA_BURST_SIZE_16BIT;
+ slave_rx_conf[i].count = transfer_len;
+ break;
+ case READING_U32:
+ slave_rx_conf[i].dma_control.src_burst_size = DMA_BURST_SIZE_32BIT;
+ slave_rx_conf[i].dma_control.dest_burst_size = DMA_BURST_SIZE_32BIT;
+ slave_rx_conf[i].count = transfer_len;
+ break;
+ }
+
+ slave_rx_conf[i].src_addr = (SPI_DR_OFFSET+zx29spi->phybase);
+ slave_rx_conf[i].dma_control.tran_mode = TRAN_PERI_TO_MEM;
+ slave_rx_conf[i].dma_control.irq_mode = DMA_ALL_IRQ_ENABLE;
+ slave_rx_conf[i].dest_addr = (unsigned int)spi->rx_dma + transfer_len*i;
+ slave_rx_conf[i].link_addr = 1;
+ //yu.dong@20240617 [T106BUG-641] SPI packet loss issue, increase kernel buffer and read all cached data away, no data loss.
+ *(volatile unsigned int *)(spi->cyc_buf + transfer_len*i + transfer_len -4) = SPI_MAGIC;
+ }
+
+ dmaengine_slave_config(rxchan,(struct dma_slave_config*)&slave_rx_conf[0]);
+
+ /* Submit and fire RX and TX with TX last so we're ready to read! */
+ if (spi->rx_dma) {
+ rxdesc = rxchan->device->device_prep_dma_cyclic(rxchan,NULL,SPI_SLVAE_RX_MAX_PACK_NUM * SPI_SLVAE_RX_PACK_LEN, SPI_SLVAE_RX_PACK_LEN,0,0);
+ if (!rxdesc) {
+ printk(KERN_INFO "!!ERROR DESC !!![%s][%d]\n",__func__,__LINE__);
+ dmaengine_terminate_all(rxchan);
+ return -EBUSY;
+ }
+ /* Put the callback on the RX transfer only, that should finish last */
+ rxdesc->callback = dma_cyclic_callback;
+ rxdesc->callback_param = spi;
+ dmaengine_submit(rxdesc);
+ dma_async_issue_pending(rxchan);
+ zx29spi->dma_running = RX_TRANSFER;
+ }
+ return 0;
+}
+
+static int zx29_slave_rd_start(struct spi_device *spi)
+{
+ struct zx29_spi *zx29spi = NULL;
+ struct device *dev;
+ int status = 0;
+ static int wd_wait_queue_init = 0;
+
+ printk("zx29_slave_rd_start...\r\n");
+
+ zx29spi = spi_master_get_devdata(spi->master);
+ dev = &zx29spi->pdev->dev;
+ if (!zx29spi)
+ return -EINVAL;
+
+ spi->cyc_index = 0;
+ spi->rd_pos = spi->recv_pos = 0;
+
+ spi->cyc_buf = dma_alloc_coherent(dev, SPI_SLVAE_RX_BUFF_SIZE, &spi->rx_dma, GFP_KERNEL);
+ if (dma_mapping_error(dev, spi->rx_dma)) {
+ dev_err(dev, "dma_map_single spi rx failed\n");
+ return -ENOMEM;
+ }
+
+ if(wd_wait_queue_init == 0) {
+ init_waitqueue_head(&spi->rd_wait);
+ spi->recv_done = false;
+ spi->is_rd_waiting = false;
+ wd_wait_queue_init = 1;
+ }
+ status = zx29_slave_config_dma(zx29spi,spi);
+
+ return status;
+}
+
+static int zx29_slave_rd_stop(struct spi_device *spi)
+{
+ struct zx29_spi *zx29spi = NULL;
+ struct device *dev;
+ int status = 0;
+ struct chip_data *chip = NULL;
+ struct dma_chan *rxchan = NULL;
+
+ zx29spi = spi_master_get_devdata(spi->master);
+ dev = &zx29spi->pdev->dev;
+ if (!zx29spi)
+ return -EINVAL;
+
+ chip = zx29spi->cur_chip= spi->controller_state;
+ writel(chip->fifo_ctrl, (SPI_FIFO_CTRL_OFFSET+zx29spi->virtbase));
+ rxchan = zx29spi->dma_rx_channel;
+ /* Submit and fire RX and TX with TX last so we're ready to read! */
+ if(spi->rx_dma) {
+ dmaengine_terminate_all(rxchan);
+ zx29spi->dma_running = 0;
+ }
+
+ if(spi->cyc_buf != NULL && spi->rx_dma) {
+ dma_free_coherent(dev, SPI_SLVAE_RX_BUFF_SIZE, spi->cyc_buf, spi->rx_dma);
+ spi->cyc_buf = NULL;
+ }
+
+ spi->cyc_index = 0;
+ spi->rd_pos = spi->recv_pos = 0;
+ spi->recv_done = false;
+ spi->is_rd_waiting = false;
+ printk("zx29_slave_rd_stop...\r\n");
+
+ return status;
+}
+/* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme end */
+
+static int zx29_prepare_transfer_hardware(struct spi_master *master)
+{
+
+ return 0;
+}
+
+static int zx29_unprepare_transfer_hardware(struct spi_master *master)
+{
+ //struct zx29_spi *zx29spi = spi_master_get_devdata(master);
+
+ //dev_warn(&zx29spi->pdev->dev,"in function %s\n", __FUNCTION__);
+
+ /* nothing more to do - disable spi/ssp and power off */
+ //writel(readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) & ~ SPI_COM_CTRL_MASK_SSPE, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+
+ return 0;
+}
+
+static int verify_controller_parameters(struct zx29_spi *zx29spi,
+ struct spi_config_chip const *chip_info)
+{
+ if ((chip_info->iface < SPI_INTERFACE_MOTOROLA_SPI)
+ || (chip_info->iface > SPI_INTERFACE_ISI_SPI)) {
+ dev_err(&zx29spi->pdev->dev,
+ "interface is configured incorrectly\n");
+ return -EINVAL;
+ }
+
+ if ((chip_info->hierarchy != SPI_MASTER)
+ && (chip_info->hierarchy != SPI_SLAVE)) {
+ dev_err(&zx29spi->pdev->dev,
+ "hierarchy is configured incorrectly\n");
+ return -EINVAL;
+ }
+ if ((chip_info->com_mode != INTERRUPT_TRANSFER)
+ && (chip_info->com_mode != DMA_TRANSFER)
+ && (chip_info->com_mode != POLLING_TRANSFER)) {
+ dev_err(&zx29spi->pdev->dev,
+ "Communication mode is configured incorrectly\n");
+ return -EINVAL;
+ }
+ switch (chip_info->rx_lev_trig) {
+ case SPI_RX_1_OR_MORE_ELEM:
+ case SPI_RX_4_OR_MORE_ELEM:
+ case SPI_RX_8_OR_MORE_ELEM:
+ /* These are always OK, all variants can handle this */
+ break;
+ case SPI_RX_16_OR_MORE_ELEM:
+ if (zx29spi->vendor->fifodepth < 16) {
+ dev_err(&zx29spi->pdev->dev,
+ "RX FIFO Trigger Level is configured incorrectly\n");
+ return -EINVAL;
+ }
+ break;
+ case SPI_RX_32_OR_MORE_ELEM:
+ if (zx29spi->vendor->fifodepth < 32) {
+ dev_err(&zx29spi->pdev->dev,
+ "RX FIFO Trigger Level is configured incorrectly\n");
+ return -EINVAL;
+ }
+ break;
+ default:
+ dev_err(&zx29spi->pdev->dev,
+ "RX FIFO Trigger Level is configured incorrectly\n");
+ return -EINVAL;
+ break;
+ }
+ switch (chip_info->tx_lev_trig) {
+ case SPI_TX_1_OR_MORE_EMPTY_LOC:
+ case SPI_TX_4_OR_MORE_EMPTY_LOC:
+ case SPI_TX_8_OR_MORE_EMPTY_LOC:
+ /* These are always OK, all variants can handle this */
+ break;
+ case SPI_TX_16_OR_MORE_EMPTY_LOC:
+ if (zx29spi->vendor->fifodepth < 16) {
+ dev_err(&zx29spi->pdev->dev,
+ "TX FIFO Trigger Level is configured incorrectly\n");
+ return -EINVAL;
+ }
+ break;
+ case SPI_TX_32_OR_MORE_EMPTY_LOC:
+ if (zx29spi->vendor->fifodepth < 32) {
+ dev_err(&zx29spi->pdev->dev,
+ "TX FIFO Trigger Level is configured incorrectly\n");
+ return -EINVAL;
+ }
+ break;
+ default:
+ dev_err(&zx29spi->pdev->dev,
+ "TX FIFO Trigger Level is configured incorrectly\n");
+ return -EINVAL;
+ break;
+ }
+
+ return 0;
+}
+
+static struct vendor_data vendor_arm = {
+ .fifodepth = 16,
+ .max_bpw = 32,
+ .loopback = true,
+};
+
+/*
+ * A piece of default chip info unless the platform
+ * supplies it.
+ */
+static const struct spi_config_chip spi_default_chip_info = {
+ .com_mode = DMA_TRANSFER,//INTERRUPT_TRANSFER,//POLLING_TRANSFER,
+ .iface = SPI_INTERFACE_MOTOROLA_SPI,
+ .hierarchy = SPI_MASTER,
+ .slave_tx_disable = DO_NOT_DRIVE_TX,
+ .rx_lev_trig = SPI_RX_4_OR_MORE_ELEM,
+ .tx_lev_trig = SPI_TX_4_OR_MORE_EMPTY_LOC,
+// .ctrl_len = SSP_BITS_8,
+// .wait_state = SSP_MWIRE_WAIT_ZERO,
+// .duplex = SSP_MICROWIRE_CHANNEL_FULL_DUPLEX,
+// .cs_control = default_cs_control,
+};
+
+/*
+
+*/
+static void spi_set_gpio_function(int dev_id)
+{
+ if (pinctrl_select_state(ssp_pins[dev_id].pctrl, ssp_pins[dev_id].pfunc) < 0) {
+ printk("spi%d setting spi pin ctrl failed\n",dev_id);
+ }
+ return;
+}
+static void spi_set_gpio_gpio(int dev_id)
+{
+ if (pinctrl_select_state(ssp_pins[dev_id].pctrl, ssp_pins[dev_id].pgpio) < 0) {
+ printk("spi%d setting spi pin ctrl failed\n",dev_id);
+ }
+ return;
+}
+
+
+static void spi_set_gpio_val(int gpio_num, int val)
+{
+ //zx29_gpio_output_data(gpio_num, val);
+ gpio_set_value(gpio_num,val);
+
+}
+
+static int spi_get_gpio_val(int gpio_num)
+{
+ //zx29_gpio_set_direction(gpio,GPIO_IN);
+
+ return gpio_get_value(gpio_num);
+}
+
+static void spi_time_delay(int delay/*us*/)
+{
+ udelay(delay);
+}
+
+void spi_fun_mode_stop(int dev_id)
+{
+ spi_set_gpio_gpio(dev_id);
+}
+
+void spi_gpio_mode_start(int dev_id)
+{
+ //mutex_lock(&g_zx29_spi->spi_lock); //spi control function mutex.
+ /* set clk tx rx cs to gpio */
+ //spi_set_gpio_gpio(dev_id);
+ gpio_direction_output(ssp_pins[dev_id].gpio_cs,SPI_GPIO_HIGH);
+ gpio_direction_output(ssp_pins[dev_id].gpio_clk,SPI_GPIO_LOW);
+ gpio_direction_output(ssp_pins[dev_id].gpio_tx,0);//value ?
+ gpio_direction_input(ssp_pins[dev_id].gpio_rx);
+
+ return ;
+}
+EXPORT_SYMBOL(spi_gpio_mode_start);
+void spi_gpio_mode_stop(int dev_id)
+{
+ /* set clk tx rx cs to function */
+ spi_set_gpio_function(dev_id);
+ //mutex_unlock(&g_zx29_spi->spi_lock); //spi control function mutex.
+}
+EXPORT_SYMBOL(spi_gpio_mode_stop);
+
+void spi_gpio_write_single8(int dev_id,unsigned char data)
+{
+ int i;
+
+ //printk("spi_gpio_write_single8 %x\n", data);
+
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_clk, SPI_GPIO_HIGH);
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_cs, SPI_GPIO_LOW);/* CS invail*/
+
+ for( i=7; i>=0; i-- )
+ {
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_clk, SPI_GPIO_LOW);
+ if ((data >> i) & 0x1)
+ {
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_tx, SPI_GPIO_HIGH);
+ }
+ else
+ {
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_tx, SPI_GPIO_LOW);
+ }
+ spi_time_delay(1);
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_clk, SPI_GPIO_HIGH);
+ spi_time_delay(1);
+ }
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_cs, SPI_GPIO_HIGH);
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_tx, SPI_GPIO_LOW);
+
+}
+EXPORT_SYMBOL(spi_gpio_write_single8);
+/*******************************************************************************
+ * Function:
+ * Description:
+ * Parameters:
+ * Input:
+ *
+ * Output:
+ *
+ * Returns:
+ *
+ *
+ * Others:
+ ********************************************************************************/
+unsigned char spi_gpio_read_single8(int dev_id)
+{
+ int i;
+ unsigned char readData = 0;
+
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_clk, SPI_GPIO_HIGH);
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_cs, SPI_GPIO_LOW);/* CS */
+
+ for( i=7; i>=0; i-- )
+ {
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_clk, SPI_GPIO_LOW);
+ spi_time_delay(1);
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_clk, SPI_GPIO_HIGH);
+ if( spi_get_gpio_val(ssp_pins[dev_id].gpio_rx) )/* lcd tx rx */
+ {
+ readData |= (1 << i);
+ }
+ spi_time_delay(1);
+ }
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_cs, SPI_GPIO_HIGH);
+
+ //printk("spi_gpio_read_single8 %x\n", readData);
+ return readData;
+}
+EXPORT_SYMBOL(spi_gpio_read_single8);
+
+/**
+ * @brief spi gpio mode, cs control
+ *
+ * This function used for lcd 3-wires spi mode.
+ * before cs pull down, spi pads will change to gpio mode.
+ * after cs pull high, spi pads gpio mode recovery to spi mode.
+ *
+ * @param level 0: cs line pull down, no-zero: cs line pull up.
+ *
+ * @retval none
+ */
+void spi_gpio_3wire_cs(int dev_id,unsigned char level)
+{
+ if(level){
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_cs,SPI_GPIO_HIGH);
+ gpio_direction_input(ssp_pins[dev_id].gpio_tx);
+
+ /* zx29_gpio_function_sel(GPIO_AP_SPI0_CS, GPIO_AP_SPI0_CS_FUN); */
+ //zx29_gpio_function_sel(GPIO_AP_SPI0_CLK, GPIO_AP_SPI0_CLK_FUN);
+ //zx29_gpio_function_sel(GPIO_AP_SPI0_TXD, GPIO_AP_SPI0_TXD_FUN);
+
+ //mutex_unlock(&g_zx29_spi->spi_lock); //spi control function mutex.
+ }
+ else{
+ //mutex_lock(&g_zx29_spi->spi_lock);
+
+ /* zx29_gpio_function_sel(GPIO_AP_SPI0_CS, GPIO_AP_CS_GPIO_FUN); */
+ //zx29_gpio_function_sel(GPIO_AP_SPI0_CLK, GPIO_AP_CLK_GPIO_FUN);
+ //zx29_gpio_function_sel(GPIO_AP_SPI0_TXD, GPIO_AP_TXD_GPIO_FUN);
+
+ gpio_direction_output(ssp_pins[dev_id].gpio_cs,SPI_GPIO_LOW);
+ gpio_direction_output(ssp_pins[dev_id].gpio_clk,SPI_GPIO_LOW);
+ gpio_direction_output(ssp_pins[dev_id].gpio_tx,SPI_GPIO_LOW);
+
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_clk,SPI_GPIO_LOW);
+ spi_set_gpio_val(ssp_pins[dev_id].gpio_cs,SPI_GPIO_LOW);
+ }
+}
+EXPORT_SYMBOL(spi_gpio_3wire_cs);
+
+/**
+ * @brief spi gpio mode, one byte write.
+ *
+ * This function used for lcd 3-wires spi mode.
+ * txd line used tx function and rx function at different time.
+ *
+ * @param reg one byte write data.
+ *
+ * @retval none
+ */
+void spi_gpio_3wire_write8(int dev_id,unsigned char reg)
+{
+ int i;
+ //unsigned char readData = 0;
+
+ //write
+ spi_time_delay(50);
+ for (i = 0; i < 8; i++)
+ {
+ gpio_set_value(ssp_pins[dev_id].gpio_clk, SPI_GPIO_LOW);
+ spi_time_delay(50);
+
+ if ((reg & 0x80)==0x80)
+ {
+ gpio_set_value(ssp_pins[dev_id].gpio_tx, SPI_GPIO_HIGH);
+ }
+ else
+ {
+ gpio_set_value(ssp_pins[dev_id].gpio_tx, SPI_GPIO_LOW);
+ }
+ spi_time_delay(50);
+
+ gpio_set_value(ssp_pins[dev_id].gpio_clk, SPI_GPIO_HIGH);
+ spi_time_delay(50);
+
+ reg <<= 1;
+ }
+ //spi_time_delay(50);
+}
+EXPORT_SYMBOL(spi_gpio_3wire_write8);
+
+/**
+ * @brief spi gpio mode, one byte read.
+ *
+ * This function used for lcd 3-wires spi mode.
+ * txd line used tx function and rx function at different time.
+ *
+ * @param none.
+ *
+ * @retval one byte readed data.
+ */
+unsigned char spi_gpio_3wire_read8(int dev_id)
+{
+ int i;
+ unsigned char readData = 0;
+ //read
+ gpio_direction_input(ssp_pins[dev_id].gpio_tx);
+ spi_time_delay(50);
+
+ readData = 0;
+ for (i = 0; i < 8; i++)
+ {
+ readData <<= 1;
+ gpio_set_value(ssp_pins[dev_id].gpio_clk, SPI_GPIO_LOW);
+ spi_time_delay(50);
+
+ if (SPI_GPIO_HIGH == gpio_get_value(ssp_pins[dev_id].gpio_tx))
+ {
+ readData |= 0x01;
+ }
+
+ gpio_set_value(ssp_pins[dev_id].gpio_clk, SPI_GPIO_HIGH);
+ spi_time_delay(50);
+ }
+ //spi_time_delay(50);
+
+ //printk("spi_gpio_read_single8 %x\n", readData);
+ return readData;
+}
+EXPORT_SYMBOL(spi_gpio_3wire_read8);
+
+
+static void zx29_setup_to_regs(struct chip_data *chip,struct zx29_spi *zx29spi)
+{
+ unsigned int regval = 0;
+ ktime_t k_time_start = 0;
+ ktime_t k_time_end = 0;
+ ktime_t diff_ns = 0;
+ /* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme start */
+ regval = readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) & (~SPI_COM_CTRL_MASK_SSPE);
+ writel(regval, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+
+ writel(chip->fmt_ctrl, (SPI_FMT_CTRL_OFFSET+zx29spi->virtbase));
+ //writel(chip->fifo_ctrl, (SPI_FIFO_CTRL_OFFSET+zx29spi->virtbase));
+ /* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme end */
+ writel(chip->com_ctrl, (SPI_COM_CTRL_OFFSET + zx29spi->virtbase));
+ //writel(chip->timing, (SPI_TIMING_OFFSET + zx29spi->virtbase));
+
+ writel(readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) | SPI_COM_CTRL_MASK_SSPE, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+
+ //while(((readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase))>> 4)&0x1) == 0);
+ k_time_start = ktime_get();
+ do {
+ regval = readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) & SPI_COM_CTRL_MASK_SSPE_BACK;
+ diff_ns = ktime_sub(ktime_get(),k_time_start);
+ cpu_relax();
+ }
+ while (!regval && diff_ns < 10000000);
+
+ if(diff_ns >= 10000000) {
+ dev_info(&zx29spi->pdev->dev, " zx29_setup_to_regs failed! diff_ns=%lld \n",diff_ns);
+ }
+
+}
+/**
+ * zx29_setup - setup function registered to SPI master framework
+ * @spi: spi device which is requesting setup
+ *
+ * This function is registered to the SPI framework for this SPI master
+ * controller. If it is the first time when setup is called by this device,
+ * this function will initialize the runtime state for this chip and save
+ * the same in the device structure. Else it will update the runtime info
+ * with the updated chip info. Nothing is really being written to the
+ * controller hardware here, that is not done until the actual transfer
+ * commence.
+ */
+static int zx29_setup(struct spi_device *spi)
+{
+ struct spi_config_chip const *chip_info;
+ struct chip_data *chip;
+ unsigned speed_hz;
+ int status = 0;
+ struct zx29_spi *zx29spi = NULL;
+ unsigned int bits =0;
+ u8 iface = 0;
+ u32 tmp;
+
+ if (!spi)
+ return -EINVAL;
+ bits = spi->bits_per_word;
+ zx29spi = spi_master_get_devdata(spi->master);
+ if (!zx29spi)
+ return -EINVAL;
+ iface = zx29spi->iface_mode;
+
+ /* Get controller_state if one is supplied */
+ chip = spi_get_ctldata(spi);
+
+ if (chip == NULL) {
+ chip = kzalloc(sizeof(struct chip_data), GFP_KERNEL);
+ if (!chip) {
+ dev_err(&spi->dev, "cannot allocate controller state\n");
+ return -ENOMEM;
+ }
+ dev_dbg(&spi->dev, "allocated memory for controller's runtime state\n");
+ }
+
+ /* Get controller data if one is supplied */
+ chip_info = spi->controller_data;
+
+ if (chip_info == NULL) {
+ chip_info = &spi_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");
+
+ /*
+ * We can override with custom divisors, else we use the board
+ * frequency setting
+ */
+
+ /* set spi clock source at 104MHz/1 */
+ //writel(chip ->clk_div-1, M0_SSP_CLKDIV_REG_VA);
+ speed_hz = spi->max_speed_hz;
+// clk_set_rate(zx29spi->spi_clk, speed_hz * 2); /* f(ssp_clk) = 2*f(ssp_sclk_out) */
+ spi->max_speed_hz = clk_round_rate(zx29spi->spi_clk, speed_hz * 2) / 2;
+
+ if (spi->max_speed_hz != speed_hz)
+ dev_dbg(&spi->dev, "round speed %dHz differs from requested %dHz.", spi->max_speed_hz, speed_hz);
+
+ status = verify_controller_parameters(zx29spi, chip_info);
+ if (status) {
+ dev_err(&spi->dev, "controller data is incorrect");
+ goto err_config_params;
+ }
+
+ zx29spi->rx_lev_trig = chip_info->rx_lev_trig;
+ zx29spi->tx_lev_trig = chip_info->tx_lev_trig;
+
+ /* Now set controller state based on controller data */
+ //chip->xfer_type = chip_info->com_mode;
+ chip->xfer_type = spi->dma_used ? DMA_TRANSFER : POLLING_TRANSFER;
+ dev_dbg(&spi->dev, "chip->xfer_type = 0x%x \n",chip->xfer_type);
+
+ if (!chip_info->cs_control) {
+ chip->cs_control = default_cs_control;
+
+ if (spi->master->num_chipselect != 1)
+ dev_err(&spi->dev, "chip select function is NULL!\n");
+ } else
+ chip->cs_control = chip_info->cs_control;
+
+ /* Check bits per word with vendor specific range */
+ if ((bits <= 3) || (bits > zx29spi->vendor->max_bpw)) {
+ 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",
+ zx29spi->vendor->max_bpw);
+ goto err_config_params;
+ } else if (bits <= 8) {
+ dev_dbg(&spi->dev, "4 <= n <=8 bits per word\n");
+ chip->n_bytes = 1;
+ chip->read = READING_U8;
+ chip->write = WRITING_U8;
+ } else if (bits <= 16) {
+ dev_dbg(&spi->dev, "9 <= n <= 16 bits per word\n");
+ chip->n_bytes = 2;
+ 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;
+ }
+
+ /* Now Initialize all register settings required for this chip */
+ chip->com_ctrl = 0;
+ chip->fmt_ctrl = 0;
+ chip->fifo_ctrl = 0;
+ chip->timing = 0;
+
+ if ((chip->xfer_type == DMA_TRANSFER)
+ && ((zx29spi->master_info)->enable_dma)) {
+ chip->enable_dma = true;
+ dev_dbg(&spi->dev, "DMA mode set in controller state\n");
+ } else {
+ chip->enable_dma = false;
+ dev_dbg(&spi->dev, "DMA mode NOT set in controller state\n");
+ }
+ SPI_WRITE_BITS(chip->fifo_ctrl, SPI_DMA_DISABLED, SPI_FIFO_CTRL_MASK_RX_DMA_EN, 2);
+ SPI_WRITE_BITS(chip->fifo_ctrl, SPI_DMA_DISABLED, SPI_FIFO_CTRL_MASK_TX_DMA_EN, 3);
+
+ if (zx29spi->rx_lev_trig == SPI_RX_8_OR_MORE_ELEM)
+ SPI_WRITE_BITS(chip->fifo_ctrl, SPI_FIFO_THRES_8, SPI_FIFO_CTRL_MASK_RX_FIFO_THRES, 4);
+ else
+ SPI_WRITE_BITS(chip->fifo_ctrl, SPI_FIFO_THRES_4, SPI_FIFO_CTRL_MASK_RX_FIFO_THRES, 4);
+ if (zx29spi->tx_lev_trig == SPI_TX_8_OR_MORE_EMPTY_LOC)
+ SPI_WRITE_BITS(chip->fifo_ctrl, SPI_FIFO_THRES_8, SPI_FIFO_CTRL_MASK_TX_FIFO_THRES, 8);
+ else
+ SPI_WRITE_BITS(chip->fifo_ctrl, SPI_FIFO_THRES_4, SPI_FIFO_CTRL_MASK_TX_FIFO_THRES, 8);
+
+ SPI_WRITE_BITS(chip->fmt_ctrl, bits - 1, SPI_FMT_CTRL_MASK_DSS, 4);
+ SPI_WRITE_BITS(chip->fmt_ctrl, chip_info->iface, SPI_FMT_CTRL_MASK_FRF, 0);
+
+ if((iface== SPI_TI_FORMAT)||(iface== SPI_ISI_FORMAT)){
+ printk("qhf %s set iface = %d\n",__func__,iface);
+ SPI_WRITE_BITS(chip->fmt_ctrl, iface, SPI_FMT_CTRL_MASK_FRF, 0);
+ }
+ /* Stuff that is common for all versions */
+ if (spi->mode & SPI_CPOL)
+ tmp = SPI_CLK_POL_IDLE_HIGH;
+ else
+ tmp = SPI_CLK_POL_IDLE_LOW;
+ SPI_WRITE_BITS(chip->fmt_ctrl, tmp, SPI_FMT_CTRL_MASK_POL, 2);
+
+ if (spi->mode & SPI_CPHA)
+ tmp = SPI_CLK_SECOND_EDGE;
+ else
+ tmp = SPI_CLK_FIRST_EDGE;
+
+ SPI_WRITE_BITS(chip->fmt_ctrl, tmp, SPI_FMT_CTRL_MASK_PHA, 3);
+
+ /* Loopback is available on all versions except PL023 */
+ if (zx29spi->vendor->loopback) {
+ if (spi->mode & SPI_LOOP)
+ tmp = LOOPBACK_ENABLED;
+ else
+ tmp = LOOPBACK_DISABLED;
+ SPI_WRITE_BITS(chip->com_ctrl, tmp, SPI_COM_CTRL_MASK_LBM, 0);
+ }
+// SPI_WRITE_BITS(chip->com_ctrl, SPI_ENABLED, SPI_COM_CTRL_MASK_SSPE, 1);
+ SPI_WRITE_BITS(chip->com_ctrl, chip_info->hierarchy, SPI_COM_CTRL_MASK_MS, 2);
+// SPI_WRITE_BITS(chip->com_ctrl, chip_info->slave_tx_disable, SPI_COM_CTRL_MASK_SOD, 3);
+
+ if(spi->trans_gaped) {
+ chip->enable_trans_gap = true;
+ }
+ SPI_WRITE_BITS(chip->timing, spi->trans_gap_num, SPI_TIMING_MASK_T_CS_DESEL, 0);
+ /* Save controller_state */
+ spi_set_ctldata(spi, chip);
+ if(zx29spi->mode == ZX29_SSP_SLAVE_TYPE) {
+
+ SPI_WRITE_BITS(chip->com_ctrl, SPI_SLAVE_MODE, SPI_COM_CTRL_MASK_MS, 2);
+ zx29_setup_to_regs(chip,zx29spi);
+ }
+
+ //yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme.
+
+ return status;
+ err_config_params:
+ spi_set_ctldata(spi, NULL);
+ kfree(chip);
+ return status;
+}
+
+/**
+ * zx29_cleanup - cleanup function registered to SPI master framework
+ * @spi: spi device which is requesting cleanup
+ *
+ * This function is registered to the SPI framework for this SPI master
+ * controller. It will free the runtime state of chip.
+ */
+static void zx29_cleanup(struct spi_device *spi)
+{
+ struct chip_data *chip = spi_get_ctldata(spi);
+
+ spi_set_ctldata(spi, NULL);
+ kfree(chip);
+}
+
+static int zx29_spi_clock_init(struct zx29_spi *zx29spi)
+{
+ int status = 0;
+ struct platform_device *pdev = zx29spi->pdev;
+ /* work clock */
+ zx29spi->spi_clk = devm_clk_get(&pdev->dev, "work_clk");
+ if (IS_ERR(zx29spi->spi_clk)) {
+ status = PTR_ERR(zx29spi->spi_clk);
+ dev_err(&pdev->dev, "could not retrieve SPI work clock\n");
+ return status;
+ }
+
+ /* enable spiclk at function zx29_setup */
+
+ if (device_property_read_u32(&pdev->dev, "clock-frequency", &zx29spi->clkfreq))
+ zx29spi->clkfreq = SPI_SPICLK_FREQ_26M;
+ status = clk_set_rate(zx29spi->spi_clk, zx29spi->clkfreq);
+ if(status) {
+ dev_err(&pdev->dev,"clc_set_rate err status=%d \n",status);
+ return status;
+ }
+ /* enable ssp clock source */
+ clk_prepare_enable(zx29spi->spi_clk);
+
+ /* apb clock */
+ zx29spi->pclk = devm_clk_get(&pdev->dev, "apb_clk");
+ if (IS_ERR(zx29spi->pclk)) {
+ status = PTR_ERR(zx29spi->pclk);
+ dev_err(&pdev->dev, "could not retrieve SPI work clock\n");
+ return status;
+ }
+ clk_prepare_enable(zx29spi->pclk);
+
+ return status;
+}
+
+static void spicc_clkgate_ctrl(struct zx29_spi *zx29spi,unsigned char is_enable)
+{
+ if (is_enable) {
+ clk_enable(zx29spi->spi_clk);
+ clk_enable(zx29spi->pclk);
+ } else {
+ clk_disable(zx29spi->spi_clk);
+ clk_disable(zx29spi->pclk);
+ }
+}
+
+static int zx29_spi_slave_clock_init(struct zx29_spi *zx29spi)
+{
+ int status=0;
+ struct platform_device *pdev = zx29spi->pdev;
+ /* work clock */
+ zx29spi->spi_clk = devm_clk_get(&pdev->dev, "work_clk");
+ if (IS_ERR(zx29spi->spi_clk)) {
+ status = PTR_ERR(zx29spi->spi_clk);
+ dev_err(&pdev->dev, "could not retrieve SPI work clock\n");
+ return status;
+ }
+
+ /* enable spiclk at function zx29_setup */
+ //if (device_property_read_u32(&pdev->dev, "clock-frequency", &zx29spi->clkfreq))
+ zx29spi->clkfreq = SPI_SPICLK_FREQ_156M; /*salve */
+
+ status = clk_set_rate(zx29spi->spi_clk, zx29spi->clkfreq);
+ if(status) {
+ dev_err(&pdev->dev,"clc_set_rate err status=%d \n",status);
+ return status;
+ }
+ /* enable ssp clock source */
+ clk_prepare_enable(zx29spi->spi_clk);
+
+ /* apb clock */
+ zx29spi->pclk = devm_clk_get(&pdev->dev, "apb_clk");
+ if (IS_ERR(zx29spi->pclk)) {
+ status = PTR_ERR(zx29spi->pclk);
+ dev_err(&pdev->dev, "could not retrieve SPI work clock\n");
+ return status;
+ }
+ clk_prepare_enable(zx29spi->pclk);
+ spicc_clkgate_ctrl(zx29spi,true);
+
+ return status;
+}
+
+
+static int zx29_spi_init_pinctrl(struct platform_device *pdev)
+{
+ struct pinctrl *pctrl;
+ enum of_gpio_flags flags;
+ int ret;
+ struct zx29_spi *zx29spi = NULL;
+
+ if(!pdev) {
+ printk("pdev not exist \n");
+ return -1;
+ }
+ zx29spi = (struct zx29_spi *)platform_get_drvdata(pdev);
+ if (IS_ERR(zx29spi)) {
+ dev_warn(&pdev->dev, "Failed to get zx29->ssp%d pins",pdev->id);
+ pctrl = NULL;
+ return 0;
+ }
+
+ pctrl = devm_pinctrl_get(&pdev->dev);
+ if (IS_ERR(pctrl)) {
+ dev_warn(&pdev->dev, "Failed to get zx29->ssp%d pins",pdev->id);
+ pctrl = NULL;
+ return 0;
+ }
+ ssp_pins[pdev->id].pctrl=pctrl;
+
+ ssp_pins[pdev->id].pcs_gpio_active = pinctrl_lookup_state(pctrl, "cs_gpio_active");
+ if (IS_ERR(ssp_pins[pdev->id].pcs_gpio_active)) {
+ dev_err(&pdev->dev, "missing cs_gpio_active \n");
+ }
+
+ ssp_pins[pdev->id].pcs_gpio_sleep = pinctrl_lookup_state(pctrl, "cs_gpio_sleep");
+ if (IS_ERR(ssp_pins[pdev->id].pcs_gpio_sleep)) {
+ dev_err(&pdev->dev, "missing cs_gpio_sleep \n");
+ }
+ ssp_pins[pdev->id].pcs_func = pinctrl_lookup_state(ssp_pins[pdev->id].pctrl, "cs_func");
+ if (IS_ERR(ssp_pins[pdev->id].pcs_func)) {
+ dev_err(&pdev->dev, "missing cs_func \n");
+ }
+
+ if(zx29spi->master->slave == false) {
+ if (pinctrl_select_state(ssp_pins[pdev->id].pctrl, ssp_pins[pdev->id].pcs_gpio_active) < 0) {
+ printk("spi%d setting cs_gpio pin ctrl failed\n",pdev->id);
+ }
+ }else {
+ if (pinctrl_select_state(ssp_pins[pdev->id].pctrl, ssp_pins[pdev->id].pcs_func) < 0) {
+ printk("spi%d setting cs_func pin ctrl failed\n",pdev->id);
+ }
+ }
+
+ ssp_pins[pdev->id].gpio_cs = of_get_gpio_flags(pdev->dev.of_node, 0, &flags);
+ if (!gpio_is_valid(ssp_pins[pdev->id].gpio_cs)) {
+ pr_info("ssp%d gpio_cs no found\n",pdev->id);
+ }
+
+ ssp_pins[pdev->id].gpio_clk = of_get_gpio_flags(pdev->dev.of_node, 1, &flags);
+ if (!gpio_is_valid(ssp_pins[pdev->id].gpio_clk)) {
+ pr_info("ssp%d gpio_clk no found\n",pdev->id);
+ }
+ ssp_pins[pdev->id].gpio_tx = of_get_gpio_flags(pdev->dev.of_node, 2, &flags);
+ if (!gpio_is_valid(ssp_pins[pdev->id].gpio_tx)) {
+ pr_info("ssp%d gpio_tx no found\n",pdev->id);
+ }
+
+ ssp_pins[pdev->id].gpio_rx = of_get_gpio_flags(pdev->dev.of_node, 3, &flags);
+ if (!gpio_is_valid(ssp_pins[pdev->id].gpio_rx)) {
+ pr_info("ssp%d gpio_rx no found\n",pdev->id);
+ }
+
+ if(zx29spi->master->slave == false)
+ gpio_direction_output(ssp_pins[pdev->id].gpio_cs,SPI_GPIO_HIGH);
+
+ return 0;
+}
+static void zx29_spi_get_platformInfo(struct platform_device *pdev,struct zx29_spi_controller *platform_info)
+{
+ struct device *dev=&pdev->dev;
+ u32 dma_tx,dma_rx,enable_dma;
+
+
+ if (device_property_read_u16(dev, "bus_id", &platform_info->bus_id)) {
+ platform_info->bus_id = pdev->id;
+ }
+ if (device_property_read_u8(dev, "num_chipselect", &platform_info->num_chipselect)) {
+ platform_info->num_chipselect = 1;
+ }
+#if 0
+ if (device_property_read_u32(dev, "enable_dma",&enable_dma)) {
+ dev_err(&pdev->dev,"enable_dma get failed");
+ platform_info->enable_dma = 0;
+ }
+ else {
+ platform_info->enable_dma = enable_dma;
+ }
+#endif
+ if (device_property_read_u32(dev, "autosuspend_delay", &platform_info->autosuspend_delay))
+ platform_info->autosuspend_delay = 0;
+
+ if(device_property_read_u32(dev, "dma_rx", &dma_rx)){
+ dev_err(&pdev->dev,"dma_rx get failed");
+ }
+ platform_info->dma_rx_param = (void*)dma_rx;
+ device_property_read_u32(dev, "dma_tx", &dma_tx);
+ platform_info->dma_tx_param = (void*)dma_tx;
+
+ dev_dbg(&pdev->dev,"get dma_rx=0x%x dma_tx=0x%x enable_dma=0x%x",dma_rx,dma_tx,platform_info->enable_dma);
+
+}
+
+#if defined(CONFIG_DEBUG_FS)
+#define dump_register(reg) \
+{ \
+ .name = __stringify(reg), \
+ .offset = SPI_ ##reg##_OFFSET, \
+}
+
+
+static const struct debugfs_reg32 spi_regs[] = {
+ dump_register(VER_REG),
+ dump_register(COM_CTRL),
+ dump_register(FMT_CTRL),
+ dump_register(DR),
+ dump_register(FIFO_CTRL),
+ dump_register(FIFO_SR),
+ dump_register(INTR_EN),
+ dump_register(INTR_SR),
+ dump_register(TIMING),
+};
+
+//#define Strcat(x, fmt, ...) sprintf(x, "%s" #fmt, x, __VA_ARGS__)
+
+static void debugfs_spi_init(struct zx29_spi *zx29spi)
+{
+ struct dentry *root;
+ struct dentry *node;
+ char tmp[32];
+
+ if(!zx29spi)
+ return;
+
+ //create root
+ sprintf(tmp,"spi%d_zx29", zx29spi->pdev->id);
+ root = debugfs_create_dir(tmp, NULL);
+ if (!root) {
+ dev_err(&zx29spi->pdev->dev, "debugfs_create_dir %s err\n", tmp);
+ goto err;
+ }
+
+ //create regs
+ zx29spi->spi_regset.regs = (struct debugfs_reg32 *)spi_regs;
+ zx29spi->spi_regset.nregs = sizeof(spi_regs)/sizeof(struct debugfs_reg32);
+ zx29spi->spi_regset.base = zx29spi->virtbase;
+
+ debugfs_create_regset32("spi_regs", S_IRUGO, root, &zx29spi->spi_regset);
+ //create info
+ debugfs_create_u32("poll_cnt", S_IRUGO, root, &zx29spi->spi_poll_cnt);
+ debugfs_create_u32("dma_cnt", S_IRUGO, root, &zx29spi->spi_dma_cnt);
+
+ zx29spi->spi_root = (void *)root;
+ return;
+err:
+ dev_err(&zx29spi->pdev->dev, "debugfs_spi_init err\n");
+}
+
+#endif
+
+
+static int zx29_spi_init_irq(struct platform_device *pdev, struct zx29_spi *zx29spi)
+{
+ int irq = 0,ret = 0;
+
+ if(!zx29spi || !pdev) {
+ ret = -ENOENT;
+ return ret;
+ }
+ irq = platform_get_irq(pdev, 0);
+ if (irq == NULL) {
+ dev_err(&pdev->dev, "Cannot get IORESOURCE_IRQ\n");
+ ret = -ENOENT;
+ return ret;
+ }
+ zx29spi->irq = irq;
+ dev_dbg(&pdev->dev, "used interrupt num is %d\n", zx29spi->irq);
+ ret = devm_request_irq(&pdev->dev, zx29spi->irq, zx29_spi_irq,
+ IRQF_TRIGGER_HIGH | IRQF_NO_THREAD | IRQF_ONESHOT, dev_name(&pdev->dev), zx29spi);
+ if (ret < 0) {
+ dev_err(&pdev->dev, "probe - cannot get IRQ (%d)\n", ret);
+ return ret;
+ }
+ disable_irq_nosync(zx29spi->irq);
+ return ret;
+
+}
+
+static int zx29_spi_probe_of_master(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ struct zx29_spi_controller *platform_info=NULL ;
+ struct spi_master *master;
+ struct zx29_spi *zx29spi = NULL; /*Data for this driver */
+ struct resource *regs = NULL;
+ struct resource *gpio = NULL;
+ struct resource *irq = NULL;
+ struct device_node *np = pdev->dev.of_node;
+ int status = 0, i,ret;
+ u32 regval = 0;
+
+ platform_info = devm_kzalloc(&pdev->dev, sizeof(struct zx29_spi_controller), GFP_KERNEL);
+ if(platform_info == NULL)
+ return 0;
+ platform_info->bus_id = 0,
+ platform_info->num_chipselect = 1,
+ platform_info->enable_dma = 1,
+ platform_info->autosuspend_delay=0,
+
+ /* Allocate master with space for data */
+ master = spi_alloc_master(dev, sizeof(struct zx29_spi));
+ if (master == NULL) {
+ dev_err(&pdev->dev, "probe - cannot alloc SPI master\n");
+ status = -ENOMEM;
+ goto err_no_master;
+ }
+
+ zx29spi = spi_master_get_devdata(master);
+ memset(zx29spi,0,sizeof(struct zx29_spi));
+ pdev->id = of_alias_get_id(np, "spi");
+ if(pdev->id < 0){
+ printk("zx29_ssp of_alias_get_id fail ret:%d\n", pdev->id);
+ status = -ENOMEM;
+ goto err_no_master;
+ }
+ snprintf(zx29spi->name, sizeof(zx29spi->name), "zx29-spi%d", pdev->id);
+ zx29_spi_get_platformInfo(pdev,platform_info);
+ //mutex_init(&zx29spi->spi_lock);
+ g_zx29_spi[pdev->id] = zx29spi;
+ zx29spi->master = master;
+ zx29spi->master_info = platform_info;
+ zx29spi->pdev = pdev;
+ zx29spi->vendor = &vendor_arm;
+ zx29spi->mode = ZX29_SSP_MASTER_TYPE;
+ zx29spi->zx29_flush_rxfifo = zx29_flush_rxfifo;
+ sema_init(&zx29spi->sema_dma, 0);
+ /* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck start */
+ init_waitqueue_head(&zx29spi->wait);
+ zx29spi->trans_done = false;
+ /* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck end */
+ dev_set_drvdata(&pdev->dev, zx29spi);
+ device_init_wakeup(&pdev->dev, true);
+ /*
+ * Bus Number Which has been Assigned to this SSP controller
+ * on this board
+ */
+ master->bus_num = platform_info->bus_id;
+ master->num_chipselect = platform_info->num_chipselect;
+ master->cleanup = zx29_cleanup;
+ master->setup = zx29_setup;
+ master->prepare_transfer_hardware = zx29_prepare_transfer_hardware;
+ master->transfer_one_message = zx29_transfer_one_message;
+ master->unprepare_transfer_hardware = zx29_unprepare_transfer_hardware;
+ //master->rt = platform_info->rt;
+
+ /*
+ * Supports mode 0-3, loopback, and active low CS..
+ */
+ master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_NO_CS|SPI_LOOP;
+
+ dev_dbg(&pdev->dev, "BUSNO: %d\n", master->bus_num);
+
+ zx29_spi_init_pinctrl(pdev);
+
+ /* registers */
+ regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (regs == NULL){
+ dev_err(&pdev->dev, "Cannot get IORESOURCE_MEM\n");
+ status = -ENOENT;
+ goto err_no_registers;
+ }
+ zx29spi->phybase = regs->start;
+ zx29spi->virtbase = devm_platform_ioremap_resource(pdev, 0);
+ if (zx29spi->virtbase == NULL) {
+ status = -ENOMEM;
+ goto err_no_ioremap;
+ }
+ dev_dbg( &pdev->dev," mapped registers from 0x%08x to 0x%p\n",
+ regs->start, zx29spi->virtbase);
+
+#if defined(CONFIG_DEBUG_FS)
+ debugfs_spi_init(zx29spi);
+#endif
+
+ /*clock init*/
+ status = zx29_spi_clock_init(zx29spi);
+ if(status)
+ goto err_no_clk;
+
+ /* Initialize transfer pump */
+ //tasklet_init(&zx29spi->pump_transfers, pump_transfers,(unsigned long)zx29spi);
+
+ /* Disable SPI */
+ regval = readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) & (~SPI_COM_CTRL_MASK_SSPE);
+ writel(regval, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+
+ load_spi_default_config(zx29spi);
+ writel(0, (SPI_TIMING_OFFSET + zx29spi->virtbase));
+ if(!strcmp(pdev->name,"1410000.ssp")) {
+ regval = readl((SPI_FMT_CTRL_OFFSET+zx29spi->virtbase))&(~(0x1<<12));
+ writel(regval, (SPI_FMT_CTRL_OFFSET+zx29spi->virtbase));
+ dev_info(&pdev->dev,"%s set non-camera mode regval:0x%x \n",pdev->name,regval);
+ }
+ status = zx29_spi_init_irq(pdev,zx29spi);
+ if(status != 0) {
+ dev_err(&pdev->dev, "zx29_spi_init_irq err!!! \n");
+ goto err_no_irq;
+ }
+ /* Get DMA channels */
+ if (platform_info->enable_dma) {
+ status = zx29_dma_probe(zx29spi);
+ if (status != 0) {
+ platform_info->enable_dma = 0;
+ sc_debug_info_record(MODULE_ID_CAP_SPI, "%s dma probe failed \n",pdev->name);
+ }
+ }
+
+#if SPI_PSM_CONTROL
+ wake_lock_init(&zx29spi->psm_lock, WAKE_LOCK_SUSPEND, zx29spi->name);
+#endif
+ master->dev.of_node = pdev->dev.of_node;
+ ret = devm_spi_register_master(&pdev->dev, master);
+ if (ret < 0) {
+ dev_err(&pdev->dev, "can not register to master err %d\n", ret);
+ goto err_spi_register;
+ }
+ dev_info(&pdev->dev," probe succeeded\n");
+
+ /* let runtime pm put suspend */
+ if (platform_info->autosuspend_delay > 0) {
+ dev_info(&pdev->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_autosuspend(dev);
+ } else {
+ pm_runtime_put(dev);
+ }
+
+ return 0;
+
+ err_spi_register:
+#if SPI_PSM_CONTROL
+ wake_lock_destroy(&zx29spi->psm_lock);
+#endif
+ if (platform_info->enable_dma)
+ zx29_dma_remove(zx29spi);
+
+ err_no_irq:
+ clk_disable(zx29spi->spi_clk);
+// err_no_clk_en:
+ //clk_unprepare(pl022->clk);
+ //err_clk_prep:
+ clk_put(zx29spi->spi_clk);
+ err_no_clk:
+// iounmap(zx29spi->virtbase);
+ err_gpios:
+ /* add */
+ err_no_ioremap:
+ err_no_registers:
+ spi_master_put(master);
+ err_no_master:
+ err_no_pdata:
+ return status;
+}
+
+static int zx29_spi_probe_of_slave(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ struct zx29_spi_controller *platform_info=NULL ;
+ struct spi_master *master;
+ struct zx29_spi *zx29spi = NULL; /*Data for this driver */
+ struct resource *regs = NULL;
+ struct resource *gpio = NULL;
+ struct resource *irq = NULL;
+ struct device_node *np = pdev->dev.of_node;
+ int status = 0, i,ret;
+ u32 regval = 0;
+
+ platform_info = devm_kzalloc(&pdev->dev, sizeof(struct zx29_spi_controller), GFP_KERNEL);
+ if(platform_info == NULL)
+ return 0;
+ platform_info->bus_id = 0,
+ platform_info->num_chipselect = 1,
+ platform_info->enable_dma = 1,
+ platform_info->autosuspend_delay=0,
+
+ /* Allocate master with space for data */
+ master = spi_alloc_master(dev, sizeof(struct zx29_spi));
+ if (master == NULL) {
+ dev_err(&pdev->dev, "probe - cannot alloc SPI master\n");
+ status = -ENOMEM;
+ goto err_no_master;
+ }
+ master->slave = true;
+ zx29spi = spi_master_get_devdata(master);
+ memset(zx29spi,0,sizeof(struct zx29_spi));
+ pdev->id = of_alias_get_id(np, "spi");
+ if(pdev->id < 0){
+ printk("zx29_ssp of_alias_get_id fail ret:%d\n", pdev->id);
+ goto err_no_master;
+ }
+ snprintf(zx29spi->name, sizeof(zx29spi->name), "zx29-spi%d", pdev->id);
+
+ zx29_spi_get_platformInfo(pdev,platform_info);
+ //mutex_init(&zx29spi->spi_lock);
+ g_zx29_spi[pdev->id] = zx29spi;
+ zx29spi->master = master;
+ zx29spi->master_info = platform_info;
+ zx29spi->pdev = pdev;
+ zx29spi->vendor = &vendor_arm;
+ zx29spi->mode = ZX29_SSP_SLAVE_TYPE;
+ zx29spi->zx29_flush_rxfifo = zx29_flush_rxfifo;
+ sema_init(&zx29spi->sema_dma, 0);
+ /* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck start */
+ init_waitqueue_head(&zx29spi->wait);
+ zx29spi->trans_done = false;
+ /* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck end */
+ dev_set_drvdata(&pdev->dev, zx29spi);
+ /*
+ * Bus Number Which has been Assigned to this SSP controller
+ * on this board
+ */
+ master->bus_num = platform_info->bus_id;
+ master->num_chipselect = platform_info->num_chipselect;
+ master->cleanup = zx29_cleanup;
+ master->setup = zx29_setup;
+ master->prepare_transfer_hardware = zx29_prepare_transfer_hardware;
+ master->transfer_one_message = zx29_slave_transfer_one_message;
+ master->unprepare_transfer_hardware = zx29_unprepare_transfer_hardware;
+ /* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme start */
+ master->spi_slave_rd_start = zx29_slave_rd_start;
+ master->spi_slave_rd_stop = zx29_slave_rd_stop;
+ /* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme end */
+ //master->rt = platform_info->rt;
+
+ /*
+ * Supports mode 0-3, loopback, and active low CS..
+ */
+ master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_NO_CS|SPI_LOOP;
+
+ dev_dbg(&pdev->dev, "BUSNO: %d\n", master->bus_num);
+
+ zx29_spi_init_pinctrl(pdev);
+
+ /* registers */
+ regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (regs == NULL){
+ dev_err(&pdev->dev, "Cannot get IORESOURCE_MEM\n");
+ status = -ENOENT;
+ goto err_no_registers;
+ }
+ zx29spi->phybase = regs->start;
+ zx29spi->virtbase = devm_platform_ioremap_resource(pdev, 0);
+ if (zx29spi->virtbase == NULL) {
+ status = -ENOMEM;
+ goto err_no_ioremap;
+ }
+ dev_dbg( &pdev->dev," mapped registers from 0x%08x to 0x%p\n",
+ regs->start, zx29spi->virtbase);
+
+#if defined(CONFIG_DEBUG_FS)
+ debugfs_spi_init(zx29spi);
+#endif
+
+ /*clock init*/
+ status = zx29_spi_slave_clock_init(zx29spi);
+ if(status)
+ goto err_no_clk;
+ /* Initialize transfer pump */
+ //tasklet_init(&zx29spi->pump_transfers, pump_transfers,(unsigned long)zx29spi);
+
+ /* Disable SPI */
+ regval = readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) & (~SPI_COM_CTRL_MASK_SSPE);
+ writel(regval, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+
+ load_spi_default_config(zx29spi);
+ writel(0, (SPI_TIMING_OFFSET + zx29spi->virtbase));
+
+ if(!strcmp(pdev->name,"1410000.ssp")) {
+ regval = readl((SPI_FMT_CTRL_OFFSET+zx29spi->virtbase))&(~(0x1<<12));
+ writel(regval, (SPI_FMT_CTRL_OFFSET+zx29spi->virtbase));
+ dev_info(&pdev->dev," %s set non-camera mode regval:0x%x \n",pdev->name,regval);
+ }
+
+ writel(readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase)) | SPI_COM_CTRL_MASK_SSPE, (SPI_COM_CTRL_OFFSET+zx29spi->virtbase));
+ while(((readl((SPI_COM_CTRL_OFFSET+zx29spi->virtbase))>> 4)&0x1) == 0);
+
+ dev_info(&pdev->dev,"ssp enabled \n",regval);
+ /* irq*/
+ status = zx29_spi_init_irq(pdev,zx29spi);
+ if(status != 0) {
+ dev_err(&pdev->dev, "zx29_spi_init_irq err!!! \n");
+ goto err_no_irq;
+ }
+
+ /* Get DMA channels */
+ if (platform_info->enable_dma) {
+ status = zx29_dma_probe(zx29spi);
+ if (status != 0) {
+ platform_info->enable_dma = 0;
+ sc_debug_info_record(MODULE_ID_CAP_SPI, "%s dma probe failed",pdev->name);
+ }
+ }
+
+#if SPI_PSM_CONTROL
+ wake_lock_init(&zx29spi->psm_lock, WAKE_LOCK_SUSPEND, zx29spi->name);
+#endif
+ master->dev.of_node = pdev->dev.of_node;
+ ret = devm_spi_register_master(&pdev->dev, master);
+ if (ret < 0) {
+ dev_err(&pdev->dev, "can not register to master err %d\n", ret);
+ goto err_spi_register;
+ }
+
+ dev_info(&pdev->dev," probe succeeded\n");
+
+ /* let runtime pm put suspend */
+ if (platform_info->autosuspend_delay > 0) {
+ dev_info(&pdev->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_autosuspend(dev);
+ } else {
+ pm_runtime_put(dev);
+ }
+
+ return 0;
+
+ err_spi_register:
+#if SPI_PSM_CONTROL
+ wake_lock_destroy(&zx29spi->psm_lock);
+#endif
+ if (platform_info->enable_dma)
+ zx29_dma_remove(zx29spi);
+
+ err_no_irq:
+ clk_disable(zx29spi->spi_clk);
+// err_no_clk_en:
+ //clk_unprepare(pl022->clk);
+ //err_clk_prep:
+ clk_put(zx29spi->spi_clk);
+ err_no_clk:
+// iounmap(zx29spi->virtbase);
+ err_gpios:
+ /* add */
+ err_no_ioremap:
+ err_no_registers:
+ spi_master_put(master);
+ err_no_master:
+ err_no_pdata:
+ return status;
+}
+
+
+
+static int zx29_spi_probe(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ const struct of_device_id *match;
+ const struct zx29_ssp_device_of_data *data;
+ enum zx29_ssp_device_mode mode;
+ int status = -EINVAL;
+ match = of_match_device(zx29_spi_of_match, dev);
+ if (!match)
+ return -EINVAL;
+ data = (struct zx29_ssp_device_of_data *)match->data;
+ mode = (enum zx29_ssp_device_mode)data->mode;
+
+ dev_info(&pdev->dev,"%s mode \n", (mode==0)?"MASTER":(mode==1)?"SLAVE":"UNKNOWN");
+ if(mode == ZX29_SSP_MASTER_TYPE)
+ status = zx29_spi_probe_of_master(pdev);
+ if(mode == ZX29_SSP_SLAVE_TYPE)
+ status = zx29_spi_probe_of_slave(pdev);
+
+ return status;
+}
+
+static int __exit zx29_spi_remove(struct platform_device *pdev)
+{
+ struct zx29_spi *zx29spi = dev_get_drvdata(&pdev->dev);
+ struct resource * gpio = NULL;
+ //struct resource * irq = NULL;
+ int i;
+
+ if (!zx29spi)
+ return 0;
+
+ /*
+ * undo pm_runtime_put() in probe. I assume that we're not
+ * accessing the primecell here.
+ */
+ pm_runtime_get_noresume(&pdev->dev);
+
+ spi_unregister_master(zx29spi->master);
+
+ load_spi_default_config(zx29spi);
+ if (zx29spi->master_info->enable_dma)
+ zx29_dma_remove(zx29spi);
+/*
+ irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+ if( irq != NULL )
+ {
+ free_irq(irq->start, zx29spi);
+ }
+*/
+ devm_free_irq(&pdev->dev, zx29spi->irq, zx29spi);
+
+ clk_disable(zx29spi->spi_clk);
+ clk_put(zx29spi->spi_clk);
+
+ clk_disable(zx29spi->pclk);
+ clk_put(zx29spi->pclk);
+
+ #if defined(CONFIG_DEBUG_FS)
+ if(zx29spi->spi_root){
+ printk(KERN_INFO "spi:debugfs_remove_recursive \n");
+ debugfs_remove_recursive(zx29spi->spi_root);
+ }
+ #endif
+
+
+ // iounmap(zx29spi->virtbase);
+ //amba_release_regions(adev);
+ //tasklet_disable(&zx29spi->pump_transfers);
+
+ spi_master_put(zx29spi->master);
+ //amba_set_drvdata(adev, NULL);
+ dev_set_drvdata(&pdev->dev, NULL);
+
+#if SPI_PSM_CONTROL
+ wake_lock_destroy(&zx29spi->psm_lock);
+#endif
+
+ return 0;
+}
+
+static const struct zx29_ssp_device_of_data zx29_ssp_master_of_data = {
+ .mode = ZX29_SSP_MASTER_TYPE,
+};
+
+static const struct zx29_ssp_device_of_data zx29_ssp_slave_of_data = {
+ .mode = ZX29_SSP_SLAVE_TYPE,
+};
+
+static const struct of_device_id zx29_spi_of_match[] = {
+ {
+ .compatible = "zte,zx29_ssp",
+ .data = &zx29_ssp_master_of_data,
+ },
+ {
+ .compatible = "zte,zx29_ssp_slave",
+ .data = &zx29_ssp_slave_of_data,
+ },
+ {},
+};
+MODULE_DEVICE_TABLE(of, zx29_spi_of_match);
+
+#ifdef CONFIG_PM
+static int zx29_spi_suspend(struct platform_device *pdev,pm_message_t state)
+{
+ struct zx29_spi *zx29spi = NULL;
+
+ if(pdev == NULL)
+ return -1;
+ if(pdev && &pdev->dev)
+ pinctrl_pm_select_sleep_state(&pdev->dev);
+
+ zx29spi = (struct zx29_spi *)platform_get_drvdata(pdev);
+ if(zx29spi && (zx29spi->master->slave == true)) {
+ if (pinctrl_select_state(ssp_pins[pdev->id].pctrl, ssp_pins[pdev->id].pcs_gpio_sleep) < 0) {
+ printk("spi%d setting cs_gpio pin ctrl failed\n",pdev->id);
+ return -1;
+ }
+ }
+ if(zx29spi&&zx29spi->master->slave == false) {
+ if (pinctrl_select_state(ssp_pins[pdev->id].pctrl, ssp_pins[pdev->id].pcs_gpio_sleep) < 0) {
+ printk("spi%d setting cs_gpio_sleep pin ctrl failed\n",pdev->id);
+ return -1;
+ }
+ printk("spi%d setting cs_gpio_sleep pin ctrl\n",pdev->id);
+ }
+ return 0;
+}
+
+static int zx29_spi_resume(struct platform_device *pdev)
+{
+ struct zx29_spi *zx29spi = NULL;
+
+ if(pdev == NULL)
+ return -1;
+ if(pdev && &pdev->dev)
+ pinctrl_pm_select_default_state(&pdev->dev);
+
+ zx29spi = (struct zx29_spi *)platform_get_drvdata(pdev);
+ if(zx29spi && (zx29spi->master->slave == true)) {
+ if (pinctrl_select_state(ssp_pins[pdev->id].pctrl, ssp_pins[pdev->id].pcs_func) < 0) {
+ printk("spi%d setting cs_func pin ctrl failed\n",pdev->id);
+ return -1;
+ }
+ }
+ if(zx29spi&&zx29spi->master->slave == false) {
+ if (pinctrl_select_state(ssp_pins[pdev->id].pctrl, ssp_pins[pdev->id].pcs_gpio_active) < 0) {
+ printk("spi%d setting cs_gpio_active pin ctrl failed\n",pdev->id);
+ return -1;
+ }
+ printk("spi%d setting cs_gpio_active pin ctrl\n",pdev->id);
+ gpio_direction_output(ssp_pins[pdev->id].gpio_cs,SPI_GPIO_HIGH);
+ }
+ return 0;
+}
+#endif
+
+static struct platform_driver zx29_spi_driver = {
+ .driver = {
+ .name = "zx29_ssp",
+ .of_match_table = of_match_ptr(zx29_spi_of_match),
+ .owner = THIS_MODULE,
+ },
+ .probe = zx29_spi_probe,
+ #ifdef CONFIG_PM
+ .suspend = zx29_spi_suspend,
+ .resume = zx29_spi_resume,
+ #endif
+ .remove = __exit_p(zx29_spi_remove),
+};
+
+static int __init zx29_spi_init(void)
+{
+ return platform_driver_register(&zx29_spi_driver);
+}
+
+static void __exit zx29_spi_exit(void)
+{
+ platform_driver_unregister(&zx29_spi_driver);
+}
+
+module_init(zx29_spi_init);
+module_exit(zx29_spi_exit);
+
+MODULE_DESCRIPTION("zx29 spi controller driver");
+MODULE_AUTHOR("zte");
+MODULE_LICENSE("GPL");
+