//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; }
void read_frr_b(u8 *value) { u8 cmd; u8 rx[3]; int j; cmd = FRR_B_READ; // mutex_lock(&mutex_spi); cs_low(); spidev_global.buffer = &cmd; spidev_sync_write(&spidev_global, 1); cmd = 0x00; spidev_sync_transfer(&spidev_global, &cmd, value, 1); cs_high(); // mutex_unlock(&mutex_spi); // while(*value == 0 || *value == 0xff) // { // mutex_lock(&mutex_spi); // get_ph_status(rx); // mutex_unlock(&mutex_spi); // *value = rx[1]; // } }
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