ftl_config.c File Reference

#include <assert.h>
#include "debug.h"
#include "xil_printf.h"
#include "memory_map.h"
#include "t4nsc_ucode.h"
#include "nsc_driver.h"

Include dependency graph for ftl_config.c:

Go to the source code of this file.

Functions
void	InitFTL ()
	The entry function for FTL initialization. More...
void	InitChCtlReg ()
	Initialize the base addresses of all channel controllers. More...
void	InitNandArray ()
	Send RESET and SET_FEATURE to all the flash dies. More...
void	CheckConfigRestriction ()
	Check the configurations are legal before the initializations start. More...

Variables
unsigned int	storageCapacity_L
T4REGS	chCtlReg [USER_CHANNELS]
unsigned int	NSCS []
unsigned int	NSC_UCODES []

Function Documentation

CheckConfigRestriction()

void CheckConfigRestriction

(

)

Check the configurations are legal before the initializations start.

This function will check two things:

1. the geometry of flash memory doesn't exceed the limit of flash controller
2. there is no overlap in the memory map

Warning

only allow SLC mode ?

Definition at line 242 of file ftl_config.c.

{
    // geometry configutations of flash memory
    if (USER_CHANNELS > NSC_MAX_CHANNELS)
        assert(!"[WARNING] Configuration Error: Channel [WARNING]");
    if (USER_WAYS > NSC_MAX_WAYS)
        assert(!"[WARNING] Configuration Error: WAY [WARNING]");
    if (USER_BLOCKS_PER_LUN > MAIN_BLOCKS_PER_LUN)
        assert(!"[WARNING] Configuration Error: BLOCK [WARNING]");
    if ((BITS_PER_FLASH_CELL != SLC_MODE))
        assert(!"[WARNING] Configuration Error: BIT_PER_FLASH_CELL [WARNING]");
 
    // the size of some area are variable, make sure there is no overlap
    if (RESERVED_DATA_BUFFER_BASE_ADDR + 0x00200000 > COMPLETE_FLAG_TABLE_ADDR)
        assert(!"[WARNING] Configuration Error: Data buffer size is too large to be allocated to predefined range "
                "[WARNING]");
    if (TEMPORARY_PAY_LOAD_ADDR + 0x00001000 > DATA_BUFFER_MAP_ADDR)
        assert(!"[WARNING] Configuration Error: Metadata for NAND request completion process is too large to be "
                "allocated to predefined range [WARNING]");
    if (FTL_MANAGEMENT_END_ADDR > DRAM_END_ADDR)
        assert(!"[WARNING] Configuration Error: Metadata of FTL is too large to be allocated to DRAM [WARNING]");
}

Here is the caller graph for this function:

InitChCtlReg()

void InitChCtlReg

(

)

Initialize the base addresses of all channel controllers.

Definition at line 119 of file ftl_config.c.

{
    int i;
    if (USER_CHANNELS < 1)
        assert(!"[WARNING] Configuration Error: Channel [WARNING]");
 
    for (i = 0; i < USER_CHANNELS; i++)
    {
        nfc_install_ucode((unsigned int *)NSC_UCODES[i]);
        V2FInitializeHandle(&chCtlReg[i], (void *)NSCS[i]);
        nfc_set_dqs_delay(i, 28);
    }
 
    // nfc_set_dqs_delay(0, 31);
    // nfc_set_dqs_delay(1, 31);
    // nfc_set_dqs_delay(5, 4);
    // nfc_set_dqs_delay(6, 18);
}

Here is the caller graph for this function:

InitFTL()

void InitFTL

(

)

The entry function for FTL initialization.

Definition at line 62 of file ftl_config.c.

{
    CheckConfigRestriction();
 
    InitChCtlReg();        // assigned the predefined addresses of channel controllers
    InitReqPool();         //
    InitDependencyTable(); //
    InitReqScheduler();    //
    InitNandArray();       // "[ NAND device reset complete. ]"
    InitAddressMap();      // "Press 'X' to re-make the bad block table."
    InitDataBuf();         //
    InitGcVictimMap();     //
 
    /*
     * MB_PER_BLOCK                         == 16384 * 256 / (1024 * 1024) == 4
     * MB_PER_SSD                           == USER_BLOCKS_PER_DIE * USER_DIES * MB_PER_BLOCK == 524288
     * MB_PER_MIN_FREE_BLOCK_SPACE          == USER_DIES * MB_PER_BLOCK
     * MB_PER_OVER_PROVISION_BLOCK_SPACE    == (USER_BLOCKS_PER_DIE * USER_DIES / 10) * MB_PER_BLOCK
     * BYTES_PER_NVME_BLOCK                 == 4096
     */
    pr_info("[Total bad blocks size: %d MB ]\r\n", mbPerbadBlockSpace); // calculated in `RemapBadBlock()`
    pr_info("[Total min free block size: %d MB ]\r\n", MB_PER_MIN_FREE_BLOCK_SPACE);
    pr_info("[Total over provision size: %d MB ]\r\n", MB_PER_OVER_PROVISION_BLOCK_SPACE);
 
    storageCapacity_L =
        (MB_PER_SSD - (MB_PER_MIN_FREE_BLOCK_SPACE + mbPerbadBlockSpace + MB_PER_OVER_PROVISION_BLOCK_SPACE)) *
        ((1024 * 1024) / BYTES_PER_NVME_BLOCK);
 
    pr_info("[ storage capacity %d MB ]\r\n", storageCapacity_L / ((1024 * 1024) / BYTES_PER_NVME_BLOCK));
    pr_info("[ ftl configuration complete. ]\r\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

InitNandArray()

void InitNandArray

(

)

Send RESET and SET_FEATURE to all the flash dies.

This function send two requests to each die:

1. REQ_CODE_RESET:

   Todo:

2. REQ_CODE_SET_FEATURE:

   This request is used to make the flash enter the toggle mode, check the function IssueNandReq() for details.

The two types of request have some characteristics:

• no need to do address translation -> use physical address directly:

  set nandAddr to REQ_OPT_NAND_ADDR_PHY_ORG set physicalCh to the channel number of target die set physicalWay to the way number of target die set physicalBlock to any value (no effect) set physicalPage to any value (no effect)

• no dependency problem:

  set rowAddrDependencyCheck to REQ_OPT_ROW_ADDR_DEPENDENCY_NONE set prevBlockingReq to REQ_SLOT_TAG_NONE

• no need data buffer needed:

  set dataBufFormat to REQ_OPT_DATA_BUF_NONE

• apply to all the blocks (main space + extended space)

  set blockSpace to REQ_OPT_BLOCK_SPACE_TOTAL

These requests must be done in the initialization stage, make sure they are all done before going to next initialization step.

Definition at line 175 of file ftl_config.c.

{
    unsigned int chNo, wayNo, reqSlotTag;
    int i;
 
    for (chNo = 0; chNo < USER_CHANNELS; ++chNo)
        for (wayNo = 0; wayNo < USER_WAYS; ++wayNo)
        {
            reqSlotTag                                                    = GetFromFreeReqQ();
            reqPoolPtr->reqPool[reqSlotTag].reqType                       = REQ_TYPE_NAND;
            reqPoolPtr->reqPool[reqSlotTag].reqCode                       = REQ_CODE_RESET;
            reqPoolPtr->reqPool[reqSlotTag].reqOpt.nandAddr               = REQ_OPT_NAND_ADDR_PHY_ORG;
            reqPoolPtr->reqPool[reqSlotTag].reqOpt.dataBufFormat          = REQ_OPT_DATA_BUF_NONE;
            reqPoolPtr->reqPool[reqSlotTag].reqOpt.rowAddrDependencyCheck = REQ_OPT_ROW_ADDR_DEPENDENCY_NONE;
            reqPoolPtr->reqPool[reqSlotTag].reqOpt.blockSpace             = REQ_OPT_BLOCK_SPACE_TOTAL;
            reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalCh           = chNo;
            reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalWay          = wayNo;
            reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalBlock        = 0; // dummy
            reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalPage         = 0; // dummy
            reqPoolPtr->reqPool[reqSlotTag].prevBlockingReq               = REQ_SLOT_TAG_NONE;
            SelectLowLevelReqQ(reqSlotTag);
 
            reqSlotTag                                                    = GetFromFreeReqQ();
            reqPoolPtr->reqPool[reqSlotTag].reqType                       = REQ_TYPE_NAND;
            reqPoolPtr->reqPool[reqSlotTag].reqCode                       = REQ_CODE_SET_FEATURE;
            reqPoolPtr->reqPool[reqSlotTag].reqOpt.nandAddr               = REQ_OPT_NAND_ADDR_PHY_ORG;
            reqPoolPtr->reqPool[reqSlotTag].reqOpt.dataBufFormat          = REQ_OPT_DATA_BUF_NONE;
            reqPoolPtr->reqPool[reqSlotTag].reqOpt.rowAddrDependencyCheck = REQ_OPT_ROW_ADDR_DEPENDENCY_NONE;
            reqPoolPtr->reqPool[reqSlotTag].reqOpt.blockSpace             = REQ_OPT_BLOCK_SPACE_TOTAL;
            reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalCh           = chNo;
            reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalWay          = wayNo;
            reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalBlock        = 0; // dummy
            reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalPage         = 0; // dummy
            reqPoolPtr->reqPool[reqSlotTag].prevBlockingReq               = REQ_SLOT_TAG_NONE;
            SelectLowLevelReqQ(reqSlotTag);
        }
 
    SyncAllLowLevelReqDone();
 
    for (i = 0; i < USER_CHANNELS; i++)
    {
        int j;
        unsigned char *idData = (unsigned char *)(TEMPORARY_PAY_LOAD_ADDR + 16);
        V2FReadIdSync(&chCtlReg[i], 0, idData);
        pr_info("Ch %d ReadId: ", i);
        for (j = 0; j < 6; j++)
            pr_raw("%x ", idData[j]);
        pr("\r\n");
    }
 
    xil_printf("[ NAND device reset complete. ]\r\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

chCtlReg

T4REGS chCtlReg[USER_CHANNELS]

Definition at line 57 of file ftl_config.c.

NSC_UCODES

unsigned int NSC_UCODES[]

Initial value:

= {NSC_0_UCODEADDR, NSC_1_UCODEADDR, NSC_2_UCODEADDR, NSC_3_UCODEADDR,
                             NSC_4_UCODEADDR, NSC_5_UCODEADDR, NSC_6_UCODEADDR, NSC_7_UCODEADDR}

Definition at line 113 of file ftl_config.c.

NSCS

unsigned int NSCS[]

Initial value:

= {
    NSC_0_BASEADDR, NSC_1_BASEADDR, NSC_2_BASEADDR, NSC_3_BASEADDR,
    NSC_4_BASEADDR, NSC_5_BASEADDR, NSC_6_BASEADDR, NSC_7_BASEADDR,
}

Definition at line 108 of file ftl_config.c.

storageCapacity_L

unsigned int storageCapacity_L

Definition at line 56 of file ftl_config.c.