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