//u8 test[300];
//void spi_write_fifo(unsigned char * data, int len) {
// int j;
///*
//// test[0] = WRITE_TX_FIFO;
//// memcpy(test+1, data, len);
//// mutex_lock(&mutex_spi);
//// printk(KERN_ALERT "spi_write_fifo: write %d\n", len);
// cs_low();
// u8 cmd = WRITE_TX_FIFO;
// spidev_global.buffer = &cmd;
// spidev_sync_write(&spidev_global, 1);
//// for (j = 0; j < len; j++) {
//// cmd = data[j];
//// spidev_sync_write(&spidev_global, 1);
//// }
// spidev_global.buffer = data;
// spidev_sync_write(&spidev_global, len);
// cs_high();
//
//// mutex_unlock(&mutex_spi);
// */
// ssize_t ret;
// u8 cmd = WRITE_TX_FIFO;
// struct spi_transfer t_cmd = {
// .tx_buf = &cmd,
// .len = 1,
// };
// struct spi_transfer t_data = {
// .tx_buf = data,
// .len = len,
// };
// struct spi_message m;
//
// spi_message_init(&m);
// spi_message_add_tail(&t_cmd, &m);
// spi_message_add_tail(&t_data, &m);
// ret = spidev_sync(spidev_global, &m);
//}
void spi_write_fifo(unsigned char * data, int len) {
int j;
ssize_t ret;
u8 cmd = 0x66;
struct spi_transfer t_cmd = {
.tx_buf = &cmd,
.len = 1,
.cs_change = 0,
};
struct spi_transfer t_data = {
.tx_buf = data,
.len = len,
.cs_change = 0,
};
struct spi_message m;
spi_message_init(&m);
spi_message_add_tail(&t_cmd, &m);
spi_message_add_tail(&t_data, &m);
cs_low();
ret = spidev_sync(&spidev_global, &m);
cs_high();
}
void spi_read_fifo(unsigned char * st, int len) {
int j;
// mutex_lock(&mutex_spi);
cs_low();
u8 cmd = READ_RX_FIFO;
// u8 ret;
spidev_global.buffer = &cmd;
spidev_sync_write(&spidev_global, 1);
cmd = 0xff;
// for (j = 0; j < len; j++) {
// spidev_sync_transfer(&spidev_global, &cmd, &(st[j]), 1);
//
// }
spidev_global.buffer = st;
spidev_sync_read(&spidev_global,len);
cs_high();
// mutex_unlock(&mutex_spi);
//Serial.println();
// unsigned char p[] = {READ_RX_FIFO};
// SendCmdReceiveAnswer(1,payload_length,p);
}
void get_fifo_info(u8 *rx) // 复位发射和接收 FIFO
{
// u8 rx[10];
unsigned char p[2];
p[0] = FIFO_INFO;
p[1] = 0x00;
SendCmdReceiveAnswer(2, 3, p, rx);
// spi_write(2,p);
}
u8 * SendCmdReceiveAnswer(int byteCountTx, int byteCountRx, u8 * in_buff,
u8 * out_buff) {
/* TEST */
// if (byteCountTx == 1)
// byteCountTx++;
char answer, i, j, k;
//发送命令
//printk(KERN_ALERT "Send CMD! \n");
mutex_lock(&mutex_spi);
cs_low();
// for (i=0; i<byteCountTx; i++){
// spidev_global.buffer = &(in_buff[i]);
// //printk(KERN_ALERT "%x ", *(spidev_global.buffer));
// spidev_sync_write(&spidev_global, 1);
// }
spidev_global.buffer = in_buff;
spidev_sync_write(&spidev_global, byteCountTx);
cs_high();
// ndelay(100);
// ndelay(10);
cs_low();
// if(!getCTS_gpio())
getCTS();
if(byteCountRx == 0) {
cs_high();
mutex_unlock(&mutex_spi);
return NULL;
}
// for (k=0; k<byteCountRx; k++){
// spidev_global.buffer = &(out_buff[k]);
// spidev_sync_read(&spidev_global, 1);
//
//// printk(KERN_ALERT "%x ", *(spidev_global.buffer));
// }
spidev_global.buffer = out_buff;
spidev_sync_read(&spidev_global, byteCountRx);
cs_high();
mutex_unlock(&mutex_spi);
return out_buff;
}
static inline ssize_t
spidev_sync_write(struct spidev_data *spidev, size_t len)
{
struct spi_transfer t = {
.tx_buf = spidev->buffer,
.len = len,
};
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->buffer,
.len = len,
};
struct spi_message m;
spi_message_init(&m);
spi_message_add_tail(&t, &m);
return spidev_sync(spidev, &m);
}
/*-------------------------------------------------------------------------*/
/* 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 = 0;
/* chipselect only toggles at start or end of operation */
if (count > bufsiz)
return -EMSGSIZE;
spidev = filp->private_data;
mutex_lock(&spidev->buf_lock);
status = spidev_sync_read(spidev, count);
if (status > 0) {
unsigned long missing;
missing = copy_to_user(buf, spidev->buffer, status);
if (missing == status)
status = -EFAULT;
else
status = status - missing;
}
mutex_unlock(&spidev->buf_lock);
return status;
}
/* 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 = 0;
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->buffer, buf, count);
if (missing == 0) {
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;
u8 *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.
*/
buf = spidev->buffer;
total = 0;
for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;
n;
n--, k_tmp++, u_tmp++) {
k_tmp->len = u_tmp->len;
total += k_tmp->len;
if (total > bufsiz) {
status = -EMSGSIZE;
goto done;
}
if (u_tmp->rx_buf) {
k_tmp->rx_buf = buf;
if (!access_ok(VERIFY_WRITE, (u8 __user *)
(uintptr_t) u_tmp->rx_buf,
u_tmp->len))
goto done;
}
if (u_tmp->tx_buf) {
k_tmp->tx_buf = buf;
if (copy_from_user(buf, (const u8 __user *)
(uintptr_t) u_tmp->tx_buf,
u_tmp->len))
goto done;
}
buf += k_tmp->len;
k_tmp->cs_change = !!u_tmp->cs_change;
k_tmp->bits_per_word = u_tmp->bits_per_word;
k_tmp->delay_usecs = u_tmp->delay_usecs;
k_tmp->speed_hz = u_tmp->speed_hz;
#ifdef VERBOSE
dev_dbg(&spi->dev,
" xfer len %zd %s%s%s%dbits %u usec %uHz\n",
u_tmp->len,
u_tmp->rx_buf ? "rx " : "",
u_tmp->tx_buf ? "tx " : "",
u_tmp->cs_change ? "cs " : "",
u_tmp->bits_per_word ? : spi->bits_per_word,
u_tmp->delay_usecs,
u_tmp->speed_hz ? : 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 */
buf = spidev->buffer;
for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) {
if (u_tmp->rx_buf) {
if (__copy_to_user((u8 __user *)
(uintptr_t) u_tmp->rx_buf, buf,
u_tmp->len)) {
status = -EFAULT;
goto done;
}
}
buf += u_tmp->len;
}
status = total;
done:
kfree(k_xfers);
return status;
}
static long
spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
int err = 0;
int retv
