Linux驱动修炼之道-SPI驱动框架源码分析(下)

长平狐 发布于 2012/06/12 15:33
阅读 1K+
收藏 0

来自:http://blog.csdn.net/woshixingaaa/article/details/6574224

这篇文档主要介绍spi数据传输过程。

当应用层要向设备传输数据的时候,会通过ioctl向设备驱动发送传输数据的命令。如图,向SPI从设备发送读写命令,实际的读写操作还是调用了主机控制器驱动的数据传输函数。transfer函数用于spi的IO传输。但是,transfer函数一般不会执行真正的传输操作,而是把要传输的内容放到一个队列里,然后调用一种类似底半部的机制进行真正的传输。这是因为,spi总线一般会连多个spi设备,而spi设备间的访问可能会并发。如果直接在transfer函数中实现传输,那么会产生竞态,spi设备互相间会干扰。所以,真正的spi传输与具体的spi控制器的实现有关,spi的框架代码中没有涉及。像spi设备的片选,根据具体设备进行时钟调整等等都在实现传输的代码中被调用。spi的传输命令都是通过结构spi_message定义,设备程序调用transfer函数将spi_message交给spi总线驱动,总线驱动再将message传到底半部排队,实现串行化传输。



在spidev.c中实现了file_operations:

  1. <span style="font-size:18px;">static struct file_operations spidev_fops = {  
  2.     .owner =    THIS_MODULE,  
  3.     .write =    spidev_write,  
  4.     .read =     spidev_read,  
  5.     .unlocked_ioctl = spidev_ioctl,  
  6.     .open =     spidev_open,  
  7.     .release =  spidev_release,  
  8. };</span>  
这里看spidev_ioctl的实现:

  1. <span style="font-size:18px;">static long  
  2. spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)  
  3. {  
  4.     int         err = 0;  
  5.     int         retval = 0;  
  6.     struct spidev_data  *spidev;  
  7.     struct spi_device   *spi;  
  8.     u32         tmp;  
  9.     unsigned        n_ioc;  
  10.     struct spi_ioc_transfer *ioc;  
  11.   
  12.     /*查看这个命令的幻数字段是否为'k'*/  
  13.     if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)  
  14.         return -ENOTTY;  
  15.   
  16.     /*如果方向是用户空间从内核读,即内核向用户空间写,则检查用户空间的地址是否有效*/  
  17.     if (_IOC_DIR(cmd) & _IOC_READ)  
  18.         err = !access_ok(VERIFY_WRITE,  
  19.                 (void __user *)arg, _IOC_SIZE(cmd));  
  20.     /*如果方向是用户空间向内核写,即内核读用户空间,则检查用户空间的地址是否有效*/  
  21.     if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE)  
  22.         err = !access_ok(VERIFY_READ,  
  23.                 (void __user *)arg, _IOC_SIZE(cmd));  
  24.     if (err)  
  25.         return -EFAULT;  
  26.   
  27.     /* guard against device removal before, or while, 
  28.      * we issue this ioctl. 
  29.      */  
  30.     spidev = filp->private_data;  
  31.     spin_lock_irq(&spidev->spi_lock);  
  32.     spi = spi_dev_get(spidev->spi);  
  33.     spin_unlock_irq(&spidev->spi_lock);  
  34.   
  35.     if (spi == NULL)  
  36.         return -ESHUTDOWN;  
  37.   
  38.     mutex_lock(&spidev->buf_lock);  
  39.   
  40.     switch (cmd) {  
  41.     /* read requests */  
  42.     case SPI_IOC_RD_MODE:  
  43.         /*因为已经进行了地址是否有效的检查,所以这里使用__put_user,__get_user,__copy_from_user可以节省几个时钟周期呢*/  
  44.         retval = __put_user(spi->mode & SPI_MODE_MASK,  
  45.                     (__u8 __user *)arg);  
  46.         break;  
  47.     case SPI_IOC_RD_LSB_FIRST:  
  48.         retval = __put_user((spi->mode & SPI_LSB_FIRST) ?  1 : 0,  
  49.                     (__u8 __user *)arg);  
  50.         break;  
  51.     case SPI_IOC_RD_BITS_PER_WORD:  
  52.         retval = __put_user(spi->bits_per_word, (__u8 __user *)arg);  
  53.         break;  
  54.     case SPI_IOC_RD_MAX_SPEED_HZ:  
  55.         retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg);  
  56.         break;  
  57.   
  58.     /*设置SPI模式*/  
  59.     case SPI_IOC_WR_MODE:  
  60.         retval = __get_user(tmp, (u8 __user *)arg);  
  61.         if (retval == 0) {  
  62.             /*先将之前的模式保存起来,一旦设置失败进行回复*/  
  63.             u8  save = spi->mode;  
  64.   
  65.             if (tmp & ~SPI_MODE_MASK) {  
  66.                 retval = -EINVAL;  
  67.                 break;  
  68.             }  
  69.   
  70.             tmp |= spi->mode & ~SPI_MODE_MASK;  
  71.             spi->mode = (u8)tmp;  
  72.             retval = spi_setup(spi);  
  73.             if (retval < 0)  
  74.                 spi->mode = save;  
  75.             else  
  76.                 dev_dbg(&spi->dev, "spi mode %02x\n", tmp);  
  77.         }  
  78.         break;  
  79.     case SPI_IOC_WR_LSB_FIRST:  
  80.         retval = __get_user(tmp, (__u8 __user *)arg);  
  81.         if (retval == 0) {  
  82.             u8  save = spi->mode;  
  83.   
  84.             if (tmp)  
  85.                 spi->mode |= SPI_LSB_FIRST;  
  86.             else  
  87.                 spi->mode &= ~SPI_LSB_FIRST;  
  88.             retval = spi_setup(spi);  
  89.             if (retval < 0)  
  90.                 spi->mode = save;  
  91.             else  
  92.                 dev_dbg(&spi->dev, "%csb first\n",  
  93.                         tmp ? 'l' : 'm');  
  94.         }  
  95.         break;  
  96.     case SPI_IOC_WR_BITS_PER_WORD:  
  97.         retval = __get_user(tmp, (__u8 __user *)arg);  
  98.         if (retval == 0) {  
  99.             u8  save = spi->bits_per_word;  
  100.   
  101.             spi->bits_per_word = tmp;  
  102.             retval = spi_setup(spi);  
  103.             if (retval < 0)  
  104.                 spi->bits_per_word = save;  
  105.             else  
  106.                 dev_dbg(&spi->dev, "%d bits per word\n", tmp);  
  107.         }  
  108.         break;  
  109.     case SPI_IOC_WR_MAX_SPEED_HZ:  
  110.         retval = __get_user(tmp, (__u32 __user *)arg);  
  111.         if (retval == 0) {  
  112.             u32 save = spi->max_speed_hz;  
  113.   
  114.             spi->max_speed_hz = tmp;  
  115.             retval = spi_setup(spi);  
  116.             if (retval < 0)  
  117.                 spi->max_speed_hz = save;  
  118.             else  
  119.                 dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);  
  120.         }  
  121.         break;  
  122.   
  123.     default:  
  124.         /* segmented and/or full-duplex I/O request */  
  125.         if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))  
  126.                 || _IOC_DIR(cmd) != _IOC_WRITE) {  
  127.             retval = -ENOTTY;  
  128.             break;  
  129.         }  
  130.         /*得到用户空间数据的大小*/  
  131.         tmp = _IOC_SIZE(cmd);  
  132.         /*如果这些数据不能分成spi_ioc_transfer的整数倍,则不能进行传输,spi_io_transfer是对spi_transfer的映射*/  
  133.         if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) {  
  134.             retval = -EINVAL;  
  135.             break;  
  136.         }  
  137.         /*计算出能分多少个spi_ioc_transfer*/  
  138.         n_ioc = tmp / sizeof(struct spi_ioc_transfer);  
  139.         if (n_ioc == 0)  
  140.             break;  
  141.   
  142.         /*在内核中分配装载这些数据的内存空间*/  
  143.         ioc = kmalloc(tmp, GFP_KERNEL);  
  144.         if (!ioc) {  
  145.             retval = -ENOMEM;  
  146.             break;  
  147.         }  
  148.         /*把用户空间的数据拷贝过来*/  
  149.         if (__copy_from_user(ioc, (void __user *)arg, tmp)) {  
  150.             kfree(ioc);  
  151.             retval = -EFAULT;  
  152.             break;  
  153.         }  
  154.   
  155.         /*进行数据传输*/  
  156.         <span style="color:#ff0000;">retval = spidev_message(spidev, ioc, n_ioc);</span>  
  157.         kfree(ioc);  
  158.         break;  
  159.     }  
  160.   
  161.     mutex_unlock(&spidev->buf_lock);  
  162.     spi_dev_put(spi);  
  163.     return retval;  
  164. }  
  165. </span>  

下面跟踪spidev_message看看:

  1. <span style="font-size:18px;">static int spidev_message(struct spidev_data *spidev,  
  2.         struct spi_ioc_transfer *u_xfers, unsigned n_xfers)  
  3. {  
  4.     struct spi_message  msg;  
  5.     struct spi_transfer *k_xfers;  
  6.     struct spi_transfer *k_tmp;  
  7.     struct spi_ioc_transfer *u_tmp;  
  8.     unsigned        n, total;  
  9.     u8          *buf;  
  10.     int         status = -EFAULT;  
  11.     /*初始化spi_message的tranfers链表头*/  
  12.     spi_message_init(&msg);  
  13.     /*分配n个spi_transfer的内存空间,一个spi_message由多个数据段spi_message组成*/  
  14.     k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL);  
  15.     if (k_xfers == NULL)  
  16.         return -ENOMEM;  
  17.   
  18.     buf = spidev->buffer;  
  19.     total = 0;  
  20.     /*这个for循环的主要任务是将所有的spi_transfer组装成一个spi_message*/  
  21.     for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;  
  22.             n;  
  23.             n--, k_tmp++, u_tmp++) {  
  24.         /*u_tmp是从用户空间传下来的spi_ioc_message的大小,spi_ioc_message是对spi_message的映射*/  
  25.         k_tmp->len = u_tmp->len;  
  26.         /*统计要传输数据的总量*/  
  27.         total += k_tmp->len;  
  28.         if (total > bufsiz) {  
  29.             status = -EMSGSIZE;  
  30.             goto done;  
  31.         }  
  32.         /*spi_transfer是一个读写的buffer对,如果是要接收则把buffer给接收的rx_buf*/  
  33.         if (u_tmp->rx_buf) {  
  34.             k_tmp->rx_buf = buf;  
  35.             if (!access_ok(VERIFY_WRITE, (u8 __user *)  
  36.                         (uintptr_t) u_tmp->rx_buf,  
  37.                         u_tmp->len))  
  38.                 goto done;  
  39.         }  
  40.         /*如果要传输,这个buffer给tx_buf使用,从用户空间拷过来要传输的数据*/  
  41.         if (u_tmp->tx_buf) {  
  42.             k_tmp->tx_buf = buf;  
  43.             if (copy_from_user(buf, (const u8 __user *)  
  44.                         (uintptr_t) u_tmp->tx_buf,  
  45.                     u_tmp->len))  
  46.                 goto done;  
  47.         }  
  48.         /*指向下一段内存*/  
  49.         buf += k_tmp->len;  
  50.         /*最后一个transfer传输完毕是否会影响片选*/  
  51.         k_tmp->cs_change = !!u_tmp->cs_change;  
  52.         /*每字长的字节数*/  
  53.         k_tmp->bits_per_word = u_tmp->bits_per_word;  
  54.         /*一段数据传输完需要一定的时间等待*/  
  55.         k_tmp->delay_usecs = u_tmp->delay_usecs;  
  56.         /*初始化传输速度*/  
  57.         k_tmp->speed_hz = u_tmp->speed_hz;  
  58.         /*将spi_transfer通过它的transfer_list字段挂到spi_message的transfer队列上*/  
  59.         spi_message_add_tail(k_tmp, &msg);  
  60.     }  
  61.     /*调用底层的传输函数*/  
  62.     <span style="color:#ff0000;">status = spidev_sync(spidev, &msg);</span>  
  63.     if (status < 0)  
  64.         goto done;  
  65.   
  66.     /* copy any rx data out of bounce buffer */  
  67.     buf = spidev->buffer;  
  68.     /*把传输数据拷贝到用户空间打印出来,可以查看是否传输成功*/  
  69.     for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) {  
  70.         if (u_tmp->rx_buf) {  
  71.             if (__copy_to_user((u8 __user *)  
  72.                     (uintptr_t) u_tmp->rx_buf, buf,  
  73.                     u_tmp->len)) {  
  74.                 status = -EFAULT;  
  75.                 goto done;  
  76.             }  
  77.         }  
  78.         buf += u_tmp->len;  
  79.     }  
  80.     status = total;  
  81.   
  82. done:  
  83.     kfree(k_xfers);  
  84.     return status;  
  85. }  
  86. </span>  

看spidev_sync的实现:

  1. <span style="font-size:18px;">static ssize_t  
  2. spidev_sync(struct spidev_data *spidev, struct spi_message *message)  
  3. {  
  4.     /*声明并初始化一个完成量*/  
  5.     DECLARE_COMPLETION_ONSTACK(done);  
  6.     int status;  
  7.     /*指定spi_message使用的唤醒完成量函数*/  
  8.     message->complete = spidev_complete;  
  9.     message->context = &done;  
  10.   
  11.     spin_lock_irq(&spidev->spi_lock);  
  12.     if (spidev->spi == NULL)  
  13.         status = -ESHUTDOWN;  
  14.     else  
  15.         /*调用spi核心中的函数进行数据传输*/  
  16.     <span style="color:#ff0000;"> status = spi_async(spidev->spi, message);</span>  
  17.     spin_unlock_irq(&spidev->spi_lock);  
  18.   
  19.     if (status == 0) {  
  20.         /*等待完成量被唤醒*/  
  21.         wait_for_completion(&done);  
  22.         status = message->status;  
  23.         if (status == 0)  
  24.             status = message->actual_length;  
  25.     }  
  26.     return status;  
  27. }  
  28. </span>  
spi_async在spi.h中定义的:

  1. <span style="font-size:18px;">static inline int  
  2. spi_async(struct spi_device *spi, struct spi_message *message)  
  3. {  
  4.     message->spi = spi;  
  5.     return spi->master->transfer(spi, message);  
  6. }  
  7. </span>  
这里的master->transfer是在spi_bitbang_start中进行赋值的:

bitbang->master->transfer= spi_bitbang_transfer;

看spi_bitbang_transfer的实现:

  1. <span style="font-size:18px;">int spi_bitbang_transfer(struct spi_device *spi, struct spi_message *m)  
  2. {  
  3.     struct spi_bitbang  *bitbang;  
  4.     unsigned long       flags;  
  5.     int         status = 0;  
  6.   
  7.     m->actual_length = 0;  
  8.     m->status = -EINPROGRESS;  
  9.     /*在spi_alloc_master函数中调用spi_master_set_devdata把struct s3c24xx_spi结构存放起来,而struct spi_bitbang正是struct s3c24xx_spi结构所包含的第一个结构*/  
  10.     bitbang = spi_master_get_devdata(spi->master);  
  11.   
  12.     spin_lock_irqsave(&bitbang->lock, flags);  
  13.     if (!spi->max_speed_hz)  
  14.         status = -ENETDOWN;  
  15.     else {  
  16.         /*把message加入到bitbang的等待队列中*/  
  17.         list_add_tail(&m->queue, &bitbang->queue);  
  18.         /*把bitbang-work加入bitbang->workqueue中,调度运行*/  
  19.         queue_work(bitbang->workqueue, &bitbang->work);  
  20.     }  
  21.     spin_unlock_irqrestore(&bitbang->lock, flags);  
  22.   
  23.     return status;  
  24. }  
  25. EXPORT_SYMBOL_GPL(spi_bitbang_transfer);  
  26. </span>  

分析工作队列的处理函数:


  1. <span style="font-size:18px;">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.   
  7.     spin_lock_irqsave(&bitbang->lock, flags);  
  8.     /*设置成忙状态*/  
  9.     bitbang->busy = 1;  
  10.     /*对bitqueue中的每一个spi_message进行处理*/  
  11.     while (!list_empty(&bitbang->queue)) {  
  12.         struct spi_message  *m;  
  13.         struct spi_device   *spi;  
  14.         unsigned        nsecs;  
  15.         struct spi_transfer *t = NULL;  
  16.         unsigned        tmp;  
  17.         unsigned        cs_change;  
  18.         int         status;  
  19.         int         (*setup_transfer)(struct spi_device *,  
  20.                         struct spi_transfer *);  
  21.   
  22.         m = container_of(bitbang->queue.next, struct spi_message,  
  23.                 queue);  
  24.         /*从队列中驱动这个spi_message*/  
  25.         list_del_init(&m->queue);  
  26.         spin_unlock_irqrestore(&bitbang->lock, flags);  
  27.   
  28.         nsecs = 100;  
  29.   
  30.         spi = m->spi;  
  31.         tmp = 0;  
  32.         cs_change = 1;  
  33.         status = 0;  
  34.         setup_transfer = NULL;  
  35.         /*对spi_message的transfers上的每个spi_transfer进行处理*/  
  36.         list_for_each_entry (t, &m->transfers, transfer_list) {  
  37.         。。。。。。。。。。。。。。。。。  
  38.             if (t->len) {                  
  39.                 if (!m->is_dma_mapped)  
  40.                     t->rx_dma = t->tx_dma = 0;  
  41.                 /*调用bitbang->txrx_bufs进行数据的传输,bitbang->txrx_bufs = s3c24xx_spi_txrx;这个在s3c24xx_spi_probe中进行赋值的*/  
  42.                 <span style="color:#ff0000;">status = bitbang->txrx_bufs(spi, t);</span>  
  43.             }  
  44.         。。。。。。。。。。。。。。。。  
  45.   
  46.         m->status = status;  
  47.         /*传输完成,唤醒刚才的那个完成变量*/  
  48.         m->complete(m->context);  
  49.   
  50.         /* restore speed and wordsize */  
  51.         if (setup_transfer)  
  52.             setup_transfer(spi, NULL);  
  53.         if (!(status == 0 && cs_change)) {  
  54.             ndelay(nsecs);  
  55.             bitbang->chipselect(spi, BITBANG_CS_INACTIVE);  
  56.             ndelay(nsecs);  
  57.         }  
  58.   
  59.         spin_lock_irqsave(&bitbang->lock, flags);  
  60.     }  
  61.     bitbang->busy = 0;  
  62.     spin_unlock_irqrestore(&bitbang->lock, flags);  
  63. }  
  64. </span>  
这个工作队列的处理函数中调用了spi controller driver中的传输函数:

  1. <span style="font-size:18px;">static int s3c24xx_spi_txrx(struct spi_device *spi, struct spi_transfer *t)  
  2. {  
  3.     struct s3c24xx_spi *hw = to_hw(spi);  
  4.   
  5.     dev_dbg(&spi->dev, "txrx: tx %p, rx %p, len %d\n",  
  6.         t->tx_buf, t->rx_buf, t->len);  
  7.   
  8.     hw->tx = t->tx_buf;  //发送指针  
  9.     hw->rx = t->rx_buf;  //接收指针  
  10.     hw->len = t->len;    //需要发送/接收的数目  
  11.     hw->count = 0;       //存放实际spi传输的数据数目  
  12.     /*初始化了完成量*/  
  13.     init_completion(&hw->done);  
  14.       
  15.     /* 
  16.      *只需发送第一个字节(如果发送为空,则发送0xff),中断中就会自动发送完其他字节(并接受数据) 
  17.      *直到所有数据发送完毕且所有数据接收完毕才返回 
  18.      */  
  19.     writeb(hw_txbyte(hw, 0), hw->regs + S3C2410_SPTDAT);  
  20.     /*等待完成量被唤醒*/  
  21.     wait_for_completion(&hw->done);  
  22.     return hw->count;  
  23. }  
  24. static inline unsigned int hw_txbyte(struct s3c24xx_spi *hw, int count)  
  25. {  
  26.         return hw->tx ? hw->tx[count] : 0xff;  
  27.         //如果还有数据没接收完且要发送的数据经已发送完毕,发送空数据0xFF  
  28. }  
  29. </span>  
下面来分析中断函数:

  1. <span style="font-size:18px;">static irqreturn_t s3c24xx_spi_irq(int irq, void *dev)  
  2. {  
  3.     struct s3c24xx_spi *hw = dev;  
  4.     /*读取spi的状态寄存器*/  
  5.     unsigned int spsta = readb(hw->regs + S3C2410_SPSTA);  
  6.     unsigned int count = hw->count;  
  7.     /*检测冲突*/  
  8.     if (spsta & S3C2410_SPSTA_DCOL) {               
  9.         dev_dbg(hw->dev, "data-collision\n");   
  10.         /*唤醒完成量*/  
  11.         complete(&hw->done);  
  12.         goto irq_done;  
  13.     }  
  14.     /*设备忙*/  
  15.     if (!(spsta & S3C2410_SPSTA_READY)) {  
  16.         dev_dbg(hw->dev, "spi not ready for tx?\n");  
  17.         /*唤醒完成量*/  
  18.         complete(&hw->done);  
  19.         goto irq_done;  
  20.     }  
  21.   
  22.     hw->count++;  
  23.     /*接收数据*/  
  24.     if (hw->rx)  
  25.         hw->rx[count] = readb(hw->regs + S3C2410_SPRDAT);  
  26.   
  27.     count++;  
  28.     /*如果count小于需要发送或接收数据的数目,发送其他数据*/  
  29.     if (count < hw->len)  
  30.         writeb(hw_txbyte(hw, count), hw->regs + S3C2410_SPTDAT);  
  31.     else  
  32.         /*唤醒完成量,通知s3c24xx_spi_txrx函数*/  
  33.         complete(&hw->done);  
  34.   
  35.  irq_done:  
  36.     return IRQ_HANDLED;  
  37. }  
  38. </span>  
至此spi数据传输过程完成,如果不想为自己的SPI设备写驱动,那么可以用Linux自带的spidev.c提供的驱动程序,只要在登记时,把设备名设置成spidev就可以了。spidev.c会在device目录下自动为每一个匹配的SPI设备创建设备节点,节点名"spi%d"。之后,用户程序可以通过字符型设备的通用接口控制SPI设备。需要注意的是,spidev创建的设备在设备模型中属于虚拟设备,他的class是spidev_class,他的父设备是在boardinfo中定义的spi设备。

原文链接:http://blog.csdn.net/lanmanck/article/details/6895324
加载中
返回顶部
顶部