一、函数的调用语法
函数调用，很像变量的使用，也是以“$”来标识的，其语法如下：
$(<function> <arguments> ) 
或是
${<function> <arguments>}

这里，<function>就是函数名，make支持的函数不多。<arguments>是函数的参数，参数 
间以逗号“,”分隔，而函数名和参数之间以“空格”分隔。函数调用以“$”开头，以圆 
括号或花括号把函数名和参数括起。感觉很像一个变量，是不是？函数中的参数可以使 
用变量，为了风格的统一，函数和变量的括号最好一样，如使用“$(substa,b,$(x))”这 
样的形式，而不是“$(substa,b,${x})”的形式。因为统一会更清楚，也会减少一些不必 
要的麻烦。
还是来看一个示例：
comma:= , 
empty:= 
space:= $(empty) $(empty) 
foo:= a b c 
bar:= $(subst $(space),$(comma),$(foo))
在这个示例中，$(comma)的值是一个逗号。$(space)使用了$(empty)定义了一个空格， 
$(foo)的值是“a b c”，$(bar)的定义用，调用了函数“subst”，这是一个替换函数，这 
个函数有三个参数，第一个参数是被替换字串，第二个参数是替换字串，第三个参数 
是替换操作作用的字串。这个函数也就是把$(foo)中的空格替换成逗号，所以$(bar)的值 
是“a,b,c”。

二、字符串处理函数

$(subst <from>,<to>,<text> )

名称：字符串替换函数——subst。 
功能：把字串<text>中的<from>字符串替换成<to>。 
返回：函数返回被替换过后的字符串。

示例：
$(subst ee,EE,feet on the street)，
把“feetonthestreet”中的“ee”替换成“EE”，返回结果是“fEEtonthestrEEt”。

$(patsubst <pattern>,<replacement>,<text> ) 

名称：模式字符串替换函数——patsubst。 
功能：查找<text>中的单词（单词以“空格”、“Tab”或“回车”“换行”分隔）是否 
符合模式<pattern>，如果匹配的话，则以<replacement>替换。这里，<pattern>可以包括 
通配符“%”，表示任意长度的字串。如果<replacement>中也包含“%”，那么， 
<replacement>中的这个“%”将是<pattern>中的那个“%”所代表的字串。（可以用“\” 
来转义，以“\%”来表示真实含义的“%”字符） 
返回：函数返回被替换过后的字符串。

示例：
$(patsubst %.c,%.o,x.c.c bar.c)
把字串“x.c.cbar.c”符合模式[%.c]的单词替换成[%.o]，返回结果是“x.c.obar.o”
备注：
这和我们前面“变量章节”说过的相关知识有点相似。如：

“$(var:<pattern>=<replacement> )” 
相当于 
“$(patsubst <pattern>,<replacement>,$(var))”，

而“$(var:<suffix>=<replacement>)” 
则相当于 
“$(patsubst %<suffix>,%<replacement>,$(var))”。

例如有：objects=foo.obar.obaz.o， 
那么，“$(objects:.o=.c)”和“$(patsubst%.o,%.c,$(objects))”是一样的。

$(strip <string> )

名称：去空格函数——strip。 
功能：去掉<string>字串中开头和结尾的空字符。 
返回：返回被去掉空格的字符串值。 
示例：
$(strip a b c )
把字串“abc”去到开头和结尾的空格，结果是“abc”。
$(findstring <find>,<in> )

名称：查找字符串函数——findstring。 

功能：在字串<in>中查找<find>字串。 
返回：如果找到，那么返回<find>，否则返回空字符串。 
示例：
$(findstring a,a b c) 
$(findstring a,b c)
第一个函数返回“a”字符串，第二个返回“”字符串（空字符串）
$(filter <pattern...>,<text> )
名称：过滤函数——filter。 
功能：以<pattern>模式过滤<text>字符串中的单词，保留符合模式<pattern>的单词。可 
以有多个模式。 
返回：返回符合模式<pattern>的字串。 
示例：

sources := foo.c bar.c baz.s ugh.h 
foo: $(sources) 
cc $(filter %.c %.s,$(sources)) -o foo

$(filter %.c %.s,$(sources))返回的值是“foo.c bar.c baz.s”。

$(filter-out <pattern...>,<text> )

名称：反过滤函数——filter-out。 
功能：以<pattern>模式过滤<text>字符串中的单词，去除符合模式<pattern>的单词。可 
以有多个模式。 
返回：返回不符合模式<pattern>的字串。 
示例：

objects=main1.o foo.o main2.o bar.o 
mains=main1.o main2.o

$(filter-out $(mains),$(objects)) 返回值是“foo.o bar.o”。

$(sort <list> )

名称：排序函数——sort。 
功能：给字符串<list>中的单词排序（升序）。 
返回：返回排序后的字符串。 
示例：$(sortfoobarlose)返回“barfoolose”。 
备注：sort函数会去掉<list>中相同的单词。 

$(word <n>,<text> )

名称：取单词函数——word。 
功能：取字符串<text>中第<n>个单词。（从一开始） 
返回：返回字符串<text>中第<n>个单词。如果<n>比<text>中的单词数要大，那么返回 
空字符串。 
示例：$(word2,foobarbaz)返回值是“bar”。

$(wordlist <s>,<e>,<text> )

名称：取单词串函数——wordlist。 
功能：从字符串<text>中取从<s>开始到<e>的单词串。<s>和<e>是一个数字。 
返回：返回字符串<text>中从<s>到<e>的单词字串。如果<s>比<text>中的单词数要大， 
那么返回空字符串。如果<e>大于<text>的单词数，那么返回从<s>开始，到<text>结束 
的单词串。 
示例：$(wordlist2,3,foobarbaz)返回值是“barbaz”。

$(words <text> )

名称：单词个数统计函数——words。 
功能：统计<text>中字符串中的单词个数。 
返回：返回<text>中的单词数。 
示例：$(words,foobarbaz)返回值是“3”。 
备注：如果我们要取<text>中最后的一个单词，我们可以这样：$(word $(words 
<text> ),<text> )。

$(firstword <text> )

名称：首单词函数——firstword。 
功能：取字符串<text>中的第一个单词。 
返回：返回字符串<text>的第一个单词。 
示例：$(firstwordfoobar)返回值是“foo”。 
备注：这个函数可以用word函数来实现：$(word1,<text>)。

以上，是所有的字符串操作函数，如果搭配混合使用，可以完成比较复杂的功能。这里， 
举一个现实中应用的例子。我们知道，make使用“VPATH”变量来指定“依赖文件”的 
搜索路径。于是，我们可以利用这个搜索路径来指定编译器对头文件的搜索路径参数 
CFLAGS，如：

override CFLAGS += $(patsubst %,-I%,$(subst :, ,$(VPATH)))

如果我们的“$(VPATH)”值是“src:../headers”，那么“$(patsubst %,-I%,$(subst :, , 
$(VPATH)))”将返回“-Isrc -I../headers”，这正是 cc 或 gcc 搜索头文件路径的参数。 

三、文件名操作函数

下面我们要介绍的函数主要是处理文件名的。每个函数的参数字符串都会被当做一个或 
是一系列的文件名来对待。

$(dir <names...> )

名称：取目录函数——dir。 
功能：从文件名序列<names>中取出目录部分。目录部分是指最后一个反斜杠（“/”） 
之前的部分。如果没有反斜杠，那么返回“./”。 
返回：返回文件名序列<names>的目录部分。 
示例：$(dirsrc/foo.chacks)返回值是“src/./”。

$(notdir <names...> )

名称：取文件函数——notdir。 
功能：从文件名序列<names>中取出非目录部分。非目录部分是指最后一个反斜杠（“/ 
”）之后的部分。 
返回：返回文件名序列<names>的非目录部分。 
示例：$(notdirsrc/foo.chacks)返回值是“foo.chacks”。

$(suffix <names...> )

名称：取后缀函数——suffix。 
功能：从文件名序列<names>中取出各个文件名的后缀。 
返回：返回文件名序列<names>的后缀序列，如果文件没有后缀，则返回空字串。 
示例：$(suffixsrc/foo.csrc-1.0/bar.chacks)返回值是“.c.c”。

$(basename <names...> )

名称：取前缀函数——basename。 
功能：从文件名序列<names>中取出各个文件名的前缀部分。 
返回：返回文件名序列<names>的前缀序列，如果文件没有前缀，则返回空字串。 
示例：$(basenamesrc/foo.csrc-1.0/bar.chacks)返回值是“src/foosrc-1.0/barhacks”。

$(addsuffix <suffix>,<names...> )

名称：加后缀函数——addsuffix。 
功能：把后缀<suffix>加到<names>中的每个单词后面。 
返回：返回加过后缀的文件名序列。 
示例：$(addsuffix.c,foobar)返回值是“foo.cbar.c”。 

$(addprefix <prefix>,<names...> )

名称：加前缀函数——addprefix。 
功能：把前缀<prefix>加到<names>中的每个单词后面。 
返回：返回加过前缀的文件名序列。 
示例：$(addprefixsrc/,foobar)返回值是“src/foosrc/bar”。

$(join <list1>,<list2> )

名称：连接函数——join。 
功能：把<list2>中的单词对应地加到<list1>的单词后面。如果<list1>的单词个数要比 
<list2>的多，那么，<list1>中的多出来的单词将保持原样。如果<list2>的单词个数要比 
<list1>多，那么，<list2>多出来的单词将被复制到<list2>中。 
返回：返回连接过后的字符串。 
示例：$(joinaaabbb,111222333)返回值是“aaa111bbb222333”。

 
四、foreach函数

foreach 函数和别的函数非常的不一样。因为这个函数是用来做循环用的，Makefile 中的 
foreach 函数几乎是仿照于 Unix 标准 Shell（/bin/sh）中的 for 语句，或是 C-Shell 
（/bin/csh）中的foreach语句而构建的。它的语法是：

$(foreach <var>,<list>,<text> )

这个函数的意思是，把参数<list>中的单词逐一取出放到参数<var>所指定的变量中， 
然后再执行<text>所包含的表达式。每一次<text>会返回一个字符串，循环过程中， 
<text>的所返回的每个字符串会以空格分隔，最后当整个循环结束时，<text>所返回的 
每个字符串所组成的整个字符串（以空格分隔）将会是foreach函数的返回值。

所以，<var>最好是一个变量名，<list>可以是一个表达式，而<text>中一般会使用 
<var>这个参数来依次枚举<list>中的单词。举个例子： 

names := a b c d

files := $(foreach n,$(names),$(n).o)

上面的例子中，$(name)中的单词会被挨个取出，并存到变量“n”中，“$(n).o”每次根 
据“$(n)”计算出一个值，这些值以空格分隔，最后作为foreach函数的返回，所以， 
$(files)的值是“a.o b.o c.o d.o”。

注意，foreach中的<var>参数是一个临时的局部变量，foreach函数执行完后，参数 
<var>的变量将不在作用，其作用域只在 foreach 函数当中。

五、if函数

if 函数很像 GNU 的 make 所支持的条件语句——ifeq（参见前面所述的章节），if 函数 
的语法是：

$(if <condition>,<then-part> )

或是

$(if <condition>,<then-part>,<else-part> )

可见，if函数可以包含“else”部分，或是不含。即if函数的参数可以是两个，也可以是 
三个。<condition>参数是if的表达式，如果其返回的为非空字符串，那么这个表达式就 

相当于返回真，于是，<then-part>会被计算，否则<else-part>会被计算。

 
而if函数的返回值是，如果<condition>为真（非空字符串），那个<then-part>会是整 
个函数的返回值，如果<condition>为假（空字符串），那么<else-part>会是整个函数的 
返回值，此时如果<else-part>没有被定义，那么，整个函数返回空字串。 
所以，<then-part>和<else-part>只会有一个被计算。

六、call函数

call 函数是唯一一个可以用来创建新的参数化的函数。你可以写一个非常复杂的表达式， 
这个表达式中，你可以定义许多参数，然后你可以用call函数来向这个表达式传递参 
数。其语法是：

$(call <expression>,<parm1>,<parm2>,<parm3>...)

当make执行这个函数时，<expression>参数中的变量，如$(1)，$(2)，$(3)等，会被参 
数<parm1>，<parm2>，<parm3>依次取代。而<expression>的返回值就是call函数的返 
回值。例如：

reverse = $(1) $(2)

foo = $(call reverse,a,b)

那么，foo的值就是“ab”。当然，参数的次序是可以自定义的，不一定是顺序的，如： 

reverse = $(2) $(1)

foo = $(call reverse,a,b)

此时的foo的值就是“ba”。 
七、origin函数 
origin 函数不像其它的函数，他并不操作变量的值，他只是告诉你你的这个变量是哪里 
来的？其语法是： 
$(origin <variable> )

注意，<variable>是变量的名字，不应该是引用。所以你最好不要在<variable>中使用“ 
$”字符。Origin 函数会以其返回值来告诉你这个变量的“出生情况”，下面，是 origin 
函数的返回值:

“undefined” 
如果<variable>从来没有定义过，origin函数返回这个值“undefined”。 
“default”

如果<variable>是一个默认的定义，比如“CC”这个变量，这种变量我们将在后面讲述。 

“environment” 
如果<variable>是一个环境变量，并且当Makefile被执行时，“-e”参数没有被打开。

“file”

如果<variable>这个变量被定义在Makefile中。 
“command line”

如果<variable>这个变量是被命令行定义的。

 
“override”

如果<variable>是被override指示符重新定义的。

 
“automatic” 
如果<variable>是一个命令运行中的自动化变量。关于自动化变量将在后面讲述。 
这些信息对于我们编写Makefile是非常有用的，例如，假设我们有一个Makefile其包 
了一个定义文件Make.def，在Make.def中定义了一个变量“bletch”，而我们的环境中 
也有一个环境变量“bletch”，此时，我们想判断一下，如果变量来源于环境，那么我 
们就把之重定义了，如果来源于Make.def或是命令行等非环境的，那么我们就不重新 
定义它。于是，在我们的Makefile中，我们可以这样写： 
ifdef bletch 

ifeq "$(origin bletch)" "environment" 
bletch = barf, gag, etc. 
endif 
endif 
当然，你也许会说，使用override关键字不就可以重新定义环境中的变量了吗？为什 
么需要使用这样的步骤？是的，我们用override是可以达到这样的效果，可是override 
过于粗暴，它同时会把从命令行定义的变量也覆盖了，而我们只想重新定义环境传来 
的，而不想重新定义命令行传来的。

八、shell函数

shell 函数也不像其它的函数。顾名思义，它的参数应该就是操作系统 Shell 的命令。它和 
反引号“`”是相同的功能。这就是说，shell函数把执行操作系统命令后的输出作为函数 
返回。于是，我们可以用操作系统命令以及字符串处理命令awk，sed等等命令来生成 
一个变量，如：

contents := $(shell cat foo)

files := $(shell echo *.c)

注意，这个函数会新生成一个Shell程序来执行命令，所以你要注意其运行性能，如果 
你的Makefile中有一些比较复杂的规则，并大量使用了这个函数，那么对于你的系统 
性能是有害的。特别是Makefile的隐晦的规则可能会让你的shell函数执行的次数比你 
想像的多得多。

1. os.system

import os
import tempfile

filename1 = tempfile.mktemp (".txt")
open (filename1, "w").close ()
filename2 = filename1 + ".copy"
print filename1, "=>", filename2

#拷文件
os.system ("copy %s %s" % (filename1, filename2))

if os.path.isfile (filename2): print "Success"

dirname1 = tempfile.mktemp (".dir")
os.mkdir (dirname1)
dirname2 = dirname1 + ".copy"
print dirname1, "=>", dirname2

#拷目录
os.system ("xcopy /s %s %s" % (dirname1, dirname2))

if os.path.isdir (dirname2): print "Success"

2. shutil.copy和shutil.copytree

import os
import shutil
import tempfile

filename1 = tempfile.mktemp (".txt")
open (filename1, "w").close ()
filename2 = filename1 + ".copy"
print filename1, "=>", filename2

#拷文件
shutil.copy (filename1, filename2)

if os.path.isfile (filename2): print "Success"

dirname1 = tempfile.mktemp (".dir")
os.mkdir (dirname1)
dirname2 = dirname1 + ".copy"
print dirname1, "=>", dirname2

#拷目录
shutil.copytree (dirname1, dirname2)

if os.path.isdir (dirname2): print "Success"

3.  win32file.CopyFile

import os
import win32file
import tempfile

filename1 = tempfile.mktemp (".txt")
open (filename1, "w").close ()
filename2 = filename1 + ".copy"
print filename1, "=>", filename2

#拷文件
#文件已存在时，1为不覆盖，0为覆盖
win32file.CopyFile (filename1, filename2, 1)
win32file.CopyFile (filename1, filename2, 0)
win32file.CopyFile (filename1, filename2, 1)

if os.path.isfile (filename2): print "Success"

dirname1 = tempfile.mktemp (".dir")
os.mkdir (dirname1)
dirname2 = dirname1 + ".copy"
print dirname1, "=>", dirname2

#拷目录
win32file.CopyFile (dirname1, dirname2, 1)

if os.path.isdir (dirname2): print "Success"

4. SHFileOperation 

import os
from win32com.shell import shell, shellcon
import tempfile

filename1 = tempfile.mktemp (".txt")
open (filename1, "w").close ()
filename2 = filename1 + ".copy"
print filename1, "=>", filename2

#拷文件
#文件已存在时，shellcon.FOF_RENAMEONCOLLISION会指示重命名文件
shell.SHFileOperation (
  (0, shellcon.FO_COPY, filename1, filename2, 0, None, None)
)
shell.SHFileOperation (
  (0, shellcon.FO_COPY, filename1, filename2, shellcon.FOF_RENAMEONCOLLISION, None, None)
)
shell.SHFileOperation (
  (0, shellcon.FO_COPY, filename1, filename2, 0, None, None)
)

if os.path.isfile (filename2): print "Success"

dirname1 = tempfile.mktemp (".dir")
os.mkdir (dirname1)
dirname2 = dirname1 + ".copy"
print dirname1, "=>", dirname2

#拷目录
shell.SHFileOperation (
  (0, shellcon.FO_COPY, dirname1, dirname2, 0, None, None)
)

if os.path.isdir (dirname2): print "Success"

不知道有没有其它的了，os.rename不算，那个是移动文件。另外我在测试它们的性能如何。
http://timgolden.me.uk/python/win32_how_do_i/copy-a-file.html 
这里和楼主列出的都一样，没有更多的了 
或者使用Chilkat  http://www.chilkatsoft.com/refdoc/pythonCkFileAccessRef.html

测试结果出来了： 
 测试环境：系统——Win7 RTM，CPU——P4 3.0，MEM——1.5G DDR400，U盘——Kingston 4G 
  
 用4种不同的方法从硬盘拷贝MSDN 2008 SP1（2.37G）到U盘： 
  
 os System      的方法耗时903.218秒 
 shutil         的方法耗时1850.634秒 
 win32file      的方法耗时861.438秒 
 SHFileOperation的方法耗时794.023秒 
  
 另外SHFileOperation是显示对话框的，可以这样用 

shell.SHFileOperation (
  (0, shellcon.FO_COPY, filename1, filename2, 
   shellcon.FOF_RENAMEONCOLLISION | \
   shellcon.FOF_NOCONFIRMATION |\
   shellcon.FOF_NOERRORUI | \
   shellcon.FOF_SILENT, None, None)
)

secname和contents是必须的，其他的都是可选的。下面挑几个常用的看看：

#include <config.h>
#include <version.h>

#if defined(CONFIG_S3C2410)
#include <s3c2410.h>
#elif defined(CONFIG_S3C2440)//include\configs\smdk2440.h中定义。
#include <s3c2440.h>
#endif

#include <status_led.h>

/*************************************************************************
  Jump vector table as in table 3.1 in [1]
 *************************************************************************/
//.global声明一个符号可被其它文件引用，相当于声明了一个
//全局变量，.globl与.global相同。
//该部分为处理器的异常处理向量表。地址范围为
//0x0000 0000 ~ 0x0000 0020,刚好8条指令。

//声明全局变量 _start
.globl _start     /*系统复位位置,整个程序入口*/
_start:	b       start_code    /*各个异常向量对应的相对跳转代码,0x00*/
     /*start_code用b，就是因为start_code在MMU建立前后都有可能发生*/
     /*其他的异常只有在MMU建立之后才会发生*/
	ldr	pc, _undefined_instruction  //未定义指令异常,0x04
	ldr	pc, _software_interrupt    //软中断异常,0x08
	ldr	pc, _prefetch_abort  //内存操作异常,0x0c
	ldr	pc, _data_abort     //数据异常,0x10
	ldr	pc, _not_used      //未适用,0x14
	ldr	pc, _irq          //慢速中断异常,0x18 
	ldr	pc, _fiq         //快速中断异常,0x1c

//.word伪操作用于分配一段字内存单元（分配的单元都是字对齐的），并
//用伪操作中的expr初始化。.long与.int作用与之相同。
/*.word 表达式 ==> 就是在当前位置放一个word型的值，这个值就是"表达式"
;rWTCON: .word 0x15300000 就是在当前地址，即_rWTCON处放一个值0x15300000*/ 

_undefined_instruction:	.word undefined_instruction
_software_interrupt:	.word software_interrupt
_prefetch_abort:	.word prefetch_abort
_data_abort:		.word data_abort
_not_used:		.word not_used
_irq:			.word irq
_fiq:			.word fiq


/*.balign[wl] abs-expr, abs-expr, abs-expr
;增加位置计数器(在当前子段)使它指向规定的存储边界。
;第一个表达式参数(结果必须是纯粹的数字)是必需参数：边界基准,单位
为字节。
;例如， '.balign 8'向后移动位置计数器直至计数器的值等于8的倍数。
;如果位置计数器已经是8的倍数，则无需移动。
;第2个表达式参数(结果必须是纯粹的数字)给出填充字节的值，用这个值
填充位置计数器越过的地方。
;第2个参数(和逗点)可以省略。如果省略它，填充字节的值通常是0。
;但在某些系统上，如果本段标识为包含代码，而填充值被省略,则使用
no-op指令填充空白区。
;第3个参数的结果也必须是纯粹的数字，这个参数是可选的。如果存在第
3个参数，
;它代表本对齐命令允许跳过字节数的最大值。如果完成这个对齐需要跳
过的字节数比规定的最大值还多,
;则根本无法完成对齐。您可以在边界基准参数后简单地使用两个逗号，
以省略填充值参数(第二参数)；
;如果您在想在适当的时候，对齐操作自动使用no-op指令填充

balignw和.balignl是.balign命令的变化形式。.balignw使用2个字节来填充空白区。
.balignl使用4字节来填充。例如,.balignw 4,0x368d将地址对齐到4的倍数，如果它跳
过2个字节，GAS将使用0x368d填充这2个字节(字节的确切存放位置视处理器
的存储方式而定)。
如果它跳过1或3个字节,则填充值不明确。


//它的含义是以16字节边界对齐，为了对齐而越过的地址以字为单位填冲
//值0xdeadbeef。我猜0xdeadbeef可能NOP指令。
	.balignl 16,0xdeadbeef  //对齐内存为16的倍数
/*************************************************************************
 *
 * Startup Code (called from the ARM reset exception vector)
 *
 * do important init only if we don't start from memory!
 * relocate armboot to ram
 * setup stack
 * jump to second stage
 *
 *************************************************************************/

// TEXT_BASE在开发板相关的目录中的config.mk文件中定义, 它定义了
// 代码在运行时所在的地址, 那么_TEXT_BASE中保存了这个地址
/*
 *保存变量的数据区,保存一些全局变量,用于BOOT程序从FLASH拷贝到RAM,或者
 其它的使用。
 *还有一些变量的长度是通过连接脚本里得到,实际上由编译器算出来的
 */
//TEXT_BASE定义在\board\smdk2410\config.mk中。

/*TEXT_BASE是代码执行的起始地址.编译产生的二进制文件必需下载到该地
址,因为所有的函数,全局变量等等定位都是以这个地址为参照的.
如果uboot中是TEXT_BASE就是设的0x33F80000, 那么必需download到这个地址的ram中才
能正常运行.
*/  
_TEXT_BASE:  //_TEXT_BASE=TEXT_BASE.
			.word	TEXT_BASE   /*uboot映像在SDRAM中的重定位地址*/

// 标号_start在前面有定义
	
.globl _armboot_start   // /*在_armboot_start标号处，保存了_start的值*/
_armboot_start:     //_armboot_start=_start。
				.word _start    /*_start是程序入口，链接完毕它的值应该是TEXT_BASE*/ 

/*
 * These are defined in the board-specific linker script.
 */
//__bss_start是uboot 的bss段起始地址，那么uboot映像的大小就是__bss_start - _start；
//实际上，_armboot_start并没有实际意义，它只是在"ldr r2, _armboot_start"中用來寻
//址_start的值而已，_bss_start也是一样的道理，真正有意义的应该是_start和 
//__bss_start本身。 

.globl _bss_start  /*__bss_start是uboot 的bss段起始地址，*/
_bss_start:         /*uboot映像的大小就是__bss_start - _start*/
		.word __bss_start

.globl _bss_end
_bss_end:
		.word _end

#ifdef CONFIG_USE_IRQ
/* IRQ stack memory (calculated at run-time) */
.globl IRQ_STACK_START
IRQ_STACK_START:
				.word	0x0badc0de

/* IRQ stack memory (calculated at run-time) */
.globl FIQ_STACK_START
FIQ_STACK_START:
				.word 0x0badc0de
#endif


/* the actual start code*/
start_code:/*复位启动子程序*/
	/*设置cpu运行在SVC32模式。共有7种模式*/	
	mrs	r0,cpsr  /*复制当前程序状态寄存器cpsr到r0*/
	bic	r0,r0,#0x1f  //这里使用位清除指令,把中断全部清除,只置位模式控制位
	                          //7种异常，共占0x00 - 0x16空间
	/*ORR{条件}{S}  <dest>, <op 1>, <op 2>*/
       /*OR 将在两个操作数上进行逻辑或，把结果放置到目的寄存器中*/
	orr	r0,r0,#0xd3 /*选择新模式，(现在设为超级保护模式)*/
	
	msr	cpsr,r0  /*设置cpsr为超级保护模式*/
   /*通过设置ARM的CPSR寄存器,让CPU运行在操作系统模式,为后面进行其它操作作好准备*/

//如果定义了CONFIG_AT91RM9200DK,CONFIG_AT91RM9200EK,CONFIG_AT91RM9200DF中的任意一个
//,就会执行其中的语句.这里没有用。
#if	defined(CONFIG_AT91RM9200DK) || defined(CONFIG_AT91RM9200EK) || defined(CONFIG_AT91RM9200DF)
	/* relocate exception table*/
	ldr		r0, =_start
	ldr		r1, =0x0
	mov		r2, #16
copyex:
	subs	r2, r2,   #1
	ldr		r3, [r0], #4
	str		r3, [r1], #4
	bne		copyex
#endif

#if defined(CONFIG_S3C2400) || defined(CONFIG_S3C2410) || defined(CONFIG_S3C2440)

#if defined(CONFIG_S3C2400)
#define pWTCON	0x15300000
#define INTMSK	0x14400008	/* Interupt-Controller base addresses */
#define CLKDIVN	0x14800014	/* clock divisor register */
#elif defined(CONFIG_S3C2410) || defined(CONFIG_S3C2440)
#define pWTCON	0x53000000  /*"看门狗定时器控制寄存器"的地址0x53000000*/  
#define INTMSK	0x4A000008 /*"中断屏蔽寄存器"的地址:0x4A000008 */
#define INTSUBMSK	0x4A00001C /*针对INTMAK具体化的一个中断请求屏蔽寄存器,其地
                                                             址0x4A00001C */  
#define LOCKTIME	0x4c000000  //锁时计数寄存器    
#define MPLLCON 	0x4c000004  //MPLL寄存器
#define UPLLCON 	0x4c000008  //UPLL寄存器
#define CLKDIVN	0x4C000014	/*CPU时钟分频控制寄存器,地址0x4C000014*/  
#endif

#if defined(CONFIG_S3C2410)
#define INTSUBMSK_val	0x7ff
#define MPLLCON_val	((0x90 << 12) + (0x7 << 4) + 0x0)	/* 202 MHz */
#define UPLLCON_val	((0x78 << 12) + (0x2 << 4) + 0x3)
#define CLKDIVN_val	3 /* FCLK:HCLK:PCLK = 1:2:4 */
#elif defined(CONFIG_S3C2440)
#define INTSUBMSK_val	0xffff  //以便屏蔽INTSUBMSK的bit[15:0]对应的中断请求
#if (CONFIG_SYS_CLK_FREQ == 16934400)//晶振=16.9344M在include\configs\smdk2440.h中定义。
/*
Mpll = (2 * m * Fin) / (p * 2s)
m = (MDIV + 8), p = (PDIV + 2), s = SDIV

Upll = (m * Fin) / (p * 2s)
m = (MDIV + 8), p = (PDIV + 2), s = SDIV

MDIV =PLLCON[19:12];  PDIV=PLLCON[9:4];  SDIV=PLLCON[1:0];
*/
//# define MPLLCON_val	((0x61 << 12) + (0x1 << 4) + 0x2)	/* 296.35 MHz */
//# define UPLLCON_val	((0x3c << 12) + (0x4 << 4) + 0x2)	/*  47.98 MHz */
                                //MDIV=184        PDIV=2     SDIV=2                                 
#define MPLLCON_val	((184 << 12) + (2 << 4) + 2)	/*406M*/
                                //MDIV=60        PDIV=4     SDIV=2  
#define UPLLCON_val 	((60 << 12) + (4 << 4) + 2)   /*  47M */
#elif (CONFIG_SYS_CLK_FREQ == 12000000)
#define MPLLCON_val	((0x44 << 12) + (0x1 << 4) + 0x1)	/* 304.00 MHz */
#define UPLLCON_val	((0x38 << 12) + (0x2 << 4) + 0x2)	/*  48.00 MHz */
#endif
#define CLKDIVN_val	7 /* FCLK:HCLK:PCLK = 1:3:6   CLKDIVN=7  */
                       //CPU  : 高速设备:  低速设备
#define CAMDIVN	0x4C000018
#endif

        //禁用看门狗
	ldr       r0, =pWTCON
	mov     r1, #0x0
	str       r1, [r0]

	/* mask all IRQs by setting all bits in the INTMR - default*/
	/*在SVC模式下，屏蔽所有中断发生*/
	mov	  r1, #0xffffffff
	ldr	  r0, =INTMSK
	str	  r1, [r0]
	
#if defined(CONFIG_S3C2410) || defined(CONFIG_S3C2440)
	ldr	r1, =INTSUBMSK_val  /*子中断同样屏蔽INTSUBMSK_val=0xffff*/
	ldr	r0, =INTSUBMSK
	str	r1, [r0]

/*To reduce PLL lock time, adjust the LOCKTIME register. */
        ldr     r0,=LOCKTIME
        ldr     r1,=0xffffff
        str     r1,[r0]	
#endif

    /* FCLK:HCLK:PCLK = 1:3:6*//* default FCLK is 406M MHz ! */
	ldr	r0, =CLKDIVN
	mov	r1, #CLKDIVN_val
	str	r1, [r0]

#if defined(CONFIG_S3C2440)
      /* Make sure we get FCLK:HCLK:PCLK = 1:3:6 */
        ldr        r0, =CAMDIVN
        mov     r1, #0
        str       r1, [r0]

        /* Clock asynchronous mode */
        mrc     p15, 0, r1, c1, c0, 0
        orr      r1,   r1, #0xc0000000
        mcr     p15, 0, r1, c1, c0, 0

	ldr	r0,=UPLLCON
	ldr	r1,=UPLLCON_val
	str	r1,[r0]
	
	nop	
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	
	ldr	r0,=MPLLCON
	ldr	r1,=MPLLCON_val
	str	r1,[r0]
//
#define GPJCON      0x560000D0
#define GPJDAT       0x560000D4
#define GPJUP		0x560000D8
/*
        LDR   R0,   = GPJCON
        LDR   R1,   = 0x15555
        STR   R1,   [R0]
        LDR   R0,   = GPJUP
        LDR   R1,   = 0x1f
        STR   R1,   [R0]
        LDR   R0,   = GPJDAT  
//    LDR   R1,   = 0xffff
        LDR   R1,   = 0x00
        STR   R1,   [R0]
*/
#endif

#endif	/* CONFIG_S3C2400 || CONFIG_S3C2410 */

	/*
	 * we do sys-critical inits only at reboot,
	 * not when booting from ram!
	 */
	//bl      LED_FLASH
#ifndef CONFIG_SKIP_LOWLEVEL_INIT
/*这些初始化代码在系统重启的时候执行，运行时热复位从RAM中启动不执行*/
	bl	cpu_init_crit
#endif
#if 1
        LDR   R0,   = GPJCON
        LDR   R1,   = 0x15555
        STR   R1,   [R0]
        LDR   R0,   = GPJUP
        LDR   R1,   = 0x1f
        STR   R1,   [R0]
        LDR   R0,   = GPJDAT
        LDR   R1,   = 0x00
        STR   R1,   [R0]
#endif
	
#if defined(CONFIG_AT91RM9200) || defined(CONFIG_S3C2410) || defined(CONFIG_S3C2440)
#ifndef CONFIG_SKIP_RELOCATE_UBOOT
#ifndef CONFIG_S3C2410_NAND_BOOT
//NOR_BOOT :
relocate:	/* 把U-BOOT重新定位到RAM*/
         //r0=0;
	adr	r0, _start		/* r0是代码的当前位置*/
	//r1=TEXT_BASE = 0x33F80000
	ldr	r1, _TEXT_BASE	/*测试判断是从FLASH启动，还是RAM  */
	cmp     r0, r1     /*比较R0、R1，调试的时候不需要重定位。 */
	beq     stack_setup  /*如果R0等于R1，跳到重定位代码。*/

	//如果不是从RAM运行的话，则将代码拷贝到_TEXT_BASE标识的RAM中。
	/*准备重新定义代码。*/
	ldr	r2, _armboot_start//_armboot_start=_start
	ldr	r3, _bss_start  //
	sub	r2, r3, r2		/* r2得到armboot的大小*/
	add	r2, r0, r2		/* r2得到要复制代码的末尾地址*/
//kaobei guo cheng
copy_loop:/*重新定位代码*/
	ldmia	r0!, {r3-r10}		/*从源地址[r0]复制,r0指向_start(=0)*/
	stmia	r1!, {r3-r10}		/*复制到目的地址[r1],r1指向_TEXT_BASE(=0x33F80000)*/
	cmp	r0, r2			/* 复制数据块直到源数据末尾地址[r2]*/
	ble	copy_loop
#else /* NAND_BOOT */
//relocate:
copy_myself:
	/* mov	r10, lr */
#if defined(CONFIG_S3C2410)
	@ reset NAND
	mov	r1, #S3C2410_NAND_BASE
	ldr	r2, =0xf842		@ initial value enable tacls=3,rph0=6,rph1=0
	str	r2, [r1, #oNFCONF]
	ldr	r2, [r1, #oNFCONF]
	bic	r2, r2, #0x800		@ enable chip
	str	r2, [r1, #oNFCONF]
	mov	r2, #0xff		@ RESET command
	strb	r2, [r1, #oNFCMD]
	mov	r3, #0			@ wait
1:	add	r3, r3, #0x1
	cmp	r3, #0xa
	blt	1b
2:	ldr	r2, [r1, #oNFSTAT]	@ wait ready
	tst	r2, #0x1
	beq	2b
	ldr	r2, [r1, #oNFCONF]
	orr	r2, r2, #0x800		@ disable chip
	str	r2, [r1, #oNFCONF]
#elif defined(CONFIG_S3C2440)
        /*从NAND闪存中把U-BOOT拷贝到RAM*/
	mov	r1, #S3C2440_NAND_BASE //S3C2440_NAND_BASE=0x4E000000
	ldr	r2, =0xfff0		@ initial value tacls=3,rph0=7,rph1=7
	ldr	r3, [r1, #oNFCONF] //oNFCONF=0x00
	orr	r3, r3, r2
	str	r3, [r1, #oNFCONF]//oNFCONF=0x00

	ldr	r3, [r1, #oNFCONT] //oNFCONT=0x04
	orr	r3, r3, #1		@ enable nand controller
	str	r3, [r1, #oNFCONT]//oNFCONT=0x04
#endif  //if defined(CONFIG_S3C2410)

#if 0
	@ get ready to call C functions (for nand_read())
	ldr	sp, DW_STACK_START	@ setup stack pointer
	mov	fp, #0			@ no previous frame, so fp=0
#else
	ldr	r0, _TEXT_BASE		/* upper 128 KiB: relocated uboot   */
	
        /* CFG_MALLOC_LEN=(CFG_ENV_SIZE + 2048*1024) =0x210000 ;   CFG_ENV_SIZE	= 0x10000
             CFG_GBL_DATA_SIZE=128	*/
	sub	r0, r0, #CFG_MALLOC_LEN	/* malloc area                      */
	sub	r0, r0, #CFG_GBL_DATA_SIZE /* bdinfo                        */
#ifdef CONFIG_USE_IRQ  /*include/configs/smdk2440.h*/
	sub	r0, r0, #(CONFIG_STACKSIZE_IRQ+CONFIG_STACKSIZE_FIQ)  //8K+4K
#endif
	sub	sp, r0, #12		/* leave 3 words for abort-stack    */
#endif   //#if 0

	@ copy u-boot to RAM
	ldr	r0, _TEXT_BASE //置第1个参数: UBOOT在RAM中的起始地址
	mov     r1, #0x0   //设置第2个参数:NAND闪存的起始地址
	//CFG_UBOOT_SIZE=0x40000=256k
	mov	r2, #CFG_UBOOT_SIZE  // 设置第3个参数: U-BOOT的长度(256KB)
	bl	nand_read_ll   //调用nand_read_whole(),把NAND闪存中的数据读入到RAM中

	tst	r0, #0x0 // 如果函数的返回值为0,表示执行成功
	beq	ok_nand_read  //执行内存比较，把RAM中的前4K内容与NAND闪存中的前4K内容进行比较, 如果完全相同, 则表示搬移成功
#ifdef CONFIG_DEBUG_LL
bad_nand_read:
	ldr	r0, STR_FAIL
	ldr	r1, SerBase
	bl	PrintWord
1:	b	1b		@ infinite loop
#endif

ok_nand_read:
#ifdef CONFIG_DEBUG_LL
	ldr	r0, STR_OK
	ldr	r1, SerBase
	bl	PrintWord
#endif

	@ verify
	mov	r0, #0
	@ldr	r1, =0x33f00000
	ldr	r1, _TEXT_BASE
	mov	r2, #0x400	@ 4 bytes * 1024 = 4K-bytes
go_next:
	ldr	r3, [r0], #4
	ldr	r4, [r1], #4
	teq	r3, r4
	bne	notmatch
	subs	r2, r2, #4
	beq	done_nand_read
	bne	go_next
notmatch:
#ifdef CONFIG_DEBUG_LL
	sub	r0, r0, #4
	ldr	r1, SerBase
	bl	PrintHexWord
	ldr	r0, STR_FAIL
	ldr	r1, SerBase
	bl	PrintWord
#endif

#if 1
        LDR   R0,   = GPJDAT
        LDR   R1,   = 0x4
        STR   R1,   [R0]
#endif
1:	b	1b
done_nand_read:
#if 1
        LDR   R0,   = GPJDAT
        LDR   R1,   = 0x2
        STR   R1,   [R0]
#endif

#endif /* NAND_BOOT */
#endif	/* CONFIG_SKIP_RELOCATE_UBOOT */
#endif
	/* 初始化堆栈*/
stack_setup:
	ldr	r0, _TEXT_BASE		/*上面是128kib重定位的u-boot*/
	/*在smdk244.h中定义 #define CFG_MALLOC_LEN		(CFG_ENV_SIZE + 2048*1024)
	                    #define CFG_ENV_SIZE	    0x10000 
			   #define CFG_GBL_DATA_SIZE	128	*/
	sub	r0, r0, #CFG_MALLOC_LEN	/*向下是内存分配空间*/
	sub	r0, r0, #CFG_GBL_DATA_SIZE /*然后是bdinfo结构体地址空间*/
#ifdef CONFIG_USE_IRQ  //在 smdk2440.h中定义。
    /*在smdk244.h中定义#define CONFIG_STACKSIZE_IRQ	(8*1024)	
                                                 #define CONFIG_STACKSIZE_FIQ	(4*1024)	 */
	sub	r0, r0, #(CONFIG_STACKSIZE_IRQ+CONFIG_STACKSIZE_FIQ)
#endif
	sub	sp, r0, #12		/*为 abort-stack 预留3个字,得到最终sp指针初始值*/

clear_bss:
	ldr	r0, _bss_start		/*找到bss 段起始地址。*/
	ldr	r1, _bss_end		/* bss 段末尾地址。*/
	mov r2, #0x00000000		/* 清零。*/

clbss_l:str	r2, [r0]		/*bss 段地址空间清零循环。。。*/
	add	r0, r0, #4
	cmp	r0, r1
	ble	clbss_l
#if 1
        LDR   R0,   = GPJDAT
        LDR   R1,   = 0x1
        STR   R1,   [R0]
#endif
     /*跳转到start_armboot函数入口，_start_armboot字保存函数入口指针*/
	ldr	pc, _start_armboot

//_start_armboot=start_armboot
//pc=start_armboot;
//去执行void start_armboot (void)，在lib_arm/boarb.c中。
_start_armboot:	.word start_armboot


/*
 *************************************************************************
 *
 * CPU_init_critical registers
 *
 * setup important registers
 * setup memory timing
 *
 *************************************************************************
 */

//功能:设置CP15寄存器 这里完成的功能:失效Icache和Dcache,禁能MMU和cache 
#ifndef CONFIG_SKIP_LOWLEVEL_INIT
//关键的初始化子程序。
cpu_init_crit:
	 /*  flush v4 I/D caches  | 失效指令cache和数据cache       */
	mov	r0, #0
	//使I/D cache失效：将寄存器r0的数据传送到协处理器p15的c7中。C7寄存器
	//位对应cp15中的cache控制寄存器
	mcr	p15, 0, r0, c7, c7, 0	/* flush v3/v4 cache */
	//使TLB操作寄存器失效：将r0数据送到cp15的c8、c7中。C8对应TLB操作
	//寄存器
	mcr	p15, 0, r0, c8, c7, 0	/* flush v4 TLB */

	/*
	 * disable MMU stuff and caches
	 */
	 /*   disable MMU stuff and caches |   禁能MMU和cache       */ 
	mrc	p15, 0, r0, c1, c0, 0 //先把c1和c0寄存器的各位置0(r0 = 0)
	bic	r0, r0, #0x00002300	@ clear bits 13, 9:8 (--V- --RS)
	bic	r0, r0, #0x00000087	@ clear bits 7, 2:0 (B--- -CAM)
	orr	r0, r0, #0x00000002	@ set bit 2 (A) Align
	orr	r0, r0, #0x00001000	@ set bit 12 (I) I-Cache
	mcr	p15, 0, r0, c1, c0, 0

	/*
	 * before relocating, we have to setup RAM timing
	 * because memory timing is board-dependend, you will
	 * find a lowlevel_init.S in your board directory.
	 */
	mov	ip, lr
#if	defined(CONFIG_AT91RM9200DK) || defined(CONFIG_AT91RM9200EK) || defined(CONFIG_AT91RM9200DF)

#else
	bl	lowlevel_init  //位于board/smdk2440/lowlevel_init.S：用于完成芯片存储器的初始化，
	                             //执行完成后返回
#endif
	mov	lr, ip
	mov	pc, lr
#endif /* CONFIG_SKIP_LOWLEVEL_INIT */

/*
 *************************************************************************
 *
 * Interrupt handling
 *
 *************************************************************************
 */

@
@ IRQ stack frame.
@
#define S_FRAME_SIZE	72

#define S_OLD_R0	68
#define S_PSR		64
#define S_PC		60
#define S_LR		56
#define S_SP		52

#define S_IP		48
#define S_FP		44
#define S_R10		40
#define S_R9		36
#define S_R8		32
#define S_R7		28
#define S_R6		24
#define S_R5		20
#define S_R4		16
#define S_R3		12
#define S_R2		8
#define S_R1		4
#define S_R0		0

#define MODE_SVC 0x13
#define I_BIT	 0x80

/*
 * use bad_save_user_regs for abort/prefetch/undef/swi ...
 * use irq_save_user_regs / irq_restore_user_regs for IRQ/FIQ handling
 */

	.macro	bad_save_user_regs
	sub	sp, sp, #S_FRAME_SIZE
	stmia	sp, {r0 - r12}			@ Calling r0-r12
	ldr	r2, _armboot_start
	sub	r2, r2, #(CONFIG_STACKSIZE+CFG_MALLOC_LEN)
	sub	r2, r2, #(CFG_GBL_DATA_SIZE+8)  @ set base 2 words into abort stack
	ldmia	r2, {r2 - r3}			@ get pc, cpsr
	add	r0, sp, #S_FRAME_SIZE		@ restore sp_SVC

	add	r5, sp, #S_SP
	mov	r1, lr
	stmia	r5, {r0 - r3}			@ save sp_SVC, lr_SVC, pc, cpsr
	mov	r0, sp
	.endm

	.macro	irq_save_user_regs
	sub	sp, sp, #S_FRAME_SIZE
	stmia	sp, {r0 - r12}			@ Calling r0-r12
	add     r8, sp, #S_PC
	stmdb   r8, {sp, lr}^                   @ Calling SP, LR
	str     lr, [r8, #0]                    @ Save calling PC
	mrs     r6, spsr
	str     r6, [r8, #4]                    @ Save CPSR
	str     r0, [r8, #8]                    @ Save OLD_R0
	mov	r0, sp
	.endm

	.macro	irq_restore_user_regs
	ldmia	sp, {r0 - lr}^			@ Calling r0 - lr
	mov	r0, r0
	ldr	lr, [sp, #S_PC]			@ Get PC
	add	sp, sp, #S_FRAME_SIZE
	subs	pc, lr, #4			@ return & move spsr_svc into cpsr
	.endm

	.macro get_bad_stack
	ldr	r13, _armboot_start		@ setup our mode stack
	sub	r13, r13, #(CONFIG_STACKSIZE+CFG_MALLOC_LEN)
	sub	r13, r13, #(CFG_GBL_DATA_SIZE+8) @ reserved a couple spots in abort stack

	str	lr, [r13]			@ save caller lr / spsr
	mrs	lr, spsr
	str     lr, [r13, #4]

	mov	r13, #MODE_SVC			@ prepare SVC-Mode
	@ msr	spsr_c, r13
	msr	spsr, r13
	mov	lr, pc
	movs	pc, lr
	.endm

	.macro get_irq_stack			@ setup IRQ stack
	ldr	sp, IRQ_STACK_START
	.endm

	.macro get_fiq_stack			@ setup FIQ stack
	ldr	sp, FIQ_STACK_START
	.endm

/*
 * exception handlers
 */
	.align  5
undefined_instruction:
	get_bad_stack
	bad_save_user_regs
	bl 	do_undefined_instruction

	.align	5
software_interrupt:
	get_bad_stack
	bad_save_user_regs
	bl 	do_software_interrupt

	.align	5
prefetch_abort:
	get_bad_stack
	bad_save_user_regs
	bl 	do_prefetch_abort

	.align	5
data_abort:
	get_bad_stack
	bad_save_user_regs
	bl 	do_data_abort

	.align	5
not_used:
	get_bad_stack
	bad_save_user_regs
	bl 	do_not_used

#ifdef CONFIG_USE_IRQ

	.align	5
irq:
	get_irq_stack
	irq_save_user_regs
	bl 	do_irq
	irq_restore_user_regs

	.align	5
fiq:
	get_fiq_stack
	/* someone ought to write a more effiction fiq_save_user_regs */
	irq_save_user_regs
	bl 	do_fiq
	irq_restore_user_regs

#else

	.align	5
irq:
	get_bad_stack
	bad_save_user_regs
	bl 	do_irq

	.align	5
fiq:
	get_bad_stack
	bad_save_user_regs
	bl 	do_fiq

#endif

最近遇到一个设置系统sleep状态的case，最后从客户那里得到了设置方法~就是用Powercfg 命令

powercfg -energy

顺便找了一些powercfg的其他命令行选项在下面：

powercfg [-l] [-q ] [-x] [-changename] [-duplicatescheme] [-d] [-deletesetting] [-setactive] [-getactivescheme] [-setacvalueindex] [-setdcvalueindex] [-h] [-a] [-devicequery] [-deviceenablewake] [-devicedisablewake] [-import] [-export] [-lastwake] [-?][-aliases] [-setsecuritydescriptor] [-getsecuritydescriptor]

ACPI BIOS implementations that directly access certain system hardware resources from AML code cannot be synchronized with operating system access to the same resources, which can cause the operating system to become unstable or to stop responding. This article describes issues related to BIOS AML firmware accessing system board resources, and the changes implemented to address these issues in the Windows XP, Windows Server 2003, and future versions of the operating system.

Introduction

During the development of the Windows XP operating system, Microsoft discovered many ACPI BIOS implementations that directly access and attempt to manipulate system hardware resources from BIOS ASL code. At run time, system board resources must not be simultaneously accessed or modified by both the BIOS and the operating system, because these accesses cannot be synchronized with operating system access to the same system resources. As a result, BIOS read or write access to these resources can cause adverse effects, ranging from general instability to causing the system to stop responding.

Historically, error conditions of this nature might have been construed by the operating system as an unrecoverable error, resulting in a stop error (blue screen) and system shutdown. In an effort to improve the end user experience and increase system reliability, Windows XP has been re-designed as described in this article.

Changes in Windows XP

While developing and testing Windows XP a list of system board resources was identified that, when accessed from BIOS AML code, proved to be the most problematic. This article refers to the list of addresses associated with these resources as the "blocked ports list." Table 1 lists affected system resources and their associated I/O addresses.

The ACPI AML interpreter in the Windows XP kernel monitors all attempts by BIOS AML code to read from or write to the specific addresses on the blocked ports list. When a read or write access is detected at any of these addresses, the following actions will occur:

Windows XP BIOS Compatibility Determined Using _OSI

The specific actions taken by the operating system when read or write accesses to these resources are detected depends on the version of ACPI interface that the BIOS indicates it supports. This is determined through the BIOS use of the _OSI method as described in this article.

For complete details about the _OSI method, see How to Identify Windows Versions in ACPI Using _OSI.

The _OSI method is being introduced with the Windows XP operating system. BIOS ASL code can test for the level of features supported in the current Windows operating system by passing a string to the _OSI method. The operating system returns TRUE for any string that represents a feature set that it can support. Windows XP, for example, returns TRUE for the string "Windows 2001".

By passing the string "Windows 2001" into the _OSI method, the BIOS indicates to the operating system that the BIOS is aware of and compatible with the ACPI implementation and feature set of Windows XP. Windows XP will then reject all I/O reads or writes from BIOS ASL code to addresses on the blocked ports list and generate an error in the system event log.

Windows XP and Legacy BIOS ASL Implementations

For those BIOS implementations that are compatible with versions of Windows released before Windows XP, the operating system will allow the read or write access to succeed in most cases. Accesses to the PIC and cascaded PIC, and to the PIC Edge/Level Control Registers, are always blocked. In all cases an error will be written to the system event log.

To help ensure system stability on systems with legacy BIOS ASL implementations, Windows XP attempts to synchronize accesses to resources whenever possible. For example:

Accessing BIOS Non-volatile Memory (CMOS NVRAM)

With these changes in Windows XP, BIOS developers may be looking for alternative methods to access CMOS NVRAM. The following examples present some possible solutions.

Reading from CMOS NVRAM

This example ASL code defines an operation region in the system memory address space. During POST, BIOS code copies the data from CMOS to this memory area. ASL code can then use fields to read the CMOS data.

Each CMnn field in the example corresponds to 8 bits of CMOS. The BIOS engineer is responsible for defining these fields appropriately. Each field of this memory can be any combination of bits.

During system boot, BIOS POST code should update this memory area with the value written in the CMOS before handing off to the operating system. Once the operating system has switched to ACPI mode, any attempt to read CMOS from ASL code should be done by reading from these memory locations and not from CMOS NVRAM I/O ports.

// Declare a memory operation region for 255 bytes of CMOS. 
// First 0 to 127 bytes reflects CMOS access from IO ports 0x70 
// and 0x71 and the subsequent bytes reflect CMOS access from IO 
// ports 0x72 to 0x73.  BIOS code should properly set up the base 
// address of the beginning of this memory range at offset during 
// BIOS POST.

OperationRegion (CMRM, SystemMemory, offset, 255)  //Operation Region 

Field (CMRM, AnyAcc, NoLock, Preserve) {   //Field
    //  Memory corresponding to addresses 0x70, 0x71
    CM00,    8,
    CM01,    8,
    CM02,    8,
    .
    .
    CM7f,     8,     

    // Memory corresponding to addresses 0x72, 0x73
    CM80,    8,
    .
    .
    CMFF
    }   // End of CMOS field

The following is an example of ASL code which reads from CMOS offset 52 bits 4 to 7 and returns the value read.

// This example returns bits 4 to 7 of CMOS offset 52

Method (RDCM) {
    ShiftRight (CM52, 4, Local0)
    Return (Local0) 
    }

Writing to CMOS NVRAM

BIOS code should write to CMOS NVRAM by generating a system management interrupt (SMI). AML code can generate a SMI by writing a specific value to the SMI command port. AML code can pass the CMOS offset and value to be written through the NVRAM memory operation region. The BIOS SMI handles the writes to CMOS, and also updates the memory area pointed by the CMRM operation region to reflect the correct CMOS contents.

Affected System Resources and Addresses

Table 1 lists the system resources and associated I/O addresses that should not be directly accessed by BIOS AML code (the "blocked ports" list).

Table 1 Blocked I/O Port Addresses and System Board Resources

*Read or write accesses to these ports are always blocked, regardless of the BIOS use of the _OSI method.

Call to Action

BIOS developers should design their BIOS code according to the guidelines in this article:

        如果EFI支持64-bit的话，那么就可以启动Windows 7, 还不是因为MS不好好支持32-bit，这样就不需要CSM module了
        那么如果EFI支持64-bit的话，SMM driver也就变成64-bit了，这个时候SMM就必须从Real mode 转成64-bit protect mode，其实主要的问题就是CPU的mode是IA-32e mode，这是由CPU的一个寄存器来决定的，具体的就是MSR（C0000080h）的bit8，所以在SMI handler中就需要load 64-bit的GDT，然后切成保护模式之前，设置CPU的这个寄存器，使之变成64-bit，其他的和32-bit的一模一样，就可以去执行64-bit的C程序了
        需要强调的是，64-bit汇编code中，eax就用rax了，等等。
        贴一张图吧，说明一下CPU的不同模式：

       ACPI Table是BIOS提供给OSPM的硬件配置数据，包括系统硬件的电源管理和配置管理，ACPI Table有很多表，根据存储的位置，可以分为：

1） RSDP位于F段，用于OSPM搜索ACPI Table，RSDP可以定位其他所有ACPI Table

2） FACS位于ACPI NVS内存，用于系统进行S3保存的恢复指针，内存为NV Store

3） 剩下所有ACPI Table都位于ACPI Reclaim内存，进入OS后，内存可以释放

           ACPI Table根据版本又分为1.0B，2.0，3.0，4.0。2.0以后，支持了64-bit的地址空间，因此几个重要的Table会不大一样，比如：RSDP，RSDT，FADT，FACS。简单的列举一下不同版本的ACPI Table：

1） ACPI 1.0B：RSDP1，RSDT，FADT1，FACS1，DSDT，MADT，SSDT，HPET，MCFG等

2） ACPI 3.0 ：RSDP3，RSDT，XSDT，FADT3，FACS3，DSDT，MADT，HPET，MCFG，SSDT等

以系统支持ACPI3.0为例子，说明系统中ACPI table之间的关系如图：

 其中绿色代表在内存F段，蓝色是ACPI Reclaim内存，红色是NV store内存

    当我们在coding的时候，使用两个变量相加的情况，或者用 +，或者用 | ，都是没有问题，比如：
    0x1000 + 0x55 = 0x1055
    0x1000 | 0x55  = 0x1055
    介于以前这种固有的思维，因此没有把其中不同仔细考虑，直到这几天的bug，才恍然大悟，还是因为基础知识的不扎实和习惯性的思维导致这个bug，不过也给我了一个机会，彻底的搞清楚这两个运算符在变量相加的时候的区别。
    因为code是这么定义的：
#define PCI_ADDR(bus,device,func,reg)  (UINT64)(bus<<24 + device<<16 + func<<8 + reg ) & 0x00000000FFFFFFFF
#define DRAM_PCI    PCI_ADDR(0,0,3,0)
    UINT64 Addr；
    假如我要访问寄存器0x55
    （1） Addr = DRAM_PCI + 0x55;
    （2） Addr = DRAM_PCI  | 0x55;
     那么请问（1）和（2）相等吗？
     答案是： （1） Addr = 0；
                       （2） Addr = RealValue;

     那么为什么在（1）中，Addr = 0呢，问题还是出在PCI_ADDR这个宏定义上：
     因为宏定义最后做了一个与运算，所以在之后的运算中就需要和 + 或者 | 进行优先级的比较，由于+  》 &  》 | ，因此当使用 | 的时候，就不会出现问题，能够和我们想要的运算一致；当使用 + 的时候，由于 + 比 & 优先级高，因此就率先计算了 0x00000000FFFFFFFF + 0x55，导致得到了新值 0x0000000100000054，然后和之前的数值进行 &， 不就得到了 0 嘛
     所以得到的经验教训：
     1）在复杂的定义面前不能想当然的去使用自己认为没有问题的运算符，因为检查这个问题可不是这么容易找到根源的。
     2）在进行宏定义的时候最好给整个宏加上括号，那么就可以避免很多优先级的问题，因为调用这个宏的人可能多种多样。
     3）尽可能的使用最简单的运算符进行coding，可以避免一些问题，当然如果反复调用的情况下，还是需要定义宏，当然定义要慎重，参考2）
     4）基础很重要啊，要能快速的找到问题的根源还是需要熟悉各种运算符的优先级，这次又好好的复习了一下。

顺便附上C语言中常用运算符的优先级：
1 () [] -> .   ::  ! ~ ++ --
2 - (unary) * (dereference)  & (address of) sizeof
3 ->* .*
4 * (multiply) / %
5 + -
6 << >>
7 < <= > >=
8 == !=
9 & (bitwise AND)
10 ^
11 |
12 &&
13 ||
14 ? :
15 = += -= etc.
16 ,