linux驱动系列之arm汇编

当前位置:

首页 > 编程开发 > 汇编语言 >

linux驱动系列之arm汇编

在arm平台学习linux时，会遇到arm汇编指令，arm汇编指令与8086汇编指令很多地方都不同，在此记下来以免后面忘了，同时在学习了汇编指令之后分析一些汇编指令编写的代码。

一、相对跳转指令b、bl

b、bl指令都实现短跳转，bl指令执行后会在链接寄存器r14中保存下一条指令的地址。

二、数据传送指令mov

　　mov指令会把一个寄存器的数赋值给另一个寄存器，或者把一个常数传递给另一个寄存器。

　　如：mov r0，r1 //将r1中的值传递给r0，mov r0，#0xff //将常数0xff传递给r0寄存器。

　　mov指令传递的常数必须能够用立即数表示，当不知道一个数是否能够用“立即数传递”时，可以用ldr指令进行传递。

　　如：ldr r0，=0xff。

三、内存访问指令str、ldr、ldm、stm

　　ldr指令从内存中读取数到寄存器中，str指令将寄存器中的数传递到内存中，ldr、str指令操作的数都是32位的。ldm、stm是批量内存访问指令，用一个指令就能访问多个数据。下面是从s3c2440 datasheet上面的截图

　　{cond}表示指令的执行条件

　　Rn中保存内存地址，如果后面有！指令执行后会更新为下一个内存单元的地址

　　<Rlist>寄存器列表对于ldm指令相当于将内存的数据取出放入列表中的寄存器中，stm指令相当于将列表中的寄存器中的值放入内存中。

　　{^}有两种含义：如果<Rlist>有PC寄存器时，它表示指令执行后，spsr寄存器的值会自动复制cpsr寄存器中，这个常用于从中断处理函数中返回。如果<Rlist>中没有PC寄存器时，{^}表示操作的是用户模式下的寄存器，不是特权模式下的寄存器。

　　指令中列表中的寄存器与内存对应关系为：编号底的寄存器对应低地址内存单元，编号搞的对应高地址内存单元。

四、加减指令add、sub

　　如：add r0，r1，#0xff //r0=r1+0xff sub r0，r1，#0xff //表示r0=r1-0xff

五、程序状态寄存器访问指令msr、mrs

arm有个程序状态寄存器cpsr，它用来控制处理器的工作模式和设置中断的总开关。

　　msr cpsr，r0 //复制r0到cpsr中

　　mrs r0，cpsr //复制cpsr到r0中

六、伪指令

　　.gloabl _start

　　_start:

　　.text

　　.extern main

　　.gloabl将本文件中的某个程序定义为全局的

　　.extern 将某个变量或者函数引用到本文件中

　　.text 表示下面的语句都属于代码段

八、uboot启动过程分析

　　在看了韦东山老师的书和视频后，对汇编指令及bootloader的工作流程有了一个新的认识，我们接触比较的bootloader就是电脑的bios了，bootloader就是一段将我们硬盘上的代码搬运到内存中指定位置运行的程序。

　　在说硬盘内存这些概念时我们首先要对s3c24xx或者其他的微处理器的存储空间有一个大致的了解。我做实验主要用的是2440，下面也就2440进行说明。在2440中我们一般使用三种存储设备：SDRAM、Nandflash、Norflash。这三个存储设备相对于我们平常的PC就是：SDRAM====>内存条，(Nandflash、Norflash)====>硬盘，对于Nandflash和Norflash的区别主要是前者不能直接运行代码，后者代码可以直接运行但是不能进行写数据，所以我们常常将Nandflash 存放程序，Norflash存放数据。

　　对于存储空间2440有一个专门的存储控制器，

　　一般我们把Norflash、Nandflash都与nGCS0相连，然后通过选择OM0、OM1选择哪种启动方式，如果选择Norflash我们的代码就会从Norflash的0地址开始执行，如果选择Nandflash我们的代码会被处理器将Nandflash的前4k拷贝到芯片内部的4k RAM中，然后程序在内部4k RAM中开始执行，这个拷贝过程是一个硬件过程，芯片内部自动完成。由于只有4k大小如果我们的程序小于4k，我们就直接让其在芯片内部RAM中执行，如果我们的代码大于4k，一般我们会用4k大小的程序将Nandflash里面的其余部分程序直接拷贝到SDRAM(0x3000 0000)中执行。

　　我们的bootloader肯定是大于4k的，说以如果在Nandflash中运行我们就必须在4k 大小的代码中将bootloader拷贝到SDRAM,然后在SDRAM中将Nandflash 中的Kernerl拷贝到SDRAM中完成内核的启动，大的流程就如前面所说，但是具体在实现的过程中有很多的小细节。

8.1 bootloader启动前的准备

　　1、关看门狗

　　2、设置时钟

　　3、初始化SDRAM

　　4、重定位将bootloader的代码从Nandflash中拷贝到SDRAM中

　　5、执行main

　　 ====》在main函数中所做的工作

　　　　　　　　　　1、初始化串口(因为要加载内核需要打印一些信息，内核没有串口初始化的代码所以需要在内核启动前进行初始化)

　　　　　　　　　　2、从Nandflash中将内核读入SDRAM

　　　　　　　　　　3、设置参数(这个工作非常重要，因为内核在启动过程中需要设置启动参数比如：设置内存标记(内存的起始地址、内存大小)、设置命令行标记(命令行就是一个字符串，用于控制内核的一些行为。比如"noinitrd root=/dev/mtdblock3 init=/linuxrc console=ttySAC0" 表示根文件系统在MTD3分区上，启动系统后执行的第一个程序是linuxrc，控制台为ttySAC0(第一个串口)))。在启动时bootloader与Kernel的交互式单项的所以只能是在bootloader启动阶段将我们用于设置内核的参数放在内存的某个地方，bootloader与Kernel约定好内核启动时就在这个地方去读取这些配置参数完成启动，一般这些参数存放在SDRAM 0x3100 0000地址上。

 1 /* 3. 跳转执行 */
 2 puts("Boot kernel\n\r");
 3 theKernel = (void (*)(int, int, unsigned int))0x30008000;
 4 theKernel(0, 362, 0x30000100);  
 5 /* 
 6  *  mov r0, #0
 7  *  ldr r1, =362
 8  *  ldr r2, =0x30000100
 9 *  mov pc, #0x30008000 
10  */

　　　　第3行代码就是将函数指针的首地址放到内核存放的内存首地址中去执行，下面的参数因为是函数调用所以会把我们上面说的bootloader与Kernel交互的设置参数保存在内存中的地址0x3000 0100放在r2寄存器中，内核执行时会从r2寄存器中取出地址然后找到我们在bootloader启动阶段存放的设置参数，这个过程相当的巧妙，主要是利用了函数调用时参数一般会保存在r0-r3，被调用的子程序返回前无需回复r0-r3的内容。　　

　　参考主要代码：

　　1、bootloader启动汇编部分

 1 #define S3C2440_MPLL_200MHZ     ((0x5c<<12)|(0x01<<4)|(0x02))
 2 #define S3C2440_MPLL_400MHZ     ((0x5c<<12)|(0x01<<4)|(0x01))
 3 #define MEM_CTL_BASE    0x48000000
 4 
 5 .text
 6 .global _start
 7 _start:
 8 
 9 /* 1. 关看门狗 */
10     ldr r0, =0x53000000
11     mov r1, #0
12     str r1, [r0]
13 
14 /* 2. 设置时钟 */
15     ldr r0, =0x4c000014
16     //    mov r1, #0x03;              // FCLK:HCLK:PCLK=1:2:4, HDIVN=1,PDIVN=1
17     mov r1, #0x05;              // FCLK:HCLK:PCLK=1:4:8
18     str r1, [r0]
19        
20     /* 如果HDIVN非0，CPU的总线模式应该从“fast bus mode”变为“asynchronous bus mode” */
21     mrc    p15, 0, r1, c1, c0, 0        /* 读出控制寄存器 */ 
22     orr    r1, r1, #0xc0000000            /* 设置为“asynchronous bus mode” */
23     mcr    p15, 0, r1, c1, c0, 0        /* 写入控制寄存器 */
24 
25     /* MPLLCON = S3C2440_MPLL_200MHZ */
26     ldr r0, =0x4c000004
27     ldr r1, =S3C2440_MPLL_400MHZ
28     str r1, [r0]
29 
30     /* 启动ICACHE */
31     mrc p15, 0, r0, c1, c0, 0    @ read control reg
32     orr r0, r0, #(1<<12)
33     mcr    p15, 0, r0, c1, c0, 0   @ write it back
34 
35 
36 /* 3. 初始化SDRAM */
37     ldr r0, =MEM_CTL_BASE
38     adr r1, sdram_config     /* sdram_config的当前地址 */
39     add r3, r0, #(13*4)
40 1:
41     ldr r2, [r1], #4
42     str r2, [r0], #4
43     cmp r0, r3
44     bne 1b
45 
46 /* 4. 重定位 : 把bootloader本身的代码从flash复制到它的链接地址去 */
47     ldr sp, =0x34000000
48 
49     bl nand_init
50 
51     mov r0, #0
52     ldr r1, =_start
53     ldr r2, =__bss_start
54     sub r2, r2, r1
55     
56     bl copy_code_to_sdram
57     bl clear_bss
58     
59 /* 5. 执行main */
60     ldr lr, =halt
61     ldr pc, =main
62 halt:
63     b halt
64 
65 sdram_config:
66     .long 0x22011110     //BWSCON
67     .long 0x00000700     //BANKCON0
68     .long 0x00000700     //BANKCON1
69     .long 0x00000700     //BANKCON2
70     .long 0x00000700     //BANKCON3  
71     .long 0x00000700     //BANKCON4
72     .long 0x00000700     //BANKCON5
73     .long 0x00018005     //BANKCON6
74     .long 0x00018005     //BANKCON7
75     .long 0x008C04F4     // REFRESH
76     .long 0x000000B1     //BANKSIZE
77     .long 0x00000030     //MRSRB6
78     .long 0x00000030     //MRSRB7

　　2、main函数部分

  1 #include "setup.h"
  2 
  3 extern void uart0_init(void);
  4 extern void nand_read(unsigned int addr, unsigned char *buf, unsigned int len);
  5 extern void puts(char *str);
  6 extern void puthex(unsigned int val);
  7 
  8 
  9 static struct tag *params;
 10 
 11 void setup_start_tag(void)
 12 {
 13     params = (struct tag *)0x30000100;
 14 
 15     params->hdr.tag = ATAG_CORE;
 16     params->hdr.size = tag_size (tag_core);
 17 
 18     params->u.core.flags = 0;
 19     params->u.core.pagesize = 0;
 20     params->u.core.rootdev = 0;
 21 
 22     params = tag_next (params);
 23 }
 24 
 25 void setup_memory_tags(void)
 26 {
 27     params->hdr.tag = ATAG_MEM;
 28     params->hdr.size = tag_size (tag_mem32);
 29     
 30     params->u.mem.start = 0x30000000;
 31     params->u.mem.size  = 64*1024*1024;
 32     
 33     params = tag_next (params);
 34 }
 35 
 36 int strlen(char *str)
 37 {
 38     int i = 0;
 39     while (str[i])
 40     {
 41         i++;
 42     }
 43     return i;
 44 }
 45 
 46 void strcpy(char *dest, char *src)
 47 {
 48     while ((*dest++ = *src++) != '\0');
 49 }
 50 
 51 void setup_commandline_tag(char *cmdline)
 52 {
 53     int len = strlen(cmdline) + 1;
 54     
 55     params->hdr.tag  = ATAG_CMDLINE;
 56     params->hdr.size = (sizeof (struct tag_header) + len + 3) >> 2;
 57 
 58     strcpy (params->u.cmdline.cmdline, cmdline);
 59 
 60     params = tag_next (params);
 61 }
 62 
 63 void setup_end_tag(void)
 64 {
 65     params->hdr.tag = ATAG_NONE;
 66     params->hdr.size = 0;
 67 }
 68 
 69 
 70 int main(void)
 71 {
 72     void (*theKernel)(int zero, int arch, unsigned int params);
 73     volatile unsigned int *p = (volatile unsigned int *)0x30008000;
 74 
 75     /* 0. 帮内核设置串口: 内核启动的开始部分会从串口打印一些信息,但是内核一开始没有初始化串口 */
 76     uart0_init();
 77     
 78     /* 1. 从NAND FLASH里把内核读入内存 */
 79     puts("Copy kernel from nand\n\r");
 80     nand_read(0x60000+64, (unsigned char *)0x30008000, 0x200000);
 81     puthex(0x1234ABCD);
 82     puts("\n\r");
 83     puthex(*p);
 84     puts("\n\r");
 85 
 86     /* 2. 设置参数 */
 87     puts("Set boot params\n\r");
 88     setup_start_tag();
 89     setup_memory_tags();
 90     setup_commandline_tag("noinitrd root=/dev/mtdblock3 init=/linuxrc console=ttySAC0");
 91     setup_end_tag();
 92 
 93     /* 3. 跳转执行 */
 94     puts("Boot kernel\n\r");
 95     theKernel = (void (*)(int, int, unsigned int))0x30008000;
 96     theKernel(0, 362, 0x30000100);  
 97     /* 
 98      *  mov r0, #0
 99      *  ldr r1, =362
100      *  ldr r2, =0x30000100
101      *  mov pc, #0x30008000 
102      */
103 
104     puts("Error!\n\r");
105     /* 如果一切正常, 不会执行到这里 */
106 
107     return -1;
108 }

　　3、对设备初始化部分(Nandflash、Uart等)

  1 /* NAND FLASH控制器 */
  2 #define NFCONF (*((volatile unsigned long *)0x4E000000))
  3 #define NFCONT (*((volatile unsigned long *)0x4E000004))
  4 #define NFCMMD (*((volatile unsigned char *)0x4E000008))
  5 #define NFADDR (*((volatile unsigned char *)0x4E00000C))
  6 #define NFDATA (*((volatile unsigned char *)0x4E000010))
  7 #define NFSTAT (*((volatile unsigned char *)0x4E000020))
  8 
  9 /* GPIO */
 10 #define GPHCON              (*(volatile unsigned long *)0x56000070)
 11 #define GPHUP               (*(volatile unsigned long *)0x56000078)
 12 
 13 /* UART registers*/
 14 #define ULCON0              (*(volatile unsigned long *)0x50000000)
 15 #define UCON0               (*(volatile unsigned long *)0x50000004)
 16 #define UFCON0              (*(volatile unsigned long *)0x50000008)
 17 #define UMCON0              (*(volatile unsigned long *)0x5000000c)
 18 #define UTRSTAT0            (*(volatile unsigned long *)0x50000010)
 19 #define UTXH0               (*(volatile unsigned char *)0x50000020)
 20 #define URXH0               (*(volatile unsigned char *)0x50000024)
 21 #define UBRDIV0             (*(volatile unsigned long *)0x50000028)
 22 
 23 #define TXD0READY   (1<<2)
 24 
 25 
 26 void nand_read(unsigned int addr, unsigned char *buf, unsigned int len);
 27 
 28 
 29 int isBootFromNorFlash(void)
 30 {
 31     volatile int *p = (volatile int *)0;
 32     int val;
 33 
 34     val = *p;
 35     *p = 0x12345678;
 36     if (*p == 0x12345678)
 37     {
 38         /* 写成功, 是nand启动 */
 39         *p = val;
 40         return 0;
 41     }
 42     else
 43     {
 44         /* NOR不能像内存一样写 */
 45         return 1;
 46     }
 47 }
 48 
 49 void copy_code_to_sdram(unsigned char *src, unsigned char *dest, unsigned int len)
 50 {    
 51     int i = 0;
 52     
 53     /* 如果是NOR启动 */
 54     if (isBootFromNorFlash())
 55     {
 56         while (i < len)
 57         {
 58             dest[i] = src[i];
 59             i++;
 60         }
 61     }
 62     else
 63     {
 64         //nand_init();
 65         nand_read((unsigned int)src, dest, len);
 66     }
 67 }
 68 
 69 void clear_bss(void)
 70 {
 71     extern int __bss_start, __bss_end;
 72     int *p = &__bss_start;
 73     
 74     for (; p < &__bss_end; p++)
 75         *p = 0;
 76 }
 77 
 78 void nand_init(void)
 79 {
 80 #define TACLS   0
 81 #define TWRPH0  1
 82 #define TWRPH1  0
 83     /* 设置时序 */
 84     NFCONF = (TACLS<<12)|(TWRPH0<<8)|(TWRPH1<<4);
 85     /* 使能NAND Flash控制器, 初始化ECC, 禁止片选 */
 86     NFCONT = (1<<4)|(1<<1)|(1<<0);    
 87 }
 88 
 89 void nand_select(void)
 90 {
 91     NFCONT &= ~(1<<1);    
 92 }
 93 
 94 void nand_deselect(void)
 95 {
 96     NFCONT |= (1<<1);    
 97 }
 98 
 99 void nand_cmd(unsigned char cmd)
100 {
101     volatile int i;
102     NFCMMD = cmd;
103     for (i = 0; i < 10; i++);
104 }
105 
106 void nand_addr(unsigned int addr)
107 {
108     unsigned int col  = addr % 2048;
109     unsigned int page = addr / 2048;
110     volatile int i;
111 
112     NFADDR = col & 0xff;
113     for (i = 0; i < 10; i++);
114     NFADDR = (col >> 8) & 0xff;
115     for (i = 0; i < 10; i++);
116     
117     NFADDR  = page & 0xff;
118     for (i = 0; i < 10; i++);
119     NFADDR  = (page >> 8) & 0xff;
120     for (i = 0; i < 10; i++);
121     NFADDR  = (page >> 16) & 0xff;
122     for (i = 0; i < 10; i++);    
123 }
124 
125 void nand_wait_ready(void)
126 {
127     while (!(NFSTAT & 1));
128 }
129 
130 unsigned char nand_data(void)
131 {
132     return NFDATA;
133 }
134 
135 void nand_read(unsigned int addr, unsigned char *buf, unsigned int len)
136 {
137     int col = addr % 2048;
138     int i = 0;
139         
140     /* 1. 选中 */
141     nand_select();
142 
143     while (i < len)
144     {
145         /* 2. 发出读命令00h */
146         nand_cmd(0x00);
147 
148         /* 3. 发出地址(分5步发出) */
149         nand_addr(addr);
150 
151         /* 4. 发出读命令30h */
152         nand_cmd(0x30);
153 
154         /* 5. 判断状态 */
155         nand_wait_ready();
156 
157         /* 6. 读数据 */
158         for (; (col < 2048) && (i < len); col++)
159         {
160             buf[i] = nand_data();
161             i++;
162             addr++;
163         }
164         
165         col = 0;
166     }
167 
168     /* 7. 取消选中 */        
169     nand_deselect();
170 }
171 
172 #define PCLK            50000000    // init.c中的clock_init函数设置PCLK为50MHz
173 #define UART_CLK        PCLK        //  UART0的时钟源设为PCLK
174 #define UART_BAUD_RATE  115200      // 波特率
175 #define UART_BRD        ((UART_CLK  / (UART_BAUD_RATE * 16)) - 1)
176 
177 /*
178  * 初始化UART0
179  * 115200,8N1,无流控
180  */
181 void uart0_init(void)
182 {
183     GPHCON  |= 0xa0;    // GPH2,GPH3用作TXD0,RXD0
184     GPHUP   = 0x0c;     // GPH2,GPH3内部上拉
185 
186     ULCON0  = 0x03;     // 8N1(8个数据位，无较验，1个停止位)
187     UCON0   = 0x05;     // 查询方式，UART时钟源为PCLK
188     UFCON0  = 0x00;     // 不使用FIFO
189     UMCON0  = 0x00;     // 不使用流控
190     UBRDIV0 = UART_BRD; // 波特率为115200
191 }
192 
193 /*
194  * 发送一个字符
195  */
196 void putc(unsigned char c)
197 {
198     /* 等待，直到发送缓冲区中的数据已经全部发送出去 */
199     while (!(UTRSTAT0 & TXD0READY));
200     
201     /* 向UTXH0寄存器中写入数据，UART即自动将它发送出去 */
202     UTXH0 = c;
203 }
204 
205 void puts(char *str)
206 {
207     int i = 0;
208     while (str[i])
209     {
210         putc(str[i]);
211         i++;
212     }
213 }
214 
215 void puthex(unsigned int val)
216 {
217     /* 0x1234abcd */
218     int i;
219     int j;
220     
221     puts("0x");
222 
223     for (i = 0; i < 8; i++)
224     {
225         j = (val >> ((7-i)*4)) & 0xf;
226         if ((j >= 0) && (j <= 9))
227             putc('0' + j);
228         else
229             putc('A' + j - 0xa);
230         
231     }
232     
233 }

　　4、寄存器地址设置、内核标记列表数据结构实现等

  1 /*
  2  *  linux/include/asm/setup.h
  3  *
  4  *  Copyright (C) 1997-1999 Russell King
  5  *
  6  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License version 2 as
  8  * published by the Free Software Foundation.
  9  *
 10  *  Structure passed to kernel to tell it about the
 11  *  hardware it's running on.  See linux/Documentation/arm/Setup
 12  *  for more info.
 13  *
 14  * NOTE:
 15  *  This file contains two ways to pass information from the boot
 16  *  loader to the kernel. The old struct param_struct is deprecated,
 17  *  but it will be kept in the kernel for 5 years from now
 18  *  (2001). This will allow boot loaders to convert to the new struct
 19  *  tag way.
 20  */
 21 #ifndef __ASMARM_SETUP_H
 22 #define __ASMARM_SETUP_H
 23 
 24 #define u8  unsigned char
 25 #define u16 unsigned short
 26 #define u32 unsigned long
 27 
 28 /*
 29  * Usage:
 30  *  - do not go blindly adding fields, add them at the end
 31  *  - when adding fields, don't rely on the address until
 32  *    a patch from me has been released
 33  *  - unused fields should be zero (for future expansion)
 34  *  - this structure is relatively short-lived - only
 35  *    guaranteed to contain useful data in setup_arch()
 36  */
 37 #define COMMAND_LINE_SIZE 1024
 38 
 39 /* This is the old deprecated way to pass parameters to the kernel */
 40 struct param_struct {
 41     union {
 42     struct {
 43         unsigned long page_size;        /*  0 */
 44         unsigned long nr_pages;        /*  4 */
 45         unsigned long ramdisk_size;        /*  8 */
 46         unsigned long flags;        /* 12 */
 47 #define FLAG_READONLY    1
 48 #define FLAG_RDLOAD    4
 49 #define FLAG_RDPROMPT    8
 50         unsigned long rootdev;        /* 16 */
 51         unsigned long video_num_cols;    /* 20 */
 52         unsigned long video_num_rows;    /* 24 */
 53         unsigned long video_x;        /* 28 */
 54         unsigned long video_y;        /* 32 */
 55         unsigned long memc_control_reg;    /* 36 */
 56         unsigned char sounddefault;        /* 40 */
 57         unsigned char adfsdrives;        /* 41 */
 58         unsigned char bytes_per_char_h;    /* 42 */
 59         unsigned char bytes_per_char_v;    /* 43 */
 60         unsigned long pages_in_bank[4];    /* 44 */
 61         unsigned long pages_in_vram;    /* 60 */
 62         unsigned long initrd_start;        /* 64 */
 63         unsigned long initrd_size;        /* 68 */
 64         unsigned long rd_start;        /* 72 */
 65         unsigned long system_rev;        /* 76 */
 66         unsigned long system_serial_low;    /* 80 */
 67         unsigned long system_serial_high;    /* 84 */
 68         unsigned long mem_fclk_21285;       /* 88 */
 69     } s;
 70     char unused[256];
 71     } u1;
 72     union {
 73     char paths[8][128];
 74     struct {
 75         unsigned long magic;
 76         char n[1024 - sizeof(unsigned long)];
 77     } s;
 78     } u2;
 79     char commandline[COMMAND_LINE_SIZE];
 80 };
 81 
 82 
 83 /*
 84  * The new way of passing information: a list of tagged entries
 85  */
 86 
 87 /* The list ends with an ATAG_NONE node. */
 88 #define ATAG_NONE    0x00000000
 89 
 90 struct tag_header {
 91     u32 size;
 92     u32 tag;
 93 };
 94 
 95 /* The list must start with an ATAG_CORE node */
 96 #define ATAG_CORE    0x54410001
 97 
 98 struct tag_core {
 99     u32 flags;        /* bit 0 = read-only */
100     u32 pagesize;
101     u32 rootdev;
102 };
103 
104 /* it is allowed to have multiple ATAG_MEM nodes */
105 #define ATAG_MEM    0x54410002
106 
107 struct tag_mem32 {
108     u32    size;
109     u32    start;    /* physical start address */
110 };
111 
112 /* VGA text type displays */
113 #define ATAG_VIDEOTEXT    0x54410003
114 
115 struct tag_videotext {
116     u8        x;
117     u8        y;
118     u16        video_page;
119     u8        video_mode;
120     u8        video_cols;
121     u16        video_ega_bx;
122     u8        video_lines;
123     u8        video_isvga;
124     u16        video_points;
125 };
126 
127 /* describes how the ramdisk will be used in kernel */
128 #define ATAG_RAMDISK    0x54410004
129 
130 struct tag_ramdisk {
131     u32 flags;    /* bit 0 = load, bit 1 = prompt */
132     u32 size;    /* decompressed ramdisk size in _kilo_ bytes */
133     u32 start;    /* starting block of floppy-based RAM disk image */
134 };
135 
136 /* describes where the compressed ramdisk image lives (virtual address) */
137 /*
138  * this one accidentally used virtual addresses - as such,
139  * its depreciated.
140  */
141 #define ATAG_INITRD    0x54410005
142 
143 /* describes where the compressed ramdisk image lives (physical address) */
144 #define ATAG_INITRD2    0x54420005
145 
146 struct tag_initrd {
147     u32 start;    /* physical start address */
148     u32 size;    /* size of compressed ramdisk image in bytes */
149 };
150 
151 /* board serial number. "64 bits should be enough for everybody" */
152 #define ATAG_SERIAL    0x54410006
153 
154 struct tag_serialnr {
155     u32 low;
156     u32 high;
157 };
158 
159 /* board revision */
160 #define ATAG_REVISION    0x54410007
161 
162 struct tag_revision {
163     u32 rev;
164 };
165 
166 /* initial values for vesafb-type framebuffers. see struct screen_info
167  * in include/linux/tty.h
168  */
169 #define ATAG_VIDEOLFB    0x54410008
170 
171 struct tag_videolfb {
172     u16        lfb_width;
173     u16        lfb_height;
174     u16        lfb_depth;
175     u16        lfb_linelength;
176     u32        lfb_base;
177     u32        lfb_size;
178     u8        red_size;
179     u8        red_pos;
180     u8        green_size;
181     u8        green_pos;
182     u8        blue_size;
183     u8        blue_pos;
184     u8        rsvd_size;
185     u8        rsvd_pos;
186 };
187 
188 /* command line: \0 terminated string */
189 #define ATAG_CMDLINE    0x54410009
190 
191 struct tag_cmdline {
192     char    cmdline[1];    /* this is the minimum size */
193 };
194 
195 /* acorn RiscPC specific information */
196 #define ATAG_ACORN    0x41000101
197 
198 struct tag_acorn {
199     u32 memc_control_reg;
200     u32 vram_pages;
201     u8 sounddefault;
202     u8 adfsdrives;
203 };
204 
205 /* footbridge memory clock, see arch/arm/mach-footbridge/arch.c */
206 #define ATAG_MEMCLK    0x41000402
207 
208 struct tag_memclk {
209     u32 fmemclk;
210 };
211 
212 struct tag {
213     struct tag_header hdr;
214     union {
215         struct tag_core        core;
216         struct tag_mem32    mem;
217         struct tag_videotext    videotext;
218         struct tag_ramdisk    ramdisk;
219         struct tag_initrd    initrd;
220         struct tag_serialnr    serialnr;
221         struct tag_revision    revision;
222         struct tag_videolfb    videolfb;
223         struct tag_cmdline    cmdline;
224 
225         /*
226          * Acorn specific
227          */
228         struct tag_acorn    acorn;
229 
230         /*
231          * DC21285 specific
232          */
233         struct tag_memclk    memclk;
234     } u;
235 };
236 
237 struct tagtable {
238     u32 tag;
239     int (*parse)(const struct tag *);
240 };
241 
242 
243 #define tag_member_present(tag,member)                \
244     ((unsigned long)(&((struct tag *)0L)->member + 1)    \
245         <= (tag)->hdr.size * 4)
246 
247 #define tag_next(t)    ((struct tag *)((u32 *)(t) + (t)->hdr.size))
248 #define tag_size(type)    ((sizeof(struct tag_header) + sizeof(struct type)) >> 2)
249 
250 #define for_each_tag(t,base)        \
251     for (t = base; t->hdr.size; t = tag_next(t))
252 
253 /*
254  * Memory map description
255  */
256 #define NR_BANKS 8
257 
258 struct meminfo {
259     int nr_banks;
260     unsigned long end;
261     struct {
262         unsigned long start;
263         unsigned long size;
264         int           node;
265     } bank[NR_BANKS];
266 };
267 
268 extern struct meminfo meminfo;
269 
270 #endif

出处：https://www.cnblogs.com/qiuheng/p/5539241.html

栏目列表