US20220050685A1 - Memory Systems and Memory Control Methods - Google Patents
Memory Systems and Memory Control Methods Download PDFInfo
- Publication number
- US20220050685A1 US20220050685A1 US17/512,082 US202117512082A US2022050685A1 US 20220050685 A1 US20220050685 A1 US 20220050685A1 US 202117512082 A US202117512082 A US 202117512082A US 2022050685 A1 US2022050685 A1 US 2022050685A1
- Authority
- US
- United States
- Prior art keywords
- executable instructions
- program counter
- instruction
- memory
- executable
- 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.)
- Pending
Links
- 238000000034 method Methods 0.000 title abstract description 15
- 238000006467 substitution reaction Methods 0.000 claims abstract description 24
- 238000001514 detection method Methods 0.000 claims description 4
- 238000012360 testing method Methods 0.000 claims description 4
- 238000004519 manufacturing process Methods 0.000 description 7
- 239000000872 buffer Substances 0.000 description 5
- 238000010586 diagram Methods 0.000 description 4
- 238000003491 array Methods 0.000 description 2
- 230000003068 static effect Effects 0.000 description 2
- 101100113692 Caenorhabditis elegans clk-2 gene Proteins 0.000 description 1
- 101100003180 Colletotrichum lindemuthianum ATG1 gene Proteins 0.000 description 1
- 238000007792 addition Methods 0.000 description 1
- 238000004458 analytical method Methods 0.000 description 1
- 239000004020 conductor Substances 0.000 description 1
- 238000007796 conventional method Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 238000012545 processing Methods 0.000 description 1
- 210000003813 thumb Anatomy 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/32—Address formation of the next instruction, e.g. by incrementing the instruction counter
- G06F9/322—Address formation of the next instruction, e.g. by incrementing the instruction counter for non-sequential address
- G06F9/328—Address formation of the next instruction, e.g. by incrementing the instruction counter for non-sequential address for runtime instruction patching
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/32—Address formation of the next instruction, e.g. by incrementing the instruction counter
- G06F9/321—Program or instruction counter, e.g. incrementing
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/30003—Arrangements for executing specific machine instructions
- G06F9/3005—Arrangements for executing specific machine instructions to perform operations for flow control
- G06F9/30054—Unconditional branch instructions
Definitions
- Embodiments disclosed herein pertain to memory systems and memory control methods.
- Memory devices are widely used in electronic devices, such as computers, digital cameras, personal audio and video players, appliances, vehicles, etc., for storing digital information. Many different types of memory are available, using different fundamental technologies for storing data.
- Memory cells of memory are programmed to have different states to store the digital information.
- Program signals may be applied to the memory cells to change the memory cells from one memory state to another different memory state.
- the memory states of the memory cells may be subsequently read to access the stored digital information.
- Controllers which execute programming may be utilized to control operations with respect to memory.
- programming is often hard-coded as firmware into a memory device and changes to the hard-coded firmware may involve an expensive and time-consuming process.
- At least some example embodiments discussed herein are directed towards memory systems and memory control methods, and more specific example embodiments facilitate modifications and/or additions to executable code of the memory systems as described in detail below.
- FIG. 1 is a functional block diagram of a memory system according to one embodiment.
- FIG. 2 is a functional block diagram which illustrates additional details of a control unit and program memory according to one embodiment.
- FIG. 3 is a timing diagram of operations of the control unit and program memory according to one embodiment.
- FIG. 4 is a flow chart illustrating fetch operations of the control unit according to one embodiment.
- FIG. 1 a functional block diagram of a memory system 10 is shown according to one embodiment.
- the illustrated embodiment of memory system 10 includes main memory 12 , a plurality of buffers 16 a , 16 b , a control unit 18 , substitution circuitry 20 and an algorithm 22 which is stored in program memory (an example embodiment of program memory is shown in FIG. 2 ).
- Other embodiments of memory system 10 may include more, less and/or alternative components or circuitry.
- Memory system 10 may be implemented within or with respect to various associated devices (not shown), such as computers, cameras, media players, and thumb drives, in some illustrative examples. Memory system 10 stores data generated or utilized by the associated devices in the described examples.
- Main memory 12 includes a plurality of arrays of memory cells 14 a , 14 b configured to store data, conductors electrically connected with the memory cells 14 a , 14 b , and additional circuitry, for example circuits of access circuitry (not shown) which may include drivers and sense amplifiers to implement write and read operations with respect to main memory 12 . At least some of the memory cells 14 a , 14 b are individually capable of being programmed to a plurality of different memory states at a plurality of moments in time. Main memory 12 is accessible to the user and/or associated device for storage of digital information.
- main memory 12 is NAND flash memory although the apparatus and methods of the described example embodiments may be utilized with other memory architectures in other embodiments.
- Main memory 12 may be implemented in different arrangements in different embodiments.
- the main memory 12 may be implemented within a memory device, such as a chip, a portion of the chip or other arrangements.
- the memory device may also include other circuitry and components of FIG. 1 or portions thereof.
- Buffers 16 a , 16 b include a plurality of latches which temporarily store data being written to or accessed from main memory 12 in one embodiment.
- the illustrated example memory system 10 includes two planes individually including one of the arrays of memory cells 14 a , 14 b and a corresponding one of the buffers 16 a , 16 b.
- Control unit 18 controls operations of writing, reading and re-writing data of main memory 12 as well as interfacing with other components or circuitry, such as sources of data to be stored within main memory 12 .
- Control unit 18 may access and execute executable instructions and generate commands with respect to main memory 12 during operations of an associated device.
- Example commands instruct the generation of program signals and read signals which are applied to main memory 12 in one embodiment.
- the program signals are used to write data to main memory 12 (i.e., program the memory) during programming operations and the read signals are used to access or sense the contents of the data stored in main memory 12 in one embodiment.
- control unit 18 comprises processing circuitry configured to execute programming (i.e., algorithm 22 ) stored within computer-readable storage media (e.g., program memory 23 of FIG. 2 ) in at least one embodiment.
- programming i.e., algorithm 22
- computer-readable storage media e.g., program memory 23 of FIG. 2
- control unit 18 may be implemented as one or more processor(s) and/or other structure configured to execute executable instructions including, for example, software and/or firmware instructions.
- Substitution circuitry 20 is configured to implement operations with respect to algorithm 22 as described further below.
- substitution circuitry 20 may be configured to implement testing and debugging operations during execution of algorithm 22 as well as implementing operations with respect to modifying and updating algorithm 22 .
- Algorithm 22 is a sequence of procedures to perform read and write operations with respect to main memory 12 .
- one portion of algorithm 22 is hard-coded within non-volatile memory (e.g., read only memory or ROM) and another portion of algorithm 22 is provided to update or modify the hard-coded portion of the algorithm 22 and which may be stored within volatile memory (e.g., static random access memory or SRAM).
- volatile memory e.g., static random access memory or SRAM.
- the updated portion of algorithm 22 stored in volatile memory may be used for debugging to validate fixes to the hard-coded portion of algorithm 22 as well as for testing of new sequences and for user flow to add fixes and advanced or newly-developed features not present within the hard-coded portion of algorithm 22 .
- control unit 18 additional details regarding fetching and execution of algorithm 22 by control unit 18 are described according to one embodiment.
- Algorithm 22 is stored within a program memory 23 including a first storage space comprising read only memory (ROM) 36 and a second storage space comprising static random access memory (SRAM) 38 in one embodiment.
- An initial portion of algorithm 22 is hard-coded within ROM 36 during manufacture and production of the memory system 10 in one embodiment.
- Another portion of algorithm 22 may be stored in SRAM 38 during manufacture or production of the memory system 10 or subsequently thereafter.
- the portion of algorithm 22 stored in SRAM 38 may include new code added after the memory system 10 has been fabricated and perhaps used or implemented within an associated device.
- the executable instructions of SRAM 38 may be marked with FW tags to distinguish the new executable code of SRAM 38 from the executable code of ROM 36 .
- the portion of algorithm 22 stored in ROM 36 includes a plurality of executable instructions (e.g., operation code) which are ordered, accessed and executed according to a first instruction sequence.
- the executable instructions of ROM 36 may be referred to as first executable instructions and are stored in order in a plurality of sequential addresses of ROM 36 in one embodiment.
- the portion of algorithm 22 stored in SRAM 38 includes a plurality of executable instructions which are ordered, accessed and executed according to a second instruction sequence in one embodiment.
- the executable instructions of SRAM 38 may be referred to as second executable instructions and are stored in order in a plurality of sequential addresses of SRAM 38 .
- the executable instructions of ROM 36 and SRAM 38 are stored in a continuous instruction set address space of ROM 36 and SRAM 38 .
- SRAM 38 may be considered as an extension of the ROM 36 providing increased flexibility and replacement capability with respect to the algorithm 22 .
- the first executable instruction of the first or second instruction sequence is fetched and executed, followed by the second executable instruction of the respective first or second instruction sequence and so on.
- the executable instructions of the first instruction sequence stored in ROM 36 are executed in order until an appropriate time when the executable instructions of the second instruction sequence stored in SRAM 38 are to be executed.
- a branch instruction is used in one example embodiment to change the execution of the executable instructions of the first instruction sequence to execution of the executable instructions of the second instruction sequence.
- Control unit 18 includes a program counter 30 which is configured to generate a plurality of program counter values which may be applied to ROM 36 and SRAM 38 to fetch the executable instructions in order according to the first instruction sequence or second instruction sequence, respectively.
- Program counter values generated to fetch executable instructions from ROM 36 may be referred to as first program counter values and program counter values generated to fetch executable instructions from SRAM 38 may be referred to as second program counter values.
- control unit 18 fetches and executes instructions stored in ROM 36 following power-up of the memory system 10 .
- the program counter 30 outputs a first program counter value to program memory 23 to fetch the first executable instruction from ROM 36 followed by the second program counter value, and so on while the executable instructions of the first instruction sequence are executed in order.
- the executable instructions fetched by the program counter values are applied according to the first instruction sequence via a bus 40 to a multiplexer 34 and an instruction register 32 of control unit 18 where the executable instructions are executed in order according to the first instruction sequence.
- the control unit 18 may implement writing and reading operations with respect to main memory 12 during execution of the executable instructions stored in ROM 36 .
- the portion of algorithm 22 stored in ROM 36 may be referred to as the user mode algorithm.
- the program counter values outputted from program counter 30 may also be applied to substitution circuitry 20 which comprises logic circuitry 19 in the illustrated example embodiment.
- Substitution circuitry 20 is configured to control switching of the execution by control unit 18 of the executable instructions stored in ROM 36 to execution of the executable instructions stored in SRAM 38 as a result of detection of a predefined event in one embodiment.
- the predefined event is the generation of a predefined program counter value to fetch one of the executable instructions from ROM 36 .
- logic circuitry 19 is content-addressable memory which may be programmed with a predefined program counter value.
- the predefined program counter value may be predefined to initiate execution of the executable instructions of the second instruction sequence at a desired point of execution of the executable instructions of the first instruction sequence corresponding to the predefined program counter value.
- Substitution circuitry 20 controls a branch to begin execution of the executable instructions of the second instruction sequence of SRAM 38 as a result of the program counter 30 generating a program counter value which corresponds to the predefined program counter value during the execution of the executable instructions of the first instruction sequence.
- the logic circuitry 19 compares the received individual program counter values with the predefined program counter value.
- Corresponding executable instructions are fetched from ROM 36 and applied via mux 34 to instruction register 32 if the received program counter values do not match the predefined program counter value.
- the logic circuitry 19 Upon detection of a program counter value which is received from control unit 18 matching the predefined program counter value, the logic circuitry 19 controls the execution of the executable instructions from the SRAM 38 according to the second instruction sequence in one example embodiment.
- the logic circuitry 19 outputs a match control signal 42 as a result of a received program counter value matching the predefined program counter value.
- the match control signal 42 is applied to multiplexer 34 which controls multiplexer 34 to select an input received via a bus 44 for application to instruction register 32 as opposed to inputs received via bus 40 .
- Logic circuitry 19 additionally outputs a substitute executable instruction which is applied via bus 44 and multiplexer 34 to instruction register 32 .
- the substitute executable instruction is a branch instruction (e.g., jump or call instruction) which causes the control unit 18 to begin execution of the executable instructions of the second instruction sequence in one embodiment.
- the substitution circuitry 20 replaces one of the executable instructions stored in ROM 36 (i.e., the executable instruction which otherwise would have been fetched by the program counter value which matched the predefined program counter value) with the substitute executable instruction for execution by control unit 18 .
- the logic circuitry 19 also applies the match control signal 42 and a substitute program counter value to program counter 30 as a result of a program counter value matching the predefined program counter value. If a current program counter value does not match the predefined program counter value, then the match control signal 42 is not asserted and the current program counter value generated by the program counter 30 is applied to program memory 23 . However, if the current program counter value matches the predefined program counter value, then the match control signal 42 is asserted and the substitute program counter value is applied from logic circuitry 19 to program counter 30 which outputs the substitute program counter value to program memory 23 .
- the substitute circuitry 20 is configured to control the program counter 30 to replace one of the program counter values for fetching one of the executable instructions from ROM 36 with the substitute program counter value.
- the substitute program counter value identifies a memory address of SRAM 38 which includes the first executable instruction of the second instruction sequence to be fetched and executed in one embodiment.
- the substitute program counter value is the first program counter value of the second instruction sequence.
- the application of the substitute executable instruction and substitute program counter value from logic circuitry 19 to control unit 18 initiates the branch operation to the executable instructions stored in SRAM 38 .
- the program counter 30 of control unit 18 outputs additional sequential program counter values to fetch subsequent executable instructions from SRAM 38 in the order of the second instruction sequence of SRAM 38 until execution of the algorithm 22 is controlled to return to execution of the executable instructions of ROM 36 in one embodiment.
- the logic circuitry 19 de-asserts the match control signal 42 during the execution of the substitute executable instruction.
- the de-assertion of the match control signal 42 controls multiplexer 34 to apply the executable instructions received via bus 40 from the SRAM 38 to instruction register 32 for execution by control unit 18 .
- the de-assertion of the match control signal 42 also controls the program counter to generate the appropriate program counter values to address SRAM 38 in the order of the second instruction sequence.
- the executable instructions of SRAM 38 may include an appropriate executable instruction to return execution by the control unit 18 to the executable instructions of ROM 36 at an appropriate moment in time following execution of the executable instructions of the second instruction sequence.
- ROM 36 is programmed in the factory during manufacture of the memory system 10 .
- SRAM 38 may be programmed differently in different embodiments including the following examples.
- SRAM 38 is programmed in the factory and may be utilized as a debug structure for example to validate fixes to the executable instructions stored within ROM 36 .
- logic circuitry 19 may also be programmed by the factory with the predefined program counter value when branching from execution of instructions of ROM 36 to SRAM 38 is to occur as well as the substitute executable instruction (e.g., branch instruction) which is to initiate the branch operation.
- SRAM 38 and logic circuitry 19 are programmed during use of the memory system 10 after the memory system 10 has been fabricated and shipped from the factory.
- executable instructions for the SRAM 38 and the program counter value and substitute executable instruction for logic circuitry 19 may be stored within a portion of main memory 12 and loaded into SRAM 38 during power-up of the memory system 10 during use.
- a user can load the executable instructions into SRAM 38 and the program counter value and substitute executable instruction for logic circuitry 19 from externally of the memory system 10 via an input 46 (e.g., external interface) during use and which are transferred to SRAM 38 and logic circuitry 19 .
- the executable instructions loaded into SRAM 38 may replace a portion of the executable instructions of the ROM 36 or be in addition to the executable instructions of the ROM 36 in illustrative examples.
- timing of an example branch operation is illustrated according to one embodiment where time progresses from left to right.
- Line 50 of FIG. 3 corresponds to clk 1 which is a clock of program memory 23 and line 56 corresponds to clk 2 which is a clock of control unit 18 .
- Line 52 is IR_SRAM_UNLT which is a not latched instruction from SRAM and line 54 is IR_ROM_UNLT which is a not latched instruction from ROM.
- Line 58 corresponds to latched contents of the instruction register and line 60 corresponds to program counter values which are applied to program memory to fetch executable instructions.
- Line 62 corresponds to the match control signal applied from the logic circuitry to the control unit.
- executable instructions from the ROM are fetched and executed according to the first instruction sequence as shown by an instruction IR ROM UNLT N ⁇ 1 being latched by the instruction register indicated by line 58 .
- the program counter value PC_ROM N which is used to fetch an instruction from the ROM matches the predefined program counter value of the substitution circuitry resulting in the assertion of the match control signal on line 62 .
- the assertion of the match control signal results in the substitution of the substitute executable instruction (JMP/CALL) for the executable instruction IR ROM UNLT N as indicated by the latching of the substitute executable instruction by the instruction register.
- the program counter outputs the substitute program counter value PC_SRAM N to the program memory as a result of the match control signal being asserted.
- the application of the substitute program counter value PC_SRAM N to the program memory fetches instruction IR SRAM UNLT N from the SRAM as indicted by line 52 and which is latched in the instruction register as indicated by line 58 .
- the execution of the algorithm continues according to the instruction sequence of the SRAM through use of program counter value PC SRAM N+1 which fetched instruction IR SRAM UNLT N+1 and which is latched as executable instruction IR SRAM N+1.
- Additional program counter values may be generated and executable instructions fetched and executed during the execution of the instructions from the SRAM.
- example operations of fetching executable instructions from program memory are shown according to one embodiment. Other methods are possible including more, less and/or alternative acts.
- the program counter outputs a current program counter value.
- act A 12 If the result of act A 12 is affirmative, the process proceeds to an act A 18 to assert a match control signal to control the multiplexer which is coupled with an input of the instruction register (shown in FIG. 2 ) to receive a substitute executable instruction from the substitution circuitry.
- a substitute program counter value is applied from the substitution circuitry to the program counter of the control unit to fetch instructions from the SRAM.
- the substitute executable instruction comprising a branch instruction in one embodiment is outputted from the substitution circuitry to the instruction register to control the control unit to branch to the executable instructions stored in SRAM.
- the program counter is incremented from the substitute program counter value according to the instruction sequence of the SRAM to fetch subsequent executable instructions from the SRAM during subsequent executions of the illustrated flow chart.
- At least some of the described example embodiments enable a user mode algorithm and a debug algorithm to be executed at the same clock speed and which utilize the same executable code. This enables analysis of the functionality of the user mode algorithm in terms of flow and timing. Furthermore, some arrangements may be used to replace portions of user mode code of the ROM with new user mode code up to the dimension of the SRAM and the SRAM provides additional space for storing executable code in debug or production operations of the memory systems. The executable code may also be updated following production of the memory systems with no compilation cost according to some embodiments described herein. In addition, incremental compilation integrates the executable instructions of the SRAM with the executable instructions of the ROM in one embodiment.
- the executable instructions of the SRAM are a seamless extension of the ROM in one embodiment, for example which may utilize call and jump procedures of the code of the ROM.
- the hierarchy of the executable code of the ROM can be modified by new procedures and incremental variables may be allocated in some embodiments.
- Some conventional systems have utilized eXecute In Place (XIP) operations to update hard-coded firmware.
- XIP eXecute In Place
- these systems provide new instructions within a buffer of one plane of the memory system which precludes access to the memory cells coupled with the buffer and thereby limits the execution of the new instructions to only a portion of the memory.
- the execution speed may not match the original algorithm being modified and the new instructions may not be able to use full resources of the memory system as discussed above.
- Another conventional method uses a logic module to intercept and replace incorrect instructions of firmware. However, this method is limited to single line replacement and cannot be utilized to test new algorithm flows.
- a memory system comprises a plurality of memory cells individually configured to store data, program memory configured to store a plurality of first executable instructions which are ordered according to a first instruction sequence and a plurality of second executable instructions which are ordered according to a second instruction sequence, substitution circuitry configured to replace one of the first executable instructions with a substitute executable instruction, and a control unit configured to execute the first executable instructions to implement at least one operation with respect to the storage of the data using the memory cells, wherein the control unit is configured to execute the first executable instructions according to the first instruction sequence, to execute the substitute executable instruction after the execution of the first executable instructions, and to execute the second executable instructions according to the second instruction sequence as a result of the execution of the substitute executable instruction.
- a memory system comprises a plurality of memory cells individually configured to store data, a control unit configured to control reading and writing of the data with respect to the memory cells, program memory configured to store a plurality of first executable instructions which are ordered according to a first instruction sequence and to store a plurality of second executable instructions which are ordered according to a second instruction sequence, a program counter configured to generate a plurality of first program counter values to fetch the first executable instructions according to the first instruction sequence and to generate a plurality of second program counter values to fetch the second executable instructions according to the second instruction sequence, substitution circuitry configured to replace one of the first program counter values with one of the second program counter values to initiate the fetching of the second executable instructions, and wherein the control unit is configured to execute the first executable instructions to implement at least one operation with respect to the storage of the data using the memory cells.
- a memory system comprises a plurality of memory cells individually configured to store data, a first storage space configured to store a plurality of first executable instructions of a first instruction sequence, a second storage space configured to store a plurality of second executable instructions of a second instruction sequence, a control unit configured to execute the first executable instructions to implement at least one operation with respect to storage of the data using the memory cells, and logic circuitry configured to detect a predefined event during the execution of the first executable instructions by the control unit and to control the control unit to execute the second executable instructions as a result of the detection.
- a memory control method comprises first executing a plurality of first executable instructions according to a first instruction sequence to implement at least one operation with respect to storage of data using a plurality of memory cells of a memory system, during the executing of the first executable instructions, replacing one of the first executable instructions with a substitute executable instruction comprising a branch instruction configured to initiate execution of a plurality of second executable instructions, second executing the substitute executable instruction after the replacing, and third executing the second executable instructions according to a second instruction sequence as a result of the second executing.
- a memory control method comprises generating a plurality of program counter values, comparing the program counter values with a predefined program counter value, as a result of one of the program counter values not matching the predefined program counter value during the comparing, fetching one of a plurality of first executable instructions of a first instruction sequence using the one program counter value, executing the one first executable instruction to implement an operation with respect to storage of data using a plurality of memory cells of a memory system, as a result of another of the program counter values matching the predefined program counter value, replacing the another program counter value with a substitute program counter value, using the substitute program counter value, fetching one of a plurality of second executable instructions of a second instruction sequence, and executing the one second executable instruction.
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Executing Machine-Instructions (AREA)
- Microcomputers (AREA)
Abstract
Memory systems and memory control methods are described. According to one aspect, a memory system includes a plurality of memory cells individually configured to store data, program memory configured to store a plurality of first executable instructions which are ordered according to a first instruction sequence and a plurality of second executable instructions which are ordered according to a second instruction sequence, substitution circuitry configured to replace one of the first executable instructions with a substitute executable instruction, and a control unit configured to execute the first and second executable instructions to control reading and writing of the data with respect to the memory, wherein the control unit is configured to execute the first executable instructions according to the first instruction sequence, to execute the substitute executable instruction after the execution of the first executable instructions, and to execute the second executable instructions according to the second instruction sequence as a result of execution of the substitute executable instruction.
Description
- Embodiments disclosed herein pertain to memory systems and memory control methods.
- Memory devices are widely used in electronic devices, such as computers, digital cameras, personal audio and video players, appliances, vehicles, etc., for storing digital information. Many different types of memory are available, using different fundamental technologies for storing data.
- Memory cells of memory are programmed to have different states to store the digital information. Program signals may be applied to the memory cells to change the memory cells from one memory state to another different memory state. The memory states of the memory cells may be subsequently read to access the stored digital information.
- Controllers which execute programming may be utilized to control operations with respect to memory. However, the programming is often hard-coded as firmware into a memory device and changes to the hard-coded firmware may involve an expensive and time-consuming process.
- At least some example embodiments discussed herein are directed towards memory systems and memory control methods, and more specific example embodiments facilitate modifications and/or additions to executable code of the memory systems as described in detail below.
-
FIG. 1 is a functional block diagram of a memory system according to one embodiment. -
FIG. 2 is a functional block diagram which illustrates additional details of a control unit and program memory according to one embodiment. -
FIG. 3 is a timing diagram of operations of the control unit and program memory according to one embodiment. -
FIG. 4 is a flow chart illustrating fetch operations of the control unit according to one embodiment. - Referring to
FIG. 1 , a functional block diagram of amemory system 10 is shown according to one embodiment. The illustrated embodiment ofmemory system 10 includesmain memory 12, a plurality ofbuffers control unit 18,substitution circuitry 20 and analgorithm 22 which is stored in program memory (an example embodiment of program memory is shown inFIG. 2 ). Other embodiments ofmemory system 10 may include more, less and/or alternative components or circuitry. -
Memory system 10 may be implemented within or with respect to various associated devices (not shown), such as computers, cameras, media players, and thumb drives, in some illustrative examples.Memory system 10 stores data generated or utilized by the associated devices in the described examples. -
Main memory 12 includes a plurality of arrays ofmemory cells memory cells main memory 12. At least some of thememory cells Main memory 12 is accessible to the user and/or associated device for storage of digital information. One more specific example ofmain memory 12 is NAND flash memory although the apparatus and methods of the described example embodiments may be utilized with other memory architectures in other embodiments. -
Main memory 12 may be implemented in different arrangements in different embodiments. For example, themain memory 12 may be implemented within a memory device, such as a chip, a portion of the chip or other arrangements. The memory device may also include other circuitry and components ofFIG. 1 or portions thereof. -
Buffers main memory 12 in one embodiment. The illustratedexample memory system 10 includes two planes individually including one of the arrays ofmemory cells buffers -
Control unit 18 controls operations of writing, reading and re-writing data ofmain memory 12 as well as interfacing with other components or circuitry, such as sources of data to be stored withinmain memory 12.Control unit 18 may access and execute executable instructions and generate commands with respect tomain memory 12 during operations of an associated device. Example commands instruct the generation of program signals and read signals which are applied tomain memory 12 in one embodiment. The program signals are used to write data to main memory 12 (i.e., program the memory) during programming operations and the read signals are used to access or sense the contents of the data stored inmain memory 12 in one embodiment. - In one embodiment,
control unit 18 comprises processing circuitry configured to execute programming (i.e., algorithm 22) stored within computer-readable storage media (e.g.,program memory 23 ofFIG. 2 ) in at least one embodiment. For example, thecontrol unit 18 may be implemented as one or more processor(s) and/or other structure configured to execute executable instructions including, for example, software and/or firmware instructions. -
Substitution circuitry 20 is configured to implement operations with respect toalgorithm 22 as described further below. For example,substitution circuitry 20 may be configured to implement testing and debugging operations during execution ofalgorithm 22 as well as implementing operations with respect to modifying and updatingalgorithm 22. -
Algorithm 22 is a sequence of procedures to perform read and write operations with respect tomain memory 12. In one more specific embodiment described in detail below, one portion ofalgorithm 22 is hard-coded within non-volatile memory (e.g., read only memory or ROM) and another portion ofalgorithm 22 is provided to update or modify the hard-coded portion of thealgorithm 22 and which may be stored within volatile memory (e.g., static random access memory or SRAM). For example, the updated portion ofalgorithm 22 stored in volatile memory may be used for debugging to validate fixes to the hard-coded portion ofalgorithm 22 as well as for testing of new sequences and for user flow to add fixes and advanced or newly-developed features not present within the hard-coded portion ofalgorithm 22. - Referring to
FIG. 2 , additional details regarding fetching and execution ofalgorithm 22 bycontrol unit 18 are described according to one embodiment. -
Algorithm 22 is stored within aprogram memory 23 including a first storage space comprising read only memory (ROM) 36 and a second storage space comprising static random access memory (SRAM) 38 in one embodiment. An initial portion ofalgorithm 22 is hard-coded withinROM 36 during manufacture and production of thememory system 10 in one embodiment. Another portion ofalgorithm 22 may be stored inSRAM 38 during manufacture or production of thememory system 10 or subsequently thereafter. The portion ofalgorithm 22 stored in SRAM 38 may include new code added after thememory system 10 has been fabricated and perhaps used or implemented within an associated device. In some embodiments, the executable instructions of SRAM 38 may be marked with FW tags to distinguish the new executable code of SRAM 38 from the executable code ofROM 36. - In one embodiment, the portion of
algorithm 22 stored inROM 36 includes a plurality of executable instructions (e.g., operation code) which are ordered, accessed and executed according to a first instruction sequence. The executable instructions ofROM 36 may be referred to as first executable instructions and are stored in order in a plurality of sequential addresses ofROM 36 in one embodiment. - Similarly, the portion of
algorithm 22 stored in SRAM 38 includes a plurality of executable instructions which are ordered, accessed and executed according to a second instruction sequence in one embodiment. The executable instructions of SRAM 38 may be referred to as second executable instructions and are stored in order in a plurality of sequential addresses of SRAM 38. In one example, the executable instructions ofROM 36 and SRAM 38 are stored in a continuous instruction set address space ofROM 36 and SRAM 38. SRAM 38 may be considered as an extension of theROM 36 providing increased flexibility and replacement capability with respect to thealgorithm 22. - During execution of the executable instructions, the first executable instruction of the first or second instruction sequence is fetched and executed, followed by the second executable instruction of the respective first or second instruction sequence and so on. In one more specific example, the executable instructions of the first instruction sequence stored in
ROM 36 are executed in order until an appropriate time when the executable instructions of the second instruction sequence stored in SRAM 38 are to be executed. A branch instruction is used in one example embodiment to change the execution of the executable instructions of the first instruction sequence to execution of the executable instructions of the second instruction sequence. -
Control unit 18 includes aprogram counter 30 which is configured to generate a plurality of program counter values which may be applied toROM 36 and SRAM 38 to fetch the executable instructions in order according to the first instruction sequence or second instruction sequence, respectively. Program counter values generated to fetch executable instructions fromROM 36 may be referred to as first program counter values and program counter values generated to fetch executable instructions from SRAM 38 may be referred to as second program counter values. - In one embodiment, the
control unit 18 fetches and executes instructions stored inROM 36 following power-up of thememory system 10. The program counter 30 outputs a first program counter value toprogram memory 23 to fetch the first executable instruction fromROM 36 followed by the second program counter value, and so on while the executable instructions of the first instruction sequence are executed in order. The executable instructions fetched by the program counter values are applied according to the first instruction sequence via abus 40 to amultiplexer 34 and aninstruction register 32 ofcontrol unit 18 where the executable instructions are executed in order according to the first instruction sequence. - The
control unit 18 may implement writing and reading operations with respect tomain memory 12 during execution of the executable instructions stored inROM 36. The portion ofalgorithm 22 stored inROM 36 may be referred to as the user mode algorithm. - As shown in
FIG. 2 , the program counter values outputted fromprogram counter 30 may also be applied tosubstitution circuitry 20 which compriseslogic circuitry 19 in the illustrated example embodiment.Substitution circuitry 20 is configured to control switching of the execution bycontrol unit 18 of the executable instructions stored inROM 36 to execution of the executable instructions stored inSRAM 38 as a result of detection of a predefined event in one embodiment. In one example described below, the predefined event is the generation of a predefined program counter value to fetch one of the executable instructions fromROM 36. - In one embodiment,
logic circuitry 19 is content-addressable memory which may be programmed with a predefined program counter value. For example, the predefined program counter value may be predefined to initiate execution of the executable instructions of the second instruction sequence at a desired point of execution of the executable instructions of the first instruction sequence corresponding to the predefined program counter value. -
Substitution circuitry 20 controls a branch to begin execution of the executable instructions of the second instruction sequence ofSRAM 38 as a result of theprogram counter 30 generating a program counter value which corresponds to the predefined program counter value during the execution of the executable instructions of the first instruction sequence. - In the described example embodiment, the
logic circuitry 19 compares the received individual program counter values with the predefined program counter value. Corresponding executable instructions are fetched fromROM 36 and applied viamux 34 toinstruction register 32 if the received program counter values do not match the predefined program counter value. - Upon detection of a program counter value which is received from
control unit 18 matching the predefined program counter value, thelogic circuitry 19 controls the execution of the executable instructions from theSRAM 38 according to the second instruction sequence in one example embodiment. - In one specific embodiment, the
logic circuitry 19 outputs amatch control signal 42 as a result of a received program counter value matching the predefined program counter value. Thematch control signal 42 is applied tomultiplexer 34 which controlsmultiplexer 34 to select an input received via abus 44 for application to instruction register 32 as opposed to inputs received viabus 40.Logic circuitry 19 additionally outputs a substitute executable instruction which is applied viabus 44 andmultiplexer 34 toinstruction register 32. The substitute executable instruction is a branch instruction (e.g., jump or call instruction) which causes thecontrol unit 18 to begin execution of the executable instructions of the second instruction sequence in one embodiment. Accordingly, in one embodiment, thesubstitution circuitry 20 replaces one of the executable instructions stored in ROM 36 (i.e., the executable instruction which otherwise would have been fetched by the program counter value which matched the predefined program counter value) with the substitute executable instruction for execution bycontrol unit 18. - In addition, the
logic circuitry 19 also applies thematch control signal 42 and a substitute program counter value toprogram counter 30 as a result of a program counter value matching the predefined program counter value. If a current program counter value does not match the predefined program counter value, then thematch control signal 42 is not asserted and the current program counter value generated by theprogram counter 30 is applied toprogram memory 23. However, if the current program counter value matches the predefined program counter value, then thematch control signal 42 is asserted and the substitute program counter value is applied fromlogic circuitry 19 toprogram counter 30 which outputs the substitute program counter value toprogram memory 23. In other words, thesubstitute circuitry 20 is configured to control theprogram counter 30 to replace one of the program counter values for fetching one of the executable instructions fromROM 36 with the substitute program counter value. The substitute program counter value identifies a memory address ofSRAM 38 which includes the first executable instruction of the second instruction sequence to be fetched and executed in one embodiment. In one embodiment, the substitute program counter value is the first program counter value of the second instruction sequence. - The application of the substitute executable instruction and substitute program counter value from
logic circuitry 19 to controlunit 18 initiates the branch operation to the executable instructions stored inSRAM 38. Following the branching to the first executable instruction stored inSRAM 38, theprogram counter 30 ofcontrol unit 18 outputs additional sequential program counter values to fetch subsequent executable instructions fromSRAM 38 in the order of the second instruction sequence ofSRAM 38 until execution of thealgorithm 22 is controlled to return to execution of the executable instructions ofROM 36 in one embodiment. - In one example arrangement, the
logic circuitry 19 de-asserts thematch control signal 42 during the execution of the substitute executable instruction. The de-assertion of thematch control signal 42 controls multiplexer 34 to apply the executable instructions received viabus 40 from theSRAM 38 to instruction register 32 for execution bycontrol unit 18. The de-assertion of thematch control signal 42 also controls the program counter to generate the appropriate program counter values to addressSRAM 38 in the order of the second instruction sequence. In one embodiment, the executable instructions ofSRAM 38 may include an appropriate executable instruction to return execution by thecontrol unit 18 to the executable instructions ofROM 36 at an appropriate moment in time following execution of the executable instructions of the second instruction sequence. - In a typical arrangement,
ROM 36 is programmed in the factory during manufacture of thememory system 10.SRAM 38 may be programmed differently in different embodiments including the following examples. In one embodiment,SRAM 38 is programmed in the factory and may be utilized as a debug structure for example to validate fixes to the executable instructions stored withinROM 36. In addition,logic circuitry 19 may also be programmed by the factory with the predefined program counter value when branching from execution of instructions ofROM 36 toSRAM 38 is to occur as well as the substitute executable instruction (e.g., branch instruction) which is to initiate the branch operation. - In other embodiments,
SRAM 38 andlogic circuitry 19 are programmed during use of thememory system 10 after thememory system 10 has been fabricated and shipped from the factory. For example, executable instructions for theSRAM 38 and the program counter value and substitute executable instruction forlogic circuitry 19 may be stored within a portion ofmain memory 12 and loaded intoSRAM 38 during power-up of thememory system 10 during use. In another example, a user can load the executable instructions intoSRAM 38 and the program counter value and substitute executable instruction forlogic circuitry 19 from externally of thememory system 10 via an input 46 (e.g., external interface) during use and which are transferred toSRAM 38 andlogic circuitry 19. The executable instructions loaded intoSRAM 38 may replace a portion of the executable instructions of theROM 36 or be in addition to the executable instructions of theROM 36 in illustrative examples. - Referring to
FIG. 3 , timing of an example branch operation is illustrated according to one embodiment where time progresses from left to right. -
Line 50 ofFIG. 3 corresponds to clk1 which is a clock ofprogram memory 23 andline 56 corresponds to clk2 which is a clock ofcontrol unit 18.Line 52 is IR_SRAM_UNLT which is a not latched instruction from SRAM andline 54 is IR_ROM_UNLT which is a not latched instruction from ROM.Line 58 corresponds to latched contents of the instruction register andline 60 corresponds to program counter values which are applied to program memory to fetch executable instructions.Line 62 corresponds to the match control signal applied from the logic circuitry to the control unit. - Initially, in
FIG. 3 , executable instructions from the ROM are fetched and executed according to the first instruction sequence as shown by an instruction IR ROM UNLT N−1 being latched by the instruction register indicated byline 58. - In the illustrated example, the program counter value PC_ROM N which is used to fetch an instruction from the ROM matches the predefined program counter value of the substitution circuitry resulting in the assertion of the match control signal on
line 62. - The assertion of the match control signal results in the substitution of the substitute executable instruction (JMP/CALL) for the executable instruction IR ROM UNLT N as indicated by the latching of the substitute executable instruction by the instruction register. In addition, the program counter outputs the substitute program counter value PC_SRAM N to the program memory as a result of the match control signal being asserted.
- The application of the substitute program counter value PC_SRAM N to the program memory fetches instruction IR SRAM UNLT N from the SRAM as indicted by
line 52 and which is latched in the instruction register as indicated byline 58. The execution of the algorithm continues according to the instruction sequence of the SRAM through use of program counter value PC SRAM N+1 which fetched instruction IR SRAM UNLT N+1 and which is latched as executable instruction IR SRAM N+1. Additional program counter values may be generated and executable instructions fetched and executed during the execution of the instructions from the SRAM. - Referring to
FIG. 4 , example operations of fetching executable instructions from program memory are shown according to one embodiment. Other methods are possible including more, less and/or alternative acts. - At an act A10, the program counter outputs a current program counter value.
- At an act A12, it is determined whether the current program counter value matches the substitute program counter value of the substitution circuitry.
- If the result of act A12 is negative, the process proceeds to an act A14 to access an executable instruction from ROM.
- At an act A16, the program counter is incremented and flow returns to act A10.
- If the result of act A12 is affirmative, the process proceeds to an act A18 to assert a match control signal to control the multiplexer which is coupled with an input of the instruction register (shown in
FIG. 2 ) to receive a substitute executable instruction from the substitution circuitry. - At an act A20, a substitute program counter value is applied from the substitution circuitry to the program counter of the control unit to fetch instructions from the SRAM.
- At an act A22, the substitute executable instruction comprising a branch instruction in one embodiment is outputted from the substitution circuitry to the instruction register to control the control unit to branch to the executable instructions stored in SRAM.
- At an act A24, the program counter is incremented from the substitute program counter value according to the instruction sequence of the SRAM to fetch subsequent executable instructions from the SRAM during subsequent executions of the illustrated flow chart.
- At least some of the described example embodiments enable a user mode algorithm and a debug algorithm to be executed at the same clock speed and which utilize the same executable code. This enables analysis of the functionality of the user mode algorithm in terms of flow and timing. Furthermore, some arrangements may be used to replace portions of user mode code of the ROM with new user mode code up to the dimension of the SRAM and the SRAM provides additional space for storing executable code in debug or production operations of the memory systems. The executable code may also be updated following production of the memory systems with no compilation cost according to some embodiments described herein. In addition, incremental compilation integrates the executable instructions of the SRAM with the executable instructions of the ROM in one embodiment. The executable instructions of the SRAM are a seamless extension of the ROM in one embodiment, for example which may utilize call and jump procedures of the code of the ROM. The hierarchy of the executable code of the ROM can be modified by new procedures and incremental variables may be allocated in some embodiments.
- Some conventional systems have utilized eXecute In Place (XIP) operations to update hard-coded firmware. However, these systems provide new instructions within a buffer of one plane of the memory system which precludes access to the memory cells coupled with the buffer and thereby limits the execution of the new instructions to only a portion of the memory. Furthermore, the execution speed may not match the original algorithm being modified and the new instructions may not be able to use full resources of the memory system as discussed above. Another conventional method uses a logic module to intercept and replace incorrect instructions of firmware. However, this method is limited to single line replacement and cannot be utilized to test new algorithm flows.
- In some embodiments, a memory system comprises a plurality of memory cells individually configured to store data, program memory configured to store a plurality of first executable instructions which are ordered according to a first instruction sequence and a plurality of second executable instructions which are ordered according to a second instruction sequence, substitution circuitry configured to replace one of the first executable instructions with a substitute executable instruction, and a control unit configured to execute the first executable instructions to implement at least one operation with respect to the storage of the data using the memory cells, wherein the control unit is configured to execute the first executable instructions according to the first instruction sequence, to execute the substitute executable instruction after the execution of the first executable instructions, and to execute the second executable instructions according to the second instruction sequence as a result of the execution of the substitute executable instruction.
- In some embodiments, a memory system comprises a plurality of memory cells individually configured to store data, a control unit configured to control reading and writing of the data with respect to the memory cells, program memory configured to store a plurality of first executable instructions which are ordered according to a first instruction sequence and to store a plurality of second executable instructions which are ordered according to a second instruction sequence, a program counter configured to generate a plurality of first program counter values to fetch the first executable instructions according to the first instruction sequence and to generate a plurality of second program counter values to fetch the second executable instructions according to the second instruction sequence, substitution circuitry configured to replace one of the first program counter values with one of the second program counter values to initiate the fetching of the second executable instructions, and wherein the control unit is configured to execute the first executable instructions to implement at least one operation with respect to the storage of the data using the memory cells.
- In some embodiments, a memory system comprises a plurality of memory cells individually configured to store data, a first storage space configured to store a plurality of first executable instructions of a first instruction sequence, a second storage space configured to store a plurality of second executable instructions of a second instruction sequence, a control unit configured to execute the first executable instructions to implement at least one operation with respect to storage of the data using the memory cells, and logic circuitry configured to detect a predefined event during the execution of the first executable instructions by the control unit and to control the control unit to execute the second executable instructions as a result of the detection.
- In some embodiments, a memory control method comprises first executing a plurality of first executable instructions according to a first instruction sequence to implement at least one operation with respect to storage of data using a plurality of memory cells of a memory system, during the executing of the first executable instructions, replacing one of the first executable instructions with a substitute executable instruction comprising a branch instruction configured to initiate execution of a plurality of second executable instructions, second executing the substitute executable instruction after the replacing, and third executing the second executable instructions according to a second instruction sequence as a result of the second executing.
- In some embodiments, a memory control method comprises generating a plurality of program counter values, comparing the program counter values with a predefined program counter value, as a result of one of the program counter values not matching the predefined program counter value during the comparing, fetching one of a plurality of first executable instructions of a first instruction sequence using the one program counter value, executing the one first executable instruction to implement an operation with respect to storage of data using a plurality of memory cells of a memory system, as a result of another of the program counter values matching the predefined program counter value, replacing the another program counter value with a substitute program counter value, using the substitute program counter value, fetching one of a plurality of second executable instructions of a second instruction sequence, and executing the one second executable instruction.
- In compliance with the statute, the subject matter disclosed herein has been described in language more or less specific as to structural and methodical features. It is to be understood, however, that the claims are not limited to the specific features shown and described, since the means herein disclosed comprise example embodiments. The claims are thus to be afforded full scope as literally worded, and to be appropriately interpreted in accordance with the doctrine of equivalents.
Claims (21)
1. A memory system comprising:
a plurality of memory cells individually configured to store data;
program memory configured to store a plurality of first executable instructions which are ordered according to a first instruction sequence and a plurality of second executable instructions which are ordered according to a second instruction sequence;
substitution circuitry configured to replace one of the first executable instructions with a substitute executable instruction; and
a control unit configured to execute the first executable instructions to implement at least one operation with respect to the storage of the data using the memory cells, wherein the control unit is configured to execute the first executable instructions according to the first instruction sequence, to execute the substitute executable instruction after the execution of the first executable instructions, and to execute the second executable instructions according to the second instruction sequence as a result of the execution of the substitute executable instruction.
2. The system of claim 1 further comprising a program counter configured to generate a plurality of program counter values to fetch the first and second executable instructions
3. The system of claim 2 wherein the substitution circuitry is configured to replace the one first executable instruction with the substitute executable instruction as a result of the program counter generating a predefined one of the program counter values.
4. The system of claim 2 wherein the substitution circuitry is configured to control the program counter to replace one of the program counter values with a substitute program counter value as a result of the program counter generating a predefined one of the program counter values.
5. The system of claim 2 wherein the program counter values comprise a plurality of first program counter values to fetch the first executable instructions according to the first instruction sequence and wherein the substitution circuitry is configured to control the program counter to replace one of the first program counter values with one of a plurality of second program counter values to initiate fetching of the second executable instructions.
6. The system of claim 1 wherein the substitute executable instruction is a branch instruction configured to control the control unit to begin execution of the second executable instructions.
7. The system of claim 1 further comprising an input configured to receive the second executable instructions from externally of the memory system and to transfer the second executable instructions to the program memory.
8. The system of claim 1 wherein some of the memory cells store the second executable instructions and the program memory receives the second executable instructions from the some memory cells.
9. The system of claim 1 wherein the control unit comprises an instruction register, and wherein the substitution circuitry is configured to control provision of the substitute executable instruction to the instruction register to replace the one first executable instruction.
10. The system of claim 1 wherein the first executable instructions are stored in non-volatile memory and the second executable instructions are stored in volatile memory.
11. The system of claim 10 wherein the first and second executable instructions are stored within a continuous instruction set address space of the non-volatile memory and the volatile memory.
12. The system of claim 1 wherein the control unit is configured to test the execution of the first executable instructions during the execution of the second executable instructions.
13. A memory system comprising:
a plurality of memory cells individually configured to store data;
a control unit configured to control reading and writing of the data with respect to the memory cells;
program memory configured to store a plurality of first executable instructions which are ordered according to a first instruction sequence and to store a plurality of second executable instructions which are ordered according to a second instruction sequence;
a program counter configured to generate a plurality of first program counter values to fetch the first executable instructions according to the first instruction sequence and to generate a plurality of second program counter values to fetch the second executable instructions according to the second instruction sequence;
substitution circuitry configured to replace one of the first program counter values with one of the second program counter values to initiate the fetching of the second executable instructions; and
wherein the control unit is configured to execute the first executable instructions to implement at least one operation with respect to the storage of the data using the memory cells.
14. The system of claim 13 wherein the substitution circuitry is configured to replace one of the first executable instructions with a branch instruction configured to control the control unit to initiate execution of the second executable instructions.
15. The system of claim 13 wherein the substitution circuitry is configured to replace the one first program counter value with the one second program counter value as a result of the program counter generating a predefined first program counter value.
16. The system of claim 13 wherein the first executable instructions are stored in non-volatile memory and the second executable instructions are stored in volatile memory.
17. The system of claim 16 wherein the first and second executable instructions are stored within a continuous instruction set address space of the non-volatile memory and the volatile memory.
18. A memory system comprising:
a plurality of memory cells individually configured to store data;
a first storage space configured to store a plurality of first executable instructions of a first instruction sequence;
a second storage space configured to store a plurality of second executable instructions of a second instruction sequence;
a control unit configured to execute the first executable instructions to implement at least one operation with respect to storage of the data using the memory cells; and
logic circuitry configured to detect a predefined event during the execution of the first executable instructions by the control unit and to control the control unit to execute the second executable instructions as a result of the detection.
19. The system of claim 18 wherein the first storage space is non-volatile memory and the second storage space is volatile memory.
20. The system of claim 18 wherein the first and second executable instructions are stored within a continuous instruction set address space of the first and second storage spaces.
21-38. (canceled)
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US17/512,082 US20220050685A1 (en) | 2014-02-04 | 2021-10-27 | Memory Systems and Memory Control Methods |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US14/172,806 US11163572B2 (en) | 2014-02-04 | 2014-02-04 | Memory systems and memory control methods |
US17/512,082 US20220050685A1 (en) | 2014-02-04 | 2021-10-27 | Memory Systems and Memory Control Methods |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US14/172,806 Continuation US11163572B2 (en) | 2014-02-04 | 2014-02-04 | Memory systems and memory control methods |
Publications (1)
Publication Number | Publication Date |
---|---|
US20220050685A1 true US20220050685A1 (en) | 2022-02-17 |
Family
ID=53754887
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US14/172,806 Active 2037-01-13 US11163572B2 (en) | 2014-02-04 | 2014-02-04 | Memory systems and memory control methods |
US17/512,082 Pending US20220050685A1 (en) | 2014-02-04 | 2021-10-27 | Memory Systems and Memory Control Methods |
Family Applications Before (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US14/172,806 Active 2037-01-13 US11163572B2 (en) | 2014-02-04 | 2014-02-04 | Memory systems and memory control methods |
Country Status (3)
Country | Link |
---|---|
US (2) | US11163572B2 (en) |
TW (1) | TWI570556B (en) |
WO (1) | WO2015119793A1 (en) |
Families Citing this family (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
GB2563881B (en) * | 2017-06-28 | 2019-12-25 | Advanced Risc Mach Ltd | Realm execution context masking and saving |
US10725699B2 (en) | 2017-12-08 | 2020-07-28 | Sandisk Technologies Llc | Microcontroller instruction memory architecture for non-volatile memory |
CN108762235A (en) * | 2018-06-12 | 2018-11-06 | 重庆穗通汽车工业发展有限公司 | Vehicle analyzes adjustment method, vehicle analysis debugging system and electric vehicle |
US10942742B1 (en) | 2018-12-11 | 2021-03-09 | Amazon Technologies, Inc. | Hardware engine with configurable instructions |
US11720352B2 (en) * | 2019-12-10 | 2023-08-08 | Micron Technology, Inc. | Flexible command pointers to microcode operations |
Citations (9)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5581776A (en) * | 1995-02-03 | 1996-12-03 | Nokia Mobile Phones Limited | Branch control system for rom-programmed processor |
US6078548A (en) * | 1999-03-08 | 2000-06-20 | Winbond Electronics Corporation | CPU capable of modifying built-in program codes thereof and method for the same |
US20020124161A1 (en) * | 2001-03-05 | 2002-09-05 | Moyer William C. | Data processing system having redirecting circuitry and method therefor |
US20030037225A1 (en) * | 2000-12-28 | 2003-02-20 | Deng Brian Tse | Apparatus and method for microcontroller debugging |
US20040128590A1 (en) * | 2002-12-30 | 2004-07-01 | Michael Derr | Patch mechanism |
US20050071605A1 (en) * | 2003-09-30 | 2005-03-31 | Yao-Huang Hsieh | Method for enabling a branch-control system in a microcomputer apparatus |
US20080013375A1 (en) * | 2006-06-30 | 2008-01-17 | Endo Keiichiro | Memory system |
US20080091923A1 (en) * | 2006-10-16 | 2008-04-17 | International Business Machines Corporation | Register-based instruction optimization for facilitating efficient emulation of an instruction stream |
US20140047222A1 (en) * | 2011-04-29 | 2014-02-13 | Beijing Zhongtian Antai Technology Co., Ltd. | Method and device for recombining runtime instruction |
Family Cites Families (20)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
JPH08272625A (en) | 1995-03-29 | 1996-10-18 | Toshiba Corp | Device and method for multiprogram execution control |
US6275119B1 (en) * | 1999-08-25 | 2001-08-14 | Micron Technology, Inc. | Method to find a value within a range using weighted subranges |
US7127718B1 (en) | 2000-11-15 | 2006-10-24 | National Semiconductor Corporation | Multitasking microcontroller for controlling the physical layer of a network interface card and method of operation |
US6916745B2 (en) * | 2003-05-20 | 2005-07-12 | Fairchild Semiconductor Corporation | Structure and method for forming a trench MOSFET having self-aligned features |
AU2003233536A1 (en) | 2002-05-08 | 2003-11-11 | Nptest, Inc. | Tester system having multiple instruction memories |
JP2004272844A (en) * | 2003-03-12 | 2004-09-30 | Renesas Technology Corp | Method for controlling interruption |
US7069377B2 (en) | 2003-05-08 | 2006-06-27 | Micron Technology, Inc. | Scratch control memory array in a flash memory device |
US20050007160A1 (en) * | 2003-07-10 | 2005-01-13 | Neff Robert M. R. | Tunable differential transconductor and adjustment method |
ITRM20030354A1 (en) | 2003-07-17 | 2005-01-18 | Micron Technology Inc | CONTROL UNIT FOR MEMORY DEVICE. |
JP2005050208A (en) | 2003-07-30 | 2005-02-24 | Matsushita Electric Ind Co Ltd | Memory managing system in multi-task system and task controller |
US7395419B1 (en) * | 2004-04-23 | 2008-07-01 | Apple Inc. | Macroscalar processor architecture |
GB0410151D0 (en) * | 2004-05-07 | 2004-06-09 | Zeus Technology Ltd | Load balancing & traffic management |
US7292487B1 (en) | 2006-05-10 | 2007-11-06 | Micron Technology, Inc. | Independent polling for multi-page programming |
US7657491B2 (en) * | 2006-10-31 | 2010-02-02 | Hewlett-Packard Development Company, L.P. | Application of fuzzy logic to response and unsolicited information |
US20080263115A1 (en) * | 2007-04-17 | 2008-10-23 | Horizon Semiconductors Ltd. | Very long arithmetic logic unit for security processor |
US8055886B2 (en) * | 2007-07-12 | 2011-11-08 | Texas Instruments Incorporated | Processor micro-architecture for compute, save or restore multiple registers and responsive to first instruction for repeated issue of second instruction |
US8856500B2 (en) * | 2008-02-06 | 2014-10-07 | Nxp B.V. | Obfuscating program by scattering sequential instructions into memory regions such that jumps occur with steps of both signs in equal frequency |
US9015720B2 (en) | 2008-04-30 | 2015-04-21 | Advanced Micro Devices, Inc. | Efficient state transition among multiple programs on multi-threaded processors by executing cache priming program |
US7845613B2 (en) * | 2008-08-07 | 2010-12-07 | Francisco Membrive Martinez | Ground securing rod |
JP2010152962A (en) * | 2008-12-24 | 2010-07-08 | Toshiba Corp | Semiconductor memory device |
-
2014
- 2014-02-04 US US14/172,806 patent/US11163572B2/en active Active
-
2015
- 2015-01-23 WO PCT/US2015/012735 patent/WO2015119793A1/en active Application Filing
- 2015-02-03 TW TW104103609A patent/TWI570556B/en active
-
2021
- 2021-10-27 US US17/512,082 patent/US20220050685A1/en active Pending
Patent Citations (9)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5581776A (en) * | 1995-02-03 | 1996-12-03 | Nokia Mobile Phones Limited | Branch control system for rom-programmed processor |
US6078548A (en) * | 1999-03-08 | 2000-06-20 | Winbond Electronics Corporation | CPU capable of modifying built-in program codes thereof and method for the same |
US20030037225A1 (en) * | 2000-12-28 | 2003-02-20 | Deng Brian Tse | Apparatus and method for microcontroller debugging |
US20020124161A1 (en) * | 2001-03-05 | 2002-09-05 | Moyer William C. | Data processing system having redirecting circuitry and method therefor |
US20040128590A1 (en) * | 2002-12-30 | 2004-07-01 | Michael Derr | Patch mechanism |
US20050071605A1 (en) * | 2003-09-30 | 2005-03-31 | Yao-Huang Hsieh | Method for enabling a branch-control system in a microcomputer apparatus |
US20080013375A1 (en) * | 2006-06-30 | 2008-01-17 | Endo Keiichiro | Memory system |
US20080091923A1 (en) * | 2006-10-16 | 2008-04-17 | International Business Machines Corporation | Register-based instruction optimization for facilitating efficient emulation of an instruction stream |
US20140047222A1 (en) * | 2011-04-29 | 2014-02-13 | Beijing Zhongtian Antai Technology Co., Ltd. | Method and device for recombining runtime instruction |
Also Published As
Publication number | Publication date |
---|---|
TWI570556B (en) | 2017-02-11 |
US11163572B2 (en) | 2021-11-02 |
TW201543213A (en) | 2015-11-16 |
WO2015119793A1 (en) | 2015-08-13 |
US20150220344A1 (en) | 2015-08-06 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US20220050685A1 (en) | Memory Systems and Memory Control Methods | |
US10388393B2 (en) | Apparatus and methods for debugging on a host and memory device | |
US6772276B2 (en) | Flash memory command abstraction | |
GB2514882A (en) | Instruction emulation processors, methods, and systems | |
US9261932B2 (en) | Minimizing switchover time in a hot swappable program memory | |
KR102590679B1 (en) | Testing bit values inside vector elements | |
US10199108B2 (en) | Methods for read retries and apparatuses using the same | |
US20090271593A1 (en) | Patching device for patching rom code, method for patching rom code, and electronic device utilizing the same | |
US7272683B2 (en) | Memory device controller | |
KR930002935A (en) | Information processing device | |
US6925522B2 (en) | Device and method capable of changing codes of micro-controller | |
US20170262195A1 (en) | Semiconductor device | |
US9081895B2 (en) | Identifying and tagging breakpoint instructions for facilitation of software debug | |
CN111630492A (en) | Hinting in a data processing apparatus | |
US11074988B2 (en) | Apparatus and methods for debugging on a host and memory device | |
US20180203699A1 (en) | Vector operand bitsize control | |
EP1177499A1 (en) | Processor and method of executing instructions from several instruction sources | |
CN112534414A (en) | Software trace message receiver peripheral | |
Guo et al. | BOOTLOADER Analysis Construction and U-BOOT Porting Based on S3C2440 | |
KR950033821A (en) | Trace device and emulator using it | |
JP2781779B2 (en) | Branch control circuit | |
JP2016184376A (en) | Performance evaluation module and semiconductor integrated circuit incorporating the same | |
JPS63156231A (en) | Changing method for instruction in read-only memory | |
JP2007213415A (en) | Memory device | |
JP2006215984A (en) | Circuit system |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
STPP | Information on status: patent application and granting procedure in general |
Free format text: DOCKETED NEW CASE - READY FOR EXAMINATION |
|
STPP | Information on status: patent application and granting procedure in general |
Free format text: FINAL REJECTION MAILED |
|
STPP | Information on status: patent application and granting procedure in general |
Free format text: DOCKETED NEW CASE - READY FOR EXAMINATION |
|
STPP | Information on status: patent application and granting procedure in general |
Free format text: NON FINAL ACTION MAILED |
|
STPP | Information on status: patent application and granting procedure in general |
Free format text: RESPONSE TO NON-FINAL OFFICE ACTION ENTERED AND FORWARDED TO EXAMINER |
|
STPP | Information on status: patent application and granting procedure in general |
Free format text: FINAL REJECTION MAILED |