razzor/ispprog
1
0
Fork 0
Code Issues 1 Pull Requests Releases Activity

Move UART handling to own file

Browse Source
This commit is contained in:
Olaf Rempel 2019-12-30 21:27:47 +01:00
parent 49ffbdb579
commit 118eaa091b
3 changed files with 187 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

204
ispprog.c
View File

@ -25,9 +25,9 @@
#include "avrdevice.h" #include "avrdevice.h"
#include "display.h" #include "display.h"
#include "target.h" #include "target.h"
#include "uart.h"
#include <util/delay.h> #include <util/delay.h>
#define UART_CALC_BAUDRATE(baudRate) (((uint32_t)F_CPU) / (((uint32_t)baudRate)*16) -1)
/* F_CPU /4 (1.8432MHz) */ /* F_CPU /4 (1.8432MHz) */
#define SPI_MODE4 ((1<<SPE) | (1<<MSTR)) #define SPI_MODE4 ((1<<SPE) | (1<<MSTR))
@ -116,32 +116,6 @@ static uint8_t last_cmd;
static uint8_t last_val; static uint8_t last_val;
static uint16_t last_addr; static uint16_t last_addr;
/* Send one byte to PC */
static void ser_send(uint8_t data)
{
#if defined(__AVR_ATmega16__)
loop_until_bit_is_set(UCSRA, UDRE);
UDR = data;
#elif defined(__AVR_ATmega328P__)
loop_until_bit_is_set(UCSR0A, UDRE0);
UDR0 = data;
#endif
} /* ser_send */
/* Receive one byte from PC */
static uint8_t ser_recv(void)
{
#if defined(__AVR_ATmega16__)
loop_until_bit_is_set(UCSRA, RXC);
return UDR;
#elif defined(__AVR_ATmega328P__)
loop_until_bit_is_set(UCSR0A, RXC0);
return UDR0;
#endif
} /* ser_recv */
/* Send one byte to target, and return received one */ /* Send one byte to target, and return received one */
static uint8_t spi_rxtx(uint8_t val) static uint8_t spi_rxtx(uint8_t val)
{ {
@ -254,7 +228,7 @@ static void cmdloop(void)
} }
#endif /* (USE_DISPLAY) */ #endif /* (USE_DISPLAY) */
switch (ser_recv()) { switch (uart_recv()) {
/* Enter programming mode */ /* Enter programming mode */
case 'P': { case 'P': {
reset_statemachine(EV_PROG_ENTER); reset_statemachine(EV_PROG_ENTER);
@ -262,17 +236,17 @@ static void cmdloop(void)
while (1) { while (1) {
if (reset_state == STATE_IDLE) { if (reset_state == STATE_IDLE) {
/* device not supported */ /* device not supported */
ser_send('!'); uart_send('!');
break; break;
} else if (reset_state == STATE_RESET_PROGMODE) { } else if (reset_state == STATE_RESET_PROGMODE) {
if (m_device.flags & POLL_UNTESTED) { if (m_device.flags & POLL_UNTESTED) {
reset_statemachine(EV_PROG_LEAVE); reset_statemachine(EV_PROG_LEAVE);
/* untested device */ /* untested device */
ser_send('!'); uart_send('!');
} else { } else {
/* supported device */ /* supported device */
ser_send('\r'); uart_send('\r');
} }
break; break;
} }
@ -282,33 +256,33 @@ static void cmdloop(void)
/* Autoincrement address */ /* Autoincrement address */
case 'a': case 'a':
ser_send('Y'); uart_send('Y');
break; break;
/* Set address */ /* Set address */
case 'A': case 'A':
addr = (ser_recv() << 8); addr = (uart_recv() << 8);
addr |= ser_recv(); addr |= uart_recv();
ser_send('\r'); uart_send('\r');
break; break;
/* Write program memory, low byte */ /* Write program memory, low byte */
case 'c': case 'c':
led_mode = LED_FAST; led_mode = LED_FAST;
mem_write(CMD_LOAD_FLASH_LO, addr, ser_recv()); mem_write(CMD_LOAD_FLASH_LO, addr, uart_recv());
/* poll on byte addressed targets */ /* poll on byte addressed targets */
if (m_device.pagemask == 0x00) { if (m_device.pagemask == 0x00) {
poll(); poll();
} }
ser_send('\r'); uart_send('\r');
break; break;
/* Write program memory, high byte */ /* Write program memory, high byte */
case 'C': case 'C':
led_mode = LED_FAST; led_mode = LED_FAST;
mem_write(CMD_LOAD_FLASH_HI, addr, ser_recv()); mem_write(CMD_LOAD_FLASH_HI, addr, uart_recv());
/* poll on byte addressed targets */ /* poll on byte addressed targets */
if (m_device.pagemask == 0x00) { if (m_device.pagemask == 0x00) {
@ -316,45 +290,45 @@ static void cmdloop(void)
} }
addr++; addr++;
ser_send('\r'); uart_send('\r');
break; break;
/* Issue Page Write */ /* Issue Page Write */
case 'm': case 'm':
led_mode = LED_FAST; led_mode = LED_FAST;
mem_pagewrite(last_addr); mem_pagewrite(last_addr);
ser_send('\r'); uart_send('\r');
break; break;
/* Read Lock Bits */ /* Read Lock Bits */
case 'r': case 'r':
ser_send(mem_read(CMD_READ_LOCK_1, CMD_READ_LOCK_2 << 8)); uart_send(mem_read(CMD_READ_LOCK_1, CMD_READ_LOCK_2 << 8));
ser_send('\r'); uart_send('\r');
break; break;
/* Read program memory */ /* Read program memory */
case 'R': case 'R':
led_mode = LED_SLOW; led_mode = LED_SLOW;
ser_send(mem_read(CMD_READ_FLASH_HI, addr)); uart_send(mem_read(CMD_READ_FLASH_HI, addr));
ser_send(mem_read(CMD_READ_FLASH_LO, addr)); uart_send(mem_read(CMD_READ_FLASH_LO, addr));
addr++; addr++;
break; break;
/* Read data memory */ /* Read data memory */
case 'd': case 'd':
led_mode = LED_SLOW; led_mode = LED_SLOW;
ser_send(mem_read(CMD_READ_EEPROM, addr)); uart_send(mem_read(CMD_READ_EEPROM, addr));
addr++; addr++;
break; break;
/* Write data memory */ /* Write data memory */
case 'D': case 'D':
led_mode = LED_FAST; led_mode = LED_FAST;
mem_write(CMD_WRITE_EEPROM, addr, ser_recv()); mem_write(CMD_WRITE_EEPROM, addr, uart_recv());
poll(); poll();
addr++; addr++;
ser_send('\r'); uart_send('\r');
break; break;
/* Chip erase */ /* Chip erase */
@ -365,35 +339,35 @@ static void cmdloop(void)
spi_rxtx(0x00); spi_rxtx(0x00);
_delay_ms(10); _delay_ms(10);
ser_send('\r'); uart_send('\r');
break; break;
/* Write lock bits */ /* Write lock bits */
case 'l': { case 'l': {
uint8_t val = ser_recv(); uint8_t val = uart_recv();
spi_rxtx(CMD_WRITE_LOCK_1); spi_rxtx(CMD_WRITE_LOCK_1);
spi_rxtx(CMD_WRITE_LOCK_2); spi_rxtx(CMD_WRITE_LOCK_2);
spi_rxtx(0x00); spi_rxtx(0x00);
spi_rxtx(val); spi_rxtx(val);
_delay_ms(10); _delay_ms(10);
ser_send('\r'); uart_send('\r');
break; break;
} }
/* Read fusebits */ /* Read fusebits */
case 'F': case 'F':
ser_send(mem_read(CMD_READ_FUSE_1, CMD_READ_FUSE_2 << 8)); uart_send(mem_read(CMD_READ_FUSE_1, CMD_READ_FUSE_2 << 8));
break; break;
/* Read high fusebits */ /* Read high fusebits */
case 'N': case 'N':
ser_send(mem_read(CMD_READ_FUSE_H_1, CMD_READ_FUSE_H_2 << 8)); uart_send(mem_read(CMD_READ_FUSE_H_1, CMD_READ_FUSE_H_2 << 8));
break; break;
/* Read extended fusebits */ /* Read extended fusebits */
case 'Q': case 'Q':
ser_send(mem_read(CMD_READ_FUSE_E_1, CMD_READ_FUSE_E_2 << 8)); uart_send(mem_read(CMD_READ_FUSE_E_1, CMD_READ_FUSE_E_2 << 8));
break; break;
/* Leave programming mode */ /* Leave programming mode */
@ -402,76 +376,74 @@ static void cmdloop(void)
/* Exit Bootloader */ /* Exit Bootloader */
case 'E': case 'E':
reset_statemachine(EV_PROG_LEAVE); reset_statemachine(EV_PROG_LEAVE);
ser_send('\r'); uart_send('\r');
break; break;
/* Select device type */ /* Select device type */
case 'T': { case 'T': {
ser_recv(); // ignore uart_recv(); // ignore
ser_send('\r'); uart_send('\r');
break; break;
} }
/* Read signature bytes */ /* Read signature bytes */
case 's': { case 's':
uint8_t i = 2; uart_send(m_device.sig[2]);
do { uart_send(m_device.sig[1]);
ser_send(m_device.sig[i]); uart_send(m_device.sig[0]);
} while (i--);
break; break;
}
/* Return supported device codes */ /* Return supported device codes */
case 't': case 't':
avrdevice_iterate_devcodes(ser_send); avrdevice_iterate_devcodes(uart_send);
ser_send(0x00); uart_send(0x00);
break; break;
/* Return software identifier */ /* Return software identifier */
case 'S': case 'S':
ser_send('A'); uart_send('A');
ser_send('V'); uart_send('V');
ser_send('R'); uart_send('R');
ser_send('-'); uart_send('-');
ser_send('I'); uart_send('I');
ser_send('S'); uart_send('S');
ser_send('P'); uart_send('P');
break; break;
/* Return software version */ /* Return software version */
case 'V': case 'V':
ser_send('3'); uart_send('3');
ser_send('8'); uart_send('8');
break; break;
/* Return hardware version */ /* Return hardware version */
case 'v': case 'v':
ser_send('1'); uart_send('1');
ser_send('2'); uart_send('2');
break; break;
/* Return programmer type */ /* Return programmer type */
case 'p': case 'p':
ser_send('S'); uart_send('S');
break; break;
/* Set LED */ /* Set LED */
case 'x': case 'x':
ser_recv(); uart_recv();
led_mode = LED_ON; led_mode = LED_ON;
break; break;
/* Clear LED */ /* Clear LED */
case 'y': case 'y':
ser_recv(); uart_recv();
led_mode = LED_OFF; led_mode = LED_OFF;
break; break;
/* Report Block write Mode */ /* Report Block write Mode */
case 'b': { case 'b': {
ser_send('Y'); uart_send('Y');
ser_send(sizeof(page_buf) >> 8); uart_send(sizeof(page_buf) >> 8);
ser_send(sizeof(page_buf) & 0xFF); uart_send(sizeof(page_buf) & 0xFF);
break; break;
} }
@ -482,12 +454,11 @@ static void cmdloop(void)
led_mode = LED_FAST; led_mode = LED_FAST;
size = ser_recv() << 8; size = uart_recv() << 8;
size |= ser_recv(); size |= uart_recv();
type = ser_recv(); type = uart_recv();
for (i = 0; i < size; i++) uart_recv_buf(page_buf, size);
page_buf[i] = ser_recv();
if (type == 'F') { if (type == 'F') {
for (i = 0; i < size; i += 2) { for (i = 0; i < size; i += 2) {
@ -514,7 +485,7 @@ static void cmdloop(void)
addr++; addr++;
} }
} }
ser_send('\r'); uart_send('\r');
break; break;
} }
@ -525,20 +496,20 @@ static void cmdloop(void)
led_mode = LED_SLOW; led_mode = LED_SLOW;
size = ser_recv() << 8; size = uart_recv() << 8;
size |= ser_recv(); size |= uart_recv();
type = ser_recv(); type = uart_recv();
if (type == 'F') { if (type == 'F') {
for (i = 0; i < size; i += 2) { for (i = 0; i < size; i += 2) {
ser_send(mem_read(CMD_READ_FLASH_LO, addr)); uart_send(mem_read(CMD_READ_FLASH_LO, addr));
ser_send(mem_read(CMD_READ_FLASH_HI, addr)); uart_send(mem_read(CMD_READ_FLASH_HI, addr));
addr++; addr++;
} }
} else if (type == 'E') { } else if (type == 'E') {
for (i = 0; i < size; i++) { for (i = 0; i < size; i++) {
ser_send(mem_read(CMD_READ_EEPROM, addr)); uart_send(mem_read(CMD_READ_EEPROM, addr));
addr++; addr++;
} }
} }
@ -547,45 +518,42 @@ static void cmdloop(void)
/* Write fusebits */ /* Write fusebits */
case 'f': { case 'f': {
uint8_t val = ser_recv(); uint8_t val = uart_recv();
spi_rxtx(CMD_WRITE_FUSE_1); spi_rxtx(CMD_WRITE_FUSE_1);
spi_rxtx(CMD_WRITE_FUSE_2); spi_rxtx(CMD_WRITE_FUSE_2);
spi_rxtx(0x00); spi_rxtx(0x00);
spi_rxtx(val); spi_rxtx(val);
_delay_ms(10); _delay_ms(10);
ser_send('\r'); uart_send('\r');
break; break;
} }
/* Universial command */ /* Universial command */
case ':': { case ':': {
uint8_t val[3]; uint8_t val[3];
val[0] = ser_recv();
val[1] = ser_recv(); uart_recv_buf(val, sizeof(val));
val[2] = ser_recv();
spi_rxtx(val[0]); spi_rxtx(val[0]);
spi_rxtx(val[1]); spi_rxtx(val[1]);
ser_send(spi_rxtx(val[2])); uart_send(spi_rxtx(val[2]));
_delay_ms(10); _delay_ms(10);
ser_send('\r'); uart_send('\r');
break; break;
} }
/* New universal command */ /* New universal command */
case '.': { case '.': {
uint8_t val[4]; uint8_t val[4];
val[0] = ser_recv();
val[1] = ser_recv(); uart_recv_buf(val, sizeof(val));
val[2] = ser_recv();
val[3] = ser_recv();
spi_rxtx(val[0]); spi_rxtx(val[0]);
spi_rxtx(val[1]); spi_rxtx(val[1]);
spi_rxtx(val[2]); spi_rxtx(val[2]);
ser_send(spi_rxtx(val[3])); uart_send(spi_rxtx(val[3]));
/* most CMD_WRITE_* commands need delay */ /* most CMD_WRITE_* commands need delay */
if (val[0] == CMD_WRITE_LOCK_1) if (val[0] == CMD_WRITE_LOCK_1)
@ -593,7 +561,7 @@ static void cmdloop(void)
_delay_ms(10); _delay_ms(10);
} }
ser_send('\r'); uart_send('\r');
break; break;
} }
@ -602,7 +570,7 @@ static void cmdloop(void)
break; break;
default: default:
ser_send('?'); uart_send('?');
break; break;
} }
} }
@ -843,27 +811,7 @@ int main(void)
{ {
GPIO_INIT(); GPIO_INIT();
#if defined(OSCCAL_VALUE) uart_init();
OSCCAL = OSCCAL_VALUE;
#endif /* defined(OSCCAL_VALUE) */
#if defined(__AVR_ATmega16__)
/* Set baud rate */
UBRRH = (UART_CALC_BAUDRATE(BAUDRATE)>>8) & 0xFF;
UBRRL = (UART_CALC_BAUDRATE(BAUDRATE) & 0xFF);
/* enable usart with 8n1 */
UCSRB = (1<<TXEN) | (1<<RXEN);
UCSRC = (1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0);
#elif defined(__AVR_ATmega328P__)
/* Set baud rate */
UBRR0H = (UART_CALC_BAUDRATE(BAUDRATE)>>8) & 0xFF;
UBRR0L = (UART_CALC_BAUDRATE(BAUDRATE) & 0xFF);
/* enable usart with 8n1 */
UCSR0B = (1<<TXEN0) | (1<<RXEN0);
UCSR0C = (1<<UCSZ01) | (1<<UCSZ00);
#endif
/* enable SPI master mode */ /* enable SPI master mode */
SPCR = SPI_MODE4; SPCR = SPI_MODE4;

94
uart.c Normal file
View File

@ -0,0 +1,94 @@
/***************************************************************************
* Copyright (C) 2006 - 2020 by Olaf Rempel *
* razzor AT kopf MINUS tisch DOT de *
* *
* 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; version 2 of the License, *
* *
* 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 <avr/io.h>
#include "target.h"
#include "uart.h"
#define UART_CALC_BAUDRATE(baudRate) (((uint32_t)F_CPU) / (((uint32_t)baudRate)*16) -1)
/* ***********************************************************************
* uart_send
* *********************************************************************** */
void uart_send(uint8_t data)
{
#if defined(__AVR_ATmega16__)
loop_until_bit_is_set(UCSRA, UDRE);
UDR = data;
#elif defined(__AVR_ATmega328P__)
loop_until_bit_is_set(UCSR0A, UDRE0);
UDR0 = data;
#endif
} /* uart_send */
/* ***********************************************************************
* uart_recv
* *********************************************************************** */
uint8_t uart_recv(void)
{
#if defined(__AVR_ATmega16__)
loop_until_bit_is_set(UCSRA, RXC);
return UDR;
#elif defined(__AVR_ATmega328P__)
loop_until_bit_is_set(UCSR0A, RXC0);
return UDR0;
#endif
} /* uart_recv */
/* ***********************************************************************
* uart_recv_buf
* *********************************************************************** */
void uart_recv_buf(uint8_t * p_data, uint16_t data_length)
{
while (data_length--)
{
*p_data++ = uart_recv();
}
} /* uart_recv_buf */
/* ***********************************************************************
* uart_init
* *********************************************************************** */
void uart_init(void)
{
#if defined(OSCCAL_VALUE)
OSCCAL = OSCCAL_VALUE;
#endif /* defined(OSCCAL_VALUE) */
#if defined(__AVR_ATmega16__)
/* Set baud rate */
UBRRH = (UART_CALC_BAUDRATE(BAUDRATE)>>8) & 0xFF;
UBRRL = (UART_CALC_BAUDRATE(BAUDRATE) & 0xFF);
/* enable usart with 8n1 */
UCSRB = (1<<TXEN) | (1<<RXEN);
UCSRC = (1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0);
#elif defined(__AVR_ATmega328P__)
/* Set baud rate */
UBRR0H = (UART_CALC_BAUDRATE(BAUDRATE)>>8) & 0xFF;
UBRR0L = (UART_CALC_BAUDRATE(BAUDRATE) & 0xFF);
/* enable usart with 8n1 */
UCSR0B = (1<<TXEN0) | (1<<RXEN0);
UCSR0C = (1<<UCSZ01) | (1<<UCSZ00);
#endif
} /* uart_init */

17
uart.h Normal file
View File

@ -0,0 +1,17 @@
#ifndef UART_H_
#define UART_H_
#include <stdint.h>
/* *********************************************************************** */
void uart_send (uint8_t data);
uint8_t uart_recv (void);
void uart_recv_buf (uint8_t * p_data, uint16_t data_length);
void uart_init (void);
/* *********************************************************************** */
#endif /* UART_H_ */