Memory Controller Firmware Loading with Dual Copy Error Recovery
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
As flash memory devices increase in size and complexity, bit errors in firmware codes become more common, leading to potential failures in loading program codes, which can prevent system startup, necessitating the use of multiple code copies but still risking unsuccessful loading if both copies are corrupted.
Innovation Solution
A method for loading program codes from a rewritable non-volatile memory module that involves storing two identical code copies across separate physical blocks and using an error correction mechanism to alternate between them, ensuring successful loading even if one copy contains uncorrectable error bits.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If two program code copies are stored in flash memory to prevent bit errors, then reliability is improved, but the risk remains that both copies could be corrupted and system startup fails
Solution Approach 1:
The program code is divided into multiple data segments, and each segment is distributed across different physical blocks in the flash memory. This segmentation ensures that even if multiple bit errors occur in one copy, other segments can be recovered from different physical blocks, preventing complete failure of system startup.
Solution Approach 2:
The patent introduces a third dimension of redundancy by distributing code segments across multiple physical blocks rather than just storing multiple copies at the same location. This spatial distribution across different physical blocks provides protection against bit errors that would affect all copies at a single location.
2Adaptability or versatility
If firmware code size and complexity increase, then functionality is improved, but the probability of bit errors increases
Solution Approach 1:
The firmware code is segmented into multiple data segments that are distributed across different physical blocks. This allows the system to maintain large and complex firmware functionality while reducing the impact of bit errors by isolating corruption to specific segments that can be recovered from alternative locations.
Solution Approach 2:
The system performs preliminary actions by pre-distributing multiple code copies across different physical blocks during the programming phase. This preliminary distribution ensures that when bit errors occur during operation, the system already has redundant copies available for recovery without requiring additional real-time actions.
3Reliability
If multiple code copies are stored to ensure reliability, then system startup reliability is improved, but device complexity increases
Solution Approach 1:
The code is segmented and distributed across multiple physical blocks, which simplifies the memory structure compared to storing complete duplicate copies. The memory controller only needs to manage segment-level redundancy and physical block mapping, reducing the complexity of handling multiple full code copies.
Solution Approach 2:
The physical blocks serve multiple functions: they store code segments for normal operation, provide redundancy for error recovery, and enable flexible code loading strategies. This multi-functionality reduces the need for separate dedicated redundancy structures, thereby reducing overall device complexity.
Data Source
AI summary
A method of loading a program code from a rewritable non-volatile memory module is provided, wherein the program code includes data segments and two program code copies corresponding to the program code are stored in the rewritable non-volatile memory module. The method includes loading a first data segment of a first program code copy and determining whether the first data segment contains any uncorrectable error bit. The method still includes, when the first data segment does not contain any uncorrectable error bit, loading a second data segment of the first program code copy. The method further includes, when the first data segment contains an uncorrectable error bit, loading a first data segment of a second program code copy, and then loading a second data segment of the first program code copy or the second program code copy. Thereby, the program code can be successfully loaded.