request_schedule.h File Reference

#include "ftl_config.h"

Include dependency graph for request_schedule.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	_COMPLETE_FLAG_TABLE
struct	_STATUS_REPORT_TABLE
struct	_ERROR_INFO_TABLE
struct	_RETRY_LIMIT_TABLE
struct	_DIE_STATE_ENTRY
struct	_DIE_STATE_TABLE
	The status table of each die on the flash memory. More...
struct	_WAY_PRIORITY_ENTRY
	The way priority table of this channel. More...
struct	_WAY_PRIORITY_TABLE
	The channel status table, each entry contains 7 lists. More...

Macros
#define	WAY_NONE   0xF
#define	LUN_0_BASE_ADDR   0x00000000
#define	LUN_1_BASE_ADDR   0x00100000
#define	PSEUDO_BAD_BLOCK_MARK   0
#define	RETRY_LIMIT   5
	The max number of times a request can retry if it failed. More...
#define	DIE_STATE_IDLE   0
#define	DIE_STATE_EXE   1
#define	REQ_STATUS_CHECK_OPT_NONE   0
#define	REQ_STATUS_CHECK_OPT_CHECK   1
#define	REQ_STATUS_CHECK_OPT_REPORT   2
#define	REQ_STATUS_CHECK_OPT_COMPLETION_FLAG   3
#define	REQ_STATUS_RUNNING   0
#define	REQ_STATUS_DONE   1
#define	REQ_STATUS_FAIL   2
#define	REQ_STATUS_WARNING   3
#define	ERROR_INFO_FAIL   0
#define	ERROR_INFO_PASS   1
#define	ERROR_INFO_WARNING   2

Typedefs
typedef struct _COMPLETE_FLAG_TABLE	COMPLETE_FLAG_TABLE
typedef struct _COMPLETE_FLAG_TABLE *	P_COMPLETE_FLAG_TABLE
typedef struct _STATUS_REPORT_TABLE	STATUS_REPORT_TABLE
typedef struct _STATUS_REPORT_TABLE *	P_STATUS_REPORT_TABLE
typedef struct _ERROR_INFO_TABLE	ERROR_INFO_TABLE
typedef struct _ERROR_INFO_TABLE *	P_ERROR_INFO_TABLE
typedef struct _RETRY_LIMIT_TABLE	RETRY_LIMIT_TABLE
typedef struct _RETRY_LIMIT_TABLE *	P_RETRY_LIMIT_TABLE
typedef struct _DIE_STATE_ENTRY	DIE_STATE_ENTRY
typedef struct _DIE_STATE_ENTRY *	P_DIE_STATE_ENTRY
typedef struct _DIE_STATE_TABLE	DIE_STATE_TABLE
	The status table of each die on the flash memory. More...
typedef struct _DIE_STATE_TABLE *	P_DIE_STATE_TABLE
typedef struct _WAY_PRIORITY_ENTRY	WAY_PRIORITY_ENTRY
	The way priority table of this channel. More...
typedef struct _WAY_PRIORITY_ENTRY *	P_WAY_PRIORITY_ENTRY
typedef struct _WAY_PRIORITY_TABLE	WAY_PRIORITY_TABLE
	The channel status table, each entry contains 7 lists. More...
typedef struct _WAY_PRIORITY_TABLE *	P_WAY_PRIORITY_TABLE

Functions
void	InitReqScheduler ()
	Initialize scheduling related tables. More...
void	SyncAllLowLevelReqDone ()
	Do schedule until all the requests are done. More...
void	SyncAvailFreeReq ()
	Try release request entries by doing scheduling (both NVMe and NAND). More...
void	SyncReleaseEraseReq (unsigned int chNo, unsigned int wayNo, unsigned int blockNo)
	Issuing requests until the specified block can be erased. More...
void	SchedulingNandReq ()
	Iteratively do schedule on each channel by calling SchedulingNandReqPerCh. More...
void	SchedulingNandReqPerCh (unsigned int chNo)
	The main function to schedule NAND requests on the specified channel. More...
void	PutToNandWayPriorityTable (unsigned int reqSlotTag, unsigned int chNo, unsigned int wayNo)
	Append the specified die to a NAND state list based on the request type of the given request. More...
void	PutToNandIdleList (unsigned int chNo, unsigned int wayNo)
	Append the specified die to the tail of the idle list of its channel. More...
void	SelectivGetFromNandIdleList (unsigned int chNo, unsigned int wayNo)
	Remove the specified die from the idle list of its channel. More...
void	PutToNandStatusReportList (unsigned int chNo, unsigned int wayNo)
	Append the specified die to the tail of the status report list of its channel. More...
void	SelectivGetFromNandStatusReportList (unsigned int chNo, unsigned int wayNo)
	Remove the specified die from the status report list of its channel. More...
void	PutToNandReadTriggerList (unsigned int chNo, unsigned int wayNo)
	Append the specified die to the tail of the read trigger list of its channel. More...
void	SelectiveGetFromNandReadTriggerList (unsigned int chNo, unsigned int wayNo)
	Remove the specified die from the read trigger list of its channel. More...
void	PutToNandWriteList (unsigned int chNo, unsigned int wayNo)
	Append the specified die to the tail of the write list of its channel. More...
void	SelectiveGetFromNandWriteList (unsigned int chNo, unsigned int wayNo)
	Remove the specified die from the write list of its channel. More...
void	PutToNandReadTransferList (unsigned int chNo, unsigned int wayNo)
	Append the specified die to the tail of the read transfer list of its channel. More...
void	SelectiveGetFromNandReadTransferList (unsigned int chNo, unsigned int wayNo)
	Remove the specified die from the read transfer list of its channel. More...
void	PutToNandEraseList (unsigned int chNo, unsigned int wayNo)
	Append the specified die to the tail of the erase list of its channel. More...
void	SelectiveGetFromNandEraseList (unsigned int chNo, unsigned int wayNo)
	Remove the specified die from the erase list of its channel. More...
void	PutToNandStatusCheckList (unsigned int chNo, unsigned int wayNo)
	Append the specified die to the tail of the status check list of its channel. More...
void	SelectiveGetFromNandStatusCheckList (unsigned int chNo, unsigned int wayNo)
	Remove the specified die from the status check list of its channel. More...
void	IssueNandReq (unsigned int chNo, unsigned int wayNo)
	Issue a flash operations to the storage controller. More...
unsigned int	GenerateNandRowAddr (unsigned int reqSlotTag)
	Get the nand row (block) address of the given request. More...
unsigned int	GenerateDataBufAddr (unsigned int reqSlotTag)
	Get the corresponding data buffer entry address of the given request. More...
unsigned int	GenerateSpareDataBufAddr (unsigned int reqSlotTag)
	Get the corresponding sparse data buffer entry address of the given request. More...
unsigned int	CheckReqStatus (unsigned int chNo, unsigned int wayNo)
	Update the die status and return the request status. More...
unsigned int	CheckEccErrorInfo (unsigned int chNo, unsigned int wayNo)
void	ExecuteNandReq (unsigned int chNo, unsigned int wayNo, unsigned int reqStatus)
	Update die state and issue new NAND requests if the die is in IDLE state. More...

Variables
P_COMPLETE_FLAG_TABLE	completeFlagTablePtr
P_STATUS_REPORT_TABLE	statusReportTablePtr
P_ERROR_INFO_TABLE	eccErrorInfoTablePtr
P_RETRY_LIMIT_TABLE	retryLimitTablePtr
P_DIE_STATE_TABLE	dieStatusTablePtr
P_WAY_PRIORITY_TABLE	wayPriorityTablePtr

Macro Definition Documentation

DIE_STATE_EXE

#define DIE_STATE_EXE   1

Definition at line 69 of file request_schedule.h.

DIE_STATE_IDLE

#define DIE_STATE_IDLE   0

Definition at line 68 of file request_schedule.h.

ERROR_INFO_FAIL

#define ERROR_INFO_FAIL   0

Definition at line 85 of file request_schedule.h.

ERROR_INFO_PASS

#define ERROR_INFO_PASS   1

Definition at line 86 of file request_schedule.h.

ERROR_INFO_WARNING

#define ERROR_INFO_WARNING   2

Definition at line 87 of file request_schedule.h.

LUN_0_BASE_ADDR

#define LUN_0_BASE_ADDR   0x00000000

Definition at line 54 of file request_schedule.h.

LUN_1_BASE_ADDR

#define LUN_1_BASE_ADDR   0x00100000

Definition at line 55 of file request_schedule.h.

PSEUDO_BAD_BLOCK_MARK

#define PSEUDO_BAD_BLOCK_MARK   0

Definition at line 57 of file request_schedule.h.

REQ_STATUS_CHECK_OPT_CHECK

#define REQ_STATUS_CHECK_OPT_CHECK   1

Definition at line 72 of file request_schedule.h.

REQ_STATUS_CHECK_OPT_COMPLETION_FLAG

#define REQ_STATUS_CHECK_OPT_COMPLETION_FLAG   3

Definition at line 74 of file request_schedule.h.

REQ_STATUS_CHECK_OPT_NONE

#define REQ_STATUS_CHECK_OPT_NONE   0

Definition at line 71 of file request_schedule.h.

REQ_STATUS_CHECK_OPT_REPORT

#define REQ_STATUS_CHECK_OPT_REPORT   2

Definition at line 73 of file request_schedule.h.

REQ_STATUS_DONE

#define REQ_STATUS_DONE   1

Definition at line 81 of file request_schedule.h.

REQ_STATUS_FAIL

#define REQ_STATUS_FAIL   2

Definition at line 82 of file request_schedule.h.

REQ_STATUS_RUNNING

#define REQ_STATUS_RUNNING   0

Definition at line 80 of file request_schedule.h.

REQ_STATUS_WARNING

#define REQ_STATUS_WARNING   3

Definition at line 83 of file request_schedule.h.

RETRY_LIMIT

#define RETRY_LIMIT   5

The max number of times a request can retry if it failed.

Each die has their own retry counter, which is managed by the RETRY_LIMIT_TABLE, if a request is done or reaching the max retry times, the corresponding counter will be reset to this value.

Definition at line 66 of file request_schedule.h.

WAY_NONE

#define WAY_NONE   0xF

Definition at line 52 of file request_schedule.h.

Typedef Documentation

COMPLETE_FLAG_TABLE

typedef struct _COMPLETE_FLAG_TABLE COMPLETE_FLAG_TABLE

DIE_STATE_ENTRY

typedef struct _DIE_STATE_ENTRY DIE_STATE_ENTRY

like a node of doubly-linked list.

Each entry consist of 4 members:

• dieState
• reqStatusCheckOpt
• prevWay
• nextWay

In the beginning, the dieState of each way was initialized to IDLE and all the ways of this channel were connected in serial order.

DIE_STATE_TABLE

typedef struct _DIE_STATE_TABLE DIE_STATE_TABLE

The status table of each die on the flash memory.

This table is simply a 2D status array of each way on each channel.

ERROR_INFO_TABLE

typedef struct _ERROR_INFO_TABLE ERROR_INFO_TABLE

P_COMPLETE_FLAG_TABLE

typedef struct _COMPLETE_FLAG_TABLE * P_COMPLETE_FLAG_TABLE

P_DIE_STATE_ENTRY

typedef struct _DIE_STATE_ENTRY * P_DIE_STATE_ENTRY

P_DIE_STATE_TABLE

typedef struct _DIE_STATE_TABLE * P_DIE_STATE_TABLE

P_ERROR_INFO_TABLE

typedef struct _ERROR_INFO_TABLE * P_ERROR_INFO_TABLE

P_RETRY_LIMIT_TABLE

typedef struct _RETRY_LIMIT_TABLE * P_RETRY_LIMIT_TABLE

P_STATUS_REPORT_TABLE

typedef struct _STATUS_REPORT_TABLE * P_STATUS_REPORT_TABLE

P_WAY_PRIORITY_ENTRY

typedef struct _WAY_PRIORITY_ENTRY * P_WAY_PRIORITY_ENTRY

P_WAY_PRIORITY_TABLE

typedef struct _WAY_PRIORITY_TABLE * P_WAY_PRIORITY_TABLE

RETRY_LIMIT_TABLE

typedef struct _RETRY_LIMIT_TABLE RETRY_LIMIT_TABLE

STATUS_REPORT_TABLE

typedef struct _STATUS_REPORT_TABLE STATUS_REPORT_TABLE

WAY_PRIORITY_ENTRY

typedef struct _WAY_PRIORITY_ENTRY WAY_PRIORITY_ENTRY

The way priority table of this channel.

This table manage several statuses:

• idle
• readTrigger
• readTransfer
• write
• erase
• statusReport
• statusCheck

Each status manage the serial number of head way and tail way,

At the initialization stage, the idle list contains all ways in the channel and the other lists are empty.

WAY_PRIORITY_TABLE

typedef struct _WAY_PRIORITY_TABLE WAY_PRIORITY_TABLE

The channel status table, each entry contains 7 lists.

Function Documentation

CheckEccErrorInfo()

unsigned int CheckEccErrorInfo	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Definition at line 1321 of file request_schedule.c.

{
    unsigned int errorInfo0, errorInfo1, reqSlotTag;
 
    reqSlotTag = nandReqQ[chNo][wayNo].headReq;
 
    errorInfo0 = eccErrorInfoTablePtr->errorInfo[chNo][wayNo][0];
    errorInfo1 = eccErrorInfoTablePtr->errorInfo[chNo][wayNo][1];
 
    if (V2FCrcValid(eccErrorInfoTablePtr->errorInfo[chNo][wayNo]))
    // if (V2FPageDecodeSuccess(&eccErrorInfoTablePtr->errorInfo[chNo][wayNo][1]))
    {
        if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.nandEccWarning == REQ_OPT_NAND_ECC_WARNING_ON)
            if (V2FWorstChunkErrorCount(&errorInfo0) > BIT_ERROR_THRESHOLD_PER_CHUNK)
                return ERROR_INFO_WARNING;
 
        return ERROR_INFO_PASS;
    }
 
    return ERROR_INFO_FAIL;
}

Here is the caller graph for this function:

CheckReqStatus()

unsigned int CheckReqStatus	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Update the die status and return the request status.

Note

This function has a side effect: the flag reqStatusCheckOpt of this die may be updated from REQ_STATUS_CHECK_OPT_CHECK, which means the first stage status check, to REQ_STATUS_CHECK_OPT_REPORT, which means the second stage status check, or changed from REQ_STATUS_CHECK_OPT_REPORT to REQ_STATUS_CHECK_OPT_CHECK, so this function should be used carefully.

Parameters

chNo	the target channel number to check the status.
wayNo	the target die number to check the status.

Returns

unsigned int the status of the request being executed on this die.

Definition at line 1257 of file request_schedule.c.

{
    unsigned int reqSlotTag, completeFlag, statusReport, errorInfo, readyBusy, status;
    unsigned int *statusReportPtr;
 
    reqSlotTag = nandReqQ[chNo][wayNo].headReq;
    if (dieStateTablePtr->dieState[chNo][wayNo].reqStatusCheckOpt == REQ_STATUS_CHECK_OPT_COMPLETION_FLAG)
    {
        completeFlag = completeFlagTablePtr->completeFlag[chNo][wayNo];
 
        if (V2FTransferComplete(completeFlag))
        {
            if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.nandEcc == REQ_OPT_NAND_ECC_ON)
            {
                errorInfo = CheckEccErrorInfo(chNo, wayNo);
 
                if (errorInfo == ERROR_INFO_WARNING)
                    return REQ_STATUS_WARNING;
                else if (errorInfo == ERROR_INFO_FAIL)
                    return REQ_STATUS_FAIL;
            }
            return REQ_STATUS_DONE;
        }
    }
    else if (dieStateTablePtr->dieState[chNo][wayNo].reqStatusCheckOpt == REQ_STATUS_CHECK_OPT_CHECK)
    {
        statusReportPtr = (unsigned int *)(&statusReportTablePtr->statusReport[chNo][wayNo]);
 
        V2FStatusCheckAsync(&chCtlReg[chNo], wayNo, statusReportPtr);
 
        dieStateTablePtr->dieState[chNo][wayNo].reqStatusCheckOpt = REQ_STATUS_CHECK_OPT_REPORT;
    }
    else if (dieStateTablePtr->dieState[chNo][wayNo].reqStatusCheckOpt == REQ_STATUS_CHECK_OPT_REPORT)
    {
        statusReport = statusReportTablePtr->statusReport[chNo][wayNo];
 
        if (V2FRequestReportDone(statusReport))
        {
            status = V2FEliminateReportDoneFlag(statusReport);
            if (V2FRequestComplete(status))
            {
                if (V2FRequestFail(status))
                    return REQ_STATUS_FAIL;
 
                dieStateTablePtr->dieState[chNo][wayNo].reqStatusCheckOpt = REQ_STATUS_CHECK_OPT_NONE;
                return REQ_STATUS_DONE;
            }
            else
                dieStateTablePtr->dieState[chNo][wayNo].reqStatusCheckOpt = REQ_STATUS_CHECK_OPT_CHECK;
        }
    }
    else if (dieStateTablePtr->dieState[chNo][wayNo].reqStatusCheckOpt == REQ_STATUS_CHECK_OPT_NONE)
    {
        readyBusy = V2FReadyBusyAsync(&chCtlReg[chNo]);
 
        if (V2FWayReady(readyBusy, wayNo))
            return REQ_STATUS_DONE;
    }
    else
        assert(!"[WARNING] wrong request status check option [WARNING]");
 
    return REQ_STATUS_RUNNING;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ExecuteNandReq()

void ExecuteNandReq	(	unsigned int	chNo,
		unsigned int	wayNo,
		unsigned int	reqStatus
	)

Update die state and issue new NAND requests if the die is in IDLE state.

If the die state is IDLE, we can just issue new NAND request on that die. But if the state is EXE, we should do different thing based on the request status:

• previous request is RUNNING

  Nothing to do, just wait for it.

• previous request is DONE

  Before we set the die state to IDLE, we need to do something based on its request type:

  • if previous request is READ_TRIGGER, just convert to READ_TRANSFER
  • otherwise, removed from the request queue and reset the retry count

  Note

  if a command should be split into some continuous requests, we should modify this to ensure other requests will not be executed before these requests finished. Take READ for example, if a READ_TRIGGER finished, the data is still in its die register, thus we should make sure the READ_TRANSFER to be the next request that will be executed on this die to prevent the die register from being overwritten.

• previous request is FAIL

  If the request failed, there are different things to do based on the request type. For READ_TRIGGER and READ_TRANSFER, retry the request (from READ_TRIGGER state) until reaching the retry limitation. For other requests, just mark as bad block.

• previous request is WARNING

  This means ECC failed, report bad block then make die IDLE and reset retry count

  Todo:

  bad block and ECC related handling

Note

in current implementation, this is the only function that changes the dieState.

Parameters

chNo	the channel number which should exec this request
wayNo	the way number which should exec this request
reqStatus	the status of the previous request executed on the specified die

Definition at line 1386 of file request_schedule.c.

{
    unsigned int reqSlotTag, rowAddr, phyBlockNo;
    unsigned char *badCheck;
 
    reqSlotTag = nandReqQ[chNo][wayNo].headReq;
 
    switch (dieStateTablePtr->dieState[chNo][wayNo].dieState)
    {
    case DIE_STATE_IDLE:
        IssueNandReq(chNo, wayNo);
        dieStateTablePtr->dieState[chNo][wayNo].dieState = DIE_STATE_EXE;
        break;
    case DIE_STATE_EXE:
        if (reqStatus == REQ_STATUS_DONE)
        {
            if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_READ)
                reqPoolPtr->reqPool[reqSlotTag].reqCode = REQ_CODE_READ_TRANSFER;
            else
            {
                retryLimitTablePtr->retryLimit[chNo][wayNo] = RETRY_LIMIT;
                GetFromNandReqQ(chNo, wayNo, reqStatus, reqPoolPtr->reqPool[reqSlotTag].reqCode);
            }
 
            dieStateTablePtr->dieState[chNo][wayNo].dieState = DIE_STATE_IDLE;
        }
        else if (reqStatus == REQ_STATUS_FAIL)
        {
            if ((reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_READ) ||
                (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_READ_TRANSFER))
                if (retryLimitTablePtr->retryLimit[chNo][wayNo] > 0)
                {
                    retryLimitTablePtr->retryLimit[chNo][wayNo]--;
                    // FIXME: why not just use READ_TRANSFER
                    if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_READ_TRANSFER)
                        reqPoolPtr->reqPool[reqSlotTag].reqCode = REQ_CODE_READ;
 
                    dieStateTablePtr->dieState[chNo][wayNo].dieState = DIE_STATE_IDLE;
                    return;
                }
 
            if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_READ)
                pr_warn("Read Trigger FAIL on      ");
            else if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_READ_TRANSFER)
                pr_warn("Read Transfer FAIL on     ");
            else if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_WRITE)
                pr_warn("Write FAIL on             ");
            else if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_ERASE)
                pr_warn("Erase FAIL on             ");
 
            rowAddr = GenerateNandRowAddr(reqSlotTag);
            pr_warn("ch %x way %x rowAddr 0x%x: completeFlag 0x%x statusReport 0x%x", chNo, wayNo, rowAddr,
                    completeFlagTablePtr->completeFlag[chNo][wayNo],
                    statusReportTablePtr->statusReport[chNo][wayNo]);
 
            if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.nandEcc == REQ_OPT_NAND_ECC_OFF)
                if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.dataBufFormat == REQ_OPT_DATA_BUF_ADDR)
                {
                    // Request fail in the bad block detection process
                    badCheck  = (unsigned char *)reqPoolPtr->reqPool[reqSlotTag].dataBufInfo.addr;
                    *badCheck = PSEUDO_BAD_BLOCK_MARK; // FIXME: why not two step assign ?
                }
 
            // grown bad block information update
            phyBlockNo = ((rowAddr % LUN_1_BASE_ADDR) / PAGES_PER_MLC_BLOCK) +
                         ((rowAddr / LUN_1_BASE_ADDR) * TOTAL_BLOCKS_PER_LUN);
            UpdatePhyBlockMapForGrownBadBlock(Pcw2VdieTranslation(chNo, wayNo), phyBlockNo);
 
            retryLimitTablePtr->retryLimit[chNo][wayNo] = RETRY_LIMIT;
            GetFromNandReqQ(chNo, wayNo, reqStatus, reqPoolPtr->reqPool[reqSlotTag].reqCode);
            dieStateTablePtr->dieState[chNo][wayNo].dieState = DIE_STATE_IDLE;
        }
        else if (reqStatus == REQ_STATUS_WARNING)
        {
            rowAddr = GenerateNandRowAddr(reqSlotTag);
            xil_printf("ECC Uncorrectable Soon on ch %x way %x rowAddr %x / completion %x statusReport %x \r\n",
                       chNo, wayNo, rowAddr, completeFlagTablePtr->completeFlag[chNo][wayNo],
                       statusReportTablePtr->statusReport[chNo][wayNo]);
 
            // grown bad block information update
            phyBlockNo = ((rowAddr % LUN_1_BASE_ADDR) / PAGES_PER_MLC_BLOCK) +
                         ((rowAddr / LUN_1_BASE_ADDR) * TOTAL_BLOCKS_PER_LUN);
            UpdatePhyBlockMapForGrownBadBlock(Pcw2VdieTranslation(chNo, wayNo), phyBlockNo);
 
            retryLimitTablePtr->retryLimit[chNo][wayNo] = RETRY_LIMIT;
            GetFromNandReqQ(chNo, wayNo, reqStatus, reqPoolPtr->reqPool[reqSlotTag].reqCode);
            dieStateTablePtr->dieState[chNo][wayNo].dieState = DIE_STATE_IDLE;
        }
        else if (reqStatus == REQ_STATUS_RUNNING)
            break;
        else
            assert(!"[WARNING] wrong req status [WARNING]");
        break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateDataBufAddr()

unsigned int GenerateDataBufAddr

(

unsigned int

reqSlotTag

)

Get the corresponding data buffer entry address of the given request.

Before issuing the DMA operations, we have to set the buffer address where the request should get/put their data during the READ/WRITE request.

To do this, we may have to specify the entry index of real data buffer and convert to the real address if the data buffer format not REQ_OPT_DATA_BUF_ADDR:

• find the index of data buffer entry to be used:

  Similar to the two request data buffer dataBuf and tempDataBuf, there are also two types of real data buffer specified by the two address DATA_BUFFER_BASE_ADDR and TEMPORARY_DATA_BUFFER_BASE_ADDR.

  Since the two real data buffer have same number of entries with its corresponding request data buffer, AVAILABLE_TEMPORARY_DATA_BUFFER_ENTRY_COUNT for temp buffer and AVAILABLE_DATA_BUFFER_ENTRY_COUNT for normal buffer, we can just simply use the index of the request data buffer entry to find the corresponding index of real data buffer entry.

• get the address of real data buffer entry:

  Since the real data buffer entry have the same size with NAND page size, and we have already found the entry index, we can just multiply the index by the page size defined by BYTES_PER_DATA_REGION_OF_SLICE to get the starting address of the corresponding data buffer of the given data buffer entry.

  However, if the request is a NVMe request, we should do some extra works. Since the unit size of NVMe block is 4K, which is one-fourth of the page size, if the LBA didn't align by 4, we have to move (N*4K) bytes within the real data buffer entry by using the offset to find the address corresponding to the NVMe block.

Parameters

reqSlotTag

the request data buffer entry index

Returns

unsigned int the address of real data buffer entry to be used

Definition at line 1169 of file request_schedule.c.

{
    if (reqPoolPtr->reqPool[reqSlotTag].reqType == REQ_TYPE_NAND)
    {
        if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.dataBufFormat == REQ_OPT_DATA_BUF_ENTRY)
            return (DATA_BUFFER_BASE_ADDR +
                    reqPoolPtr->reqPool[reqSlotTag].dataBufInfo.entry * BYTES_PER_DATA_REGION_OF_SLICE);
        else if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.dataBufFormat == REQ_OPT_DATA_BUF_TEMP_ENTRY)
            return (TEMPORARY_DATA_BUFFER_BASE_ADDR +
                    reqPoolPtr->reqPool[reqSlotTag].dataBufInfo.entry * BYTES_PER_DATA_REGION_OF_SLICE);
        else if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.dataBufFormat == REQ_OPT_DATA_BUF_ADDR)
            return reqPoolPtr->reqPool[reqSlotTag].dataBufInfo.addr;
 
        /*
         * For some requests not belongs to I/O requests, such as RESET, SET_FEATURE and
         * ERASE, the fw just assign a reserved buffer for these requests.
         */
        return RESERVED_DATA_BUFFER_BASE_ADDR;
    }
    else if (reqPoolPtr->reqPool[reqSlotTag].reqType == REQ_TYPE_NVME_DMA)
    {
        // similar to NAND request, but may have offset
        if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.dataBufFormat == REQ_OPT_DATA_BUF_ENTRY)
            return (DATA_BUFFER_BASE_ADDR +
                    reqPoolPtr->reqPool[reqSlotTag].dataBufInfo.entry * BYTES_PER_DATA_REGION_OF_SLICE +
                    reqPoolPtr->reqPool[reqSlotTag].nvmeDmaInfo.nvmeBlockOffset * BYTES_PER_NVME_BLOCK);
        else
            assert(!"[WARNING] wrong reqOpt-dataBufFormat [WARNING]");
    }
    else
        assert(!"[WARNING] wrong reqType [WARNING]");
}

Here is the caller graph for this function:

GenerateNandRowAddr()

unsigned int GenerateNandRowAddr

(

unsigned int

reqSlotTag

)

Get the nand row (block) address of the given request.

To get the row address, we have first check if the nand address format is VSA or not. If the address is VSA, we should convert it to the physical address by doing address translation.

Warning

Toshiba NAND only have SLC mode?

Parameters

reqSlotTag

the request pool index of the target request.

Returns

unsigned int the nand row address for the target request.

Definition at line 1085 of file request_schedule.c.

{
    unsigned int rowAddr, lun, virtualBlockNo, tempBlockNo, phyBlockNo, tempPageNo, dieNo;
 
    if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.nandAddr == REQ_OPT_NAND_ADDR_VSA)
    {
        dieNo          = Vsa2VdieTranslation(reqPoolPtr->reqPool[reqSlotTag].nandInfo.virtualSliceAddr);
        virtualBlockNo = Vsa2VblockTranslation(reqPoolPtr->reqPool[reqSlotTag].nandInfo.virtualSliceAddr);
        phyBlockNo     = Vblock2PblockOfTbsTranslation(virtualBlockNo);
        lun            = phyBlockNo / TOTAL_BLOCKS_PER_LUN;
        tempBlockNo    = phyBlockMapPtr->phyBlock[dieNo][phyBlockNo].remappedPhyBlock % TOTAL_BLOCKS_PER_LUN;
        tempPageNo     = Vsa2VpageTranslation(reqPoolPtr->reqPool[reqSlotTag].nandInfo.virtualSliceAddr);
 
        // if(BITS_PER_FLASH_CELL == SLC_MODE)
        //  tempPageNo = Vpage2PlsbPageTranslation(tempPageNo);
    }
    else if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.nandAddr == REQ_OPT_NAND_ADDR_PHY_ORG)
    {
        dieNo = Pcw2VdieTranslation(reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalCh,
                                    reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalWay);
        if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.blockSpace == REQ_OPT_BLOCK_SPACE_TOTAL)
        {
            lun         = reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalBlock / TOTAL_BLOCKS_PER_LUN;
            tempBlockNo = reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalBlock % TOTAL_BLOCKS_PER_LUN;
            tempPageNo  = reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalPage;
        }
        else if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.blockSpace == REQ_OPT_BLOCK_SPACE_MAIN)
        {
            lun         = reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalBlock / MAIN_BLOCKS_PER_LUN;
            tempBlockNo = reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalBlock % MAIN_BLOCKS_PER_LUN +
                          lun * TOTAL_BLOCKS_PER_LUN;
 
            // phyBlock remap
            tempBlockNo = phyBlockMapPtr->phyBlock[dieNo][tempBlockNo].remappedPhyBlock % TOTAL_BLOCKS_PER_LUN;
            tempPageNo  = reqPoolPtr->reqPool[reqSlotTag].nandInfo.physicalPage;
        }
    }
    else
        assert(!"[WARNING] wrong nand addr option [WARNING]");
 
    if (lun == 0)
        rowAddr = LUN_0_BASE_ADDR + tempBlockNo * PAGES_PER_MLC_BLOCK + tempPageNo;
    else
        rowAddr = LUN_1_BASE_ADDR + tempBlockNo * PAGES_PER_MLC_BLOCK + tempPageNo;
 
    return rowAddr;
}

Here is the caller graph for this function:

GenerateSpareDataBufAddr()

unsigned int GenerateSpareDataBufAddr

(

unsigned int

reqSlotTag

)

Get the corresponding sparse data buffer entry address of the given request.

Similar to GenerateDataBufAddr(), but with different buffer base address, different entry size (256B for metadata/sparse data) and no need to deal with the offset of NVMe requests.

Note

the RESERVED_DATA_BUFFER_BASE_ADDR didn't explicitly split into real data area and sparse data area, hence we should manually add 16K (page size) to get the area for sparse data.

Parameters

reqSlotTag

the request data buffer entry index

Returns

unsigned int the address of sparse data buffer entry to be used

Definition at line 1216 of file request_schedule.c.

{
    if (reqPoolPtr->reqPool[reqSlotTag].reqType == REQ_TYPE_NAND)
    {
        if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.dataBufFormat == REQ_OPT_DATA_BUF_ENTRY)
            return (SPARE_DATA_BUFFER_BASE_ADDR +
                    reqPoolPtr->reqPool[reqSlotTag].dataBufInfo.entry * BYTES_PER_SPARE_REGION_OF_SLICE);
        else if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.dataBufFormat == REQ_OPT_DATA_BUF_TEMP_ENTRY)
            return (TEMPORARY_SPARE_DATA_BUFFER_BASE_ADDR +
                    reqPoolPtr->reqPool[reqSlotTag].dataBufInfo.entry * BYTES_PER_SPARE_REGION_OF_SLICE);
        else if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.dataBufFormat == REQ_OPT_DATA_BUF_ADDR)
            return (reqPoolPtr->reqPool[reqSlotTag].dataBufInfo.addr +
                    BYTES_PER_DATA_REGION_OF_SLICE); // modify PAGE_SIZE to other
 
        return (RESERVED_DATA_BUFFER_BASE_ADDR + BYTES_PER_DATA_REGION_OF_SLICE);
    }
    else if (reqPoolPtr->reqPool[reqSlotTag].reqType == REQ_TYPE_NVME_DMA)
    {
        if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.dataBufFormat == REQ_OPT_DATA_BUF_ENTRY)
            return (SPARE_DATA_BUFFER_BASE_ADDR +
                    reqPoolPtr->reqPool[reqSlotTag].dataBufInfo.entry * BYTES_PER_SPARE_REGION_OF_SLICE);
        else
            assert(!"[WARNING] wrong reqOpt-dataBufFormat [WARNING]");
    }
    else
        assert(!"[WARNING] wrong reqType [WARNING]");
}

Here is the caller graph for this function:

InitReqScheduler()

void InitReqScheduler

(

)

Initialize scheduling related tables.

The following tables may be used for scheduling:

Todo:

• dieStateTablePtr: contains the metadata of all dies
• wayPriorityTablePtr: manages the way state table of each channel
• completeFlagTablePtr:
• statusReportTablePtr:
• eccErrorInfoTablePtr:
• retryLimitTablePtr: manages the remain retry count of each die

In this function:

• all the ways of same channel are in the idle list of their channel.
• all the dies are in idle state and connected in serial order
• the completion count and status report of all die are set to 0
• the retry limit number of each die is set to RETRY_LIMIT

Definition at line 83 of file request_schedule.c.

{
    int chNo, wayNo;
 
    completeFlagTablePtr = (P_COMPLETE_FLAG_TABLE)COMPLETE_FLAG_TABLE_ADDR;
    statusReportTablePtr = (P_STATUS_REPORT_TABLE)STATUS_REPORT_TABLE_ADDR;
    eccErrorInfoTablePtr = (P_ERROR_INFO_TABLE)ERROR_INFO_TABLE_ADDR;
    retryLimitTablePtr   = (P_RETRY_LIMIT_TABLE)RETRY_LIMIT_TABLE_ADDR;
 
    dieStateTablePtr    = (P_DIE_STATE_TABLE)DIE_STATE_TABLE_ADDR;
    wayPriorityTablePtr = (P_WAY_PRIORITY_TABLE)WAY_PRIORITY_TABLE_ADDR;
 
    for (chNo = 0; chNo < USER_CHANNELS; ++chNo)
    {
        wayPriorityTablePtr->wayPriority[chNo].idleHead         = 0;
        wayPriorityTablePtr->wayPriority[chNo].idleTail         = USER_WAYS - 1;
        wayPriorityTablePtr->wayPriority[chNo].statusReportHead = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].statusReportTail = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].eraseHead        = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].eraseTail        = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].readTriggerHead  = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].readTriggerTail  = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].writeHead        = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].writeTail        = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].readTransferHead = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].readTransferTail = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].statusCheckHead  = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].statusCheckTail  = WAY_NONE;
 
        for (wayNo = 0; wayNo < USER_WAYS; ++wayNo)
        {
            dieStateTablePtr->dieState[chNo][wayNo].dieState          = DIE_STATE_IDLE;
            dieStateTablePtr->dieState[chNo][wayNo].reqStatusCheckOpt = REQ_STATUS_CHECK_OPT_NONE;
            dieStateTablePtr->dieState[chNo][wayNo].prevWay           = wayNo - 1;
            dieStateTablePtr->dieState[chNo][wayNo].nextWay           = wayNo + 1;
 
            completeFlagTablePtr->completeFlag[chNo][wayNo] = 0;
            statusReportTablePtr->statusReport[chNo][wayNo] = 0;
            retryLimitTablePtr->retryLimit[chNo][wayNo]     = RETRY_LIMIT;
        }
        dieStateTablePtr->dieState[chNo][0].prevWay             = WAY_NONE;
        dieStateTablePtr->dieState[chNo][USER_WAYS - 1].nextWay = WAY_NONE;
    }
}

Here is the caller graph for this function:

IssueNandReq()

void IssueNandReq	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Issue a flash operations to the storage controller.

To issue a NAND request, we should first allocate a data buffer entry for the request, though some request may not use the buffer, and then call the corresponding function defined in the nsc_driver.c based on the request type.

Before we issue the request, we should set the reqStatusCheckOpt flag of the specified die based on the request type:

• for READ_TRANSFER request, set to REQ_STATUS_CHECK_OPT_COMPLETION_FLAG, which means the we should use the complete flag table to determine if this request is done. Beside checking the status, this flag also used for distinguishing between READ_TRANSFER and other flash operations, since the ECC result may need to be checked, check the function CheckReqStatus() for details.
• for RESET, SET_FEATURE request, set to REQ_STATUS_CHECK_OPT_NONE, which means the request won't update the status table, and we can just use the busy/ready status to determine whether this request is done.
• for READ_TRIGGER, WRITE, ERASE request, set to REQ_STATUS_CHECK_OPT_CHECK, but this flag is a little bit complicated; this flag actually represent the first stage status check, and this flag may be updated to the REQ_STATUS_CHECK_OPT_REPORT, which is used to represent the second stage status check, if the function CheckReqStatus() called during the scheduling process. Check SchedulingNandReqPerCh() and CheckReqStatus() for details.

Warning

replace the condition statements with switch statement

Parameters

chNo	the channel number of the targe die to issue the NAND request.
wayNo	the way number of the targe die to issue the NAND request.

Definition at line 1013 of file request_schedule.c.

{
    unsigned int reqSlotTag, rowAddr;
    void *dataBufAddr;
    void *spareDataBufAddr;
    unsigned int *errorInfo;
    unsigned int *completion;
 
    reqSlotTag       = nandReqQ[chNo][wayNo].headReq;
    rowAddr          = GenerateNandRowAddr(reqSlotTag);
    dataBufAddr      = (void *)GenerateDataBufAddr(reqSlotTag);
    spareDataBufAddr = (void *)GenerateSpareDataBufAddr(reqSlotTag);
 
    if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_READ)
    {
        dieStateTablePtr->dieState[chNo][wayNo].reqStatusCheckOpt = REQ_STATUS_CHECK_OPT_CHECK;
 
        V2FReadPageTriggerAsync(&chCtlReg[chNo], wayNo, rowAddr);
    }
    else if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_READ_TRANSFER)
    {
        dieStateTablePtr->dieState[chNo][wayNo].reqStatusCheckOpt = REQ_STATUS_CHECK_OPT_COMPLETION_FLAG;
 
        errorInfo  = (unsigned int *)(&eccErrorInfoTablePtr->errorInfo[chNo][wayNo]);
        completion = (unsigned int *)(&completeFlagTablePtr->completeFlag[chNo][wayNo]);
 
        if (reqPoolPtr->reqPool[reqSlotTag].reqOpt.nandEcc == REQ_OPT_NAND_ECC_ON)
            V2FReadPageTransferAsync(&chCtlReg[chNo], wayNo, dataBufAddr, spareDataBufAddr, errorInfo, completion,
                                     rowAddr);
        else
            V2FReadPageTransferRawAsync(&chCtlReg[chNo], wayNo, dataBufAddr, completion);
    }
    else if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_WRITE)
    {
        dieStateTablePtr->dieState[chNo][wayNo].reqStatusCheckOpt = REQ_STATUS_CHECK_OPT_CHECK;
 
        V2FProgramPageAsync(&chCtlReg[chNo], wayNo, rowAddr, dataBufAddr, spareDataBufAddr);
    }
    else if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_ERASE)
    {
        dieStateTablePtr->dieState[chNo][wayNo].reqStatusCheckOpt = REQ_STATUS_CHECK_OPT_CHECK;
 
        V2FEraseBlockAsync(&chCtlReg[chNo], wayNo, rowAddr);
    }
    else if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_RESET)
    {
        dieStateTablePtr->dieState[chNo][wayNo].reqStatusCheckOpt = REQ_STATUS_CHECK_OPT_NONE;
 
        V2FResetSync(&chCtlReg[chNo], wayNo);
    }
    else if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_SET_FEATURE)
    {
        dieStateTablePtr->dieState[chNo][wayNo].reqStatusCheckOpt = REQ_STATUS_CHECK_OPT_NONE;
 
        V2FEnterToggleMode(&chCtlReg[chNo], wayNo, TEMPORARY_PAY_LOAD_ADDR);
    }
    else
        assert(!"[WARNING] not defined nand req [WARNING]");
}

Here is the call graph for this function:

Here is the caller graph for this function:

PutToNandEraseList()

void PutToNandEraseList	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Append the specified die to the tail of the erase list of its channel.

Similar to PutToNandIdleList() but with different target list.

Parameters

chNo	the channel number of target die
wayNo	the way number of target die

Definition at line 859 of file request_schedule.c.

{
    if (wayPriorityTablePtr->wayPriority[chNo].eraseTail != WAY_NONE)
    {
        dieStateTablePtr->dieState[chNo][wayNo].prevWay = wayPriorityTablePtr->wayPriority[chNo].eraseTail;
        dieStateTablePtr->dieState[chNo][wayNo].nextWay = WAY_NONE;
        dieStateTablePtr->dieState[chNo][wayPriorityTablePtr->wayPriority[chNo].eraseTail].nextWay = wayNo;
        wayPriorityTablePtr->wayPriority[chNo].eraseTail                                           = wayNo;
    }
    else
    {
        dieStateTablePtr->dieState[chNo][wayNo].prevWay  = WAY_NONE;
        dieStateTablePtr->dieState[chNo][wayNo].nextWay  = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].eraseHead = wayNo;
        wayPriorityTablePtr->wayPriority[chNo].eraseTail = wayNo;
    }
}

Here is the caller graph for this function:

PutToNandIdleList()

void PutToNandIdleList	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Append the specified die to the tail of the idle list of its channel.

Note

This function won't change the reqStatusCheckOpt and dieState flags.

Parameters

chNo	the channel number of target die
wayNo	the way number of target die

Definition at line 536 of file request_schedule.c.

{
    if (wayPriorityTablePtr->wayPriority[chNo].idleTail != WAY_NONE)
    {
        dieStateTablePtr->dieState[chNo][wayNo].prevWay = wayPriorityTablePtr->wayPriority[chNo].idleTail;
        dieStateTablePtr->dieState[chNo][wayNo].nextWay = WAY_NONE;
        dieStateTablePtr->dieState[chNo][wayPriorityTablePtr->wayPriority[chNo].idleTail].nextWay = wayNo;
        wayPriorityTablePtr->wayPriority[chNo].idleTail                                           = wayNo;
    }
    else
    {
        dieStateTablePtr->dieState[chNo][wayNo].prevWay = WAY_NONE;
        dieStateTablePtr->dieState[chNo][wayNo].nextWay = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].idleHead = wayNo;
        wayPriorityTablePtr->wayPriority[chNo].idleTail = wayNo;
    }
}

Here is the caller graph for this function:

PutToNandReadTransferList()

void PutToNandReadTransferList	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Append the specified die to the tail of the read transfer list of its channel.

Similar to PutToNandIdleList() but with different target list.

Parameters

chNo	the channel number of target die
wayNo	the way number of target die

Definition at line 796 of file request_schedule.c.

{
    if (wayPriorityTablePtr->wayPriority[chNo].readTransferTail != WAY_NONE)
    {
        dieStateTablePtr->dieState[chNo][wayNo].prevWay = wayPriorityTablePtr->wayPriority[chNo].readTransferTail;
        dieStateTablePtr->dieState[chNo][wayNo].nextWay = WAY_NONE;
        dieStateTablePtr->dieState[chNo][wayPriorityTablePtr->wayPriority[chNo].readTransferTail].nextWay = wayNo;
        wayPriorityTablePtr->wayPriority[chNo].readTransferTail                                           = wayNo;
    }
    else
    {
        dieStateTablePtr->dieState[chNo][wayNo].prevWay         = WAY_NONE;
        dieStateTablePtr->dieState[chNo][wayNo].nextWay         = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].readTransferHead = wayNo;
        wayPriorityTablePtr->wayPriority[chNo].readTransferTail = wayNo;
    }
}

Here is the caller graph for this function:

PutToNandReadTriggerList()

void PutToNandReadTriggerList	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Append the specified die to the tail of the read trigger list of its channel.

Similar to PutToNandIdleList() but with different target list.

Parameters

chNo	the channel number of target die
wayNo	the way number of target die

Definition at line 670 of file request_schedule.c.

{
    if (wayPriorityTablePtr->wayPriority[chNo].readTriggerTail != WAY_NONE)
    {
        dieStateTablePtr->dieState[chNo][wayNo].prevWay = wayPriorityTablePtr->wayPriority[chNo].readTriggerTail;
        dieStateTablePtr->dieState[chNo][wayNo].nextWay = WAY_NONE;
        dieStateTablePtr->dieState[chNo][wayPriorityTablePtr->wayPriority[chNo].readTriggerTail].nextWay = wayNo;
        wayPriorityTablePtr->wayPriority[chNo].readTriggerTail                                           = wayNo;
    }
    else
    {
        dieStateTablePtr->dieState[chNo][wayNo].prevWay        = WAY_NONE;
        dieStateTablePtr->dieState[chNo][wayNo].nextWay        = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].readTriggerHead = wayNo;
        wayPriorityTablePtr->wayPriority[chNo].readTriggerTail = wayNo;
    }
}

Here is the caller graph for this function:

PutToNandStatusCheckList()

void PutToNandStatusCheckList	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Append the specified die to the tail of the status check list of its channel.

Similar to PutToNandIdleList() but with different target list.

Parameters

chNo	the channel number of target die
wayNo	the way number of target die

Definition at line 922 of file request_schedule.c.

{
    if (wayPriorityTablePtr->wayPriority[chNo].statusCheckTail != WAY_NONE)
    {
        dieStateTablePtr->dieState[chNo][wayNo].prevWay = wayPriorityTablePtr->wayPriority[chNo].statusCheckTail;
        dieStateTablePtr->dieState[chNo][wayNo].nextWay = WAY_NONE;
        dieStateTablePtr->dieState[chNo][wayPriorityTablePtr->wayPriority[chNo].statusCheckTail].nextWay = wayNo;
        wayPriorityTablePtr->wayPriority[chNo].statusCheckTail                                           = wayNo;
    }
    else
    {
        dieStateTablePtr->dieState[chNo][wayNo].prevWay        = WAY_NONE;
        dieStateTablePtr->dieState[chNo][wayNo].nextWay        = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].statusCheckHead = wayNo;
        wayPriorityTablePtr->wayPriority[chNo].statusCheckTail = wayNo;
    }
}

Here is the caller graph for this function:

PutToNandStatusReportList()

void PutToNandStatusReportList	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Append the specified die to the tail of the status report list of its channel.

Similar to PutToNandIdleList() but with different target list.

Parameters

chNo	the channel number of target die
wayNo	the way number of target die

Definition at line 605 of file request_schedule.c.

{
    if (wayPriorityTablePtr->wayPriority[chNo].statusReportTail != WAY_NONE)
    {
        dieStateTablePtr->dieState[chNo][wayNo].prevWay = wayPriorityTablePtr->wayPriority[chNo].statusReportTail;
        dieStateTablePtr->dieState[chNo][wayNo].nextWay = WAY_NONE;
        dieStateTablePtr->dieState[chNo][wayPriorityTablePtr->wayPriority[chNo].statusReportTail].nextWay = wayNo;
        wayPriorityTablePtr->wayPriority[chNo].statusReportTail                                           = wayNo;
    }
    else
    {
        dieStateTablePtr->dieState[chNo][wayNo].prevWay         = WAY_NONE;
        dieStateTablePtr->dieState[chNo][wayNo].nextWay         = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].statusReportHead = wayNo;
        wayPriorityTablePtr->wayPriority[chNo].statusReportTail = wayNo;
    }
}

Here is the caller graph for this function:

PutToNandWayPriorityTable()

void PutToNandWayPriorityTable	(	unsigned int	reqSlotTag,
		unsigned int	chNo,
		unsigned int	wayNo
	)

Append the specified die to a NAND state list based on the request type of the given request.

Parameters

reqSlotTag	the request pool entry index of a request.
chNo	the channel number of the specified die.
wayNo	the way number of the specified die.

Definition at line 511 of file request_schedule.c.

{
    if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_READ)
        PutToNandReadTriggerList(chNo, wayNo);
    else if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_READ_TRANSFER)
        PutToNandReadTransferList(chNo, wayNo);
    else if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_WRITE)
        PutToNandWriteList(chNo, wayNo);
    else if (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_ERASE)
        PutToNandEraseList(chNo, wayNo);
    else if ((reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_RESET) ||
             (reqPoolPtr->reqPool[reqSlotTag].reqCode == REQ_CODE_SET_FEATURE))
        PutToNandWriteList(chNo, wayNo);
    else
        assert(!"[WARNING] wrong reqCode [WARNING]");
}

Here is the call graph for this function:

Here is the caller graph for this function:

PutToNandWriteList()

void PutToNandWriteList	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Append the specified die to the tail of the write list of its channel.

Similar to PutToNandIdleList() but with different target list.

Parameters

chNo	the channel number of target die
wayNo	the way number of target die

Definition at line 733 of file request_schedule.c.

{
    if (wayPriorityTablePtr->wayPriority[chNo].writeTail != WAY_NONE)
    {
        dieStateTablePtr->dieState[chNo][wayNo].prevWay = wayPriorityTablePtr->wayPriority[chNo].writeTail;
        dieStateTablePtr->dieState[chNo][wayNo].nextWay = WAY_NONE;
        dieStateTablePtr->dieState[chNo][wayPriorityTablePtr->wayPriority[chNo].writeTail].nextWay = wayNo;
        wayPriorityTablePtr->wayPriority[chNo].writeTail                                           = wayNo;
    }
    else
    {
        dieStateTablePtr->dieState[chNo][wayNo].prevWay  = WAY_NONE;
        dieStateTablePtr->dieState[chNo][wayNo].nextWay  = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].writeHead = wayNo;
        wayPriorityTablePtr->wayPriority[chNo].writeTail = wayNo;
    }
}

Here is the caller graph for this function:

SchedulingNandReq()

void SchedulingNandReq

(

)

Iteratively do schedule on each channel by calling SchedulingNandReqPerCh.

Definition at line 186 of file request_schedule.c.

{
    int chNo;
 
    for (chNo = 0; chNo < USER_CHANNELS; chNo++)
        SchedulingNandReqPerCh(chNo);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SchedulingNandReqPerCh()

void SchedulingNandReqPerCh

(

unsigned int

chNo

)

The main function to schedule NAND requests on the specified channel.

This function can be separated into 3 parts:

1. select idle ways which has requests want to execute
2. update the request status of each way (second stage status check) and move the die to the idle list if the request is done.
3. update some requests' status (first step status check) and issue requests based on the predefined flash operation priority.

Check the inline comments for more detailed explanation.

Parameters

chNo	the channel number for scheduling

Before doing scheduling on this channel, we should check if there is any idle way on this channel.

If there is any idle way in the idle list, we have to traverse the idle list, and try to schedule requests on the idle ways.

Currently no available requests should be executed on this way, but there may be some requests in the blockedByRowAddrDepReqQ instead. Try to release the blockedByRowAddrDepReqQ and check again if there are any requests to do later.

If any blocked request is released in ReleaseBlockedByRowAddrDepReq(), they will be added to the PutToNandReqQ.

If there is any request should be scheduled on this die, move this die from idle state list to the state list corresponding to the request type. Otherwise, there is really no request want to use this die, just skip this die.

The most important task of this part is to check the request status (second stage status check). Base on the request status, move to the die to the idle state list if its request is done, or back to statusCheck list (first stage status check, check next part for details) if its request not complete yet.

But beside this, we also move the dies that had completed their requests to the corresponding state list if there is any request should be scheduled on this die, just like what we did in the previous part, before issuing requests in next part.

Since the previous part had moved all idle ways to the state list corresponding to the head request of this die, this die must not in DIE_STATE_IDLE state.

Also, we had check the request state is not REQ_STATUS_RUNNING, thus the ExecuteNandReq() must bring the die to DIE_STATE_IDLE.

Since the die become idle, now we can try to schedule request on this die like what we just did in the previous part, if there is any request should be executed on this die.

Note

In current implementation, here is the only place to change the state a die to IDLE and put it into the idle state list.

If the status shows that this request not finish yet, and the flag reqStatusCheckOpt is set to REQ_STATUS_CHECK_OPT_CHECK, which means this request is not READ_TRANSFER since READ_TRANSFER use another flag REQ_STATUS_CHECK_OPT_COMPLETION_FLAG for checking, thus we have to move it back to the statusCheck list (first stage status check) for the next part to check it again.

Similar to next part, because the CheckReqStatus() will turn the flag reqStatusCheckOpt from REQ_STATUS_CHECK_OPT_REPORT to REQ_STATUS_CHECK_OPT_CHECK, we don't have to manually change the flag after/before the die was moved to the statusCheck list.

In the last part, we now can try to issue the requests based on the priority of flash operations. (check the paper)

Note

This part reflect the priority of flash operations mentioned in the paper, therefore DO NOT break the order of these 'if' conditions as long as there is no need to adjust the priority of flash operations.

If there is at least one request should be scheduled and their ways and the channel is not busy, we can issue the requests by calling ExecuteNandReq().

Note

Since some request may make the channel controller busy, we should skip the remaining requests right away as the channel become busy.

After the command is issued, we should move the die to the state list statusCheck or statusReport based on the request type:

• For READ_TRIGGER, WRITE, ERASE requests:

  These types of requests will be moved to the statusCheck list as they were issued. And next time we entered this part, we will check the status of those requests first, since they are in the statusCheck list and status check has the highest priority.

  To check the request status, we use the function CheckReqStatus() to get the requests status of the ways and then move the die to the statusReport list.

  Note

  the function CheckReqStatus() will change the flag reqStatusCheckOpt to REQ_STATUS_CHECK_OPT_REPORT, therefore there is no need to modified the flag before/after we move the die to the statusReport list.

  Not all the requests' status can be retrieve since the die may be busy. Therefore, we only move the dies that successfully retrieved the status to the statusReport for second stage status checking.

• For READ_TRANSFER requests:

  This type of requests will be directly added to the statusReport list. in other words, the status of READ_TRANSFER requests will not be checked in this part.

  GUESS: The reason that we don't check the status of READ_TRANSFER requests may be this type of requests are supposed to be time consuming task, thus we have no need to check the status right after they just being issued.

  Warning

  here should second stage status check

Definition at line 211 of file request_schedule.c.

{
    unsigned int readyBusy, wayNo, reqStatus, nextWay, waitWayCnt;
 
    waitWayCnt = 0;
 
    if (wayPriorityTablePtr->wayPriority[chNo].idleHead != WAY_NONE)
    {
        wayNo = wayPriorityTablePtr->wayPriority[chNo].idleHead;
        while (wayNo != WAY_NONE)
        {
            if (nandReqQ[chNo][wayNo].headReq == REQ_SLOT_TAG_NONE)
                ReleaseBlockedByRowAddrDepReq(chNo, wayNo);
 
            if (nandReqQ[chNo][wayNo].headReq != REQ_SLOT_TAG_NONE)
            {
                nextWay = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
                SelectivGetFromNandIdleList(chNo, wayNo);
                PutToNandWayPriorityTable(nandReqQ[chNo][wayNo].headReq, chNo, wayNo);
                wayNo = nextWay;
            }
            else
            {
                wayNo = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
                waitWayCnt++;
            }
        }
    }
 
    if (wayPriorityTablePtr->wayPriority[chNo].statusReportHead != WAY_NONE)
    {
        readyBusy = V2FReadyBusyAsync(&chCtlReg[chNo]);
        wayNo     = wayPriorityTablePtr->wayPriority[chNo].statusReportHead;
 
        while (wayNo != WAY_NONE)
        {
            if (V2FWayReady(readyBusy, wayNo))
            {
                reqStatus = CheckReqStatus(chNo, wayNo);
                if (reqStatus != REQ_STATUS_RUNNING)
                {
                    ExecuteNandReq(chNo, wayNo, reqStatus);
                    nextWay = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
 
                    SelectivGetFromNandStatusReportList(chNo, wayNo);
                    if (nandReqQ[chNo][wayNo].headReq == REQ_SLOT_TAG_NONE)
                        ReleaseBlockedByRowAddrDepReq(chNo, wayNo);
 
                    if (nandReqQ[chNo][wayNo].headReq != REQ_SLOT_TAG_NONE)
                        PutToNandWayPriorityTable(nandReqQ[chNo][wayNo].headReq, chNo, wayNo);
                    else
                    {
                        PutToNandIdleList(chNo, wayNo);
                        waitWayCnt++;
                    }
 
                    wayNo = nextWay;
                }
                else if (dieStateTablePtr->dieState[chNo][wayNo].reqStatusCheckOpt == REQ_STATUS_CHECK_OPT_CHECK)
                {
                    nextWay = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
                    SelectivGetFromNandStatusReportList(chNo, wayNo);
                    PutToNandStatusCheckList(chNo, wayNo);
                    wayNo = nextWay;
                }
                else
                {
                    wayNo = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
                    waitWayCnt++;
                }
            }
            else
            {
                wayNo = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
                waitWayCnt++;
            }
        }
    }
    else
    {
        pr_debug("Ch[%u]: No idle way can be used to issue new request ...", chNo);
    }
 
    if (waitWayCnt != USER_WAYS)
        if (!V2FIsControllerBusy(&chCtlReg[chNo]))
        {
            if (wayPriorityTablePtr->wayPriority[chNo].statusCheckHead != WAY_NONE)
            {
                readyBusy = V2FReadyBusyAsync(&chCtlReg[chNo]);
                wayNo     = wayPriorityTablePtr->wayPriority[chNo].statusCheckHead;
 
                while (wayNo != WAY_NONE)
                {
                    if (V2FWayReady(readyBusy, wayNo)) // TODO why this need?
                    {
                        // FIXME: called again in second stage status check?? redundant?
                        reqStatus = CheckReqStatus(chNo, wayNo);
 
                        SelectiveGetFromNandStatusCheckList(chNo, wayNo);
                        PutToNandStatusReportList(chNo, wayNo);
 
                        if (V2FIsControllerBusy(&chCtlReg[chNo]))
                            return;
                    }
 
                    wayNo = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
                }
            }
            if (wayPriorityTablePtr->wayPriority[chNo].readTriggerHead != WAY_NONE)
            {
                wayNo = wayPriorityTablePtr->wayPriority[chNo].readTriggerHead;
 
                while (wayNo != WAY_NONE)
                {
                    ExecuteNandReq(chNo, wayNo, REQ_STATUS_RUNNING);
 
                    SelectiveGetFromNandReadTriggerList(chNo, wayNo);
                    PutToNandStatusCheckList(chNo, wayNo);
 
                    if (V2FIsControllerBusy(&chCtlReg[chNo]))
                        return;
 
                    wayNo = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
                }
            }
 
            if (wayPriorityTablePtr->wayPriority[chNo].eraseHead != WAY_NONE)
            {
                wayNo = wayPriorityTablePtr->wayPriority[chNo].eraseHead;
 
                while (wayNo != WAY_NONE)
                {
                    ExecuteNandReq(chNo, wayNo, REQ_STATUS_RUNNING);
 
                    SelectiveGetFromNandEraseList(chNo, wayNo);
                    PutToNandStatusCheckList(chNo, wayNo);
 
                    if (V2FIsControllerBusy(&chCtlReg[chNo]))
                        return;
 
                    wayNo = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
                }
            }
            if (wayPriorityTablePtr->wayPriority[chNo].writeHead != WAY_NONE)
            {
                wayNo = wayPriorityTablePtr->wayPriority[chNo].writeHead;
 
                while (wayNo != WAY_NONE)
                {
                    ExecuteNandReq(chNo, wayNo, REQ_STATUS_RUNNING);
 
                    SelectiveGetFromNandWriteList(chNo, wayNo);
                    PutToNandStatusCheckList(chNo, wayNo);
 
                    if (V2FIsControllerBusy(&chCtlReg[chNo]))
                        return;
 
                    wayNo = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
                }
            }
            if (wayPriorityTablePtr->wayPriority[chNo].readTransferHead != WAY_NONE)
            {
                wayNo = wayPriorityTablePtr->wayPriority[chNo].readTransferHead;
 
                while (wayNo != WAY_NONE)
                {
                    ExecuteNandReq(chNo, wayNo, REQ_STATUS_RUNNING);
 
                    SelectiveGetFromNandReadTransferList(chNo, wayNo);
                    PutToNandStatusReportList(chNo, wayNo);
 
                    if (V2FIsControllerBusy(&chCtlReg[chNo]))
                        return;
 
                    wayNo = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
                }
            }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SelectiveGetFromNandEraseList()

void SelectiveGetFromNandEraseList	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Remove the specified die from the erase list of its channel.

Similar to SelectivGetFromNandIdleList(), but with different target list.

Parameters

chNo	the channel number of target die
wayNo	the way number of target die

Definition at line 885 of file request_schedule.c.

{
    if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay != WAY_NONE) &&
        (dieStateTablePtr->dieState[chNo][wayNo].prevWay != WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].prevWay].nextWay =
            dieStateTablePtr->dieState[chNo][wayNo].nextWay;
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].nextWay].prevWay =
            dieStateTablePtr->dieState[chNo][wayNo].prevWay;
    }
    else if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay == WAY_NONE) &&
             (dieStateTablePtr->dieState[chNo][wayNo].prevWay != WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].prevWay].nextWay = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].eraseTail = dieStateTablePtr->dieState[chNo][wayNo].prevWay;
    }
    else if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay != WAY_NONE) &&
             (dieStateTablePtr->dieState[chNo][wayNo].prevWay == WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].nextWay].prevWay = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].eraseHead = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
    }
    else
    {
        wayPriorityTablePtr->wayPriority[chNo].eraseHead = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].eraseTail = WAY_NONE;
    }
}

Here is the caller graph for this function:

SelectiveGetFromNandReadTransferList()

void SelectiveGetFromNandReadTransferList	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Remove the specified die from the read transfer list of its channel.

Similar to SelectivGetFromNandIdleList(), but with different target list.

Parameters

chNo	the channel number of target die
wayNo	the way number of target die

Definition at line 822 of file request_schedule.c.

{
    if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay != WAY_NONE) &&
        (dieStateTablePtr->dieState[chNo][wayNo].prevWay != WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].prevWay].nextWay =
            dieStateTablePtr->dieState[chNo][wayNo].nextWay;
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].nextWay].prevWay =
            dieStateTablePtr->dieState[chNo][wayNo].prevWay;
    }
    else if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay == WAY_NONE) &&
             (dieStateTablePtr->dieState[chNo][wayNo].prevWay != WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].prevWay].nextWay = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].readTransferTail = dieStateTablePtr->dieState[chNo][wayNo].prevWay;
    }
    else if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay != WAY_NONE) &&
             (dieStateTablePtr->dieState[chNo][wayNo].prevWay == WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].nextWay].prevWay = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].readTransferHead = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
    }
    else
    {
        wayPriorityTablePtr->wayPriority[chNo].readTransferHead = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].readTransferTail = WAY_NONE;
    }
}

Here is the caller graph for this function:

SelectiveGetFromNandReadTriggerList()

void SelectiveGetFromNandReadTriggerList	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Remove the specified die from the read trigger list of its channel.

Similar to SelectivGetFromNandIdleList(), but with different target list.

Parameters

chNo	the channel number of target die
wayNo	the way number of target die

Definition at line 696 of file request_schedule.c.

{
    if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay != WAY_NONE) &&
        (dieStateTablePtr->dieState[chNo][wayNo].prevWay != WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].prevWay].nextWay =
            dieStateTablePtr->dieState[chNo][wayNo].nextWay;
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].nextWay].prevWay =
            dieStateTablePtr->dieState[chNo][wayNo].prevWay;
    }
    else if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay == WAY_NONE) &&
             (dieStateTablePtr->dieState[chNo][wayNo].prevWay != WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].prevWay].nextWay = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].readTriggerTail = dieStateTablePtr->dieState[chNo][wayNo].prevWay;
    }
    else if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay != WAY_NONE) &&
             (dieStateTablePtr->dieState[chNo][wayNo].prevWay == WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].nextWay].prevWay = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].readTriggerHead = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
    }
    else
    {
        wayPriorityTablePtr->wayPriority[chNo].readTriggerHead = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].readTriggerTail = WAY_NONE;
    }
}

Here is the caller graph for this function:

SelectiveGetFromNandStatusCheckList()

void SelectiveGetFromNandStatusCheckList	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Remove the specified die from the status check list of its channel.

Similar to SelectivGetFromNandIdleList(), but with different target list.

Parameters

chNo	the channel number of target die
wayNo	the way number of target die

Definition at line 948 of file request_schedule.c.

{
    if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay != WAY_NONE) &&
        (dieStateTablePtr->dieState[chNo][wayNo].prevWay != WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].prevWay].nextWay =
            dieStateTablePtr->dieState[chNo][wayNo].nextWay;
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].nextWay].prevWay =
            dieStateTablePtr->dieState[chNo][wayNo].prevWay;
    }
    else if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay == WAY_NONE) &&
             (dieStateTablePtr->dieState[chNo][wayNo].prevWay != WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].prevWay].nextWay = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].statusCheckTail = dieStateTablePtr->dieState[chNo][wayNo].prevWay;
    }
    else if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay != WAY_NONE) &&
             (dieStateTablePtr->dieState[chNo][wayNo].prevWay == WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].nextWay].prevWay = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].statusCheckHead = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
    }
    else
    {
        wayPriorityTablePtr->wayPriority[chNo].statusCheckHead = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].statusCheckTail = WAY_NONE;
    }
}

Here is the caller graph for this function:

SelectiveGetFromNandWriteList()

void SelectiveGetFromNandWriteList	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Remove the specified die from the write list of its channel.

Similar to SelectivGetFromNandIdleList(), but with different target list.

Parameters

chNo	the channel number of target die
wayNo	the way number of target die

Definition at line 759 of file request_schedule.c.

{
    if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay != WAY_NONE) &&
        (dieStateTablePtr->dieState[chNo][wayNo].prevWay != WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].prevWay].nextWay =
            dieStateTablePtr->dieState[chNo][wayNo].nextWay;
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].nextWay].prevWay =
            dieStateTablePtr->dieState[chNo][wayNo].prevWay;
    }
    else if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay == WAY_NONE) &&
             (dieStateTablePtr->dieState[chNo][wayNo].prevWay != WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].prevWay].nextWay = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].writeTail = dieStateTablePtr->dieState[chNo][wayNo].prevWay;
    }
    else if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay != WAY_NONE) &&
             (dieStateTablePtr->dieState[chNo][wayNo].prevWay == WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].nextWay].prevWay = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].writeHead = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
    }
    else
    {
        wayPriorityTablePtr->wayPriority[chNo].writeHead = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].writeTail = WAY_NONE;
    }
}

Here is the caller graph for this function:

SelectivGetFromNandIdleList()

void SelectivGetFromNandIdleList	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Remove the specified die from the idle list of its channel.

Since the state lists only records the index of head/tail way in their list, there is no need to modify the wayPriority if the target way is at the body of its idle list.

Note

Like PutToNandIdleList(), this function won't change reqStatusCheckOpt and dieState too.

Warning

function name typo

Parameters

chNo	the channel number of target die
wayNo	the way number of target die

Definition at line 568 of file request_schedule.c.

{
    if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay != WAY_NONE) &&
        (dieStateTablePtr->dieState[chNo][wayNo].prevWay != WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].prevWay].nextWay =
            dieStateTablePtr->dieState[chNo][wayNo].nextWay;
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].nextWay].prevWay =
            dieStateTablePtr->dieState[chNo][wayNo].prevWay;
    }
    else if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay == WAY_NONE) &&
             (dieStateTablePtr->dieState[chNo][wayNo].prevWay != WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].prevWay].nextWay = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].idleTail = dieStateTablePtr->dieState[chNo][wayNo].prevWay;
    }
    else if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay != WAY_NONE) &&
             (dieStateTablePtr->dieState[chNo][wayNo].prevWay == WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].nextWay].prevWay = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].idleHead = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
    }
    else
    {
        wayPriorityTablePtr->wayPriority[chNo].idleHead = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].idleTail = WAY_NONE;
    }
}

Here is the caller graph for this function:

SelectivGetFromNandStatusReportList()

void SelectivGetFromNandStatusReportList	(	unsigned int	chNo,
		unsigned int	wayNo
	)

Remove the specified die from the status report list of its channel.

Similar to SelectivGetFromNandIdleList(), but with different target list.

Warning

function name typo

Parameters

chNo	the channel number of target die
wayNo	the way number of target die

Definition at line 633 of file request_schedule.c.

{
    if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay != WAY_NONE) &&
        (dieStateTablePtr->dieState[chNo][wayNo].prevWay != WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].prevWay].nextWay =
            dieStateTablePtr->dieState[chNo][wayNo].nextWay;
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].nextWay].prevWay =
            dieStateTablePtr->dieState[chNo][wayNo].prevWay;
    }
    else if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay == WAY_NONE) &&
             (dieStateTablePtr->dieState[chNo][wayNo].prevWay != WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].prevWay].nextWay = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].statusReportTail = dieStateTablePtr->dieState[chNo][wayNo].prevWay;
    }
    else if ((dieStateTablePtr->dieState[chNo][wayNo].nextWay != WAY_NONE) &&
             (dieStateTablePtr->dieState[chNo][wayNo].prevWay == WAY_NONE))
    {
        dieStateTablePtr->dieState[chNo][dieStateTablePtr->dieState[chNo][wayNo].nextWay].prevWay = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].statusReportHead = dieStateTablePtr->dieState[chNo][wayNo].nextWay;
    }
    else
    {
        wayPriorityTablePtr->wayPriority[chNo].statusReportHead = WAY_NONE;
        wayPriorityTablePtr->wayPriority[chNo].statusReportTail = WAY_NONE;
    }
}

Here is the caller graph for this function:

SyncAllLowLevelReqDone()

void SyncAllLowLevelReqDone

(

)

Do schedule until all the requests are done.

As mentioned in the paper, the NVMe requests have higher priority than NAND requests. Therefore the function that handles NVMe request CheckDoneNvmeDmaReq() should be called before the function for scheduling NAND requests SchedulingNandReq().

Definition at line 135 of file request_schedule.c.

{
    while ((nvmeDmaReqQ.headReq != REQ_SLOT_TAG_NONE) || notCompletedNandReqCnt || blockedReqCnt)
    {
        CheckDoneNvmeDmaReq();
        SchedulingNandReq();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SyncAvailFreeReq()

void SyncAvailFreeReq

(

)

Try release request entries by doing scheduling (both NVMe and NAND).

Similar to SyncAllLowLevelReqDone(), but this function will stop at there is at least one free request entry exists.

Definition at line 150 of file request_schedule.c.

{
    while (freeReqQ.headReq == REQ_SLOT_TAG_NONE)
    {
        CheckDoneNvmeDmaReq();
        SchedulingNandReq();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SyncReleaseEraseReq()

void SyncReleaseEraseReq	(	unsigned int	chNo,
		unsigned int	wayNo,
		unsigned int	blockNo
	)

Issuing requests until the specified block can be erased.

Sometimes, a request on a block may be blocked by the previous erase request on the same block. However, the erase request may also blocked by the previous read requests.

So, this function will try to release the pending requests on the specified block that is blocked by the pending erase request.

See also

CheckRowAddrDep(), UpdateRowAddrDepTableForBufBlockedReq().

Parameters

chNo	The channel number of the target block.
wayNo	The way number of the target channel.
blockNo	The block number of the target die.

Definition at line 174 of file request_schedule.c.

{
    while (rowAddrDependencyTablePtr->block[chNo][wayNo][blockNo].blockedEraseReqFlag)
    {
        CheckDoneNvmeDmaReq();
        SchedulingNandReq();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

completeFlagTablePtr

P_COMPLETE_FLAG_TABLE completeFlagTablePtr

extern

Definition at line 54 of file request_schedule.c.

dieStatusTablePtr

P_DIE_STATE_TABLE dieStatusTablePtr

extern

eccErrorInfoTablePtr

P_ERROR_INFO_TABLE eccErrorInfoTablePtr

extern

Definition at line 56 of file request_schedule.c.

retryLimitTablePtr

P_RETRY_LIMIT_TABLE retryLimitTablePtr

extern

Definition at line 57 of file request_schedule.c.

statusReportTablePtr

P_STATUS_REPORT_TABLE statusReportTablePtr

extern

Definition at line 55 of file request_schedule.c.

wayPriorityTablePtr

P_WAY_PRIORITY_TABLE wayPriorityTablePtr

extern

Definition at line 60 of file request_schedule.c.