arch/arm/include/asm/arch-mx6/hab.h

   1 /*
   2  * Copyright (C) 2012-2015 Freescale Semiconductor, Inc. All Rights Reserved.
   3  *
   4  * SPDX-License-Identifier:    GPL-2.0+
   5  *
   6 */
   7
   8 #ifndef __ARCH_MX6_HAB_H
   9 #define __ARCH_MX6_HAB_H
  10
  11 #ifdef CONFIG_SECURE_BOOT
  12
  13 #include <linux/types.h>
  14 #include <asm/arch/sys_proto.h>
  15
  16 int get_hab_status(void);
  17 /*
  18  * IVT header definitions
  19  * Security Reference Manual for i.MX 7Dual and 7Solo Applications Processors,
  20  * Rev. 0, 03/2017
  21  * Section : 6.7.1.1
  22  */
  23 #define IVT_HEADER_MAGIC        0xD1
  24 #define IVT_TOTAL_LENGTH        0x20
  25 #define IVT_HEADER_V1           0x40
  26 #define IVT_HEADER_V2           0x41
  27
  28 struct __packed ivt_header {
  29         uint8_t         magic;
  30         uint16_t        length;
  31         uint8_t         version;
  32 };
  33
  34 struct ivt {
  35         struct ivt_header hdr;  /* IVT header above */
  36         uint32_t entry;         /* Absolute address of first instruction */
  37         uint32_t reserved1;     /* Reserved should be zero */
  38         uint32_t dcd;           /* Absolute address of the image DCD */
  39         uint32_t boot;          /* Absolute address of the boot data */
  40         uint32_t self;          /* Absolute address of the IVT */
  41         uint32_t csf;           /* Absolute address of the CSF */
  42         uint32_t reserved2;     /* Reserved should be zero */
  43 };
  44
  45 struct __packed hab_hdr {
  46         u8 tag;                 /* Tag field */
  47         u8 len[2];              /* Length field in bytes (big-endian) */
  48         u8 par;                 /* Parameters field */
  49 };
  50
  51 /* -------- start of HAB API updates ------------*/
  52 /* The following are taken from HAB4 SIS */
  53
  54 /* Status definitions */
  55 enum hab_status {
  56         HAB_STS_ANY = 0x00,
  57         HAB_FAILURE = 0x33,
  58         HAB_WARNING = 0x69,
  59         HAB_SUCCESS = 0xf0
  60 };
  61
  62 /* Security Configuration definitions */
  63 enum hab_config {
  64         HAB_CFG_RETURN = 0x33,          /* Field Return IC */
  65         HAB_CFG_OPEN = 0xf0,            /* Non-secure IC */
  66         HAB_CFG_CLOSED = 0xcc           /* Secure IC */
  67 };
  68
  69 /* State definitions */
  70 enum hab_state {
  71         HAB_STATE_INITIAL = 0x33,       /* Initialising state (transitory) */
  72         HAB_STATE_CHECK = 0x55,         /* Check state (non-secure) */
  73         HAB_STATE_NONSECURE = 0x66,     /* Non-secure state */
  74         HAB_STATE_TRUSTED = 0x99,       /* Trusted state */
  75         HAB_STATE_SECURE = 0xaa,        /* Secure state */
  76         HAB_STATE_FAIL_SOFT = 0xcc,     /* Soft fail state */
  77         HAB_STATE_FAIL_HARD = 0xff,     /* Hard fail state (terminal) */
  78         HAB_STATE_NONE = 0xf0,          /* No security state machine */
  79         HAB_STATE_MAX
  80 };
  81
  82 enum hab_target {
  83         HAB_TGT_MEMORY = 0x0f, /* Check memory white list */
  84         HAB_TGT_PERIPHERAL = 0xf0, /* Check peripheral white list*/
  85         HAB_TGT_ANY = 0x55, /**< Check memory & peripheral white list */
  86 };
  87
  88 enum HAB_FUNC_OFFSETS {
  89         HAB_RVT_HEADER,
  90         HAB_RVT_ENTRY,
  91         HAB_RVT_EXIT,
  92         HAB_RVT_CHECK_TARGET,
  93         HAB_RVT_AUTHENTICATE_IMAGE,
  94         HAB_RVT_RUN_DCD,
  95         HAB_RVT_RUN_CSF,
  96         HAB_RVT_ASSERT,
  97         HAB_RVT_REPORT_EVENT,
  98         HAB_RVT_REPORT_STATUS,
  99         HAB_RVT_FAILSAFE,
 100 };
 101
 102 enum hab_reason {
 103         HAB_RSN_ANY = 0x00,             /* Match any reason */
 104         HAB_ENG_FAIL = 0x30,            /* Engine failure */
 105         HAB_INV_ADDRESS = 0x22,         /* Invalid address: access denied */
 106         HAB_INV_ASSERTION = 0x0c,       /* Invalid assertion */
 107         HAB_INV_CALL = 0x28,            /* Function called out of sequence */
 108         HAB_INV_CERTIFICATE = 0x21,     /* Invalid certificate */
 109         HAB_INV_COMMAND = 0x06,         /* Invalid command: command malformed */
 110         HAB_INV_CSF = 0x11,             /* Invalid csf */
 111         HAB_INV_DCD = 0x27,             /* Invalid dcd */
 112         HAB_INV_INDEX = 0x0f,           /* Invalid index: access denied */
 113         HAB_INV_IVT = 0x05,             /* Invalid ivt */
 114         HAB_INV_KEY = 0x1d,             /* Invalid key */
 115         HAB_INV_RETURN = 0x1e,          /* Failed callback function */
 116         HAB_INV_SIGNATURE = 0x18,       /* Invalid signature */
 117         HAB_INV_SIZE = 0x17,            /* Invalid data size */
 118         HAB_MEM_FAIL = 0x2e,            /* Memory failure */
 119         HAB_OVR_COUNT = 0x2b,           /* Expired poll count */
 120         HAB_OVR_STORAGE = 0x2d,         /* Exhausted storage region */
 121         HAB_UNS_ALGORITHM = 0x12,       /* Unsupported algorithm */
 122         HAB_UNS_COMMAND = 0x03,         /* Unsupported command */
 123         HAB_UNS_ENGINE = 0x0a,          /* Unsupported engine */
 124         HAB_UNS_ITEM = 0x24,            /* Unsupported configuration item */
 125         HAB_UNS_KEY = 0x1b,             /* Unsupported key type/parameters */
 126         HAB_UNS_PROTOCOL = 0x14,        /* Unsupported protocol */
 127         HAB_UNS_STATE = 0x09,           /* Unsuitable state */
 128         HAB_RSN_MAX
 129 };
 130
 131 enum hab_context {
 132         HAB_CTX_ANY = 0x00,             /* Match any context */
 133         HAB_CTX_FAB = 0xff,             /* Event logged in hab_fab_test() */
 134         HAB_CTX_ENTRY = 0xe1,           /* Event logged in hab_rvt.entry() */
 135         HAB_CTX_TARGET = 0x33,          /* Event logged in hab_rvt.check_target() */
 136         HAB_CTX_AUTHENTICATE = 0x0a,    /* Logged in hab_rvt.authenticate_image() */
 137         HAB_CTX_DCD = 0xdd,             /* Event logged in hab_rvt.run_dcd() */
 138         HAB_CTX_CSF = 0xcf,             /* Event logged in hab_rvt.run_csf() */
 139         HAB_CTX_COMMAND = 0xc0,         /* Event logged executing csf/dcd command */
 140         HAB_CTX_AUT_DAT = 0xdb,         /* Authenticated data block */
 141         HAB_CTX_ASSERT = 0xa0,          /* Event logged in hab_rvt.assert() */
 142         HAB_CTX_EXIT = 0xee,            /* Event logged in hab_rvt.exit() */
 143         HAB_CTX_MAX
 144 };
 145
 146 /*Function prototype description*/
 147 typedef enum hab_status hab_rvt_report_event_t(enum hab_status, uint32_t,
 148                 uint8_t* , size_t*);
 149 typedef enum hab_status hab_rvt_report_status_t(enum hab_config *,
 150                 enum hab_state *);
 151 typedef enum hab_status hab_loader_callback_f_t(void**, size_t*, const void*);
 152 typedef enum hab_status hab_rvt_entry_t(void);
 153 typedef enum hab_status hab_rvt_exit_t(void);
 154 typedef enum hab_status hab_rvt_check_target_t(enum hab_target, const void *,
 155                 size_t);
 156
 157 typedef void *hab_rvt_authenticate_image_t(uint8_t, ptrdiff_t,
 158                 void **, size_t *, hab_loader_callback_f_t);
 159
 160 typedef enum hab_status hab_rvt_run_dcd_t(const uint8_t *dcd);
 161
 162 typedef enum hab_status hab_rvt_run_csf_t(const uint8_t *csf, uint8_t cid);
 163
 164 typedef enum hab_status hab_rvt_assert_t(uint32_t, const void *,
 165                 size_t);
 166
 167 typedef enum hab_status hab_rvt_report_event_t(enum hab_status, uint32_t,
 168                 uint8_t* , size_t*);
 169
 170 typedef enum hab_status hab_rvt_report_status_t(enum hab_config *,
 171                 enum hab_state *);
 172
 173 typedef void hapi_clock_init_t(void);
 174
 175 #define HAB_ENG_ANY             0x00   /* Select first compatible engine */
 176 #define HAB_ENG_SCC             0x03   /* Security controller */
 177 #define HAB_ENG_RTIC            0x05   /* Run-time integrity checker */
 178 #define HAB_ENG_SAHARA          0x06   /* Crypto accelerator */
 179 #define HAB_ENG_CSU             0x0a   /* Central Security Unit */
 180 #define HAB_ENG_SRTC            0x0c   /* Secure clock */
 181 #define HAB_ENG_DCP             0x1b   /* Data Co-Processor */
 182 #define HAB_ENG_CAAM            0x1d   /* CAAM */
 183 #define HAB_ENG_SNVS            0x1e   /* Secure Non-Volatile Storage */
 184 #define HAB_ENG_OCOTP           0x21   /* Fuse controller */
 185 #define HAB_ENG_DTCP            0x22   /* DTCP co-processor */
 186 #define HAB_ENG_ROM             0x36   /* Protected ROM area */
 187 #define HAB_ENG_HDCP            0x24   /* HDCP co-processor */
 188 #define HAB_ENG_RTL             0x77   /* RTL simulation engine */
 189 #define HAB_ENG_SW              0xff   /* Software engine */
 190
 191 static inline void **hab_rvt_base(void)
 192 {
 193         unsigned long base;
 194         int cpu_type = get_cpu_type();
 195         int rev = soc_rev();
 196         const uint32_t mask = 0xfc0000ff;
 197
 198         switch (cpu_type) {
 199         case MXC_CPU_MX6Q:
 200         case MXC_CPU_MX6D:
 201                 if (rev >= CHIP_REV_1_5)
 202                         base = 0x98UL;
 203                 else
 204                         base = 0x94UL;
 205                 break;
 206         case MXC_CPU_MX6DL:
 207                 if (rev >= CHIP_REV_1_2)
 208                         base = 0x98UL;
 209                 else
 210                         base = 0x94UL;
 211                 break;
 212         case MXC_CPU_MX6SOLO:
 213                 base = 0x98UL;
 214                 break;
 215         case MXC_CPU_MX6SX:
 216         case MXC_CPU_MX6UL:
 217         case MXC_CPU_MX6ULL:
 218                 base = 0x100UL;
 219                 break;
 220         default:
 221                 printf("Unsupported CPU type: %02x\n", cpu_type);
 222                 return NULL;
 223         }
 224
 225         if (((rev = readl(base)) & mask) != cpu_to_be32(0xdd000040)) {
 226                 printf("Invalid RVT @ %08lx: %08x:%08x\n",
 227                         base, rev, rev & mask);
 228                 return NULL;
 229         }
 230         return (void **)base;
 231 }
 232
 233 #define HAB_CID_ROM 0 /**< ROM Caller ID */
 234 #define HAB_CID_UBOOT 1 /**< UBOOT Caller ID*/
 235
 236 #define HAB_CMD_HDR          0xD4  /* CSF Header */
 237 #define HAB_CMD_WRT_DAT      0xCC  /* Write Data command tag */
 238 #define HAB_CMD_CHK_DAT      0xCF  /* Check Data command tag */
 239 #define HAB_CMD_SET          0xB1  /* Set command tag */
 240 #define HAB_PAR_MID          0x01  /* MID parameter value */
 241 /* ----------- end of HAB API updates ------------*/
 242
 243 #define hab_rvt_entry_p                                         \
 244         ((hab_rvt_entry_t *)hab_rvt_base()[HAB_RVT_ENTRY])
 245
 246 #define hab_rvt_exit_p                                          \
 247         ((hab_rvt_exit_t *)hab_rvt_base()[HAB_RVT_EXIT])
 248
 249 #define hab_rvt_check_target_p                                  \
 250         ((hab_rvt_check_target_t*)hab_rvt_base()[HAB_RVT_CHECK_TARGET])
 251
 252 #define hab_rvt_authenticate_image_p                            \
 253         ((hab_rvt_authenticate_image_t *)hab_rvt_base()[HAB_RVT_AUTHENTICATE_IMAGE])
 254
 255 #define hab_rvt_run_dcd_p                                       \
 256         ((hab_rvt_run_dcd_t*)hab_rvt_base()[HAB_RVT_RUN_DCD])
 257
 258 #define hab_rvt_run_csf_p                                       \
 259         ((hab_rvt_run_csf_t*)hab_rvt_base()[HAB_RVT_RUN_CSF])
 260
 261 #define hab_rvt_assert_p                                        \
 262         ((hab_rvt_assert_t*)hab_rvt_base()[HAB_RVT_ASSERT])
 263
 264 #define hab_rvt_report_event_p                                  \
 265         ((hab_rvt_report_event_t*)hab_rvt_base()[HAB_RVT_REPORT_EVENT])
 266
 267 #define hab_rvt_report_status_p                                 \
 268         ((hab_rvt_report_status_t*)hab_rvt_base()[HAB_RVT_REPORT_STATUS])
 269
 270 #define HAB_FUNC(n, rt)                                                 \
 271 static inline rt hab_rvt_##n(void)                                      \
 272 {                                                                       \
 273         if (hab_rvt_base() == NULL)                                     \
 274                 return (rt)-1;                                          \
 275         return hab_rvt_##n##_p();                                       \
 276 }                                                                       \
 277
 278 #define HAB_FUNC1(n, rt, t1)                                            \
 279 static inline rt hab_rvt_##n(t1 p1)                                     \
 280 {                                                                       \
 281         if (hab_rvt_base() == NULL)                                     \
 282                 return (rt)-1;                                          \
 283         return hab_rvt_##n##_p(p1);                                     \
 284 }
 285
 286 #define HAB_FUNC2(n, rt, t1, t2)                                        \
 287 static inline rt hab_rvt_##n(t1 p1, t2 p2)                              \
 288 {                                                                       \
 289         if (hab_rvt_base() == NULL)                                     \
 290                 return (rt)-1;                                          \
 291         return hab_rvt_##n##_p(p1, p2);                                 \
 292 }
 293
 294 #define HAB_FUNC3(n, rt, t1, t2, t3)                                    \
 295 static inline rt hab_rvt_##n(t1 p1, t2 p2, t3 p3)                       \
 296 {                                                                       \
 297         if (hab_rvt_base() == NULL)                                     \
 298                 return (rt)-1;                                          \
 299         return hab_rvt_##n##_p(p1, p2, p3);                             \
 300 }
 301
 302 #define HAB_FUNC4(n, rt, t1, t2, t3, t4)                                \
 303 static inline rt hab_rvt_##n(t1 p1, t2 p2, t3 p3, t4 p4)                \
 304 {                                                                       \
 305         if (hab_rvt_base() == NULL)                                     \
 306                 return (rt)-1;                                          \
 307         return hab_rvt_##n##_p(p1, p2, p3, p4);                         \
 308 }
 309
 310 #define HAB_FUNC5(n, rt, t1, t2, t3, t4, t5)                            \
 311 static inline rt hab_rvt_##n(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5) \
 312 {                                                                       \
 313         if (hab_rvt_base() == NULL)                                     \
 314                 return (rt)-1;                                          \
 315         return hab_rvt_##n##_p(p1, p2, p3, p4, p5);                     \
 316 }
 317
 318 #else /* CONFIG_SECURE_BOOT */
 319
 320 static inline int get_hab_status(void)
 321 {
 322         return 0;
 323 }
 324
 325 #endif /* CONFIG_SECURE_BOOT */
 326 #endif /* __ARCH_MX6_HAB_H */