一.spidev.c文件

看一个设备驱动的方法:

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

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

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

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

  1. spidev->users++; //spidev_data使用者计数++
  2. filp->private_data = spidev; //spidev_data放在文件的私有数据里
  3. 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方法中看以下代码:

点击(此处)折叠或打开

  1. static void bitbang_work(struct work_struct *work)
  2. {
  3. struct spi_bitbang    *bitbang =
  4. container_of(work, struct spi_bitbang, work);
  5. unsigned long        flags;
  6. int            do_setup = -1;
  7. int            (*setup_transfer)(struct spi_device *,
  8. struct spi_transfer *);
  9. setup_transfer = bitbang->setup_transfer;
  10. spin_lock_irqsave(&bitbang->lock, flags);
  11. bitbang->busy = 1;
  12. while (!list_empty(&bitbang->queue)) {
  13. struct spi_message    *m;
  14. struct spi_device    *spi;
  15. unsigned        nsecs;
  16. struct spi_transfer    *t = NULL;
  17. unsigned        tmp;
  18. unsigned        cs_change;
  19. int            status;
  20. m = container_of(bitbang->queue.next, struct spi_message,
  21. queue);
  22. list_del_init(&m->queue);
  23. spin_unlock_irqrestore(&bitbang->lock, flags);
  24. /* FIXME this is made-up ... the correct value is known to
  25. * word-at-a-time bitbang code, and presumably chipselect()
  26. * should enforce these requirements too?
  27. */
  28. nsecs = 100;
  29. spi = m->spi;
  30. tmp = 0;
  31. cs_change = 1;
  32. status = 0;
  33. list_for_each_entry (t, &m->transfers, transfer_list) {
  34. /* override speed or wordsize? */
  35. if (t->speed_hz || t->bits_per_word)
  36. do_setup = 1;
  37. /* init (-1) or override (1) transfer params */
  38. if (do_setup != 0) {
  39. if (!setup_transfer) {
  40. status = -ENOPROTOOPT;
  41. break;
  42. }
  43. status = setup_transfer(spi, t);
  44. if (status < 0)
  45. break;
  46. }
  47. /* set up default clock polarity, and activate chip;
  48. * this implicitly updates clock and spi modes as
  49. * previously recorded for this device via setup().
  50. * (and also deselects any other chip that might be
  51. * selected ...)
  52. */
  53. if (cs_change) {
  54. bitbang->chipselect(spi, BITBANG_CS_ACTIVE);
  55. ndelay(nsecs);
  56. }
  57. cs_change = t->cs_change;
  58. if (!t->tx_buf && !t->rx_buf && t->len) {
  59. status = -EINVAL;
  60. break;
  61. }
  62. /* transfer data. the lower level code handles any
  63. * new dma mappings it needs. our caller always gave
  64. * us dma-safe buffers.
  65. */
  66. if (t->len) {
  67. /* REVISIT dma API still needs a designated
  68. * DMA_ADDR_INVALID; ~0 might be better.
  69. */
  70. if (!m->is_dma_mapped)
  71. t->rx_dma = t->tx_dma = 0;
  72. status = bitbang->txrx_bufs(spi, t);
  73. }
  74. if (status > 0)
  75. m->actual_length += status;
  76. if (status != t->len) {
  77. /* always report some kind of error */
  78. if (status >= 0)
  79. status = -EREMOTEIO;
  80. break;
  81. }
  82. status = 0;
  83. /* protocol tweaks before next transfer */
  84. if (t->delay_usecs)
  85. udelay(t->delay_usecs);
  86. if (!cs_change)
  87. continue;
  88. if (t->transfer_list.next == &m->transfers)
  89. break;
  90. /* sometimes a short mid-message deselect of the chip
  91. * may be needed to terminate a mode or command
  92. */
  93. ndelay(nsecs);
  94. bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
  95. ndelay(nsecs);
  96. }
  97. m->status = status;
  98. m->complete(m->context);
  99. /* restore speed and wordsize if it was overridden */
  100. if (do_setup == 1)
  101. setup_transfer(spi, NULL);
  102. do_setup = 0;
  103. /* normally deactivate chipselect ... unless no error and
  104. * cs_change has hinted that the next message will probably
  105. * be for this chip too.
  106. */
  107. if (!(status == 0 && cs_change)) {
  108. ndelay(nsecs);
  109. bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
  110. ndelay(nsecs);
  111. }
  112. spin_lock_irqsave(&bitbang->lock, flags);
  113. }
  114. bitbang->busy = 0;
  115. spin_unlock_irqrestore(&bitbang->lock, flags);
  116. }

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

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

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

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

[cpp] view plaincopy
  1. #include <linux/init.h>
  2. #include <linux/module.h>
  3. #include <linux/ioctl.h>
  4. #include <linux/fs.h>
  5. #include <linux/device.h>
  6. #include <linux/err.h>
  7. #include <linux/list.h>
  8. #include <linux/errno.h>
  9. #include <linux/mutex.h>
  10. #include <linux/slab.h>
  11. #include <linux/spi/spi.h>
  12. #include <linux/spi/spidev.h>
  13. #include <asm/uaccess.h>
  14. #define SPIDEV_MAJOR            153 //spidev主设备号
  15. #define N_SPI_MINORS            32  /* ... up to 256 */
  16. static DECLARE_BITMAP(minors, N_SPI_MINORS);    //声明次设备位图
  17. #define SPI_MODE_MASK (SPI_CPHA|SPI_CPOL|SPI_CS_HIGH|SPI_LSB_FIRST|SPI_3WIRE|SPI_LOOP|SPI_NO_CS|SPI_READY)
  18. struct spidev_data {
  19. dev_t   devt;               //设备号
  20. spinlock_t  spi_lock;       //自旋锁
  21. struct spi_device   *spi;   //spi设备结构体
  22. struct list_head    device_entry;
  23. struct mutex    buf_lock;   //互斥锁
  24. unsigned        users;      //使用者计数
  25. u8          *buffer;        //缓冲区
  26. };
  27. static LIST_HEAD(device_list);  //声明spi设备链表
  28. static DEFINE_MUTEX(device_list_lock);  //定义互斥锁
  29. static unsigned bufsiz = 4096;  //最大传输缓冲区大小
  30. module_param(bufsiz, uint, S_IRUGO);
  31. MODULE_PARM_DESC(bufsiz, "data bytes in biggest supported SPI message");
  32. static void spidev_complete(void *arg)
  33. {
  34. complete(arg);  //调用complete
  35. }
  36. static ssize_t spidev_sync(struct spidev_data *spidev, struct spi_message *message)
  37. {
  38. DECLARE_COMPLETION_ONSTACK(done);
  39. int status;
  40. message->complete = spidev_complete; //设置spi消息的complete方法 回调函数
  41. message->context = &done;
  42. spin_lock_irq(&spidev->spi_lock);
  43. if (spidev->spi == NULL) //判断是否有指定对应的spi设备
  44. status = -ESHUTDOWN;
  45. else
  46. status = spi_async(spidev->spi, message);    //spi异步同步
  47. spin_unlock_irq(&spidev->spi_lock);
  48. if (status == 0) {
  49. wait_for_completion(&done); //等待传输完成
  50. status = message->status;    //获取spi消息传输事务状态
  51. if (status == 0)
  52. status = message->actual_length; //status等于传输的实际长度
  53. }
  54. return status;  //返回实际传输长度
  55. }
  56. static inline ssize_t spidev_sync_write(struct spidev_data *spidev, size_t len)
  57. {
  58. struct spi_transfer t = {
  59. .tx_buf     = spidev->buffer,    //发送缓冲区
  60. .len        = len,  //发送数据长度
  61. };
  62. struct spi_message  m;
  63. spi_message_init(&m);   //初始化spi消息(初始化spi传递事务队列)
  64. spi_message_add_tail(&t, &m);   //添加spr传递到该队列
  65. return spidev_sync(spidev, &m); //同步读写
  66. }
  67. static inline ssize_t spidev_sync_read(struct spidev_data *spidev, size_t len)
  68. {
  69. struct spi_transfer t = {
  70. .rx_buf     = spidev->buffer,    //接收缓冲区
  71. .len        = len,  //接收数据长度
  72. };
  73. struct spi_message  m;
  74. spi_message_init(&m);   //初始化spi消息(初始化spi传递事务队列)
  75. spi_message_add_tail(&t, &m);   //添加spr传递到该队列
  76. return spidev_sync(spidev, &m); //同步读写
  77. }
  78. static ssize_t spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
  79. {
  80. struct spidev_data  *spidev;
  81. ssize_t status = 0;
  82. if (count > bufsiz)  //传输数据大于缓冲区容量
  83. return -EMSGSIZE;
  84. spidev = filp->private_data; //从文件私有数据指针获取spidev_data
  85. mutex_lock(&spidev->buf_lock);   //上互斥锁
  86. status = spidev_sync_read(spidev, count);   //同步读,返回传输数据长度
  87. if (status > 0) {
  88. unsigned long   missing;    //丢失的数据个数
  89. missing = copy_to_user(buf, spidev->buffer, status); //内核空间复制到用户空间
  90. if (missing == status)      //丢失的数据个数等于要传输的数据个数
  91. status = -EFAULT;
  92. else
  93. status = status - missing;  //传输成功的数据个数
  94. }
  95. mutex_unlock(&spidev->buf_lock);//解互斥锁
  96. return status;  //返回读取成功的数据个数
  97. }
  98. static ssize_t spidev_write(struct file *filp, const char __user *buf,size_t count, loff_t *f_pos)
  99. {
  100. struct spidev_data  *spidev;
  101. ssize_t         status = 0;
  102. unsigned long       missing;
  103. if (count > bufsiz)  //传输数据大于缓冲区容量
  104. return -EMSGSIZE;
  105. spidev = filp->private_data; //从文件私有数据指针获取spidev_data
  106. mutex_lock(&spidev->buf_lock);   //上互斥锁
  107. missing = copy_from_user(spidev->buffer, buf, count);    //用户空间复制到内核空间
  108. if (missing == 0) { //传输失败个数为0
  109. status = spidev_sync_write(spidev, count);  //同步写,返回传输数据长度
  110. }
  111. else
  112. status = -EFAULT;
  113. mutex_unlock(&spidev->buf_lock);//解互斥锁
  114. return status;  //返回写数据的实际个数
  115. }
  116. static int spidev_message(struct spidev_data *spidev,struct spi_ioc_transfer *u_xfers, unsigned n_xfers)
  117. {
  118. struct spi_message  msg;
  119. struct spi_transfer *k_xfers;
  120. struct spi_transfer *k_tmp;
  121. struct spi_ioc_transfer *u_tmp;
  122. unsigned    n, total;
  123. u8  *buf;
  124. int status = -EFAULT;
  125. spi_message_init(&msg); //初始化spi消息(初始化spi传递事务队列)
  126. k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL); //分配spi传输指针内存
  127. if (k_xfers == NULL)
  128. return -ENOMEM;
  129. buf = spidev->buffer;    //获取spidev_data的缓冲区
  130. total = 0;
  131. //n=xfers为spi_ioc_transfer个数,u_tmp = u_xfers为要处理的spi_ioc_transfer指针
  132. for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;n;n--, k_tmp++, u_tmp++) {
  133. k_tmp->len = u_tmp->len;  //设置传输信息的长度
  134. total += k_tmp->len; //累加传输信息的总长度
  135. if (total > bufsiz) {    //信息量超过bufsiz缓冲区最大容量
  136. status = -EMSGSIZE;
  137. goto done;
  138. }
  139. if (u_tmp->rx_buf) { //接收缓冲区指针不为空
  140. k_tmp->rx_buf = buf; //缓冲区指向buf
  141. if (!access_ok(VERIFY_WRITE, (u8 __user *)(uintptr_t) u_tmp->rx_buf,u_tmp->len))
  142. goto done;
  143. }
  144. if (u_tmp->tx_buf) { //发送缓冲区指针不为空
  145. k_tmp->tx_buf = buf; //缓冲区指针指向buf
  146. if (copy_from_user(buf, (const u8 __user *)(uintptr_t) u_tmp->tx_buf,u_tmp->len)) //用户空间复制数据到buf
  147. goto done;
  148. }
  149. buf += k_tmp->len;   //缓冲区指针移动一个传输信息的长度
  150. k_tmp->cs_change = !!u_tmp->cs_change;    //设置cs_change
  151. k_tmp->bits_per_word = u_tmp->bits_per_word;  //设置bits_per_word 一个字多少位
  152. k_tmp->delay_usecs = u_tmp->delay_usecs;  //设置delay_usecs 毫秒级延时
  153. k_tmp->speed_hz = u_tmp->speed_hz;    //设置speed_hz 速率
  154. #ifdef VERBOSE
  155. dev_dbg(&spidev->spi->dev,"  xfer len %zd %s%s%s%dbits %u usec %uHz\n",
  156. u_tmp->len,u_tmp->rx_buf ? "rx " : "",u_tmp->tx_buf ? "tx " : "",u_tmp->cs_change ? "cs " : "",
  157. u_tmp->bits_per_word ? : spidev->spi->bits_per_word,u_tmp->delay_usecs,u_tmp->speed_hz ? : spidev->spi->max_speed_hz);
  158. #endif
  159. spi_message_add_tail(k_tmp, &msg);  //添加spr传递到该队列
  160. }
  161. //for循环的作用是将spi_ioc_transfer批量转换为spi传递结构体spi_transfer,然后添加进spi传递事务队列
  162. status = spidev_sync(spidev, &msg);     //同步读写
  163. if (status < 0)
  164. goto done;
  165. buf = spidev->buffer;    //获取spidev_data缓冲区指针
  166. for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) {   //批量从内核空间复制spi_ioc_transfer到用户空间
  167. if (u_tmp->rx_buf) { //判断是否存在接收缓冲区
  168. if (__copy_to_user((u8 __user *)(uintptr_t) u_tmp->rx_buf, buf,u_tmp->len)) {
  169. status = -EFAULT;
  170. goto done;
  171. }
  172. }
  173. buf += u_tmp->len;   //buf指针位置调整指向下一个spi_ioc_transfer
  174. }
  175. status = total; //status等于实际传输的数据长度
  176. done:
  177. kfree(k_xfers); //释放k_xfers
  178. return status;  //返回实际传输的数据长度
  179. }
  180. static long spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
  181. {
  182. int err = 0;
  183. int retval = 0;
  184. struct spidev_data  *spidev;
  185. struct spi_device   *spi;
  186. u32 tmp;
  187. unsigned    n_ioc;
  188. struct spi_ioc_transfer *ioc;
  189. if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)    //判断控制命令的类型
  190. return -ENOTTY;
  191. if (_IOC_DIR(cmd) & _IOC_READ)  //判断控制命令的方向是否为读read
  192. err = !access_ok(VERIFY_WRITE,(void __user *)arg, _IOC_SIZE(cmd));  //判断传输数据大小
  193. if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE) //判断控制命令的方向是否为写write
  194. err = !access_ok(VERIFY_READ,(void __user *)arg, _IOC_SIZE(cmd));   //判断传输数据大小
  195. if (err)
  196. return -EFAULT;
  197. spidev = filp->private_data; //从文件私有数据中获取spidev_data
  198. spin_lock_irq(&spidev->spi_lock);    //上自旋锁
  199. spi = spi_dev_get(spidev->spi);          //获取spi设备
  200. spin_unlock_irq(&spidev->spi_lock);  //解自旋锁
  201. if (spi == NULL)    //获取spi设备失败
  202. return -ESHUTDOWN;  //则返回错误
  203. mutex_lock(&spidev->buf_lock);   //上互斥锁
  204. switch (cmd) {
  205. case SPI_IOC_RD_MODE:   //设置spi读模式  (此处原作者的理解与我不同,这里应该是应用程序获取数据)
  206. retval = __put_user(spi->mode & SPI_MODE_MASK,(__u8 __user *)arg);
  207. break;
  208. case SPI_IOC_RD_LSB_FIRST:  //设置spi读最低有效位  (此处原作者的理解与我不同,这里应该是应用程序获取数据)
  209. retval = __put_user((spi->mode & SPI_LSB_FIRST) ?  1 : 0,(__u8 __user *)arg);
  210. break;
  211. case SPI_IOC_RD_BITS_PER_WORD:  //设置spi读每个字含多个个位  (此处原作者的理解与我不同,这里应该是应用程序获取数据)
  212. retval = __put_user(spi->bits_per_word, (__u8 __user *)arg);
  213. break;
  214. case SPI_IOC_RD_MAX_SPEED_HZ:   //设置spi读最大速率  (此处原作者的理解与我不同,这里应该是应用程序获取数据)
  215. retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg);
  216. break;
  217. case SPI_IOC_WR_MODE:   //设置spi写模式
  218. retval = __get_user(tmp, (u8 __user *)arg);
  219. if (retval == 0) {
  220. u8  save = spi->mode;    //获取spi设备模式
  221. if (tmp & ~SPI_MODE_MASK) {
  222. retval = -EINVAL;
  223. break;
  224. }
  225. tmp |= spi->mode & ~SPI_MODE_MASK;
  226. spi->mode = (u8)tmp;
  227. retval = spi_setup(spi);    //配置spi设备
  228. if (retval < 0)
  229. spi->mode = save;
  230. else
  231. dev_dbg(&spi->dev, "spi mode %02x\n", tmp);
  232. }
  233. break;
  234. case SPI_IOC_WR_LSB_FIRST:  //设置spi写最低有效位
  235. retval = __get_user(tmp, (__u8 __user *)arg);
  236. if (retval == 0) {
  237. u8  save = spi->mode;    //获取spi设备模式
  238. if (tmp)
  239. spi->mode |= SPI_LSB_FIRST;
  240. else
  241. spi->mode &= ~SPI_LSB_FIRST;
  242. retval = spi_setup(spi);    //配置spi设备
  243. if (retval < 0)
  244. spi->mode = save;
  245. else
  246. dev_dbg(&spi->dev, "%csb first\n",tmp ? 'l' : 'm');
  247. }
  248. break;
  249. case SPI_IOC_WR_BITS_PER_WORD:  //设置spi写每个字含多个个位
  250. retval = __get_user(tmp, (__u8 __user *)arg);   //用户空间获取数据
  251. if (retval == 0) {
  252. u8  save = spi->bits_per_word;   //获取spi设备 每个字含多少位
  253. spi->bits_per_word = tmp;    //更新新的spi设备 每个字含多少位
  254. retval = spi_setup(spi);    //配置spi设备
  255. if (retval < 0)  //配置失败
  256. spi->bits_per_word = save;   //还原spi设备 每个字含多少位
  257. else
  258. dev_dbg(&spi->dev, "%d bits per word\n", tmp);
  259. }
  260. break;
  261. case SPI_IOC_WR_MAX_SPEED_HZ:       //设置spi写最大速率
  262. retval = __get_user(tmp, (__u32 __user *)arg);  //用户空间获取数据
  263. if (retval == 0) {
  264. u32 save = spi->max_speed_hz;    //获取spi设备最大速率
  265. spi->max_speed_hz = tmp; //更新新的spi设备最大速率
  266. retval = spi_setup(spi);    //配置spi设备
  267. if (retval < 0)  //配置失败
  268. spi->max_speed_hz = save;    //还原spi设备最大速率
  269. else
  270. dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);
  271. }
  272. break;
  273. default:
  274. //命令必须为写方向的命令,且传输数据必须是SPI_IOC_MESSAGE()修饰的命令
  275. if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))|| _IOC_DIR(cmd) != _IOC_WRITE) {
  276. retval = -ENOTTY;
  277. break;
  278. }
  279. tmp = _IOC_SIZE(cmd);   //计算传输数据大小
  280. if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) { //判断是否为spi_ioc_transfer对齐
  281. retval = -EINVAL;
  282. break;
  283. }
  284. n_ioc = tmp / sizeof(struct spi_ioc_transfer);  //计算出spi_ioc_transfer数据的个数
  285. if (n_ioc == 0)
  286. break;
  287. ioc = kmalloc(tmp, GFP_KERNEL); //分配spi_ioc_transfer指针ioc内存
  288. if (!ioc) {
  289. retval = -ENOMEM;
  290. break;
  291. }
  292. if (__copy_from_user(ioc, (void __user *)arg, tmp)) {   //从用户空间复制到内核空间
  293. kfree(ioc); //复制失败则释放ioc内存
  294. retval = -EFAULT;
  295. break;
  296. }
  297. retval = spidev_message(spidev, ioc, n_ioc);    //spidev消息处理
  298. kfree(ioc); //释放ioc内存
  299. break;
  300. }
  301. mutex_unlock(&spidev->buf_lock); //解互斥锁
  302. spi_dev_put(spi);   //增加spi设备的引用计数
  303. return retval;
  304. }
  305. static int spidev_open(struct inode *inode, struct file *filp)
  306. {
  307. struct spidev_data  *spidev;
  308. int status = -ENXIO;
  309. mutex_lock(&device_list_lock);  //上互斥锁
  310. list_for_each_entry(spidev, &device_list, device_entry) {   //遍历device_list
  311. if (spidev->devt == inode->i_rdev) {  //判断设备号找到对应的设备
  312. status = 0; //设置状态为0
  313. break;
  314. }
  315. }
  316. if (status == 0) {  //找得到对应的设备
  317. if (!spidev->buffer) {   //spidev_data缓冲区为空
  318. spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);    //则分配内存
  319. if (!spidev->buffer) {   //还空
  320. dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");  //申请内存失败
  321. status = -ENOMEM;
  322. }
  323. }
  324. if (status == 0) {  //找得到对应的设备
  325. spidev->users++; //spidev_data使用者计数++
  326. filp->private_data = spidev; //spidev_data放在文件的私有数据里
  327. nonseekable_open(inode, filp);  //设置文件的打开模式(文件读写指针不会跟随读写操作移动)
  328. }
  329. }
  330. else
  331. pr_debug("spidev: nothing for minor %d\n", iminor(inode));
  332. mutex_unlock(&device_list_lock);    //接互斥锁
  333. return status;
  334. }
  335. static int spidev_release(struct inode *inode, struct file *filp)
  336. {
  337. struct spidev_data  *spidev;
  338. int status = 0;
  339. mutex_lock(&device_list_lock);
  340. spidev = filp->private_data; //获取spidev_data
  341. filp->private_data = NULL;       //清除文件的私有数据指针
  342. spidev->users--;             //使用者个数--
  343. if (!spidev->users) {    //如果使用者个数为0
  344. int     dofree;
  345. kfree(spidev->buffer);   //释放spidev_data的缓冲区内存
  346. spidev->buffer = NULL;   //清除spidev_data缓冲区指针
  347. spin_lock_irq(&spidev->spi_lock);    //上自旋锁
  348. dofree = (spidev->spi == NULL);  //判断spi设备是否与spidev_data解绑了
  349. spin_unlock_irq(&spidev->spi_lock);  //解自旋锁
  350. if (dofree)         //没有捆绑的spi设备
  351. kfree(spidev);  //则是否spidev_data内存
  352. }
  353. mutex_unlock(&device_list_lock);
  354. return status;
  355. }
  356. static const struct file_operations spidev_fops = {     //文件操作函数集
  357. .owner =    THIS_MODULE,
  358. .write =    spidev_write,       //写write
  359. .read =     spidev_read,        //读read
  360. .unlocked_ioctl = spidev_ioctl, //控制ioctl
  361. .open =     spidev_open,        //打开open
  362. .release =  spidev_release,     //释放release
  363. .llseek =   no_llseek,          //文件指针移动 no_llseek表示没有移动
  364. };
  365. static struct class *spidev_class;
  366. static int __devinit spidev_probe(struct spi_device *spi)
  367. {
  368. struct spidev_data  *spidev;
  369. int status;
  370. unsigned long   minor;
  371. spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);  //分配spidev_data内存
  372. if (!spidev)
  373. return -ENOMEM;
  374. spidev->spi = spi;   //设置spidev_data->spi(spi设备)
  375. spin_lock_init(&spidev->spi_lock);
  376. mutex_init(&spidev->buf_lock);
  377. INIT_LIST_HEAD(&spidev->device_entry);   //初始化spidev_data入口链表
  378. mutex_lock(&device_list_lock);
  379. minor = find_first_zero_bit(minors, N_SPI_MINORS);  //查找次设备位图分配次设备号
  380. if (minor < N_SPI_MINORS) {
  381. struct device *dev;
  382. spidev->devt = MKDEV(SPIDEV_MAJOR, minor);   //计算出设备号
  383. //创建设备/dev/spidev%d.%d(spidev总线号.片选号)
  384. dev = device_create(spidev_class, &spi->dev, spidev->devt,spidev, "spidev%d.%d",spi->master->bus_num, spi->chip_select);
  385. status = IS_ERR(dev) ? PTR_ERR(dev) : 0;
  386. }
  387. else {
  388. dev_dbg(&spi->dev, "no minor number available!\n");
  389. status = -ENODEV;
  390. }
  391. if (status == 0) {  //分配设备号成功
  392. set_bit(minor, minors); //更新次设备位图
  393. list_add(&spidev->device_entry, &device_list);   //添加进设备链表
  394. }
  395. mutex_unlock(&device_list_lock);
  396. if (status == 0)
  397. spi_set_drvdata(spi, spidev);   //spi->dev->p->driver_data=spidev
  398. else
  399. kfree(spidev);
  400. return status;
  401. }
  402. static int __devexit spidev_remove(struct spi_device *spi)
  403. {
  404. struct spidev_data  *spidev = spi_get_drvdata(spi);     //根据spi设备获取spidev_data
  405. spin_lock_irq(&spidev->spi_lock);            //上自旋锁
  406. spidev->spi = NULL;                              //清空spidev_data->spi指针
  407. spi_set_drvdata(spi, NULL);                     //spi->dev->p->driver_data=NULL
  408. spin_unlock_irq(&spidev->spi_lock);          //解自旋锁
  409. mutex_lock(&device_list_lock);              //上互斥锁
  410. list_del(&spidev->device_entry);             //删除spidev_data入口链表
  411. device_destroy(spidev_class, spidev->devt);      //销毁/dev/spidev%d.%d
  412. clear_bit(MINOR(spidev->devt), minors);          //清除次设备位图对应位
  413. if (spidev->users == 0)                          //使用者个数为0
  414. kfree(spidev);                              //释放spidev_data内存
  415. mutex_unlock(&device_list_lock);            //解互斥锁
  416. return 0;
  417. }
  418. static struct spi_driver spidev_spi_driver = {  //spi设备驱动
  419. .driver = {
  420. .name =     "spidev",
  421. .owner =    THIS_MODULE,
  422. },
  423. .probe =    spidev_probe,   //spidev的probe方法(当注册了modalias域为"spidev"的spi设备或板级设备,则会调用probe方法)
  424. .remove =   __devexit_p(spidev_remove), //spidev的remove方法
  425. };
  426. static int __init spidev_init(void)     //spidev接口初始化
  427. {
  428. int status;
  429. BUILD_BUG_ON(N_SPI_MINORS > 256);
  430. //注册字符设备,主设备号SPIDEV_MAJOR=153,捆绑的设备操作函数集为spidev_fops
  431. status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
  432. if (status < 0)
  433. return status;
  434. spidev_class = class_create(THIS_MODULE, "spidev"); //创建设备类spidev_class
  435. if (IS_ERR(spidev_class)) {
  436. unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
  437. return PTR_ERR(spidev_class);
  438. }
  439. status = spi_register_driver(&spidev_spi_driver);   //注册spi设备驱动spidev_spi_driver
  440. if (status < 0) {
  441. class_destroy(spidev_class);
  442. unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
  443. }
  444. return status;
  445. }
  446. module_init(spidev_init);   //声明初始化入口
  447. static void __exit spidev_exit(void)            //spidev接口销毁
  448. {
  449. spi_unregister_driver(&spidev_spi_driver);  //注销spi设备驱动spidev_spi_driver
  450. class_destroy(spidev_class);                //注销设备类spidev_class
  451. unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name); //注销字符设备
  452. }
  453. module_exit(spidev_exit);   //声明初始化出口
  454. MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
  455. MODULE_DESCRIPTION("User mode SPI device interface");
  456. MODULE_LICENSE("GPL");
  457. MODULE_ALIAS("spi:spidev");

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

[cpp] view plaincopy
  1. #include <stdint.h>
  2. #include <unistd.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <getopt.h>
  6. #include <fcntl.h>
  7. #include <sys/ioctl.h>
  8. #include <linux/types.h>
  9. #include <linux/spi/spidev.h>
  10. #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
  11. static void pabort(const char *s)
  12. {
  13. perror(s);
  14. abort();
  15. }
  16. static const char *device = "/dev/spidev1.1";
  17. static uint8_t mode;
  18. static uint8_t bits = 8;
  19. static uint32_t speed = 500000;
  20. static uint16_t delay;
  21. static void transfer(int fd)
  22. {
  23. int ret;
  24. uint8_t tx[] = {    //要发送的数据数组
  25. 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  26. 0x40, 0x00, 0x00, 0x00, 0x00, 0x95,
  27. 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  28. 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  29. 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  30. 0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD,
  31. 0xF0, 0x0D,
  32. };
  33. uint8_t rx[ARRAY_SIZE(tx)] = {0, }; //接收的数据数据
  34. struct spi_ioc_transfer tr = {  //声明并初始化spi_ioc_transfer结构体
  35. .tx_buf = (unsigned long)tx,
  36. .rx_buf = (unsigned long)rx,
  37. .len = ARRAY_SIZE(tx),
  38. .delay_usecs = delay,
  39. .speed_hz = speed,
  40. .bits_per_word = bits,
  41. };
  42. //SPI_IOC_MESSAGE(1)的1表示spi_ioc_transfer的数量
  43. ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);   //ioctl默认操作,传输数据
  44. if (ret < 1)
  45. pabort("can't send spi message");
  46. for (ret = 0; ret < ARRAY_SIZE(tx); ret++) { //打印接收缓冲区
  47. if (!(ret % 6))     //6个数据为一簇打印
  48. puts("");
  49. printf("%.2X ", rx[ret]);
  50. }
  51. puts("");
  52. }
  53. static void print_usage(const char *prog)   //参数错误则打印帮助信息
  54. {
  55. printf("Usage: %s [-DsbdlHOLC3]\n", prog);
  56. puts("  -D --device   device to use (default /dev/spidev1.1)\n"
  57. "  -s --speed    max speed (Hz)\n"
  58. "  -d --delay    delay (usec)\n"
  59. "  -b --bpw      bits per word \n"
  60. "  -l --loop     loopback\n"
  61. "  -H --cpha     clock phase\n"
  62. "  -O --cpol     clock polarity\n"
  63. "  -L --lsb      least significant bit first\n"
  64. "  -C --cs-high  chip select active high\n"
  65. "  -3 --3wire    SI/SO signals shared\n");
  66. exit(1);
  67. }
  68. static void parse_opts(int argc, char *argv[])
  69. {
  70. while (1) {
  71. static const struct option lopts[] = {  //参数命令表
  72. { "device",  1, 0, 'D' },
  73. { "speed",   1, 0, 's' },
  74. { "delay",   1, 0, 'd' },
  75. { "bpw",     1, 0, 'b' },
  76. { "loop",    0, 0, 'l' },
  77. { "cpha",    0, 0, 'H' },
  78. { "cpol",    0, 0, 'O' },
  79. { "lsb",     0, 0, 'L' },
  80. { "cs-high", 0, 0, 'C' },
  81. { "3wire",   0, 0, '3' },
  82. { "no-cs",   0, 0, 'N' },
  83. { "ready",   0, 0, 'R' },
  84. { NULL, 0, 0, 0 },
  85. };
  86. int c;
  87. c = getopt_long(argc, argv, "D:s:d:b:lHOLC3NR", lopts, NULL);
  88. if (c == -1)
  89. break;
  90. switch (c) {
  91. case 'D':   //设备名
  92. device = optarg;
  93. break;
  94. case 's':   //速率
  95. speed = atoi(optarg);
  96. break;
  97. case 'd':   //延时时间
  98. delay = atoi(optarg);
  99. break;
  100. case 'b':   //每字含多少位
  101. bits = atoi(optarg);
  102. break;
  103. case 'l':   //回送模式
  104. mode |= SPI_LOOP;
  105. break;
  106. case 'H':   //时钟相位
  107. mode |= SPI_CPHA;
  108. break;
  109. case 'O':   //时钟极性
  110. mode |= SPI_CPOL;
  111. break;
  112. case 'L':   //lsb 最低有效位
  113. mode |= SPI_LSB_FIRST;
  114. break;
  115. case 'C':   //片选高电平
  116. mode |= SPI_CS_HIGH;
  117. break;
  118. case '3':   //3线传输模式
  119. mode |= SPI_3WIRE;
  120. break;
  121. case 'N':   //没片选
  122. mode |= SPI_NO_CS;
  123. break;
  124. case 'R':   //从机拉低电平停止数据传输
  125. mode |= SPI_READY;
  126. break;
  127. default:    //错误的参数
  128. print_usage(argv[0]);
  129. break;
  130. }
  131. }
  132. }
  133. int main(int argc, char *argv[])
  134. {
  135. int ret = 0;
  136. int fd;
  137. parse_opts(argc, argv); //解析传递进来的参数
  138. fd = open(device, O_RDWR);  //打开设备文件
  139. if (fd < 0)
  140. pabort("can't open device");
  141. /*
  142. * spi mode //设置spi设备模式
  143. */
  144. ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);    //写模式
  145. if (ret == -1)
  146. pabort("can't set spi mode");
  147. ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);    //读模式
  148. if (ret == -1)
  149. pabort("can't get spi mode");
  150. /*
  151. * bits per word    //设置每个字含多少位
  152. */
  153. ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);   //写 每个字含多少位
  154. if (ret == -1)
  155. pabort("can't set bits per word");
  156. ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);   //读 每个字含多少位
  157. if (ret == -1)
  158. pabort("can't get bits per word");
  159. /*
  160. * max speed hz     //设置速率
  161. */
  162. ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);   //写速率
  163. if (ret == -1)
  164. pabort("can't set max speed hz");
  165. ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);   //读速率
  166. if (ret == -1)
  167. pabort("can't get max speed hz");
  168. //打印模式,每字多少位和速率信息
  169. printf("spi mode: %d\n", mode);
  170. printf("bits per word: %d\n", bits);
  171. printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);
  172. transfer(fd);   //传输测试
  173. close(fd);  //关闭设备
  174. return ret;
  175. }

这里整理下ioctl的命令:

[cpp] view plaincopy
  1. SPI_IOC_RD_MODE     //读 模式
  2. SPI_IOC_RD_LSB_FIRST    //读 LSB
  3. SPI_IOC_RD_BITS_PER_WORD    //读 每字多少位
  4. SPI_IOC_RD_MAX_SPEED_HZ //读 最大速率
  5. SPI_IOC_WR_MODE     //写 模式
  6. SPI_IOC_WR_LSB_FIRST    //写 LSB
  7. SPI_IOC_WR_BITS_PER_WORD    //写 每字多少位
  8. SPI_IOC_WR_MAX_SPEED_HZ //写 最大速率
  9. SPI_IOC_MESSAGE(n)      //传输n个数据包

转载于:https://www.cnblogs.com/sankye/p/3955630.html

linux spi驱动开发学习-----spidev.c和spi test app相关推荐

  1. Linux字符驱动开发学习总结

    linux驱动编写(虚拟字符设备编写) 昨天我们说了一些简单模块编写方法,但是终归没有涉及到设备的编写内容,今天我们就可以了解一下相关方面的内容,并且用一个实例来说明在linux上面设备是如何编写的. ...

  2. Linux/android 驱动开发学习

    参考资料: <Android深度探索 卷1 HAL与驱动开发.pdf> <嵌入式linux开发教程(下册).pdf> https://blog.51cto.com/u_1380 ...

  3. Linux下驱动开发_块设备驱动开发(硬件上采用SD卡+SPI协议)

    一.前言 块设备主要为存储设备设计的框架. 在前面章节Linux下驱动开发_块设备驱动开发(内存模拟存储) 里介绍了块设备驱动编写思路,并且利用内存模拟了硬件存储,完成了块设备驱动开发测试.这一篇文章 ...

  4. 《Linux设备驱动开发详解》学习笔记一

    Linux设备驱动开发详解学习笔记<一> 书名:<Linux设备驱动开发详解>第二版 主机环境:Linux version 2.6.25-14.fc9.i686@Fedora ...

  5. linux底层驱动内核,Linux底层驱动开发需要学习哪些内容

    Linux底层驱动开发需要学习哪些内容想必这是很多学习Linux的朋友十分头疼的问题,今天就让我来告诉大家我们到底该学习哪些内容呢? 1. 要会一些硬件知识,比如Arm接口编程 2. 学会写简单的ma ...

  6. Linux 设备驱动开发思想 —— 驱动分层与驱动分离

    前面我们学习I2C.USB.SD驱动时,有没有发现一个共性,就是在驱动开发时,每个驱动都分层三部分,由上到下分别是: 1.XXX 设备驱动 2.XXX 核心层 3.XXX 主机控制器驱动 而需要我们编 ...

  7. Linux 设备驱动开发 —— 设备树在platform设备驱动中的使用

    关与设备树的概念,我们在Exynos4412 内核移植(六)-- 设备树解析 里面已经学习过,下面看一下设备树在设备驱动开发中起到的作用 Device Tree是一种描述硬件的数据结构,设备树源(De ...

  8. 《Linux设备驱动开发详解(第2版)》隆重出版

    Linux设备驱动开发详解(第2版)(前一版狂销3万册,畅销书最新升级) [新品] 点击看大图     基本信息 * 作者: 宋宝华       * 出版社:人民邮电出版社     * ISBN:97 ...

  9. 《Linux设备驱动开发详解 A》一一2.3 接口与总线

    本节书摘来华章计算机出版社<Linux设备驱动开发详解 A>一书中的第2章,第2.3节,作者:宋宝华 更多章节内容可以访问云栖社区"华章计算机"公众号查看.1 2.3 ...

  10. linux cached释放_正点原子Linux第四十一章嵌入式Linux LED驱动开发实验

    1)资料下载:点击资料即可下载 2)对正点原子Linux感兴趣的同学可以加群讨论:935446741 3)关注正点原子公众号,获取最新资料更新 第四十一章嵌入式Linux LED驱动开发实验 上一章我 ...

最新文章

  1. 阿里如何实现100%容器化镜像化?八年技术演进之路回顾
  2. 毕业一年左右的前端妹子面经总结
  3. WebDriver自动化测试框架详解
  4. CentOS 7 DIG命令工具打上EDNS补丁
  5. 快速pow和sqrt的小技巧 hdu4282
  6. 列注释_【EXCEL检查问题】:如何快速检查并删除EXCEL中隐藏的工作表、行、列等信息...
  7. Linux: wget 使用技巧
  8. weblogic多次连接后tcp服务堵塞_网络编程——服务器篇
  9. Spring Boot:Consider defining a bean of type ‘*.*.*‘ in your configuration解决方案
  10. matlab振荡环节相频特性,自动控制原理第五章频率特性)汇总.ppt
  11. 初闻“Linux中的cp,mv,rm”
  12. ffmpeg使用硬件加速hwaccel、cuvid、h264_cuvid、h264_nvenc
  13. 通过禁用受保护的视图来启用所有Office 2010文档的编辑
  14. html平板电脑打不开,苹果平板电脑浏览器打不开网页
  15. 科普!人人都爱Python,可Python为什么叫Python?
  16. R语言ggplot2可视化气泡图(bubble plot)、将可视化图像的图例(lengend)放置在图像底部、图例水平方向排布(horizontal direction)、图例标题在图例标签顶部
  17. CHECKBOX用法
  18. 360浏览器保存网页html,如何设置360浏览器网页保存类型默认为html
  19. JAVA MySQL数据库 笔记
  20. AFL(american fuzzy lop)学习二

热门文章

  1. 空间如何超越极小而存在
  2. 由蔺相如谈谈某些人的娱乐表演
  3. 吾是否有“受迫害妄想症”之反省
  4. draw9patch做一个中心不变形的图片
  5. C# 16进制转10进制 16进制字符串转换
  6. python的浮点数_Python的浮点数损失精度问题
  7. 永磁无刷电机及其驱动技术_「技术」某种车型后驱动桥装配工艺及其工装的设计...
  8. 《中国人工智能学会通讯》——1.20 聊天机器人研究存在的挑战
  9. Linux命令行操作快捷键及技巧
  10. 基于日志处理的ElasticSearch的学(gen)习(feng)