tools/ublimage.c

   1 /*
   2  * (C) Copyright 2011
   3  * Heiko Schocher, DENX Software Engineering, hs@denx.de.
   4  *
   5  * Based on:
   6  * (C) Copyright 2009
   7  * Stefano Babic, DENX Software Engineering, sbabic@denx.de.
   8  *
   9  * (C) Copyright 2008
  10  * Marvell Semiconductor <www.marvell.com>
  11  * Written-by: Prafulla Wadaskar <prafulla@marvell.com>
  12  *
  13  * SPDX-License-Identifier:     GPL-2.0+
  14  */
  15
  16 #include "mkimage.h"
  17 #include <image.h>
  18 #include "ublimage.h"
  19
  20 /*
  21  * Supported commands for configuration file
  22  */
  23 static table_entry_t ublimage_cmds[] = {
  24         {CMD_BOOT_MODE, "MODE",         "UBL special modes", },
  25         {CMD_ENTRY,     "ENTRY",        "Entry point addr for bootloader", },
  26         {CMD_PAGE,      "PAGES",
  27                 "number of pages (size of bootloader)", },
  28         {CMD_ST_BLOCK,  "START_BLOCK",
  29                 "block number where bootloader is present", },
  30         {CMD_ST_PAGE,   "START_PAGE",
  31                 "page number where bootloader is present", },
  32         {CMD_LD_ADDR,   "LD_ADDR",
  33                 "load addr", },
  34         {-1,            "",             "", },
  35 };
  36
  37 /*
  38  * Supported Boot options for configuration file
  39  * this is needed to set the correct flash offset
  40  */
  41 static table_entry_t ublimage_bootops[] = {
  42         {UBL_MAGIC_SAFE,        "safe", "Safe boot mode",       },
  43         {-1,                    "",     "Invalid",              },
  44 };
  45
  46 static struct ubl_header ublimage_header;
  47
  48 static uint32_t get_cfg_value(char *token, char *name,  int linenr)
  49 {
  50         char *endptr;
  51         uint32_t value;
  52
  53         errno = 0;
  54         value = strtoul(token, &endptr, 16);
  55         if (errno || (token == endptr)) {
  56                 fprintf(stderr, "Error: %s[%d] - Invalid hex data(%s)\n",
  57                         name,  linenr, token);
  58                 exit(EXIT_FAILURE);
  59         }
  60         return value;
  61 }
  62
  63 static void print_hdr(struct ubl_header *ubl_hdr)
  64 {
  65         printf("Image Type : Davinci UBL Boot Image\n");
  66         printf("UBL magic  : %08x\n", ubl_hdr->magic);
  67         printf("Entry Point: %08x\n", ubl_hdr->entry);
  68         printf("nr of pages: %08x\n", ubl_hdr->pages);
  69         printf("start block: %08x\n", ubl_hdr->block);
  70         printf("start page : %08x\n", ubl_hdr->page);
  71 }
  72
  73 static void parse_cfg_cmd(struct ubl_header *ublhdr, int32_t cmd, char *token,
  74                                 char *name, int lineno, int fld, int dcd_len)
  75 {
  76         static int cmd_ver_first = ~0;
  77
  78         switch (cmd) {
  79         case CMD_BOOT_MODE:
  80                 ublhdr->magic = get_table_entry_id(ublimage_bootops,
  81                                         "ublimage special boot mode", token);
  82                 if (ublhdr->magic == -1) {
  83                         fprintf(stderr, "Error: %s[%d] -Invalid boot mode"
  84                                 "(%s)\n", name, lineno, token);
  85                         exit(EXIT_FAILURE);
  86                 }
  87                 ublhdr->magic += UBL_MAGIC_BASE;
  88                 if (unlikely(cmd_ver_first != 1))
  89                         cmd_ver_first = 0;
  90                 break;
  91         case CMD_ENTRY:
  92                 ublhdr->entry = get_cfg_value(token, name, lineno);
  93                 break;
  94         case CMD_PAGE:
  95                 ublhdr->pages = get_cfg_value(token, name, lineno);
  96                 break;
  97         case CMD_ST_BLOCK:
  98                 ublhdr->block = get_cfg_value(token, name, lineno);
  99                 break;
 100         case CMD_ST_PAGE:
 101                 ublhdr->page = get_cfg_value(token, name, lineno);
 102                 break;
 103         case CMD_LD_ADDR:
 104                 ublhdr->pll_m = get_cfg_value(token, name, lineno);
 105                 break;
 106         }
 107 }
 108
 109 static void parse_cfg_fld(struct ubl_header *ublhdr, int32_t *cmd,
 110                 char *token, char *name, int lineno, int fld, int *dcd_len)
 111 {
 112
 113         switch (fld) {
 114         case CFG_COMMAND:
 115                 *cmd = get_table_entry_id(ublimage_cmds,
 116                         "ublimage commands", token);
 117                 if (*cmd < 0) {
 118                         fprintf(stderr, "Error: %s[%d] - Invalid command"
 119                         "(%s)\n", name, lineno, token);
 120                         exit(EXIT_FAILURE);
 121                 }
 122                 break;
 123         case CFG_REG_VALUE:
 124                 parse_cfg_cmd(ublhdr, *cmd, token, name, lineno, fld, *dcd_len);
 125                 break;
 126         default:
 127                 break;
 128         }
 129 }
 130 static uint32_t parse_cfg_file(struct ubl_header *ublhdr, char *name)
 131 {
 132         FILE *fd = NULL;
 133         char *line = NULL;
 134         char *token, *saveptr1, *saveptr2;
 135         int lineno = 0;
 136         int     i;
 137         char *ptr = (char *)ublhdr;
 138         int fld;
 139         size_t len;
 140         int dcd_len = 0;
 141         int32_t cmd;
 142         int ublhdrlen = sizeof(struct ubl_header);
 143
 144         fd = fopen(name, "r");
 145         if (fd == 0) {
 146                 fprintf(stderr, "Error: %s - Can't open DCD file\n", name);
 147                 exit(EXIT_FAILURE);
 148         }
 149
 150         /* Fill header with 0xff */
 151         for (i = 0; i < ublhdrlen; i++) {
 152                 *ptr = 0xff;
 153                 ptr++;
 154         }
 155
 156         /*
 157          * Very simple parsing, line starting with # are comments
 158          * and are dropped
 159          */
 160         while ((getline(&line, &len, fd)) > 0) {
 161                 lineno++;
 162
 163                 token = strtok_r(line, "\r\n", &saveptr1);
 164                 if (token == NULL)
 165                         continue;
 166
 167                 /* Check inside the single line */
 168                 for (fld = CFG_COMMAND, cmd = CMD_INVALID,
 169                                 line = token; ; line = NULL, fld++) {
 170                         token = strtok_r(line, " \t", &saveptr2);
 171                         if (token == NULL)
 172                                 break;
 173
 174                         /* Drop all text starting with '#' as comments */
 175                         if (token[0] == '#')
 176                                 break;
 177
 178                         parse_cfg_fld(ublhdr, &cmd, token, name,
 179                                         lineno, fld, &dcd_len);
 180                 }
 181         }
 182         fclose(fd);
 183
 184         return dcd_len;
 185 }
 186
 187 static int ublimage_check_image_types(uint8_t type)
 188 {
 189         if (type == IH_TYPE_UBLIMAGE)
 190                 return EXIT_SUCCESS;
 191         else
 192                 return EXIT_FAILURE;
 193 }
 194
 195 static int ublimage_verify_header(unsigned char *ptr, int image_size,
 196                         struct mkimage_params *params)
 197 {
 198         struct ubl_header *ubl_hdr = (struct ubl_header *)ptr;
 199
 200         if ((ubl_hdr->magic & 0xFFFFFF00) != UBL_MAGIC_BASE)
 201                 return -1;
 202
 203         return 0;
 204 }
 205
 206 static void ublimage_print_header(const void *ptr)
 207 {
 208         struct ubl_header *ubl_hdr = (struct ubl_header *) ptr;
 209
 210         print_hdr(ubl_hdr);
 211 }
 212
 213 static void ublimage_set_header(void *ptr, struct stat *sbuf, int ifd,
 214                                 struct mkimage_params *params)
 215 {
 216         struct ubl_header *ublhdr = (struct ubl_header *)ptr;
 217
 218         /* Parse configuration file */
 219         parse_cfg_file(ublhdr, params->imagename);
 220 }
 221
 222 int ublimage_check_params(struct mkimage_params *params)
 223 {
 224         if (!params)
 225                 return CFG_INVALID;
 226         if (!strlen(params->imagename)) {
 227                 fprintf(stderr, "Error: %s - Configuration file not"
 228                         "specified, it is needed for ublimage generation\n",
 229                         params->cmdname);
 230                 return CFG_INVALID;
 231         }
 232         /*
 233          * Check parameters:
 234          * XIP is not allowed and verify that incompatible
 235          * parameters are not sent at the same time
 236          * For example, if list is required a data image must not be provided
 237          */
 238         return  (params->dflag && (params->fflag || params->lflag)) ||
 239                 (params->fflag && (params->dflag || params->lflag)) ||
 240                 (params->lflag && (params->dflag || params->fflag)) ||
 241                 (params->xflag) || !(strlen(params->imagename));
 242 }
 243
 244 /*
 245  * ublimage parameters
 246  */
 247 static struct image_type_params ublimage_params = {
 248         .name           = "Davinci UBL boot support",
 249         .header_size    = sizeof(struct ubl_header),
 250         .hdr            = (void *)&ublimage_header,
 251         .check_image_type = ublimage_check_image_types,
 252         .verify_header  = ublimage_verify_header,
 253         .print_header   = ublimage_print_header,
 254         .set_header     = ublimage_set_header,
 255         .check_params   = ublimage_check_params,
 256 };
 257
 258 void init_ubl_image_type(void)
 259 {
 260         mkimage_register(&ublimage_params);
 261 }