Uboot下关于Nor Flash的驱动问题

　　本文主要是关于Nor Flash的相关介绍，并着重对Nor Flash的编写及驱动程序进行了相近的阐述。

　　Nor Flash驱动编写

　　1.

　　Bottom/Top Boot Sect（底部/顶部 启动块）

　　所谓的boot sect，是指的是Nor Flash和Nand Flash不太一样。Nand Flash从开始到最后，都是由同样大小的page所组成的。

　　而Nor Flash，一般都是有个boot sect，好像是由于历史原因，常将Nor Flash用于作为存储启动代码的设备，也就是从Nor Flash启动，所以，这个boot sect块，专门设计出来，用于存放启动代码。如果详细解释，按照datasheet中的描述就是，第一个或最后一个，此处是bottom sect，所以是最后一个64KB大小的块，被分为4个独立的块。第一个16KB，用于少量的系统初始化代码。而2个8KB的块用于存储参数，余下的32KB的块叫做Main Block，用于存储应用程序的代码。

　　2.

　　Sector（扇区）

　　此处的sector（扇区）也就是flash里面的最小的擦除单位：块（block）。

　　所以sector count，也就是有多少个block。

　　3.

　　Sector Count （扇区数）和Sector List

　　此处的Nor Flash，M29W320DB，一共有正常的63个64KB的block，加上上面提到的原先是正常的1个64KB分成的4个小块，所以是63+4=67个。

　　而所谓的驱动中的sector list，也就是block list，代码注释写的也很清楚了：

　　ulong

　　start［CFG_MAX_FLASH_SECT］;

　　/* physical sector start addresses */

　　用于存储每一个块的起始地址的。也是需要你驱动初始化的。对于这里的M29W320DB，也很简单了，从开始顺序加上块大小64K，直到最后3个，计算一下对应地址，填进去就可以了。

　　4.

　　Protect（写保护）

　　Nor Flash从软件的寄存器配置和硬件上，都提供了对应的保护机制，目的是，防止有意或无意间，把那些不希望被改动/删除的数据破坏了。比如有些机制把Flash的一些系统启动参数存储Nor Flash，或者是其他某种原因，只允许你使用部分Nor Flash的空间，所以，把这类需要保护的部分，在uboot的flash_info_t的结构体中，把对应的位设置成1：

　　uchar

　　protect［CFG_MAX_FLASH_SECT］; /* sector protection status

　　*/

　　这样，之后程序就可以避免有意无意的擦除有用的数据了。

　　【写Nor Flash驱动时的一些注意事项】

　　1.

　　位宽（bitwidth，X8/X16/X32）

　　在Nor Flash控制器，此处我这里用的是，ARM的PromeCell PL172，MPMC（MultiPort Memory Controller），可以接多种不同的存储设备，比如SRAM（Static Memory），Nor Flash，而其中又可以分别设置是否支持Page Mode，Extended wait和写保护（启用写保护，就可以看出是ROM了）等。

　　在硬件上MPMC和Nor Flash连接好了之后。在使用Nor Flash之前，要初始化MPMC。

　　这里说的，要注意位宽，是因为我开始就没注意到，所以，在开始初始化MPMC的时候，设置MPMCStaticConfig寄存器的时候，设置成了X16（16位），但是，后来去uboot中找到别人的Nor Flash的驱动（参考的是oardoxcflash.c），发出的命令去读ID，也都是X8（8位）的：

　　addr［0x0AAA］ = 0xAA;

　　addr［0x0555］ = 0x55;

　　addr［0x0AAA］ = 0x90;

　　所以，导致读取Manufacture ID 和Device ID，都无法读正确，读的都是0xFF。后来重新去确认，在配置MPMCStaticConfig的时候，是配置的X16模式，然后再发命令，也对应的是按照X16模式发命令，可以参考：oardmvs1flash.c中的代码，读取ID时是：

　　addr［0x0555］ = 0x00AA;

　　addr［0x02AA］= 0x0055;

　　addr［0x0555］ = 0x0090;

　　才能正确读取到期望出的ID：

　　value = addr［0］;

　　/* manufacturer ID

　　*/

　　读出来的是0x20h。

　　value = addr［1］;

　　/* device ID

　　*/

　　读出来的是0x22CB

　　和datasheet中的匹配：

　　– Manufacturer Code： 0020h

　　– Bottom Device Code M29W320DB： 22CBh

　　2.

　　不同位宽对应不同的时序

　　此处说的时序，也就是上面提到的，X8和X16发的地址，是不一样的，而且顺序也不同。

　　而且还有一小点要注意的是，记得转换地址成对应的类型：

　　X8是vu_char *

　　X16是 vu_short *

　　这样再写入对应的地址和数值，就可以了。

　　3.

　　reset命令

　　看了uboot中的代码，好像是其他设备，多数的reset命令，都是0xFF。

　　而这里用到的是STM（STMicroelectronics，后来好像改成Intel和ST合资的恒忆（Numonyx）了。。。）的 Nor Flash，M29W320DB （32 M， bottom boot sect）

　　，比较特殊些，是0xF0。

　　4.

　　boot sector的位置

　　刚刚看了下datasheet，很汗的是，本以为bottom sect是底部的sect，是地址最大的那个，结果datasheet中的是倒叙计算开始处的，也就是地址最大的那个块，是第一个块，所以，此处的boot sector 是块0-3：

　　# Size （KByte/KWord） Address Range（x8 ）/ Address Range （x16）

　　66 64/32 3F0000h-3FFFFFh

　　1F8000h-1FFFFFh

　　。。。。。

　　。。。。。

　　3 32/16 008000h-00FFFFh

　　004000h-007FFFh

　　2 8/4

　　006000h-007FFFh

　　003000h-003FFFh

　　1 8/4

　　004000h-005FFFh

　　002000h-002FFFh

　　0 16/8 000000h-003FFFh

　　000000h-001FFFh

　　Uboot下关于Nor Flash的驱动问题

　　nor flash 的使用特点是 ： 读操作可以按地址读， 写之前必须进行擦除， 一旦擦除必须擦除整个扇区。

　　新型的flash 使用3V 的电压便可以进行整个扇区的擦除和写入操作

　　任何芯片的使用， 都离不开驱动的支持。 uboot下的nor flash的驱动逻辑非常简单。 而且， 对于符合 CFI （ Common Flash Interface ）规范的flash芯片，驱动有很大的通用性。

　　uboot 提供了很好的 flash 驱动逻辑 和 flash的使用范例， 这些基本的使用方法在linux里也是同样的逻辑，只不过linux下需要加上一层分区信息。 结合flash 芯片手册， 可以对nor flash的使用逻辑有较为清晰的理解。

　　nor flash的驱动初始化部分：

　　arch/mips/cpu/octeon/start.S

　　board_init_r -》 flash_init（）

　　drivers/mtd/cfi_flash.c

　　unsigned long flash_init （void）{

　　for （i = 0; i 《 CONFIG_SYS_MAX_FLASH_BANKS; ++i） {

　　flash_info［i］.flash_id = FLASH_UNKNOWN;

　　…

　　//由于使用的flash 是新型的CFI 规范的flash， 没有使用 CONFIG_FLASH_CFI_LEGACY 这个宏， 所以flash_detect_legacy直接返回0

　　if （！flash_detect_legacy（cfi_flash_bank_addr（i）， i））

　　flash_get_size（cfi_flash_bank_addr（i）， i）;

　　size += flash_info［i］.size;

　　ulong flash_get_size （phys_addr_t base， int banknum）

　　{

　　flash_info_t *info = &flash_info［banknum］;

　　int i， j;

　　flash_sect_t sect_cnt;

　　phys_addr_t sector;

　　unsigned long tmp;

　　int size_ratio;

　　uchar num_erase_regions;

　　int erase_region_size;

　　int erase_region_count;

　　struct cfi_qry qry;

　　unsigned long max_size;

　　memset（&qry， 0， sizeof（qry））;

　　info-》ext_addr = 0;

　　info-》cfi_version = 0;

　　#ifdef CONFIG_SYS_FLASH_PROTECTION

　　info-》legacy_unlock = 0;

　　#endif

　　info-》start［0］ = （ulong）map_physmem（base， info-》portwidth， MAP_NOCACHE）;

　　//如果是CFI 接口， 那么有统一的查询规范， 将查询到的信息保存到 qry中

　　if （flash_detect_cfi （info， &qry）） {

　　info-》vendor = le16_to_cpu（qry.p_id）;

　　info-》ext_addr = le16_to_cpu（qry.p_adr） * 2;

　　debug（“extended address is 0x%x ”， info-》ext_addr）;

　　num_erase_regions = qry.num_erase_regions;

　　if （info-》ext_addr） {

　　#define FLASH_OFFSET_CFI_RESP 0x20

　　flash_detect_cfi -》

　　static int __flash_detect_cfi （flash_info_t * info， struct cfi_qry *qry）

　　{

　　int cfi_offset;

　　for （cfi_offset=0;

　　cfi_offset 《 sizeof（flash_offset_cfi） / sizeof（uint）;

　　cfi_offset++） {

　　/* Issue FLASH reset command */

　　flash_cmd_reset（info）;

　　flash_write_cmd （info， 0， flash_offset_cfi［cfi_offset］，

　　FLASH_CMD_CFI）;

　　//向0x20 地址进行查询， CFI 规定 ， 前三个字符应该是 Q， R， Y

　　if （flash_isequal （info， 0， FLASH_OFFSET_CFI_RESP， ‘Q’）

　　&& flash_isequal （info， 0， FLASH_OFFSET_CFI_RESP + 2， ‘R’）

　　&& flash_isequal （info， 0， FLASH_OFFSET_CFI_RESP + 4， ‘Y’）） {

　　//如果确认为CFI 规范， 那么就按照 struct cfi_qry数据结构进行查询

　　flash_read_cfi（info， qry， FLASH_OFFSET_CFI_RESP，

　　sizeof（struct cfi_qry））;

　　…

　　//在进行CFI 规范查询之后， 还要将addr_unlock1 ， addr_unlock2 进行赋值， 这两个地址分别表示8位宽的地址和16位宽的地址， 可以实现byte和word的操作。

　　//一般地， 我们只使用addr_unlock1

　　//在一些代码里， 这两个数值就通过宏定义来实现的

　　info-》addr_unlock1 = 0xaaa;

　　info-》addr_unlock2 = 0x555;

　　…

　　}

　　下面是flash 芯片手册里CFI 规范查询的信息：

　　

　　cfi_qry 定义：

　　struct cfi_qry {

　　u8 qry［3］; //保存 Q， R， Y

　　u16 p_id; //Primary algorithm

　　u16 p_adr; //Address for primary algorithm

　　u16 a_id; //Alternate

　　u16 a_adr; //Address for alternate

　　u8 vcc_min; // 最小Vcc

　　u8 vcc_max; //最大Vcc

　　u8 vpp_min; //最小Vpp

　　u8 vpp_max; //最大Vpp

　　u8 word_write_timeout_typ; //字节写典型超时

　　u8 buf_write_timeout_typ; //缓存写典型超时

　　u8 block_erase_timeout_typ; //块擦除典型超时

　　u8 chip_erase_timeout_typ; //整片擦除典型超时

　　u8 word_write_timeout_max; //字节写最大超时

　　u8 buf_write_timeout_max; //缓存写最大超时

　　u8 block_erase_timeout_max; //块写最大超时

　　u8 chip_erase_timeout_max; //整片擦除最大超时

　　u8 dev_size; //芯片大小

　　u16 interface_desc; //接口描述

　　u16 max_buf_write_size; //最大缓存写长度

　　u8 num_erase_regions; //擦除块扇区数量

　　u32 erase_region_info［NUM_ERASE_REGIONS］; //4个块区的信息

　　} __attribute__（（packed））;

　　从上图可以看到， 是获取了CFI query identification string ， System interface information ， Device geometry definition 信息，对照手册， 就可以知道成员的数值

　　其中， 最为重要的是擦写扇区信息 erase_region_info， 对应手册的如下信息：

　　

　　手册给出了扇区的信息， 第一部分说明了扇区（block）的个数 ： 0xff + 1 = 256 个， 第二部分说明了一个扇区（block）大小： 0x200 * 256 =131072， 即128K字节

　　我们的flash， 为00ff， 和0200 。那么uint32_t的tmp 的数值应该为： 0x020000ff

　　tmp = le32_to_cpu（qry.erase_region_info［i］）;

　　debug（“erase region %u： 0x%08lx ”， i， tmp）;

　　erase_region_count = （tmp & 0xffff） + 1;

　　tmp 》》= 16;

　　erase_region_size = （tmp & 0xffff） ？ （（tmp & 0xffff） * 256） ： 128;

　　tmp = qry.erase_region_info［i］ = 0x20000ff

　　tmp 》》=16 后， tmp = 0x200

　　擦写扇区的大小 erase_region_size = （tmp & 0xffff） * 256 = 0x20000 ， 即一个扇区的大小为0x2000字节。

　　擦写扇区的个数 erase_region_count为0x201， 即256个扇区

　　那么， 可以知道， 整个nor flash 总的容量为： 0x2000 * 256 = 33554432 字节，

　　验证一下： 33554432 / 1024 / 1024 = 32 M

　　sect_cnt = 0;

　　sector = base;//基地址为 0x1dc00000

　　…

　　那么会循环256次。

　　for （j = 0; j 《 erase_region_count; j++） {

　　。。

　　//在256次循环中， 256个start成员保存各个扇区的地址

　　info-》start［sect_cnt］ =

　　（ulong）map_physmem（sector，

　　info-》portwidth，

　　MAP_NOCACHE）;

　　//计算各个扇区的地址， 地址计算方法为， 扇区的大小 * size_ratio（ 为 size_ratio = info-》portwidth / info-》chipwidth;，比值为1）

　　//可以看出， 各个扇区的地址相隔一个扇区的大小

　　sector += （erase_region_size * size_ratio）;

　　…

　　sect_cnt++;

　　}

　　info-》sector_count = sect_cnt;

　　//buffer_size 为 1 《《 8 ， 256

　　info-》buffer_size = 1 《《 （8 * info-》portwidth）;

　　…

　　}

　　循环结束后， sect_cnt 的数值为 256

　　现在， 所有扇区的地址都保存到了init-》start数组里。 那么现在如果要向flash里烧写一个文件， 在知道文件的大小的情况下，就可以计算出要使用几个扇区。

　　include/flash.h：

　　#define CONFIG_SYS_MAX_FLASH_SECT （256）

　　typedef struct {

　　ulong size; /* total bank size in bytes */

　　ushort sector_count; /* number of erase units */

　　ulong flash_id; /* combined device & manufacturer code */

　　ulong start［CONFIG_SYS_MAX_FLASH_SECT］; /* virtual sector start address */

　　uchar protect［CONFIG_SYS_MAX_FLASH_SECT］; /* sector protection status */

　　#ifdef CONFIG_SYS_FLASH_CFI

　　uchar portwidth; /* the width of the port */

　　uchar chipwidth; /* the width of the chip */

　　ushort buffer_size; /* # of bytes in write buffer */

　　ulong erase_blk_tout; /* maximum block erase timeout */

　　ulong write_tout; /* maximum write timeout */

　　ulong buffer_write_tout; /* maximum buffer write timeout */

　　ushort vendor; /* the primary vendor id */

　　ushort cmd_reset; /* vendor specific reset command */

　　ushort interface; /* used for x8/x16 adjustments */

　　ushort legacy_unlock; /* support Intel legacy （un）locking */

　　ushort manufacturer_id; /* manufacturer id */

　　ushort device_id; /* device id */

　　ushort device_id2; /* extended device id */

　　ushort ext_addr; /* extended query table address */

　　ushort cfi_version; /* cfi version */

　　ushort cfi_offset; /* offset for cfi query */

　　ulong addr_unlock1; /* unlock address 1 for AMD flash roms */

　　ulong addr_unlock2; /* unlock address 2 for AMD flash roms */

　　const char *name; /* human-readable name */

　　#endif

　　} flash_info_t;

　　uboot 就是按照如上的思路来实现uboot的更新， common/cmd_flash.c 有很好的flash使用范例：

　　int do_upgrade （cmd_tbl_t *cmdtp， int flag， int argc， char * const argv［］）

　　{

　　int rcode = 0;

　　ulong addr， addr_first， addr_last;

　　const bootloader_header_t *header;

　　if （argc ！= 4） {

　　if （argc == 2 || argc == 3） {

　　if （strcmp（argv［1］， “uboot”） ！= 0）

　　return cmd_usage（cmdtp）;

　　//获取环境变量loadaddr的数值， 这是要更新的文件在内存里的起始地址

　　if （getenv（“loadaddr”） ！= NULL）

　　addr = simple_strtoul（getenv（“loadaddr”）， NULL， 16）;

　　else

　　return cmd_usage（cmdtp）;

　　//（0x1fc00000 - CONFIG_SYS_FLASH_SIZE） = 0x1dc00000

　　//计算出uboot的起始地址

　　addr_first = CONFIG_SYS_FLASH_BASE;

　　if （argc == 3 && strcmp（argv［2］， “all”） == 0） {

　　addr_last = addr_first + CONFIG_BOOT_SIZE - 1;

　　}else

　　//CONFIG_ENV_ADDR = 0x1fbe0000

　　//addr_last = 0x1fbdffff

　　//计算出uboot的结束地址

　　addr_last = CONFIG_ENV_ADDR - 1;

　　// 验证下载的uboot 释放符合bootload 的格式。

　　header = （void *）addr;

　　if （validate_header（header）） {

　　printf（“Image does not have valid header form addr:0x%lx ”， addr）;

　　return 1;

　　}

　　。。.

　　//知道了uboot的起始，结束地址， 就可以知道uboot在flash 里要使用几个扇区。

　　/*

　　一， 先取消要使用的扇区保护， 参数0 表示取消保护

　　*/

　　if （（rcode = flash_sect_protect（0， addr_first， addr_last）） ！= 0）

　　return rcode;

　　//擦除要使用到的扇区

　　if （（rcode = flash_sect_erase（addr_first， addr_last）） ！= 0）

　　return rcode;

　　//向要使用到的扇区写入数据

　　puts （“Copy to Flash.。。 ”）;

　　if （（rcode = flash_write（（char *）addr， addr_first， addr_last - addr_first）） ！= 0） {

　　flash_perror（rcode）;

　　return 1;

　　}

　　puts （“done ”）;

　　return 0;

　　}

　　int flash_sect_protect （int p， ulong addr_first， ulong addr_last）

　　{

　　flash_info_t *info;

　　ulong bank;

　　int s_first［CONFIG_SYS_MAX_FLASH_BANKS］， s_last［CONFIG_SYS_MAX_FLASH_BANKS］;

　　int protected， i;

　　int planned;

　　int rcode;

　　/*

　　通过flash的起始地址和结束地址， 计算出起始扇区和结束扇区， 以及要使用到的扇区个数， 分别保存到s_first， s_last， planned 中。

　　*/

　　rcode = flash_fill_sect_ranges（ addr_first， addr_last， s_first， s_last， &planned ）;

　　…

　　static int

　　flash_fill_sect_ranges （ulong addr_first， ulong addr_last，

　　int *s_first， int *s_last，

　　int *s_count ）

　　{

　　flash_info_t *info;

　　ulong bank;

　　int rcode = 0;

　　*s_count = 0;

　　//初始化参数

　　for （bank=0; bank 《 CONFIG_SYS_MAX_FLASH_BANKS; ++bank） {

　　s_first［bank］ = -1; /* first sector to erase */

　　s_last ［bank］ = -1; /* last sector to erase */

　　}

　　//只有一次循环

　　for （bank=0，info = &flash_info［0］;

　　（bank 《 CONFIG_SYS_MAX_FLASH_BANKS） && （addr_first 《= addr_last）;

　　++bank， ++info） {

　　ulong b_end;

　　int sect;

　　short s_end;

　　if （info-》flash_id == FLASH_UNKNOWN） {

　　continue;

　　}

　　//start［0］保存的是flash的起始地址 ， size是整个芯片的大小， 那么info-》start［0］ + info-》size - 1的 含义就是 整个芯片的结束地址

　　b_end = info-》start［0］ + info-》size - 1; /* bank end addr */

　　//最后一个扇区的标号

　　s_end = info-》sector_count - 1; /* last sector */

　　//遍历所有扇区， 即256个扇区

　　for （sect=0; sect 《 info-》sector_count; ++sect） {

　　ulong end; /* last address in current sect */

　　//当前扇区的最后地址

　　end = （sect == s_end） ？ b_end ： info-》start［sect + 1］ - 1;

　　if （addr_first 》 end）

　　continue;

　　//当uboot的结束地址小于当前扇区的地址时， 直接判断下个扇区。 目的是快速找到uboot的结束地址所在flash的扇区。

　　if （addr_last 《 info-》start［sect］）

　　continue;

　　//当文件起始地址等于扇区起始地址， 将当前扇区地址保存到s_first［0］ 中。

　　if （addr_first == info-》start［sect］） {

　　s_first［bank］ = sect;

　　}

　　//当文件结束地址等于当前扇区结束地址时， 将当前扇区标号保存到s_last［0］中。。 这个部分uboot的代码需要优化， 正常的逻辑下， 这个时候可以直接break了。 无须再进入循环。 本人已经验证通过

　　if （addr_last == end） {

　　s_last［bank］ = sect;

　　}

　　}

　　//如果s_first［0］有数值， 即查找成功的话， 计算出占有了几个扇区。

　　if （s_first［bank］ 》= 0） {

　　//如果没有找到s_last， 有两种情况， 如果目标文件大于flash的大小， 那么设定s_last 为最后一个扇区。 否则是逻辑错误。

　　if （s_last［bank］ 《 0） {

　　if （addr_last 》 b_end） {

　　s_last［bank］ = s_end;

　　} else {

　　puts （“Error： end address”

　　“ not on sector boundary ”）;

　　rcode = 1;

　　break;

　　}

　　} //如果得到的结果是结束的扇区标号小于起始扇区标号， 也是逻辑错误

　　if （s_last［bank］ 《 s_first［bank］） {

　　puts （“Error： end sector”

　　“ precedes start sector ”）;

　　rcode = 1;

　　break;

　　}

　　//记录结束扇区的编号。

　　sect = s_last［bank］;

　　addr_first = （sect == s_end） ？ b_end + 1： info-》start［sect + 1］;

　　//s_last［bank］ - s_first［bank］ + 1 就是中间的扇区个数

　　（*s_count） += s_last［bank］ - s_first［bank］ + 1;

　　} else if （addr_first 》= info-》start［0］ && addr_first 《 b_end） {

　　puts （“Error： start address not on sector boundary ”）;

　　rcode = 1;

　　break;

　　} else if （s_last［bank］ 》= 0） {

　　puts （“Error： cannot span across banks when they are”

　　“ mapped in reverse order ”）;

　　rcode = 1;

　　break;

　　}

　　}

　　return rcode;

　　}

　　回到：

　　#ifndef CONFIG_SYS_NO_FLASH

　　int flash_sect_protect （int p， ulong addr_first， ulong addr_last）

　　{

　　flash_info_t *info;

　　ulong bank;

　　int s_first［CONFIG_SYS_MAX_FLASH_BANKS］， s_last［CONFIG_SYS_MAX_FLASH_BANKS］;

　　int protected， i;

　　int planned;

　　int rcode;

　　rcode = flash_fill_sect_ranges（ addr_first， addr_last， s_first， s_last， &planned ）;

　　protected = 0;

　　if （planned && （rcode == 0）） {

　　for （bank=0，info = &flash_info［0］; bank 《 CONFIG_SYS_MAX_FLASH_BANKS; ++bank， ++info） {

　　if （info-》flash_id == FLASH_UNKNOWN） {

　　continue;

　　}

　　if （s_first［bank］》=0 && s_first［bank］《=s_last［bank］） {

　　debug （“%sProtecting sectors %d..%d in bank %ld ”，

　　p ？ “” ： “Un-”，

　　s_first［bank］， s_last［bank］， bank+1）;

　　protected += s_last［bank］ - s_first［bank］ + 1;

　　//为获取到的扇区取消保护

　　for （i=s_first［bank］; i《=s_last［bank］; ++i） {

　　#if defined（CONFIG_SYS_FLASH_PROTECTION）

　　//就是 改变 info-》addr_unlock1 的标识和将info-》protect 的对应成员置0， 否则后面不能 erase 和write

　　if （flash_real_protect（info， i， p））

　　rcode = 1;

　　putc （‘。’）;

　　#else

　　info-》protect［i］ = p;

　　#endif /* CONFIG_SYS_FLASH_PROTECTION */

　　}

　　}

　　}

　　#if defined（CONFIG_SYS_FLASH_PROTECTION）

　　puts （“ done ”）;

　　#endif /* CONFIG_SYS_FLASH_PROTECTION */

　　printf （“%sProtected %d sectors ”，

　　p ？ “” ： “Un-”， protected）;

　　} else if （rcode == 0） {

　　puts （“Error： start and/or end address”

　　“ not on sector boundary ”）;

　　rcode = 1;

　　}

　　return rcode;

　　}

　　#ifndef CONFIG_SYS_NO_FLASH

　　int flash_sect_erase （ulong addr_first， ulong addr_last）

　　{

　　flash_info_t *info;

　　ulong bank;

　　int s_first［CONFIG_SYS_MAX_FLASH_BANKS］， s_last［CONFIG_SYS_MAX_FLASH_BANKS］;

　　int erased = 0;

　　int planned;

　　int rcode = 0;

　　//跟之前取消保护一样， 也需要通过给定地址计算出要操作的扇区。 这个地方实在多余， 完全可以使用之前已经获取到的数据作为参数传下来。

　　//总之 flash_sect_erase 和 flash_sect_protect 的重复度太高

　　rcode = flash_fill_sect_ranges （addr_first， addr_last，

　　s_first， s_last， &planned ）;

　　if （planned && （rcode == 0）） {

　　for （bank=0，info = &flash_info［0］;

　　（bank 《 CONFIG_SYS_MAX_FLASH_BANKS） && （rcode == 0）;

　　++bank， ++info） {

　　if （s_first［bank］》=0） {

　　erased += s_last［bank］ - s_first［bank］ + 1;

　　debug （“Erase Flash from 0x%08lx to 0x%08lx ”

　　“in Bank # %ld ”，

　　info-》start［s_first［bank］］，

　　（s_last［bank］ == info-》sector_count） ？

　　info-》start［0］ + info-》size - 1：

　　info-》start［s_last［bank］+1］ - 1，

　　bank+1）;

　　//flash_erase 是drivers/mtd/cfi_flash.c 提供的flash 擦除接口。

　　rcode = flash_erase （info， s_first［bank］， s_last［bank］）;

　　}

　　}

　　printf （“Erased %d sectors ”， erased）;

　　} else if （rcode == 0） {

　　puts （“Error： start and/or end address”

　　“ not on sector boundary ”）;

　　rcode = 1;

　　}

　　return rcode;

　　}

　　#endi

　　int flash_erase （flash_info_t * info， int s_first， int s_last）

　　{

　　…

　　for （sect = s_first; sect 《= s_last; sect++） {

　　////如果扇区处于保护状态， 将无法擦除

　　if （info-》protect［sect］ == 0） { /* not protected */

　　switch （info-》vendor） {

　　…

　　break;

　　case CFI_CMDSET_AMD_STANDARD：

　　case CFI_CMDSET_AMD_EXTENDED：

　　flash_write_cmd （info， 0， 0， AMD_CMD_RESET）; // （1）

　　flash_unlock_seq （info， sect）; //（2）

　　flash_write_cmd （info， sect， info-》addr_unlock1，AMD_CMD_ERASE_START）; //（3）

　　flash_unlock_seq （info， sect）;//（4）

　　flash_write_cmd （info， sect， 0，AMD_CMD_ERASE_SECTOR）;//（5）

　　break;

　　…

　　}

　　/*

　　根据手册， 扇区的擦写动作指令为：

　　

　　#define AMD_CMD_UNLOCK_START 0xAA

　　#define AMD_CMD_UNLOCK_ACK 0x55

　　static void flash_unlock_seq （flash_info_t * info， flash_sect_t sect）{

　　flash_write_cmd （info， sect， info-》addr_unlock1， AMD_CMD_UNLOCK_START）;

　　flash_write_cmd （info， sect， info-》addr_unlock2， AMD_CMD_UNLOCK_ACK）;

　　}

　　全部擦写的操作是，

　　__RESET

　　1， 向 0xaaa 写入 aa

　　2， 向 0x555 写入 55

　　3， 向 0xaaa 写入80

　　4， 向 0xaaa 写入aa

　　5， 向0x555 写入55

　　6， 向扇区地址 写入30

　　__RESET 由（1） 完成

　　1，2 由 （2） 完成

　　3 由 （3）完成

　　4，5由（4）完成

　　6 由 （5）完成

　　*/

　　/*

　　指令的下发后， 还要使用状态查询函数， 等待指令的完成， 即硬件的执行完成。 这个过程是最耗时的。

　　*/

　　if （use_flash_status_poll（info）） {

　　cfiword_t cword = （cfiword_t）0xffffffffffffffffULL;

　　void *dest;

　　//获取扇区的内存地址

　　dest = flash_map（info， sect， 0）;

　　//传入的超时时间为 info-》erase_blk_tout， 这个数值为： （1 《《 qry.block_erase_timeout_typ） * （1 《《 qry.block_erase_timeout_max）

　　//根据手册， 计算出扇区最大超时时间为： 4096s， 意味着， 如果4096s内扇区还没有擦写完成， 那么就超时退出

　　st = flash_status_poll（info， &cword， dest， info-》erase_blk_tout， “erase”）;

　　flash_unmap（info， sect， 0， dest）;

　　} else

　　st = flash_full_status_check（info， sect，

　　info-》erase_blk_tout，

　　“erase”）;

　　if （st）

　　rcode = 1;

　　else if （flash_verbose）

　　putc （‘。’）;

　　if （ctrlc（）） {

　　puts（“ Interrupted ”）;

　　return 1;

　　}

　　}

　　}

　　if （flash_verbose）

　　puts （“ done ”）;

　　return rcode;

　　}

　　static int flash_status_poll（flash_info_t *info， void *src， void *dst，

　　ulong tout， char *prompt）

　　{

　　#ifdef CONFIG_SYS_CFI_FLASH_STATUS_POLL

　　ulong start;

　　int ready;

　　…

　　start = get_timer（0）;

　　WATCHDOG_RESET（）;

　　while （1） {

　　switch （info-》portwidth） {

　　case FLASH_CFI_8BIT：

　　/*根据flash 的位宽（portwidth）， 判断目的地址的数值是否等于src地址的数值。 上面传下来src的数值为全f， dst地址是当前扇区的0地址，

　　那么flash_erase 的擦写指令完成的判断条件是： 当前扇区的0地址的数值为0xff

　　如果判断条件成立后跳出循环， 否则udelay后， 再次进入循环 */

　　ready = flash_read8（dst） == flash_read8（src）;

　　break;

　　case FLASH_CFI_16BIT：

　　ready = flash_read16（dst） == flash_read16（src）;

　　break;

　　case FLASH_CFI_32BIT：

　　ready = flash_read32（dst） == flash_read32（src）;

　　break;

　　case FLASH_CFI_64BIT：

　　ready = flash_read64（dst） == flash_read64（src）;

　　break;

　　default：

　　ready = 0;

　　break;

　　}

　　if （ready）

　　break;

　　if （get_timer（start） 》 tout） {

　　printf（“Flash %s timeout at address %lx data %lx ”，

　　prompt， （ulong）dst， （ulong）flash_read8（dst））;

　　return ERR_TIMOUT;

　　}

　　udelay（1）; /* also triggers watchdog */

　　}

　　#endif /* CONFIG_SYS_CFI_FLASH_STATUS_POLL */

　　return ERR_OK;

　　}

　　回到do_upgrade， 扇区擦写完成后， 调用flash_write 进行写入操作

　　code = flash_write（（char *）addr， addr_first， addr_last - addr_first）） ！= 0） {

　　src 是要烧些的文件的起始， addr 是要烧写到flash的目的地址， cnt 是要烧写的长度

　　int flash_write （char *src， ulong addr， ulong cnt）{

　　int i;

　　ulong end = addr + cnt - 1;

　　//在单个bank的flash里， 只有一个info， info_first等于info_last

　　flash_info_t *info_first = addr2info （addr）;

　　flash_info_t *info_last = addr2info （end ）;

　　flash_info_t *info;

　　…

　　//在单个bank的flash里， 只有一次循环

　　for （info = info_first; info 《= info_last; ++info） {

　　ulong b_end = info-》start［0］ + info-》size; /* bank end addr */

　　short s_end = info-》sector_count - 1;

　　for （i=0; i《info-》sector_count; ++i） {

　　ulong e_addr = （i == s_end） ？ b_end ： info-》start［i + 1］;

　　//如果要操作的扇区没有取消保护， 直接返回

　　if （（end 》= info-》start［i］） && （addr 《 e_addr） &&

　　（info-》protect［i］ ！= 0） ） {

　　return （ERR_PROTECTED）;

　　}

　　}

　　}

　　/* finally write data to flash */

　　for （info = info_first; info 《= info_last && cnt》0; ++info） {

　　ulong len;

　　len = info-》start［0］ + info-》size - addr;

　　if （len 》 cnt）

　　len = cnt;

　　//单个bank的flash调用 write_buf后返回操作结果

　　if （（i = write_buff（info， （uchar *）src， addr， len）） ！= 0） {

　　return （i）;

　　}

　　//多个bank的情况

　　cnt -= len;

　　addr += len;

　　src += len;

　　}

　　return （ERR_OK）;

　　}

　　//info 为flash的数据结构， src为源文件的内存地址， addr 为目的flash 地址， cnt 为文件要写的长度

　　int write_buff （flash_info_t * info， uchar * src， ulong addr， ulong cnt）

　　{

　　ulong wp;

　　uchar *p;

　　int aln;

　　cfiword_t cword;

　　int i， rc;

　　#ifdef CONFIG_SYS_FLASH_USE_BUFFER_WRITE

　　int buffered_size;

　　#endif

　　#ifdef CONFIG_FLASH_SHOW_PROGRESS

　　int digit = CONFIG_FLASH_SHOW_PROGRESS;

　　int scale = 0;

　　int dots = 0;

　　/*

　　* Suppress if there are fewer than CONFIG_FLASH_SHOW_PROGRESS writes.

　　*/

　　if （cnt 》= CONFIG_FLASH_SHOW_PROGRESS） {

　　scale = （int）（（cnt + CONFIG_FLASH_SHOW_PROGRESS - 1） /

　　CONFIG_FLASH_SHOW_PROGRESS）;

　　}

　　#endif

　　//wp的数值为addr

　　wp = （addr & ~（info-》portwidth - 1））;

　　…

　　buffered_size = （info-》portwidth / info-》chipwidth）;

　　buffered_size *= info-》buffer_size;

　　//buffered_size 为256

　　while （cnt 》= info-》portwidth） {

　　//buffer_size 长度为1的情况，就是按字节写的情况

　　if （info-》buffer_size == 1） {

　　cword.l = 0;

　　for （i = 0; i 《 info-》portwidth; i++）

　　flash_add_byte （info， &cword， *src++）;

　　if （（rc = flash_write_cfiword （info， wp， cword）） ！= 0）

　　return rc;

　　wp += info-》portwidth;

　　cnt -= info-》portwidth;

　　continue;

　　}

　　//buffer_size 不为1， 按buffer 写的情况

　　//如果地址为buffer_size 的整数倍， 那么i 就等于 buffer_size.256 字节。

　　//可以看到， 按缓存写的话 ， 总共会执行 （文件长度 / 256 + 1 次） 。 如果要写入的长度为 0xdffff， 那么要执行的次数为 0xdffff / 256 + 1 = 3584 次。

　　i = buffered_size - （wp % buffered_size）;

　　if （i 》 cnt）

　　i = cnt; //如果缓存写长度大于剩余的要写入的文件长度， 那么长度截为cnt

　　if （（rc = flash_write_cfibuffer （info， wp， src， i）） ！= ERR_OK）

　　return rc;

　　i -= i & （info-》portwidth - 1）;

　　wp += i; //要写入的内容的地址移动 i 长度

　　src += i; //要写入的文件的地址向后移动 i 长度

　　cnt -= i; //文件的剩余长度减去 i 长度

　　FLASH_SHOW_PROGRESS（scale， dots， digit， i）;

　　}

　　…

　　if （cnt == 0） {

　　return （0）;

　　}

　　/*

　　* handle unaligned tail bytes

　　*/

　　cword.l = 0;

　　p = （uchar *）wp;

　　for （i = 0; （i 《 info-》portwidth） && （cnt 》 0）; ++i） {

　　flash_add_byte （info， &cword， *src++）;

　　--cnt;

　　}

　　for （; i 《 info-》portwidth; ++i）

　　flash_add_byte （info， &cword， flash_read8（p + i））;

　　return flash_write_cfiword （info， wp， cword）;

　　}

　　对于字节写和缓存写， 分别 有flash_write_cfiword 和flash_write_cfibuffer 实现

　　static int flash_write_cfiword （flash_info_t * info， ulong dest，

　　cfiword_t cword）

　　{

　　void *dstaddr = （void *）dest;

　　int flag;

　　flash_sect_t sect = 0;

　　char sect_found = 0;

　　//根据端口宽度 ， 判断要操作的地址上的数值是否为cword的数值。

　　//上面传的cword 为0 ， 那么要判断要写的地址的数值是否为0 ， 如果判断结果为假，那么退出，返回ERR_NOT_ERASE错误数值。提示没有经过擦写。

　　switch （info-》portwidth） {

　　case FLASH_CFI_8BIT：

　　flag = （（flash_read8（dstaddr） & cword.c） == cword.c）;

　　break;

　　case FLASH_CFI_16BIT：

　　flag = （（flash_read16（dstaddr） & cword.w） == cword.w）;

　　break;

　　case FLASH_CFI_32BIT：

　　flag = （（flash_read32（dstaddr） & cword.l） == cword.l）;

　　break;

　　case FLASH_CFI_64BIT：

　　flag = （（flash_read64（dstaddr） & cword.ll） == cword.ll）;

　　break;

　　default：

　　flag = 0;

　　break;

　　}

　　if （！flag）

　　return ERR_NOT_ERASED;

　　//上面看到， flash在执行烧些前， 要先取消保护， 再进行擦除， 当两者都成功后， 才可以进行write

　　//在执行烧些过程中， 关闭全部中断， 所有的中断新号会被忽略

　　flag = disable_interrupts （）;

　　//根据不同厂商，执行对应的指令。

　　switch （info-》vendor） {

　　case CFI_CMDSET_INTEL_PROG_REGIONS：

　　case CFI_CMDSET_INTEL_EXTENDED：

　　case CFI_CMDSET_INTEL_STANDARD://intel 的规范

　　flash_write_cmd （info， 0， 0， FLASH_CMD_CLEAR_STATUS）;

　　flash_write_cmd （info， 0， 0， FLASH_CMD_WRITE）;

　　break;

　　case CFI_CMDSET_AMD_EXTENDED：

　　case CFI_CMDSET_AMD_STANDARD： //AMD 的规范

　　//根据目的地址找到要操作的扇区

　　sect = find_sector（info， dest）;

　　//解锁扇区

　　flash_unlock_seq （info， sect）;

　　//输入write 指令

　　flash_write_cmd （info， sect， info-》addr_unlock1， AMD_CMD_WRITE）;

　　sect_found = 1;

　　break;

　　…

　　}

　　//等待指令完成

　　switch （info-》portwidth） {

　　case FLASH_CFI_8BIT：

　　flash_write8（cword.c， dstaddr）;

　　if （info-》vendor ！= 1） {

　　while （flash_read8（dstaddr） ！= cword.c）

　　;

　　}

　　break;

　　case FLASH_CFI_16BIT：

　　flash_write16（cword.w， dstaddr）;

　　if （info-》vendor ！= 1） {

　　while （flash_read16（dstaddr） ！= cword.w）

　　;

　　}

　　break;

　　case FLASH_CFI_32BIT：

　　flash_write32（cword.l， dstaddr）;

　　case FLASH_CFI_64BIT：

　　flash_write64（cword.ll， dstaddr）;

　　if （info-》vendor ！= 1） {

　　while （flash_read64（dstaddr） ！= cword.ll）

　　;

　　}

　　break;

　　}

　　//恢复中断

　　if （flag）

　　enable_interrupts （）;

　　if （！sect_found）

　　sect = find_sector （info， dest）;

　　if （use_flash_status_poll（info））

　　return flash_status_poll（info， &cword， dstaddr，

　　info-》write_tout， “write”）;

　　else

　　return flash_full_status_check（info， sect，

　　info-》write_tout， “write”）;

　　}

　　flash_write_cfibuffer 使用了同样的逻辑 ， 不同的指令

　　结语

　　关于Nor Flash的相关介绍就到这了，如有不足之处欢迎指正。

相关阅读推荐：对于嵌入式为什么要有uboot的深度解析

相关阅读推荐：nand和nor区别