ddr.c

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

    struct flash_chip *chip;        //芯片指针
    bool_t finished;
    uint32_t i,DDR_blocks;
    chip = DBX_flash_tag->chip; //取得文件柜所属芯片

    DDR_blocks = (DBX_flash_tag->DDR_size + chip->block_size -1)
                        / chip->block_size;     //计算DDR表所占的块数
    do
    {
        finished = true;
        __DFFSD_write_DDR_exe(DBX_flash_tag,0);    //写入DDR_main
        __DFFSD_write_DDR_exe(DBX_flash_tag,1);    //写入DDR_bak
        for(i = 0; i < DDR_blocks; i++)
        {
            if(DBX_flash_tag->writed_DDR_main[i] == false)
            {
                finished = false;
                break;
            }
            if(DBX_flash_tag->writed_DDR_bak[i] == false)
            {
                finished = false;
                break;
            }
        }
    }while(finished == false);  //直到DDR_main和DDR_bak全部完成
    return true;
}

//----MAT链表接龙--------------------------------------------------------------
//功能: 把一个MAT链表延长一块，新增加的块在链表的尾部，本函数没有把MAT表写入flash。
//      当写入文件导致文件延长、需要增加存储块时，调用本函数延长该文件对应的MAT
//      表的表项。
//参数: DBX_flash_tag，被操作的文件柜，flash文件柜的专有数据结构指针
//      last_block_no，原链表中的最后一块
//      new_block_no，替换块号，本块原来是空闲块
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_add_MAT_item(struct st_DBX_flash_tag *DBX_flash_tag,
                           uint32_t last_block_no,uint32_t new_block_no)
{
    struct flash_chip *chip = DBX_flash_tag->chip;
    uint32_t i,MAT_start;
    struct MAT_table *MAT_item = DBX_flash_tag->DDR_MAT;

    MAT_start = __DFFSD_MAT_start(DBX_flash_tag);
    //原最后一块的向后指针指向新块
    MAT_item[last_block_no].next = new_block_no;
    //新块的向前指针指向原最后一块
    MAT_item[new_block_no].previous = last_block_no;
    //新块的向后指针指向自己
    MAT_item[new_block_no].next = new_block_no;
    if(MAT_item[last_block_no].attr == cn_FDT_block)
    {
        //新块的属性改为FDT块
        MAT_item[new_block_no].attr = cn_FDT_block;
    }else
    {
        //新块的属性改为文件后续块
        MAT_item[new_block_no].attr = cn_file_block_continue;
    }
    //计算last_block_no在MAT表中位置处在DDR表中是第几块
    i=(MAT_start + last_block_no*4*2) / chip->block_size;
    //DDR_bak中标记该块为未写入
    DBX_flash_tag->writed_DDR_bak[i] = false;
    //DDR_main中标记该块为未写入
    DBX_flash_tag->writed_DDR_main[i] = false;

    //计算new_block_no在MAT表中位置处在DDR表中是第几块
    i=(MAT_start +new_block_no*4*2) / chip->block_size;
    //DDR_bak中标记该块为未写入
    DBX_flash_tag->writed_DDR_bak[i] = false;
    //DDR_main中标记该块为未写入
    DBX_flash_tag->writed_DDR_main[i] = false;
}

//----修改MAT表项--------------------------------------------------------------
//功能: 把一个MAT链表中的一块替换成另一块，如果该MAT表项刚好是一个文件的首块，
//      还要修改FDT表。本函数没有把MAT表写入flash。
//参数: DBX_flash_tag，被操作的文件柜，flash文件柜的专有数据结构指针
//      old_block_no，被替换的块号，替换后不改变其原来属性
//      new_block_no，替换块号，本块原来是空闲块
//返回: 无
//-----------------------------------------------------------------------------
void __DFFSD_update_MAT_item(struct st_DBX_flash_tag *DBX_flash_tag,
                       uint32_t old_block_no,uint32_t new_block_no)
{
    struct MAT_table *MAT_item = DBX_flash_tag->DDR_MAT;
    struct flash_chip *chip = DBX_flash_tag->chip;  //取文件柜所属芯片
    uint32_t pre_block_no,next_block_no,temp,DDR_blocks,u32_temp;
    uint32_t MAT_start,FDSB_start;

    if(old_block_no == new_block_no)
        return;
    MAT_start = __DFFSD_MAT_start(DBX_flash_tag);

    //计算new_block_no在MAT表中位置处在DDR表中是第几块
    temp = (MAT_start + new_block_no*4*2) / chip->block_size;
    //DDR_bak中标记该块为未写入
    DBX_flash_tag->writed_DDR_bak[temp] = false;
    //DDR_main中标记该块为未写入
    DBX_flash_tag->writed_DDR_main[temp] = false;

    switch(MAT_item[old_block_no].attr)
    {
        case cn_file_block_start:  //原old_block_no块是文件首块
        {
            //new_block_no设置为文件首块
            MAT_item[new_block_no].attr = cn_file_block_start;
            //new_block_no的向前指针指向old_block_no的向前指针(即fdt条目号)
            MAT_item[new_block_no].previous=MAT_item[old_block_no].previous;
            //修改fdt中相应的条目，这个函数也可能会调用__DFFSD_update_MAT_item
            //函数，但不用担心会造成死循环，因为彼时__DFFSD_update_MAT_item的
            //执行路径是switch--case cn_FDT_block
            __DFFSD_update_FDT_fstart_dson(DBX_flash_tag,
                              MAT_item[new_block_no].previous,new_block_no);

            if(MAT_item[old_block_no].next == old_block_no)
            {//既是首块又是末块，这是一个只有一块的文件
                //new_block_no的向后指针指向自己
                MAT_item[new_block_no].next = new_block_no;
            }else
            {//是首块但不是末块
                next_block_no = MAT_item[next_block_no].next;
                //new_block_no的向后指针指向old_block_no的向后指针
                MAT_item[new_block_no].next = next_block_no;
                //old_block_no的后一块的向前指针指向new_block_no
                MAT_item[next_block_no].previous = new_block_no;

                //计算old_block_no的后一块在MAT表中位置处在DDR表中是第几块
                temp = (MAT_start + next_block_no*4*2) / chip->block_size;
                //DDR_bak中标记该块为未写入
                DBX_flash_tag->writed_DDR_bak[temp] = false;
                //DDR_main中标记该块为未写入
                DBX_flash_tag->writed_DDR_main[temp] = false;
            }

        }break;
        case cn_file_block_continue: //原old_block_no块文件后续块
        {
            //new_block_no设置为文件首块
            MAT_item[new_block_no].attr = cn_file_block_continue;
            pre_block_no = MAT_item[old_block_no].previous;
            //new_block_no的向前指针指向old_block_no的向前指针
            MAT_item[new_block_no].previous = pre_block_no;
            MAT_item[pre_block_no].next = new_block_no;

            //计算old_block_no的前一块在MAT表中位置处在DDR表中是第几块
            temp = (MAT_start + pre_block_no*4*2) / chip->block_size;
            //DDR_bak中标记该块为未写入
            DBX_flash_tag->writed_DDR_bak[temp] = false;
            //DDR_main中标记该块为未写入
            DBX_flash_tag->writed_DDR_main[temp] = false;
            if(MAT_item[old_block_no].next == old_block_no)
            {//是末块
                //old_block_no的前一块的向后指针指向new_block_no
                MAT_item[pre_block_no].next = new_block_no;
                //new_block_no的向后指针指向自己
                MAT_item[new_block_no].next = new_block_no;

            }else
            {//不是末块。
                next_block_no = MAT_item[old_block_no].next;
                //new_block_no的向后指针指向old_block_no的向后指针
                MAT_item[new_block_no].next = next_block_no;
                //old_block_no的后一块的向前指针指向new_block_no
                MAT_item[next_block_no].previous = new_block_no;

                //计算old_block_no的后一块在MAT表中位置处在DDR表中是第几块
                temp = (MAT_start+next_block_no*4*2) / chip->block_size;
                //DDR_bak中标记该块为未写入
                DBX_flash_tag->writed_DDR_bak[temp] = false;
                //DDR_main中标记该块为未写入
                DBX_flash_tag->writed_DDR_main[temp] = false;
            }
        }break;
        case cn_FDT_block : //原old_block_no块是FDT块
        {
            FDSB_start = (DBX_flash_tag->DDR_size + chip->block_size -1)
                                / chip->block_size * 4;
            //new_block_no设置为FDT块
            MAT_item[new_block_no].attr = cn_FDT_block;
            if(old_block_no == DBX_flash_tag->DDR_FDSB)        //首块标志
            {
                DBX_flash_tag->DDR_FDSB = new_block_no;
                //计算DDR_FDSB_off在MAT表中位置处在DDR表中是第几块
                temp = FDSB_start / chip->block_size;
                //DDR_bak中标记该块为未写入
                DBX_flash_tag->writed_DDR_bak[temp] = false;
                //DDR_main中标记该块为未写入
                DBX_flash_tag->writed_DDR_main[temp] = false;
                //new_block_no的向前指针指向自己
                MAT_item[new_block_no].previous = new_block_no;
                if(MAT_item[old_block_no].next == old_block_no)
                {//既是首块又是末块，fdt表只占用1块
                    MAT_item[new_block_no].next = new_block_no;
                }else       //不是末块，是中间块
                {
                    next_block_no = MAT_item[old_block_no].next;  //后一块的块号
                    //new_block_no的向后指针指向next_block_no
                    MAT_item[new_block_no].next = next_block_no;
                    //后一块的向前指针指向new_block_no
                    MAT_item[next_block_no].previous = new_block_no;
                    //计算old_block_no的后一块在MAT表中位置处在DDR表中是第几块
                    temp = (MAT_start + next_block_no*4*2) / chip->block_size;
                    //DDR_bak中标记该块为未写入
                    DBX_flash_tag->writed_DDR_bak[temp] = false;
                    //DDR_main中标记该块为未写入
                    DBX_flash_tag->writed_DDR_main[temp] = false;
                }
                //new_block_no的向后指针指向自己
            }else
            {//不是首块，是末块
                pre_block_no = MAT_item[old_block_no].previous;
                //new_block_no的向前指针指向old_block_no的向前指针
                MAT_item[new_block_no].previous = pre_block_no;
                //old_block_no的前一块的向后指针指向new_block_no
                MAT_item[pre_block_no].next = new_block_no;
                //计算old_block_no的前一块在MAT表中位置处在DDR表中是第几块
                temp = (MAT_start+pre_block_no*4*2) / chip->block_size;
                //DDR_bak中标记该块为未写入
                DBX_flash_tag->writed_DDR_bak[temp] = false;
                //DDR_main中标记该块为未写入
                DBX_flash_tag->writed_DDR_main[temp] = false;
                if(MAT_item[old_block_no].next == old_block_no)     //是末块
                {
                    //new_block_no的向后指针指向自己
                    MAT_item[new_block_no].next = new_block_no;
                }else       //是中间块
                {
                    next_block_no = MAT_item[old_block_no].next;
                    //new_block_no的向后指针指向后一块
                    MAT_item[new_block_no].next = next_block_no;
                    //old_block_no的后一块的向前指针指向new_block_no
                    MAT_item[next_block_no].previous = new_block_no;
                    //计算old_block_no的后一块在MAT表中位置处在DDR表中是第几块
                    temp=(MAT_start+next_block_no*4*2) / chip->block_size;
                    //DDR_bak中标记该块为未写入
                    DBX_flash_tag->writed_DDR_bak[temp] = false;
                    //DDR_main中标记该块为未写入
                    DBX_flash_tag->writed_DDR_main[temp] = false;
                }

            }
        }break;
        case cn_invalid_block : //原old_block_no块是坏块，这是不可能的情况
        {
        }break;
        case cn_free_block :    //原old_block_no块是空闲块，也是不可能的
        {
        }break;
        case cn_DDR_main_block ://原old_block_no块是DDR_main块
        {
            //new_block_no设置为DDR_main块
            MAT_item[new_block_no].attr = cn_DDR_main_block;
            DDR_blocks = (DBX_flash_tag->DDR_size + chip->block_size -1)
                                / chip->block_size;     //计算DDR表所占的块数
            //保存DDR_main的块杯更换，需要相应的DBL项
            for(temp = 0; temp < DDR_blocks; temp++)
            {