CN116185892A

CN116185892A - Flash memory controller and method for accessing flash memory particles

Info

Publication number: CN116185892A
Application number: CN202310471973.2A
Authority: CN
Inventors: 刘弋波; 赖鼐; 龚晖
Original assignee: Zhuhai Miaocun Technology Co ltd
Current assignee: Zhuhai Miaocun Technology Co ltd
Priority date: 2023-04-27
Filing date: 2023-04-27
Publication date: 2023-05-30
Anticipated expiration: 2043-04-27
Also published as: CN116185892B

Abstract

The invention discloses a flash memory controller and a method for accessing flash memory particles, and relates to the technical field of flash memories. The flash memory controller includes: a descriptor queue for retrieving and storing descriptors; the task scheduler is used for scheduling the descriptors which meet the scheduling conditions in the descriptor queue; the task analyzer is used for analyzing the descriptors scheduled by the task scheduler to form a plurality of control instructions; the execution unit is used for executing access operation to the flash memory particles according to the plurality of control instructions; and the suspension waiting area is used for storing the descriptors in the suspension waiting area when the time for waiting the execution result of the execution unit by the control instruction exceeds the preset time, so that the task analyzer pauses the subsequent analysis tasks of the descriptors and the task scheduler schedules the descriptors corresponding to other CE/LUNs meeting the scheduling conditions. According to the flash memory controller provided by the invention, the burden and the expenditure of a CPU can be reduced.

Description

Flash memory controller and method for accessing flash memory particles

Technical Field

The present invention relates to the field of flash memory technologies, and in particular, to a flash memory controller and a method for accessing flash memory particles.

Background

In the design of a traditional Nand Flash controller, a CPU controls and drives access operation of hardware to Nand Flash particles in a mode of directly configuring a register, for example, command and address are sent through Nand IO, data read-write operation is carried out, and a DMA module of the controller is instructed to move data to a system cache and the like. The software almost participates in the control and command of each specific task of the Nand Flash controller, and a large number of registers need to be configured in a complicated way, so that heavy load and expenditure are brought to a CPU, and the control and command become barriers for further improving performance and energy efficiency.

Disclosure of Invention

The present invention aims to solve at least one of the technical problems existing in the prior art. Therefore, the invention provides a flash memory controller and a method for accessing flash memory particles, which can reduce the burden and the expenditure of a CPU.

In one aspect, a flash memory controller according to an embodiment of the present invention includes:

a descriptor queue for retrieving and storing descriptors; the descriptor specifies CE/LUN information of the flash memory grain being accessed;

the task scheduler is used for scheduling the descriptors meeting the scheduling conditions in the descriptor queue;

the task analyzer is used for analyzing the descriptors scheduled by the task scheduler to form a plurality of control instructions;

The execution unit is used for executing the access operation to the flash memory particles according to the plurality of control instructions;

and a suspension waiting area, configured to, when the time that the control instruction needs to wait for the execution result of the execution unit exceeds a preset time, suspend the description Fu Cunfang in the suspension waiting area, so that the task parser pauses the task for subsequent parsing of the descriptor, and enable the task scheduler to schedule descriptors corresponding to other CEs/LUNs that meet a scheduling condition.

According to some embodiments of the invention, the execution unit comprises:

internal caching;

the FCU is used for executing access operation to the flash memory particles through Nand IO;

RDMA, which is used for reading out the specified number of data from the specified address in the system cache and sending the data to the internal cache;

WDMA, used for writing the state information of the specified quantity of data or descriptors in the internal cache into the specified address of the system cache.

According to some embodiments of the invention, the execution unit further comprises an error correction engine for error correcting the data.

According to some embodiments of the invention, the flash memory controller further comprises a register module, and the CPU is capable of implementing an access operation to the flash memory granule by configuring a register in the register module.

In another aspect, a method for accessing flash memory particles by a flash memory controller according to an embodiment of the present invention includes the following steps:

the descriptor queue obtains and stores descriptors; the descriptor specifies CE/LUN information of the flash memory grain being accessed;

the task scheduler schedules out the descriptors meeting the scheduling conditions in the descriptor queue;

the task analyzer analyzes the descriptors scheduled by the task scheduler to form a plurality of control instructions;

the execution unit executes access operation to the flash memory particles according to the plurality of control instructions;

when the time of the control instruction needing to wait for the execution result of the execution unit exceeds the preset time, storing the descriptors in a suspension waiting area, enabling the task analyzer to suspend the subsequent analysis tasks of the descriptors, enabling the task scheduler to schedule the descriptors corresponding to other CE/LUNs meeting the scheduling conditions, and returning to the step that the task analyzer analyzes the descriptors scheduled by the task scheduler to form a plurality of control instructions.

According to some embodiments of the invention, the descriptor queue includes a head pointer and a tail pointer, the tail pointer being incremented by 1 when a descriptor enters the descriptor queue and the head pointer being incremented by 1 when a descriptor leaves the descriptor queue; when the descriptor is in the unit pointed by the head pointer and the descriptor completes all scheduling and parsing tasks, the descriptor leaves the descriptor queue.

According to some embodiments of the invention, the descriptor includes an OPCODE pointer; the task scheduler further comprises the following steps after the step of scheduling out the descriptors meeting the conditions in the descriptor queue:

and searching a corresponding task sequence from an OPCODE table according to the scheduled OPCODE pointer of the descriptor, and sending the task sequence and the descriptor to the task analyzer.

According to some embodiments of the invention, the task sequence includes one or more of four types of tasks, a DMA start type, a suspend wait type, an FCU instruction type, and an end type; the task analyzer analyzes the descriptors scheduled by the task scheduler to form a plurality of control instructions, and the method comprises the following steps:

if the task type is a DMA start type, the task analyzer analyzes the descriptor to generate an RDMA or WDMA start instruction;

or if the task type is a suspension waiting type, the task analyzer stores the descriptor in the suspension waiting area and pauses the subsequent analysis action of the descriptor;

or if the type of the task is FCU instruction type, the task analyzer reads parameters and command sets in a command table according to the task and generates an instruction for accessing flash memory particles according to the parameters and command sets;

Or if the type of the task is an ending type, the task analyzer generates an instruction for updating the state of the descriptor to the designated position of the system cache, and ends the analysis task of the whole descriptor.

According to some embodiments of the invention, the pending wait area records a pending state of the CE/LUN corresponding to the descriptor stored in the pending wait area, a pending exit condition of the descriptor, and a position in the OPCODE table at which the task sequence is pending.

According to some embodiments of the invention, the method further comprises the steps of:

when the execution unit feeds back a signal meeting a suspension exit condition, the task scheduler schedules out the descriptors of the suspension waiting area when idle, and sends the descriptors to the task analyzer to perform subsequent analysis work.

The flash memory controller and the method for accessing the flash memory particles have at least the following beneficial effects: the mode of realizing Nand Flash access based on the descriptor is adopted, and task scheduling and analysis work of the descriptor are all executed by a hardware module, so that the cost of software and the load of a CPU can be greatly reduced. Meanwhile, by setting the suspension waiting area, the parallelism of simultaneous access of Nand Flash particles under multiple CEs/LUNs and the utilization rate of Nand IO are improved.

Additional aspects and advantages of the invention will be set forth in part in the description which follows, and in part will be obvious from the description, or may be learned by practice of the invention.

Drawings

The foregoing and/or additional aspects and advantages of the invention will become apparent and may be better understood from the following description of embodiments taken in conjunction with the accompanying drawings in which:

FIG. 1 is a schematic diagram of a flash memory controller according to an embodiment of the present invention;

FIG. 2 is a schematic diagram of a descriptor according to an embodiment of the present invention;

FIG. 3 is a schematic diagram of a descriptor chain according to an embodiment of the present invention;

FIG. 4 is a schematic diagram of the overall structure of a flash memory access system according to an embodiment of the present invention;

FIG. 5 is a schematic diagram of ROM and SRAM structures according to an embodiment of the present invention;

FIG. 6 is a flowchart illustrating steps of a method for accessing flash memory particles by a flash memory controller according to an embodiment of the present invention.

Detailed Description

Reference will now be made in detail to the present embodiments of the present invention, examples of which are illustrated in the accompanying drawings, wherein the accompanying drawings are used to supplement the description of the written description so that one can intuitively and intuitively understand each technical feature and overall technical scheme of the present invention, but not to limit the scope of the present invention.

In the description of the present invention, a number means one or more, a number means two or more, and greater than, less than, exceeding, etc. are understood to not include the present number, and above, below, within, etc. are understood to include the present number. The description of the first and second is for the purpose of distinguishing between technical features only and should not be construed as indicating or implying relative importance or implicitly indicating the number of technical features indicated or implicitly indicating the precedence of the technical features indicated.

In the description of the present invention, unless explicitly defined otherwise, terms such as arrangement, installation, connection, etc. should be construed broadly and the specific meaning of the terms in the present invention can be reasonably determined by a person skilled in the art in combination with the specific contents of the technical scheme.

Nand Flash: flash refers to Flash memory, which is a nonvolatile memory capable of being rapidly erased and programmed by electricity, and Flash can be divided into Nor Flash and Nand Flash from the chip technology. The Nand Flash memory is a Flash memory, and a nonlinear macro unit mode is adopted in the Nand Flash memory, so that a cheap and effective solution is provided for the realization of a solid-state large-capacity memory. The Nand Flash memory has the advantages of larger capacity, high rewriting speed and the like, and is suitable for storing a large amount of data, so that the Nand Flash memory is increasingly widely applied in industry, such as embedded products including digital cameras, MP3 walkman memory cards, small-sized U discs and the like.

DMA: direct Memory Access direct memory access, which is a function provided by some computer bus architectures, enables data to be sent directly from an attached device to the memory of a computer motherboard.

OPCODE: operation Code, an Operation Code, is used to describe the portion of machine language instructions that specify certain operations to be performed, and the instruction format and specification that make up the Operation Code are specified by the processor.

eMMC: embedded Multi Media Card, an embedded multimedia card, is an embedded memory standard specification defined by the MMC society and mainly aimed at products such as mobile phones or tablet computers. The eMMC is an embedded non-volatile memory system, mainly comprising a flash memory, a flash memory controller, an eMMC protocol interface and the like, defines the physical architecture, an access interface and a protocol of the memory system based on an embedded multimedia card, has the advantages of small volume, low power consumption, large capacity and the like, and is very suitable for being used as a memory medium of electronic equipment such as a smart phone, a tablet personal computer, mobile internet equipment and the like.

UFS: universal Flash storage, general flash memory storage, is a flash memory storage specification designed for consumer electronics such as digital cameras, smartphones, and the like. The design goal is to develop a unified flash memory card format that provides high data transfer speed and stability while also reducing consumer confusion for various memory card formats and the use of different memory card adapters on the market.

SSD: solid State Disk, also called Solid State drive, is a hard Disk made of Solid State electronic memory chip array.

SRAM: static Random-Access Memory, static Random Access Memory, is one type of Random Access Memory. The memory can always hold the data stored therein as long as the memory is kept powered on.

DDR: double Data Rate, double Rate synchronous dynamic random access memory.

Therefore, a mode of realizing NAND Flash access based on descriptors is adopted, so that the cost of software and the burden of a CPU can be greatly reduced; in the design of a NAND Flash controller (hereinafter referred to as a Flash controller), the scheduling and analyzing work of the descriptors are all executed by a hardware module, and compared with the traditional mode of directly configuring an internal register of the Flash controller by a CPU to drive hardware to access NAND Flash particles (hereinafter referred to as Flash particles), in the mode, a software layer only needs to construct the descriptors at a very high abstraction level, and does not need to care about hardware implementation details in the Flash controller too much, so that the cost of software and the burden of the CPU are greatly reduced; meanwhile, the parallelism of simultaneous access of Nand Flash particles under multiple CEs/LUNs and the utilization rate of Nand IO can be improved. Each Nand Flash may have a plurality of CEs (independent chip select units), and each CE may have a plurality of LUNs (Logical Unit Number, logical unit numbers), where a LUN is the smallest independent unit that can execute commands in the Flash memory and report its own status.

The descriptor is a data structure constructed by a software layer and is used for describing access tasks to Nand Flash, such as erasure of Block (Block: block, minimum erasure unit of Flash memory, flash memory is composed of a plurality of blocks), reading and writing of Nand Page and the like (Page: page, minimum unit capable of being read and written in Flash memory, one Block contains a plurality of pages), any common access operation can be realized by one descriptor or a plurality of descriptors, and software can create different descriptors in a flexible way to adapt to various scene requirements.

As shown in FIG. 2, in some embodiments of the invention, a descriptor is made up of multiple domains, one each of OPCODE pointer, CE/LUN information, nand Flash address, system cache address, hardware control information, and the next descriptor address. The OPCODE pointer is an index number of the OPCODE table to be described below, and the task scheduler of the flash memory controller searches the corresponding task sequence from the OPCODE table according to the pointer to schedule and send the task sequence to a subsequent module for analysis and execution. The CE/LUN information refers to CE and LUN information of Flash memory particles to be accessed in the descriptor, and each Nand Flash can have a plurality of CEs, and each CE can have a plurality of LUNs. The Nand Flash address refers to an address (block, page address, etc.) where the descriptor also needs to specify the Flash granule to be accessed. The system cache address refers to a destination address where the descriptor needs to specify the system cache address, for example, for a read operation of Nand Flash, the hardware needs to read data from a Page of Nand Flash granule and then move the data to the system cache. In addition, hardware control information can be added in the descriptor, and the hardware control information is used for guiding the hardware to flexibly execute according to a mode of software requirements so as to meet the requirements of different application scenes. Finally, as shown in FIG. 3, the descriptors typically appear in a chain, so that the descriptors also specify where the next descriptor is in the system cache.

As shown in fig. 4, according to the flash access system of the embodiment of the present invention, after the software creates the descriptor through the CPU, the descriptor is written into the system cache (eMMC and UFS type controller chips may use SRAM to make system cache, SSD may also use DDR to make system cache), and the first address of the descriptor chain formed by a plurality of descriptors is written into the Entry register of the descriptor reader, and the Fetch module reads out the descriptors of the descriptor chain one by one and sends them to the descriptor queue of the flash controller according to the first address. It should be noted that the present design supports one to multiple Nand Flash channel schemes, one Flash controller for each channel, only two Flash controller channels are shown in fig. 4. And the flash memory controller schedules and analyzes the descriptors in the descriptor queue, thereby realizing access operation to flash memory particles and data movement work between the flash memory particles and a system cache. The flash memory controller realizes the access to flash memory particles through Nand IO, and accesses the bus and the system cache through DMA.

Referring to fig. 1, a flash memory controller according to an embodiment of the present invention is described in detail, and includes:

Specifically, as shown in fig. 1, the flash memory controller is composed of a front-stage module and a rear-stage module, wherein the front-stage module is used for performing task scheduling and analysis on the descriptors, and then sending control instructions to the rear-stage module for execution, which can be understood that the front-stage module is a control center, the rear-stage module is an execution unit, and the front-stage module sends the control instructions to control and command the operation of the rear-stage module.

The front-end module comprises a descriptor queue, a task scheduler, a task parser and a suspension waiting area. After the descriptor reader reads the descriptor from the system cache, the descriptor is sent to a descriptor queue of the flash memory controller for waiting, and the queue can store a plurality of descriptors, so that a space for realizing the parallel access of multiple CEs/LUNs is provided for a task scheduler. And when the task scheduler is idle, selecting candidate descriptors meeting the scheduling conditions from the descriptor queue, scheduling the candidate descriptors, sending the candidate descriptors to a task analyzer for analysis, and sending a control instruction generated after analysis to a hardware unit (FCU, WDMA, RDMA) corresponding to a later-stage module for execution. Wherein FCU refers to Flash Control Unit, flash memory control unit; WDMA refers to Write DMA, write DMA; RDMA refers to Read DMA, read DMA.

The task scheduler relies on an OPCODE table that stores a number of different combinations of task sequences for use in creating descriptors for the software, the OPCODE pointer in each descriptor pointing to a particular task sequence in the OPCODE table for use in implementing different access operations to the flash memory.

The task parser typically needs to complete work with the help of a command table when parsing control instructions to the execution units are generated, where the parsed instructions include access operations to Nand grains through FCU and Nand IO (e.g., sending commands, addresses, and performing data read and write operations, erasing, status queries, etc.), RDMA and WDMA start instructions, and instructions to update descriptor status to system cache, etc.

For a descriptor, a plurality of control instructions are generated after the descriptor is parsed, not every control instruction can be executed immediately, and some control instructions need to be executed for a long time, for example, a certain control instruction requires RDMA to read a sufficient amount of data from a system cache to an internal cache of a later module, if the descriptor is always waited for to be parsed and executed, other descriptors are parsed and executed, and the utilization rate of Nand IO is low. In order to improve the utilization rate and access efficiency of Nand IO, in the example of the present invention, a suspension waiting area is further designed in the front module, so that the characteristic that different CE/LUNs of Nand Flash particles can be accessed in parallel is fully utilized, after a control instruction needing to wait for an execution result for a long time is sent to the rear module, the subsequent task analysis action of the descriptor is suspended, the task analyzer notifies the suspension waiting area to record the execution state of the current CE/LUN, suspension exit waiting condition, the current position of a task sequence in an OPCODE table, etc., and then resources are yielded to execute the scheduling and analysis work of the descriptors under other CE/LUNs, thereby realizing the parallel access to different CE/LUNs of Nand Flash particles and improving the utilization efficiency of Nand IO. After the post module feeds back the signal meeting the suspension exit condition to the suspension waiting area, the descriptor task suspended under the corresponding CE/LUN can be then scheduled again to be sent to the task analyzer for further analysis and execution.

As shown in fig. 1, in this example, the execution unit includes an internal cache, FCU, RDMA, WDMA, and an error correction engine, wherein:

after the FCU obtains the control instruction of the task resolver from the previous module, the Nand Flash granule is accessed through the Nand IO, and the instruction sent to the FCU by the task resolver needs to provide enough information, including specific commands, block/Page addresses, and the like.

After RDMA receives a control instruction sent by a task analyzer of a front-stage module, reading specified quantity of data from a specified address in a system cache and sending the read data to an internal cache of a rear-stage module; WDMA writes the state information of the appointed amount of data or descriptors in the internal cache of the later module into the appointed address of the system cache according to the control instruction.

The error correction engine is used for realizing the encoding and decoding of data error correction of BCH (the BCH code is a multi-stage, cyclic, error correction and variable length digital coding for correcting a plurality of random error modes) or LDPC (a parity check code, which is a simple and widely adopted method for increasing the minimum distance of a binary transmission system, and a coding method for enabling the number of '1's in a codeword to be constant odd or even by adding redundancy bits), so as to solve the reliability problem of data storage in Nand Flash particles.

In addition, the flash memory controller of the design also comprises a register module, so that the flash memory controller can still bypass the front-stage module by a mode of configuring the register module through a CPU to generate instructions to control FCU, WDMA and RDMA to work, thereby realizing the operation of a traditional non-descriptor mode, and being capable of being used for debugging and other purposes.

According to the Flash memory controller provided by the embodiment of the invention, a mode of realizing Nand Flash access based on the descriptor is adopted, and task scheduling and analysis work of the descriptor are all executed by the hardware module, so that the cost of software and the load of a CPU can be greatly reduced. Meanwhile, by setting the suspension waiting area, the parallelism of simultaneous access of Nand Flash particles under multiple CEs/LUNs and the utilization rate of Nand IO are improved.

In the front-end module, there is a block of buffer (i.e., descriptor queue) for receiving descriptors from the descriptor reader, which may store multiple descriptors, providing space for the task scheduler to implement multiple CE/LUNs parallel access.

/>

Table 1 descriptor queue case

Referring to Table 1, one example of a descriptor queue is shown. The descriptor queue for storing descriptors may employ a circular queue design to implement push (enqueue) and pop (dequeue) operations of the descriptor queue, and queue management, such as determining empty and full of the queue by a relationship of physical locations of cache units pointed to by head/tail pointers. The tail pointer (tail pointer) is automatically incremented by 1 when a new descriptor push comes in, and the head pointer (head pointer) is automatically incremented by 1 when a descriptor pop goes out. It should be noted that if a descriptor at a location has completed all scheduling and parsing (i.e., state done), but it is not in the location pointed to by the head pointer, the pop condition is not met and it must wait for the previous descriptor to be all popped out of itself before it can be popped. For example, in the case of table 1, the descriptor with physical location 5 is already in done's state, but since the physical location of the location pointed to by the head pointer is 3, the descriptor does not meet the condition of being pop.

The descriptor queues are scheduled for execution in substantially the order from head to tail, from beginning to end, although out-of-order scheduling may be implemented in some cases. Each LUN under each CE belongs to the minimum storage unit for executing Nand Flash access operation, and the storage units under the same CE/LUN cannot be accessed out-of-order and can only be executed in sequence, but descriptors for accessing the storage units under different CEs/LUNs can be scheduled out-of-order to realize parallel access, so that the utilization rate of Nand IO is improved. For example, the descriptor pointed by the head pointer in table 1 (physical location is 3) is in a running state (in scheduling) at this time, and in parsing and executing, a long-time waiting for the feedback result of the later module is encountered, so that the descriptor may be registered in the pending waiting area of the earlier module and suspend the subsequent parsing action, at this time, the task scheduler has a space to find whether a candidate (pending state) meeting the scheduling condition exists from the next unit (physical location is 4) in the descriptor queue, but in the case, the access object of the descriptor pointed by the head pointer and the descriptor pointed by the physical location 4 both belong to the same CE/LUN, do not meet the scheduling condition, the task scheduler continues to find the state that the descriptor pointed by the physical location is done, the descriptor pointed by the physical location is 6 is in pending state, and the CE/LUN of the access object is different from the previous descriptor and can be scheduled.

Each descriptor has an OPCODE pointer, and after a candidate descriptor in the descriptor queue of the previous module is scheduled, the task scheduler reads a series of task sequences according to the pointer to the corresponding position in the OPCODE table to parse and execute.

TABLE 2 OPCODE table virtual case

Table 2 is a virtual case of an OPCODE table where each cell or cells can construct a complete task sequence, e.g., one task sequence for each of the positions pointed to by pointers 3 and 4, and are of different lengths. The task sequence with the OPCODE pointer 5 position occupies two units.

Let us take the OPCODE pointer 3 as an example to illustrate how a descriptor is scheduled to execute, its stored task sequence is assumed to be AA- > BB- >20- > CC- > FF, in this virtual case AA represents that RDMA needs to read data from the system cache to the internal cache of the later module, because this time needs to wait longer, BB represents that the task sequence of the current descriptor needs to register to the suspension wait area until the later module feeds back that RDMA has read a sufficient amount of data to the internal cache, and this waiting period the task scheduler can de-schedule another descriptor to execute, thereby improving parallelism. After the data is read, the task scheduler continues to read the task represented by 20 and sends the task to the task parser for parsing, assuming that the task represents that the FCU of the later module needs to be controlled to access the Nand Flash granule through the Nand IO, the task parser parses the content pointed to by 20 in the command table and sends the control command to the FCU after parsing the content in combination with the current descriptor, the command represents that the data needing to be cached in the internal is sent to a certain page of the Nand Flash through the command mode specified in the command table, the CC represents that the data needs to be registered again in the suspension waiting area until the Nand Flash granule returns to the completion signal, because the waiting time is long, the middle is allowed to execute scheduling and parsing of other descriptors again, the FF represents that the task of the descriptor is all ended, and sends the control command to the WDMA of the later module, and the WDMA needs to write the state of the descriptor to the specified position of the system cache.

Table 3 pending wait area data structure case

Table 3 shows a data structure case of the pending area, whether the storage unit record under each CE/LUN combination is in pending state, the exit condition (pending event) after pending, whether the exit condition is satisfied, and the location in the OPCODE table where it was suspended. When the task analyzer encounters a task sent by the task scheduler and representing a suspension action, the "state" is set to "suspension" after finding a corresponding unit in the suspension waiting area according to the CE/LUN value, and a "suspension exit condition" is recorded, such as waiting for an RB signal ready, or waiting for RDMA to read a sufficient amount of data to an internal cache, or other conditions, whether the "exit condition" satisfies "set to" NO ", and the position of the OPCODE table when the task sequence is suspended is recorded, including an OPCODE pointer and an offset in the current unit.

After a period of waiting, the latter module returns a standard signal indicating that the exit condition is satisfied after waiting for suspension, and the task scheduler reschedules the suspended descriptor task when idle, and then continues to execute according to the recorded position of the suspension waiting area.

TABLE 4 Command representing intent

Table 4 shows the intent of the command to generate an FCU instruction to the execution unit, and if the task sent by the task scheduler is to parse and generate the FCU instruction, the task is a CMD pointer at this time, and the data content of the pointer corresponding to the pointer is read in the CMD table, and the latter is various parameters and CMD SET. The task parser parses according to the following several types:

1) DMA start type: reading content analysis such as a system cache address in the descriptor to generate an RDMA or WDMA starting instruction;

2) Type of hold wait: no instruction is generated, a corresponding unit registration suspension state of a suspension waiting area is found according to the CE/LUN, and an exit waiting condition and a task sequence suspension position are recorded;

3) FCU instruction type: the task is a command table pointer, reads corresponding parameters and command sets in the command table according to the pointer, reads descriptor content at the same time, and generates an FCU instruction according to the configuration of a register;

4) End type: instructions are generated to update the descriptor state to the system cache specified address and the task of the entire descriptor is ended.

In order to support different types of Nand Flash granules from different manufacturers, the OPCODE table and the command table used for task scheduling and parsing in the front-end module need to store a large amount of content, and in order to save the area of the storage module and the large initialization time, a ROM (Read-only Memory) with a large capacity is generally used to store the content. However, in the life cycle of the actual chip product, new application requirements may appear, such as new particle type support, or some entries in the table are found to have errors, and the chip design modification is costly; therefore, the embodiment of the invention adopts the SRAM with small capacity for expansion or replacement, as shown in fig. 5, three new entries are written into the SRAM, two of the three new entries are used for expansion of functions and application scenes, and one of the three new entries is used for replacing the error entry in the ROM, because the number of the new entries is usually smaller, and the time for initializing and loading is short. In practice, the software only needs to configure a register to tell the number of OPCODE and command entries stored in ROM, and when the OPCODE pointer or command pointer exceeds a specified number, the task scheduler and parser module will read the new entry from the expansion SRAM.

On the other hand, as shown in fig. 6, the embodiment of the invention further provides a method for accessing flash memory particles by a flash memory controller, which comprises the following steps:

step S100: the descriptor queue obtains and stores descriptors; the descriptor specifies CE/LUN information of the flash memory grain being accessed;

step S200: the task scheduler schedules out the descriptors meeting the scheduling conditions in the descriptor queue;

step S300: the task analyzer analyzes the descriptors scheduled by the task scheduler to form a plurality of control instructions;

step S400: the execution unit executes access operation to the flash memory particles according to the plurality of control instructions;

step S500: when the control instruction needs to wait for the execution result of the execution unit for more than a preset time (the specific duration can be determined according to the actual situation), storing the descriptor in a suspension waiting area, enabling the task analyzer to suspend the subsequent analysis task of the descriptor, enabling the task scheduler to schedule the descriptors corresponding to other CEs/LUNs meeting the scheduling conditions, and returning to step S300.

Specifically, for the above step S100, as shown in fig. 2, in some embodiments of the present invention, one descriptor is composed of a plurality of fields, which are an OPCODE pointer, CE/LUN information, nand Flash address, system cache address, hardware control information, and the next descriptor address, respectively. As shown in fig. 3, the descriptors typically appear in a chain, so that the descriptors specify where the next descriptor is in the system cache. After the software creates the descriptors through the CPU, the descriptors are written into the system cache, and the first address of the descriptor chain formed by a plurality of descriptors is written into the Entry register of the descriptor reader, and the Fetch module reads out the descriptors of the descriptor chain one by one according to the first address and sends the descriptors to the descriptor queue of the flash memory controller.

For the above step S100, the flash controller receives the descriptor sent from the descriptor reader through the descriptor queue, and this queue can store a plurality of descriptors, so as to provide space for the task scheduler to realize parallel access of a plurality of CEs/LUNs.

Table 1 descriptor queue case

Referring to Table 1, one example of a descriptor queue is shown. The descriptor queue for storing descriptors may employ a circular queue design to implement push (enqueue) and pop (dequeue) operations of the descriptor queue, and queue management, such as determining empty and full of the queue by a relationship of physical locations of cache units pointed to by head/tail pointers. The tail pointer (tail pointer) is automatically incremented by 1 when a new descriptor push comes in, and the head pointer (head pointer) is automatically incremented by 1 when a descriptor pop goes out. It should be noted that if a descriptor at a location has completed all scheduling and parsing (i.e., state done), but it is not in the location pointed to by the head pointer, the pop condition is not met and it must wait for the previous descriptor to be all popped out of itself before it can be popped. For example, in the case of table 1, the descriptor with physical location 5 is already in done's state, but since the physical location of the location pointed to by the head pointer is 2, the descriptor does not meet the pop condition.

For step S200 described above, the task scheduler schedules execution in substantially the order from head to tail, but may in some cases effect out-of-order scheduling execution when scheduling descriptors in the descriptor queue. Each LUN under each CE belongs to the minimum storage unit for executing Nand Flash access operation, and the storage units under the same CE/LUN cannot be accessed out-of-order and can only be executed in sequence, but descriptors for accessing the storage units under different CEs/LUNs can be scheduled out-of-order to realize parallel access, so that the utilization rate of Nand IO is improved. For example, the descriptor pointed by the head pointer (physical location is 3) in table 1 is in a running state (in scheduling) at this time, and in parsing and executing, a long-time waiting for the feedback result of the later module is encountered, so that the descriptor may be stored in a suspension waiting area and the subsequent parsing action is paused, at this time, the task scheduler has a space to find out whether a candidate meeting the scheduling condition exists (pending state) from the next unit (physical location is 4) in the descriptor queue, but in the case, the access object of the descriptor pointed by the head pointer and the descriptor pointed by the physical location 4 both belong to the same CE/LUN, do not meet the scheduling condition, the task scheduler continues to find down, the descriptor pointed by the physical location 5 is in a done state, continues to find down, the descriptor pointed by the physical location 6 is in the pending state, and the CE/LUN of the access object is different from the previous descriptor and can be scheduled out for parsing.

After the task scheduler schedules the descriptor, the task scheduler searches the corresponding task sequence from the OPCODE table according to the OPCODE pointer of the descriptor, and sends the task sequence and the descriptor to the task analyzer for analysis.

TABLE 2 OPCODE table virtual case

Table 2 is a virtual case of an OPCODE table where each cell or cells can construct a complete task sequence, e.g., one task sequence for each of the positions pointed to by pointers 3 and 4, and are of different lengths. The task sequence with the OPCODE pointer 5 position occupies two units. Let us take the OPCODE pointer 3 as an example to illustrate how a descriptor is scheduled to execute, its stored task sequence is assumed to be AA- > BB- >20- > CC- > FF, in this virtual case AA represents that RDMA needs to read data from the system cache to the internal cache of the later module, because this time needs to wait longer, BB represents that the task sequence of the current descriptor needs to register to the suspension wait area until the later module feeds back that RDMA has read a sufficient amount of data to the internal cache, and this waiting period the task scheduler can de-schedule another descriptor to execute, thereby improving parallelism. After the data is read, the task scheduler continues to read the task represented by 20 and sends the task to the task parser for parsing, assuming that the task represents that the FCU of the later module needs to be controlled to access the Nand Flash granule through the Nand IO, the task parser parses the content pointed to by 20 in the command table and combines the content of the current descriptor to generate a control instruction, and then sends the control instruction to the FCU, the instruction represents that the data needing to be cached in the inner part is sent to a certain page of Nand Flash in a command mode specified in the command table, the CC represents that the data is registered again in a suspension waiting area until the Nand Flash granule returns a signal meeting the suspension exit condition, because the waiting time is long, the intermediate is allowed to execute scheduling and parsing of other descriptors again, the FF represents that the task of the descriptor is all ended, and the control instruction is sent to the WDMA of the later module, and the WDMA needs to write the state of the descriptor into the specified position of the system cache.

Table 3 pending wait area data structure case

After a period of waiting, when the latter module returns a signal meeting the suspension exit condition, the task scheduler reschedules the suspended descriptor task when idle, and then continues to execute according to the recorded position of the suspension waiting area.

TABLE 4 Command representing intent

According to the method for accessing the Flash memory particles by the Flash memory controller, which is disclosed by the embodiment of the invention, a mode of realizing Nand Flash access based on the descriptor is adopted, and task scheduling and analysis work of the descriptor are all executed by a hardware module, so that the cost of software and the load of a CPU (Central processing Unit) can be greatly reduced. Meanwhile, by setting the suspension waiting area, the parallelism of simultaneous access of Nand Flash particles under multiple CEs/LUNs and the utilization rate of Nand IO are improved.

Although specific embodiments are described herein, those of ordinary skill in the art will recognize that many other modifications or alternative embodiments are also within the scope of the present disclosure. For example, any of the functions and/or processing capabilities described in connection with a particular device or component may be performed by any other device or component. In addition, while various exemplary implementations and architectures have been described in terms of embodiments of the present disclosure, those of ordinary skill in the art will recognize that many other modifications to the exemplary implementations and architectures described herein are also within the scope of the present disclosure.

Certain aspects of the present disclosure are described above with reference to block diagrams and flowchart illustrations of systems, methods, systems and/or computer program products according to example embodiments. It will be understood that one or more blocks of the block diagrams and flowchart illustrations, and combinations of blocks in the block diagrams and flowchart illustrations, respectively, can be implemented by executing computer-executable program instructions. Also, some of the blocks in the block diagrams and flowcharts may not need to be performed in the order shown, or may not need to be performed in their entirety, according to some embodiments. In addition, additional components and/or operations beyond those shown in blocks of the block diagrams and flowcharts may be present in some embodiments.

Accordingly, blocks of the block diagrams and flowchart illustrations support combinations of means for performing the specified functions, combinations of elements or steps for performing the specified functions and program instruction means for performing the specified functions. It will also be understood that each block of the block diagrams and flowchart illustrations, and combinations of blocks in the block diagrams and flowchart illustrations, can be implemented by special purpose hardware-based computer systems that perform the specified functions, elements or steps, or combinations of special purpose hardware and computer instructions.

Program modules, applications, etc. described herein may include one or more software components including, for example, software objects, methods, data structures, etc. Each such software component may include computer-executable instructions that, in response to execution, cause at least a portion of the functions described herein (e.g., one or more operations of the exemplary methods described herein) to be performed.

The software components may be encoded in any of a variety of programming languages. An exemplary programming language may be a low-level programming language, such as an assembly language associated with a particular hardware architecture and/or operating system platform. Software components including assembly language instructions may need to be converted into executable machine code by an assembler prior to execution by a hardware architecture and/or platform. Another exemplary programming language may be a higher level programming language that may be portable across a variety of architectures. Software components, including higher-level programming languages, may need to be converted to an intermediate representation by an interpreter or compiler before execution. Other examples of programming languages include, but are not limited to, a macro language, a shell or command language, a job control language, a scripting language, a database query or search language, or a report writing language. In one or more exemplary embodiments, a software component containing instructions of one of the programming language examples described above may be executed directly by an operating system or other software component without first converting to another form.

The software components may be stored as files or other data storage constructs. Software components having similar types or related functionality may be stored together, such as in a particular directory, folder, or library. The software components may be static (e.g., preset or fixed) or dynamic (e.g., created or modified at execution time).

The embodiments of the present invention have been described in detail with reference to the accompanying drawings, but the present invention is not limited to the above embodiments, and various changes can be made within the knowledge of one of ordinary skill in the art without departing from the spirit of the present invention.

Claims

1. A flash memory controller, comprising:

2. The flash memory controller of claim 1, wherein the execution unit comprises:

internal caching;

3. The flash controller of claim 2, wherein the execution unit further comprises an error correction engine to error correct the data.

4. The flash controller of claim 1, further comprising a register module, wherein the CPU is capable of implementing access operations to the flash particles by configuring registers within the register module.

5. A method of accessing flash memory particles by a flash memory controller according to any of claims 1 to 4, comprising the steps of:

6. The method of claim 5, wherein the descriptor queue includes a head pointer and a tail pointer, the tail pointer being incremented by 1 when a descriptor enters the descriptor queue and the head pointer being incremented by 1 when a descriptor leaves the descriptor queue; when the descriptor is in the unit pointed by the head pointer and the descriptor completes all scheduling and parsing tasks, the descriptor leaves the descriptor queue.

7. The method of accessing flash memory granules by a flash memory controller of claim 5, wherein the descriptor comprises an OPCODE pointer; the task scheduler further comprises the following steps after the step of scheduling out the descriptors meeting the conditions in the descriptor queue:

8. The method of claim 7, wherein the task sequence includes one or more of four types of tasks, a DMA start type, a suspend wait type, an FCU instruction type, and an end type; the task analyzer analyzes the descriptors scheduled by the task scheduler to form a plurality of control instructions, and the method comprises the following steps:

9. The method of claim 8, wherein the suspend waiting area records a suspend state of a CE/LUN corresponding to the descriptor stored in the suspend waiting area, a suspend exit condition of the descriptor, and a position in the OPCODE table when the task sequence is suspended.

10. The method of accessing flash memory particles by a flash memory controller of claim 5, further comprising the steps of: