Lines Matching refs:self
24 def len_of_burn_unit(self): argument
29 def __init__(self, parent, param, skip_read=False): argument
31 super(EfuseBlock, self).__init__(parent, param, skip_read=skip_read)
33 def apply_coding_scheme(self): argument
34 data = self.get_raw(from_read=False)[::-1]
35 if len(data) < self.len_of_burn_unit():
36 add_empty_bytes = self.len_of_burn_unit() - len(data)
38 if self.get_coding_scheme() == self.parent.REGS.CODING_SCHEME_RS:
62 self, argument
69 self.Blocks = EfuseDefineBlocks()
70 self.Fields = EfuseDefineFields(extend_efuse_table)
71 self.REGS = EfuseDefineRegisters
72 self.BURN_BLOCK_DATA_NAMES = self.Blocks.get_burn_block_data_names()
73 self.BLOCKS_FOR_KEYS = self.Blocks.get_blocks_for_keys()
74 self._esp = esp
75 self.debug = debug
76 self.do_not_confirm = do_not_confirm
83 flags = self._esp.get_security_info()["flags"]
89 self.blocks = [
90 EfuseBlock(self, self.Blocks.get(block), skip_read=skip_connect)
91 for block in self.Blocks.BLOCKS
94 self.get_coding_scheme_warnings()
95 self.efuses = [EfuseField.convert(self, efuse) for efuse in self.Fields.EFUSES]
96 self.efuses += [
97 EfuseField.convert(self, efuse) for efuse in self.Fields.KEYBLOCKS
100 self.efuses += [
101 EfuseField.convert(self, efuse)
102 for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
111 self.efuses += [
112 EfuseField.convert(self, efuse) for efuse in self.Fields.CALC
115 def __getitem__(self, efuse_name): argument
117 for e in self.efuses:
121 for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES:
125 self.efuses += [
126 EfuseField.convert(self, efuse)
127 for efuse in self.Fields.BLOCK2_CALIBRATION_EFUSES
131 for e in self.efuses:
136 def read_coding_scheme(self): argument
137 self.coding_scheme = self.REGS.CODING_SCHEME_RS
139 def print_status_regs(self): argument
141 self.blocks[0].print_block(self.blocks[0].err_bitarray, "err__regs", debug=True)
144 "EFUSE_RD_RS_ERR0_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR0_REG)
149 "EFUSE_RD_RS_ERR1_REG", self.read_reg(self.REGS.EFUSE_RD_RS_ERR1_REG)
153 def efuse_controller_setup(self): argument
154 self.set_efuse_timing()
155 self.clear_pgm_registers()
156 self.wait_efuse_idle()
158 def write_efuses(self, block): argument
159 self.efuse_program(block)
160 return self.get_coding_scheme_warnings(silent=True)
162 def clear_pgm_registers(self): argument
163 self.wait_efuse_idle()
165 self.REGS.EFUSE_PGM_DATA0_REG, self.REGS.EFUSE_PGM_DATA0_REG + 32, 4
167 self.write_reg(r, 0)
169 def wait_efuse_idle(self): argument
170 deadline = time.time() + self.REGS.EFUSE_BURN_TIMEOUT
172 cmds = self.REGS.EFUSE_PGM_CMD | self.REGS.EFUSE_READ_CMD
173 if self.read_reg(self.REGS.EFUSE_CMD_REG) & cmds == 0:
174 if self.read_reg(self.REGS.EFUSE_CMD_REG) & cmds == 0:
183 def efuse_program(self, block): argument
184 self.wait_efuse_idle()
185 self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_WRITE_OP_CODE)
186 self.write_reg(self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_PGM_CMD | (block << 2))
187 self.wait_efuse_idle()
188 self.clear_pgm_registers()
189 self.efuse_read()
191 def efuse_read(self): argument
192 self.wait_efuse_idle()
193 self.write_reg(self.REGS.EFUSE_CONF_REG, self.REGS.EFUSE_READ_OP_CODE)
198 self.write_reg(
199 self.REGS.EFUSE_CMD_REG, self.REGS.EFUSE_READ_CMD, delay_after_us=1000
201 self.wait_efuse_idle()
203 secure_download_mode_before = self._esp.secure_download_mode
206 self._esp = self.reconnect_chip(self._esp)
209 if not self["DIS_DOWNLOAD_MODE"].get() and self[
222 if self._esp.secure_download_mode and not secure_download_mode_before:
224 if not self["ENABLE_SECURITY_DOWNLOAD"].get() and self[
235 def set_efuse_timing(self): argument
238 apb_freq = self.get_crystal_freq()
245 def get_coding_scheme_warnings(self, silent=False): argument
250 for block in self.blocks:
253 self.read_reg(self.REGS.EFUSE_RD_REPEAT_ERR0_REG + offs * 4)
262 addr_reg, err_num_mask, err_num_offs, fail_bit = self.REGS.BLOCK_ERRORS[
269 reg_value = self.read_reg(addr_reg)
278 if (self.debug or ret_fail) and not silent:
279 self.print_status_regs()
282 def summary(self): argument
299 def get(self, from_read=True): argument
300 value = self.get_bitstring(from_read)
306 def get(self, from_read=True): argument
308 value = self.get_bitstring(from_read)
314 def check_format(self, new_value_str): argument
319 num_bytes = 8 if self.name == "MAC_EUI64" else 6
326 hexad = hexad.split(" ", 1)[0] if self.is_field_calculated() else hexad
335 if not self.is_field_calculated():
342 def check(self): argument
343 errs, fail = self.parent.get_block_errors(self.block)
345 output = "Block%d has ERRORS:%d FAIL:%d" % (self.block, errs, fail)
350 def get(self, from_read=True): argument
351 if self.name == "CUSTOM_MAC":
352 mac = self.get_raw(from_read)[::-1]
353 elif self.name == "MAC":
354 mac = self.get_raw(from_read)
355 elif self.name == "MAC_EUI64":
356 mac = self.parent["MAC"].get_bitstring(from_read).copy()
357 mac_ext = self.parent["MAC_EXT"].get_bitstring(from_read)
361 mac = self.get_raw(from_read)
362 return "%s %s" % (util.hexify(mac, ":"), self.check())
364 def save(self, new_value): argument
372 if self.name == "CUSTOM_MAC":
373 bitarray_mac = self.convert_to_bitstring(new_value)
374 print_field(self, bitarray_mac)
375 super(EfuseMacField, self).save(new_value)
404 def check_format(self, new_value_str): argument
408 for purpose_name in self.KEY_PURPOSES:
413 if int(raw_val) not in [p[1] for p in self.KEY_PURPOSES if p[1] > 0]:
419 def need_reverse(self, new_key_purpose): argument
420 for key in self.KEY_PURPOSES:
424 def need_rd_protect(self, new_key_purpose): argument
425 for key in self.KEY_PURPOSES:
429 def get(self, from_read=True): argument
430 for p in self.KEY_PURPOSES:
431 if p[1] == self.get_raw(from_read):
435 def get_name(self, raw_val): argument
436 for key in self.KEY_PURPOSES:
440 def save(self, new_value): argument
441 raw_val = int(self.check_format(str(new_value)))
442 return super(EfuseKeyPurposeField, self).save(raw_val)