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.1 2007/04/10 16:33:44 debug Exp $
 *
 *  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	/*
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	* $Id: file_srec.c,v 1.1 2007/04/10 16:33:44 debug Exp $
29	*
30	* SREC file support.
31	*/
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