mdr.c

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

            write_len = write_size-complete_len;
        //写入数据到flash中，不校验
        chip->write_data_no_ecc(block_no,block_offset,
                                MDR_DBX_buf+complete_len,write_len);
        block_no++;             //这里并没有考虑坏块的情况----db
        block_offset = 0;       //下一块肯定从块首开始写
        complete_len += write_len;
    }while(complete_len < write_size);
}

//----写MDR_bak的DBX部分------------------------------------------------
//功能: 把DBX写入到MDR_bak中，调用此函数前，确保保存DBX记录的部分已经被擦除.
//参数: chip，被操作的芯片
//      MDR_buf，缓冲区指针
//      DBX_no，文件柜编号
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_write_MDR_DBX_bak(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
                                    + chip->MDR.MDR_bak_block;
    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
            write_len = write_size-complete_len;
        //写入数据到flash中，不校验
        chip->write_data_no_ecc(block_no,block_offset,
                                MDR_DBX_buf+complete_len,write_len);
        block_no++;             //这里并没有考虑坏块的情况----db
        block_offset = 0;       //下一块肯定从块首开始写
        complete_len += write_len;
    }while(complete_len < write_size);
}

//----写一条MDR滚动记录--------------------------------------------------------
//功能: MDR表中写入一个滚动记录，只有MDR_main中才会有此操作，MDR_bak中是所有滚动
//      记录同时写入，不会有单项写入的操作。
//参数: chip，被操作的芯片
//      DBX_no，文件柜编号
//      type，写入类型，可能值cn_MDR_DDR_main、cn_MDR_DDR_bak、cn_MDR_PCRB
//      value，被写入的数值
//返回: 无
//注意: 不能对未格式化的文件柜调用本函数，这是一个内部函数，不检查目标文件柜
//      是否已经格式化
//-----------------------------------------------------------------------------
void __DFFSD_write_MDR_roll_record(struct flash_chip *chip,uint32_t DBX_no,
                                   uint32_t type,uint32_t value)
{
    uint8_t item_buf[8];
    uint32_t block_no,block_offset;
    uint8_t MDR_buf[cn_MDR_size];
    struct MDR_temp_record MDR_record;
    item_buf[0] = type;             //填充记录类型
    item_buf[1] = DBX_no;           //填充文件柜号
    //填充该文件柜的DDR_main块号
    __fill_little_32bit(&item_buf[2],0,value);
    __DFFSD_fill_ECC_MDR_record(item_buf);//填充校验码
    if((chip->MDR.roll_next_main + 8) > cn_MDR_size-8)
    {//特别注明，如cn_MDR_size<784,此处将成死循环
        __DFFSD_read_MDR_main(chip,MDR_buf);
        __DFFSD_uasm_DBX(chip,&MDR_record,MDR_buf);
        __DFFSD_uasm_roll(chip,MDR_buf,&MDR_record,
                          chip->MDR.roll_next_main);
        if(type == cn_MDR_DDR_main)
            MDR_record.DDR_main_block_no[DBX_no] = value;
        else if(type == cn_MDR_DDR_bak)
            MDR_record.DDR_bak_block_no[DBX_no] = value;
        else if(type == cn_MDR_PCRB)
            MDR_record.PCRB_block_no[DBX_no] = value;
        __DFFSD_write_roll_bak(chip,&MDR_record);
        __DFFSD_erase_MDR_main(chip);
        __DFFSD_write_MDR_main(chip,MDR_buf,cn_CDR_and_DBX_size);
        __DFFSD_write_roll_main(chip,&MDR_record);
        __DFFSD_write_end_flag_main(chip);
    }else
    {
        block_no = chip->MDR.roll_next_main / chip->block_size ;
        block_offset = chip->MDR.roll_next_main % chip->block_size ;
        chip->write_data_no_ecc(block_no,block_offset,item_buf,8);
        chip->MDR.roll_next_main += 8;
    }
}

//----构造滚动存储区-----------------------------------------------------------
//功能: 从滚动存储记录生成能够直接保存在flash中的数据，已格式化的文件柜才会有
//      滚动记录。
//参数: chip，被操作的芯片
//      MDR_record，滚动存储记录
//      roll_buf，滚动存储区缓冲区
//返回: roll_buf中有效数据长度
//-----------------------------------------------------------------------------
uint32_t __DFFSD_asm_roll_buf(struct flash_chip *chip,
                          struct MDR_temp_record *MDR_record,uint8_t *roll_buf)
{
    uint32_t loop,DBX_sum=0;
    uint8_t *buf = roll_buf;
    for(loop = 0; loop < cn_DBX_sum_max; loop++)
    {
        if(MDR_record->formatted[loop])   //文件柜已经格式化
        {
            buf[0] = (uint8_t)cn_MDR_DDR_main; //填充记录类型
            buf[1] = (uint8_t)loop;            //填充文件柜号
            //填充该文件柜的DDR_main块号
            __fill_little_32bit(buf+2,0,MDR_record->DDR_main_block_no[loop]);
            __DFFSD_fill_ECC_MDR_record(buf);//填充校验码
            buf += 8;
            buf[0] = cn_MDR_DDR_bak; //填充记录类型
            buf[1] = loop;            //填充文件柜号
            //填充该文件柜的DDR_bak块号
            __fill_little_32bit(buf+2,0,MDR_record->DDR_main_block_no[loop]);
            __DFFSD_fill_ECC_MDR_record(buf);//填充校验码
            buf += 8;
            buf[0] = cn_MDR_PCRB; //填充记录类型
            buf[1] = loop;            //填充文件柜号
            //填充该文件柜的PCRB块号
            __fill_little_32bit(buf+2,0,MDR_record->DDR_main_block_no[loop]);
            __DFFSD_fill_ECC_MDR_record(buf);//填充校验码
            buf += 8;
            DBX_sum +=8*3;
        }
    }
    return DBX_sum;
}
//----写MDR_main的全部滚动记录-------------------------------------------------
//功能: 写入MDR_main表中的全部滚动存储项
//参数: chip，被操作的芯片
//      MDR_record，保存全部滚动存储项的指针
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_write_roll_main(struct flash_chip *chip,
                             struct MDR_temp_record *MDR_record)
{
    struct st_MDR_flag *MDR_flag = &chip->MDR;
    uint8_t roll_buf[cn_DBX_sum_max*3*8];
    uint32_t complete_len=0,write_len,write_size;
    uint32_t block_no,block_offset;
    bool_t write_end_flag=false;
    uint8_t MDR_buf[cn_MDR_size];

    write_size = __DFFSD_asm_roll_buf(chip,MDR_record,roll_buf);
    if(write_size != 0)
    {
        //如果写入长度+当前偏移大于滚动区容量
        if((MDR_flag->roll_next_main + write_size) > cn_MDR_size-8)
        {//特别注明，如cn_MDR_size<784,此处将成死循环
            __DFFSD_write_roll_bak(chip,MDR_record);
            __DFFSD_read_MDR_main(chip,MDR_buf);
            __DFFSD_erase_MDR_main(chip);
            __DFFSD_write_MDR_main(chip,MDR_buf,cn_CDR_and_DBX_size);
            MDR_flag->roll_next_main = cn_roll_offset;
            write_end_flag = true;
        }
        block_no = MDR_flag->roll_next_main / chip->block_size ;
        block_offset = MDR_flag->roll_next_main % chip->block_size;
        MDR_flag->roll_next_main += write_size;
        do  //把缓冲区中的数据写入到flash中，数据可能跨块边界，故循环
        {
            if((write_size-complete_len) > chip->block_size-block_offset)
                write_len = chip->block_size-block_offset;
            else
                write_len = write_size-complete_len;
            //写入数据到flash中，不校验
            chip->write_data_no_ecc(block_no,block_offset,
                                    roll_buf+complete_len,write_len);
            block_no++;             //这里并没有考虑坏块的情况----db
            block_offset = 0;       //下一块肯定从块首开始写
            complete_len += write_len;
        }while(complete_len < write_size);
        if(write_end_flag)
            __DFFSD_write_end_flag_main(chip);
    }
}

//----写MDR_bak的全部滚动记录-------------------------------------------------
//功能: 写入MDR_bak表中的全部滚动存储项
//参数: chip，被操作的芯片
//      MDR_record，保存全部滚动存储项的指针
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_write_roll_bak(struct flash_chip *chip,
                            struct MDR_temp_record *MDR_record)
{
    struct st_MDR_flag *MDR_flag = &chip->MDR;
    uint8_t roll_buf[cn_DBX_sum_max*3*8];
    uint32_t complete_len=0,write_len,write_size;
    uint32_t block_no,block_offset;
    bool_t write_end_flag=false;
    uint8_t MDR_buf[cn_MDR_size];

    write_size = __DFFSD_asm_roll_buf(chip,MDR_record,roll_buf);
    if(write_size != 0)
    {
        if((MDR_flag->roll_next_bak + write_size) > cn_MDR_size-8)
        {//特别注明，如cn_MDR_size<784,此处将成死循环
            __DFFSD_read_MDR_bak(chip,MDR_buf);
            __DFFSD_erase_MDR_bak(chip);
            __DFFSD_write_MDR_bak(chip,MDR_buf,cn_CDR_and_DBX_size);
            MDR_flag->roll_next_bak = cn_roll_offset;
            write_end_flag = true;
        }
        block_no = MDR_flag->roll_next_main / chip->block_size ;
        block_offset = MDR_flag->roll_next_main % chip->block_size ;
        MDR_flag->roll_next_bak += write_size;
        do  //把缓冲区中的数据写入到flash中，数据可能跨块边界，故循环
        {
            if((write_size-complete_len) > chip->block_size-block_offset)
                write_len = chip->block_size-block_offset;
            else
                write_len = write_size-complete_len;
            //写入数据到flash中，不校验
            chip->write_data_no_ecc(block_no,block_offset,
                                    roll_buf+complete_len,write_len);
            block_no++;             //这里并没有考虑坏块的情况----db
            block_offset = 0;       //下一块肯定从块首开始写
            complete_len += write_len;
        }while(complete_len < write_size);
        if(write_end_flag)
            __DFFSD_write_end_flag_bak(chip);
    }
}

//----写入一个MDR记录----------------------------------------------------------
//功能: 保存一个MDR记录，本函数供flash driver使用，flash driver并不知道使用滚动
//      方式记录，本函数只是__DFFSD_write_MDR_roll_record函数的包装而已。
//参数: DBX_flash_tag，被操作的文件柜
//      type，写入类型，可能值cn_MDR_DDR_main、cn_MDR_DDR_bak、cn_MDR_PCRB
//      value，被写入的数值
//返回: 无
//注意: 不能对未格式化的文件柜调用本函数，这是一个内部函数，不检查目标文件柜
//      是否已经格式化
//-----------------------------------------------------------------------------
void __DFFSD_write_MDR_item(struct st_DBX_flash_tag *DBX_flash_tag,
                            uint32_t type,uint32_t value)
{
    uint32_t DBX_no;
    struct flash_chip *chip;
    if(DBX_flash_tag == NULL)
        return;
    if((type==cn_MDR_DDR_main)||(type==cn_MDR_DDR_bak)||(type==cn_MDR_PCRB))
    {
        DBX_no = DBX_flash_tag->DBX_no;
        chip = DBX_flash_tag->chip;
        __DFFSD_write_MDR_roll_record(chip,DBX_no,type,value);
    }
}

//----标记文件柜为已格式化-----------------------------------------------------
//功能: 在MDR_DBX表中标记一个文件柜为已经格式化，在MDR_main和MDR_bak中都要修改。
//参数：chip，被操作的芯片
//      DBX_no，文件柜号
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_set_MDR_DBX_formatted(struct flash_chip *chip,uint32_t DBX_no)
{
    uint8_t MDR_buf[cn_MDR_size];
    struct MDR_DBX_mirror *MDR_DBX;
    //计算被写的文件柜的MDR_DBX记录的地址
    MDR_DBX = (struct MDR_DBX_mirror *)(MDR_buf +
                        cn_MDR_CDR_size + DBX_no * cn_MDR_DBX_size);

    __DFFSD_read_MDR_bak(chip,MDR_buf);
    strcpy(MDR_DBX->DBX_format_flag,"ready");
    __DFFSD_fill_ECC_MDR_DBX((uint8_t *)MDR_DBX);
    __DFFSD_erase_MDR_bak(chip);
    //最后4字节是结束标志AA5555AA，故减4
    __DFFSD_write_MDR_bak(chip,MDR_buf,cn_MDR_size-4);
    __DFFSD_write_end_flag_bak(chip);

    __DFFSD_read_MDR_main(chip,MDR_buf);
    strcpy(MDR_DBX->DBX_format_flag,"ready");
    __DFFSD_fill_ECC_MDR_DBX((uint8_t *)MDR_DBX);
    __DFFSD_erase_MDR_main(chip);
    //最后4字节是结束标志AA5555AA，故减4
    __DFFSD_write_MDR_main(chip,MDR_buf,cn_MDR_size-4);
    __DFFSD_write_end_flag_main(chip);
    return;
}
//----擦除MDR_main-------------------------------------------------------------
//功能: 擦除MDR_main，MDR_main的起始块默认为0
//参数：chip，被操作的芯片
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_erase_MDR_main(struct flash_chip *chip)
{
    uint32_t blocks,loop;
    blocks = (cn_MDR_size + chip->block_size -1) / chip->block_size;
    for(loop = 0; loop < blocks; loop++)
        chip->erase_block(loop);
}

//----擦除MDR_bak-------------------------------------------------------------
//功能: 擦除MDR_bak，MDR_bak的起始块默认为0
//参数：chip，被操作的芯片
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_erase_MDR_bak(struct flash_chip *chip)
{
    uint32_t blocks,loop;
    blocks = (cn_MDR_size + chip->block_size -1) / chip->block_size;
    for(loop = 0; loop < blocks; loop++)
        chip->erase_block(loop + chip->MDR.MDR_bak_block);
}