在实际解决问题的时候，各种数据都不是孤立的，数据之间总是存在关系，这种数据之间的关系叫做数据结构。我们可以把数据结构的形式归并为四种：

数据类型是一个值的集合和定义在这个值集上的一组操作的总称。

数据类型可分两类，一类是每个对象仅由单值组成，称为原子类型，如整型、字符型等。另一类是由某种结构组成的类型，叫结构类型，如数组、字符串等。

抽象数据结构（Abstract Data Type，ADT）是一种数据类型及在这个类型上定义的一组合法的操作。

算法（Algorithm）是一个有穷规则（或语句、指令）的有序集合。通俗地说，就是计算机解决问题的过程。算法应具备以下几个重要的特性：

描述算法的工具：自然语言、流程图、形式化语言和程序设计语言。

由瑞士科学家Niklaus Wirthrn提出的计算机界公认的公式：算法 + 数据结构 = 程序

算法设计的要求：正确、可读、健壮、快速、节省存储空间。

线性结构中的数据元素之间是一种线性关系，数据元素一个接一个地排列。如排除的队列、表格中一行行的记录等。数据元素可以包含多个数据项（字段），包含多个数据项的数据元素叫做记录。由大量记录组成的线性表又称为文件。

线性表的数学表示模型：a0,a1,a2,...a（n-1）。

顺序连续存放的线性表是最简单的，称为顺序存储结构线性表。它在内存开辟一片连续的存储空间，让线性表的第一个元素存放在内存空间的第一个位置，第二个元素存放在第二个位置，其它元素以此类推。数据元素间的前驱和后继关系表现在存放位置的前后关系上。顺序存储结构线性表算法在插入或删除操作时的效率不高。平均起来，每插入或删除一个元素需要移动一半的元素，最坏的情况更要移动全部的元素。另外，顺序表不利于存储空间的分配。在经常需要进入插入或删除操作的线性表中，使用顺序存储结构线性表是不合适的。所以我们有了链式存储结构线性表。

	数组就是顺序存储结构的程序实现。

链式存储结构线性表由结点组成，每个节点由一个数据元素和一个指向下个结点的指针组成。每个结点中如果只有一个指向后续指针的链表，叫单链表。由于链表通过指针指向下一个结点，所以数据元素可以分散存储。

单链表的建立是一种动态内在管理操作，表中的每个节点占用的存储空间无需预先指定，而是在运行时动态申请。

单链表一旦创建就可对链表进行操作。

EthernetII帧的结构（DMAC+SMAC+Type+Data+CRC），EthernetII帧的大小是有限制的，最小不能小于64字节，最大不能超过1518字节，否则帧会被丢弃。一个EthernetII帧包括的内容有：

IP包结构：

下面我们开发一个模拟Echo服务功能的tcp程序。通过这个简单的程序我们可以学习tcp/ip网络编程的基础结构。

tcpserver.c是服务端程序，运行后会监听一个端口。

debian:~/c/kernelmodule# cat tcpserver.c
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <errno.h>

int main(int argc,char *argv[]){
        int iswork,data,fd1,fd2;
        pid_t pidchild;
        socklen_t clientlen;
        struct sockaddr_in clientaddr;
        struct sockaddr_in serveraddr;
        char buffer[1000];

        if(argc != 2){
                printf("Usage: tcpserver [port number]\n");
                exit(1);
        }

        if((fd1 = socket(AF_INET,SOCK_STREAM,0))<0){
                printf("socket error!\n");
                exit(1);
        }

        memset(&serveraddr,0,sizeof(serveraddr));

        serveraddr.sin_family = AF_INET;
        serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
        serveraddr.sin_port = htons(atoi(argv[1]));

        if(bind(fd1,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0){
                printf("bind error!\n");
                exit(1);
        }

        if(listen(fd1,3)<0){
                printf("listen error!\n");
                exit(1);
        }

        iswork = 1;
        while(iswork){
                clientlen = sizeof(clientaddr);
                if((fd2 = accept(fd1,(struct sockaddr *)&clientaddr,&clientlen))<0){
                        printf("accept error!\n");
                        exit(1);
                }

                if((pidchild = fork()) == -1){
                        printf("fork error!\n");
                        exit(1);
                }

                if(pidchild == 0){
                        if(close(fd1) == -1){
                                printf("close error!\n");
                                exit(1);
                }

                printf("Connect from %s\n",inet_ntoa(clientaddr.sin_addr));

                while(1){
                        memset(buffer,0,1000);

                        if(data = read(fd2,buffer,sizeof(buffer))>0){
                                printf("%s",buffer);
                                if(write(fd2,buffer,sizeof(buffer))<0){
                                        printf("send error!\n");
                                        exit(1);
                                }
                        }
                }
                exit(0);
                }

                if(close(fd2) == -1){
                        printf("close error!\n");
                        exit(1);
                }
        }
}

几个主要函数说明：

数据包在应用层称为data，在TCP层称为segment，在IP层称为packet，在数据链路层称为frame。

整数类型（int），

各种整数数制表示法：

关键字是C语言本身保留使用的，不能用于变量和函数名。

auto          double          int          struct
break         else            long         switch
case          enum            register     typedef
char          extern          return       union
const         float           short        unsigned
continue      for             signed       void
default       goto            sizeof       volatile
do            if              static       while

变量等级的概念也同样适用于函数。若想调用不在有效范围内的函数，则要用extern扩展声明函数的有效范围。

内部变量是以堆栈方式存放的，必须在函数执行时才会存在，所以称为声明（Declaration）。其它如static auto、extern和static extern等级的变量，都是以固定的地址来存放的，而不是以堆栈方式存放的，在程序编译时就已分配了空间，所以称之为定义（Definition）。

数组是内存中的连续区间，可根据声明类型存放多种数值类型。如：

int a[10];         声明一个有10个int元素的数组
char b[20];        声明一个有20个char元素的数组

指针示例：

int *p;            /* p是一个指针，p的内容是内存的地址，在这个地址中将存放一个整数。

数组名和指针都是用来存放内存地址的，不过数组名具有固定长度，不可变。而指针与一般变量一样，其值是可变的。

结构体是用户定义的由基本数据类型组成的复合式数据类型。数组也是复合式数据类型，但二者是不同的，数组是相同类型数据的集合，而结构体是不同类型数据的集合。如我们可以把一个人的姓名、性别，年龄组成一个单一结构体。这样在程序处理时就把它当成一个独立对象进行处理。

结构体声明方法有两种，一种是分离式声明，一种是结合式声明。分离式声明是先把声明结构体，在程序中再声明结构体变量。结合式声明是把结构体声明和变量声明同时完成。

分离式声明示例
struct person{
    char name;
    char sex;
    int age;
};
main(void){
struct person worker;
...
}

结合式声明示例
struct person{
   char name;
   char sex;
   int age;
}worker;

每个结构体可以表示一个工人的信息，如果要表示多个工人的信息，则可以用结构体数组。

struct person{
    char name;
    char sex;
    int age;
};
main(void){
struct person worker[20];     //表示20个工人
...
}

结构体初始设置。

struct person{
    char name;
    char sex;
    int age;
}worker={"jims","male",30};

用"."和"->"运算符存取结构体中的数据。"."是直接存取法，"->"为间接存取法，用于结构体指针。如果p是一个指向person结构体的指针，则p->name和(*p).name的结果是一样的。

结构体可以自定义数据类型，而typedef可以自定义新的类型名。如：

#include <stdio.h>

typedef char *STRING;  //定义一个新的字符指针类型名STRING

main(void){
        STRING a;

        a = "abc";
        printf("the a value is %s.\n",a);
}

a为字符指针类型，自定义类型名通常以大写方式表示，以示区别。

#define与typedef的区别是：#define只是单纯地进行变量替换，而typedef是创建新的类型名。typedef的一个主要作用是简化声明，提高程序的可读性。如：

typedef struct person{
   char name;
   char sex;
   int age;
} p

这样我们就定义一个新的结构体类型名p，在程序中我们可以使用它来声明变量。如

main(void){
   p worker;

  worker = {"jims","male",30};
}

函数是C代码的集合，每个C程序由一个或多个函数组成，main()是一个特殊的函数，是C程序的入口，每个C程序必须有且只能有一个mian()函数。

ANSI函数定义：

类型 函数名（类型 参数1，类型 参数2, ...）
{
   函数代码；
}

示例：
int func(int i, char c)
{
   ...
}

在程序中要使用我们设计开发的函数，需要先进行声明，函数声明的作用是把函数类型告诉编译器。函数声明与定义差不多，只是不包括程序主体。上面示例的函数在主程序中的声明方式如下：

void main()
{
   int total;

   int func(int i, char c);            //函数声明
   total = int(xxx,xxx);               //声明后才能调用该函数 
}

	定义和声明中的参数类型（int,char）要相同，但名称（i，c）可以不同。

当函数没有返回值时，需声定义成void类型，调用者也要做void声明。

一般我们把函数的声明放在一个统一的文件中，这个文件叫头文件。在程序中用#include命令把头文件包含进来。在程序中调用函数前就不用再进行函数声明了。头文件简化了函数声明的管理并使头文件可被多个程序重复使用。大大提高C程序的开发效率。例如：我们最常使用的printf()函数，在使用前我们不需每次都进行声明操作，直接使用就可以啦。但前提是我们要把stdio.h头文件包含进来。printf()函数声明在stdio.h文件中已进行了声明。

Linux系统头文件位于/usr/include中。默认情况下编译器只在该目录下搜索头文件。

在设置Linux的系统路径时，使用冒号分隔每个路径名。如:

PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/bin/X11"

在Linux中的程序有两种，一种是可执行程序，与Windows下的.exe文件类似，一种是脚本，与Windows下的.bat文件类似。

Linux中常用的程序存放路径有以下几个：

开发工具，多数位于/usr/bin或/usr/local/bin目录下。

头文件，位于/usr/include目录。头文件包含有常量定义、系统调用和库函数调用的声明。这是系统默认的头文件存放路径，在编译程序时，编译器会自动查找该目录。gcc编译器在编译程序时也可用-I参数指定另外的头文件路径。如：

gcc -I/usr/local/myinclude test.c。

库文件，库是一组已编译的函数集合，可方便我们重用代码。默认存放在/lib和/usr/lib目录。库文件可分为静态和共享两类。

在编译时可用包含路径的库文件名或用-l参数指定使用的库文件，/usr/lib/libm.a等价于-lm。如:

gcc -o hello hello.c /usr/lib/libm.a  
或用-l参数写成 
gcc -o hello hello.c -lm

如果我们要使用的库文件不在默认位置，在编译程序时可用-L参数指定库文件的路径。下面例子使用了/usr/hello/lib目录下的libhello库文件：

gcc -o hello -L/usr/hello/lib hello.c -lhello

创建和使用静态库。

共享库比静态库具有以下的优点：

ldconfig程序用来安装一个共享库，。

只有在为系统库安装一个库的时候，才需要在/etc/ld.so.conf中创建记录，并运行ldconfig更新共享库的缓存。

LD_LIBRARY_PATH环境变量用来指定附加的库文件路径。系统默认的库文件路径位于/usr/lib和/lib目录下。

LD_PRELOAD环境变量指定提前载入的库，用于替代系统库。

预处理，在程序开头以“#”开头的命令就是预处理命令，它在语法扫描和分析法时被预处理程序处理。预处理有以下几类：

使用gcc编译程序时，要经过四个步骤。

GCC默认将.i文件看成是预处理后的C语言源代码，所以我们可以这样把.i文件编译成目标文件。

debian:~# gcc -c hello.i -o hello.o}}}

在GCC中使用-pedantic选项能够帮助程序员发现一些不符合ANSI/ISO C标准的代码，但不是全部。从程序员的角度看，函数库实际上就是一些头文件（.h）和库文件（.so或者.a）的集合。

要理解系统调用就要先理解程序代码运行的两种模式，一种是用户模式，一种是内核模式。我们编写的应用程序运行在用户模式下，而设备驱动程序和文件系统运行在内核模式。在用户模式下运行的程序受到严格的管理，不会破坏系统级应用。而在内核模式下运行的程序可以对电脑有完全的访问权。系统调用就是运行在内核模式下的代码为运行在用户模式下的代码提供服务。

系统调用的错误返回码是负数，定义在>errno.h<文件中。在系统调用中发生错误，C函数库就会用错误码填充全局变量errno。用perror()和strerror()函数可以输出错误信息。

系统调用多数在>unistd.h<中定义。

void main()表示程序没有参数，int main(int argc, char *argv[])表示程序要带参数，argc保存着参数的个数，argv[]数组保存着参数列表。如：

debian:~# mytest a b c 
argc: 4
argv: ["mytest","a","b","c"]

getopt()函数和getopt_long()用来处理程序选项。getopt_long()函数可以处理以"--"开头的选项。Gnu官方手册页：http://www.gnu.org/software/libc/manual/html_node/Getopt.html

获取命令行参数的示例代码：

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
   int opt;

   while((opt = getopt(argc,argv,"if:lr")) != -1)       /* 返回“-1”表示已没选项需要处理。*/
   {
           switch(opt){
           case 'i':
           case 'l':
           case 'r':
                   printf("option: %c\n", opt);
                   break;
           case 'f':
                   printf("filename: %s\n", optarg);           /*如果选项需要一个参数，则参数存放在外部变量optarg中。*/
                   break;
           case ':':
                   printf("option needs a value \n");          /*“：”表示选项需要参数*/
                   break;
           case '?':
                   printf("unknown option: %c\n", optopt);    /*返回“?”表示无效的选项，并把无效的选项存放在外部变量optopt中。*/
                   break;
           }
   }
   for(; optind < argc; optind++)                      /*外部变量optind指向下一个要处理的选项索引值。*/
           printf("argument: %s\n", argv[optind]);
}

在bash shell中使用set命令可以列出Linux系统的环境变量，在C程序中我们也可以用putenv()和getenv()函数来获取Linux系统的环境变量。这两个函数的声明如下：

char *getenv(const char *name);
int putenv(const char *string);

系统有一个environ变量记录了所有的系统变量。下面的示例代码可把environ的值显示同来。

#include <stdlib.h>
#include <stdio.h>

extern char **environ;

int main()
{
        char **env = environ;

        while(*env)
        {
                printf("%s\n",*env);
                env++;
        }
}

linux和其它unix一样，使用GMT1970年1月1日子夜作为系统时间的开始，也叫UNIX纪元的开始。现在的时间表示为UNIX纪元至今经过的秒数。

#include <time.h>
 time_t time(time_t *t);

显示系统时间的示例代码：
#include <time.h>
#include <stdio.h>
#include <unistd.h>

int main()
{
        int i;
        time_t the_time;

        for(i = 1; i <= 10; i++){
                the_time = time((time_t *)0);
                printf("%d  the time is %ld\n", i, the_time);
                sleep(2);
        }
}

用ctime()函数以友好方式返回当前时间，它的函数声明格式：

#include <time.h>
char *ctime(const time_t *timeval);

示例：
#include <time.h>
#include <stdio.h>

int main(void)
{
        time_t time1;

        (void)time(&time1);
        printf("The date is: %s\n",ctime(&time1));
}

程序输出：
The date is: Thu Dec  7 09:58:23 2006

用localtime()函数可以返回本地时间，它是一个tm结构，tm结构体的内容如下：

 struct tm
{
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
};

int tm_sec    Seconds, 0-61
int tm_min    Minutes, 0-59
int tm_hour   Hours, 0-23
int tm_mday   Day in the month, 1-31
int tm_mon    Month in the year, 0-11(January= 0)
int tm_year   Years since 1900
int tm_wday   Day in the week, 0-6. (Sunday = 0)
int tm_yday   Day in the year, 0-365
int tm_isdst  Daylight savings in effect

localtime()函数的使用方法如下：

函数声明：
#include <time.h>
struct tm *localtime(const time_t *timeval);

示例代码：
#include <time.h>
#include <stdio.h>

int main(void)
{
        time_t time1;
        struct tm *p;

        time1 = time(NULL);
        printf("The ctime is: %s\n",ctime(&time1));

        p = localtime(&time1);
        printf("The localtime is:\n tm_year+1900 = %d年\n tm_mon = %d月\n tm_mday = %d日\n wday = %d\n hour = %d 时\n min = %d分\n sec = %d秒\n",p->tm_year+1900,p->tm_mon,p->tm_mday,p->tm_wday,p->tm_hour,p->tm_min,p->tm_sec);
}
运行结果：
The ctime is: Thu Dec  7 10:31:36 2006

The localtime is:
 tm_year+1900 = 2006年
 tm_mon = 11月
 tm_mday = 7日
 wday = 4
 hour = 10 时
 min = 31分
 sec = 36秒

用mkstemp()函数创建临时文件。

#include<stdlib.h>
int mkstemp(char * template);

示例：
#include <stdio.h>

int main(void)
{
        char template[] = "template-XXXXXX";
        int fp;
        fp = mkstemp(template);
        printf("template = %s\n", template);
        close(fp);
}

获取用户信息。

声明：
#include <sys/types.h>
#include <pwd.h>
struct passwd *getpwuid(uid_t uid);   /* 根据uid返回用户信息 */
struct passwd *getpwnam(const char *name);   /* 根据用户名返回用户信息 */

passwd结构体说明：
passwd Member Description
char *pw_name          The user's login name
uid_t pw_uid             The UID number
gid_t pw_gid             The GID number
char *pw_dir            The user's home directory
char *pw_gecos        The user's full name
char *pw_shell         The user's default shell

示例代码：
#include <stdio.h>
#include <sys/types.h>
#include <stdio.h>
#include <pwd.h>

int main(void)
{
        uid_t uid;
        gid_t gid;
        struct passwd *pw;

        uid = getuid();
        gid = getgid();
        pw = getpwuid(uid);

        printf("User is %s\n", getlogin());
        printf("The uid is:%d\n", uid);
        printf("The gid is:%d\n",gid);
        printf("The pw struct:\n name=%s, uid=%d, gid=%d, home=%s,shell=%s\n", pw->pw_name, pw->pw_uid, pw->pw_gid, pw->pw_dir, pw->pw_shell);
}

用gethostname()函数获取主机名。

函数声明：
#include <unistd.h>
int gethostname(char *name, size_t namelen);    /* 主机名返回给name变量 */

示例代码：
#include <stdio.h>
#include <unistd.h>

int main(void)
{
        char computer[100];
        int status;

        status = gethostname(computer, 100);
        printf("The status is %d\n", status);
        printf("The hostname is: %s\n", computer);
}

用uname()函数获取主机详细信息，就像shell的uname命令返回的信息一样。

函数声明：
#include <sys/utsname.h>
int uname(struct utsname *name);

utsname结构体说明：
utsname Member                  Description
char sysname[]                  The operating system name
char nodename[]                 The host name
char release[]                  The release level of the system
char version[]                  The version number of the system
char machine[]                  The hardware type

示例代码：
#include <stdio.h>
#include <unistd.h>
#include <sys/utsname.h>

int main(void)
{
        char computer[100];
        int status;
        struct utsname uts;

        status = gethostname(computer,100);
        printf("The computer's size is %d\n",sizeof(computer));
        printf("The status is %d\n", status);
        printf("The hostname is: %s\n", computer);

        uname(&uts);
        printf("The uname's information.\n uts.sysname=%s\n uts.machine=%s\n uts.nodename=%s\n uts.release=%s\n uts.version=%s\n", uts.sysname,uts.machine,uts.nodename,uts.release,uts.version);
}

使用syslog()函数处理日志信息。

函数声明：
#include <syslog.h>
void syslog(int priority, const char *message, arguments...);

priority参数的格式（severity level|facility code）
示例： 
LOG_ERR|LOG_USER

severity level：
Priority Level               Description
LOG_EMERG                    An emergency situation
LOG_ALERT                    High-priority problem, such as database corruption
LOG_CRIT                     Critical error, such as hardware failure
LOG_ERR                      Errors
LOG_WARNING                  Warning
LOG_NOTICE                   Special conditions requiring attention
LOG_INFO                     Informational messages
LOG_DEBUG                    Debug messages

facility value（转自syslog.h头文件）：
/* facility codes */
#define LOG_KERN        (0<<3)  /* kernel messages */
#define LOG_USER        (1<<3)  /* random user-level messages */
#define LOG_MAIL        (2<<3)  /* mail system */
#define LOG_DAEMON      (3<<3)  /* system daemons */
#define LOG_AUTH        (4<<3)  /* security/authorization messages */
#define LOG_SYSLOG      (5<<3)  /* messages generated internally by syslogd */
#define LOG_LPR         (6<<3)  /* line printer subsystem */
#define LOG_NEWS        (7<<3)  /* network news subsystem */
#define LOG_UUCP        (8<<3)  /* UUCP subsystem */
#define LOG_CRON        (9<<3)  /* clock daemon */
#define LOG_AUTHPRIV    (10<<3) /* security/authorization messages (private) */
#define LOG_FTP         (11<<3) /* ftp daemon */

示例代码：
#include <syslog.h>
#include <stdio.h>

int main(void)
{
        FILE *f;

        f = fopen("abc","r");
        if(!f)                                    
                syslog(LOG_ERR|LOG_USER,"test - %m\n");       
}

上面的日志信息由系统自动给出，我们也可过滤日志信息。用到以下函数：

#include <syslog.h>
void closelog(void);
void openlog(const char *ident, int logopt, int facility);
int setlogmask(int maskpri);

logopt参数的选项：
logopt Parameter    Description
LOG_PID             Includes the process identifier, a unique number allocated to each process by the system, in the messages.
LOG_CONS            Sends messages to the console if they can’t be logged.
LOG_ODELAY          Opens the log facility at first call to .
LOG_NDELAY          Opens the log facility immediately, rather than at first log.

示例代码：
#include <syslog.h>
#include <stdio.h>
#include <unistd.h>

int main(void)
{
        int logmask;

        openlog("logmask", LOG_PID|LOG_CONS, LOG_USER); /*日志信息会包含进程id。*/
        syslog(LOG_INFO, "informative message, pid=%d", getpid()); 
        syslog(LOG_DEBUG,"debug message, should appear");   /*记录该日志信息。*/
        logmask = setlogmask(LOG_UPTO(LOG_NOTICE));     /*设置屏蔽低于NOTICE级别的日志信息。*/
        syslog(LOG_DEBUG, "debug message, should not appear");  /*该日志信息被屏蔽，不记录。*/
}

不同安全级别的日志信息存放在/var/log目录下的哪个文件中是由/etc/syslog.conf文件控制的，下面是我系统中syslog.conf文件的内容：

#  /etc/syslog.conf     Configuration file for syslogd.
#
#                       For more information see syslog.conf(5)
#                       manpage.

#
# First some standard logfiles.  Log by facility.
#

auth,authpriv.*                 /var/log/auth.log
*.*;auth,authpriv.none          -/var/log/syslog
#cron.*                         /var/log/cron.log
daemon.*                        -/var/log/daemon.log
kern.*                          -/var/log/kern.log
lpr.*                           -/var/log/lpr.log
mail.*                          -/var/log/mail.log
user.*                          -/var/log/user.log
uucp.*                          /var/log/uucp.log

#
# Logging for the mail system.  Split it up so that
# it is easy to write scripts to parse these files.
#
mail.info                       -/var/log/mail.info
mail.warn                       -/var/log/mail.warn
mail.err                        /var/log/mail.err

# Logging for INN news system
#
news.crit                       /var/log/news/news.crit
news.err                        /var/log/news/news.err
news.notice                     -/var/log/news/news.notice

#
# Some `catch-all' logfiles.
#
*.=debug;\
        auth,authpriv.none;\
        news.none;mail.none     -/var/log/debug
*.=info;*.=notice;*.=warn;\
        auth,authpriv.none;\
        cron,daemon.none;\
        mail,news.none          -/var/log/messages

#
# Emergencies are sent to everybody logged in.
#
*.emerg                         *

#
# I like to have messages displayed on the console, but only on a virtual
# console I usually leave idle.
#
#daemon,mail.*;\
#       news.=crit;news.=err;news.=notice;\
#       *.=debug;*.=info;\
#       *.=notice;*.=warn       /dev/tty8

# The named pipe /dev/xconsole is for the `xconsole' utility.  To use it,
# you must invoke `xconsole' with the `-file' option:
#
#    $ xconsole -file /dev/xconsole [...]
#
# NOTE: adjust the list below, or you'll go crazy if you have a reasonably
#      busy site..
#
daemon.*;mail.*;\
        news.crit;news.err;news.notice;\
        *.=debug;*.=info;\
        *.=notice;*.=warn       |/dev/xconsole

pid是进程的标识符，存放在pid_t结构的变量中。在一个进程中创建另一个进程时，这个新进程就是子进程，原来的进程就是父进程。子进程结束时会通知父进程。如果父进程结束而子进程没有结束，则子进程会成为孤儿进程。所有孤儿进程都会变成init进程的子进程。init进程是系统启动的第一个进程，它其中一个主要功能就是收集孤儿进程，以便内核将子进程从进程表中删除。通过getpid()和getppid()函数可以获得进程的pid。

使用open()函数打开串口，open()函数有两个参数，第一个是要打开的设备名（如：/dev/ttyS0）。第二个是打开的方式。打开方式有以下三种：

成功打开串口则会返回文件描述符，打开失败则返回-1。下面是一个打开串口的示例：

fd = open("/dev/ttyS0",O_RDWR|O_NDELAY|O_NDELAY);

使用close()关闭打开的串口，唯一的参数是打开串口的文件描述符。下面是一个关闭串口的示例：

close(fd);        //fd是打开串口返回的文件描述符

用write()函数向串口写数据。下面是一个向串口写数据的示例：

n = write(fd,buff,len);    
/* n表示成功写到串口的字节数，如果写入失败则返回-1
   fd是打开串口返回的文件描述符
   buff表示写入的内容
   len表示写入信息的长度。
*/

用read()函数从串口读取数据。下面是一个从串口读数据的示例：

n = read(fd,buff,len);
/* n表示从串口读到字节数
   fd是文件描述符
   buff是读入字节存放的缓冲区
   len表示读入的字节数
*/

通过fcntl()函数可以操作文件描述符，用以控制读取数据的状态。fcntl(fd,F_SETFL,0)表示没有数据则阻塞，处于等待状态，直到有数据到来；fcntl(fd,F_SETFL,FNDELAY)表示当端口没有数据时马上返回0。

所有的串口属性都在一个名为termios的结构体中，要使用该结构体要包含termios.h头文件。在该头文件中还定义两个重要的函数tcgetattr()和tcsetattr()，分别用以获取和设置串口的属性。如：tcgetattr(fd,&old_termios)，tcsetattr(fd,TCSANOW,&new_termios)。old_termios是旧的串口属性，new_termios是重新设置的新串口属性。tcsetattr()函数中常量的意义是：

termios结构体内容：

成员            描述
-------------------------------]]>


http://www.52RD.com/Blog/more.asp?name=wangxg97&id=6914
wangxg97
2007-3-18 11:41:00
ARM基础知识二

***************************************************************
程序状态寄存器
***************************************************************
　　CPSR(当前程序状态寄存器)在任何处理器模式下被访问。它包含了条件标志位、中断禁止位、当前处理器模式标志以及其他的一些控制和状态位。每一种处理器
　　模式下都有一个专用的物理状态寄存器，称为SPSR（备份程序状态寄存器）。当特定的异常中断发生时，这个寄存器用于存放当前程序状态寄存器的内容。在异常中断退出时，可以用SPSR来恢复CPSR。由于用户模式和系统模式不是异常
　　中断模式，所以他没有SPSR。当用户在用户模式或系统模式访问SPSR，将产生不可预知的后果。

　　CPSR格式如下所示。SPSR和CPSR格式相同。
 31  30  29  28  27           26           7  6  5  4  3  2  1  0
 N   Z   C   V   Q          DNM(RAZ)       I  F  T  M4 M3 M2 M1 M0

　　***条件标志位***

　　N——本位设置成当前指令运算结果的bit[31]的值。当两个表示的有符号整数运算时，n=1表示运算结果为负数，n=0表示结果为正书或零。
　　z——z=1表示运算的结果为零；z=0表示运算的结果不为零。对于CMP指令，Z=1表示进行比较的两个数大小相等。
　　C——下面分四种情况讨论C的设置方法：

　　 在加法指令中（包括比较指令CMP），当结果产生了进位,则C=1,表示无符号运算发生上溢出；其他情况C=0。
　　 在减法指令中（包括减法指令CMP），当运算中发生错位，则C=0，表示无符号运算数发生下溢出；其他情况下C=1。
　　 对于包含移位操作的非加碱运算指令，C中包含最后一次溢出的的位的数值
　　 对于其他非加减运算指令，C位的值通常不受影响

　　V——对于加减运算指令，当操作数和运算结果为二进制的补码表示的带符号数时，V=1表示符号为溢出；通常其他指令不影响V位。
　　***Q标识位***

　　在ARM V5的E系列处理器中，CPSR的bit[27]称为q标识位，主要用于指示增强的dsp指令是否发生了溢出。同样的spsr的bit[27]位也称为q标识位，用于在异常中
　　断发生时保存和恢复CPSR中的Q标识位。

　　在ARM V5以前的版本及ARM V5的非E系列的处理器中，Q标识位没有被定义。

　　***CPSR中的控制位***
　　CPSR的低八位I、F、T、M[4:0]统称为控制位。当异常中断发生时这些位发生变化。在特权级的处理器模式下，软件可以修改这些控制位。
　　**中断禁止位：当I=1时禁止IRQ中断，当F=1时禁止FIQ中断
　　**T控制位：T控制位用于控制指令执行的状态，即说明本指令是ARM指令还是Thumb指令。对于ARM V4以更高版本的T系列ARM处理器，T控制位含义如下：

T=0表示执行ARM指令
T=1表示执行Thumb指令

　　对于ARM V5以及更高版本的非T系列处理器，T控制位的含义如下
 
T=0表示执行ARM指令
T=1表示强制下一条执行的指令产生未定指令中断
　　***M控制位***
　　M控制位控制处理器模式，具体含义如下：
M[4:0]       处理器模式      可访问的寄存器
ob10000  user                  pc,r14~r0,CPSR
0b10001  FIQ                   PC,R14_FIQ-R8_FIQ,R7~R0,CPSR,SPSR_FIQ
0b10010  IRQ                   PC,R14_IRQ-R13_IRQ,R12~R0,CPSR,SPSR_IRQ
0B10011  SUPERVISOR     PC,R14_SVC-R13_SVC,R12~R0,CPSR,SPSR_SVC
0b10111  ABORT             PC,R14_ABT-R13_ABT,R12~R0,CPSR,SPSR_ABT
0b11011  UNDEFINEED     PC,R14_UND-R8_UND,R12~R0,CPSR,SPSR_UND
0b11111  SYSTEM           PC,R14-R0,CPSR(ARM V4以及更高版本）
　　***CPSR中的其他位***
　　这些位用于将来扩展。应用软件不要操作这些位。
]]>


http://www.52RD.com/Blog/more.asp?name=wangxg97&id=6913
wangxg97
2007-3-18 11:36:00
ARM基础知识一

ARM处理器共有37个寄存器。其中包括：
　　**31个通用寄存器，包括程序计数器（PC）在内。这些寄存器都是32位寄存器。
　　**6个状态寄存器。这些寄存器都是32位寄存器。
　　ARM处理器共有7种不同的处理器模式，每一种模式中都有一组相应的寄存器组。在任何时刻，可见的寄存器包括15个通用寄存器（R0-R14）,一个或两个状态寄存器及程序计数器（PC）。在所有的寄存器中，有些是各模式公用一个物理寄存器，有一些寄存器各模式拥有自己独立的物理寄存器。
****************************************************
通用寄存器
***************************************************8
　　通用寄存器分为以下三类：备份寄存器、未备份寄存器、程序计数器PC
　　未备份寄存器
　　未备份寄存器包括R0-R7。对于每一个未备份寄存器来说，所有处理器模式下都是使用同一个物理寄存器。未备份寄存器没有被系统用于特别的用途，任何可采用通用寄存器的场合都可以使用未备份寄存器。
　　备份寄存器
　　对于R8-R12备份寄存器来说，每个寄存器对应两个不同的物理寄存器。系统为将备份寄存器用于任何的特殊用途，但是当中断处理非常简单，仅仅使用R8-R14寄存器时，FIQ处理程序可以不必执行保存和恢复中断现场的指令，从而可以使中断处理非常迅速。
　　对于R13,R14备份寄存器来说，每个寄存器对应六个不同的物理寄存器，其中的一个是系统模式和用户模式共用的；另外的五个对应于其他的五种处理器模式。采用下面的记号来区分各个物理寄存器：
　　R13_<MODE>
　　其中MODE可以是下面几种模式之一：usr,svc,abt,und,irq,fiq
　　程序计数器PC
　　可以作为一般的通用寄存器使用，但有一些指令在使用R15时有一些限制。由于ARM采用了流水线处理器机制，当正确读取了PC的值时，该值为当前指令地址值加上8个字节。也就是说，对于ARM指令集来说，PC指向当前指令的下两条指令的地址。由于ARM指令是字对齐的，PC值的第0位和第一位总为0。
　　需要注意的是，当使用str/stm保存R15时，保存的可能是当前指令地址值加8个字节，也可能保存的是当前指令地址值加12个字节。到底哪种方式取决于芯片的具体设计。对于用户来说，尽量避免使用STR/STM指令来保存R15的值。

　　当成功的向R15写入一个数值时，程序将跳转到该地址执行。由于ARM指令是字对齐的，写入R15的值应满足bits[1:0]为0b00，具体要求arm个版本有所不同：

　　**对于arm3以及更低的版本，写入R15的地址值bits[1:0]被忽略，即写入r15的地址值将与0xFFFF FFFC做与操作。

　　**对于ARM4以及更高的版本，程序必须保证写入R15的地址值bits[1:0]为0b00，否则将产生不可预知的后果。

　　对于Thumb指令集来说，指令是班子对齐的，处理器将忽略bit[0]。
 
]]>


http://www.52RD.com/Blog/more.asp?name=wangxg97&id=6912
wangxg97
2007-3-18 11:21:00
ARM入门

1 ARM 的启动 

　　一般的嵌入式系统在主程序执行之前都需要执行一些初始化的过程以创造嵌入式程序运行的环境，尤其是一些高级的嵌入式系统，由于核心芯片使用内存映射、内存保护等机制以及编程使用高级语言 C,C++ 甚至 JAVA 语言，都需要先创建一个适合程序运行的硬件环境，然后初始化或者配置或者剪裁 run-time library, 这些工作都必须在主程序运行前完成，所以一个 startup 程序或者程序组对于一个嵌入式系统来说是非常重要的。要编写 startup 程序，需要对编译器、链接器和汇编器的细节有一定的了解，同时对 ARM 芯片硬件本身的地址分配以及 memory mapping 机制也需要有一些了解。 

　　2 ARM 程序的工作过程 

　　首先由各种 source file 经过编译产生 object 文件，然后 object 文件经过链接生成 Image 文件，然后通过 ICE 的方法，根据描述文件的指定下载到目标板上的固态存储器指定地址当中，比如 flash ， EEPROM, ROM 等等。在程序执行之前，根据某些描述文件，将需要读写数据的部分读出放入动态存储器比如 RAM 当中，然后程序从 ROM 开始执行。或者有时为了提高程序的运行速度，也可以将所有的程序 ( 有一些 root 的部分除外，以后会提及 ) 通过一个描述文件放入指定的 RAM 当中，然后程序从 RAM 开始执行，但是这样会耗费大量的动态存储器，所以大部分程序会取折中的方法，将需要快速运行的部分和要读写的部分放入 RAM 中 ( 一般读固态存储器的过程和动态存储器的过程是一样的，但是写就不同了，所以读写的部分一定要放到 RAM 中 ) ，而只读的部分和对速度要求不是那么高的部分放入固态存储器。同时 ARM 结构的异常向量表规定放在地址为 0x00000000 开始的地址空间上，而一般的 CPU 为了提高异常相应速度，会将这个向量段 remap 到其他的 RAM 当中，所以在描述文件当中必须精确指定异常向量跳转程序的地址到 remap 的地方。在 application 程序执行前，还需要由一些文件描述 application 程序执行的环境。比如系统工作时钟，总线频率。现在一般嵌入式编程语言为 C,C++ 等。如果在使用它们的时候使用的 runtime-library ，那么在程序执行前还需要为这些库函数初始化 heap 。然后 ARM 可能工作在不同的模式，还需要为不同的工作模式设置 stack 。这样，描述链接地址的文件，以及在 application 运行前所有的初始化程序就是 startup 程序组 

　　3 STARTUP 分类 

　　这样，将 startup 程序所完成的功能分类。一类是链接地址描述，一类是各种初始化的程序。根据不同的应用，描述文件和初始化程序的内容以及结构和复杂程度都会不同。但是基本上，它们都必须实现以下功能。 

　　3.1 描述文件实现功能 
　　描述文件可以是链接命令行上简单的几个字符，也可以是一个非常复杂的文件，但是它必须完成如下功能： 
　　; 指定程序下载的地址 
　　; 指定程序执行的地址 

　　3.2 初始化程序实现的功能 
　　初始化程序根据不同的应用，其结构和复杂度也不同，但是它必须完成如下基本功能： 
　　; 异常向量初始化 
　　; 内存环境初始化 
　　; 其他硬件环境初始化 
]]>


http://www.52RD.com/Blog/more.asp?name=wangxg97&id=6911
wangxg97
2007-3-18 11:13:00
ARM微处理器概述

1  ARM－Advanced RISC Machines 

　　ARM（Advanced RISC Machines），既可以认为是一个公司的名字，也可以认为是对一类微处理器的通称，还可以认为是一种技术的名字。

　　1991年ARM公司成立于英国剑桥，主要出售芯片设计技术的授权。目前，采用ARM技术知识产权（IP）核的微处理器，即我们通常所说的ARM微处理器，已遍及工业控制、消费类电子产品、通信系统、网络系统、无线系统等各类产品市场，基于ARM技术的微处理器应用约占据了32位RISC微处理器75％以上的市场份额，ARM技术正在逐步渗入到我们生活的各个方面。

　　ARM公司是专门从事基于RISC技术芯片设计开发的公司，作为知识产权供应商，本身不直接从事芯片生产，靠转让设计许可由合作公司生产各具特色的芯片，世界各大半导体生产商从ARM公司购买其设计的ARM微处理器核，根据各自不同的应用领域，加入适当的外围电路，从而形成自己的ARM微处理器芯片进入市场。目前，全世界有几十家大的半导体公司都使用ARM公司的授权，因此既使得ARM技术获得更多的第三方工具、制造、软件的支持，又使整个系统成本降低，使产品更容易进入市场被消费者所接受，更具有竞争力。 

　　2  ARM微处理器的应用领域及特点 

　　2.1  ARM微处理器的应用领域

　　到目前为止，ARM微处理器及技术的应用几乎已经深入到各个领域：

　　 1、工业控制领域：作为32的RISC架构，基于ARM核的微控制器芯片不但占据了高端微控制器市场的大部分市场份额，同时也逐渐向低端微控制器应用领域扩展，ARM微控制器的低功耗、高性价比，向传统的8位/16位微控制器提出了挑战。

　　2、无线通讯领域：目前已有超过85%的无线通讯设备采用了ARM技术， ARM以其高性能和低成本，在该领域的地位日益巩固。

　　3、网络应用：随着宽带技术的推广，采用ARM技术的ADSL芯片正逐步获得竞争优势。此外，ARM在语音及视频处理上行了优化，并获得广泛支持，也对DSP的应用领域提出了挑战。

　　4、消费类电子产品：ARM技术在目前流行的数字音频播放器、数字机顶盒和游戏机中得到广泛采用。

　　5、成像和安全产品：现在流行的数码相机和打印机中绝大部分采用ARM技术。手机中的32位SIM智能卡也采用了ARM技术。

　　除此以外，ARM微处理器及技术还应用到许多不同的领域，并会在将来取得更加广泛的应用。 
　　2.2  ARM微处理器的特点

　　采用RISC架构的ARM微处理器一般具有如下特点：

　　1、体积小、低功耗、低成本、高性能；
　　2、支持Thumb（16位）/ARM（32位）双指令集，能很好的兼容8位/16位器件；
　　3、大量使用寄存器，指令执行速度更快；
　　4、大多数数据操作都在寄存器中完成；
　　5、寻址方式灵活简单，执行效率高；
　　6、指令长度固定； 
　　3  ARM微处理器系列 

　　ARM微处理器目前包括下面几个系列，以及其它厂商基于ARM体系结构的处理器，除了具有ARM体系结构的共同特点以外，每一个系列的ARM微处理器都有各自的特点和应用领域。

－ ARM7系列
－ ARM9系列
－ ARM9E系列
－ ARM10E系列
－ SecurCore系列
－ Inter的Xscale
－ Inter的StrongARM

　　其中，ARM7、ARM9、ARM9E和ARM10为4个通用处理器系列，每一个系列提供一套相对独特的性能来满足不同应用领域的需求。SecurCore系列专门为安全要求较高的应用而设计。

　　以下我们来详细了解一下各种处理器的特点及应用领域。 

　　3.1  ARM7微处理器系列

　　ARM7系列微处理器为低功耗的32位RISC处理器，最适合用于对价位和功耗要求较高的消费类应用。ARM7微处理器系列具有如下特点：

－ 具有嵌入式ICE－RT逻辑，调试开发方便。
－ 极低的功耗，适合对功耗要求较高的应用，如便携式产品。
－ 能够提供0.9MIPS/MHz的三级流水线结构。
 － 代码密度高并兼容16位的Thumb指令集。
 － 对操作系统的支持广泛，包括Windows CE、Linux、Palm OS等。
－ 指令系统与ARM9系列、ARM9E系列和ARM10E系列兼容，便于用户的产品升级换代。
 － 主频最高可达130MIPS，高速的运算处理能力能胜任绝大多数的复杂应用。

　　ARM7系列微处理器的主要应用领域为：工业控制、Internet设备、网络和调制解调器设备、移动电话等多种多媒体和嵌入式应用。

　　ARM7系列微处理器包括如下几种类型的核：ARM7TDMI、ARM7TDMI-S、ARM720T、ARM7EJ。其中，ARM7TMDI是目前使用最广泛的32位嵌入式RISC处理器，属低端ARM处理器核。TDMI的基本含义为：

T： 支持16为压缩指令集Thumb；
D： 支持片上Debug；
M：内嵌硬件乘法器（Multiplier）
I： 嵌入式ICE，支持片上断点和调试点；
本书所介绍的Samsung公司的S3C4510B即属于该系列的处理器。 

　　3.2  ARM9微处理器系列

　　ARM9系列微处理器在高性能和低功耗特性方面提供最佳的性能。具有以下特点：

－ 5级整数流水线，指令执行效率更高。
－ 提供1.1MIPS/MHz的哈佛结构。
－ 支持32位ARM指令集和16位Thumb指令集。
－ 支持32位的高速AMBA总线接口。
－ 全性能的MMU，支持Windows CE、Linux、Palm OS等多种主流嵌入式操作系统。
－ MPU支持实时操作系统。
－ 支持数据Cache和指令Cache，具有更高的指令和数据处理能力。

　　ARM9系列微处理器主要应用于无线设备、仪器仪表、安全系统、机顶盒、高端打印机、数字照相机和数字摄像机等。

　　ARM9系列微处理器包含ARM920T、ARM922T和ARM940T三种类型，以适用于不同的应用场合。 
　　3.3  ARM9E微处理器系列

　　ARM9E系列微处理器为可综合处理器，使用单一的处理器内核提供了微控制器、DSP、Java应用系统的解决方案，极大的减少了芯片的面积和系统的复杂程度。ARM9E系列微处理器提供了增强的DSP处理能力，很适合于那些需要同时使用DSP和微控制器的应用场合。

　　ARM9E系列微处理器的主要特点如下：

－ 支持DSP指令集，适合于需要高速数字信号处理的场合。
－ 5级整数流水线，指令执行效率更高。
－ 支持32位ARM指令集和16位Thumb指令集。
－ 支持32位的高速AMBA总线接口。
－ 支持VFP9浮点处理协处理器。
－ 全性能的MMU，支持Windows CE、Linux、Palm OS等多种主流嵌入式操作系统。
－ MPU支持实时操作系统。
－ 支持数据Cache和指令Cache，具有更高的指令和数据处理能力。
－ 主频最高可达300MIPS。

　　ARM9系列微处理器主要应用于下一代无线设备、数字消费品、成像设备、工业控制、存储设备和网络设备等领域。

　　ARM9E系列微处理器包含ARM926EJ-S、ARM946E-S和ARM966E-S三种类型，以适用于不同的应用场合。 
　　3.4  ARM10E微处理器系列

　　ARM10E系列微处理器具有高性能、低功耗的特点，由于采用了新的体系结构，与同等的ARM9器件相比较，在同样的时钟频率下，性能提高了近50％，同时，ARM10E系列微处理器采用了两种先进的节能方式，使其功耗极低。

　　ARM10E系列微处理器的主要特点如下：

－ 支持DSP指令集，适合于需要高速数字信号处理的场合。
－ 6级整数流水线，指令执行效率更高。
－ 支持32位ARM指令集和16位Thumb指令集。
－ 支持32位的高速AMBA总线接口。
－ 支持VFP10浮点处理协处理器。
－ 全性能的MMU，支持Windows CE、Linux、Palm OS等多种主流嵌入式操作系统。
－ 支持数据Cache和指令Cache，具有更高的指令和数据处理能力
－ 主频最高可达400MIPS。
－ 内嵌并行读/写操作部件。

　　ARM10E系列微处理器主要应用于下一代无线设备、数字消费品、成像设备、工业控制、通信和信息系统等领域。

　　ARM10E系列微处理器包含ARM1020E、ARM1022E和ARM1026EJ-S三种类型，以适用于不同的应用场合。 
　　3.5  SecurCore微处理器系列

　　SecurCore系列微处理器专为安全需要而设计，提供了完善的32位RISC技术的安全解决方案，因此，SecurCore系列微处理器除了具有ARM体系结构的低功耗、高性能的特点外，还具有其独特的优势，即提供了对安全解决方案的支持。

　　SecurCore系列微处理器除了具有ARM体系结构各种主要特点外，还在系统安全方面具有如下的特点：

－ 带有灵活的保护单元，以确保操作系统和应用数据的安全。
－ 采用软内核技术，防止外部对其进行扫描探测。
－ 可集成用户自己的安全特性和其他协处理器。

　　SecurCore系列微处理器主要应用于一些对安全性要求较高的应用产品及应用系统，如电子商务、电子政务、电子银行业务、网络和认证系统等领域。

　　SecurCore系列微处理器包含SecurCore SC100、SecurCore SC110、SecurCore SC200和SecurCore SC210四种类型，以适用于不同的应用场合。 
　　3.6  StrongARM微处理器系列

　　Inter StrongARM SA-1100处理器是采用ARM体系结构高度集成的32位RISC微处理器。它融合了Inter公司的设计和处理技术以及ARM体系结构的电源效率，采用在软件上兼容ARMv4体系结构、同时采用具有Intel技术优点的体系结构。
Intel StrongARM处理器是便携式通讯产品和消费类电子产品的理想选择，已成功应用于多家公司的掌上电脑系列产品。 
　　3.7  Xscale处理器

　　Xscale 处理器是基于ARMv5TE体系结构的解决方案，是一款全性能、高性价比、低功耗的处理器。它支持16位的Thumb指令和DSP指令集，已使用在数字移动电话、个人数字助理和网络产品等场合。
Xscale 处理器是Inter目前主要推广的一款ARM微处理器。 
　　4  ARM微处理器结构 

　　4.1  RISC体系结构

　　传统的CISC（Complex Instruction Set Computer，复杂指令集计算机）结构有其固有的缺点，即随着计算机技术的发展而不断引入新的复杂的指令集，为支持这些新增的指令，计算机的体系结构会越来越复杂，然而，在CISC指令集的各种指令中，其使用频率却相差悬殊，大约有20％的指令会被反复使用，占整个程序代码的80％。而余下的80％的指令却不经常使用，在程序设计中只占20％，显然，这种结构是不太合理的。

　　基于以上的不合理性，1979年美国加州大学伯克利分校提出了RISC（Reduced Instruction Set Computer，精简指令集计算机）的概念，RISC并非只是简单地去减少指令，而是把着眼点放在了如何使计算机的结构更加简单合理地提高运算速度上。RISC结构优先选取使用频最高的简单指令，避免复杂指令；将指令长度固定，指令格式和寻地方式种类减少；以控制逻辑为主，不用或少用微码控制等措施来达到上述目的。

　　到目前为止，RISC体系结构也还没有严格的定义，一般认为，RISC体系结构应具有如下特点：

－ 采用固定长度的指令格式，指令归整、简单、基本寻址方式有2～3种。
－ 使用单周期指令，便于流水线操作执行。
－ 大量使用寄存器，数据处理指令只对寄存器进行操作，只有加载/ 存储指令可以访问存储器，以提高指令的执行效率。

　　除此以外，ARM体系结构还采用了一些特别的技术，在保证高性能的前提下尽量缩小芯片的面积，并降低功耗：

－ 所有的指令都可根据前面的执行结果决定是否被执行，从而提高指令的执行效率。
－ 可用加载/存储指令批量传输数据，以提高数据的传输效率。
－ 可在一条数据处理指令中同时完成逻辑处理和移位处理。
－ 在循环处理中使用地址的自动增减来提高运行效率。

　　当然，和CISC架构相比较，尽管RISC架构有上述的优点，但决不能认为RISC架构就可以取代CISC架构，事实上，RISC和CISC各有优势，而且界限并不那么明显。现代的CPU往往采用CISC的外围，内部加入了RISC的特性，如超长指令集CPU就是融合了RISC和CISC的优势，成为未来的CPU发展方向之一。 
　　4.2  ARM微处理器的寄存器结构

　　ARM处理器共有37个寄存器，被分为若干个组（BANK），这些寄存器包括：

－ 31个通用寄存器，包括程序计数器（PC指针），均为32位的寄存器。
－ 6个状态寄存器，用以标识CPU的工作状态及程序的运行状态，均为32位，目前只使用了其中的一部分。

　　同时，ARM处理器又有7种不同的处理器模式，在每一种处理器模式下均有一组相应的寄存器与之对应。即在任意一种处理器模式下，可访问的寄存器包括15个通用寄存器（R0～R14）、一至二个状态寄存器和程序计数器。在所有的寄存器中，有些是在7种处理器模式下共用的同一个物理寄存器，而有些寄存器则是在不同的处理器模式下有不同的物理寄存器。
关于ARM处理器的寄存器结构，在后面的相关章节将会详细描述。 

　　4.3  ARM微处理器的指令结构

　　ARM微处理器的在较新的体系结构中支持两种指令集：ARM指令集和Thumb指令集。其中，ARM指令为32位的长度，Thumb指令为16位长度。Thumb指令集为ARM指令集的功能子集，但与等价的ARM代码相比较，可节省30％～40％以上的存储空间，同时具备32位代码的所有优点。

　　关于ARM处理器的指令结构，在后面的相关章节将会详细描述。
  
　　ARM微处理器的应用选型

　　鉴于ARM微处理器的众多优点，随着国内外嵌入式应用领域的逐步发展，ARM微处理器必然会获得广泛的重视和应用。但是，由于ARM微处理器有多达十几种的内核结构，几十个芯片生产厂家，以及千变万化的内部功能配置组合，给开发人员在选择方案时带来一定的困难，所以，对ARM芯片做一些对比研究是十分必要的。

　　以下从应用的角度出发，对在选择ARM微处理器时所应考虑的主要问题做一些简要的探讨。

　　ARM微处理器内核的选择

　　从前面所介绍的内容可知，ARM微处理器包含一系列的内核结构，以适应不同的应用领域，用户如果希望使用WinCE或标准Linux等操作系统以减少软件开发时间，就需要选择ARM720T以上带有MMU（Memory Management Unit）功能的ARM芯片，ARM720T、ARM920T、ARM922T、ARM946T、Strong-ARM都带有MMU功能。而ARM7TDMI则没有MMU，不支持Windows CE和标准Linux，但目前有uCLinux等不需要MMU支持的操作系统可运行于ARM7TDMI硬件平台之上。事实上，uCLinux已经成功移植到多种不带MMU的微处理器平台上，并在稳定性和其他方面都有上佳表现。

　　本书所讨论的S3C4510B即为一款不带MMU的ARM微处理器，可在其上运行uCLinux操作系统。

　　系统的工作频率

　　系统的工作频率在很大程度上决定了ARM微处理器的处理能力。ARM7系列微处理器的典型处理速度为0.9MIPS/MHz，常见的ARM7芯片系统主时钟为20MHz-133MHz，ARM9系列微处理器的典型处理速度为1.1MIPS/MHz，常见的ARM9的系统主时钟频率为100MHz-233MHz，ARM10最高可以达到700MHz。不同芯片对时钟的处理不同，有的芯片只需要一个主时钟频率，有的芯片内部时钟控制器可以分别为ARM核和USB、UART、DSP、音频等功能部件提供不同频率的时钟。

　　芯片内存储器的容量

　　大多数的ARM微处理器片内存储器的容量都不太大，需要用户在设计系统时外扩存储器，但也有部分芯片具有相对较大的片内存储空间，如ATMEL的AT91F40162就具有高达2MB的片内程序存储空间，用户在设计时可考虑选用这种类型，以简化系统的设计。

　　片内外围电路的选择

　　除ARM微处理器核以外，几乎所有的ARM芯片均根据各自不同的应用领域，扩展了相关功能模块，并集成在芯片之中，我们称之为片内外围电路，如USB接口、IIS接口、LCD控制器、键盘接口、RTC、ADC和DAC、DSP协处理器等，设计者应分析系统的需求，尽可能采用片内外围电路完成所需的功能，这样既可简化系统的设计，同时提高系统的可靠性。
]]>


http://www.52RD.com/Blog/more.asp?name=wangxg97&id=6909
wangxg97
2007-3-17 11:31:00
S3c2410软件调试总结

S3c2410软件调试总结（一）

硬件平台介绍

我的硬件平台主要是 S3c2410 ＋ FPGA（cyclone EP1C6），出于成本的考虑，我买了一块2410的核心板，然后自己画了一块底板，主要的模块有：
S3c2410   ARM920 CORE RISC CPU
EP1C6   Altera cyclone series Fpga
AT89S52   atmel 51 
RTL8019as  10M network device
Sdram   x2  total: 64M byte
K9F5608   Nand flash 32M byte
AM29LV160D  x2  NOR flash total: 4M byte
64LV25616  SRAM  512K byte
UDA1341   IIS Interface 
24C256   EEPROM
USB   Host 1, Dev 1
SD interface
UART   x2
S3c2410软件调试总结（二）

   ADS下C语言的入口方式和ROM镜像文件的生成

这部分介绍下ADS下如何生成可以运行的ROM镜像文件，我们知道当程序下载到flash中运行的时候，对于RW、ZI数据就存在着两个环境，一个load环境，一个是exec环境，有时候由于速度的需要RO数据也要重新加载，那么对RO数据也是有两个环境。编译器产生ROM镜像文件时候，这三块数据的存放依次为RO、RW、ZI，并且地址空间时连续的。但是到了运行的时候，RW数据必须被拷贝到SDRAM（SRAM）中以支持读写，这就是我们所谓的运行环境。那么就要有一段代码去完成这个任务，在本章中我们介绍如何生成这段代码。

玩过2410的朋友都知道2410初始化代码中有一段搬运RW和ZI初始化的代码，没错，它确实能够在一定程度上完成上面所说的任务，只要我们在生成二进制可执行代码的时候在编译器链接项的地方填写正确的RO＆RW地址，（比如RO = 0, RW = 0x30000000), 那么将程序下到 NOR flash的零地址并从nor flash启动，启动代码会将RW＆ZI数据弄到0x30000000，程序就能跑起来了。

但是各位有没有想过，怎么把RO代码弄到SDRAM中（有时候这是必须的，比方后面我将提到用nor flash的bootloader烧写nor flash）？如果直接设RO＝0x30000000，那么这段代码下载到0地址肯定跑不起来，除非是ROPI，这个要求就高了。这里我们有必要从介绍ADS中规定的C语言入口开始，ADS中从初始化汇编代码跳到main函数有两种方式，main和__main：

1，在__main入口的模式下，汇编代码的指令为 b  __main, 编译器在跳转到main之前还要作一系列的工作，这其中就包括对运行环境的初始化，在<ADS COMPILE GUIDE>中提到： copies nonroot(RO&RW) execution regions from load addr to exec addr, and Zeros ZI region. 借助编译器，我们就可以定义更为复杂的运行环境，这里要用到scatter文件(.scf)，比如我们要的目标运行环境是：将启动代码以外的所有代码都 拷贝到SDRAM的初始地址中运行，比且把RW段设在0x30800000，那么对应的scf文件如下：
   
   FLASH 0x0  0x200000
   {
    EXEC1 0x0 0x200000
    {
     2410init.o(Init, +First)  
     __main.o(+RO)   ; copy code      
     * (Region$$Table)       ; RO/RW addresses to copy
     * (ZISection$$Table)    ; ZI addresses to zero
    }
    EXEC2 0x30000000 0x00800000
    {
     *(+RO)
    }
    SDRAM 0x30800000 0x00800000
    {
     *(+RW,+ZI)
    }
   }
  ;Sections named Region$$Table and ZISection$$Table which contain the addresses of the code/data to be copied. 

当然，在这种模式下，有些入口函数必须自己重定义，比如__user_initial_stackheap,具体参见ADS文档。

2, main入口模式即简单的跳转，这里起始不用“main”这个名字也无所谓。那么编译器不会作任何的初始化，所有运行环境的建立都要* 我们自己，这就是大家看到的那段搬运代码存在的理由。但是它实现一些简单的运行环境是可取的，如果用scf定义的复杂环境，虽然我 相信是可以做到的，但是可能会比较麻烦。我还没深究。

另外，这里提一下semihost，因为我们在看ADS的东西的时候经常出现这个词，我也一直受其困扰。这里我简单说一下自己的见解，semihost 仅仅是一种调试手段，它的机理就是利用MULTI_IDE等工具捕捉目标环境运行过程中产生的值为0x123456的SWI中断，然后向上位机的ADS 软件发送对应的调试信息。对于我们最后的应用代码来说，都是nonsemihost类型的。如果我们在调试中使用semihost，那么只要在最后重定义 ADS中的一些使用到的库函数（比如fputc），代码就可以从semihost向nonsemihost的类型转变。不过到目前为止，我还没体会到semihost的威力。
 
S3c2410软件调试总结（三）

2410启动代码分析

这一章主要对目前广泛流行的2410启动代码进行分析：S3C2410的初始化代码主要涉及到对系统主要模块的配置、运行环境的建立、系统时钟、MMU等模块的配置，下面按执行顺序依次都各个部分进行分析：

程序入口：（ResetHandler）
  在程序一开始，首先进行的一些操作主要保证初始化程序能够顺利的运行， 因此主要包括关闭WDT、中断，配置锁相环等。

配置memory接口
   memory接口是确保数据访问正确的基本保障，此处主要配置SFR寄存器中0x48000000开始的memory接口寄存器组，  确保每个bank的位宽、访问类型（waitable）以及时序参数正确。如果没有特别的要求，一般来说时序参数使用默认值即可。

初始化堆栈
   ARM有6种运行模式，必须为每一种模式提供独立的堆栈空间，在堆栈设置之前是不能进行C函数的调用的。ARM的堆栈模式 是从高地址递减的，我的所有代码统一将堆栈的首地址设在0x33ff8000处，往低依次为FIQ、IRQ、Abort、Undef、SVC，其中
  SVC和User模式不予区分。堆栈大小一般可在头文件或者当前文件中修改。

运行空间的初始化
   这段代码主要完成两个功能，一是将RW数据搬运到RW空间（我们生成ROM镜像时，RW数据是跟在RO数据之后的），二是 初始化ZI数据段。当然，这段代码存在的前提是代码的运行环境只是标准的两段式：一段RO空间和一段RW空间；并且在C程序
  入口时没有调用编译器的链接库（__main）。后者已经提供相应的功能，并且支持更加复杂的运行环境定义（使用SCF文件），
  （关于这一点，我在介绍ADS中C代码的启动模式时已经详细介绍）。

__rt_lib_init
   在ADS1.2的环境中，如果在C入口没有调用编译器的链接库（__main），那么在C程序一开始要调用该函数以初始化运行时的函数库，以保证对ADS提供的某些库函数能够正常调用。从这个函数开始，我们已经在C语言环境下了。

MMU初始化
   2410的MMU支持1级＆2级地址映射，在我们目前大部分应用中均采用1级section模式的地址映射，一个section的大小为1M，也就是说从逻辑地址到物理地址的转变是这样的一个过程：
   一个32位的地址，高12位决定了该地址在页表中的index，这个index的内容决定了该逻辑section对应的物理section；  低20位决定了该地址在section中的偏移（index）。
   因此从0x0～0xffffffff的地址空间总共可以分成0x1000（4K）个section，页表中每项的大小为32个bit，因此页表的大小为0x4000（16K）。在我的代码中所有程序的页表统一存放在地址0x33ff8000。
   每个页表项的内容如下:
  
          bit: 31                              20 19     12 11  10 9 8          5  4  3  2  1  0
   content:  Section对应的物理地址     NULL     AP   0  Domain   1  C B  1  0
   
      最低两位（10）是section分页的标识。
      AP：Access Permission，区分只读、读写、SVC＆其它模式。
   Domain：每个section都属于某个Domain，一个有16个Domain，每个Domain的属性由CP15的R3寄存器控制。 在我得所有程序中，都只包含两个Domain，一个是SFR地址以下（包括SFR）的空间，可访问；  另一个是SFR以上的空间，不可访问。
   C、B：这两位决定了该section的cache＆write buffer属性，这与该段的用途(RO or RW)有密切关系。不同的用途要做不同的设置。

       C     B                         具体含义
        0    0   无cache，无写缓冲，任何对memory的读写都反映到ASB总线上。  

                   对 memory 的操作过程中CPU需要等待。
        0    1   无cache，有写缓冲，读操作直接反映到ASB总线上。写操作CPU将数据写

                   入 到写缓冲后继续运行，由写缓冲进行ASB操作。
       1    0    有cache，写通模式，读操作首先考虑cache hit；写操作时直接将数据写入

                   写缓冲，如果同时出现cache hit，那么也更新cache。
      1    1    有cache，写回模式，读操作首先考虑cache hit；写操作也首先考虑cache，

                  如果hit，则只修改cache，并将cache对应半行的dirty比特置位；如果miss，

                   则写入写缓冲，触发ASB总线操作。
               
            在我的程序中内存空间的分配统一采用了文末的MEMORY图。虽然MMU只是使用了逻辑地址到物理地址的linear transfer（值不改变），但是由于MMU能够引入cache＆write buffer，因此系统性能有很大的提高！

配置时钟比、重新设置PLL
   2410内部有三个时钟：FCLK、HCLK、PCLK，分别供CPU、AHB总线和APB总线使用，为了降低功耗，一般都选择周期比为1：2：4的合理配置。 同时将PLL配置为运行环境时钟，一般都达到最高202M。

IO初始化
   将IO口配置为对应的功能选项，同时一般会点亮相应的LED灯。
   
中断初始化
   2410的内存空间没有remap的机制，应该中断入口时钟位于零地址。因此中断服务机制可以描述如下：
    首先，不管使用那种启动方式，必须确保一下代码段位于内存的0x0地址：
     b ResetHandler  
     b HandlerUndef ;handler for Undefined mode
     b HandlerSWI ;handler for SWI interrupt
     b HandlerPabort ;handler for PAbort
     b HandlerDabort ;handler for DAbort
     b .   ;reserved
     b HandlerIRQ ;handler for IRQ interrupt 
     b HandlerFIQ ;handler for FIQ interrupt
    除ResetHandler外，其余各项都是由如下的宏定义的一段代码：
       HandlerFIQ   HANDLER  HandleFIQ
     MACRO
     $HandlerLabel  HANDLER  $HandleLabel
     $HandlerLabel
      sub sp,sp,#4            ;decrement sp(to store jump address)
      stmfd sp!,{r0}        ;PUSH the work register to stack
      ldr     r0,=$HandleLabel  ;load the address of HandleXXX to r0
      ldr     r0,[r0]            ;load the contents
      str     r0,[sp,#4]     ;store the contents(ISR) of HandleXXX to stack
      ldmfd   sp!,{r0,pc}     ;POP the work register and pc(jump to ISR)
        MEND
      这段代码的含义是通过堆栈将中断向量表中的内容赋给PC指针（如HandleFIQ是存放着FIQ服务程序入口地址的地址），自然程序就跳到相应的入口地址。
   可见，中断向量表存放的是各个中断服务程序的入口地址，它是用来被加载的，而并不是可执行代码。为了统一，所有示例程序都将中断向量表放在0x33ffff00开始的地址，并根据入口地址依次排列。
   需要注意的是如果各种模式的服务程序用C语言定义，那么类型必须用__irq定义，以保证能够正确返回。
   
初始化串口
     串口统一选用UART0，模式采用115200、1bit STOP、No Parity。
  
最后跳转到我们自己的应用程序！

附：我得程序所使用的地址空间结构以及MMU中C、B的设置：

      Blank Area: RW_FAULT   0x5b000000 ～ 0xffffffff
      
      Sram & SFR: NCNB           0x40000000 ～ 0x4affffff
      
      Blank Area: RW_FAULT    0x34000000 ～ 0x3fffffff

      Int_Vec, Stack, MTT: CNB  0x33f00000 ～ 0x33ffffff
      
      SDRAM Download: NCNB   0x31000000 ～ 0x33efffff
      
      SDRAM Exec RW: CB         0x30800000 ～ 0x30ffffff
      
      SDRAM Exec R CNB        0x30000000 ～ 0x307fffff
      
      Bank5, FPGA: NCNB          0x28000000 ～ 0x2fffffff
      
      Bank4, FPGA: NCNB            0x20000000 ～ 0x27ffffff
      
      Bank3, Bottom NIC: NCNB   0x18000000 ～ 0x1fffffff
      
      Bank2, Bottom Flash: CNB  0x10000000 ～ 0x17ffffff
      
      Bank1, Bottom Sram: CNB   0x08000000  ～ 0x0fffffff
      
      Bank0, Flash or Sram: CNB  0x00000000 ～ 0x07ffffff
S3c2410软件调试总结（四）

Nor Flash Bootloader
   
这是我着手写的第一个程序，我的想法是让这个程序同时支持通过串口对Nand 和 Nor FLASH的烧写，如果不进行任何烧写，那么就跳到Nor Flash的第二个section启动应用程序，这样一来，即使脱离JTGA，我也可以使用串口进行盲调。

由于有现成的初始化文件和flash烧写的示例程序，开发起来还比较快。当然也遇到了一些问题，一开始连flash的device ID都读不出来，后来发现我指针没有定义成volatile类型，flash的操作时序被编译器优化了；再者，在对Nor Flash进行操作时，bank0在MMU中的类型一定要设为NCNB，这样比较保险。

遇到最大的问题就是下面的了，一开始我用jtag把程序下载到0x30000000的地方运行，对Nor Flash的烧写完全正常，但是当把程序下载到Nor Flash中启动运行后，再对Nor Flash的section 2进行烧写时，就出现了问题。所幸没多久我就意识到了问题，将程序放在Nor Flash中运行，同时有对同一片flash进行操作，那么操作时序势必会被CPU的指令读取时序所破坏，因此程序必须搬运到SDRAM中运行。

但是启动地址有必须是零地址，所以我采用了前文提到的scatter文件的方法，将非必要的代码全部搬到sdram中运行，scf文件格式就是前文中的那个。当然采用了__main的入口，调用了ADS的链接库，让它帮忙建立程序的运行环境。

至此，Nor Flash Bootloader可以顺畅无忧的实现其功能了。
 
S3c2410软件调试总结（后记&特别感谢）

  后记 & 特别感谢
  
第一次写这么洋洋洒洒的文章，想必垃圾成分一定很高，不过能有那么一点点有用的东西，我也就很高兴了。毕竟自己这么一路走过来，真的是满有感触的。

在此，特别要感谢版上twentyone朋友对我的大力帮助，在高人的指点下，我长进不小，另外我用的他开发的JTAG代理软件XJTAG，个人觉得性能相当不错，各位在用简易JTAG口的，强烈推荐大家尝试：http://www.twentyone.blogchina.com/

走到这一步，我只能说精彩的生活刚刚开始，接下来我会在linux和FPGA上作一些文章，这两方面的工作我都刚刚开始，远不够深入啊！非常乐意和大家一起探讨、学习、交流，让我们一起进步！
]]>


http://www.52RD.com/Blog/more.asp?name=wangxg97&id=6873
wangxg97
2007-3-14 23:15:00
 SDRAM学习笔记

1.SDRAM的burst mode：SDRAM是一种命令型动作的设备，就算读写资料只有一个也要先下命令才可以用，为了增加工作效率，就产生了一种传送一个命令，写多个数据的模式，这就是burst mode。
burst mode是一种利用内部列地址发生器来工作的高速读写模式，只要设置最开始的列地址，后面的地址就可以通过内部的列地址发生器来自动生成。
2.为什么要做precharge动作？ 关闭正在作用的SDRAM bank，算是一种结束命令，后面可以下新的命令。我想这是和SDRAM内部管理有关。(这是从网上查到的，感觉不够详细，也不太理解)
3.自动刷新功能？动态存储器（Dynamic RAM）都存在刷新问题。这里主要采用自动刷新方式，每隔一段时间向SDRAM发一条刷新命令。
4.SDRAM的地址线:在我们一般用的什么SRAM啊，PSRAM啊，RAM啊，一般而言都是有多少根地址线，然后可以算出寻址空间，比如有11根地址线，那寻址空间就是2的11次方减1。但是SDRAM是分列地址和行地址的，行、列地址线是复用的，所以有时候我们看到说寻址空间有多大多大，但是看看地址线怎么就那么几根啊，呵呵。SDRAM一般还有2根BANK的线，分成4个BANK，在有的处理器的SDRAM控制模块中，这两根线可能映射到地址线的某两根去。一般芯片常按照以下方式写芯片的配置，比如4Meg x 4 x 16，那这个芯片就是256Mbits。其中16指数据线是16根，中间一个4是只分4个BANK， 每个BANK是4Meg。
5.SDRAM的初始化:
SDRAM上电后使用前必须要经过一段初始化操作才可以使用。这个操作过程是标准的过程。这个过程如下 
A:   precharge 
B:   auto-refresh 
C:   Load Mode Register 
D: Normal Read/Write 
在上电后输入初始化命令值钱，最少要100us延迟（这个其实很容易满足，呵呵）。 
在输入precharge命令后，因为必须是对所有BANK进行Precharge，所以A10这个管脚要设置成高，因此在Precharge后面要做一个读的操作，这个操作最主要的是在SDRAM的寻址空间里设置的地址必须是A10是高的。 
在输入Auto-refresh命令后，一般要跟几句空操作或者读什么之类的，反正要达到延迟的目的，以使得SDRAM有时间来完成refresh。 
之后就是要设置SDRAM的模式寄存器，这个寄存器里一般设置了burst长度，CAS，burst类型，操作模式，还有是设置SDRAM是工作在单个读写操作还是burst操作下。而这个寄存器的设置也是通过地址线来设置的，所以在发出Load Mode Register命令后要做一个操作可是使得在SDRAM的地址线上出线的值就是你要设置的值。这里很有必要提醒的一下的是，这个操作是8位的操作，切记切记。 
设置完模式寄存器后就进入正常操作模式。 
实际上具体的操作要跟选用的处理器的SDRAM控制模块相结合来设置。对于这些初始化命令比较直观的理解就是拿逻辑分析仪来分析。 
在这里需要提醒一下CAS这个参数很重要。还有SDRAM必须要刷新的，因此刷新频率可以按照手册算出来的，但是设置的高一点也是可以的。常常SDRAM都有工作频率，但是也可以工作在低一点的频率上，比如PC133的，你工作到100也是可以的，设置基本不需要修改。
6.基本读写操作：
SDRAM的基本读操作需要控制线和地址线相配合地发出一系列命令来完成。先发出BANK激活命令（ACTIVE），并锁存相应的BANK地址（BA0、BA1给出）和行地址（A0～A12给出）。BANK激活命令后必须等待大于tRCD(SDRAM的RAS到CAS的延迟指标)时间后，发出读命令字。CL（CAS延迟值）个工作时钟后，读出数据依次出现在数据总线上。在读操作的最后，要向SDRAM发出预充电（PRECHARGE）命令，以关闭已经激活的页。等待tRP时间（PRECHARGE）命令，以关闭已经激活的页。等待tRP时间（PRECHAREG命令后，相隔tRP时间，才可再次访问该行）后，可以开始下一次的读、写操作。SDRAM的读操作只有突发模式（Burst Mode），突发长度为1、2、4、8可选。 
SDRAM的基本写操作也需要控制线和地址线相配合地发出一系列命令来完成。先发出BANK激活命令（ACTIVE），并锁存相应的BANK地址（BA0、BA1给出）和行地址（A0～A12给出）。BANK激活命令后必须等待大于tRCD的时间后，发出写命令字。写命令可以立即写入，需写入数据依次送到DQ（数据线）上。在最后一个数据写入后延迟tWR时间。发出预充电命令，关闭已经激活的页。等待tRP时间后，可以展开下一次操作。写操作可以有突发写和非突发写两种。突发长度同读操作。 
7.其他：我们有时候看到有的原理图上数据线有倒过来接的，其实这个无所谓的，反过接，写进去的就是反的，但是读出又反了一下，反反两次正好没反。 
延伸一下到DDR，其实DDR就是SDRAM外面加了一个乌龟壳。因此初始化是一样的。当然DDR一是多了一个把时钟频率反相的时钟，因此有2个相位差180度的时钟。这两个一般都是用同一个时钟源产生，一致性会比较好。还有多了2个DQS，这个也是一个时序要求，一般CPU的控制模块都有设置好了。如果你使用的CPU不含有控制模块，那用FPGA去做一个控制模块的话，那就要好好研究时序了。 
在有些处理器的控制模块中，由于EMI的设置，地址线映射关系复杂，因此推算会比较麻烦，一般如果没有什么映射的话，还是很容易操作的。
]]>


http://www.52RD.com/Blog/more.asp?name=wangxg97&id=6869
wangxg97
2007-3-14 20:32:00




ARM启动代码设计



基于ARM的芯片多数为复杂的片上系统，这种复杂系统里的多数硬件模块都是可配置的，需要由软件来设置其需要的工作状态。因此在用户的应用程序之前，需要由专门的一段代码来完成对系统的初始化。由于这类代码直接面对处理器内核和硬件控制器进行编程，一般都是用汇编语言。一般通用的内容包括： 
中断向量表
初始化存储器系统
初始化堆栈
初始化有特殊要求的断口，设备
初始化用户程序执行环境
改变处理器模式
呼叫主应用程序 
1. 中断向量表
ARM要求中断向量表必须放置在从0地址开始，连续8X4字节的空间内。
每当一个中断发生以后，ARM处理器便强制把PC指针置为向量表中对应中断类型的地址值。因为每个中断只占据向量表中1个字的存储空间，只能放置一条ARM指令，使程序跳转到存储器的其他地方，再执行中断处理。
中断向量表的程序实现通常如下表示：
AREA Boot ,CODE, READONLY
ENTRY
B    ResetHandler
B    UndefHandler
B    SWIHandler
B    PreAbortHandler
B    DataAbortHandler
B
B    IRQHandler
B    FIQHandler
其中关键字ENTRY是指定编译器保留这段代码，因为编译器可能会认为这是一段亢余代码而加以优化。链接的时候要确保这段代码被链接在0地址处，并且作为整个程序的入口。 
2. 初始化存储器系统
(1)存储器类型和时序配置
通常Flash和SRAM同属于静态存储器类型，可以合用同一个存储器端口；而DRAM因为有动态刷新和地址线复用等特性，通常配有专用的存储器端口。
存储器端口的接口时序优化是非常重要的，这会影响到整个系统的性能。因为一般系统运行的速度瓶颈都存在于存储器访问，所以存储器访问时序应尽可能的快；而同时又要考虑到由此带来的稳定性问题。
(2)存储器地址分布
一种典型的情况是启动ROM的地址重映射。
3. 初始化堆栈
因为ARM有7种执行状态，每一种状态的堆栈指针寄存器（SP）都是独立的。因此，对程序中需要用到的每一种模式都要给SP定义一个堆栈地址。方法是改变状态寄存器内的状态位，使处理器切换到不同的状态，让后给SP赋值。注意：不要切换到User模式进行User模式的堆栈设置，因为进入User模式后就不能再操作CPSR回到别的模式了，可能会对接下去的程序执行造成影响。
这是一段堆栈初始化的代码示例，其中只定义了三种模式的SP指针：
MRS   R0,CPSR
BIC    R0,R0,#MODEMASK  安全起见，屏蔽模式位以外的其他位
ORR   R1,R0,#IRQMODE
MSR   CPSR_cxfs,R1
LDR   SP,=UndefStack
 
ORR   R1,R0,#FIQMODE
MSR   CPSR_cxsf,R1
LDR   SP,=FIQStack
 
ORR   R1,R0,#SVCMODE
MSR   CPSR_cxsf,R1
LDR   SP,=SVCStack
4. 初始化有特殊要求的端口，设备
5. 初始化应用程序执行环境
映像一开始总是存储在ROM／Flash里面的，其RO部分即可以在ROM／Flash里面执行，也可以转移到速度更快的RAM中执行；而RW和ZI这两部分是必须转移到可写的RAM里去。所谓应用程序执行环境的初始化，就是完成必要的从ROM到RAM的数据传输和内容清零。
下面是在ADS下，一种常用存储器模型的直接实现：
LDR    r0,=|Image$$RO$$Limit|      ;得到RW数据源的起始地址
LDR    r1,=|Image$$RW$$Base|      ;RW区在RAM里的执行区起始地址
LDR    r2,=|Image$$ZI$$Base|        ;ZI区在RAM里面的起始地址
CMP    r0,r1                      ;比较它们是否相等
      BEQ    %F1
0     CMP    r1,r3
      LDRCC  r2,[r0],#4
      STRCC  r2,[r1],#4
      BCC    %B0
1     LDR    r1,=|Image$$ZI$$Limit|
      MOV   r2,#0
2     CMP    r3,r1
      STRCC  r2,[r3],#4
      BCC    %B2
程序实现了RW数据的拷贝和ZI区域的清零功能。其中引用到的4个符号是由链接器第一输出的。
|Image$$RO$$Limit|：表示RO区末地址后面的地址，即RW数据源的起始地址
|Image$$RW$$Base|：RW区在RAM里的执行区起始地址，也就是编译器选项RW_Base指定的地址
|Image$$ZI$$Base|：ZI区在RAM里面的起始地址
|Image$$ZI$$Limit|：ZI区在RAM里面的结束地址后面的一个地址
程序先把ROM里|Image$$RO$$Limt|开始的RW初始数据拷贝到RAM里面|Image$$RW$$Base|开始的地址，当RAM这边的目标地址到达|Image$$ZI$$Base|后就表示RW区的结束和ZI区的开始，接下去就对这片ZI区进行清零操作，直到遇到结束地址|Image$$ZI$$Limit|
6. 改变处理器模式
因为在初始化过程中，许多操作需要在特权模式下才能进行（比如对CPSR的修改），所以要特别注意不能过早的进入用户模式。
内核级的中断使能也可以考虑在这一步进行。如果系统中另外存在一个专门的中断控制器，这么做总是安全的。
7. 呼叫主应用程序
当所有的系统初始化工作完成之后，就需要把程序流程转入主应用程序。最简单的一种情况是：
IMPORT main
B      main
直接从启动代码跳转到应用程序的主函数入口，当然主函数名字可以由用户随便定义。
在ARM ADS环境中，还另外提供了一套系统级的呼叫机制。
IMPORT __main
B     __main
__main()是编译系统提供的一个函数，负责完成库函数的初始化和初始化应用程序执行环境，最后自动跳转到main()函数。
]]>