A memory device and an operating method for controlling a non-volatile memory are provided. The non-volatile memory includes segments. Each of the segments includes memory cells. The operating method includes the following steps. A programming operation is performed multiple times on the memory cells in sequence according to increment commands, a segment order, and a memory cell order. When receiving a read command, a read operation is performed multiple times on the memory cells according to the segment order and the memory cell order until a last programmed memory cell is learned. According to an address of the last programmed memory cell, a replay-protected monotonic count value associated with a number of the increment commands is calculated.
|
1. An operating method adapted for controlling a non-volatile memory, wherein the non-volatile memory comprises a plurality of segments arranged in a segment order, a plurality of memory cells of each of the segments are arranged in a same memory cell order, and the operating method comprises:
performing a programming operation multiple times on the memory cells of the segments in sequence according to a plurality of increment commands, the segment order, and the memory cell order;
performing, when receiving a read command, a read operation multiple times according to the segment order and the memory cell order until a last programmed memory cell is learned; and
calculating, according to an address of the last programmed memory cell, a replay-protected monotonic count value associated with a number of the increment commands.
11. A memory device adapted for a replay-protected monotonic counter and comprising:
a non-volatile memory comprising a plurality of segments, wherein the segments are arranged in a segment order, and a plurality of memory cells of each of the segments are arranged in a same memory cell order; and
a controller coupled to the non-volatile memory and configured to:
receive a plurality of increment commands, and perform a programming operation multiple times on the memory cells of the segments in sequence according to the increment command, the segment order, and the memory cell order,
perform, when receiving a read command, a read operation multiple times according to the segment order and the memory cell order until a last programmed memory cell is learned, and
calculate, according to an address of the last programmed memory cell, a replay-protected monotonic count value associated with a number of the increment commands.
2. The operating method according to
performing, when receiving one of the increment commands, the programming operation once on one of the segments according to the increment command.
3. The operating method according to
when the plurality of memory cells of the segments are all programmed, setting a base value, and performing an erasing operation on the segments.
4. The operating method according to
calculating, according to the base value and the address of the last programmed memory cell, the replay-protected monotonic count value associated with the number of the increment commands.
5. The operating method according to
performing the programming operation on a plurality of memory cells of a first segment of the segments according to the memory cell order;
selecting, when all of the memory cells of the first segment are programmed, a second segment of the segments according to the segment order; and
performing the programming operation on a plurality of memory cells of the second segment according to the memory cell order.
6. The operating method according to
using one of the segments as a read segment one by one according to the segment order, and reading a first bit memory cell of the read segment to determine whether the read segment has a programmed first bit memory cell; and
when determining that the read segment of the segments has the programmed first bit memory cell and the read segment is not a last segment, using a next segment as the read segment according to the segment order to read a first bit memory cell of the read segment.
7. The operating method according to
when determining that the read segment does not have the programmed first bit memory cell, using a previous segment as the read segment according to the segment order, and reading a plurality of memory cells of the read segment one by one from a second bit memory cell of the read segment according to the memory cell order; and
learning the last programmed memory cell according to one of a determining result that an unprogrammed memory cell is read from the read segment for the first time and a determining result that a plurality of memory cells of the read segment are all programmed.
8. The operating method according to
performing the programming operation on a first bit memory cell of each of the segments according to the segment order; and
performing, after the first bit memory cell of each of the segments is programmed, the programming operation on a second bit memory cell of each of the segments according to the segment order and the memory cell order.
9. The operating method according to
using a last segment of the segments as a read segment;
reading a plurality of memory cells of the read segment one by one from the first bit memory cell of the read segment according to the memory cell order to determine whether the memory cells of the read segment are programmed; and
when determining that an ith bit memory cell of the read segment is not programmed, using a previous segment as the read segment according to the segment order, and reading an ith bit memory cell of the read segment to determine whether the ith bit memory cell of the read segment is programmed, wherein i is a positive integer greater than 0.
10. The operating method according to
learning the last programmed memory cell according to one of the following conditions:
it is determined that a read memory cell is a last bit memory cell of the last segment;
it is determined that the read memory cell is a programmed memory cell of a segment other than the last segment; and
it is determined that the read segment is a first segment of the segments.
12. The memory device according to
13. The memory device according to
14. The memory device according to
15. The memory device according to
perform the programming operation on a plurality of memory cells of a first segment of the segments according to the memory cell order;
select, when all of the memory cells of the first segment are programmed, a second segment of the segments according to the segment order; and
perform the programming operation on a plurality of memory cells of the second segment according to the memory cell order.
16. The memory device according to
use one of the segments as a read segment one by one according to the segment order, and read a first bit memory cell of the read segment to determine whether the read segment has a programmed first bit memory cell, and
when determining that the read segment of the segments has the programmed first bit memory cell and the read segment is not a last segment, use a next segment as the read segment according to the segment order to read a first bit memory cell of the read segment.
17. The memory device according to
when determining that the read segment does not have the programmed first bit memory cell, use a previous segment as the read segment according to the segment order, and read a plurality of memory cells of the read segment one by one from a second bit memory cell of the read segment according to the memory cell order, and
learning the last programmed memory cell according to one of a determining result that an unprogrammed memory cell is read from the read segment for the first time and a determining result that a plurality of memory cells of the read segment are all programmed.
18. The memory device according to
perform the programming operation on a first bit memory cell of each of the segments according to the segment order, and
perform, after the first bit memory cell of each of the segments is programmed, the programming operation on a second bit memory cell of each of the segments according to the segment order and the memory cell order.
19. The memory device according to
use a last segment of the segments as a read segment,
read a plurality of memory cells of the read segment one by one from the first bit memory cell of the read segment according to the memory cell order to determine whether the memory cells of the read segment are programmed, and
when determining that an ith bit memory cell of the read segment is not programmed, use a previous segment as the read segment according to the segment order, and read an ith bit memory cell of the read segment to determine whether the ith bit memory cell of the read segment is programmed, wherein i is a positive integer greater than 0.
20. The memory device according to
it is determined that a read memory cell is a last bit memory cell of the last segment;
it is determined that the read memory cell is a programmed memory cell of a segment other than the last segment; and
it is determined that the read segment is a first segment of the segments.
|
|||||||||||||||||||||||||||||
The disclosure relates to a memory device and an operating method, and in particular, to a memory device and an operating method for a replay-protected monotonic counter.
In general, memory devices are not protected from attacks against hardware. Therefore, a hacker can access a memory device to tamper with data stored therein. To prevent attacks by hackers, some memory devices are designed to require authentication of the identity of a user with respect to a command sent to the memory device. In a method for identity authentication, signatures for authentication by the user and the memory device are generated.
The replay-protected monotonic counter (RPMC) is one of encryption protocols. The RPMC may be configured to enhance security requirements of a memory device on applications such as Internet of Things (IoT). The RPMC provides a dynamic replay-protected monotonic count value. The RPMC can increment the replay-protected monotonic count value according to an operation of the memory device or an operation of a related device connected to the memory device, and can provide the replay-protected monotonic count value according to an external instruction. Therefore, the replay-protected monotonic count value is randomly incremented. The hacker has no way of learning the replay-protected monotonic count value of the RPMC. Only the user (because the user controls the operation of a counter) and the memory device (because information is stored in a memory array) know the replay-protected monotonic count value. In other words, only the user can complete identity verification by using the replay-protected monotonic count value to obtain the right to operating the memory device.
The RPMC performs programming operations on a plurality of memory cells of a memory one by one according to each increment command, and counts a number of programming operations only upon receiving a read command, so as to obtain the replay-protected monotonic count value. It should be noted that the RPMC needs to read the plurality of memory cells of the memory one by one to learn the number of memory cells programmed due to the increment command. The number of the read operations are substantially proportional to the number of the memory cells programmed due to the increment command. Therefore, when more memory cells are programmed due to the increment command, more read operations are required, so that it takes a long time for the RPMC to learn the replay-protected monotonic count value.
The invention provides a memory device and an operating method for accelerating the learning of a replay-protected monotonic count value.
The operating method of the invention is adapted for controlling a non-volatile memory. The non-volatile memory includes a plurality of segments. The plurality of segments are arranged in a segment order. A plurality of memory cells of each of the segments are arranged in a same memory cell order. The operating method includes the following steps. A programming operation is performed multiple times on the plurality of memory cells of the plurality of segments in sequence according to a plurality of increment commands, a segment order, and a memory cell order. When a read command is received, a read operation is performed multiple times according to the segment order and the memory cell order until a last programmed memory cell is learned. According to an address of the last programmed memory cell, a replay-protected monotonic count value associated with a number of the increment commands is calculated.
The memory device of the invention is adapted for being used as a replay-protected monotonic counter. The memory device includes a non-volatile memory and a controller. The non-volatile memory includes a plurality of segments. The plurality of segments are arranged in a segment order. A plurality of memory cells of each of the segments are arranged in a same memory cell order. The controller is coupled to the non-volatile memory. The controller is configured to receive a plurality of increment commands, perform a programming operation multiple times on the plurality of memory cells of the plurality of segments in sequence according to the plurality of increment commands, the segment order, and a memory cell order. The controller is further configured to perform, when a read command is received, a read operation multiple times according to the segment order and the memory cell order until a last programmed memory cell is learned, and calculate a replay-protected monotonic count value according to an address of the last programmed memory cell.
Based on the foregoing, in the invention, the programming operation is performed multiple times on the memory cells in sequence according to the plurality of increment commands, the segment order, and the memory cell order. In the invention, the read operation is performed multiple times according to a read command, the segment order, and the memory cell order to learn the last programmed memory cell. In addition, the replay-protected monotonic count value associated with the number of increment commands is further calculated according to the address of the last programmed memory cell. In this way, the learning of the replay-protected monotonic count value can be accelerated.
To make the above-mentioned features and advantages of the invention more comprehensible, the following gives a detailed description of embodiments with reference to accompanying drawings.
In the present embodiment, the controller 120 is coupled to the non-volatile memory 110. The controller 120 receives a plurality of increment commands ICMD in step S110, and performs a programming operation multiple times on the memory cells of the segments SG1-SGN in sequence according to the plurality of increment commands ICMD, the segment order, and the memory cell order. For example, in step S110, when receiving a first increment command ICMD, the controller 120 performs a single programming operation on a single memory cell of the segments SG1-SGN according to the segment order and the memory cell order. Next, when receiving a second increment command ICMD, the controller 120 performs a single programming operation on another memory cell of the segments SG1-SGN according to the segment order and the memory cell order. In other words, when receiving one increment command ICMD, the controller 120 performs one programming operation on the non-volatile memory 110 according to the segment order and the memory cell order. In the present embodiment, the programming operation is an operation to convert a logic value of the memory cell from “1” to “0”.
The controller 120 receives a read command RCMD in step S120, and performs a read operation multiple times according to the read command RCMD, the segment order, and the memory cell order until a last programmed memory cell is learned. For example, in step S120, when receiving the read command RCMD, the controller 120 performs a read operation multiple times on the non-volatile memory 110 according to the segment order and the memory cell order. When learning the last programmed memory cell in the non-volatile memory 110, the controller 120 stops the read operation.
In step S130, the controller 120 calculates, according to information about the last programmed memory cell, a replay-protected monotonic count value RS associated with a number of the increment commands ICMD. In detail, the controller 120 can calculate a number of programmed memory cells (equivalent to the number of increment commands ICMD) according to an address of the last programmed memory cell, and then calculate the replay-protected monotonic count value RS associated with the number of increment commands ICMD.
It is worth mentioning that the controller 120 performs programming operations on the non-volatile memory 110 based on the segment order and the memory cell order. The controller 120 further performs a read operation on the non-volatile memory 110 based on the segment order and the memory cell order until the last programmed memory cell is learned, and calculates the replay-protected monotonic count value RS according to the information about the last programmed memory cell. Compared to a manner in which a current RPMC performs the read operation on a plurality of memory cells of the memory one by one, the memory device 100 can learn the replay-protected monotonic count value RS more quickly.
In step S212, the controller 120 initially sets a programming segment and an address of a programmed target memory cell in the programming segment. In detail, the controller 120 sets a jth segment as the programming segment, and sets an ith bit memory cell of the jth segment as the programmed target memory cell. Therefore, the controller 120 initially sets values of i and j in step S212. For example, the controller 120 sets a 1st segment as the programming segment, and initially sets a 1st bit memory cell of the programming segment as the programmed target memory cell (that is, it is set that i=1, j=1). In other words, step S211 and step S212 are initialization steps in the programming step. In the present embodiment, 1≤j≤N, 1≤i≤M.
In step S213, when the controller 120 receives an increment command ICMD, the controller 120 performs a programming operation on the target memory cell in step S214. For example, when the controller 120 receives the increment command ICMD for the first time in step S213, the controller 120 performs a programming operation on the 1st bit memory cell of the 1st segment. If the controller 120 does not receive the increment command ICMD in step S213, the controller remains to wait for the increment command ICMD in step S213.
In step S215, the controller 120 determines whether the target memory cell is a last bit memory cell of the programming segment. If the target memory cell is not the last bit memory cell of the programming segment, the controller 120 sets a next bit memory cell as the target memory cell in step S216, and returns to step S213 to wait for a next increment command ICMD. In detail, the controller 120 sets the next bit memory cell of the programming segment as the target memory cell according to a memory cell order in step S216, for example, it is set that i=i+1 (a value of j is unchanged). In other words, in the present embodiment, the controller 120 performs a programming operation on the plurality of memory cells of the programming segment in an incremental memory cell order based on a cycle of step S213-step S216. In other embodiments, in step S212, the controller 120 may initially set a last bit memory cell of a 1st segment SG1 as a programmed target memory cell (that is, it is set that i=M, j=1). At this time, in step S216, it is set that i=i−1. Therefore, the controller 120 performs the programming operation on the plurality of memory cells of the programming segment in a decremental memory cell order based on the cycle of step S213-step S216.
In addition, in step S215, if the target memory cell is the last bit memory cell of the programming segment, it means that the last bit memory cell of the programming segment is programmed. At this time, the controller 120 determines whether the programming segment is the last segment in step S217. If the programming segment is not the last segment, the controller 120 sets a 1st bit memory cell of a next segment as a target memory cell in step S218, and returns to step S213 to wait for a next increment command ICMD. In detail, in step S218, the controller 120 sets the next segment as the programming segment according to a segment order, and sets a 1St memory cell of the programming segment as the target memory cell according to the memory cell segment. For example, it is set that j=j+1 and i=1. In other words, in the present embodiment, when programming on a plurality of memory cells of the programming segment is completed, the controller 120 performs programming the operation on the plurality of memory cells of the next segment in an incremental segment order based on the cycle of step S213-step S216.
In addition, in step S217, if the programming segment is the last segment, the controller 120 updates the base value B in step S219, performs an erasing operation on the memory cells of all segments SG1-SGN, and returns to step S212 to initially reset the programming segment and the address of the programmed target memory cell in the programming segment. In other words, when the memory cells of all segments SG1-SGN are programmed, after the controller 120 updates the base value B and erases all memory cells, and step S212 is re-performed. In the present embodiment, a preset value is added to the base value in step S219. The preset value is greater than or equal to a total number of the memory cells of all segments SG1-SGN. Afterwards, the controller 120 returns to step S212 to initialize values of i and j.
Referring to
When an 8th increment command ICMD, the controller 120 performs the programming operation on an 8th bit memory cell b1_8 of the programming segment SG1 (step S213, step S214). Next, the controller 120 determines that the target memory cell b1_8 is a last bit of the programming segment SG1, and the programming segment SG1 is not a last segment (step S215, step S217). Therefore, the controller 120 sets a next segment SG2 as the programming segment according to the segment order, and sets a 1st bit memory cell b2_1 of the programming segment SG2 as the target memory cell (step S218), and then performs a programming operation on the memory cells of the programming segment SG2 based on a cycle of step S213-step S216. Therefore, when receiving a 9th increment command ICMD, the controller 120 performs the programming operation on the 1st bit memory cell b2_1 of the programming segment SG2. Next, when receiving a 10th increment command ICMD, the controller 120 performs a programming operation on a 2nd bit memory cell b2_2 of the programming segment SG2 (as shown in example (b)), and the rest can be done in a same manner. When receiving a 16th increment command ICMD, the controller 120 performs a programming operation on the 8th bit memory cell b2_8 of the programming segment SG2 (as shown in example (c)). At this time, the controller 120 determines that the target memory cell b2_8 is a last bit of the programming segment SG2, and the programming segment SG2 is a last segment (step S215, step S217).
Next, the controller 120 updates the base value B, performs an erasing operation on both the segments SG1, SG2 (step S219), and initially resets the programming segment and an address of the programmed target memory cell in the programming segment (step S212), to wait for a next increment command ICMD. Herein, for example, a value of 16 is added to the base value B, and therefore an updated base value B is equal to 16.
In a cycle of step S222-step S225, a value of i is always unchanged (for example, the value keeps at 1 herein). Therefore, the controller 120 reads an ith bit memory cell of each of the segments one by one according to the segment order until the controller 120 finds an unprogrammed ith bit memory cell (step S223—No) or all ith bit memory cells of all segments are programmed memory cells (step S224—Yes).
In addition, if the controller 120 determines that the target memory cell is not the programmed memory cell in step S223, the controller 120 sets a previous segment as the read segment and sets a next bit memory cell of the read segment as the target memory cell in step S226, and performs the read operation on the target memory cell in step S227. In detail, in step S226, the controller 120 sets the previous segment as the read segment according to the segment order, and sets the next bit memory cell as the target memory cell according to the memory cell order. For example, it is set that j=j−1 and i=i+1. In other words, when the controller 120 finds an unprogrammed ith bit memory cell in the cycle of step S222-step S225, the controller 120 then performs the read operation on the next bit memory cell of the previous segment.
Next, the controller 120 determines whether the target memory cell is the programmed memory cell in step S228. If the target memory cell is not the programmed memory cell, the controller 120 learns the last programmed memory cell in step S231. In other words, at this time, the (i−1)th bit memory cell of the jth segment is the last programmed memory cell.
If the controller 120 determines that the target memory cell is the programmed memory cell in step S228, the controller 120 determines whether the target memory cell is the last bit memory cell of the read segment in step S229. If the target memory cell is the last bit memory cell of the read segment, the controller 120 further learns the last programmed memory cell in step S231. In other words, at this time, the ith bit memory cell of the jth segment is the last programmed memory cell.
In addition, if the controller 120 determines that the target memory cell is not the last bit memory cell of the read segment in step S229, the controller 120 sets a next bit memory cell as the target memory cell in step S230. In detail, in step S230, the controller 120 sets the next bit memory cell of the read segment as the target memory cell according to the memory cell order, for example, it is set that i=i+1 (the value of j is unchanged). Next, the controller 120 returns to step S227 to continue to perform a read operation on the target memory cell. In addition, when the controller 120 determines that the read segment is the last segment in step S224, the controller 120 performs step S230.
It can be learned from this that in the present embodiment, based on step S226-step S231, the controller 120 reads a plurality of memory cells of the previous segment according to the segment order and the memory cell order. Next, the controller 120 learns a last programmed memory cell according to a determining result that an unprogrammed memory cell is read first in the segment and a determining result that a plurality of cells of the segment are programmed.
Referring to
When a programming result of an example (b) is read, first, the controller 120 sets the 1st segment SG1 as a read segment, sets a 1st bit memory cell b1_1 of the read segment SG1 as a read target memory cell, and performs a read operation on the target memory cell b1_1 (steps S221, S222). Next, the controller 120 determines that the target memory cell b1_1 is the programmed memory cell, and the read segment SG1 is not a last segment (step S223, step S224). Therefore, the controller 120 sets a next segment SG2 as the read segment according to the segment order, sets a 1st bit memory cell b2_1 of the read segment SG2 as the target memory cell, and continues to perform a read operation on the target memory cell b2_1 (step 225, step S222). Next, the controller 120 determines that the target memory cell b2_1 is the programmed memory cell, and the read segment SG2 is the last segment (step S223, step S224). Therefore, the controller 120 sets a next bit memory cell b2_2 of the read segment SG2 as the target memory cell according to the memory cell order, and continues to perform the read operation on the target memory cell b2_2 (step S230, step S227). Next, the controller 120 determines that the target memory cell b2_2 is the programmed memory cell, and the target memory cell b2_2 is not a last bit memory cell of a 2nd segment (step S228, step S229). Therefore, the controller 120 sets a next bit memory cell b2_3 of the read segment SG2 as the target memory cell according to the memory cell order, and continues to perform the read operation on the target memory cell b2_3 (step S230, step S227). Next, the controller 120 determines that the target memory cell b2_3 is not the programmed memory cell. Therefore, the controller learns that the previous bit memory cell b2_2 at this time is the last programmed memory cell (step S228, step S231). In the example (b), the controller 120 may learn that the memory cell b2_2 is the last programmed memory cell after four read operations.
When a programming result of an example (c) is read, first, the controller 120 sets a 1st segment SG1 as a read segment, sets a 1st bit memory cell b1_1 of the read segment SG1 as a read target memory cell, and performs a read operation on a target memory cell b1_1 (step S221, step S222). Next, the controller 120 determines that the target memory cell b1_1 is the programmed memory cell, and the read segment SG1 is not a last segment (step S223, step S224). Therefore, the controller 120 sets a next segment SG2 as the read segment according to the segment order, sets a 1st bit memory cell b2_1 of the read segment SG2 as the target memory cell, and continues to perform a read operation on the target memory cell b2_1 (step 225, step S222). Next, the controller 120 determines that the target memory cell b2_1 is the programmed memory cell, and the read segment SG2 is the last segment (step S223, step S224). Therefore, the controller 120 sets a next bit memory cell b2_2 of the read segment SG2 as the target memory cell according to the memory cell order, and continues to perform the read operation on the target memory cell b2_2 (step S230, step S227). Next, the controller 120 determines that the target memory cell b2_2 is the programmed memory cell, and the target memory cell b2_2 is not a last bit memory cell of a 2nd segment (step S228, step S229). Therefore, the controller 120 sets a next bit memory cell b2_3 of the read segment SG2 as the target memory cell according to the memory cell order, and continues to perform the read operation on the target memory cell b2_3 (step S230, step S227), and rest can be done in a same manner. When the controller 120 reads a target memory cell b2_8, the controller 120 determines that the target memory cell b2_8 is a programmed memory cell (step S227, step S228), then the controller 120 determines that the target memory cell b2_8 is a last bit memory cell of a read segment SG2. Therefore, the controller learns that the target memory cell b2_8 at this time is a last programmed memory cell (step S231). In the example (c), the controller 120 may learn that the memory cell b2_8 is the last programmed memory cell after nine read operations.
Still referring to
Following step S314, in step S315, the controller 120 determines whether the programming segment is a last segment. If the programming segment is not the last segment, the controller 120 sets a next segment as a read segment in step 316, sets an ith bit memory cell of the read segment as a target memory cell, and returns to step S313 to wait for a next increment command ICMD. In detail, the controller 120 sets the next segment as the programming segment according to the segment order in step S316, and sets the ith bit memory cell of the programming segment as the target memory cell, for example, it is set that j=j+1 (a value of i is unchanged). In other words, in the present embodiment, the controller S120 performs a programming operation on ith bit memory cells of all segments in an incremental segment order based on a cycle of step S313-step S316.
In addition, in step S315, if the programming segment is the last segment, it means that the ith bit memory cell of all segments is programmed. At this time, the controller 120 determines whether the target memory cell is a last bit memory cell of the programming segment in step S317. If the target memory cell is not the last bit memory cell, the controller 120 sets a next bit memory cell of the 1st segment as the target memory cell in step S318, and returns to step S313 to wait for a next increment command ICMD. In detail, in step S318, the controller 120 sets the 1st segment as the programming segment according to the segment order, and sets the next bit memory cell as the target memory cell according to the memory cell order, for example, it is set that j=1 and i=i+1. In other words, in the present embodiment, after ith bit memory cells of all segments SG1-SGN are programmed, the controller 120 then performs a programming operation on next bit memory cells of all segments based on a cycle of step S313-step S316.
In addition, in step S317, if the target memory cell is the last bit memory cell of the programming segment, the controller 120 updates a base value B in step S319 and performs an erasing operation on the memory cells of all segments SG1-SGN. For step S319 in the present embodiment, reference may be made to relevant description of step S219 in the second embodiment, and the descriptions thereof are omitted herein.
Referring to
If the controller 120 determines that the target memory cell is not the programmed memory cell in step S323, the controller 120 sets an ith bit memory cell of a previous segment as the target memory cell in step S326, and performs the read operation on the target memory cell in step S327. In detail, the controller 120 sets a previous segment as the read segment according to the segment order in step S326, and sets the ith bit memory cell of the read segment as the target memory cell, for example, it is set that j=j−1 (a value of i is unchanged). In other words, when the controller 120 finds an unprogrammed ith bit memory cell in a cycle of step S322-step S325, the controller 120 performs the read operation on the ith bit memory cell of the previous segment.
Next, the controller 120 determines whether the target memory cell is the programmed memory cell in step S328. If the target memory cell is the programmed memory cell, the controller 120 learns the last programmed memory cell in step S330. In other words, at this time, the ith bit memory cell of the jth segment is the last programmed memory cell.
However, when the controller 120 determines, in step S328, that the target memory cell is not the programmed memory cell, the controller 120 determines, in step S329, whether the read segment is the 1st segment. If the read segment is not the 1st segment, the controller 120 returns to step S326 and then sets a previous segment as the read segment, sets an ith bit memory cell of the read segment as the target memory cell, and performs, in S327, a read operation on the target memory cell.
In addition, if the controller 120 determines, in step S329, that the read segment is the 1st segment, the controller 120 further learns the last programmed memory cell in step S330. In other words, because it is determined in step S326-step S329 that ith bit memory cells of all segments are not programmed, it may be learned according to the read results of step S321-step S325 that an i−1th bit of the last segment is the last programmed memory cell.
In addition, in step S324, if the controller 120 determines that the target memory cell is a last bit memory cell, it means that memory cells of all segments are programmed, and therefore the last programmed memory cell is also learned in step S330. In other words, the last bit memory cell of the last segment is the last programmed memory cell.
It may be learned that in the present embodiment, the controller 120 first reads a memory cell in a last segment (that is, an Nth segment SGN) one by one according to the memory cell order in step S322 to step S325. Afterwards, when the controller 120 reads an unprogrammed ith bit memory cell for the first time in the last segment, the controller 120 reads an ith bit memory cell of each segment one by one according to a decremental segment order in step S326 to step S329. Next, the controller 120 learns the last programmed memory cell according to a determining result (step S328—Yes) that a programmed ith bit memory cell is read for the first time, a determining result (step S329—Yes) that ith bit memory cells of all segments are not programmed, and a determining result (step S324—Yes) that memory cells of all segments are programmed.
Referring to
When a programming result of the example (e) is read, first, the controller 120 sets a last segment SG2 as a read segment, and sets a 1st bit memory cell b2_1 of the read segment SG2 as a read target memory cell, and performs a read operation on the target memory cell b2_1 (step S321, step S322). Next, the controller 120 determines that the target memory cell b2_1 is a programmed memory cell, and the target memory cell b2_1 is not a last bit memory cell of a last segment (step S323, step S324). Therefore, the controller 120 sets a next bit memory cell b2_2 of the read segment SG2 as the target memory cell according to the memory cell order, and continues to perform the read operation on the target memory cell b2_2 (step S325, step S322), and the rest can be done in a same manner. When a 6th bit memory cell b2_6 of the last segment SG2 is read, the controller 120 determines that the target memory cell b2_6 is not the programmed memory cell (step S322, step S323). Next, the controller 120 sets a previous segment SG1 as a read segment, sets a 6th bit memory cell b1_6 of the read segment SG1 as the target memory cell, and continues to perform the read operation on the target memory cell b1_6 (step S326, step S327). Next, the controller 120 determines that the target memory cell b1_6 is not a programmed memory cell, and the segment SG1 at this time is the 1st segment (step S328, step S329). Therefore, the controller learns that the memory cell b2_5 is a last programmed memory cell (step S330). In the example (e), the controller 120 may learn that the memory cell b2_5 is the last programmed memory cell after seven read operations.
When a programming result of an example (f) is read, first, the controller 120 sets a last segment SG2 as a read segment, and sets a 1st bit memory cell b2_1 of the read segment SG2 as a read target memory cell, and performs a read operation on the target memory cell b2_1 (step S321, step S322). Next, the controller 120 determines that the target memory cell b2_1 is a programmed memory cell, and the target memory cell b2_1 is not a last bit memory cell of a last segment (step S323, step S324). Therefore, the controller 120 sets a next bit memory cell b2_2 of the read segment SG2 as the target memory cell according to the memory cell order, and continues to perform the read operation on the target memory cell b2_2 (step S325, step S322), and the rest can be done in a same manner. When an 8th bit memory cell b2_8 of a last segment SG2 is read (step S322), the controller 120 determines that the target memory cell b2_8 is a programmed memory cell, and the target memory cell b2_8 is the last bit memory cell of the last segment (step S323, step S324). Therefore, the controller learns that the target memory cell b2_8 is a last programmed memory cell (step S330). In the example (f), the controller 120 may learn that the memory cell b2_8 is the last programmed memory cell after eight read operations.
Returning to the embodiments of
Next, according to Table 1, a comparison result of numbers of read operations in a comparison example, and the second embodiment and the third embodiment of the invention are summarized. The comparison example has 16 memory cells the same as the second embodiment and the third embodiment of the invention. In the comparison example, when the non-volatile memory receives a programming command and a read command, a memory cell is not planned as an example of a plurality of segments. Therefore, the comparison example simply performs a programming operation on memory cells according to a memory cell order, and performs a read operation on the memory cells according to the memory cell order. In order to learn the replay-protected monotonic count value, a number of read operations required in the comparison example is greater than or equal to a number of increment instructions.
TABLE 1
A number of performed read operations
Comparison
Second
Third
example
embodiment
embodiment
1
2
3
2
2
3
4
3
3
4
5
3
4
5
6
4
5
6
7
4
6
7
8
5
7
8
9
5
8
9
9
6
9
10
3
6
10
11
4
7
11
12
5
7
12
13
6
8
13
14
7
8
14
15
8
9
15
16
9
9
16
16
9
8
Average
9.4
6.4
5.9
number
It may be learned from the result in Table 1 that when the programming operation and the read operation are performed in a case that the non-volatile memory is planned as a plurality of segments, the replay-protected monotonic count value may be learned through less read operations in the second embodiment and the third embodiment. If there is a larger a space of the non-volatile memory and a greater number of segments, the effect of accelerating the learning of the replay-protected monotonic count value will be more significant in the second embodiment and the third embodiment.
Based on the foregoing, according to the invention, the programming operation is performed multiple times on the memory cells of the plurality of segments according to the segment order and the memory cell order. According to the invention, the read operation is performed multiple times according to the segment order and the memory cell order to learn the last programmed memory cell. In addition, according to the invention, the replay-protected monotonic count value associated with the number of increment commands is calculated according to the information about the last programmed memory cell. In this way, the learning of the replay-protected monotonic count value can be accelerated.
Although the invention has been described above by using the embodiments, the embodiments are not intended to limit the invention. A person of ordinary skill in the art may make variations and improvements without departing from the spirit and scope of the invention. Therefore, the protection scope of the invention should be subject to the appended claims.
| Patent | Priority | Assignee | Title |
| Patent | Priority | Assignee | Title |
| 8072804, | Jul 22 2008 | Samsung Electronics Co., Ltd. | Multi-bit flash memory devices and methods of programming and erasing the same |
| 9213598, | Feb 19 2013 | Samsung Electronics Co., Ltd. | Nonvolatile memory device and method of operating the same |
| 9355724, | Nov 12 2012 | Samsung Electronics Co., Ltd. | Memory system comprising nonvolatile memory device and method of adjusting read voltage based on sub-block level program and erase status |
| 9396798, | Apr 09 2013 | GIGADEVICE SEMICONDUCTOR INC | Enhanced flash chip and method for packaging chip |
| 9728520, | Apr 09 2013 | GIGADEVICE SEMICONDUCTOR INC | Enhanced flash chip and method for packaging chip |
| 9836236, | Apr 09 2013 | GIGADEVICE SEMICONDUCTOR INC | SPI interface enhanced flash chip and chip packaging method |
| 20110170346, | |||
| 20190325167, |
| Executed on | Assignor | Assignee | Conveyance | Frame | Reel | Doc |
| Sep 14 2020 | HO, WEN-CHIAO | Winbond Electronics Corp | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 053766 | /0807 | |
| Sep 15 2020 | Winbond Electronics Corp. | (assignment on the face of the patent) | / |
| Date | Maintenance Fee Events |
| Sep 15 2020 | BIG: Entity status set to Undiscounted (note the period is included in the code). |
| Nov 19 2024 | M1551: Payment of Maintenance Fee, 4th Year, Large Entity. |
| Date | Maintenance Schedule |
| Jun 01 2024 | 4 years fee payment window open |
| Dec 01 2024 | 6 months grace period start (w surcharge) |
| Jun 01 2025 | patent expiry (for year 4) |
| Jun 01 2027 | 2 years to revive unintentionally abandoned end. (for year 4) |
| Jun 01 2028 | 8 years fee payment window open |
| Dec 01 2028 | 6 months grace period start (w surcharge) |
| Jun 01 2029 | patent expiry (for year 8) |
| Jun 01 2031 | 2 years to revive unintentionally abandoned end. (for year 8) |
| Jun 01 2032 | 12 years fee payment window open |
| Dec 01 2032 | 6 months grace period start (w surcharge) |
| Jun 01 2033 | patent expiry (for year 12) |
| Jun 01 2035 | 2 years to revive unintentionally abandoned end. (for year 12) |