src/file/file_srec.c

/*
 *  Copyright (C) 2003-2007  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: file_srec.c,v 1.2 2007/06/17 23:32:20 debug Exp $
 *
 *  COMMENT: SREC file support
 */

/*  Note: Included from file.c.  */


/*
 *  file_load_srec():
 *
 *  Loads a Motorola SREC file into emulated memory. Description of the SREC
 *  file format can be found at here:
 *
 *      http://www.ndsu.nodak.edu/instruct/tareski/373f98/notes/srecord.htm
 *  or  http://www.amelek.gda.pl/avr/uisp/srecord.htm
 */
static void file_load_srec(struct machine *m, struct memory *mem,
        char *filename, uint64_t *entrypointp)
{
        FILE *f;
        unsigned char buf[516];
        unsigned char bytes[270];
        uint64_t entry = 0, vaddr = 0;
        int i, j, count;
        char ch;
        int buf_len, data_start = 0;
        int entry_set = 0;
        int warning = 0;
        int warning_len = 0;
        int total_bytes_loaded = 0;

        f = fopen(filename, "r");
        if (f == NULL) {
                perror(filename);
                exit(1);
        }

        /*  Load file contents:  */
        while (!feof(f)) {
                memset(buf, 0, sizeof(buf));
                fgets((char *)buf, sizeof(buf)-1, f);

                if (buf[0] == 0 || buf[0]=='\r' || buf[0]=='\n')
                        continue;

                if (buf[0] != 'S') {
                        if (!warning)
                                debug("WARNING! non-S-record found\n");
                        warning = 1;
                        continue;
                }

                buf_len = strlen((char *)buf);

                if (buf_len < 10) {
                        if (!warning_len)
                                debug("WARNING! invalid S-record found\n");
                        warning_len = 1;
                        continue;
                }

                /*
                 *  Stype count address data checksum
                 *  01    23    4..     ..   (last 2 bytes)
                 *
                 *  TODO: actually check the checksum
                 */

                j = 0;
                for (i=1; i<buf_len; i++) {
                        if (buf[i]>='a' && buf[i]<='f')
                                buf[i] += 10 - 'a';
                        else if (buf[i] >= 'A' && buf[i] <= 'F')
                                buf[i] += 10 - 'A';
                        else if (buf[i] >= '0' && buf[i] <= '9')
                                buf[i] -= '0';
                        else if (buf[i] == '\r' || buf[i] == '\n') {
                        } else
                                fatal("invalid characters '%c' in S-record\n",
                                    buf[i]);

                        if (i >= 4) {
                                if (i & 1)
                                        bytes[j++] += buf[i];
                                else
                                        bytes[j] = buf[i] * 16;
                        }
                }

                count = buf[2] * 16 + buf[3];
                /*  debug("count=%i j=%i\n", count, j);  */
                /*  count is j - 1.  */

                switch (buf[1]) {
                case 0:
                        debug("SREC \"");
                        for (i=2; i<count-1; i++) {
                                ch = bytes[i];
                                if (ch >= ' ' && ch < 127)
                                        debug("%c", ch);
                                else
                                        debug("?");
                        }
                        debug("\"\n");
                        break;
                case 1:
                case 2:
                case 3:
                        /*  switch again, to get the load address:  */
                        switch (buf[1]) {
                        case 1: data_start = 2;
                                vaddr = (bytes[0] << 8) + bytes[1];
                                break;
                        case 2: data_start = 3;
                                vaddr = (bytes[0] << 16) + (bytes[1] << 8) +
                                    bytes[2];
                                break;
                        case 3: data_start = 4;
                                vaddr = ((uint64_t)bytes[0] << 24) +
                                    (bytes[1] << 16) + (bytes[2]<<8) + bytes[3];
                        }
                        m->cpus[0]->memory_rw(m->cpus[0], mem, vaddr,
                            &bytes[data_start], count - 1 - data_start,
                            MEM_WRITE, NO_EXCEPTIONS);
                        total_bytes_loaded += count - 1 - data_start;
                        break;
                case 7:
                case 8:
                case 9:
                        /*  switch again, to get the entry point:  */
                        switch (buf[1]) {
                        case 7: entry = ((uint64_t)bytes[0] << 24) +
                                    (bytes[1] << 16) + (bytes[2]<<8) + bytes[3];
                                break;
                        case 8: entry = (bytes[0] << 16) + (bytes[1] << 8) +
                                    bytes[2];
                                break;
                        case 9: entry = (bytes[0] << 8) + bytes[1];
                                break;
                        }
                        entry_set = 1;
                        debug("entry point 0x%08x\n", (unsigned int)entry);
                        break;
                default:
                        debug("unimplemented S-record type %i\n", buf[1]);
                }
        }

        debug("0x%x bytes loaded\n", total_bytes_loaded);

        fclose(f);

        if (!entry_set)
                debug("WARNING! no entrypoint found!\n");
        else
                *entrypointp = entry;

        n_executables_loaded ++;
}

1	dpavlin	38	/*
2			* Copyright (C) 2003-2007 Anders Gavare. All rights reserved.
3			*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			*
28	dpavlin	44	* $Id: file_srec.c,v 1.2 2007/06/17 23:32:20 debug Exp $
29	dpavlin	38	*
30	dpavlin	44	* COMMENT: SREC file support
31	dpavlin	38	*/
32
33			/* Note: Included from file.c. */
34
35
36			/*
37			* file_load_srec():
38			*
39			* Loads a Motorola SREC file into emulated memory. Description of the SREC
40			* file format can be found at here:
41			*
42			* http://www.ndsu.nodak.edu/instruct/tareski/373f98/notes/srecord.htm
43			* or http://www.amelek.gda.pl/avr/uisp/srecord.htm
44			*/
45			static void file_load_srec(struct machine m, struct memory mem,
46			char filename, uint64_t entrypointp)
47			{
48			FILE *f;
49			unsigned char buf[516];
50			unsigned char bytes[270];
51			uint64_t entry = 0, vaddr = 0;
52			int i, j, count;
53			char ch;
54			int buf_len, data_start = 0;
55			int entry_set = 0;
56			int warning = 0;
57			int warning_len = 0;
58			int total_bytes_loaded = 0;
59
60			f = fopen(filename, "r");
61			if (f == NULL) {
62			perror(filename);
63			exit(1);
64			}
65
66			/* Load file contents: */
67			while (!feof(f)) {
68			memset(buf, 0, sizeof(buf));
69			fgets((char *)buf, sizeof(buf)-1, f);
70
71			if (buf[0] == 0 \|\| buf[0]=='\r' \|\| buf[0]=='\n')
72			continue;
73
74			if (buf[0] != 'S') {
75			if (!warning)
76			debug("WARNING! non-S-record found\n");
77			warning = 1;
78			continue;
79			}
80
81			buf_len = strlen((char *)buf);
82
83			if (buf_len < 10) {
84			if (!warning_len)
85			debug("WARNING! invalid S-record found\n");
86			warning_len = 1;
87			continue;
88			}
89
90			/*
91			* Stype count address data checksum
92			* 01 23 4.. .. (last 2 bytes)
93			*
94			* TODO: actually check the checksum
95			*/
96
97			j = 0;
98			for (i=1; i<buf_len; i++) {
99			if (buf[i]>='a' && buf[i]<='f')
100			buf[i] += 10 - 'a';
101			else if (buf[i] >= 'A' && buf[i] <= 'F')
102			buf[i] += 10 - 'A';
103			else if (buf[i] >= '0' && buf[i] <= '9')
104			buf[i] -= '0';
105			else if (buf[i] == '\r' \|\| buf[i] == '\n') {
106			} else
107			fatal("invalid characters '%c' in S-record\n",
108			buf[i]);
109
110			if (i >= 4) {
111			if (i & 1)
112			bytes[j++] += buf[i];
113			else
114			bytes[j] = buf[i] * 16;
115			}
116			}
117
118			count = buf[2] * 16 + buf[3];
119			/* debug("count=%i j=%i\n", count, j); */
120			/* count is j - 1. */
121
122			switch (buf[1]) {
123			case 0:
124			debug("SREC \"");
125			for (i=2; i<count-1; i++) {
126			ch = bytes[i];
127			if (ch >= ' ' && ch < 127)
128			debug("%c", ch);
129			else
130			debug("?");
131			}
132			debug("\"\n");
133			break;
134			case 1:
135			case 2:
136			case 3:
137			/* switch again, to get the load address: */
138			switch (buf[1]) {
139			case 1: data_start = 2;
140			vaddr = (bytes[0] << 8) + bytes[1];
141			break;
142			case 2: data_start = 3;
143			vaddr = (bytes[0] << 16) + (bytes[1] << 8) +
144			bytes[2];
145			break;
146			case 3: data_start = 4;
147			vaddr = ((uint64_t)bytes[0] << 24) +
148			(bytes[1] << 16) + (bytes[2]<<8) + bytes[3];
149			}
150			m->cpus[0]->memory_rw(m->cpus[0], mem, vaddr,
151			&bytes[data_start], count - 1 - data_start,
152			MEM_WRITE, NO_EXCEPTIONS);
153			total_bytes_loaded += count - 1 - data_start;
154			break;
155			case 7:
156			case 8:
157			case 9:
158			/* switch again, to get the entry point: */
159			switch (buf[1]) {
160			case 7: entry = ((uint64_t)bytes[0] << 24) +
161			(bytes[1] << 16) + (bytes[2]<<8) + bytes[3];
162			break;
163			case 8: entry = (bytes[0] << 16) + (bytes[1] << 8) +
164			bytes[2];
165			break;
166			case 9: entry = (bytes[0] << 8) + bytes[1];
167			break;
168			}
169			entry_set = 1;
170			debug("entry point 0x%08x\n", (unsigned int)entry);
171			break;
172			default:
173			debug("unimplemented S-record type %i\n", buf[1]);
174			}
175			}
176
177			debug("0x%x bytes loaded\n", total_bytes_loaded);
178
179			fclose(f);
180
181			if (!entry_set)
182			debug("WARNING! no entrypoint found!\n");
183			else
184			*entrypointp = entry;
185
186			n_executables_loaded ++;
187			}
188