logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

spi驱动框架分板(上)

 zhouxitaa 2012-04-17
嵌入式微处理器访问SPI设备有两种方式：使用GPIO模拟SPI接口的工作时序或者使用SPI控制器。使用GPIO模拟SPI接口的工作时序是非常容易实现的，但是会导致大量的时间耗费在模拟SPI接口的时序上，访问效率比较低，容易成为系统瓶颈。这里主要分析使用SPI控制器的情况。

这个是由sys文件系统导出的spi子系统在内核中的视图了。
首先了解一下Linux内核中的几个文件:spi.c也就是spi子系统的核心了，spi_s3c24xx.c是s3c24xx系列芯片的SPI controller驱动，它向更上层的SPI核心层(spi.c)提供接口用来控制芯片的SPI controller，是一个被其他驱动使用的驱动。而spidev.c是在核心层基础之上将SPI controller模拟成一个字符型的驱动，向文件系统提供标准的文件系统接口，用来操作对应的SPI controller。
下面我们来看看spi子系统是怎么注册进内核的：

[cpp] view plaincopyprint?
  1. static int __init spi_init(void)
  2. {
  3. int status;
  4. buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
  5. if (!buf) {
  6. status = -ENOMEM;
  7. goto err0;
  8. }
  9. status = bus_register(&spi_bus_type);
  10. if (status < 0)
  11. goto err1;
  12. status = class_register(&spi_master_class);
  13. if (status < 0)
  14. goto err2;
  15. return 0;
  16. err2:
  17. bus_unregister(&spi_bus_type);
  18. err1:
  19. kfree(buf);
  20. buf = NULL;
  21. err0:
  22. return status;
  23. }
  24. postcore_initcall(spi_init);
这里注册了一个spi_bus_type，也就是一个spi总线，和一个spi_master的class。分别对应上图中sys/bus/下的spi目录和sys/class/下的spi_master目录。

下面来分析SPI controller驱动的注册与初始化过程，首先执行的是s3c24xx_spi_init。

[cpp] view plaincopyprint?
  1. static int __init s3c24xx_spi_init(void)
  2. {
  3. return platform_driver_probe(&s3c24xx_spi_driver, s3c24xx_spi_probe);
  4. }
platform_driver_probe中完成了s3c24xx_spi_driver这个平台驱动的注册，相应的平台设备在devs.c中定义，在smdk2440_devices中添加&s3c_device_spi0，&s3c_device_spi1，这就生成了图中所示的s3c24xx-spi.0与s3c24xx-spi.1，当然了这图是在网上找的，不是我画的，所以是6410的。这里s3c24xx-spi.0表示s3c2440的spi controller的0号接口，s3c24xx-spi.1表示s3c2440的spi controller的1号接口。注册了s3c24xx_spi_driver后，赋值了平台驱动的probe函数为s3c24xx_spi_probe。所以当match成功后，调用s3c24xx_spi_probe，这里看其实现：

[html] view plaincopyprint?
  1. static int __init s3c24xx_spi_probe(struct platform_device *pdev)
  2. {
  3. struct s3c2410_spi_info *pdata;
  4. struct s3c24xx_spi *hw;
  5. struct spi_master *master;
  6. struct resource *res;
  7. int err = 0;
  8. /*分配struct spi_master+struct s3c24xx_spi大小的数据，把s3c24xx_spi设为spi_master的私有数据*/
  9. master = spi_alloc_master(&pdev->dev, sizeof(struct s3c24xx_spi));
  10. if (master == NULL) {
  11. dev_err(&pdev->dev, "No memory for spi_master\n");
  12. err = -ENOMEM;
  13. goto err_nomem;
  14. }
  15. /*从master中获得s3c24xx_spi*/
  16. hw = spi_master_get_devdata(master);
  17. memset(hw, 0, sizeof(struct s3c24xx_spi));
  20. hw->master = spi_master_get(master);
  21. /*驱动移植的时候需要实现的重要结构，初始化为&s3c2410_spi0_platdata*/
  22. hw->pdata = pdata = pdev->dev.platform_data;
  23. hw->dev = &pdev->dev;
  26. if (pdata == NULL) {
  27. dev_err(&pdev->dev, "No platform data supplied\n");
  28. err = -ENOENT;
  29. goto err_no_pdata;
  30. }
  31. /*设置平台的私有数据为s3c24xx_spi*/
  32. platform_set_drvdata(pdev, hw);
  33. init_completion(&hw->done);
  36. /* setup the master state. */
  37. /*该总线上的设备数*/
  38. master->num_chipselect = hw->pdata->num_cs;
  39. /*总线号*/
  40. master->bus_num = pdata->bus_num;
  43. /* setup the state for the bitbang driver */
  44. /*spi_bitbang专门负责数据的传输*/
  45. hw->bitbang.master = hw->master;
  46. hw->bitbang.setup_transfer = s3c24xx_spi_setupxfer;
  47. hw->bitbang.chipselect = s3c24xx_spi_chipsel;
  48. hw->bitbang.txrx_bufs = s3c24xx_spi_txrx;
  49. hw->bitbang.master->setup = s3c24xx_spi_setup;
  52. dev_dbg(hw->dev, "bitbang at %p\n", &hw->bitbang);
  54. 。。。。。。。。。。。。。。。。。。。。。。。。
  56. /*初始化设置寄存器，包括对SPIMOSI,SPIMISO,SPICLK引脚的设置*/
  57. s3c24xx_spi_initialsetup(hw);
  60. /* register our spi controller */
  63. err = spi_bitbang_start(&hw->bitbang);
  64. 。。。。。。。。。。。。。。。。。。。。。
  65. }
spi controller的register在spi_bitbang_start函数中实现：
[html] view plaincopyprint?
  1. int spi_bitbang_start(struct spi_bitbang *bitbang)
  2. {
  3. int status;
  6. if (!bitbang->master || !bitbang->chipselect)
  7. return -EINVAL;
  8. /*动态创建一个work_struct结构，它的处理函数是bitbang_work*/
  9. INIT_WORK(&bitbang->work, bitbang_work);
  10. spin_lock_init(&bitbang->lock);
  11. INIT_LIST_HEAD(&bitbang->queue);
  12. /*spi的数据传输就是用这个方法*/
  13. if (!bitbang->master->transfer)
  14. bitbang->master->transfer = spi_bitbang_transfer;
  15. if (!bitbang->txrx_bufs) {
  16. bitbang->use_dma = 0;
  17. /*spi_s3c24xx.c中有spi_bitbang_bufs方法，在bitbang_work中被调用*/
  18. bitbang->txrx_bufs = spi_bitbang_bufs;
  19. if (!bitbang->master->setup) {
  20. if (!bitbang->setup_transfer)
  21. bitbang->setup_transfer =
  22. spi_bitbang_setup_transfer;
  23. /*在spi_s3c24xx.c中有setup的处理方法，在spi_new_device中被调用*/
  24. bitbang->master->setup = spi_bitbang_setup;
  25. bitbang->master->cleanup = spi_bitbang_cleanup;
  26. }
  27. } else if (!bitbang->master->setup)
  28. return -EINVAL;
  31. /* this task is the only thing to touch the SPI bits */
  32. bitbang->busy = 0;
  33. /调用create_singlethread_workqueue创建单个工作线程/
  34. bitbang->workqueue = create_singlethread_workqueue(
  35. dev_name(bitbang->master->dev.parent));
  36. if (bitbang->workqueue == NULL) {
  37. status = -EBUSY;
  38. goto err1;
  39. }
  40. status = spi_register_master(bitbang->master);
  41. if (status < 0)
  42. goto err2;
  43. return status;
  44. err2:
  45. destroy_workqueue(bitbang->workqueue);
  46. err1:
  47. return status;
  48. }

然后看这里是怎样注册spi主机控制器驱动的:

[cpp] view plaincopyprint?
  1. int spi_register_master(struct spi_master *master)
  2. {
  3. 。。。。。。。。。。。。。。。。
  4. /*将spi添加到内核，这也是sys/class/Spi_master下产生Spi0，Spi1的原因*/
  5. dev_set_name(&master->dev, "spi%u", master->bus_num);
  6. status = device_add(&master->dev);
  7. scan_boardinfo(master);
  8. }

这里跟踪scan_boardinfo函数：

[cpp] view plaincopyprint?
  1. static void scan_boardinfo(struct spi_master *master)
  2. {
  3. struct boardinfo *bi;
  4. mutex_lock(&board_lock);
  5. /*遍历所有挂在board_list上的struct boardinfo*/
  6. list_for_each_entry(bi, &board_list, list) {
  7. struct spi_board_info *chip = bi->board_info;
  8. unsigned n;
  9. /*遍历每个boardinfo管理的spi_board_info，如果设备的总线号与控制器的总线好相等，则创建新设备*/
  10. for (n = bi->n_board_info; n > 0; n--, chip++) {
  11. if (chip->bus_num != master->bus_num)
  12. continue;
  13. (void) spi_new_device(master, chip);
  14. }
  15. }
  16. mutex_unlock(&board_lock);
  17. }
在移植的时候我们会在mach-smdk2440.c中的smdk2440_machine_init中添加spi_register_board_info

这个函数完成了将spi_board_info交由boardinfo管理，并把boardinfo挂载到board_list链表上。也就是说在系统初始化的时候将spi_device交由到挂在board_list上的boardinfo管理，在spi controller的driver注册的时候不但注册这个主机控制器的驱动，还要遍历这个主机控制器的总线上的spi_device，将总线上的spi_device全部注册进内核。当注册进内核并且spi_driver已经注册的时候，如果总线match成功，则会调用spi_driver的probe函数，这个将在后边进行分析。

[html] view plaincopyprint?
  1. int __init
  2. spi_register_board_info(struct spi_board_info const *info, unsigned n)
  3. {
  4. struct boardinfo *bi;
  7. bi = kmalloc(sizeof(*bi) + n * sizeof *info, GFP_KERNEL);
  8. if (!bi)
  9. return -ENOMEM;
  10. bi->n_board_info = n;
  11. memcpy(bi->board_info, info, n * sizeof *info);
  14. mutex_lock(&board_lock);
  15. list_add_tail(&bi->list, &board_list);
  16. mutex_unlock(&board_lock);
  17. return 0;
  18. }

看一下创建新设备的函数：

[html] view plaincopyprint?
  1. struct spi_device *spi_new_device(struct spi_master *master,
  2. struct spi_board_info *chip)
  3. {
  4. struct spi_device *proxy;
  5. int status;
  6. proxy = spi_alloc_device(master);
  7. if (!proxy)
  8. return NULL;
  11. WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
  12. /*初始化spi_device的各个字段*/
  13. proxy->chip_select = chip->chip_select;
  14. proxy->max_speed_hz = chip->max_speed_hz;
  15. proxy->mode = chip->mode;
  16. proxy->irq = chip->irq;
  17. /*这里获得了spi_device的名字，这个modalias也是在我们移植时在mach-smdk2440.c中的s3c2410_spi0_board中设定的*/
  18. strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));
  19. proxy->dev.platform_data = (void *) chip->platform_data;
  20. proxy->controller_data = chip->controller_data;
  21. proxy->controller_state = NULL;
  22. /*主要完成将spi_device添加到内核*/
  23. status = spi_add_device(proxy);
  24. if (status < 0) {
  25. spi_dev_put(proxy);
  26. return NULL;
  27. }
  30. return proxy;
  31. }

下面来看分配spi_alloc_device的函数，主要完成了分配spi_device，并初始化spi->dev的一些字段。
[cpp] view plaincopyprint?
  1. struct spi_device *spi_alloc_device(struct spi_master *master)
  2. {
  3. struct spi_device *spi;
  4. struct device *dev = master->dev.parent;
  5. if (!spi_master_get(master))
  6. return NULL;
  7. spi = kzalloc(sizeof *spi, GFP_KERNEL);
  8. if (!spi) {
  9. dev_err(dev, "cannot alloc spi_device\n");
  10. spi_master_put(master);
  11. return NULL;
  12. }
  13. spi->master = master;
  14. spi->dev.parent = dev;
  15. /*设置总线是spi_bus_type，下面会讲到spi_device与spi_driver是怎样match上的*/
  16. spi->dev.bus = &spi_bus_type;
  17. spi->dev.release = spidev_release;
  18. device_initialize(&spi->dev);
  19. return spi;
  20. }
下面来看分配的这个spi_device是怎样注册进内核的：
[cpp] view plaincopyprint?
  1. int spi_add_device(struct spi_device *spi)
  2. {
  3. static DEFINE_MUTEX(spi_add_lock);
  4. struct device *dev = spi->master->dev.parent;
  5. int status;
  6. /*spi_device的片选号不能大于spi控制器的片选数*/
  7. if (spi->chip_select >= spi->master->num_chipselect) {
  8. dev_err(dev, "cs%d >= max %d\n",
  9. spi->chip_select,
  10. spi->master->num_chipselect);
  11. return -EINVAL;
  12. }
  13. /*这里设置是spi_device在Linux设备驱动模型中的name，也就是图中的spi0.0，而在/dev/下设备节点的名字是proxy->modalias中的名字*/
  14. dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),
  15. spi->chip_select);
  16. mutex_lock(&spi_add_lock);
  17. /*如果总线上挂的设备已经有这个名字，则设置状态忙碌，并退出*/
  18. if (bus_find_device_by_name(&spi_bus_type, NULL, dev_name(&spi->dev))
  19. != NULL) {
  20. dev_err(dev, "chipselect %d already in use\n",
  21. spi->chip_select);
  22. status = -EBUSY;
  23. goto done;
  24. }
  25. /对spi_device的时钟等进行设置/
  26. status = spi->master->setup(spi);
  27. if (status < 0) {
  28. dev_err(dev, "can't %s %s, status %d\n",
  29. "setup", dev_name(&spi->dev), status);
  30. goto done;
  31. }
  32. /*添加到内核*/
  33. status = device_add(&spi->dev);
  34. if (status < 0)
  35. dev_err(dev, "can't %s %s, status %d\n",
  36. "add", dev_name(&spi->dev), status);
  37. else
  38. dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));
  41. done:
  42. mutex_unlock(&spi_add_lock);
  43. return status;
  44. }
  47. static int s3c24xx_spi_setup(struct spi_device *spi)
  48. {
  49. 。。。。。。。。。。。。。。
  50. ret = s3c24xx_spi_setupxfer(spi, NULL);
  51. 。。。。。。。。。。。。。。
  52. }
  55. static int s3c24xx_spi_setupxfer(struct spi_device *spi,
  56. struct spi_transfer *t)
  57. {
  58. struct s3c24xx_spi *hw = to_hw(spi);
  59. unsigned int bpw;
  60. unsigned int hz;
  61. unsigned int div;
  62. /*设置了每字长的位数，发送速度*/
  63. bpw = t ? t->bits_per_word : spi->bits_per_word;
  64. hz = t ? t->speed_hz : spi->max_speed_hz;
  67. if (bpw != 8) {
  68. dev_err(&spi->dev, "invalid bits-per-word (%d)\n", bpw);
  69. return -EINVAL;
  70. }
  71. /*设置分频值*/
  72. div = clk_get_rate(hw->clk) / hz;
  75. /* is clk = pclk / (2 * (pre+1)), or is it
  76. * clk = (pclk * 2) / ( pre + 1) */
  79. div /= 2;
  82. if (div > 0)
  83. div -= 1;
  86. if (div > 255)
  87. div = 255;
  90. dev_dbg(&spi->dev, "setting pre-scaler to %d (hz %d)\n", div, hz);
  91. writeb(div, hw->regs + S3C2410_SPPRE);
  94. spin_lock(&hw->bitbang.lock);
  95. if (!hw->bitbang.busy) {
  96. hw->bitbang.chipselect(spi, BITBANG_CS_INACTIVE);
  97. /* need to ndelay for 0.5 clocktick ? */
  98. }
  99. spin_unlock(&hw->bitbang.lock);
  102. return 0;
  103. }
下面来看这个spi_driver是怎样注册的，又是与spi_device怎样match上的。
在spidev.c中：
[cpp] view plaincopyprint?
  1. static int __init spidev_init(void)
  2. {
  3. int status;
  4. BUILD_BUG_ON(N_SPI_MINORS > 256);
  5. status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
  6. if (status < 0)
  7. return status;
  8. spidev_class = class_create(THIS_MODULE, "spidev");
  9. if (IS_ERR(spidev_class)) {
  10. unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
  11. return PTR_ERR(spidev_class);
  12. }
  13. status = spi_register_driver(&spidev_spi);
  14. if (status < 0) {
  15. class_destroy(spidev_class);
  16. unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
  17. }
  18. return status;
  19. }
注册了名为”spi”的字符驱动，然后注册了spidev_spi驱动，这个就是图中sys/Bus/Spi/Drivers/下的spidev。
[cpp] view plaincopyprint?
  1. static struct spi_driver spidev_spi = {
  2. .driver = {
  3. .name = "spidev",
  4. .owner = THIS_MODULE,
  5. },
  6. .probe = spidev_probe,
  7. .remove = __devexit_p(spidev_remove),
  8. };
[cpp] view plaincopyprint?
  1. static struct spi_driver spidev_spi = {
  2. .driver = {
  3. .name = "spidev",
  4. .owner = THIS_MODULE,
  5. },
  6. .probe = spidev_probe,
  7. .remove = __devexit_p(spidev_remove),
  8. };
这里来看__driver_attach这个函数，其中分别调用了driver_match_device，driver_probe_device函数。如果匹配成果调用probe函数，否则返回。
[cpp] view plaincopyprint?
  1. static int __driver_attach(struct device *dev, void *data)
  2. {
  3. struct device_driver *drv = data;
  4. if (!driver_match_device(drv, dev))
  5. return 0;
  7. if (dev->parent) /* Needed for USB */
  8. down(&dev->parent->sem);
  9. down(&dev->sem);
  10. if (!dev->driver)
  11. driver_probe_device(drv, dev);
  12. up(&dev->sem);
  13. if (dev->parent)
  14. up(&dev->parent->sem);
  16. return 0;
  17. }
匹配的时候调用的bus的match函数。
[cpp] view plaincopyprint?
  1. struct bus_type spi_bus_type = {
  2. .name = "spi",
  3. .dev_attrs = spi_dev_attrs,
  4. .match = spi_match_device,
  5. .uevent = spi_uevent,
  6. .suspend = spi_suspend,
  7. .resume = spi_resume,
  8. };
  9. static int spi_match_device(struct device *dev, struct device_driver *drv)
  10. {
  11. const struct spi_device *spi = to_spi_device(dev);
  14. return strcmp(spi->modalias, drv->name) == 0;
  15. }
可以看到这里根据驱动和设备的名字进行匹配，匹配成功后调用驱动的probe函数。
[cpp] view plaincopyprint?
  1. static int spi_drv_probe(struct device *dev)
  2. {
  3. const struct spi_driver *sdrv = to_spi_driver(dev->driver);
  6. return sdrv->probe(to_spi_device(dev));
  7. }
可以看大调用了具体的probe函数，这里实现了把spidev添加到device_list，这样这个虚拟的字符驱动就注册并初始化完毕。
[cpp] view plaincopyprint?
  1. static int spidev_remove(struct spi_device *spi)
  2. {
  3. struct spidev_data *spidev = spi_get_drvdata(spi);
  6. /* make sure ops on existing fds can abort cleanly */
  7. spin_lock_irq(&spidev->spi_lock);
  8. spidev->spi = NULL;
  9. spi_set_drvdata(spi, NULL);
  10. spin_unlock_irq(&spidev->spi_lock);
  13. /* prevent new opens */
  14. mutex_lock(&device_list_lock);
  15. list_del(&spidev->device_entry);
  16. device_destroy(spidev_class, spidev->devt);
  17. clear_bit(MINOR(spidev->devt), minors);
  18. if (spidev->users == 0)
  19. kfree(spidev);
  20. mutex_unlock(&device_list_lock);
  23. return 0;
  24. }
在spidev的注册函数中注册了文件操作集合file_operations，为用户空间提供了操作SPI controller的接口。
[cpp] view plaincopyprint?
  1. static struct file_operations spidev_fops = {
  2. .owner = THIS_MODULE,
  3. /* REVISIT switch to aio primitives, so that userspace
  4. * gets more complete API coverage. It'll simplify things
  5. * too, except for the locking.
  6. */
  7. .write = spidev_write,
  8. .read = spidev_read,
  9. .unlocked_ioctl = spidev_ioctl,
  10. .open = spidev_open,
  11. .release = spidev_release,
  12. };

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： zhouxitaa > 《spi》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多