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

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

view plain

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函数：

view plain

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函数，这个将在后边进行分析。

view plain

1. <span style="font-size:18px;">int __init  
2. spi_register_board_info(struct spi_board_info const *info, unsigned n)  
3. {  
4.     struct boardinfo    *bi;  
5.   
6.   
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);  
12.   
13.   
14.     mutex_lock(&board_lock);  
15.     list_add_tail(&bi->list, &board_list);  
16.     mutex_unlock(&board_lock);  
17.     return 0;  
18. }</span>  

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

view plain

1. <span style="font-size:18px;">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;  
9.   
10.   
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.     }  
28.   
29.   
30.     return proxy;  
31. }</span>  

下面来看分配spi_alloc_device的函数，主要完成了分配spi_device，并初始化spi->dev的一些字段。

view plain

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是怎样注册进内核的：

view plain

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));  
39.   
40.   
41. done:  
42.     mutex_unlock(&spi_add_lock);  
43.     return status;  
44. }  
45.   
46.   
47. static int s3c24xx_spi_setup(struct spi_device *spi)  
48. {  
49.     。。。。。。。。。。。。。。  
50.     ret = s3c24xx_spi_setupxfer(spi, NULL);  
51.     。。。。。。。。。。。。。。  
52. }  
53.   
54.   
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;  
65.   
66.   
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;  
73.   
74.   
75.     /* is clk = pclk / (2 * (pre+1)), or is it 
76.      *    clk = (pclk * 2) / ( pre + 1) */  
77.   
78.   
79.     div /= 2;  
80.   
81.   
82.     if (div > 0)  
83.         div -= 1;  
84.   
85.   
86.     if (div > 255)  
87.         div = 255;  
88.   
89.   
90.     dev_dbg(&spi->dev, "setting pre-scaler to %d (hz %d)\n", div, hz);  
91.     writeb(div, hw->regs + S3C2410_SPPRE);  
92.   
93.   
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);  
100.   
101.   
102.     return 0;  
103. }  

下面来看这个spi_driver是怎样注册的，又是与spi_device怎样match上的。
在spidev.c中：

view plain

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。

view plain

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. };  

view plain

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函数，否则返回。

view plain

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;    
6.     
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);    
15.     
16.     return 0;    
17. }    

匹配的时候调用的bus的match函数。

view plain

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);  
12.   
13.   
14.     return strcmp(spi->modalias, drv->name) == 0;  
15. }  

可以看到这里根据驱动和设备的名字进行匹配，匹配成功后调用驱动的probe函数。

view plain

1. static int spi_drv_probe(struct device *dev)  
2. {  
3.     const struct spi_driver     *sdrv = to_spi_driver(dev->driver);  
4.   
5.   
6.     return sdrv->probe(to_spi_device(dev));  
7. }  

可以看大调用了具体的probe函数，这里实现了把spidev添加到device_list，这样这个虚拟的字符驱动就注册并初始化完毕。

view plain

1. static int spidev_remove(struct spi_device *spi)  
2. {  
3.     struct spidev_data  *spidev = spi_get_drvdata(spi);  
4.   
5.   
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);  
11.   
12.   
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);  
21.   
22.   
23.     return 0;  
24. }  

在spidev的注册函数中注册了文件操作集合file_operations，为用户空间提供了操作SPI controller的接口。

view plain

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. };  

到此为止spi子系统与spi_master,spi_device,spi_driver这个Linux设备驱动模型已经建立完了。