spi驱动框架学习记录

目录

1. spi驱动框架简要描述

2. 通过编写itop4412开发板rfid接口的spi驱动来熟悉spi驱动的编写

1. spi驱动框架简要描述

　　如上图所示，spi硬件架构中，一个spi控制器可以同时接多个spi外设，通信时通过片选脚来选择和某个spi外设通信。

　　如上图，在linux内核中，将spi驱动分为spi主机控制器驱动和具体的spi设备驱动两个部分；spi主机控制器设备和spi主机控制器驱动挂载在平台总线上，在spi控制器驱动加载成功后，会创建一个SPI总线，spi主控制上连接的spi设备以及对应的spi设备驱动挂载在这个SPI总线上。

　　spi控制器驱动部分大致实现如下功能

　　1. 通过spi总线，将具体的spi设备和spi设备驱动匹配起来

　　2. 提供数据收发函数给spi设备驱动，将spi设备驱动下发的数据转成总线波形发送出去，将总线上接收的数据上发给spi设备驱动

       spi控制器驱动一般由厂家编写，比如itop4412开发板，spi控制器驱动对应drivers/spi/spi-s3c64xx.c这个文件；

       spi控制器驱动中使用虚拟平台驱动结构体platform_driver注册的代码段如下

drivers/spi/spi-s3c64xx.c

static struct platform_driver s3c64xx_spi_driver = {
    .driver = {
        .name    = "s3c64xx-spi",
        .pm = &s3c64xx_spi_pm,
        .of_match_table = of_match_ptr(s3c64xx_spi_dt_match),
    },
    .probe = s3c64xx_spi_probe,
    .remove = s3c64xx_spi_remove,
    .id_table = s3c64xx_spi_driver_ids,
};

module_platform_driver(s3c64xx_spi_driver);

　　在编写spi设备驱动时，我们只需要在对应spi控制器中添加spi设备描述，然后编写spi设备驱动即可；

　　有两种方法添加spi设备描述，第一，在arm/mach-xxx对应的板级描述文件的spi_board_info结构体中添加；第二，在设备树中的spi控制器节点中添加。

2. 通过编写itop4412开发板rfid接口的spi驱动来熟悉spi驱动的编写

2.1 rfid接口对应的引脚图

　　如上图所示，rfid的spi接在SPI_2控制器上，片选引脚是GPC1_2

2.2 在设备树文件的spi_2控制器节点中添加rfid的spi设备

　　spi_2控制器节点如下图所示

　　在dts文件中，引用spi_2节点，添加rfid的spi设备

　　在设备树spi控制器的节点中添加spi设备后，内核解析设备树时，就会在这个控制器对应的spi总线上注册一个spi设备spi_device，设备对应的属性名是”spidev”。

2.3 编写spi设备驱动

　　spi设备驱动主体由两部分组成：

       1. 创建注册struct spi_driver结构体，指定结构体的compatible属性为”spidev”，这样就可以和spi设备匹配

static const struct of_device_id spidev_dt_ids[] = {
    { .compatible = "spidev" },
    {},
};
MODULE_DEVICE_TABLE(of, spidev_dt_ids);

static struct spi_driver spidev_spi_driver = {
    .driver = {
        .name =        "spidev",
        .of_match_table = of_match_ptr(spidev_dt_ids),
    },
    .probe =    spidev_probe,
    .remove =    spidev_remove,

};

spi_register_driver(&spidev_spi_driver);

　　2. 在应用程序接口函数中使用spi控制器驱动程序提供的接口函数收发数据，函数主体如下

/* 数据传输结构体 */
struct spi_transfer    t = {
    .tx_buf        = tx_buf,
    .len        = count,
};

struct spi_message    m;
spi_message_init(&m);
spi_message_add_tail(&t, &m);
DECLARE_COMPLETION_ONSTACK(done);
m.complete = complete;
m.context = &done;
    
printk("spi_async send begin!
");
/* 异步收发函数 */
status = spi_async(my_spi,&m);
if(status == 0){
    wait_for_completion(&done);
    status = m.status;
    if (status == 0)
        status = m.actual_length;
}

设备驱动示例如下，驱动中注册了一个spi_driver，然后创建了一个杂项设备和应用程序交互

#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/miscdevice.h>

#include <linux/spi/spi.h>
#include <linux/spi/spidev.h>

#include <linux/uaccess.h>

/* 创建spi结构体，填入设备树属性 */
/* 创建杂项设备，用于读写及ioctl控制 */

static struct spi_device *my_spi;
static spinlock_t        spi_lock;
static struct mutex        buf_lock;

static long
rc522_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;

    int i;
    int status;
    struct spi_message    m;
    char *usertx_buf, *userrx_buf, txbuf[255];

    copy_from_user(&ioc, (struct spi_ioc_transfer __user *)arg, sizeof(struct spi_ioc_transfer));
    usertx_buf = (unsigned long)ioc.tx_buf;
    copy_from_user(txbuf, usertx_buf, ioc.len);

    printk("ioc.len = %d
", ioc.len);
#if 1
    struct spi_transfer    t = {
        .tx_buf        = txbuf,
        .rx_buf     = txbuf,
        .len        = ioc.len,
    };
    
    spi_message_init(&m);
    spi_message_add_tail(&t, &m);
    DECLARE_COMPLETION_ONSTACK(done);
    m.complete = complete;
    m.context = &done;

    printk("spi_async spidev_ioctl begin!
");
    status = spi_async(my_spi,&m);
    if(status == 0){
        wait_for_completion(&done);
        status = m.status;
        if (status == 0)
            status = m.actual_length;
    }

    userrx_buf = (unsigned long)ioc.rx_buf;
    copy_to_user(userrx_buf, txbuf, ioc.len);

    printk("
");
#endif
    return status;
}

static ssize_t rc522_write(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    int status;
    unsigned char tx_buf[512];
    
    if (count > 512) {
        printk("count > 512, rc522_write write failed, return.
");
        return -EMSGSIZE;
    }
    
    status = copy_from_user(tx_buf,buf,count);
    
    struct spi_transfer    t = {
        .tx_buf        = tx_buf,
        .len        = count,
    };
    struct spi_message    m;
    spi_message_init(&m);
    spi_message_add_tail(&t, &m);
    DECLARE_COMPLETION_ONSTACK(done);
    m.complete = complete;
    m.context = &done;
    
    printk("spi_async send begin!
");
    status = spi_async(my_spi,&m);
    if(status == 0){
        wait_for_completion(&done);
        status = m.status;
        if (status == 0)
            status = m.actual_length;
    }
    return status;
}

static ssize_t rc522_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    int status;
    unsigned char rx_buf[255];

    struct spi_transfer    t = {
        .rx_buf        = rx_buf,
        .len        = count,
    };
    struct spi_message    m;
    spi_message_init(&m);
    spi_message_add_tail(&t, &m);
    DECLARE_COMPLETION_ONSTACK(done);
    m.complete = complete;
    m.context = &done;
    
    printk("spi_async read begin!
");
    status = spi_async(my_spi,&m);
    if(status == 0){
        wait_for_completion(&done);
        status = m.status;
        if (status == 0)
            status = m.actual_length;
    }
    
    status = copy_to_user(buf,&rx_buf,status);
    
    return status;
}

int rc522_open(struct inode *inode,struct file *filp)
{
    printk("rc522_open.
");
    return 0;
}

static struct file_operations rc522_ops = {
    .owner     = THIS_MODULE,
    .open     = rc522_open,
    .read    = rc522_read,
    .write     = rc522_write,
    .unlocked_ioctl = rc522_ioctl,
};

static struct miscdevice rc522_dev = {
    .minor    = MISC_DYNAMIC_MINOR,
    .fops    = &rc522_ops,
    .name    = "rc522",
};

#ifdef CONFIG_OF
static const struct of_device_id spidev_dt_ids[] = {
    { .compatible = "spidev" },
    {},
};
MODULE_DEVICE_TABLE(of, spidev_dt_ids);
#endif

static int spidev_probe(struct spi_device *spi)
{
    int            status;

    /* 检查是否是设备树节点 */
    if (spi->dev.of_node && !of_match_device(spidev_dt_ids, &spi->dev)) {
        dev_err(&spi->dev, "buggy DT: spidev listed directly in DT
");
        WARN_ON(spi->dev.of_node &&
            !of_match_device(spidev_dt_ids, &spi->dev));
    }

    my_spi = spi;
    spin_lock_init(&spi_lock);
    mutex_init(&buf_lock);

    return status;
}

static int spidev_remove(struct spi_device *spi)
{
    printk("spidev_remove
");
    return 0;
}

static struct spi_driver spidev_spi_driver = {
    .driver = {
        .name =        "spidev",
        .of_match_table = of_match_ptr(spidev_dt_ids),
    },
    .probe =    spidev_probe,
    .remove =    spidev_remove,

};

static int __init spidrv_dts_init(void)
{
    int status;

    misc_register(&rc522_dev);

    status = spi_register_driver(&spidev_spi_driver);
    if (status < 0) {
        misc_deregister(&rc522_dev);
    }
    return status;
}

static void __exit spidrv_dts_exit(void)
{
    spi_unregister_driver(&spidev_spi_driver);
    misc_deregister(&rc522_dev);
}

module_init(spidrv_dts_init);
module_exit(spidrv_dts_exit);

MODULE_LICENSE("GPL");

测试应用程序如下，在测试时，将spi接口的MOSI和MISO引脚对接，这样spi就可以收到自己发送的数据，这两个引脚是rfid接口的外侧第3脚和内测di4脚

#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/types.h>
#include <linux/spi/spidev.h>
#include <pthread.h>
#include <errno.h>
#include <time.h>
#include <string.h>

#define filename  "/dev/rc522"

#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))

/* 读写需要互斥 */
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
/* 1. 打开设备 */
static int fd;
/* 2. 创建三个线程 */
/* 3. 一个线程每隔2s向设备写数据 */
static void createThread_write(void);
static void *thread_func_write(void *arg);
/* 4. 另一个线程不停地读数据 */
static void createThread_read(void);
static void *thread_func_read(void *arg);
/* 5. 第三个线程用ioctl测试数据读写 */
static void createThread_ioctl(void);
static void *thread_func_ioctl(void *arg);

/* repetition repetition repetition */
/* 按照正常的文件读写，不停地写数据 */
/* 以阻塞的方式读数据 */
/* XXX 多线程操作，将同步阻塞信号通知都走一遍 */
/* 驱动，实现阻塞读 */
/* 线程1 */
static void *thread_func_write(void *arg)
{
    int nByte;
    char data[6] = {0x12, 0x22, 0x34, 0x66, 0x32, 0x11};

    while (1) {
        pthread_mutex_lock(&mutex);
        printf("write.
");
        if ((nByte = write(fd, data, sizeof(data))) == -1) {
            printf("write failed, thread_func_write return.
");
            pthread_mutex_unlock(&mutex);
            return;
        }
        else {
            printf("write %d bytes.
", nByte);
        }

        pthread_mutex_unlock(&mutex);

        /* 每2秒发一个数据包 */
        sleep(2);
    }
}

static void createThread_write(void)
{
    pthread_attr_t attr;
    pthread_t pthread_id;

    /* set pthread detach */
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    pthread_create(&pthread_id, &attr, thread_func_write, NULL);
    pthread_attr_destroy(&attr);
}

/* 线程2 */
static void *thread_func_read(void *arg)
{
    int nByte;
    char buffer[255];

    while (1) {
        pthread_mutex_lock(&mutex);
        memset(buffer, 0, sizeof(buffer));
        if ((nByte = read(fd, buffer, sizeof(buffer))) == -1) {
            printf("read failed , thread_func_read return.
");
            return;
        }
        pthread_mutex_unlock(&mutex);

        printf("read %d bytes, buffer is : %s
", nByte, buffer);

        usleep(50);
        sleep(2);
    } /* end of while (1) */
}

static void createThread_read(void)
{
    pthread_attr_t attr;
    pthread_t pthread_id;

    /* set pthread detach */
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    pthread_create(&pthread_id, &attr, thread_func_read, NULL);
    pthread_attr_destroy(&attr);
}

/* 线程3 */
static void *thread_func_ioctl(void *arg)
{
    int ret, i;

    uint8_t tx[] = {
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0x40, 0x00, 0x00, 0x00, 0x00, 0x95,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD,
        0xF0, 0x0D,
    };
    uint8_t rx[ARRAY_SIZE(tx)] = {0, };
    struct spi_ioc_transfer tr = {
        .tx_buf = (unsigned long)tx,
        .rx_buf = (unsigned long)rx,
        .len = ARRAY_SIZE(tx),
        .delay_usecs = 0,
        .speed_hz = 500000,
        .bits_per_word = 8,
    };
    while (1) {
        pthread_mutex_lock(&mutex);
        if ((ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr)) == -1) {
            printf("ioctl failed, thread_func_ioctl return.
");
            pthread_mutex_unlock(&mutex);
            return;
        }
        pthread_mutex_unlock(&mutex);

        for (i = 0; i < ARRAY_SIZE(tx); i++) {
            if (i % 6 == 0) {
                printf("
");
            }
            printf("%.2X,", rx[i]);
        }
        printf("
");
printf("ioctl.
");
        sleep(2);
    }
}

static void createThread_ioctl(void)
{
    pthread_attr_t attr;
    pthread_t pthread_id;

    /* set pthread detach */
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    pthread_create(&pthread_id, &attr, thread_func_ioctl, NULL);
    pthread_attr_destroy(&attr);
}

int main(int argc, char ** argv)
{
    /* 打开文件 */
    if ((fd = open(filename, O_RDWR)) == -1) {
        printf("open file %s failed.
", filename);
        return -1;
    }
    else {
        printf("open file %s successful.
", filename);
    }

    /* 创建第一个线程，每2s向设备写入数据 */
    createThread_write();

    /* 创建第二个线程，不停地读数据 */
    /* 阻塞需要驱动程序中实现 */
    createThread_read();

    /* 创建第三个线程 */
    createThread_ioctl();

    while (1) {
        sleep(1000);
    }

    return 0;
}

---

参考博客

       https://www.cnblogs.com/-4412/articles/5202793.html