[fnordlicht-mini] / firmware / fnordlicht-bootloader / fboot.c

/* vim:ts=4 sts=4 et tw=80
 *
 *         fnordlichtmini serial bootloader
 *
 *    for additional information please
 *    see http://lochraster.org/fnordlichtmini
 *
 * (c) by Alexander Neumann <alexander@bumpern.de>
 *     Lars Noschinski <lars@public.noschinski.de>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 3 as published by
 * the Free Software Foundation.
 *
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <avr/io.h>
#include <avr/boot.h>
#include <avr/wdt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <util/crc16.h>
#include <string.h>
#include <stdbool.h>
#include "../common/io.h"
#include "../common/remote-proto.h"
#include "../common/common.h"
#include "uart.h"
#include "global.h"

struct global_t
{
    /* for bus synchronization */
    uint8_t synced;
    uint8_t sync_len;

    /* own device address */
    uint8_t address;

    /* for crc checking */
    bool crc_match;
    uint8_t delay;

    /* for enter_application command */
    bool request_exit;
    uint8_t exit_delay;

    /* for internal message buffer */
    uint8_t len;
    union {
        uint8_t buf[REMOTE_MSG_LEN];
        struct remote_msg_t msg;
    };

    /* length and address for data buffer */
    uint16_t data_len;
    uint8_t *data_address;
    union {
        uint8_t data_buf[CONFIG_BOOTLOADER_BUFSIZE];
        uint16_t data_buf16[CONFIG_BOOTLOADER_BUFSIZE/2];
    };
};

struct global_t __global;
#define global (&__global)

/* disable watchdog - NEVER CALL DIRECTLY! */
void disable_watchdog(void) \
  __attribute__((naked)) \
  __attribute__((section(".init3")));
void disable_watchdog(void)
{
    MCUSR = 0;
    wdt_disable();
}

static void (*jump_to_application)(void) = 0;

static void start_application(void) __attribute__((noreturn));
static void start_application(void)
{
    /* pwm pins */
    P_PORT = 0;
    P_DDR = 0;

    /* in pin */
    R_PORT = 0;
    R_DDR = 0;

    /* uart */
    _UBRRH_UART0 = 0;
    _UBRRL_UART0 = 0;
    _UCSRA_UART0 = _BV(_TXC_UART0);
    _UCSRB_UART0 = 0;

    /* timer1 */
    TCCR1B = 0;
    OCR1A = 0;
    TCNT1 = 0;
    _TIFR_TIMER1 = _TIFR_TIMER1;

    /* move interrupt vectors and start real application */
    jump_to_application();
}

static void parse_boot_config(struct remote_msg_boot_config_t *msg)
{
    /* remember flash address */
    global->data_address = (uint8_t *)msg->start_address;
}

static void parse_data(struct remote_msg_boot_data_t *msg)
{
    uint8_t len = sizeof(msg->data);
    if (global->data_len + len > CONFIG_BOOTLOADER_BUFSIZE)
        len = CONFIG_BOOTLOADER_BUFSIZE - global->data_len;

    memcpy(&global->data_buf[global->data_len], msg->data, len);
    global->data_len += len;
}

static void parse_crc(struct remote_msg_boot_crc_check_t *msg)
{
    /* compute crc16 over buffer */
    uint16_t checksum = 0xffff;

    uint8_t *ptr = &global->data_buf[0];
    uint16_t i = msg->len+1;
    while (--i)
        checksum = _crc16_update(checksum, *ptr++);

    if (checksum != msg->checksum) {
        global->delay = msg->delay;
        global->crc_match = false;
    } else
        global->crc_match = true;
}

static void parse_crc_flash(struct remote_msg_boot_crc_flash_t *msg)
{
    /* compute crc16 over flash */
    uint16_t checksum = 0xffff;

    uint8_t *address = (uint8_t *)msg->start;
    uint16_t i = msg->len+1;
    while (--i) {
        uint8_t data = pgm_read_byte(address++);
        checksum = _crc16_update(checksum, data);
    }

    if (checksum != msg->checksum) {
        global->delay = msg->delay;
        global->crc_match = false;
    } else
        global->crc_match = true;
}

static void flash(void)
{
    /* pull int */
    R_DDR |= _BV(INTPIN);

    uint8_t *addr = global->data_address;
    uint16_t *data = &global->data_buf16[0];

    uint8_t last_page = global->data_len/SPM_PAGESIZE;
    if (global->data_len % SPM_PAGESIZE)
        last_page++;

    for (uint8_t page = 0; page < last_page; page++)
    {
        PWM_PIN_ON(PWM_GREEN);

        /* erase page */
        boot_page_erase(addr);
        boot_spm_busy_wait();

        for (uint16_t i = 0; i < SPM_PAGESIZE; i += 2) {
            /* fill internal buffer */
            boot_page_fill(addr+i, *data++);
            boot_spm_busy_wait();
        }

        /* after filling the temp buffer, write the page and wait till we're done */
        boot_page_write(addr);
        boot_spm_busy_wait();

        /* re-enable application flash section, so we can read it again */
        boot_rww_enable();

        PWM_PIN_OFF(PWM_GREEN);
        addr += SPM_PAGESIZE;
    }

    global->data_address = addr;

    /* release int */
    R_DDR &= ~_BV(INTPIN);
}

static void remote_parse_msg(struct remote_msg_t *msg)
{
    /* verify address */
    if (msg->address != global->address && msg->address != REMOTE_ADDR_BROADCAST)
        return;

    /* parse command */
    switch (msg->cmd) {
        case REMOTE_CMD_BOOT_CONFIG: parse_boot_config((struct remote_msg_boot_config_t *)msg);
                                     break;
        case REMOTE_CMD_BOOT_INIT:   global->data_len = 0;
                                     break;
        case REMOTE_CMD_BOOT_DATA:   parse_data((struct remote_msg_boot_data_t *)msg);
                                     break;
        case REMOTE_CMD_CRC_CHECK:   parse_crc((struct remote_msg_boot_crc_check_t *)msg);
                                     break;
        case REMOTE_CMD_CRC_FLASH:   parse_crc_flash((struct remote_msg_boot_crc_flash_t *)msg);
                                     break;
        case REMOTE_CMD_FLASH:       flash();
                                     break;
        case REMOTE_CMD_ENTER_APP:   global->request_exit = true;
                                     global->exit_delay = CONFIG_EXIT_DELAY;
                                     break;
    }

    if (global->delay && global->crc_match == false) {
        /* pull int to gnd */
        R_DDR |= _BV(INTPIN);

        PWM_PIN_ON(PWM_RED);
    }
}

static void remote_poll(void)
{
    /* wait for a byte */
    if (uart_receive_complete())
    {
        uint8_t data = uart_getc();

        /* check if sync sequence has been received before */
        if (global->sync_len == REMOTE_SYNC_LEN) {
            /* synced, safe address and send next address to following device */
            global->address = data;
            uart_putc(data+1);

            /* reset buffer */
            global->len = 0;

            /* enable remote command thread */
            global->synced = 1;
        } else {
            /* just pass through data */
            uart_putc(data);

            /* put data into remote buffer
             * (just processed if remote.synced == 1) */
            if (global->len < sizeof(global->buf))
                global->buf[global->len++] = data;
        }

        /* remember the number of sync bytes received so far */
        if (data == REMOTE_CMD_RESYNC)
            global->sync_len++;
        else
            global->sync_len = 0;
    }

    if (global->synced && global->len == REMOTE_MSG_LEN) {
        remote_parse_msg(&global->msg);
        global->len = 0;
    }
}

static void check_startup(void)
{
    /* check for valid reset vector */
    if (pgm_read_word(NULL) == 0xffff)
        return;

    /* configure pullup resistor at int pin */
    R_PORT |= _BV(INTPIN);

    /* sleep 100ms (TCNT1 == 2, -> TCNT1L == 2) */
    while (TCNT1L < 2);

    /* if int pin is pulled down, remain in bootloader */
    if (!(R_PIN & _BV(INTPIN)))
        return;

    /* else cleanup and start application */
    start_application();
}

int __attribute__ ((noreturn,OS_main)) main(void)
{
    /* initialize timer1, CTC at 50ms, prescaler 1024 */
    OCR1A = F_CPU/1024/20;
    TCCR1B = _BV(WGM12) | _BV(CS12) | _BV(CS10);

    /* start application if necessary */
    check_startup();

    /* configure and enable uart */
    uart_init();

    /* configure outputs */
    P_DDR = PWM_CHANNEL_MASK;

#ifdef PWM_INVERTED
    P_PORT = PWM_CHANNEL_MASK;
#endif

    while(1) {
        remote_poll();

        if (_TIFR_TIMER1 & _BV(OCF1A)) {
            _TIFR_TIMER1 = _BV(OCF1A);

            static uint8_t c;
            if (c++ == 20) {
                /* blink */
                PWM_PIN_TOGGLE(PWM_BLUE);
                c = 0;
            }

            /* if int is pulled, decrement delay */
            if (R_DDR & _BV(INTPIN)) {
                if (--global->delay == 0) {
                    /* release int */
                    R_DDR &= ~_BV(INTPIN);
                    P_PORT &= ~1;
                }
            }

            /* exit (after exit_delay) if requested */
            if (global->request_exit && global->exit_delay-- == 0)
                start_application();
        }
    }
}
Commit	Line	Data
ec1bef8e	1	/* vim:ts=4 sts=4 et tw=80
	2	*
	3	* fnordlichtmini serial bootloader
	4	*
	5	* for additional information please
	6	* see http://lochraster.org/fnordlichtmini
	7	*
	8	* (c) by Alexander Neumann <alexander@bumpern.de>
	9	* Lars Noschinski <lars@public.noschinski.de>
	10	*
	11	* This program is free software: you can redistribute it and/or modify it
	12	* under the terms of the GNU General Public License version 3 as published by
	13	* the Free Software Foundation.
	14	*
	15	* This program is distributed in the hope that it will be useful, but WITHOUT
	16	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	17	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	18	* more details.
	19	*
	20	* You should have received a copy of the GNU General Public License along with
	21	* this program. If not, see <http://www.gnu.org/licenses/>.
	22	*/
	23
	24	#include <avr/io.h>
	25	#include <avr/boot.h>
	26	#include <avr/wdt.h>
	27	#include <avr/pgmspace.h>
	28	#include <util/delay.h>
	29	#include <util/crc16.h>
	30	#include <string.h>
	31	#include <stdbool.h>
	32	#include "../common/io.h"
	33	#include "../common/remote-proto.h"
	34	#include "../common/common.h"
	35	#include "uart.h"
	36	#include "global.h"
	37
	38	struct global_t
	39	{
	40	/* for bus synchronization */
	41	uint8_t synced;
	42	uint8_t sync_len;
	43
	44	/* own device address */
	45	uint8_t address;
	46
	47	/* for crc checking */
	48	bool crc_match;
	49	uint8_t delay;
	50
	51	/* for enter_application command */
	52	bool request_exit;
	53	uint8_t exit_delay;
	54
	55	/* for internal message buffer */
	56	uint8_t len;
	57	union {
	58	uint8_t buf[REMOTE_MSG_LEN];
	59	struct remote_msg_t msg;
	60	};
	61
	62	/* length and address for data buffer */
	63	uint16_t data_len;
	64	uint8_t *data_address;
65	union {
66	uint8_t data_buf[CONFIG_BOOTLOADER_BUFSIZE];
67	uint16_t data_buf16[CONFIG_BOOTLOADER_BUFSIZE/2];
68	};
69	};
70
71	struct global_t __global;
72	#define global (&__global)
73
74	/* disable watchdog - NEVER CALL DIRECTLY! */
75	void disable_watchdog(void) \
76	__attribute__((naked)) \
77	__attribute__((section(".init3")));
78	void disable_watchdog(void)
79	{
80	MCUSR = 0;
81	wdt_disable();
82	}
83
84	static void (*jump_to_application)(void) = 0;
85
86	static void start_application(void) __attribute__((noreturn));
87	static void start_application(void)
88	{
89	/* pwm pins */
90	P_PORT = 0;
91	P_DDR = 0;
92
93	/* in pin */
94	R_PORT = 0;
95	R_DDR = 0;
96
97	/* uart */
98	_UBRRH_UART0 = 0;
99	_UBRRL_UART0 = 0;
100	_UCSRA_UART0 = _BV(_TXC_UART0);
101	_UCSRB_UART0 = 0;
102
103	/* timer1 */
104	TCCR1B = 0;
105	OCR1A = 0;
106	TCNT1 = 0;
107	_TIFR_TIMER1 = _TIFR_TIMER1;
108
109	/* move interrupt vectors and start real application */
110	jump_to_application();
111	}
112
113	static void parse_boot_config(struct remote_msg_boot_config_t *msg)
114	{
115	/* remember flash address */
116	global->data_address = (uint8_t *)msg->start_address;
117	}
118
119	static void parse_data(struct remote_msg_boot_data_t *msg)
120	{
121	uint8_t len = sizeof(msg->data);
122	if (global->data_len + len > CONFIG_BOOTLOADER_BUFSIZE)
123	len = CONFIG_BOOTLOADER_BUFSIZE - global->data_len;
124
125	memcpy(&global->data_buf[global->data_len], msg->data, len);
126	global->data_len += len;
127	}
128
129	static void parse_crc(struct remote_msg_boot_crc_check_t *msg)
130	{
131	/* compute crc16 over buffer */
132	uint16_t checksum = 0xffff;
133
134	uint8_t *ptr = &global->data_buf[0];
135	uint16_t i = msg->len+1;
136	while (--i)
137	checksum = _crc16_update(checksum, *ptr++);
138
139	if (checksum != msg->checksum) {
140	global->delay = msg->delay;
141	global->crc_match = false;
142	} else
143	global->crc_match = true;
144	}
145
146	static void parse_crc_flash(struct remote_msg_boot_crc_flash_t *msg)
147	{
148	/* compute crc16 over flash */
149	uint16_t checksum = 0xffff;
150
151	uint8_t address = (uint8_t )msg->start;
152	uint16_t i = msg->len+1;
153	while (--i) {
154	uint8_t data = pgm_read_byte(address++);
155	checksum = _crc16_update(checksum, data);
156	}
157
158	if (checksum != msg->checksum) {
159	global->delay = msg->delay;
160	global->crc_match = false;
161	} else
162	global->crc_match = true;
163	}
164
165	static void flash(void)
166	{
167	/* pull int */
168	R_DDR \|= _BV(INTPIN);
169
170	uint8_t *addr = global->data_address;
171	uint16_t *data = &global->data_buf16[0];
172
173	uint8_t last_page = global->data_len/SPM_PAGESIZE;
174	if (global->data_len % SPM_PAGESIZE)
175	last_page++;
176
177	for (uint8_t page = 0; page < last_page; page++)
178	{
179	PWM_PIN_ON(PWM_GREEN);
180
181	/* erase page */
182	boot_page_erase(addr);
183	boot_spm_busy_wait();
184
185	for (uint16_t i = 0; i < SPM_PAGESIZE; i += 2) {
186	/* fill internal buffer */
187	boot_page_fill(addr+i, *data++);
188	boot_spm_busy_wait();
189	}
190
191	/* after filling the temp buffer, write the page and wait till we're done */
192	boot_page_write(addr);
193	boot_spm_busy_wait();
194
195	/* re-enable application flash section, so we can read it again */
196	boot_rww_enable();
197
198	PWM_PIN_OFF(PWM_GREEN);
199	addr += SPM_PAGESIZE;
200	}
201
202	global->data_address = addr;
203
204	/* release int */
205	R_DDR &= ~_BV(INTPIN);
206	}
207
208	static void remote_parse_msg(struct remote_msg_t *msg)
209	{
210	/* verify address */
211	if (msg->address != global->address && msg->address != REMOTE_ADDR_BROADCAST)
212	return;
213
214	/* parse command */
215	switch (msg->cmd) {
216	case REMOTE_CMD_BOOT_CONFIG: parse_boot_config((struct remote_msg_boot_config_t *)msg);
217	break;
218	case REMOTE_CMD_BOOT_INIT: global->data_len = 0;
219	break;
220	case REMOTE_CMD_BOOT_DATA: parse_data((struct remote_msg_boot_data_t *)msg);
221	break;
222	case REMOTE_CMD_CRC_CHECK: parse_crc((struct remote_msg_boot_crc_check_t *)msg);
223	break;
224	case REMOTE_CMD_CRC_FLASH: parse_crc_flash((struct remote_msg_boot_crc_flash_t *)msg);
225	break;
226	case REMOTE_CMD_FLASH: flash();
227	break;
228	case REMOTE_CMD_ENTER_APP: global->request_exit = true;
229	global->exit_delay = CONFIG_EXIT_DELAY;
230	break;
231	}
232
233	if (global->delay && global->crc_match == false) {
234	/* pull int to gnd */
235	R_DDR \|= _BV(INTPIN);
236
237	PWM_PIN_ON(PWM_RED);
238	}
239	}
240
241	static void remote_poll(void)
242	{
243	/* wait for a byte */
244	if (uart_receive_complete())
245	{
246	uint8_t data = uart_getc();
247
248	/* check if sync sequence has been received before */
249	if (global->sync_len == REMOTE_SYNC_LEN) {
250	/* synced, safe address and send next address to following device */
251	global->address = data;
252	uart_putc(data+1);
253
254	/* reset buffer */
255	global->len = 0;
256
257	/* enable remote command thread */
258	global->synced = 1;
259	} else {
260	/* just pass through data */
261	uart_putc(data);
262
263	/* put data into remote buffer
264	* (just processed if remote.synced == 1) */
265	if (global->len < sizeof(global->buf))
266	global->buf[global->len++] = data;
267	}
268
269	/* remember the number of sync bytes received so far */
270	if (data == REMOTE_CMD_RESYNC)
271	global->sync_len++;
272	else
273	global->sync_len = 0;
274	}
275
276	if (global->synced && global->len == REMOTE_MSG_LEN) {
277	remote_parse_msg(&global->msg);
278	global->len = 0;
279	}
280	}
281
282	static void check_startup(void)
283	{
284	/* check for valid reset vector */
285	if (pgm_read_word(NULL) == 0xffff)
286	return;
287
288	/* configure pullup resistor at int pin */
289	R_PORT \|= _BV(INTPIN);
290
291	/* sleep 100ms (TCNT1 == 2, -> TCNT1L == 2) */
292	while (TCNT1L < 2);
293
294	/* if int pin is pulled down, remain in bootloader */
295	if (!(R_PIN & _BV(INTPIN)))
296	return;
297
298	/* else cleanup and start application */
299	start_application();
300	}
301
302	int __attribute__ ((noreturn,OS_main)) main(void)
303	{
304	/* initialize timer1, CTC at 50ms, prescaler 1024 */
305	OCR1A = F_CPU/1024/20;
306	TCCR1B = _BV(WGM12) \| _BV(CS12) \| _BV(CS10);
307
308	/* start application if necessary */
309	check_startup();
310
311	/* configure and enable uart */
312	uart_init();
313
314	/* configure outputs */
315	P_DDR = PWM_CHANNEL_MASK;
316
317	#ifdef PWM_INVERTED
318	P_PORT = PWM_CHANNEL_MASK;
319	#endif
320
321	while(1) {
322	remote_poll();
323
324	if (_TIFR_TIMER1 & _BV(OCF1A)) {
325	_TIFR_TIMER1 = _BV(OCF1A);
326
327	static uint8_t c;
328	if (c++ == 20) {
329	/* blink */
330	PWM_PIN_TOGGLE(PWM_BLUE);
331	c = 0;
332	}
333
334	/* if int is pulled, decrement delay */
335	if (R_DDR & _BV(INTPIN)) {
336	if (--global->delay == 0) {
337	/* release int */
338	R_DDR &= ~_BV(INTPIN);
339	P_PORT &= ~1;
340	}
341	}
342
343	/* exit (after exit_delay) if requested */
344	if (global->request_exit && global->exit_delay-- == 0)
345	start_application();
346	}
347	}
348	}