Abstract:
The invention concerns a solid state memory, comprising multiple logical units. The solid state memory contains an internal buffer for temporarily storing the incoming data steam before the incoming data are programmed to at least one page. The internal buffer keeps data that are not yet programmed in case a switch from one logical unit to another is performed. A method for operating such a device is presented.

Description:
FIELD OF THE INVENTION 
       [0001]    The present invention concerns a solid state memory, for example being organized in targets, each target containing one or more logical units (LUN), each logical unit containing one or more blocks and each block containing one or more pages. Such a device is e.g. a NAND flash memory device, which is designed according to the Open NAND Flash Interface Specification (ONFI). 
       BACKGROUND OF THE INVENTION 
       [0002]    Such devices are known from US patent publication US2008/0183949, which describes a method for programming a flash memory. Programming within this context is understood by a person skilled in the art as writing or storing bits in the flash memory cells. Programming data on a flash memory is done by programming data of one page at one time. If not enough data is provided at the end of the data stream to program a full page, the page programmed at the end of the data stream is only partially filled. If the data stream to be programmed continues later on, there is a partially filled page between other fully filled pages. This can be regarded as insufficient. A better solution is provided by reading out again the partially filled data page and completing the data with data later provided to be written and then programming a full data page to the flash memory. Partially filled pages are reduced at the cost of additional read and programming cycles. 
         [0003]    US patent publication US2006/0136656 describes a block as the minimum erasable unit of a flash memory. It further describes the problem of partially filled pages which cannot be erased easily because the minimum erasable unit is not a page but a block. Thus, the flash memory is worn down unnecessarily. 
         [0004]    The effect of partially filled pages also arises when a switching operation between two logical units is performed. When a switch from a first logical unit to a second logical unit is performed, the data left in an input buffer is programmed to the first logical unit and after that the switching to the second logical unit is made. If later on data are programmed to the first logical unit, a new page is used for programming the data and thus, partially used pages arise in the logical unit. 
         [0005]    According to the Open NAND Flash Interface Specification (ONFI), writing data to a NAND Flash device is done by issuing a PROGRAM PAGE command with the corresponding logical unit number (LUN), block address and page address to the target. Afterwards data of a complete memory page, usually multiple kilobytes, is written to the page register of the selected logical unit. When a full page is written to the page register, the logical unit starts to program the data to its memory array. During programming, the logical unit is busy and the next page can be written to the logical units&#39; page register after programming of the first page is finished. After a complete page has been written to the page register and the page program has been started, the other logical units of the target could be selected and used. The ONFI specification provides also a possibility to program partial pages, but that would implicate additional programming times and the reachable bandwidth would decrease. 
         [0006]    The following programming instructions are defined according to the ONFI specification:
       PAGE PROGRAM: Data is written to the data register and programming starts after the data phase has finished.   PAGE CACHE PROGRAM: Data is written to the data register and after the data phase is finished, the content of the data register is copied to the cache register and programming starts.   PAGE PROGRAM INTERLEAVED: Data is written to multiple data registers of one LUN and programming starts when the last data register is filled.       
 
         [0010]    The known page program flow is used to write a complete data page to the page register of the NAND device and to start the programming to the memory array. Each procedure causes a number of state switches of the target state machine and the logical unit state machine. The state switches of the state machines in dependence of the procedure are shown below: 
         [0000]    
       
         
               
               
               
             
           
               
                   
               
               
                 Procedure 
                 Target State Sequence 
                 LUN State Sequence 
               
               
                   
               
             
             
               
                 Write Command 80h 
                 T_Idle 
                 L_Idle 
               
               
                 to NAND device 
                 -&gt; T_Cmd_Decode 
                   
               
               
                   
                 -&gt; T_PP_Execute 
                   
               
               
                   
                 -&gt; T_PP_AddrWait 
                   
               
               
                 Write LUN-, block- 
                 T_PP_AddrWait 
                 L_Idle 
               
               
                 and page-address 
                 -&gt; T_PP_Addr 
                 -&gt; 
               
               
                 to NAND device 
                 -&gt; T_PP_LUN_Execute  
                 L_Idle_TargetRequest 
               
               
                   
                 -&gt; T_PP_LUN_DataWait 
                 -&gt; L_ PP Execute 
               
               
                   
                   
                 -&gt; L_PP_Addr 
               
               
                   
                   
                 -&gt; L_PP_WaitForData 
               
               
                 Write complete 
                 T_PP_LUN_DataWait 
                   
               
               
                 data page to NAND 
                 -&gt; T_PP_LUN_ DataPass 
                 L_PP_WaitForData 
               
               
                 device 
                 -&gt; T_PP_LUN DataWait 
                 -&gt; L_PP_AcceptData 
               
               
                   
                   
                 -&gt; L_PP_WaitForData 
               
               
                 Write Command 10h 
                 T_PP_LUN_DataWait 
                   
               
               
                 to NAND device 
                 -&gt; T_PP_Cmd_Pass 
                 L_PP_WaitForData 
               
               
                   
                 -&gt; T_Idle 
                 -&gt; L_PP_Prog 
               
               
                   
                   
                 -&gt; L_PP_ProgWait 
               
               
                   
                   
                 -&gt; L_PP_Sts 
               
               
                   
                   
                 -&gt; L_Idle 
               
               
                   
               
             
          
         
       
     
         [0011]    Interleaved operations enable to issue multiple commands of the same type to different blocks of the same logical unit. The known interleaved page program flow is used to write complete data pages to multiple independent page registers of a logical unit and to start the programming to the memory array when all registers are filled. 
         [0000]    
       
         
               
               
               
             
           
               
                   
               
               
                 Procedure 
                 Target State Sequence  
                 LUN State Sequence 
               
               
                   
               
             
             
               
                 Write Command  
                 T_Idle 
                 L_Idle 
               
               
                 80h to NAND  
                 -&gt; T_Cmd_Decode 
                   
               
               
                 device 
                 -&gt; T_PP_Execute 
                   
               
               
                   
                 -&gt; T_PP_AddrWait 
                   
               
               
                 Write LUN-, block-  
                 T_PP_AddrWait 
                 L_Idle 
               
               
                 and page-address 
                 -&gt; T_PP_Addr 
                 -&gt; L_Idle_TargetRequest 
               
               
                 to NAND device 
                 -&gt; T_PP_LUN_Execute 
                 -&gt; L_PP_Execute 
               
               
                   
                 -&gt; T_PP_LUN_DataWait 
                 -&gt; L_PP_Addr 
               
               
                   
                   
                 -&gt; L_PP_WaitForData 
               
               
                 Write complete 
                 T_PP_LUN_DataWait 
                 L_PP_WaitForData 
               
               
                 data page to  
                 -&gt; T_PP_LUN_DataPass 
                 -&gt; L_PP_AcceptData 
               
               
                 NAND device 
                 -&gt; T_PP_LUN_DataWait 
                 -&gt; L_PP_WaitForData 
               
               
                 Write Command  
                 T_PP_LUN_DataWait 
                 L_PP_WaitForData 
               
               
                 11h to NAND  
                 -&gt; T_PP_Cmd_Pass 
                 -&gt; L_PP_Ilv 
               
               
                 device 
                 -&gt; T_PP_IlvWait 
                 -&gt; L_PP_Ilv_Wait 
               
               
                 Write Command  
                 T_PP_IlvWait 
                 L_PP_Ilv_Wait 
               
               
                 80h* to NAND  
                 -&gt; T_PP_AddrWait 
                   
               
               
                 device 
                   
                   
               
               
                 Write LUN-, block- 
                 T_PP_AddrWait 
                 L_PP_Ilv_Wait 
               
               
                 and page-address 
                 -&gt; T_PP_Addr 
                 -&gt; L_PP_Addr 
               
               
                 to NAND device 
                 -&gt; T_PP_LUN_Execute 
                 -&gt; L_PP_WaitForData 
               
               
                   
                 -&gt; T_PP_LUN_DataWait 
                   
               
               
                 Write complete 
                 T_PP_LUN_DataWait 
                 L_PP_WaitForData 
               
               
                 data page to NAND 
                 -&gt; T_PP_LUN_DataPass 
                 -&gt; L_PP_AcceptData 
               
               
                 device 
                 -&gt; T_PP_LUN_DataWait 
                 -&gt; L_PP_WaitForData 
               
               
                 Write Command  
                 T_PP_LUN_DataWait 
                 L_PP_WaitForData 
               
               
                 10h to NAND  
                 -&gt; T_PP_Cmd_Pass 
                 -&gt; L_PP_Prog 
               
               
                 device 
                 -&gt; T_Idle 
                 -&gt; L_PP_ProgWait 
               
               
                   
                   
                 -&gt; L_PP_Sts 
               
               
                   
                   
                 -&gt; L_Idle 
               
               
                   
               
               
                 *The address cycles for the program operation of state ‘T_PP_IlvWait’ is intended to have a different interleaved block address than the one issued in the preceding program operation. 
               
             
          
         
       
     
         [0012]    If data of two independent sources are recorded in independent LUNs of a target, one of the above described processes is first issued to the first LUN for the first independent source and after finishing the writing process, one of the above described processes is issued to the second LUN for writing the data of the second independent source to the second LUN. 
         [0013]    When independent concurrent streams should be recorded to a flash device, it is advantageous to write the different streams to different logical units. The file management is easier with such a regular strategy and the full bandwidth of a logical unit is guaranteed for recording of an incoming data stream. If data of the streams arrive in blocks of smaller size than the page size, there is a need to cache data of each stream in a cache arranged outside of the flash device and to write it to the NAND Flash device, when a full page for one logical unit is ready to be programmed. Depending on the amount of streams and logical units, a lot of cache memory is needed outside the memory device, while the available page register inside the device remains unused. 
       SUMMARY OF THE INVENTION 
       [0014]    It is an object of the invention to provide a solid state memory and a method for operating a solid state memory which reduces the problem of partially filled pages. It is a further object of the invention to provide a solid state memory and a method for operating a solid state memory which reduces the need for outside cache memory and which makes use of the internal page registers in case multiple incoming data streams are programmed to a flash device. 
         [0015]    In order to use the page register of a logical unit as input buffer for the corresponding incoming data stream, an active logical unit has to be switched to dependent on the nature of the currently incoming stream, even if the pages on the other logical units can not yet be completely filled. The ONFI specification does not address this problem and does not provide a dedicated mechanism. 
         [0016]    According to the invention, a solid state memory for storing at least one incoming data stream has multiple logical units within one target. Each logical unit has at least one page for programming data to the memory. The solid state memory contains an internal buffer memory, often called page register, for temporarily storing the incoming data stream before the incoming data are programmed to at least one page. Further, the internal buffer memory keeps data, which are not yet programmed, when a switching operation between different logical units is performed. This has the advantage that in the event of switching from a first logical unit to a second logical unit the remaining data, which is not yet enough to completely fill a page, does not need to be programmed but is kept in the page register. If later on, more data for this logical unit is provided, this data is added to the remaining data and the remaining data and the new data are programmed together as a full page. This enhances the overall bitrate for programming a specific logical unit because programming only partial pages is omitted. As programming of a full page and of a partial page needs almost the same time, less programming cycles are necessary for programming a specific amount of data in case care is taken to program only full pages in any possible case. Further, the problem of pages in the solid state memory device that are only partially filled with data in the solid state memory device is omitted. The solid state memory is more efficiently used. 
         [0017]    Advantageously, the solid state memory is organized as groups of targets, wherein each target contains at least one logical unit. Each logical unit is provided with a page register for temporarily storing the incoming data to be programmed to this logical unit. Further, each logical unit contains at least one block. Erasing the memory is done blockwise. Each block contains at least one page. Data stored to be in one page is programmed at one time. 
         [0018]    Preferably, each logical unit of the solid state memory has an internal buffer for temporarily storing the incoming data stream before the data is programmed to the pages. The size of the internal buffer is at least the size of one page plus the size of data received during the programming cycle of a page at highest allowable input bitrate. Thus: 
         [0000]      Size internalBuffer ≧Size Page +Time PageProgramCycle *Bitrate InputData  
 
         [0019]    This has the advantage that during programming of a page also the data for programming the next page can be received in the internal buffer. An internal buffer of the size of for example two pages can receive data for a whole page to be programmed during the programming cycle of another page, if the bitrate of the input data is high enough. Thus, the overall waiting times are reduced and the bitrate of the solid state memory is further enhanced. 
         [0020]    Advantageously, the storage device is a NAND Flash device, which is operated according to the Open NAND Flash Interface (ONFI) specification. The ONFI specification does not foresee a specific algorithm to omit partially programmed pages if switching between different logical units is performed and to reduce programming times and thus programming bitrate in case of partial page programming. The proposed memory device has the advantage that it is essentially in accordance with the ONFI specification and omits partial pages at the same time. A device according to the invention deviates only from the known implementation of the ONFI standard. The program instructions of the ONFI standard are still used. The deviation from the implementation rules as known in the art is not in contradiction to the ONFI standard. Thus, a device according to the invention can still be regarded as being in compliance with the ONFI standard. Further, programming times are reduced because complete pages are programmed whenever appropriate. Besides that, the invention concerns a solid state storage device, which operates in a page oriented way and which is applicable for example for streaming applications, especially for streaming of several video sources in parallel, as central storage device for capturing measurement data of a research environment, especially for capturing of several measurement data streams in parallel or similar environments. 
         [0021]    Preferably, the solid state memory is part of a video capturing camera system with one or more cameras. The data issued by the cameras are provided to the solid state memory device. Advantageously, the solid state memory stores data streams captured by different cameras in different logical units. Preferably, the camera system is provided for 3D video capturing. In this case several video streams, at least one of which is of high data rate are generated. That video data streams have to be stored in real time in parallel. The solid state memory provides several advantages for a camera system as described above. Storing the data streams of different cameras in different logical units has the advantage that an easy file structure is provided and the data are organized in accordance with the hierarchical memory structure. Thus, especially using a camera system with more than one camera, as it is for example mandatory for 3D capture, multiple data streams have to be stored at the same time. In addition, the data stream output by a camera has usually a high data rate. Using high definition cameras (HD), the data stream of one camera is for example up to 2 Gbits/s. The solid state storage according to the invention is especially advantageous for such systems, because the input data rate of the storage device is not unnecessarily reduced by writing and reading partially filled pages. A benefit is high in systems with multiple cameras, wherein data streams of different cameras are stored in different logical units, because switching between different logical units is done regularly in such systems and the problem of pages that are not written in one cycle or that are only partially written would arise frequently. Besides 3D capture, also multidimensional capture is in the focus of the film industry. The invention is also dedicated to scene captures of a multidimensional environment in real time. 
         [0022]    Preferably, a method is implemented for operating a solid state storage device comprising at least one logical unit. Each logical unit comprises at least one page and a page being programmed at one time. In the method according to the invention, at least one incoming data stream is sequentially input into the solid state memory. The data is temporarily stored in an internal buffer, the page register. The internal buffer is for example a buffer as described above and allocated to a logical unit. A checking step is performed whether the internal buffer contains an amount of data that is sufficient for one complete page to be programmed. If the internal buffer contains sufficient data for one complete page to be programmed, at least one complete page is programmed. Sufficient data for one complete page may be just slightly more data than necessary for one complete page, but it may also be data that is sufficient to fill several complete pages. If a switching operation is performed between different logical units, not yet programmed data of the internal buffer of the logical unit that is currently active is kept in the internal buffer. The switching between the logical units is then performed. This has the advantage that before switching from a first logical unit to a second logical unit the remaining data which does not fill a complete page does not need to be programmed but is kept in the internal buffer and is still kept after switching is finished. If, later on, more data for this logical unit is provided, this data is added to the remaining data and the remaining data and the new data are programmed together as a full page. This reduces the overall programming time because programming of a partial page needs approximately the same processing time as programming a full page. Thus, by programming only full pages, the programming bandwidth is enhanced. Further, the problem of pages which are only partially filled with data during one programming cycle in the solid state memory device is omitted. The solid state memory is more efficiently used. 
         [0023]    Advantageously, the method is used for storing the input data streams which are captured by different cameras in different logical units. Storing the data streams of different cameras in different logical units has the advantage that an easy file structure is provided and the data are organized in accordance with the hierarchical memory structure. Thus, especially using a camera system with more than one camera, as it is for example mandatory for 3D capture, multiple data streams have to be stored at the same time. In addition, the data stream output by a camera has usually a high data rate. Using high definition cameras (HD), the data stream of one camera is for example up to 2 Gbits/s. The provided solid state storage is especially advantageous for such systems, because the input data rate of the storage is not unnecessarily reduced by reading and writing partial pages. The benefit is high in systems with multiple cameras, wherein data streams of different cameras are stored in different logical units, because switching between different logical units is done regularly in such system and the problem of partial pages would arise often. Besides 3D capture, also multidimensional capture is in the focus of the film industry. The invention is also dedicated to scene captures of a multidimensional environment. 
         [0024]    Preferably, the method operates according to the Open NAND Flash Interface (ONFI) specification. Advantageously, after data for one logical unit was received in a data register and in case a switch of the logical&#39;unit is to be performed, the target is set into state T_PP_Ilv_Wait using the Page Program Interleaved command  11   h . Using this command, the logical unit is set into state L_PP_Ilv_Wait. Subsequently, the target is kept in state T_PP_Ilv_Wait and the logical unit is kept in state L_PP_Ilv_Wait until the data register of a LUN is filled with a full page. Then, these data are programmed to a page using the commands  10   h  or  15   h . Setting the target into state T_PP_LUN_DataWait and setting logical units into state L_PP_WaitForData after programming a full page to a logical unit using the commands  10   h  or  15   h  to prevent the target from deleting the data from the page register of the addressed logical unit. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0025]    For better understanding the invention shall now be explained in more detail in the following description with reference to the figures. It is understood that the invention is not limited to these exemplary embodiments and that specified features can also expediently be combined and/or modified without departing from the scope of the present invention. 
           [0026]      FIG. 1  depicts the hierarchical structure of a solid state memory device 
           [0027]      FIG. 2  depicts a method for operating a solid state memory device according to the invention 
           [0028]      FIG. 3  depicts a state diagram of a target according to the invention 
           [0029]      FIG. 4  depicts a state diagram of a logical unit according to the invention 
           [0030]      FIG. 5  depicts a state diagram of a solid state memory comprising one target and two logical units according to the invention 
       
    
    
     DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS 
       [0031]      FIG. 1  depicts a structure of a NAND flash memory, which is operated by the ONFI specification command set according to the invention. The NAND flash memory is organized as a target. A target contains one or multiple logical units LOGICAL UNIT  0 , LOGICAL UNIT  1 , . . . , LOGICAL UNIT L, each logical unit LOGICAL UNIT  0 , LOGICAL UNIT  1 , . . . , LOGICAL UNIT L contains multiple blocks BLOCK  0 , BLOCK  1 , . . . , BLOCK M and a block BLOCK  0 , BLOCK  1 , . . . , BLOCK M contains multiple pages PAGE  0 , PAGE  1 , . . . , PAGE N. A page PAGE  0 , PAGE  1 , . . . , PAGE N is typically a read or write unit. This means that a page contains the smallest number of data that can be read or written in one step. A block BLOCK  0 , BLOCK  1 , . . . , BLOCK M is typically an erase unit. This means that a block contains the smallest number of data that can be erased in one step. A logical unit LOGICAL UNIT  0 , LOGICAL UNIT  1 , . . . , LOGICAL UNIT L is an operating unit that operates independently. Each logical unit LOGICAL UNIT  0 , LOGICAL UNIT  1 , . . . , LOGICAL UNIT L contains a page register PAGE REGISTER for temporarily storing data to be written or to be read. Further, each logical unit contains a controller unit CU_LU_ 0 , CU_LU_ 1 , . . . , CU_LU_L for operating the logical unit LOGICAL UNIT  0 , LOGICAL UNIT  1 , . . . , LOGICAL UNIT L. A target TARGET further contains a target control unit CU_TRG for controlling the device on a target level. 
         [0032]      FIG. 2  depicts a program flow of a device according to the invention. In step S 1  it is checked if incoming data is available. 
         [0033]    If incoming data is available (YES), a page program command  80   h  is written to the target in step S 2 . In step S 3  the LUN-, block-, page- and column address is written to the page register of the NAND flash target. In step S 4 , the next data word is written to the NAND flash target. Then, it is checked if a complete page is available in the page register of the flash target in step S 5 . 
         [0034]    If a complete page is available (YES), in step S 8  the data is stored in the respective page of the target using the page program  10   h  or page cache program  15   h  command. In step S 9 , the page- and block-addresses are incremented. Then, a further page program command  80   h  is written to the target in step S 10 . In step S 11  the LUN-, block-, page- and column address is written to the page register of the NAND flash target. 
         [0035]    Step  6  is performed if no complete page is available in step S 5  (NO). Step  6  is also performed after step S 11 . In step  6  it is checked if there are remaining bytes available. If there are remaining bytes available (YES), the method proceeds with step S 4 . If there are no remaining bytes available (NO), an interleaved command  11   h  is written to the NAND in step  7  target and the method proceeds with step S 1 . 
         [0036]    If no incoming data is available in step S 1  (NO), it is checked if the end of the record is reached in step S 12 . If the end of the record is not reached (NO), the method further proceeds with step S 1 . If the end of the record is reached (YES), the method checks in step S 13  if there are unfinished pages left in the register. 
         [0037]    If there are unfinished pages in the register (YES), a page program  80   h  command is written to the NAND target in step S 14  and the LUN-, block-, page- and column address is written to the NAND flash device in step S 15 . Then, the method further proceeds with step S 8 . 
         [0038]    If no unfinished pages are left in the register in step S 13  (NO), the method proceeds with storing the data in the respective page of the target using the page program  10   h  or page cache program  15   h  command in step S 16 . Then, the method restarts with step S 1 . 
         [0039]    It is to be noted that storing data on a page in a logical unit using a page program command or a cache page program command requires two cycles. In the first cycle, both, page program and cache page program, are initiated using the  80   h  command. In the second cycle, the  10   h  command is issued for page program and the  15   h  command is issued for cache page program. 
         [0040]      FIG. 3  depicts a target state diagram according to the invention. The target state diagram according to the invention considered separately corresponds to the target state diagram according to the ONFI standard. The initial state is T_Idle. After a command is received, the target decodes the received command in state T_Cmd_Decode. If the decoded command is a page program  80   h  command, the target switches to state T_PP_Execute. Then, the target sets tLastCmd to  80   h . If R/B# is cleared to zero, then tbStatus 78 hReq is set to TRUE. In addition, all LUNs are requested to clear their page registers. Then, in state T_PP_AddrWait, the target waits for an address cycle. After an address cycle is received, the address cycle received is stored in state T_PP_Addr. If a further address cycle is required, the target switches to back to T_PP_AddrWait to receive the next address cycle. If no further address cycle is required, the target switches to state T_PP_LUN_Execute. The LUN indicated by the row address received is selected and the target issues the program to the LUN. Then the target waits for the data word or command cycle to be received from the host in state T_PP_LUN_DataWait and passes the data word to the selected LUN in state T_PP_LUN_DataPass. When a command is received in T_PP_LUN_DataWait, the target switches to state T_PP_Cmd_Pass. Then, the command is passed to the respective LUN. If the command is an  11   h  command, the target switches to state T_PP_IlvWait to wait for the next command to be issued. If this command is a page program  80   h , the next byte is written to the LUN according to the above described method. On the other hand, if the command is a  10   h  or  15   h  command, the target returns back to the initial state T_Idle. 
         [0041]      FIG. 4  depicts a logical unit state diagram according to the invention. The logical unit state diagram according to the invention considered separately corresponds to the logical unit state diagram according to the ONFI standard. The initial state is L_Idle. After a target request is received for this LUN, the LUN switches to state L_Idle_TargetRequest and waits for the command issued by the target. If the target indicates a program request, the LUN switches to L_PP_Execute and then to L_PP_Addr to record the address received by the target. Further, the correct page register is selected based on the interleaved address and the column in the page register is selected according to the column address received. Then, the LUN receives the data passed by the target in the states L_PP_WaitForData and L_PP_AcceptData. In case the LUN then receives an  11   h  command, the LUN switches to state L_PP_IlvWait until the target requests a further program command for this LUN. In case the LUN receives a  10   h  or  15   h  command in state L_PP_WaitForData, the LUN switches to states L_PP_Prog, L_PP_ProgWait and L_PP_Sts and programs the respective data to the respective pages. 
         [0042]    To illustrate the inventive method in more detail,  FIG. 5  depicts a state diagram of a solid state memory comprising one target and two logical units according to the invention. Thus, the allowable combinations of target states and corresponding logical units LU 1 , LU 2  are shown. It is understood, that the inventive method is also applicable for at least one target containing more than two logical units. Fore sake of simplicity, only states are illustrated in which page program commands or page cache program commands of the first cycle  80   h  or the second cycle  10   h / 15   h  or interleaved commands  11   h  are issued. It is understood that in order to switch from a first state to a second one of the target and of the respective LUN, the state switches according to  FIG. 3  and  FIG. 4  between the first and second state have also to be performed. The state switches are performed as described in the ONFI specification. 
         [0043]    In the initial state S 50 , the target is in idle state T_Idle. The LUNs are as well in the idle states L_Idle. If a page program command of the first cycle  80   h  is received for LU 1 , state S 51  is activated. Thus, the target is switched to T_PP_LUN_DataWait and LU 1  is switched to L_PP_WaitForData. LU 2  has not changed its state. Accordingly, LU 1  is now ready for receipt of data. After data receipt in LU 1 , it is checked if a page program  10   h  or page cache program  15   h  of the second cycle is issued. In this case, the data is programmed to a page of the first logical unit LU 1  and the state machine switches back to idle state S 50 . If an interleaved command  11   h  for LU 1  is issued, the target switches to T_PP_IlvWait and LU 1  switches to L_PP_Ilv_Wait. LU 2  stays in L_idle state. This corresponds to S 52  of  FIG. 5 . Thus, further page program commands  80   h  of the first cycle can be issued either for logical unit LU 1  or LU 2 . In case a page program command  80   h  is issued for LU 1 , the state machine switches back to state S 51 . In case a page program command  80   h  is issued for LU 2 , the state machine switches to S 53 . To issue a page program  80   h  command of the first cycle to a second logical unit, while an interleaved  11   h  command was issued to a first logical unit before, forms part of the inventive character of the method. The state transition is thus indicated by a bold arrow. The target is then waiting for new data or a new command from the host in state T_PP_LUN_DataWait, LU 1  is waiting in state L_PP_IlvWait and LU 2  is waiting for data to be received in state L_PP_WaitForData. As a consequence, LU 1  is not reset to idle state before LU 2  is switched to a state in which it waits for data. Thus, when switching to LU 2  from LU 1  according to the inventive method, data in the page registers from LU 1  are not lost, which is one of the advantages of the inventive method. 
         [0044]    State S 53  is reached after a command of the first cycle was issued to LU 2 , thus in state S 53  a page program command  10   h , a page cache program command  15   h  or an interleaved command  11   h  of the second cycle dedicated to LU 2  are allowable. Issuing a page program command  10   h  or page cache program command  15   h  dedicated to LU 2  leads to T_Idle state of the target and L_Idle state of LU 2 . This corresponds to state S 54  if  FIG. 5 . From state S 54  a page program  80   h  or page cache program  80   h  command of the first cycle can be issued for LU 1  or LU 2 . In case the  80   h  command is issued to LU 1 , the state machines switches to state S 51 . In case the  80   h  command is issued to LU 2 , the state machine switches to S 53 . 
         [0045]    If an interleaved  11   h  command is issued to LU 2  in state S 53 , the target switches to T_PP_IlvWait and LU 2  switches to L_PP_IlvWait. As LU 1  stays in L_PP_IlvWait, the state machine is in state S 59  and is ready to receive the next request of the first cycle either for LU 1  or LU 2 . In case the  80   h  command is issued to LU 1 , the state machine switches to state S 57  for waiting for a command for LU 1 . Switching from state S 59 , which was reached after receiving an interleaved command for LU 2 , to state S 57 , in which the state machine waits for a page program command  10   h , a page cache program command  15   h  or an interleaved command  11   h  of the second cycle dedicated to LU 1  is part of the invention. The known way would be to receive a page program command  80   h  of the first cycle for LU 1  in state S 59 , if state S 59  was reached by an interleaved command  11   h  for LU 2 . The state machine would then switch back to state S 53  for waiting for a command for LU 2  as already described above. 
         [0046]    States S 55 , S 56 , S 57  and S 58  and their state switches correspond to states S 51 , S 52 , S 53  and S 54  and their state switches, if the commands are issued correspondingly for the other logical unit. A detailed description is therefore omitted. 
         [0047]    Thus, the program flow according to the invention uses the interleaved page program  11   h  to bring target and LUN to a state waiting for additional data T_PP_IlvWait and L_PP_IlvWait, respectively. This is the case in states S 52 , S 56  and S 59  according to  FIG. 5 . According to the invention, writing small data blocks of less than one page size to the page register of a fist logical unit, switching to another logical unit and continue writing to the page register of the fist logical unit after a switch back to the first logical unit was made, and then programming a complete page to the first logical unit is enabled. 
         [0048]    The program flow to write data, e.g. of different data sources to different LUNs is as follows. 
         [0000]    
       
         
               
               
               
             
               
             
               
               
               
             
           
               
                   
               
               
                 Procedure 
                 Target State 
                 LUN State 
               
               
                   
               
             
             
               
                 Write Command  
                 T_Idle 
                 L_Idle 
               
               
                 80h to NAND  
                 -&gt; T_Cmd_Decode 
                   
               
               
                 device 
                 -&gt; T_PP_Execute 
                   
               
               
                   
                 -&gt; T_PP_AddrWait 
                   
               
               
                 Write LUN-, block-  
                 T_PP_AddrWait 
                 L_Idle 
               
               
                 and page-address 
                 -&gt; T_PP_Addr 
                 -&gt; L_Idle_TargetRequest 
               
               
                 to NAND device 
                 -&gt; T_PP_LUN_Execute 
                 -&gt; L_PP_Execute 
               
               
                   
                 -&gt; T_PP_LUN_DataWait  
                 -&gt; L_PP_Addr 
               
               
                   
                   
                 -&gt; L_PP_WaitForData 
               
               
                 Write data block 
                 T_PP_LUN_DataWait 
                 L_PP_WaitForData 
               
               
                 of less than 
                 -&gt; T_PP_LUN_DataPass 
                 -&gt; L_PP_AcceptData 
               
               
                 pagesize to NAND 
                 -&gt; T_PP_LUN_DataWait 
                 -&gt;L_PP_WaitForData 
               
               
                 device 
                   
                   
               
               
                 Write Command  
                 T_PP_LUN_DataWait 
                 L_PP_WaitForData 
               
               
                 11h to NAND  
                 -&gt; T_PP_Cmd_Pass 
                 -&gt; L_PP_Ilv 
               
               
                 device 
                 -&gt; T_PP_IlvWait 
                 -&gt; L_PP_Ilv_Wait 
               
             
          
           
               
                 [ . . . write data to other logical units . . . ] 
               
             
          
           
               
                 Write Command  
                 T_PP_IlvWait 
                 L_PP_Ilv_Wait 
               
               
                 80h* to NAND  
                 -&gt; T_PP_AddrWait 
                   
               
               
                 device 
                   
                   
               
               
                 Write LUN-, block-, 
                 T_PP_AddrWait 
                 L_PP_Ilv_Wait 
               
               
                 page- and 
                 -&gt; T_PP_Addr 
                 -&gt; L_PP_Addr 
               
               
                 column-address to 
                 -&gt; T_PP_LUN_Execute 
                 -&gt; L_PP_WaitForData 
               
               
                 NAND device 
                 -&gt; T_PP_LUN_DataWait 
                   
               
               
                 Write additional 
                 T_PP_LUN_DataWait 
                 L_PP_WaitForData 
               
               
                 data to NAND 
                 -&gt; T_PP_LUN_DataPass 
                 -&gt; L_PP_AcceptData 
               
               
                 device, until full 
                 -&gt; T_PP_LUN_DataWait 
                 -&gt; L_PP_WaitForData 
               
               
                 page has been 
                   
                   
               
               
                 written 
                   
                   
               
               
                 Write Command  
                 T_PP_LUN_DataWait 
                 L_PP_WaitForData 
               
               
                 10h to NAND  
                 -&gt; T_PP_Cmd_Pass 
                 -&gt; L_PP_Prog 
               
               
                 device 
                 -&gt; T_Idle 
                 -&gt; L_PP_ProgWait 
               
               
                   
                   
                 -&gt; L_PP_Sts 
               
               
                   
                   
                 -&gt; L_Idle 
               
               
                   
               
               
                 * The address cycles for the page program operation of state T_PP_IlvWait have the same interleaved block address as the one issued in the preceding page program operation, but the column address is incremented to place the further data blocks to the right position in page register.