1 SPI协议
SPI全称为serial peripheral interface串行外围接口协议，一般为四线，也可以省略为三线或两线；
支持全双工，在主设备发送数据的时候同时从从设备接收数据；此时的从设备接收到主设备的时钟信号和数据的第一位，将准备好的数据发送给主设备；
支持半双工，要么发送数据，要么接收数据；操作设备的read，wirte函数属于半双工通信；
SPI协议大部分用在EEPROM和FLASH存储器上，通过单片机与其通信；不巧本文的SPI是GPIO复用的SPI；
SPI协议发送数据的时候通常选择高位在前先发送；通信总是由主设备发起；
部分相关在STM32:SPI相关的笔记中补充，这里不重复了；
2 SPI驱动
概括来说，就是先用spi_board_info的device信息向内核框架注册一个driver东东，
这个driver东东对于内核而言被称之为从设备，由内核管理，感觉和SPI通信过程中的主从设备有点差别的；
然后在匹配好的.probe函数中将driver绑定到具体的spi设备(/dev/SPI0)，并存储下匹配上的硬件SPI的地址；
(问题：比如设备树，通过dts管理，由厂家写好配置，只要匹配上，配置后就由dts自己映射到寄存器地址了；
这里是怎么匹配上硬件SPI的地址有些不理解，对于misc框架不熟悉；资料都不知道怎么找；)
(补充：匹配上的mt_spi1_t是具体硬件地址映射的结构体，较为直观，可以理解，
难道是因为这个芯片只有一个SPI外设，所以前面的板级信息spi_board_info就传给了这个SPI，于是就对应上了；)
然后使用spi_master东东来处理传输数据到硬件相关的结构体中；
这些东东分别处理着自己的任务，然后通过接口函数将处理完的数据进行交换；在分析的时候应该考虑成多个独立的结构；
2.1 首先需要编写module_init();和module_exit()；在module_init()中向board注册board的device和driver的信息；
2.1.1 driver的配置信息为spi_driver 结构体，主要是用来匹配的.name，以及匹配成功执行的.probe和.remove；
2.1.2 device的配置信息为spi_board_info结构体，主要是用来匹配的.modalias，以及spi的配置信息；
提供的spi的配置信息可以让内核单独运行spi，是配置boadr info需要的信息；
问题：spi_board_info和spi_device的功能有些分不清，spi_device是硬件层的映射，其中成员spi_master就是所在总线；
至于spi_board_info应该在某些地方，最终把值传入spi_device，或者在这里就自动传入了；
2.2 接着是.probe和.remove函数
内核开始运行时，自动加载模块执行module_init()，然后查看注册的device和driver是否匹配，匹配的话则将其绑定，然后执行.porbe的函数；
2.2.1 .probe的函数spi_probe；
1)主要是使用misc_register函数注册了一个misc设备，注册的设备可以在/dev下查看；misc设备的.fops操作函数之后补充；
2)然后分配一个内核缓存buff，之后收发数据的时候会用到；
3)然后把匹配成功的(struct spi_device * spi)的地址放入了spi_dev变量中；
问题：这里的 (struct spi_device * spi)的spi是.probe的参数，应该是设备的device部分，此device目前应该只包含了前面spi_board_info的信息；
问题：这里注册的misc设备，等会又是如何映射到硬件的device和驱动的driver的呢？
2.2.2 .remove的函数spi_remove；
1)使用misc_deregister函数注销了前面注册的misc设备，释放前面分配的内核缓存；
2)这里传入的参数也是struct spi_device * spi，但是没有用上；.remove应该是关机的时候调用的；
2.3 接下来是misc设备的.fops函数的编写了；
2.3.1 .open的函数mt_spi_open；
1)将匹配成功的spi_device的地址内的spi_master地址取出，然后将spi_master内专门给driver使用的数据地址传给mt1_spi_t结构体；
2)然后初始化了两个锁，还有mt1_spi_t结构体的一些参数；
2.3.2 .write的函数mt_spi_write；
初始化spi_transfer和spi_message，然后将其绑定，然后调用spidev_sync异步传输，使用的是前面匹配上的&spidev；
write函数都是半双工通信，配置spi_transfer的时候，需要把发送数据放入.tx中；然后.rx为NULL不用配置，表示半双工通信；
2.3.3 .read的函数mt_spi_read；
同上的write函数的代码框架一样；
2.3.4 .unlock_ioctl的函数mt_spi_ioctl；
2.3.5 .close的函数mt_spi_close；
什么也没执行；值返回了个0；
3 设备树：用树形结构描述硬件设备信息；方便内核管理和解析硬件设备
之前内核中描述硬件信息的代码主要是通过arch下arm文件夹内C文件，来直接配置各种开发板的硬件信息，就和单片机开发一样；
使得linux决定将描述板间硬件信息的内容从linux内核中分离出来，用称之为硬件树的专属文件格式.dts来描述；
这些硬件信息包括开发板上的IIC设备，SPI设备等。另外包括SOC级硬件信息如CPU个数、频率、外设控制器等信息。
用.dts文件将设备描述信息从Linux内核中分离出来，.dts文件位于arch/arm/boot/dts文件夹下；一个平台或机器对应一个.dts文件；
.dts文件需要使用dtc工具编译成.dtb文件才可以使用；
查找了一下arch/arm64/boot/dts下的mt6735.dtsi文件，可以得到spi设备的信息如下：
4 ioctl操作函数
将不容易通过框架实现的字符设备的操作函数放在ioctl函数中，然后通过应用层传入的cmd，在ioctl里去直接控制寄存器，
在有些时候像这样不使用linux的框架，有时候比较便利。
使用ioctl来注册一个misc类型的spi设备，虽然这样又麻烦，又不方便，但是这样就不用了解框架了；
5 代码部分
此代码目前只测试了发送数据是可行的，接收数据会停在wait_for_completion_done(&done)函数部分；
该函数根据代码是在等待接收完成，然后自动调用complete(arg)来唤醒释放，那么接收完成对于内核而言接收完成的标志又是什么呢？
个人觉得，接收完成的标志是不是和底层寄存器相关，由于没有外设，于是一直没有被设置；导致程序一直卡在这里；
后面证实和底层寄存器没有关系，主要是接收数据也需要先发送数据，所以加了发送buf之后就可以了；
#include <linux/kernel.h> #include <linux/init.h> #include <linux/module.h> #include <linux/ioctl.h> #include <linux/fs.h> #include <linux/device.h> #include <linux/miscdevice.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/spi/spi.h> #include <linux/spi/spidev.h> #include <linux/wakelock.h> #include <mach/mt_spi.h> #include <mach/mt_gpio.h> #include <asm/uaccess.h> #define SPI_MODE_MASK (SPI_CPHA | SPI_CPOL | SPI_CS_HIGH | SPI_LSB_FIRST | SPI_3WIRE | SPI_LOOP | SPI_NO_CS | SPI_READY) static struct mutex buf_lock; static spinlock_t spi_lock; static unsigned char * TxRx_buf = NULL; static unsigned int TxRx_bufsize = 256; static struct spi_device * spi_dev; #define TAG "kernel_spi3" //spi_message是将一系列协议操作集中在一起作为原子操作的； //使用完transfer_one_message()之后，必须调用spi_finalize_current_message()初始化message给下次调用； static int spidev_message(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; unsigned char *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 = TxRx_buf; 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 > TxRx_buf) { status = -EMSGSIZE; goto done; } if (u_tmp->rx_buf) { k_tmp->rx_buf = buf; if (!access_ok(VERIFY_WRITE, (unsigned char __user *)(size_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 unsigned char __user *)(size_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; spi_message_add_tail(k_tmp, &msg); } status = spidev_sync(&msg); if (status < 0) goto done; /* copy any rx data out of bounce buffer */ buf = TxRx_buf; for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) { if (u_tmp->rx_buf) { if (__copy_to_user((unsigned char __user *)(size_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; } //主要是通过spi_setup()来重新配置spi的模式， static long mt_spi_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { int err = 0; int retval = 0; struct spi_ioc_transfer *ioc; struct spi_device *spi = spi_dev; unsigned int n_ioc, tmp; /* Check type and command number */ if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC) return -ENOTTY; if (_IOC_DIR(cmd) & _IOC_READ) err = !access_ok(VERIFY_WRITE, (void __user *)arg, _IOC_SIZE(cmd)); if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE) err = !access_ok(VERIFY_READ, (void __user *)arg, _IOC_SIZE(cmd)); if (err) return -EFAULT; if (spi_dev == NULL) return -ESHUTDOWN; mutex_lock(&buf_lock); switch (cmd) { /* read requests */ case SPI_IOC_RD_MODE: retval = __put_user(spi->mode & SPI_MODE_MASK, (unsigned char __user *)arg); printk("%s SPI_IOC_RD_MODE retval:%#x ",TAG,retval); break; case SPI_IOC_RD_LSB_FIRST: retval = __put_user((spi->mode & SPI_LSB_FIRST) ? 1 : 0, (unsigned char __user *)arg); printk("%s SPI_IOC_RD_LSB_FIRST retval:%#x ",TAG,retval); break; case SPI_IOC_RD_BITS_PER_WORD: retval = __put_user(spi->bits_per_word, (unsigned char __user *)arg); printk("%s SPI_IOC_RD_BITS_PER_WORD retval:%#x ",TAG,retval); break; case SPI_IOC_RD_MAX_SPEED_HZ: retval = __put_user(spi->max_speed_hz, (unsigned int __user *)arg); printk("%s SPI_IOC_RD_MAX_SPEED_HZ retval:%#x ",TAG,retval); break; /* write requests */ case SPI_IOC_WR_MODE: retval = __get_user(tmp, (unsigned char __user *)arg); if (retval == 0) { unsigned char save = spi->mode; if (tmp & ~SPI_MODE_MASK) { retval = -EINVAL; break; } tmp |= spi->mode & ~SPI_MODE_MASK; spi->mode = (unsigned char)tmp; retval = spi_setup(spi); if (retval < 0) spi->mode = save; else dev_dbg(&spi->dev, "spi mode %02x ", tmp); } break; case SPI_IOC_WR_LSB_FIRST: retval = __get_user(tmp, (unsigned char __user *)arg); if (retval == 0) { unsigned char save = spi->mode; if (tmp) spi->mode |= SPI_LSB_FIRST; else spi->mode &= ~SPI_LSB_FIRST; retval = spi_setup(spi); if (retval < 0) spi->mode = save; else dev_dbg(&spi->dev, "%csb first ", tmp ? 'l' : 'm'); } break; case SPI_IOC_WR_BITS_PER_WORD: retval = __get_user(tmp, (unsigned char __user *)arg); if (retval == 0) { unsigned char save = spi->bits_per_word; spi->bits_per_word = tmp; retval = spi_setup(spi); if (retval < 0) spi->bits_per_word = save; else dev_dbg(&spi->dev, "%d bits per word ", tmp); } break; case SPI_IOC_WR_MAX_SPEED_HZ: retval = __get_user(tmp, (unsigned int __user *)arg); if (retval == 0) { unsigned int save = spi->max_speed_hz; spi->max_speed_hz = tmp; retval = spi_setup(spi); if (retval < 0) spi->max_speed_hz = save; else dev_dbg(&spi->dev, "%d Hz (max) ", tmp); } break; default: /* segmented and/or full-duplex I/O request */ 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) { retval = -EINVAL; break; } n_ioc = tmp / sizeof(struct spi_ioc_transfer); if (n_ioc == 0) break; /* copy into scratch area */ ioc = kmalloc(tmp, GFP_KERNEL); if (!ioc) { retval = -ENOMEM; break; } if (__copy_from_user(ioc, (void __user *)arg, tmp)) { kfree(ioc); retval = -EFAULT; break; } /* translate to spi_message, execute */ retval = spidev_message(ioc, n_ioc); kfree(ioc); break; } mutex_unlock(&buf_lock); spi_dev_put(spi); printk("%s spi ioctl ", TAG); return retval; } //spi_async() 来打包的时候需要context和completion一起使用； //对于像spi_sync(),spi_write()来打包发送的时候一般只需要context； static void spidev_complete(void *arg) { complete(arg); } static ssize_t spidev_sync(struct spi_message *message) { DECLARE_COMPLETION_ONSTACK(done); int ret; message->complete = spidev_complete; message->context = &done; if (spi_dev == NULL) return -ESHUTDOWN; spin_lock_irq(&spi_lock);//自旋锁，要是解不开就一直在这里等的那种； ret = spi_async(spi_dev, message); spin_unlock_irq(&spi_lock); printk("%s spi_async ret:%d ",TAG,(int)ret); if (ret == 0) { printk("%s wait_for_completion ... ",TAG); wait_for_completion(&done); printk("%s wait_for_completion done ",TAG); ret = message->status; message->context = NULL; if (ret == 0) ret = message->actual_length; } printk("%s spidev_sync spin unlock,wait_for_completion_done. ",TAG); return ret; } static ssize_t mt_spi_read(struct file *file, char *buf, size_t count, loff_t *offset) { ssize_t ret = -EMSGSIZE; if (count > TxRx_buf) goto s_read_exit; //mutex_lock(&buf_lock); struct spi_transfer t = {
.tx_buf = TxRx_buf, //接收不行，主要是因为接收前也需要发送buf来提供时钟，这里添加了buf之后就可以接收了； .rx_buf = TxRx_buf, .len = count, }; struct spi_message m; spi_message_init(&m); spi_message_add_tail(&t, &m); ret = spidev_sync(&m); if (ret > 0) { unsigned long missing; missing = copy_to_user(buf, TxRx_buf, ret); if (missing == ret) ret = -EFAULT; else ret = ret - missing; } //mutex_unlock(&buf_lock); printk("%s spi sync read done,ret :%d ", TAG, (int)ret); s_read_exit: printk("%s spi read exit ", TAG); return ret; } static ssize_t mt_spi_write(struct file *file, const char *buf, size_t count, loff_t *offset) { ssize_t ret = -EMSGSIZE; if (count > TxRx_buf) goto s_write_exit; mutex_lock(&buf_lock); ret = copy_from_user(TxRx_buf, buf, count); if(ret){ printk("%s copy from user space fail ",TAG); ret = -EFAULT; } mutex_unlock(&buf_lock); //每个spi_transfer都会包含.tx_buf发送缓存和.rx_buf接收缓存； //当两个buf相同的时候，一般是全双工；其中一个buf为null时，为半双工； //可以通过.delay_usecs来定义transfer之后的延时，延时单位是us； struct spi_transfer t = { .tx_buf = TxRx_buf, .len = count, }; struct spi_message m; spi_message_init(&m);//初始化message spi_message_add_tail(&t, &m);//将spi_transfer添加到spi_message上； ret = spidev_sync(&m); //异步传输，用的是device的地址； printk("%s spi write done, ret:%d ",TAG,(int)ret); s_write_exit: printk("%s spi write exit ", TAG); return ret; } //配置信息2：platform_device包括了寄存器的物理地址等； //如何编写spi master 呢？ //通过spi_alloc_master()来分配一个master, //然后通过spi_master_get_devdata()来获取该master结构与device相关的所有数据如mt1_spi_t struct mt1_spi_t { struct platform_device *pdev; void __iomem *regs; int irq; int running; struct wake_lock wk_lock; struct mt_chip_conf *config; struct spi_master *master; struct spi_transfer *cur_transfer; struct spi_transfer *next_transfer; spinlock_t lock; //spi_message中也有lock和queue，使用完后要初始化，不然下次用不了transfer_one_message； struct list_head queue; }; //将&master->dev的数据传递给mt1_spi_t,然后初始化spi_message； static int mt_spi_open(struct inode *inode,struct file *file) { struct spi_message *msg; struct spi_master *master = spi_dev->master; struct mt1_spi_t *ms = spi_master_get_devdata(master); //将绑定的spi device的master取出，&master->dev的数据传递给mt1_spi_t; mutex_init(&buf_lock);//互斥锁初始化；如果互斥锁不能加锁，就阻塞睡眠线程，直到Unlock唤醒线程； spin_lock_init(&spi_lock);//自旋锁初始化；如果自旋锁不能加锁，CPU始终处于忙等待不能做其他任务； list_for_each_entry(msg, &ms->queue, queue) { msg->status = -ESHUTDOWN; msg->complete(msg->context); } ms->cur_transfer = NULL; ms->next_transfer = NULL; ms->running = 0; INIT_LIST_HEAD(&ms->queue); //初始化的是上面的mt1_spi_t，这是绑定的spi_device的一部分；看不太懂； printk("%s spi opened ", TAG); return 0; } //.release和.remove的区别在哪里呢？这个close感觉没什么用啊； static int mt_spi_close(struct inode *inode,struct file *file) { printk("%s spi close ", TAG); return 0; } static struct file_operations spi_fops = { .owner = THIS_MODULE, .open = mt_spi_open, .release = mt_spi_close, .read = mt_spi_read, .write = mt_spi_write, .unlocked_ioctl = mt_spi_ioctl, }; //misc device的设备信息，文件操作 static struct miscdevice misc_dev = { .minor = MISC_DYNAMIC_MINOR, .name = "SPI0", .fops = &spi_fops, }; //注册 misc device,分配device buff的内存，存储device的地址到指针中； static int spi_probe(struct spi_device * spi) { int result; result = misc_register(&misc_dev); if(result < 0){ printk("%s misc register fail. ",TAG); return result; } TxRx_buf = kmalloc(TxRx_bufsize,GFP_KERNEL); if(!TxRx_buf){ printk("%s TxRx_buf null! ",TAG); return -ENOMEM; } spi_dev = spi;//这里把匹配成功的spi device的地址放入了spi_dev中; printk("%s spi probe done. ",TAG); return 0; } //注销misc device,注销device使用的buffer内存； static int spi_remove(struct spi_device * spi) { int result; result = misc_deregister(&misc_dev); if(result < 0){ printk("%s misc de register fail! ",TAG); return result; } if(TxRx_buf) kfree(TxRx_buf); TxRx_buf = NULL; return 0; } //配置信息1：(slave devices的配置信息)board info的信息;提供的这些信息需要足够内核单独运行spi static struct spi_board_info spi_board_devs[] __initdata = { [0] = { .modalias = "mt_spi3", .max_speed_hz = 25 * 1000 *1000, // 25MHz .bus_num = 0, .chip_select = 0, .mode = SPI_MODE_0, }, }; //spi protocol driver:当spi_driver注册之后， //会自动查找注册的device中board_info的.modalias与.name匹配的device,然后绑定； static struct spi_driver mt_spi_driver = { .driver = { .name = "mt_spi3", .owner = THIS_MODULE, }, .probe = spi_probe, .remove = spi_remove, }; static int __init mt_spi_init ( void ) { int ret; //向当前board注册一个SPI device spi_register_board_info(spi_board_devs, ARRAY_SIZE(spi_board_devs)); //向当前board注册一个SPI driver ret = spi_register_driver(&mt_spi_driver); printk("%s module spi init ... ret :%#x ",TAG,ret); return ret; } static void __init mt_spi_exit ( void ) { printk("%s module spi exit ",TAG); spi_unregister_driver(&mt_spi_driver); } module_init(mt_spi_init); module_exit(mt_spi_exit); MODULE_LICENSE("GPL");