Linux建立Nor Flash分区


韩大卫@吉林师范大学

接上文章<<linux系统Nor Flash芯片初始化及驱动>>, 当Nor Flash 芯片在flash芯片驱动器里链表chip_drvs_list中找到并调用名为”cfi_probe”的驱动后, 完成芯片初始化阶段, 接着进入linux对Flash建立分区阶段.


在 arch/mips/cavium-octeon/flash_setup.c 中

static struct map_info flash_map;


static int __init flash_init(void)

{                         
                 
    union cvmx_mio_boot_reg_cfgx region_cfg;
	
//从bootbus总线上获取flash的基地址.
    region_cfg.u64 = cvmx_read_csr(CVMX_MIO_BOOT_REG_CFGX(0));

    if (region_cfg.s.en) {
            
    //将全局数据结构struct map_info flash_map命名为octeon_nor0
        flash_map.name = "octeon_nor0";

	//物理地址和大小
        flash_map.phys = region_cfg.s.base << 16;

        flash_map.size = 0x1fc00000 - flash_map.phys;

        flash_map.bankwidth = 1;


	//使用ioremap()将32M 大小的Flash的物理地址映射到虚拟地址上.
        flash_map.virt = ioremap(flash_map.phys, flash_map.size);

        pr_notice("Bootbus flash: Setting flash for %luMB flash at "

              "0x%08llx\n", flash_map.size >> 20, flash_map.phys);

        simple_map_init(&flash_map);

	
		/*
	调用do_map_probe()进入Nor Flash芯片初始化阶段,该函数会在Flash芯片驱动器列表中找到名为cfi_probe的驱动器, 并调用其probe()函数, 准备好read/wirte/ioctl等函数的实现方法.
		*/
        mymtd = do_map_probe("cfi_probe", &flash_map);

        if (mymtd) {      

            mymtd->owner = THIS_MODULE;

     

#ifdef CONFIG_MTD_PARTITIONS

/*
	对FLash芯片成功探测(调用过probe)后, linux进入处理Flash分区阶段
*/
nr_parts = parse_mtd_partitions(mymtd,
part_probe_types,
&parts, 0);

            if (nr_parts > 0)


/*
	nr_parts>0 ,说明解析到存在多个分区, 那么添加各个分区
*/
                add_mtd_partitions(mymtd, parts, nr_parts);

            else          

                add_mtd_device(mymtd);

#else             

		//由于定义了CONFIG_MTD_PARTITIONS
宏, 不执行该函数        

            add_mtd_device(mymtd);

#endif                    

        } else {          

            pr_err("Failed to register MTD device for flash\n");

        }                 

    }                     

    return 0;             

}                                                

late_initcall(flash_init);                                                                                                                   

调用do_map_probe()后, 成功的话返回一个重要的数据结构struct mtd_info.

Struct mtd_info是linux描述MTD类型设备的数据结构, 里面有mtd设备等待初始化的信息(变量)和一些设备操作方法(函数指针).

经过do_map_probe()的初始化, 其中有一些成员已经得到赋值, 请参考drivers/mtd/chips/cfi_probe.c 中的cfi_probe()函数.



parse_mtd_partitions(mymtd,
 part_probe_types,&parts, 0); 


解析器类型: 有cmdlinepart和 RedBoot两中, 如没有定义CONFIG_MTD_REDBOOT_PARTS, 那只将cmdlinepart编译在内, 最后只连接cmdlinepart.o.

static const char *part_probe_types[] = { 

    "cmdlinepart",

#ifdef CONFIG_MTD_REDBOOT_PARTS

    "RedBoot",

#endif

    NULL

};


parse_mtd_partitions()定义在drivers/mtd/mtdpart.c 中:

int parse_mtd_partitions(struct mtd_info *master, const char **types,

             struct mtd_partition **pparts, unsigned long origin)

{

    struct mtd_part_parser *parser;

    int ret = 0;

 
	//循环次数: 解析器的个数, 这里只有一个解析器cmdlinepart, 故只循环一次

    for ( ; ret <= 0 && *types; types++) {


		//获取cmdlinepart解析器
        parser = get_partition_parser(*types);

        if (!parser && !request_module("%s", *types))

                parser = get_partition_parser(*types);

        if (!parser) {

            printk(KERN_NOTICE "%s partition parsing not available\n",

                   *types);

            continue;

        }   

		
		/*
		获取成功的话, 调用其解析函数 parse_fn(), 类似于do_map_probe()
		后者是获取驱动器cfi_probe, 获取成功的话, 调用其探测函数Probe()
		*/
        ret = (*parser->parse_fn)(master, pparts, origin);


		/*
			parse_fn()返回解析到的分区个数.在此打印出相关信息,此信息可在dmesg中看到.
		 parser->name 为cmdlinepart,  master->name为octeon_nor0
		*/
        if (ret > 0) {

            printk(KERN_NOTICE "%d %s partitions found on MTD device %s\n",

                   ret, parser->name, master->name);

         

      
      
    

      

#include    <stdio.h>  
#include    <stdlib.h>  
#include    <unistd.h>  
#include    <fcntl.h>  
#include    <sys/mman.h>  
#include    <pthread.h>  
pthread_mutex_t* g_mutex;  
//创建共享的mutex  
void init_mutex(void)  
{  
    int ret;  
    //g_mutex一定要是进程间可以共享的，否则无法达到进程间互斥  
    g_mutex=(pthread_mutex_t*)mmap(NULL, sizeof(pthread_mutex_t), PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);  
    if( MAP_FAILED==g_mutex )  
    {  
        perror("mmap");  
        exit(1);  
    }  
      
    //设置attr的属性  
    pthread_mutexattr_t attr;  
    pthread_mutexattr_init(&attr);  
    //一定要设置为PTHREAD_PROCESS_SHARED  
    //具体可以参考http://blog.chinaunix.net/u/22935/showart_340408.html  
    ret=pthread_mutexattr_setpshared(&attr,PTHREAD_PROCESS_SHARED);  
    if( ret!=0 )  
    {  
        perror("init_mutex pthread_mutexattr_setpshared");  
        exit(1);  
    }  
    pthread_mutex_init(g_mutex, &attr);  
}  
int main(int argc, char *argv[])  
{  
    init_mutex();  
    int ret;      
    char str1[]="this is child process/r/n";  
    char str2[]="this is father process/r/n";  
    int fd=open("tmp", O_RDWR|O_CREAT|O_TRUNC, 0666);  
    if( -1==fd )  
    {  
        perror("open");  
        exit(1);  
    }  
    pid_t pid;  
    pid=fork();  
    if( pid<0 )  
    {  
        perror("fork");  
        exit(1);  
    }  
    else if( 0==pid )  
    {  
        ret=pthread_mutex_lock(g_mutex);  
        if( ret!=0 )  
        {  
            perror("child pthread_mutex_lock");  
        }  
        sleep(10);//测试是否能够阻止父进程的写入  
        write(fd, str1, sizeof(str1));  
        ret=pthread_mutex_unlock(g_mutex);    
        if( ret!=0 )  
        {  
            perror("child pthread_mutex_unlock");  
        }     
    }  
    else  
    {  
        sleep(2);//保证子进程先执行   
        ret=pthread_mutex_lock(g_mutex);  
        if( ret!=0 )  
        {  
            perror("father pthread_mutex_lock");  
        }  
        write(fd, str2, sizeof(str2));  
        ret=pthread_mutex_unlock(g_mutex);    
        if( ret!=0 )  
        {  
            perror("father pthread_mutex_unlock");  
        }                 
    }  
    wait(NULL);  
    munmap(g_mutex, sizeof(pthread_mutex_t));  
}  

运行后tmp文件内容为：

this is child process

this is father process

//threadpool.h  
#ifndef     __THREADPOOL_H__  
#define     __THREADPOOL_H__  
#include    <pthread.h>  
typedef void* (*task_fun)(void*);  
//用链表来维护等待任务  
typedef struct threadtask  
{  
    //任务的执行函数  
    task_fun task;  
    //执行函数的参数  
    void* arg;  
    //下一节点  
    struct threadtask* next;  
}THREAD_TASK;  
  
void* thr_fun(void* arg);//每个线程执行的函数  
int init_task(void);//初始化等待任务链表  
int init_pool(void);//初始化线程池  
//向任务链表中添加任务  
int add_task(task_fun task, void* arg);  
int destroy_poll(void);  
#endif  

//threadpool.c  
//对于基本不出现的错误不进行检测  
#include    <stdio.h>  
#include    <stdlib.h>  
#include    <unistd.h>  
#include    <string.h>  
#include    "threadpool.h"  
//线程池中最多允许的线程数  
#define     THREADPOOLSIZE 3  
//当前等待任务的个数  
static unsigned int taskwaittingnum=0;  
//taskwaittingnum的锁  
pthread_mutex_t g_nummutex= PTHREAD_MUTEX_INITIALIZER;  
//等待任务队列的锁  
pthread_mutex_t g_taskmutex=PTHREAD_MUTEX_INITIALIZER;  
THREAD_TASK* g_pTask=NULL;  
pthread_t tid[THREADPOOLSIZE];  
//是否销毁线程池  
static int isShut=0;  
void* thr_fun(void* arg)  
{  
    task_fun task;  
    void* funarg=NULL;  
    THREAD_TASK* ptmp=NULL;  
      
    while(1)  
    {  
        //如果要销毁线程池，跳出while循环  
        if( 1==isShut )   
        {  
            break;//跳出while循环  
        }  
        pthread_mutex_lock(&g_nummutex);  
        //如果当前没有任务需要调度，休眠5000微妙  
        if( 0==taskwaittingnum )  
        {  
            pthread_mutex_unlock(&g_nummutex);  
            usleep(5000);  
            continue;  
        }  
        //当前有任务调度  
        else  
        {  
            //需要写入链表，所以要锁定链表  
            pthread_mutex_lock(&g_taskmutex);  
            task=g_pTask->next->task;  
            funarg=g_pTask->next->arg;  
            ptmp=g_pTask->next;  
            g_pTask->next=ptmp->next;  
            taskwaittingnum--;  
            pthread_mutex_unlock(&g_taskmutex);  
            pthread_mutex_unlock(&g_nummutex);  
              
            free(ptmp);  
            ptmp=NULL;  
            (*task)(funarg);  
        }  
    }  
    pthread_exit(NULL);  
}  
//初始化任务链表，首个节点不用来存储任务  
int init_task(void)  
{  
    g_pTask=(THREAD_TASK*)malloc(sizeof(THREAD_TASK));  
    if( NULL==g_pTask )  
    {  
        printf("init_task malloc fails./n");  
        return -1;  
    }  
    memset(g_pTask, 0, sizeof(THREAD_TASK));  
    g_pTask->next=NULL;  
    return 0;  
}  
//初始化线程池  
int init_pool(void)  
{  
    int ret;  
    int i;  
    for( i=0 ; i<THREADPOOLSIZE ; i++ )  
    {  
        ret=pthread_create(tid+i, NULL, thr_fun, NULL);  
        if( ret!=0 )  
        {  
            printf("init_pool pthread_create:/n%s/n", strerror(ret));  
            return -1;  
        }  
    }  
    return 0;     
}  
int add_task(task_fun task, void* arg)  
{  
    THREAD_TASK* ptmp=NULL;  
    pthread_mutex_lock(&g_nummutex);  
    pthread_mutex_lock(&g_taskmutex);  
    ptmp=g_pTask;  
    while( ptmp->next!=NULL )  
    {  
        ptmp=ptmp->next;  
    }  
    ptmp->next=(THREAD_TASK*)malloc(sizeof(THREAD_TASK));  
    if( NULL==ptmp->next )  
    {  
        printf("add_task malloc fails/n");  
        return -1;  
    }  
    ptmp=ptmp->next;  
    ptmp->task=task;  
    ptmp->arg=arg;  
    ptmp->next=NULL;  
    taskwaittingnum++;  
    pthread_mutex_unlock(&g_nummutex);  
    pthread_mutex_unlock(&g_taskmutex);  
    return 0;  
}  
int destroy_pool(void)  
{  
    isShut=1;  
    pthread_mutex_destroy(&g_nummutex);  
    pthread_mutex_destroy(&g_taskmutex);  
    return 0;  
}  

//用来测试的main.c  
#include    <stdio.h>  
#include    "threadpool.h"  
void* task1(void* arg)  
{  
    printf("task1正在运行！/n");  
    sleep(10);  
    printf("task1运行结束!/n");  
    return NULL;  
}  
void* task2(void* arg)  
{  
    printf("task2正在运行！/n");  
    sleep(10);  
    printf("task2运行结束！/n");  
    return NULL;  
}  
void* task3(void* arg)  
{  
    printf("task3正在运行！/n");  
    printf("task3运行结束！/n");  
    return NULL;  
}  
void* task4(void* arg)  
{  
    printf("task4正在运行！/n");  
    printf("task4运行结束！/n");  
    return NULL;  
}  
int main(int argc, char *argv[])  
{  
    init_task();  
    init_pool();  
    add_task(task1, NULL);  
    add_task(task2, NULL);  
    add_task(task3, NULL);  
    add_task(task4, NULL);  
    sleep(30);  
    destroy_pool();  
    return 0;  
}