US20110185225A1 - Memory system with nonvolatile semiconductor memory - Google Patents
Memory system with nonvolatile semiconductor memory Download PDFInfo
- Publication number
- US20110185225A1 US20110185225A1 US13/078,647 US201113078647A US2011185225A1 US 20110185225 A1 US20110185225 A1 US 20110185225A1 US 201113078647 A US201113078647 A US 201113078647A US 2011185225 A1 US2011185225 A1 US 2011185225A1
- Authority
- US
- United States
- Prior art keywords
- data
- memory
- write
- row address
- instruction
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
- G06F12/02—Addressing or allocation; Relocation
- G06F12/0207—Addressing or allocation; Relocation with multidimensional access, e.g. row/column, matrix
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
- G06F12/02—Addressing or allocation; Relocation
- G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
- G06F12/02—Addressing or allocation; Relocation
- G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
- G06F12/0802—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
- G06F12/0866—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches for peripheral storage systems, e.g. disk cache
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
- G06F12/02—Addressing or allocation; Relocation
- G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
- G06F12/0802—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
- G06F12/0877—Cache access modes
- G06F12/0882—Page mode
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/08—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers from or to individual record carriers, e.g. punched card, memory card, integrated circuit [IC] card or smart card
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2212/00—Indexing scheme relating to accessing, addressing or allocation within memory systems or architectures
- G06F2212/21—Employing a record carrier using a specific recording technology
- G06F2212/214—Solid state disk
Definitions
- This invention relates to a memory system and a card controller. More particularly, this invention relates to a memory system which includes a nonvolatile semiconductor memory and a card controller for controlling the operation of the nonvolatile semiconductor memory.
- NAND flash memory In a NAND flash memory, data is written into a plurality of memory cells simultaneously. A unit for simultaneous writing is called a page. With the recent trend of NAND flash memories toward higher capacity, the page size is getting larger.
- a host unit does not necessarily provide access in pages. For example, in a write operation, the end position of write data may not be at the page boundary. Moreover, chances are high the host unit will provide write access again using consecutive addresses. The reason is that the host unit cannot send a large quantity of data at a time to a flash memory and therefore divides the data into pieces and writes them a plurality of times.
- a control system for a NAND flash memory when consecutive write accesses end at a place which is not the end position of a page, writes the data on the page into another memory block.
- a memory block is a set of memory cells and serves as a unit for erasing data.
- the method has the problem of being unable to write data until the data size is eventually determined and therefore causing loss of time.
- a memory system includes:
- nonvolatile semiconductor memory which has a plurality memory blocks each including memory cells capable of holding data, the data in each of the memory blocks being erased simultaneously, and the data being written simultaneously in pages in each of the memory blocks, each of the pages being a set of a plurality of memory cells;
- a controller which transfers write data and a first row address to the nonvolatile semiconductor memory and issues a change instruction for the transferred first row address and a second row address differing from the first row address, the nonvolatile semiconductor memory writing the write data into the memory cells corresponding to the first row address when the change instruction has not been issued, and writing the write data into the memory cells corresponding to the second row address when the change instruction has been issued.
- a card controller for controlling a nonvolatile semiconductor memory includes:
- a host interface which is configured to be connectable to a host unit and receives write data and a first row address from the host unit;
- an arithmetic processing unit which transfers the write data to the nonvolatile semiconductor memory having a plurality of memory blocks each including memory cells capable of holding data and issues a change instruction for the first row address and a second row address differing from the first row address, the data in each of the memory blocks being erased simultaneously, the write data being written simultaneously in pages in each of the memory blocks, each of the pages being a set of a plurality of memory cells in each of the memory blocks, and the arithmetic processing unit, according to the change instruction, instructing the nonvolatile semiconductor memory to write the write data into the memory cells corresponding to the second row address.
- FIG. 1 is a block diagram of a memory system according to a first embodiment of the invention
- FIG. 2 is a table showing the allocation of signals to the signal pins of a memory card according to the first embodiment
- FIG. 3 is a block diagram of a card controller included in the memory card of the first embodiment
- FIG. 4 is a block diagram of a flash memory according to the first embodiment
- FIG. 5 is a flowchart to help explain the processing in the card controller in a data writing method for the flash memory of the first embodiment
- FIG. 6 is a timing chart for the signals output by the card controller of the flash memory according to the first embodiment
- FIG. 7 is a flowchart to help explain the processing in a NAND flash memory in a data writing method for the flash memory of the first embodiment
- FIGS. 8 and 9 are block diagrams of a memory system according to the first embodiment, showing the way data is written;
- FIG. 10 is a flowchart to help explain a data writing method for a flash memory according to a second embodiment of the invention.
- FIGS. 11 to 14 are block diagrams of a memory system according to the second embodiment, showing the way data is aggregated
- FIG. 15 is a flowchart to help explain the processing in a card controller in a data aggregating method for a flash memory according to a third embodiment of the invention.
- FIG. 16 is a flowchart to help explain the processing in a NAND flash memory in a data writing method for the flash memory of the third embodiment
- FIGS. 17 to 19 are block diagrams of a memory system according to the third embodiment, showing the way data is aggregated
- FIG. 20 is a conceptual diagram of the memory space of a NAND flash memory included in a memory system according to each of the second and third embodiments;
- FIG. 21 is a block diagram of a flash memory
- FIG. 22 is a block diagram of a flash memory, showing the way data is aggregated.
- FIG. 23 is a block diagram of a flash memory according to a modification of the second and third embodiments, showing the way data is aggregated.
- FIG. 1 is a block diagram of a memory system according to the first embodiment.
- the memory system includes a memory card 1 and a host unit 2 .
- the host unit 2 includes hardware and software for accessing the memory card 1 to which the host unit is connected via a bus interface 14 .
- the memory card 1 is supplied with power when being connected to the host unit 2 and carries out a process according to the access from the host unit 2 .
- the memory card 1 exchanges information with the host unit 2 via the bus interface 14 .
- the memory card 1 includes a NAND flash memory chip (sometimes simply referred to as a NAND flash memory or a flash memory) 11 , a card controller 12 for controlling the flash memory chip 11 , and a plurality of signal pins (a first pin to a ninth pin) 13 .
- the plurality of signal pins 13 are electrically connected to the card controller 12 . Signals are allocated to a first to a ninth pin of the plurality of signal pins 13 as shown in, for example, FIG. 2 .
- FIG. 2 is a table showing the first to ninth pins and signals allocated to the pins.
- Data 0 to data 3 are allocated to a seventh pin, an eighth pin, a ninth pin, and a first pin, respectively.
- the first pin is also allocated to a card detection signal.
- the second pin is allocated to a command
- the third and sixth pins are allocated to the ground potential Vss
- the fourth pin is allocated to a power supply potential Vdd
- the fifth pin is allocated to a clock signal.
- the memory card 1 is so designed that it can be inserted into and removed from a slot made in the host unit 2 .
- a host controller (not shown) provided in the host unit 2 exchanges various signals and data with the card controller 12 in the memory card 1 via the first to ninth pins. For example, when data is written into the memory card 1 , the host controller sends a write commend to the card controller 12 via the second pin in the form of a serial signal. At this time, in response to the clock signal supplied to the fifth pin, the card controller 12 takes in the write command supplied to the second pin.
- the write command is input serially to the card controller 12 using only the second pin.
- the second pint allocated to the input of a command is provided between the first pin for data 3 and the third pin for ground potential Vss.
- a plurality of signal pins 13 and a bus interface 14 for the signal pins 13 are used for the communication between the host controller in the host unit 2 and the memory card 1 .
- the communication between the flash memory 11 and the card controller 12 is performed by an interface for NAND flash memory.
- the flash memory 11 and the card controller 12 are connected to each other with, for example, 8-bit input/output (I/O) lines.
- the card controller 12 when the card controller 12 writes data into the flash memory 11 , the card controller 12 inputs data input command 80H, a column address, a page address, data, and program command 10H to the flash memory 11 sequentially via the I/O lines.
- “H” in command 80H represents hexadecimal number.
- an 8-bit signal of “10000000” is supplied in parallel to the 8-bit I/O lines. That is, in the NAND flash memory interface, a plurality of bits in a command are supplied in parallel.
- the command and data for the flash memory 11 are transmitted using the same I/O lines.
- the interface used for the communication between the host controller and memory card 1 in the host unit 2 differs from the interface used for the communication between the flash memory 11 and card controller 12 .
- FIG. 3 is a block diagram of the card controller 12 .
- the card controller 12 manages the physical state of the flash memory 11 (for example, at what physical block address what number logical sector address data is included or which block is in the erased state).
- the card controller 12 includes a host interface module 21 , a microprocessor unit (MPU) 22 , a flash controller 23 , a read-only memory (ROM) 24 , a random access memory (RAM) 25 , and a buffer 26 .
- MPU microprocessor unit
- ROM read-only memory
- RAM random access memory
- the host interface module 21 executes an interfacing process between the card controller 12 and the host apparatus 2 .
- the MPU 22 controls the operation of the overall memory card 1 .
- the MPU 22 reads the firmware (control program) stored in the ROM 24 into the RAM 25 and carries out a specific process, thereby creating various tables on the RAM 25 .
- the MPU 22 receives a write command, a read command, or an erase command from the host unit 2 and then performs a specific process on the flash memory 11 or controls a data transfer process via the buffer 26 .
- the ROM 24 stores a control program or the like controlled by the MPU 22 .
- the RAM 25 is used as a work area of the MPU 22 and stores the control program and various tables.
- the flash controller 23 executes an interfacing process between the card controller 12 and the flash memory 11 .
- the buffer 26 stores a specific amount of data (e.g., a page of data) temporarily when the data sent from the host unit 2 is written into the flash memory 11 or when the data read from the flash memory 11 is sent to the host unit 2 .
- a specific amount of data e.g., a page of data
- FIG. 4 is a block diagram of the NAND flash memory 11 .
- the NAND flash memory 11 includes a memory cell array 30 and a page buffer 31 .
- the memory cell array 30 includes a plurality of memory cell blocks BLK 0 to BLKn (n is a natural number equal to or larger than 2).
- the memory cell blocks BLK 0 to BLKn may be simply referred to as the memory blocks BLK.
- Data is erased in memory blocks BLK. That is, the data in the same memory cell block BLK is erased simultaneously.
- Each of the memory cell blocks BLK includes a plurality of memory cells MC.
- Each memory cell is a MOS transistor having a stacked gate including a charge accumulation layer (for example, a floating gate in the embodiment) and a control gate.
- a memory cell block BLK a plurality of word lines WL 0 , WL 1 , . . . (hereinafter, referred to as word lines WL) and bit lines BL 0 , BL 1 , . . . (hereinafter, referred to as bit lines BL) perpendicular to the word lines WL are provided.
- the memory cells in the same row are connected equally to the same word line.
- the memory cells MC in the same column are connected equally to a bit line BL in units of a plurality of memory cells.
- Each page of the flash memory 11 has 2112 bytes (a 512-byte data storage section ⁇ 4+a 10-byte redundant section ⁇ 4+a 24-byte management data storage section).
- Each memory block BLK includes, for example, 128 pages.
- the page buffer 31 which inputs and outputs data to and from the flash memory 11 , holds the data temporarily.
- the data size the page buffer 31 can hold is 2112 bytes (2048 bytes+64 bytes), which is the same as the page size of each memory block BLK.
- the page buffer 11 inputs and outputs data to and from the flash memory 11 in units of one page corresponding to its own memory capacity.
- the redundant section and the management data storage section are omitted and the data size of one page is assumed to be 2048 bytes.
- FIG. 5 is a flowchart to help explain the processing in the card controller 12 .
- the card controller 12 receives from the host unit 2 a data write instruction and an address in which data is to be written in the NAND flash memory 11 (step S 10 ). Then, the card controller 12 receives write data from the host unit 2 (step S 11 ). The card controller 12 then outputs a first write instruction, the write data, and the address to the flash memory 11 . Receiving the first write instruction, the flash memory 11 recognizes the start of a write operation. Here, it is when a second write operation described later is given that data is actually written into the memory cells MC.
- the MCU 22 of the card controller 12 determines whether a write access end or interrupt instruction has been received from the host unit 2 (step S 13 ). If none of them have been received (No in step S 13 ), the MCU 22 outputs a second write instruction to the flash memory 11 (step S 14 ). In step S 14 , the flash memory 11 waits for a continued input write data, the second write instruction or the reset instruction from the card controller 12 .
- step S 15 the MCU 22 determines whether the write data transferred to the flash memory 11 satisfies the page size in the flash memory 11 (step S 15 ). That is, the MCU 22 determines whether the data size of the write data is equal to or less than 2048 bytes. If the condition is satisfied, that is, if the data size is 2048 bytes (Yes in step S 16 ), the MCU 22 outputs the second write instruction to the flash memory 11 (step S 17 ).
- step S 16 If the condition is not fulfilled, that is, if the data size is less than 2048 bytes (No in step S 16 ), the MCU 22 issues a row address change instruction and a new row address and outputs them to the flash memory 11 (step S 18 ) and then carries out the process of step S 17 .
- FIG. 6 is a timing chart for the signals output from the card controller 12 to the flash memory 11 .
- the signals output when there is neither an end instruction nor an interrupt instruction (No in step S 13 ) or when the write data has satisfied the page size (Yes in step S 16 ) are shown.
- the signals output when the write data has not satisfied the page size are shown.
- a first write instruction is output. Thereafter, addresses (row address and column address) and the write data are output at time t 1 and time t 2 in sequence, respectively. Then, when there is neither an end instruction nor an interrupt instruction, or when the write data has satisfied the page size, a second write instruction is output at time t 4 , which completes the flow of a series of signals.
- a row address change instruction is output at time t 3 and a new row address is output at time t 5 .
- a second write instruction is output at time t 6 .
- an effective row address is not the row address output at time t 1 but a new row address output at time t 5 .
- the new row address is an address corresponding to a memory block BLK differing from the memory block BLK to which the first row address corresponds.
- FIG. 7 is a flowchart to help explain the processing in the flash memory 11 .
- the flash memory 11 receives a first write instruction, write data, and an address from the card controller 12 (step S 20 ). Then, the flash memory 11 determines whether it has received a row address change instruction and a new row address (step S 21 ). If the flash memory 11 has received neither a row address change instruction nor a new row address (No in step S 22 ), it receives a second write instruction from the card controller 12 (step S 23 ) and then writes data into the memory cell MC specified by the row address and column address received in step S 20 (step S 24 ).
- step S 22 If the flash memory has received a row address change instruction (Yes in step S 22 ), it receives a second write instruction (step S 25 ) and then writes data into the memory cell MC specified by the column address received in step S 20 and a new row address received after the row address change instruction (step S 26 ).
- FIGS. 8 and 9 are block diagrams of a memory system.
- FIG. 8 shows a case where there is neither an end instruction nor an interrupt instruction (No in step S 13 ) or where the write data has satisfied the page size (Yes in step S 16 ).
- FIG. 9 shows a case where the write data has not satisfied the page size (No in step S 16 ).
- Both FIG. 8 and FIG. 9 show a case where the page size of one page is 2048 bytes and the card controller 112 transfers data in units of 512 bytes to the flash memory 11 .
- the shaded areas show write data.
- FIG. 8 will be explained.
- write data supplied from the host unit 2 is stored in the buffer 26 of the card controller 12 .
- an address is given to the card controller 12 .
- the card controller 12 transfers the write data in the buffer 26 to the page buffer 31 .
- FIG. 8 shows the way four items of data each having a data size of 512 bytes, that is, 2048 bytes of write data, are transferred to the page buffer 31 .
- the card controller 12 transfers a row address to the row decoder 32 in the flash memory 11 .
- the row decoder 32 selects any one of the word lines WL.
- the word line WL in memory block BLK 0 is selected.
- the write data in the page buffer 31 is written into the memory cell MC connected to the selected word line WL.
- FIG. 9 shows the way data is transferred to the page buffer 31 in such a manner that four items of data each having a data size of 512 bytes, that is, 2048 bytes of write data, are written into each of two pages of memory block BLK 0 , and then three items of data each having a data size of 512 bytes, that is, 1536 bytes of write data, are written into consecutive addresses in memory block BLK 0 . Only what differs from FIG. 8 will be explained.
- the MCU 22 of the card controller 12 After determining that the data in the buffer 26 (or page buffer 31 ) is less than the page size (1536 bytes ⁇ 2048 bytes), the MCU 22 of the card controller 12 outputs a row address change instruction to the flash memory 11 and further issues a new row address and outputs it to the row decoder 32 .
- the new row address corresponds to the word line WL in memory block BLK 1 .
- the row decoder 32 selects the word line WL in memory block BLK 1 , not in memory block BLK 0 .
- 1536 bytes of write data in the page buffer 31 are written into the memory cell MC connected to the word line WL selected by the row decoder 32 .
- the memory system with the above configuration produces the following effect.
- the data in the page buffer 31 falls short of the page size, the data is written into a memory block BLK differing from the memory block BLK into which the data has been written so far. That is, there is no need to wait for a write operation until the data in the page buffer has reached the page size. Accordingly, the write speed can be improved.
- the controller can transmit the data to the NAND flash memory without delay, therefore the data write speed can be improved compared to the method that the reset instruction is issued and data is re-input to inhibit writing data and change the row address, and data write is carried out in wait for storing the data with the page size in the buffer of the controller.
- the card controller 12 issues a row address change instruction and a new row address.
- the flash memory 11 selects the row direction of the memory cell array 30 on the basis of the new row address. Then, the data transferred to the page buffer 31 can be written into a different memory block BLK at high speed.
- the card controller 12 has no row address change instruction
- the card controller has to transfer the data again to the page buffer.
- the card controller outputs a reset instruction to cancel the write instruction.
- the card controller issues a first write instruction to specify a new row address.
- the card controller inputs data to the page buffer again.
- the card controller issues a second write operation.
- the retransfer of data to the page buffer is needed, which leads to loss of time.
- the data write speed can be improved.
- FIG. 10 is a flowchart to help explain a data aggregating method in a memory system according to the second embodiment.
- a NAND flash memory of the second embodiment is such that the configuration shown in FIGS. 8 and 9 explained in the first embodiment further includes a data cache.
- the data cache holds data in pages temporarily as the page buffer does.
- the MCU 22 of the card controller 12 outputs a read instruction to the flash memory 11 (step S 30 ).
- the read instruction may be a read instruction as a part of a data aggregate instruction, not just an ordinary data read instruction.
- the card controller 12 gives an address together with the read instruction to the flash memory 11 .
- the flash memory 11 selects a page corresponding to the address given in step S 30 and reads data in pages into the data buffer (step S 31 ). Thereafter, the data read into the page buffer is transferred to the data cache (step S 32 ). Then, the data transferred to the data cache is transferred to the buffer 26 of the card controller 12 (step S 33 ).
- FIG. 11 is a diagram to help explain step S 30 to step S 33 .
- FIG. 11 is a block diagram of the card controller 12 and flash memory 11 .
- memory block BLK 0 holds data D 1 whose data size corresponds to two pages, or is 4096 bytes.
- Memory block BLK 1 holds data D 2 whose data size is less than the page size, for example, 1536 bytes.
- Memory block BLKn holds data D 3 whose data size is less than the page size, for example, 512 bytes.
- 1536-byte data D 2 and 512-byte data D 3 are aggregated into 2048 bytes of data, that is, one-page-size data, which is then written into memory block BLK 0 . This will be explained below.
- the row decoder 32 selects a word line WL in, for example, memory block BLK 1 .
- the data on the page including data D 2 is read in pages into the page buffer 31 .
- the data read in pages may be referred to page data.
- step S 33 the MCU 22 of the card controller 12 checks data D 2 transferred to the buffer 26 for an error. If having detected an error, the MCU 22 corrects the error. Moreover, while the card controller 12 is performing error detection and error correction, the flash memory 11 reads data differing from the data in step S 31 in pages into the page buffer 31 (step S 34 ).
- FIG. 12 is a diagram to help explain step S 34 .
- the row decoder 32 selects any one of the word lines WL in, for example, memory block BLKn.
- the data on a page including 512-byte data D 3 is read in pages into the page buffer 31 .
- the row address corresponding to the word line WL selected in step S 34 may be given in step S 30 or at any point in time before the card controller 12 performs error detection and error correction.
- the card controller 12 determines which data item (here, data D 3 ) should be read to aggregate the data item and data D 2 into a data size of one page.
- the card controller 12 since the card controller 12 holds a table showing in which area what data has been stored, it selects appropriate data with reference to the table. While in the example of FIG. 12 , data is read from memory block BLKn different from memory block BLK 0 , data may be read from another page in the same memory block BLK 0 .
- step S 34 the flash memory transfers only the necessary data of the data read into the page buffer 31 in step S 34 to the data cache 33 (step S 35 ).
- the data cache 33 holds data falling short of the page size transferred in step S 32 . That is, the data cache 33 has a free area.
- step S 34 since data is read in pages in step S 32 , not only necessary data but also unnecessary data on the same page as that of the necessary data are held in the data cache 33 .
- step S 34 too, data is read in pages, unnecessary data is also read into the data buffer.
- step S 35 only the necessary data of the data read in pages in step S 34 is transferred to the area in which unnecessary data has been held in the data cache 33 .
- the data cache holds the data falling short of the page size read in step S 32 and the data falling short of the page size read in step S 34 , which are aggregated to produce just the same data size as one page (step S 36 ). That is, two data items are aggregated into a page size.
- the data transferred to the data cache 33 in step S 35 is transferred to the buffer 26 of the memory controller 12 (step S 37 ). Then, the MCU 22 performs error detection and error correction (step S 38 ).
- FIG. 13 is a diagram to help explain step S 35 to step S 38 .
- the data cache 33 Since 1536-byte data D 3 is held in the data cache 33 , the cache 33 has the remaining 512-byte free area. Thus, 512-byte data D 3 is transferred to the free area.
- the data cache 33 holds data D 2 and data D 3 .
- the data size of an aggregate of data D 2 and data D 3 is 2048 bytes, just the data size of one page. Then, data D 3 in the data cache 33 is transferred to the buffer 26 .
- step S 38 if the MCU 22 has detected an error in any data item and corrected the error (Yes in step S 39 ), it transfers the corrected data to the data cache 33 (step S 40 ). At this time, the MCU 22 transfers only the corrected data to the data cache 33 , thereby replacing the uncorrected data. Then, the flash memory 11 writes the data held in the data cache 33 into the memory cell MC in pages (step S 41 ).
- FIG. 14 is a diagram to help explain step S 39 to step S 41 .
- the data in the data cache 33 is replaced with the corrected data.
- the data in the data cache 33 (2048 bytes of data obtained by aggregating data D 2 and data D 3 ) is transferred to the data buffer 33 and further written into the memory cell array 30 .
- the row decoder 32 selects the word line WL corresponding to the address continuous with data D 1 in memory block BLK 0 . This enables data D 2 and data D 3 to be written into the same page in memory block BLK 0 .
- the row address for the row decoder 32 to select a word line WL may be given from the card controller 12 to the row decoder 32 in step S 41 . Alternatively, the row address may be given in step S 30 or step S 40 .
- the page buffer 31 exchanges data with the data cache 33 in units smaller than page units. This enables the aggregation of data to be made easier and the data aggregating speed to be made faster.
- data exchange between the page buffer 31 and data cache 33 is carried out in units smaller than the page units. Accordingly, a plurality of data items can be aggregated into a page in the data cache 33 . If there is an error in the data, only the corrected data has to be transferred from the buffer 26 to the data cache 33 . However, if there is no error, the transfer is not needed.
- FIG. 15 is a flowchart to help explain the processing in the card controller 12 .
- step S 10 to step S 17 are the same as those in the first embodiment and an explanation of them will be omitted.
- the MCU 22 of the card controller 13 If the result of the determination in step S 15 has shown that the data size of the write data is smaller than the page size (No in step S 16 ), the MCU 22 of the card controller 13 outputs a write cancel instruction to the flash memory 11 (step S 50 ).
- the write cancel instruction is an instruction to cause the flash memory 11 to stop a subsequent write operation.
- the MCU 22 outputs a data read instruction to the flash memory 11 (step S 51 ).
- the MCU 22 supplies not only the read instruction but also the address for the data to be read to the flash memory 11 .
- the data to be read in step S 51 forms just one-page-size data when it is aggregated with the data determined to fall short of the page size in step S 15 and step S 16 .
- the MCM 22 performs error detection and error correction on the read data (step S 52 ). Thereafter, the MCU 22 transfers only the error-corrected data to the flash memory 11 and further instructs the flash memory 11 to write the data to the data cache 33 (step S 53 ).
- FIG. 16 is a flowchart to help explain the processing in the flash memory 11 .
- the flash memory 11 receives a write cancel instruction from the card controller 12 (step S 60 ). Receiving the write cancel instruction, the flash memory 11 stops writing data and holds the data in the data cache 33 as it is (step S 61 ). Then, on the basis of the read instruction given from the card controller 12 in step S 51 , the flash memory 11 reads data in pages into the page buffer 31 (step S 62 ). Of the data read into the page buffer 31 , only the necessary data is transferred to the data cache 33 (step S 35 ). As a result, the data cache 33 holds the write data falling short of the page size and the data falling short of the page size read in step S 62 , which are aggregated to produce the same size as one page (step S 36 ).
- step S 35 the data transferred to the data cache 33 in step S 35 is transferred to the buffer 26 of the memory controller 12 (step S 37 ).
- step S 35 to step S 37 The processes in step S 35 to step S 37 are as explained in the second embodiment.
- the corrected data is received from the MCU 22 (step S 63 ) and then the data in the data cache 33 is written into a page corresponding to the original row address (step S 41 ).
- FIG. 17 is a block diagram of the memory system.
- FIGS. 18 and 19 are block diagrams of the memory card.
- the data size of one page is 2048 bytes and the card controller 12 transfers data in units of 512 bytes to the flash memory 11 .
- the shaded areas show write data. As shown in FIG.
- the MCU 22 outputs a write cancel instruction to the flash memory 11 . Then, the row decoder 32 of the flash memory 11 makes the word line WL unselected, thereby stopping the operation of writing data D 6 transferred to the data cache 33 into memory block BLK 0 .
- the MCU 22 outputs to the flash memory 11 , for example, a read instruction to read data D 4 from memory block BLKn and an address.
- the flash memory 11 reads the data in the page including data D 4 from memory block BLKn in pages into the data buffer 31 .
- the page data read into the data buffer 31 only data D 4 of the 512-byte data size is transferred to the data cache 33 .
- 1536-byte data D 6 is held in the data cache 33 , there is a 512-byte free area left.
- 512-byte data D 4 is transferred to the free area.
- data D 6 and data D 4 are aggregated into exactly a one-page size of data.
- data D 4 in the data cache 33 is transferred to the buffer 26 of the card controller 12 , followed by error detection and error correction.
- the corrected data is written into the data cache 33 , with the result that data D 6 and data D 4 held in the data cache 33 are written into the same page in memory block BLK 0 .
- the page into which data D 4 and data D 6 are written is an area corresponding to an address continuous with data D 5 where data D 6 was to originally be written.
- the memory system with the above configuration produces not only the effect in item (2) explained in the second embodiment but also the effect in item (3) below.
- the operating speed of the NAND flash memory can be improved.
- information on what data should be read and aggregated to produce exactly one-page data size is held by the card controller 12 in, for example, the RAM 25 in the form of a table. Specifically, since the card controller 12 has grasped in what address what data size of data has been written, any suitable one of them is selected and a read instruction is issued.
- the file system is a system of managing files (data) stored in a memory.
- FAT file allocation table
- a method of creating directory information, such as files or folders, in a memory a method of moving files or folders, a method of erasing files or folders, a method of storing data, management area locations, a method of using management areas, and others are determined.
- FIG. 20 is a conceptual diagram of the memory space of a NAND flash memory 11 according to each of the above embodiments.
- the memory space is roughly divided into a user data area 40 and a management area 41 .
- the user data area 40 is an area which stores net data written by the user.
- the management area 41 includes, for example, a boot area 42 , a partition information area 43 , a FAT1 ( 44 ), a FAT2 ( 45 ), and a root directory entry area 46 .
- the boot area 42 stores, for example, boot information.
- the partition information area 43 stores partition information.
- the FAT1 and FAT2 store in what address data has been stored. Hereinafter, FAT1 and FAT2 will be explained briefly.
- the user data area 40 includes a plurality of areas called clusters. If data to be written is larger than a cluster size, the data is divided into clusters, which are then stored. At this time, clusters into which data is written may be inconsecutive. That is, an item of data is written into clusters separate from one another. In this case, management data for indicating in which clusters the divided items of data have been written is stored in FAT1 and FAT2.
- the root directory entry area 46 stores information on root directory entries.
- the root directory entry area 46 further stores not only file names or folder names, file sizes, attributes, and file update time and date but also flags indicating which clusters shown in FAT1 and FAT2 are first clusters of files.
- management data Each item of data (hereinafter, referred to as management data) in the management area, particularly FAT1 and FAT2, is frequently updated and has a small data size, generally falling short of one page.
- management data since data is prevented from being overwritten, data frequently updated is written temporarily into any erase memory block (referred to as a cache block). Each time the data is updated, it is written into the cache block sequentially. Then, with specific timing, the latest data in the cache block is transcribed into another memory block (which is referred to as cache reconstruction). From the viewpoint of the speeding up of cache reconstruction, it is desirable to use a method according to the first to third embodiments. On this point, explanation will be given below.
- FIG. 21 is a conceptual diagram of memory block BLK 0 .
- memory block BLK 0 includes 128 pages and addresses“000,” “001,” “002,” . . . “1FF” are allocated in units of 512 bytes in each page.
- addresses“000,” “001,” “002,” . . . “1FF” are allocated in units of 512 bytes in each page.
- write A 512 bytes of data are written in address “000.”
- write B 1024 bytes of data are written in address “005.”
- write C 2048 bytes of data are written in address “03F.”
- write D 1024 bytes of data are written in address “000.”
- write E 1024 bytes of data are written in address “003.”
- FIG. 22 is a conceptual diagram of the cache block and memory block BLK 0 , showing the way cache reconstruction is performed.
- write A is done on page 1 of the cache block.
- write B is done on page 2 of the cache block.
- write C is done on page 3 and page 4 of the cache block.
- write D is done on page 6 of the cache block.
- cache reconstruction is performed.
- data to be written in address “000” is the data written in write D. That is, the data written in write A has been overwritten with the data in write D and becomes unnecessary. Therefore, first, data is read from page 5 of the cache block.
- address “002” of memory block BLK 0 has not been updated, the data in address “002” of memory block BLK 0 is read to use the original data as it is.
- data in address “003” is the data written in write E, data is read from page 6 of the cache block. As a result of the three data reads, data items to be written into page 1 of memory block BLK 0 are aggregated.
- FIG. 23 is a conceptual diagram of the cache block and memory block BLK 0 , showing the way cache reconstruction is performed.
- write A is done on page 1 of the cache block.
- write B is done on page 2 of the cache block.
- write C is done on page 3 and page 4 of the cache block.
- write D is done on page 6 of the cache block.
- cache reconstruction is performed.
- the data corresponding to page 1 of memory block BLK 0 is held in pages 1 , 5 , and 6 of the cache block. Of them, page 6 which holds the latest data is read and written into page 1 of memory block BLK 0 .
- the data in page 2 of the cache block is transcribed into page 2 of memory block BLK 0 .
- memory block BLK 0 has to be caused to correspond to the cache block for each 512-byte area in FIG. 22 , leading to a tremendous amount of information.
- memory block BLK 0 has to be caused to correspond to the cache block in pages, which enables the amount of correspondence information to be decreased.
- the above method is desirable from the viewpoint of not only cache reconstruction and correspondence relationship but also reading from the host unit. That is, to perform file system operations, including the update of FATs, efficiently, the host unit generally reads data in a batch to some extent in advance. Specifically, in the flash memory, small data size random writing may be performed in a FAT area or the like and a specific large amount of data obtained by aggregating the small data sizes may be read. In such a case, too, with the method of the third embodiment, small sizes of data get together in pages, enabling the operating speed to be improved, since the read operation at the cache reconstruction has to be carried out only once per page.
Abstract
A memory system includes a nonvolatile semiconductor memory and a controller. The memory has a plurality memory blocks each including memory cells capable of holding data. The data in each of the memory blocks is erased simultaneously. The data is written simultaneously in pages in each of the memory blocks. Each of the pages is a set of a plurality of memory cells. The controller transfers write data and a first row address to the memory and issues a change instruction for the transferred first row address and a second row address differing from the first row address. The memory writes the write data into the memory cells corresponding to the first row address when the change instruction has not been issued, and writes the write data into the memory cells corresponding to the second row address when the change instruction has been issued.
Description
- This application is based upon and claims the benefit of priority from prior Japanese Patent Application No. 2006-182631, filed Jun. 30, 2006, the entire contents of which are incorporated herein by reference.
- 1. Field of the Invention
- This invention relates to a memory system and a card controller. More particularly, this invention relates to a memory system which includes a nonvolatile semiconductor memory and a card controller for controlling the operation of the nonvolatile semiconductor memory.
- 2. Description of the Related Art
- In a NAND flash memory, data is written into a plurality of memory cells simultaneously. A unit for simultaneous writing is called a page. With the recent trend of NAND flash memories toward higher capacity, the page size is getting larger.
- However, a host unit does not necessarily provide access in pages. For example, in a write operation, the end position of write data may not be at the page boundary. Moreover, chances are high the host unit will provide write access again using consecutive addresses. The reason is that the host unit cannot send a large quantity of data at a time to a flash memory and therefore divides the data into pieces and writes them a plurality of times.
- In a conventional NAND flash memory, the same page is generally allowed to be written into unless overwriting whereby the same column is written into twice is done. Therefore, in such a case, no problem Occurs.
- In recent years, however, memory cells have been miniaturized further and designed to have a multilevel configuration. With this trend, writing data into the same page a plurality of times becomes a problem in terms of reliability. Thus, NAND flash memories prevented from performing such an operation have been increasing.
- Predicting access from the above-described host unit, a control system for a NAND flash memory, when consecutive write accesses end at a place which is not the end position of a page, writes the data on the page into another memory block. A memory block is a set of memory cells and serves as a unit for erasing data. In this connection, there is a known technique where a page size of data is stored in a buffer when a write end address has not been given in advance by the host unit or when the transfer of data from the host unit has been interrupted for some reason. Such a technique has been disclosed in, for example, Jpn. Pat. Appln. KOKAI Publication No. 2006-092169. In the method, when the data size has finally failed to reach the page size, the data is written into another memory block.
- However, the method has the problem of being unable to write data until the data size is eventually determined and therefore causing loss of time.
- A memory system according to an aspect of the present invention includes:
- a nonvolatile semiconductor memory which has a plurality memory blocks each including memory cells capable of holding data, the data in each of the memory blocks being erased simultaneously, and the data being written simultaneously in pages in each of the memory blocks, each of the pages being a set of a plurality of memory cells; and
- a controller which transfers write data and a first row address to the nonvolatile semiconductor memory and issues a change instruction for the transferred first row address and a second row address differing from the first row address, the nonvolatile semiconductor memory writing the write data into the memory cells corresponding to the first row address when the change instruction has not been issued, and writing the write data into the memory cells corresponding to the second row address when the change instruction has been issued.
- A card controller for controlling a nonvolatile semiconductor memory according to an aspect of the present invention includes:
- a host interface which is configured to be connectable to a host unit and receives write data and a first row address from the host unit; and
- an arithmetic processing unit which transfers the write data to the nonvolatile semiconductor memory having a plurality of memory blocks each including memory cells capable of holding data and issues a change instruction for the first row address and a second row address differing from the first row address, the data in each of the memory blocks being erased simultaneously, the write data being written simultaneously in pages in each of the memory blocks, each of the pages being a set of a plurality of memory cells in each of the memory blocks, and the arithmetic processing unit, according to the change instruction, instructing the nonvolatile semiconductor memory to write the write data into the memory cells corresponding to the second row address.
-
FIG. 1 is a block diagram of a memory system according to a first embodiment of the invention; -
FIG. 2 is a table showing the allocation of signals to the signal pins of a memory card according to the first embodiment; -
FIG. 3 is a block diagram of a card controller included in the memory card of the first embodiment; -
FIG. 4 is a block diagram of a flash memory according to the first embodiment; -
FIG. 5 is a flowchart to help explain the processing in the card controller in a data writing method for the flash memory of the first embodiment; -
FIG. 6 is a timing chart for the signals output by the card controller of the flash memory according to the first embodiment; -
FIG. 7 is a flowchart to help explain the processing in a NAND flash memory in a data writing method for the flash memory of the first embodiment; -
FIGS. 8 and 9 are block diagrams of a memory system according to the first embodiment, showing the way data is written; -
FIG. 10 is a flowchart to help explain a data writing method for a flash memory according to a second embodiment of the invention; -
FIGS. 11 to 14 are block diagrams of a memory system according to the second embodiment, showing the way data is aggregated; -
FIG. 15 is a flowchart to help explain the processing in a card controller in a data aggregating method for a flash memory according to a third embodiment of the invention; -
FIG. 16 is a flowchart to help explain the processing in a NAND flash memory in a data writing method for the flash memory of the third embodiment; -
FIGS. 17 to 19 are block diagrams of a memory system according to the third embodiment, showing the way data is aggregated; -
FIG. 20 is a conceptual diagram of the memory space of a NAND flash memory included in a memory system according to each of the second and third embodiments; -
FIG. 21 is a block diagram of a flash memory; -
FIG. 22 is a block diagram of a flash memory, showing the way data is aggregated; and -
FIG. 23 is a block diagram of a flash memory according to a modification of the second and third embodiments, showing the way data is aggregated. - A memory system according to a first embodiment of the invention will be explained using
FIG. 1 .FIG. 1 is a block diagram of a memory system according to the first embodiment. - As shown in
FIG. 1 , the memory system includes amemory card 1 and ahost unit 2. Thehost unit 2 includes hardware and software for accessing thememory card 1 to which the host unit is connected via abus interface 14. Thememory card 1 is supplied with power when being connected to thehost unit 2 and carries out a process according to the access from thehost unit 2. - The
memory card 1 exchanges information with thehost unit 2 via thebus interface 14. Thememory card 1 includes a NAND flash memory chip (sometimes simply referred to as a NAND flash memory or a flash memory) 11, acard controller 12 for controlling theflash memory chip 11, and a plurality of signal pins (a first pin to a ninth pin) 13. - The plurality of
signal pins 13 are electrically connected to thecard controller 12. Signals are allocated to a first to a ninth pin of the plurality ofsignal pins 13 as shown in, for example,FIG. 2 .FIG. 2 is a table showing the first to ninth pins and signals allocated to the pins. -
Data 0 todata 3 are allocated to a seventh pin, an eighth pin, a ninth pin, and a first pin, respectively. The first pin is also allocated to a card detection signal. The second pin is allocated to a command, the third and sixth pins are allocated to the ground potential Vss, the fourth pin is allocated to a power supply potential Vdd, and the fifth pin is allocated to a clock signal. - The
memory card 1 is so designed that it can be inserted into and removed from a slot made in thehost unit 2. A host controller (not shown) provided in thehost unit 2 exchanges various signals and data with thecard controller 12 in thememory card 1 via the first to ninth pins. For example, when data is written into thememory card 1, the host controller sends a write commend to thecard controller 12 via the second pin in the form of a serial signal. At this time, in response to the clock signal supplied to the fifth pin, thecard controller 12 takes in the write command supplied to the second pin. - As described above, the write command is input serially to the
card controller 12 using only the second pin. As shown inFIG. 2 , the second pint allocated to the input of a command is provided between the first pin fordata 3 and the third pin for ground potential Vss. A plurality of signal pins 13 and abus interface 14 for the signal pins 13 are used for the communication between the host controller in thehost unit 2 and thememory card 1. - In contrast, the communication between the
flash memory 11 and thecard controller 12 is performed by an interface for NAND flash memory. Thus, although not shown here, theflash memory 11 and thecard controller 12 are connected to each other with, for example, 8-bit input/output (I/O) lines. - For example, when the
card controller 12 writes data into theflash memory 11, thecard controller 12 inputs data input command 80H, a column address, a page address, data, and program command 10H to theflash memory 11 sequentially via the I/O lines. Here, “H” in command 80H represents hexadecimal number. Actually, an 8-bit signal of “10000000” is supplied in parallel to the 8-bit I/O lines. That is, in the NAND flash memory interface, a plurality of bits in a command are supplied in parallel. - Moreover, in the NAND flash memory interface, the command and data for the
flash memory 11 are transmitted using the same I/O lines. As described above, the interface used for the communication between the host controller andmemory card 1 in thehost unit 2 differs from the interface used for the communication between theflash memory 11 andcard controller 12. - Next, the internal configuration of the card controller included in the
memory card 1 ofFIG. 1 will be explained usingFIG. 3 .FIG. 3 is a block diagram of thecard controller 12. - The
card controller 12 manages the physical state of the flash memory 11 (for example, at what physical block address what number logical sector address data is included or which block is in the erased state). - The
card controller 12 includes ahost interface module 21, a microprocessor unit (MPU) 22, aflash controller 23, a read-only memory (ROM) 24, a random access memory (RAM) 25, and abuffer 26. - The
host interface module 21 executes an interfacing process between thecard controller 12 and thehost apparatus 2. - The
MPU 22 controls the operation of theoverall memory card 1. For example, when thememory card 1 is supplied with power, theMPU 22 reads the firmware (control program) stored in theROM 24 into theRAM 25 and carries out a specific process, thereby creating various tables on theRAM 25. Moreover, theMPU 22 receives a write command, a read command, or an erase command from thehost unit 2 and then performs a specific process on theflash memory 11 or controls a data transfer process via thebuffer 26. - The
ROM 24 stores a control program or the like controlled by theMPU 22. TheRAM 25 is used as a work area of theMPU 22 and stores the control program and various tables. Theflash controller 23 executes an interfacing process between thecard controller 12 and theflash memory 11. - The
buffer 26 stores a specific amount of data (e.g., a page of data) temporarily when the data sent from thehost unit 2 is written into theflash memory 11 or when the data read from theflash memory 11 is sent to thehost unit 2. - Next, the internal configuration of the
NAND flash memory 11 will be explained briefly.FIG. 4 is a block diagram of theNAND flash memory 11. As shown inFIG. 4 , theNAND flash memory 11 includes amemory cell array 30 and apage buffer 31. - The
memory cell array 30 includes a plurality of memory cell blocks BLK0 to BLKn (n is a natural number equal to or larger than 2). Hereinafter, the memory cell blocks BLK0 to BLKn may be simply referred to as the memory blocks BLK. Data is erased in memory blocks BLK. That is, the data in the same memory cell block BLK is erased simultaneously. Each of the memory cell blocks BLK includes a plurality of memory cells MC. - Each memory cell is a MOS transistor having a stacked gate including a charge accumulation layer (for example, a floating gate in the embodiment) and a control gate. In a memory cell block BLK, a plurality of word lines WL0, WL1, . . . (hereinafter, referred to as word lines WL) and bit lines BL0, BL1, . . . (hereinafter, referred to as bit lines BL) perpendicular to the word lines WL are provided. The memory cells in the same row are connected equally to the same word line. The memory cells MC in the same column are connected equally to a bit line BL in units of a plurality of memory cells. Data is written and read in units of a set of a plurality of memory cells. A set of memory cells is called one page. In a read operation and a write operation, a word line WL is selected according to a row address and a bit line BL is selected according to a column address. In the example of
FIG. 4 , each page of theflash memory 11 has 2112 bytes (a 512-byte data storage section×4+a 10-byte redundant section×4+a 24-byte management data storage section). Each memory block BLK includes, for example, 128 pages. - The
page buffer 31, which inputs and outputs data to and from theflash memory 11, holds the data temporarily. The data size thepage buffer 31 can hold is 2112 bytes (2048 bytes+64 bytes), which is the same as the page size of each memory block BLK. When data is written, thepage buffer 11 inputs and outputs data to and from theflash memory 11 in units of one page corresponding to its own memory capacity. Hereinafter, to simplify the explanation, the redundant section and the management data storage section are omitted and the data size of one page is assumed to be 2048 bytes. - Next, a data writing method in the memory system with the above configuration will be explained. First, a process carried out mainly by the
card controller 12 will be explained usingFIG. 5 .FIG. 5 is a flowchart to help explain the processing in thecard controller 12. - As shown in
FIG. 5 , first, thecard controller 12 receives from the host unit 2 a data write instruction and an address in which data is to be written in the NAND flash memory 11 (step S10). Then, thecard controller 12 receives write data from the host unit 2 (step S11). Thecard controller 12 then outputs a first write instruction, the write data, and the address to theflash memory 11. Receiving the first write instruction, theflash memory 11 recognizes the start of a write operation. Here, it is when a second write operation described later is given that data is actually written into the memory cells MC. - Next, the
MCU 22 of thecard controller 12 determines whether a write access end or interrupt instruction has been received from the host unit 2 (step S13). If none of them have been received (No in step S13), theMCU 22 outputs a second write instruction to the flash memory 11 (step S14). In step S14, theflash memory 11 waits for a continued input write data, the second write instruction or the reset instruction from thecard controller 12. - If either the end instruction or interrupt instruction has been given in step S13 (Yes in step S13), the
MCU 22 determines whether the write data transferred to theflash memory 11 satisfies the page size in the flash memory 11 (step S15). That is, theMCU 22 determines whether the data size of the write data is equal to or less than 2048 bytes. If the condition is satisfied, that is, if the data size is 2048 bytes (Yes in step S16), theMCU 22 outputs the second write instruction to the flash memory 11 (step S17). If the condition is not fulfilled, that is, if the data size is less than 2048 bytes (No in step S16), theMCU 22 issues a row address change instruction and a new row address and outputs them to the flash memory 11 (step S18) and then carries out the process of step S17. - The signals given from the
card controller 12 to theflash memory 11 in the above processes will be explained usingFIG. 6 .FIG. 6 is a timing chart for the signals output from thecard controller 12 to theflash memory 11. In the upper part ofFIG. 6 , the signals output when there is neither an end instruction nor an interrupt instruction (No in step S13) or when the write data has satisfied the page size (Yes in step S16) are shown. In the lower part of theFIG. 6 , the signals output when the write data has not satisfied the page size (No in step S16) are shown. - As shown in
FIG. 6 , in each case, first, at time to, a first write instruction is output. Thereafter, addresses (row address and column address) and the write data are output at time t1 and time t2 in sequence, respectively. Then, when there is neither an end instruction nor an interrupt instruction, or when the write data has satisfied the page size, a second write instruction is output at time t4, which completes the flow of a series of signals. When the write data has not satisfied the page size, the transfer of data ends at time t3 earlier than time t4, since the amount of data is less than when the page size has been satisfied. Then, following the write data, a row address change instruction is output at time t3 and a new row address is output at time t5. Thereafter, a second write instruction is output at time t6. In the latter case, an effective row address is not the row address output at time t1 but a new row address output at time t5. The new row address is an address corresponding to a memory block BLK differing from the memory block BLK to which the first row address corresponds. - Next, a process carried out mainly by the
NAND flash memory 11 will be explained usingFIG. 7 .FIG. 7 is a flowchart to help explain the processing in theflash memory 11. As shown inFIG. 7 , first, theflash memory 11 receives a first write instruction, write data, and an address from the card controller 12 (step S20). Then, theflash memory 11 determines whether it has received a row address change instruction and a new row address (step S21). If theflash memory 11 has received neither a row address change instruction nor a new row address (No in step S22), it receives a second write instruction from the card controller 12 (step S23) and then writes data into the memory cell MC specified by the row address and column address received in step S20 (step S24). If the flash memory has received a row address change instruction (Yes in step S22), it receives a second write instruction (step S25) and then writes data into the memory cell MC specified by the column address received in step S20 and a new row address received after the row address change instruction (step S26). - The way the write operation is carried out will be explained using
FIGS. 8 and 9 .FIGS. 8 and 9 are block diagrams of a memory system.FIG. 8 shows a case where there is neither an end instruction nor an interrupt instruction (No in step S13) or where the write data has satisfied the page size (Yes in step S16).FIG. 9 shows a case where the write data has not satisfied the page size (No in step S16). BothFIG. 8 andFIG. 9 show a case where the page size of one page is 2048 bytes and the card controller 112 transfers data in units of 512 bytes to theflash memory 11. InFIGS. 8 and 9 , the shaded areas show write data. - First,
FIG. 8 will be explained. As shown inFIG. 8 , write data supplied from thehost unit 2 is stored in thebuffer 26 of thecard controller 12. Moreover, an address is given to thecard controller 12. Then, thecard controller 12 transfers the write data in thebuffer 26 to thepage buffer 31.FIG. 8 shows the way four items of data each having a data size of 512 bytes, that is, 2048 bytes of write data, are transferred to thepage buffer 31. In step S12, thecard controller 12 transfers a row address to therow decoder 32 in theflash memory 11. On the basis of the row address given in step S12, therow decoder 32 selects any one of the word lines WL. InFIG. 8 , the word line WL in memory block BLK0 is selected. Then, in response to the second write instruction, the write data in thepage buffer 31 is written into the memory cell MC connected to the selected word line WL. - Next,
FIG. 9 will be explained.FIG. 9 shows the way data is transferred to thepage buffer 31 in such a manner that four items of data each having a data size of 512 bytes, that is, 2048 bytes of write data, are written into each of two pages of memory block BLK0, and then three items of data each having a data size of 512 bytes, that is, 1536 bytes of write data, are written into consecutive addresses in memory block BLK0. Only what differs fromFIG. 8 will be explained. - It is assumed that the row address given to the
flash memory 11 in step S12 corresponds to the word line WL in memory block BLK0. After determining that the data in the buffer 26 (or page buffer 31) is less than the page size (1536 bytes<2048 bytes), theMCU 22 of thecard controller 12 outputs a row address change instruction to theflash memory 11 and further issues a new row address and outputs it to therow decoder 32. Suppose the new row address corresponds to the word line WL in memory block BLK1. Then, on the basis of the new row address, therow decoder 32 selects the word line WL in memory block BLK1, not in memory block BLK0. Then, in response to the second write instruction, 1536 bytes of write data in thepage buffer 31 are written into the memory cell MC connected to the word line WL selected by therow decoder 32. - The memory system with the above configuration produces the following effect.
- (1) Data Write Speed can be Improved.
- With the memory system of the first embodiment, when the data in the
page buffer 31 falls short of the page size, the data is written into a memory block BLK differing from the memory block BLK into which the data has been written so far. That is, there is no need to wait for a write operation until the data in the page buffer has reached the page size. Accordingly, the write speed can be improved. In the method according to the embodiment using the row address change instruction, since the data with a page size is not required to be stored in the buffer of thecard controller 12, the controller can transmit the data to the NAND flash memory without delay, therefore the data write speed can be improved compared to the method that the reset instruction is issued and data is re-input to inhibit writing data and change the row address, and data write is carried out in wait for storing the data with the page size in the buffer of the controller. - Furthermore, with the memory system of the first embodiment, the
card controller 12 issues a row address change instruction and a new row address. When receiving the row address change instruction, theflash memory 11 selects the row direction of thememory cell array 30 on the basis of the new row address. Then, the data transferred to thepage buffer 31 can be written into a different memory block BLK at high speed. - In this respect, when the
card controller 12 has no row address change instruction, if an attempt is made to write the data in thepage buffer 31 into a different memory block BLK, the card controller has to transfer the data again to the page buffer. Specifically, when the row address is changed, the card controller outputs a reset instruction to cancel the write instruction. Next, the card controller issues a first write instruction to specify a new row address. Then, the card controller inputs data to the page buffer again. Finally, the card controller issues a second write operation. As described above, the retransfer of data to the page buffer is needed, which leads to loss of time. With the first embodiment, however, since the retransfer of data is not needed, the data write speed can be improved. - Next, a memory system according to a second embodiment of the invention will be explained. The second embodiment relates to a method of aggregating a plurality of data items each having a data size of less than one page into one page (hereinafter, referred to as data aggregation) with the configuration of the first embodiment.
FIG. 10 is a flowchart to help explain a data aggregating method in a memory system according to the second embodiment. A NAND flash memory of the second embodiment is such that the configuration shown inFIGS. 8 and 9 explained in the first embodiment further includes a data cache. The data cache holds data in pages temporarily as the page buffer does. - As shown in
FIG. 10 , first, theMCU 22 of thecard controller 12 outputs a read instruction to the flash memory 11 (step S30). The read instruction may be a read instruction as a part of a data aggregate instruction, not just an ordinary data read instruction. Thecard controller 12 gives an address together with the read instruction to theflash memory 11. Next, theflash memory 11 selects a page corresponding to the address given in step S30 and reads data in pages into the data buffer (step S31). Thereafter, the data read into the page buffer is transferred to the data cache (step S32). Then, the data transferred to the data cache is transferred to thebuffer 26 of the card controller 12 (step S33). -
FIG. 11 is a diagram to help explain step S30 to step S33.FIG. 11 is a block diagram of thecard controller 12 andflash memory 11. As shown inFIG. 11 , memory block BLK0 holds data D1 whose data size corresponds to two pages, or is 4096 bytes. Memory block BLK1 holds data D2 whose data size is less than the page size, for example, 1536 bytes. Memory block BLKn holds data D3 whose data size is less than the page size, for example, 512 bytes. With this configuration, 1536-byte data D2 and 512-byte data D3 are aggregated into 2048 bytes of data, that is, one-page-size data, which is then written into memory block BLK0. This will be explained below. - As shown in
FIG. 11 , when receiving a read instruction from thecard controller 12, therow decoder 32 selects a word line WL in, for example, memory block BLK1. As a result, the data on the page including data D2 is read in pages into thepage buffer 31. Hereinafter, the data read in pages may be referred to page data. The page data read at this point in time includes not only 1536-byte data D2 but also 512 (=2048-1536) bytes of unnecessary data. Then, data D2 in the page data read into thedata buffer 31 is transferred to thedata cache 33 and further to thebuffer 26. - To return to
FIG. 10 , the explanation is continued. After step S33, theMCU 22 of thecard controller 12 checks data D2 transferred to thebuffer 26 for an error. If having detected an error, theMCU 22 corrects the error. Moreover, while thecard controller 12 is performing error detection and error correction, theflash memory 11 reads data differing from the data in step S31 in pages into the page buffer 31 (step S34). -
FIG. 12 is a diagram to help explain step S34. As shown inFIG. 12 , therow decoder 32 selects any one of the word lines WL in, for example, memory block BLKn. As a result, the data on a page including 512-byte data D3 is read in pages into thepage buffer 31. The row address corresponding to the word line WL selected in step S34 may be given in step S30 or at any point in time before thecard controller 12 performs error detection and error correction. At this time, thecard controller 12 determines which data item (here, data D3) should be read to aggregate the data item and data D2 into a data size of one page. Specifically, since thecard controller 12 holds a table showing in which area what data has been stored, it selects appropriate data with reference to the table. While in the example ofFIG. 12 , data is read from memory block BLKn different from memory block BLK0, data may be read from another page in the same memory block BLK0. - To return to
FIG. 10 , the explanation is continued. After step S34, the flash memory transfers only the necessary data of the data read into thepage buffer 31 in step S34 to the data cache 33 (step S35). At this time, thedata cache 33 holds data falling short of the page size transferred in step S32. That is, thedata cache 33 has a free area. In other words, since data is read in pages in step S32, not only necessary data but also unnecessary data on the same page as that of the necessary data are held in thedata cache 33. Similarly, since in step S34, too, data is read in pages, unnecessary data is also read into the data buffer. To overcome this problem, in step S35, only the necessary data of the data read in pages in step S34 is transferred to the area in which unnecessary data has been held in thedata cache 33. As a result, the data cache holds the data falling short of the page size read in step S32 and the data falling short of the page size read in step S34, which are aggregated to produce just the same data size as one page (step S36). That is, two data items are aggregated into a page size. Thereafter, the data transferred to thedata cache 33 in step S35 is transferred to thebuffer 26 of the memory controller 12 (step S37). Then, theMCU 22 performs error detection and error correction (step S38). -
FIG. 13 is a diagram to help explain step S35 to step S38. As shown inFIG. 13 , only the necessary data D3 of the page data including data D3 read into thedata buffer 31 is transferred to thedata cache 33. Since 1536-byte data D3 is held in thedata cache 33, thecache 33 has the remaining 512-byte free area. Thus, 512-byte data D3 is transferred to the free area. As a result, thedata cache 33 holds data D2 and data D3. The data size of an aggregate of data D2 and data D3 is 2048 bytes, just the data size of one page. Then, data D3 in thedata cache 33 is transferred to thebuffer 26. - To return to
FIG. 10 , the explanation is continued. After step S38, if theMCU 22 has detected an error in any data item and corrected the error (Yes in step S39), it transfers the corrected data to the data cache 33 (step S40). At this time, theMCU 22 transfers only the corrected data to thedata cache 33, thereby replacing the uncorrected data. Then, theflash memory 11 writes the data held in thedata cache 33 into the memory cell MC in pages (step S41). -
FIG. 14 is a diagram to help explain step S39 to step S41. As shown inFIG. 14 , if the data has been corrected, the data in thedata cache 33 is replaced with the corrected data. Then, the data in the data cache 33 (2048 bytes of data obtained by aggregating data D2 and data D3) is transferred to thedata buffer 33 and further written into thememory cell array 30. Specifically, therow decoder 32 selects the word line WL corresponding to the address continuous with data D1 in memory block BLK0. This enables data D2 and data D3 to be written into the same page in memory block BLK0. The row address for therow decoder 32 to select a word line WL may be given from thecard controller 12 to therow decoder 32 in step S41. Alternatively, the row address may be given in step S30 or step S40. - The memory system as described above produces the effect described in item (2) below.
- (2) The Aggregation of Data Falling Short of the Page Size is Made Easier and Faster.
- With the memory system of the second embodiment, the
page buffer 31 exchanges data with thedata cache 33 in units smaller than page units. This enables the aggregation of data to be made easier and the data aggregating speed to be made faster. - Data exchange between the page buffer and the data cache was generally performed in page size units. In this method, however, the process of aggregating data falling short of the page size into a page had to be carried out at the
buffer 26 in thecard controller 26. Moreover, for example, when two data items read in two read operations were aggregated, the data cache held the data read later and could not hold the data read earlier. Therefore, regardless of whether there is an error in the read data, the aggregated data has to be transferred from thebuffer 26 of thecard controller 12 to thedata cache 33. The transfer leads to loss of time in the aggregating process. - In the second embodiment, however, data exchange between the
page buffer 31 anddata cache 33 is carried out in units smaller than the page units. Accordingly, a plurality of data items can be aggregated into a page in thedata cache 33. If there is an error in the data, only the corrected data has to be transferred from thebuffer 26 to thedata cache 33. However, if there is no error, the transfer is not needed. - Consequently, the data aggregating process can be made easier and faster.
- Next, a memory system according to a third embodiment of the invention will be explained. The third embodiment is such that a method according to the second embodiment is applied to a data write operation. Specifically, the third embodiment relates to a method of forming data to be written into page size data by aggregating data when write data has a data size smaller than the page size at the time of writing data. First, a process carried out mainly by the
card controller 12 will be explained usingFIG. 15 .FIG. 15 is a flowchart to help explain the processing in thecard controller 12. - As shown in
FIG. 15 , the processes in step S10 to step S17 are the same as those in the first embodiment and an explanation of them will be omitted. If the result of the determination in step S15 has shown that the data size of the write data is smaller than the page size (No in step S16), theMCU 22 of thecard controller 13 outputs a write cancel instruction to the flash memory 11 (step S50). The write cancel instruction is an instruction to cause theflash memory 11 to stop a subsequent write operation. Then, theMCU 22 outputs a data read instruction to the flash memory 11 (step S51). TheMCU 22 supplies not only the read instruction but also the address for the data to be read to theflash memory 11. The data to be read in step S51 forms just one-page-size data when it is aggregated with the data determined to fall short of the page size in step S15 and step S16. - Then, when data is read at the
flash memory 11, theMCM 22 performs error detection and error correction on the read data (step S52). Thereafter, theMCU 22 transfers only the error-corrected data to theflash memory 11 and further instructs theflash memory 11 to write the data to the data cache 33 (step S53). - Next, using
FIG. 16 , a process carried out mainly by theNAND flash memory 11 will be explained. In the third embodiment, an operation when a write cancel instruction is output in step S50 will be explained. The remaining operation is the same as in the first embodiment.FIG. 16 is a flowchart to help explain the processing in theflash memory 11. - As shown in
FIG. 16 , first, theflash memory 11 receives a write cancel instruction from the card controller 12 (step S60). Receiving the write cancel instruction, theflash memory 11 stops writing data and holds the data in thedata cache 33 as it is (step S61). Then, on the basis of the read instruction given from thecard controller 12 in step S51, theflash memory 11 reads data in pages into the page buffer 31 (step S62). Of the data read into thepage buffer 31, only the necessary data is transferred to the data cache 33 (step S35). As a result, thedata cache 33 holds the write data falling short of the page size and the data falling short of the page size read in step S62, which are aggregated to produce the same size as one page (step S36). That is, two data items are aggregated into page-size data. Thereafter, the data transferred to thedata cache 33 in step S35 is transferred to thebuffer 26 of the memory controller 12 (step S37). The processes in step S35 to step S37 are as explained in the second embodiment. - Thereafter, if the data has been corrected, the corrected data is received from the MCU 22 (step S63) and then the data in the
data cache 33 is written into a page corresponding to the original row address (step S41). - The way the write operation is carried out will be explained using
FIGS. 17 to 19 .FIG. 17 is a block diagram of the memory system.FIGS. 18 and 19 are block diagrams of the memory card. InFIGS. 17 to 19 , the data size of one page is 2048 bytes and thecard controller 12 transfers data in units of 512 bytes to theflash memory 11. In the figures, the shaded areas show write data. As shown inFIG. 17 , in a state where data D4 whose data size is smaller than the page size, for example, a 512-byte data size, has been written in memory block BLKn, it is assumed that data D5 whose data size corresponds to two pages (2048×2=4096 bytes) and data D6 whose data size is smaller than the page size, for example, a 1536-byte data size, are written sequentially in memory block BLK0. Then, consider a case where data D5 has already written in memory block BLK0 and data D6 is written in an address continuous with data D5. - First, as shown in
FIG. 17 , since data D6 falls short of the page size, theMCU 22 outputs a write cancel instruction to theflash memory 11. Then, therow decoder 32 of theflash memory 11 makes the word line WL unselected, thereby stopping the operation of writing data D6 transferred to thedata cache 33 into memory block BLK0. - Next, as shown in
FIG. 18 , theMCU 22 outputs to theflash memory 11, for example, a read instruction to read data D4 from memory block BLKn and an address. In response to this, theflash memory 11 reads the data in the page including data D4 from memory block BLKn in pages into thedata buffer 31. Of the page data read into thedata buffer 31, only data D4 of the 512-byte data size is transferred to thedata cache 33. At this time, since 1536-byte data D6 is held in thedata cache 33, there is a 512-byte free area left. Thus, 512-byte data D4 is transferred to the free area. As a result, in thedata cache 33, data D6 and data D4 are aggregated into exactly a one-page size of data. Moreover, data D4 in thedata cache 33 is transferred to thebuffer 26 of thecard controller 12, followed by error detection and error correction. - Thereafter, as shown in
FIG. 19 , when error correction has been performed, the corrected data is written into thedata cache 33, with the result that data D6 and data D4 held in thedata cache 33 are written into the same page in memory block BLK0. The page into which data D4 and data D6 are written is an area corresponding to an address continuous with data D5 where data D6 was to originally be written. - The memory system with the above configuration produces not only the effect in item (2) explained in the second embodiment but also the effect in item (3) below.
- (3) The Data Aggregating Process can be Made More Efficient.
- With the memory system of the third embodiment, using data exchange between the
page buffer 31 anddata cache 33 in units less than page units, data is aggregated in writing data. This makes it possible to carry out the data aggregating process efficiently. - As described above, with the configuration according to each of the first to third embodiments, the operating speed of the NAND flash memory can be improved. When data is aggregated in the second and third embodiments, information on what data should be read and aggregated to produce exactly one-page data size is held by the
card controller 12 in, for example, theRAM 25 in the form of a table. Specifically, since thecard controller 12 has grasped in what address what data size of data has been written, any suitable one of them is selected and a read instruction is issued. - Furthermore, applying the second and third embodiments to a file system produces a more prominent effect. Hereinafter, the file system will be explained briefly. The file system is a system of managing files (data) stored in a memory. Hereinafter, explanation will be given taking a file allocation table (FAT) file system as an example. In the file system, a method of creating directory information, such as files or folders, in a memory, a method of moving files or folders, a method of erasing files or folders, a method of storing data, management area locations, a method of using management areas, and others are determined.
FIG. 20 is a conceptual diagram of the memory space of aNAND flash memory 11 according to each of the above embodiments. - As shown in
FIG. 20 , the memory space is roughly divided into auser data area 40 and amanagement area 41. Theuser data area 40 is an area which stores net data written by the user. - The
management area 41 includes, for example, aboot area 42, apartition information area 43, a FAT1 (44), a FAT2 (45), and a rootdirectory entry area 46. Theboot area 42 stores, for example, boot information. - The
partition information area 43 stores partition information. The FAT1 and FAT2 store in what address data has been stored. Hereinafter, FAT1 and FAT2 will be explained briefly. - The
user data area 40 includes a plurality of areas called clusters. If data to be written is larger than a cluster size, the data is divided into clusters, which are then stored. At this time, clusters into which data is written may be inconsecutive. That is, an item of data is written into clusters separate from one another. In this case, management data for indicating in which clusters the divided items of data have been written is stored in FAT1 and FAT2. - The root
directory entry area 46 stores information on root directory entries. The rootdirectory entry area 46 further stores not only file names or folder names, file sizes, attributes, and file update time and date but also flags indicating which clusters shown in FAT1 and FAT2 are first clusters of files. - Each item of data (hereinafter, referred to as management data) in the management area, particularly FAT1 and FAT2, is frequently updated and has a small data size, generally falling short of one page. In a NAND flash memory, since data is prevented from being overwritten, data frequently updated is written temporarily into any erase memory block (referred to as a cache block). Each time the data is updated, it is written into the cache block sequentially. Then, with specific timing, the latest data in the cache block is transcribed into another memory block (which is referred to as cache reconstruction). From the viewpoint of the speeding up of cache reconstruction, it is desirable to use a method according to the first to third embodiments. On this point, explanation will be given below.
-
FIG. 21 is a conceptual diagram of memory block BLK0. As shown inFIG. 21 , suppose memory block BLK0 includes 128 pages and addresses“000,” “001,” “002,” . . . “1FF” are allocated in units of 512 bytes in each page. Consider a case where five writes A to E have been done on memory block BLK0. In write A, 512 bytes of data are written in address “000.” In write B, 1024 bytes of data are written in address “005.” In write C, 2048 bytes of data are written in address “03F.” In write D, 1024 bytes of data are written in address “000.” In write E, 1024 bytes of data are written in address “003.” These items of write data are data items frequently updated, such as management data. Suppose they are first written into the cache block. - First, cache reconstruction by a conventional method will be explained using
FIG. 22 .FIG. 22 is a conceptual diagram of the cache block and memory block BLK0, showing the way cache reconstruction is performed. - First, write A is done on
page 1 of the cache block. Next, write B is done onpage 2 of the cache block. Then, write C is done onpage 3 andpage 4 of the cache block. Then, write D is done onpage 6 of the cache block. - Thereafter, cache reconstruction is performed. First, data to be written in address “000” is the data written in write D. That is, the data written in write A has been overwritten with the data in write D and becomes unnecessary. Therefore, first, data is read from
page 5 of the cache block. Next, since address “002” of memory block BLK0 has not been updated, the data in address “002” of memory block BLK0 is read to use the original data as it is. Moreover, since the data in address “003” is the data written in write E, data is read frompage 6 of the cache block. As a result of the three data reads, data items to be written intopage 1 of memory block BLK0 are aggregated. - Next, cache reconstruction when the embodiments are applied will be explained using
FIG. 23 .FIG. 23 is a conceptual diagram of the cache block and memory block BLK0, showing the way cache reconstruction is performed. - First, as in the conventional method, write A is done on
page 1 of the cache block. Next, write B is done onpage 2 of the cache block. Then, write C is done onpage 3 andpage 4 of the cache block. Then, write D is done onpage 6 of the cache block. These write operations differ from those in the conventional method in that one-page size of data obtained by aggregating data with the data in memory block BLK0 is written into the cache block. - Specifically, when
page 1 is written into, 512 bytes of data given in write A and 1536 bytes of data in address “001” to “003” of memory block BLK0 are aggregated and written intopage 1. The same holds true for writing intopage 2 and onward. Whenpage 6 is written into, 512 bytes of data given in write E, data D from the cache block, and data in address “002” are aggregated. - Thereafter, cache reconstruction is performed. The data corresponding to
page 1 of memory block BLK0 is held inpages page 6 which holds the latest data is read and written intopage 1 of memory block BLK0. The data inpage 2 of the cache block is transcribed intopage 2 of memory block BLK0. - Specifically, in the embodiments, when data is written into the cache block, write data and another item of data in the preceding block are aggregated into one-page size of data. The resulting data is written into the cache block. Therefore, at the time of cache reconstruction, data is updated in pages. Accordingly, a read operation at the time of cache reconstruction has to be carried out only once per page, which makes it possible to speed up cache reconstruction.
- Moreover, memory block BLK0 has to be caused to correspond to the cache block for each 512-byte area in
FIG. 22 , leading to a tremendous amount of information. However, in the case ofFIG. 23 where the embodiments have been applied, memory block BLK0 has to be caused to correspond to the cache block in pages, which enables the amount of correspondence information to be decreased. - Furthermore, the above method is desirable from the viewpoint of not only cache reconstruction and correspondence relationship but also reading from the host unit. That is, to perform file system operations, including the update of FATs, efficiently, the host unit generally reads data in a batch to some extent in advance. Specifically, in the flash memory, small data size random writing may be performed in a FAT area or the like and a specific large amount of data obtained by aggregating the small data sizes may be read. In such a case, too, with the method of the third embodiment, small sizes of data get together in pages, enabling the operating speed to be improved, since the read operation at the cache reconstruction has to be carried out only once per page.
- Additional advantages and modifications will readily occur to those skilled in the art. Therefore, the invention in its broader aspects is not limited to the specific details and representative embodiments shown and described herein. Accordingly, various modifications may be made without departing from the spirit or scope of the general inventive concept as defined by the appended claims and their equivalents.
Claims (16)
1. A memory system comprising:
a nonvolatile semiconductor memory which has a plurality memory blocks each including memory cells capable of holding data, the data in each of the memory blocks being erased simultaneously, and the data being written simultaneously in pages in each of the memory blocks, each of the pages being a set of a plurality of memory cells; and
a controller which transfers write data and a first row address to the nonvolatile semiconductor memory and issues a change instruction for the transferred first row address and a second row address differing from the first row address, the nonvolatile semiconductor memory writing the write data into the memory cells corresponding to the first row address when the change instruction has not been issued, and writing the write data into the memory cells corresponding to the second row address when the change instruction has been issued.
2. The system according to claim 1 , wherein the controller, when a data size of the write data is smaller than a page size, issues the change instruction and the second row address, and
the second row address corresponds to the memory block differing from the memory block corresponding to the first row address.
3. The system according to claim 1 , wherein the controller outputs a first write instruction, the first row address, the write data, and a second write instruction sequentially to the nonvolatile semiconductor memory, and
when issuing the change instruction, outputs the change instruction and the second row address sequentially to the nonvolatile semiconductor memory after outputting the write data to the nonvolatile semiconductor memory,
the second instruction is output to the nonvolatile semiconductor memory after the second row address is output,
the first write instruction is an instruction to cause the nonvolatile semiconductor memory to recognize that a data write operation is started, and
the second write instruction is an instruction to cause the nonvolatile semiconductor memory to write the write data into the memory cell block.
4. The system according to claim 1 , wherein the controller determines whether a data size of the write data is smaller than a page size when having received a write access end or a stop instruction for the data from a host unit.
5. The system according to claim 1 , wherein the write data is management data in a FAT file system.
6. A memory system comprising:
a nonvolatile semiconductor memory which has a plurality memory blocks each including memory cells capable of holding data, the data in each of the memory blocks being erased simultaneously, and the data being written simultaneously in pages in each of the memory blocks, each of the pages being a set of a plurality of memory cells; and
a controller which controls the operation of the nonvolatile semiconductor memory, the nonvolatile semiconductor memory including
the memory blocks,
a first buffer circuit which exchanges the data with the memory blocks in pages and is capable of holding data with a page size, and
a second buffer circuit which exchanges the data with the first buffer circuit and the controller in data units smaller than the page size and is capable of holding data with the page size.
7. The system according to claim 6 , wherein the controller issues a data read instruction, a first row address, and a second row address to the nonvolatile semiconductor memory,
the nonvolatile semiconductor memory reads, into the second buffer circuit, first page data which corresponds to the first row address and includes first data falling short of the page size and further reads, into the first buffer circuit, second page data which corresponds to the second row address and includes second data falling short of the page size, and
the first buffer circuit transfers only the second data in the second page data to an area which holds data other than the first data in the second buffer circuit.
8. The system according to claim 7 , wherein the second buffer circuit transfers the first data and the second data to the controller,
the controller checks the transferred first data and second data for an error and, if having detected an error, corrects the error and transfers at least either the error-corrected first data or second data to the second buffer circuit, and
if the controller has corrected the error, at least either the corrected first or second data is written into the nonvolatile semiconductor memory.
9. The system according to claim 8 , wherein the controller, if the result of checking for an error has shown that no error has been detected, does not transfer the second data to the second buffer circuit, and
the first and second data held in the second buffer circuit are written into the nonvolatile semiconductor memory.
10. The system according to claim 6 , wherein the controller, when data is written, not only issues a first row address but also transfers first data to the second buffer circuit and, when the data size of the first data transferred to the second buffer circuit is smaller than the page size, issues a write stop instruction, a data read instruction, and a second row address,
the nonvolatile semiconductor memory, in response to the write stop instruction, stops the write operation, while holding the first data in the second buffer circuit and, in response to the read instruction, reads page data corresponding to the second address and including second data falling short of the page size into the first buffer circuit,
the first buffer circuit transfers only the second data in the page data to an area which holds data other than the first data in the second buffer circuit, and
the second buffer circuit writes the first and second data simultaneously into the memory cells corresponding to the first row address.
11. The system according to claim 10 , wherein the second buffer circuit transfers the second data transferred from the first buffer circuit to the controller,
the controller checks the transferred second data for an error and, if having detected an error, corrects the error and transfers the error-corrected second data to the second buffer circuit, and
the first data held in the second buffer circuit and the second data transferred to the second buffer circuit are written into the nonvolatile semiconductor memory.
12. The system according to claim 11 , wherein the controller, if the result of checking for an error has shown that no error has been detected, does not transfer the second data to the second buffer circuit, and
the first and second data held in the second buffer circuit are written into the nonvolatile semiconductor memory.
13. A card controller for controlling a nonvolatile semiconductor memory comprising:
a host interface which is configured to be connectable to a host unit and receives write data and a first row address from the host unit; and
an arithmetic processing unit which transfers the write data to the nonvolatile semiconductor memory having a plurality of memory blocks each including memory cells capable of holding data and issues a change instruction for the first row address and a second row address differing from the first row address, the data in each of the memory blocks being erased simultaneously, the write data being written simultaneously in pages in each of the memory blocks, each of the pages being a set of a plurality of memory cells in each of the memory blocks, and the arithmetic processing unit, according to the change instruction, instructing the nonvolatile semiconductor memory to write the write data into the memory cells corresponding to the second row address.
14. The controller according to claim 13 , wherein the arithmetic processing unit issues the change instruction and the second row address when a data size of the write data is smaller than a page size, and
the second row address corresponds to the memory block differing from the memory block corresponding to the first row address.
15. The controller according to claim 13 , wherein the arithmetic processing unit outputs a first write instruction, the first row address, the write data, and a second write instruction sequentially to the nonvolatile semiconductor memory, and
when issuing the change instruction, outputs the change instruction and the second row address sequentially to the nonvolatile semiconductor memory after outputting the write data to the nonvolatile semiconductor memory,
the second instruction is output to the nonvolatile semiconductor memory after the second row address is output,
the first write instruction is an instruction to cause the nonvolatile semiconductor memory to recognize that a data write operation is started, and
the second write instruction is an instruction to cause the nonvolatile semiconductor memory to write the write data into the memory cell block.
16. The controller according to claim 13 , wherein the arithmetic processing unit determines whether the data size of the write data is smaller than a page size when having received a write access end or a stop instruction for the data from the host unit.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US13/078,647 US20110185225A1 (en) | 2006-06-30 | 2011-04-01 | Memory system with nonvolatile semiconductor memory |
Applications Claiming Priority (4)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
JP2006-182631 | 2006-06-30 | ||
JP2006182631A JP5002201B2 (en) | 2006-06-30 | 2006-06-30 | Memory system |
US11/770,344 US7937523B2 (en) | 2006-06-30 | 2007-06-28 | Memory system with nonvolatile semiconductor memory |
US13/078,647 US20110185225A1 (en) | 2006-06-30 | 2011-04-01 | Memory system with nonvolatile semiconductor memory |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US11/770,344 Continuation US7937523B2 (en) | 2006-06-30 | 2007-06-28 | Memory system with nonvolatile semiconductor memory |
Publications (1)
Publication Number | Publication Date |
---|---|
US20110185225A1 true US20110185225A1 (en) | 2011-07-28 |
Family
ID=39011388
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US11/770,344 Expired - Fee Related US7937523B2 (en) | 2006-06-30 | 2007-06-28 | Memory system with nonvolatile semiconductor memory |
US13/078,647 Abandoned US20110185225A1 (en) | 2006-06-30 | 2011-04-01 | Memory system with nonvolatile semiconductor memory |
Family Applications Before (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US11/770,344 Expired - Fee Related US7937523B2 (en) | 2006-06-30 | 2007-06-28 | Memory system with nonvolatile semiconductor memory |
Country Status (5)
Country | Link |
---|---|
US (2) | US7937523B2 (en) |
JP (1) | JP5002201B2 (en) |
KR (1) | KR100884429B1 (en) |
CN (1) | CN101097543B (en) |
TW (1) | TWI358020B (en) |
Cited By (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20110154162A1 (en) * | 2009-12-23 | 2011-06-23 | Phison Electronics Corp. | Data writing method for a flash memory, and flash memory controller and flash memory storage apparatus using the same |
US9659621B2 (en) | 2013-02-26 | 2017-05-23 | Samsung Electronics Co., Ltd. | Semiconductor memory and memory system including the semiconductor memory |
Families Citing this family (37)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
FI103329B1 (en) * | 1997-12-22 | 1999-06-15 | Nordberg Lokomo Oy | Ways to attach a wear jaw to a jaw crusher and jaw crusher |
JPWO2008102610A1 (en) * | 2007-02-23 | 2010-05-27 | パナソニック株式会社 | MEMORY CONTROLLER, NONVOLATILE STORAGE DEVICE, AND NONVOLATILE STORAGE SYSTEM |
JP5032155B2 (en) * | 2007-03-02 | 2012-09-26 | 株式会社東芝 | Nonvolatile semiconductor memory device and nonvolatile semiconductor memory system |
US7962683B2 (en) * | 2007-08-15 | 2011-06-14 | Silicon Motion, Inc. | Flash memory, and method for operating a flash memory |
US8185685B2 (en) | 2007-12-14 | 2012-05-22 | Hitachi Global Storage Technologies Netherlands B.V. | NAND flash module replacement for DRAM module |
JP4653817B2 (en) * | 2008-03-01 | 2011-03-16 | 株式会社東芝 | Memory system |
JP4592774B2 (en) * | 2008-03-01 | 2010-12-08 | 株式会社東芝 | Memory system |
KR101067457B1 (en) | 2008-03-01 | 2011-09-27 | 가부시끼가이샤 도시바 | Memory system |
TWI385519B (en) * | 2008-04-18 | 2013-02-11 | Phison Electronics Corp | Data writing method, and flash storage system and controller using the same |
JP4649503B2 (en) * | 2008-08-13 | 2011-03-09 | 株式会社東芝 | Semiconductor device |
TWI413984B (en) * | 2008-10-16 | 2013-11-01 | Silicon Motion Inc | Flash memory apparatus and updating method |
US8549209B2 (en) * | 2008-11-04 | 2013-10-01 | Mosaid Technologies Incorporated | Bridging device having a configurable virtual page size |
US8700840B2 (en) * | 2009-01-05 | 2014-04-15 | SanDisk Technologies, Inc. | Nonvolatile memory with write cache having flush/eviction methods |
US8244960B2 (en) * | 2009-01-05 | 2012-08-14 | Sandisk Technologies Inc. | Non-volatile memory and method with write cache partition management methods |
US8094500B2 (en) * | 2009-01-05 | 2012-01-10 | Sandisk Technologies Inc. | Non-volatile memory and method with write cache partitioning |
CN101859605B (en) * | 2009-04-10 | 2013-05-01 | 国民技术股份有限公司 | Method using flaw flash memory |
TWI435215B (en) * | 2009-08-26 | 2014-04-21 | Phison Electronics Corp | Method for giving read commands and reading data, and controller and storage system using the same |
JP5657242B2 (en) * | 2009-12-09 | 2015-01-21 | 株式会社東芝 | Semiconductor device and memory system |
JP5708216B2 (en) * | 2011-05-09 | 2015-04-30 | ソニー株式会社 | Flash memory device, memory control device, memory control method, and storage system |
JP5768654B2 (en) * | 2011-10-25 | 2015-08-26 | ソニー株式会社 | Storage control device, storage device, information processing system, and storage control method |
CN103680610A (en) * | 2012-09-03 | 2014-03-26 | 北京兆易创新科技股份有限公司 | Method and device for write operation of NAND Flash storage device with differential storage |
WO2014138118A1 (en) * | 2013-03-07 | 2014-09-12 | Peddle Charles I | High speed flash controllers |
US9069660B2 (en) * | 2013-03-15 | 2015-06-30 | Apple Inc. | Systems and methods for writing to high-capacity memory |
US20150095551A1 (en) * | 2013-09-30 | 2015-04-02 | Micron Technology, Inc. | Volatile memory architecutre in non-volatile memory devices and related controllers |
JP6107625B2 (en) * | 2013-12-02 | 2017-04-05 | ソニー株式会社 | Storage control device, storage device, information processing system, and storage control method thereof |
US9460019B2 (en) * | 2014-06-26 | 2016-10-04 | Intel Corporation | Sending packets using optimized PIO write sequences without SFENCEs |
JP2016028319A (en) * | 2014-07-08 | 2016-02-25 | 富士通株式会社 | Access control program, access control device, and access control method |
KR20170008339A (en) * | 2015-07-13 | 2017-01-24 | 에스케이하이닉스 주식회사 | Memory system and operating method of memory system |
US11112990B1 (en) | 2016-04-27 | 2021-09-07 | Pure Storage, Inc. | Managing storage device evacuation |
US11809727B1 (en) * | 2016-04-27 | 2023-11-07 | Pure Storage, Inc. | Predicting failures in a storage system that includes a plurality of storage devices |
CN109582235B (en) * | 2018-11-27 | 2021-12-21 | 杭州宏杉科技股份有限公司 | Management metadata storage method and device |
CN109815711B (en) * | 2018-12-21 | 2020-12-25 | 航天信息股份有限公司 | Storage device, data storage method and data reading method |
KR20210142974A (en) * | 2020-05-19 | 2021-11-26 | 에스케이하이닉스 주식회사 | Storage device and operating method thereof |
JP2022047855A (en) | 2020-09-14 | 2022-03-25 | キオクシア株式会社 | Memory system |
CN113409849A (en) * | 2021-05-21 | 2021-09-17 | 芯天下技术股份有限公司 | Method, device, storage medium and terminal for reducing programming power consumption |
CN113409852A (en) * | 2021-06-17 | 2021-09-17 | 芯天下技术股份有限公司 | Method, device, storage medium and terminal for improving flash memory programming efficiency |
CN113409850A (en) * | 2021-06-17 | 2021-09-17 | 芯天下技术股份有限公司 | Method, device, storage medium and terminal for improving programming efficiency |
Citations (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5604702A (en) * | 1993-09-20 | 1997-02-18 | Sgs-Thomson Microelectronics S.A. | Dynamic redundancy circuit for memory in integrated circuit form |
US20040027856A1 (en) * | 2002-07-05 | 2004-02-12 | Aplus Flash Technology, Inc. | Combination nonvolatile memory using unified technology with byte, page and block write and simultaneous read and write operations |
US20040145952A1 (en) * | 2003-01-28 | 2004-07-29 | Jian Chen | Non-volatile semiconductor memory with large erase blocks storing cycle counts |
US20070028155A1 (en) * | 2005-07-04 | 2007-02-01 | Kim Moo-Sung | Flash memory device having single page buffer structure and related programming method |
US7529879B2 (en) * | 2004-06-30 | 2009-05-05 | Samsung Electronics Co., Ltd. | Incremental merge methods and memory systems using the same |
Family Cites Families (17)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4680647A (en) * | 1983-09-26 | 1987-07-14 | Pioneer Electronic Corporation | Method for recording and reproducing video format signal |
US5371885A (en) * | 1989-08-29 | 1994-12-06 | Microsoft Corporation | High performance file system |
GB2285524B (en) | 1994-01-11 | 1998-02-04 | Advanced Risc Mach Ltd | Data memory and processor bus |
US6047352A (en) * | 1996-10-29 | 2000-04-04 | Micron Technology, Inc. | Memory system, method and predecoding circuit operable in different modes for selectively accessing multiple blocks of memory cells for simultaneous writing or erasure |
JPH11224492A (en) | 1997-11-06 | 1999-08-17 | Toshiba Corp | Semiconductor memory, non-volatile semiconductor memory, and flash memory |
JPH11242630A (en) * | 1997-12-26 | 1999-09-07 | Mitsubishi Electric Corp | Base band ic |
JP2000067582A (en) * | 1998-08-14 | 2000-03-03 | Texas Instr Inc <Ti> | Memory system and operating method for electronic device |
US6449193B1 (en) * | 2000-12-28 | 2002-09-10 | Texas Instruments Incorporated | Burst access memory system |
JP3979486B2 (en) | 2001-09-12 | 2007-09-19 | 株式会社ルネサステクノロジ | Nonvolatile storage device and data storage method |
CN100349138C (en) | 2003-08-08 | 2007-11-14 | 倚天资讯股份有限公司 | Non-volatility memory access system and its cycling usage method of access space |
JP2005063038A (en) | 2003-08-08 | 2005-03-10 | Sony Corp | Data processing device, method thereof, program thereof, and recording medium |
JP4287433B2 (en) | 2003-11-18 | 2009-07-01 | パナソニック株式会社 | File recording device |
JP2005332125A (en) | 2004-05-19 | 2005-12-02 | Victor Co Of Japan Ltd | Memory controller and shared memory system |
JP4253272B2 (en) * | 2004-05-27 | 2009-04-08 | 株式会社東芝 | Memory card, semiconductor device, and control method of semiconductor memory |
JP4713867B2 (en) * | 2004-09-22 | 2011-06-29 | 株式会社東芝 | Memory controller, memory device, and memory controller control method |
US7366826B2 (en) * | 2004-12-16 | 2008-04-29 | Sandisk Corporation | Non-volatile memory and method with multi-stream update tracking |
JP4738038B2 (en) | 2005-03-25 | 2011-08-03 | 株式会社東芝 | Memory card |
-
2006
- 2006-06-30 JP JP2006182631A patent/JP5002201B2/en not_active Expired - Fee Related
-
2007
- 2007-06-28 KR KR1020070064437A patent/KR100884429B1/en not_active IP Right Cessation
- 2007-06-28 US US11/770,344 patent/US7937523B2/en not_active Expired - Fee Related
- 2007-06-29 TW TW096123646A patent/TWI358020B/en not_active IP Right Cessation
- 2007-07-02 CN CN2007101269602A patent/CN101097543B/en not_active Expired - Fee Related
-
2011
- 2011-04-01 US US13/078,647 patent/US20110185225A1/en not_active Abandoned
Patent Citations (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5604702A (en) * | 1993-09-20 | 1997-02-18 | Sgs-Thomson Microelectronics S.A. | Dynamic redundancy circuit for memory in integrated circuit form |
US20040027856A1 (en) * | 2002-07-05 | 2004-02-12 | Aplus Flash Technology, Inc. | Combination nonvolatile memory using unified technology with byte, page and block write and simultaneous read and write operations |
US20040145952A1 (en) * | 2003-01-28 | 2004-07-29 | Jian Chen | Non-volatile semiconductor memory with large erase blocks storing cycle counts |
US7529879B2 (en) * | 2004-06-30 | 2009-05-05 | Samsung Electronics Co., Ltd. | Incremental merge methods and memory systems using the same |
US20070028155A1 (en) * | 2005-07-04 | 2007-02-01 | Kim Moo-Sung | Flash memory device having single page buffer structure and related programming method |
Cited By (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20110154162A1 (en) * | 2009-12-23 | 2011-06-23 | Phison Electronics Corp. | Data writing method for a flash memory, and flash memory controller and flash memory storage apparatus using the same |
US8276033B2 (en) * | 2009-12-23 | 2012-09-25 | Phison Electronics Corp. | Data writing method for a flash memory, and flash memory controller and flash memory storage apparatus using the same |
US9659621B2 (en) | 2013-02-26 | 2017-05-23 | Samsung Electronics Co., Ltd. | Semiconductor memory and memory system including the semiconductor memory |
Also Published As
Publication number | Publication date |
---|---|
US20080046639A1 (en) | 2008-02-21 |
TWI358020B (en) | 2012-02-11 |
KR20080002646A (en) | 2008-01-04 |
KR100884429B1 (en) | 2009-02-19 |
CN101097543B (en) | 2010-06-23 |
CN101097543A (en) | 2008-01-02 |
JP2008009942A (en) | 2008-01-17 |
JP5002201B2 (en) | 2012-08-15 |
TW200819976A (en) | 2008-05-01 |
US7937523B2 (en) | 2011-05-03 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US7937523B2 (en) | Memory system with nonvolatile semiconductor memory | |
US8681552B2 (en) | System and method for accessing and storing interleaved data | |
US7392343B2 (en) | Memory card having a storage cell and method of controlling the same | |
US9122611B2 (en) | Method for giving read commands and reading data, and controller and storage system using the same | |
US8356134B2 (en) | Memory device with non-volatile memory buffer | |
US5953737A (en) | Method and apparatus for performing erase operations transparent to a solid state storage system | |
EP1242868B1 (en) | Organization of blocks within a nonvolatile memory unit to effectively decrease sector write operation time | |
JP4524309B2 (en) | Memory controller for flash memory | |
US7814264B2 (en) | Memory card, semiconductor device, and method of controlling semiconductor memory | |
US7404031B2 (en) | Memory card, nonvolatile semiconductor memory, and method of controlling semiconductor memory | |
US11630766B2 (en) | Memory system and operating method thereof | |
US20050172068A1 (en) | Memory card and semiconductor device | |
US20020194451A1 (en) | Memory controller, flash memory system employing memory controller and method for controlling flash memory device | |
US8321633B2 (en) | Memory card and method for storing data on memory card | |
US20110055457A1 (en) | Method for giving program commands to flash memory, and controller and storage system using the same | |
US20100042777A1 (en) | Semiconductor device including memory cell having charge accumulation layer and control gate and data write method for the same | |
US9619380B2 (en) | Data writing method, memory control circuit unit and memory storage apparatus | |
US9378130B2 (en) | Data writing method, and memory controller and memory storage apparatus using the same | |
CN109815158A (en) | Carry out method, memory storage and the controller and electronic device of system backup | |
US11586379B2 (en) | Memory system and method of operating the same | |
US8180951B2 (en) | Memory system and method of controlling the memory system | |
US20080109588A1 (en) | Memory Card and Method of Driving the Same | |
US20230236963A1 (en) | Memory system |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
STCB | Information on status: application discontinuation |
Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION |