[u-boot.git] / common / s_record.c

/*
 * (C) Copyright 2000
 * Wolfgang Denk, DENX Software Engineering, [email protected].
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

#include <common.h>
#include <s_record.h>

static int hex1_bin (char  c);
static int hex2_bin (char *s);

int srec_decode (char *input, int *count, ulong *addr, char *data)
{
	int	i;
	int	v;				/* conversion buffer	*/
	int	srec_type;			/* S-Record type	*/
	unsigned char chksum;			/* buffer for checksum	*/

	chksum = 0;

	/* skip anything before 'S', and the 'S' itself.
	 * Return error if not found
	 */

	for (; *input; ++input) {
		if (*input == 'S') {		/* skip 'S' */
			++input;
			break;
		}
	}
	if (*input == '\0') {			/* no more data?	*/
		return (SREC_EMPTY);
	}

	v = *input++;				/* record type		*/

	if ((*count = hex2_bin(input)) < 0) {
		return (SREC_E_NOSREC);
	}

	chksum += *count;
	input  += 2;

	switch (v) {				/* record type		*/

	case '0':				/* start record		*/
		srec_type = SREC_START;		/* 2 byte addr field	*/
		*count   -= 3;			/* - checksum and addr	*/
		break;
	case '1':
		srec_type = SREC_DATA2;		/* 2 byte addr field	*/
		*count   -= 3;			/* - checksum and addr	*/
		break;
	case '2':
		srec_type = SREC_DATA3;		/* 3 byte addr field	*/
		*count   -= 4;			/* - checksum and addr	*/
		break;
	case '3':				/* data record with a	*/
		srec_type = SREC_DATA4;		/* 4 byte addr field	*/
		*count   -= 5;			/* - checksum and addr	*/
		break;
/***	case '4'  ***/
	case '5':			/* count record, addr field contains */
		srec_type = SREC_COUNT;	/* a 2 byte record counter	*/
		*count    = 0;			/* no data		*/
		break;
/***	case '6' -- not used  ***/
	case '7':				/* end record with a	*/
		srec_type = SREC_END4;		/* 4 byte addr field	*/
		*count   -= 5;			/* - checksum and addr	*/
		break;
	case '8':				/* end record with a	*/
		srec_type = SREC_END3;		/* 3 byte addr field	*/
		*count   -= 4;			/* - checksum and addr	*/
		break;
	case '9':				/* end record with a	*/
		srec_type = SREC_END2;		/* 2 byte addr field	*/
		*count   -= 3;			/* - checksum and addr	*/
		break;
	default:
		return (SREC_E_BADTYPE);
	}

	/* read address field */
	*addr = 0;

	switch (v) {
	case '3':				/* 4 byte addr field	*/
	case '7':
		if ((v = hex2_bin(input)) < 0) {
			return (SREC_E_NOSREC);
		}
		*addr  += v;
		chksum += v;
		input  += 2;
		/* FALL THRU */
	case '2':				/* 3 byte addr field	*/
	case '8':
		if ((v = hex2_bin(input)) < 0) {
			return (SREC_E_NOSREC);
		}
		*addr <<= 8;
		*addr  += v;
		chksum += v;
		input  += 2;
		/* FALL THRU */
	case '0':				/* 2 byte addr field	*/
	case '1':
	case '5':
	case '9':
		if ((v = hex2_bin(input)) < 0) {
			return (SREC_E_NOSREC);
		}
		*addr <<= 8;
		*addr  += v;
		chksum += v;
		input  += 2;

		if ((v = hex2_bin(input)) < 0) {
			return (SREC_E_NOSREC);
		}
		*addr <<= 8;
		*addr  += v;
		chksum += v;
		input  += 2;

		break;
	default:
		return (SREC_E_BADTYPE);
	}

	/* convert data and calculate checksum */
	for (i=0; i < *count; ++i) {
		if ((v = hex2_bin(input)) < 0) {
			return (SREC_E_NOSREC);
		}
		data[i] = v;
		chksum += v;
		input  += 2;
	}

	/* read anc check checksum */
	if ((v = hex2_bin(input)) < 0) {
		return (SREC_E_NOSREC);
	}

	if ((unsigned char)v != (unsigned char)~chksum) {
		return (SREC_E_BADCHKS);
	}

	return (srec_type);
}

static int hex1_bin (char c)
{
	if (c >= '0' && c <= '9')
		return (c - '0');
	if (c >= 'a' && c <= 'f')
		return (c + 10 - 'a');
	if (c >= 'A' && c <= 'F')
		return (c + 10 - 'A');
	return (-1);
}

static int hex2_bin (char *s)
{
	int i, j;

	if ((i = hex1_bin(*s++)) < 0) {
		return (-1);
	}
	if ((j = hex1_bin(*s)) < 0) {
		return (-1);
	}

	return ((i<<4) + j);
}
Commit	Line	Data
affae2bf WD	1	/*
	2	* (C) Copyright 2000
	3	* Wolfgang Denk, DENX Software Engineering, [email protected].
	4	*
	5	* See file CREDITS for list of people who contributed to this
	6	* project.
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License as
	10	* published by the Free Software Foundation; either version 2 of
	11	* the License, or (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	21	* MA 02111-1307 USA
	22	*/
	23
	24	#include <common.h>
	25	#include <s_record.h>
	26
	27	static int hex1_bin (char c);
	28	static int hex2_bin (char *s);
	29
	30	int srec_decode (char input, int count, ulong addr, char data)
	31	{
	32	int i;
	33	int v; /* conversion buffer */
	34	int srec_type; /* S-Record type */
	35	unsigned char chksum; /* buffer for checksum */
	36
	37	chksum = 0;
	38
	39	/* skip anything before 'S', and the 'S' itself.
	40	* Return error if not found
	41	*/
	42
	43	for (; *input; ++input) {
	44	if (input == 'S') { / skip 'S' */
	45	++input;
	46	break;
	47	}
	48	}
	49	if (input == '\0') { / no more data? */
	50	return (SREC_EMPTY);
	51	}
	52
	53	v = input++; / record type */
	54
	55	if ((*count = hex2_bin(input)) < 0) {
	56	return (SREC_E_NOSREC);
	57	}
	58
	59	chksum += *count;
	60	input += 2;
	61
	62	switch (v) { /* record type */
	63
	64	case '0': /* start record */
65	srec_type = SREC_START; /* 2 byte addr field */
66	count -= 3; / - checksum and addr */
67	break;
68	case '1':
69	srec_type = SREC_DATA2; /* 2 byte addr field */
70	count -= 3; / - checksum and addr */
71	break;
72	case '2':
73	srec_type = SREC_DATA3; /* 3 byte addr field */
74	count -= 4; / - checksum and addr */
75	break;
76	case '3': /* data record with a */
77	srec_type = SREC_DATA4; /* 4 byte addr field */
78	count -= 5; / - checksum and addr */
79	break;
80	/* case '4' */
81	case '5': /* count record, addr field contains */
82	srec_type = SREC_COUNT; /* a 2 byte record counter */
83	count = 0; / no data */
84	break;
85	/* case '6' -- not used */
86	case '7': /* end record with a */
87	srec_type = SREC_END4; /* 4 byte addr field */
88	count -= 5; / - checksum and addr */
89	break;
90	case '8': /* end record with a */
91	srec_type = SREC_END3; /* 3 byte addr field */
92	count -= 4; / - checksum and addr */
93	break;
94	case '9': /* end record with a */
95	srec_type = SREC_END2; /* 2 byte addr field */
96	count -= 3; / - checksum and addr */
97	break;
98	default:
99	return (SREC_E_BADTYPE);
100	}
101
102	/* read address field */
103	*addr = 0;
104
105	switch (v) {
106	case '3': /* 4 byte addr field */
107	case '7':
108	if ((v = hex2_bin(input)) < 0) {
109	return (SREC_E_NOSREC);
110	}
111	*addr += v;
112	chksum += v;
113	input += 2;
114	/* FALL THRU */
115	case '2': /* 3 byte addr field */
116	case '8':
117	if ((v = hex2_bin(input)) < 0) {
118	return (SREC_E_NOSREC);
119	}
120	*addr <<= 8;
121	*addr += v;
122	chksum += v;
123	input += 2;
124	/* FALL THRU */
125	case '0': /* 2 byte addr field */
126	case '1':
127	case '5':
128	case '9':
129	if ((v = hex2_bin(input)) < 0) {
130	return (SREC_E_NOSREC);
131	}
132	*addr <<= 8;
133	*addr += v;
134	chksum += v;
135	input += 2;
136
137	if ((v = hex2_bin(input)) < 0) {
138	return (SREC_E_NOSREC);
139	}
140	*addr <<= 8;
141	*addr += v;
142	chksum += v;
143	input += 2;
144
145	break;
146	default:
147	return (SREC_E_BADTYPE);
148	}
149
150	/* convert data and calculate checksum */
151	for (i=0; i < *count; ++i) {
152	if ((v = hex2_bin(input)) < 0) {
153	return (SREC_E_NOSREC);
154	}
155	data[i] = v;
156	chksum += v;
157	input += 2;
158	}
159
160	/* read anc check checksum */
161	if ((v = hex2_bin(input)) < 0) {
162	return (SREC_E_NOSREC);
163	}
164
165	if ((unsigned char)v != (unsigned char)~chksum) {
166	return (SREC_E_BADCHKS);
167	}
168
169	return (srec_type);
170	}
171
172	static int hex1_bin (char c)
173	{
174	if (c >= '0' && c <= '9')
175	return (c - '0');
176	if (c >= 'a' && c <= 'f')
177	return (c + 10 - 'a');
178	if (c >= 'A' && c <= 'F')
179	return (c + 10 - 'A');
180	return (-1);
181	}
182
183	static int hex2_bin (char *s)
184	{
185	int i, j;
186
187	if ((i = hex1_bin(*s++)) < 0) {
188	return (-1);
189	}
190	if ((j = hex1_bin(*s)) < 0) {
191	return (-1);
192	}
193
194	return ((i<<4) + j);
195	}