Linux SPI框架(下)

 

分类： Linux驱动程序2012-07-11 20:44 3006人阅读 评论(2) 收藏 举报
linuxstructlistclassdelayprocessing

水平有限，描述不当之处还请之处，转载请注明出处http://blog.csdn.net/vanbreaker/article/details/7737833  

     本节以spidev设备驱动为例，来阐述SPI数据传输的过程。spidev是内核中一个通用的设备驱动，我们注册的从设备都可以使用该驱动，只需在注册时将从设备的modalias字段设置为"spidev",这样才能和spidev驱动匹配成功。我们要传输的数据有时需要分为一段一段的(比如先发送，后读取，就需要两个字段)，每个字段都被封装成一个transfer,N个transfer可以被添加到message中，作为一个消息包进行传输。当用户发出传输数据的请求时，message并不会立刻传输到从设备，而是由之前定义的transfer()函数将message放入一个等待队列中，这些message会以FIFO的方式有workqueue调度进行传输，这样能够避免SPI从设备同一时间对主SPI控制器的竞争。和之前一样，还是习惯先画一张图来描述数据传输的主要过程。

 

         在使用spidev设备驱动时，需要先初始化spidev. spidev是以字符设备的形式注册进内核的。

[cpp] view plaincopy
 
  1. static int __init spidev_init(void)  
  2. {  
  3.     int status;  
  4.   
  5.     /* Claim our 256 reserved device numbers.  Then register a class 
  6.      * that will key udev/mdev to add/remove /dev nodes.  Last, register 
  7.      * the driver which manages those device numbers. 
  8.      */  
  9.     BUILD_BUG_ON(N_SPI_MINORS > 256);  
  10.     /*将spidev作为字符设备注册*/  
  11.     status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);  
  12.     if (status < 0)  
  13.         return status;  
  14.   
  15.     /*创建spidev类*/  
  16.     spidev_class = class_create(THIS_MODULE, "spidev");  
  17.     if (IS_ERR(spidev_class)) {  
  18.         unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);  
  19.         return PTR_ERR(spidev_class);  
  20.     }  
  21.   
  22.     /*注册spidev的driver,可与modalias字段为"spidev"的spi_device匹配*/  
  23.     status = spi_register_driver(&spidev_spi);  
  24.     if (status < 0) {  
  25.         class_destroy(spidev_class);  
  26.         unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);  
  27.     }  
  28.     return status;  
  29. }  


与相应的从设备匹配成功后，则调用spidev中的probe函数

[cpp] view plaincopy
 
  1. static int spidev_probe(struct spi_device *spi)  
  2. {  
  3.     struct spidev_data  *spidev;  
  4.     int         status;  
  5.     unsigned long       minor;  
  6.   
  7.     /* Allocate driver data */  
  8.     spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);  
  9.     if (!spidev)  
  10.         return -ENOMEM;  
  11.   
  12.     /* Initialize the driver data */  
  13.     spidev->spi = spi;//设定spi  
  14.     spin_lock_init(&spidev->spi_lock);  
  15.     mutex_init(&spidev->buf_lock);  
  16.   
  17.     INIT_LIST_HEAD(&spidev->device_entry);  
  18.   
  19.     /* If we can allocate a minor number, hook up this device. 
  20.      * Reusing minors is fine so long as udev or mdev is working. 
  21.      */  
  22.     mutex_lock(&device_list_lock);  
  23.     minor = find_first_zero_bit(minors, N_SPI_MINORS);//寻找没被占用的次设备号  
  24.     if (minor < N_SPI_MINORS) {  
  25.         struct device *dev;  
  26.         /*计算设备号*/  
  27.         spidev->devt = MKDEV(SPIDEV_MAJOR, minor);  
  28.         /*在spidev_class下创建设备*/  
  29.         dev = device_create(spidev_class, &spi->dev, spidev->devt,  
  30.                     spidev, "spidev%d.%d",  
  31.                     spi->master->bus_num, spi->chip_select);  
  32.         status = IS_ERR(dev) ? PTR_ERR(dev) : 0;  
  33.     } else {  
  34.         dev_dbg(&spi->dev, "no minor number available!\n");  
  35.         status = -ENODEV;  
  36.     }  
  37.     if (status == 0) {  
  38.         set_bit(minor, minors);//将minors的相应位置位，表示该位对应的次设备号已被占用  
  39.         list_add(&spidev->device_entry, &device_list);//将创建的spidev添加到device_list  
  40.     }  
  41.     mutex_unlock(&device_list_lock);  
  42.   
  43.     if (status == 0)  
  44.         spi_set_drvdata(spi, spidev);  
  45.     else  
  46.         kfree(spidev);  
  47.   
  48.     return status;  
  49. }  


然后就可以利用spidev模块提供的接口来实现主从设备之间的数据传输了。我们以spidev_write()函数为例来分析数据传输的过程，实际上spidev_read()和其是差不多的，只是前面的一些步骤不一样，可以参照上图。

[cpp] view plaincopy
 
  1. static ssize_t  
  2. spidev_write(struct file *filp, const char __user *buf,  
  3.         size_t count, loff_t *f_pos)  
  4. {  
  5.     struct spidev_data  *spidev;  
  6.     ssize_t         status = 0;  
  7.     unsigned long       missing;  
  8.   
  9.     /* chipselect only toggles at start or end of operation */  
  10.     if (count > bufsiz)  
  11.         return -EMSGSIZE;  
  12.   
  13.     spidev = filp->private_data;  
  14.   
  15.     mutex_lock(&spidev->buf_lock);  
  16.     //将用户要发送的数据拷贝到spidev->buffer  
  17.     missing = copy_from_user(spidev->buffer, buf, count);  
  18.     if (missing == 0) {//全部拷贝成功，则调用spidev_sysn_write()  
  19.         status = spidev_sync_write(spidev, count);  
  20.     } else  
  21.         status = -EFAULT;  
  22.     mutex_unlock(&spidev->buf_lock);  
  23.   
  24.     return status;  
  25. }  


 

[cpp] view plaincopy
 
  1. static inline ssize_t  
  2. spidev_sync_write(struct spidev_data *spidev, size_t len)  
  3. {  
  4.     struct spi_transfer t = {//设置传输字段  
  5.             .tx_buf     = spidev->buffer,  
  6.             .len        = len,  
  7.         };  
  8.     struct spi_message   m;//创建message  
  9.   
  10.     spi_message_init(&m);  
  11.     spi_message_add_tail(&t, &m);//将transfer添加到message中  
  12.     return spidev_sync(spidev, &m);  
  13. }  


我们来看看struct spi_transfer和struct spi_message是如何定义的

[cpp] view plaincopy
 
  1. struct spi_transfer {  
  2.     /* it's ok if tx_buf == rx_buf (right?) 
  3.      * for MicroWire, one buffer must be null 
  4.      * buffers must work with dma_*map_single() calls, unless 
  5.      *   spi_message.is_dma_mapped reports a pre-existing mapping 
  6.      */  
  7.     const void  *tx_buf;//发送缓冲区  
  8.     void        *rx_buf;//接收缓冲区  
  9.     unsigned    len;    //传输数据的长度  
  10.   
  11.     dma_addr_t  tx_dma;  
  12.     dma_addr_t  rx_dma;  
  13.   
  14.     unsigned    cs_change:1; //该位如果为1，则表示当该transfer传输完后，改变片选信号  
  15.     u8      bits_per_word;//字比特数  
  16.     u16     delay_usecs;  //传输后的延时   
  17.     u32     speed_hz;  //指定的时钟  
  18.   
  19.     struct list_head transfer_list;//用于将该transfer链入message  
  20. };  


 

[cpp] view plaincopy
 
  1. struct spi_message {  
  2.     struct list_head    transfers;//用于链接spi_transfer  
  3.   
  4.     struct spi_device   *spi;      //指向目的从设备  
  5.   
  6.     unsigned        is_dma_mapped:1;  
  7.   
  8.     /* REVISIT:  we might want a flag affecting the behavior of the 
  9.      * last transfer ... allowing things like "read 16 bit length L" 
  10.      * immediately followed by "read L bytes".  Basically imposing 
  11.      * a specific message scheduling algorithm. 
  12.      * 
  13.      * Some controller drivers (message-at-a-time queue processing) 
  14.      * could provide that as their default scheduling algorithm.  But 
  15.      * others (with multi-message pipelines) could need a flag to 
  16.      * tell them about such special cases. 
  17.      */  
  18.   
  19.     /* completion is reported through a callback */  
  20.     void            (*complete)(void *context);//用于异步传输完成时调用的回调函数  
  21.     void            *context;                  //回调函数的参数  
  22.     unsigned        actual_length;            //实际传输的长度  
  23.     int         status;  
  24.   
  25.     /* for optional use by whatever driver currently owns the 
  26.      * spi_message ...  between calls to spi_async and then later 
  27.      * complete(), that's the spi_master controller driver. 
  28.      */  
  29.     struct list_head    queue; //用于将该message链入bitbang等待队列  
  30.     void            *state;  
  31. };  


继续跟踪源码，进入spidev_sync(),从这一步开始，read和write就完全一样了

[cpp] view plaincopy
 
  1. <span style="font-size:12px;">static ssize_t  
  2. spidev_sync(struct spidev_data *spidev, struct spi_message *message)  
  3. {  
  4.     DECLARE_COMPLETION_ONSTACK(done);  
  5.     int status;  
  6.   
  7.     message->complete = spidev_complete;//设置回调函数  
  8.     message->context = &done;              
  9.   
  10.     spin_lock_irq(&spidev->spi_lock);  
  11.     if (spidev->spi == NULL)  
  12.         status = -ESHUTDOWN;  
  13.     else  
  14.         status = spi_async(spidev->spi, message);//调用spi核心层的函数spi_async()  
  15.     spin_unlock_irq(&spidev->spi_lock);  
  16.   
  17.     if (status == 0) {  
  18.         wait_for_completion(&done);  
  19.         status = message->status;  
  20.         if (status == 0)  
  21.             status = message->actual_length;  
  22.     }  
  23.     return status;  
  24. }</span>  


 

[cpp] view plaincopy
 
  1. static inline int  
  2. spi_async(struct spi_device *spi, struct spi_message *message)  
  3. {  
  4.     message->spi = spi;  
  5.     /*调用master的transfer函数将message放入等待队列*/  
  6.     return spi->master->transfer(spi, message);  
  7. }  

 

 

s3c24xx平台下的transfer函数是在bitbang_start()函数中定义的，为bitbang_transfer()

[cpp] view plaincopy
 
  1. 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.   
  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.         list_add_tail(&m->queue, &bitbang->queue);//将message添加到bitbang的等待队列  
  17.         queue_work(bitbang->workqueue, &bitbang->work);//调度运行work  
  18.     }  
  19.     spin_unlock_irqrestore(&bitbang->lock, flags);  
  20.   
  21.     return status;  
  22. }  

这里可以看到transfer函数不负责实际的数据传输，而是将message添加到等待队列中。同样在spi_bitbang_start()中，有这样一个定义INIT_WORK(&bitbang->work, bitbang_work);因此bitbang_work()函数会被调度运行，类似于底半部机制

[cpp] view plaincopy
 
  1. static void bitbang_work(struct work_struct *work)  
  2. {  
  3.     struct spi_bitbang  *bitbang =  
  4.         container_of(work, struct spi_bitbang, work);//获取bitbang  
  5.     unsigned long       flags;  
  6.   
  7.     spin_lock_irqsave(&bitbang->lock, flags);  
  8.     bitbang->busy = 1;  
  9.     while (!list_empty(&bitbang->queue)) {//等待队列不为空  
  10.         struct spi_message  *m;  
  11.         struct spi_device   *spi;  
  12.         unsigned        nsecs;  
  13.         struct spi_transfer *t = NULL;  
  14.         unsigned        tmp;  
  15.         unsigned        cs_change;  
  16.         int         status;  
  17.         int         (*setup_transfer)(struct spi_device *,  
  18.                         struct spi_transfer *);  
  19.         /*取出等待队列中的的第一个message*/  
  20.         m = container_of(bitbang->queue.next, struct spi_message,  
  21.                 queue);  
  22.         list_del_init(&m->queue);//将message从队列中删除  
  23.         spin_unlock_irqrestore(&bitbang->lock, flags);  
  24.   
  25.         /* FIXME this is made-up ... the correct value is known to 
  26.          * word-at-a-time bitbang code, and presumably chipselect() 
  27.          * should enforce these requirements too? 
  28.          */  
  29.         nsecs = 100;  
  30.   
  31.         spi = m->spi;  
  32.         tmp = 0;  
  33.         cs_change = 1;  
  34.         status = 0;  
  35.         setup_transfer = NULL;  
  36.   
  37.         /*遍历message中的所有传输字段,逐一进行传输*/  
  38.         list_for_each_entry (t, &m->transfers, transfer_list) {  
  39.   
  40.             /* override or restore speed and wordsize */  
  41.             if (t->speed_hz || t->bits_per_word) {  
  42.                 setup_transfer = bitbang->setup_transfer;  
  43.                 if (!setup_transfer) {  
  44.                     status = -ENOPROTOOPT;  
  45.                     break;  
  46.                 }  
  47.             }  
  48.             /*调用setup_transfer根据transfer中的信息进行时钟、字比特数的设定*/  
  49.             if (setup_transfer) {  
  50.                 status = setup_transfer(spi, t);  
  51.                 if (status < 0)  
  52.                     break;  
  53.             }  
  54.   
  55.             /* set up default clock polarity, and activate chip; 
  56.              * this implicitly updates clock and spi modes as 
  57.              * previously recorded for this device via setup(). 
  58.              * (and also deselects any other chip that might be 
  59.              * selected ...) 
  60.              */  
  61.             if (cs_change) {//使能外设的片选  
  62.                 bitbang->chipselect(spi, BITBANG_CS_ACTIVE);  
  63.                 ndelay(nsecs);  
  64.             }  
  65.             cs_change = t->cs_change;//这里确定进行了这个字段的传输后是否要改变片选状态  
  66.             if (!t->tx_buf && !t->rx_buf && t->len) {  
  67.                 status = -EINVAL;  
  68.                 break;  
  69.             }  
  70.   
  71.             /* transfer data.  the lower level code handles any 
  72.              * new dma mappings it needs. our caller always gave 
  73.              * us dma-safe buffers. 
  74.              */  
  75.             if (t->len) {  
  76.                 /* REVISIT dma API still needs a designated 
  77.                  * DMA_ADDR_INVALID; ~0 might be better. 
  78.                  */  
  79.                 if (!m->is_dma_mapped)  
  80.                     t->rx_dma = t->tx_dma = 0;  
  81.                 /*调用针对于平台的传输函数txrx_bufs*/  
  82.                 status = bitbang->txrx_bufs(spi, t);  
  83.             }  
  84.             if (status > 0)  
  85.                 m->actual_length += status;  
  86.             if (status != t->len) {  
  87.                 /* always report some kind of error */  
  88.                 if (status >= 0)  
  89.                     status = -EREMOTEIO;  
  90.                 break;  
  91.             }  
  92.             status = 0;  
  93.   
  94.             /* protocol tweaks before next transfer */  
  95.             /*如果要求在传输完一个字段后进行delay,则进行delay*/  
  96.             if (t->delay_usecs)  
  97.                 udelay(t->delay_usecs);  
  98.   
  99.             if (!cs_change)  
  100.                 continue;  
  101.               
  102.             /*最后一个字段传输完毕了，则跳出循环*/  
  103.             if (t->transfer_list.next == &m->transfers)  
  104.                 break;  
  105.   
  106.             /* sometimes a short mid-message deselect of the chip 
  107.              * may be needed to terminate a mode or command 
  108.              */  
  109.             ndelay(nsecs);  
  110.             bitbang->chipselect(spi, BITBANG_CS_INACTIVE);  
  111.             ndelay(nsecs);  
  112.         }  
  113.   
  114.         m->status = status;  
  115.         m->complete(m->context);  
  116.   
  117.         /* restore speed and wordsize */  
  118.         if (setup_transfer)  
  119.             setup_transfer(spi, NULL);  
  120.   
  121.         /* normally deactivate chipselect ... unless no error and 
  122.          * cs_change has hinted that the next message will probably 
  123.          * be for this chip too. 
  124.          */  
  125.         if (!(status == 0 && cs_change)) {  
  126.             ndelay(nsecs);  
  127.             bitbang->chipselect(spi, BITBANG_CS_INACTIVE);  
  128.             ndelay(nsecs);  
  129.         }  
  130.   
  131.         spin_lock_irqsave(&bitbang->lock, flags);  
  132.     }  
  133.     bitbang->busy = 0;  
  134.     spin_unlock_irqrestore(&bitbang->lock, flags);  
  135. }  


只要bitbang->queue等待队列不为空，就表示相应的SPI主控制器上还有传输任务没有完成，因此bitbang_work()会被不断地调度执行。 bitbang_work()中的工作主要是两个循环，外循环遍历等待队列中的message,内循环遍历message中的transfer,在bitbang_work()中，传输总是以transfer为单位的。当选定了一个transfer后，便会调用transfer_txrx()函数，进行实际的数据传输，显然这个函数是针对于平台的SPI控制器而实现的，在s3c24xx平台中，该函数为s3c24xx_spi_txrx();

[cpp] view plaincopy
 
  1. 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;  
  12.   
  13.     init_completion(&hw->done);//初始化完成量  
  14.   
  15.     /* send the first byte */  
  16.     /*只发送第一个字节，其他的在中断中发送(读取)*/  
  17.     writeb(hw_txbyte(hw, 0), hw->regs + S3C2410_SPTDAT);  
  18.   
  19.     wait_for_completion(&hw->done);  
  20.   
  21.     return hw->count;  
  22. }  


 

[cpp] view plaincopy
 
  1. static inline unsigned int hw_txbyte(struct s3c24xx_spi *hw, int count)  
  2. {  
  3.     /*如果tx不为空，也就是说当前是从主机向从机发送数据，则直接将tx[count]发送过去， 
  4.       如果tx为空，也就是说当前是从从机向主机发送数据，则向从机写入0*/  
  5.     return hw->tx ? hw->tx[count] : 0;  
  6. }  


负责SPI数据传输的中断函数：

[cpp] view plaincopy
 
  1. static irqreturn_t s3c24xx_spi_irq(int irq, void *dev)  
  2. {  
  3.     struct s3c24xx_spi *hw = dev;  
  4.     unsigned int spsta = readb(hw->regs + S3C2410_SPSTA);  
  5.     unsigned int count = hw->count;  
  6.   
  7.     /*冲突检测*/  
  8.     if (spsta & S3C2410_SPSTA_DCOL) {  
  9.         dev_dbg(hw->dev, "data-collision\n");  
  10.         complete(&hw->done);  
  11.         goto irq_done;  
  12.     }  
  13.   
  14.     /*设备忙检测*/  
  15.     if (!(spsta & S3C2410_SPSTA_READY)) {  
  16.         dev_dbg(hw->dev, "spi not ready for tx?\n");  
  17.         complete(&hw->done);  
  18.         goto irq_done;  
  19.     }  
  20.   
  21.     hw->count++;  
  22.   
  23.     if (hw->rx)//读取数据到缓冲区  
  24.         hw->rx[count] = readb(hw->regs + S3C2410_SPRDAT);  
  25.   
  26.     count++;  
  27.   
  28.     if (count < hw->len)//向从机写入数据  
  29.         writeb(hw_txbyte(hw, count), hw->regs + S3C2410_SPTDAT);  
  30.     else//count == len，一个字段发送完成，唤醒完成量  
  31.         complete(&hw->done);  
  32.   
  33.  irq_done:  
  34.     return IRQ_HANDLED;  
  35. }  

这里可以看到一点，即使tx为空，也就是说用户申请的是从从设备读取数据，也要不断地向从设备写入数据，只不过写入从设备的是无效数据(0)，这样做得目的是为了维持SPI总线上的时钟。至此，SPI框架已分析完毕。

posted @ 2014-04-13 16:48  欢乐小飞  阅读(642)  评论(0)  编辑  收藏  举报