? ? ?先給出Linux SPI子系統(tǒng)的體系結(jié)構(gòu)圖：

? ? ? ? ? ? ? ? ? ? ? ? ?SPI子系統(tǒng)體系結(jié)構(gòu)

下面開(kāi)始分析SPI子系統(tǒng)。

Linux中SPI子系統(tǒng)的初始化是從drivers/spi/spi.c文件中的spi_init函數(shù)開(kāi)始的，看看它的定義：

00001025 static int __init spi_init(void) 00001026 { 00001027 int status; 00001028 00001029 buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL); 00001030 if (!buf) { 00001031 status = -ENOMEM; 00001032 goto err0; 00001033 } 00001034 00001035 status = bus_register(&spi_bus_type); 00001036 if (status < 0) 00001037 goto err1; 00001038 00001039 status = class_register(&spi_master_class); 00001040 if (status < 0) 00001041 goto err2; 00001042 return 0; 00001043 00001044 err2: 00001045 bus_unregister(&spi_bus_type); 00001046 err1: 00001047 kfree(buf); 00001048 buf = NULL; 00001049 err0: 00001050 return status; 00001051 }

1029行，分配spi buf內(nèi)存，其中buf和SPI_BUFSIZ都在spi.c文件中定義：

00000945 #define SPI_BUFSIZ max(32,SMP_CACHE_BYTES) 00000946 00000947 static u8 *buf;

1035行，注冊(cè)spi總線，同樣是在spi.c文件中：

00000145 struct bus_type spi_bus_type = { 00000146 .name = "spi", 00000147 .dev_attrs = spi_dev_attrs, 00000148 .match = spi_match_device, 00000149 .uevent = spi_uevent, 00000150 .suspend = spi_suspend, 00000151 .resume = spi_resume, 00000152 };

146行，總線的名字就叫spi。

148行，比較重要的，spi_match_device是spi總線上匹配設(shè)備和設(shè)備驅(qū)動(dòng)的函數(shù)，同樣是在spi.c文件中：

00000085 static int spi_match_device(struct device *dev, struct device_driver *drv) 00000086 { 00000087 const struct spi_device *spi = to_spi_device(dev); 00000088 const struct spi_driver *sdrv = to_spi_driver(drv); 00000089 00000090 /* Attempt an OF style match */ 00000091 if (of_driver_match_device(dev, drv)) 00000092 return 1; 00000093 00000094 if (sdrv->id_table) 00000095 return !!spi_match_id(sdrv->id_table, spi); 00000096 00000097 return strcmp(spi->modalias, drv->name) == 0; 00000098 }

寫過(guò)驅(qū)動(dòng)的都應(yīng)該知道platform總線有struct platform_device和struct platform_driver，到了SPI總線，當(dāng)然也有對(duì)應(yīng)的struct spi_device和struct spi_driver，如87、88行所示。87行，關(guān)于struct spi_device的定義是在include/linux/spi/spi.h中：

00000069 struct spi_device { 00000070 struct device dev; 00000071 struct spi_master *master; 00000072 u32 max_speed_hz; 00000073 u8 chip_select; 00000074 u8 mode; 00000075 #define SPI_CPHA 0x01 /* clock phase */ 00000076 #define SPI_CPOL 0x02 /* clock polarity */ 00000077 #define SPI_MODE_0 (0|0) /* (original MicroWire) */ 00000078 #define SPI_MODE_1 (0|SPI_CPHA) 00000079 #define SPI_MODE_2 (SPI_CPOL|0) 00000080 #define SPI_MODE_3 (SPI_CPOL|SPI_CPHA) 00000081 #define SPI_CS_HIGH 0x04 /* chipselect active high? */ 00000082 #define SPI_LSB_FIRST 0x08 /* per-word bits-on-wire */ 00000083 #define SPI_3WIRE 0x10 /* SI/SO signals shared */ 00000084 #define SPI_LOOP 0x20 /* loopback mode */ 00000085 #define SPI_NO_CS 0x40 /* 1 dev/bus, no chipselect */ 00000086 #define SPI_READY 0x80 /* slave pulls low to pause */ 00000087 u8 bits_per_word; 00000088 int irq; 00000089 void *controller_state; 00000090 void *controller_data; 00000091 char modalias[SPI_NAME_SIZE]; 00000092 00000093 /* 00000094 * likely need more hooks for more protocol options affecting how 00000095 * the controller talks to each chip, like: 00000096 * - memory packing (12 bit samples into low bits, others zeroed) 00000097 * - priority 00000098 * - drop chipselect after each word 00000099 * - chipselect delays 00000100 * - ... 00000101 */ 00000102 };

70行，dev，嵌入到設(shè)備模型中用的。

71行，master，spi設(shè)備的更高層描述，每一個(gè)spi控制器就對(duì)應(yīng)一個(gè)master，一個(gè)spi設(shè)備必須對(duì)應(yīng)一個(gè)master，master下可以有多個(gè)spi設(shè)備。

72，73行沒(méi)什么好說(shuō)的，從變量的名字就可以明白。

74行，mode，針對(duì)時(shí)鐘相位CPHA（0或1）和時(shí)鐘極性CPOL（0或1）的不同組合，將spi分成四種模式，就是77至80行這四種。CPOL表示當(dāng)空閑時(shí)（沒(méi)有進(jìn)行數(shù)據(jù)傳輸）時(shí)鐘信號(hào)的電平，CPOL=0表示低電平，CPOL=1表示高電平。每個(gè)時(shí)鐘周期都有兩次電平的跳變，上升沿和下降沿，CPHA就表示在每個(gè)時(shí)鐘周期里是第一個(gè)邊沿采樣數(shù)據(jù)還是第二個(gè)邊沿采樣數(shù)據(jù)，具體第一個(gè)邊沿或者第二個(gè)邊沿是上升沿還是下降沿則由CPOL決定。看下面這張圖就明白了。藍(lán)色箭頭表示對(duì)數(shù)據(jù)進(jìn)行采樣。

87行，如果傳輸是以字節(jié)為單位的話就設(shè)置為8，相應(yīng)地，如果是以2個(gè)字節(jié)為單位則設(shè)置為16。

88行，中斷號(hào)。89行，沒(méi)有使用，在后面會(huì)看到這個(gè)值會(huì)被設(shè)置為NULL。90行，后面講到具體的控制器再說(shuō)。91行，很重要，一般來(lái)說(shuō)設(shè)備與驅(qū)動(dòng)能否匹配起來(lái)就要看它，注意，這里只是說(shuō)一般，因?yàn)檫€有另外兩種匹配的方法，不過(guò)大部分設(shè)備和驅(qū)動(dòng)能否匹配起來(lái)都是根據(jù)名字是否相等，當(dāng)然像USB驅(qū)動(dòng)就不是根據(jù)名字來(lái)匹配的，而是根據(jù)與id table。struct spi_driver的定義也是在include/linux/spi/spi.h：

00000175 struct spi_driver { 00000176 const struct spi_device_id *id_table; 00000177 int (*probe)(struct spi_device *spi); 00000178 int (*remove)(struct spi_device *spi); 00000179 void (*shutdown)(struct spi_device *spi); 00000180 int (*suspend)(struct spi_device *spi, pm_message_t mesg); 00000181 int (*resume)(struct spi_device *spi); 00000182 struct device_driver driver; 00000183 };

182行，driver就是在設(shè)備模型中使用的那個(gè)device_driver，其他都是一些函數(shù)指針的定義，挺熟悉的了，就不多說(shuō)了。

? ? ? 回到spi_match_device函數(shù)，91行和95行就是設(shè)備和驅(qū)動(dòng)匹配的另外兩種方法，因?yàn)楹笪囊v的spi驅(qū)動(dòng)使用的是第三種方法，因此這里就不討論這兩種方法了。97行，根據(jù)設(shè)備名和驅(qū)動(dòng)名是否相等進(jìn)行匹配，相等則返回1，表示匹配成功，此時(shí)驅(qū)動(dòng)里的probe函數(shù)將會(huì)被調(diào)用，這也是我們最希望看到的，返回0則表示匹配失敗。

? ? ? 我們知道，對(duì)于具體的平臺(tái)，nand、iic、frame buffer等這些都是平臺(tái)設(shè)備，spi當(dāng)然也一樣是平臺(tái)設(shè)備，對(duì)于平臺(tái)設(shè)備，大部分情況下是先注冊(cè)設(shè)備再注冊(cè)驅(qū)動(dòng)。因此下面就以exynos4412為具體平臺(tái)，按照這種先后順序來(lái)講述。

exynos4412有三個(gè)SPI控制器，以SPI0為例就可以了。首先看exynos4412中關(guān)于SPI0控制器的描述，在arch/arm/mach-exynos/dev-spi.c文件中：

struct platform_device exynos_device_spi0 = {.name = "s3c64xx-spi",.id = 0,.num_resources = ARRAY_SIZE(exynos_spi0_resource),.resource = exynos_spi0_resource,.dev = {.dma_mask = &spi_dmamask,.coherent_dma_mask = DMA_BIT_MASK(32),.platform_data = &exynos_spi0_pdata,}, };

第2行，驅(qū)動(dòng)能否與這個(gè)設(shè)備匹配，就看這個(gè)名字了，因此對(duì)應(yīng)的驅(qū)動(dòng)名字必須與之一樣。3行，SPI控制器的ID，SPI0控制器就為0，SPI1控制器就為1。

4和5行是關(guān)于IO口資源、DMA資源和中斷資源的。7、8行是關(guān)于DMA的，不說(shuō)了。9行，給驅(qū)動(dòng)用的，在驅(qū)動(dòng)那里再說(shuō)。在板初始化函數(shù)smdk4x12_machine_init里調(diào)用platform_add_devices函數(shù)就可以將SPI0設(shè)備注冊(cè)到platform總線上。

exynos4412的SPI控制器驅(qū)動(dòng)在drivers/spi/spi_s3c64xx.c文件里（雖然我們是exynos4412平臺(tái)，但是上面exynos_device_spi0中name為"s3c64xx-spi"，所以，我猜這應(yīng)該是使用的s3c6410原來(lái)的驅(qū)動(dòng)程序）。初始化函數(shù)：

00001183 static int __init s3c64xx_spi_init(void) 00001184 { 00001185 return platform_driver_probe(&s3c64xx_spi_driver, s3c64xx_spi_probe); 00001186 }

1185行，s3c64xx_spi_driver是struct platform_driver的實(shí)例，也在spi_s3c64xx.c文件中定義：

00001172 static struct platform_driver s3c64xx_spi_driver = { 00001173 .driver = { 00001174 .name = "s3c64xx-spi", 00001175 .owner = THIS_MODULE, 00001176 }, 00001177 .remove = s3c64xx_spi_remove, 00001178 .suspend = s3c64xx_spi_suspend, 00001179 .resume = s3c64xx_spi_resume, 00001180 };

1174行，看到了沒(méi)？和之前在exynos_device_spi0里定義的名字是一樣的，這樣它們就可以匹配起來(lái)，1185行的s3c64xx_spi_probe驅(qū)動(dòng)探測(cè)函數(shù)就會(huì)被調(diào)用，看下它的定義：

00000911 static int __init s3c64xx_spi_probe(struct platform_device *pdev) 00000912 { 00000913 struct resource *mem_res, *dmatx_res, *dmarx_res; 00000914 struct s3c64xx_spi_driver_data *sdd; 00000915 struct s3c64xx_spi_info *sci; 00000916 struct spi_master *master; 00000917 int ret; 00000918 00000919 if (pdev->id < 0) { 00000920 dev_err(&pdev->dev, 00000921 "Invalid platform device id-%d\n", pdev->id); 00000922 return -ENODEV; 00000923 } 00000924 00000925 if (pdev->dev.platform_data == NULL) { 00000926 dev_err(&pdev->dev, "platform_data missing!\n"); 00000927 return -ENODEV; 00000928 } 00000929 00000930 sci = pdev->dev.platform_data; 00000931 if (!sci->src_clk_name) { 00000932 dev_err(&pdev->dev, 00000933 "Board init must call s3c64xx_spi_set_info()\n"); 00000934 return -EINVAL; 00000935 } 00000936 00000937 /* Check for availability of necessary resource */ 00000938 00000939 dmatx_res = platform_get_resource(pdev, IORESOURCE_DMA, 0); 00000940 if (dmatx_res == NULL) { 00000941 dev_err(&pdev->dev, "Unable to get SPI-Tx dma resource\n"); 00000942 return -ENXIO; 00000943 } 00000944 00000945 dmarx_res = platform_get_resource(pdev, IORESOURCE_DMA, 1); 00000946 if (dmarx_res == NULL) { 00000947 dev_err(&pdev->dev, "Unable to get SPI-Rx dma resource\n"); 00000948 return -ENXIO; 00000949 } 00000950 00000951 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 00000952 if (mem_res == NULL) { 00000953 dev_err(&pdev->dev, "Unable to get SPI MEM resource\n"); 00000954 return -ENXIO; 00000955 } 00000956 00000957 master = spi_alloc_master(&pdev->dev, 00000958 sizeof(struct s3c64xx_spi_driver_data)); 00000959 if (master == NULL) { 00000960 dev_err(&pdev->dev, "Unable to allocate SPI Master\n"); 00000961 return -ENOMEM; 00000962 } 00000963 00000964 platform_set_drvdata(pdev, master); 00000965 00000966 sdd = spi_master_get_devdata(master); 00000967 sdd->master = master; 00000968 sdd->cntrlr_info = sci; 00000969 sdd->pdev = pdev; 00000970 sdd->sfr_start = mem_res->start; 00000971 sdd->tx_dmach = dmatx_res->start; 00000972 sdd->rx_dmach = dmarx_res->start; 00000973 00000974 sdd->cur_bpw = 8; 00000975 00000976 master->bus_num = pdev->id; 00000977 master->setup = s3c64xx_spi_setup; 00000978 master->transfer = s3c64xx_spi_transfer; 00000979 master->num_chipselect = sci->num_cs; 00000980 master->dma_alignment = 8; 00000981 /* the spi->mode bits understood by this driver: */ 00000982 00000983 master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH; 00000984 00000985 if (request_mem_region(mem_res->start, 00000986 resource_size(mem_res), pdev->name) == NULL) { 00000987 dev_err(&pdev->dev, "Req mem region failed\n"); 00000988 ret = -ENXIO; 00000989 goto err0; 00000990 } 00000991 00000992 sdd->regs = ioremap(mem_res->start, resource_size(mem_res)); 00000993 if (sdd->regs == NULL) { 00000994 dev_err(&pdev->dev, "Unable to remap IO\n"); 00000995 ret = -ENXIO; 00000996 goto err1; 00000997 } 00000998 00000999 if (sci->cfg_gpio == NULL || sci->cfg_gpio(pdev)) { 00001000 dev_err(&pdev->dev, "Unable to config gpio\n"); 00001001 ret = -EBUSY; 00001002 goto err2; 00001003 } 00001004 00001005 /* Setup clocks */ 00001006 sdd->clk = clk_get(&pdev->dev, "spi"); 00001007 if (IS_ERR(sdd->clk)) { 00001008 dev_err(&pdev->dev, "Unable to acquire clock 'spi'\n"); 00001009 ret = PTR_ERR(sdd->clk); 00001010 goto err3; 00001011 } 00001012 00001013 if (clk_enable(sdd->clk)) { 00001014 dev_err(&pdev->dev, "Couldn't enable clock 'spi'\n"); 00001015 ret = -EBUSY; 00001016 goto err4; 00001017 } 00001018 00001019 sdd->src_clk = clk_get(&pdev->dev, sci->src_clk_name); 00001020 if (IS_ERR(sdd->src_clk)) { 00001021 dev_err(&pdev->dev, 00001022 "Unable to acquire clock '%s'\n", sci->src_clk_name); 00001023 ret = PTR_ERR(sdd->src_clk); 00001024 goto err5; 00001025 } 00001026 00001027 if (clk_enable(sdd->src_clk)) { 00001028 dev_err(&pdev->dev, "Couldn't enable clock '%s'\n", 00001029 sci->src_clk_name); 00001030 ret = -EBUSY; 00001031 goto err6; 00001032 } 00001033 00001034 sdd->workqueue = create_singlethread_workqueue( 00001035 dev_name(master->dev.parent)); 00001036 if (sdd->workqueue == NULL) { 00001037 dev_err(&pdev->dev, "Unable to create workqueue\n"); 00001038 ret = -ENOMEM; 00001039 goto err7; 00001040 } 00001041 00001042 /* Setup Deufult Mode */ 00001043 s3c64xx_spi_hwinit(sdd, pdev->id); 00001044 00001045 spin_lock_init(&sdd->lock); 00001046 init_completion(&sdd->xfer_completion); 00001047 INIT_WORK(&sdd->work, s3c64xx_spi_work); 00001048 INIT_LIST_HEAD(&sdd->queue); 00001049 00001050 if (spi_register_master(master)) { 00001051 dev_err(&pdev->dev, "cannot register SPI master\n"); 00001052 ret = -EBUSY; 00001053 goto err8; 00001054 } 00001055 00001056 dev_dbg(&pdev->dev, "Samsung SoC SPI Driver loaded for Bus SPI-%d " 00001057 "with %d Slaves attached\n", 00001058 pdev->id, master->num_chipselect); 00001059 dev_dbg(&pdev->dev, "\tIOmem=[0x%x-0x%x]\tDMA=[Rx-%d, Tx-%d]\n", 00001060 mem_res->end, mem_res->start, 00001061 sdd->rx_dmach, sdd->tx_dmach); 00001062 00001063 return 0; 00001064 00001065 err8: 00001066 destroy_workqueue(sdd->workqueue); 00001067 err7: 00001068 clk_disable(sdd->src_clk); 00001069 err6: 00001070 clk_put(sdd->src_clk); 00001071 err5: 00001072 clk_disable(sdd->clk); 00001073 err4: 00001074 clk_put(sdd->clk); 00001075 err3: 00001076 err2: 00001077 iounmap((void *) sdd->regs); 00001078 err1: 00001079 release_mem_region(mem_res->start, resource_size(mem_res)); 00001080 err0: 00001081 platform_set_drvdata(pdev, NULL); 00001082 spi_master_put(master); 00001083 00001084 return ret; 00001085 }

函數(shù)很長(zhǎng)，但做的東西卻很簡(jiǎn)單。919至923行，SPI控制器的ID是從0開(kāi)始的，小于0的話，沒(méi)門，出錯(cuò)。

925至928行，必須要有platform_data，否則出錯(cuò)。930行，如果platform_data存在的話就把它取出來(lái)。

931至935行，如果src_clk_name為0，則表示在板初始化函數(shù)里沒(méi)有調(diào)用s3c64xx_spi_set_info函數(shù)。

939至955行，獲取在設(shè)備里定義的IO口和DMA資源。

957至962行，一個(gè)SPI控制器用一個(gè)master來(lái)描述。這里使用SPI核心的spi_alloc_master函數(shù)請(qǐng)求分配master。它在drivers/spi/spi.c文件中定義：

00000471 struct spi_master *spi_alloc_master(struct device *dev, unsigned size) 00000472 { 00000473 struct spi_master *master; 00000474 00000475 if (!dev) 00000476 return NULL; 00000477 00000478 master = kzalloc(size + sizeof *master, GFP_KERNEL); 00000479 if (!master) 00000480 return NULL; 00000481 00000482 device_initialize(&master->dev); 00000483 master->dev.class = &spi_master_class; 00000484 master->dev.parent = get_device(dev); 00000485 spi_master_set_devdata(master, &master[1]); 00000486 00000487 return master; 00000488 }

478至480行，這里分配的內(nèi)存大小是*master加size，包含了兩部分內(nèi)存。

482行，設(shè)備模型中的初始設(shè)備函數(shù)，不說(shuō)。

483行，spi_master_class在SPI子系統(tǒng)初始化的時(shí)候就已經(jīng)注冊(cè)好了。

484行，設(shè)置當(dāng)前設(shè)備的父設(shè)備，關(guān)于設(shè)備模型的。

485行，&master[1]就是master之后的另一部分內(nèi)存的起始地址。

? ? ?回到s3c64xx_spi_probe函數(shù)，966行，就是取出剛才申請(qǐng)的第二部分內(nèi)存的起始地址。

966至980行，根據(jù)預(yù)先定義的變量、函數(shù)進(jìn)行填充。

983行，有點(diǎn)意思，說(shuō)明該驅(qū)動(dòng)支持哪些SPI模式。

985至997行，寫過(guò)Linux驅(qū)動(dòng)都應(yīng)該知道，IO內(nèi)存映射。

999至1003行，SPI IO管腳配置，將相應(yīng)的IO管腳設(shè)置為SPI功能。

1006至1032行，使能SPI時(shí)鐘。

1034至1040行，創(chuàng)建單個(gè)線程的工作隊(duì)列，用于數(shù)據(jù)收發(fā)操作。

1043行，硬件初始化，初始化SPI控制器寄存器。

1045至1048行，鎖，工作隊(duì)列等初始化。

1050至1054行，spi_register_master在drivers/spi/spi.c文件中定義：

00000511 int spi_register_master(struct spi_master *master) 00000512 { 00000513 static atomic_t dyn_bus_id = ATOMIC_INIT((1<<15) - 1); 00000514 struct device *dev = master->dev.parent; 00000515 int status = -ENODEV; 00000516 int dynamic = 0; 00000517 00000518 if (!dev) 00000519 return -ENODEV; 00000520 00000521 /* even if it's just one always-selected device, there must 00000522 * be at least one chipselect 00000523 */ 00000524 if (master->num_chipselect == 0) 00000525 return -EINVAL; 00000526 00000527 /* convention: dynamically assigned bus IDs count down from the max */ 00000528 if (master->bus_num < 0) { 00000529 /* FIXME switch to an IDR based scheme, something like 00000530 * I2C now uses, so we can't run out of "dynamic" IDs 00000531 */ 00000532 master->bus_num = atomic_dec_return(&dyn_bus_id); 00000533 dynamic = 1; 00000534 } 00000535 00000536 spin_lock_init(&master->bus_lock_spinlock); 00000537 mutex_init(&master->bus_lock_mutex); 00000538 master->bus_lock_flag = 0; 00000539 00000540 /* register the device, then userspace will see it. 00000541 * registration fails if the bus ID is in use. 00000542 */ 00000543 dev_set_name(&master->dev, "spi%u", master->bus_num); 00000544 status = device_add(&master->dev); 00000545 if (status < 0) 00000546 goto done; 00000547 dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev), 00000548 dynamic ? " (dynamic)" : ""); 00000549 00000550 /* populate children from any spi device tables */ 00000551 scan_boardinfo(master); 00000552 status = 0; 00000553 00000554 /* Register devices from the device tree */ 00000555 of_register_spi_devices(master); 00000556 done: 00000557 return status; 00000558 }

524行，一個(gè)SPI控制器至少有一個(gè)片選，因此片選數(shù)為0則出錯(cuò)。

528至534行，如果總線號(hào)小于0則動(dòng)態(tài)分配一個(gè)總線號(hào)。

543至548行，把master加入到設(shè)備模型中。

551行，scan_boardinfo函數(shù)同樣是在driver/spi/spi.c中定義：

00000414 static void scan_boardinfo(struct spi_master *master) 00000415 { 00000416 struct boardinfo *bi; 00000417 00000418 mutex_lock(&board_lock); 00000419 list_for_each_entry(bi, &board_list, list) { 00000420 struct spi_board_info *chip = bi->board_info; 00000421 unsigned n; 00000422 00000423 for (n = bi->n_board_info; n > 0; n--, chip++) { 00000424 if (chip->bus_num != master->bus_num) 00000425 continue; 00000426 /* NOTE: this relies on spi_new_device to 00000427 * issue diagnostics when given bogus inputs 00000428 */ 00000429 (void) spi_new_device(master, chip); 00000430 } 00000431 } 00000432 mutex_unlock(&board_lock); 00000433 }

419至431做了兩件事情，首先遍歷board_list這個(gè)鏈表，每找到一個(gè)成員就將它的總線號(hào)與master的總線號(hào)進(jìn)行比較，如果相等則調(diào)用spi_new_device函數(shù)創(chuàng)建一個(gè)spi設(shè)備。

00000336 struct spi_device *spi_new_device(struct spi_master *master, 00000337 struct spi_board_info *chip) 00000338 { 00000339 struct spi_device *proxy; 00000340 int status; 00000341 00000342 /* NOTE: caller did any chip->bus_num checks necessary. 00000343 * 00000344 * Also, unless we change the return value convention to use 00000345 * error-or-pointer (not NULL-or-pointer), troubleshootability 00000346 * suggests syslogged diagnostics are best here (ugh). 00000347 */ 00000348 00000349 proxy = spi_alloc_device(master); 00000350 if (!proxy) 00000351 return NULL; 00000352 00000353 WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias)); 00000354 00000355 proxy->chip_select = chip->chip_select; 00000356 proxy->max_speed_hz = chip->max_speed_hz; 00000357 proxy->mode = chip->mode; 00000358 proxy->irq = chip->irq; 00000359 strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias)); 00000360 proxy->dev.platform_data = (void *) chip->platform_data; 00000361 proxy->controller_data = chip->controller_data; 00000362 proxy->controller_state = NULL; 00000363 00000364 status = spi_add_device(proxy); 00000365 if (status < 0) { 00000366 spi_dev_put(proxy); 00000367 return NULL; 00000368 } 00000369 00000370 return proxy; 00000371 }

349至351行，spi_alloc_device函數(shù)的定義：

00000229 struct spi_device *spi_alloc_device(struct spi_master *master) 00000230 { 00000231 struct spi_device *spi; 00000232 struct device *dev = master->dev.parent; 00000233 00000234 if (!spi_master_get(master)) 00000235 return NULL; 00000236 00000237 spi = kzalloc(sizeof *spi, GFP_KERNEL); 00000238 if (!spi) { 00000239 dev_err(dev, "cannot alloc spi_device\n"); 00000240 spi_master_put(master); 00000241 return NULL; 00000242 } 00000243 00000244 spi->master = master; 00000245 spi->dev.parent = dev; 00000246 spi->dev.bus = &spi_bus_type; 00000247 spi->dev.release = spidev_release; 00000248 device_initialize(&spi->dev); 00000249 return spi; 00000250 }

234至242行，錯(cuò)誤檢測(cè)和分配內(nèi)存。

246行，該spi設(shè)備屬于SPI子系統(tǒng)初始化時(shí)注冊(cè)的那條叫“spi”的總線。

248行，設(shè)備模型方面的初始化，不說(shuō)。

? ? ?回到spi_new_device函數(shù)，355至362行，是一些賦值，其中359行比較關(guān)鍵，設(shè)備名字拷貝，362行，之前說(shuō)過(guò)了，設(shè)置為NULL。看364行spi_add_device函數(shù)的定義：

00000262 int spi_add_device(struct spi_device *spi) 00000263 { 00000264 static DEFINE_MUTEX(spi_add_lock); 00000265 struct device *dev = spi->master->dev.parent; 00000266 struct device *d; 00000267 int status; 00000268 00000269 /* Chipselects are numbered 0..max; validate. */ 00000270 if (spi->chip_select >= spi->master->num_chipselect) { 00000271 dev_err(dev, "cs%d >= max %d\n", 00000272 spi->chip_select, 00000273 spi->master->num_chipselect); 00000274 return -EINVAL; 00000275 } 00000276 00000277 /* Set the bus ID string */ 00000278 dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev), 00000279 spi->chip_select); 00000280 00000281 00000282 /* We need to make sure there's no other device with this 00000283 * chipselect **BEFORE** we call setup(), else we'll trash 00000284 * its configuration. Lock against concurrent add() calls. 00000285 */ 00000286 mutex_lock(&spi_add_lock); 00000287 00000288 d = bus_find_device_by_name(&spi_bus_type, NULL, dev_name(&spi->dev)); 00000289 if (d != NULL) { 00000290 dev_err(dev, "chipselect %d already in use\n", 00000291 spi->chip_select); 00000292 put_device(d); 00000293 status = -EBUSY; 00000294 goto done; 00000295 } 00000296 00000297 /* Drivers may modify this initial i/o setup, but will 00000298 * normally rely on the device being setup. Devices 00000299 * using SPI_CS_HIGH can't coexist well otherwise... 00000300 */ 00000301 status = spi_setup(spi); 00000302 if (status < 0) { 00000303 dev_err(dev, "can't %s %s, status %d\n", 00000304 "setup", dev_name(&spi->dev), status); 00000305 goto done; 00000306 } 00000307 00000308 /* Device may be bound to an active driver when this returns */ 00000309 status = device_add(&spi->dev); 00000310 if (status < 0) 00000311 dev_err(dev, "can't %s %s, status %d\n", 00000312 "add", dev_name(&spi->dev), status); 00000313 else 00000314 dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev)); 00000315 00000316 done: 00000317 mutex_unlock(&spi_add_lock); 00000318 return status; 00000319 }

270至275行，片選號(hào)是從0開(kāi)始的，如果大于或者等于片選數(shù)的話則返回出錯(cuò)。

288至295行，遍歷spi總線，看是否已經(jīng)注冊(cè)過(guò)該設(shè)備。

301至306行，spi_setup函數(shù)的定義：

00000645 int spi_setup(struct spi_device *spi) 00000646 { 00000647 unsigned bad_bits; 00000648 int status; 00000649 00000650 /* help drivers fail *cleanly* when they need options 00000651 * that aren't supported with their current master 00000652 */ 00000653 bad_bits = spi->mode & ~spi->master->mode_bits; 00000654 if (bad_bits) { 00000655 dev_dbg(&spi->dev, "setup: unsupported mode bits %x\n", 00000656 bad_bits); 00000657 return -EINVAL; 00000658 } 00000659 00000660 if (!spi->bits_per_word) 00000661 spi->bits_per_word = 8; 00000662 00000663 status = spi->master->setup(spi); 00000664 00000665 dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s" 00000666 "%u bits/w, %u Hz max --> %d\n", 00000667 (int) (spi->mode & (SPI_CPOL | SPI_CPHA)), 00000668 (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "", 00000669 (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "", 00000670 (spi->mode & SPI_3WIRE) ? "3wire, " : "", 00000671 (spi->mode & SPI_LOOP) ? "loopback, " : "", 00000672 spi->bits_per_word, spi->max_speed_hz, 00000673 status); 00000674 00000675 return status; 00000676 }

653至658行，如果驅(qū)動(dòng)不支持該設(shè)備的工作模式則返回出錯(cuò)。

663行，調(diào)用控制器驅(qū)動(dòng)里的s3c64xx_spi_setup函數(shù)，只看前一部分代碼：

00000795 static int s3c64xx_spi_setup(struct spi_device *spi) 00000796 { 00000797 struct s3c64xx_spi_csinfo *cs = spi->controller_data; 00000798 struct s3c64xx_spi_driver_data *sdd; 00000799 struct s3c64xx_spi_info *sci; 00000800 struct spi_message *msg; 00000801 u32 psr, speed; 00000802 unsigned long flags; 00000803 int err = 0; 00000804 00000805 if (cs == NULL || cs->set_level == NULL) { 00000806 dev_err(&spi->dev, "No CS for SPI(%d)\n", spi->chip_select); 00000807 return -ENODEV; 00000808 } 00000809 …

從797行就可以知道在實(shí)例化struct spi_board_info時(shí)，其controller_data成員就應(yīng)該指向struct s3c64xx_spi_csinfo的對(duì)象。

? ? ? ?spi_setup函數(shù)結(jié)束了，回到spi_add_device函數(shù)，309至314行，將該設(shè)備加入到設(shè)備模型。一直后退，回到spi_register_master函數(shù)，就剩下555行of_register_spi_devices這個(gè)函數(shù)，由于本文所講的驅(qū)動(dòng)沒(méi)有使用到設(shè)備樹(shù)方面的內(nèi)容，所以該函數(shù)里什么也沒(méi)做，直接返回。

? ? ? 到這里，SPI控制器驅(qū)動(dòng)的初始化過(guò)程已經(jīng)說(shuō)完了。接下來(lái)要說(shuō)的是SPI設(shè)備驅(qū)動(dòng)。其實(shí)Linux中已經(jīng)實(shí)現(xiàn)了一個(gè)通用的SPI設(shè)備驅(qū)動(dòng)，另外還有一個(gè)是用IO口模擬的SPI驅(qū)動(dòng)，在這里，只說(shuō)前者。

初始化函數(shù)是在drivers/spi/spidev.c文件中定義：

00000658 static int __init spidev_init(void) 00000659 { 00000660 int status; 00000661 00000662 /* Claim our 256 reserved device numbers. Then register a class 00000663 * that will key udev/mdev to add/remove /dev nodes. Last, register 00000664 * the driver which manages those device numbers. 00000665 */ 00000666 BUILD_BUG_ON(N_SPI_MINORS > 256); 00000667 00000668 status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops); 00000669 if (status < 0) 00000670 return status; 00000671 00000672 00000673 spidev_class = class_create(THIS_MODULE, "spidev"); 00000674 if (IS_ERR(spidev_class)) { 00000675 unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name); 00000676 return PTR_ERR(spidev_class); 00000677 } 00000678 00000679 status = spi_register_driver(&spidev_spi_driver); 00000680 if (status < 0) { 00000681 class_destroy(spidev_class); 00000682 unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name); 00000683 } 00000684 return status; 00000685 }

668至670行，注冊(cè)字符設(shè)備，參數(shù)spidev_fops是struct file_operations的實(shí)例，這里就可以知道，用戶程序的open、write等操作最終會(huì)調(diào)用這里面的函數(shù)。

673至677行，創(chuàng)建spidev這一類設(shè)備，為后面自動(dòng)生成設(shè)備節(jié)點(diǎn)做準(zhǔn)備。

679至684行，注冊(cè)spi設(shè)備驅(qū)動(dòng)，spi_register_driver函數(shù)的定義在drivers/spi/spi.c中：

00000182 int spi_register_driver(struct spi_driver *sdrv) 00000183 { 00000184 sdrv->driver.bus = &spi_bus_type; 00000185 if (sdrv->probe) 00000186 sdrv->driver.probe = spi_drv_probe; 00000187 if (sdrv->remove) 00000188 sdrv->driver.remove = spi_drv_remove; 00000189 if (sdrv->shutdown) 00000190 sdrv->driver.shutdown = spi_drv_shutdown; 00000191 return driver_register(&sdrv->driver); 00000192 }

184行，該驅(qū)動(dòng)所屬的總線。185至190行，一些函數(shù)指針的賦值。191行，將驅(qū)動(dòng)注冊(cè)進(jìn)設(shè)備模型，注冊(cè)成功的話就會(huì)在總線上尋找設(shè)備，調(diào)用總線上的match函數(shù)，看能否與之匹配起來(lái)，匹配成功的話，驅(qū)動(dòng)中的probe函數(shù)就會(huì)被調(diào)用。

參數(shù)spidev_spi_driver是struct spi_driver的實(shí)例，它的定義為：

00000641 static struct spi_driver spidev_spi_driver = { 00000642 .driver = { 00000643 .name = "spidev", 00000644 .owner = THIS_MODULE, 00000645 }, 00000646 .probe = spidev_probe, 00000647 .remove = __devexit_p(spidev_remove), 00000648 00000649 /* NOTE: suspend/resume methods are not necessary here. 00000650 * We don't do anything except pass the requests to/from 00000651 * the underlying controller. The refrigerator handles 00000652 * most issues; the controller driver handles the rest. 00000653 */ 00000654 };

下面看spidev_probe函數(shù)。在drivers/spi/spidev.c中定義的：

00000565 static int __devinit spidev_probe(struct spi_device *spi) 00000566 { 00000567 struct spidev_data *spidev; 00000568 int status; 00000569 unsigned long minor; 00000570 00000571 /* Allocate driver data */ 00000572 spidev = kzalloc(sizeof(*spidev), GFP_KERNEL); 00000573 if (!spidev) 00000574 return -ENOMEM; 00000575 00000576 /* Initialize the driver data */ 00000577 spidev->spi = spi; 00000578 spin_lock_init(&spidev->spi_lock); 00000579 mutex_init(&spidev->buf_lock); 00000580 00000581 INIT_LIST_HEAD(&spidev->device_entry); 00000582 00000583 /* If we can allocate a minor number, hook up this device. 00000584 * Reusing minors is fine so long as udev or mdev is working. 00000585 */ 00000586 mutex_lock(&device_list_lock); 00000587 00000588 minor = find_first_zero_bit(minors, N_SPI_MINORS); 00000589 00000590 if (minor < N_SPI_MINORS) { 00000591 struct device *dev; 00000592 00000593 spidev->devt = MKDEV(SPIDEV_MAJOR, minor); 00000594 00000595 dev = device_create(spidev_class, &spi->dev, spidev->devt, 00000596 spidev, "spidev%d.%d", 00000597 spi->master->bus_num, spi->chip_select); 00000598 status = IS_ERR(dev) ? PTR_ERR(dev) : 0; 00000599 } else { 00000600 dev_dbg(&spi->dev, "no minor number available!\n"); 00000601 status = -ENODEV; 00000602 } 00000603 if (status == 0) { 00000604 00000605 set_bit(minor, minors); 00000606 00000607 list_add(&spidev->device_entry, &device_list); 00000608 } 00000609 mutex_unlock(&device_list_lock); 00000610 00000611 if (status == 0) 00000612 spi_set_drvdata(spi, spidev); 00000613 else 00000614 kfree(spidev); 00000615 00000616 return status; 00000617 }

572至574行，分配內(nèi)存，注意對(duì)象的類型是struct spidev_data，看下它在drivers/spi/spidev.c中的定義：

00000075 struct spidev_data { 00000076 dev_t devt; 00000077 spinlock_t spi_lock; 00000078 struct spi_device *spi; 00000079 struct list_head device_entry; 00000080 00000081 /* buffer is NULL unless this device is open (users > 0) */ 00000082 struct mutex buf_lock; 00000083 unsigned users; 00000084 u8 *buffer; 00000085 };

76行，設(shè)備號(hào)。79行，設(shè)備鏈表，所有采用此驅(qū)動(dòng)的設(shè)備將連成一個(gè)鏈表。83行，計(jì)數(shù)，也即是此設(shè)備被open的次數(shù)。

回到spidev_probe函數(shù)，577至586行，一些鎖和鏈表的初始化。588行，從名字上就可以知道，就是找到第一個(gè)為0的位，第一個(gè)參數(shù)minors的定義：

00000054 #define N_SPI_MINORS 32 /* ... up to 256 */ 00000055 00000056 static DECLARE_BITMAP(minors, N_SPI_MINORS);

DECLARE_BITMAP是一個(gè)宏，定義如下：

#define DECLARE_BITMAP(name,bits) \unsigned long name[BITS_TO_LONGS(bits)]

將宏展開(kāi)后是這樣的，unsigned long minors[1]，其實(shí)就是定義一個(gè)只有一個(gè)元素的無(wú)符號(hào)長(zhǎng)整形數(shù)組miniors。

590至593行，如果找到了非0位，就將它作為次設(shè)備號(hào)與之前注冊(cè)的主設(shè)備號(hào)生成設(shè)備號(hào)。

595至598行，創(chuàng)建設(shè)備，并生成設(shè)備節(jié)點(diǎn)，設(shè)備節(jié)點(diǎn)在/dev目錄下，名字的形式為“spidevx.x”。

603至608行，創(chuàng)建設(shè)備成功后，將相應(yīng)的位置1，表示該次設(shè)備號(hào)已經(jīng)被使用，同時(shí)將該設(shè)備加入到設(shè)備鏈表。

611至614行，將設(shè)備的私有數(shù)據(jù)指針指向該設(shè)備。

? ? ? 至此，SPI設(shè)備驅(qū)動(dòng)的初始化過(guò)程也說(shuō)完了。下面就以應(yīng)用程序的操作順序來(lái)說(shuō)，假設(shè)是從open-->write這個(gè)過(guò)程。下面先看驅(qū)動(dòng)中open函數(shù)的實(shí)現(xiàn)，同樣在drivers/spi/spidev.c：

00000477 static int spidev_open(struct inode *inode, struct file *filp) 00000478 { 00000479 struct spidev_data *spidev; 00000480 int status = -ENXIO; 00000481 00000482 mutex_lock(&device_list_lock); 00000483 00000484 00000485 list_for_each_entry(spidev, &device_list, device_entry) { 00000486 if (spidev->devt == inode->i_rdev) { 00000487 status = 0; 00000488 break; 00000489 } 00000490 } 00000491 if (status == 0) { 00000492 if (!spidev->buffer) { 00000493 spidev->buffer = kmalloc(bufsiz, GFP_KERNEL); 00000494 if (!spidev->buffer) { 00000495 dev_dbg(&spidev->spi->dev, "open/ENOMEM\n"); 00000496 status = -ENOMEM; 00000497 } 00000498 } 00000499 if (status == 0) { 00000500 spidev->users++; 00000501 filp->private_data = spidev; 00000502 nonseekable_open(inode, filp); 00000503 } 00000504 } else 00000505 pr_debug("spidev: nothing for minor %d\n", iminor(inode)); 00000506 00000507 mutex_unlock(&device_list_lock); 00000508 return status; 00000509 }

485至490行，遍歷設(shè)備鏈表，每找到一個(gè)設(shè)備就將它的設(shè)備號(hào)與打開(kāi)文件的設(shè)備號(hào)進(jìn)行比較，相等的話表示查找成功。

491至505行，查找成功后就分配讀寫數(shù)據(jù)內(nèi)存，使用計(jì)數(shù)加1，設(shè)置文件私有數(shù)據(jù)指針指向查找到的設(shè)備，以后在驅(qū)動(dòng)的write、read函數(shù)里就可以把它取出來(lái)。

???? 接下來(lái)是write函數(shù)的定義：

00000190 static ssize_t 00000191 spidev_write(struct file *filp, const char __user *buf, 00000192 size_t count, loff_t *f_pos) 00000193 { 00000194 struct spidev_data *spidev; 00000195 ssize_t status = 0; 00000196 unsigned long missing; 00000197 00000198 /* chipselect only toggles at start or end of operation */ 00000199 if (count > bufsiz) 00000200 return -EMSGSIZE; 00000201 00000202 spidev = filp->private_data; 00000203 00000204 mutex_lock(&spidev->buf_lock); 00000205 missing = copy_from_user(spidev->buffer, buf, count); 00000206 if (missing == 0) { 00000207 status = spidev_sync_write(spidev, count); 00000208 } else 00000209 status = -EFAULT; 00000210 mutex_unlock(&spidev->buf_lock); 00000211 00000212 return status; 00000213 }

199至200行，應(yīng)用程序?qū)懭氲臄?shù)據(jù)不能大于驅(qū)動(dòng)中緩沖區(qū)的大小，默認(rèn)為4096個(gè)字節(jié)。

202行，指向文件的私有數(shù)據(jù)。

205行，拷貝用戶空間的數(shù)據(jù)到內(nèi)核空間。

207行，spidev_sync_write的定義：

00000130 static inline ssize_t 00000131 spidev_sync_write(struct spidev_data *spidev, size_t len) 00000132 { 00000133 struct spi_transfer t = { 00000134 .tx_buf = spidev->buffer, 00000135 .len = len, 00000136 }; 00000137 struct spi_message m; 00000138 00000139 spi_message_init(&m); 00000140 spi_message_add_tail(&t, &m); 00000141 return spidev_sync(spidev, &m); 00000142 }

133行，struct spi_transfer的定義在include/linux/spi/spi.h：

00000427 struct spi_transfer { 00000428 /* it's ok if tx_buf == rx_buf (right?) 00000429 * for MicroWire, one buffer must be null 00000430 * buffers must work with dma_*map_single() calls, unless 00000431 * spi_message.is_dma_mapped reports a pre-existing mapping 00000432 */ 00000433 const void *tx_buf; 00000434 void *rx_buf; 00000435 unsigned len; 00000436 00000437 dma_addr_t tx_dma; 00000438 dma_addr_t rx_dma; 00000439 00000440 unsigned cs_change:1; 00000441 u8 bits_per_word; 00000442 u16 delay_usecs; 00000443 u32 speed_hz; 00000444 00000445 struct list_head transfer_list; 00000446 };

433至435行，發(fā)送、接收緩沖區(qū)和長(zhǎng)度。437和438行，發(fā)送和接收的DMA地址。

440行，傳輸完成后是否改變片選信號(hào)。

441行，如果為0則使用驅(qū)動(dòng)的默認(rèn)值。

442行，傳輸完成后等待多長(zhǎng)時(shí)間（毫秒）再改變片選信號(hào)。

443行，將多個(gè)傳輸連成一個(gè)鏈表。

???? 回到spidev_sync_write函數(shù)的137行，在spi.h中定義的struct spi_message：

00000476 struct spi_message { 00000477 struct list_head transfers; 00000478 00000479 struct spi_device *spi; 00000480 00000481 unsigned is_dma_mapped:1; 00000482 00000483 /* REVISIT: we might want a flag affecting the behavior of the 00000484 * last transfer ... allowing things like "read 16 bit length L" 00000485 * immediately followed by "read L bytes". Basically imposing 00000486 * a specific message scheduling algorithm. 00000487 * 00000488 * Some controller drivers (message-at-a-time queue processing) 00000489 * could provide that as their default scheduling algorithm. But 00000490 * others (with multi-message pipelines) could need a flag to 00000491 * tell them about such special cases. 00000492 */ 00000493 00000494 /* completion is reported through a callback */ 00000495 void (*complete)(void *context); 00000496 void *context; 00000497 unsigned actual_length; 00000498 int status; 00000499 00000500 /* for optional use by whatever driver currently owns the 00000501 * spi_message ... between calls to spi_async and then later 00000502 * complete(), that's the spi_master controller driver. 00000503 */ 00000504 struct list_head queue; 00000505 void *state; 00000506 };

477行，一個(gè)message可能包含多個(gè)transfer，因此用鏈表將這些transfer連起來(lái)。

479行，這次message所使用的spi設(shè)備。

481行，是否采用DMA的標(biāo)志。

495行，傳輸完成后的回調(diào)函數(shù)指針。496行，回調(diào)函數(shù)的參數(shù)。

497行，這次message成功傳輸?shù)淖止?jié)數(shù)。

504和505行，當(dāng)前驅(qū)動(dòng)擁有的message。

? ? ? 回到spidev_sync_write函數(shù)，139行，spi.h中的內(nèi)聯(lián)函數(shù)spi_message_init：

00000508 static inline void spi_message_init(struct spi_message *m) 00000509 { 00000510 memset(m, 0, sizeof *m); 00000511 INIT_LIST_HEAD(&m->transfers); 00000512 }

很簡(jiǎn)單，清0內(nèi)存和初始化message的transfer鏈表。

140行，spi_message_add_tail也是spi.h中的內(nèi)聯(lián)函數(shù)：

00000514 static inline void 00000515 spi_message_add_tail(struct spi_transfer *t, struct spi_message *m) 00000516 { 00000517 list_add_tail(&t->transfer_list, &m->transfers); 00000518 }

將transfer加入到鏈表尾。

141行，spidev_sync函數(shù)是在drivers/spi/spidev.c中定義的：

00000105 static ssize_t 00000106 spidev_sync(struct spidev_data *spidev, struct spi_message *message) 00000107 { 00000108 DECLARE_COMPLETION_ONSTACK(done); 00000109 int status; 00000110 00000111 message->complete = spidev_complete; 00000112 message->context = &done; 00000113 00000114 spin_lock_irq(&spidev->spi_lock); 00000115 if (spidev->spi == NULL) 00000116 status = -ESHUTDOWN; 00000117 else 00000118 status = spi_async(spidev->spi, message); 00000119 spin_unlock_irq(&spidev->spi_lock); 00000120 00000121 if (status == 0) { 00000122 wait_for_completion(&done); 00000123 status = message->status; 00000124 if (status == 0) 00000125 status = message->actual_length; 00000126 } 00000127 return status; 00000128 }

108行，定義并初始化一個(gè)完成量，完成量是Linux的一種同步機(jī)制。

111行，spidev_complete函數(shù)里就用來(lái)喚醒等待completion，定義如下：

00000100 static void spidev_complete(void *arg) 00000101 { 00000102 complete(arg); 00000103 }

112行，作為spidev_complete函數(shù)的參數(shù)。

118行，調(diào)用drivers/spi/spi.c里的spi_async函數(shù)，從函數(shù)名知道，這是異步實(shí)現(xiàn)的。為什么是異步的？往下看就知道了。

00000737 int spi_async(struct spi_device *spi, struct spi_message *message) 00000738 { 00000739 struct spi_master *master = spi->master; 00000740 int ret; 00000741 unsigned long flags; 00000742 00000743 spin_lock_irqsave(&master->bus_lock_spinlock, flags); 00000744 00000745 if (master->bus_lock_flag) 00000746 ret = -EBUSY; 00000747 else 00000748 ret = __spi_async(spi, message); 00000749 00000750 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags); 00000751 00000752 return ret; 00000753 }

745行，如果master所在的總線被鎖住了，那么就返回忙。

748行，看__spi_async函數(shù)的定義：

00000679 static int __spi_async(struct spi_device *spi, struct spi_message *message) 00000680 { 00000681 struct spi_master *master = spi->master; 00000682 00000683 /* Half-duplex links include original MicroWire, and ones with 00000684 * only one data pin like SPI_3WIRE (switches direction) or where 00000685 * either MOSI or MISO is missing. They can also be caused by 00000686 * software limitations. 00000687 */ 00000688 if ((master->flags & SPI_MASTER_HALF_DUPLEX) 00000689 || (spi->mode & SPI_3WIRE)) { 00000690 struct spi_transfer *xfer; 00000691 unsigned flags = master->flags; 00000692 00000693 list_for_each_entry(xfer, &message->transfers, transfer_list) { 00000694 if (xfer->rx_buf && xfer->tx_buf) 00000695 return -EINVAL; 00000696 if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf) 00000697 return -EINVAL; 00000698 if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf) 00000699 return -EINVAL; 00000700 } 00000701 } 00000702 00000703 message->spi = spi; 00000704 message->status = -EINPROGRESS; 00000705 return master->transfer(spi, message); 00000706 }

688至701行，如果master設(shè)置了SPI_MASTER_HALF_DUPLEX標(biāo)志，或者spi設(shè)備使用的是3線模式，那么就對(duì)message里的每一個(gè)transfer的發(fā)送和接收buf做一些檢查。

705行，調(diào)用的是具體的SPI控制器驅(qū)動(dòng)里的函數(shù)，這里是drivers/spi/spi_s3c64xx.c里的s3c64xx_spi_transfer函數(shù)：

00000763 static int s3c64xx_spi_transfer(struct spi_device *spi, 00000764 struct spi_message *msg) 00000765 { 00000766 struct s3c64xx_spi_driver_data *sdd; 00000767 unsigned long flags; 00000768 00000769 sdd = spi_master_get_devdata(spi->master); 00000770 00000771 spin_lock_irqsave(&sdd->lock, flags); 00000772 00000773 if (sdd->state & SUSPND) { 00000774 spin_unlock_irqrestore(&sdd->lock, flags); 00000775 return -ESHUTDOWN; 00000776 } 00000777 00000778 msg->status = -EINPROGRESS; 00000779 msg->actual_length = 0; 00000780 00000781 list_add_tail(&msg->queue, &sdd->queue); 00000782 00000783 queue_work(sdd->workqueue, &sdd->work); 00000784 00000785 spin_unlock_irqrestore(&sdd->lock, flags); 00000786 00000787 return 0; 00000788 }

?781行之前沒(méi)什么好說(shuō)的，直接看783行，將work投入到工作隊(duì)列里，然后就返回，在這里就可以回答之前為什么是異步的問(wèn)題。以后在某個(gè)合適的時(shí)間里CPU會(huì)執(zhí)行這個(gè)work指定的函數(shù)，這里是s3c64xx_spi_work函數(shù)，看它的定義：

00000723 static void s3c64xx_spi_work(struct work_struct *work) 00000724 { 00000725 struct s3c64xx_spi_driver_data *sdd = container_of(work, 00000726 struct s3c64xx_spi_driver_data, work); 00000727 unsigned long flags; 00000728 00000729 /* Acquire DMA channels */ 00000730 while (!acquire_dma(sdd)) 00000731 msleep(10); 00000732 00000733 spin_lock_irqsave(&sdd->lock, flags); 00000734 00000735 while (!list_empty(&sdd->queue) 00000736 && !(sdd->state & SUSPND)) { 00000737 00000738 struct spi_message *msg; 00000739 00000740 msg = container_of(sdd->queue.next, struct spi_message, queue); 00000741 00000742 list_del_init(&msg->queue); 00000743 00000744 /* Set Xfer busy flag */ 00000745 sdd->state |= SPIBUSY; 00000746 00000747 spin_unlock_irqrestore(&sdd->lock, flags); 00000748 00000749 handle_msg(sdd, msg); 00000750 00000751 spin_lock_irqsave(&sdd->lock, flags); 00000752 00000753 sdd->state &= ~SPIBUSY; 00000754 } 00000755 00000756 spin_unlock_irqrestore(&sdd->lock, flags); 00000757 00000758 /* Free DMA channels */ 00000759 s3c2410_dma_free(sdd->tx_dmach, &s3c64xx_spi_dma_client); 00000760 s3c2410_dma_free(sdd->rx_dmach, &s3c64xx_spi_dma_client); 00000761 }

730行，申請(qǐng)DMA，關(guān)于DMA的就不說(shuō)，一是我對(duì)DMA沒(méi)什么了解，二是這里基本上用不到，后面就知道什么時(shí)候才會(huì)用到DMA。

735至754行，循環(huán)取出隊(duì)列里的message并調(diào)用749行的handle_msg函數(shù)進(jìn)行處理，handle_msg函數(shù)的定義如下：

00000568 static void handle_msg(struct s3c64xx_spi_driver_data *sdd, 00000569 struct spi_message *msg) 00000570 { 00000571 struct s3c64xx_spi_info *sci = sdd->cntrlr_info; 00000572 struct spi_device *spi = msg->spi; 00000573 struct s3c64xx_spi_csinfo *cs = spi->controller_data; 00000574 struct spi_transfer *xfer; 00000575 int status = 0, cs_toggle = 0; 00000576 u32 speed; 00000577 u8 bpw; 00000578 00000579 /* If Master's(controller) state differs from that needed by Slave */ 00000580 if (sdd->cur_speed != spi->max_speed_hz 00000581 || sdd->cur_mode != spi->mode 00000582 || sdd->cur_bpw != spi->bits_per_word) { 00000583 sdd->cur_bpw = spi->bits_per_word; 00000584 sdd->cur_speed = spi->max_speed_hz; 00000585 sdd->cur_mode = spi->mode; 00000586 s3c64xx_spi_config(sdd); 00000587 } 00000588 00000589 /* Map all the transfers if needed */ 00000590 if (s3c64xx_spi_map_mssg(sdd, msg)) { 00000591 dev_err(&spi->dev, 00000592 "Xfer: Unable to map message buffers!\n"); 00000593 status = -ENOMEM; 00000594 goto out; 00000595 } 00000596 00000597 /* Configure feedback delay */ 00000598 writel(cs->fb_delay & 0x3, sdd->regs + S3C64XX_SPI_FB_CLK); 00000599 00000600 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 00000601 00000602 unsigned long flags; 00000603 int use_dma; 00000604 00000605 INIT_COMPLETION(sdd->xfer_completion); 00000606 00000607 /* Only BPW and Speed may change across transfers */ 00000608 bpw = xfer->bits_per_word ? : spi->bits_per_word; 00000609 speed = xfer->speed_hz ? : spi->max_speed_hz; 00000610 00000611 if (bpw != sdd->cur_bpw || speed != sdd->cur_speed) { 00000612 sdd->cur_bpw = bpw; 00000613 sdd->cur_speed = speed; 00000614 s3c64xx_spi_config(sdd); 00000615 } 00000616 00000617 /* Polling method for xfers not bigger than FIFO capacity */ 00000618 00000619 if (xfer->len <= ((sci->fifo_lvl_mask >> 1) + 1)) 00000620 use_dma = 0; 00000621 else 00000622 use_dma = 1; 00000623 00000624 spin_lock_irqsave(&sdd->lock, flags); 00000625 00000626 /* Pending only which is to be done */ 00000627 sdd->state &= ~RXBUSY; 00000628 sdd->state &= ~TXBUSY; 00000629 00000630 enable_datapath(sdd, spi, xfer, use_dma); 00000631 00000632 /* Slave Select */ 00000633 enable_cs(sdd, spi); 00000634 00000635 /* Start the signals */ 00000636 S3C64XX_SPI_ACT(sdd); 00000637 00000638 spin_unlock_irqrestore(&sdd->lock, flags); 00000639 00000640 status = wait_for_xfer(sdd, xfer, use_dma); 00000641 00000642 /* Quiese the signals */ 00000643 S3C64XX_SPI_DEACT(sdd); 00000644 00000645 if (status) { 00000646 dev_err(&spi->dev, "I/O Error: " 00000647 "rx-%d tx-%d res:rx-%c tx-%c len-%d\n", 00000648 xfer->rx_buf ? 1 : 0, xfer->tx_buf ? 1 : 0, 00000649 (sdd->state & RXBUSY) ? 'f' : 'p', 00000650 (sdd->state & TXBUSY) ? 'f' : 'p', 00000651 xfer->len); 00000652 00000653 if (use_dma) { 00000654 if (xfer->tx_buf != NULL 00000655 && (sdd->state & TXBUSY)) 00000656 s3c2410_dma_ctrl(sdd->tx_dmach, 00000657 S3C2410_DMAOP_FLUSH); 00000658 if (xfer->rx_buf != NULL 00000659 && (sdd->state & RXBUSY)) 00000660 s3c2410_dma_ctrl(sdd->rx_dmach, 00000661 S3C2410_DMAOP_FLUSH); 00000662 } 00000663 00000664 goto out; 00000665 } 00000666 00000667 if (xfer->delay_usecs) 00000668 udelay(xfer->delay_usecs); 00000669 00000670 if (xfer->cs_change) { 00000671 /* Hint that the next mssg is gonna be 00000672 for the same device */ 00000673 if (list_is_last(&xfer->transfer_list, 00000674 &msg->transfers)) 00000675 cs_toggle = 1; 00000676 else 00000677 disable_cs(sdd, spi); 00000678 } 00000679 00000680 msg->actual_length += xfer->len; 00000681 00000682 flush_fifo(sdd); 00000683 } 00000684 00000685 out: 00000686 if (!cs_toggle || status) 00000687 disable_cs(sdd, spi); 00000688 else 00000689 sdd->tgl_spi = spi; 00000690 00000691 s3c64xx_spi_unmap_mssg(sdd, msg); 00000692 00000693 msg->status = status; 00000694 00000695 if (msg->complete) 00000696 msg->complete(msg->context); 00000697 }

函數(shù)很長(zhǎng)，580至587行，如果一路走來(lái)speed、bpw和mode的值與spi設(shè)備的不一致就調(diào)用s3c64xx_spi_config函數(shù)重新配置，s3c64xx_spi_config函數(shù)里面就是對(duì)SPI寄存器進(jìn)行設(shè)置的。

590至595行，關(guān)于DMA映射的，略過(guò)。

598行，設(shè)置feedback寄存器。

600行，遍歷每一個(gè)transfer。605行，又初始化一個(gè)完成量，注意這里與之前的那個(gè)完成量是不一樣的，這里的完成量只有使用DMA傳輸時(shí)才會(huì)用得到，接下來(lái)很快就可以看到。

608至615行，也是一些關(guān)于設(shè)置值的檢查。

619至622行，只有發(fā)送或者接收的數(shù)據(jù)長(zhǎng)度大于fifo的深度（這里是64個(gè)字節(jié)）設(shè)置use_dma為1，也即使用DMA進(jìn)行傳輸，否則不使用DMA。

630行，enable_datapath函數(shù)的定義為：

00000232 static void enable_datapath(struct s3c64xx_spi_driver_data *sdd, 00000233 struct spi_device *spi, 00000234 struct spi_transfer *xfer, int dma_mode) 00000235 { 00000236 struct s3c64xx_spi_info *sci = sdd->cntrlr_info; 00000237 void __iomem *regs = sdd->regs; 00000238 u32 modecfg, chcfg; 00000239 00000240 modecfg = readl(regs + S3C64XX_SPI_MODE_CFG); 00000241 modecfg&=~(S3C64XX_SPI_MODE_TXDMA_ON|S3C64XX_SPI_MODE_RXDMA_ON); 00000242 00000243 chcfg = readl(regs + S3C64XX_SPI_CH_CFG); 00000244 chcfg &= ~S3C64XX_SPI_CH_TXCH_ON; 00000245 00000246 if (dma_mode) { 00000247 chcfg &= ~S3C64XX_SPI_CH_RXCH_ON; 00000248 } else { 00000249 /* 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 */ 00000253 chcfg |= S3C64XX_SPI_CH_RXCH_ON; 00000254 writel(((xfer->len * 8 / sdd->cur_bpw) & 0xffff) 00000255 | S3C64XX_SPI_PACKET_CNT_EN, 00000256 regs + S3C64XX_SPI_PACKET_CNT); 00000257 } 00000258 00000259 if (xfer->tx_buf != NULL) { 00000260 sdd->state |= TXBUSY; 00000261 chcfg |= S3C64XX_SPI_CH_TXCH_ON; 00000262 if (dma_mode) { 00000263 modecfg |= S3C64XX_SPI_MODE_TXDMA_ON; 00000264 s3c2410_dma_config(sdd->tx_dmach, 1); 00000265 s3c2410_dma_enqueue(sdd->tx_dmach, (void *)sdd, 00000266 xfer->tx_dma, xfer->len); 00000267 s3c2410_dma_ctrl(sdd->tx_dmach, S3C2410_DMAOP_START); 00000268 } else { 00000269 unsigned char *buf = (unsigned char *) xfer->tx_buf; 00000270 int i = 0; 00000271 while (i < xfer->len) 00000272 writeb(buf[i++], regs + S3C64XX_SPI_TX_DATA); 00000273 } 00000274 } 00000275 00000276 if (xfer->rx_buf != NULL) { 00000277 sdd->state |= RXBUSY; 00000278 00000279 if (sci->high_speed && sdd->cur_speed >= 30000000UL 00000280 && !(sdd->cur_mode & SPI_CPHA)) 00000281 chcfg |= S3C64XX_SPI_CH_HS_EN; 00000282 00000283 if (dma_mode) { 00000284 modecfg |= S3C64XX_SPI_MODE_RXDMA_ON; 00000285 chcfg |= S3C64XX_SPI_CH_RXCH_ON; 00000286 writel(((xfer->len * 8 / sdd->cur_bpw) & 0xffff) 00000287 | S3C64XX_SPI_PACKET_CNT_EN, 00000288 regs + S3C64XX_SPI_PACKET_CNT); 00000289 s3c2410_dma_config(sdd->rx_dmach, 1); 00000290 s3c2410_dma_enqueue(sdd->rx_dmach, (void *)sdd, 00000291 xfer->rx_dma, xfer->len); 00000292 s3c2410_dma_ctrl(sdd->rx_dmach, S3C2410_DMAOP_START); 00000293 } 00000294 } 00000295 00000296 writel(modecfg, regs + S3C64XX_SPI_MODE_CFG); 00000297 writel(chcfg, regs + S3C64XX_SPI_CH_CFG); 00000298 }

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

246至257行，根據(jù)是否采用DMA模式設(shè)置接收計(jì)數(shù)寄存器。

259行，很早就為tx_buf分配內(nèi)存，因此條件成立。因?yàn)椴豢紤]DMA模式，因此略過(guò)262至268行。

269至272行，循環(huán)將發(fā)送數(shù)據(jù)寫入到發(fā)送寄存器。

276至294行，由于rx_buf為NULL，因此直接略過(guò)277至294行。

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

? ? ? 回到handle_msg函數(shù)，633行，選中從設(shè)備。636行，設(shè)置寄存器，開(kāi)始數(shù)據(jù)傳輸。

640行，wait_for_xfer函數(shù)的定義：

00000319 static int wait_for_xfer(struct s3c64xx_spi_driver_data *sdd, 00000320 struct spi_transfer *xfer, int dma_mode) 00000321 { 00000322 struct s3c64xx_spi_info *sci = sdd->cntrlr_info; 00000323 void __iomem *regs = sdd->regs; 00000324 unsigned long val; 00000325 int ms; 00000326 00000327 /* millisecs to xfer 'len' bytes @ 'cur_speed' */ 00000328 ms = xfer->len * 8 * 1000 / sdd->cur_speed; 00000329 ms += 10; /* some tolerance */ 00000330 00000331 if (dma_mode) { 00000332 val = msecs_to_jiffies(ms) + 10; 00000333 val = wait_for_completion_timeout(&sdd->xfer_completion, val); 00000334 } else { 00000335 u32 status; 00000336 val = msecs_to_loops(ms); 00000337 do { 00000338 status = readl(regs + S3C64XX_SPI_STATUS); 00000339 } while (RX_FIFO_LVL(status, sci) < xfer->len && --val); 00000340 } 00000341 00000342 if (!val) 00000343 return -EIO; 00000344 00000345 if (dma_mode) { 00000346 u32 status; 00000347 00000348 /* 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 */ 00000355 if (xfer->rx_buf == NULL) { 00000356 val = msecs_to_loops(10); 00000357 status = readl(regs + S3C64XX_SPI_STATUS); 00000358 while ((TX_FIFO_LVL(status, sci) 00000359 || !S3C64XX_SPI_ST_TX_DONE(status, sci)) 00000360 && --val) { 00000361 cpu_relax(); 00000362 status = readl(regs + S3C64XX_SPI_STATUS); 00000363 } 00000364 00000365 if (!val) 00000366 return -EIO; 00000367 } 00000368 } else { 00000369 unsigned char *buf; 00000370 int i; 00000371 00000372 /* If it was only Tx */ 00000373 if (xfer->rx_buf == NULL) { 00000374 sdd->state &= ~TXBUSY; 00000375 return 0; 00000376 } 00000377 00000378 i = 0; 00000379 buf = xfer->rx_buf; 00000380 while (i < xfer->len) 00000381 buf[i++] = readb(regs + S3C64XX_SPI_RX_DATA); 00000382 00000383 sdd->state &= ~RXBUSY; 00000384 } 00000385 00000386 return 0; 00000387 }

328行，根據(jù)發(fā)送速率計(jì)算需要等待的時(shí)間。331至334行，與DMA相關(guān)的，略過(guò)。

335至339行，不斷地讀狀態(tài)寄存器，如果接收到的數(shù)據(jù)長(zhǎng)度等于發(fā)送數(shù)據(jù)的長(zhǎng)度或超時(shí)則退出循環(huán)。

342、343行，如果是超時(shí)退出循環(huán)的，則返回出錯(cuò)。

345至368行，DMA相關(guān)的，略過(guò)。

369至383行，如果只是發(fā)送數(shù)據(jù)，則直接返回0。否則從接收寄存器里將接收到的數(shù)據(jù)讀出來(lái)。

? ? ? 回到handle_msg函數(shù)，643行，停止傳輸。645至665行，如果之前wait_for_xfer函數(shù)返回大于0的值，則表示出錯(cuò)，這里就打印一些信息。

667、668行，之前如果有設(shè)置延時(shí)的話這里就延時(shí)。

670至678行，是否需要每個(gè)transfer完成都改變片選信號(hào)。

680行，累加所有transfer成功發(fā)送的數(shù)據(jù)。

682行，清發(fā)送和接收寄存器。

691行，取消DMA映射。

693行，記錄狀態(tài)信息。

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

? ? ? 到這里，已經(jīng)說(shuō)了整個(gè)write過(guò)程，不容易啊！。其他的read/ioctl過(guò)程是大同小異的。

總結(jié)

? ? ? spidev.c是一個(gè)通用的SPI驅(qū)動(dòng)，因此它不處理任何有關(guān)具體驅(qū)動(dòng)的邏輯，這就需要在用戶空間來(lái)完成具體的邏輯。其實(shí)這符合了Android驅(qū)動(dòng)的思想，這也是Android HAL層存在的目的：內(nèi)核驅(qū)動(dòng)只完成硬件操作，具體邏輯放在HAL層，這樣就有利于保護(hù)廠家、開(kāi)發(fā)者的知識(shí)產(chǎn)權(quán)。

? ? ?在用戶空間使用ioctl就可以完成write、read操作。

《新程序員》：云原生和全面數(shù)字化實(shí)踐50位技術(shù)專家共同創(chuàng)作，文字、視頻、音頻交互閱讀

總結(jié)

以上是生活随笔為你收集整理的二十、SPI设备驱动及应用（一）的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。