linux设备模型之spi子系统
===============================
本文系本站原创,欢迎转载!
转载请注明出处:http://www.cnblogs.com/gdt-a20
===============================
相比于前面介绍的i2c子系统，spi子系统相对简单，和i2c的结构也很相似，这里主要介绍一下平台无关部分的代码。先概括的说一下，spi总线或者说是spi控制器用结构体struct spi_master来表述，而一般不会明显的主动实现这个结构而是借助板级的一些信息结构，利用spi的模型填充，存在板级信息的一条链表board_list，上面挂接着板级spi设备的描述信息，其挂接的结构是struct boardinfo，这个结构内部嵌入了具体的板级spi设备所需信息结构struct spi_board_info，对于要操控的spi设备，用struct spidev_data来描述，内嵌了具体设备信息结构struct spi_device，并通过struct spi_device->device_entry成员挂接到全局spi设备链表device_list，结构struct spi_device就是根据前面board_list上所挂的信息填充的，而driver端比较简单，用struct spi_driver来描述，一会儿会看到该结构和标准的platform非常相似，总括的说下一般编写流程：对于soc，spi控制器一般注册成platform，当driver匹配后，会根据platform_device等信息构造出spi_master，一般发生在driver的probe函数，并且注册该master，在master的注册过程中会去遍历board_list找到bus号相同的spi设备信息，并实例化它，好了先就说这么多，下面先看一下具体的数据结构。
一、spi相关的数据结构
先看一下spi设备的板级信息填充的结构：
1 struct boardinfo {
2 struct list_head list; //用于挂接到链表头board_list上
3 unsigned n_board_info; //设备信息号，spi_board_info成员的编号
4 struct spi_board_info board_info[0]; //内嵌的spi_board_info结构
5 };
6 //其中内嵌的描述spi设备的具体信息的结构struct spi_board_info为：
7 struct spi_board_info {
8 /* the device name and module name are coupled, like platform_bus;
9 * "modalias" is normally the driver name.
10 *
11 * platform_data goes to spi_device.dev.platform_data,
12 * controller_data goes to spi_device.controller_data,
13 * irq is copied too
14 */
15 char modalias[SPI_NAME_SIZE]; //名字
16 const void *platform_data; //如同注释写的指向spi_device.dev.platform_data
17 void *controller_data; //指向spi_device.controller_data
18 int irq; //中断号
19 /* slower signaling on noisy or low voltage boards */
20 u32 max_speed_hz; //时钟速率
21 /* bus_num is board specific and matches the bus_num of some
22 * spi_master that will probably be registered later.
23 *
24 * chip_select reflects how this chip is wired to that master;
25 * it's less than num_chipselect.
26 */
27 u16 bus_num; //所在的spi总线编号
28 u16 chip_select;
29 /* mode becomes spi_device.mode, and is essential for chips
30 * where the default of SPI_CS_HIGH = 0 is wrong.
31 */
32 u8 mode; //模式
33 /* ... may need additional spi_device chip config data here.
34 * avoid stuff protocol drivers can set; but include stuff
35 * needed to behave without being bound to a driver:
36 * - quirks like clock rate mattering when not selected
37 */
38 };
利用boardinfo->list成员会将自身挂接到全局的board_list链表上。
再来看一下spi控制器的表述结构：
1 struct spi_master {
2 struct device dev; //内嵌的标准dev结构
3 /* other than negative (== assign one dynamically), bus_num is fully
4 * board-specific. usually that simplifies to being SOC-specific.
5 * example: one SOC has three SPI controllers, numbered 0..2,
6 * and one board's schematics might show it using SPI-2. software
7 * would normally use bus_num=2 for that controller.
8 */
9 s16 bus_num; //标识的总线号
10 /* chipselects will be integral to many controllers; some others
11 * might use board-specific GPIOs.
12 */
13 u16 num_chipselect;
14 /* some SPI controllers pose alignment requirements on DMAable
15 * buffers; let protocol drivers know about these requirements.
16 */
17 u16 dma_alignment; //dma对其要求
18 /* spi_device.mode flags understood by this controller driver */
19 u16 mode_bits; //代表操作的spi_device.mode
20 /* other constraints relevant to this driver */
21 u16 flags; //另外的一些标志
22 #define SPI_MASTER_HALF_DUPLEX BIT(0) /* can't do full duplex */
23 #define SPI_MASTER_NO_RX BIT(1) /* can't do buffer read */
24 #define SPI_MASTER_NO_TX BIT(2) /* can't do buffer write */
25 /* lock and mutex for SPI bus locking */
26 spinlock_t bus_lock_spinlock;
27 struct mutex bus_lock_mutex;
28 /* flag indicating that the SPI bus is locked for exclusive use */
29 bool bus_lock_flag;
30 /* Setup mode and clock, etc (spi driver may call many times).
31 *
32 * IMPORTANT: this may be called when transfers to another
33 * device are active. DO NOT UPDATE SHARED REGISTERS in ways
34 * which could break those transfers.
35 */
36 int (*setup)(struct spi_device *spi); //设置模式
37 /* bidirectional bulk transfers
38 *
39 * + The transfer() method may not sleep; its main role is
40 * just to add the message to the queue.
41 * + For now there's no remove-from-queue operation, or
42 * any other request management
43 * + To a given spi_device, message queueing is pure fifo
44 *
45 * + The master's main job is to process its message queue,
46 * selecting a chip then transferring data
47 * + If there are multiple spi_device children, the i/o queue
48 * arbitration algorithm is unspecified (round robin, fifo,
49 * priority, reservations, preemption, etc)
50 *
51 * + Chipselect stays active during the entire message
52 * (unless modified by spi_transfer.cs_change != 0).
53 * + The message transfers use clock and SPI mode parameters
54 * previously established by setup() for this device
55 */
56 int (*transfer)(struct spi_device *spi, //传输函数
57 struct spi_message *mesg);
58 /* called on release() to free memory provided by spi_master */
59 void (*cleanup)(struct spi_device *spi);
60 };
而对于要操控的spi总线上的设备，其表述结构为：
1 struct spi_device {
2 struct device dev; //内嵌标准device结构体
3 struct spi_master *master; //spi主控制器
4 u32 max_speed_hz; //时钟速率
5 u8 chip_select; //设备编号
6 u8 mode; //模式
7 #define SPI_CPHA 0x01 /* clock phase */
8 #define SPI_CPOL 0x02 /* clock polarity */
9 #define SPI_MODE_0 (0|0) /* (original MicroWire) */
10 #define SPI_MODE_1 (0|SPI_CPHA)
11 #define SPI_MODE_2 (SPI_CPOL|0)
12 #define SPI_MODE_3 (SPI_CPOL|SPI_CPHA)
13 #define SPI_CS_HIGH 0x04 /* chipselect active high? */
14 #define SPI_LSB_FIRST 0x08 /* per-word bits-on-wire */
15 #define SPI_3WIRE 0x10 /* SI/SO signals shared */
16 #define SPI_LOOP 0x20 /* loopback mode */
17 #define SPI_NO_CS 0x40 /* 1 dev/bus, no chipselect */
18 #define SPI_READY 0x80 /* slave pulls low to pause */
19 u8 bits_per_word;
20 int irq; //中断号
21 void *controller_state; //控制状态
22 void *controller_data; //私有数据
23 char modalias[SPI_NAME_SIZE]; //名字
24 /*
25 * likely need more hooks for more protocol options affecting how
26 * the controller talks to each chip, like:
27 * - memory packing (12 bit samples into low bits, others zeroed)
28 * - priority
29 * - drop chipselect after each word
30 * - chipselect delays
31 * - ...
32 */
33 };
再看一下对于spi设备结构更高层次的表述结构：
1 struct spidev_data {
2 dev_t devt;
3 spinlock_t spi_lock;
4 struct spi_device *spi; //指向spi设备结构
5 struct list_head device_entry; //spi设备链表device_list挂接点
6 /* buffer is NULL unless this device is open (users > 0) */
7 struct mutex buf_lock;
8 unsigned users;
9 u8 *buffer;
10 };
而driver端的表述结构struct spi_driver，具体如下:
1 struct spi_driver {
2 const struct spi_device_id *id_table; //匹配的设备表
3 int (*probe)(struct spi_device *spi);
4 int (*remove)(struct spi_device *spi);
5 void (*shutdown)(struct spi_device *spi);
6 int (*suspend)(struct spi_device *spi, pm_message_t mesg);
7 int (*resume)(struct spi_device *spi);
8 struct device_driver driver;
9 };
是不是很标准？哈，好了，关于相关的数据结构就先介绍这么多。
二、spi核心代码的初始化分析
1 static int __init spi_init(void)
2 {
3 int status;
4
5 //其中buf为static u8 *buf,
6 //SPI_BUFSIZ为#define SPI_BUFSIZ max(32,SMP_CACHE_BYTES)
7 buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
8 if (!buf) {
9 status = -ENOMEM;
10 goto err0;
11 }
12
13 //注册spi_bus
14 status = bus_register(&spi_bus_type);
15 if (status < 0)
16 goto err1;
17
18 //在sys/class下产生spi_master这个节点，用于自动产生设备节点
19 //下面挂接的是控制器的节点
20 status = class_register(&spi_master_class);
21 if (status < 0)
22 goto err2;
23 return 0;
24 err2:
25 bus_unregister(&spi_bus_type);
26 err1:
27 kfree(buf);
28 buf = NULL;
29 err0:
30 return status;
31 }
32 //其中注册bus结构为
33 struct bus_type spi_bus_type = {
34 .name = "spi",
35 .dev_attrs = spi_dev_attrs,
36 .match = spi_match_device, //匹配函数
37 .uevent = spi_uevent,
38 .suspend = spi_suspend,
39 .resume = spi_resume,
40 };
41 //类函数为
42 static struct class spi_master_class = {
43 .name = "spi_master",
44 .owner = THIS_MODULE,
45 .dev_release = spi_master_release,
46 };
47 //顺便把driver与device的匹配函数也一起分析了吧，很简单
48 static int spi_match_device(struct device *dev, struct device_driver *drv)
49 {
50 const struct spi_device *spi = to_spi_device(dev);
51 const struct spi_driver *sdrv = to_spi_driver(drv);
52 /* Attempt an OF style match */
53
54 //利用of表进行匹配
55 if (of_driver_match_device(dev, drv))
56 return 1;
57
58 //利用id表进行匹配
59 if (sdrv->id_table)
60 return !!spi_match_id(sdrv->id_table, spi);
61
62 //利用名字进行匹配
63 return strcmp(spi->modalias, drv->name) == 0;
64 }
首先看一下spi总线的注册代码很简单，位于driver/spi/spi.c下：
再看一下driver的注册，spi_register_driver函数：
1 int spi_register_driver(struct spi_driver *sdrv)
2 {
3
4 //很类似于platfor的注册，很简单，
5 //就不具体介绍了
6 sdrv->driver.bus = &spi_bus_type;
7 if (sdrv->probe)
8 sdrv->driver.probe = spi_drv_probe;
9 if (sdrv->remove)
10 sdrv->driver.remove = spi_drv_remove;
11 if (sdrv->shutdown)
12 sdrv->driver.shutdown = spi_drv_shutdown;
13
14 //注册标准的driver，此时会去匹配bus设备链表上
15 //支持的device，找到会调用相应函数
16 return driver_register(&sdrv->driver);
17 }
还有个板级信息的添加函数：
1 int __init
2 spi_register_board_info(struct spi_board_info const *info, unsigned n)
3 {
4 struct boardinfo *bi;
5 bi = kmalloc(sizeof(*bi) + n * sizeof *info, GFP_KERNEL);
6 if (!bi)
7 return -ENOMEM;
8 bi->n_board_info = n;
9 memcpy(bi->board_info, info, n * sizeof *info);
10 mutex_lock(&board_lock);
11 list_add_tail(&bi->list, &board_list);
12 mutex_unlock(&board_lock);
13 return 0;
14 }
函数很简单，利用定义的spi_board_info信息，填充了boardinfo结构，并挂到board_list链表。
最后来看一下一个重量级函数，master的注册函数：
1 int spi_register_master(struct spi_master *master)
2 {
3 static atomic_t dyn_bus_id = ATOMIC_INIT((1<<15) - 1);
4 struct device *dev = master->dev.parent;
5 int status = -ENODEV;
6 int dynamic = 0;
7 //内嵌的标准设备结构必须初始化好
8 if (!dev)
9 return -ENODEV;
10 /* even if it's just one always-selected device, there must
11 * be at least one chipselect
12 */
13
14 //支持的设备数量为0，出错返回
15 if (master->num_chipselect == 0)
16 return -EINVAL;
17 /* convention: dynamically assigned bus IDs count down from the max */
18
19 if (master->bus_num < 0) {
20 /* FIXME switch to an IDR based scheme, something like
21 * I2C now uses, so we can't run out of "dynamic" IDs
22 */
23 //控制器编号（总线编号）不能小于0
24 master->bus_num = atomic_dec_return(&dyn_bus_id);
25 dynamic = 1;
26 }
27 spin_lock_init(&master->bus_lock_spinlock);
28 mutex_init(&master->bus_lock_mutex);
29 master->bus_lock_flag = 0;
30 /* register the device, then userspace will see it.
31 * registration fails if the bus ID is in use.
32 */
33
34 //设置master->dev的名字，形式为spi+bus_num,如：spi0
35 dev_set_name(&master->dev, "spi%u", master->bus_num);
36
37 //注册master内嵌的标准device结构
38 status = device_add(&master->dev);
39 if (status < 0)
40 goto done;
41 dev_dbg(dev, "registered master %s%s/n", dev_name(&master->dev),
42 dynamic ? " (dynamic)" : "");
43 /* populate children from any spi device tables */
44
45 //重点哦，扫描并实例化spi设备
46 scan_boardinfo(master);
47 status = 0;
48 /* Register devices from the device tree */
49 of_register_spi_devices(master);
50 done:
51 return status;
52 }
53 //先来看scan_boardinfo这个分支
54 static void scan_boardinfo(struct spi_master *master)
55 {
56 struct boardinfo *bi;
57 mutex_lock(&board_lock);
58
59 //找到我们注册的spi相关的板级信息结构体
60 //还记得board_list吧
61 list_for_each_entry(bi, &board_list, list) {
62 struct spi_board_info *chip = bi->board_info;
63 unsigned n;
64
65 //因为可能存在多个spi总线，因此spi信息结构也会有
66 //多个，找到bus号匹配的就对了
67 for (n = bi->n_board_info; n > 0; n--, chip++) {
68 if (chip->bus_num != master->bus_num)
69 continue;
70 /* NOTE: this relies on spi_new_device to
71 * issue diagnostics when given bogus inputs
72 */
73
74 //找到了就要实例化它上面的设备了
75 (void) spi_new_device(master, chip);
76 }
77 }
78 mutex_unlock(&board_lock);
79 }
80 //跟进spi_new_device函数
81 struct spi_device *spi_new_device(struct spi_master *master,
82 struct spi_board_info *chip)
83 {
84 struct spi_device *proxy;
85 int status;
86 /* NOTE: caller did any chip->bus_num checks necessary.
87 *
88 * Also, unless we change the return value convention to use
89 * error-or-pointer (not NULL-or-pointer), troubleshootability
90 * suggests syslogged diagnostics are best here (ugh).
91 */
92
93 //为需要实例化的设备分配内存
94 //同时会将bus成员制定为spi_bus_type，parent
95 //指定为该master，层次关系
96 proxy = spi_alloc_device(master);
97 if (!proxy)
98 return NULL;
99 WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
100 //各个成员赋值，都是用我们注册的板级信息
101 proxy->chip_select = chip->chip_select;
102 proxy->max_speed_hz = chip->max_speed_hz;
103 proxy->mode = chip->mode;
104 proxy->irq = chip->irq;
105 strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));
106 proxy->dev.platform_data = (void *) chip->platform_data;
107 proxy->controller_data = chip->controller_data;
108 proxy->controller_state = NULL;
109
110 //把该设备添加到spi总线
111 status = spi_add_device(proxy);
112 if (status < 0) {
113 spi_dev_put(proxy);
114 return NULL;
115 }
116 return proxy;
117 }
118 //继续spi_add_device函数
119 int spi_add_device(struct spi_device *spi)
120 {
121 static DEFINE_MUTEX(spi_add_lock);
122 struct device *dev = spi->master->dev.parent;
123 struct device *d;
124 int status;
125 /* Chipselects are numbered 0..max; validate. */
126
127 //spi设备的编号不能大于master定义的最大数目
128 if (spi->chip_select >= spi->master->num_chipselect) {
129 dev_err(dev, "cs%d >= max %d/n",
130 spi->chip_select,
131 spi->master->num_chipselect);
132 return -EINVAL;
133 }
134 /* Set the bus ID string */
135 //设备节点名字，形式：spi0.0
136 dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),
137 spi->chip_select);
138
139 /* We need to make sure there's no other device with this
140 * chipselect **BEFORE** we call setup(), else we'll trash
141 * its configuration. Lock against concurrent add() calls.
142 */
143 mutex_lock(&spi_add_lock);
144
145 //确保设备不会重复注册
146 d = bus_find_device_by_name(&spi_bus_type, NULL, dev_name(&spi->dev));
147 if (d != NULL) {
148 dev_err(dev, "chipselect %d already in use/n",
149 spi->chip_select);
150 put_device(d);
151 status = -EBUSY;
152 goto done;
153 }
154 /* Drivers may modify this initial i/o setup, but will
155 * normally rely on the device being setup. Devices
156 * using SPI_CS_HIGH can't coexist well otherwise...
157 */
158
159 //设置spi模式和时钟速率
160 //会调用spi->master->setup函数设置
161 status = spi_setup(spi);
162 if (status < 0) {
163 dev_err(dev, "can't %s %s, status %d/n",
164 "setup", dev_name(&spi->dev), status);
165 goto done;
166 }
167 /* Device may be bound to an active driver when this returns */
168
169 //将该实例化的设备添加到总线
170 status = device_add(&spi->dev);
171 if (status < 0)
172 dev_err(dev, "can't %s %s, status %d/n",
173 "add", dev_name(&spi->dev), status);
174 else
175 dev_dbg(dev, "registered child %s/n", dev_name(&spi->dev));
176 done:
177 mutex_unlock(&spi_add_lock);
178 return status;
179 }
180 //最后看下spi_setup函数
181 int spi_setup(struct spi_device *spi)
182 {
183 unsigned bad_bits;
184 int status;
185 /* help drivers fail *cleanly* when they need options
186 * that aren't supported with their current master
187 */
188
189 //必须和当前的master设置的模式匹配
190 bad_bits = spi->mode & ~spi->master->mode_bits;
191 if (bad_bits) {
192 dev_dbg(&spi->dev, "setup: unsupported mode bits %x/n",
193 bad_bits);
194 return -EINVAL;
195 }
196 if (!spi->bits_per_word)
197 spi->bits_per_word = 8;
198
199 //最后调用控制器平台相关的setup成员设置该spi设备
200 status = spi->master->setup(spi);
201 dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s"
202 "%u bits/w, %u Hz max --> %d/n",
203 (int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
204 (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
205 (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
206 (spi->mode & SPI_3WIRE) ? "3wire, " : "",
207 (spi->mode & SPI_LOOP) ? "loopback, " : "",
208 spi->bits_per_word, spi->max_speed_hz,
209 status);
210 return status;
211 }
212 //回头看下一开始下面的那个分支of_register_spi_devices
213 void of_register_spi_devices(struct spi_master *master)
214 {
215 struct spi_device *spi;
216 struct device_node *nc;
217 const __be32 *prop;
218 int rc;
219 int len;
220 //如果定义了of_node成员才会走该分支
221 if (!master->dev.of_node)
222 return;
223
224 //从控制器master->dev.of_node中去获取注册SPI设备spi_device的信息，然
225 //后分配结构体spi_device并注册
226 for_each_child_of_node(master->dev.of_node, nc) {
227 /* Alloc an spi_device */
228 spi = spi_alloc_device(master);
229 if (!spi) {
230 dev_err(&master->dev, "spi_device alloc error for %s/n",
231 nc->full_name);
232 spi_dev_put(spi);
233 continue;
234 }
235 /* Select device driver */
236 if (of_modalias_node(nc, spi->modalias,
237 sizeof(spi->modalias)) < 0) {
238 dev_err(&master->dev, "cannot find modalias for %s/n",
239 nc->full_name);
240 spi_dev_put(spi);
241 continue;
242 }
243 /* Device address */
244 prop = of_get_property(nc, "reg", &len);
245 if (!prop || len < sizeof(*prop)) {
246 dev_err(&master->dev, "%s has no 'reg' property/n",
247 nc->full_name);
248 spi_dev_put(spi);
249 continue;
250 }
251 spi->chip_select = be32_to_cpup(prop);
252 /* Mode (clock phase/polarity/etc.) */
253 if (of_find_property(nc, "spi-cpha", NULL))
254 spi->mode |= SPI_CPHA;
255 if (of_find_property(nc, "spi-cpol", NULL))
256 spi->mode |= SPI_CPOL;
257 if (of_find_property(nc, "spi-cs-high", NULL))
258 spi->mode |= SPI_CS_HIGH;
259 /* Device speed */
260 prop = of_get_property(nc, "spi-max-frequency", &len);
261 if (!prop || len < sizeof(*prop)) {
262 dev_err(&master->dev, "%s has no 'spi-max-frequency' property/n",
263 nc->full_name);
264 spi_dev_put(spi);
265 continue;
266 }
267 spi->max_speed_hz = be32_to_cpup(prop);
268 /* IRQ */
269 spi->irq = irq_of_parse_and_map(nc, 0);
270 /* Store a pointer to the node in the device structure */
271 of_node_get(nc);
272 spi->dev.of_node = nc;
273 /* Register the new device */
274 request_module(spi->modalias);
275 rc = spi_add_device(spi);
276 if (rc) {
277 dev_err(&master->dev, "spi_device register error %s/n",
278 nc->full_name);
279 spi_dev_put(spi);
280 }
281 }
282 }
三、spi设备文件的自动产生代码分析
这部分代码相当于注册了一个spi实际driver，既是核心平台无关代码，又是个具体实例，我们来看下一下具体做了什么，也好学习一spi_driver的各部分具体都需要做些什么,代码位于driver/spi/spidev.c下：
1 static int __init spidev_init(void)
2 {
3 int status;
4 /* Claim our 256 reserved device numbers. Then register a class
5 * that will key udev/mdev to add/remove /dev nodes. Last, register
6 * the driver which manages those device numbers.
7 */
8 BUILD_BUG_ON(N_SPI_MINORS > 256);
9
10 //注册主设备号为153的spi字符设备，spidev_fops结构下面会介绍
11 //暂且不表
12 status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
13 if (status < 0)
14 return status;
15 //在sys/class下产生spidev这个节点，udev会利用其在dev下产生spidev
16 //这个设备节点
17 spidev_class = class_create(THIS_MODULE, "spidev");
18 if (IS_ERR(spidev_class)) {
19 unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
20 return PTR_ERR(spidev_class);
21 }
22 //注册spi驱动，该函数上面已经分析过
23 status = spi_register_driver(&spidev_spi_driver);
24 if (status < 0) {
25 class_destroy(spidev_class);
26 unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
27 }
28 return status;
29 }
30 //先看一下spidev_spi_driver具体的结构
31 static struct spi_driver spidev_spi_driver = {
32 .driver = {
33 .name = "spidev",
34 .owner = THIS_MODULE,
35 },
36 .probe = spidev_probe,
37 .remove = __devexit_p(spidev_remove),
38 /* NOTE: suspend/resume methods are not necessary here.
39 * We don't do anything except pass the requests to/from
40 * the underlying controller. The refrigerator handles
41 * most issues; the controller driver handles the rest.
42 */
43 };
44 //利用bus的match函数匹配成功后将首先调用spidev_probe函数，我们具体看下该函数：
45 static int __devinit spidev_probe(struct spi_device *spi)
46 {
47 struct spidev_data *spidev;
48 int status;
49 unsigned long minor;
50 /* Allocate driver data */
51
52 //申请spidev_data所需内存，前面已经讲过该结构
53 spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
54 if (!spidev)
55 return -ENOMEM;
56 /* Initialize the driver data */
57 //赋值
58 spidev->spi = spi;
59 spin_lock_init(&spidev->spi_lock);
60 mutex_init(&spidev->buf_lock);
61 INIT_LIST_HEAD(&spidev->device_entry);
62 /* If we can allocate a minor number, hook up this device.
63 * Reusing minors is fine so long as udev or mdev is working.
64 */
65 mutex_lock(&device_list_lock);
66
67 //找到一个最小的次设备号
68 //addr为内存区的起始地址，size为要查找的最大长度
69 //返回第一个位为0的位号
70 minor = find_first_zero_bit(minors, N_SPI_MINORS);
71 if (minor < N_SPI_MINORS) {
72 struct device *dev;
73
74 //下面两句用于在sys/class/spidev下产生类似于
75 //spidev%d.%d形式的节点，这样，udev等工具就可以
76 //自动在dev下创建相应设备号的设备节点
77 spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
78 dev = device_create(spidev_class, &spi->dev, spidev->devt,
79 spidev, "spidev%d.%d",
80 spi->master->bus_num, spi->chip_select);
81 status = IS_ERR(dev) ? PTR_ERR(dev) : 0;
82 } else {
83 dev_dbg(&spi->dev, "no minor number available!/n");
84 status = -ENODEV;
85 }
86
87 //如果成功标明刚才的次设备号已被占用
88 //并且将该设备挂接到device_list链表
89 if (status == 0) {
90 set_bit(minor, minors);
91 list_add(&spidev->device_entry, &device_list);
92 }
93 mutex_unlock(&device_list_lock);
94 //设置spi->dev->p = spidev
95 if (status == 0)
96 spi_set_drvdata(spi, spidev);
97 else
98 kfree(spidev);
99 return status;
100 }
当我们利用板级信息添加一个设备的时候，该driver如果匹配到这个设备，那么就会自动为其创建设备节点，封装spidev_data
信息，并且挂到全局设备链表device_list。
最后看一下刚才注册的字符设备的统一操作集：
1 static const 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 };
13 //按应用的操作顺序先看下open函数
14 static int spidev_open(struct inode *inode, struct file *filp)
15 {
16 struct spidev_data *spidev;
17 int status = -ENXIO;
18 mutex_lock(&device_list_lock);
19
20 //遍历spi设备链表device_list，根据设备号找到spidev_data结构
21 list_for_each_entry(spidev, &device_list, device_entry) {
22 if (spidev->devt == inode->i_rdev) {
23 status = 0;
24 break;
25 }
26 }
27 if (status == 0) {
28 //buffer为空，为其申请内存
29 if (!spidev->buffer) {
30 spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);
31 if (!spidev->buffer) {
32 dev_dbg(&spidev->spi->dev, "open/ENOMEM/n");
33 status = -ENOMEM;
34 }
35 }
36
37 //设备用户使用量+1
38 if (status == 0) {
39 spidev->users++;
40
41 //传到filp的私有成员，在read，write的时候可以从其得到该结构
42 filp->private_data = spidev;
43 nonseekable_open(inode, filp);
44 }
45 } else
46 pr_debug("spidev: nothing for minor %d/n", iminor(inode));
47 mutex_unlock(&device_list_lock);
48 return status;
49 }
50 //再看read函数
51 static ssize_t
52 spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
53 {
54 struct spidev_data *spidev;
55 ssize_t status = 0;
56 /* chipselect only toggles at start or end of operation */
57 if (count > bufsiz)
58 return -EMSGSIZE;
59
60 //得到传递的结构
61 spidev = filp->private_data;
62 mutex_lock(&spidev->buf_lock);
63
64 //调用具体的读函数
65 status = spidev_sync_read(spidev, count);
66 if (status > 0) {
67 unsigned long missing;
68 //将得到的信息传递给用户
69 missing = copy_to_user(buf, spidev->buffer, status);
70 if (missing == status)
71 status = -EFAULT;
72 else
73 status = status - missing;
74 }
75 mutex_unlock(&spidev->buf_lock);
76 return status;
77 }
78 //跟进spidev_sync_read函数，下面的操作比较直白，简要分析下
79 //只关注主流程
80 static inline ssize_t
81 spidev_sync_read(struct spidev_data *spidev, size_t len)
82 {
83 //临时传输操作结构
84 struct spi_transfer t = {
85 .rx_buf = spidev->buffer,
86 .len = len,
87 };
88
89 //传输所用的信息结构
90 struct spi_message m;
91 //初始化该结构
92 spi_message_init(&m);
93 //加到请求队列尾
94 spi_message_add_tail(&t, &m);
95 //调用spidev_sync继续
96 return spidev_sync(spidev, &m);
97 }
98 //继续spidev_sync函数
99 static ssize_t
100 spidev_sync(struct spidev_data *spidev, struct spi_message *message)
101 {
102 DECLARE_COMPLETION_ONSTACK(done);
103 int status;
104 message->complete = spidev_complete;
105 //设置个完成量
106 message->context = &done;
107 spin_lock_irq(&spidev->spi_lock);
108 if (spidev->spi == NULL)
109 status = -ESHUTDOWN;
110 else
111 //继续调用spi_async函数
112 status = spi_async(spidev->spi, message);
113 spin_unlock_irq(&spidev->spi_lock);
114 if (status == 0) {
115 //等待完成
116 wait_for_completion(&done);
117 status = message->status;
118 if (status == 0)
119 status = message->actual_length;
120 }
121 return status;
122 }
123 //spi_async函数
124 int spi_async(struct spi_device *spi, struct spi_message *message)
125 {
126 struct spi_master *master = spi->master;
127 int ret;
128 unsigned long flags;
129 spin_lock_irqsave(&master->bus_lock_spinlock, flags);
130 if (master->bus_lock_flag)
131 ret = -EBUSY;
132 else
133 //好长...继续跟进
134 ret = __spi_async(spi, message);
135 spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
136 return ret;
137 }
138 //__spi_async函数
139 static int __spi_async(struct spi_device *spi, struct spi_message *message)
140 {
141 struct spi_master *master = spi->master;
142 /* Half-duplex links include original MicroWire, and ones with
143 * only one data pin like SPI_3WIRE (switches direction) or where
144 * either MOSI or MISO is missing. They can also be caused by
145 * software limitations.
146 */
147 if ((master->flags & SPI_MASTER_HALF_DUPLEX)
148 || (spi->mode & SPI_3WIRE)) {
149 struct spi_transfer *xfer;
150 unsigned flags = master->flags;
151 list_for_each_entry(xfer, &message->transfers, transfer_list) {
152 if (xfer->rx_buf && xfer->tx_buf)
153 return -EINVAL;
154 if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
155 return -EINVAL;
156 if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
157 return -EINVAL;
158 }
159 }
160 message->spi = spi;
161 message->status = -EINPROGRESS;
162
163 //最后调用master->transfer具体的平台相关的结构
164 return master->transfer(spi, message);
165 }
read函数就分析到此，至于write函数就不具体分析了，流程是相似的！
四、总结
根据前面的积累，这次简要分析了下spi设备驱动的模型，由于和i2c很相似，就不给出具体框图了，后面有时间会结合具体平台分析一下spi的实例，这次就到这里了 @^.^@
