781行之前没什么好说的，直接看783行，将work投入到工作队列里，然后就返回，在这里就可以回答之前为什么是异步的问题。以后在某个合适的时间里CPU会执行这个work指定的函数，这里是s3c64xx_spi_work函数，看它的定义：

 static void s3c64xx_spi_work(struct work_struct *work)

 {

     struct s3c64xx_spi_driver_data *sdd = container_of(work,

                     struct s3c64xx_spi_driver_data, work);

     unsigned long flags;

     /* Acquire DMA channels */

     while (!acquire_dma(sdd))

         msleep();

     spin_lock_irqsave(&sdd->lock, flags);

     while (!list_empty(&sdd->queue)

                 && !(sdd->state & SUSPND)) {

         struct spi_message *msg;

         msg = container_of(sdd->queue.next, struct spi_message, queue);

         list_del_init(&msg->queue);

         /* Set Xfer busy flag */

         sdd->state |= SPIBUSY;

         spin_unlock_irqrestore(&sdd->lock, flags);

         handle_msg(sdd, msg);

         spin_lock_irqsave(&sdd->lock, flags);

         sdd->state &= ~SPIBUSY;

     }

     spin_unlock_irqrestore(&sdd->lock, flags);

     /* Free DMA channels */

     s3c2410_dma_free(sdd->tx_dmach, &s3c64xx_spi_dma_client);

     s3c2410_dma_free(sdd->rx_dmach, &s3c64xx_spi_dma_client);

 }

730行，申请DMA，关于DMA的就不说，一是我对DMA没什么了解，二是这里基本上用不到，后面就知道什么时候才会用到DMA。

735至754行，循环取出队列里的message并调用749行的handle_msg函数进行处理，handle_msg函数的定义如下：

 static void handle_msg(struct s3c64xx_spi_driver_data *sdd,

                     struct spi_message *msg)

 {

     struct s3c64xx_spi_info *sci = sdd->cntrlr_info;

     struct spi_device *spi = msg->spi;

     struct s3c64xx_spi_csinfo *cs = spi->controller_data;

     struct spi_transfer *xfer;

     int status = , cs_toggle = ;

     u32 speed;

     u8 bpw;

     /* If Master's(controller) state differs from that needed by Slave */

     if (sdd->cur_speed != spi->max_speed_hz

             || sdd->cur_mode != spi->mode

             || sdd->cur_bpw != spi->bits_per_word) {

         sdd->cur_bpw = spi->bits_per_word;

         sdd->cur_speed = spi->max_speed_hz;

         sdd->cur_mode = spi->mode;

         s3c64xx_spi_config(sdd);

     }

     /* Map all the transfers if needed */

     if (s3c64xx_spi_map_mssg(sdd, msg)) {

         dev_err(&spi->dev,

             "Xfer: Unable to map message buffers!\n");

         status = -ENOMEM;

         goto out;

     }

     /* Configure feedback delay */

     writel(cs->fb_delay & 0x3, sdd->regs + S3C64XX_SPI_FB_CLK);

     list_for_each_entry(xfer, &msg->transfers, transfer_list) {

         unsigned long flags;

         int use_dma;

         INIT_COMPLETION(sdd->xfer_completion);

         /* Only BPW and Speed may change across transfers */

         bpw = xfer->bits_per_word ? : spi->bits_per_word;

         speed = xfer->speed_hz ? : spi->max_speed_hz;

         if (bpw != sdd->cur_bpw || speed != sdd->cur_speed) {

             sdd->cur_bpw = bpw;

             sdd->cur_speed = speed;

             s3c64xx_spi_config(sdd);

         }

         /* Polling method for xfers not bigger than FIFO capacity */

         if (xfer->len <= ((sci->fifo_lvl_mask >> ) + ))

             use_dma = ;

         else

             use_dma = ;

         spin_lock_irqsave(&sdd->lock, flags);

         /* Pending only which is to be done */

         sdd->state &= ~RXBUSY;

         sdd->state &= ~TXBUSY;

         enable_datapath(sdd, spi, xfer, use_dma);

         /* Slave Select */

         enable_cs(sdd, spi);

         /* Start the signals */

         S3C64XX_SPI_ACT(sdd);

         spin_unlock_irqrestore(&sdd->lock, flags);

         status = wait_for_xfer(sdd, xfer, use_dma);

         /* Quiese the signals */

         S3C64XX_SPI_DEACT(sdd);

         if (status) {

             dev_err(&spi->dev, "I/O Error: "

                 "rx-%d tx-%d res:rx-%c tx-%c len-%d\n",

                 xfer->rx_buf ?  : , xfer->tx_buf ?  : ,

                 (sdd->state & RXBUSY) ? 'f' : 'p',

                 (sdd->state & TXBUSY) ? 'f' : 'p',

                 xfer->len);

             if (use_dma) {

                 if (xfer->tx_buf != NULL

                         && (sdd->state & TXBUSY))

                     s3c2410_dma_ctrl(sdd->tx_dmach,

                             S3C2410_DMAOP_FLUSH);

                 if (xfer->rx_buf != NULL

                         && (sdd->state & RXBUSY))

                     s3c2410_dma_ctrl(sdd->rx_dmach,

                             S3C2410_DMAOP_FLUSH);

             }

             goto out;

         }

         if (xfer->delay_usecs)

             udelay(xfer->delay_usecs);

         if (xfer->cs_change) {

             /* Hint that the next mssg is gonna be

00000672                for the same device */

             if (list_is_last(&xfer->transfer_list,

                         &msg->transfers))

                 cs_toggle = ;

             else

                 disable_cs(sdd, spi);

         }

         msg->actual_length += xfer->len;

         flush_fifo(sdd);

     }

 out:

     if (!cs_toggle || status)

         disable_cs(sdd, spi);

     else

         sdd->tgl_spi = spi;

     s3c64xx_spi_unmap_mssg(sdd, msg);

     msg->status = status;

     if (msg->complete)

         msg->complete(msg->context);

 }

函数很长，580至587行，如果一路走来speed、bpw和mode的值与spi设备的不一致就调用s3c64xx_spi_config函数重新配置，s3c64xx_spi_config函数里面就是对SPI寄存器进行设置的。

590至595行，关于DMA映射的，略过。

598行，设置feedback寄存器。

600行，遍历每一个transfer。605行，又初始化一个完成量，注意这里与之前的那个完成量是不一样的，这里的完成量只有使用DMA传输时才会用得到，接下来很快就可以看到。

608至615行，也是一些关于设置值的检查。

619至622行，只有发送或者接收的数据长度大于fifo的深度（这里是64个字节）设置use_dma为1，也即使用DMA进行传输，否则不使用DMA。

630行，enable_datapath函数的定义为：

 static void enable_datapath(struct s3c64xx_spi_driver_data *sdd,

                 struct spi_device *spi,

                 struct spi_transfer *xfer, int dma_mode)

 {

     struct s3c64xx_spi_info *sci = sdd->cntrlr_info;

     void __iomem *regs = sdd->regs;

     u32 modecfg, chcfg;

     modecfg = readl(regs + S3C64XX_SPI_MODE_CFG);

     modecfg&=~(S3C64XX_SPI_MODE_TXDMA_ON|S3C64XX_SPI_MODE_RXDMA_ON);

     chcfg = readl(regs + S3C64XX_SPI_CH_CFG);

     chcfg &= ~S3C64XX_SPI_CH_TXCH_ON;

     if (dma_mode) {

         chcfg &= ~S3C64XX_SPI_CH_RXCH_ON;

     } else {

         /* Always shift in data in FIFO, even if xfer is Tx only,

00000250          * this helps setting PCKT_CNT value for generating clocks

00000251          * as exactly needed.

00000252          */

         chcfg |= S3C64XX_SPI_CH_RXCH_ON;

         writel(((xfer->len *  / sdd->cur_bpw) & 0xffff)

                     | S3C64XX_SPI_PACKET_CNT_EN,

                     regs + S3C64XX_SPI_PACKET_CNT);

     }

     if (xfer->tx_buf != NULL) {

         sdd->state |= TXBUSY;

         chcfg |= S3C64XX_SPI_CH_TXCH_ON;

         if (dma_mode) {

             modecfg |= S3C64XX_SPI_MODE_TXDMA_ON;

             s3c2410_dma_config(sdd->tx_dmach, );

             s3c2410_dma_enqueue(sdd->tx_dmach, (void *)sdd,

                         xfer->tx_dma, xfer->len);

             s3c2410_dma_ctrl(sdd->tx_dmach, S3C2410_DMAOP_START);

         } else {

             unsigned char *buf = (unsigned char *) xfer->tx_buf;

             int i = ;

             while (i < xfer->len)

                 writeb(buf[i++], regs + S3C64XX_SPI_TX_DATA);

         }

     }

     if (xfer->rx_buf != NULL) {

         sdd->state |= RXBUSY;

         if (sci->high_speed && sdd->cur_speed >= 30000000UL

                     && !(sdd->cur_mode & SPI_CPHA))

             chcfg |= S3C64XX_SPI_CH_HS_EN;

         if (dma_mode) {

             modecfg |= S3C64XX_SPI_MODE_RXDMA_ON;

             chcfg |= S3C64XX_SPI_CH_RXCH_ON;

             writel(((xfer->len *  / sdd->cur_bpw) & 0xffff)

                     | S3C64XX_SPI_PACKET_CNT_EN,

                     regs + S3C64XX_SPI_PACKET_CNT);

             s3c2410_dma_config(sdd->rx_dmach, );

             s3c2410_dma_enqueue(sdd->rx_dmach, (void *)sdd,

                         xfer->rx_dma, xfer->len);

             s3c2410_dma_ctrl(sdd->rx_dmach, S3C2410_DMAOP_START);

         }

     }

     writel(modecfg, regs + S3C64XX_SPI_MODE_CFG);

     writel(chcfg, regs + S3C64XX_SPI_CH_CFG);

 }

240至244行，读取模式配置和通道配置寄存器。

246至257行，根据是否采用DMA模式设置接收计数寄存器。

259行，很早就为tx_buf分配内存，因此条件成立。因为不考虑DMA模式，因此略过262至268行。

269至272行，循环将发送数据写入到发送寄存器。

276至294行，由于rx_buf为NULL，因此直接略过277至294行。

296、297行，将之前的值写入到寄存器中。

回到handle_msg函数，633行，选中从设备。636行，设置寄存器，开始数据传输。

640行，wait_for_xfer函数的定义：

 static int wait_for_xfer(struct s3c64xx_spi_driver_data *sdd,

                 struct spi_transfer *xfer, int dma_mode)

 {

     struct s3c64xx_spi_info *sci = sdd->cntrlr_info;

     void __iomem *regs = sdd->regs;

     unsigned long val;

     int ms;

     /* millisecs to xfer 'len' bytes @ 'cur_speed' */

     ms = xfer->len *  *  / sdd->cur_speed;

     ms += ; /* some tolerance */

     if (dma_mode) {

         val = msecs_to_jiffies(ms) + ;

         val = wait_for_completion_timeout(&sdd->xfer_completion, val);

     } else {

         u32 status;

         val = msecs_to_loops(ms);

         do {

             status = readl(regs + S3C64XX_SPI_STATUS);

         } while (RX_FIFO_LVL(status, sci) < xfer->len && --val);

     }

     if (!val)

         return -EIO;

     if (dma_mode) {

         u32 status;

         /*

00000349          * DmaTx returns after simply writing data in the FIFO,

00000350          * w/o waiting for real transmission on the bus to finish.

00000351          * DmaRx returns only after Dma read data from FIFO which

00000352          * needs bus transmission to finish, so we don't worry if

00000353          * Xfer involved Rx(with or without Tx).

00000354          */

         if (xfer->rx_buf == NULL) {

             val = msecs_to_loops();

             status = readl(regs + S3C64XX_SPI_STATUS);

             while ((TX_FIFO_LVL(status, sci)

                 || !S3C64XX_SPI_ST_TX_DONE(status, sci))

                     && --val) {

                 cpu_relax();

                 status = readl(regs + S3C64XX_SPI_STATUS);

             }

             if (!val)

                 return -EIO;

         }

     } else {

         unsigned char *buf;

         int i;

         /* If it was only Tx */

         if (xfer->rx_buf == NULL) {

             sdd->state &= ~TXBUSY;

             return ;

         }

         i = ;

         buf = xfer->rx_buf;

         while (i < xfer->len)

             buf[i++] = readb(regs + S3C64XX_SPI_RX_DATA);

         sdd->state &= ~RXBUSY;

     }

     return ;

 }

328行，根据发送速率计算需要等待的时间。331至334行，与DMA相关的，略过。

335至339行，不断地读状态寄存器，如果接收到的数据长度等于发送数据的长度或超时则退出循环。

342、343行，如果是超时退出循环的，则返回出错。

345至368行，DMA相关的，略过。

369至383行，如果只是发送数据，则直接返回0。否则从接收寄存器里将接收到的数据读出来。

回到handle_msg函数，643行，停止传输。645至665行，如果之前wait_for_xfer函数返回大于0的值，则表示出错，这里就打印一些信息。

667、668行，之前如果有设置延时的话这里就延时。

670至678行，是否需要每个transfer完成都改变片选信号。

680行，累加所有transfer成功发送的数据。

682行，清发送和接收寄存器。

691行，取消DMA映射。

693行，记录状态信息。

695、696行，唤醒之前等待的完成量。

到这里，已经说了整个write过程，不容易啊！。其他的read/ioctl过程是大同小异的。

总结

spidev.c是一个通用的SPI驱动，因此它不处理任何有关具体驱动的逻辑，这就需要在用户空间来完成具体的逻辑。其实这符合了Android驱动的思想，这也是Android HAL层存在的目的：内核驱动只完成硬件操作，具体逻辑放在HAL层，这样就有利于保护厂家、开发者的知识产权。

在用户空间使用ioctl就可以完成write、read操作。

最新文章

  1. Cocos2d-x 3.2 学习笔记（十五）保卫萝卜 场景与数据
  2. 献给广大it从业人士:早睡早起,晚睡也早起
  3. 解决VMware下安装Ubuntu15不支持1920X1080分辨率的问题
  4. 算法教程（2）zz
  5. [saiku] 连接 mondrain 数据源出错-空指针错误
  6. How Tomcat Works（十四）补充
  7. VirtualBox从USB设备(PE)启动
  8. IOS百度地图语音导航
  9. C#设置窗体最大化且不遮挡任务栏的方法
  10. phpStorm 2016.1.2 最新版激活方法【亲测可用】
  11. css3特效
  12. studio grandle渠道打包
  13. linux学习之路(3)
  14. oldboy s21day15模块装饰器及其他应用
  15. BZOJ2649 : riddle
  16. 随机模拟（MCMC）
  17. python-基础-文件
  18. async await 的 实质 本质
  19. InnoDB的锁机制浅析(五)—死锁场景(Insert死锁)
  20. 自适应巡航控制系统——ACC

热门文章

  1. Python——Requests库的开发者接口
  2. 查看eclipse版本信息
  3. VS 调试 无法启动IIS Express Web 服务器（进程不存在）
  4. JSON数组，JSON对象，数组的区别与基本操作整理
  5. Xcode : svn 无法上传静态库（.a）文件
  6. js 原型链（转）
  7. SQL随机生成6位数字
  8. VC获得本机网络连接状态
  9. Lua获取系统时间和时间格式化方法及格式化参数
  10. 比SRCNN效果好的传统超分辨率算法汇总