[Feature][T106_eSDK]T106-V2.01.01.02P56U06.AP.15.05_CAP.15.05(SDK4.4)diff_15.11
Only Configure: No
Affected branch: master
Affected module: unknow
Is it affected on both ZXIC and MTK: only ZXIC
Self-test: Yes
Doc Update: No
Change-Id: Ief12bb341bd859dd73c7a8c5fa3d25e5ba7e1c6d
diff --git a/upstream/linux-5.10/drivers/spi/spidev.c b/upstream/linux-5.10/drivers/spi/spidev.c
new file mode 100755
index 0000000..1522a21
--- /dev/null
+++ b/upstream/linux-5.10/drivers/spi/spidev.c
@@ -0,0 +1,2406 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Simple synchronous userspace interface to SPI devices
+ *
+ * Copyright (C) 2006 SWAPP
+ * Andrea Paterniani <a.paterniani@swapp-eng.it>
+ * Copyright (C) 2007 David Brownell (simplification, cleanup)
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/ioctl.h>
+#include <linux/fs.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/list.h>
+#include <linux/errno.h>
+#include <linux/mutex.h>
+#include <linux/slab.h>
+#include <linux/compat.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/acpi.h>
+
+#include <linux/spi/spi.h>
+#include <linux/spi/spidev.h>
+
+#include <linux/uaccess.h>
+#include <linux/of_gpio.h>
+#include <linux/pinctrl/consumer.h>
+#include <linux/of_irq.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+/* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme start*/
+#include <linux/wait.h>
+#include <linux/suspend.h>
+
+#define SPI_SLAVE_FOR_YK
+/* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme end */
+/*
+ * This supports access to SPI devices using normal userspace I/O calls.
+ * Note that while traditional UNIX/POSIX I/O semantics are half duplex,
+ * and often mask message boundaries, full SPI support requires full duplex
+ * transfers. There are several kinds of internal message boundaries to
+ * handle chipselect management and other protocol options.
+ *
+ * SPI has a character major number assigned. We allocate minor numbers
+ * dynamically using a bitmask. You must use hotplug tools, such as udev
+ * (or mdev with busybox) to create and destroy the /dev/spidevB.C device
+ * nodes, since there is no fixed association of minor numbers with any
+ * particular SPI bus or device.
+ */
+#define SPIDEV_MAJOR 153 /* assigned */
+#define N_SPI_MINORS 32 /* ... up to 256 */
+
+static DECLARE_BITMAP(minors, N_SPI_MINORS);
+
+
+/* Bit masks for spi_device.mode management. Note that incorrect
+ * settings for some settings can cause *lots* of trouble for other
+ * devices on a shared bus:
+ *
+ * - CS_HIGH ... this device will be active when it shouldn't be
+ * - 3WIRE ... when active, it won't behave as it should
+ * - NO_CS ... there will be no explicit message boundaries; this
+ * is completely incompatible with the shared bus model
+ * - READY ... transfers may proceed when they shouldn't.
+ *
+ * REVISIT should changing those flags be privileged?
+ */
+#define SPI_MODE_MASK (SPI_CPHA | SPI_CPOL | SPI_CS_HIGH \
+ | SPI_LSB_FIRST | SPI_3WIRE | SPI_LOOP \
+ | SPI_NO_CS | SPI_READY | SPI_TX_DUAL \
+ | SPI_TX_QUAD | SPI_TX_OCTAL | SPI_RX_DUAL \
+ | SPI_RX_QUAD | SPI_RX_OCTAL)
+
+struct spidev_data {
+ dev_t devt;
+ spinlock_t spi_lock;
+ struct spi_device *spi;
+ struct list_head device_entry;
+
+ /* TX/RX buffers are NULL unless this device is open (users > 0) */
+ struct mutex buf_lock;
+ unsigned users;
+ u8 *tx_buffer;
+ u8 *rx_buffer;
+ u32 speed_hz;
+ u8 rd_from_rx_buffer;
+
+//#define SPIDEV_DEBUG
+#ifdef SPIDEV_DEBUG
+ struct pinctrl *pctrl;
+ struct pinctrl_state *pgpioex;
+ struct pinctrl_state *pint_ex;
+ int gpio_ex;
+ int gpio_int;
+ int irq;
+ int tx_flag;
+ int rx_cnt_in_rx_thread;
+ int rx_cnt_in_tx_thread;
+ struct semaphore wait_req;
+ struct semaphore rec_req;
+ struct semaphore rec_head_msg_req;
+ struct semaphore rec_data_msg_req;
+ spinlock_t tx_flag_lock;
+ int msg_id;
+ bool is_data_check;
+ int rx_data_check_ok_cnt;
+ int rx_data_check_err_cnt;
+#endif
+//#define TEST_SWAP_KERNEL_AND_USER
+#ifdef TEST_SWAP_KERNEL_AND_USER
+ struct pinctrl *pctrl;
+ struct pinctrl_state *pgpioex;
+ struct pinctrl_state *pint_ex;
+ struct semaphore sig_req;
+ struct semaphore sem_dma_cfg_done;
+ int gpio_ex;
+ int gpio_int;
+ int irq;
+ int pid;
+ int dma_cfg_done;
+#endif
+};
+
+static LIST_HEAD(device_list);
+static DEFINE_MUTEX(device_list_lock);
+
+static unsigned bufsiz = 4096;
+module_param(bufsiz, uint, S_IRUGO);
+MODULE_PARM_DESC(bufsiz, "data bytes in biggest supported SPI message");
+
+/*-------------------------------------------------------------------------*/
+
+static ssize_t
+spidev_sync(struct spidev_data *spidev, struct spi_message *message)
+{
+ int status;
+ struct spi_device *spi;
+
+ spin_lock_irq(&spidev->spi_lock);
+ spi = spidev->spi;
+ spin_unlock_irq(&spidev->spi_lock);
+
+ if (spi == NULL)
+ status = -ESHUTDOWN;
+ else
+ status = spi_sync(spi, message);
+
+ if (status == 0)
+ status = message->actual_length;
+
+ return status;
+}
+
+static inline ssize_t
+spidev_sync_write(struct spidev_data *spidev, size_t len)
+{
+ struct spi_transfer t = {
+ .tx_buf = spidev->tx_buffer,
+ .len = len,
+ .speed_hz = spidev->speed_hz,
+ };
+ struct spi_message m;
+
+ spi_message_init(&m);
+ spi_message_add_tail(&t, &m);
+ return spidev_sync(spidev, &m);
+}
+
+static inline ssize_t
+spidev_sync_read(struct spidev_data *spidev, size_t len)
+{
+ struct spi_transfer t = {
+ .rx_buf = spidev->rx_buffer,
+ .len = len,
+ .speed_hz = spidev->speed_hz,
+ };
+ struct spi_message m;
+
+ spi_message_init(&m);
+ spi_message_add_tail(&t, &m);
+ return spidev_sync(spidev, &m);
+}
+
+
+static inline ssize_t
+spidev_sync_write_and_read(struct spidev_data *spidev, size_t len)
+{
+ struct spi_transfer t = {
+ .tx_buf = spidev->tx_buffer,
+ .rx_buf = spidev->rx_buffer,
+ .len = len,
+ .speed_hz = spidev->speed_hz,
+ };
+ struct spi_message m;
+
+ spi_message_init(&m);
+ spi_message_add_tail(&t, &m);
+ return spidev_sync(spidev, &m);
+}
+
+
+
+/*-------------------------------------------------------------------------*/
+/* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme start*/
+/* Read-only message with current device setup */
+static ssize_t
+spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
+{
+ struct spidev_data *spidev;
+ ssize_t status;
+ unsigned long missing;
+ /* chipselect only toggles at start or end of operation */
+ if (count > bufsiz)
+ return -EMSGSIZE;
+
+ spidev = filp->private_data;
+
+
+
+ #ifdef SPI_SLAVE_FOR_YK
+ size_t total = 0;
+
+ if (spidev->spi->rd_pos == spidev->spi->recv_pos) {
+
+ status = 0;
+ spidev->spi->is_rd_waiting = true;
+ if(0 != wait_event_freezable(spidev->spi->rd_wait, spidev->spi->recv_done)) {
+ if(spidev->spi->controller->spi_slave_rd_stop)
+ spidev->spi->controller->spi_slave_rd_stop(spidev->spi);
+ spidev->spi->is_rd_waiting = false;
+ return status;
+ }else {
+ spidev->spi->recv_done = false;
+ spidev->spi->is_rd_waiting = false;
+ }
+ }
+ mutex_lock(&spidev->buf_lock);
+ if(spidev->spi->rd_pos < spidev->spi->recv_pos) {
+
+ total = spidev->spi->recv_pos - spidev->spi->rd_pos;
+ status = (total > count) ? count : total;
+
+ missing = copy_to_user(buf, spidev->rx_buffer+spidev->spi->rd_pos, status);
+ if (missing == status) {
+ status = -EFAULT;
+ }
+ else {
+ status = status - missing;
+ spidev->spi->rd_pos += status;
+ }
+
+ }else if(spidev->spi->rd_pos > spidev->spi->recv_pos) {
+
+ total = bufsiz - (spidev->spi->rd_pos - spidev->spi->recv_pos);
+ status = (total > count) ? count : total;
+
+ if((spidev->spi->rd_pos + status) <= bufsiz) {
+
+ missing = copy_to_user(buf, spidev->rx_buffer+spidev->spi->rd_pos, status);
+ if (missing == status) {
+ status = -EFAULT;
+ }
+ else {
+ status = status - missing;
+ spidev->spi->rd_pos += status;
+ spidev->spi->rd_pos = spidev->spi->rd_pos%bufsiz;
+ }
+ }else {
+
+ unsigned long first,rest;
+
+ first = bufsiz - spidev->spi->rd_pos;
+ missing = copy_to_user(buf, spidev->rx_buffer+spidev->spi->rd_pos, first);
+ if (missing == first) {
+ status = -EFAULT;
+ } else {
+ status = status - missing;
+ }
+
+ rest = status-first;
+ missing = copy_to_user(buf+first, spidev->rx_buffer, rest);
+ if (missing == rest) {
+ status = -EFAULT;
+ } else {
+ status = status - missing;
+ }
+ spidev->spi->rd_pos = rest;
+ }
+ }
+ #else
+ mutex_lock(&spidev->buf_lock);
+ if(spidev->rd_from_rx_buffer)
+ status = count;
+ else
+ status = spidev_sync_read(spidev, count);
+
+ if (status > 0) {
+
+ missing = copy_to_user(buf, spidev->rx_buffer, status);
+ if (missing == status)
+ status = -EFAULT;
+ else
+ status = status - missing;
+ }
+ #endif
+ mutex_unlock(&spidev->buf_lock);
+
+ return status;
+}
+/* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme end*/
+
+/* Write-only message with current device setup */
+static ssize_t
+spidev_write(struct file *filp, const char __user *buf,
+ size_t count, loff_t *f_pos)
+{
+ struct spidev_data *spidev;
+ ssize_t status;
+ unsigned long missing;
+
+ /* chipselect only toggles at start or end of operation */
+ if (count > bufsiz)
+ return -EMSGSIZE;
+
+ spidev = filp->private_data;
+
+ mutex_lock(&spidev->buf_lock);
+ missing = copy_from_user(spidev->tx_buffer, buf, count);
+ if (missing == 0) {
+ if(spidev->rd_from_rx_buffer)
+ status = spidev_sync_write_and_read(spidev, count);
+ else
+ status = spidev_sync_write(spidev, count);
+ }else {
+ status = -EFAULT;
+ }
+ mutex_unlock(&spidev->buf_lock);
+
+ return status;
+}
+
+static int spidev_message(struct spidev_data *spidev,
+ struct spi_ioc_transfer *u_xfers, unsigned n_xfers)
+{
+ struct spi_message msg;
+ struct spi_transfer *k_xfers;
+ struct spi_transfer *k_tmp;
+ struct spi_ioc_transfer *u_tmp;
+ unsigned n, total, tx_total, rx_total;
+ u8 *tx_buf, *rx_buf;
+ int status = -EFAULT;
+
+ spi_message_init(&msg);
+ k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL);
+ if (k_xfers == NULL)
+ return -ENOMEM;
+
+ /* Construct spi_message, copying any tx data to bounce buffer.
+ * We walk the array of user-provided transfers, using each one
+ * to initialize a kernel version of the same transfer.
+ */
+ tx_buf = spidev->tx_buffer;
+ rx_buf = spidev->rx_buffer;
+ total = 0;
+ tx_total = 0;
+ rx_total = 0;
+ for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;
+ n;
+ n--, k_tmp++, u_tmp++) {
+ /* Ensure that also following allocations from rx_buf/tx_buf will meet
+ * DMA alignment requirements.
+ */
+ unsigned int len_aligned = ALIGN(u_tmp->len, ARCH_KMALLOC_MINALIGN);
+
+ k_tmp->len = u_tmp->len;
+
+ total += k_tmp->len;
+ /* Since the function returns the total length of transfers
+ * on success, restrict the total to positive int values to
+ * avoid the return value looking like an error. Also check
+ * each transfer length to avoid arithmetic overflow.
+ */
+ if (total > INT_MAX || k_tmp->len > INT_MAX) {
+ status = -EMSGSIZE;
+ goto done;
+ }
+
+ if (u_tmp->rx_buf) {
+ /* this transfer needs space in RX bounce buffer */
+ rx_total += len_aligned;
+ if (rx_total > bufsiz) {
+ status = -EMSGSIZE;
+ goto done;
+ }
+ k_tmp->rx_buf = rx_buf;
+ rx_buf += len_aligned;
+ }
+ if (u_tmp->tx_buf) {
+ /* this transfer needs space in TX bounce buffer */
+ tx_total += len_aligned;
+ if (tx_total > bufsiz) {
+ status = -EMSGSIZE;
+ goto done;
+ }
+ k_tmp->tx_buf = tx_buf;
+ if (copy_from_user(tx_buf, (const u8 __user *)
+ (uintptr_t) u_tmp->tx_buf,
+ u_tmp->len))
+ goto done;
+ tx_buf += len_aligned;
+ }
+
+ k_tmp->cs_change = !!u_tmp->cs_change;
+ k_tmp->tx_nbits = u_tmp->tx_nbits;
+ k_tmp->rx_nbits = u_tmp->rx_nbits;
+ k_tmp->bits_per_word = u_tmp->bits_per_word;
+ k_tmp->delay.value = u_tmp->delay_usecs;
+ k_tmp->delay.unit = SPI_DELAY_UNIT_USECS;
+ k_tmp->speed_hz = u_tmp->speed_hz;
+ k_tmp->word_delay.value = u_tmp->word_delay_usecs;
+ k_tmp->word_delay.unit = SPI_DELAY_UNIT_USECS;
+ if (!k_tmp->speed_hz)
+ k_tmp->speed_hz = spidev->speed_hz;
+#ifdef VERBOSE
+ dev_dbg(&spidev->spi->dev,
+ " xfer len %u %s%s%s%dbits %u usec %u usec %uHz\n",
+ k_tmp->len,
+ k_tmp->rx_buf ? "rx " : "",
+ k_tmp->tx_buf ? "tx " : "",
+ k_tmp->cs_change ? "cs " : "",
+ k_tmp->bits_per_word ? : spidev->spi->bits_per_word,
+ k_tmp->delay.value,
+ k_tmp->word_delay.value,
+ k_tmp->speed_hz ? : spidev->spi->max_speed_hz);
+#endif
+ spi_message_add_tail(k_tmp, &msg);
+ }
+
+ status = spidev_sync(spidev, &msg);
+ if (status < 0)
+ goto done;
+
+ /* copy any rx data out of bounce buffer */
+ for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;
+ n;
+ n--, k_tmp++, u_tmp++) {
+ if (u_tmp->rx_buf) {
+ if (copy_to_user((u8 __user *)
+ (uintptr_t) u_tmp->rx_buf, k_tmp->rx_buf,
+ u_tmp->len)) {
+ status = -EFAULT;
+ goto done;
+ }
+ }
+ }
+ status = total;
+
+done:
+ kfree(k_xfers);
+ return status;
+}
+
+static struct spi_ioc_transfer *
+spidev_get_ioc_message(unsigned int cmd, struct spi_ioc_transfer __user *u_ioc,
+ unsigned *n_ioc)
+{
+ u32 tmp;
+
+ /* Check type, command number and direction */
+ if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC
+ || _IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))
+ || _IOC_DIR(cmd) != _IOC_WRITE)
+ return ERR_PTR(-ENOTTY);
+
+ tmp = _IOC_SIZE(cmd);
+ if ((tmp % sizeof(struct spi_ioc_transfer)) != 0)
+ return ERR_PTR(-EINVAL);
+ *n_ioc = tmp / sizeof(struct spi_ioc_transfer);
+ if (*n_ioc == 0)
+ return NULL;
+
+ /* copy into scratch area */
+ return memdup_user(u_ioc, tmp);
+}
+
+static long
+spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+{
+ int retval = 0;
+ struct spidev_data *spidev;
+ struct spi_device *spi;
+ u32 tmp;
+ unsigned n_ioc;
+ struct spi_ioc_transfer *ioc;
+
+ /* Check type and command number */
+ if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)
+ return -ENOTTY;
+
+ /* guard against device removal before, or while,
+ * we issue this ioctl.
+ */
+ spidev = filp->private_data;
+ spin_lock_irq(&spidev->spi_lock);
+ spi = spi_dev_get(spidev->spi);
+ spin_unlock_irq(&spidev->spi_lock);
+
+ if (spi == NULL)
+ return -ESHUTDOWN;
+
+ /* use the buffer lock here for triple duty:
+ * - prevent I/O (from us) so calling spi_setup() is safe;
+ * - prevent concurrent SPI_IOC_WR_* from morphing
+ * data fields while SPI_IOC_RD_* reads them;
+ * - SPI_IOC_MESSAGE needs the buffer locked "normally".
+ */
+ mutex_lock(&spidev->buf_lock);
+
+ switch (cmd) {
+ /* read requests */
+ case SPI_IOC_RD_MODE:
+ retval = put_user(spi->mode & SPI_MODE_MASK,
+ (__u8 __user *)arg);
+ break;
+ case SPI_IOC_RD_MODE32:
+ retval = put_user(spi->mode & SPI_MODE_MASK,
+ (__u32 __user *)arg);
+ break;
+ case SPI_IOC_RD_LSB_FIRST:
+ retval = put_user((spi->mode & SPI_LSB_FIRST) ? 1 : 0,
+ (__u8 __user *)arg);
+ break;
+ case SPI_IOC_RD_BITS_PER_WORD:
+ retval = put_user(spi->bits_per_word, (__u8 __user *)arg);
+ break;
+ case SPI_IOC_RD_MAX_SPEED_HZ:
+ retval = put_user(spidev->speed_hz, (__u32 __user *)arg);
+ break;
+ case SPI_IOC_RD_RD_DATA_FROM:
+ retval = put_user(spidev->rd_from_rx_buffer, (__u32 __user *)arg);
+ break;
+
+#ifdef TEST_SWAP_KERNEL_AND_USER
+ case SPI_IOC_RD_INT_ST:
+ tmp = gpio_get_value(spidev->gpio_int);
+ retval = put_user(tmp, (__u32 __user *)arg);
+ break;
+#endif
+ /* write requests */
+ case SPI_IOC_WR_MODE:
+ case SPI_IOC_WR_MODE32:
+ if (cmd == SPI_IOC_WR_MODE)
+ retval = get_user(tmp, (u8 __user *)arg);
+ else
+ retval = get_user(tmp, (u32 __user *)arg);
+ if (retval == 0) {
+ struct spi_controller *ctlr = spi->controller;
+ u32 save = spi->mode;
+
+ if (tmp & ~SPI_MODE_MASK) {
+ retval = -EINVAL;
+ break;
+ }
+
+ if (ctlr->use_gpio_descriptors && ctlr->cs_gpiods &&
+ ctlr->cs_gpiods[spi->chip_select])
+ tmp |= SPI_CS_HIGH;
+
+ tmp |= spi->mode & ~SPI_MODE_MASK;
+ spi->mode = (u16)tmp;
+ retval = spi_setup(spi);
+ if (retval < 0)
+ spi->mode = save;
+ else
+ dev_dbg(&spi->dev, "spi mode %x\n", tmp);
+ }
+ break;
+ case SPI_IOC_WR_LSB_FIRST:
+ retval = get_user(tmp, (__u8 __user *)arg);
+ if (retval == 0) {
+ u32 save = spi->mode;
+
+ if (tmp)
+ spi->mode |= SPI_LSB_FIRST;
+ else
+ spi->mode &= ~SPI_LSB_FIRST;
+ retval = spi_setup(spi);
+ if (retval < 0)
+ spi->mode = save;
+ else
+ dev_dbg(&spi->dev, "%csb first\n",
+ tmp ? 'l' : 'm');
+ }
+ break;
+ case SPI_IOC_WR_BITS_PER_WORD:
+ retval = get_user(tmp, (__u8 __user *)arg);
+ if (retval == 0) {
+ u8 save = spi->bits_per_word;
+
+ spi->bits_per_word = tmp;
+ retval = spi_setup(spi);
+ if (retval < 0)
+ spi->bits_per_word = save;
+ else
+ dev_dbg(&spi->dev, "%d bits per word\n", tmp);
+ }
+ break;
+ case SPI_IOC_WR_MAX_SPEED_HZ:
+ retval = get_user(tmp, (__u32 __user *)arg);
+ if (retval == 0) {
+ u32 save = spi->max_speed_hz;
+
+ spi->max_speed_hz = tmp;
+ retval = spi_setup(spi);
+ if (retval == 0) {
+ spidev->speed_hz = tmp;
+ dev_dbg(&spi->dev, "%d Hz (max)\n",
+ spidev->speed_hz);
+ } else {
+ spi->max_speed_hz = save;
+ }
+ }
+ break;
+ case SPI_IOC_WR_RD_DATA_FROM:
+ retval = get_user(tmp, (__u8 __user *)arg);
+ if (retval == 0) {
+ spidev->rd_from_rx_buffer = tmp;
+ dev_dbg(&spi->dev, "RD DATA FROM %s \n",
+ spidev->rd_from_rx_buffer ? "RX_BUFFER":"DEVICE");
+ }
+ break;
+/* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme start */
+#ifdef SPI_SLAVE_FOR_YK
+ case SPI_IOC_RD_BLOCK_RELEASE:
+ if(spidev->spi->is_rd_waiting == true) {
+ wake_up(&spidev->spi->rd_wait);
+ spidev->spi->recv_done = 1;
+ }
+ break;
+#endif
+/* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme end */
+#ifdef TEST_SWAP_KERNEL_AND_USER
+ case SPI_IOC_WR_SIG_PID:
+ retval = get_user(tmp, (__u32 __user *)arg);
+ if (retval == 0) {
+ spidev->pid = tmp;
+ dev_dbg(&spi->dev, "SET SIG PID %d \n",
+ spidev->pid);
+ }else{
+ printk("%s %d %d \r\n",__FUNCTION__,__LINE__,retval);
+ }
+
+ break;
+#endif
+ default:
+ /* segmented and/or full-duplex I/O request */
+ /* Check message and copy into scratch area */
+ ioc = spidev_get_ioc_message(cmd,
+ (struct spi_ioc_transfer __user *)arg, &n_ioc);
+ if (IS_ERR(ioc)) {
+ retval = PTR_ERR(ioc);
+ break;
+ }
+ if (!ioc)
+ break; /* n_ioc is also 0 */
+
+ /* translate to spi_message, execute */
+ retval = spidev_message(spidev, ioc, n_ioc);
+ kfree(ioc);
+ break;
+ }
+
+ mutex_unlock(&spidev->buf_lock);
+ spi_dev_put(spi);
+ return retval;
+}
+
+#ifdef CONFIG_COMPAT
+static long
+spidev_compat_ioc_message(struct file *filp, unsigned int cmd,
+ unsigned long arg)
+{
+ struct spi_ioc_transfer __user *u_ioc;
+ int retval = 0;
+ struct spidev_data *spidev;
+ struct spi_device *spi;
+ unsigned n_ioc, n;
+ struct spi_ioc_transfer *ioc;
+
+ u_ioc = (struct spi_ioc_transfer __user *) compat_ptr(arg);
+
+ /* guard against device removal before, or while,
+ * we issue this ioctl.
+ */
+ spidev = filp->private_data;
+ spin_lock_irq(&spidev->spi_lock);
+ spi = spi_dev_get(spidev->spi);
+ spin_unlock_irq(&spidev->spi_lock);
+
+ if (spi == NULL)
+ return -ESHUTDOWN;
+
+ /* SPI_IOC_MESSAGE needs the buffer locked "normally" */
+ mutex_lock(&spidev->buf_lock);
+
+ /* Check message and copy into scratch area */
+ ioc = spidev_get_ioc_message(cmd, u_ioc, &n_ioc);
+ if (IS_ERR(ioc)) {
+ retval = PTR_ERR(ioc);
+ goto done;
+ }
+ if (!ioc)
+ goto done; /* n_ioc is also 0 */
+
+ /* Convert buffer pointers */
+ for (n = 0; n < n_ioc; n++) {
+ ioc[n].rx_buf = (uintptr_t) compat_ptr(ioc[n].rx_buf);
+ ioc[n].tx_buf = (uintptr_t) compat_ptr(ioc[n].tx_buf);
+ }
+
+ /* translate to spi_message, execute */
+ retval = spidev_message(spidev, ioc, n_ioc);
+ kfree(ioc);
+
+done:
+ mutex_unlock(&spidev->buf_lock);
+ spi_dev_put(spi);
+ return retval;
+}
+
+static long
+spidev_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+{
+ if (_IOC_TYPE(cmd) == SPI_IOC_MAGIC
+ && _IOC_NR(cmd) == _IOC_NR(SPI_IOC_MESSAGE(0))
+ && _IOC_DIR(cmd) == _IOC_WRITE)
+ return spidev_compat_ioc_message(filp, cmd, arg);
+
+ return spidev_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
+}
+#else
+#define spidev_compat_ioctl NULL
+#endif /* CONFIG_COMPAT */
+
+static int spidev_open(struct inode *inode, struct file *filp)
+{
+ struct spidev_data *spidev;
+ int status = -ENXIO;
+ struct spi_device *spi;
+
+ mutex_lock(&device_list_lock);
+
+ list_for_each_entry(spidev, &device_list, device_entry) {
+ if (spidev->devt == inode->i_rdev) {
+ status = 0;
+ break;
+ }
+ }
+
+ if (status) {
+ pr_debug("spidev: nothing for minor %d\n", iminor(inode));
+ goto err_find_dev;
+ }
+
+ if (!spidev->tx_buffer) {
+ spidev->tx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->tx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ status = -ENOMEM;
+ goto err_find_dev;
+ }
+ }
+
+ if (!spidev->rx_buffer) {
+ spidev->rx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->rx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ status = -ENOMEM;
+ goto err_alloc_rx_buf;
+ }
+ }
+
+ /* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme start */
+ #ifdef SPI_SLAVE_FOR_YK
+ if(spidev->rx_buffer) {
+ spidev->spi->rx_buf = spidev->rx_buffer;
+ if(spidev->spi->controller->spi_slave_rd_start)
+ spidev->spi->controller->spi_slave_rd_start(spidev->spi);
+ }
+ #endif
+ /* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme end */
+ spidev->users++;
+ filp->private_data = spidev;
+ stream_open(inode, filp);
+
+ mutex_unlock(&device_list_lock);
+
+
+ spin_lock_irq(&spidev->spi_lock);
+ spi = spi_dev_get(spidev->spi);
+ spin_unlock_irq(&spidev->spi_lock);
+ if(spi && spi->master->slave)
+ pm_stay_awake(&spi->dev);
+
+ return 0;
+
+err_alloc_rx_buf:
+ kfree(spidev->tx_buffer);
+ spidev->tx_buffer = NULL;
+err_find_dev:
+ mutex_unlock(&device_list_lock);
+ return status;
+}
+
+static int spidev_release(struct inode *inode, struct file *filp)
+{
+ struct spidev_data *spidev;
+ int dofree;
+ struct spi_device *spi;
+
+ mutex_lock(&device_list_lock);
+ spidev = filp->private_data;
+ filp->private_data = NULL;
+
+ spin_lock_irq(&spidev->spi_lock);
+ /* ... after we unbound from the underlying device? */
+ dofree = (spidev->spi == NULL);
+ spin_unlock_irq(&spidev->spi_lock);
+
+ /* last close? */
+ spidev->users--;
+ if (!spidev->users) {
+
+ spin_lock_irq(&spidev->spi_lock);
+ spi = spi_dev_get(spidev->spi);
+ spin_unlock_irq(&spidev->spi_lock);
+
+ /* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme start */
+ #ifdef SPI_SLAVE_FOR_YK
+ if(spidev->rx_buffer) {
+ if(spi->controller->spi_slave_rd_stop)
+ spi->controller->spi_slave_rd_stop(spi);
+ }
+ #endif
+ /* yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme end */
+ if(spi && spi->master->slave)
+ pm_relax(&spi->dev);
+ kfree(spidev->tx_buffer);
+ spidev->tx_buffer = NULL;
+
+ kfree(spidev->rx_buffer);
+ spidev->rx_buffer = NULL;
+
+ if (dofree)
+ kfree(spidev);
+ else
+ spidev->speed_hz = spidev->spi->max_speed_hz;
+ }
+#ifdef CONFIG_SPI_SLAVE
+ if (!dofree)
+ spi_slave_abort(spidev->spi);
+#endif
+ mutex_unlock(&device_list_lock);
+
+ return 0;
+}
+
+static const struct file_operations spidev_fops = {
+ .owner = THIS_MODULE,
+ /* REVISIT switch to aio primitives, so that userspace
+ * gets more complete API coverage. It'll simplify things
+ * too, except for the locking.
+ */
+ .write = spidev_write,
+ .read = spidev_read,
+ .unlocked_ioctl = spidev_ioctl,
+ .compat_ioctl = spidev_compat_ioctl,
+ .open = spidev_open,
+ .release = spidev_release,
+ .llseek = no_llseek,
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* The main reason to have this class is to make mdev/udev create the
+ * /dev/spidevB.C character device nodes exposing our userspace API.
+ * It also simplifies memory management.
+ */
+
+static struct class *spidev_class;
+
+#ifdef CONFIG_OF
+static const struct of_device_id spidev_dt_ids[] = {
+ { .compatible = "rohm,dh2228fv" },
+ { .compatible = "lineartechnology,ltc2488" },
+ { .compatible = "ge,achc" },
+ { .compatible = "semtech,sx1301" },
+ { .compatible = "lwn,bk4" },
+ { .compatible = "dh,dhcom-board" },
+ { .compatible = "menlo,m53cpld" },
+ { .compatible = "zte,spidev" },
+ {},
+};
+MODULE_DEVICE_TABLE(of, spidev_dt_ids);
+#endif
+
+#ifdef CONFIG_ACPI
+
+/* Dummy SPI devices not to be used in production systems */
+#define SPIDEV_ACPI_DUMMY 1
+
+static const struct acpi_device_id spidev_acpi_ids[] = {
+ /*
+ * The ACPI SPT000* devices are only meant for development and
+ * testing. Systems used in production should have a proper ACPI
+ * description of the connected peripheral and they should also use
+ * a proper driver instead of poking directly to the SPI bus.
+ */
+ { "SPT0001", SPIDEV_ACPI_DUMMY },
+ { "SPT0002", SPIDEV_ACPI_DUMMY },
+ { "SPT0003", SPIDEV_ACPI_DUMMY },
+ {},
+};
+MODULE_DEVICE_TABLE(acpi, spidev_acpi_ids);
+
+static void spidev_probe_acpi(struct spi_device *spi)
+{
+ const struct acpi_device_id *id;
+
+ if (!has_acpi_companion(&spi->dev))
+ return;
+
+ id = acpi_match_device(spidev_acpi_ids, &spi->dev);
+ if (WARN_ON(!id))
+ return;
+
+ if (id->driver_data == SPIDEV_ACPI_DUMMY)
+ dev_warn(&spi->dev, "do not use this driver in production systems!\n");
+}
+#else
+static inline void spidev_probe_acpi(struct spi_device *spi) {}
+#endif
+
+#ifdef SPIDEV_DEBUG
+#define SPIDEV_ATTR(_name) \
+static struct kobj_attribute _name##_attr = { \
+ .attr = { \
+ .name = __stringify(_name), \
+ .mode = 0644, \
+ }, \
+ .show = _name##_show, \
+ .store = _name##_store, \
+}
+
+
+static void print_buf_data(void * buf,int count)
+{
+ int i = 0;
+ if(buf) {
+ unsigned char *p = buf;
+ for(i = 0;i<= count-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]);
+ }
+ }
+}
+
+
+struct spi_dev_hand_msg{
+ unsigned short head;
+ unsigned int len;
+ unsigned short tail;
+};
+
+#define MSG_HEAD 0xa5a5
+#define MSG_TAIL 0x7e7e
+
+extern void slave_mode_set(struct spi_device *spi,unsigned int param);
+extern void set_spi_timing(struct spi_device *spi,unsigned int param);
+extern int get_spi_rx_fifo(struct spi_device *spi,unsigned char *buf);
+static int spidev_get_rxfifo(struct spi_device *spi,unsigned char *buf)
+{
+ int ret = 0;
+
+ if(!spi || !buf)
+ return ret;
+ return get_spi_rx_fifo(spi,buf);
+
+}
+
+
+static int data_to_packet(void * buf,int len)
+{
+ int i = 2,ret = -1;
+ unsigned char sum = 0;
+ unsigned char *p = (unsigned char *)buf;
+
+ if(!p || len < 4) {
+ printk("%s param err! \n",__FUNCTION__);
+ return ret;
+ }
+ for(i = 2;i<len-2;i++)
+ sum += p[i];
+ p[1] = sum;
+ ret = 0;
+ return ret;
+}
+
+static int packet_check(void *buf,int len)
+{
+ unsigned char *p = (unsigned char *)buf;
+ int i = 2,ret = -1;
+ unsigned char sum=0;
+ if(!p || len < 4) {
+ printk("%s param err! \n",__FUNCTION__);
+ return ret;
+ }
+ if( (p[0] == 0xa5) && (p[len-1] == 0x7e) ) {
+ for(i = 2;i<len-2;i++)
+ sum +=p[i];
+ if(sum == p[1])
+ ret = 0;
+ }
+ return ret;
+
+}
+
+
+static int spi_dev_pin_init_test(struct spi_device *spi)
+{
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+ enum of_gpio_flags flags;
+ static int spi_dev_pin_init_flag = 0;
+ int status = 0;
+
+ if(spi_dev_pin_init_flag < 2){
+ spidev->pctrl = devm_pinctrl_get(&spi->dev);
+ if(!spidev->pctrl) {
+ dev_info(&spi->dev,"get dev pctrl failed!\n",status);
+ return status;
+ }
+
+ spidev->pint_ex = pinctrl_lookup_state(spidev->pctrl, "int_ex");
+ if (IS_ERR(spidev->pint_ex)) {
+ dev_err(&spi->dev, "TEST: missing pint_ex \n");
+ return status;
+ }
+ if (pinctrl_select_state(spidev->pctrl, spidev->pint_ex) < 0) {
+ dev_err(&spi->dev, "TEST: slect pint_ex \n");
+ return status;
+ }
+
+ spidev->pgpioex = pinctrl_lookup_state(spidev->pctrl, "ex_gpio");
+ if (IS_ERR(spidev->pgpioex)) {
+ dev_err(&spi->dev, "TEST: missing ex_gpio \n");
+ return status;
+ }
+
+ spidev->gpio_ex = of_get_gpio_flags(spi->dev.of_node, 0, &flags);
+ if (!gpio_is_valid(spidev->gpio_ex)) {
+ dev_err(&spi->dev,"gpio_ex no found,spidev->gpio_ex=%d \n",spidev->gpio_ex);
+ return status;
+ }
+ dev_info(&spi->dev,"gpio_ex found,spidev->gpio_ex=%d \n",spidev->gpio_ex);
+
+ status = gpio_request(spidev->gpio_ex, "gpio_ex");
+ if (status) {
+ pr_info("spidev->gpio_ex request error.\n");
+ }else {
+ gpio_direction_output(spidev->gpio_ex, 1);
+ dev_info(&spi->dev, "spidev->gpio_ex success \n");
+ }
+
+ spidev->gpio_int = of_get_gpio_flags(spi->dev.of_node, 1, &flags);
+ if (!gpio_is_valid(spidev->gpio_int)) {
+ dev_err(&spi->dev,"gpio_int no found,spidev->gpio_int=%d \n",spidev->gpio_int);
+ return status;
+ }
+ dev_info(&spi->dev,"gpio_int found,spidev->gpio_int=%d \n",spidev->gpio_int);
+
+ spi_dev_pin_init_flag += 1;
+ }
+ return status;
+
+}
+
+static irqreturn_t spidev_master_hand_shake_irq(int irqno, void *dev_id)
+{
+ static int count;
+ int gpio_in_status = 0,gpio_out_status = 0;
+
+ struct spidev_data *spidev = dev_id;
+
+ gpio_out_status = gpio_get_value(spidev->gpio_ex);
+ gpio_in_status = gpio_get_value(spidev->gpio_int);
+
+ //pr_info("hand_shake_irq get = %d %d %d\n", ++count,gpio_out_status,gpio_in_status);
+
+ if(gpio_out_status && !gpio_in_status) {
+ if(spidev->tx_flag == 0) {
+ up(&spidev->rec_req); /*receive slave reqeuet*/
+ }else {
+ pr_info("mmm \r\n");
+ up(&spidev->wait_req); /*first receive master req*/
+ }
+ }else if(!gpio_out_status && !gpio_in_status) {
+ up(&spidev->wait_req); /*receive slave ack*/
+ }else {
+ pr_info("recive invalid request\n");
+ }
+ return IRQ_HANDLED;
+}
+
+static irqreturn_t spidev_slave_hand_shake_irq(int irqno, void *dev_id)
+{
+ static int count;
+ int gpio_in_status = 0,gpio_out_status = 0;
+
+ struct spidev_data *spidev = dev_id;
+
+ gpio_out_status = gpio_get_value(spidev->gpio_ex);
+ gpio_in_status = gpio_get_value(spidev->gpio_int);
+
+ //pr_info("hand_shake_irq get = %d %d %d\n", ++count,gpio_out_status,gpio_in_status);
+
+ if(gpio_out_status && !gpio_in_status)
+ {
+ if(spidev->tx_flag == 0) {
+ up(&spidev->rec_req); /*first receive master req*/
+ }else {
+ pr_info("sss \n");
+ up(&spidev->wait_req);
+ }
+ /*. then set gpio_out low as ack. */
+ }else if(!gpio_out_status && !gpio_in_status) {
+ up(&spidev->wait_req); /*receive master ack*/
+ }else {
+ pr_info("recive invalid request\n");
+ }
+ return IRQ_HANDLED;
+}
+
+
+
+static int spi_dev_irq_init_test(struct spi_device *spi)
+{
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+ static int spi_dev_irq_init_flag = 0;
+ int irq = 0,ret = 0;
+
+ if(spi_dev_irq_init_flag < 2) {
+ if(!spi || !spidev) {
+ ret = -ENOENT;
+ return ret;
+ }
+ irq = irq_of_parse_and_map(spi->dev.of_node, 0);
+ if (irq <= 0) {
+ dev_err(&spi->dev, "ERROR: invalid interrupt number, irq = %d\n",irq);
+ return -EBUSY;
+ }
+ spidev->irq = irq;
+ dev_info(&spi->dev, "used interrupt num is %d\n", spidev->irq);
+ if(strcmp(dev_name(&spi->dev),"spi1.0")==0) {
+ ret = devm_request_irq(&spi->dev, spidev->irq, spidev_master_hand_shake_irq,
+ 0, dev_name(&spi->dev), spidev);
+ }else {
+ ret = devm_request_irq(&spi->dev, spidev->irq, spidev_slave_hand_shake_irq,
+ 0, dev_name(&spi->dev), spidev);
+ }
+ if (ret < 0) {
+ dev_err(&spi->dev, "probe - cannot get IRQ (%d)\n", ret);
+ return ret;
+ }
+ spi_dev_irq_init_flag += 1;
+ }
+ return ret;
+
+}
+
+static size_t spi_dev_send_handle_pack_test(struct spidev_data *spidev,int len,struct spi_dev_hand_msg *recv_msg)
+{
+ struct spi_dev_hand_msg send_msg={0};
+
+ send_msg.head = MSG_HEAD;
+ send_msg.len = len;
+ send_msg.tail = MSG_TAIL;
+
+ struct spi_transfer t = {
+ .tx_buf = &send_msg,
+ .rx_buf = recv_msg,
+ .len = sizeof(struct spi_dev_hand_msg),
+ .speed_hz = spidev->speed_hz,
+ };
+ struct spi_message m;
+
+ spi_message_init(&m);
+ spi_message_add_tail(&t, &m);
+ return spidev_sync(spidev, &m);
+
+
+}
+
+
+
+static size_t spi_dev_recv_handle_pack_test(struct spidev_data *spidev,int len,struct spi_dev_hand_msg *recv_msg)
+{
+ struct spi_dev_hand_msg send_msg={0};
+
+ struct spi_transfer t = {
+ .tx_buf = &send_msg,
+ .rx_buf = recv_msg,
+ .len = sizeof(struct spi_dev_hand_msg),
+ .speed_hz = spidev->speed_hz,
+ };
+ struct spi_message m;
+
+ spi_message_init(&m);
+ spi_message_add_tail(&t, &m);
+ return spidev_sync(spidev, &m);
+
+
+}
+
+
+static void wait_spi_bus_idle_status_test(struct spidev_data *spidev)
+{
+ int count = 0;
+
+ do {
+ spin_lock_irq(&spidev->tx_flag_lock);
+ if( gpio_get_value(spidev->gpio_ex) && gpio_get_value(spidev->gpio_int))
+ break;
+ else {
+ spin_unlock(&spidev->tx_flag_lock);
+ usleep_range(50,100);
+ count++;
+ if(count%20 == 0) {
+ printk("bus busy %d us cnts.outst(%d),intst(%d).\n",count*50,
+ gpio_get_value(spidev->gpio_ex),gpio_get_value(spidev->gpio_int));
+ }
+
+ }
+ }while(1);
+ spidev->tx_flag = 1;
+ spin_unlock_irq(&spidev->tx_flag_lock);
+
+}
+
+static size_t spi_dev_send_one_pack_test(struct spi_device *spi,size_t len) {
+
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+ struct spi_dev_hand_msg recv_msg={0};
+ size_t status;
+ int ret;
+ int rx_data_flag = 0;
+ if(len>4096)
+ printk("len(%d) err: \r\n",len);
+ wait_spi_bus_idle_status_test(spidev);
+ gpio_set_value(spidev->gpio_ex,0);
+ ret = down_timeout(&spidev->wait_req, msecs_to_jiffies(50)); /*first ack m= 0,s=0*/
+ if (ret < 0) {
+ printk("first ack timeout\n");
+ }
+ spi_dev_send_handle_pack_test(spidev,len,&recv_msg); /*send head msg*/
+ if(recv_msg.head == MSG_HEAD && recv_msg.tail == MSG_TAIL) {
+ len = (recv_msg.len >= len) ? recv_msg.len : len;
+ spidev->rx_cnt_in_tx_thread++;
+ rx_data_flag = 1;
+ if(len>4096)
+ printk("len(%d) err: \r\n",len);
+ }
+ ret = down_timeout(&spidev->wait_req, msecs_to_jiffies(100));
+ if (ret < 0) {
+ printk("second ack timeout\n");
+ }
+ //down(&spidev->wait_req); /*second ack m= 0,s=0*/
+ status = spidev_sync_write_and_read(spidev,len);
+ if(rx_data_flag && spidev->is_data_check) {
+ ret = packet_check(spidev->rx_buffer,recv_msg.len);
+ if(ret) {
+ spidev->rx_data_check_err_cnt++;
+ //dev_info(&spi->dev,"%s packet check err \r\n",__FUNCTION__);
+ }else {
+ spidev->rx_data_check_ok_cnt++;
+ //dev_info(&spi->dev,"%s packet check success \r\n",__FUNCTION__);
+ }
+ }
+ spidev->tx_flag = 0;
+ gpio_set_value(spidev->gpio_ex,1);
+ return status;
+}
+
+
+static size_t spi_dev_slave_send_one_pack_test(struct spi_device *spi,size_t len) {
+
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+ struct spi_dev_hand_msg recv_msg={0};
+ size_t status;
+ int ret;
+ int rx_data_flag = 0;
+ if(len>4096)
+ printk("len(%d) err: \r\n",len);
+ wait_spi_bus_idle_status_test(spidev);
+ up(&spidev->rec_head_msg_req);/*response master tx/rx dma set */
+ //printk("%s %d \r\n",__FUNCTION__,__LINE__);
+ spi_dev_send_handle_pack_test(spidev,len,&recv_msg); /*send head msg*/
+ if(recv_msg.head == MSG_HEAD && recv_msg.tail == MSG_TAIL) {
+ if(len != recv_msg.len) {
+ //printk("%s len=%d rec_len=%d\n",__FUNCTION__,len,recv_msg.len);
+ len = (recv_msg.len >= len) ? recv_msg.len : len;
+
+ }
+ spidev->rx_cnt_in_tx_thread++;
+ rx_data_flag = 1;
+ if(len>4096)
+ printk("len(%d) err: \r\n",len);
+ }
+
+ //down(&spidev->wait_req);
+ ret = down_timeout(&spidev->wait_req, msecs_to_jiffies(100));
+ if (ret < 0) {
+ printk("wait req timeout\n");
+ }
+ up(&spidev->rec_data_msg_req);/*response master tx/rx dma set */
+ //printk("%s %d \r\n",__FUNCTION__,__LINE__);
+ status = spidev_sync_write_and_read(spidev,len);
+ if(rx_data_flag && spidev->is_data_check) {
+ ret = packet_check(spidev->rx_buffer,recv_msg.len);
+ if(ret) {
+ spidev->rx_data_check_err_cnt++;
+ //dev_info(&spi->dev,"%s packet check err \r\n",__FUNCTION__);
+ }else {
+ spidev->rx_data_check_ok_cnt++;
+ //dev_info(&spi->dev,"%s packet check success \r\n",__FUNCTION__);
+ }
+ }
+ spidev->tx_flag = 0;
+ gpio_set_value(spidev->gpio_ex,1);
+ return status;
+}
+
+static int spi_dev_slave_read_hand_msg_process_test(void *arg)
+{
+ struct spi_device *spi = (struct spi_device *)arg;
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+
+ while(1) {
+ down(&spidev->rec_head_msg_req);
+ //printk("%s %d \r\n",__FUNCTION__,__LINE__);
+ gpio_set_value(spidev->gpio_ex,0);
+ }
+ return 0;
+}
+
+
+static int spi_dev_slave_read_data_process_test(void *arg)
+{
+ struct spi_device *spi = (struct spi_device *)arg;
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+ struct spi_dev_hand_msg *recv_msg=(struct spi_dev_hand_msg *)spidev->rx_buffer;
+
+ while(1) {
+ down(&spidev->rec_data_msg_req);
+ //printk("%s %d \r\n",__FUNCTION__,__LINE__);
+ gpio_set_value(spidev->gpio_ex,1);
+ usleep_range(50,100);
+ gpio_set_value(spidev->gpio_ex,0);
+ }
+ return 0;
+}
+
+static int spi_dev_master_read_thread_test(void *arg)
+{
+ struct spi_device *spi = (struct spi_device *)arg;
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+ pid_t kid;
+ struct pid *pid;
+ struct task_struct * tsk;
+ struct spi_dev_hand_msg recv_msg;
+ int ret;
+ if(!spidev){
+ dev_info(&spi->dev,"spi_dev return \r\n");
+ return 0;
+ }
+ while(1) {
+
+ down(&spidev->rec_req); /*first receive slave req*/
+ spi_dev_recv_handle_pack_test(spidev, sizeof(struct spi_dev_hand_msg), &recv_msg);
+ gpio_set_value(spidev->gpio_ex,0);
+ ret = down_timeout(&spidev->wait_req, msecs_to_jiffies(100));
+ if (ret < 0) {
+ printk("%s wait req timeout\n",__FUNCTION__);
+ }
+ if(recv_msg.head == MSG_HEAD && recv_msg.tail == MSG_TAIL) {
+ int len = recv_msg.len;
+ spidev_sync_write_and_read(spidev, len); /*set dma and recv data msg*/
+ spidev->rx_cnt_in_rx_thread++;
+ if(spidev->is_data_check) {
+ ret = packet_check(spidev->rx_buffer,len);
+ if(ret) {
+ spidev->rx_data_check_err_cnt++;
+ //dev_info(&spi->dev,"%s packet check err \r\n",__FUNCTION__);
+ }else {
+ spidev->rx_data_check_ok_cnt++;
+ //dev_info(&spi->dev,"%s packet check success \r\n",__FUNCTION__);
+ }
+ }
+ gpio_set_value(spidev->gpio_ex,1);
+ //print_buf_data(spidev->rx_buffer, len);
+ }else {
+ printk("%s data invalid\n",__FUNCTION__);
+ gpio_set_value(spidev->gpio_ex,1);
+ }
+ }
+ return 0;
+}
+
+
+
+
+static int spi_dev_slave_read_thread_test(void *arg)
+{
+ struct spi_device *spi = (struct spi_device *)arg;
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+ int ret;
+ struct spi_dev_hand_msg recv_msg;
+
+ if(!spidev){
+ dev_info(&spi->dev,"spi_dev return \r\n");
+ return 0;
+ }
+ while(1) {
+
+ down(&spidev->rec_req); /*first receive master req*/
+ //printk("%s %d \r\n",__FUNCTION__,__LINE__);
+ up(&spidev->rec_head_msg_req);/*response master tx/rx dma set */
+ //printk("%s %d \r\n",__FUNCTION__,__LINE__);
+ //spidev_sync_write_and_read(spidev,sizeof(struct spi_dev_hand_msg)); /*set dma and recv head msg*/
+ spi_dev_recv_handle_pack_test(spidev, sizeof(struct spi_dev_hand_msg), &recv_msg);
+ //recv_msg=(struct spi_dev_hand_msg *)spidev->rx_buffer;
+ if(recv_msg.head == MSG_HEAD && recv_msg.tail == MSG_TAIL) {
+ int len = recv_msg.len;
+ up(&spidev->rec_data_msg_req); /*response master tx/rx dma set */
+ //printk("%s %d %d \r\n",__FUNCTION__,__LINE__,len);
+ spidev_sync_write_and_read(spidev, len); /*set dma and recv data msg*/
+ if(spidev->is_data_check) {
+ ret = packet_check(spidev->rx_buffer,len);
+ if(ret) {
+ spidev->rx_data_check_err_cnt++;
+ //dev_info(&spi->dev,"%s packet check err \r\n",__FUNCTION__);
+ }else {
+ spidev->rx_data_check_ok_cnt++;
+ //dev_info(&spi->dev,"%s packet check success \r\n",__FUNCTION__);
+ }
+ }
+ gpio_set_value(spidev->gpio_ex,1);
+ spidev->rx_cnt_in_rx_thread++;
+ //print_buf_data(spidev->rx_buffer, len);
+ }else {
+ up(&spidev->rec_data_msg_req);
+ printk("%s data invalid\n",__FUNCTION__);
+ gpio_set_value(spidev->gpio_ex,1);
+ }
+ }
+ return 0;
+}
+
+
+static int spidev_debug_test_init(struct spi_device *spi)
+{
+ int ret = 0;
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+
+ ret =spi_dev_pin_init_test(spi);
+ if(ret) {
+ dev_info(&spi->dev, "spi_dev_pin_init_test,ret=%d \n",ret);
+ return ret;
+ }
+ spin_lock_init(&spidev->tx_flag_lock);
+ sema_init(&spidev->wait_req, 0);
+ sema_init(&spidev->rec_req, 0);
+ sema_init(&spidev->rec_head_msg_req, 0);
+ sema_init(&spidev->rec_data_msg_req, 0);
+ spidev->tx_flag = 0;
+ spidev->rx_cnt_in_rx_thread = 0;
+ spidev->rx_cnt_in_tx_thread = 0;
+ spidev->is_data_check = false;
+ if (!spidev->tx_buffer) {
+ spidev->tx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->tx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ return ret;
+ }
+ }
+
+ if (!spidev->rx_buffer) {
+ spidev->rx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->rx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ kfree(spidev->tx_buffer);
+ spidev->tx_buffer = NULL;
+ return ret;
+ }
+ }
+
+ if(strcmp(dev_name(&spi->dev),"spi1.0")==0) {
+ kernel_thread(spi_dev_master_read_thread_test,spi, 0); /* fork the main thread */
+ }else {
+ kernel_thread(spi_dev_slave_read_thread_test,spi, 0); /* fork the main thread */
+ kernel_thread(spi_dev_slave_read_hand_msg_process_test,spi, 0);
+ kernel_thread(spi_dev_slave_read_data_process_test,spi, 0);
+ }
+
+ ret =spi_dev_irq_init_test(spi);
+ if(ret) {
+ dev_info(&spi->dev, "spi_dev_irq_init_test,ret=%d \n",ret);
+ return ret;
+ }
+
+ return ret;
+}
+
+
+static ssize_t spidevinfo_show(struct kobject *kobj, struct kobj_attribute *attr,
+ char *buf)
+{
+
+ ssize_t count = 0;
+
+ struct device *dev = container_of(kobj, struct device, kobj);
+ //struct platform_device *pdev = container_of(dev, struct platform_device, dev);
+ unsigned char cmd_str[16] = {0};
+ u32 param1,param2,param3;
+ u8 rwaddr,rwsize;
+ int ret,i;
+
+
+ return count;
+
+
+}
+extern void get_random_bytes(void * buf, size_t len);
+static ssize_t spidevinfo_store(struct kobject *kobj, struct kobj_attribute *attr,
+ const char *buf, size_t n)
+
+{
+ ssize_t ret =0;
+ struct device *dev = container_of(kobj, struct device, kobj);
+ //struct platform_device *pdev = container_of(dev, struct platform_device, dev);
+ struct spi_device *spi = (struct spi_device *)dev;
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+ unsigned char cmd_str[0x20] = {0};
+ u8 bBuf[32];
+
+ u32 param1 = 0,param2 = 0,param3 = 0;
+ u32 rwaddr =0 ,rwsize = 0;
+ int i;
+ s8 rev = -1;
+ size_t count = 0;
+
+
+ dev_info(&spi->dev, "spidev->speed_hz:%d \n", spi->max_speed_hz);
+
+ sscanf(buf, "%31s %x %x %x", &cmd_str,¶m1,¶m2,¶m3);
+ dev_info(dev, "cmd_str:%s,param1:%x,param2:%x,param3:%x\n",cmd_str,param1,param2,param3);
+
+ dev_info(&spi->dev, "mode %d, %s%s%s%s%u bits/w, %u Hz max --\n",
+ (int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
+ (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
+ (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
+ (spi->mode & SPI_3WIRE) ? "3wire, " : "",
+ (spi->mode & SPI_LOOP) ? "loopback, " : "",
+ spi->bits_per_word, spi->max_speed_hz);
+
+ count = param1;
+ ret = strcmp(cmd_str,"spi_write");
+ if( ret == 0) {
+ count = param1;
+ if (!spidev->tx_buffer) {
+ spidev->tx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->tx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ return n;
+ }
+ }
+ dev_info(dev, "spidev->tx_buffer=0x%x\n",spidev->tx_buffer);
+ for(i = 0;i<count;i++) {
+ spidev->tx_buffer[i]=i;
+ }
+ print_buf_data(spidev->tx_buffer,count);
+ ret = spidev_sync_write(spidev, count);
+ if(ret == count) {
+ dev_info(dev, "send len success(len:%d) \n",ret);
+ }
+ kfree(spidev->tx_buffer);
+ spidev->tx_buffer = NULL;
+ dev_info(dev, "spi write end: \n");
+ }
+
+ ret = strcmp(cmd_str,"spi_read");
+ if(ret == 0) {
+ count = param1;
+ if (!spidev->rx_buffer) {
+ spidev->rx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->rx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ return n;
+ }
+ }
+ memset(spidev->rx_buffer,0x0,bufsiz);
+ ret = spidev_sync_read(spidev, count);
+
+ if(ret == count) {
+ dev_info(dev, "read len success(len:%d) \n",ret);
+ print_buf_data(spidev->rx_buffer,count);
+ }
+ kfree(spidev->rx_buffer);
+ spidev->rx_buffer = NULL;
+ dev_info(dev, "spi read end: \n");
+ }
+
+ ret = strcmp(cmd_str,"write_then_read");
+ if(ret == 0) {
+ count = param1;
+
+ if (!spidev->tx_buffer) {
+ spidev->tx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->tx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ return n;
+ }
+ }
+
+ if (!spidev->rx_buffer) {
+ spidev->rx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->rx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ kfree(spidev->tx_buffer);
+ spidev->tx_buffer = NULL;
+ return n;
+ }
+ }
+ for(i = 0;i<count;i++) {
+ spidev->tx_buffer[i]=i;
+ }
+ //memset(spidev->rx_buffer,0x0,bufsiz);
+ ret = spi_write_then_read(spi, spidev->tx_buffer, count, spidev->rx_buffer, count);
+
+ if(ret == 0) {
+ dev_info(dev, "spi write data(%d bytes) \n",count);
+ print_buf_data(spidev->tx_buffer,count);
+ dev_info(dev, "spi read data(%d bytes) \n",count);
+ print_buf_data(spidev->rx_buffer,count);
+ }
+
+ kfree(spidev->tx_buffer);
+ spidev->tx_buffer = NULL;
+ kfree(spidev->rx_buffer);
+ spidev->rx_buffer = NULL;
+ dev_info(dev, "write_then_read.\n");
+
+ }
+
+
+ ret = strcmp(cmd_str,"write_and_read");
+ if(ret == 0) {
+ count = param1;
+ if (!spidev->tx_buffer) {
+ spidev->tx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->tx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ return n;
+ }
+ }
+
+ if (!spidev->rx_buffer) {
+ spidev->rx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->rx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ kfree(spidev->tx_buffer);
+ spidev->tx_buffer = NULL;
+ return n;
+ }
+ }
+ for(i = 0;i<count;i++) {
+ spidev->tx_buffer[i]=i;
+ }
+ memset(spidev->rx_buffer,0x0,bufsiz);
+ ret = spidev_sync_write_and_read(spidev, count);
+
+ if(ret == count) {
+ dev_info(dev, "spi write data(%d bytes) \n",ret);
+ print_buf_data(spidev->tx_buffer,count);
+ dev_info(dev, "spi read data(%d bytes) \n",ret);
+ print_buf_data(spidev->rx_buffer,count);
+ dev_info(dev, "write_and_read.\n");
+ }
+#if 0
+ kfree(spidev->tx_buffer);
+ spidev->tx_buffer = NULL;
+ kfree(spidev->rx_buffer);
+ spidev->rx_buffer = NULL;
+#endif
+ dev_info(dev, "write_and_read.\n");
+
+ }
+ ret = strcmp(cmd_str,"fifo_flush");
+ if(ret == 0) {
+ unsigned char buff[64] ={0};
+
+ ret = spidev_get_rxfifo(spi,buff);
+ dev_info(dev, "get rx_fifo_len(%d bytes) \n",ret);
+ print_buf_data(buff,ret);
+ }
+
+ ret = strcmp(cmd_str,"timing-set");
+ if(ret == 0) {
+ dev_info(dev, "timing param(%d) \n",param1);
+ set_spi_timing(spi,param1);
+ }
+
+ ret = strcmp(cmd_str,"loop-en");
+ if(ret == 0) {
+ spi->mode |= SPI_LOOP;
+ spi_setup(spi);
+ }
+ ret = strcmp(cmd_str,"loop-dis");
+ if(ret == 0) {
+ spi->mode &= ~SPI_LOOP;
+ spi_setup(spi);
+ }
+ ret = strcmp(cmd_str,"speed_set");
+ if(ret == 0) {
+ spi->max_speed_hz = param1;
+ spi_setup(spi);
+ }
+
+ ret = strcmp(cmd_str,"mode_set");
+ if(ret == 0) {
+ if(param1 != 0 && param1 != 1 && param1 != 2 && param1 != 3)
+ dev_info(dev, "param err(%d) \n",param1);
+ else
+ dev_info(dev, "set spi mode(%d) \n",param1);
+ spi->mode &= (~0x3);
+ spi->mode |= param1;
+ ret = spi_setup(spi);
+ dev_info(dev, "set spi mode(0x%x),ret=%d \n",spi->mode,ret);
+ }
+
+
+ ret = strcmp(cmd_str,"slave_mode_set");
+ if(ret == 0) {
+ if(param1 != 0 && param1 != 1 && param1 != 2 && param1 != 3)
+ dev_info(dev, "param err(%d) \n",param1);
+ else
+ dev_info(dev, "set spi mode(%d) \n",param1);
+ slave_mode_set(spi,param1);
+ }
+
+ ret = strcmp(cmd_str,"send_msg_rand_len");
+ if(ret == 0) {
+
+ count = 0;
+ int times = param1;
+ while(times--) {
+
+ get_random_bytes(&count,4);
+ count = (count%0x1000) + 1;
+ if (!spidev->tx_buffer) {
+ spidev->tx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->tx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ return n;
+ }
+ }
+
+ if (!spidev->rx_buffer) {
+ spidev->rx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->rx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ kfree(spidev->tx_buffer);
+ spidev->tx_buffer = NULL;
+ return n;
+ }
+ }
+ for(i = 0;i<count;i++) {
+ spidev->tx_buffer[i]=i;
+ }
+ //memset(spidev->rx_buffer,0x0,bufsiz);
+ if(strcmp(dev_name(&spi->dev),"spi1.0")==0) {
+ ret = spi_dev_send_one_pack_test(spi, count);
+ }
+ else {
+ ret = spi_dev_slave_send_one_pack_test(spi, count);
+ }
+ if(ret == count) {
+ #if 0
+ dev_info(dev, "spi write data(%d bytes) \n",ret);
+ print_buf_data(spidev->tx_buffer,count);
+ dev_info(dev, "spi read data(%d bytes) \n",ret);
+ print_buf_data(spidev->rx_buffer,count);
+ #endif
+ dev_info(dev, "write_and_read success. retain times:%d rx_cnt_in_tx_thread:%d spidev->rx_cnt_in_rx_thread:%d \n",
+ times,spidev->rx_cnt_in_tx_thread,spidev->rx_cnt_in_rx_thread);
+
+ }
+ msleep((count%5)+1);
+ //usleep_range(5+(count%10),20);
+ }
+#if 0
+ kfree(spidev->tx_buffer);
+ spidev->tx_buffer = NULL;
+ kfree(spidev->rx_buffer);
+ spidev->rx_buffer = NULL;
+#endif
+
+ }
+
+ ret = strcmp(cmd_str,"send_msg_fixed_len");
+ if(ret == 0) {
+ int times = param1;
+ int debug = param3;
+ count = param2;
+ if(count > 4096) {
+ printk("msg_fixed_len(%d bytes) out of range(4KB)\r\n",count);
+ return n;
+ }
+ while(times--) {
+ if (!spidev->tx_buffer) {
+ spidev->tx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->tx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ return n;
+ }
+ }
+
+ if (!spidev->rx_buffer) {
+ spidev->rx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->rx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ kfree(spidev->tx_buffer);
+ spidev->tx_buffer = NULL;
+ return n;
+ }
+ }
+
+ get_random_bytes(spidev->tx_buffer,count);
+ //memset(spidev->rx_buffer,0x0,bufsiz);
+ #if 0
+ for(i = 0;i<count;i++) {
+ spidev->tx_buffer[i]=i;
+ }
+ memset(spidev->rx_buffer,0x0,bufsiz);
+ #endif
+ if(strcmp(dev_name(&spi->dev),"spi1.0")==0) {
+ ret = spi_dev_send_one_pack_test(spi, count);
+ }
+ else {
+ ret = spi_dev_slave_send_one_pack_test(spi, count);
+ }
+ if(ret == count) {
+ if(debug) {
+ dev_info(dev, "spi write data(%d bytes) \n",ret);
+ print_buf_data(spidev->tx_buffer,count);
+ }
+ dev_info(dev, "write_and_read success. retain times:%d rx_cnt_in_tx_thread:%d spidev->rx_cnt_in_rx_thread:%d \n",
+ times,spidev->rx_cnt_in_tx_thread,spidev->rx_cnt_in_rx_thread);
+ }
+ msleep((count%5)+1);
+ }
+#if 0
+ kfree(spidev->tx_buffer);
+ spidev->tx_buffer = NULL;
+ kfree(spidev->rx_buffer);
+ spidev->rx_buffer = NULL;
+#endif
+
+ }
+
+ ret = strcmp(cmd_str,"data_check_ctrl");
+ if(ret == 0) {
+ if(param1) {
+ spidev->is_data_check = true;
+ spidev->rx_data_check_ok_cnt = 0;
+ spidev->rx_data_check_err_cnt = 0;
+ }
+ else {
+ spidev->is_data_check = false;
+ }
+ dev_info(dev, "rx_check_ok_cnt:%d rx_check_err_cnt:%d\n",spidev->rx_data_check_ok_cnt,spidev->rx_data_check_err_cnt);
+ }
+ ret = strcmp(cmd_str,"send_msg_with_check");
+ if(ret == 0) {
+ int times = param1;
+ int debug = param3;
+ count = param2;
+ if(count > 4096 || count < 4) {
+ printk("msg_fixed_len(%d bytes) out of range(4KB)\r\n",count);
+ return n;
+ }
+ while(times--) {
+ if (!spidev->tx_buffer) {
+ spidev->tx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->tx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ return n;
+ }
+ }
+
+ if (!spidev->rx_buffer) {
+ spidev->rx_buffer = kmalloc(bufsiz, GFP_KERNEL);
+ if (!spidev->rx_buffer) {
+ dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+ kfree(spidev->tx_buffer);
+ spidev->tx_buffer = NULL;
+ return n;
+ }
+ }
+
+ get_random_bytes(spidev->tx_buffer,count);
+ spidev->tx_buffer[0] = 0xa5;
+ spidev->tx_buffer[count-1] = 0x7e;
+ ret = data_to_packet(spidev->tx_buffer,count);
+ //memset(spidev->rx_buffer,0x0,bufsiz);
+ if(strcmp(dev_name(&spi->dev),"spi1.0")==0) {
+ ret = spi_dev_send_one_pack_test(spi, count);
+ }
+ else {
+ ret = spi_dev_slave_send_one_pack_test(spi, count);
+ }
+ if(ret == count) {
+ if(debug) {
+ dev_info(dev, "spi write data(%d bytes) \n",ret);
+ print_buf_data(spidev->tx_buffer,count);
+ }
+ dev_info(dev, "complete.retain:%d rx_cnt_in_tx_thread:%d spidev->rx_cnt_in_rx_thread:%d rx_check_ok_cnt:%d rx_check_err_cnt:%d\n",
+ times,spidev->rx_cnt_in_tx_thread,spidev->rx_cnt_in_rx_thread,
+ spidev->rx_data_check_ok_cnt,spidev->rx_data_check_err_cnt);
+ }
+ usleep_range(5+(count%10),20);
+ }
+ }
+
+ ret = strcmp(cmd_str,"gpio_out_val");
+ if(ret == 0) {
+ if(param1)
+ gpio_set_value(spidev->gpio_ex,1);
+ else
+ gpio_set_value(spidev->gpio_ex,0);
+ }
+ ret = strcmp(cmd_str,"test_ktime_get");
+ if(ret == 0) {
+ ktime_t k_time_start = 0;
+ ktime_t k_time_end = 0;
+ ktime_t diff = 0;
+
+ k_time_start = ktime_get();
+ gpio_set_value(spidev->gpio_ex,0);
+ do {
+ diff = ktime_sub(ktime_get(),k_time_start);
+ }while(diff <= (param1*1000));
+ gpio_set_value(spidev->gpio_ex,1);
+ printk("test ktime_get: start=%lld end=%lld diff=%lld \r\n",k_time_start,ktime_get(),diff);
+ }
+ return n;
+
+}
+
+
+SPIDEV_ATTR(spidevinfo);
+
+
+static struct attribute * test_attr[] = {
+ &spidevinfo_attr.attr,
+
+ NULL,
+};
+
+static const struct attribute_group attr_group = {
+ .attrs = test_attr,
+};
+
+static const struct attribute_group *attr_groups[] = {
+ &attr_group,
+
+ NULL,
+};
+#endif
+
+
+#ifdef TEST_SWAP_KERNEL_AND_USER
+
+/* v3e
+spi0(master)-------------------------------------spi1(slave)
+GPIO129 <----------------------------------------INT4(GPIO51)
+INT7(GPIO54) <-----------------------------------GPIO130
+*/
+
+/* v3 mdl
+4#(master) --------------------------------------5#(slave)
+GPIO130 <----------------------------------------INT6(GPIO53)
+INT7(GPIO54) <-----------------------------------GPIO131
+*/
+
+//#define TEST_SPI_SLAVE
+#ifdef TEST_SPI_SLAVE
+#define GPIO_NUM_EX 131
+#define GPIO_NUM_INT 53
+#else
+#define GPIO_NUM_EX 130
+#define GPIO_NUM_INT 54
+#endif
+
+static int spi_dev_pin_init_test(struct spi_device *spi)
+{
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+ enum of_gpio_flags flags;
+ int status = 0;
+
+
+ spidev->pctrl = devm_pinctrl_get(&spi->dev);
+ if(!spidev->pctrl) {
+ dev_info(&spi->dev,"get dev pctrl failed!\n",status);
+ return status;
+ }
+
+ spidev->pint_ex = pinctrl_lookup_state(spidev->pctrl, "int_ex");
+ if (IS_ERR(spidev->pint_ex)) {
+ dev_err(&spi->dev, "TEST: missing pint_ex \n");
+ return status;
+ }
+
+ if (pinctrl_select_state(spidev->pctrl, spidev->pint_ex) < 0) {
+ dev_err(&spi->dev, "TEST: slect pint_ex \n");
+ return status;
+ }
+ if(strcmp(dev_name(&spi->dev),"spi1.0")==0) {
+ spidev->gpio_ex = GPIO_NUM_EX;
+ spidev->gpio_int = GPIO_NUM_INT;
+ } else {
+ spidev->gpio_ex = 130;
+ spidev->gpio_int = 51;
+ }
+ return status;
+
+}
+
+static void send_signal(int sig_no,void *dev_id)
+{
+ int ret;
+ struct spidev_data *spidev = (struct spidev_data *)dev_id;
+ struct kernel_siginfo info;
+ struct task_struct * my_task = NULL;
+
+ //printk("send signal %d to pid %d \n",sig_no,spidev->pid);
+ memset(&info,0,sizeof(struct siginfo));
+ if(spidev->pid == 0) {
+ printk("send_signal pid is not valid \n");
+ return;
+ }
+
+ info.si_signo = sig_no;
+ info.si_code = gpio_get_value(spidev->gpio_int);
+ info.si_errno = gpio_get_value(spidev->gpio_ex);
+ rcu_read_lock();
+ my_task = pid_task(find_vpid(spidev->pid),PIDTYPE_PID);
+ rcu_read_unlock();
+
+ if(!my_task) {
+ printk("%s get pid_task failed! \n",__FUNCTION__);
+ return;
+ }
+ ret = send_sig_info(sig_no, &info, my_task);
+ if(ret < 0)
+ printk("send signal failed! \n");
+
+}
+
+static int spi_dev_sig_process_test(void *arg)
+{
+ struct spi_device *spi = (struct spi_device *)arg;
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+
+ while(1) {
+ down(&spidev->sig_req);
+ send_signal(SIGUSR1,spidev);
+
+ }
+ return 0;
+}
+static void send_dma_cfg_done_signal(int sig_no,void *dev_id)
+{
+ int ret;
+ struct spidev_data *spidev = (struct spidev_data *)dev_id;
+ struct kernel_siginfo info;
+ struct task_struct * my_task = NULL;
+ int dma_cfg_done = 0;
+ //printk("send signal %d to pid %d \n",sig_no,spidev->pid);
+ memset(&info,0,sizeof(struct siginfo));
+
+ if(spidev->dma_cfg_done == 1) {
+ dma_cfg_done = spidev->dma_cfg_done;
+ spidev->dma_cfg_done= 0;
+ }
+ if(spidev->pid == 0) {
+ printk("%s is not valid\n",__FUNCTION__);
+ return;
+ }
+ info.si_signo = sig_no;
+ info.si_errno = dma_cfg_done;
+ rcu_read_lock();
+ my_task = pid_task(find_vpid(spidev->pid),PIDTYPE_PID);
+ rcu_read_unlock();
+
+ if(!my_task) {
+ printk("%s get pid_task failed! \n",__FUNCTION__);
+ return;
+ }
+ ret = send_sig_info(sig_no, &info, my_task);
+ if(ret < 0)
+ printk("send signal failed! \n");
+
+}
+
+static int spi_dev_dma_cfg_done_process_test(void *arg)
+{
+ struct spi_device *spi = (struct spi_device *)arg;
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+
+ while(1) {
+ down(&spidev->sem_dma_cfg_done);
+ send_dma_cfg_done_signal(SIGUSR2,spidev);
+ }
+ return 0;
+}
+
+static irqreturn_t spidev_hand_shake_irq(int irqno, void *dev_id)
+{
+ struct spidev_data *spidev = (struct spidev_data *)dev_id;
+
+ int gpio_out_status = gpio_get_value(spidev->gpio_ex);
+ int gpio_int_status = gpio_get_value(spidev->gpio_int);
+
+ up(&spidev->sig_req);
+ dev_dbg(&spidev->spi->dev,"out=%d int=%d \r\n",gpio_out_status,gpio_int_status);
+
+ return IRQ_HANDLED;
+}
+
+
+static int spi_dev_irq_init_test(struct spi_device *spi)
+{
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+ int irq = 0,ret = 0;
+
+ if(!spi || !spidev) {
+ ret = -ENOENT;
+ return ret;
+ }
+
+ sema_init(&spidev->sig_req, 0);
+ sema_init(&spidev->sem_dma_cfg_done, 0);
+ kernel_thread(spi_dev_sig_process_test,spi, 0); /* fork the main thread */
+ kernel_thread(spi_dev_dma_cfg_done_process_test,spi, 0); /* fork the main thread */
+ irq = irq_of_parse_and_map(spi->dev.of_node, 0);
+ if (irq <= 0) {
+ dev_err(&spi->dev, "ERROR: invalid interrupt number, irq = %d\n",irq);
+ return -EBUSY;
+ }
+ spidev->irq = irq;
+ dev_info(&spi->dev, "used interrupt num is %d\n", spidev->irq);
+
+ ret = devm_request_irq(&spi->dev, spidev->irq, spidev_hand_shake_irq,
+ 0, dev_name(&spi->dev), spidev);
+
+ if (ret < 0) {
+ dev_err(&spi->dev, "probe - cannot get IRQ (%d)\n", ret);
+ return ret;
+ }
+
+ return ret;
+
+}
+
+#endif
+
+#ifdef TEST_SWAP_KERNEL_AND_USER
+void spi_dev_send_dma_cfg_down(struct spi_device *spi)
+{
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+ spidev->dma_cfg_done = 1;
+ up(&spidev->sem_dma_cfg_done);
+}
+#else
+void spi_dev_send_dma_cfg_down(struct spi_device *spi)
+{
+ return;
+}
+#endif
+/*-------------------------------------------------------------------------*/
+
+static int spidev_probe(struct spi_device *spi)
+{
+ struct spidev_data *spidev;
+ int status;
+ unsigned long minor;
+ u32 val;
+ /*
+ * spidev should never be referenced in DT without a specific
+ * compatible string, it is a Linux implementation thing
+ * rather than a description of the hardware.
+ */
+ WARN(spi->dev.of_node &&
+ of_device_is_compatible(spi->dev.of_node, "spidev"),
+ "%pOF: buggy DT: spidev listed directly in DT\n", spi->dev.of_node);
+
+ spidev_probe_acpi(spi);
+
+ /* Allocate driver data */
+ spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
+ if (!spidev)
+ return -ENOMEM;
+
+ /* Initialize the driver data */
+ spidev->spi = spi;
+ spin_lock_init(&spidev->spi_lock);
+ mutex_init(&spidev->buf_lock);
+
+ INIT_LIST_HEAD(&spidev->device_entry);
+
+ if (device_property_read_u32(&spi->dev, "enable_dma",&val)) {
+ spi->dma_used = 0;
+ dev_err(&spi->dev,"enable_dma get failed");
+ }
+ else {
+ spi->dma_used = val;
+ dev_info(&spi->dev,"enable_dma = 0x%x",val);
+ }
+
+ if (device_property_read_u32(&spi->dev, "enable_trans_gap",&val)) {
+ spi->trans_gaped = 0;
+ dev_err(&spi->dev,"enable_trans_gap get failed");
+ }
+ else {
+ spi->trans_gaped = val;
+ dev_info(&spi->dev,"enable_trans_gap = 0x%x",val);
+ }
+
+ if (device_property_read_u32(&spi->dev, "trans_gap_num",&val)) {
+ spi->trans_gap_num = 0;
+ dev_err(&spi->dev,"trans_gap_num get failed");
+ }
+ else {
+ spi->trans_gap_num = val;
+ dev_info(&spi->dev,"trans_gap_num = 0x%x",val);
+ }
+
+ // yu.dong@20240617 [T106BUG-641] SPI packet loss problem, add kernel buffer scheme.
+
+ /* If we can allocate a minor number, hook up this device.
+ * Reusing minors is fine so long as udev or mdev is working.
+ */
+ mutex_lock(&device_list_lock);
+ minor = find_first_zero_bit(minors, N_SPI_MINORS);
+ if (minor < N_SPI_MINORS) {
+ struct device *dev;
+
+ spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
+ dev = device_create(spidev_class, &spi->dev, spidev->devt,
+ spidev, "spidev%d.%d",
+ spi->master->bus_num, spi->chip_select);
+ status = PTR_ERR_OR_ZERO(dev);
+ } else {
+ dev_dbg(&spi->dev, "no minor number available!\n");
+ status = -ENODEV;
+ }
+ if (status == 0) {
+ set_bit(minor, minors);
+ list_add(&spidev->device_entry, &device_list);
+ }
+ mutex_unlock(&device_list_lock);
+
+ spidev->speed_hz = spi->max_speed_hz;
+ spidev->rd_from_rx_buffer = 0;
+ if (status == 0)
+ spi_set_drvdata(spi, spidev);
+ else
+ kfree(spidev);
+ spi_setup(spi);
+ if(0 == status && spi->master->slave)
+ device_init_wakeup(&spi->dev, true);
+#ifdef SPIDEV_DEBUG
+ int ret = sysfs_create_groups(&spi->dev.kobj, attr_groups);
+
+ if (ret) {
+ dev_err(&spi->dev, "create test_kobj attr group fain error=%d\n", ret);
+ return ret;
+ }
+
+ ret = spidev_debug_test_init(spi);
+ if (ret) {
+ dev_err(&spi->dev, "spidev_debug_test_init error=%d\n", ret);
+ return ret;
+ }
+#endif
+
+#ifdef TEST_SWAP_KERNEL_AND_USER
+ int ret;
+ spidev->dma_cfg_done = 0;
+ spidev->pid = 0;
+ ret =spi_dev_pin_init_test(spi);
+ if(ret) {
+ dev_info(&spi->dev, "spi_dev_pin_init_test,ret=%d \n",ret);
+ return ret;
+ }
+
+ ret =spi_dev_irq_init_test(spi);
+ if(ret) {
+ dev_info(&spi->dev, "spi_dev_irq_init_test,ret=%d \n",ret);
+ return ret;
+ }
+#endif
+ return status;
+}
+
+static int spidev_remove(struct spi_device *spi)
+{
+ struct spidev_data *spidev = spi_get_drvdata(spi);
+
+ /* prevent new opens */
+ mutex_lock(&device_list_lock);
+ /* make sure ops on existing fds can abort cleanly */
+ spin_lock_irq(&spidev->spi_lock);
+ spidev->spi = NULL;
+ spin_unlock_irq(&spidev->spi_lock);
+
+ list_del(&spidev->device_entry);
+ device_destroy(spidev_class, spidev->devt);
+ clear_bit(MINOR(spidev->devt), minors);
+ if (spidev->users == 0)
+ kfree(spidev);
+ mutex_unlock(&device_list_lock);
+
+ return 0;
+}
+
+static struct spi_driver spidev_spi_driver = {
+ .driver = {
+ .name = "spidev",
+ .of_match_table = of_match_ptr(spidev_dt_ids),
+ .acpi_match_table = ACPI_PTR(spidev_acpi_ids),
+ },
+ .probe = spidev_probe,
+ .remove = spidev_remove,
+
+ /* NOTE: suspend/resume methods are not necessary here.
+ * We don't do anything except pass the requests to/from
+ * the underlying controller. The refrigerator handles
+ * most issues; the controller driver handles the rest.
+ */
+};
+
+/*-------------------------------------------------------------------------*/
+
+static int __init spidev_init(void)
+{
+ int status;
+
+ /* Claim our 256 reserved device numbers. Then register a class
+ * that will key udev/mdev to add/remove /dev nodes. Last, register
+ * the driver which manages those device numbers.
+ */
+ BUILD_BUG_ON(N_SPI_MINORS > 256);
+ status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
+ if (status < 0)
+ return status;
+
+ spidev_class = class_create(THIS_MODULE, "spidev");
+ if (IS_ERR(spidev_class)) {
+ unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
+ return PTR_ERR(spidev_class);
+ }
+
+ status = spi_register_driver(&spidev_spi_driver);
+ if (status < 0) {
+ class_destroy(spidev_class);
+ unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
+ }
+ return status;
+}
+module_init(spidev_init);
+
+static void __exit spidev_exit(void)
+{
+ spi_unregister_driver(&spidev_spi_driver);
+ class_destroy(spidev_class);
+ unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
+}
+module_exit(spidev_exit);
+
+MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
+MODULE_DESCRIPTION("User mode SPI device interface");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("spi:spidev");