linux spi驱动开发学习(二)-----spidev.c和spi test app

一.spidev.c文件

看一个设备驱动的方法：

module_init标识的入口初始化函数spidev_init,(module_exit标识的出口函数)

设备与设备驱动匹配时候调用的probe方法spidev_probe

设备驱动的操作函数集file_operations--->spidev_fops

@@open方法spidev_open
进行检查, 重点是以后三条语句,其他的见下面代码注释:

spidev->users++; //spidev_data使用者计数++
filp->private_data = spidev; //spidev_data放在文件的私有数据里
nonseekable_open(inode, filp);  //设置文件的打开模式(文件读写指针不会跟随读写操作移动)

@@read方法spidev_read
spidev = filp->private_data;=========>>status = spidev_sync_read(spidev, count);===========>>
spidev_sync(spidev, &m);==========>>status = spi_async(spidev->spi, message);===========>>
wait_for_completion(&done);========>>到了这一步是重点,在spi_async()方法中,使用以下语句将要做的事情加到workqueue中
list_add_tail(&m->queue, &bitbang->queue);
queue_work(bitbang->workqueue, &bitbang->work);
此后所有的处理程序便转移到在之前初始化的work方法中看以下代码:

static void bitbang_work(struct work_struct *work)
{
    struct spi_bitbang    *bitbang =
        container_of(work, struct spi_bitbang, work);
    unsigned long        flags;
    int            do_setup = -1;
    int            (*setup_transfer)(struct spi_device *,
                    struct spi_transfer *);

    setup_transfer = bitbang->setup_transfer;

    spin_lock_irqsave(&bitbang->lock, flags);
    bitbang->busy = 1;
    while (!list_empty(&bitbang->queue)) {
        struct spi_message    *m;
        struct spi_device    *spi;
        unsigned        nsecs;
        struct spi_transfer    *t = NULL;
        unsigned        tmp;
        unsigned        cs_change;
        int            status;

        m = container_of(bitbang->queue.next, struct spi_message,
                queue);
        list_del_init(&m->queue);
        spin_unlock_irqrestore(&bitbang->lock, flags);

        /* FIXME this is made-up ... the correct value is known to
         * word-at-a-time bitbang code, and presumably chipselect()
         * should enforce these requirements too?
         */
        nsecs = 100;

        spi = m->spi;
        tmp = 0;
        cs_change = 1;
        status = 0;

        list_for_each_entry (t, &m->transfers, transfer_list) {

            /* override speed or wordsize? */
            if (t->speed_hz || t->bits_per_word)
                do_setup = 1;

            /* init (-1) or override (1) transfer params */
            if (do_setup != 0) {
                if (!setup_transfer) {
                    status = -ENOPROTOOPT;
                    break;
                }
                status = setup_transfer(spi, t);
                if (status < 0)
                    break;
            }

            /* set up default clock polarity, and activate chip;
             * this implicitly updates clock and spi modes as
             * previously recorded for this device via setup().
             * (and also deselects any other chip that might be
             * selected ...)
             */
            if (cs_change) {
                bitbang->chipselect(spi, BITBANG_CS_ACTIVE);
                ndelay(nsecs);
            }
            cs_change = t->cs_change;
            if (!t->tx_buf && !t->rx_buf && t->len) {
                status = -EINVAL;
                break;
            }

            /* transfer data. the lower level code handles any
             * new dma mappings it needs. our caller always gave
             * us dma-safe buffers.
             */
            if (t->len) {
                /* REVISIT dma API still needs a designated
                 * DMA_ADDR_INVALID; ~0 might be better.
                 */
                if (!m->is_dma_mapped)
                    t->rx_dma = t->tx_dma = 0;
                status = bitbang->txrx_bufs(spi, t);
            }
            if (status > 0)
                m->actual_length += status;
            if (status != t->len) {
                /* always report some kind of error */
                if (status >= 0)
                    status = -EREMOTEIO;
                break;
            }
            status = 0;

            /* protocol tweaks before next transfer */
            if (t->delay_usecs)
                udelay(t->delay_usecs);

            if (!cs_change)
                continue;
            if (t->transfer_list.next == &m->transfers)
                break;

            /* sometimes a short mid-message deselect of the chip
             * may be needed to terminate a mode or command
             */
            ndelay(nsecs);
            bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
            ndelay(nsecs);
        }

        m->status = status;
        m->complete(m->context);

        /* restore speed and wordsize if it was overridden */
        if (do_setup == 1)
            setup_transfer(spi, NULL);
        do_setup = 0;

        /* normally deactivate chipselect ... unless no error and
         * cs_change has hinted that the next message will probably
         * be for this chip too.
         */
        if (!(status == 0 && cs_change)) {
            ndelay(nsecs);
            bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
            ndelay(nsecs);
        }

        spin_lock_irqsave(&bitbang->lock, flags);
    }
    bitbang->busy = 0;
    spin_unlock_irqrestore(&bitbang->lock, flags);
}

结束处理所有任务后,见上面红色底纹部分解除wait_for_completion(&done);
最后missing = copy_to_user(buf, spidev->buffer, status);将数据发送到用户空间

@@write方法spidev_write
与上面open方式基本相同

@@ioctl方法spidev_ioctl
具体的详解见下面章节(三,四)

下面是spidev.c添加注释部分

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#define SPIDEV_MAJOR            153 //spidev主设备号
#define N_SPI_MINORS            32  /* ... up to 256 */
static DECLARE_BITMAP(minors, N_SPI_MINORS);    //声明次设备位图
#define SPI_MODE_MASK (SPI_CPHA|SPI_CPOL|SPI_CS_HIGH|SPI_LSB_FIRST|SPI_3WIRE|SPI_LOOP|SPI_NO_CS|SPI_READY)

struct spidev_data {
    dev_t   devt;               //设备号
    spinlock_t  spi_lock;       //自旋锁
    struct spi_device   *spi;   //spi设备结构体
    struct list_head    device_entry;
    struct mutex    buf_lock;   //互斥锁
    unsigned        users;      //使用者计数
    u8          *buffer;        //缓冲区
};

static LIST_HEAD(device_list);  //声明spi设备链表
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 void spidev_complete(void *arg)
{
    complete(arg);  //调用complete
}

static ssize_t spidev_sync(struct spidev_data *spidev, struct spi_message *message)
{
    DECLARE_COMPLETION_ONSTACK(done);
    int status;

    message->complete = spidev_complete; //设置spi消息的complete方法 回调函数
    message->context = &done;

    spin_lock_irq(&spidev->spi_lock);
    if (spidev->spi == NULL) //判断是否有指定对应的spi设备
        status = -ESHUTDOWN;
    else
        status = spi_async(spidev->spi, message);    //spi异步同步
    spin_unlock_irq(&spidev->spi_lock);

    if (status == 0) {
        wait_for_completion(&done); //等待传输完成
        status = message->status;    //获取spi消息传输事务状态
        if (status == 0)
            status = message->actual_length; //status等于传输的实际长度
    }
    return status;  //返回实际传输长度
}

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消息(初始化spi传递事务队列)
    spi_message_add_tail(&t, &m);   //添加spr传递到该队列
    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消息(初始化spi传递事务队列)
    spi_message_add_tail(&t, &m);   //添加spr传递到该队列
    return spidev_sync(spidev, &m); //同步读写
}

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;

    if (count > bufsiz)  //传输数据大于缓冲区容量
        return -EMSGSIZE;
    spidev = filp->private_data; //从文件私有数据指针获取spidev_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;  //返回读取成功的数据个数
}

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;

    if (count > bufsiz)  //传输数据大于缓冲区容量
        return -EMSGSIZE;
    spidev = filp->private_data; //从文件私有数据指针获取spidev_data
    mutex_lock(&spidev->buf_lock);   //上互斥锁
    missing = copy_from_user(spidev->buffer, buf, count);    //用户空间复制到内核空间
    if (missing == 0) { //传输失败个数为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); //初始化spi消息(初始化spi传递事务队列)
    k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL); //分配spi传输指针内存
    if (k_xfers == NULL)
        return -ENOMEM;
    buf = spidev->buffer;    //获取spidev_data的缓冲区
    total = 0;
    //n=xfers为spi_ioc_transfer个数,u_tmp = u_xfers为要处理的spi_ioc_transfer指针
    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) {    //信息量超过bufsiz缓冲区最大容量
            status = -EMSGSIZE;
            goto done;
        }
        if (u_tmp->rx_buf) { //接收缓冲区指针不为空
            k_tmp->rx_buf = 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; //缓冲区指针指向buf
            if (copy_from_user(buf, (const u8 __user *)(uintptr_t) u_tmp->tx_buf,u_tmp->len)) //用户空间复制数据到buf
                goto done;
        }
        buf += k_tmp->len;   //缓冲区指针移动一个传输信息的长度
        k_tmp->cs_change = !!u_tmp->cs_change;    //设置cs_change
        k_tmp->bits_per_word = u_tmp->bits_per_word;  //设置bits_per_word 一个字多少位
        k_tmp->delay_usecs = u_tmp->delay_usecs;  //设置delay_usecs 毫秒级延时
        k_tmp->speed_hz = u_tmp->speed_hz;    //设置speed_hz 速率
#ifdef VERBOSE
        dev_dbg(&spidev->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 ? : spidev->spi->bits_per_word,u_tmp->delay_usecs,u_tmp->speed_hz ? : spidev->spi->max_speed_hz);
#endif
        spi_message_add_tail(k_tmp, &msg);  //添加spr传递到该队列
    }
    //for循环的作用是将spi_ioc_transfer批量转换为spi传递结构体spi_transfer,然后添加进spi传递事务队列
    status = spidev_sync(spidev, &msg);     //同步读写
    if (status < 0)
        goto done;
    buf = spidev->buffer;    //获取spidev_data缓冲区指针
    for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) {   //批量从内核空间复制spi_ioc_transfer到用户空间
        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;   //buf指针位置调整指向下一个spi_ioc_transfer
    }
    status = total; //status等于实际传输的数据长度
done:
    kfree(k_xfers); //释放k_xfers
    return status;  //返回实际传输的数据长度
}

static long spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    int err = 0;
    int retval = 0;
    struct spidev_data  *spidev;
    struct spi_device   *spi;
    u32 tmp;
    unsigned    n_ioc;
    struct spi_ioc_transfer *ioc;

    if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)    //判断控制命令的类型
        return -ENOTTY;
    if (_IOC_DIR(cmd) & _IOC_READ)  //判断控制命令的方向是否为读read
        err = !access_ok(VERIFY_WRITE,(void __user *)arg, _IOC_SIZE(cmd));  //判断传输数据大小
    if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE) //判断控制命令的方向是否为写write
        err = !access_ok(VERIFY_READ,(void __user *)arg, _IOC_SIZE(cmd));   //判断传输数据大小
    if (err)
        return -EFAULT;

    spidev = filp->private_data; //从文件私有数据中获取spidev_data
    spin_lock_irq(&spidev->spi_lock);    //上自旋锁
    spi = spi_dev_get(spidev->spi);          //获取spi设备
    spin_unlock_irq(&spidev->spi_lock);  //解自旋锁
    if (spi == NULL)    //获取spi设备失败
        return -ESHUTDOWN;  //则返回错误
    mutex_lock(&spidev->buf_lock);   //上互斥锁

    switch (cmd) {
    case SPI_IOC_RD_MODE:   //设置spi读模式  (此处原作者的理解与我不同,这里应该是应用程序获取数据)
        retval = __put_user(spi->mode & SPI_MODE_MASK,(__u8 __user *)arg);
        break;
    case SPI_IOC_RD_LSB_FIRST:  //设置spi读最低有效位  (此处原作者的理解与我不同,这里应该是应用程序获取数据)
        retval = __put_user((spi->mode & SPI_LSB_FIRST) ?  1 : 0,(__u8 __user *)arg);
        break;
    case SPI_IOC_RD_BITS_PER_WORD:  //设置spi读每个字含多个个位  (此处原作者的理解与我不同,这里应该是应用程序获取数据)
        retval = __put_user(spi->bits_per_word, (__u8 __user *)arg);
        break;
    case SPI_IOC_RD_MAX_SPEED_HZ:   //设置spi读最大速率  (此处原作者的理解与我不同,这里应该是应用程序获取数据)
        retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg);
        break;
    case SPI_IOC_WR_MODE:   //设置spi写模式
        retval = __get_user(tmp, (u8 __user *)arg);
        if (retval == 0) {
            u8  save = spi->mode;    //获取spi设备模式

            if (tmp & ~SPI_MODE_MASK) {
                retval = -EINVAL;
                break;
            }

            tmp |= spi->mode & ~SPI_MODE_MASK;
            spi->mode = (u8)tmp;
            retval = spi_setup(spi);    //配置spi设备
            if (retval < 0)
                spi->mode = save;
            else
                dev_dbg(&spi->dev, "spi mode %02x\n", tmp);
        }
        break;
    case SPI_IOC_WR_LSB_FIRST:  //设置spi写最低有效位
        retval = __get_user(tmp, (__u8 __user *)arg);
        if (retval == 0) {
            u8  save = spi->mode;    //获取spi设备模式

            if (tmp)
                spi->mode |= SPI_LSB_FIRST;
            else
                spi->mode &= ~SPI_LSB_FIRST;
            retval = spi_setup(spi);    //配置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:  //设置spi写每个字含多个个位
        retval = __get_user(tmp, (__u8 __user *)arg);   //用户空间获取数据
        if (retval == 0) {
            u8  save = spi->bits_per_word;   //获取spi设备 每个字含多少位

            spi->bits_per_word = tmp;    //更新新的spi设备 每个字含多少位
            retval = spi_setup(spi);    //配置spi设备
            if (retval < 0)  //配置失败
                spi->bits_per_word = save;   //还原spi设备 每个字含多少位
            else
                dev_dbg(&spi->dev, "%d bits per word\n", tmp);
        }
        break;
    case SPI_IOC_WR_MAX_SPEED_HZ:       //设置spi写最大速率
        retval = __get_user(tmp, (__u32 __user *)arg);  //用户空间获取数据
        if (retval == 0) {
            u32 save = spi->max_speed_hz;    //获取spi设备最大速率

            spi->max_speed_hz = tmp; //更新新的spi设备最大速率
            retval = spi_setup(spi);    //配置spi设备
            if (retval < 0)  //配置失败
                spi->max_speed_hz = save;    //还原spi设备最大速率
            else
                dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);
        }
        break;

    default:
        //命令必须为写方向的命令,且传输数据必须是SPI_IOC_MESSAGE()修饰的命令
        if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))|| _IOC_DIR(cmd) != _IOC_WRITE) {
            retval = -ENOTTY;
            break;
        }

        tmp = _IOC_SIZE(cmd);   //计算传输数据大小
        if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) { //判断是否为spi_ioc_transfer对齐
            retval = -EINVAL;
            break;
        }
        n_ioc = tmp / sizeof(struct spi_ioc_transfer);  //计算出spi_ioc_transfer数据的个数
        if (n_ioc == 0)
            break;

        ioc = kmalloc(tmp, GFP_KERNEL); //分配spi_ioc_transfer指针ioc内存
        if (!ioc) {
            retval = -ENOMEM;
            break;
        }
        if (__copy_from_user(ioc, (void __user *)arg, tmp)) {   //从用户空间复制到内核空间
            kfree(ioc); //复制失败则释放ioc内存
            retval = -EFAULT;
            break;
        }

        retval = spidev_message(spidev, ioc, n_ioc);    //spidev消息处理
        kfree(ioc); //释放ioc内存
        break;
    }

    mutex_unlock(&spidev->buf_lock); //解互斥锁
    spi_dev_put(spi);   //增加spi设备的引用计数
    return retval;
}

static int spidev_open(struct inode *inode, struct file *filp)
{
    struct spidev_data  *spidev;
    int status = -ENXIO;

    mutex_lock(&device_list_lock);  //上互斥锁
    list_for_each_entry(spidev, &device_list, device_entry) {   //遍历device_list
        if (spidev->devt == inode->i_rdev) {  //判断设备号找到对应的设备
            status = 0; //设置状态为0
            break;
        }
    }
    if (status == 0) {  //找得到对应的设备
        if (!spidev->buffer) {   //spidev_data缓冲区为空
            spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);    //则分配内存
            if (!spidev->buffer) {   //还空
                dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");  //申请内存失败
                status = -ENOMEM;
            }
        }
        if (status == 0) {  //找得到对应的设备
            spidev->users++; //spidev_data使用者计数++
            filp->private_data = spidev; //spidev_data放在文件的私有数据里
            nonseekable_open(inode, filp);  //设置文件的打开模式(文件读写指针不会跟随读写操作移动)
        }
    }
    else
        pr_debug("spidev: nothing for minor %d\n", iminor(inode));
    mutex_unlock(&device_list_lock);    //接互斥锁
    return status;
}

static int spidev_release(struct inode *inode, struct file *filp)
{
    struct spidev_data  *spidev;
    int status = 0;

    mutex_lock(&device_list_lock);
    spidev = filp->private_data; //获取spidev_data
    filp->private_data = NULL;       //清除文件的私有数据指针
    spidev->users--;             //使用者个数--
    if (!spidev->users) {    //如果使用者个数为0
        int     dofree;
        kfree(spidev->buffer);   //释放spidev_data的缓冲区内存
        spidev->buffer = NULL;   //清除spidev_data缓冲区指针
        spin_lock_irq(&spidev->spi_lock);    //上自旋锁
        dofree = (spidev->spi == NULL);  //判断spi设备是否与spidev_data解绑了
        spin_unlock_irq(&spidev->spi_lock);  //解自旋锁
        if (dofree)         //没有捆绑的spi设备
            kfree(spidev);  //则是否spidev_data内存
    }
    mutex_unlock(&device_list_lock);
    return status;
}

static const struct file_operations spidev_fops = {     //文件操作函数集
    .owner =    THIS_MODULE,
    .write =    spidev_write,       //写write
    .read =     spidev_read,        //读read
    .unlocked_ioctl = spidev_ioctl, //控制ioctl
    .open =     spidev_open,        //打开open
    .release =  spidev_release,     //释放release
    .llseek =   no_llseek,          //文件指针移动 no_llseek表示没有移动
};

static struct class *spidev_class;

static int __devinit spidev_probe(struct spi_device *spi)
{
    struct spidev_data  *spidev;
    int status;
    unsigned long   minor;

    spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);  //分配spidev_data内存
    if (!spidev)
        return -ENOMEM;
    spidev->spi = spi;   //设置spidev_data->spi(spi设备)
    spin_lock_init(&spidev->spi_lock);
    mutex_init(&spidev->buf_lock);
    INIT_LIST_HEAD(&spidev->device_entry);   //初始化spidev_data入口链表
    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/spidev%d.%d(spidev总线号.片选号)
        dev = device_create(spidev_class, &spi->dev, spidev->devt,spidev, "spidev%d.%d",spi->master->bus_num, spi->chip_select);
        status = IS_ERR(dev) ? PTR_ERR(dev) : 0;
    }
    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);

    if (status == 0)
        spi_set_drvdata(spi, spidev);   //spi->dev->p->driver_data=spidev
    else
        kfree(spidev);

    return status;
}

static int __devexit spidev_remove(struct spi_device *spi)
{
    struct spidev_data  *spidev = spi_get_drvdata(spi);     //根据spi设备获取spidev_data
    spin_lock_irq(&spidev->spi_lock);            //上自旋锁
    spidev->spi = NULL;                              //清空spidev_data->spi指针
    spi_set_drvdata(spi, NULL);                     //spi->dev->p->driver_data=NULL
    spin_unlock_irq(&spidev->spi_lock);          //解自旋锁
    mutex_lock(&device_list_lock);              //上互斥锁
    list_del(&spidev->device_entry);             //删除spidev_data入口链表
    device_destroy(spidev_class, spidev->devt);      //销毁/dev/spidev%d.%d
    clear_bit(MINOR(spidev->devt), minors);          //清除次设备位图对应位
    if (spidev->users == 0)                          //使用者个数为0
        kfree(spidev);                              //释放spidev_data内存
    mutex_unlock(&device_list_lock);            //解互斥锁
    return 0;
}

static struct spi_driver spidev_spi_driver = {  //spi设备驱动
    .driver = {
        .name =     "spidev",
        .owner =    THIS_MODULE,
    },
    .probe =    spidev_probe,   //spidev的probe方法(当注册了modalias域为"spidev"的spi设备或板级设备,则会调用probe方法)
    .remove =   __devexit_p(spidev_remove), //spidev的remove方法
};

static int __init spidev_init(void)     //spidev接口初始化
{
    int status;
    BUILD_BUG_ON(N_SPI_MINORS > 256);
    //注册字符设备,主设备号SPIDEV_MAJOR=153,捆绑的设备操作函数集为spidev_fops
    status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
    if (status < 0)
        return status;
    spidev_class = class_create(THIS_MODULE, "spidev"); //创建设备类spidev_class
    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);   //注册spi设备驱动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)            //spidev接口销毁
{
    spi_unregister_driver(&spidev_spi_driver);  //注销spi设备驱动spidev_spi_driver
    class_destroy(spidev_class);                //注销设备类spidev_class
    unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name); //注销字符设备
}
module_exit(spidev_exit);   //声明初始化出口

MODULE_AUTHOR("Andrea Paterniani, ");
MODULE_DESCRIPTION("User mode SPI device interface");
MODULE_LICENSE("GPL");
MODULE_ALIAS("spi:spidev");

二.用户空间例子(spidev_test.c)

#include
#include
#include
#include
#include
#include
#include
#include
#include

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

static void pabort(const char *s)
{
    perror(s);
    abort();
}

static const char *device = "/dev/spidev1.1";
static uint8_t mode;
static uint8_t bits = 8;
static uint32_t speed = 500000;
static uint16_t delay;

static void transfer(int fd)
{
    int ret;
    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 = {  //声明并初始化spi_ioc_transfer结构体
        .tx_buf = (unsigned long)tx,
        .rx_buf = (unsigned long)rx,
        .len = ARRAY_SIZE(tx),
        .delay_usecs = delay,
        .speed_hz = speed,
        .bits_per_word = bits,
    };
    //SPI_IOC_MESSAGE(1)的1表示spi_ioc_transfer的数量
    ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);   //ioctl默认操作,传输数据
    if (ret < 1)
        pabort("can't send spi message");

    for (ret = 0; ret < ARRAY_SIZE(tx); ret++) { //打印接收缓冲区
        if (!(ret % 6))     //6个数据为一簇打印
            puts("");
        printf("%.2X ", rx[ret]);
    }
    puts("");
}

static void print_usage(const char *prog)   //参数错误则打印帮助信息
{
    printf("Usage: %s [-DsbdlHOLC3]\n", prog);
    puts("  -D --device   device to use (default /dev/spidev1.1)\n"
         "  -s --speed    max speed (Hz)\n"
         "  -d --delay    delay (usec)\n"
         "  -b --bpw      bits per word \n"
         "  -l --loop     loopback\n"
         "  -H --cpha     clock phase\n"
         "  -O --cpol     clock polarity\n"
         "  -L --lsb      least significant bit first\n"
         "  -C --cs-high  chip select active high\n"
         "  -3 --3wire    SI/SO signals shared\n");
    exit(1);
}

static void parse_opts(int argc, char *argv[])
{
    while (1) {
        static const struct option lopts[] = {  //参数命令表
            { "device",  1, 0, 'D' },
            { "speed",   1, 0, 's' },
            { "delay",   1, 0, 'd' },
            { "bpw",     1, 0, 'b' },
            { "loop",    0, 0, 'l' },
            { "cpha",    0, 0, 'H' },
            { "cpol",    0, 0, 'O' },
            { "lsb",     0, 0, 'L' },
            { "cs-high", 0, 0, 'C' },
            { "3wire",   0, 0, '3' },
            { "no-cs",   0, 0, 'N' },
            { "ready",   0, 0, 'R' },
            { NULL, 0, 0, 0 },
        };
        int c;

        c = getopt_long(argc, argv, "D:s:d:b:lHOLC3NR", lopts, NULL);

        if (c == -1)
            break;

        switch (c) {
        case 'D':   //设备名
            device = optarg;
            break;
        case 's':   //速率
            speed = atoi(optarg);
            break;
        case 'd':   //延时时间
            delay = atoi(optarg);
            break;
        case 'b':   //每字含多少位
            bits = atoi(optarg);
            break;
        case 'l':   //回送模式
            mode |= SPI_LOOP;
            break;
        case 'H':   //时钟相位
            mode |= SPI_CPHA;
            break;
        case 'O':   //时钟极性
            mode |= SPI_CPOL;
            break;
        case 'L':   //lsb 最低有效位
            mode |= SPI_LSB_FIRST;
            break;
        case 'C':   //片选高电平
            mode |= SPI_CS_HIGH;
            break;
        case '3':   //3线传输模式
            mode |= SPI_3WIRE;
            break;
        case 'N':   //没片选
            mode |= SPI_NO_CS;
            break;
        case 'R':   //从机拉低电平停止数据传输
            mode |= SPI_READY;
            break;
        default:    //错误的参数
            print_usage(argv[0]);
            break;
        }
    }
}

int main(int argc, char *argv[])
{
    int ret = 0;
    int fd;

    parse_opts(argc, argv); //解析传递进来的参数

    fd = open(device, O_RDWR);  //打开设备文件
    if (fd < 0)
        pabort("can't open device");

    /*
     * spi mode //设置spi设备模式
     */
    ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);    //写模式
    if (ret == -1)
        pabort("can't set spi mode");

    ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);    //读模式
    if (ret == -1)
        pabort("can't get spi mode");

    /*
     * bits per word    //设置每个字含多少位
     */
    ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);   //写 每个字含多少位
    if (ret == -1)
        pabort("can't set bits per word");

    ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);   //读 每个字含多少位
    if (ret == -1)
        pabort("can't get bits per word");

    /*
     * max speed hz     //设置速率
     */
    ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);   //写速率
    if (ret == -1)
        pabort("can't set max speed hz");

    ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);   //读速率
    if (ret == -1)
        pabort("can't get max speed hz");
    //打印模式,每字多少位和速率信息
    printf("spi mode: %d\n", mode);
    printf("bits per word: %d\n", bits);
    printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);

    transfer(fd);   //传输测试

    close(fd);  //关闭设备

    return ret;
}

这里整理下ioctl的命令:

SPI_IOC_RD_MODE     //读 模式
SPI_IOC_RD_LSB_FIRST    //读 LSB
SPI_IOC_RD_BITS_PER_WORD    //读 每字多少位
SPI_IOC_RD_MAX_SPEED_HZ //读 最大速率
SPI_IOC_WR_MODE     //写 模式
SPI_IOC_WR_LSB_FIRST    //写 LSB
SPI_IOC_WR_BITS_PER_WORD    //写 每字多少位
SPI_IOC_WR_MAX_SPEED_HZ //写 最大速率
SPI_IOC_MESSAGE(n)      //传输n个数据包