tools/mxsimage.h

   1 /*
   2  * Freescale i.MX28 SB image generator
   3  *
   4  * Copyright (C) 2012 Marek Vasut <marex@denx.de>
   5  *
   6  * SPDX-License-Identifier:     GPL-2.0+
   7  */
   8
   9 #ifndef __MXSSB_H__
  10 #define __MXSSB_H__
  11
  12 #include <stdint.h>
  13 #include <arpa/inet.h>
  14
  15 #define SB_BLOCK_SIZE           16
  16
  17 #define roundup(x, y)           ((((x) + ((y) - 1)) / (y)) * (y))
  18 #define ARRAY_SIZE(x)           (sizeof(x) / sizeof((x)[0]))
  19
  20 struct sb_boot_image_version {
  21         uint16_t        major;
  22         uint16_t        pad0;
  23         uint16_t        minor;
  24         uint16_t        pad1;
  25         uint16_t        revision;
  26         uint16_t        pad2;
  27 };
  28
  29 struct sb_boot_image_header {
  30         union {
  31                 /* SHA1 of the header. */
  32                 uint8_t digest[20];
  33                 struct {
  34                         /* CBC-MAC initialization vector. */
  35                         uint8_t iv[16];
  36                         uint8_t extra[4];
  37                 };
  38         };
  39         /* 'STMP' */
  40         uint8_t         signature1[4];
  41         /* Major version of the image format. */
  42         uint8_t         major_version;
  43         /* Minor version of the image format. */
  44         uint8_t         minor_version;
  45         /* Flags associated with the image. */
  46         uint16_t        flags;
  47         /* Size of the image in 16b blocks. */
  48         uint32_t        image_blocks;
  49         /* Offset of the first tag in 16b blocks. */
  50         uint32_t        first_boot_tag_block;
  51         /* ID of the section to boot from. */
  52         uint32_t        first_boot_section_id;
  53         /* Amount of crypto keys. */
  54         uint16_t        key_count;
  55         /* Offset to the key dictionary in 16b blocks. */
  56         uint16_t        key_dictionary_block;
  57         /* Size of this header in 16b blocks. */
  58         uint16_t        header_blocks;
  59         /* Amount of section headers. */
  60         uint16_t        section_count;
  61         /* Section header size in 16b blocks. */
  62         uint16_t        section_header_size;
  63         /* Padding to align timestamp to uint64_t. */
  64         uint8_t         padding0[2];
  65         /* 'sgtl' (since v1.1) */
  66         uint8_t         signature2[4];
  67         /* Image generation date, in microseconds since 1.1.2000 . */
  68         uint64_t        timestamp_us;
  69         /* Product version. */
  70         struct sb_boot_image_version
  71                         product_version;
  72         /* Component version. */
  73         struct sb_boot_image_version
  74                         component_version;
  75         /* Drive tag for the system drive. (since v1.1) */
  76         uint16_t        drive_tag;
  77         /* Padding. */
  78         uint8_t         padding1[6];
  79 };
  80
  81 #define SB_VERSION_MAJOR        1
  82 #define SB_VERSION_MINOR        1
  83
  84 /* Enable to HTLLC verbose boot report. */
  85 #define SB_IMAGE_FLAG_VERBOSE   (1 << 0)
  86
  87 struct sb_key_dictionary_key {
  88         /* The CBC-MAC of image and sections header. */
  89         uint8_t         cbc_mac[SB_BLOCK_SIZE];
  90         /* The AES key encrypted by image key (zero). */
  91         uint8_t         key[SB_BLOCK_SIZE];
  92 };
  93
  94 struct sb_ivt_header {
  95         uint32_t        header;
  96         uint32_t        entry;
  97         uint32_t        reserved1;
  98         uint32_t        dcd;
  99         uint32_t        boot_data;
 100         uint32_t        self;
 101         uint32_t        csf;
 102         uint32_t        reserved2;
 103 };
 104
 105 #define SB_HAB_IVT_TAG                  0xd1UL
 106 #define SB_HAB_DCD_TAG                  0xd2UL
 107
 108 #define SB_HAB_VERSION                  0x40UL
 109
 110 /*
 111  * The "size" field in the IVT header is not naturally aligned,
 112  * use this macro to fill first 4 bytes of the IVT header without
 113  * causing issues on some systems (esp. M68k, PPC, MIPS-BE, ARM-BE).
 114  */
 115 static inline uint32_t sb_hab_ivt_header(void)
 116 {
 117         uint32_t ret = 0;
 118         ret |= SB_HAB_IVT_TAG << 24;
 119         ret |= sizeof(struct sb_ivt_header) << 16;
 120         ret |= SB_HAB_VERSION;
 121         return htonl(ret);
 122 }
 123
 124 struct sb_sections_header {
 125         /* Section number. */
 126         uint32_t        section_number;
 127         /* Offset of this sections first instruction after "TAG". */
 128         uint32_t        section_offset;
 129         /* Size of the section in 16b blocks. */
 130         uint32_t        section_size;
 131         /* Section flags. */
 132         uint32_t        section_flags;
 133 };
 134
 135 #define SB_SECTION_FLAG_BOOTABLE        (1 << 0)
 136
 137 struct sb_command {
 138         struct {
 139                 uint8_t         checksum;
 140                 uint8_t         tag;
 141                 uint16_t        flags;
 142 #define ROM_TAG_CMD_FLAG_ROM_LAST_TAG   0x1
 143 #define ROM_LOAD_CMD_FLAG_DCD_LOAD      0x1     /* MX28 only */
 144 #define ROM_JUMP_CMD_FLAG_HAB           0x1     /* MX28 only */
 145 #define ROM_CALL_CMD_FLAG_HAB           0x1     /* MX28 only */
 146         } header;
 147
 148         union {
 149         struct {
 150                 uint32_t        reserved[3];
 151         } nop;
 152         struct {
 153                 uint32_t        section_number;
 154                 uint32_t        section_length;
 155                 uint32_t        section_flags;
 156         } tag;
 157         struct {
 158                 uint32_t        address;
 159                 uint32_t        count;
 160                 uint32_t        crc32;
 161         } load;
 162         struct {
 163                 uint32_t        address;
 164                 uint32_t        count;
 165                 uint32_t        pattern;
 166         } fill;
 167         struct {
 168                 uint32_t        address;
 169                 uint32_t        reserved;
 170                 /* Passed in register r0 before JUMP */
 171                 uint32_t        argument;
 172         } jump;
 173         struct {
 174                 uint32_t        address;
 175                 uint32_t        reserved;
 176                 /* Passed in register r0 before CALL */
 177                 uint32_t        argument;
 178         } call;
 179         struct {
 180                 uint32_t        reserved1;
 181                 uint32_t        reserved2;
 182                 uint32_t        mode;
 183         } mode;
 184
 185         };
 186 };
 187
 188 /*
 189  * Most of the mode names are same or at least similar
 190  * on i.MX23 and i.MX28, but some of the mode names
 191  * differ. The "name" field represents the mode name
 192  * on i.MX28 as seen in Table 12-2 of the datasheet.
 193  * The "altname" field represents the differently named
 194  * fields on i.MX23 as seen in Table 35-3 of the
 195  * datasheet.
 196  */
 197 static const struct {
 198         const char      *name;
 199         const char      *altname;
 200         const uint8_t   mode;
 201 } modetable[] = {
 202         { "USB",                NULL,           0x00 },
 203         { "I2C",                NULL,           0x01 },
 204         { "SPI2_FLASH",         "SPI1_FLASH",   0x02 },
 205         { "SPI3_FLASH",         "SPI2_FLASH",   0x03 },
 206         { "NAND_BCH",           NULL,           0x04 },
 207         { "JTAG",               NULL,           0x06 },
 208         { "SPI3_EEPROM",        "SPI2_EEPROM",  0x08 },
 209         { "SD_SSP0",            NULL,           0x09 },
 210         { "SD_SSP1",            NULL,           0x0A }
 211 };
 212
 213 enum sb_tag {
 214         ROM_NOP_CMD     = 0x00,
 215         ROM_TAG_CMD     = 0x01,
 216         ROM_LOAD_CMD    = 0x02,
 217         ROM_FILL_CMD    = 0x03,
 218         ROM_JUMP_CMD    = 0x04,
 219         ROM_CALL_CMD    = 0x05,
 220         ROM_MODE_CMD    = 0x06
 221 };
 222
 223 struct sb_source_entry {
 224         uint8_t         tag;
 225         uint32_t        address;
 226         uint32_t        flags;
 227         char            *filename;
 228 };
 229
 230 #endif  /* __MXSSB_H__ */