1 /*
2  * SPDX-FileCopyrightText: 2020-2021 Espressif Systems (Shanghai) CO LTD
3  *
4  * SPDX-License-Identifier: Apache-2.0
5  */
6 
7 /* INTERNAL API
8  * implementation of generic interface to MMU memory protection features
9  */
10 
11 #include <stdio.h>
12 #include "sdkconfig.h"
13 #include "soc/sensitive_reg.h"
14 #include "soc/periph_defs.h"
15 #include "esp_intr_alloc.h"
16 #include "hal/memprot_ll.h"
17 #include "hal/memprot_peri_ll.h"
18 #include "esp32s2/memprot.h"
19 #include "esp_fault.h"
20 #include "esp_cpu.h"
21 #include "esp_rom_sys.h"
22 
23 extern int _iram_text_end;
24 extern int _data_start;
25 extern int _rtc_text_end;
26 extern int _rtc_dummy_end;
27 
esp_memprot_ll_err_to_esp_err(memprot_hal_err_t err)28 static inline esp_err_t esp_memprot_ll_err_to_esp_err(memprot_hal_err_t err)
29 {
30     switch (err) {
31     case MEMP_HAL_OK: return ESP_OK;
32     case MEMP_HAL_FAIL: return ESP_FAIL;
33     case MEMP_HAL_ERR_SPLIT_ADDR_INVALID: return ESP_ERR_INVALID_STATE;
34     case MEMP_HAL_ERR_SPLIT_ADDR_UNALIGNED: return ESP_ERR_INVALID_SIZE;
35     case MEMP_HAL_ERR_UNI_BLOCK_INVALID: return ESP_ERR_NOT_FOUND;
36     default:
37         return ESP_FAIL;
38     }
39 }
40 
esp_memprot_iram0_sram_get_min_split_addr(void)41 uint32_t *esp_memprot_iram0_sram_get_min_split_addr(void)
42 {
43     return (uint32_t *)&_iram_text_end;
44 }
45 
esp_memprot_iram0_rtcfast_get_min_split_addr(void)46 uint32_t *esp_memprot_iram0_rtcfast_get_min_split_addr(void)
47 {
48     return (uint32_t *)&_rtc_text_end;
49 }
50 
esp_memprot_dram0_sram_get_min_split_addr(void)51 uint32_t *esp_memprot_dram0_sram_get_min_split_addr(void)
52 {
53     return (uint32_t *)&_data_start;
54 }
55 
esp_memprot_dram0_rtcfast_get_min_split_addr(void)56 uint32_t *esp_memprot_dram0_rtcfast_get_min_split_addr(void)
57 {
58     return (uint32_t *)&_rtc_dummy_end;
59 }
60 
esp_memprot_peri1_rtcslow_get_min_split_addr(void)61 uint32_t *esp_memprot_peri1_rtcslow_get_min_split_addr(void)
62 {
63     return (uint32_t *)PERI1_RTCSLOW_ADDRESS_BASE;
64 }
65 
esp_memprot_peri2_rtcslow_0_get_min_split_addr(void)66 uint32_t *esp_memprot_peri2_rtcslow_0_get_min_split_addr(void)
67 {
68     return (uint32_t *)PERI2_RTCSLOW_0_ADDRESS_BASE;
69 }
70 
esp_memprot_peri2_rtcslow_1_get_min_split_addr(void)71 uint32_t *esp_memprot_peri2_rtcslow_1_get_min_split_addr(void)
72 {
73     return (uint32_t *)PERI2_RTCSLOW_1_ADDRESS_BASE;
74 }
75 
esp_memprot_get_split_addr(mem_type_prot_t mem_type)76 uint32_t *esp_memprot_get_split_addr(mem_type_prot_t mem_type)
77 {
78     switch (mem_type) {
79     case MEMPROT_IRAM0_SRAM:
80         return esp_memprot_iram0_sram_get_min_split_addr();
81     case MEMPROT_DRAM0_SRAM:
82         return esp_memprot_dram0_sram_get_min_split_addr();
83     case MEMPROT_IRAM0_RTCFAST:
84         return esp_memprot_iram0_rtcfast_get_min_split_addr();
85     case MEMPROT_DRAM0_RTCFAST:
86         return esp_memprot_dram0_rtcfast_get_min_split_addr();
87     case MEMPROT_PERI1_RTCSLOW:
88         return esp_memprot_peri1_rtcslow_get_min_split_addr();
89     case MEMPROT_PERI2_RTCSLOW_0:
90         return esp_memprot_peri2_rtcslow_0_get_min_split_addr();
91     case MEMPROT_PERI2_RTCSLOW_1:
92         return esp_memprot_peri2_rtcslow_1_get_min_split_addr();
93     default:
94         return (uint32_t *)MEMPROT_INVALID_ADDRESS;
95     }
96 }
97 
esp_memprot_type_to_str(mem_type_prot_t mem_type)98 const char *esp_memprot_type_to_str(mem_type_prot_t mem_type)
99 {
100     switch (mem_type) {
101     case MEMPROT_IRAM0_SRAM:
102         return "IRAM0_SRAM";
103     case MEMPROT_DRAM0_SRAM:
104         return "DRAM0_SRAM";
105     case MEMPROT_IRAM0_RTCFAST:
106         return "IRAM0_RTCFAST";
107     case MEMPROT_DRAM0_RTCFAST:
108         return "DRAM0_RTCFAST";
109     case MEMPROT_PERI1_RTCSLOW:
110         return "PERI1_RTCSLOW";
111     case MEMPROT_PERI2_RTCSLOW_0:
112         return "PERI2_RTCSLOW_0";
113     case MEMPROT_PERI2_RTCSLOW_1:
114         return "PERI2_RTCSLOW_1";
115     default:
116         return "INVALID_MEM_TYPE";
117     }
118 }
119 
esp_memprot_intr_init(mem_type_prot_t mem_type)120 esp_err_t esp_memprot_intr_init(mem_type_prot_t mem_type)
121 {
122     ESP_INTR_DISABLE(ETS_MEMACCESS_ERR_INUM);
123 
124     switch (mem_type) {
125     case MEMPROT_IRAM0_SRAM:
126     case MEMPROT_IRAM0_RTCFAST:
127         esp_rom_route_intr_matrix(PRO_CPU_NUM, memprot_ll_iram0_get_intr_source_num(), ETS_MEMACCESS_ERR_INUM);
128         break;
129     case MEMPROT_DRAM0_SRAM:
130     case MEMPROT_DRAM0_RTCFAST:
131         esp_rom_route_intr_matrix(PRO_CPU_NUM, memprot_ll_dram0_get_intr_source_num(), ETS_MEMACCESS_ERR_INUM);
132         break;
133     case MEMPROT_PERI1_RTCSLOW:
134         esp_rom_route_intr_matrix(PRO_CPU_NUM, memprot_ll_peri1_get_intr_source_num(), ETS_MEMACCESS_ERR_INUM);
135         break;
136     case MEMPROT_PERI2_RTCSLOW_0:
137     case MEMPROT_PERI2_RTCSLOW_1:
138         esp_rom_route_intr_matrix(PRO_CPU_NUM, memprot_ll_peri2_get_intr_source_num(), ETS_MEMACCESS_ERR_INUM);
139         break;
140     default:
141         return ESP_ERR_NOT_SUPPORTED;
142     }
143 
144     ESP_INTR_ENABLE(ETS_MEMACCESS_ERR_INUM);
145 
146     return ESP_OK;
147 }
148 
esp_memprot_intr_ena(mem_type_prot_t mem_type,bool enable)149 esp_err_t esp_memprot_intr_ena(mem_type_prot_t mem_type, bool enable)
150 {
151     switch (mem_type) {
152     case MEMPROT_IRAM0_SRAM:
153     case MEMPROT_IRAM0_RTCFAST:
154         memprot_ll_iram0_intr_ena(enable);
155         break;
156     case MEMPROT_DRAM0_SRAM:
157     case MEMPROT_DRAM0_RTCFAST:
158         memprot_ll_dram0_intr_ena(enable);
159         break;
160     case MEMPROT_PERI1_RTCSLOW:
161         memprot_ll_peri1_intr_ena(enable);
162         break;
163     case MEMPROT_PERI2_RTCSLOW_0:
164     case MEMPROT_PERI2_RTCSLOW_1:
165         memprot_ll_peri2_intr_ena(enable);
166         break;
167     default:
168         return ESP_ERR_NOT_SUPPORTED;
169     }
170 
171     return ESP_OK;
172 }
173 
esp_memprot_get_active_intr_memtype()174 mem_type_prot_t esp_memprot_get_active_intr_memtype()
175 {
176     if (memprot_ll_iram0_sram_is_intr_mine()) {
177         return MEMPROT_IRAM0_SRAM;
178     } else if (memprot_ll_iram0_rtcfast_is_intr_mine()) {
179         return MEMPROT_IRAM0_RTCFAST;
180     } else if (memprot_ll_dram0_sram_is_intr_mine()) {
181         return MEMPROT_DRAM0_SRAM;
182     } else if (memprot_ll_dram0_rtcfast_is_intr_mine()) {
183         return MEMPROT_DRAM0_RTCFAST;
184     } else if (memprot_ll_peri1_rtcslow_is_intr_mine()) {
185         return MEMPROT_PERI1_RTCSLOW;
186     } else if (memprot_ll_peri2_rtcslow_0_is_intr_mine()) {
187         return MEMPROT_PERI2_RTCSLOW_0;
188     } else if (memprot_ll_peri2_rtcslow_1_is_intr_mine()) {
189         return MEMPROT_PERI2_RTCSLOW_1;
190     }
191 
192     return MEMPROT_NONE;
193 }
194 
esp_memprot_clear_intr(mem_type_prot_t mem_type)195 esp_err_t esp_memprot_clear_intr(mem_type_prot_t mem_type)
196 {
197     switch (mem_type) {
198     case MEMPROT_IRAM0_SRAM:
199     case MEMPROT_IRAM0_RTCFAST:
200         memprot_ll_iram0_clear_intr();
201         break;
202     case MEMPROT_DRAM0_SRAM:
203     case MEMPROT_DRAM0_RTCFAST:
204         memprot_ll_dram0_clear_intr();
205         break;
206     case MEMPROT_PERI1_RTCSLOW:
207         memprot_ll_peri1_clear_intr();
208         break;
209     case MEMPROT_PERI2_RTCSLOW_0:
210     case MEMPROT_PERI2_RTCSLOW_1:
211         memprot_ll_peri2_clear_intr();
212         break;
213     default:
214         return ESP_ERR_NOT_SUPPORTED;
215     }
216 
217     return ESP_OK;
218 }
219 
esp_memprot_set_lock(mem_type_prot_t mem_type)220 esp_err_t esp_memprot_set_lock(mem_type_prot_t mem_type)
221 {
222     switch (mem_type) {
223     case MEMPROT_IRAM0_SRAM:
224     case MEMPROT_IRAM0_RTCFAST:
225         memprot_ll_iram0_set_lock();
226         break;
227     case MEMPROT_DRAM0_SRAM:
228     case MEMPROT_DRAM0_RTCFAST:
229         memprot_ll_dram0_set_lock();
230         break;
231     case MEMPROT_PERI1_RTCSLOW:
232         memprot_ll_peri1_set_lock();
233         break;
234     case MEMPROT_PERI2_RTCSLOW_0:
235     case MEMPROT_PERI2_RTCSLOW_1:
236         memprot_ll_peri2_set_lock();
237         break;
238     default:
239         return ESP_ERR_NOT_SUPPORTED;
240     }
241 
242     return ESP_OK;
243 }
244 
esp_memprot_get_lock(mem_type_prot_t mem_type,bool * locked)245 esp_err_t esp_memprot_get_lock(mem_type_prot_t mem_type, bool *locked)
246 {
247     if (locked == NULL) {
248         return ESP_ERR_INVALID_ARG;
249     }
250 
251     switch (mem_type) {
252     case MEMPROT_IRAM0_SRAM:
253     case MEMPROT_IRAM0_RTCFAST:
254         *locked = memprot_ll_iram0_get_lock_bit() > 0;
255         break;
256     case MEMPROT_DRAM0_SRAM:
257     case MEMPROT_DRAM0_RTCFAST:
258         *locked = memprot_ll_dram0_get_lock_bit() > 0;
259         break;
260     case MEMPROT_PERI1_RTCSLOW:
261         *locked = memprot_ll_peri1_get_lock_bit() > 0;
262         break;
263     case MEMPROT_PERI2_RTCSLOW_0:
264     case MEMPROT_PERI2_RTCSLOW_1:
265         *locked = memprot_ll_peri2_get_lock_bit() > 0;
266         break;
267     default:
268         return ESP_ERR_NOT_SUPPORTED;
269     }
270 
271     return ESP_OK;
272 }
273 
esp_memprot_is_locked_any()274 bool esp_memprot_is_locked_any()
275 {
276     return
277         memprot_ll_iram0_get_lock_bit() > 0 ||
278         memprot_ll_dram0_get_lock_bit() > 0 ||
279         memprot_ll_peri1_get_lock_bit() > 0 ||
280         memprot_ll_peri2_get_lock_bit() > 0;
281 }
282 
esp_memprot_get_conf_reg(mem_type_prot_t mem_type,uint32_t * conf_reg_val)283 esp_err_t esp_memprot_get_conf_reg(mem_type_prot_t mem_type, uint32_t *conf_reg_val)
284 {
285     if (conf_reg_val == NULL) {
286         return ESP_ERR_INVALID_ARG;
287     }
288 
289     switch (mem_type) {
290     case MEMPROT_IRAM0_SRAM:
291     case MEMPROT_IRAM0_RTCFAST:
292         *conf_reg_val = memprot_ll_iram0_get_conf_reg();
293         break;
294     case MEMPROT_DRAM0_SRAM:
295     case MEMPROT_DRAM0_RTCFAST:
296         *conf_reg_val = memprot_ll_dram0_get_conf_reg();
297         break;
298     case MEMPROT_PERI1_RTCSLOW:
299         *conf_reg_val = memprot_ll_peri1_rtcslow_get_conf_reg();
300         break;
301     case MEMPROT_PERI2_RTCSLOW_0:
302         *conf_reg_val = memprot_ll_peri2_rtcslow_0_get_conf_reg();
303         break;
304     case MEMPROT_PERI2_RTCSLOW_1:
305         *conf_reg_val = memprot_ll_peri2_rtcslow_1_get_conf_reg();
306         break;
307     default:
308         return ESP_ERR_NOT_SUPPORTED;
309     }
310 
311     return ESP_OK;
312 }
313 
esp_memprot_get_fault_reg(mem_type_prot_t mem_type,uint32_t * fault_reg_val)314 esp_err_t esp_memprot_get_fault_reg(mem_type_prot_t mem_type, uint32_t *fault_reg_val)
315 {
316     if (fault_reg_val == NULL) {
317         return ESP_ERR_INVALID_ARG;
318     }
319 
320     switch (mem_type) {
321     case MEMPROT_IRAM0_SRAM:
322     case MEMPROT_IRAM0_RTCFAST:
323         *fault_reg_val = memprot_ll_iram0_get_fault_reg();
324         break;
325     case MEMPROT_DRAM0_SRAM:
326     case MEMPROT_DRAM0_RTCFAST:
327         *fault_reg_val = memprot_ll_dram0_get_fault_reg();
328         break;
329     case MEMPROT_PERI1_RTCSLOW:
330         *fault_reg_val = memprot_ll_peri1_get_fault_reg();
331         break;
332     case MEMPROT_PERI2_RTCSLOW_0:
333     case MEMPROT_PERI2_RTCSLOW_1:
334         *fault_reg_val = memprot_ll_peri2_get_fault_reg();
335         break;
336     default:
337         return ESP_ERR_NOT_SUPPORTED;
338     }
339 
340     return ESP_OK;
341 }
342 
esp_memprot_get_fault_status(mem_type_prot_t mem_type,uint32_t ** faulting_address,uint32_t * op_type,uint32_t * op_subtype)343 esp_err_t esp_memprot_get_fault_status(mem_type_prot_t mem_type, uint32_t **faulting_address, uint32_t *op_type, uint32_t *op_subtype)
344 {
345     if (*faulting_address == NULL || op_type == NULL || op_subtype == NULL) {
346         return ESP_ERR_INVALID_ARG;
347     }
348 
349     switch (mem_type) {
350     case MEMPROT_IRAM0_SRAM:
351         *faulting_address = (uint32_t *)memprot_ll_iram0_sram_get_fault_address();
352         memprot_ll_iram0_get_fault_op_type(op_type, op_subtype);
353         break;
354     case MEMPROT_IRAM0_RTCFAST:
355         *faulting_address = (uint32_t *)memprot_ll_iram0_rtcfast_get_fault_address();
356         memprot_ll_iram0_get_fault_op_type(op_type, op_subtype);
357         break;
358     case MEMPROT_DRAM0_SRAM:
359         *faulting_address = (uint32_t *)memprot_ll_dram0_sram_get_fault_address();
360         memprot_ll_dram0_get_fault_op_type(op_type, op_subtype);
361         break;
362     case MEMPROT_DRAM0_RTCFAST:
363         *faulting_address = (uint32_t *)memprot_ll_dram0_rtcfast_get_fault_address();
364         memprot_ll_dram0_get_fault_op_type(op_type, op_subtype);
365         break;
366     case MEMPROT_PERI1_RTCSLOW:
367         *faulting_address = (uint32_t *)memprot_ll_peri1_rtcslow_get_fault_address();
368         memprot_ll_peri1_get_fault_op_type(op_type, op_subtype);
369         break;
370     case MEMPROT_PERI2_RTCSLOW_0:
371     case MEMPROT_PERI2_RTCSLOW_1:
372         *faulting_address = (uint32_t *)memprot_ll_peri2_rtcslow_get_fault_address();
373         memprot_ll_peri2_get_fault_op_type(op_type, op_subtype);
374         break;
375     default:
376         return ESP_ERR_NOT_SUPPORTED;
377     }
378 
379     return ESP_OK;
380 }
381 
esp_memprot_is_intr_ena_any()382 bool esp_memprot_is_intr_ena_any()
383 {
384     return
385         memprot_ll_iram0_get_intr_ena_bit() > 0 ||
386         memprot_ll_dram0_get_intr_ena_bit() > 0 ||
387         memprot_ll_peri1_get_intr_ena_bit() > 0 ||
388         memprot_ll_peri2_get_intr_ena_bit() > 0;
389 }
390 
esp_memprot_get_intr_ena_bit(mem_type_prot_t mem_type,uint32_t * enable_bit)391 esp_err_t esp_memprot_get_intr_ena_bit(mem_type_prot_t mem_type, uint32_t *enable_bit)
392 {
393     if (enable_bit == NULL) {
394         return ESP_ERR_INVALID_ARG;
395     }
396 
397     switch (mem_type) {
398     case MEMPROT_IRAM0_SRAM:
399     case MEMPROT_IRAM0_RTCFAST:
400         *enable_bit = memprot_ll_iram0_get_intr_ena_bit();
401         break;
402     case MEMPROT_DRAM0_SRAM:
403     case MEMPROT_DRAM0_RTCFAST:
404         *enable_bit = memprot_ll_dram0_get_intr_ena_bit();
405         break;
406     case MEMPROT_PERI1_RTCSLOW:
407         *enable_bit = memprot_ll_peri1_get_intr_ena_bit();
408         break;
409     case MEMPROT_PERI2_RTCSLOW_0:
410     case MEMPROT_PERI2_RTCSLOW_1:
411         *enable_bit =  memprot_ll_peri2_get_intr_ena_bit();
412         break;
413     default:
414         return ESP_ERR_NOT_SUPPORTED;
415     }
416 
417     return ESP_OK;
418 }
419 
esp_memprot_get_intr_on_bit(mem_type_prot_t mem_type,uint32_t * intr_on_bit)420 esp_err_t esp_memprot_get_intr_on_bit(mem_type_prot_t mem_type, uint32_t *intr_on_bit)
421 {
422     if (intr_on_bit == NULL) {
423         return ESP_ERR_INVALID_ARG;
424     }
425 
426     switch (mem_type) {
427     case MEMPROT_IRAM0_SRAM:
428     case MEMPROT_IRAM0_RTCFAST:
429         *intr_on_bit = memprot_ll_iram0_get_intr_on_bit();
430         break;
431     case MEMPROT_DRAM0_SRAM:
432     case MEMPROT_DRAM0_RTCFAST:
433         *intr_on_bit = memprot_ll_dram0_get_intr_on_bit();
434         break;
435     case MEMPROT_PERI1_RTCSLOW:
436         *intr_on_bit = memprot_ll_peri1_get_intr_on_bit();
437         break;
438     case MEMPROT_PERI2_RTCSLOW_0:
439     case MEMPROT_PERI2_RTCSLOW_1:
440         *intr_on_bit = memprot_ll_peri2_get_intr_on_bit();
441         break;
442     default:
443         return ESP_ERR_NOT_SUPPORTED;
444     }
445 
446     return ESP_OK;
447 }
448 
esp_memprot_get_intr_clr_bit(mem_type_prot_t mem_type,uint32_t * clear_bit)449 esp_err_t esp_memprot_get_intr_clr_bit(mem_type_prot_t mem_type, uint32_t *clear_bit)
450 {
451     if (clear_bit == NULL) {
452         return ESP_ERR_INVALID_ARG;
453     }
454 
455     switch (mem_type) {
456     case MEMPROT_IRAM0_SRAM:
457     case MEMPROT_IRAM0_RTCFAST:
458         *clear_bit = memprot_ll_iram0_get_intr_clr_bit();
459         break;
460     case MEMPROT_DRAM0_SRAM:
461     case MEMPROT_DRAM0_RTCFAST:
462         *clear_bit = memprot_ll_dram0_get_intr_clr_bit();
463         break;
464     case MEMPROT_PERI1_RTCSLOW:
465         *clear_bit = memprot_ll_peri1_get_intr_clr_bit();
466         break;
467     case MEMPROT_PERI2_RTCSLOW_0:
468     case MEMPROT_PERI2_RTCSLOW_1:
469         *clear_bit = memprot_ll_peri2_get_intr_clr_bit();
470         break;
471     default:
472         return ESP_ERR_NOT_SUPPORTED;
473     }
474 
475     return ESP_OK;
476 }
477 
esp_memprot_get_uni_block_read_bit(mem_type_prot_t mem_type,uint32_t block,uint32_t * read_bit)478 esp_err_t esp_memprot_get_uni_block_read_bit(mem_type_prot_t mem_type, uint32_t block, uint32_t *read_bit)
479 {
480     if (read_bit == NULL) {
481         return ESP_ERR_INVALID_ARG;
482     }
483 
484     esp_err_t ret = ESP_OK;
485 
486     switch (mem_type) {
487     case MEMPROT_IRAM0_SRAM:
488         if (!memprot_ll_iram0_sram_get_uni_block_read_bit(block, read_bit)) {
489             ret = ESP_ERR_NOT_FOUND;
490         }
491         break;
492     case MEMPROT_DRAM0_SRAM:
493         if (!memprot_ll_dram0_sram_get_uni_block_read_bit(block, read_bit)) {
494             ret = ESP_ERR_NOT_FOUND;
495         }
496         break;
497     default:
498         ret = ESP_ERR_NOT_SUPPORTED;
499         break;
500     }
501 
502     return ret;
503 }
504 
esp_memprot_get_uni_block_write_bit(mem_type_prot_t mem_type,uint32_t block,uint32_t * write_bit)505 esp_err_t esp_memprot_get_uni_block_write_bit(mem_type_prot_t mem_type, uint32_t block, uint32_t *write_bit)
506 {
507     if (write_bit == NULL) {
508         return ESP_ERR_INVALID_ARG;
509     }
510 
511     esp_err_t ret = ESP_OK;
512 
513     switch (mem_type) {
514     case MEMPROT_IRAM0_SRAM:
515         if (!memprot_ll_iram0_sram_get_uni_block_write_bit(block, write_bit)) {
516             ret = ESP_ERR_NOT_FOUND;
517         }
518         break;
519     case MEMPROT_DRAM0_SRAM:
520         if (!memprot_ll_dram0_sram_get_uni_block_write_bit(block, write_bit)) {
521             ret = ESP_ERR_NOT_FOUND;
522         }
523         break;
524     default:
525         ret = ESP_ERR_NOT_SUPPORTED;
526         break;
527     }
528 
529     return ret;
530 }
531 
esp_memprot_get_uni_block_exec_bit(mem_type_prot_t mem_type,uint32_t block,uint32_t * exec_bit)532 esp_err_t esp_memprot_get_uni_block_exec_bit(mem_type_prot_t mem_type, uint32_t block, uint32_t *exec_bit)
533 {
534     if (exec_bit == NULL) {
535         return ESP_ERR_INVALID_ARG;
536     }
537 
538     switch (mem_type) {
539     case MEMPROT_IRAM0_SRAM:
540         if (!memprot_ll_iram0_sram_get_uni_block_exec_bit(block, exec_bit)) {
541             return ESP_ERR_NOT_FOUND;
542         }
543         break;
544     default:
545         return ESP_ERR_NOT_SUPPORTED;
546     }
547 
548     return ESP_OK;
549 }
550 
esp_memprot_set_uni_block_perm_dram(mem_type_prot_t mem_type,uint32_t block,bool write_perm,bool read_perm)551 esp_err_t esp_memprot_set_uni_block_perm_dram(mem_type_prot_t mem_type, uint32_t block, bool write_perm, bool read_perm)
552 {
553     switch (mem_type) {
554     case MEMPROT_DRAM0_SRAM:
555         return esp_memprot_ll_err_to_esp_err(memprot_ll_dram0_sram_set_uni_block_perm(block, write_perm, read_perm));
556     default:
557         return ESP_ERR_NOT_SUPPORTED;
558     }
559 }
560 
esp_memprot_get_perm_uni_reg(mem_type_prot_t mem_type,uint32_t * perm_reg)561 esp_err_t esp_memprot_get_perm_uni_reg(mem_type_prot_t mem_type, uint32_t *perm_reg)
562 {
563     if (perm_reg == NULL) {
564         return ESP_ERR_INVALID_ARG;
565     }
566 
567     switch (mem_type) {
568     case MEMPROT_IRAM0_SRAM:
569         *perm_reg = memprot_ll_iram0_sram_get_perm_uni_reg();
570         break;
571     case MEMPROT_DRAM0_SRAM:
572         *perm_reg = memprot_ll_dram0_sram_get_perm_reg();
573         break;
574     default:
575         return ESP_ERR_NOT_SUPPORTED;
576     }
577 
578     return ESP_OK;
579 }
580 
esp_memprot_get_perm_split_reg(mem_type_prot_t mem_type,uint32_t * split_reg)581 esp_err_t esp_memprot_get_perm_split_reg(mem_type_prot_t mem_type, uint32_t *split_reg)
582 {
583     if (split_reg == NULL) {
584         return ESP_ERR_INVALID_ARG;
585     }
586 
587     switch (mem_type) {
588     case MEMPROT_IRAM0_SRAM:
589         *split_reg = memprot_ll_iram0_sram_get_perm_split_reg();
590         break;
591     case MEMPROT_IRAM0_RTCFAST:
592         *split_reg = memprot_ll_iram0_rtcfast_get_perm_split_reg();
593         break;
594     case MEMPROT_DRAM0_SRAM:
595         *split_reg = memprot_ll_dram0_sram_get_perm_reg();
596         break;
597     case MEMPROT_DRAM0_RTCFAST:
598         *split_reg = memprot_ll_dram0_rtcfast_get_perm_split_reg();
599         break;
600     case MEMPROT_PERI1_RTCSLOW:
601         *split_reg = memprot_ll_peri1_rtcslow_get_conf_reg();
602         break;
603     case MEMPROT_PERI2_RTCSLOW_0:
604         *split_reg = memprot_ll_peri2_rtcslow_0_get_conf_reg();
605         break;
606     case MEMPROT_PERI2_RTCSLOW_1:
607         *split_reg = memprot_ll_peri2_rtcslow_1_get_conf_reg();
608         break;
609     default:
610         return ESP_ERR_NOT_SUPPORTED;
611     }
612 
613     return ESP_OK;
614 }
615 
esp_memprot_set_prot_dram(mem_type_prot_t mem_type,uint32_t * split_addr,bool lw,bool lr,bool hw,bool hr)616 esp_err_t esp_memprot_set_prot_dram(mem_type_prot_t mem_type, uint32_t *split_addr, bool lw, bool lr, bool hw, bool hr)
617 {
618     switch (mem_type) {
619     case MEMPROT_DRAM0_SRAM:
620         return esp_memprot_ll_err_to_esp_err(memprot_ll_dram0_sram_set_prot(split_addr != NULL ? split_addr : esp_memprot_dram0_sram_get_min_split_addr(), lw, lr, hw, hr));
621     case MEMPROT_DRAM0_RTCFAST:
622         return esp_memprot_ll_err_to_esp_err(memprot_ll_dram0_rtcfast_set_prot(split_addr != NULL ? split_addr : esp_memprot_dram0_rtcfast_get_min_split_addr(), lw, lr, hw, hr));
623     default:
624         return ESP_ERR_NOT_SUPPORTED;
625     }
626 }
627 
esp_memprot_set_uni_block_perm_iram(mem_type_prot_t mem_type,uint32_t block,bool write_perm,bool read_perm,bool exec_perm)628 esp_err_t esp_memprot_set_uni_block_perm_iram(mem_type_prot_t mem_type, uint32_t block, bool write_perm, bool read_perm, bool exec_perm)
629 {
630     switch (mem_type) {
631     case MEMPROT_IRAM0_SRAM:
632         if (!memprot_ll_iram0_sram_set_uni_block_perm(block, write_perm, read_perm, exec_perm)) {
633             return ESP_ERR_INVALID_ARG;
634         }
635         break;
636     default:
637         return ESP_ERR_NOT_SUPPORTED;
638     }
639 
640     return ESP_OK;
641 }
642 
esp_memprot_set_prot_iram(mem_type_prot_t mem_type,uint32_t * split_addr,bool lw,bool lr,bool lx,bool hw,bool hr,bool hx)643 esp_err_t esp_memprot_set_prot_iram(mem_type_prot_t mem_type, uint32_t *split_addr, bool lw, bool lr, bool lx, bool hw, bool hr, bool hx)
644 {
645     switch (mem_type) {
646     case MEMPROT_IRAM0_SRAM:
647         return esp_memprot_ll_err_to_esp_err(memprot_ll_iram0_sram_set_prot(split_addr != NULL ? split_addr : esp_memprot_iram0_sram_get_min_split_addr(), lw, lr, lx, hw, hr, hx));
648     case MEMPROT_IRAM0_RTCFAST:
649         return esp_memprot_ll_err_to_esp_err(memprot_ll_iram0_rtcfast_set_prot(split_addr != NULL ? split_addr : esp_memprot_iram0_rtcfast_get_min_split_addr(), lw, lr, lx, hw, hr, hx));
650     default:
651         return ESP_ERR_NOT_SUPPORTED;
652     }
653 }
654 
esp_memprot_get_perm_split_bits_iram(mem_type_prot_t mem_type,bool * lw,bool * lr,bool * lx,bool * hw,bool * hr,bool * hx)655 esp_err_t esp_memprot_get_perm_split_bits_iram(mem_type_prot_t mem_type, bool *lw, bool *lr, bool *lx, bool *hw, bool *hr, bool *hx)
656 {
657     if (lw == NULL || lr == NULL || lx == NULL || hw == NULL || hr == NULL || hx == NULL) {
658         return ESP_ERR_INVALID_ARG;
659     }
660 
661     switch (mem_type) {
662     case MEMPROT_IRAM0_SRAM:
663         memprot_ll_iram0_sram_get_split_sgnf_bits(lw, lr, lx, hw, hr, hx);
664         break;
665     case MEMPROT_IRAM0_RTCFAST:
666         memprot_ll_iram0_rtcfast_get_split_sgnf_bits(lw, lr, lx, hw, hr, hx);
667         break;
668     default:
669         return ESP_ERR_NOT_SUPPORTED;
670     }
671 
672     return ESP_OK;
673 }
674 
esp_memprot_get_perm_split_bits_dram(mem_type_prot_t mem_type,bool * lw,bool * lr,bool * hw,bool * hr)675 esp_err_t esp_memprot_get_perm_split_bits_dram(mem_type_prot_t mem_type, bool *lw, bool *lr, bool *hw, bool *hr)
676 {
677     if (lw == NULL || lr == NULL || hw == NULL || hr == NULL) {
678         return ESP_ERR_INVALID_ARG;
679     }
680 
681     switch (mem_type) {
682     case MEMPROT_DRAM0_SRAM:
683         memprot_ll_dram0_sram_get_split_sgnf_bits(lw, lr, hw, hr);
684         break;
685     case MEMPROT_DRAM0_RTCFAST:
686         memprot_ll_dram0_rtcfast_get_split_sgnf_bits(lw, lr, hw, hr);
687         break;
688     default:
689         return ESP_ERR_NOT_SUPPORTED;
690     }
691 
692     return ESP_OK;
693 }
694 
esp_memprot_get_perm_split_bits_peri1(mem_type_prot_t mem_type,bool * lw,bool * lr,bool * hw,bool * hr)695 esp_err_t esp_memprot_get_perm_split_bits_peri1(mem_type_prot_t mem_type, bool *lw, bool *lr, bool *hw, bool *hr)
696 {
697     if (lw == NULL || lr == NULL || hw == NULL || hr == NULL) {
698         return ESP_ERR_INVALID_ARG;
699     }
700 
701     switch (mem_type) {
702     case MEMPROT_PERI1_RTCSLOW:
703         memprot_ll_peri1_rtcslow_get_split_sgnf_bits(lw, lr, hw, hr);
704         break;
705     default:
706         return ESP_ERR_NOT_SUPPORTED;
707     }
708 
709     return ESP_OK;
710 }
711 
esp_memprot_set_prot_peri1(mem_type_prot_t mem_type,uint32_t * split_addr,bool lw,bool lr,bool hw,bool hr)712 esp_err_t esp_memprot_set_prot_peri1(mem_type_prot_t mem_type, uint32_t *split_addr, bool lw, bool lr, bool hw, bool hr)
713 {
714     switch (mem_type) {
715     case MEMPROT_PERI1_RTCSLOW:
716         return esp_memprot_ll_err_to_esp_err(
717                    memprot_ll_peri1_rtcslow_set_prot(
718                        split_addr != NULL ? split_addr : esp_memprot_peri1_rtcslow_get_min_split_addr(),
719                        lw,
720                        lr,
721                        hw,
722                        hr)
723                );
724     default:
725         return ESP_ERR_NOT_SUPPORTED;
726     }
727 }
728 
esp_memprot_get_perm_split_bits_peri2(mem_type_prot_t mem_type,bool * lw,bool * lr,bool * lx,bool * hw,bool * hr,bool * hx)729 esp_err_t esp_memprot_get_perm_split_bits_peri2(mem_type_prot_t mem_type, bool *lw, bool *lr, bool *lx, bool *hw, bool *hr, bool *hx)
730 {
731     if (lw == NULL || lr == NULL || lx == NULL || hw == NULL || hr == NULL || hx == NULL) {
732         return ESP_ERR_INVALID_ARG;
733     }
734 
735     switch (mem_type) {
736     case MEMPROT_PERI2_RTCSLOW_0:
737         memprot_ll_peri2_rtcslow_0_get_split_sgnf_bits(lw, lr, lx, hw, hr, hx);
738         break;
739     case MEMPROT_PERI2_RTCSLOW_1:
740         memprot_ll_peri2_rtcslow_1_get_split_sgnf_bits(lw, lr, lx, hw, hr, hx);
741         break;
742     default:
743         return ESP_ERR_NOT_SUPPORTED;
744     }
745 
746     return ESP_OK;
747 }
748 
esp_memprot_set_prot_peri2(mem_type_prot_t mem_type,uint32_t * split_addr,bool lw,bool lr,bool lx,bool hw,bool hr,bool hx)749 esp_err_t esp_memprot_set_prot_peri2(mem_type_prot_t mem_type, uint32_t *split_addr, bool lw, bool lr, bool lx, bool hw, bool hr, bool hx)
750 {
751     switch (mem_type) {
752     case MEMPROT_PERI2_RTCSLOW_0:
753         return esp_memprot_ll_err_to_esp_err(
754                    memprot_ll_peri2_rtcslow_0_set_prot(
755                        split_addr != NULL ? split_addr : esp_memprot_peri2_rtcslow_0_get_min_split_addr(),
756                        lw,
757                        lr,
758                        lx,
759                        hw,
760                        hr,
761                        hx)
762                );
763     case MEMPROT_PERI2_RTCSLOW_1:
764         return esp_memprot_ll_err_to_esp_err(
765                    memprot_ll_peri2_rtcslow_1_set_prot(
766                        split_addr != NULL ? split_addr : esp_memprot_peri2_rtcslow_1_get_min_split_addr(),
767                        lw,
768                        lr,
769                        lx,
770                        hw,
771                        hr,
772                        hx)
773                );
774     default:
775         return ESP_ERR_NOT_SUPPORTED;
776     }
777 }
778 
esp_memprot_set_prot(bool invoke_panic_handler,bool lock_feature,uint32_t * mem_type_mask)779 esp_err_t esp_memprot_set_prot(bool invoke_panic_handler, bool lock_feature, uint32_t *mem_type_mask)
780 {
781     esp_err_t ret;
782 
783     //any IRAM0/DRAM0 enable/disable call applies to all memory modules connected
784     uint32_t required_mem_prot = mem_type_mask == NULL ? (uint32_t)MEMPROT_ALL : *mem_type_mask;
785     bool use_iram0 = required_mem_prot & MEMPROT_IRAM0_SRAM || required_mem_prot & MEMPROT_IRAM0_RTCFAST;
786     bool use_dram0 = required_mem_prot & MEMPROT_DRAM0_SRAM || required_mem_prot & MEMPROT_DRAM0_RTCFAST;
787     bool use_peri1 = required_mem_prot & MEMPROT_PERI1_RTCSLOW;
788     bool use_peri2 = required_mem_prot & MEMPROT_PERI2_RTCSLOW_0 || required_mem_prot & MEMPROT_PERI2_RTCSLOW_1;
789 
790     //disable protection
791     if (use_iram0 && (ret = esp_memprot_intr_ena(MEMPROT_IRAM0_SRAM, false)) != ESP_OK) {
792         return ret;
793     }
794     if (use_dram0 && (ret = esp_memprot_intr_ena(MEMPROT_DRAM0_SRAM, false)) != ESP_OK) {
795         return ret;
796     }
797     if (use_peri1 && (ret = esp_memprot_intr_ena(MEMPROT_PERI1_RTCSLOW, false)) != ESP_OK) {
798         return ret;
799     }
800     if (use_peri2 && (ret = esp_memprot_intr_ena(MEMPROT_PERI2_RTCSLOW_0, false)) != ESP_OK) {
801         return ret;
802     }
803 
804     //if being debugged check we are not glitched and dont enable Memprot
805     if (esp_cpu_dbgr_is_attached()) {
806         ESP_FAULT_ASSERT(esp_cpu_dbgr_is_attached());
807     } else {
808         //initialize for specific buses (any memory type does the job)
809         if (invoke_panic_handler) {
810             if (use_iram0 && (ret = esp_memprot_intr_init(MEMPROT_IRAM0_SRAM)) != ESP_OK) {
811                 return ret;
812             }
813             if (use_dram0 && (ret = esp_memprot_intr_init(MEMPROT_DRAM0_SRAM)) != ESP_OK) {
814                 return ret;
815             }
816             if (use_peri1 && (ret = esp_memprot_intr_init(MEMPROT_PERI1_RTCSLOW)) != ESP_OK) {
817                 return ret;
818             }
819             if (use_peri2 && (ret = esp_memprot_intr_init(MEMPROT_PERI2_RTCSLOW_0)) != ESP_OK) {
820                 return ret;
821             }
822         }
823 
824         //set permissions
825         if (required_mem_prot & MEMPROT_IRAM0_SRAM) {
826             ret = esp_memprot_set_prot_iram(MEMPROT_IRAM0_SRAM, DEF_SPLIT_LINE, WR_LOW_DIS, RD_LOW_ENA, EX_LOW_ENA, WR_HIGH_DIS, RD_HIGH_DIS, EX_HIGH_DIS);
827             if (ret != ESP_OK) {
828                 return ret;
829             }
830         }
831         if (required_mem_prot & MEMPROT_IRAM0_RTCFAST) {
832             ret = esp_memprot_set_prot_iram(MEMPROT_IRAM0_RTCFAST, DEF_SPLIT_LINE, WR_LOW_DIS, RD_LOW_ENA, EX_LOW_ENA, WR_HIGH_DIS, RD_HIGH_DIS, EX_HIGH_DIS);
833             if (ret != ESP_OK) {
834                 return ret;
835             }
836         }
837         if (required_mem_prot & MEMPROT_DRAM0_SRAM) {
838             ret = esp_memprot_set_prot_dram(MEMPROT_DRAM0_SRAM, DEF_SPLIT_LINE, WR_LOW_DIS, RD_LOW_ENA, WR_HIGH_ENA, RD_HIGH_ENA);
839             if (ret != ESP_OK) {
840                 return ret;
841             }
842         }
843         if (required_mem_prot & MEMPROT_DRAM0_RTCFAST) {
844             ret = esp_memprot_set_prot_dram(MEMPROT_DRAM0_RTCFAST, DEF_SPLIT_LINE, WR_LOW_DIS, RD_LOW_ENA, WR_HIGH_ENA, RD_HIGH_ENA);
845             if (ret != ESP_OK) {
846                 return ret;
847             }
848         }
849         if (required_mem_prot & MEMPROT_PERI1_RTCSLOW) {
850             ret = esp_memprot_set_prot_peri1(MEMPROT_PERI1_RTCSLOW, DEF_SPLIT_LINE, WR_LOW_DIS, RD_LOW_DIS, WR_HIGH_DIS, RD_HIGH_DIS);
851             if (ret != ESP_OK) {
852                 return ret;
853             }
854         }
855         if (required_mem_prot & MEMPROT_PERI2_RTCSLOW_0) {
856             ret = esp_memprot_set_prot_peri2(MEMPROT_PERI2_RTCSLOW_0, DEF_SPLIT_LINE, WR_LOW_ENA, RD_LOW_ENA, EX_LOW_DIS, WR_HIGH_ENA, RD_HIGH_ENA, EX_HIGH_DIS);
857             if (ret != ESP_OK) {
858                 return ret;
859             }
860         }
861         if (required_mem_prot & MEMPROT_PERI2_RTCSLOW_1) {
862             ret = esp_memprot_set_prot_peri2(MEMPROT_PERI2_RTCSLOW_1, DEF_SPLIT_LINE, WR_LOW_DIS, RD_LOW_DIS, EX_LOW_DIS, WR_HIGH_DIS, RD_HIGH_DIS, EX_HIGH_DIS);
863             if (ret != ESP_OK) {
864                 return ret;
865             }
866         }
867 
868         //reenable protection (bus based)
869         if (use_iram0 && (ret = esp_memprot_intr_ena(MEMPROT_IRAM0_SRAM, true)) != ESP_OK) {
870             return ret;
871         }
872         if (use_dram0 && (ret = esp_memprot_intr_ena(MEMPROT_DRAM0_SRAM, true)) != ESP_OK) {
873             return ret;
874         }
875         if (use_peri1 && (ret = esp_memprot_intr_ena(MEMPROT_PERI1_RTCSLOW, true)) != ESP_OK) {
876             return ret;
877         }
878         if (use_peri2 && (ret = esp_memprot_intr_ena(MEMPROT_PERI2_RTCSLOW_0, true)) != ESP_OK) {
879             return ret;
880         }
881 
882         //lock if required (bus based)
883         if (lock_feature) {
884             if (use_iram0 && (ret = esp_memprot_set_lock(MEMPROT_IRAM0_SRAM)) != ESP_OK) {
885                 return ret;
886             }
887             if (use_dram0 && (ret = esp_memprot_set_lock(MEMPROT_DRAM0_SRAM)) != ESP_OK) {
888                 return ret;
889             }
890             if (use_peri1 && (ret = esp_memprot_set_lock(MEMPROT_PERI1_RTCSLOW)) != ESP_OK) {
891                 return ret;
892             }
893             if (use_peri2 && (ret = esp_memprot_set_lock(MEMPROT_PERI2_RTCSLOW_0)) != ESP_OK) {
894                 return ret;
895             }
896         }
897     }
898 
899     return ESP_OK;
900 }
901 
esp_memprot_get_permissions(mem_type_prot_t mem_type,bool * lw,bool * lr,bool * lx,bool * hw,bool * hr,bool * hx)902 esp_err_t esp_memprot_get_permissions(mem_type_prot_t mem_type, bool *lw, bool *lr, bool *lx, bool *hw, bool *hr, bool *hx)
903 {
904     if (lw == NULL || lr == NULL || lx == NULL || hw == NULL || hr == NULL || hx == NULL) {
905         return ESP_ERR_INVALID_ARG;
906     }
907 
908     switch (mem_type) {
909     case MEMPROT_IRAM0_SRAM:
910         memprot_ll_iram0_sram_get_split_sgnf_bits(lw, lr, lx, hw, hr, hx);
911         break;
912     case MEMPROT_DRAM0_SRAM:
913         memprot_ll_dram0_sram_get_split_sgnf_bits(lw, lr, hw, hr);
914         break;
915     case MEMPROT_IRAM0_RTCFAST:
916         memprot_ll_iram0_rtcfast_get_split_sgnf_bits(lw, lr, lx, hw, hr, hx);
917         break;
918     case MEMPROT_DRAM0_RTCFAST:
919         memprot_ll_dram0_rtcfast_get_split_sgnf_bits(lw, lr, hw, hr);
920         break;
921     case MEMPROT_PERI1_RTCSLOW:
922         memprot_ll_peri1_rtcslow_get_split_sgnf_bits(lw, lr, hw, hr);
923         break;
924     case MEMPROT_PERI2_RTCSLOW_0:
925         memprot_ll_peri2_rtcslow_0_get_split_sgnf_bits(lw, lr, lx, hw, hr, hx);
926         break;
927     case MEMPROT_PERI2_RTCSLOW_1:
928         memprot_ll_peri2_rtcslow_1_get_split_sgnf_bits(lw, lr, lx, hw, hr, hx);
929         break;
930     default:
931         return ESP_ERR_NOT_SUPPORTED;
932     }
933 
934     return ESP_OK;
935 }
936 
esp_memprot_get_perm_read(mem_type_prot_t mem_type,bool * lr,bool * hr)937 esp_err_t esp_memprot_get_perm_read(mem_type_prot_t mem_type, bool *lr, bool *hr)
938 {
939     bool _lw, _lr, _lx, _hw, _hr, _hx;
940     esp_err_t ret = esp_memprot_get_permissions(mem_type, &_lw, &_lr, &_lx, &_hw, &_hr, &_hx);
941     if (ret == ESP_OK) {
942         *lr = _lr;
943         *hr = _hr;
944     }
945     return ret;
946 }
947 
esp_memprot_get_perm_write(mem_type_prot_t mem_type,bool * lw,bool * hw)948 esp_err_t esp_memprot_get_perm_write(mem_type_prot_t mem_type, bool *lw, bool *hw)
949 {
950     bool _lw, _lr, _lx, _hw, _hr, _hx;
951     esp_err_t ret = esp_memprot_get_permissions(mem_type, &_lw, &_lr, &_lx, &_hw, &_hr, &_hx);
952     if (ret == ESP_OK) {
953         *lw = _lw;
954         *hw = _hw;
955     }
956 
957     return ret;
958 }
959 
esp_memprot_get_perm_exec(mem_type_prot_t mem_type,bool * lx,bool * hx)960 esp_err_t esp_memprot_get_perm_exec(mem_type_prot_t mem_type, bool *lx, bool *hx)
961 {
962     if (mem_type == MEMPROT_DRAM0_SRAM ||
963             mem_type == MEMPROT_DRAM0_RTCFAST ||
964             mem_type == MEMPROT_PERI1_RTCSLOW) {
965         return ESP_ERR_NOT_SUPPORTED;
966     }
967 
968     bool _lw, _lr, _lx, _hw, _hr, _hx;
969     esp_err_t ret = esp_memprot_get_permissions(mem_type, &_lw, &_lr, &_lx, &_hw, &_hr, &_hx);
970     if (ret == ESP_OK) {
971         *lx = _lx;
972         *hx = _hx;
973     }
974 
975     return ret;
976 }
977 
esp_memprot_get_low_limit(mem_type_prot_t mem_type)978 uint32_t esp_memprot_get_low_limit(mem_type_prot_t mem_type)
979 {
980     switch (mem_type) {
981     case MEMPROT_IRAM0_SRAM:
982         return IRAM0_SRAM_ADDRESS_LOW;
983     case MEMPROT_DRAM0_SRAM:
984         return DRAM0_SRAM_ADDRESS_LOW;
985     case MEMPROT_IRAM0_RTCFAST:
986         return IRAM0_RTCFAST_ADDRESS_LOW;
987     case MEMPROT_DRAM0_RTCFAST:
988         return DRAM0_RTCFAST_ADDRESS_LOW;
989     case MEMPROT_PERI1_RTCSLOW:
990         return PERI1_RTCSLOW_ADDRESS_LOW;
991     case MEMPROT_PERI2_RTCSLOW_0:
992         return PERI2_RTCSLOW_0_ADDRESS_LOW;
993     case MEMPROT_PERI2_RTCSLOW_1:
994         return PERI2_RTCSLOW_1_ADDRESS_LOW;
995     default:
996         return MEMPROT_INVALID_ADDRESS;
997     }
998 }
999 
esp_memprot_get_high_limit(mem_type_prot_t mem_type)1000 uint32_t esp_memprot_get_high_limit(mem_type_prot_t mem_type)
1001 {
1002     switch (mem_type) {
1003     case MEMPROT_IRAM0_SRAM:
1004         return IRAM0_SRAM_ADDRESS_HIGH;
1005     case MEMPROT_DRAM0_SRAM:
1006         return DRAM0_SRAM_ADDRESS_HIGH;
1007     case MEMPROT_IRAM0_RTCFAST:
1008         return IRAM0_RTCFAST_ADDRESS_HIGH;
1009     case MEMPROT_DRAM0_RTCFAST:
1010         return DRAM0_RTCFAST_ADDRESS_HIGH;
1011     case MEMPROT_PERI1_RTCSLOW:
1012         return PERI1_RTCSLOW_ADDRESS_HIGH;
1013     case MEMPROT_PERI2_RTCSLOW_0:
1014         return PERI2_RTCSLOW_0_ADDRESS_HIGH;
1015     case MEMPROT_PERI2_RTCSLOW_1:
1016         return PERI2_RTCSLOW_1_ADDRESS_HIGH;
1017     default:
1018         return MEMPROT_INVALID_ADDRESS;
1019     }
1020 }
1021 
esp_memprot_set_read_perm(mem_type_prot_t mem_type,bool lr,bool hr)1022 esp_err_t esp_memprot_set_read_perm(mem_type_prot_t mem_type, bool lr, bool hr)
1023 {
1024     switch (mem_type) {
1025     case MEMPROT_IRAM0_SRAM:
1026         memprot_ll_iram0_sram_set_read_perm(lr, hr);
1027         break;
1028     case MEMPROT_DRAM0_SRAM:
1029         memprot_ll_dram0_sram_set_read_perm(lr, hr);
1030         break;
1031     case MEMPROT_IRAM0_RTCFAST:
1032         memprot_ll_iram0_rtcfast_set_read_perm(lr, hr);
1033         break;
1034     case MEMPROT_DRAM0_RTCFAST:
1035         memprot_ll_dram0_rtcfast_set_read_perm(lr, hr);
1036         break;
1037     case MEMPROT_PERI1_RTCSLOW:
1038         memprot_ll_peri1_rtcslow_set_read_perm(lr, hr);
1039         break;
1040     case MEMPROT_PERI2_RTCSLOW_0:
1041         memprot_ll_peri2_rtcslow_0_set_read_perm(lr, hr);
1042         break;
1043     case MEMPROT_PERI2_RTCSLOW_1:
1044         memprot_ll_peri2_rtcslow_1_set_read_perm(lr, hr);
1045         break;
1046     default:
1047         return ESP_ERR_NOT_SUPPORTED;
1048     }
1049 
1050     return ESP_OK;
1051 }
1052 
esp_memprot_set_write_perm(mem_type_prot_t mem_type,bool lw,bool hw)1053 esp_err_t esp_memprot_set_write_perm(mem_type_prot_t mem_type, bool lw, bool hw)
1054 {
1055     switch (mem_type) {
1056     case MEMPROT_IRAM0_SRAM:
1057         memprot_ll_iram0_sram_set_write_perm(lw, hw);
1058         break;
1059     case MEMPROT_DRAM0_SRAM:
1060         memprot_ll_dram0_sram_set_write_perm(lw, hw);
1061         break;
1062     case MEMPROT_IRAM0_RTCFAST:
1063         memprot_ll_iram0_rtcfast_set_write_perm(lw, hw);
1064         break;
1065     case MEMPROT_DRAM0_RTCFAST:
1066         memprot_ll_dram0_rtcfast_set_write_perm(lw, hw);
1067         break;
1068     case MEMPROT_PERI1_RTCSLOW:
1069         memprot_ll_peri1_rtcslow_set_write_perm(lw, hw);
1070         break;
1071     case MEMPROT_PERI2_RTCSLOW_0:
1072         memprot_ll_peri2_rtcslow_0_set_write_perm(lw, hw);
1073         break;
1074     case MEMPROT_PERI2_RTCSLOW_1:
1075         memprot_ll_peri2_rtcslow_1_set_write_perm(lw, hw);
1076         break;
1077     default:
1078         return ESP_ERR_NOT_SUPPORTED;
1079     }
1080 
1081     return ESP_OK;
1082 }
1083 
esp_memprot_set_exec_perm(mem_type_prot_t mem_type,bool lx,bool hx)1084 esp_err_t esp_memprot_set_exec_perm(mem_type_prot_t mem_type, bool lx, bool hx)
1085 {
1086     switch (mem_type) {
1087     case MEMPROT_IRAM0_SRAM:
1088         memprot_ll_iram0_sram_set_exec_perm(lx, hx);
1089         break;
1090     case MEMPROT_IRAM0_RTCFAST:
1091         memprot_ll_iram0_rtcfast_set_exec_perm(lx, hx);
1092         break;
1093     case MEMPROT_PERI2_RTCSLOW_0:
1094         memprot_ll_peri2_rtcslow_0_set_exec_perm(lx, hx);
1095         break;
1096     case MEMPROT_PERI2_RTCSLOW_1:
1097         memprot_ll_peri2_rtcslow_1_set_exec_perm(lx, hx);
1098         break;
1099     default:
1100         return ESP_ERR_NOT_SUPPORTED;
1101     }
1102 
1103     return ESP_OK;
1104 }
1105