tools/Makefile: Move _GNU_SOURCE to Makefile
[platform/kernel/u-boot.git] / tools / kwbimage.c
1 /*
2  * (C) Copyright 2008
3  * Marvell Semiconductor <www.marvell.com>
4  * Written-by: Prafulla Wadaskar <prafulla@marvell.com>
5  *
6  * SPDX-License-Identifier:     GPL-2.0+
7  */
8
9 #include "mkimage.h"
10 #include <image.h>
11 #include "kwbimage.h"
12
13 /*
14  * Supported commands for configuration file
15  */
16 static table_entry_t kwbimage_cmds[] = {
17         {CMD_BOOT_FROM,         "BOOT_FROM",            "boot command", },
18         {CMD_NAND_ECC_MODE,     "NAND_ECC_MODE",        "NAND mode",    },
19         {CMD_NAND_PAGE_SIZE,    "NAND_PAGE_SIZE",       "NAND size",    },
20         {CMD_SATA_PIO_MODE,     "SATA_PIO_MODE",        "SATA mode",    },
21         {CMD_DDR_INIT_DELAY,    "DDR_INIT_DELAY",       "DDR init dly", },
22         {CMD_DATA,              "DATA",                 "Reg Write Data", },
23         {CMD_INVALID,           "",                     "",     },
24 };
25
26 /*
27  * Supported Boot options for configuration file
28  */
29 static table_entry_t kwbimage_bootops[] = {
30         {IBR_HDR_SPI_ID,        "spi",          "SPI Flash",    },
31         {IBR_HDR_NAND_ID,       "nand",         "NAND Flash",   },
32         {IBR_HDR_SATA_ID,       "sata",         "Sata port",    },
33         {IBR_HDR_PEX_ID,        "pex",          "PCIe port",    },
34         {IBR_HDR_UART_ID,       "uart",         "Serial port",  },
35         {-1,                    "",             "Invalid",      },
36 };
37
38 /*
39  * Supported NAND ecc options configuration file
40  */
41 static table_entry_t kwbimage_eccmodes[] = {
42         {IBR_HDR_ECC_DEFAULT,           "default",      "Default mode", },
43         {IBR_HDR_ECC_FORCED_HAMMING,    "hamming",      "Hamming mode", },
44         {IBR_HDR_ECC_FORCED_RS,         "rs",           "RS mode",      },
45         {IBR_HDR_ECC_DISABLED,          "disabled",     "ECC Disabled", },
46         {-1,                            "",             "",     },
47 };
48
49 static struct kwb_header kwbimage_header;
50 static int datacmd_cnt = 0;
51 static char * fname = "Unknown";
52 static int lineno = -1;
53
54 /*
55  * Report Error if xflag is set in addition to default
56  */
57 static int kwbimage_check_params (struct mkimage_params *params)
58 {
59         if (!strlen (params->imagename)) {
60                 printf ("Error:%s - Configuration file not specified, "
61                         "it is needed for kwbimage generation\n",
62                         params->cmdname);
63                 return CFG_INVALID;
64         }
65         return  ((params->dflag && (params->fflag || params->lflag)) ||
66                 (params->fflag && (params->dflag || params->lflag)) ||
67                 (params->lflag && (params->dflag || params->fflag)) ||
68                 (params->xflag) || !(strlen (params->imagename)));
69 }
70
71 static uint32_t check_get_hexval (char *token)
72 {
73         uint32_t hexval;
74
75         if (!sscanf (token, "%x", &hexval)) {
76                 printf ("Error:%s[%d] - Invalid hex data(%s)\n", fname,
77                         lineno, token);
78                 exit (EXIT_FAILURE);
79         }
80         return hexval;
81 }
82
83 /*
84  * Generates 8 bit checksum
85  */
86 static uint8_t kwbimage_checksum8 (void *start, uint32_t len, uint8_t csum)
87 {
88         register uint8_t sum = csum;
89         volatile uint8_t *p = (volatile uint8_t *)start;
90
91         /* check len and return zero checksum if invalid */
92         if (!len)
93                 return 0;
94
95         do {
96                 sum += *p;
97                 p++;
98         } while (--len);
99         return (sum);
100 }
101
102 /*
103  * Generates 32 bit checksum
104  */
105 static uint32_t kwbimage_checksum32 (uint32_t *start, uint32_t len, uint32_t csum)
106 {
107         register uint32_t sum = csum;
108         volatile uint32_t *p = start;
109
110         /* check len and return zero checksum if invalid */
111         if (!len)
112                 return 0;
113
114         if (len % sizeof(uint32_t)) {
115                 printf ("Error:%s[%d] - length is not in multiple of %zu\n",
116                         __FUNCTION__, len, sizeof(uint32_t));
117                 return 0;
118         }
119
120         do {
121                 sum += *p;
122                 p++;
123                 len -= sizeof(uint32_t);
124         } while (len > 0);
125         return (sum);
126 }
127
128 static void kwbimage_check_cfgdata (char *token, enum kwbimage_cmd cmdsw,
129                                         struct kwb_header *kwbhdr)
130 {
131         bhr_t *mhdr = &kwbhdr->kwb_hdr;
132         extbhr_t *exthdr = &kwbhdr->kwb_exthdr;
133         int i;
134
135         switch (cmdsw) {
136         case CMD_BOOT_FROM:
137                 i = get_table_entry_id (kwbimage_bootops,
138                                 "Kwbimage boot option", token);
139
140                 if (i < 0)
141                         goto INVL_DATA;
142
143                 mhdr->blockid = i;
144                 printf ("Preparing kirkwood boot image to boot "
145                         "from %s\n", token);
146                 break;
147         case CMD_NAND_ECC_MODE:
148                 i = get_table_entry_id (kwbimage_eccmodes,
149                         "NAND ecc mode", token);
150
151                 if (i < 0)
152                         goto INVL_DATA;
153
154                 mhdr->nandeccmode = i;
155                 printf ("Nand ECC mode = %s\n", token);
156                 break;
157         case CMD_NAND_PAGE_SIZE:
158                 mhdr->nandpagesize =
159                         (uint16_t) check_get_hexval (token);
160                 printf ("Nand page size = 0x%x\n", mhdr->nandpagesize);
161                 break;
162         case CMD_SATA_PIO_MODE:
163                 mhdr->satapiomode =
164                         (uint8_t) check_get_hexval (token);
165                 printf ("Sata PIO mode = 0x%x\n",
166                                 mhdr->satapiomode);
167                 break;
168         case CMD_DDR_INIT_DELAY:
169                 mhdr->ddrinitdelay =
170                         (uint16_t) check_get_hexval (token);
171                 printf ("DDR init delay = %d msec\n", mhdr->ddrinitdelay);
172                 break;
173         case CMD_DATA:
174                 exthdr->rcfg[datacmd_cnt].raddr =
175                         check_get_hexval (token);
176
177                 break;
178         case CMD_INVALID:
179                 goto INVL_DATA;
180         default:
181                 goto INVL_DATA;
182         }
183         return;
184
185 INVL_DATA:
186         printf ("Error:%s[%d] - Invalid data\n", fname, lineno);
187         exit (EXIT_FAILURE);
188 }
189
190 /*
191  * this function sets the kwbimage header by-
192  *      1. Abstracting input command line arguments data
193  *      2. parses the kwbimage configuration file and update extebded header data
194  *      3. calculates header, extended header and image checksums
195  */
196 static void kwdimage_set_ext_header (struct kwb_header *kwbhdr, char* name) {
197         bhr_t *mhdr = &kwbhdr->kwb_hdr;
198         extbhr_t *exthdr = &kwbhdr->kwb_exthdr;
199         FILE *fd = NULL;
200         int j;
201         char *line = NULL;
202         char * token, *saveptr1, *saveptr2;
203         size_t len = 0;
204         enum kwbimage_cmd cmd;
205
206         fname = name;
207         /* set dram register offset */
208         exthdr->dramregsoffs = (intptr_t)&exthdr->rcfg - (intptr_t)mhdr;
209
210         if ((fd = fopen (name, "r")) == 0) {
211                 printf ("Error:%s - Can't open\n", fname);
212                 exit (EXIT_FAILURE);
213         }
214
215         /* Simple kwimage.cfg file parser */
216         lineno=0;
217         while ((getline (&line, &len, fd)) > 0) {
218                 lineno++;
219                 token = strtok_r (line, "\r\n", &saveptr1);
220                 /* drop all lines with zero tokens (= empty lines) */
221                 if (token == NULL)
222                         continue;
223
224                 for (j = 0, cmd = CMD_INVALID, line = token; ; line = NULL) {
225                         token = strtok_r (line, " \t", &saveptr2);
226                         if (token == NULL)
227                         break;
228                         /* Drop all text starting with '#' as comments */
229                         if (token[0] == '#')
230                                 break;
231
232                         /* Process rest as valid config command line */
233                         switch (j) {
234                         case CFG_COMMAND:
235                                 cmd = get_table_entry_id (kwbimage_cmds,
236                                                 "Kwbimage command", token);
237
238                                 if (cmd == CMD_INVALID)
239                                         goto INVL_CMD;
240                                 break;
241
242                         case CFG_DATA0:
243                                 kwbimage_check_cfgdata (token, cmd, kwbhdr);
244                                 break;
245
246                         case CFG_DATA1:
247                                 if (cmd != CMD_DATA)
248                                         goto INVL_CMD;
249
250                                 exthdr->rcfg[datacmd_cnt].rdata =
251                                                 check_get_hexval (token);
252
253                                 if (datacmd_cnt > KWBIMAGE_MAX_CONFIG ) {
254                                         printf ("Error:%s[%d] - Found more "
255                                                 "than max(%zd) allowed "
256                                                 "data configurations\n",
257                                                 fname, lineno,
258                                                 KWBIMAGE_MAX_CONFIG);
259                                 exit (EXIT_FAILURE);
260                                 } else
261                                         datacmd_cnt++;
262                                 break;
263
264                         default:
265                                 goto INVL_CMD;
266                         }
267                         j++;
268                 }
269         }
270         if (line)
271                 free (line);
272
273         fclose (fd);
274         return;
275
276 /*
277  * Invalid Command error reporring
278  *
279  * command CMD_DATA needs three strings on a line
280  * whereas other commands need only two.
281  *
282  * if more than two/three (as per command type) are observed,
283  * then error will be reported
284  */
285 INVL_CMD:
286         printf ("Error:%s[%d] - Invalid command\n", fname, lineno);
287         exit (EXIT_FAILURE);
288 }
289
290 static void kwbimage_set_header (void *ptr, struct stat *sbuf, int ifd,
291                                 struct mkimage_params *params)
292 {
293         struct kwb_header *hdr = (struct kwb_header *)ptr;
294         bhr_t *mhdr = &hdr->kwb_hdr;
295         extbhr_t *exthdr = &hdr->kwb_exthdr;
296         uint32_t checksum;
297         int size;
298
299         /* Build and add image checksum header */
300         checksum = kwbimage_checksum32 ((uint32_t *)ptr, sbuf->st_size, 0);
301
302         size = write (ifd, &checksum, sizeof(uint32_t));
303         if (size != sizeof(uint32_t)) {
304                 printf ("Error:%s - Checksum write %d bytes %s\n",
305                         params->cmdname, size, params->imagefile);
306                 exit (EXIT_FAILURE);
307         }
308
309         sbuf->st_size += sizeof(uint32_t);
310
311         mhdr->blocksize = sbuf->st_size - sizeof(struct kwb_header);
312         mhdr->srcaddr = sizeof(struct kwb_header);
313         mhdr->destaddr= params->addr;
314         mhdr->execaddr =params->ep;
315         mhdr->ext = 0x1; /* header extension appended */
316
317         kwdimage_set_ext_header (hdr, params->imagename);
318         /* calculate checksums */
319         mhdr->checkSum = kwbimage_checksum8 ((void *)mhdr, sizeof(bhr_t), 0);
320         exthdr->checkSum = kwbimage_checksum8 ((void *)exthdr,
321                                                 sizeof(extbhr_t), 0);
322 }
323
324 static int kwbimage_verify_header (unsigned char *ptr, int image_size,
325                         struct mkimage_params *params)
326 {
327         struct kwb_header *hdr = (struct kwb_header *)ptr;
328         bhr_t *mhdr = &hdr->kwb_hdr;
329         extbhr_t *exthdr = &hdr->kwb_exthdr;
330         uint8_t calc_hdrcsum;
331         uint8_t calc_exthdrcsum;
332
333         calc_hdrcsum = kwbimage_checksum8 ((void *)mhdr,
334                         sizeof(bhr_t) - sizeof(uint8_t), 0);
335         if (calc_hdrcsum != mhdr->checkSum)
336                 return -FDT_ERR_BADSTRUCTURE;   /* mhdr csum not matched */
337
338         calc_exthdrcsum = kwbimage_checksum8 ((void *)exthdr,
339                         sizeof(extbhr_t) - sizeof(uint8_t), 0);
340         if (calc_exthdrcsum != exthdr->checkSum)
341                 return -FDT_ERR_BADSTRUCTURE; /* exthdr csum not matched */
342
343         return 0;
344 }
345
346 static void kwbimage_print_header (const void *ptr)
347 {
348         struct kwb_header *hdr = (struct kwb_header *) ptr;
349         bhr_t *mhdr = &hdr->kwb_hdr;
350         char *name = get_table_entry_name (kwbimage_bootops,
351                                 "Kwbimage boot option",
352                                 (int) mhdr->blockid);
353
354         printf ("Image Type:   Kirkwood Boot from %s Image\n", name);
355         printf ("Data Size:    ");
356         genimg_print_size (mhdr->blocksize - sizeof(uint32_t));
357         printf ("Load Address: %08x\n", mhdr->destaddr);
358         printf ("Entry Point:  %08x\n", mhdr->execaddr);
359 }
360
361 static int kwbimage_check_image_types (uint8_t type)
362 {
363         if (type == IH_TYPE_KWBIMAGE)
364                 return EXIT_SUCCESS;
365         else
366                 return EXIT_FAILURE;
367 }
368
369 /*
370  * kwbimage type parameters definition
371  */
372 static struct image_type_params kwbimage_params = {
373         .name = "Kirkwood Boot Image support",
374         .header_size = sizeof(struct kwb_header),
375         .hdr = (void*)&kwbimage_header,
376         .check_image_type = kwbimage_check_image_types,
377         .verify_header = kwbimage_verify_header,
378         .print_header = kwbimage_print_header,
379         .set_header = kwbimage_set_header,
380         .check_params = kwbimage_check_params,
381 };
382
383 void init_kwb_image_type (void)
384 {
385         mkimage_register (&kwbimage_params);
386 }