summaryrefslogtreecommitdiff
path: root/flash/make_firmware/make_firmware.c
diff options
context:
space:
mode:
Diffstat (limited to 'flash/make_firmware/make_firmware.c')
-rw-r--r--flash/make_firmware/make_firmware.c359
1 files changed, 0 insertions, 359 deletions
diff --git a/flash/make_firmware/make_firmware.c b/flash/make_firmware/make_firmware.c
deleted file mode 100644
index bd838bf3bf..0000000000
--- a/flash/make_firmware/make_firmware.c
+++ /dev/null
@@ -1,359 +0,0 @@
1/***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2003 by Jörg Hohensohn
11 *
12 * Autoring tool for the firmware image to be programmed into Flash ROM
13 * It composes the flash content with header, bootloader and image(s)
14 *
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version 2
18 * of the License, or (at your option) any later version.
19 *
20 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
21 * KIND, either express or implied.
22 *
23 ****************************************************************************/
24
25
26#include <stdio.h>
27#include <stdlib.h>
28#include <inttypes.h>
29#include <string.h>
30
31#define UINT8 unsigned char
32#define UINT16 unsigned short
33#define UINT32 unsigned long
34#define BOOL int
35#define TRUE 1
36#define FALSE 0
37
38// size of one flash sector, the granularity with which it can be erased
39#define SECTORSIZE 4096
40
41#define BOOTLOAD_DEST 0x0FFFF500 // for the "normal" one
42#define FLASH_START 0x02000000
43#define BOOTLOAD_SCR 0x02000100
44#define ROCKBOX_DEST 0x09000000
45#define ROCKBOX_EXEC 0x09000200
46
47
48// place a 32 bit value into memory, big endian
49void Write32(UINT8* pByte, UINT32 value)
50{
51 pByte[0] = (UINT8)(value >> 24);
52 pByte[1] = (UINT8)(value >> 16);
53 pByte[2] = (UINT8)(value >> 8);
54 pByte[3] = (UINT8)(value);
55}
56
57
58// read a 32 bit value from memory, big endian
59UINT32 Read32(UINT8* pByte)
60{
61 UINT32 value = 0;
62
63 value |= (UINT32)pByte[0] << 24;
64 value |= (UINT32)pByte[1] << 16;
65 value |= (UINT32)pByte[2] << 8;
66 value |= (UINT32)pByte[3];
67
68 return value;
69}
70
71
72static UINT32 CalcCRC32 (const UINT8* buf, UINT32 len)
73{
74 static const UINT32 crc_table[256] =
75 { // CRC32 lookup table for polynomial 0x04C11DB7
76 0x00000000, 0x04C11DB7, 0x09823B6E, 0x0D4326D9, 0x130476DC, 0x17C56B6B,
77 0x1A864DB2, 0x1E475005, 0x2608EDB8, 0x22C9F00F, 0x2F8AD6D6, 0x2B4BCB61,
78 0x350C9B64, 0x31CD86D3, 0x3C8EA00A, 0x384FBDBD, 0x4C11DB70, 0x48D0C6C7,
79 0x4593E01E, 0x4152FDA9, 0x5F15ADAC, 0x5BD4B01B, 0x569796C2, 0x52568B75,
80 0x6A1936C8, 0x6ED82B7F, 0x639B0DA6, 0x675A1011, 0x791D4014, 0x7DDC5DA3,
81 0x709F7B7A, 0x745E66CD, 0x9823B6E0, 0x9CE2AB57, 0x91A18D8E, 0x95609039,
82 0x8B27C03C, 0x8FE6DD8B, 0x82A5FB52, 0x8664E6E5, 0xBE2B5B58, 0xBAEA46EF,
83 0xB7A96036, 0xB3687D81, 0xAD2F2D84, 0xA9EE3033, 0xA4AD16EA, 0xA06C0B5D,
84 0xD4326D90, 0xD0F37027, 0xDDB056FE, 0xD9714B49, 0xC7361B4C, 0xC3F706FB,
85 0xCEB42022, 0xCA753D95, 0xF23A8028, 0xF6FB9D9F, 0xFBB8BB46, 0xFF79A6F1,
86 0xE13EF6F4, 0xE5FFEB43, 0xE8BCCD9A, 0xEC7DD02D, 0x34867077, 0x30476DC0,
87 0x3D044B19, 0x39C556AE, 0x278206AB, 0x23431B1C, 0x2E003DC5, 0x2AC12072,
88 0x128E9DCF, 0x164F8078, 0x1B0CA6A1, 0x1FCDBB16, 0x018AEB13, 0x054BF6A4,
89 0x0808D07D, 0x0CC9CDCA, 0x7897AB07, 0x7C56B6B0, 0x71159069, 0x75D48DDE,
90 0x6B93DDDB, 0x6F52C06C, 0x6211E6B5, 0x66D0FB02, 0x5E9F46BF, 0x5A5E5B08,
91 0x571D7DD1, 0x53DC6066, 0x4D9B3063, 0x495A2DD4, 0x44190B0D, 0x40D816BA,
92 0xACA5C697, 0xA864DB20, 0xA527FDF9, 0xA1E6E04E, 0xBFA1B04B, 0xBB60ADFC,
93 0xB6238B25, 0xB2E29692, 0x8AAD2B2F, 0x8E6C3698, 0x832F1041, 0x87EE0DF6,
94 0x99A95DF3, 0x9D684044, 0x902B669D, 0x94EA7B2A, 0xE0B41DE7, 0xE4750050,
95 0xE9362689, 0xEDF73B3E, 0xF3B06B3B, 0xF771768C, 0xFA325055, 0xFEF34DE2,
96 0xC6BCF05F, 0xC27DEDE8, 0xCF3ECB31, 0xCBFFD686, 0xD5B88683, 0xD1799B34,
97 0xDC3ABDED, 0xD8FBA05A, 0x690CE0EE, 0x6DCDFD59, 0x608EDB80, 0x644FC637,
98 0x7A089632, 0x7EC98B85, 0x738AAD5C, 0x774BB0EB, 0x4F040D56, 0x4BC510E1,
99 0x46863638, 0x42472B8F, 0x5C007B8A, 0x58C1663D, 0x558240E4, 0x51435D53,
100 0x251D3B9E, 0x21DC2629, 0x2C9F00F0, 0x285E1D47, 0x36194D42, 0x32D850F5,
101 0x3F9B762C, 0x3B5A6B9B, 0x0315D626, 0x07D4CB91, 0x0A97ED48, 0x0E56F0FF,
102 0x1011A0FA, 0x14D0BD4D, 0x19939B94, 0x1D528623, 0xF12F560E, 0xF5EE4BB9,
103 0xF8AD6D60, 0xFC6C70D7, 0xE22B20D2, 0xE6EA3D65, 0xEBA91BBC, 0xEF68060B,
104 0xD727BBB6, 0xD3E6A601, 0xDEA580D8, 0xDA649D6F, 0xC423CD6A, 0xC0E2D0DD,
105 0xCDA1F604, 0xC960EBB3, 0xBD3E8D7E, 0xB9FF90C9, 0xB4BCB610, 0xB07DABA7,
106 0xAE3AFBA2, 0xAAFBE615, 0xA7B8C0CC, 0xA379DD7B, 0x9B3660C6, 0x9FF77D71,
107 0x92B45BA8, 0x9675461F, 0x8832161A, 0x8CF30BAD, 0x81B02D74, 0x857130C3,
108 0x5D8A9099, 0x594B8D2E, 0x5408ABF7, 0x50C9B640, 0x4E8EE645, 0x4A4FFBF2,
109 0x470CDD2B, 0x43CDC09C, 0x7B827D21, 0x7F436096, 0x7200464F, 0x76C15BF8,
110 0x68860BFD, 0x6C47164A, 0x61043093, 0x65C52D24, 0x119B4BE9, 0x155A565E,
111 0x18197087, 0x1CD86D30, 0x029F3D35, 0x065E2082, 0x0B1D065B, 0x0FDC1BEC,
112 0x3793A651, 0x3352BBE6, 0x3E119D3F, 0x3AD08088, 0x2497D08D, 0x2056CD3A,
113 0x2D15EBE3, 0x29D4F654, 0xC5A92679, 0xC1683BCE, 0xCC2B1D17, 0xC8EA00A0,
114 0xD6AD50A5, 0xD26C4D12, 0xDF2F6BCB, 0xDBEE767C, 0xE3A1CBC1, 0xE760D676,
115 0xEA23F0AF, 0xEEE2ED18, 0xF0A5BD1D, 0xF464A0AA, 0xF9278673, 0xFDE69BC4,
116 0x89B8FD09, 0x8D79E0BE, 0x803AC667, 0x84FBDBD0, 0x9ABC8BD5, 0x9E7D9662,
117 0x933EB0BB, 0x97FFAD0C, 0xAFB010B1, 0xAB710D06, 0xA6322BDF, 0xA2F33668,
118 0xBCB4666D, 0xB8757BDA, 0xB5365D03, 0xB1F740B4
119 };
120 UINT32 i;
121 UINT32 crc = 0xffffffff;
122
123 for (i = 0; i < len; i++)
124 crc = (crc << 8) ^ crc_table[((crc >> 24) ^ *buf++) & 0xFF];
125
126 return crc;
127}
128
129
130static UINT32 PlaceImage(char* filename, UINT32 pos, UINT8* pFirmware, UINT32 limit)
131{
132 UINT32 size, read;
133 FILE* pFile;
134 UINT32 align;
135 UINT32 flags;
136 UINT32 load_addr = ROCKBOX_DEST, exec_addr = ROCKBOX_EXEC; // defaults
137
138 // magic file header for compressed files
139 static const UINT8 magic[8] = { 0x00,0xe9,0x55,0x43,0x4c,0xff,0x01,0x1a };
140 UINT8 ucl_header[26];
141
142 pFile = fopen(filename, "rb"); // open the current image
143 if (pFile == NULL)
144 {
145 printf("Image file %s not found!\n", filename);
146 exit(5);
147 }
148
149 fseek(pFile, 0, SEEK_END);
150 size = ftell(pFile);
151 fseek(pFile, 0, SEEK_SET);
152
153 // determine if compressed
154 flags = 0x00000000; // default: flags for uncompressed
155 fread(ucl_header, 1, sizeof(ucl_header), pFile);
156 if (memcmp(magic, ucl_header, sizeof(magic)) == 0)
157 {
158 if (ucl_header[12] != 0x2E // check algorithm
159 && ucl_header[12] != 0x2B) // or uncompressed
160 {
161 printf("UCL compressed files must use algorithm 2e, not %d\n", ucl_header[12]);
162 printf("Generate with: uclpack --best --2e rockbox.bin %s\n", filename);
163 exit(6);
164 }
165
166 size = Read32(ucl_header + 22); // compressed size
167 if (Read32(ucl_header + 18) > size) // compare with uncompressed size
168 { // normal case
169 flags = 0x00000001; // flags for UCL compressed
170 }
171
172 if (ucl_header[12] == 0x2B) // uncompressed means "ROMbox", for direct flash execution
173 {
174 UINT8 start_addr[4];
175 UINT8 reset_vec[4];
176 fread(start_addr, 1, sizeof(start_addr), pFile); // read the link address from image
177 fread(reset_vec, 1, sizeof(reset_vec), pFile); // read the reset vector from image
178 fseek(pFile, 0-sizeof(start_addr)-sizeof(reset_vec), SEEK_CUR); // wind back
179 load_addr = Read32(start_addr);
180 if (load_addr != FLASH_START + pos + 16) // behind 16 byte header
181 {
182 printf("Error: Rombox .ucl file is linked to 0x%08X instead of 0x%08X\n", load_addr, FLASH_START + pos + 16);
183 exit(11);
184 }
185 exec_addr = Read32(reset_vec);
186 }
187 }
188 else
189 {
190 fseek(pFile, 0, SEEK_SET); // go back
191 }
192
193 if (pos + 16 + size > limit) // enough space for all that?
194 {
195 printf("Exceeding maximum image size %d\n", limit);
196 exit(7);
197 }
198
199 // write header
200 align = (pos + 16 + size + SECTORSIZE-1) & ~(SECTORSIZE-1); // round up to next flash sector
201 Write32(pFirmware + pos, load_addr); // load address
202 Write32(pFirmware + pos + 4, align - (pos + 16)); // image size
203 Write32(pFirmware + pos + 8, exec_addr); // execution address
204 Write32(pFirmware + pos + 12, flags); // compressed or not
205 pos += 16;
206
207 // load image
208 read = fread(pFirmware + pos, 1, size, pFile);
209 if (read != size)
210 {
211 printf("Read error, expecting %d bytes, got only %d\n", size, read);
212 exit(8);
213 }
214 fclose (pFile);
215
216 pos += size;
217
218 return pos;
219}
220
221
222int main(int argc, char* argv[])
223{
224 static UINT8 aFirmware[512*1024]; // maximum with exchanged chip
225 FILE* pFile;
226 UINT32 size; // size of loaded item
227 UINT32 pos; // current position in firmware
228 UINT32 crc32; // checksum of "payload"
229 BOOL hasBootRom; // flag if regular boot ROM or directly starts from flash
230 UINT32 template_F8, template_FC; // my platform ID, mask and version
231
232 int i;
233
234 if (argc <= 4)
235 {
236 printf("Usage:\n");
237 printf("make_firmware <output> <template.bin> <bootloader.ajz> <image1.ucl> {image2.ucl}\n");
238 printf("<template.bin> is the original firmware from your box\n");
239 printf("<bootloader.ajz> is the scrambled bootloader\n");
240 printf("<image1.ucl> is the first image, compressed (recommended) or uncompressed\n");
241 printf("<image1.ucl> is the second image, compressed (recommended) or uncompressed\n");
242 printf("More images may follow, but keep the flash size in mind!\n");
243 printf("Compression must be UCL, algorithm 2e.\n");
244 printf("Generated with: uclpack --best --2e rockbox.bin imageN.ucl\n");
245 exit(0);
246 }
247
248 memset(aFirmware, 0xFF, sizeof(aFirmware));
249
250 /******* process template *******/
251
252 pFile = fopen(argv[2], "rb"); // open the template
253 if (pFile == NULL)
254 {
255 printf("Template file %s not found!\n", argv[2]);
256 exit(1);
257 }
258 size = fread(aFirmware, 1, 256, pFile); // need only the header
259 fclose(pFile);
260 if (size < 256) // need at least the firmware header
261 {
262 printf("Template file %s too small, need at least the header!\n", argv[2]);
263 exit(2);
264 }
265
266 if (strncmp(aFirmware, "ARCH", 4) == 0)
267 {
268 hasBootRom = TRUE;
269 pos = 256; // place bootloader after this "boot block"
270 }
271 else if (Read32(aFirmware) == 0x0200)
272 {
273 hasBootRom = FALSE;
274 pos = 0; // directly start with the bootloader
275 template_F8 = Read32(aFirmware + 0xF8); // my platform ID and future info
276 template_FC = Read32(aFirmware + 0xFC); // use mask+version from template
277 }
278 else
279 {
280 printf("Template file %s invalid!\n", argv[2]);
281 exit(3);
282 }
283
284 /******* process bootloader *******/
285
286 pFile = fopen(argv[3], "rb"); // open the bootloader
287 if (pFile == NULL)
288 {
289 printf("Bootloader file %s not found!\n", argv[3]);
290 exit(4);
291 }
292 if (hasBootRom && fseek(pFile, 6, SEEK_SET)) // skip the ajz header
293 {
294 printf("Bootloader file %s too short!\n", argv[3]);
295 exit(5);
296 }
297
298 // place bootloader after header
299 size = fread(aFirmware + pos, 1, sizeof(aFirmware) - pos, pFile);
300 fclose(pFile);
301
302 if (hasBootRom)
303 {
304 Write32(aFirmware + 4, BOOTLOAD_DEST); // boot code destination address
305
306 for (i=0x08; i<=0x28; i+=8)
307 {
308 Write32(aFirmware + i, BOOTLOAD_SCR); // boot code source address
309 Write32(aFirmware + i + 4, size); // boot code size
310 }
311 }
312 else
313 {
314 Write32(aFirmware + 0xF8, template_F8); // values from template
315 Write32(aFirmware + 0xFC, template_FC); // mask and version
316 }
317
318 size = (size + 3) & ~3; // make shure it's 32 bit aligned
319 pos += size; // prepare position for first image
320
321 /******* process images *******/
322 for (i = 4; i < argc; i++)
323 {
324 pos = PlaceImage(argv[i], pos, aFirmware, sizeof(aFirmware));
325
326 if (i < argc-1)
327 { // not the last: round up to next flash sector
328 pos = (pos + SECTORSIZE-1) & ~(SECTORSIZE-1);
329 }
330 }
331
332
333 /******* append CRC32 checksum *******/
334 crc32 = CalcCRC32(aFirmware, pos);
335 Write32(aFirmware + pos, crc32);
336 pos += sizeof(crc32); // 4 bytes
337
338
339 /******* save result to output file *******/
340
341 pFile = fopen(argv[1], "wb"); // open the output file
342 if (pFile == NULL)
343 {
344 printf("Output file %s cannot be created!\n", argv[1]);
345 exit(9);
346 }
347 size = fwrite(aFirmware, 1, pos, pFile);
348 fclose(pFile);
349
350 if (size != pos)
351 {
352 printf("Error writing %d bytes to output file %s!\n", pos, argv[1]);
353 exit(10);
354 }
355
356 printf("Firmware file generated with %d bytes.\n", pos);
357
358 return 0;
359}
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-12 18:01:45 +0000