upstream/linux-5.10/drivers/spi/spi-zx29.c

/******************************************************************************* 
* 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)

/*
 * 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@20240715 [T106BUG-641] SPI packet loss problem, merged into ZXW patch start */
/* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme start */
#define SPI_SLAVE_RX_BUFF_SIZE        4096
#define SPI_SLAVE_RX_MAX_PACK_NUM     15
#define SPI_SLAVE_RX_PACK_LEN         146
#define SPI_SLAVE_RX_LIST_BUFF_LEN    (SPI_SLAVE_RX_MAX_PACK_NUM*SPI_SLAVE_RX_PACK_LEN)
static dma_channel_def slave_rx_conf[SPI_SLAVE_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_SLAVE_RX_PACK_LEN)
			return 1;
		else
			return 0;
	}
	else {
		if ((SPI_SLAVE_RX_BUFF_SIZE - spi->recv_pos + spi->rd_pos ) > SPI_SLAVE_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_SLAVE_RX_PACK_LEN + SPI_SLAVE_RX_PACK_LEN - 4);
	while((end != SPI_MAGIC) && index < SPI_SLAVE_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_SLAVE_RX_PACK_LEN) <= SPI_SLAVE_RX_BUFF_SIZE) {
				memcpy(spi->rx_buf + spi->recv_pos,spi->cyc_buf + spi->cyc_index * SPI_SLAVE_RX_PACK_LEN,SPI_SLAVE_RX_PACK_LEN);
			}else {
				memcpy(spi->rx_buf + spi->recv_pos,spi->cyc_buf + spi->cyc_index * SPI_SLAVE_RX_PACK_LEN,SPI_SLAVE_RX_BUFF_SIZE - spi->recv_pos);
				memcpy(spi->rx_buf,spi->cyc_buf + spi->cyc_index * SPI_SLAVE_RX_PACK_LEN + (SPI_SLAVE_RX_BUFF_SIZE - spi->recv_pos),SPI_SLAVE_RX_PACK_LEN-(SPI_SLAVE_RX_BUFF_SIZE-spi->recv_pos));
			}
			*(volatile unsigned int *)(spi->cyc_buf +spi->cyc_index * SPI_SLAVE_RX_PACK_LEN + SPI_SLAVE_RX_PACK_LEN - 4) = SPI_MAGIC;
			spi->recv_pos = (spi->recv_pos + SPI_SLAVE_RX_PACK_LEN)%SPI_SLAVE_RX_BUFF_SIZE;
			spi->cyc_index = (spi->cyc_index + 1)%SPI_SLAVE_RX_MAX_PACK_NUM;

			zx29spi->spi_dma_cnt++;
			index++;
			end = *(volatile unsigned int *)(spi->cyc_buf +spi->cyc_index * SPI_SLAVE_RX_PACK_LEN + SPI_SLAVE_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_SLAVE_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_SLAVE_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_SLAVE_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_SLAVE_RX_MAX_PACK_NUM * SPI_SLAVE_RX_PACK_LEN, SPI_SLAVE_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);
	if (!zx29spi)
		return -EINVAL;
	dev = &zx29spi->pdev->dev;
	spi->cyc_index = 0;
	spi->rd_pos = spi->recv_pos = 0;

	spi->cyc_buf = dma_alloc_coherent(dev, SPI_SLAVE_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);
	if (!zx29spi)
		return -EINVAL;
	dev = &zx29spi->pdev->dev;
	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_SLAVE_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 */
/* yu.dong@20240715 [T106BUG-641] SPI packet loss problem, merged into ZXW patch 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,
	/* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck start */
	.rx_lev_trig = SPI_RX_8_OR_MORE_ELEM,
	/* yu.dong@20240521 [T106BUG-616] SPI set to slave mode for read will get stuck end */
	.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@20240715 [T106BUG-641] SPI packet loss problem, merged into ZXW patch start */
    /* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme start */
	if(false == zx29spi->master->slave)
		pm_stay_awake(&zx29spi->pdev->dev);
	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);
	}

	if(false == zx29spi->master->slave)
		pm_relax(&zx29spi->pdev->dev);
    /* yu.dong@20240715 [T106BUG-641] SPI packet loss problem, merged into ZXW patch end */
}
/**
 * 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);
	}

	if(zx29spi->mode == ZX29_SSP_MASTER_TYPE) {
		if(spi->setup_immediately == 1)
			zx29_setup_to_regs(chip,zx29spi);
	}

	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");