spi_sync和spi_async使用场景

SPI (Serial Peripheral Interface) 是一种常用的全双工通信协议，在微控制器或嵌入式系统中常用于与外部设备如存储器、传感器等进行数据交换。SPI同步模式（spi_sync）和异步模式（spi_async）有各自的使用场景：

**spi_sync (同步模式)**：
- 适合于对传输速度和数据一致性要求较高的场合，因为它需要主机（Master）严格控制传输的时序，比如读取固定长度的数据块或需要精确响应时间的应用。
- 使用时，主机能够直接读取或写入数据，无需额外处理中断，程序流程相对简单。
- 适用于实时性强，不需要立即处理大量数据，而是按部就班操作的情况。

**spi_async (异步模式)**：
- 异步模式常用于对传输速率要求不高但数据量大，或者是需要同时处理其他任务的场景。它允许主机会在完成数据发送或接收后通过中断触发回调函数，实现非阻塞操作。
- 适用于事件驱动型应用，例如物联网节点中，可能同时需要监听多个输入，而SPI通信只是众多任务之一。
- 在处理高并发或者中断密集型任务时，async模式有助于提高系统的响应能力和吞吐量。

相关问题

epoll 字符设备驱动 使用spi通信驱动代码

以下是一个使用 epoll 和 SPI 通信的字符设备驱动代码示例：

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/spi/spi.h>
#include <linux/uaccess.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/irq.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/poll.h>
#include <linux/slab.h>

#define DRIVER_NAME "my_spi_driver"
#define DEVICE_NAME "my_spi_device"
#define MAX_BUF_LEN 256

static struct spi_device *spi_dev;
static struct cdev my_cdev;
static dev_t my_dev;
static struct class *my_class;
static struct device *my_device;
static char spi_buf[MAX_BUF_LEN];
static int buf_len;
static int irq_gpio = -1;
static volatile int irq_flag = 0;
static struct fasync_struct *async_queue;

static DECLARE_WAIT_QUEUE_HEAD(irq_wait_queue);

static irqreturn_t my_spi_irq_handler(int irq, void *dev_id)
{
    irq_flag = 1;
    wake_up_interruptible(&irq_wait_queue);
    kill_fasync(&async_queue, SIGIO, POLL_IN);
    return IRQ_HANDLED;
}

static int my_spi_open(struct inode *inode, struct file *filp)
{
    int ret = 0;
    printk(KERN_INFO "my_spi: opening device\n");

    ret = spi_sync(spi_dev, NULL, 0);
    if (ret < 0)
    {
        printk(KERN_ERR "my_spi: SPI sync failed\n");
        return ret;
    }

    return 0;
}

static int my_spi_release(struct inode *inode, struct file *filp)
{
    printk(KERN_INFO "my_spi: closing device\n");
    return 0;
}

static ssize_t my_spi_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    int ret = 0;

    if (count > buf_len)
        count = buf_len;

    ret = copy_to_user(buf, spi_buf, count);
    if (ret < 0)
    {
        printk(KERN_ERR "my_spi: copy_to_user failed\n");
        return ret;
    }

    return count;
}

static ssize_t my_spi_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
    int ret = 0;

    if (count > MAX_BUF_LEN)
        count = MAX_BUF_LEN;

    ret = copy_from_user(spi_buf, buf, count);
    if (ret < 0)
    {
        printk(KERN_ERR "my_spi: copy_from_user failed\n");
        return ret;
    }

    buf_len = count;

    return count;
}

static unsigned int my_spi_poll(struct file *filp, poll_table *wait)
{
    unsigned int mask = 0;

    poll_wait(filp, &irq_wait_queue, wait);

    if (irq_flag != 0)
        mask |= POLLIN | POLLRDNORM;

    return mask;
}

static int my_spi_fasync(int fd, struct file *filp, int mode)
{
    return fasync_helper(fd, filp, mode, &async_queue);
}

static struct file_operations my_spi_fops = {
    .owner = THIS_MODULE,
    .open = my_spi_open,
    .release = my_spi_release,
    .read = my_spi_read,
    .write = my_spi_write,
    .poll = my_spi_poll,
    .fasync = my_spi_fasync,
};

static int my_spi_probe(struct spi_device *spi)
{
    int ret = 0;

    printk(KERN_INFO "my_spi: probing device\n");

    spi_dev = spi;

    ret = gpio_request(spi->irq, "my_spi_irq");
    if (ret < 0)
    {
        printk(KERN_ERR "my_spi: request irq gpio failed\n");
        return ret;
    }

    irq_gpio = spi->irq;
    ret = gpio_direction_input(irq_gpio);
    if (ret < 0)
    {
        printk(KERN_ERR "my_spi: set irq gpio direction failed\n");
        goto fail;
    }

    ret = request_irq(gpio_to_irq(irq_gpio), my_spi_irq_handler, IRQF_TRIGGER_RISING, "my_spi_irq_handler", NULL);
    if (ret < 0)
    {
        printk(KERN_ERR "my_spi: request irq failed\n");
        goto fail;
    }

    ret = alloc_chrdev_region(&my_dev, 0, 1, DRIVER_NAME);
    if (ret < 0)
    {
        printk(KERN_ERR "my_spi: alloc_chrdev_region failed\n");
        goto fail;
    }

    cdev_init(&my_cdev, &my_spi_fops);
    my_cdev.owner = THIS_MODULE;

    ret = cdev_add(&my_cdev, my_dev, 1);
    if (ret < 0)
    {
        printk(KERN_ERR "my_spi: cdev_add failed\n");
        goto fail;
    }

    my_class = class_create(THIS_MODULE, DRIVER_NAME);
    if (IS_ERR(my_class))
    {
        printk(KERN_ERR "my_spi: class_create failed\n");
        ret = PTR_ERR(my_class);
        goto fail;
    }

    my_device = device_create(my_class, NULL, my_dev, NULL, DEVICE_NAME);
    if (IS_ERR(my_device))
    {
        printk(KERN_ERR "my_spi: device_create failed\n");
        ret = PTR_ERR(my_device);
        goto fail;
    }

    return 0;

fail:
    if (irq_gpio != -1)
        gpio_free(spi->irq);

    return ret;
}

static int my_spi_remove(struct spi_device *spi)
{
    printk(KERN_INFO "my_spi: removing device\n");

    device_destroy(my_class, my_dev);
    class_destroy(my_class);
    cdev_del(&my_cdev);
    unregister_chrdev_region(my_dev, 1);

    free_irq(gpio_to_irq(irq_gpio), NULL);
    gpio_free(irq_gpio);

    return 0;
}

static struct spi_driver my_spi_driver = {
    .driver = {
        .name = "my_spi_driver",
        .owner = THIS_MODULE,
    },
    .probe = my_spi_probe,
    .remove = my_spi_remove,
};

static int __init my_spi_init(void)
{
    int ret = 0;

    printk(KERN_INFO "my_spi: initializing driver\n");

    ret = spi_register_driver(&my_spi_driver);
    if (ret < 0)
    {
        printk(KERN_ERR "my_spi: spi_register_driver failed\n");
        return ret;
    }

    return 0;
}

static void __exit my_spi_exit(void)
{
    printk(KERN_INFO "my_spi: exiting driver\n");
    spi_unregister_driver(&my_spi_driver);
}

module_init(my_spi_init);
module_exit(my_spi_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("My SPI Driver");

该驱动程序使用 SPI 通信与外部设备通信，并使用字符设备接口提供用户空间访问。它使用 epoll 和 fasync 机制来实现非阻塞 I/O 和异步通知。它还使用了一个 GPIO 中断来实现异步通知。该驱动程序在初始化时注册了一个 SPI 设备驱动程序，当 SPI 总线上有新设备被探测到时，驱动程序的 probe 函数将被调用。在 probe 函数中，驱动程序会为该设备分配一个字符设备号，并创建一个字符设备文件，以便用户空间程序可以打开和读写该设备。当 SPI 设备从系统中移除时，驱动程序的 remove 函数将被调用，该函数将执行清理操作，以确保系统在设备被移除时不会出现问题。