xref: /openbmc/u-boot/tools/img2srec.c (revision a380279b) 
1 /*************************************************************************
2 |  COPYRIGHT (c) 2000 BY ABATRON AG
3 |*************************************************************************
4 |
5 |  PROJECT NAME: Linux Image to S-record Conversion Utility
6 |  FILENAME    : img2srec.c
7 |
8 |  COMPILER    : GCC
9 |
10 |  TARGET OS   : LINUX / UNIX
11 |  TARGET HW   : -
12 |
13 |  PROGRAMMER  : Abatron / RD
14 |  CREATION    : 07.07.00
15 |
16 |*************************************************************************
17 |
18 |  DESCRIPTION :
19 |
20 |  Utility to convert a Linux Boot Image to S-record:
21 |  ==================================================
22 |
23 |  This command line utility can be used to convert a Linux boot image
24 |  (zimage.initrd) to S-Record format used for flash programming.
25 |  This conversion takes care of the special sections "IMAGE" and INITRD".
26 |
27 |  img2srec [-o offset] image > image.srec
28 |
29 |
30 |  Build the utility:
31 |  ==================
32 |
33 |  To build the utility use GCC as follows:
34 |
35 |  gcc img2srec.c -o img2srec
36 |
37 |
38 |*************************************************************************
39 |
40 |
41 |  UPDATES     :
42 |
43 |  DATE      NAME  CHANGES
44 |  -----------------------------------------------------------
45 |  Latest update
46 |
47 |  07.07.00  aba   Initial release
48 |
49 |*************************************************************************/
50 
51 /*************************************************************************
52 |  INCLUDES
53 |*************************************************************************/
54 
55 #include "os_support.h"
56 #include <stddef.h>
57 #include <stdio.h>
58 #include <stdlib.h>
59 #include <ctype.h>
60 #include <string.h>
61 #include <elf.h>
62 #include <unistd.h>
63 #include <errno.h>
64 
65 /*************************************************************************
66 |  DEFINES
67 |*************************************************************************/
68 
69 #define FALSE           0
70 #define TRUE            1
71 
72 /*************************************************************************
73 |  MACROS
74 |*************************************************************************/
75 
76 /*************************************************************************
77 |  TYPEDEFS
78 |*************************************************************************/
79 
80 typedef uint8_t   CHAR;
81 typedef uint8_t   BYTE;
82 typedef uint16_t  WORD;
83 typedef uint32_t  DWORD;
84 typedef int       BOOL;
85 
86 /*************************************************************************
87 |  LOCALS
88 |*************************************************************************/
89 
90 /*************************************************************************
91 |  PROTOTYPES
92 |*************************************************************************/
93 
94 static char *ExtractHex(DWORD *value, char *getPtr);
95 static char *ExtractDecimal(DWORD *value, char *getPtr);
96 static void ExtractNumber(DWORD *value, char *getPtr);
97 static BYTE *ExtractWord(WORD *value, BYTE *buffer);
98 static BYTE *ExtractLong(DWORD *value, BYTE *buffer);
99 static BYTE *ExtractBlock(WORD count, BYTE *data, BYTE *buffer);
100 static char *WriteHex(char *pa, BYTE value, WORD *pCheckSum);
101 static char *BuildSRecord(char *pa, WORD sType, DWORD addr,
102 			  const BYTE *data, int nCount);
103 static void ConvertELF(char *fileName, DWORD loadOffset);
104 int main(int argc, char *argv[]);
105 
106 /*************************************************************************
107 |  FUNCTIONS
108 |*************************************************************************/
109 
110 static char* ExtractHex (DWORD* value,  char* getPtr)
111 {
112   DWORD num;
113   DWORD digit;
114   BYTE  c;
115 
116   while (*getPtr == ' ') getPtr++;
117   num = 0;
118   for (;;) {
119     c = *getPtr;
120     if      ((c >= '0') && (c <= '9')) digit = (DWORD)(c - '0');
121     else if ((c >= 'A') && (c <= 'F')) digit = (DWORD)(c - 'A' + 10);
122     else if ((c >= 'a') && (c <= 'f')) digit = (DWORD)(c - 'a' + 10);
123     else break;
124     num <<= 4;
125     num += digit;
126     getPtr++;
127   } /* for */
128   *value = num;
129   return getPtr;
130 } /* ExtractHex */
131 
132 static char* ExtractDecimal (DWORD* value,  char* getPtr)
133 {
134   DWORD num;
135   DWORD digit;
136   BYTE  c;
137 
138   while (*getPtr == ' ') getPtr++;
139   num = 0;
140   for (;;) {
141     c = *getPtr;
142     if      ((c >= '0') && (c <= '9')) digit = (DWORD)(c - '0');
143     else break;
144     num *= 10;
145     num += digit;
146     getPtr++;
147   } /* for */
148   *value = num;
149   return getPtr;
150 } /* ExtractDecimal */
151 
152 
153 static void ExtractNumber (DWORD* value,  char* getPtr)
154 {
155   BOOL  neg = FALSE;;
156 
157   while (*getPtr == ' ') getPtr++;
158   if (*getPtr == '-') {
159     neg = TRUE;
160     getPtr++;
161   } /* if */
162   if ((*getPtr == '0') && ((*(getPtr+1) == 'x') || (*(getPtr+1) == 'X'))) {
163     getPtr +=2;
164     (void)ExtractHex(value, getPtr);
165   } /* if */
166   else {
167     (void)ExtractDecimal(value, getPtr);
168   } /* else */
169   if (neg) *value = -(*value);
170 } /* ExtractNumber */
171 
172 
173 static BYTE* ExtractWord(WORD* value, BYTE* buffer)
174 {
175   WORD x;
176   x = (WORD)*buffer++;
177   x = (x<<8) + (WORD)*buffer++;
178   *value = x;
179   return buffer;
180 } /* ExtractWord */
181 
182 
183 static BYTE* ExtractLong(DWORD* value, BYTE* buffer)
184 {
185   DWORD x;
186   x = (DWORD)*buffer++;
187   x = (x<<8) + (DWORD)*buffer++;
188   x = (x<<8) + (DWORD)*buffer++;
189   x = (x<<8) + (DWORD)*buffer++;
190   *value = x;
191   return buffer;
192 } /* ExtractLong */
193 
194 
195 static BYTE* ExtractBlock(WORD count, BYTE* data, BYTE* buffer)
196 {
197   while (count--) *data++ = *buffer++;
198   return buffer;
199 } /* ExtractBlock */
200 
201 
202 static char* WriteHex(char* pa, BYTE value, WORD* pCheckSum)
203 {
204   WORD  temp;
205 
206   static  char ByteToHex[] = "0123456789ABCDEF";
207 
208   *pCheckSum += value;
209   temp  = value / 16;
210   *pa++ = ByteToHex[temp];
211   temp  = value % 16;
212   *pa++ = ByteToHex[temp];
213   return pa;
214 }
215 
216 
217 static char* BuildSRecord(char* pa, WORD sType, DWORD addr,
218 			  const BYTE* data, int nCount)
219 {
220   WORD  addrLen;
221   WORD  sRLen;
222   WORD  checkSum;
223   WORD  i;
224 
225   switch (sType) {
226   case 0:
227   case 1:
228   case 9:
229     addrLen = 2;
230     break;
231   case 2:
232   case 8:
233     addrLen = 3;
234     break;
235   case 3:
236   case 7:
237     addrLen = 4;
238     break;
239   default:
240     return pa;
241   } /* switch */
242 
243   *pa++ = 'S';
244   *pa++ = (char)(sType + '0');
245   sRLen = addrLen + nCount + 1;
246   checkSum = 0;
247   pa = WriteHex(pa, (BYTE)sRLen, &checkSum);
248 
249   /* Write address field */
250   for (i = 1; i <= addrLen; i++) {
251     pa = WriteHex(pa, (BYTE)(addr >> (8 * (addrLen - i))), &checkSum);
252   } /* for */
253 
254   /* Write code/data fields */
255   for (i = 0; i < nCount; i++) {
256     pa = WriteHex(pa, *data++, &checkSum);
257   } /* for */
258 
259   /* Write checksum field */
260   checkSum = ~checkSum;
261   pa = WriteHex(pa, (BYTE)checkSum, &checkSum);
262   *pa++ = '\0';
263   return pa;
264 }
265 
266 
267 static void ConvertELF(char* fileName, DWORD loadOffset)
268 {
269   FILE*         file;
270   int           i;
271   int           rxCount;
272   BYTE          rxBlock[1024];
273   DWORD         loadSize;
274   DWORD         firstAddr;
275   DWORD         loadAddr;
276   DWORD         loadDiff = 0;
277   Elf32_Ehdr    elfHeader;
278   Elf32_Shdr    sectHeader[32];
279   BYTE*         getPtr;
280   char          srecLine[128];
281   char		*hdr_name;
282 
283 
284   /* open file */
285   if ((file = fopen(fileName,"rb")) == NULL) {
286     fprintf (stderr, "Can't open %s: %s\n", fileName, strerror(errno));
287     return;
288   } /* if */
289 
290   /* read ELF header */
291   rxCount = fread(rxBlock, 1, sizeof elfHeader, file);
292   getPtr = ExtractBlock(sizeof elfHeader.e_ident, elfHeader.e_ident, rxBlock);
293   getPtr = ExtractWord(&elfHeader.e_type, getPtr);
294   getPtr = ExtractWord(&elfHeader.e_machine, getPtr);
295   getPtr = ExtractLong((DWORD *)&elfHeader.e_version, getPtr);
296   getPtr = ExtractLong((DWORD *)&elfHeader.e_entry, getPtr);
297   getPtr = ExtractLong((DWORD *)&elfHeader.e_phoff, getPtr);
298   getPtr = ExtractLong((DWORD *)&elfHeader.e_shoff, getPtr);
299   getPtr = ExtractLong((DWORD *)&elfHeader.e_flags, getPtr);
300   getPtr = ExtractWord(&elfHeader.e_ehsize, getPtr);
301   getPtr = ExtractWord(&elfHeader.e_phentsize, getPtr);
302   getPtr = ExtractWord(&elfHeader.e_phnum, getPtr);
303   getPtr = ExtractWord(&elfHeader.e_shentsize, getPtr);
304   getPtr = ExtractWord(&elfHeader.e_shnum, getPtr);
305   getPtr = ExtractWord(&elfHeader.e_shstrndx, getPtr);
306   if (    (rxCount              != sizeof elfHeader)
307        || (elfHeader.e_ident[0] != ELFMAG0)
308        || (elfHeader.e_ident[1] != ELFMAG1)
309        || (elfHeader.e_ident[2] != ELFMAG2)
310        || (elfHeader.e_ident[3] != ELFMAG3)
311        || (elfHeader.e_type     != ET_EXEC)
312      ) {
313     fclose(file);
314     fprintf (stderr, "*** illegal file format\n");
315     return;
316   } /* if */
317 
318   /* read all section headers */
319   fseek(file, elfHeader.e_shoff, SEEK_SET);
320   for (i = 0; i < elfHeader.e_shnum; i++) {
321     rxCount = fread(rxBlock, 1, sizeof sectHeader[0], file);
322     getPtr = ExtractLong((DWORD *)&sectHeader[i].sh_name, rxBlock);
323     getPtr = ExtractLong((DWORD *)&sectHeader[i].sh_type, getPtr);
324     getPtr = ExtractLong((DWORD *)&sectHeader[i].sh_flags, getPtr);
325     getPtr = ExtractLong((DWORD *)&sectHeader[i].sh_addr, getPtr);
326     getPtr = ExtractLong((DWORD *)&sectHeader[i].sh_offset, getPtr);
327     getPtr = ExtractLong((DWORD *)&sectHeader[i].sh_size, getPtr);
328     getPtr = ExtractLong((DWORD *)&sectHeader[i].sh_link, getPtr);
329     getPtr = ExtractLong((DWORD *)&sectHeader[i].sh_info, getPtr);
330     getPtr = ExtractLong((DWORD *)&sectHeader[i].sh_addralign, getPtr);
331     getPtr = ExtractLong((DWORD *)&sectHeader[i].sh_entsize, getPtr);
332     if (rxCount != sizeof sectHeader[0]) {
333       fclose(file);
334       fprintf (stderr, "*** illegal file format\n");
335       return;
336     } /* if */
337   } /* for */
338 
339   if ((hdr_name = strrchr(fileName, '/')) == NULL) {
340     hdr_name = fileName;
341   } else {
342     ++hdr_name;
343   }
344   /* write start record */
345   (void)BuildSRecord(srecLine, 0, 0, (BYTE *)hdr_name, strlen(hdr_name));
346   printf("%s\r\n",srecLine);
347 
348   /* write data records */
349   firstAddr = ~0;
350   loadAddr  =  0;
351   for (i = 0; i < elfHeader.e_shnum; i++) {
352     if (    (sectHeader[i].sh_type == SHT_PROGBITS)
353 	 && (sectHeader[i].sh_size != 0)
354 	 ) {
355       loadSize = sectHeader[i].sh_size;
356       if (sectHeader[i].sh_flags != 0) {
357 	loadAddr = sectHeader[i].sh_addr;
358 	loadDiff = loadAddr - sectHeader[i].sh_offset;
359       } /* if */
360       else {
361 	loadAddr = sectHeader[i].sh_offset + loadDiff;
362       } /* else */
363 
364       if (loadAddr < firstAddr)
365 	firstAddr = loadAddr;
366 
367       /* build s-records */
368       loadSize = sectHeader[i].sh_size;
369       fseek(file, sectHeader[i].sh_offset, SEEK_SET);
370       while (loadSize) {
371 	rxCount = fread(rxBlock, 1, (loadSize > 32) ? 32 : loadSize, file);
372 	if (rxCount < 0) {
373 	  fclose(file);
374 	  fprintf (stderr, "*** illegal file format\n");
375 	return;
376 	} /* if */
377 	(void)BuildSRecord(srecLine, 3, loadAddr + loadOffset, rxBlock, rxCount);
378 	loadSize -= rxCount;
379 	loadAddr += rxCount;
380 	printf("%s\r\n",srecLine);
381       } /* while */
382     } /* if */
383   } /* for */
384 
385   /* add end record */
386   (void)BuildSRecord(srecLine, 7, firstAddr + loadOffset, 0, 0);
387   printf("%s\r\n",srecLine);
388   fclose(file);
389 } /* ConvertELF */
390 
391 
392 /*************************************************************************
393 |  MAIN
394 |*************************************************************************/
395 
396 int main( int argc, char *argv[ ])
397 {
398   DWORD offset;
399 
400   if (argc == 2) {
401     ConvertELF(argv[1], 0);
402   } /* if */
403   else if ((argc == 4) && (strcmp(argv[1], "-o") == 0)) {
404     ExtractNumber(&offset, argv[2]);
405     ConvertELF(argv[3], offset);
406   } /* if */
407   else {
408     fprintf (stderr, "Usage: img2srec [-o offset] <image>\n");
409   } /* if */
410 
411   return 0;
412 } /* main */
413