一个项目引起的7天写一个nor flash字符驱动程序的经历

1480阅读　0评论2013-04-09　andyluo324324
分类：嵌入式


点击(此处)折叠或打开

  1. /********************************** Include ********************************/
  2. #include<stdarg.h>
  3. #include<stdlib.h>
  4. #include<string.h>
  5. #include<stdio.h>

  7. #include <unistd.h>
  8. #include <fcntl.h>
  9. #include <assert.h>
  10. #include <time.h>

  12. #include <sys/ioctl.h>
  13. #include <sys/mman.h>


  16. /********************************** Define *********************************/
  17. #define UBOOT_START_ADDR 0xff000000
  18. #define UBOOT_SIZE 0x00040000 //256k

  20. #define KERNEL_START_ADDR 0xff060000
  21. #define KERNEL_SIZE 0x000c0000 //768k

  23. #define ROOTFS_START_ADDR 0xff120000
  24. #define ROOTFS_SIZE 0x00ee0000 //15232k

  26. /****************************** Local Variable *****************************/

  28. static int uboot_fd;
  29. static int kernel_fd;
  30. static int rootfs_fd;

  32. volatile char *uboot_map_addr;//address from using mmap（）
  33. volatile char *kernel_map_addr;
  34. volatile char *rootfs_map_addr;

  36. /****************************** Extern Variable ****************************/

  38. /****************************** Local Function *****************************/

  40. static int openMemRW(void);
  41. static void closeMemRW(void);

  43. /********************************* Code ************************************/



  47. int main(int argc, char* argv[])
  48. {

  50. // if(argc<1)
  51. // {
  52. // printf("parameter error!\n");
  53. // return -1;
  54. // }
  55.    // -----------------------------------------------------------
  56.    // Step 1, open /dev/mem to access NOR FLASH
  57.    // -----------------------------------------------------------

  59.      int len,i;
  60.      
  61.      len=strlen(argv[1])+1;
  62.      
  63.      for(i=0;i<len;i++)
  64.      printf("%c\n",argv[1][i]);
  65.     
  66.     if(openMemRW()<0)
  67.     {
  68.         printf("openMemRW fail\n");
  69.         return -1;
  70.     }
  71.     closeMemRW();
  72.     return 0;
  73. }

  75. static int openMemRW(void)

  77. {
  78.           int i;
  79.         
  80.              //将NOR FLASH的uboot区域映射到进程空间,以便以后直接通过访问映射的进程区域来访问uboot区域
  81.     uboot_fd = open("/dev/mem",O_RDWR|O_SYNC);
  82.     if(uboot_fd < 0)
  83.     {
  84.         printf("open /dev/mem failed!\n");
  85.         return -1;
  86.     }
  87.     uboot_map_addr = (char *)mmap(NULL,UBOOT_SIZE,PROT_READ|PROT_WRITE,MAP_SHARED,uboot_fd,UBOOT_START_ADDR);
  88.     if(uboot_map_addr == NULL)
  89.     {
  90.         printf("openMemRW ERROR : mmap fd=%d failed!\n",uboot_fd);
  91.         close(uboot_fd);
  92.         return -1;
  93.      }
  94.     printf("uboot_map_addr=%x\n",uboot_map_addr);
  95.     
  96.     for(i=0;i<16;i++)
  97.     {
  98.         printf("%x ",uboot_map_addr[i]);
  99.         printf("\n");
  100.      }
  101.     printf("__uboot_map_addr=%x\n",&uboot_map_addr[i]);
  102.    // printf("usage:%s string\n",uboot_map_addr);
  103.                 //将NOR FLASH的kernel区域映射到进程空间,以便以后直接通过访问映射的进程区域来访问kernel区域
  104.     kernel_fd = open("/dev/mem",O_RDWR|O_SYNC);
  105.     if(kernel_fd < 0)
  106.      {
  107.         printf("open /dev/mem failed!\n");
  108.         return -1;
  109.       }
  110.     kernel_map_addr = (char *)mmap(NULL,KERNEL_SIZE,PROT_READ|PROT_WRITE,MAP_SHARED,kernel_fd,KERNEL_START_ADDR);
  111.     if(kernel_map_addr == NULL)
  112.      {
  113.         printf("openMemRW ERROR : mmap fd=%d failed!\n",kernel_fd);
  114.         close(kernel_fd);
  115.         return -1;
  116.       }
  117.     printf("kernel_map_addr=%x\n",kernel_map_addr);
  118.     
  119.     for(i=0;i<16;i++)
  120.     {
  121.         printf("%x",kernel_map_addr[i]);
  122.         printf("\n");
  123.      }
  124.     printf("__kernel_map_addr=%x\n",&kernel_map_addr[i]);
  125.     //printf("usage:%s string\n",kernel_map_addr);
  126.                 //将NOR FLASH的ROOTFS区域映射到进程空间,以便以后直接通过访问映射的进程区域来访问ROOTFS区域
  127.     rootfs_fd = open("/dev/mem",O_RDWR|O_SYNC);
  128.     if(rootfs_fd < 0)
  129.      {
  130.         printf("open /dev/mem failed!\n");
  131.         return -1;
  132.       }
  133.     rootfs_map_addr = (char *)mmap(NULL,ROOTFS_SIZE ,PROT_READ|PROT_WRITE,MAP_SHARED,rootfs_fd,ROOTFS_START_ADDR);
  134.     if(rootfs_map_addr == NULL)
  135.      {
  136.         printf("openMemRW ERROR : mmap fd=%d failed!\n",rootfs_fd);
  137.         close(rootfs_fd);
  138.         return -1;
  139.       }
  140.     printf("rootfs_map_addr=%x\n",rootfs_map_addr);
  141.     for(i=0;i<16;i++)
  142.     {
  143.         printf("%x",rootfs_map_addr[i]);
  144.         printf("\n");
  145.      }
  146.     printf("__rootfs_map_addr=%x\n",&rootfs_map_addr[i]);

  148.     //printf("usage:%s string\n",rootfs_map_addr);
  149.         return 0;
  150. }
  151. //关闭映射
  152. static void closeMemRW(void)
  153. {
  154.   
  155.      munmap((void*)uboot_map_addr,UBOOT_SIZE);
  156.               close(uboot_fd);
  157.   
  158.      munmap((void*)kernel_map_addr,KERNEL_SIZE);
  159.               close(kernel_fd);

  161.      munmap((void*)rootfs_map_addr,ROOTFS_SIZE);
  162.               close(rootfs_fd);
  163. }

仅以此文纪念自己的程序员生涯的开端！
故事源于一个刚毕业的学生，也就是本故事的主人公作者，废话少说，开始故事：
2011年2月21号：
也就是今天我带着喜悦和莫名的伤感来到一个牛逼的公司报道，开始我正式的程序员生涯，作为一个新人来讲，那个时候我觉得刚开始肯定会有很多人指导你的工作，可是报道之后才发现一切都靠自己，没有人主动指导你什么，只有你不懂的时候自己找适合的人去问，所以基本也是很重要的，好，开始说项目吧。


需求分析：
在嵌入式linux中一般我们更新内核和rootfs的时候，都需要再UBOOT的支持下才能更新，而且要输入一大串的命令，这样比较不方便，因此我们尝试在内核运行的时候直接将内核和rootfs更新掉，（在本文中Uboot,kernel,rootfs都存放在nor flash）
本文的nor flash容量为16M，其地址
ff000000          ~       ff03ffff               UBOOT
ff060000          ~       ff11ffff               Kernel
ff120000          ~       ffffffff                 filesystem
看完需求分析，我的头脑一片空白，说实在话：因为我不知道什么叫nor flash?nand flash？当然刚开始最好的方法就是google and baidu. After google and baidu之后我大概了解nor flash是一种字符设备，按照我以前所学的知识来理解：既然作为一种设备，那么在linux下设备都可以作为文件存在，那么在Linux中写文件和都文件那岂不是很简单吗？说是迟那是快我就有了下面的想法：
1.        首先我可以把nor flash作为一个设备文件打开，通过open调用，返回一个设备文件描述符fd1
2.        将kernel文件或者filesystem文件下载到嵌入式系统中去（注意：这里的kernel文件和filesystem文件是要去更新nor flash中的文件）
3.        open下载进去的kernel文件或者filesystem文件,返回一个文件描述符fd2
4.        然后通过mmap调用将fd1中要替换的区域映射到进程地址空间,mmap返回一个虚拟地址addr1
5.        将第三步open的文件fd2也通过mmap映射到进程地址空间，mmap返回一个虚拟地址add2
6.        已经知道addr1和addr2，接下来更新文件的工作就相当于字符串拷贝的工作，很简单
为了安全起见，我并没有直接按照上面的步骤来，我怕如果此方法不通，会把kernel区域破坏掉，我想先试试能不能将nor flash中的kernel区域的前16字节 都出来，开和kernel文件中的前16字节是否一致，如果一致，那至少证明这种方式可以读Nor flash的区域，那就有了我的程序员生涯的第一个程序：
1.首先通过一个宏定义nor flash中kernel的地址和大小：
#define KERNEL_START_ADDR  0xff060000
#define KERNEL_SIZE         0x000c0000 //768k
2.打开nor flash设备文件，在本系统中nor flash对应的设备文件名/dev/mem,然后将设备文件映射到进程地址空间中，返回的虚拟地址起始地址kernel_map_addr
kernel_fd =  open("/dev/mem",O_RDWR|O_SYNC);
kernel_map_addr=(char*)mmap(NULL,KERNEL_SIZE,PROT_READ|PROT_WRITE,MAP_SHARED,kernel_fd,KERNEL_START_ADDR);
3.打印nor flash文件kernel区域的前16个字节，与kernel.img文件的前16个字节比较一下开是否读的对：
    for(i=0;i<16;i++)
    {
        printf("%x",rootfs_map_addr);
        printf("\n");
     }

这边小小的提示一下打印的时候要用”%x”,我一开始用的是”%c”,出了很多乱码，为什么会出乱码我相信读者朋友肯定知道为什么了？如果不知道大家google一下吧！
经过上面的步骤我发现;我读出的内容和kernel.img文件的前16个字节一致 ，那证明我的程序可以读nor flash任意区域的想法是对的。下面我把代码贴出来，代码中我是分别读三个区域都进行验证的。其他区域的方法和上面提到的方法是一致的。
补充一下：如果读者对Linux中设备可以作为文件来读写的机制不了解可以去google一下，或者对mmap系统调用不是很了解的也可以去google一下，其实mmap操作我也是临时google的，才了解的

题外话：其实这天我一直搞到夜里1点多钟才休息的，刚开始程序员的生涯，就这么惨了，因为第一天我都不知道什么是交叉编译，只是以前听说过，也不知道我开发的平台是什么，就为了搞开发平台我就搞了一上午，哎，新人就是惨啊，不过第一天抗过来了，有了这么大的收获还是蛮幸福的！兄弟姐妹肯定会怀疑：心里肯定会想，作者不是写字符驱动吗？怎么现在一点也没有，在这里我做个保证，到第三天肯定会有的，我之所以这样写的原因有三个：
第一：记录一下我做一个项目从无到有的经历
第二：让大家了解做这个项目的研究的思路
第三：与大家分享我遇到问题时候解决问题的思路，我觉得第三点是最重要的
 
 
 
------------------------------------
2011年2月22号：
今天一大早就来到了公司，开始我昨天的想法，通过open和mmap的方法来更新nor flash的kernel区域或者rootfs区域。（忘了补充一下我的开发平台是linux 2.4版本的，嵌入式平台是Motolora PPC平台）。我仔细了思考了一下，如果直接写kernel或者rootfs区域的话万一不行怎么办（呵呵，我做人比较谨慎，思考问题也一样，我相信做程序的做事就应该谨慎一点好），我可以试试写nor flash的空白区域，如果空白区域能写进去东西，那再往kernel或者rootfs区域也不迟啊。经过分析，我发现nor flash总共128个sector，每个sector的大小128K，编号是从0~127,那么我想最后的一个扇区应该是空的，我就准备写最后一个扇区：
我的思路如下：
1.        char buf[]="eeeeeeeeeee!"要写入到nor flash第127扇区的数据
2.        rootfs_fd =  open("/dev/mem",O_RDWR|O_SYNC);打开nor flash设备文件
3.        rootfs_map_addr=(char*)mmap(NULL,ROOTFS_SIZE ,PROT_READ|PROT_WRITE,MAP_SHARED,rootfs_fd,ROOTFS_START_ADDR);将nor flash的rootfs区域映射到进程地址空间
4.        打印出前第127扇区的前11个字节的内容，与char buf[]中的数据进行比较
5.        将cha buf[]的内容写入到底127扇区，直接通过字符串拷贝的方式，然后再将第127扇区的前11个字节打印出来与写入得数据进行比较
下面是我的代码：

点击(此处)折叠或打开

  1. /********************************** Include ********************************/
  2. #include<stdarg.h>
  3. #include<stdlib.h>
  4. #include<string.h>
  5. #include<stdio.h>

  7. #include <unistd.h>
  8. #include <fcntl.h>
  9. #include <assert.h>
  10. #include <time.h>

  12. #include <sys/ioctl.h>
  13. #include <sys/mman.h>

  15. /********************************** Define *********************************/
  16. #define UBOOT_START_ADDR 0xff000000
  17. #define UBOOT_SIZE 0x00040000 //256k

  19. #define KERNEL_START_ADDR 0xff060000
  20. #define KERNEL_SIZE 0x000c0000 //768k

  22. #define ROOTFS_START_ADDR 0xff120000
  23. #define ROOTFS_SIZE 0x00ee0000 //15232k
  24. #define START_READ_OFFSET 0x00800000 //8M

  26. #define START_WRITE_OFFSET 0x00C00000 //12M

  28. /****************************** Local Variable *****************************/
  29. static int uboot_fd;
  30. static int kernel_fd;
  31. static int rootfs_fd;

  33. volatile char *uboot_map_addr;//address from using mmap（）
  34. volatile char *kernel_map_addr;
  35. volatile char *rootfs_map_addr;


  38. /****************************** Extern Variable ****************************/

  40. /****************************** Local Function *****************************/
  41. static int openMemRW(void);
  42. static void closeMemRW(void);

  44. /********************************* Code ************************************/


  47. int main(int argc, char* argv[])
  48. {
  49.     
  50.     
  51.     
  52.     if(openMemRW()<0)
  53.     {
  54.         printf("openMemRW fail\n");
  55.         return -1;
  56.     }
  57.     closeMemRW();
  58.     return 0;
  59. }



  63. static int openMemRW(void)
  64. {
  65.     int i,len;
  66.     char buf[]="eeeeeeeeeee!";//准备写入到rootfs_map_addr[START_WRITE_OFFSET]开始的地方
  67.     rootfs_fd = open("/dev/mem",O_RDWR|O_SYNC);
  68.     if(rootfs_fd < 0)
  69.      {
  70.         printf("open /dev/mem failed!\n");
  71.         return -1;
  72.       }
  73.     rootfs_map_addr = (char *)mmap(NULL,ROOTFS_SIZE ,PROT_READ|PROT_WRITE,MAP_SHARED,rootfs_fd,ROOTFS_START_ADDR);
  74.     if(rootfs_map_addr == NULL)
  75.      {
  76.         printf("openMemRW ERROR : mmap fd=%d failed!\n",rootfs_fd);
  77.         close(rootfs_fd);
  78.         return -1;
  79.      }
  80.     printf("rootfs_map_addr=%x\n",rootfs_map_addr);//在进程地址空间为映射文件分配的起始地址
  81.     len=strlen(buf)+1;
  82.     
  83.     //将rootfs_map_addr[START_READ_OFFSET]打印出来与rootfs_map_addr[START_WRITE_OFFSET]未写入信息之前的值比较
  84.     
  85.     printf("start from START_READ_OFFSET：\n");
  86.     for(i=0;i<len;i++)
  87.     {
  88.         printf("%x",rootfs_map_addr[START_READ_OFFSET+i]);
  89.         printf("\n");
  90.     }
  91.     
  92.     
  93.     printf("before write:\n");
  94.     //在往rootfs区域写之前，先将原来的内容打印出来
  95.     
  96.     for(i=0;i<len;i++)
  97.     {
  98.         printf("%x",rootfs_map_addr[START_WRITE_OFFSET+i]);
  99.         printf("\n");
  100.     }
  101.     printf("after write:\n");
  102.     //将写入到rootfs区域的信息打印出来
  103.     for(i=0;i<len;i++)
  104.     {
  105.         rootfs_map_addr[START_WRITE_OFFSET+i]=buf[i];
  106.         printf("%x",rootfs_map_addr[START_WRITE_OFFSET+i]);
  107.         printf("\n");
  108.        
  109.     }
  110.     printf("%s\n",buf);
  111.     printf("rootfs_map_addr=%x\n",&rootfs_map_addr[START_WRITE_OFFSET]);
  112.     printf("len=%d\n",len);
  113.     printf("rootfs_map_addr=%x\n",&rootfs_map_addr[START_WRITE_OFFSET+i]);
  114.     return 0;
  115.         

  117. }

  119. //关闭映射
  120. static void closeMemRW(void)
  121. {
  122.   
  123.      munmap((void*)rootfs_map_addr,ROOTFS_SIZE);
  124.               close(rootfs_fd);
  125. }
经过程序测试：发现读出来的东西和写进去的东西不一致，而且秩序执行几次打印出来的结果也不一致，我当时就崩溃了。一个人之所以崩溃，是因为他面临的情况超出了他的知识范围领域，在这种情况下，大多数人都是去问别人或者是google，我选择了两者的结合，通过google和询问我发现：这边之所以失败的原因如下（搞过nor flash的可以跳过下面的分析）：
Nor flash的写必须遵守一种规则，大家注意，这里只提到了写操作，而我们上面的写操作没有遵守这种规则，具体的规则在这里我不详细阐述，这边有一边文章写的不错：
http://www.cnblogs.com/yytblog/archive/2009/09/02/1558943.html
不懂的兄弟姐妹去看一下就明白为什么了，如果不想看的话，下面还会大概介绍一下写规则的
既然上面的方法不行：根据那个链接里提示的规则，我把程序进行了修改，思路如下：
1.        在写之前先将第127扇区前面的一些字节打印出来，我是通过printFlashData()来实现的
2.        然后擦除第127扇区，我是通过eraseFlashSector函数实现的
3.        printFlashData()一下，比较擦除前与擦除后数据是否一致，在这里我要大概介绍一下nor flash的写规则：nor flash在写之前先要erase，然后再写，nor flash erase的单位是以一个sector也就是128K，也就是说一次erase是一个扇区，erase之后的扇区都填充着0xff，那么这一步通过printFlashData()打印出来的内容都应该是0xff
4.        writeFlashWord()函数往第127扇区写数据。
下面来分析一下我上面提到的两个函数：eraseFlashSector和writeFlashWord()
static int eraseFlashSector(void)
{
    volatile unsigned char *addr;
    printf("start to erase:\n";
    addr = rootfs_map_addr; //要擦除的扇区的起始地址，记住这必须是128k的整数倍
    *addr =0x50; /* clear status register */
    *addr =0x20; /* erase setup */
    *addr =0xD0; /* erase confirm */
    *addr =0x70; /* read status register */
    while((*addr & 0x80) != 0x80 )
    {
        *addr = 0x70;
    }
    printf("erase sector  ok!\n";
//    sync();
    *addr = 0xFF;//最后要记住回到read mode那个链接里面也讲到的
//    printf("flash_reset!\n";
    return 0;
}
static int writeFlashWord(unsigned short data)
{
    volatile unsigned char *addr_ptr;
    int i;

    addr_ptr =rootfs_map_addr;
    for(i=0;i<16;i++)
        {
            *addr_ptr=0x60;/* clear status register */
            *addr_ptr =0x40;/* write byte */
            *addr_ptr =data;//要写入扇区的数据，记住这里一次只能写一个byte
            *addr_ptr =0x70;/* read status register */
            while((*addr_ptr & 0x80) != 0x80 )
            {
                *addr_ptr = 0x70;
            }
            addr_ptr++;
            
        }
        *rootfs_map_addr = 0xFF;        //还是要回到read mode
    return 0;
}
不知道为什么上面的程序经过一翻调试和验证发现还是出现很多奇怪的问题：数据还是不能写入，每次执行的结果都有可能有差别，我就不停得找原因，找来找去就是找不到原因，后来没办法只能去问别人，别人给了我一个手册就是关于Nor flash的英文手册，网上都可以下的到，花了一个晚上的时间我仔细的去研读了这个手册，突然眼前一亮，发现有这么一句话：我就把它的大概意思翻译出来：就是erase的时候要保证一次erase序列的完整性，中间不能被打断。大家可以看一下eraseFlashSector()这个函数中对*addr赋值的那几个步骤就是一个完整的序列。如果这个序列被打断的话，有两个寄存器SR4和SR5会报被SET了。在我的程序执行完的时候经常会报SR4和SR5被SET，而且erase后，通过printFlashData()打印出来的值也不是0xff，从这两点我推测，应该是我的应用程序在执行的时候被某个中断打断了，尤其是在erase的时候，那个序列肯定被打断了，所以我的erase总是不成功。那么下面我们就来分析一下:为什么程序在erase的时候会被打断了，这个问题在我们操作系统理论中就讲过，那是由于我们现代多道程序设计的理念才会产生的并发的操作。那么如何避免并发操作给我们erase序列带来的问题了？这个问题纠结了我很久，到这个时候其实已经夜里12点多了，女朋友还在等我回家了，那个时候我大脑已经不运转了，算了，还是明天找原因吧。下面是我的源代码，细心的朋友会发现，这次的源代码从结构上变的很清晰了，打印方面我做了一个简单的函数做处理了，简化了main函数，erase和write操作都单独做了一个函数。聪明的读者会发现明天注定我们要与驱动接触了！
 

点击(此处)折叠或打开

  1. #include<stdarg.h>
  2. #include<stdlib.h>
  3. #include<string.h>
  4. #include<stdio.h>

  6. #include <unistd.h>
  7. #include <fcntl.h>
  8. #include <assert.h>
  9. #include <time.h>

  11. #include <sys/ioctl.h>
  12. #include <sys/mman.h>
  13. #include <sys/mount.h>


  16. #define FLASH_START_ADDR 0xff000000
  17. #define sectno 127
  18. #define ROOTFS_START_ADDR 0xff120000
  19. #define ROOTFS_SIZE 0x00ee0000 //15232k
  20. #define SECT_SIZE 0x00020000 //128K
  21. #define SECT_OFFSET_ADDR (127*SECT_SIZE)//第127扇区相对于FLASH_START_ADDR的偏移地址
  22. #define SECT_START_ADDR (SECT_OFFSET_ADDR+FLASH_START_ADDR)//第127扇区的起始地址


  25. #define FLASH_TEST_ADDR 0xffFE0000


  28. static int eraseFlashSector(void);
  29. static int writeFlashWord(unsigned short data);
  30. static int openMemRW(void);
  31. static void closeMemRW(void);

  33. //volatile unsigned short *sect_start_addr= (volatile unsigned short *)(FLASH_START_ADDR + sectno*0x20000);
  34. static int rootfs_fd;
  35. volatile unsigned char *rootfs_map_addr;

  37. //char *buf[];


  40. void printFlashData(void);
  41. //void printFile(void);


  44. int main(int argc, char* argv[])
  45. {
  46.     unsigned char data;
  47.     data=2;
  48.     int i;
  49.     char buf[8];
  50.     for(i=0;i<8;i++)
  51.     buf[i]='a';
  52.     //在写之前先读数据
  53.      if(openMemRW()<0)
  54.     {
  55.         printf("openMemRW fail\n");
  56.         return -1;
  57.     }

  59.     printFlashData();
  60. // if(write(rootfs_fd,buf,8)<0)
  61. // {
  62. // printf("write fail\n");
  63. // return -1;
  64. // }
  65. // printFlashData();
  66.         
  67. // printFile();
  68. // write_to_buff();

  70. // umount("dev/mtdblock2");
  71. // #if 0
  72.     if(eraseFlashSector()<0)
  73.     {
  74.         printf(" erase fail\n");
  75.         return -1;
  76.     }
  77.     printFlashData();

  79.    
  80.     if(writeFlashWord(data)<0)
  81.     {
  82.         printf("write fail\n");
  83.         return -1;
  84.     }
  85.     data = *(unsigned char *)rootfs_map_addr;
  86.     printf("read data=%d\n", data);
  87.     printFlashData();
  88.     //写完之后再读数据，看是否写入
  89. // if(openMemRW()<0)
  90. // {
  91. // printf("openMemRW fail\n");
  92. // return -1;
  93. // }
  94. //#endif
  95.     closeMemRW();
  96.     
  97.     return 0;
  98. }



  102. //FLASH 16M, 128K/SECTOR, TOTAL 128, 0~127
  103. static int eraseFlashSector(void)
  104. {
  105.     volatile unsigned char *addr;
  106.     printf("start to erase:\n");
  107.     addr = rootfs_map_addr;
  108.     *addr =0x50; /* clear status register */
  109.     *addr =0x20; /* erase setup */
  110.     *addr =0xD0; /* erase confirm */
  111.     *addr =0x70; /* read status register */
  112.     while((*addr & 0x80) != 0x80 )
  113.     {
  114.         *addr = 0x70;
  115.     }
  116.     printf("erase sector ok!\n");
  117. // sync();
  118.     *addr = 0xFF;
  119. // printf("flash_reset!\n");
  120.     return 0;
  121. }

  123. static int writeFlashWord(unsigned short data)
  124. {
  125.     volatile unsigned char *addr_ptr;
  126.     int i;

  128.     addr_ptr =rootfs_map_addr;
  129.     for(i=0;i<16;i++)
  130.         {
  131.             *addr_ptr=0x60;/* clear status register */
  132.             *addr_ptr =0x40;/* write byte */
  133.             *addr_ptr =data;
  134.             *addr_ptr =0x70;/* read status register */
  135.             while((*addr_ptr & 0x80) != 0x80 )
  136.             {
  137.                 *addr_ptr = 0x70;
  138.             }
  139.             addr_ptr++;
  140.             
  141.         }
  142.         *rootfs_map_addr = 0xFF;
  143.     return 0;
  144. }


  147. static int openMemRW(void)
  148. {
  149.     rootfs_fd = open("/dev/mem",O_RDWR|O_SYNC);
  150.     if(rootfs_fd < 0)
  151.      {
  152.         printf("open /dev/mem failed!\n");
  153.         return -1;
  154.       }
  155.     printf("start to map flash %x\n", SECT_START_ADDR);
  156.     //把第127扇区映射到进程地址空间
  157.     rootfs_map_addr = (volatile unsigned short *)mmap(NULL,SECT_SIZE,PROT_READ|PROT_WRITE,MAP_SHARED,rootfs_fd,SECT_START_ADDR);
  158. // if(lseek(rootfs_fd,0,SEEK_SET)==-1)
  159. // {
  160. // printf("cannot seek\n");
  161. // return -1;
  162. // }
  163.     if(rootfs_map_addr == NULL)
  164.     {
  165.         printf("openMemRW ERROR : mmap fd=%d failed!\n",rootfs_fd);
  166.         close(rootfs_fd);
  167.         return -1;
  168.     }
  169.     return 0;
  170. }


  173. static void closeMemRW(void)
  174. {
  175.   
  176.     munmap((void*)rootfs_map_addr,SECT_SIZE );
  177.     close(rootfs_fd);
  178. }

  180. void printFlashData(void)
  181. {
  182.     int i;
  183.     printf("rootfs_map_addr=%x\n",rootfs_map_addr);//在进程地址空间为映射文件分配的起始地址
  184. // *rootfs_map_addr = 0xFF;
  185.     
  186.     for(i=0;i<16;i++)
  187.     {
  188.         printf("[%d]=%x ",i, rootfs_map_addr[i]);
  189.         if (i%8==7) printf("\n");
  190.     }
  191.     
  192.     printf("\n");
  193. }
  194. //
  195. //void printFile(void)
  196. //{
  197. // char buf[32];
  198. // int i;
  199. // printf("rootfs_fd=%d\n",rootfs_fd);
  200. // if(read(rootfs_fd,buf,32)<0)
  201. // {
  202. // printf("read fail\n");
  203. // return;
  204. // }
  205. // for(i=0;i<32;i++)
  206. // {
  207. // printf("[%d]=%x",i,buf[i]);
  208. // if(i%16==15)printf("\n");
  209. // }
  210. //
  211. //}

2011年2月23号：
今天早上又很早的就过来了，继续思考昨天的问题，还是回到大学的教材上找答案，在操作系统书上有这么一句话：可以通过关中断的方式来保证执行的序列不被打断。所以解决昨天遗留的问题只能通过关中断！可是问题又来了，怎么关中断，在哪关？
LDD3那本书上详细的阐述了怎么关中断：本文中使用了下面的函数来关中断和开中断：
local_irq_disable()和local_irq_enable()，可是在哪关了?
用户态显然是不能关中断的，那必然要在内核态关，看来我们离驱动有近了一步。说实在话上来就做个驱动心里还是抗拒的，虽然很兴奋，但是还是觉得比较难，心里没有底。
经过仔细的思考，直接上来做驱动风险太大：第一：不知道是不是由于erase的序列被打断而引起不能erase扇区。第二：驱动以前从来没有接触过，搞起来很难搞。因此，我打算做一个内核模块，通过这个模块先往第127扇区写东西，看能不能写进去。思路定下来开始动手了，这边遇到两个问题：
第一：模块编程从来没有接触过。
第二：怎么让你编写的一个模块加载到内核中去
好，既然没接触过那就google,发现网上最多的关于模块方面入门的就是hello world模块，我发现这个模块入门依旧那么的经典。第二个问题网上也有
与是乎就有了我的第一个内核模块程序：这个程序其实和前面的应用程序没有太大的区别：
只不在内核模块下打印不能用printf只能用printk，关于这两个函数打印格式的区别建议不熟悉的人去google一下。同时在erase和write的时候加了关中断，细心的朋友会发现程序中多了一个ioremap而不是原来的mmap函数，这里我为什么会用ioremap，其实这里完全可以不用，但是我当时觉得应该用（因为一开始理解的不是很深刻，在后来的程序中我把ioremap函数取消掉了），那关于ioremap函数，在什么情况下用：这边有一篇文章讲的非常好，建议大家看一下看http://blog.csdn.net/do2jiang/archive/2010/04/05/5450839.aspx

还有在erase和write的时候都进行了关中断
 

点击(此处)折叠或打开

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/errno.h>
  4. #include <linux/mm.h>
  5. #include <asm/io.h> /*for ioremap*/
  6. #include <linux/slab.h> /*for kmalloc and kfree*/
  7. #include <linux/types.h>
  8. #include <linux/fs.h>
  9. #include <asm/segment.h>
  10. #include <asm/uaccess.h> /*for copy_from_user() and copy_to_user()*/
  11. #include <linux/interrupt.h>
  12. #include <linux/irq.h>
  13. #include <linux/init.h>

  15. #define FLASH_START_ADDR 0xff000000
  16. #define MEM_START 0xff000000 /* the first phsical address of nor flash*/
  17. #define MEM_SIZE 0x01000000 /* the total size of nor flash, 16M*/
  18. #define SECT_SIZE 0x00020000 //128K
  19. #define SECT_OFFSET_ADDR (127*SECT_SIZE)//第127扇区相对于FLASH_START_ADDR的偏移地址
  20. #define SECT_START_ADDR (SECT_OFFSET_ADDR+FLASH_START_ADDR)//第127扇区的起始地址0xffe00000


  23. //static int major; /* major device number*/
  24. volatile unsigned char *iomap_flash_addr;/*address return from iommap for nor flash*/

  26. static int write_to_flash(void);
  27. static void printData(void);
  28. static void erase_flash(void);





  34. static int init_module(void)
  35. {


  38.     iomap_flash_addr=(volatile unsigned char *)ioremap(SECT_START_ADDR,SECT_SIZE);
  39.     if(iomap_flash_addr==NULL)
  40.      {
  41.         printk(KERN_ALERT"iomap fail\n");

  43.         return -1;
  44.      }
  45.     printk(KERN_ALERT"iomap_flash_addr=%p\n",iomap_flash_addr);
  46.     printData();
  47.     write_to_flash();
  48.     printData();
  49.     return 0;
  50. }
  51. static void exit_module(void)
  52. {
  53.     if(iomap_flash_addr!=NULL)
  54.     iounmap((void*)iomap_flash_addr);

  56.     return;
  57. }
  58. static int write_to_flash(void)
  59. {
  60. // int left;/*bytes left */

  62.     int i;
  63.         unsigned short data=1;
  64.         volatile unsigned char *addr_ptr;
  65.         addr_ptr=iomap_flash_addr;
  66.         

  68.         
  69.         
  70.         erase_flash();/*erase flash before write*/
  71.         

  73.         for(i=0;i<16;i++)
  74.         {
  75.             local_irq_disable();

  77.             *addr_ptr = 0x50;/* clear status register */
  78.             *addr_ptr = 0x40;/* write byte */
  79.             *addr_ptr = data;
  80.             *addr_ptr = 0x70;/* read status register */
  81.                     while((*addr_ptr & 0x80) != 0x80 )
  82.                     {
  83.                         *addr_ptr = 0x70;
  84.                     }
  85.                     
  86.                 local_irq_enable();
  87.                 addr_ptr++;
  88.         }
  89.         
  90.         *addr_ptr = 0xFF;/* reset to read mode */
  91.         return 0;
  92. }
  93. static void printData()
  94. {
  95.     int i;
  96.     volatile unsigned char *addr;
  97.     addr=iomap_flash_addr;
  98.     for(i=0;i<16;i++)
  99.     {
  100.         printk(KERN_ALERT"[%02d]=%04x ",i,iomap_flash_addr[i]);
  101.         if(i%8==7)
  102.         printk("\n");
  103.     }
  104.     return;

  106. }

  108. static void erase_flash()
  109. {
  110.    
  111.     volatile unsigned char *addr;
  112.     addr=iomap_flash_addr;
  113.    
  114.     printk(KERN_ALERT"start to erase:\n");
  115.         local_irq_disable(); // 注意此时要关中断啦
  116.         *addr = 0x50; /* clear status register */
  117.         *addr = 0x20; /* erase setup */
  118.         *addr = 0xD0; /* erase confirm */
  119.         *addr = 0x70; /* read status register */
  120.         while((*addr & 0x80) != 0x80 )
  121.         {
  122.                 *addr = 0x70;
  123.         }
  124.         local_irq_enable();
  125.         printk(KERN_ALERT"erase sector ok!\n");
  126.         *addr = 0xFF;/* reset to read mode */
  127.         return;
  128. }
  129.          

  131. //module_init(init_module);
  132. //
  133. //module_exit(exit_module);
  134. //


 
 
上一篇：WIFI基本知识整理
下一篇：Linux下读写FLASH驱动——MTD设备分析