SPI主要分主控制器及SPI设备两端，两者之间靠spi.h这个公共接口来作为抽象层。
首先来分析SPI总线：【本篇着重分析注册及匹配流程，下篇将会详细分析SPI master驱动的时序及实现方式】
===================================================================================================
spi bus
===================================================================================================
总线类型：
struct bus_type spi_bus_type = {
.name = "spi",
.dev_attrs = spi_dev_attrs,
.match = spi_match_device,
.uevent = spi_uevent,
.pm = &spi_pm,
};
注：这里的spi_bus_type没有实现probe函数，对下面的drv.probe有重要影响。
总线注册：【对应与/sys/bus/目录】
static int __init spi_init(void)
{
int status;
buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
status = bus_register(&spi_bus_type); //注册总线类型
status = class_register(&spi_master_class); //注册spi主控器类型
return 0;
}
spi主控器为一个device,为此类型
static struct class spi_master_class = {
.name = "spi_master",
.owner = THIS_MODULE,
.dev_release = spi_master_release,
};
整个spi master侧的设备及驱动都是依赖与平台驱动的，下面详细跟踪spi的整个注册流程:
以展讯平台的8810 spi master为例：
static struct platform_device sprd_spi_controller_device[] =
{
{
.name = "sprd_spi",
.id = 0,
.dev = {
.dma_mask = &spi_dmamask,
.coherent_dma_mask = DMA_BIT_MASK(32),
},
.resource = spi_resources[0],
.num_resources = ARRAY_SIZE(spi_resources[0]),
},
{
.name = "sprd_spi",
.id = 1,
.dev = {
.dma_mask = &spi_dmamask,
.coherent_dma_mask = DMA_BIT_MASK(32),
},
.resource = spi_resources[1],
.num_resources = ARRAY_SIZE(spi_resources[1]),
},
};
在8810中一共有两个spi master,由id来区别，下面是对应的MEM/IRQ资源：
static struct resource spi_resources[][2] = {
{
{
.start = SPRD_SPI0_PHYS,
.end = SPRD_SPI0_PHYS + SZ_4K - 1,
.flags = IORESOURCE_MEM,
},
{
.start = IRQ_SPI0_INT,
.end = IRQ_SPI0_INT,
.flags = IORESOURCE_IRQ,
},
},
{
{
.start = SPRD_SPI1_PHYS,
.end = SPRD_SPI1_PHYS + SZ_4K - 1,
.flags = IORESOURCE_MEM,
},
{
.start = IRQ_SPI1_INT,
.end = IRQ_SPI1_INT,
.flags = IORESOURCE_IRQ,
},
},
};
首先需要注册平台设备：
platform_device_register(&sprd_spi_controller_device[0]);
platform_device_register(&sprd_spi_controller_device[1]);
这一步主要的工作有：
1. 初始化platform_device的dev结构
2. 设置dev的dma相关
3. 挂接设备所属总线到platform_bus_type
4. 解析资源RES
5. 挂接dev到驱动模型
然后需要注册平台驱动：【在master的驱动实现中】
static struct platform_driver sprd_spi_driver = {
.driver = {
.name = "sprd_spi",
.owner = THIS_MODULE,
},
.suspend = sprd_spi_suspend,
.resume = sprd_spi_resume,
.remove = __exit_p(sprd_spi_remove),
};
初始化：
static int __init sprd_spi_init(void)
{
return platform_driver_probe(&sprd_spi_driver, sprd_spi_probe);
}
这一步主要的工作有：
1. 填入驱动真正的probe,并注册平台驱动【platform_driver_register】
2. 挂上平台总线platform_bus_type，检测驱动名称是否重复，加入bus【bus_add_driver】
3. 下面的事情是设备驱动模型里面的任务了，为驱动建立节点，建立私有driver_private，初始化设备链等
probe的详细过程见上一篇【设备驱动模型】。
4. 调用probe函数，进行匹配
4.1 int __init sprd_spi_probe(struct platform_device *pdev)，这里的参数来自于哪里呢？从上面的分析来看，很明显这个时候device/driver
都已经明确挂到了平台总线下，那么这里的平台设备为此驱动所属的bus下的所有设备。
4.2 在probe函数内部，可以区分也可以不区分具体的platform device, 这里分成两种模式：
a. 不同的spi master使用自己独立的master driver
b. 使用相同的spi master driver，但是需要生成两个master是必须的，并且由不同的bus_num来提供给device挂接
这里涉及到两个匹配的过程：
master device <-----> master driver
master driver <-----> spi slave
第一个过程可以由device的name + id来判断，并由id来转化成master的bus_num,第二个过程则直接由device的bus_num项与master匹配
4.3 生成具体的master后，需要挂接标准接口实现到spi master，如：setup/transfer/cleanup等
4.4 这里可以有两个数据位置值得注意，其一是master内部的private data，第二个是dev下的master
master = spi_alloc_master(&pdev->dev, sizeof *sprd_data);/spi_master_get_devdata(master);
platform_set_drvdata(pdev, master);/platform_get_drvdata(pdev);
4.5 还有就是一些资源的解析到private data中，设置dma 参数，中断及相关的变量/队列等
4.6 最重要的一个步骤，注册master到整个SPI系统中【注，不是bus!,master作为一个抽象，代表了spi的master端的所有功能及控制】
ret = spi_register_master(master);
a.初始化一些标准接口，如用于传输spi_message的消息队列
b.加入到全局链尾，spi_master_list
c.匹配已经存在的board_list链，并进行匹配，spi_match_master_to_boardinfo，这里主要进行两步操作：第一是匹配bus_num，第二步是
进行实际的slave与master的匹配工作，
struct spi_device *spi_new_device(struct spi_master *master, struct spi_board_info *chip)【分析在slave后面】
注：这里的触发spi_match_master_to_boardinfo流程的源头可能有两个：
1. 注册master:spi_register_master
2. 注册spi board:spi_register_board_info
系统为了SPI slave及master的匹配，声明了两个静态链表
static LIST_HEAD(board_list); 宿主为board_info->{list + spi_board_info}
static LIST_HEAD(spi_master_list); 宿主为spi_master【已包含list_head】
一个用于存储spi_board_info【slave端会详细描述】,一个用于存储master链。
slave端的device声明：
static struct spi_board_info openhone_spi_devices_wifi[] = {
{
.modalias = "spi_slot0", // "spidev" --> spidev_spi
.chip_select = SPRD_3RDPARTY_SPI_WIFI_CS,
//.max_speed_hz = 24 * 1000 * 1000, wch
.max_speed_hz = 8 * 1000 * 1000,
.mode = SPI_CPOL | SPI_CPHA,
},
};
slave端的注册流程：
1.标准做法
spi_register_board_info
2.展讯做法
gps_spi_dev = sprd_spi_wifi_device_register(1, NULL);
struct spi_device *sprd_spi_wifi_device_register(int master_bus_num, struct spi_board_info *chip)
{
return sprd_spi_device_register(master_bus_num, chip, SPRD_3RDPARTY_SPI_WIFI_CS);
}
struct spi_device *sprd_spi_device_register(int master_bus_num,struct spi_board_info *chip,int type)
展讯的实现流程较为混乱，梳理后的方式如下：【没有采用标准的做法】
一共需要两个参数：1. 与master相对应的bus_num; 2. 与spi_board_info spi slave device相对应的CS【每个设备需要一个独立的CS】
找到这两个设备后：
使用1获取到master结构体，使用2获取到spi_board_info结构体，直接调用 spi_new_device
标准的做法为：
只需要注册spi_register_board_info即可，相关的匹配流程交给kernel去匹配。【boardinfo中含有bus_num/cs等，不需要单独拿出来自己匹配】
至此：master与slave端都同时汇聚到了一起：spi_new_device，下面是这个函数的详细描述，
在spi_new_device中并没有判断是否已经生成spi proxy的代码，那么是否会同一个master/slave生成了两次proxy?
展讯的方法中，spi_board_info并没有注册到board_list中，故master不会匹配到，只有等到slave主动调用spi_new_device的时候才会成功匹配，
标准的方法中，总是后加入链的进行匹配的工作。
spi_new_device
这个函数调用的条件是:master与slave bus_num一致，进行两者之间的匹配
具体的工作如下：
1.生成一个父节点为master->dev的spi_device对象，并且master指向匹配的master结构【注意：这里将设备的bus指向 &spi_bus_type,后续对设备驱动有大的作用！，
而master指针则会负责后续的传输责任转发】
2.获取spi_board_info上的所有信息到spi_device对象中去
3.添加此spi_device设备到系统中去：spi_add_device
检查片选小于master支持的片选总数
设置名称为master->dev.name + cs_num
确认没有使用总线上其它设备已占用的cs号（从名称判断）【不管什么的master上配对的device都隶属于这条系统仅有的spi总线】
【这里有个问题：不同master上的cs号的范围不能重复？一般cs号即为gpio号，不会重复】
启动master接口，setup
添加device->dev到sys系统中去
以上都是在平台总线上的master device与driver的配对，master与slave的配对，这些对于一般的spi设备驱动开发人员都是透明的，下面来说
spi driver与spi device的配对过程：
static struct spi_driver gpsspidev_spi = {
.driver = {
.name = "spi_slot0",
.owner = THIS_MODULE,
},
.probe = gpsspidev_probe,
.remove = __devexit_p(mxdspidev_remove),
};
注册到系统中去：
major= spi_register_driver(&gpsspidev_spi);
主要完成如下工作：
首先设置其bus指向spi_bus_type,然后调用driver_register【加入到bus的driver链表中】
一般在加入device或者driver的时候都会调用：driver_attach/device_attach
Probe的详细过程见【设备驱动模型】
在匹配过程中__driver_attach，首先会调用spi bus type的match函数【最高匹配否认优先级】
其次是bus的probe【spi未实现，则调用driver本身的probe函数】，最后执行设备与驱动的绑定
probe成功后需要对驱动本生的一些成员进行初始化，代表我probe到设备后就要开始准备工作了。
SPI框架的match实现：
static int spi_match_device(struct device *dev, struct device_driver *drv)
{
const struct spi_device *spi = to_spi_device(dev);
const struct spi_driver *sdrv = to_spi_driver(drv);
/* Attempt an OF style match */
if (of_driver_match_device(dev, drv))
return 1;
if (sdrv->id_table)
return !!spi_match_id(sdrv->id_table, spi);
return strcmp(spi->modalias, drv->name) == 0;
}
先匹配driver的id table中的每一项中的名字是否与device匹配
其次匹配driver的name与device是否相配
一般的SPI slave驱动，直接名称匹配即可，不需要自己进行probe
在分析的过程中，想到这么几个问题：
总线类型与实际总线【master】的关系？
系统中不区分master的不同，而只有一条类型为spi_bus_type的spi总线，所有注册上来的设备(spi_device)及设备驱动(spi_driver)都隶属于
这条总线，这样可以对整个spi体系下的所有slave设备及驱动进行管理。
spi device是什么时候挂到spi_bus_type设备链中去的？
spi device指向总线spi_bus_type是在spi device初始化的时候做的
反向挂是在：初始化完成之后，device_add函数中通过 bus_add_device(dev);添加到spi总线中去的
如何访问spi设备以及访问过程中如何分发到master?
spi slave driver会自行封装spi message，并请求同步到slave,具体由slave挂接的master实现具体的分发功能。
这部分内容放在下一篇【SPI master驱动的时序及实现方式】详细讲解