mdr.c

新一代基于事件的嵌入式操作系统dyos在三星的s3c44b0的arm芯片上的完整移植代码

            if(free_endian == middle+1)
            {
                result = free_endian*8;
                break;
            }else
                busy_endian = middle;
        }
    }//查找滚动位置结束
    return result;
}

//----解析DBX表----------------------------------------------------------------
//功能: 扫描MDR缓冲区的3个DBX表，找出已经建立的文件柜并读出文件柜参数
//参数: chip，目标芯片，也用于保存扫描结果
//      MDR_record，用于保存结果的指针
//      MDR_buf，MDR表缓冲区
//返回: 已经建立的文件柜数量
//-----------------------------------------------------------------------------
ufast_t __DFFSD_uasm_DBX(struct flash_chip *chip,
                         struct MDR_temp_record *MDR_record,uint8_t *MDR_buf)
{
    struct MDR_DBX_mirror *MDR_DBX;
    uint32_t loop,name_len;
    ufast_t DBX_sum=0;    //已经建立的文件柜数量
    bool_t formatted,unformatted;
    //取MDR_DBX记录的起始地址
    MDR_DBX = (struct MDR_DBX_mirror *)(MDR_buf + cn_MDR_CDR_size);
    for(loop = 0; loop < cn_DBX_sum_max; loop++)
    {//本循环： 1、判断文件柜创建否
     //         2、读文件柜名，
     //         3、读各文件柜的起始块号和块数，不管初始化否
        formatted = (strcmp(MDR_DBX->DBX_format_flag,"ready")==0);
        unformatted = (strcmp(MDR_DBX->DBX_format_flag,"unready")==0);
        if(formatted || unformatted)    //不管格式化否，都表示文件柜已经建立。
        {
            DBX_sum++;                              //文件柜总数增量
            chip->MDR.DBX_created[loop] = true;     //文件柜创建标志设为true
            MDR_record->formatted[loop] = formatted;    //设格式化标志
            name_len = rtstrlen(MDR_DBX->DBX_name,cn_flash_DBX_name_limit);
            if(name_len == 0)
                strcpy(MDR_record->name[loop],"no name deedbox");
            else if(name_len != cn_limit_uint32)
                strcpy(MDR_record->name[loop],MDR_DBX->DBX_name);
            else
            {
                memcpy(MDR_record->name[loop],MDR_DBX->DBX_name,
                                        cn_flash_DBX_name_limit);
                MDR_record->name[loop][cn_flash_DBX_name_limit] = '\0';
            }
            //文件柜起始块号
            MDR_record->start_blocks[loop] =
                            __pick_little_32bit(MDR_DBX->DBX_start_block,0);
            //文件柜尺寸(以块数表示)
            MDR_record->blocks_sum[loop] =
                            __pick_little_32bit(MDR_DBX->DBX_blocks_sum,0);

        }else   //MDR_DBX既不是"ready"也不是"unready"开头，表明文件柜未创建
        {
            chip->MDR.DBX_created[loop] = false;    //文件柜创建标志设为false
            MDR_record->formatted[loop] = false;    //设格式化标志
        }
        //取下一个文件柜MDR_DBX的偏移地址
        MDR_DBX = (struct MDR_DBX_mirror *)((uint32_t)MDR_DBX +cn_MDR_DBX_size);
    }
    return DBX_sum;
}

//----初始化读MDR表------------------------------------------------------------
//功能: 芯片初始化时读整个MDR表，提取有效数据。如果发现MDR_main和MDR_bak中任意
//      一个有错误，刷新之
//参数: chip，被操作的芯片，同时用于返回结果
//      MDR_record，保存有效数据的指针
//返回: 扫描MDR的结果保存在chip和MDR_record两个结构指针中
//      true=芯片已经按djyosfs初始化，false=芯片未按djyosfs初始化
//-----------------------------------------------------------------------------
//特注: 调试本函数时多次引起rvd崩溃，访问非法地址而被windows关闭，而ARM本身运行
//      正常，重新打开rvd后，甚至可以从上次退出的地方接着运行。
bool_t __DFFSD_read_MDR(struct flash_chip *chip,struct MDR_temp_record *MDR_record)
{
    uint8_t MDR_buf[cn_MDR_size];
    uint32_t roll_size;
    uint8_t roll_buf[cn_DBX_sum_max*3*8];
    bool_t MDR_main_valid,MDR_bak_valid;
    struct MDR_CDR_mirror *MDR_CDR;
    ufast_t DBX_sum=0;    //已经建立的文件柜数量

    __DFFSD_read_MDR_main(chip,MDR_buf);
    if(!__DFFSD_verify_end_flag(&MDR_buf[cn_MDR_size-4]))  //检查MDR_main是否完整
    {//MDR_main有错误，读取MDR_bak
        MDR_main_valid = false;
        chip->MDR.MDR_bak_block = __DFFSD_probe_MDR_bak(chip);   //探测MDR_bak的存储位置
    }else
    {
        MDR_main_valid = true;
        MDR_CDR = (struct MDR_CDR_mirror *)MDR_buf;
        if(strcmp(MDR_CDR->chip_init_flag,"djyosfs") != 0)
        {
            return false;      //存储器尚未初始化
        }
        //下面把CDR表的内容读取到chip资源中
        chip->MDR.MDR_bak_block = __pick_little_32bit(MDR_CDR->chip_MDR_bak,0);
        //读取保留块的数量和起始块号，保留块数量并不考虑其中可能有坏块
        chip->rev_start = chip->MDR.MDR_bak_block
                          + (cn_MDR_size+chip->block_size -1)/chip->block_size;
        chip->rev_blocks = __pick_little_32bit(MDR_CDR->chip_reserve,0);
        //计算用于文件柜的起始块号，这里也没有考虑MDR区和保留区有坏块---db
        chip->DBX_start = chip->rev_start + chip->rev_blocks;
        DBX_sum = __DFFSD_uasm_DBX(chip,MDR_record,MDR_buf);
        if(DBX_sum != 0)
        {
            //找到滚动存储区的下一个存储位置
            chip->MDR.roll_next_main = __DFFSD_find_roll_next(chip,MDR_buf);
            //扫描并提取滚动记录中的有效记录(即每类记录的最后一条记录)
            __DFFSD_uasm_roll(chip,MDR_buf,MDR_record,
                              chip->MDR.roll_next_main);
        }else
            chip->MDR.roll_next_main = cn_roll_offset;
    }

    __DFFSD_read_MDR_bak(chip,MDR_buf);     //读MDR_bak到缓冲区中
    if(!__DFFSD_verify_end_flag(&MDR_buf[cn_MDR_size-4]))  //检查MDR_main是否完整
    {//MDR_main有错误，读取MDR_bak
        MDR_bak_valid = false;
    }else
    {
        MDR_bak_valid = true;
        if(MDR_main_valid)      //如果MDR_main有效，则只读取下一个滚动存储位置
        {
            if(DBX_sum != 0)
                chip->MDR.roll_next_bak = __DFFSD_find_roll_next(chip,MDR_buf);
            else
                chip->MDR.roll_next_bak = cn_roll_offset;
        }else   //如果MDR_main无效，则所有文件柜信息从MDR_bak读取
        {
            MDR_CDR = (struct MDR_CDR_mirror *)MDR_buf;
            if(strcmp(MDR_CDR->chip_init_flag,"djyosfs")!=0)
            {
                return false;      //存储器尚未初始化
            }
            //下面把CDR表的内容读取到chip资源中
            //读取保留块的数量和起始块号，保留块数量并不考虑其中可能有坏块
            chip->rev_start = chip->MDR.MDR_bak_block
                          +(cn_MDR_size+chip->block_size -1)/chip->block_size;
            chip->rev_blocks = __pick_little_32bit(MDR_CDR->chip_reserve,0);
            //计算用于文件柜的起始块号，这里也没有考虑MDR区和保留区有坏块---db
            chip->DBX_start = chip->rev_start + chip->rev_blocks;
            DBX_sum = __DFFSD_uasm_DBX(chip,MDR_record,MDR_buf);
            if(DBX_sum != 0)
            {
                chip->MDR.roll_next_bak = __DFFSD_find_roll_next(chip,MDR_buf);
                //扫描并提取滚动记录中的有效记录(即每类记录的最后一条记录)
                __DFFSD_uasm_roll(chip,MDR_buf,MDR_record,
                                  chip->MDR.roll_next_bak);
            }
        }
    }
    if((!MDR_main_valid) && (!MDR_bak_valid))
        return false;
    else
    {
        roll_size = __DFFSD_asm_roll_buf(chip,MDR_record,roll_buf);
        if(!MDR_main_valid)
        {
            __DFFSD_erase_MDR_main(chip);
            memcpy(MDR_buf+cn_roll_offset,roll_buf,roll_size);
            __DFFSD_write_MDR_main(chip,MDR_buf,cn_roll_offset + roll_size);
            __DFFSD_write_end_flag_main(chip);
        }else if(!MDR_bak_valid)
        {
            __DFFSD_erase_MDR_bak(chip);
            memcpy(MDR_buf+cn_roll_offset,roll_buf,roll_size);
            __DFFSD_write_MDR_bak(chip,MDR_buf,cn_roll_offset + roll_size);
            __DFFSD_write_end_flag_bak(chip);
        }
    }
    return true;
}

//----填充滚动条目校验码-------------------------------------------------------
//功能: 给一个MDR的滚动存储记录增加校验码。
//参数: buf，记录指针
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_fill_ECC_MDR_record(uint8_t *buf)
{
}

//----填充MDR_CDR校验码--------------------------------------------------------
//功能: 给一个MDR_CDR增加校验码。
//参数: buf，CDR记录指针
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_fill_ECC_MDR_CDR(uint8_t *buf)
{
}

//----填充MDR_DBX校验码--------------------------------------------------------
//功能: 给一个MDR_DBX增加校验码。
//参数: buf，DBX记录指针
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_fill_ECC_MDR_DBX(uint8_t *buf)
{
}

//----写MDR_main的结束标记-----------------------------------------------------
//功能: 写入MDR_main的结束标志，表示MDR_main是完整的
//参数: chip，被操作的芯片
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_write_end_flag_main(struct flash_chip *chip)
{
    uint32_t block_no,block_offset;
    uint8_t buf[4];
    block_no = (cn_MDR_size -4)/chip->block_size;
    block_offset = (cn_MDR_size -4)%chip->block_size;
    buf[0] = 0xaa;
    buf[1] = 0x55;
    buf[2] = 0x55;
    buf[3] = 0xaa;
    chip->write_data_no_ecc(block_no,block_offset,buf,4);
}

//----写MDR_bak的结束标记-----------------------------------------------------
//功能: 写入MDR_bak的结束标志，表示MDR_bak是完整的
//参数: chip，被操作的芯片
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_write_end_flag_bak(struct flash_chip *chip)
{
    uint32_t block_no,block_offset;
    uint8_t buf[4];
    block_no = (cn_MDR_size -4)/chip->block_size + chip->MDR.MDR_bak_block;
    block_offset = (cn_MDR_size -4)%chip->block_size;
    buf[0] = 0xaa;
    buf[1] = 0x55;
    buf[2] = 0x55;
    buf[3] = 0xaa;
    chip->write_data_no_ecc(block_no,block_offset,buf,4);
}

//----写MDR_main--------------------------------------------------------------
//功能: 从DDR_main开头部分开始，写入指定长度的数据。
//参数: chip，被操作的芯片
//      MDR_buf，缓冲区指针
//      len,写入长度
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_write_MDR_main(struct flash_chip *chip,uint8_t *MDR_buf,uint32_t len)
{
    uint32_t complete_len=0,write_len;
    uint32_t block_no;
    block_no = 0;   //MDR_main默认从0块开始
    do  //把缓冲区中的数据写入到flash中，数据可能跨块边界，故循环
    {
        if((len - complete_len) > chip->block_size)
            write_len = chip->block_size;
        else
            write_len = len-complete_len;
        //写入数据到flash中，不校验
        chip->write_data_no_ecc(block_no,0,MDR_buf+complete_len,write_len);
        block_no++;             //这里并没有考虑坏块的情况----db
        complete_len += write_len;
    }while(complete_len < len);
}

//----写MDR_bak--------------------------------------------------------------
//功能: 从DDR_bak开头部分开始，写入指定长度的数据。
//参数: chip，被操作的芯片
//      MDR_buf，缓冲区指针
//      len,写入长度
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_write_MDR_bak(struct flash_chip *chip,uint8_t *MDR_buf,uint32_t len)
{
    uint32_t complete_len=0,write_len;
    uint32_t block_no;
    block_no = chip->MDR.MDR_bak_block;   //MDR_main默认从0块开始
    do  //把缓冲区中的数据写入到flash中，数据可能跨块边界，故循环
    {
        if((len - complete_len) > chip->block_size)
            write_len = chip->block_size;
        else
            write_len = len-complete_len;
        //写入数据到flash中，不校验
        chip->write_data_no_ecc(block_no,0,MDR_buf+complete_len,write_len);
        block_no++;             //这里并没有考虑坏块的情况----db
        complete_len += write_len;
    }while(complete_len < len);
}

//----写MDR_main的DBX部分------------------------------------------------
//功能: 把DBX写入到MDR_main中，调用此函数前，确保保存DBX记录的部分已经被擦除.
//参数: chip，被操作的芯片
//      MDR_buf，缓冲区指针
//      DBX_no，文件柜编号
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_write_MDR_DBX_main(struct flash_chip *chip,uint8_t *MDR_DBX_buf,
                                                      uint32_t DBX_no)
{
    uint32_t complete_len=0,write_len,write_size;
    uint32_t block_no,block_offset;
    write_size = cn_MDR_DBX_size;
    block_no = (cn_MDR_CDR_size + DBX_no*cn_MDR_DBX_size) / chip->block_size ;
    block_offset = (cn_MDR_CDR_size + DBX_no*cn_MDR_DBX_size)% chip->block_size;
    do  //把缓冲区中的数据写入到flash中，数据可能跨块边界，故循环
    {
        if((write_size-complete_len) > chip->block_size-block_offset)
            write_len = chip->block_size-block_offset;
        else