ba6b31d49070a3eb19416a68c7712d95529e5f81
[people/ms/u-boot.git] / arch / arm / mach-imx / hab.c
1 /*
2  * Copyright (C) 2010-2015 Freescale Semiconductor, Inc.
3  *
4  * SPDX-License-Identifier:    GPL-2.0+
5  */
6
7 #include <common.h>
8 #include <config.h>
9 #include <fuse.h>
10 #include <asm/io.h>
11 #include <asm/system.h>
12 #include <asm/arch/clock.h>
13 #include <asm/arch/sys_proto.h>
14 #include <asm/mach-imx/hab.h>
15
16 /* -------- start of HAB API updates ------------*/
17
18 #define hab_rvt_report_event_p                                  \
19 (                                                               \
20         (is_mx6dqp()) ?                                         \
21         ((hab_rvt_report_event_t *)HAB_RVT_REPORT_EVENT_NEW) :  \
22         (is_mx6dq() && (soc_rev() >= CHIP_REV_1_5)) ?           \
23         ((hab_rvt_report_event_t *)HAB_RVT_REPORT_EVENT_NEW) :  \
24         (is_mx6sdl() && (soc_rev() >= CHIP_REV_1_2)) ?          \
25         ((hab_rvt_report_event_t *)HAB_RVT_REPORT_EVENT_NEW) :  \
26         ((hab_rvt_report_event_t *)HAB_RVT_REPORT_EVENT)        \
27 )
28
29 #define hab_rvt_report_status_p                                 \
30 (                                                               \
31         (is_mx6dqp()) ?                                         \
32         ((hab_rvt_report_status_t *)HAB_RVT_REPORT_STATUS_NEW) :\
33         (is_mx6dq() && (soc_rev() >= CHIP_REV_1_5)) ?           \
34         ((hab_rvt_report_status_t *)HAB_RVT_REPORT_STATUS_NEW) :\
35         (is_mx6sdl() && (soc_rev() >= CHIP_REV_1_2)) ?          \
36         ((hab_rvt_report_status_t *)HAB_RVT_REPORT_STATUS_NEW) :\
37         ((hab_rvt_report_status_t *)HAB_RVT_REPORT_STATUS)      \
38 )
39
40 #define hab_rvt_authenticate_image_p                            \
41 (                                                               \
42         (is_mx6dqp()) ?                                         \
43         ((hab_rvt_authenticate_image_t *)HAB_RVT_AUTHENTICATE_IMAGE_NEW) : \
44         (is_mx6dq() && (soc_rev() >= CHIP_REV_1_5)) ?           \
45         ((hab_rvt_authenticate_image_t *)HAB_RVT_AUTHENTICATE_IMAGE_NEW) : \
46         (is_mx6sdl() && (soc_rev() >= CHIP_REV_1_2)) ?          \
47         ((hab_rvt_authenticate_image_t *)HAB_RVT_AUTHENTICATE_IMAGE_NEW) : \
48         ((hab_rvt_authenticate_image_t *)HAB_RVT_AUTHENTICATE_IMAGE)    \
49 )
50
51 #define hab_rvt_entry_p                                         \
52 (                                                               \
53         (is_mx6dqp()) ?                                         \
54         ((hab_rvt_entry_t *)HAB_RVT_ENTRY_NEW) :                \
55         (is_mx6dq() && (soc_rev() >= CHIP_REV_1_5)) ?           \
56         ((hab_rvt_entry_t *)HAB_RVT_ENTRY_NEW) :                \
57         (is_mx6sdl() && (soc_rev() >= CHIP_REV_1_2)) ?          \
58         ((hab_rvt_entry_t *)HAB_RVT_ENTRY_NEW) :                \
59         ((hab_rvt_entry_t *)HAB_RVT_ENTRY)                      \
60 )
61
62 #define hab_rvt_exit_p                                          \
63 (                                                               \
64         (is_mx6dqp()) ?                                         \
65         ((hab_rvt_exit_t *)HAB_RVT_EXIT_NEW) :                  \
66         (is_mx6dq() && (soc_rev() >= CHIP_REV_1_5)) ?           \
67         ((hab_rvt_exit_t *)HAB_RVT_EXIT_NEW) :                  \
68         (is_mx6sdl() && (soc_rev() >= CHIP_REV_1_2)) ?          \
69         ((hab_rvt_exit_t *)HAB_RVT_EXIT_NEW) :                  \
70         ((hab_rvt_exit_t *)HAB_RVT_EXIT)                        \
71 )
72
73 static inline void hab_rvt_failsafe_new(void)
74 {
75 }
76
77 #define hab_rvt_failsafe_p                              \
78 (                                                       \
79         (is_mx6dqp()) ?                                 \
80         ((hab_rvt_failsafe_t *)hab_rvt_failsafe_new) :  \
81         (is_mx6dq() && (soc_rev() >= CHIP_REV_1_5)) ?   \
82         ((hab_rvt_failsafe_t *)hab_rvt_failsafe_new) :  \
83         (is_mx6sdl() && (soc_rev() >= CHIP_REV_1_2)) ?  \
84         ((hab_rvt_failsafe_t *)hab_rvt_failsafe_new) :  \
85         ((hab_rvt_failsafe_t *)HAB_RVT_FAILSAFE)        \
86 )
87
88 static inline enum hab_status hab_rvt_check_target_new(enum hab_target target,
89                                                        const void *start,
90                                                        size_t bytes)
91 {
92         return HAB_SUCCESS;
93 }
94
95 #define hab_rvt_check_target_p                                  \
96 (                                                               \
97         (is_mx6dqp()) ?                                         \
98         ((hab_rvt_check_target_t *)hab_rvt_check_target_new) :  \
99         (is_mx6dq() && (soc_rev() >= CHIP_REV_1_5)) ?           \
100         ((hab_rvt_check_target_t *)hab_rvt_check_target_new) :  \
101         (is_mx6sdl() && (soc_rev() >= CHIP_REV_1_2)) ?          \
102         ((hab_rvt_check_target_t *)hab_rvt_check_target_new) :  \
103         ((hab_rvt_check_target_t *)HAB_RVT_CHECK_TARGET)        \
104 )
105
106 #define ALIGN_SIZE              0x1000
107 #define MX6DQ_PU_IROM_MMU_EN_VAR        0x009024a8
108 #define MX6DLS_PU_IROM_MMU_EN_VAR       0x00901dd0
109 #define MX6SL_PU_IROM_MMU_EN_VAR        0x00900a18
110 #define IS_HAB_ENABLED_BIT \
111         (is_soc_type(MXC_SOC_MX7ULP) ? 0x80000000 :     \
112          (is_soc_type(MXC_SOC_MX7) ? 0x2000000 : 0x2))
113
114 static int ivt_header_error(const char *err_str, struct ivt_header *ivt_hdr)
115 {
116         printf("%s magic=0x%x length=0x%02x version=0x%x\n", err_str,
117                ivt_hdr->magic, ivt_hdr->length, ivt_hdr->version);
118
119         return 1;
120 }
121
122 static int verify_ivt_header(struct ivt_header *ivt_hdr)
123 {
124         int result = 0;
125
126         if (ivt_hdr->magic != IVT_HEADER_MAGIC)
127                 result = ivt_header_error("bad magic", ivt_hdr);
128
129         if (be16_to_cpu(ivt_hdr->length) != IVT_TOTAL_LENGTH)
130                 result = ivt_header_error("bad length", ivt_hdr);
131
132         if (ivt_hdr->version != IVT_HEADER_V1 &&
133             ivt_hdr->version != IVT_HEADER_V2)
134                 result = ivt_header_error("bad version", ivt_hdr);
135
136         return result;
137 }
138
139 #if !defined(CONFIG_SPL_BUILD)
140
141 #define MAX_RECORD_BYTES     (8*1024) /* 4 kbytes */
142
143 struct record {
144         uint8_t  tag;                                           /* Tag */
145         uint8_t  len[2];                                        /* Length */
146         uint8_t  par;                                           /* Version */
147         uint8_t  contents[MAX_RECORD_BYTES];/* Record Data */
148         bool     any_rec_flag;
149 };
150
151 static char *rsn_str[] = {
152                           "RSN = HAB_RSN_ANY (0x00)\n",
153                           "RSN = HAB_ENG_FAIL (0x30)\n",
154                           "RSN = HAB_INV_ADDRESS (0x22)\n",
155                           "RSN = HAB_INV_ASSERTION (0x0C)\n",
156                           "RSN = HAB_INV_CALL (0x28)\n",
157                           "RSN = HAB_INV_CERTIFICATE (0x21)\n",
158                           "RSN = HAB_INV_COMMAND (0x06)\n",
159                           "RSN = HAB_INV_CSF (0x11)\n",
160                           "RSN = HAB_INV_DCD (0x27)\n",
161                           "RSN = HAB_INV_INDEX (0x0F)\n",
162                           "RSN = HAB_INV_IVT (0x05)\n",
163                           "RSN = HAB_INV_KEY (0x1D)\n",
164                           "RSN = HAB_INV_RETURN (0x1E)\n",
165                           "RSN = HAB_INV_SIGNATURE (0x18)\n",
166                           "RSN = HAB_INV_SIZE (0x17)\n",
167                           "RSN = HAB_MEM_FAIL (0x2E)\n",
168                           "RSN = HAB_OVR_COUNT (0x2B)\n",
169                           "RSN = HAB_OVR_STORAGE (0x2D)\n",
170                           "RSN = HAB_UNS_ALGORITHM (0x12)\n",
171                           "RSN = HAB_UNS_COMMAND (0x03)\n",
172                           "RSN = HAB_UNS_ENGINE (0x0A)\n",
173                           "RSN = HAB_UNS_ITEM (0x24)\n",
174                           "RSN = HAB_UNS_KEY (0x1B)\n",
175                           "RSN = HAB_UNS_PROTOCOL (0x14)\n",
176                           "RSN = HAB_UNS_STATE (0x09)\n",
177                           "RSN = INVALID\n",
178                           NULL
179 };
180
181 static char *sts_str[] = {
182                           "STS = HAB_SUCCESS (0xF0)\n",
183                           "STS = HAB_FAILURE (0x33)\n",
184                           "STS = HAB_WARNING (0x69)\n",
185                           "STS = INVALID\n",
186                           NULL
187 };
188
189 static char *eng_str[] = {
190                           "ENG = HAB_ENG_ANY (0x00)\n",
191                           "ENG = HAB_ENG_SCC (0x03)\n",
192                           "ENG = HAB_ENG_RTIC (0x05)\n",
193                           "ENG = HAB_ENG_SAHARA (0x06)\n",
194                           "ENG = HAB_ENG_CSU (0x0A)\n",
195                           "ENG = HAB_ENG_SRTC (0x0C)\n",
196                           "ENG = HAB_ENG_DCP (0x1B)\n",
197                           "ENG = HAB_ENG_CAAM (0x1D)\n",
198                           "ENG = HAB_ENG_SNVS (0x1E)\n",
199                           "ENG = HAB_ENG_OCOTP (0x21)\n",
200                           "ENG = HAB_ENG_DTCP (0x22)\n",
201                           "ENG = HAB_ENG_ROM (0x36)\n",
202                           "ENG = HAB_ENG_HDCP (0x24)\n",
203                           "ENG = HAB_ENG_RTL (0x77)\n",
204                           "ENG = HAB_ENG_SW (0xFF)\n",
205                           "ENG = INVALID\n",
206                           NULL
207 };
208
209 static char *ctx_str[] = {
210                           "CTX = HAB_CTX_ANY(0x00)\n",
211                           "CTX = HAB_CTX_FAB (0xFF)\n",
212                           "CTX = HAB_CTX_ENTRY (0xE1)\n",
213                           "CTX = HAB_CTX_TARGET (0x33)\n",
214                           "CTX = HAB_CTX_AUTHENTICATE (0x0A)\n",
215                           "CTX = HAB_CTX_DCD (0xDD)\n",
216                           "CTX = HAB_CTX_CSF (0xCF)\n",
217                           "CTX = HAB_CTX_COMMAND (0xC0)\n",
218                           "CTX = HAB_CTX_AUT_DAT (0xDB)\n",
219                           "CTX = HAB_CTX_ASSERT (0xA0)\n",
220                           "CTX = HAB_CTX_EXIT (0xEE)\n",
221                           "CTX = INVALID\n",
222                           NULL
223 };
224
225 static uint8_t hab_statuses[5] = {
226         HAB_STS_ANY,
227         HAB_FAILURE,
228         HAB_WARNING,
229         HAB_SUCCESS,
230         -1
231 };
232
233 static uint8_t hab_reasons[26] = {
234         HAB_RSN_ANY,
235         HAB_ENG_FAIL,
236         HAB_INV_ADDRESS,
237         HAB_INV_ASSERTION,
238         HAB_INV_CALL,
239         HAB_INV_CERTIFICATE,
240         HAB_INV_COMMAND,
241         HAB_INV_CSF,
242         HAB_INV_DCD,
243         HAB_INV_INDEX,
244         HAB_INV_IVT,
245         HAB_INV_KEY,
246         HAB_INV_RETURN,
247         HAB_INV_SIGNATURE,
248         HAB_INV_SIZE,
249         HAB_MEM_FAIL,
250         HAB_OVR_COUNT,
251         HAB_OVR_STORAGE,
252         HAB_UNS_ALGORITHM,
253         HAB_UNS_COMMAND,
254         HAB_UNS_ENGINE,
255         HAB_UNS_ITEM,
256         HAB_UNS_KEY,
257         HAB_UNS_PROTOCOL,
258         HAB_UNS_STATE,
259         -1
260 };
261
262 static uint8_t hab_contexts[12] = {
263         HAB_CTX_ANY,
264         HAB_CTX_FAB,
265         HAB_CTX_ENTRY,
266         HAB_CTX_TARGET,
267         HAB_CTX_AUTHENTICATE,
268         HAB_CTX_DCD,
269         HAB_CTX_CSF,
270         HAB_CTX_COMMAND,
271         HAB_CTX_AUT_DAT,
272         HAB_CTX_ASSERT,
273         HAB_CTX_EXIT,
274         -1
275 };
276
277 static uint8_t hab_engines[16] = {
278         HAB_ENG_ANY,
279         HAB_ENG_SCC,
280         HAB_ENG_RTIC,
281         HAB_ENG_SAHARA,
282         HAB_ENG_CSU,
283         HAB_ENG_SRTC,
284         HAB_ENG_DCP,
285         HAB_ENG_CAAM,
286         HAB_ENG_SNVS,
287         HAB_ENG_OCOTP,
288         HAB_ENG_DTCP,
289         HAB_ENG_ROM,
290         HAB_ENG_HDCP,
291         HAB_ENG_RTL,
292         HAB_ENG_SW,
293         -1
294 };
295
296 static inline uint8_t get_idx(uint8_t *list, uint8_t tgt)
297 {
298         uint8_t idx = 0;
299         uint8_t element = list[idx];
300         while (element != -1) {
301                 if (element == tgt)
302                         return idx;
303                 element = list[++idx];
304         }
305         return -1;
306 }
307
308 static void process_event_record(uint8_t *event_data, size_t bytes)
309 {
310         struct record *rec = (struct record *)event_data;
311
312         printf("\n\n%s", sts_str[get_idx(hab_statuses, rec->contents[0])]);
313         printf("%s", rsn_str[get_idx(hab_reasons, rec->contents[1])]);
314         printf("%s", ctx_str[get_idx(hab_contexts, rec->contents[2])]);
315         printf("%s", eng_str[get_idx(hab_engines, rec->contents[3])]);
316 }
317
318 static void display_event(uint8_t *event_data, size_t bytes)
319 {
320         uint32_t i;
321
322         if (!(event_data && bytes > 0))
323                 return;
324
325         for (i = 0; i < bytes; i++) {
326                 if (i == 0)
327                         printf("\t0x%02x", event_data[i]);
328                 else if ((i % 8) == 0)
329                         printf("\n\t0x%02x", event_data[i]);
330                 else
331                         printf(" 0x%02x", event_data[i]);
332         }
333
334         process_event_record(event_data, bytes);
335 }
336
337 static int get_hab_status(void)
338 {
339         uint32_t index = 0; /* Loop index */
340         uint8_t event_data[128]; /* Event data buffer */
341         size_t bytes = sizeof(event_data); /* Event size in bytes */
342         enum hab_config config = 0;
343         enum hab_state state = 0;
344         hab_rvt_report_event_t *hab_rvt_report_event;
345         hab_rvt_report_status_t *hab_rvt_report_status;
346
347         hab_rvt_report_event = hab_rvt_report_event_p;
348         hab_rvt_report_status = hab_rvt_report_status_p;
349
350         if (imx_hab_is_enabled())
351                 puts("\nSecure boot enabled\n");
352         else
353                 puts("\nSecure boot disabled\n");
354
355         /* Check HAB status */
356         if (hab_rvt_report_status(&config, &state) != HAB_SUCCESS) {
357                 printf("\nHAB Configuration: 0x%02x, HAB State: 0x%02x\n",
358                        config, state);
359
360                 /* Display HAB Error events */
361                 while (hab_rvt_report_event(HAB_FAILURE, index, event_data,
362                                         &bytes) == HAB_SUCCESS) {
363                         puts("\n");
364                         printf("--------- HAB Event %d -----------------\n",
365                                index + 1);
366                         puts("event data:\n");
367                         display_event(event_data, bytes);
368                         puts("\n");
369                         bytes = sizeof(event_data);
370                         index++;
371                 }
372         }
373         /* Display message if no HAB events are found */
374         else {
375                 printf("\nHAB Configuration: 0x%02x, HAB State: 0x%02x\n",
376                        config, state);
377                 puts("No HAB Events Found!\n\n");
378         }
379         return 0;
380 }
381
382 static int do_hab_status(cmd_tbl_t *cmdtp, int flag, int argc,
383                          char * const argv[])
384 {
385         if ((argc != 1)) {
386                 cmd_usage(cmdtp);
387                 return 1;
388         }
389
390         get_hab_status();
391
392         return 0;
393 }
394
395 static int do_authenticate_image(cmd_tbl_t *cmdtp, int flag, int argc,
396                                  char * const argv[])
397 {
398         ulong   addr, length, ivt_offset;
399         int     rcode = 0;
400
401         if (argc < 4)
402                 return CMD_RET_USAGE;
403
404         addr = simple_strtoul(argv[1], NULL, 16);
405         length = simple_strtoul(argv[2], NULL, 16);
406         ivt_offset = simple_strtoul(argv[3], NULL, 16);
407
408         rcode = imx_hab_authenticate_image(addr, length, ivt_offset);
409         if (rcode == 0)
410                 rcode = CMD_RET_SUCCESS;
411         else
412                 rcode = CMD_RET_FAILURE;
413
414         return rcode;
415 }
416
417 static int do_hab_failsafe(cmd_tbl_t *cmdtp, int flag, int argc,
418                            char * const argv[])
419 {
420         hab_rvt_failsafe_t *hab_rvt_failsafe;
421
422         if (argc != 1) {
423                 cmd_usage(cmdtp);
424                 return 1;
425         }
426
427         hab_rvt_failsafe = hab_rvt_failsafe_p;
428         hab_rvt_failsafe();
429
430         return 0;
431 }
432
433 U_BOOT_CMD(
434                 hab_status, CONFIG_SYS_MAXARGS, 1, do_hab_status,
435                 "display HAB status",
436                 ""
437           );
438
439 U_BOOT_CMD(
440                 hab_auth_img, 4, 0, do_authenticate_image,
441                 "authenticate image via HAB",
442                 "addr length ivt_offset\n"
443                 "addr - image hex address\n"
444                 "length - image hex length\n"
445                 "ivt_offset - hex offset of IVT in the image"
446           );
447
448 U_BOOT_CMD(
449                 hab_failsafe, CONFIG_SYS_MAXARGS, 1, do_hab_failsafe,
450                 "run BootROM failsafe routine",
451                 ""
452           );
453
454 #endif /* !defined(CONFIG_SPL_BUILD) */
455
456 bool imx_hab_is_enabled(void)
457 {
458         struct imx_sec_config_fuse_t *fuse =
459                 (struct imx_sec_config_fuse_t *)&imx_sec_config_fuse;
460         uint32_t reg;
461         int ret;
462
463         ret = fuse_read(fuse->bank, fuse->word, &reg);
464         if (ret) {
465                 puts("\nSecure boot fuse read error\n");
466                 return ret;
467         }
468
469         return (reg & IS_HAB_ENABLED_BIT) == IS_HAB_ENABLED_BIT;
470 }
471
472 int imx_hab_authenticate_image(uint32_t ddr_start, uint32_t image_size,
473                                uint32_t ivt_offset)
474 {
475         uint32_t load_addr = 0;
476         size_t bytes;
477         uint32_t ivt_addr = 0;
478         int result = 1;
479         ulong start;
480         hab_rvt_authenticate_image_t *hab_rvt_authenticate_image;
481         hab_rvt_entry_t *hab_rvt_entry;
482         hab_rvt_exit_t *hab_rvt_exit;
483         hab_rvt_check_target_t *hab_rvt_check_target;
484         struct ivt *ivt;
485         struct ivt_header *ivt_hdr;
486         enum hab_status status;
487
488         hab_rvt_authenticate_image = hab_rvt_authenticate_image_p;
489         hab_rvt_entry = hab_rvt_entry_p;
490         hab_rvt_exit = hab_rvt_exit_p;
491         hab_rvt_check_target = hab_rvt_check_target_p;
492
493         if (!imx_hab_is_enabled()) {
494                 puts("hab fuse not enabled\n");
495                 return 0;
496         }
497
498         printf("\nAuthenticate image from DDR location 0x%x...\n",
499                ddr_start);
500
501         hab_caam_clock_enable(1);
502
503         /* Calculate IVT address header */
504         ivt_addr = ddr_start + ivt_offset;
505         ivt = (struct ivt *)ivt_addr;
506         ivt_hdr = &ivt->hdr;
507
508         /* Verify IVT header bugging out on error */
509         if (verify_ivt_header(ivt_hdr))
510                 goto hab_authentication_exit;
511
512         /* Verify IVT body */
513         if (ivt->self != ivt_addr) {
514                 printf("ivt->self 0x%08x pointer is 0x%08x\n",
515                        ivt->self, ivt_addr);
516                 goto hab_authentication_exit;
517         }
518
519         /* Verify if IVT DCD pointer is NULL */
520         if (ivt->dcd) {
521                 puts("Error: DCD pointer must be NULL\n");
522                 goto hab_authentication_exit;
523         }
524
525         start = ddr_start;
526         bytes = image_size;
527
528         if (hab_rvt_entry() != HAB_SUCCESS) {
529                 puts("hab entry function fail\n");
530                 goto hab_exit_failure_print_status;
531         }
532
533         status = hab_rvt_check_target(HAB_TGT_MEMORY, (void *)ddr_start, bytes);
534         if (status != HAB_SUCCESS) {
535                 printf("HAB check target 0x%08x-0x%08x fail\n",
536                        ddr_start, ddr_start + bytes);
537                 goto hab_exit_failure_print_status;
538         }
539 #ifdef DEBUG
540         printf("\nivt_offset = 0x%x, ivt addr = 0x%x\n", ivt_offset, ivt_addr);
541         printf("ivt entry = 0x%08x, dcd = 0x%08x, csf = 0x%08x\n", ivt->entry,
542                ivt->dcd, ivt->csf);
543         puts("Dumping IVT\n");
544         print_buffer(ivt_addr, (void *)(ivt_addr), 4, 0x8, 0);
545
546         puts("Dumping CSF Header\n");
547         print_buffer(ivt->csf, (void *)(ivt->csf), 4, 0x10, 0);
548
549 #if  !defined(CONFIG_SPL_BUILD)
550         get_hab_status();
551 #endif
552
553         puts("\nCalling authenticate_image in ROM\n");
554         printf("\tivt_offset = 0x%x\n", ivt_offset);
555         printf("\tstart = 0x%08lx\n", start);
556         printf("\tbytes = 0x%x\n", bytes);
557 #endif
558         /*
559          * If the MMU is enabled, we have to notify the ROM
560          * code, or it won't flush the caches when needed.
561          * This is done, by setting the "pu_irom_mmu_enabled"
562          * word to 1. You can find its address by looking in
563          * the ROM map. This is critical for
564          * authenticate_image(). If MMU is enabled, without
565          * setting this bit, authentication will fail and may
566          * crash.
567          */
568         /* Check MMU enabled */
569         if (is_soc_type(MXC_SOC_MX6) && get_cr() & CR_M) {
570                 if (is_mx6dq()) {
571                         /*
572                          * This won't work on Rev 1.0.0 of
573                          * i.MX6Q/D, since their ROM doesn't
574                          * do cache flushes. don't think any
575                          * exist, so we ignore them.
576                          */
577                         if (!is_mx6dqp())
578                                 writel(1, MX6DQ_PU_IROM_MMU_EN_VAR);
579                 } else if (is_mx6sdl()) {
580                         writel(1, MX6DLS_PU_IROM_MMU_EN_VAR);
581                 } else if (is_mx6sl()) {
582                         writel(1, MX6SL_PU_IROM_MMU_EN_VAR);
583                 }
584         }
585
586         load_addr = (uint32_t)hab_rvt_authenticate_image(
587                         HAB_CID_UBOOT,
588                         ivt_offset, (void **)&start,
589                         (size_t *)&bytes, NULL);
590         if (hab_rvt_exit() != HAB_SUCCESS) {
591                 puts("hab exit function fail\n");
592                 load_addr = 0;
593         }
594
595 hab_exit_failure_print_status:
596 #if !defined(CONFIG_SPL_BUILD)
597         get_hab_status();
598 #endif
599
600 hab_authentication_exit:
601
602         if (load_addr != 0)
603                 result = 0;
604
605         return result;
606 }