Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1154730
  • 博文数量: 511
  • 博客积分: 967
  • 博客等级: 准尉
  • 技术积分: 2560
  • 用 户 组: 普通用户
  • 注册时间: 2012-07-06 14:19
文章分类

全部博文(511)

文章存档

2016年(11)

2015年(61)

2014年(257)

2013年(63)

2012年(119)

分类: LINUX

2015-06-05 16:03:09

一.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添加注释部分



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


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

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


这里整理下ioctl的命令:

  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个数据包 
阅读(1063) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册