Linux芯片级移植与底层驱动(基于3.7.4内核).doc

1.   SoC Linux底层驱动的组成和现状
为了让Linux在一个全新的ARM SoC上运行，需要提供大量的底层支撑，如定时器节拍、中断控制器、SMP启动、CPU hotplug以及底层的GPIO、clock、pinctrl和DMA硬件的封装等。定时器节拍、中断控制器、SMP启动和CPU hotplug这几部分相对来说没有像早期GPIO、clock、pinctrl和DMA的实现那么杂乱，基本上有个固定的套路。定时器节拍为Linux基于时间片的调度机制以及内核和用户空间的定时器提供支撑，中断控制器的驱动则使得Linux内核的工程师可以直接调用local_irq_disable()、disable_irq()等通用的中断API，而SMP启动支持则用于让SoC内部的多个CPU核都投入运行，CPU hotplug则运行运行时挂载或拔除CPU。这些工作，在Linux 3.7内核中，进行了良好的层次划分和架构设计。
在GPIO、clock、pinctrl和DMA驱动方面，Linux 2.6时代，内核已或多或少有GPIO、clock等底层驱动的架构，但是核心层的代码太薄弱，各SoC对这些基础设施实现方面存在巨大差异,而且每个SoC仍然需要实现大量的代码。pinctrl和DMA则最为混乱，几乎各家公司都定义了自己的独特的实现和API。
社区必须改变这种局面，于是内核社区在2011～2012年进行了如下工作，这些工作在目前的3.7内核中基本准备就绪：
§  ST-Ericsson的工程师Linus Walleij提供了新的pinctrl驱动架构，内核新增加一个drivers/pinctrl目录，支撑SoC上的引脚复用，各个SoC的实现代码统一放入该目录；
§  TI的工程师Mike Turquette提供了common clk框架，让具体SoC实现clk_ops成员函数并通过clk_register、clk_register_clkdev注册时钟源以及源与设备对应关系，具体的clock驱动都统一迁移到drivers/clk目录；
§  建议各SoC统一采用dmaengine架构实现DMA驱动，该架构提供了通用的DMA通道API如dmaengine_prep_slave_single()、dmaengine_submit()等，要求SoC实现dma_device的成员函数 ，实现代码统一放入drivers/dma目录；
§  在GPIO方面，drivers/gpio下的gpiolib已能与新的pinctrl完美共存，实现引脚的GPIO和其他功能之间的复用，具体的SoC只需实现通用的gpio_chip结构体的成员函数。
经过以上工作，基本上就把芯片底层的基础架构方面的驱动的架构统一了，实现方法也统一了。另外，目前GPIO、clock、pinmux等功能都能良好的进行Device Tree的映射处理，譬如我们可以方面的在.dts中定义一个设备要的时钟、pinmux引脚以及GPIO。
除了上述基础设施以外，在将Linux移植入新的SoC过程中，工程师常常强烈依赖于早期的printk功能，内核则提供了相关的DEBUG_LL和EARLY_PRINTK支持，只需要SoC提供商实现少量的callback或宏。
本文主要对上述各个组成部分进行架构上的剖析以及关键的实现部分的实例分析，以求完整归纳将Linux移植入新SoC的主要工作。本文基于3.7.4内核。
2.   用于操作系统节拍的timer驱动
Linux 2.6的早期（2.6.21之前）基于tick设计，一般SoC公司在将Linux移植到自己的芯片上的时候，会从芯片内部找一个定时器，并将该定时器配置会HZ的频率，在每个时钟节拍到来时，调用ARM Linux内核核心层的timer_tick()函数，从而引发系统里的一系列行为。如2.6.17中arch/arm/mach-s3c2410/time.c的做法是：
127/*
128 * IRQ handler for the timer
129 */
130static irqreturn_t
131s3c2410_timer_interrupt(int irq, void*dev_id, struct pt_regs *regs)
132{
133       write_seqlock(&xtime_lock);
134       timer_tick(regs);
135       write_sequnlock(&xtime_lock);
136       return IRQ_HANDLED;
137}
138
139static struct irqaction s3c2410_timer_irq ={
140       .name           = "S3C2410Timer Tick",
141       .flags          = SA_INTERRUPT | SA_TIMER,
142       .handler        =s3c2410_timer_interrupt,
143};
252staticvoid __init s3c2410_timer_init (void)
253{
254       s3c2410_timer_setup();
255       setup_irq(IRQ_TIMER4, &s3c2410_timer_irq);
256}
257
当前Linux多采用tickless方案，并支持高精度定时器，内核的配置一般会使能NO_HZ（即tickless，或者说动态tick）和HIGHRES_TIMERS。要强调的是tickless并不是说系统中没有时钟节拍了，而是说这个节拍不再像以前那样，周期性地产生。Tickless意味着，根据系统的运行情况，以事件驱动的方式动态决定下一个tick在何时发生。如果画一个时间轴，周期节拍的系统tick中断发生的时序看起来如下：

而NO_HZ的Linux看起来则是，2次定时器中断发生的时间间隔可长可短：

在当前的Linux系统中，SoC底层的timer被实现为一个clock_event_device和clocksource形式的驱动。在clock_event_device结构体中，实现其set_mode()和set_next_event()成员函数；在clocksource结构体中，主要实现read()成员函数。而定时器中断服务程序中，不再调用timer_tick()，而是调用clock_event_device的event_handler()成员函数。一个典型的SoC的底层tick定时器驱动形如：
61static irqreturn_t xxx_timer_interrupt(intirq, void *dev_id)
62{
63       struct clock_event_device *ce = dev_id;
65       …
70       ce-e);
71
72       return IRQ_HANDLED;
73}
74
75/* read 64-bit timer counter */
76static cycle_t xxx_timer_read(structclocksource *cs)
77{
78       u64 cycles;
79
80       /* read the 64-bit timer counter */
81       cycles = readl_relaxed(xxx_timer_base + XXX_TIMER_LATCHED_HI);
83       cycles = (cycles < readl relaxedxxx_timer_base XXX_TIMER_LATCHED_LOp>
84
85       return cycles;
86}
87
88static int xxx_timer_set_next_event(unsignedlongdelta,
89       struct clock_event_device *ce)
90{
91       unsigned long now, next;
92
93       writel_relaxed(XXX_TIMER_LATCH_BIT, xxx_timer_base + XXX_TIMER_LATCH);
94       now = readl_relaxed(xxx_timer_base + XXX_TIMER_LATCHED_LO);
95       next = now + delta;
96       writel_relaxed(next, xxx_timer_base + SIRFSOC_TIMER_MATCH_0);
97       writel_relaxed(XXX_TIMER_LATCH_BIT, xxx_timer_base + XXX_TIMER_LATCH);
98       now = readl_relaxed(xxx_timer_base + XXX_TIMER_LATCHED_LO);
99
100       return next - now < delta ? -ETIME : 0;
101}
102
103static void xxx_timer_set_mode(enumclock_event_mode mode,
104       struct clock_event_device *ce)
105{
107       switch (mode) {
108       case CLOCK_EVT_MODE_PERIODIC:
109                …
111       case CLOCK_EVT_MODE_ONESHOT:
112                …
114       case CLOCK_EVT_MODE_SHUTDOWN:
115               …
117       case CLOCK_EVT_MODE_UNUSED:
118       case CLOCK_EVT_MODE_RESUME:
119                break;
120       }
121}
144static struct clock_event_device xxx_clockevent= {
145       .name = "xxx_clockevent",
146       .rating = 200,
147       .features = CLOCK_EVT_FEAT_ONESHOT,
148       .set_mode = xxx_timer_set_mode,
149       .set_next_event = xxx_timer_set_next_event,
150};
151
152static struct clocksource xxx_clocksource ={
153       .name = "xxx_clocksource",
154        .rating = 200,
155       .mask = CLOCKSOURCE_MASK(64),
156       .flags = CLOCK_SOURCE_IS_CONTINUOUS,
157       .read = xxx_timer_read,
158       .suspend = xxx_clocksource_suspend,
159       .resume = xxx_clocksource_resume,
160};
161
162static struct irqaction xxx_timer_irq = {
163       .name = "xxx_tick",
164       .flags = IRQF_TIMER,
165       .irq = 0,
166       .handler = xxx_timer_interrupt,
167       .dev_id = &xxx_clockevent,
168};
169
176static void __init xxx_clockevent_init(void)
177{
178       clockevents_calc_mult_shiftxxx_clockevent, CLOCK_TICK_RATE, 60);
179
180       xxx_clockevent.max_delta_ns =
181                clockevent_delta2ns(-2, &xxx_clockevent);
182       xxx_clockevent.min_delta_ns =
183                clockevent_delta2ns(2, &xxx_clockevent);
184
185       xxx_clockevent.cpumask = cpumask_of(0);
186       clockevents_register_device(&xxx_clockevent);
187}
188
189/* initialize the kernel jiffy timer source*/
190static void __init xxx_timer_init(void)
191{
192       …
214
215       BUG_ON(clocksource_register_hz(&xxx_clocksource, CLOCK_TICK_RATE));
218
219       BUG_ON(setup_irq(xxx_timer_irq.irq,&xxx_timer_irq));
220
221       xxx_clockevent_init();
222}
249struct sys_timer xxx_timer = {
250       .init = xxx_timer_init,
251};
上述代码中，我们特别关注其中的如下函数：
clock_event_device的set_next_event 成员函数xxx_timer_set_next_event()
该函数的delta参数是Linux内核传递给底层定时器的一个差值，它的含义是下一次tick中断产生的硬件定时器中计数器counter的值相对于当前counter的差值。我们在该函数中将硬件定时器设置为在“当前counter计数值” + delta的时刻产生下一次tick中断。xxx_clockevent_init()函数中设置了可接受的最小和最大delta值对应的纳秒数，即xxx_clockevent.min_delta_ns和xxx_clockevent.max_delta_ns。
clocksource 的read成员函数xxx_timer_read()
该函数可读取出从开机以来到当前时刻定时器计数器已经走过的值，无论有没有设置计数器达到某值的时候产生中断，硬件的计数总是在进行的。因此，该函数给Linux系统提供了一个底层的准确的参考时间。
定时器的中断服务程序xxx_timer_interrupt()
在该中断服务程序中，直接调用clock_event_device的event_handler()成员函数，event_handler()成员函数的具体工作也是Linux内核根据Linux内核配置和运行情况自行设置的。
clock_event_device的set_mode成员函数 xxx_timer_set_mode()
用于设置定时器的模式以及resume和shutdown等功能，目前一般采用ONESHOT模式，即一次一次产生中断。当然新版的Linux也可以使用老的周期性模式，如果内核编译的时候未选择NO_HZ,该底层的timer驱动依然可以为内核的运行提供支持。
这些函数的结合，使得ARM Linux内核底层所需要的时钟得以运行。下面举一个典型的场景，假定定时器的晶振时钟频率为1MHz（即计数器每加1等于1us），应用程序透过nanosleep() API睡眠100us，内核会据此换算出下一次定时器中断的delta值为100，并间接调用到xxx_timer_set_next_event()去设置硬件让其在100us后产生中断。100us后，中断产生，xxx_timer_interrupt()被调用，event_handler()会间接唤醒睡眠的进程导致nanosleep()函数返回，从而用户进程继续。
这里特别要强调的是，对于多核处理器来说，一般的做法是给每个核分配一个独立的定时器，各个核根据自身的运行情况动态设置自己时钟中断发生的时刻。看看我们说运行的电脑的local timer中断即知：
barry@barry-VirtualBox:~$cat /proc/interrupts
CPU0       CPU1       CPU2       CPU3      
…
20:       945          0          0          0  IO-APIC-fasteoi   vboxguest

21:      4456          0          0     21592   IO-APIC-fasteoi   ahci, Intel 82801AA-ICH
22:        26          0          0          0  IO-APIC-fasteoi   ohci_hcd:usb2
NMI:          0          0          0          0  Non-maskable interrupts
LOC:     177279    177517     177146     177139  Local timer interrupts
SPU:          0          0          0          0  Spurious interrupts
PMI:          0          0          0          0  Performance monitoring
…
而比较低效率的方法则是只给CPU0提供定时器，由CPU0将定时器中断透过IPI（InterProcessor Interrupt，处理器间中断）广播到其他核。对于ARM来讲，1号IPIIPI_TIMER就是来负责这个广播的，从arch/arm/kernel/smp.c可以看出：
62enum ipi_msg_type {
63        IPI_WAKEUP,
64        IPI_TIMER,
65        IPI_RESCHEDULE,
66        IPI_CALL_FUNC,
67         IPI_CALL_FUNC_SINGLE,
68        IPI_CPU_STOP,
69 };
3.   中断控制器驱动
在Linux内核中，各个设备驱动可以简单地调用request_irq()、enable_irq()、disable_irq()、local_irq_disable()、localirq_enable()等通用API完成中断申请、使能、禁止等功能。在将Linux移植到新的SoC时，芯片供应商需要提供该部分API的底层支持。
local_irq_disable()、local_irq_enable()的实现与具体中断控制器无关，对于ARMv6以上的体系架构而言，是直接调用CPSID/CPSIE指令进行，而对于ARMv6以前的体系结构，则是透过MRS、MSR指令来读取和设置ARM的CPSR寄存器。由此可见，local_irq_disable()、local_irq_enable()针对的并不是外部的中断控制器，而是直接让CPU本身不响应中断请求。相关的实现位于arch/arm/include/asm/irqflags.h：
[cpp]view plaincopy
1. 11#if __LINUX_ARM_ARCH__ <= 6  
2.
3. 12  
4.
5. 13static inline unsigned longarch_local_irq_save(void)  
6.
7. 14{  
8.
9. 15       unsigned long flags;  
10.
11. 16  
12.
13. 17       asm volatile(  
14.
15. 18                "       mrs    %0, cpsr        @ arch_local_irq_save\n"
16.
17. 19                "       cpsid  i"
18.
19. 20                : "=r" (flags) : :"memory", "cc");  
20.
21. 21       return flags;  
22.
23. 22}  
24.
25. 23  
26.
27. 24static inline voidarch_local_irq_enable(void)  
28.
29. 25{  
30.
31. 26       asm volatile(  
32.
33. 27                "       cpsie i                 @ arch_local_irq_enable"
34.
35. 28                :  
36.
37. 29                :  
38.
39. 30                : "memory","cc");  
40.
41. 31}  
42.
43. 32  
44.
45. 33static inline voidarch_local_irq_disable(void)  
46.
47. 34{  
48.
49. 35       asm volatile(  
50.
51. 36                "       cpsid i                 @ arch_local_irq_disable"
52.
53. 37                :  
54.
55. 38                :  
56.
57. 39                : "memory","cc");  
58.
59. 40}  
60.
61. 44#else
62.
63. 45  
64.
65. 46/*
66.
67. 47 * Save the current interrupt enable state& disable IRQs
68.
69. 48 */
70.
71. 49static inline unsigned longarch_local_irq_save(void)  
72.
73. 50{  
74.
75. 51       unsigned long flags, temp;  
76.
77. 52  
78.
79. 53       asm volatile(  
80.
81. 54                "       mrs    %0, cpsr        @ arch_local_irq_save\n"
82.
83. 55                "       orr    %1, %0, #128\n"
84.
85. 56                "       msr    cpsr_c, %1"
86.
87. 57                : "=r" (flags),"=r" (temp)  
88.
89. 58                :  
90.
91. 59                : "memory","cc");  
92.
93. 60       return flags;  
94.
95. 61}  
96.
97. 62  
98.
99. 63/*
100.
101. 64 * Enable IRQs
102.
103. 65 */
104.
105. 66static inline voidarch_local_irq_enable(void)  
106.
107. 67{  
108.
109. 68       unsigned long temp;  
110.
111. 69       asm volatile(  
112.
113. 70                "       mrs    %0, cpsr        @ arch_local_irq_enable\n"
114.
115. 71                "       bic    %0, %0, #128\n"
116.
117. 72                "       msr    cpsr_c, %0"
118.
119. 73                : "=r" (temp)  
120.
121. 74               :  
122.
123. 75                : "memory","cc");  
124.
125. 76}  
126.
127. 77  
128.
129. 78/*
130.
131. 79 * Disable IRQs
132.
133. 80 */
134.
135. 81static inline voidarch_local_irq_disable(void)  
136.
137. 82{  
138.
139. 83       unsigned long temp;  
140.
141. 84       asm volatile(  
142.
143. 85                "       mrs    %0, cpsr        @arch_local_irq_disable\n"
144.
145. 86                "       orr    %0, %0, #128\n"
146.
147. 87                "       msr    cpsr_c, %0"
148.
149. 88                : "=r" (temp)  
150.
151. 89                :  
152.
153. 90                : "memory","cc");  
154.
155. 91}  
156.
157. 92 #endif  
与local_irq_disable()和local_irq_enable()不同，disable_irq()、enable_irq()针对的则是外部的中断控制器。在内核中，透过irq_chip结构体来描述中断控制器。该结构体内部封装了中断mask、unmask、ack等成员函数，其定义于include/linux/irq.h：
[cpp]view plaincopy
1. 303structirq_chip {  
2.
3.  304       constchar      *name;  
4.
5.  305       unsigned int    (*irq_startup)(structirq_data *data);  
6.
7.  306       void           (*irq_shutdown)(struct irq_data *data);  
8.
9.  307       void           (*irq_enable)(struct irq_data *data);  
10.
11.  308       void           (*irq_disable)(struct irq_data *data);  
12.
13.  309  
14.
15.  310       void            (*irq_ack)(struct irq_data *data);  
16.
17.  311       void            (*irq_mask)(structirq_data *data);  
18.
19.  312       void           (*irq_mask_ack)(struct irq_data *data);  
20.
21.  313       void           (*irq_unmask)(struct irq_data *data);  
22.
23.  314       void            (*irq_eoi)(struct irq_data *data);  
24.
25.  315  
26.
27.  316       int            (*irq_set_affinity)(struct irq_data *data, conststruct cpumask *dest,bool force);  
28.
29.  317       int            (*irq_retrigger)(struct irq_data *data);  
30.
31.  318       int             (*irq_set_type)(struct irq_data *data,unsigned int flow_type);  
32.
33.  319       int            (*irq_set_wake)(struct irq_data *data, unsigned int on);  
34.
35.  334};  
各个芯片公司会将芯片内部的中断控制器实现为irq_chip驱动的形式。受限于中断控制器硬件的能力，这些成员函数并不一定需要全部实现，有时候只需要实现其中的部分函数即可。譬如drivers/pinctrl/pinctrl-sirf.c驱动中的
[cpp]view plaincopy
1. 1438staticstruct irq_chip sirfsoc_irq_chip = {  
2.
3. 1439        .name = "sirf-gpio-irq",  
4.
5. 1440        .irq_ack = sirfsoc_gpio_irq_ack,  
6.
7. 1441       .irq_mask = sirfsoc_gpio_irq_mask,  
8.
9. 1442        .irq_unmask = sirfsoc_gpio_irq_unmask,  
10.
11. 1443        .irq_set_type = sirfsoc_gpio_irq_type,  
12.
13. 1444};  
我们只实现了其中的ack、mask、unmask和set_type成员函数，ack函数用于清中断，mask、unmask用于中断屏蔽和取消中断屏蔽、set_type则用于配置中断的触发方式，如高电平、低电平、上升沿、下降沿等。至于enable_irq()的时候，虽然没有实现irq_enable成员函数，但是内核会间接调用到irq_unmask成员函数，这点从kernel/irq/chip.c可以看出：
[cpp]view plaincopy
1. 192voidirq_enable(struct irq_desc *desc)  
2.
3.  193{  
4.
5.  194       irq_state_clr_disabled(desc);  
6.
7.  195       if (desc-          desc-中断源，其中有4个来源于GPIO控制器外围的4组GPIO，每组GPIO上又有32个中断（许多芯片的GPIO控制器也同时是一个中断控制器），其关系如下图：

那么，一般来讲，在实际操作中，gpio0_0——gpio0_31这些引脚本身在第1级会使用中断号28，而这些引脚本身的中断号在实现GPIO控制器对应的irq_chip驱动时，我们又会把它映射到Linux系统的32——63号中断。同理，gpio1_0——gpio1_31这些引脚本身在第1级会使用中断号29，而这些引脚本身的中断号在实现GPIO控制器对应的irq_chip驱动时，我们又会把它映射到Linux系统的64——95号中断，以此类推对于中断号的使用者而言，无需看到这种2级映射关系。如果某设备想申请gpio1_0这个引脚对应的中断，它只需要申请64号中断即可。这个关系图看起来如下：

还是以drivers/pinctrl/pinctrl-sirf.c的irq_chip部分为例，我们对于每组GPIO都透过irq_domain_add_legacy()添加了相应的irq_domain，每组GPIO的中断号开始于SIRFSOC_GPIO_IRQ_START + i *SIRFSOC_GPIO_BANK_SIZE，而每组GPIO本身占用的第1级中断控制器的中断号则为bank-