19     def __init__(self, efuses, name):  argument
20         self.efuses = efuses
21         self.name = name
23     def __call__(self, new_value_str):  argument
81         efuse = self.efuses[self.name]
89     def get_read_disable_mask(self, blk_part=None):  argument
96         if isinstance(self.read_disable_bit, list):
98                 for i in self.read_disable_bit:
101                 mask |= 1 << self.read_disable_bit[blk_part]
103             mask = 1 << self.read_disable_bit
106     def get_count_read_disable_bits(self):  argument
109         return bin(self.get_read_disable_mask()).count("1")
111     def is_readable(self, blk_part=None):  argument
113         num_bit = self.read_disable_bit
116         return (self.parent["RD_DIS"].get() & self.get_read_disable_mask(blk_part)) == 0
118     def disable_read(self):  argument
119         num_bit = self.read_disable_bit
122         if not self.parent["RD_DIS"].is_writeable():
127         self.parent["RD_DIS"].save(self.get_read_disable_mask())
129     def is_writeable(self):  argument
130         num_bit = self.write_disable_bit
133         return (self.parent["WR_DIS"].get() & (1 << num_bit)) == 0
135     def disable_write(self):  argument
136         num_bit = self.write_disable_bit
137         if not self.parent["WR_DIS"].is_writeable():
142         self.parent["WR_DIS"].save(1 << num_bit)
144     def check_wr_rd_protect(self):  argument
145         if not self.is_readable():
146             error_msg = "\t{} is read-protected.".format(self.name)
149             self.parent.print_error_msg(error_msg)
150         if not self.is_writeable():
152                 self.name
154             self.parent.print_error_msg(error_msg)
158     def __init__(self, parent, param, skip_read=False):  argument
159         self.parent = parent
160         self.name = param.name
161         self.alias = param.alias
162         self.id = param.id
163         self.rd_addr = param.rd_addr
164         self.wr_addr = param.wr_addr
165         self.write_disable_bit = param.write_disable_bit
166         self.read_disable_bit = param.read_disable_bit
167         self.len = param.len
168         self.key_purpose_name = param.key_purpose
169         bit_block_len = self.get_block_len() * 8
170         self.bitarray = BitStream(bit_block_len)
171         self.bitarray.set(0)
172         self.wr_bitarray = BitStream(bit_block_len)
173         self.wr_bitarray.set(0)
174         self.fail = False
175         self.num_errors = 0
176         if self.id == 0:
177             self.err_bitarray = BitStream(bit_block_len)
178             self.err_bitarray.set(0)
180             self.err_bitarray = None
183             self.read()
185     def get_block_len(self):  argument
186         coding_scheme = self.get_coding_scheme()
187         if coding_scheme == self.parent.REGS.CODING_SCHEME_NONE:
188             return self.len * 4
189         elif coding_scheme == self.parent.REGS.CODING_SCHEME_34:
190             return (self.len * 3 // 4) * 4
191         elif coding_scheme == self.parent.REGS.CODING_SCHEME_RS:
192             return self.len * 4
198     def get_coding_scheme(self):  argument
199         if self.id == 0:
200             return self.parent.REGS.CODING_SCHEME_NONE
202             return self.parent.coding_scheme
204     def get_raw(self, from_read=True):  argument
206             return self.bitarray.bytes
208             return self.wr_bitarray.bytes
210     def get(self, from_read=True):  argument
211         self.get_bitstring(from_read=from_read)
213     def get_bitstring(self, from_read=True):  argument
215             return self.bitarray
217             return self.wr_bitarray
219     def convert_to_bitstring(self, new_data):  argument
225     def get_words(self):  argument
226         def get_offsets(self):  argument
227             return [x + self.rd_addr for x in range(0, self.get_block_len(), 4)]
229         return [self.parent.read_reg(offs) for offs in get_offsets(self)]
231     def read(self, print_info=True):  argument
232         words = self.get_words()
236         self.bitarray.overwrite(data, pos=0)
238             self.print_block(self.bitarray, "read_regs")
240     def print_block(self, bit_string, comment, debug=False):  argument
241         if self.parent.debug or debug:
245                 % (self.name, " ".join(self.alias)[:16], self.id, comment),
256     def check_wr_data(self):  argument
257         wr_data = self.wr_bitarray
260             if self.parent.debug:
261                 print("[{:02}] {:20} nothing to burn".format(self.id, self.name))
263         if len(wr_data.bytes) != len(self.bitarray.bytes):
266                 % (self.id, len(self.bitarray.bytes), len(wr_data.bytes))
268         self.check_wr_rd_protect()
270         if self.get_bitstring().all(False):
273                     self.id, self.name
278             if self.get_bitstring() == wr_data:
281                     "continue with EMPTY_BLOCK".format(self.id, self.name)
285                 print("[{:02}] {:20} is not empty".format(self.id, self.name))
286                 print("\t(written ):", self.get_bitstring())
288                 mask = self.get_bitstring() & wr_data
296                     coding_scheme = self.get_coding_scheme()
297                     if coding_scheme == self.parent.REGS.CODING_SCHEME_NONE:
299                     elif coding_scheme == self.parent.REGS.CODING_SCHEME_RS:
303                             "(RS coding scheme does not allow this)." % (self.name)
305                         self.parent.print_error_msg(error_msg)
306                     elif coding_scheme == self.parent.REGS.CODING_SCHEME_34:
309                         for i in range(0, self.get_bitstring().len, 6 * 8):
310                             rd_chunk = self.get_bitstring()[i : i + 6 * 8 :]
333                                 "(3/4 coding scheme does not allow this)." % (self.name)
335                             self.parent.print_error_msg(error_msg)
343     def save(self, new_data):  argument
353         if self.parent.debug:
355                 "\twritten : {} ->\n\tto write: {}".format(self.get_bitstring(), data)
357         self.wr_bitarray.overwrite(self.wr_bitarray | data, pos=0)
359     def burn_words(self, words):  argument
361             self.parent.efuse_controller_setup()
362             if self.parent.debug:
363                 print("Write data to BLOCK%d" % (self.id))
364             write_reg_addr = self.wr_addr
373                 if self.parent.debug:
375                 self.parent.write_reg(write_reg_addr, word)
378             self.parent.write_efuses(self.id)
380                 self.parent.efuse_read()
381                 self.parent.get_coding_scheme_warnings(silent=True)
382                 if self.fail or self.num_errors:
386                         % (self.id, burns, self.fail, self.num_errors)
389             if not self.fail and self.num_errors == 0:
390                 self.read(print_info=False)
391                 if self.wr_bitarray & self.bitarray != self.wr_bitarray:
404     def burn(self):  argument
405         if self.wr_bitarray.all(False):
408         before_burn_bitarray = self.bitarray[:]
409         assert before_burn_bitarray is not self.bitarray
410         self.print_block(self.wr_bitarray, "to_write")
411         words = self.apply_coding_scheme()
412         self.burn_words(words)
413         self.read()
414         if not self.is_readable():
418                     self.name, self.alias
421             if self.bitarray.all(False):
427                         self.name, self.bitarray.hex
431             if self.wr_bitarray == self.bitarray:
432                 print("BURN BLOCK%-2d - OK (write block == read block)" % self.id)
434                 self.wr_bitarray & self.bitarray == self.wr_bitarray
435                 and self.bitarray & before_burn_bitarray == before_burn_bitarray
437                 print("BURN BLOCK%-2d - OK (all write block bits are set)" % self.id)
441                 self.print_block(self.wr_bitarray, "Expected")
442                 self.print_block(self.bitarray, "Real    ")
445                 if self.id != 0:
447                         "Burn {} ({}) was not successful".format(self.name, self.alias)
449         self.wr_bitarray.set(0)
465     def __iter__(self):  argument
466         return self.efuses.__iter__()
468     def get_crystal_freq(self):  argument
469         return self._esp.get_crystal_freq()
471     def read_efuse(self, n):  argument
473         return self._esp.read_efuse(n)
475     def read_reg(self, addr):  argument
476         return self._esp.read_reg(addr)
478     def write_reg(self, addr, value, mask=0xFFFFFFFF, delay_us=0, delay_after_us=0):  argument
479         return self._esp.write_reg(addr, value, mask, delay_us, delay_after_us)
481     def update_reg(self, addr, mask, new_val):  argument
482         return self._esp.update_reg(addr, mask, new_val)
484     def efuse_controller_setup(self):  argument
487     def reconnect_chip(self, esp):  argument
494     def get_index_block_by_name(self, name):  argument
495         for block in self.blocks:
500     def read_blocks(self):  argument
501         for block in self.blocks:
504     def update_efuses(self):  argument
505         for efuse in self.efuses:
506             efuse.update(self.blocks[efuse.block].bitarray)
508     def postpone_efuses_from_block0_to_burn(self, block):  argument
526         if self._esp.CHIP_NAME == "ESP32":
540         def get_raw_value_from_write(self, efuse_name):  argument
541             return self[efuse_name].get_bitstring(from_read=False)
544             postpone_efuses[efuse_name] = get_raw_value_from_write(self, efuse_name)
547             if self.debug:
552                 self[key_name].reset()
555     def recover_postponed_efuses_from_block0_to_burn(self, postpone_efuses):  argument
559                 self[key_name].save(postpone_efuses[key_name])
561     def burn_all(self, check_batch_mode=False):  argument
563             if self.batch_mode_cnt != 0:
572         for block in self.blocks:
581         EspEfusesBase.confirm("", self.do_not_confirm)
605         for block in reversed(self.blocks):
607                 self.postpone_efuses_from_block0_to_burn(block)
608                 if self.postpone
615                 self.recover_postponed_efuses_from_block0_to_burn(postponed_efuses)
619         self.read_coding_scheme()
620         self.read_blocks()
621         self.update_efuses()
639     def print_error_msg(self, error_msg):  argument
640         if self.force_write_always is not None:
641             if not self.force_write_always:
643         if self.force_write_always:
648     def get_block_errors(self, block_num):  argument
650         return self.blocks[block_num].num_errors, self.blocks[block_num].fail
652     def is_efuses_incompatible_for_burn(self):  argument
658     def __init__(self, parent, param):  argument
659         self.category = param.category
660         self.parent = parent
661         self.block = param.block
662         self.word = param.word
663         self.pos = param.pos
664         self.write_disable_bit = param.write_disable_bit
665         self.read_disable_bit = param.read_disable_bit
666         self.name = param.name
667         self.efuse_class = param.class_type
668         self.efuse_type = param.type
669         self.description = param.description
670         self.dict_value = param.dictionary
671         self.bit_len = param.bit_len
672         self.alt_names = param.alt_names
673         self.fail = False
674         self.num_errors = 0
675         self.bitarray = BitStream(self.bit_len)
676         self.bitarray.set(0)
677         self.update(self.parent.blocks[self.block].bitarray)
679     def is_field_calculated(self):  argument
680         return self.word is None or self.pos is None
682     def check_format(self, new_value_str):  argument
686             if self.efuse_type.startswith("bytes"):
700     def convert_to_bitstring(self, new_value):  argument
704             if self.efuse_type.startswith("bytes"):
719                     return BitArray(self.efuse_type + "={}".format(new_value))
723                             new_value, self.name, self.efuse_type
728     def check_new_value(self, bitarray_new_value):  argument
729         bitarray_old_value = self.get_bitstring() | self.get_bitstring(from_read=False)
738                     self.name, bitarray_old_value.len, bitarray_new_value.len
743             or bitarray_new_value & self.get_bitstring() == bitarray_new_value
745             error_msg = "\tThe same value for {} ".format(self.name)
749         elif bitarray_new_value == self.get_bitstring(from_read=False):
750             error_msg = "\tThe same value for {} ".format(self.name)
755             if self.name not in ["WR_DIS", "RD_DIS"]:
763                     self.parent.print_error_msg(error_msg)
764             self.check_wr_rd_protect()
766     def save_to_block(self, bitarray_field):  argument
767         block = self.parent.blocks[self.block]
770             self.word * 32 + self.pos + bitarray_field.len
775     def save(self, new_value):  argument
776         bitarray_field = self.convert_to_bitstring(new_value)
777         self.check_new_value(bitarray_field)
778         self.save_to_block(bitarray_field)
780     def update(self, bit_array_block):  argument
781         if self.is_field_calculated():
782             self.bitarray.overwrite(
783                 self.convert_to_bitstring(self.check_format(self.get())), pos=0
786         field_len = self.bitarray.len
788             self.word * 32 + self.pos + field_len
790         self.bitarray.overwrite(bit_array_block.read(field_len), pos=0)
791         err_bitarray = self.parent.blocks[self.block].err_bitarray
794                 self.word * 32 + self.pos + field_len
796             self.fail = not err_bitarray.read(field_len).all(False)
798             self.fail = self.parent.blocks[self.block].fail
799             self.num_errors = self.parent.blocks[self.block].num_errors
801     def get_raw(self, from_read=True):  argument
808         return self.get_bitstring(from_read).read(self.efuse_type)
810     def get(self, from_read=True):  argument
816         if self.efuse_type.startswith("bytes"):
817             return util.hexify(self.get_bitstring(from_read).bytes[::-1], " ")
819             return self.get_raw(from_read)
821     def get_meaning(self, from_read=True):  argument
823         if self.dict_value:
825                 return self.dict_value[self.get_raw(from_read)]
828         return self.get(from_read)
830     def get_bitstring(self, from_read=True):  argument
832             self.bitarray.pos = 0
833             return self.bitarray
835             field_len = self.bitarray.len
836             block = self.parent.blocks[self.block]
838                 self.word * 32 + self.pos + field_len
840             return block.wr_bitarray.read(self.bitarray.len)
842     def burn(self, new_value):  argument
844         self.save(new_value)
845         self.parent.burn_all()
847     def get_info(self):  argument
849         if self.block == 0:
850             if self.fail:
853             errs, fail = self.parent.get_block_errors(self.block)
856         if self.efuse_class == "keyblock":
857             name = self.parent.blocks[self.block].key_purpose_name
862     def reset(self):  argument
864         bitarray_field = self.convert_to_bitstring(0)
865         block = self.parent.blocks[self.block]
868             self.word * 32 + self.pos + bitarray_field.len