Chinaunix首页 | 论坛 | 博客

oops

首页　| 　博文目录　| 　关于我

王贤才

  • 博客访问： 1184902
  • 博文数量： 573
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 66
  • 用 户 组： 普通用户
  • 注册时间： 2016-06-28 16:21
文章分类

全部博文（573）

文章存档

2018年（3）

2016年（48）

2015年（522）

我的朋友
最近访客
推荐博文
相关博文
nandflash裸机驱动程序

分类： LINUX

2015-12-02 11:49:28

def.h文件

点击(此处)折叠或打开

  1. #ifndef __DEF_H__
  2. #define __DEF_H__

  4. #define U32 unsigned int
  5. #define U16 unsigned short
  6. #define S32 int
  7. #define S16 short int
  8. #define U8 unsigned char
  9. #define    S8 char

  11. #endif
head.S文件

点击(此处)折叠或打开

  1. @*************************************************************************
  2. @ File：step1.S bootloader第1阶段的代码
  3. @ 功能：关watch_dog，初始化clock，初始化SDRAM，初始化NAND Flash，代码重定位到SDRAM
  4. @ 然后跳到SDRAM,继续执行第2阶段的代码
  5. @*************************************************************************

  7. .text @text表示是代码段
  8. .global _start
  9. _start: /*_start在这里表示.text段的链接地址。对应于：链接脚本中指定的.text段的起始地址=0x31000000*/
  10.                                             @函数disable_watch_dog, memsetup, init_nand, nand_read_ll在init.c中定义
  11.             ldr sp, =0x34000000 @设置栈
  12.             bl disable_watch_dog @关WATCH DOG
  13.             bl clock_init @设置MPLL，改变FCLK、HCLK、PCLK
  14.             bl memsetup @初始化SDRAM
  15.             @bl init_uart @初始化UART，如果代码比较大，这个函数不一定会在4k内，所以在main函数中调用
  16.             bl nand_init @初始化NAND Flash

  18.                                                                                         @ 复制nand中4k后的代码到SDRAM中
  19.                         ldr r0, =_start                                    @ 1. 目标地址 = 0x31000000,这是在SDRAM中的链接地址
  20.                         ldr r1, =0x0                                        @ 2. 源地址 = 0，运行地址在SDRAM中的代码保存在NAND Flash 0地址开始处,或者norflash的0地址处
  21.                         ldr r2, =__bss_start                        @ 3. 复制长度
  22.                         sub r2, r2, r0
  23.                  bl CopyCode2SDRAM @ 调用C函数CopyCode2SDRAM
  24.                 
  25.                     bl clean_bss         @ 清除bss段，未初始化或初值为0的全局/静态变量保存在bss段

  27.             ldr lr, =my_loop @设置返回地址
  28.             ldr pc, =main @b指令和bl指令只能前后跳转32M的范围，所以这里使用向pc赋值的方法进行跳转
  29. my_loop:
  30.             b my_loop
  31.             


  34. /*
  35. 关于是否可用 @bl init_uart 的问题
  36. makefile文件中 是 objs := head.o init.o setup.o nand.o leds.o uart.o 时，在head.S文件中 必须使用 : @bl init_uart,在main函数中调用 init_uart
  37. makefile文件中 是 objs := head.o uart.o init.o setup.o nand.o leds.o 时，在head.S文件中 可以使用 : bl init_uart
  38. 原因 :
  39. 本程序生成的 nand.bin有6.6K左右，而bl的跳转范围是4K,
  40. 生成目标文件链接时，会按照 makefile 中 给定的.o文件的顺序来链接所有.o文件，所以head.o和uart.o的距离可能超过4K。
  41. 改变 makefile 中 给定的.o文件的顺序，head.o和uart.o的距离又可能在4K以内。
  42. 注意 :
  43. 1,head.S中，使用bl调用的函数所在的.o文件，在makefile中必须和head.o很近(<4K)，pc指定的main函数的地址，可以很远(>4K)。
  44. 比较远的函数，可以在main函数中去调用，比如 : init_uart();
  45. 2,对于必须在 head.S中 使用bl调用的，比如 : bl CopyCode2SDRAM。如果距离 head.o 很远(>4K)。
  46. 就必须把 CopyCode2SDRAM 函数所在的文件拆开来，本程序没有超过4K，所以nand中相关函数都在一个文件中。
  47. */
init.c文件

点击(此处)折叠或打开

  1. #include "init.h"

  3. /*
  4.  * 关闭WATCHDOG，否则CPU会不断重启
  5.  */
  6. void disable_watch_dog(void)
  7. {
  8.     WTCON = 0; // 关闭WATCHDOG很简单，往这个寄存器写0即可
  9. }

  11. /*
  12.  * 对于MPLLCON寄存器，[19:12]为MDIV，[9:4]为PDIV，[1:0]为SDIV
  13.  * 有如下计算公式：
  14.  * S3C2440: MPLL(FCLK) = (2 * m * Fin)/(p * 2^s)
  15.  * 其中: m = MDIV + 8 = 92+8, p = PDIV + 2 = 1+2, s = SDIV = 2
  16.  * 对于本开发板，Fin = 12MHz
  17.  * 设置CLKDIVN，令分频比为：FCLK:HCLK:PCLK=1:2:4，
  18.  * FCLK=200MHz,HCLK=100MHz,PCLK=50MHz
  19.  */
  20. void clock_init(void)
  21. {
  22.     // LOCKTIME = 0x00ffffff; // 使用默认值即可
  23.     CLKDIVN = 0x03; // FCLK:HCLK:PCLK=1:2:4, HDIVN=1,PDIVN=1
  24.     /* 如果HDIVN非0，CPU的总线模式应该从“fast bus mode”变为“asynchronous bus mode” */
  25. __asm__(
  26.     "mrc p15, 0, r1, c1, c0, 0\n" /* 读出控制寄存器 */
  27.     "orr r1, r1, #0xc0000000\n" /* 设置为“asynchronous bus mode” */
  28.     "mcr p15, 0, r1, c1, c0, 0\n" /* 写入控制寄存器 */
  29.     );

  31.     MPLLCON = S3C2440_MPLL_200MHZ;
  32.     /* 现在，FCLK=200MHz,HCLK=100MHz,PCLK=50MHz
  33.     并不保证你的任何设置都是合适的。所以，如果想要工作在200MHz，还是按照vivi的推荐值((0x5c<<12)|(0x01<<4)|(0x02))即可。
  34.     */
  35. }

  37. /*
  38. s3c2440的bank6和bank7支持128M B，注意，单位是 Byte.
  39. TQ2440原理图的HY57V561620FTP是 4bank * 4M * 16bit，256M，注意，单位是 bit，也就是 32M Byte.
  40. U6+U7 : 共64M
  41. */
  42. void memsetup(void)
  43. {
  44.     volatile unsigned long *p = (volatile unsigned long *)MEM_CTL_BASE;

  46.     // 可生成”位置无关的代码”，使得这个函数可以在被复制到
  47.     // SDRAM之前就可以在steppingstone中运行
  48.     // 存储控制器13个寄存器的值
  49.     p[0] = 0x22011110; //BWSCON
  50.     p[1] = 0x00000700; //BANKCON0
  51.     p[2] = 0x00000700; //BANKCON1
  52.     p[3] = 0x00000700; //BANKCON2
  53.     p[4] = 0x00000700; //BANKCON3
  54.     p[5] = 0x00000700; //BANKCON4
  55.     p[6] = 0x00000700; //BANKCON5
  56.     p[7] = 0x00018005; //BANKCON6
  57.     p[8] = 0x00018005; //BANKCON7
  58.     
  59.                                             // REFRESH,
  60.                                             // HCLK=12MHz: 0x008C07A3,
  61.                                             // HCLK=100MHz: 0x008C04F4
  62.     p[9] = 0x008C04F4;
  63.     p[10] = 0x000000B1; //BANKSIZE
  64.     p[11] = 0x00000030; //MRSRB6
  65.     p[12] = 0x00000030; //MRSRB7
  66. }

  68. void clean_bss(void)
  69. {
  70.     extern int __bss_start, __bss_end; /*这2个在链接脚本中定义的变量*/
  71.     int *p = &__bss_start;
  72.     
  73.     for (; p < &__bss_end; p++)
  74.         *p = 0;
  75. }
init.h文件

点击(此处)折叠或打开

  1. #ifndef _INIT_H_
  2. #define _INIT_H_

  4. /**************************LED相关寄存器*******************************/
  5. #define GPBCON (*(volatile unsigned long *)0x56000010)
  6. #define GPBDAT (*(volatile unsigned long *)0x56000014)
  7. #define GPBUP (*(volatile unsigned long *)0x56000018)
  8. /*注意：这个程序没有mmu，所以寄存器的地址是物理地址*/

  10. #define GPB5_OUT (1<<(5*2))
  11. #define GPB6_OUT (1<<(6*2))
  12. #define GPB7_OUT (1<<(7*2))
  13. #define GPB8_OUT (1<<(8*2))

  15. #define GPB5_ON (~(1<<5))
  16. #define GPB6_ON (~(1<<6))
  17. #define GPB7_ON (~(1<<7))
  18. #define GPB8_ON (~(1<<8))

  20. #define GPB5_OFF (1<<5)
  21. #define GPB6_OFF (1<<6)
  22. #define GPB7_OFF (1<<7)
  23. #define GPB8_OFF (1<<8)
  24. /*********************************************************/

  26. /* WATCHDOG寄存器 */
  27. #define WTCON (*(volatile unsigned long *)0x53000000)
  28. /* SDRAM寄存器 */
  29. #define     MEM_CTL_BASE        0x48000000


  32. /*系统时钟相关寄存器*/
  33. #define    MPLLCON        (*(volatile unsigned long *)0x4c000004)
  34. #define    CLKDIVN        (*(volatile unsigned long *)0x4c000014)
  35. #define S3C2440_MPLL_200MHZ ((0x5c<<12)|(0x01<<4)|(0x02))

  37. void disable_watch_dog();
  38. void clock_init(void);
  39. void memsetup();
  40. void clean_bss(void);

  42. #endif
led.c文件

点击(此处)折叠或打开

  1. #include "def.h"
  2. #include "init.h"
  3. #include "nand.h"
  4. #include "uart.h"
  5. #include "setup.h"

  7. unsigned char nand_test();

  9. /*
  10. *功能：延时函数
  11. */
  12. static void wait(volatile unsigned int num)
  13. {
  14.     unsigned int i = 0;
  15.     unsigned int j = 0;
  16.     for(i=0; i<1000; i++)
  17.         for(j=0; j<num; j++);
  18. }

  20. int main()
  21. {
  22.     icache_enable();
  23.     init_uart();
  24.     
  25.     uart_sendString("\n\n");
  26.     uart_sendString("My nandtest start:\n\n");
  27.     
  28.     nand_test();

  30.   GPBCON = (GPB5_OUT | GPB6_OUT | GPB7_OUT | GPB8_OUT);
  31.   GPBUP = 0x1e0;
  32.   
  33.   while(1)
  34.   {
  35.       GPBDAT = (GPB5_ON & GPB6_ON & GPB7_ON & GPB8_ON);
  36.       wait(1000);
  37.       GPBDAT = (GPB5_OFF | GPB6_OFF | GPB7_OFF | GPB8_OFF);
  38.       wait(1000);
  39.   }

  41.     return 0;
  42. }



  46. unsigned char nand_test()
  47. {
  48.         unsigned char buf[128];
  49.         unsigned int i = 0;
  50.         unsigned char ch;
  51.       
  52.         uart_sendString("1*********************************\n");
  53.         ch = nand_read_random(1, 0);
  54.         uart_sendByte(':');
  55.         uart_sendByte_hex((unsigned long)ch);
  56.         uart_sendByte('\n');
  57.         ch = nand_read_random(1, 1);
  58.         uart_sendByte(':');
  59.         uart_sendByte_hex((unsigned long)ch);
  60.         uart_sendByte('\n');
  61.         ch = nand_read_random(1, 2);
  62.         uart_sendByte(':');
  63.         uart_sendByte_hex((unsigned long)ch);
  64.         uart_sendByte('\n');
  65.         ch = nand_read_random(1, 3);
  66.         uart_sendByte(':');
  67.         uart_sendByte_hex((unsigned long)ch);
  68.         uart_sendByte('\n');
  69.         
  70.         ch = nand_read_random(1, 4);
  71.         uart_sendByte(':');
  72.         uart_sendByte_hex((unsigned long)ch);
  73.         uart_sendByte('\n');
  74.         ch = nand_read_random(1, 5);
  75.         uart_sendByte(':');
  76.         uart_sendByte_hex((unsigned long)ch);
  77.         uart_sendByte('\n');
  78.         ch = nand_read_random(1, 6);
  79.         uart_sendByte(':');
  80.         uart_sendByte_hex((unsigned long)ch);
  81.         uart_sendByte('\n');
  82.         ch = nand_read_random(1, 7);
  83.         uart_sendByte(':');
  84.         uart_sendByte_hex((unsigned long)ch);
  85.         uart_sendByte('\n');

  87.         uart_sendString("1.1******\n");
  88.       uart_sendString("******\n");
  89.       uart_sendString("******\n");

  91.         ch = nand_read_random(1, 2040);
  92.         uart_sendByte(':');
  93.         uart_sendByte_hex((unsigned long)ch);
  94.         uart_sendByte('\n');
  95.         ch = nand_read_random(1, 2041);
  96.         uart_sendByte(':');
  97.         uart_sendByte_hex((unsigned long)ch);
  98.         uart_sendByte('\n');
  99.         ch = nand_read_random(1, 2042);
  100.         uart_sendByte(':');
  101.         uart_sendByte_hex((unsigned long)ch);
  102.         uart_sendByte('\n');
  103.         ch = nand_read_random(1, 2043);
  104.         uart_sendByte(':');
  105.         uart_sendByte_hex((unsigned long)ch);
  106.         uart_sendByte('\n');
  107.         
  108.         ch = nand_read_random(1, 2044);
  109.         uart_sendByte(':');
  110.         uart_sendByte_hex((unsigned long)ch);
  111.         uart_sendByte('\n');
  112.         ch = nand_read_random(1, 2045);
  113.         uart_sendByte(':');
  114.         uart_sendByte_hex((unsigned long)ch);
  115.         uart_sendByte('\n');
  116.         ch = nand_read_random(1, 2046);
  117.         uart_sendByte(':');
  118.         uart_sendByte_hex((unsigned long)ch);
  119.         uart_sendByte('\n');
  120.         ch = nand_read_random(1, 2047);
  121.         uart_sendByte(':');
  122.         uart_sendByte_hex((unsigned long)ch);
  123.         uart_sendByte('\n');
  124.         
  125.         uart_sendString("1.2******\n");
  126.       uart_sendString("******\n");
  127.       uart_sendString("******\n");
  128.       
  129.       ch = nand_read_random(1, 2048);
  130.         uart_sendByte(':');
  131.         uart_sendByte_hex((unsigned long)ch);
  132.         uart_sendByte('\n');
  133.         ch = nand_read_random(1, 2049);
  134.         uart_sendByte(':');
  135.         uart_sendByte_hex((unsigned long)ch);
  136.         uart_sendByte('\n');
  137.         ch = nand_read_random(1, 2050);
  138.         uart_sendByte(':');
  139.         uart_sendByte_hex((unsigned long)ch);
  140.         uart_sendByte('\n');
  141.         ch = nand_read_random(1, 2051);
  142.         uart_sendByte(':');
  143.         uart_sendByte_hex((unsigned long)ch);
  144.         uart_sendByte('\n');
  145.         
  146.         uart_sendString("1.3******\n");
  147.       uart_sendString("******\n");
  148.       uart_sendString("******\n");
  149.       
  150.       nand_write_random(2, 2048, 0xAA);
  151.       nand_write_random(2, 2049, 0xBB);
  152.       nand_write_random(2, 2050, 0xCC);
  153.       nand_write_random(2, 2051, 0xDD);

  155.       ch = nand_read_random(2, 2048);
  156.         uart_sendByte(':');
  157.         uart_sendByte_hex((unsigned long)ch);
  158.         uart_sendByte('\n');
  159.         ch = nand_read_random(2, 2049);
  160.         uart_sendByte(':');
  161.         uart_sendByte_hex((unsigned long)ch);
  162.         uart_sendByte('\n');
  163.         ch = nand_read_random(2, 2050);
  164.         uart_sendByte(':');
  165.         uart_sendByte_hex((unsigned long)ch);
  166.         uart_sendByte('\n');
  167.         ch = nand_read_random(2, 2051);
  168.         uart_sendByte(':');
  169.         uart_sendByte_hex((unsigned long)ch);
  170.         uart_sendByte('\n');

  172.         uart_sendString("1.4******\n");
  173.       uart_sendString("******\n");
  174.       uart_sendString("******\n");

  176.       nand_write_random(1, 2048, 0xDD);
  177.       nand_write_random(1, 2049, 0xCC);
  178.       nand_write_random(1, 2050, 0xBB);
  179.       nand_write_random(1, 2051, 0xAA);

  181.       ch = nand_read_random(1, 2048);
  182.         uart_sendByte(':');
  183.         uart_sendByte_hex((unsigned long)ch);
  184.         uart_sendByte('\n');
  185.         ch = nand_read_random(1, 2049);
  186.         uart_sendByte(':');
  187.         uart_sendByte_hex((unsigned long)ch);
  188.         uart_sendByte('\n');
  189.         ch = nand_read_random(1, 2050);
  190.         uart_sendByte(':');
  191.         uart_sendByte_hex((unsigned long)ch);
  192.         uart_sendByte('\n');
  193.         ch = nand_read_random(1, 2051);
  194.         uart_sendByte(':');
  195.         uart_sendByte_hex((unsigned long)ch);
  196.         uart_sendByte('\n');
  197.       uart_sendString("1*********************************\n");


  200.       nand_read2(buf, 2048, 16); //注意:本程序是从nand的4096地址开始放第2部分代码的
  201.         uart_sendString("2*********************************\n");
  202.     for(i=0; i<16; i++)
  203.     {
  204.             uart_sendByte(':');
  205.             uart_sendByte_hex((unsigned long)buf[i]);
  206.             uart_sendByte('\n');
  207.       }
  208.       uart_sendString("2*********************************\n");

  210.       nand_read2(buf, 2048+2032, 16); //注意:本程序是从nand的4096地址开始放第2部分代码的
  211.         uart_sendString("3*********************************\n");
  212.     for(i=0; i<16; i++)
  213.     {
  214.             uart_sendByte(':');
  215.             uart_sendByte_hex((unsigned long)buf[i]);
  216.             uart_sendByte('\n');
  217.       }
  218.       uart_sendString("3*********************************\n");
  219.       

  221. /*    
  222.       nand_read2(buf, 4096+2035, 16); //注意:本程序是从nand的4099地址开始放第2部分代码的
  223.         uart_sendString("5*********************************\n");
  224.     for(i=0; i<16; i++)
  225.     {
  226.             uart_sendByte(':');
  227.             uart_sendByte_hex((unsigned long)buf[i]);
  228.             uart_sendByte('\n');
  229.       }
  230.       uart_sendString("5*********************************\n");
  231.       

  233.         nand_read2(buf, 4096+2035, 13+64+16); //注意:本程序是从nand的4099地址开始放第2部分代码的
  234.         uart_sendString("6*********************************\n");
  235.     for(i=0; i<13+64+16; i++)
  236.     {
  237.             uart_sendByte(':');
  238.             uart_sendByte_hex((unsigned long)buf[i]);
  239.             uart_sendByte('\n');
  240.       }
  241.       uart_sendString("6*********************************\n");
  242. */

  244.       return 0x66;
  245. }
makefile文件

点击(此处)折叠或打开

  1. objs := head.o init.o setup.o nand.o leds.o uart.o

  3. nand.bin: $(objs)
  4.     arm-linux-ld -Tnand.lds -o nand_elf $^ $(shell arm-linux-gcc -msoft-float -print-libgcc-file-name)
  5.     arm-linux-objcopy -O binary -S nand_elf $@
  6.     arm-linux-objdump -D -m arm nand_elf > nand.dis

  8. %.o:%.c
  9.     arm-linux-gcc -Wall -O2 -c -o $@ $<

  11. %.o:%.S
  12.     arm-linux-gcc -Wall -O2 -c -o $@ $<

  14. clean:
  15.     rm -f nand.bin nand_elf nand.dis *.o
nand.c文件

点击(此处)折叠或打开

  1. #include "nand.h"
  2. #include "def.h"
  3. #include "uart.h"

  5. /*
  6. TQ2440开发板使用的nandflash芯片是 : K9F2G08U0A
  7. */

  9. /*
  10. TQ2440开发板使用的norflash芯片是EN29LV160AB-70TCP
  11. *函数功能：判断是nand启动，还是nor启动
  12. *返回值：0：nand启动，1：nor启动
  13. */
  14. int isBootFromNorFlash(void)
  15. {
  16.     volatile int *p = (volatile int *)0;
  17.     int val;

  19.     val = *p;                    /*先把0地址的值，保存到中间变量val*/
  20.     *p = 0x12345678;    /*试图向0地址赋值*/
  21.     if(*p == 0x12345678) /*向0地址写数据成功*/
  22.     {
  23.         /* 写成功, 是nand启动 */
  24.         *p = val;
  25.         return 0;
  26.     }
  27.     else    /*向0地址写数据失败*/
  28.     {
  29.         /* NOR不能像内存一样写 */
  30.         return 1;
  31.     }
  32. }

  34. /*
  35. *功能：重启
  36. */
  37. void nand_reset()
  38. {
  39.     /*每操作NandFlash之前必须先片选*/
  40.     NF_CE_L();
  41.     /*发送命令之前要先清除RB*/
  42.     NF_CLEAR_RB();
  43.     /*向NandFlash写命令:即发送复位命令*/
  44.     NF_CMD(CMD_RESET);
  45.     /*注意：命令执行期间，NandFlash存储器忙，所以一直要等待为1:不忙*/
  46.     NF_WAIT_RB();
  47.     /*关闭片选*/
  48.     NF_CE_H();
  49. }

  51. /*
  52. *功能：NANDFLASH初始化
  53. *注意：1,本程序使用的是ARM9 2440处理器，需要设置 NFCONF，NFCONT这2个寄存器
  54. * 2,NandFlash的芯片是K9F2G08U0A。由芯片手册可知：
  55. * 容量：（256M+8M）字节，后面的8M叫OOB空间，坏块管理会用到它。
  56. * 8bit
  57. * 2K个块，每个块有64个page页
  58. * 一个page页 =（2K+64）字节
  59. * 所以，一个块 = 64页 = 64*（2K+64）字节 =（128K+2K）字节
  60. * 一个Nand器件 = 2K个块 = 2K*64个page页 = 128K页
  61. * 一个Nand器件 = 128K页 = 128K*（2K+64）字节 = （256M+8M）字节
  62. * 3，片内内存+SDRAM+网卡+寄存器：是由CPU统一编址的，由CPU发出地址。
  63. * 但是NandFlash不是由CPU统一编址的，所以NandFlash的0地址和片内内存的0地址，不是一回事。
  64. * 4，NandFlash中的OOB不参与编址，读取NandFlash上的2049这个地址，不是读取的0页上的地址，是1页上的。
  65. * 5，NandFlash控制器的各个控制引脚的时序，不需要程序员来驱动这些引脚，
  66. * 程序员只需要设置相关寄存器之后，控制器会自动发出控制信号。
  67. */
  68. void nand_init()
  69. {
  70.     //char ret;
  71.     //char ch;
  72.     /*NANDFLASH配置寄存器 : NFCONF
  73.     [13:12]=01:时序图中CLE,ALE持续值设置,1个HCLK时钟周期，如HCLK是100Mhz，则，1个HCLK时钟周期=10ns。
  74.     [10:8]=011:时序图中TWRPH0持续值设置,3个HCLK时钟周期
  75.     [6:4]=100:时序图中TWRPH1持续值设置，0个HCLK时钟周期
  76.     */
  77.     rNFCONF = ((TACLS << 12) | (TWRPH0 << 8) | (TWRPH1 << 4));
  78.     /*NANDFLASH控制寄存器 : NFCONT
  79.     其他位基本都是初始值或者不需要设置
  80.     [1]=1:禁止片选，CE引脚输出为1
  81.     [0]=1:MODE位，使能NandFlash控制器，命令使能CLE引脚设置为1
  82.     */
  83.     //rNFCONT = (1<<4)|(1<<1)|(1<<0);
  84.     rNFCONT =(0<<13)|(0<<12)|(0<<10)|(0<<9)|(0<<8)|(1<<6)|(1<<5)|(1<<4)|(1<<1)|(1<<0);
  85.     //非锁定，屏蔽nandflash中断，初始化ECC及锁定main区和spare区(OOB区)ECC，使能nandflash片选及控制器
  86.     
  87.     nand_reset();
  88.     
  89.     /* 下面串口打印函数不能用了，因为连接脚本将nand.o放在4k内，uart.o在4k外，不能调用了
  90.     uart_sendByte('\n');
  91.     uart_sendByte('w');
  92.     uart_sendByte('x');
  93.     uart_sendByte('c');
  94.     uart_sendByte('\n');
  95.     
  96.     ret = nand_readId();
  97.     uart_sendByte('\n');
  98.     uart_sendString("nand_readId = ");
  99.     uart_sendByte_hex(ret);
  100.     uart_sendByte('\n');
  101.     
  102.     uart_sendString("please input:\n");
  103.     ch = uart_getch();
  104.     uart_sendString("your input is:");
  105.     uart_sendByte(ch);
  106.     uart_sendByte('\n');
  107.     */
  108.     
  109.     return ;
  110. }


  113. /*功能：读取芯片的ID号
  114. *注意：查看NandFlash的相关配置是否正确，可以去检查芯片的ID号。如果ID读取正确了，则说明配置正确了。
  115. *第1个周期：厂商编号 : 0xEC
  116. *第2个周期：设备编号:相同型号的芯片，有相同的ID号 : 0xDA,这个必须正确
  117. *第3个周期：内部芯片编号 : 0x10
  118. *第4个周期：页的大小 : 0x95
  119. *第5个周期：一个page另外带的融错空间的大小 : 0x44
  120. */
  121. unsigned char nand_readId()
  122. {
  123.     int i;
  124.     unsigned char cyc1;
  125.     unsigned char cyc2;
  126.     unsigned char cyc3;
  127.     unsigned char cyc4;
  128.     unsigned char cyc5;
  129.     //片选
  130.     NF_CE_L();
  131.     //清除RB
  132.     NF_CLEAR_RB();
  133.     //发送读ID命令
  134.     NF_CMD(CMD_READID);
  135.     //发送地址值：需要读取这个地址上的值,读ID号，规定就是这个地址，看的时序图，只需发送一个地址.
  136.     NF_ADDR(0x0);
  137.     for(i=0; i<1000; i++);
  138.     //从nandflash中读取数据:读5次，看时序图
  139.     //注意：每次只能读取8位数据，保存在数据寄存器中。
  140.     cyc1 = NF_RDDATA8();
  141.     for(i=0; i<100; i++);
  142.     cyc2 = NF_RDDATA8();
  143.     for(i=0; i<100; i++);
  144.     cyc3 = NF_RDDATA8();
  145.     for(i=0; i<100; i++);
  146.     cyc4 = NF_RDDATA8();
  147.     for(i=0; i<100; i++);
  148.     cyc5 = NF_RDDATA8();
  149.     for(i=0; i<100; i++);
  150.     
  151.     //等待命令执行完毕
  152.     NF_WAIT_RB();
  153.     //关闭片选
  154.     NF_CE_H();
  155.     
  156.     return cyc2;
  157. }


  160. /*功能 : 发出地址
  161. *注意： 这个地址，不是页编号，是具体的读取NandFlash的起始地址,包括页内地址
  162. */
  163. void write_addr(unsigned long addr)
  164. {
  165.         //写地址(要读取数据的起始地址) :
  166.         //包括 : 列(页内)地址,是低位地址，共A0~A11，在具体的page页内寻址。一个page页=（2K+64）字节
  167.         // 行(页)地址,是高位地址，共A12~A28，可以寻址到page页。一个Nand器件=2K*64个page页 = 128K页
  168.         // 高位地址中，A12~A17，可以寻址到block块下面的page页。一个block块=64个page页
  169.         // 高位地址中，A18~A28，可以寻址到block块。一个Nand器件=2K个block块
  170.         //要写全部的5个周期的地址
  171.     
  172.         //32位的page_number : 低29位有效 :
  173.         //| 28| 27| 26| 25| 24| 23| 22| 21| 20| 19| 18| 17| 16| 15| 14| 13| 12| 11| 10| 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  174.      // 对应最后3个地址周期的页内地址的高11位 :
  175.         //|A28|A27|A26|A25|A24|A23|A22|A21|A20|A19|A18|A17|A16|A15|A14|A13|A12|A11|A10|A09|A08|A07|A06|A05|A04|A03|A02|A01|A00|
  176.         //29位在5个地址周期中应是如下的分布 :
  177.         //| I7 | I6 | I5 | I4 | I3 | I2 | I1 | I0 |
  178.         //| L | L | L | L | L | L | L | A28 | //L表示低电平，即为0
  179.         //| A27 | A26 | A25 | A24 | A23 | A22 | A21 | A20 |
  180.         //| A19 | A18 | A17 | A16 | A15 | A14 | A13 | A12 |
  181.         //| L | L | L | L | A11 | A10 | A9 | A8 |
  182.         //| A7 | A6 | A5 | A4 | A3 | A2 | A1 | A0 |
  183.     
  184.     unsigned long i;
  185.     unsigned long col, page;

  187.         col = addr & (2048 -1); //截取低位 : 取2048的原因：本程序使用的nand芯片的一个page页是2048字节
  188.         page = addr / 2048; //截取高位 : 第page页，从第0页开始

  190.     //因为第11位已经丢弃了，所以A11肯定是0，所以这里其实只能寻址2047以内的页的main区，
  191.     //不可能寻址到2047以后的页内spare区，超过2047的地址，已经表示下一页的地址了。
  192.     NF_ADDR(col & 0xFF); //列(页内)地址 A0~A7
  193.     for(i=0; i<100; i++);
  194.         NF_ADDR((col >> 8) & 0x0F);     //列(页内)地址 A8~A11
  195.         for(i=0; i<100; i++);
  196.         
  197.         NF_ADDR(page & 0xFF); //行(页)地址 A12~A19
  198.         for(i=0; i<100; i++);
  199.         NF_ADDR((page >> 8) & 0xFF); //行(页)地址 A20~A27
  200.         for(i=0; i<100; i++);
  201.         NF_ADDR((page >> 16) & 0x01); //行(页)地址 A28
  202.         for(i=0; i<100; i++);
  203. }

  205. /*
  206. *功能 : 从NandFlash位置start_addr开始读取数据，将数据复制到指定的SDRAM地址buf处，共复制size个字节。
  207. * 数据方向:（Nand的start_addr->SDRAM的buf）
  208. *参数 : buf : SDRAM的缓冲区起始地址：0x30001000
  209. * start_addr : 如果要确保正确使用本函数来传输数据，这里的地址:不是页编号，但是必须每一个page页的开始地址，即页边界地址，即地址要2K对齐。
  210. * size ： 复制的字节数，最好是页空间整数倍。即使不指定为页的整数倍，也会读取2K整数倍的空间
  211. *注意 ： 1,read是相对于cpu说的，cpu读取nand中的程序代码，拷贝到SDRAM中去执行。
  212. * 2,如果在读取数据的过程中不进行ECC校验判断，则读操作比较简单，
  213. * 在发出读命令的两个周期之间,发出要读取的页地址，然后读取数据即可
  214. * 3,如果nand起始地址不是页对齐，则使用下面的nand_read2函数。
  215. * 使用本函数，nand起始地址一定要页对齐
  216. * 4,本函数的读操作是以页为单位进行的,size即使不是页的整数倍，也会读取整数倍的页数据。
  217. * 5,如果这里的起始地址，非页对齐的地址，可能会导致我的程序重启(应该是读指令异常)
  218. */
  219. void nand_read(unsigned char *buf, unsigned long start_addr, int size)
  220. {
  221.         unsigned long i = 0, j = 0;
  222.         //1. 选中,片选
  223.         NF_CE_L();
  224.         
  225.         for(i=start_addr; i < (start_addr + size);)
  226.         {
  227.                 //清除RB
  228.                 NF_CLEAR_RB();
  229.                 // 2. 发出读命令00h,读NandFlash时的第1个命令
  230.               //0x00命令发出后，即相当于向NFCMD寄存器中写入了0，nandflash控制器会自动发出各种控制信号，
  231.                 //会自动满足时序图的要求，不再需要人工参与了。
  232.                 //这样，nandflash控制器提供的几个寄存器，就简化了对nandflash的操作。
  233.                 NF_CMD(CMD_READ1);
  234.                 //3. 发出地址,写地址 (分5步发出)
  235.                 write_addr(i);
  236.                 //4. 发出读命令30h,读NandFlash时的第2个命令
  237.                 NF_CMD(CMD_READ2);
  238.                 //注意 : 因为这里没有继续发出页内随意读命令，所以当i=2048,2049的时候，
  239.                 //上面发地址的函数write_addr(i);经过处理，已经跳过第0页了，是要读取第1页的第1,2个字节。
  240.                 
  241.                 //5. 判断状态,等待NandFlash不忙
  242.                 NF_WAIT_RB();
  243.                 
  244.                 //6. 读数据 : 虽然读写过程可以不从页边界开始，但在这里必须从页边界开始读写至页结束
  245.                 //注意 : uboot的命令 : nand dump 0 //从nand的0地址开始，1次读取1页的数据。
  246.                 for(j=0; j<2048; j++, i++)
  247.                 {
  248.                     //1次从nandflash的8位IO口上读取8位数据。
  249.                     //注意：每次读此寄存器，即执行一次下面语句，就会启动对nandflash的1次读操作。
  250.                     //前一次读操作未完成，是不会启动下一次读操作的。
  251.                     *buf = NF_RDDATA8();
  252.                     buf++;
  253.                 }
  254.                 uart_sendString("#"); //2个nand read函数：目的是：main之后才初始化uart，可以使用这个带打印#的函数
  255.         }
  256.         //7. 取消选中,关闭片选
  257.         NF_CE_H();
  258. }


  261. /*
  262. *功能 : 从NandFlash位置start_addr开始读取数据，将数据复制到指定的SDRAM地址buf处，共复制size个字节。
  263. * 数据方向:（Nand的start_addr->SDRAM的buf）
  264. *参数 : buf : SDRAM的缓冲区起始地址：0x30001000
  265. * start_addr : 如果要确保正确使用本函数来传输数据，这里的地址:不是页编号，
  266. * 但是必须每一个page页的开始地址，即页边界地址，即地址要2K对齐。
  267. * size ： 复制的字节数，最好是页空间整数倍。即使不指定为页的整数倍，也会读取2K整数倍的空间
  268. *注意 ： 1,read是相对于cpu说的，cpu读取nand中的程序代码，拷贝到SDRAM中去执行。
  269. * 2,如果在读取数据的过程中不进行ECC校验判断，则读操作比较简单，
  270. * 在发出读命令的两个周期之间,发出要读取的页地址，然后读取数据即可
  271. * 3,如果nand起始地址不是页对齐，则使用下面的nand_read2函数。
  272. * 使用本函数，nand起始地址一定要页对齐
  273. * 4,本函数的读操作是以页为单位进行的,size即使不是页的整数倍，也会读取整数倍的页数据。
  274. * 5,如果这里的起始地址，非页对齐的地址，可能会导致我的程序重启(应该是读指令异常)
  275. */
  276. void nand_read_1(unsigned char *buf, unsigned long start_addr, int size)
  277. {
  278.         unsigned long i = 0, j = 0;
  279.         //1. 选中,片选
  280.         NF_CE_L();

  282.         for(i=start_addr; i < (start_addr + size);)
  283.         {
  284.                 //清除RB
  285.                 NF_CLEAR_RB();
  286.                 // 2. 发出读命令00h,读NandFlash时的第1个命令
  287.               //0x00命令发出后，即相当于向NFCMD寄存器中写入了0，nandflash控制器会自动发出各种控制信号，
  288.                 //会自动满足时序图的要求，不再需要人工参与了。
  289.                 //这样，nandflash控制器提供的几个寄存器，就简化了对nandflash的操作。
  290.                 NF_CMD(CMD_READ1);
  291.                 //3. 发出地址,写地址 (分5步发出)
  292.                 write_addr(i);
  293.                 //4. 发出读命令30h,读NandFlash时的第2个命令
  294.                 NF_CMD(CMD_READ2);
  295.                 //注意 : 因为这里没有继续发出页内随意读命令，所以当i=2048,2049的时候，
  296.                 //上面发地址的函数write_addr(i);经过处理，已经跳过第0页了，是要读取第1页的第1,2个字节。
  297.                 
  298.                 //5. 判断状态,等待NandFlash不忙
  299.                 NF_WAIT_RB();

  301.                 //6. 读数据 : 虽然读写过程可以不从页边界开始，但在这里必须从页边界开始读写至页结束
  302.                 //注意 : uboot的命令 : nand dump 0 //从nand的0地址开始，1次读取1页的数据。
  303.                 for(j=0; j<2048; j++, i++)
  304.                 {
  305.                     //1次从nandflash的8位IO口上读取8位数据。
  306.                     //注意：每次读此寄存器，即执行一次下面语句，就会启动对nandflash的1次读操作。
  307.                     //前一次读操作未完成，是不会启动下一次读操作的。
  308.                     *buf = NF_RDDATA8();
  309.                     buf++;
  310.                 }
  311.         }
  312.         //关闭片选
  313.         NF_CE_H();
  314.         
  315. }


  318. /*
  319. *    buf : 目标地址 = 0x30000000，这是SDRAM的起始地址
  320. *    start_addr : 源地址 = 4096，运行地址在SDRAM中的代码保存在NAND Flash 4096地址开始处
  321. * size : 复制长度 = 600K，对于本实验，这是足够了,没有图片的话，16K足够了，有图片了，得300K
  322. */
  323. int CopyCode2SDRAM(unsigned char *buf, unsigned long start_addr, int size)
  324. {
  325.     unsigned long i = 0;
  326.     
  327.     //norflash启动开发板
  328.     if(isBootFromNorFlash())
  329.     {
  330.         while (i < size)
  331.         {
  332.             buf[i] = *((char *)start_addr);
  333.             i++;
  334.             start_addr++;
  335.         }
  336.     }
  337.     else //nandflash启动开发板
  338.     {
  339.         nand_read_1(buf, start_addr, size);
  340.     }
  341.     
  342.   return 0;
  343. }


  346. /*
  347. *功能 : 从NandFlash位置start_addr开始读取数据，将数据复制到指定的SDRAM地址buf处，共复制size个字节。
  348. * 数据方向:（Nand的start_addr->SDRAM的buf）
  349. *参数 : buf : SDRAM的缓冲区起始地址：0x30001000
  350. * start_addr : 不是页编号，是具体的页内地址，可以不是每一个page页的开始地址，
  351. * 即可以是非页边界地址，即地址没有2K对齐的要求。当然地址是页对齐也会支持
  352. * size ： 复制的字节数，可以是任意字节数。
  353. * 这个大小仅仅只包括页内main区的空间，不包括页内spare区的空间。
  354. *注意 ： 1,read是相对于cpu说的，cpu读取nand中的程序代码，拷贝到SDRAM中去执行。
  355. * 2,如果在读取数据的过程中不进行ECC校验判断，则读操作比较简单，
  356. * 在发出读命令的两个周期之间,发出要读取的页地址，然后读取数据即可
  357. * 3,如果nand起始地址不是页对齐，则使用下面的nand_read2函数。
  358. * 当然，页对齐的地址，也可以使用本函数。
  359. * 4,本函数已经测试通过，可以使用，功能很强大，完全兼容上面的nand_read函数。
  360. */
  361. unsigned int nand_read2(unsigned char * buf, unsigned long start_addr, int size)
  362. {
  363.         unsigned long i = 0, j = 0;
  364.         unsigned long page_num = 0; //读取的页page的数量
  365.         unsigned long page_yu_num = 0; //不足一页page的字节数
  366.         unsigned long start_yu_num = 0; //start_addr起始地址 到 本页末尾地址 的个数。

  368.         page_num = size/2048; //+1=读取的页page的数量
  369.         page_yu_num = size & (2048 -1); //不足一页page的字节数
  370.         start_yu_num = 2048-(start_addr & (2048 -1)); //这个非对齐的页的起始地址 到 本页末尾地址 的个数。

  372.         //1. 选中,片选
  373.         NF_CE_L();
  374.         
  375.         for(i=start_addr; i < (start_addr + size);)
  376.         {
  377.                 //清除RB
  378.                 NF_CLEAR_RB();
  379.                 // 2. 发出读命令00h,读NandFlash时的第1个命令
  380.                 NF_CMD(CMD_READ1);
  381.                 //3. 发出地址,写地址 (分5步发出)
  382.                 write_addr(i);
  383.                 //4. 发出读命令30h,读NandFlash时的第2个命令
  384.                 NF_CMD(CMD_READ2);
  385.                 //5. 判断状态,等待NandFlash不忙
  386.                 NF_WAIT_RB();
  387.                 //6. 读数据
  388.                 if((i & (2048 -1)) == 0) //起始地址:是页对齐的地址
  389.                 {
  390.                         if(page_num > 0) //剩下需要读取的字节数>1页page
  391.                         {
  392.                                 for(j=0; j<2048; j++, i++) //读取一页
  393.                                 {
  394.                                     *buf = NF_RDDATA8();
  395.                                     buf++;
  396.                                 }
  397.                                 page_num--; //每读一页，则少一页
  398.                         }
  399.                         else //剩下需要读取的字节数<1页page
  400.                         {
  401.                                 for(j=0; j<page_yu_num; j++, i++) //读取不足一页的数据
  402.                                 {
  403.                                         *buf = NF_RDDATA8();
  404.                                         buf++;
  405.                                 }
  406.                         }
  407.                 }
  408.                 else //起始地址:非页对齐的地址
  409.                 {
  410.                         //start_yu_num:是 这个非对齐的页的起始地址 到 本页末尾地址 的个数。
  411.                         for(j=0; j<start_yu_num; j++, i++) //小于2048也行
  412.                         {
  413.                                 *buf = NF_RDDATA8();
  414.                                 buf++;
  415.                         }
  416.                 }
  417.         }
  418.         //7. 取消选中,关闭片选
  419.         NF_CE_H();
  420.         
  421.         return 0;
  422. }


  425. /*
  426. *函数功能 : 页内地址随意读，可以读取页内2047以内的main区地址，也可以读取页内2047以外的64字节的spare区的地址。
  427. *函数参数 : page_number : 是页编号，是第几个页。从第9页开始。
  428. * addr : 页内地址，这个地址的范围一定是: <=2K+后面的64字节的
  429. *注意 : 1, 页读和页写,一般是从页的首地址开始读、写,
  430. * 随意读、写实现了在一页范围内任意地址的读、写。
  431. * 2, 随意读操作是在页读操作后输入随意读命令和页内列地址，
  432. * 这样就可以读取到列地址所指定地址的数据。
  433. *页读/写，页内地址随意读/写的区别:
  434. * 页读/写 : 虽然读写过程可以不从页边界开始，但在正式场合下还是建议从页边界开始读写至页结束
  435. * 页内地址随意读/写 : 可以读取页内2047以内的main区地址，也可以读取页内2047以外的64字节的spare区的地址。
  436. */
  437. unsigned char nand_read_random(unsigned long page_number, unsigned long addr)
  438. {
  439.         unsigned char ch;
  440.         //1,打开Nand Flash片选
  441.         NF_CE_L();
  442.         //清RnB信号
  443.         NF_CLEAR_RB();
  444.         //2,页读命令周期1
  445.         NF_CMD(CMD_READ1);
  446.         //3,写入5个地址周期
  447.         NF_ADDR(0x00); //列(页内)地址A0~A7
  448.         NF_ADDR(0x00); //列(页内)地址A8~A11
  449.         NF_ADDR(page_number & 0xff); //行(页)地址A12~A19
  450.         NF_ADDR((page_number >> 8) & 0xff); //行(页)地址A20~A27
  451.         NF_ADDR((page_number >> 16) & 0x01); //行(页)地址A28 (低1位)
  452.         //4,页读命令周期2
  453.         NF_CMD(CMD_READ2);
  454.         //等待RnB信号变高，即不忙
  455.         NF_WAIT_RB();
  456.         //5,随意读命令周期1
  457.         NF_CMD(CMD_RANDOMREAD1);
  458.         //6，写页内地址，共12根线，可寻址2^12=2K*2空间，每一页的main区是2K空间，spare区只有64字节
  459.         //如果读取地址是2048+6，没有像write_addr()函数一样，来截取低11位，则A11肯定是1，
  460.         //后面的+6，就可以寻址到页内spare区的第6个字节。
  461.         NF_ADDR((char)(addr & 0xff)); //列(页内)地址A0~A7
  462.         NF_ADDR((char)(addr >> 8) & 0x0f); //列(页内)地址A8~A11 (低4位)
  463.         //7，随意读命令周期2
  464.         NF_CMD(CMD_RANDOMREAD2);
  465.         //8, 读取指定地址的数据
  466.         ch = NF_RDDATA8();
  467.         //9, 关闭Nand Flash片选
  468.         NF_CE_H();

  470.         return ch; //将读取的数据返回
  471. }


  474. /*
  475. *功能 : 识别坏块的读取: 从NandFlash位置start_addr开始读取数据，将数据复制到指定的SDRAM地址buf处，共复制size个字节。
  476. * 数据方向:（Nand的start_addr->SDRAM的buf）
  477. *参数 : buf : SDRAM的缓冲区起始地址：0x30001000
  478. * start_addr : 不是页编号，是 页(2K)对齐的地址。
  479. * size ： 复制的字节数，是页空间整数倍
  480. *注意 ： 1,read是相对于cpu说的，cpu读取nand中的程序代码，拷贝到SDRAM中去执行。
  481. * 2,读操作是以页为单位进行的
  482. * 3,为了更准确地读取数据，则在读取完数据之后还要进行ECC校验判断，以确定所读取的数据是否正确。
  483. * 4,为了配合ECC校验，程序的输入参数start_addr最好直接就为K9F2G08U0A的第几页
  484. * 例如我们要读取第128064页中的内容，可以调用该程序为 : start_addr=128064*2048
  485. * 由于第128064页是第2001块中的第0页 start_addr=(128064＝2001×64＋0)*2048
  486. * 即 start_addr 最好是 页(2K)对齐的地址
  487. */
  488. unsigned int nand_read_oob(unsigned char * buf, unsigned long start_addr, int size)
  489. {
  490.         unsigned long ret = 0;
  491.         unsigned long col, page;
  492.         unsigned long i = 0;

  494.         for(i=start_addr; i < (start_addr + size);)
  495.         {
  496.                 col = start_addr & (2048 - 1); //截取低位 : 如果start_addr是页对齐地址，则col肯定是0
  497.                 page = start_addr / 2048; //截取高位 : 是第几个页

  499.                 ret = nand_read_oob_page(buf, page);
  500.                 if(ret == 0) //读取成功
  501.                 {
  502.                         i = i + 2048; //继续写
  503.                         buf = buf + 2048;
  504.                 }
  505.                 else if(ret == 1) //读取失败
  506.                 {
  507.                         //这里应该打印报错语句
  508.                         return 1;
  509.                 }
  510.         }
  511.         return 0;
  512. }


  515. /*
  516. *功能 : 识别坏块的读取: 从NandFlash位置第page_number页开始读取数据，将数据复制到buf处，
  517. * 一次共复制一页(2K)个字节的数据,且只复制一页的数据。
  518. * 数据方向:（Nand的start_addr--->SDRAM的buf）
  519. *参数 : buf : SDRAM的缓冲区起始地址：0x30001000
  520. * page_number : 是页编号，是第几个页。
  521. *注意 ： 1,read是相对于cpu说的，cpu读取nand中的程序代码，拷贝到buf。
  522. * 2,读操作是以页为单位进行的，并且一次只读一页数据。
  523. * 3,为了更准确地读取数据，则在读取完数据之后还要进行ECC校验判断，以确定所读取的数据是否正确。
  524. * 4,这段程序是把某一页的内容读取到数组buffer中。该程序的输入参数直接就为K9F2G0
  525. * 8U0A的第几页，例如我们要读取第128064页中的内容，可以调用该程序为:nand_read_oob_page(128064)。
  526. * 由于第128064页是第2001块中的第0页（128064＝2001×64＋0），所以为了更清楚地表示页
  527. * 与块之间的关系，也可以写为:nand_read_oob_page(2001*64)。
  528. */
  529. unsigned int nand_read_oob_page(unsigned char * buf, unsigned long page_number)
  530. {
  531.         unsigned long i;
  532.         unsigned long meccd; //保存从OOB区读取出来的值，共4个字节:第2048+2049+2050+2051字节
  533.         unsigned long seccd; //保存从OOB区读取出来的值，共2个字节:第2052+2053字节

  535.         //复位ECC
  536.         NF_RSTECC();
  537.         //解锁main区ECC : 以便main区产生ECC码
  538.         NF_MECC_UnLock();
  539.         //1. 选中,片选
  540.         NF_CE_L();
  541.         //清除RB
  542.         NF_CLEAR_RB();
  543.         // 2. 发出读命令00h,读NandFlash时的第1个命令
  544.         NF_CMD(CMD_READ1);
  545.         //3. 发出地址,写地址 (分5步发出)
  546.         NF_ADDR(0x00);
  547.         NF_ADDR(0x00);
  548.         NF_ADDR(page_number & 0xff);
  549.         NF_ADDR((page_number >>8) & 0xff);
  550.         NF_ADDR((page_number >>16) & 0xff);
  551.         //4. 发出读命令30h,读NandFlash时的第2个命令
  552.         NF_CMD(CMD_READ2);
  553.         //5. 判断状态,等待NandFlash不忙
  554.         NF_WAIT_RB();
  555.         //6. 读数据
  556.         for(i=0; i<2048; i++)
  557.         {
  558.                 //1次从nandflash的8位IO口上读取8位数据。
  559.                 buf[i] = NF_RDDATA8();
  560.         }
  561.         //注意 : 读取完数据之后，硬件将自动产生main区ECC码
  562.         //锁定main区ECC值 : 自动产生的main区ECC码,不是保存到寄存器(NFMECCD0,1)中，是保存在另外一个位置。
  563.         //NFMECCD0，1用来存放已有的ECC码，已有的ECC码保存在OOB区，即spare区。
  564.         NF_MECC_Lock();

  566.         //解锁spare区ECC : 以便spare区产生ECC码
  567.         NF_SECC_UnLock();
  568.         //读spare区的前32位(4个字节)地址内容，即第2048~2051地址，这4个字节为写数据时，产生的main区的ECC码。
  569.         meccd = NF_RDDATA();
  570.         //meccd的顺序 : ECC0(0~7位)+ECC1(8~15位)+ECC2(16~23位)+ECC3(24~31位)
  571.         //注意 : 把读取到的main区的ECC校验码放入 NFMECCD0 和 NEMECCD1 的相应位置内。
  572.         //具体放置位置 : ECC0:NFMECCD0的0~7位 ECC1:NFMECCD0的16~23位。
  573.         // ECC2:NFMECCD1的0~7位 ECC3:NFMECCD1的16~23位。
  574.         rNFMECCD0 = ((meccd & 0xff00) << 8) | (meccd & 0xff);
  575.         rNFMECCD1 = ((meccd & 0xff000000) >>8) | ((meccd & 0xff0000)>>16);
  576.         //锁定spare区的ECC值 : 自动产生的spare区ECC码，不是保存到NFSECCD中，是保存在另外一个位置。
  577.         //NFSECCD用来存放已有的spare区的ECC码，已有的spare区ECC码保存在OOB区。
  578.         NF_SECC_Lock();

  580.         //继续读spare区的4个地址内容，即第2052~2055地址，其中前2个字节为spare区的ECC值
  581.         seccd = NF_RDDATA();
  582.         //把读取到的spare区的ECC校验码放入NFSECCD的相应位置内
  583.         //seccd的顺序 : spare区ECC0(0~7位)+spare区ECC1(8~15位)
  584.         //具体放置位置 : spare区ECC0:NFSECCD的0~7位。
  585.         //                            spare区ECC1:NFSECCD的16~23位。
  586.         rNFSECCD = ((seccd & 0xff00) << 8) | (seccd & 0xff);
  587.         //7. 取消选中,关闭片选
  588.         NF_CE_H();
  589.         
  590.         //读完一页数据之后，自动算出一个ECC码，这个自动算出来的ECC代码 和
  591.         //已经存在的ECC码(由OOB区保存到NFMECCD0+NFMECCD1+NFMECCD中),自动进行比较，
  592.         //比较的结果,保存在NFESTAT寄存器中,[1:0]=00:表示main区无错误 [3:2]=00:表示spare区无错误。
  593.         if((rNFESTAT0 & 0xf) == 0)
  594.         {
  595.                 return 0; //读取的数据都正确
  596.         }
  597.         else
  598.         {
  599.                 return 1; //读取完成，但是数据错误
  600.         }
  601. }


  604. /*
  605. *功能 : 擦除指定的块
  606. *参数 : block_number : 块号
  607. *注意 : 1,一个NandFlash块有2K个块。块大小为128K+2K字节。
  608. * 2,块被擦除后nand对应的块中的数据全部是1
  609. * 3,命令字分为2个阶段
  610. * 4,擦除是以块为单位进行的
  611. */
  612. unsigned char nand_erase(unsigned long block_number)
  613. {
  614.         unsigned long i;
  615.         unsigned char stat;
  616.         //1,选中，片选
  617.         NF_CE_L();
  618.         //清除RB
  619.         NF_CLEAR_RB();
  620.         //2,发出擦除命令0x60,写入第1个擦除命令
  621.         NF_CMD(CMD_ERASE1);
  622.         //写块的地址 : 注意 : 只写块的地址就行，块地址都在行(页)地址的高位上，
  623.         //所以前面2个周期的列(页内)地址写0就行，后面3个周期的页地址的高11位要具体写出。
  624.         //列地址 : 就是页内地址, 共12位
  625.         //行地址 : 就是页地址, 共17位 : 高11位(A28-A18)是2K的块地址，低6位是64的页地址。
  626.         
  627.         //32位block_number：低11位有效 :
  628.      //| 10 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  629.      // 对应最后3个地址周期的页内地址的高11位 :
  630.         //| A28 | A27 | A26 | A25 | A24 | A23 | A22 | A21 | A20 | A19 | A18 |
  631.         //高11位在后面3个地址周期中应是如下的分布 :
  632.         //| I7 | I6 | I5 | I4 | I3 | I2 | I1 | I0 |
  633.         //| | | | | | | | A28 |
  634.         //| A27 | A26 | A25 | A24 | A23 | A22 | A21 | A20 |
  635.         //| A19 | A18 | | | | | | |
  636.         //3，仅需发出块地址(分3步发出)
  637.         NF_ADDR((block_number << 6) & 0xFF);
  638.         NF_ADDR((block_number >> 2) & 0xFF);
  639.         NF_ADDR((block_number >> 10) & 0xFF);
  640.         //4, 发出擦除命令0xD0, 写入第2个擦除命令
  641.         NF_CMD(CMD_ERASE2);
  642.         
  643.         for(i=0; i<1000; i++);
  644.         //5, 写入读状态寄存器的命令
  645.         NF_CMD(CMD_STATUS);
  646.         //6, 判断状态
  647.         do
  648.         {
  649.          //读取8位状态数据
  650.                 stat = NF_RDDATA8();
  651.         }
  652.         while(!(stat & 0x40)); //等到第6位为1 : 表示读取数据完成
  653.         //7, 取消选中，关闭片选
  654.         NF_CE_H();

  656.         //约定用0x66来表示擦除成功，或者写成功
  657.         return 0;
  658. }


  661. /*
  662. *函数功能 : 识别坏块的擦除
  663. *函数参数 : 块编号,从第0块开始,2K个块(第0块~第2047块)
  664. *函数返回值 :
  665. * 1 : 是坏块，不能擦除
  666. *注意 : 1,擦除是以块为单位进行的，因此在写地址周期时，只需写三个行周期，并且只写块地址
  667. * 并且，擦除的范围是64个页，页内的main区+spare区的64字节都擦除成0xff。
  668. * 2,只能擦除好块，不能擦除坏块，擦除坏块的操作会失败。
  669. * 也可以根据这个特性来判断一个块是不是坏块：当第1页的spare的第6个字节的值感觉不可靠，
  670. * 并且，这个块的数据不重要，可以清除时，可以直接擦除这个块，如果擦除成功，表示是好块，
  671. * 如果擦除失败，则表示这个块是坏块，我们再在spare区的第6个字节标记一下，这是个坏块。
  672. * 3,该程序的输入参数为K9F2G08U0A的第几块，例如我们要擦除第2001块，
  673. * 则调用该函数为 : nand_erase_oob(2001)。

  675.         //写地址(要读取数据的起始地址) :
  676.         //包括 : 列(页内)地址,是低位地址，共A0~A11，在具体的page页内寻址。2^12=2K*2 一个page页=（2K+64）字节
  677.         // 行(页)地址,是高位地址，共A12~A28，可以寻址到page页。2^17=128K, 一个Nand器件=2K*64个page页 = 128K页
  678.         // 高位地址中，A12~A17，可以寻址到block块下面的page页。2^6=64, 一个block块=64个page页
  679.         // 高位地址中，A18~A28，可以寻址到block块。2^11=2K, 一个Nand器件=2K个block块
  680.         //要写全部的5个周期的地址
  681.     
  682.         //32位的page_number : 低29位有效 :
  683.         //| 28| 27| 26| 25| 24| 23| 22| 21| 20| 19| 18| 17| 16| 15| 14| 13| 12| 11| 10| 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  684.      // 对应最后3个地址周期的页内地址的高11位 :
  685.         //|A28|A27|A26|A25|A24|A23|A22|A21|A20|A19|A18|A17|A16|A15|A14|A13|A12|A11|A10|A09|A08|A07|A06|A05|A04|A03|A02|A01|A00|
  686.         //29位在5个地址周期中应是如下的分布 :
  687.         //| I7 | I6 | I5 | I4 | I3 | I2 | I1 | I0 |
  688.         //| L | L | L | L | L | L | L | A28 |
  689.         //| A27 | A26 | A25 | A24 | A23 | A22 | A21 | A20 |
  690.         //| A19 | A18 | A17 | A16 | A15 | A14 | A13 | A12 |
  691.         //| L | L | L | L | A11 | A10 | A9 | A8 |
  692.         //| A7 | A6 | A5 | A4 | A3 | A2 | A1 | A0 |
  693. */
  694. unsigned int nand_erase_oob(unsigned long block_number)
  695. {
  696.         unsigned long i = 0;
  697.         unsigned char stat; //保存 状态寄存器 中的值
  698.         unsigned int flag; //坏块标志
  699.         //判断该块是否为坏块
  700.         flag = nand_IsBadBlock(block_number);
  701.         if(flag == 1) //是坏块
  702.         {
  703.                 return 1; //是坏块，返回1
  704.         }
  705.         //本块不是坏块，才继续走到下面来
  706.         //1,选中，片选
  707.         NF_CE_L();
  708.         //清除RB
  709.         NF_CLEAR_RB();
  710.         //2,发出擦除命令0x60,写入第1个擦除命令
  711.         NF_CMD(CMD_ERASE1);
  712.         //3，仅需发出块地址(分3步发出)
  713.         //行(页)地址,是高位地址，共A12~A28，可以寻址到page页。
  714.         //A12~A17，可以寻址到block块下面的page页; A18~A28，可以寻址到block块。
  715.         NF_ADDR((block_number << 6) & 0xc0); //行(页)地址 A18~A19(高2位)
  716.         NF_ADDR((block_number >> 2) & 0xff); //行(页)地址 A20~A27(8位)
  717.         NF_ADDR((block_number >> 10) & 0x01); //行(页)地址 A28 (低1位)
  718.         //4, 发出擦除命令0xD0，写入第2个擦除命令
  719.         NF_CMD(CMD_ERASE2);
  720.         //会擦除本块的所有64个页，包括页内的main区空间+页内的spare区空间
  721.         for(i=0; i<100; i++); //延时一段时间
  722.         //5, 读状态命令
  723.         NF_CMD(CMD_STATUS);
  724.         //6, 判断状态
  725.         do
  726.         {
  727.                 //将状态寄存器的值 赋值给stat。只取8位状态数据。
  728.                 stat=NF_RDDATA();
  729.         }
  730.         while(!(stat & 0x40)); //等到第6位为1 : 表示读取状态寄存器完成。
  731.         //判断状态值的第6位是否为1，即是否在忙，该语句的作用与NF_DETECT_RB();相同
  732.         //7, 取消选中，关闭片选
  733.         NF_CE_H();
  734.         //判断状态寄存器的值的第0位是否为0，为0则表示擦除操作成功完成，否则表示擦除操作失败
  735.         if(stat & 0x01)
  736.         {
  737.                 //如果擦除失败，则标记该块为坏块，也即恢复刚才可能擦除的坏块标志。
  738.                 flag = nand_MarkBadBlock(block_number); //标注该块为坏块
  739.                 if(flag == 0)
  740.                 {
  741.                         return 2; //标注坏块成功，擦除操作失败
  742.                 }
  743.                 else
  744.                 {
  745.                         return 3; //标注坏块失败，擦除操作失败
  746.                 }
  747.         }    
  748.         else
  749.         {
  750.                 return 0; //擦除操作成功
  751.         }
  752. }


  755. /*功能 : 将buf处开始取数据，写入NandFlash的start_addr地址处，共写入size个字节。
  756. * 数据方向:（SDRAM的buf->Nand的start_addr）
  757. *参数 : buf : SDRAM的缓冲区起始地址
  758. * start_addr : 如果要确保正确使用本函数来传输数据，这里的地址:不是页编号，
  759. * 但是必须每一个page页的开始地址，即页边界地址，即地址要2K对齐。
  760. * size ： 复制的字节数，最好是页空间整数倍。即使不指定为页的整数倍，也会读取2K整数倍的空间
  761. *注意 ： 1,write是相对于cpu说的，cpu写数据到nand中，SDRAM中的数据拷贝到Nand中。
  762. * 2,页写操作的大致流程为：在两个写命令周期之间分别写入页地址和数据
  763. * 3,如果为了保证下次读取该数据时的正确性，还需要把main区的ECC值和spare区
  764. * 的ECC值写入到该页的spare区内。
  765. */
  766. unsigned int nand_write(unsigned char * buf, unsigned long start_addr, int size)
  767. {
  768.         unsigned long i,j;
  769.         unsigned char stat;
  770.         //1,选中，片选
  771.         NF_CE_L();
  772.         
  773.         for(i=start_addr; i < (start_addr + size);)
  774.         {
  775.                 //清除RB
  776.                 NF_CLEAR_RB();
  777.                 //2. 发出写命令0x80,写NandFlash时的第1个命令 : NandFlash写准备
  778.                 NF_CMD(CMD_WRITE1);
  779.                 //3. 发出地址,写地址(分5步发出)
  780.                 write_addr(i);
  781.                 //4, 写数据 : 虽然读写过程可以不从页边界开始，但在这里必须从页边界开始读写至页结束
  782.                 for(j=0; j<2048; j++, i++)
  783.                 {
  784.                  //1次写8位的数据给NandFlash的8位IO口
  785.                  //注意：每次写这个寄存器，即执行一次下面的语句，都会启动一次nandflash的写数据操作，
  786.                  //前一次写数据操作不完成，是不会启动下一次写数据操作的
  787.                         NF_WRDATA8(*buf);
  788.                         buf++;
  789.                 }

  791.                 //5. 发出写命令0x10,写NandFlash时的第2个命令 : 启动写操作
  792.                 //此时，Flash内部会自动完成写，校验操作。
  793.                 NF_CMD(CMD_WRITE2);
  794.                 for(j=0; j<100; j++);
  795.                 //6. 判断状态,写入读状态寄存器的命令 : 用来判断当前写操作是否完成，是否成功
  796.                 NF_CMD(CMD_STATUS);
  797.                 do
  798.                 {
  799.                  //读取8位状态数据
  800.                         stat = NF_RDDATA8();
  801.                 }
  802.                 while(!(stat & 0x40)); //等到第6位为1 : 表示写数据完成。
  803.         }
  804.         //7. 取消选中,关闭片选
  805.         NF_CE_H();
  806.         
  807.         return 0;
  808. }


  811. /*函数功能 : 将buf处开始取数据，写入NandFlash的start_addr地址处，共写入size个字节。
  812. * 数据方向:（SDRAM的buf->Nand的start_addr）
  813. *函数参数 : buf : SDRAM的缓冲区起始地址
  814. * start_addr : 不是页编号，是具体的页内地址，可以不是每一个page页的开始地址，
  815. * 即可以是非页边界地址，即地址没有2K对齐的要求。当然地址是页对齐也会支持
  816. * size ： 复制的字节数，可以是任意字节数。
  817. * 这个大小仅仅只包括页内main区的空间，不包括页内spare区的空间。*注意 ： 1,write是相对于cpu说的，cpu写数据到nand中，SDRAM中的数据拷贝到Nand中。
  818. *注意 : 1,页写操作的大致流程为：在两个写命令周期之间分别写入页地址和数据
  819. * 2,如果为了保证下次读取该数据时的正确性，还需要把main区的ECC值和spare区
  820. * 的ECC值写入到该页的spare区内。
  821. * 3,如果nand起始地址不是页对齐，则使用下面的 nand_write2 函数。
  822. * 当然，页对齐的地址，也可以使用本函数。
  823. * 4,本函数已经测试通过，可以使用，功能很强大，完全兼容上面的 nand_write 函数。
  824. */
  825. unsigned int nand_write2(unsigned char * buf, unsigned long start_addr, int size)
  826. {
  827.         unsigned long i,j;
  828.         unsigned char stat;
  829.         
  830.         unsigned long page_num = 0; //写入的页page的数量
  831.         unsigned long page_yu_num = 0; //不足一页page的字节数
  832.         unsigned long start_yu_num = 0; //start_addr起始地址 到 本页末尾地址 的个数。

  834.         page_num = size/2048; //写入的页page的数量
  835.         page_yu_num = size & (2048 -1); //不足一页page的字节数
  836.         start_yu_num = 2048-(start_addr & (2048 -1)); //这个非对齐的页的起始地址 到 本页末尾地址 的个数。

  838.         //1,选中，片选
  839.         NF_CE_L();
  840.         
  841.         for(i=start_addr; i < (start_addr + size);)
  842.         {
  843.                 //清除RB
  844.                 NF_CLEAR_RB();
  845.                 //2. 发出写命令0x80,写NandFlash时的第1个命令 : NandFlash写准备
  846.                 NF_CMD(CMD_WRITE1);
  847.                 //3. 发出地址,写地址(分5步发出)
  848.                 write_addr(i);
  849.                 //4, 写数据 : 虽然读写过程可以不从页边界开始，但在这里必须从页边界开始读写至页结束
  850.                 if((i & (2048 -1)) == 0) //起始地址:是页对齐的地址
  851.                 {
  852.                         if(page_num > 0) //剩下需要写入的字节数>1页page
  853.                         {
  854.                                 for(j=0; j<2048; j++, i++)
  855.                                 {
  856.                                  //1次写8位的数据给NandFlash的8位IO口
  857.                                  //注意：每次写这个寄存器，即执行一次下面的语句，都会启动一次nandflash的写数据操作，
  858.                                  //前一次写数据操作不完成，是不会启动下一次写数据操作的
  859.                                         NF_WRDATA8(*buf);
  860.                                         buf++;
  861.                                 }
  862.                         }
  863.                         else //剩下需要写入的字节数<1页page
  864.                         {
  865.                                 for(j=0; j<page_yu_num; j++, i++) //写入不足一页的数据
  866.                                 {
  867.                                         NF_WRDATA8(*buf);
  868.                                         buf++;
  869.                                 }
  870.                         }
  871.                 }
  872.                 else //起始地址:非页对齐的地址
  873.                 {
  874.                         //start_yu_num:是 这个非对齐的页的起始地址 到 本页末尾地址 的个数。
  875.                         for(j=0; j<start_yu_num; j++, i++) //小于2048也行
  876.                         {
  877.                                     NF_WRDATA8(*buf);
  878.                                     buf++;
  879.                         }
  880.                 }
  881.                 
  882.                 //5. 发出写命令0x10,写NandFlash时的第2个命令 : 启动写操作
  883.                 //此时，Flash内部会自动完成写，校验操作。
  884.                 NF_CMD(CMD_WRITE2);
  885.                 for(j=0; j<100; j++);
  886.                 //6. 判断状态,写入读状态寄存器的命令 : 用来判断当前写操作是否完成，是否成功
  887.                 NF_CMD(CMD_STATUS);
  888.                 do
  889.                 {
  890.                  //读取8位状态数据
  891.                         stat = NF_RDDATA8();
  892.                 }
  893.                 while(!(stat & 0x40)); //等到第6位为1 : 表示写数据完成。
  894.         }
  895.         //7. 取消选中,关闭片选
  896.         NF_CE_H();
  897.         
  898.         return 0;
  899. }


  902. /*
  903. *函数功能 : 页内地址随意写
  904. *函数参数 : page_number : 是页编号，从第0页开始。
  905. * 1块=64页，第2块最开始的一页是第64页
  906. * addr : 页内地址(包括2K的main区空间+64字节的spare区空间)
  907. * data : 要写入的1字节的数据
  908. *函数返回值 :
  909. * 0 : 写入成功
  910. * 1 : 写入失败
  911. *注意 : 1, 页读和页写是从页的首地址开始读、写,
  912. * 随意读、写实现了在一页范围内任意地址的读、写。
  913. * 2, 随意写操作是在页写操作的第二个页写命令周期前，输入随意写命令和页内列地址，
  914. * 以及要写入的数据，这样就可以把数据写入到列地址所指定的地址内。
  915. */
  916. unsigned int nand_write_random(unsigned long page_number, unsigned long addr, unsigned char data)
  917. {
  918.         unsigned int i = 0;
  919.         unsigned char stat; //保存状态寄存器的值
  920.         //1,打开Nand Flash片选
  921.         NF_CE_L();
  922.         //清RnB信号
  923.         NF_CLEAR_RB();
  924.         //2,页写命令周期1
  925.         NF_CMD(CMD_WRITE1);
  926.         //3,写入5个地址周期
  927.         NF_ADDR(0x00); //列地址A0~A7
  928.         NF_ADDR(0x00); //列地址A8~A11
  929.         NF_ADDR(page_number & 0xff); //行地址A12~A19
  930.         NF_ADDR((page_number >> 8) & 0xff); //行地址A20~A27
  931.         NF_ADDR((page_number >> 16) & 0x01); //行地址A28
  932.         //4,随意写命令
  933.         NF_CMD(CMD_RANDOMWRITE);
  934.         //5,页内地址
  935.         NF_ADDR((char)(addr & 0xff)); //列地址A0~A7
  936.         NF_ADDR((char)((addr >> 8) & 0x0f)); //列地址A8~A11
  937.         //6,写入数据
  938.         NF_WRDATA8(data);
  939.         //7,页写命令周期2
  940.         NF_CMD(CMD_WRITE2);
  941.         for(i=0; i<100; i++); //延时一段时间
  942.         //8. 判断状态,写入读状态寄存器的命令 : 用来判断当前写操作是否完成，是否成功
  943.         NF_CMD(CMD_STATUS);
  944.         do
  945.         {
  946.                 stat = NF_RDDATA8();
  947.         }
  948.         while(!(stat&0x40)); //等待第6位为1，表示写数据完成
  949.         //判断状态值的第6位是否为1，即是否在忙，该语句的作用与NF_DETECT_RB();相同

  951.         //9,关闭Nand Flash片选
  952.         NF_CE_H();
  953.         
  954.         //判断状态值的第0位是否为0，为0则写操作正确，否则错误
  955.         if(stat &0x1)
  956.         {
  957.                 return 1; //写入失败
  958.         }
  959.         else
  960.         {
  961.                 return 0; //写入成功
  962.         }
  963. }


  966. /*功能 : 识别坏块的写 : 将buf处开始的数据，写入NandFlash的start_addr地址处，共写入size个字节。
  967. * 数据方向:（SDRAM的buf->Nand的start_addr）
  968. *参数 : buf : SDRAM的缓冲区起始地址
  969. * start_addr : 不是页编号，是页对齐地址，
  970. * 是具体的读取NandFlash的起始地址,包括页内地址
  971. * size ： 复制的字节数，是页空间整数倍，也就是说，size是2K整数倍
  972. *注意 ： 1,write是相对于cpu说的，cpu写数据到nand中，SDRAM中的数据拷贝到Nand中。
  973. * 2,坏块的话写进去的东西肯定是不对的。一般情况下如果你手上的系统支持NAND运行，
  974. * 那么相关的读取数据代码中肯定有跳坏块处理的
  975. */
  976. unsigned int nand_write_oob(unsigned char * buf, unsigned long start_addr, int size)
  977. {
  978.         unsigned long ret = 0;
  979.         unsigned long col, page;
  980.         unsigned long i = 0;

  982.         for(i=start_addr; i < (start_addr + size);)
  983.         {
  984.                 col = start_addr & (2048 - 1); //如果start_addr是页对齐地址，则col肯定是0
  985.                 page = start_addr / 2048; //截取高位,是第几个页
  986.                 
  987.                 ret = nand_write_oob_page(buf, page);
  988.                 if(ret == 0) //写成功
  989.                 {
  990.                         i = i + 2048; //跳过坏块
  991.                         buf = buf + 2048; //继续写
  992.                 }
  993.                 else if(ret == 1) //是坏块
  994.                 {
  995.                         i = i + 2048; //跳过坏块
  996.                         buf = buf;     //再写，buf不增加
  997.                 }
  998.                 else if(ret == 2) //写失败，但是标注坏块成功，判断是坏块
  999.                 {
  1000.                         //这里应该打印一句报错信息
  1001.                         i = i + 2048; //跳过坏块
  1002.                         buf = buf;                //再写，buf不增加
  1003.                 }
  1004.                 else if(ret == 3) //写失败，标注坏块也失败，读取的时候，无法判断是否是坏块，这里当做好块
  1005.                 {
  1006.                         //这里应该打印一句报错信息
  1007.                         i = i; //当做好块，再写一次
  1008.                         buf = buf; //再写，buf不增加
  1009.                 }
  1010.         }
  1011.         return 0;
  1012. }


  1015. /*功能 : 识别坏块的写 : 将数据 从SDRAM的buf 复制到 NandFlash第page_number页开始的位置。
  1016. * 一次写且仅写一页(2K)个字节的数据
  1017. * 数据方向:（SDRAM的buf--->nandflash的第page_number页）
  1018. *参数 : buf : SDRAM的缓冲区起始地址
  1019. * page_number : 是页编号，是第几页,从第0页开始
  1020. *注意 ： 1,write是相对于cpu说的，cpu写数据到nand中， buf中的数据拷贝到Nand中。
  1021. * 2,写操作是以页为单位进行的，并且一次只写一页数据
  1022. * 3,本程序检查坏块，标记坏块，并且将ECC码记录在OOB区。
  1023. */
  1024. unsigned int nand_write_oob_page(unsigned char * buf, unsigned long page_number)
  1025. {
  1026.         unsigned long i;
  1027.         unsigned long mecc0; //保存 NFMECC0 寄存器的值，32位值均有效，即4个字节:ECC0+ECC1+ECC2+ECC3
  1028.         unsigned long secc; //保存 NFSECC 寄存器的值，低16位值有效，即2个字节:spare区ECC0+spare区ECC1
  1029.         unsigned char stat;
  1030.         unsigned int flag;                //坏块标志，标注成功与否的标志
  1031.         unsigned char ECCBuf[6];    //用来保存 上面的6个字节:mecc0+secc

  1033.         //判断该块是否为坏块
  1034.         flag = nand_IsBadBlock(page_number>>6);
  1035.         if(1 == flag)
  1036.         {
  1037.                 return 1; //是坏块，返回
  1038.         }
  1039.         //复位ECC
  1040.         NF_RSTECC();
  1041.         //解锁main区的ECC : 以便产生该区的ECC码
  1042.         NF_MECC_UnLock();
  1043.         //1,选中，片选
  1044.         NF_CE_L();
  1045.         //清除RB
  1046.         NF_CLEAR_RB();
  1047.         //2. 发出写命令0x80,写NandFlash时的第1个命令 : NandFlash写准备
  1048.         NF_CMD(CMD_WRITE1);
  1049.         //3. 发出地址,写地址(分5步发出)
  1050.         NF_ADDR(0x00);
  1051.         NF_ADDR(0x00);
  1052.         NF_ADDR(page_number & 0xff);
  1053.         NF_ADDR((page_number >>8) & 0xff);
  1054.         NF_ADDR((page_number >>16) & 0xff);
  1055.         //4, 写数据 : 一般1次写1页的数据
  1056.         for(i=0; i<2048; i++)
  1057.         {
  1058.                 //1次写8位的数据给NandFlash的8位IO口
  1059.                 //注意：每次写这个寄存器，即执行一次下面的语句，都会启动一次nandflash的写数据操作，
  1060.                 //前一次写数据操作不完成，是不会启动下一次写数据操作的
  1061.                 NF_WRDATA8(buf[i]);
  1062.                 //buf++;
  1063.         }
  1064.         //注意 : main区写完数据之后，硬件将自动产生main区的ECC码，共4个字节。
  1065.         //锁定main区的ECC值 : 会自动把产生的main区的ECC码，保存到相应的寄存器(NFMECC0)中。
  1066.         NF_MECC_Lock();
  1067.         //读取main区的ECC校验码,保存到本地变量mecc0中。
  1068.         mecc0=rNFMECC0;
  1069.         //把ECC校验码由字型转换为字节型，并保存到字节变量数组ECCBuf中
  1070.         ECCBuf[0] = (unsigned char)(mecc0 & 0xff);                    //0~7位
  1071.         ECCBuf[1] = (unsigned char)((mecc0 >> 8) & 0xff);        //8~15位
  1072.         ECCBuf[2] = (unsigned char)((mecc0 >> 16) & 0xff);    //16~23位
  1073.         ECCBuf[3] = (unsigned char)((mecc0 >> 24) & 0xff);    //24~31位

  1075.         //解锁spare区的ECC :
  1076.         NF_SECC_UnLock();
  1077.         //把main区的ECC值写入到spare区的前4个字节地址内，即第2048~2051地址
  1078.         for(i=0; i<4; i++)
  1079.         {
  1080.                 //注意 : 页内main区写满之后，继续写，会写到本页的第2049个地址，即开始写spare区的第1个字节。
  1081.                 NF_WRDATA8(ECCBuf[i]);
  1082.         }
  1083.         //注意 : spare区写完数据之后，硬件将自动产生spare区的ECC码，共2个字节。
  1084.         //锁定spare区的ECC值 : 会自动把产生的spare区的ECC码，保存到相应的寄存器(NFSECC)中。
  1085.         NF_SECC_Lock();

  1087.         //读取spare区的ECC校验码，保存到本地变量secc中。
  1088.         secc = rNFSECC;
  1089.         //把ECC校验码保存到字节变量数组ECCBuf中
  1090.         ECCBuf[4]=(unsigned char)(secc & 0xff);                    //0~7位
  1091.         ECCBuf[5]=(unsigned char)((secc >> 8) & 0xff);    //8~15位
  1092.         //把spare区的ECC值继续写入到spare区，第2052~2053地址内。
  1093.         //注意 : 每块的第0页的spare区，第2054个字节处，会有坏块标志，其他页没有。
  1094.         for(i=4; i<6; i++)
  1095.         {
  1096.                 NF_WRDATA8(ECCBuf[i]);
  1097.         }
  1098.         //5. 发出读命令0x10,写NandFlash时的第2个命令 : 启动写操作
  1099.         NF_CMD(CMD_WRITE2);
  1100.         for(i=0; i<100; i++); //延时一段时间，以等待写操作完成
  1101.         //6. 判断状态,写入读状态寄存器的命令 : 用来判断当前写操作是否完成，是否成功
  1102.         NF_CMD(CMD_STATUS);
  1103.         do
  1104.         {
  1105.                 //读取8位状态数据
  1106.                 stat = NF_RDDATA8();
  1107.         }
  1108.         while(!(stat & 0x40)); //等到第6位为1 : 表示写数据完成。
  1109.         //判断状态值的第6位是否为1，即是否在忙，该语句的作用与NF_DETECT_RB();相同
  1110.         
  1111.         //7. 取消选中,关闭片选
  1112.         NF_CE_H();    
  1113.         //判断状态值的第0位是否为0，为0则写操作正确，否则错误
  1114.         if(stat & 0x1)
  1115.         {
  1116.                 //如果写入失败，则标记坏块。
  1117.                 //A12~A17，可以寻址到block块下面的page页; A18~A28，可以寻址到block块。
  1118.                 //右移6位，表示去掉 A12~A17，只剩下 块地址 A18~A28 共11位的有效值。
  1119.                 flag = nand_MarkBadBlock(page_number>>6);
  1120.                 if(0 == flag)
  1121.                 {
  1122.                         return 2; //标注坏块成功，写入操作失败
  1123.                 }
  1124.                 else
  1125.                 {
  1126.                         return 3; //标注坏块失败，写入操作失败
  1127.                 }
  1128.         }
  1129.         else
  1130.         {
  1131.                 return 0; //写操作成功
  1132.         }
  1133. }


  1136. /*
  1137.  *函数功能 : 检查指定的块是否是坏块
  1138.  *函数参数 : 块的编号，从第0块开始
  1139.  *函数返回值 : 0 : 好块 1 : 坏块
  1140.  *注意 :
  1141.  * 1, 为了和固有坏块信息保持一致，将新发现的坏块的第1个page的 spare area的第6个Byte标记为非0xff的值。
  1142.  * 我们定义在spare区的第6个地址（即每页的第2054地址）用来标注坏块，0x44表示该块为坏块
  1143.  * 要判断坏块时，利用随意读命令来读取2054地址的内容是否为0x44，正常是0xff
  1144.  * 2, 坏块的特性是：当编程/擦除这个块时，不能将某些位拉高，这 会造成Page Program和
  1145.  * Block Erase操作时的错误，相应地反映到Status Register的相应位。
  1146.  * 我们去查看 Status Register 的相应位，我们就可以找到这个坏块是怎么来的了。即可知是什么原因造成的坏块。
  1147.  * 3, NAND Flash出厂时在OOB中已经反映出了坏块信息，因此，如果在擦除一个块之前，
  1148.  * 一定要先check一下OOB的第6个byte是否是0xff，如果是就证明这是一个好块，
  1149.  * 可以擦除；如果是非0xff，那么就不能擦除。
  1150.  * 当然，这样处理可能会犯一个错误―――“错杀伪坏块”，因为在芯片操作过程中可能
  1151.  * 由于电压不稳定等偶然因素会造成NAND操作的错误。但是，为了数据的可 靠性及软件设计
  1152.  * 的简单化，我们就要奉行“蒋委员长”的“宁可错杀一千，也决不放过一个”的宗旨。
  1153.  *            4, 如果在对一个块的某个page进行编程的时候发生了错误就要把这个块标记为坏块，
  1154.  * 首先就要把其他好的page里面的内容备份到另外一个空的好块里面，然后，把这个块标记为
  1155.  * 坏块。
  1156.  * 5, 当然，这可能会犯“错杀”之误，一个补救的办法，就是在进行完页备份之后，
  1157.  * 再将这个块擦除一遍，如果Block Erase发生错误，那就证明这个块是个真正的坏块，那就毫不犹豫地将它打个“戳”吧！
  1158.  * 6, 1个块有128K，64个页，为什么是第1页的OOB区的第6个Byte？这个是各个厂家默认的规定。
  1159.  * 即这是NAND Flash生产商的默认约定，你可以看到Samsung,Toshiba,STMicroelectronics都是使用这个Byte作为坏块标记的。
  1160.  */
  1161. unsigned int nand_IsBadBlock(unsigned long block)
  1162. {
  1163.         unsigned char ch;
  1164.         
  1165.         //如果是第0块，0*64=0，则第1个参数是第0页
  1166.         //如果是第1块，1*64=64，则第1个参数是第64页。
  1167.         //第0~63页是第0块，第64页是第1块最开始的一页
  1168.         ch = nand_read_random(block*64, 2048+6);
  1169.         if(0xFF == ch) //是好块
  1170.         {
  1171.                 return 0;
  1172.         }
  1173.         else //是坏块
  1174.         {
  1175.                 return 1;
  1176.         }
  1177. }


  1180. /*
  1181. *函数功能 : 标注坏块,标注该页所在的块为坏块
  1182. *函数参数 : 块的编号，从第0块开始
  1183. *函数返回值 :
  1184. * 0 : 标注坏块 成功
  1185. * 1 : 标注坏块 失败
  1186. *注意 : 1，要标注坏块时，利用随意写命令来向2048+6地址写0x33
  1187. * 2, 输入参数都为块地址，也就是即使仅仅一页出现问题，我们也标注整个块为坏块。
  1188. * 3，标注位置 : 约定是在 本块，第0页的第2054个字节处。即本块第0页的spare区的第6个字节处。其他页没有。
  1189. */
  1190. unsigned int nand_MarkBadBlock(unsigned long block)
  1191. {
  1192.         unsigned char flag;

  1194.         //如果是第0块，0*64=0，则第1个参数是第0页
  1195.         //如果是第1块，1*64=64，则第1个参数是第64页。
  1196.         //第0~63页是第0块，第64页是第1块最开始的一页
  1197.         flag = nand_write_random(block*64, 2048+6, 0x33);
  1198.         if(0 == flag) //写入成功
  1199.         {
  1200.                 return 0; //标注坏块 成功
  1201.         }
  1202.         else
  1203.         {
  1204.                 return 1; //标注坏块 失败
  1205.         }
  1206. }


  1209. /*
  1210. 坏块管理:
  1211. 1,我们以前没有进行坏块管理，为什么也能直接使用nandflash？
  1212. 因为三星公司为了支持nandflash的启动，确保了第0块没有坏块，所以我们读/写/擦除第0块是不会出现问题的。
  1213. 2，第0块之后的块，是可能出现坏块的。
  1214. 3，本程序没有实现坏块表BBT，有时间要实现一下。
  1215. */

  1217. /*
  1218. 测试

  1220. */
nand.h文件

点击(此处)折叠或打开

  1. #ifndef _NAND_H_
  2. #define _NAND_H_

  4. /*NANDFLASH配置寄存器 : NFCONF：用来设置时序参数宽度，数据位宽*/
  5. #define rNFCONF (*(volatile unsigned long *)0x4E000000)
  6. /*NANDFLASH控制寄存器 : NFCONT：用来禁止/使能nandflash控制器，使能/禁止片选信号*/
  7. #define rNFCONT (*(volatile unsigned long *)0x4E000004)
  8. /*NANDFLASH命令集寄存器 : NFCMMD：用来向nandflash发出命令信号*/
  9. #define rNFCMMD (*(volatile unsigned long *)0x4E000008)
  10. /*NANDFLASH地址集寄存器 : NFADDR：用来向nandflash发出地址信号*/
  11. #define rNFADDR (*(volatile unsigned long *)0x4E00000C)
  12. /*NANDFLASH数据寄存器 : NFDATA,32位=0x4E000010+0x4E000011+0x4E000012+0x4E000013*/
  13. #define rNFDATA (*(volatile unsigned long *)0x4E000010)
  14. /*截取NANDFLASH数据寄存器的8位 : 仅0x4E000010，实际上每次读写也只用到低8位，不可能用到32位。
  15. 每次读写此寄存器，就将启动一次对nandflash的读数据写数据的操作。*/
  16. #define rNFDATA8 (*(volatile unsigned char *)0x4E000010)
  17. /*NANDFLASH运行状态寄存器 : NFSTAT：只用了最低位，0：busy，1：ready*/
  18. #define rNFSTAT (*(volatile unsigned long *)0x4E000020)





  24. /************************************************************************/
  25. //下面3个寄存器 : 是在读取nandflash数据的时候，需要将已有的ECC写入下面3个寄存器，已有的ECC保存在OOB区中。
  26. //读取完毕之后，会自动算出一个ECC，再将这个已有的ECC和这个刚算出来的ECC比较。比较的结果会自动放在NFESTAT寄存器中。
  27. /*main区ECC寄存器0,本nandflash只有8位IO口
  28. 只有16位数据有效，但不是连续的16位 : 0~7位:ECC0; 16~23位:ECC1*/
  29. #define rNFMECCD0 (*(volatile unsigned long *)0x4e000014)
  30. /*main区ECC寄存器1,本nandflash只有8位IO口
  31. 只有16位数据有效，但不是连续的16位 : 0~7位:ECC2; 16~23位:ECC3*/
  32. #define rNFMECCD1 (*(volatile unsigned long *)0x4e000018)
  33. /*spare区ECC寄存器,本nandflash只有8位IO口
  34. 只有16位数据有效，但不是连续的16位 : 0~7位:spare区ECC0; 16~23位:spare区ECC1*/
  35. #define rNFSECCD (*(volatile unsigned long *)0x4e00001c)

  37. /*nandflash的ECC状态寄存器0*/
  38. #define rNFESTAT0 (*(volatile unsigned long *)0x4e000024)
  39. /*nandflash的ECC状态寄存器1,本nandflash只有8位IO口，所以只用上面的NFESTAT0寄存器就行了，NFESTAT1是适用于nandflash有16位IO口的。*/
  40. #define rNFESTAT1 (*(volatile unsigned long *)0x4e000028)

  42. //下面3个寄存器 : 是在将数据写入nandflash的时候，硬件自动生成的ECC码，硬件自动保存的位置，我们一般再保存到OOB区中。
  43. /*main区ECC寄存器0,只适用于nandflash的低8位IO口
  44. 32位数据均有效 : 0~7位:ECC0; 8~15位:ECC1; 16~23位:ECC2; 24~31位:ECC3*/
  45. #define rNFMECC0 (*(volatile unsigned long *)0x4e00002c)
  46. /*main区ECC寄存器1,本nandflash只有8位IO口，所以只用上面的NFMECC0寄存器就行了，NFMECC1是适用于nandflash有16位IO口的。*/
  47. #define rNFMECC1 (*(volatile unsigned long *)0x4e000030)
  48. /*spare区ECC寄存器,本nandflash只有8位IO口，只用本寄存器的低2个字节，高2个字节是给16位IO的nandflash用的。
  49. 低16位数据有效 : 0~7位:spare区ECC0; 8~15位:spare区ECC1*/
  50. #define rNFSECC (*(volatile unsigned long *)0x4e000034)
  51. /************************************************************************/





  57. /*相关命令如下 : */
  58. /*读NandFlash页时的命令1*/
  59. #define CMD_READ1 0x00
  60. /*读NandFlash页时的命令2*/
  61. #define CMD_READ2 0x30

  63. /*页编程 : 写NandFlash页时的命令1*/
  64. #define CMD_WRITE1 0x80
  65. /*页编程 : 写NandFlash页时的命令2*/
  66. #define CMD_WRITE2 0x10

  68. /*擦除NandFlash块的命令1*/
  69. #define CMD_ERASE1 0x60
  70. /*擦除NandFlash块的命令2*/
  71. #define CMD_ERASE2 0xD0

  73. /*读状态寄存器的命令*/
  74. #define CMD_STATUS 0x70
  75. /*读取芯片ID的命令*/
  76. #define CMD_READID 0x90
  77. /*重启命令*/
  78. #define CMD_RESET 0xFF




  83. /*随意读命令周期1*/
  84. #define CMD_RANDOMREAD1 0x05
  85. /*随意读命令周期2*/
  86. #define CMD_RANDOMREAD2 0xE0
  87. /*随意写命令*/
  88. #define CMD_RANDOMWRITE 0x85




  93. #define NF_CE_L() {(rNFCONT) &= (~(1<<1));}
  94. /*禁止nandfalsh : 控制寄存器NFCONT[1]=1*/
  95. #define NF_CE_H() {(rNFCONT) |= (1<<1);}

  97. /*向存储器发出命令 : 命令寄存器NFCMMD[7:0]*/
  98. #define NF_CMD(data) {(rNFCMMD) = (data);}
  99. /*向存储器发出地址值 : 地址寄存器NFADDR[7:0]*/
  100. #define NF_ADDR(data) {(rNFADDR) = (data);}

  102. /*等待NandFlash准备就绪(即不忙) : 一直等到状态寄存器NFSTAT[0]=1,循环才退出*/
  103. #define NF_WAIT_RB() {while(!((rNFSTAT) & (1<<0)));}
  104. /*清除RB:即检测RB传输*/
  105. #define NF_CLEAR_RB() {(rNFSTAT) |= (1<<2);}
  106. /*等待检测RnB : 一直等到状态寄存器NFSTAT[2]=1,循环才退出*/
  107. #define NF_DETECT_RB {while(!((rNDSTA) & (1<<2)));}

  109. /*从NANDFLASH的IO口中读数据(32位) : 数据寄存器NFDATA*/
  110. #define NF_RDDATA() (rNFDATA)
  111. /*从NANDFLASH的IO口中读数据(8位) : 数据寄存器NFDATA*/
  112. #define NF_RDDATA8() (rNFDATA8)
  113. /*向NANDFLASH的IO口中写数据(32位) : 数据寄存器NFDATA*/
  114. #define NF_WRDATA(data) {(rNFDATA) = (data);}
  115. /*向NANDFLASH的IO口中写数据(8位) : 数据寄存器NFDATA*/
  116. #define NF_WRDATA8(data) {(rNFDATA8) = (data);}




  121. /************************************************************************/
  122. /*复位ECC:初始化ECC编码器/译码器*/
  123. #define NF_RSTECC()             {rNFCONT |= (1<<4);}
  124. /*解锁main区ECC*/
  125. #define NF_MECC_UnLock() {rNFCONT &= (~(1<<5));}
  126. /*锁定main区ECC*/
  127. #define NF_MECC_Lock() {rNFCONT |= (1<<5);}
  128. /*解锁spare区(OOB区)ECC*/
  129. #define NF_SECC_UnLock() {rNFCONT &= (~(1<<6));}
  130. /*锁定spare区(OOB区)ECC*/
  131. #define NF_SECC_Lock() {rNFCONT |= (1<<6);}
  132. /************************************************************************/




  137. /*时序信号参数的宽度*/
  138. #define TACLS 1
  139. #define TWRPH0 3
  140. #define TWRPH1 0

  142. int isBootFromNorFlash(void);
  143. void nand_reset();
  144. void nand_init();
  145. unsigned char nand_readId();
  146. void write_addr(unsigned long addr);
  147. void nand_read(unsigned char *buf, unsigned long start_addr, int size);
  148. void nand_read_1(unsigned char *buf, unsigned long start_addr, int size);
  149. int CopyCode2SDRAM(unsigned char *buf, unsigned long start_addr, int size);

  151. unsigned int nand_read2(unsigned char * buf, unsigned long start_addr, int size);
  152. unsigned char nand_read_random(unsigned long page_number, unsigned long addr);
  153. unsigned int nand_read_oob(unsigned char *buf, unsigned long start_addr, int size);
  154. unsigned int nand_read_oob_page(unsigned char * buf, unsigned long page_number);

  156. unsigned char nand_erase(unsigned long block_number);
  157. unsigned int nand_erase_oob(unsigned long block_number);

  159. unsigned int nand_write(unsigned char *buf, unsigned long start_addr, int size);
  160. unsigned int nand_write_random(unsigned long page_number, unsigned long addr, unsigned char data);
  161. unsigned int nand_write_oob(unsigned char *buf, unsigned long start_addr, int size);
  162. unsigned int nand_write_oob_page(unsigned char * buf, unsigned long page_number);

  164. unsigned int nand_IsBadBlock(unsigned long block);
  165. unsigned int nand_MarkBadBlock(unsigned long block);

  167. #endif
nand.lds文件

点击(此处)折叠或打开

  1. SECTIONS { /*.:表示当前*/
  2.     . = 0x31000000;         /*汇编语言中：.text段中_start的值=0x31000000*/
  3.     .text : { *(.text) }
  4.     
  5.     . = ALIGN(4);
  6.     .rodata : {*(.rodata*)}
  7.     
  8.     . = ALIGN(4);
  9.     .data : { *(.data) }
  10.     
  11.     . = ALIGN(4);
  12.     __bss_start = .; /*编译出来的2进制程序比如uboot.bin中不会含有static变量初始化为0的存放的空间。我们把static变量统一放在bss段，运行程序前，将bss段清0，即将static变量初始化为0了*/
  13.     .bss : { *(.bss) *(COMMON) }
  14.     __bss_end = .;
  15. }


  18. /*
  19. 加上nandflash的其他函数之后， head.o init.o nand.o >4K 了，开发板只复制nand的前面4K到启动石。
  20. 使用下面的链接脚本会有局限性。
  21. SECTIONS {
  22.     firtst     0x00000000 : { head.o init.o nand.o}
  23.     second     0x30001000 : AT(4096) { leds.o }
  24. }
  25. 解决方法 :
  26. 1,如果非要使用上面的链接脚本，就必须把nand.c文件控制在很小范围内，
  27. 其他nand相关函数独立编写一个文件nand2.c，比如 :
  28. SECTIONS {
  29.     firtst     0x00000000 : { head.o init.o nand.o}
  30.     second     0x30001000 : AT(4096) { leds.o nand2.o }
  31. }
  32. 2,使用本文件使用的链接脚本，只要保证head.S中bl调用的少量函数(init_uart, nand_init, nand_read)在4K范围内，就可以了
  33. 整个.o文件可以完全大于4K范围。
  34. */
setup.c文件

点击(此处)折叠或打开

  1. #include "setup.h"

  3. int mystrlen(char *str)
  4. {
  5.     int i = 0;
  6.     while (str[i])
  7.     {
  8.         i++;
  9.     }
  10.     return i;
  11. }

  13. void mystrcpy(char *dest, char *src)
  14. {
  15.     while ((*dest++ = *src++) != '\0');
  16. }

  18. /*
  19. *功能：使能ICache
  20. */
  21. void icache_enable()
  22. {
  23.     unsigned int temp = 1<<12;

  25.     asm(
  26.             "mrc p15,0,r0,c1,c0,0\n" /*读出控制寄存器c1的值到r0中*/
  27.             "orr r0,r0,%0\n" /*第12位I位置1，即使能ICache*/
  28.             "mcr p15,0,r0,c1,c0,0\n" /*将修改后的值写入控制寄存器*/
  29.             :
  30.             :"r"(temp)
  31.             :"r0"
  32.         );
  33. }


  36. /*
  37. *功能：禁止ICache
  38. */
  39. void icache_disable()
  40. {
  41.     unsigned int temp = 1<<12;

  43.     asm( /*GCC内联汇编函数*/
  44.             "mrc p15,0,r0,c1,c0,0\n"
  45.             "bic r0,r0,%0\n" /*第12位I位置0，即禁止ICache*/
  46.             "mcr p15,0,r0,c1,c0,0\n"
  47.             :
  48.             :"r"(temp)
  49.             :"r0"
  50.         );
  51. }
setup.h文件

点击(此处)折叠或打开

  1. #ifndef _SETUP_H_
  2. #define _SETUP_H_

  4. int mystrlen(char *str);
  5. void mystrcpy(char *dest, char *src);

  7. void icache_enable();
  8. void icache_disable();

  10. #endif
uart.c文件

点击(此处)折叠或打开

  1. #include "uart.h"

  3. /***********************************************************************************/
  4. //串口相关函数
  5. /*功能：初始化串口UART0
  6. *轮询方式来使用串口
  7. */
  8. void init_uart(void)
  9. {
  10.      /*GPHCON寄存器
  11.     [7:6]=10,GPH2作为TXD0,串口发送数据引脚
  12.     [5:4]=10,GPH3作为RXD0,串口接受数据引脚
  13.     GPH2，GPH3控制串口通道0
  14.     GPH4，GPH5控制串口通道1
  15.     GPH6，GPH7控制串口通道2
  16.     */
  17.         rGPHCON = ((2<<6)|(2<<4)|(0<<2)|(0<<0));
  18.         rGPHUP = ((1<<3)|(1<<2)); /*禁止上拉*/
  19.         
  20.         /*ULCON0串口线路控制寄存器:设置传输格式
  21.         [6]=0，普通模式，非红外工作模式
  22.         [5:3]=000，无奇偶校验位，100=奇校验，101=偶校验，110=固定校验位为1，111=固定校验位为0
  23.         [2]=0，每帧1个停止位，1：每帧2个停止位
  24.         [1:0]=11，8位，每帧发送或接受的数据位的个数。00=5位，01=6位，10=7位
  25.         */
  26.         rULCON0 = 0x3;
  27.         
  28.         /*UCON0:串口控制寄存器：用于选择UART时钟源，设置UART中断方式
  29.         [15:12]: 当[11:10]选择PCLK时，这4位无效。选择FCLK/n时，表示n值。
  30.         [11:10]=00: 选择PCLK给UART比特率，10：PCLK, 01：UEXTCLK, 11:FCLK/n。
  31.         [9]=1: 中断请求类型
  32.         [8]=0: 中断请求类型
  33.         [7]=0: 禁止超时中断，1：使能超时中断
  34.         [6]=1: 产生接受错误状态中断，1：不产生接受错误状态中断
  35.         [5]=0: 正常操作，非回环模式。发送引脚发送的数据，直接到达接受引脚，一般是测试用。
  36.         [4]=0: 正常操作，不发送断电信号
  37.         [3:2]=01: 发送模式，中断或者轮询,如果中断寄存器不设置，就是轮询。
  38.         [1:0]=01: 接受模式，中断或者轮询
  39.         */
  40.         rUCON0 = 0x5;
  41.         
  42.         /*UFCON:串口FIFO控制寄存器：用于设置是否使用FIFO,设置各FIFO的触发阀值。
  43.         [7:6]=发送FIFO的触发深度，即在发送时，发送FIFO中还剩有多少个数据时，才触发中断，告诉CPU可以继续发送了。
  44.         [5:4]=接受FIFO的触发深度，即在接受时，接受FIFO中接受了多少个数据后，才触发中断，告诉CPU已经有接受到的数据了。
  45.         [3]=空
  46.         [2]=TX的FIFO是否复位
  47.         [1]=RX的FIFO是否复位
  48.         [0]=0,不使用FIFO，非FIFO模式，相当于接受和发送时，不使用缓冲寄存器,上面的设置无效。如果这里是1，则上面的位肯定有对应的设置。
  49.         */
  50.         rUFCON0 = 0x0;
  51.         
  52.         /*UMCON:串口MODEM控制寄存器：用于流量控制
  53.         [7:5]=000,规定必须为0
  54.         [4]=0:禁止自动流控制(AFC)，即不使用流控。一般不使用这种硬件自动流控制手段。
  55.         [3:1]=000:规定必须为0
  56.         [0]=0:高电平(撤销nRTS),1:低电平(激活nRTS),因为,AFC位禁止,nRTS必须由软件控制。如果AFC使能，则忽略这个位。
  57.         */
  58.         rUMCON0 = 0x0;
  59.         
  60.         /*UBRDIV:波特率分频寄存器：用于设置波特率
  61.         [15:0],波特率分频值。使用UEXTCLK作为输入时钟时，可以设置UBRDIV为0.
  62.         UBRDIV = (int)(UART时钟/(波特率*16))-1
  63.         */
  64.         rUBRDIV0 = UART_BRD;
  65. }

  67. /*功能：向串口发送一个字符
  68. *参数：待发送的字符

  70. UTRSTAT0:用来表明数据是否已经发送完毕，是否已经接受到数据
  71. 串口收发TX/RX状态寄存器，是CPU自动更新的，程序员检测它的状态就行。
  72. [2]:发送移位寄存器空标志。
  73. 检测为0：表示发送移位寄存器非空，或发送缓冲寄存器非空。
  74. 检测为1：表示发送移位寄存器为空，且发送缓冲寄存器为空，程序员可以继续发送数据了。
  75. [1]:发送缓冲区空标志位。
  76. 检测为0：表示发送缓冲寄存器非空，即上次要发送的数据还没有发完。不能太快，否则会覆盖掉。
  77. 检测为1：表示发送缓冲寄存器为空，程序员可以继续发送数据了。(非FIFO模式，非请求中断，非DMA)
  78. 注意：如果UART使用FIFO，用户应该使用UFSTAT寄存器中的Rx FIFO计数位 和 Rx FIFO满位取代对此位的检查。
  79. [0]:接收缓冲器数据就绪标志位。
  80. 检测为0：表示接收缓冲器为空。
  81. 检测为1：表示接收缓冲器接收到有效数据，程序员可以取数据了。(非FIFO模式，非请求中断，非DMA)
  82. 注意：如果UART使用FIFO，用户应该使用UFSTAT寄存器中的Rx FIFO计数位 和 Rx FIFO满位取代对此位的检查。

  84. UTXH0：串口发送缓冲寄存器
  85. [7:0]:串口要发送的数据
  86. */
  87. void uart_sendByte(int data)
  88. {
  89.     if(data == '\n')
  90.     {
  91.         while(!(rUTRSTAT0 &0x2));
  92.         WrUTXH0('\r'); /*回车不换行*/
  93.     }
  94.     /*等待，直到发送缓冲区中的数据已经全部发送出去
  95.     这里也可以检测UTRSTAT0[2]位*/
  96.     while(!(rUTRSTAT0 &0x2));
  97.     /*向UTXH0寄存器中写入数据，UART即自动将它发送出去
  98.     #define rUTXH0 (*(volatile unsigned char *)0x50000020)    //UART 0 Transmission Hold
  99.     #define WrUTXH0(ch) (*(volatile unsigned char *)0x50000020)=(unsigned char)(ch)
  100.     所以：WrUTXH0(data); 相当于 rUTXH0 = data；
  101.     */
  102.     WrUTXH0(data);
  103. }

  105. /*功能：向串口打印一个字符串
  106. *参数：待打印的字符串
  107. */
  108. void uart_sendString(char *p)
  109. {
  110.     while(*p)
  111.         uart_sendByte(*p++);
  112. }

  114. /*功能：向串口打印一个字符的16进制格式
  115. *参数：待打印的字符
  116. * 数字0=0x30，数字9=0x39
  117. */
  118. void uart_sendByte_hex(unsigned long val)
  119. {
  120.     // val = 0x1234ABCD
  121.     unsigned long c;
  122.     int i = 0;
  123.     
  124.     uart_sendByte('0');
  125.     uart_sendByte('x');

  127.     for (i = 0; i < 8; i++)
  128.     {
  129.         c = (val >> ((7-i)*4)) & 0xf;
  130.         if((c >= 0) && (c <= 9))
  131.         {
  132.             c = '0' + c;
  133.         }
  134.         else if ((c >= 0xA) && (c <= 0xF))
  135.         {
  136.             c = 'A' + (c - 0xA);
  137.         }
  138.         uart_sendByte((int)c);
  139.     }
  140. }

  142. /*功能：从串口接受一个字符
  143. *返回值：接受到的字符

  145. UTRSTAT0: 串口收发TX/RX状态寄存器
  146. [0]:接收缓冲器数据就绪标志位。
  147. 0：接收缓冲器为空
  148. 1：接收缓冲器接收到有效数据(非FIFO模式，非请求中断，非DMA)
  149. 注意：如果UART使用FIFO，用户应该使用UFSTAT寄存器中的Rx FIFO计数位 和 Rx FIFO满位取代对此位的检查。

  151. URXH0：串口接受缓冲寄存器
  152. [7:0]:串口接受到的数据
  153. */
  154. char uart_getch(void)
  155. {
  156.     /*等待，直到接受缓冲区中有数据*/
  157.     while(!(rUTRSTAT0 & 0x1));
  158.     /*直接读取URXH0寄存器，即可以获得接受到的数据
  159.     #define rURXH0 (*(volatile unsigned char *)0x50000024)    //UART 0 Receive buffer
  160.     #define RdURXH0() (*(volatile unsigned char *)0x50000024)
  161.     所以：return RdURXH0(); 相当于：return rURXH0；
  162.     */
  163.     return RdURXH0();
  164. }

  166. /*功能：从串口接受一个字符串
  167. *参数：输入的字符串
  168. */
  169. void uart_getString(char *string)
  170. {
  171.     char *string2 = string;
  172.     char c;
  173.     while((c=uart_getch()) != '\r')
  174.     {
  175.         if(c == '\b')
  176.         {
  177.             if((int)string2 < (int)string)
  178.             {
  179.                 //uart_printf("\b\b");
  180.                 string--;
  181.             }
  182.         }
  183.         else
  184.         {
  185.             *string++ = c;
  186.             uart_sendByte(c);
  187.         }
  188.     }
  189.     *string = '\0';
  190.     uart_sendByte('\n');
  191. }

  193. /***********************************************************************************/
  194. /*
  195. *功能：整型(int) 转化成 字符型(char)
  196. *注意：不用 % / 符号的话，只能正确打印:0...9的数字对应的字符'0'...'9'
  197. */
  198. void itoa(unsigned int n, char * buf)
  199. {
  200.     int i;

  202.     if(n < 10){
  203.         buf[0] = n + '0';
  204.         buf[1] = '\0';
  205.         return;
  206.     }
  207.     itoa(n / 10, buf);
  208.     
  209.     for(i=0; buf[i]!='\0'; i++);
  210.     
  211.     buf[i] = (n % 10) + '0';
  212.     
  213.     buf[i+1] = '\0';
  214. }

  216. /*
  217. *功能：16进制字(0x) 转化成 字符型(char)
  218. *注意：不用 % / 符号的话，只能正确打印，0...9..15的数字,对应的'0'...'9''A'...'F'
  219. *注意：由于编译问题，这个函数，暂时由uart_sendByte_hex()函数替代
  220. */
  221. void xtoa(unsigned int n, char * buf)
  222. {
  223.     int i;

  225.     if(n < 16)
  226.     {
  227.         if(n < 10)
  228.         {
  229.             buf[0] = n + '0';
  230.         }
  231.         else
  232.         {
  233.             buf[0] = n - 10 + 'a';
  234.         }
  235.         buf[1] = '\0';
  236.         return;
  237.     }
  238.     xtoa(n / 16, buf);
  239.     
  240.     for(i = 0; buf[i] != '\0'; i++);
  241.     
  242.     if((n % 16) < 10)
  243.     {
  244.         buf[i] = (n % 16) + '0';
  245.     }
  246.     else
  247.     {
  248.         buf[i] = (n % 16) - 10 + 'a';
  249.     }
  250.     buf[i + 1] = '\0';
  251. }

  253. /*******************************************************************************************
  254. 为了支持求余求模，需要:
  255. 1,修改makefile如下：增加libgcc的库
  256.     arm-linux-ld -Tuart.lds -o uart_elf $^ $(shell arm-linux-gcc -msoft-float -print-libgcc-file-name)
  257. 上面一句展开后，其实就是下面的一句：
  258. ##    arm-linux-ld -Tuart.lds -o uart_elf head.o init.o uart.o leds.o /home/wangxc/linux/toolchain/gcc-3.4.5-glibc-2.3.6/bin/../lib/gcc/arm-linux/3.4.5/libgcc.a
  259. 2,自己手写libgcc的库。
  260. 这个在uart3实现
  261. *******************************************************************************************/

  263. /*功能：向串口格式化打印一个字符串
  264. *参数：格式化的字符串
  265. *注意：由于求模求余的问题没有解决，所以这里%d输出时，只能输出0~9，10和10以上的不能输出
  266. */
  267. int uart_printf(const char *fmt, ...)
  268. {
  269.     int count = 0;
  270.     char c;
  271.     char *s;
  272.     int n;
  273.     char buf[65];
  274.     va_list ap;
  275.     
  276.     va_start(ap, fmt);
  277.     
  278.     while(*fmt != '\0')
  279.     {
  280.         if(*fmt == '%')
  281.         {
  282.             fmt++;
  283.             switch(*fmt)
  284.          {
  285.                 case 'd': /*整型*/
  286.                     n = va_arg(ap, int);
  287.                     if(n < 0)
  288.                     {
  289.                         //uputchar('-');
  290.                         uart_sendByte('-');
  291.                         n = -n;
  292.                     }    
  293.                     itoa(n, buf);
  294.                     //_uputs(buf);
  295.                     uart_sendString(buf);
  296.                     break;        
  297.                 case 'c': /*字符型*/
  298.                     c = va_arg(ap, int);
  299.                     uart_sendByte(c);
  300.                     break;
  301.                 case 'x': /*16进制*/
  302.                     n = va_arg(ap, int);
  303.                     //uart_sendByte_hex(n); /*由于求模求余编译有问题，所以用uart_sendByte_hex来替代下面的2行代码*/
  304.                     xtoa(n, buf);
  305.                     uart_sendString(buf);
  306.                     break;
  307.                 case 's': /*字符串*/
  308.                     s = va_arg(ap, char *);
  309.                     uart_sendString(s);
  310.                     break;
  311.                 case '%': /*输出%*/
  312.                     uart_sendByte('%');
  313.                     break;
  314.                 default:
  315.                     break;
  316.             }    
  317.         }
  318.         else
  319.         {
  320.             uart_sendByte(*fmt);
  321.             if(*fmt == '\n')
  322.             {
  323.                 //uart_sendByte('\r');
  324.             }
  325.         }
  326.         fmt++;
  327.     }

  329.     va_end(ap);

  331.     return count;
  332. }
uart.h文件

点击(此处)折叠或打开

  1. #ifndef _UART_H_
  2. #define _UART_H_

  4. /**************************************************************************/
  5. //串口相关寄存器
  6. #define rULCON0 (*(volatile unsigned *)0x50000000)
  7. #define rUCON0 (*(volatile unsigned *)0x50000004)
  8. #define rUFCON0 (*(volatile unsigned *)0x50000008)
  9. #define rUMCON0 (*(volatile unsigned *)0x5000000c)
  10. #define rUTRSTAT0 (*(volatile unsigned *)0x50000010)
  11. #define rUBRDIV0 (*(volatile unsigned *)0x50000028)

  13. #define WrUTXH0(ch) (*(volatile unsigned char *)0x50000020)=(unsigned char)(ch)
  14. #define RdURXH0() (*(volatile unsigned char *)0x50000024)

  16. #define rGPHCON (*(volatile unsigned *)0x56000070)
  17. #define rGPHUP (*(volatile unsigned *)0x56000078)

  19. #define PCLK 50000000 // init.c中的clock_init函数设置PCLK为50MHz
  20. #define UART_CLK PCLK // UART0的时钟源设为PCLK
  21. #define UART_BAUD_RATE 115200 // 波特率
  22. #define UART_BRD ((UART_CLK / (UART_BAUD_RATE * 16)) - 1)

  24. typedef char * va_list;
  25. #define va_start(ap,p) (ap = (char *) (&(p)+1))
  26. #define va_arg(ap, type) ((type *) (ap += sizeof(type)))[-1]
  27. #define va_argp(ap, type) ((type *) (ap += sizeof(type)))-1
  28. #define va_end(ap)

  30. void init_uart(void);
  31. void uart_sendByte(int data);
  32. void uart_sendString(char *p);
  33. void uart_sendByte_hex(unsigned long val);
  34. char uart_getch(void);
  35. void uart_getString(char *string);

  37. void itoa(unsigned int n, char * buf);
  38. void xtoa(unsigned int n, char * buf);
  39. int uart_printf(const char *fmt, ...);
  40. /**************************************************************************/

  42. #endif

阅读(1548) | 评论(0) | 转发(0) |
0

上一篇：MMU裸机驱动代码

下一篇：interrupt裸机驱动程序

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6