amt630h-sdk-beta/STEPLDR/Src/uart.c

#include <string.h>

#include "amt630h.h"
#include "typedef.h"
#include "uart.h"
#include "aic.h"
#include "update.h"
#include "spi.h"
#include "crc32.h"
#include "sysinfo.h"
#include "board.h"

#define UART_CLK	CLK_24MHZ
#define UART_ISR_PASS_LIMIT	1

static unsigned int ulUartBase[UART_NUM] = {REGS_UART0_BASE, REGS_UART1_BASE, REGS_UART2_BASE, REGS_UART3_BASE};

void InitUart(unsigned int baud)
{
	unsigned int Baud_Rate_Divisor;
	unsigned int val;

    //select pad
   val = rSYS_PAD_CTRL02;
   val &= ~(0xF<<12);
   val |=(0x1<<14)|(0x1<<12);
   rSYS_PAD_CTRL02 = val;
	
	Baud_Rate_Divisor = ((CLK_24MHZ<<3) + baud)/(baud<<1);
	rUART_IBRD = Baud_Rate_Divisor >> 6;
	rUART_FBRD = Baud_Rate_Divisor & 0x3f;
	
	rUART_LCR_H = 0x70;//data len:8 bit,parity checking disable
	rUART_IFLS = 0x19;
	rUART_CR = 0x301;
}

static char HexToChar(unsigned char value)
{
	value &= 0x0f;

	if ( value < 10 )
		return(0x30 + value);
	else
		return(0x60 + value - 9);
}


static void ShortToStr(unsigned short value, char *str)
{
	str[0] = HexToChar(value >> 12);
	str[1] = HexToChar((value >> 8) & 0x0f);
	str[2] = HexToChar((value >> 4) & 0x0f);
	str[3] = HexToChar(value & 0x0f);
	str[4] = 0;
}

void IntToStr(unsigned int value, char *str)
{
	ShortToStr(value >> 16, str);
	ShortToStr(value & 0xffff, str + 4);
	str[8] = 0;
}

void  SendUartString(char * buf)
{
	int i = 0;	
	while ( buf[i] != 0)
	{
		while ( !(rUART_FR & 0x20) )
		{
			rUART_DR = buf[i++];
			if ( buf[i] == 0 )
				return;
		}
		while ( (rUART_FR & 0x20));
	}
}

void SendUartChar(char ch)
{	
	while ( (rUART_FR & 0x20) );
	rUART_DR = ch;
}


void PrintVariableValueHex(char * variable, unsigned int value)
{
	char buf[10];

	SendUartString(variable);
	SendUartString(": 0x");
	IntToStr(value, buf);
	SendUartString(buf);
	SendUartString("\r\n");
}

void SendUartWord(unsigned int data)
{
    char buf[10];
    
    SendUartString("0x");
	IntToStr(data, buf);
	SendUartString(buf);
	SendUartString("\r\n");
}
void uart_puts(const UINT8*buf)
{
	INT32 i = 0;
	while ( buf[i] != 0)
	{
		while( !(rUART_FR & 0x20) )
		{
			if ( buf[i] == '\n' )
			{
				rUART_DR = '\r';
				while( (rUART_FR & 0x20) );
			}

			rUART_DR = buf[i++];
			if ( buf[i] == 0 )
				return;
		}
		while( (rUART_FR & 0x20) );
	}
}

/* retarget printf function */
int putchar(int ch)
{
	while (readl(REGS_UART0_BASE + UART_FR) & UART_FR_TXFF);
	writel(ch, REGS_UART0_BASE + UART_DR);
	
	return ch;
}

typedef enum {
	UART_FRAME_START,
	UART_FRAME_FILEINFO,
	UART_FRAME_FILEXFER,
	UART_FRAME_FINISH,
} eUartFrameType;

#define UUP_STATE_IDLE		0
#define UUP_STATE_START		1
#define UUP_STATE_END		2

#define UUP_ACK_OK			1
#define UUP_ACK_FAIL		0

#define UUP_MAX_FILE_SIZE	0x1000000
#define UUP_BUF_SIZE	(BYTESPERPAGE * PAGESPERSECTORS)
#define UUP_PACKET_SIZE		128
#define UUP_MAX_FRAME_LEN	(UUP_PACKET_SIZE + 16)
#define UUP_RX_FRAME_NUM	16
#define UUP_MAX_LOADER_SIZE	0x10000

typedef struct {
	int type;
	unsigned char *buf;
	unsigned int len;
	int ack;
} UartFrame;

#pragma data_alignment=16
static unsigned char uup_rx_buf[UUP_RX_FRAME_NUM][UUP_MAX_FRAME_LEN];
static unsigned char *uup_rx_ptr;
static int uup_rx_rev_len = 0;
static int uup_rx_head = 0;
static int uup_rx_tail = 0;
static int uup_rx_state = 0;
static int uup_rx_data_len = 0;
static int uup_status = UUP_STATE_IDLE;
static int uup_file_type = 0;
static unsigned int uup_file_offset;
static int uup_file_size = 0;
static int uup_packet_num = 0;
static int uup_rev_packet = 0;
static int uup_rev_len = 0;

#pragma data_alignment=16
static unsigned char uup_buf[UUP_MAX_LOADER_SIZE];
static unsigned int uup_buf_len = 0;


void uart_init(int id, unsigned int baud, unsigned int flags)
{
	unsigned int lcr_h, quot, cr;
	unsigned int regbase;
	int count = 0;

	regbase = ulUartBase[id];
	
	if (baud > UART_CLK / 16)
		quot = (UART_CLK * 8 + baud / 2) / baud;
	else
		quot = (UART_CLK * 4 + baud / 2) / baud;

	switch (flags & CSIZE) {
	case CS5:
		lcr_h = UART_LCRH_WLEN_5;
		break;
	case CS6:
		lcr_h = UART_LCRH_WLEN_6;
		break;
	case CS7:
		lcr_h = UART_LCRH_WLEN_7;
		break;
	default: // CS8
		lcr_h = UART_LCRH_WLEN_8;
		break;
	}
	if (flags & CSTOPB)
		lcr_h |= UART_LCRH_STP2;
	if (flags & PARENB) {
		lcr_h |= UART_LCRH_PEN;
		if (!(flags & PARODD))
			lcr_h |= UART_LCRH_EPS;
		if (flags & CMSPAR)
			lcr_h |= UART_LCRH_SPS;
	}
	lcr_h |= UART_LCRH_FEN;

	/* Provoke TX FIFO interrupt into asserting */
	cr = UART_CR_UARTEN | UART_CR_TXE | UART_CR_LBE;
reconfig:
	writel(cr, regbase + UART_CR);
	writel(0, regbase + UART_FBRD);
	writel(1, regbase + UART_IBRD);
	writel(0, regbase + UART_LCRH);
	writel(0, regbase + UART_DR);
	while (readl(regbase + UART_FR) & UART_FR_BUSY);
	if (count++ < 10 && !(readl(regbase + UART_RIS) & UART_TXIS)) {
		SendUartString("ERROR! Uart status wrong.\n");
		goto reconfig;
	}

	/* first, disable everything */
	writel(0, regbase + UART_CR);
	
	cr = UART_CR_RXE | UART_CR_TXE;
	if (flags & CRTSCTS)
		cr |= UART_CR_CTSEN | UART_CR_RTSEN;

	/* Set baud rate */
	writel(quot & 0x3f, regbase + UART_FBRD);
	writel(quot >> 6, regbase + UART_IBRD);

	writel(UART_RTIM | UART_RXIM, regbase + UART_IMSC);
	writel(UART_IFLS_RX4_8 | UART_IFLS_TX4_8, regbase + UART_IFLS);
	writel(lcr_h, regbase + UART_LCRH);
	writel(cr | UART_CR_UARTEN, regbase + UART_CR);
}


static int uart_rx_chars(int id)
{
	unsigned int regbase = ulUartBase[id];
	unsigned int status;
	unsigned int ch, max_count = 256;
	int fifotaken = 0;

	while (max_count--) {
		status = readl(regbase + UART_FR);
		if (status & UART_FR_RXFE)
			break;

		/* Take chars from the FIFO and update status */
		ch = readl(regbase + UART_DR);

		fifotaken++;
		switch (uup_rx_state) {
		case 0:
			if (ch == 0x55) {
				uup_rx_state++;
				uup_rx_rev_len = 0;
				uup_rx_ptr = &uup_rx_buf[uup_rx_head][0];
			}
			break;
		case 1:
			if (ch == 0x81)
				uup_rx_state++;
			else
				uup_rx_state = 0;
			*uup_rx_ptr++ = ch;
			break;
		case 2:
			if (ch == 0xc6)
				uup_rx_state++;
			else
				uup_rx_state = 0;
			*uup_rx_ptr++ = ch;
			break;
		case 3:
			uup_rx_data_len = ch;
			uup_rx_state++;
			*uup_rx_ptr++ = ch;
			break;
		case 4:
			*uup_rx_ptr++ = ch;
			if (++uup_rx_rev_len == uup_rx_data_len)
				uup_rx_state++;
			break;
		case 5:
			*uup_rx_ptr++ = ch;
			uup_rx_head = (uup_rx_head + 1) % UUP_RX_FRAME_NUM;
			uup_rx_state = 0;
			break;
		}

		/* discard when rx buf is full */

	}

	return fifotaken;
}

void uart_tx_chars(int id, unsigned char *buf, int len)
{
	unsigned int regbase = ulUartBase[id];
	int i;

	for (i = 0; i < len; i++) {
		while (readl(regbase + UART_FR) & UART_FR_TXFF);
		writel(buf[i], regbase + UART_DR);
	}
}

void uart_update_int_handler(void *param)
{
	int id = (int)param;
	unsigned int regbase = ulUartBase[id];
	unsigned int status;
	unsigned int imsc;
	uint32_t pass_counter = UART_ISR_PASS_LIMIT;
		
	imsc = readl(regbase + UART_IMSC);
	status = readl(regbase + UART_RIS) & imsc;
	if (status) {
		do {
			writel(status & ~(/*UART_TXIS | */UART_RTIS | UART_RXIS),
				    regbase + UART_ICR); 

			if (status & (UART_RTIS | UART_RXIS)) {
				uart_rx_chars(id);
			}
			/* if (status & UART_TXIS)
				xUartTxChars(uap, pdTRUE); */

			if (pass_counter-- == 0)
				break;

			status = readl(regbase + UART_RIS) & imsc;
		} while (status != 0);
	}
}

static void uart_send_ack(int type, int ret)
{
	unsigned char buf[7] = {0x55, 0x80, 0xc5, 0x02, 0x00, 0x00, 0x00};
	int i;

	buf[4] = type;
	buf[5] = ret;
	for (i = 1; i < 6; i++)
		buf[6] ^= buf[i];

	uart_tx_chars(UART_MCU_PORT, buf, 7);
}

static int uart_rev_frame(UartFrame *frame)
{
	unsigned char *buf;
	int len;
	unsigned char checksum = 0;
	int i;
	
	if (uup_rx_tail == uup_rx_head) {
		return 0;
	}
	buf = &uup_rx_buf[uup_rx_tail][0];
	uup_rx_tail = (uup_rx_tail + 1) % UUP_RX_FRAME_NUM;
	len = buf[2];
	for (i = 0; i < len + 3; i++)
		checksum ^= buf[i];
	if (checksum == buf[len + 3]) {
		frame->buf = &buf[4];
		frame->len = len - 1;
		frame->type = buf[3];
	} else {
		SendUartString("rev frame checksum err.\n");
		/* for (int i = 0; i < len + 4; i++) {
			if (i && i % 16 == 0)
				printf("\n");
			printf("%.2x, ", buf[i]);
		}
		printf("\n0x%x, 0x%x.\n", checksum, buf[len + 3]); */
		uart_send_ack(buf[3], UUP_ACK_FAIL);
		return 0;
	}

	return 1;
}


void updateFromUart(int id)
{
	UartFrame rx_frame;
	unsigned char *buf;
	unsigned int  checksum = 0, calc_checksum = 0xffffffff;
	unsigned int framelen;
	unsigned int packetnum;
	SysInfo *sysinfo = GetSysInfo();
	
	uart_init(id, 115200, 0);
	request_irq(UART0_IRQn + id, 0, uart_update_int_handler, (void*)id);

	do {
		if (!uart_rev_frame(&rx_frame))
			continue;
		
		switch (rx_frame.type) {
		case UART_FRAME_START:
			uart_send_ack(rx_frame.type, UUP_ACK_OK);
			uup_status = UUP_STATE_START;
			update_logo_init();
			break;
		case UART_FRAME_FILEINFO:
			if (uup_status != UUP_STATE_START)
				break;
			buf = rx_frame.buf;
			uup_file_type = buf[0];
			if (uup_file_type > UPFILE_TYPE_STEPLDR) {
				SendUartString("Rev wrong file type.\n");
				uart_send_ack(rx_frame.type, UUP_ACK_FAIL);
				break;
			}
			uup_file_offset = SpiGetUpfileOffset(uup_file_type);
			if (uup_file_offset == 0xffffffff) {
				uart_send_ack(rx_frame.type, UUP_ACK_FAIL);
				break;	
			}
			uup_packet_num = (buf[1] << 16) | (buf[2] << 8) | buf[3];
			uup_file_size = UUP_PACKET_SIZE * uup_packet_num;
			if (uup_file_size > UUP_MAX_FILE_SIZE) {
				SendUartString("Rev wrong file size.\n");
				uart_send_ack(rx_frame.type, UUP_ACK_FAIL);
				break;
			}
			uart_send_ack(rx_frame.type, UUP_ACK_OK);
			break;
		case UART_FRAME_FILEXFER:
			if (uup_status != UUP_STATE_START)
				break;
			buf = rx_frame.buf;
			packetnum = buf[0];
			PrintVariableValueHex("uup_rev_packet", uup_rev_packet);
			if ((uup_rev_packet & 0xff) != packetnum) {
				SendUartString("Wrong packet number.\n");
				uart_send_ack(rx_frame.type, UUP_ACK_FAIL);
				break;
			}
			if (uup_rev_packet == 0) {
				if (uup_file_type == UPFILE_TYPE_WHOLE) {
					UpFileHeader header;
					memcpy(&header, &buf[1], sizeof(UpFileHeader));
					if (header.magic != MKTAG('U', 'P', 'D', 'F')) {
						SendUartString("Wrong whole file magic.\n");
						uart_send_ack(rx_frame.type, UUP_ACK_FAIL);
						break;
					}
					checksum = header.checksum;
				} else if (uup_file_type == UPFILE_TYPE_RESOURCE) {
					RomHeader header;
					memcpy(&header, &buf[1], sizeof(RomHeader));
					if (header.magic != MKTAG('R', 'O', 'M', 'A')) {
						SendUartString("Wrong resource file magic.\n");
						uart_send_ack(rx_frame.type, UUP_ACK_FAIL);
						break;
					}
					checksum = header.checksum;
				} else if (uup_file_type == UPFILE_TYPE_ANIMATION) {
					BANIHEADER header;
					memcpy(&header, &buf[1], sizeof(BANIHEADER));
					if (header.magic != MKTAG('B', 'A', 'N', 'I')) {
						SendUartString("Wrong animation file magic.\n");
						uart_send_ack(rx_frame.type, UUP_ACK_FAIL);
						break;
					}				
					checksum = header.checksum;
				} else if (uup_file_type == UPFILE_TYPE_APP) {
					unsigned int magic = buf[1] | (buf[2] << 8) | (buf[3] << 16) | (buf[4] << 24);
					if (magic != UPFILE_APP_MAGIC) {
						SendUartString("Wrong app file magic.\n");
						uart_send_ack(rx_frame.type, UUP_ACK_FAIL);
						break;
					}
					unsigned char *tmp = buf + 1 + APPLDR_CHECKSUM_OFFSET;
					checksum = tmp[0] | (tmp[1] <<8) | (tmp[2] << 16) | (tmp[3] << 24);
				}
			}
			framelen = rx_frame.len - 1;
			/* only last frame size is less than UUP_PACKET_SIZE */
			if (framelen > UUP_PACKET_SIZE || 
				(framelen < UUP_PACKET_SIZE && uup_rev_packet != uup_packet_num - 1)) {
				SendUartString("Wrong packet len.\n");
				uart_send_ack(rx_frame.type, UUP_ACK_FAIL);
				break;
			}
			memcpy(uup_buf + uup_buf_len, buf + 1, framelen);
			uup_buf_len += framelen;
			if (uup_buf_len > UUP_MAX_LOADER_SIZE) {
				SendUartString("loader file is too large.\n");
				uart_send_ack(rx_frame.type, UUP_ACK_FAIL);
				break;
			}
			uart_send_ack(rx_frame.type, UUP_ACK_OK);
			uup_rev_packet++;
			//loader程序如果升级错误会导致系统起不来并且不能再继续升级，因此需要
			//等数据校验成功后再烧录(loader程序通常并不需要升级)
			if (uup_file_type < UPFILE_TYPE_SPILDR && uup_buf_len == UUP_BUF_SIZE) {
				SpiNorBurn(uup_buf, uup_file_offset, UUP_BUF_SIZE, 0);
				//文件起始部分需要先将头信息里的checksum清0来计算checksum
				if (uup_rev_packet == UUP_BUF_SIZE / UUP_PACKET_SIZE) {
					if (uup_file_type == UPFILE_TYPE_WHOLE) {
						UpFileHeader *pheader = (UpFileHeader *)uup_buf;
						pheader->checksum = 0;
					} else if (uup_file_type == UPFILE_TYPE_RESOURCE) {
						RomHeader *pheader = (RomHeader *)uup_buf;
						pheader->checksum = 0;					
					} else if (uup_file_type == UPFILE_TYPE_ANIMATION) {
						BANIHEADER *pheader = (BANIHEADER *)uup_buf;
						pheader->checksum = 0;
					} else if (uup_file_type == UPFILE_TYPE_APP) {
						unsigned int *tmp = (unsigned int *)(uup_buf + APPLDR_CHECKSUM_OFFSET);
						*tmp = 0;
					}
				}
				calc_checksum = xcrc32(uup_buf, UUP_BUF_SIZE, calc_checksum);
				uup_buf_len = 0;
				uup_file_offset += UUP_BUF_SIZE;
				uup_rev_len += UUP_BUF_SIZE;
				update_progress_set(uup_rev_len * 100 / uup_file_size);
			}
			break;
		case UART_FRAME_FINISH:
			buf = rx_frame.buf;
			if (!buf[0]) {
				SendUartString("update end with error!\n");
				uart_send_ack(rx_frame.type, UUP_ACK_FAIL);
				uup_status = UUP_STATE_END;
				break;
			}
			if (uup_file_type < UPFILE_TYPE_SPILDR) {
				if (uup_buf_len) {
					SpiNorBurn(uup_buf, uup_file_offset, uup_buf_len, 0);
					//如果升级文件小于UUP_BUF_SIZE，此时收到的是文件起始部分
					if (uup_rev_packet < UUP_BUF_SIZE / UUP_PACKET_SIZE) {
						if (uup_file_type == UPFILE_TYPE_WHOLE) {
							UpFileHeader *pheader = (UpFileHeader *)uup_buf;
							pheader->checksum = 0;
						} else if (uup_file_type == UPFILE_TYPE_RESOURCE) {
							RomHeader *pheader = (RomHeader *)uup_buf;
							pheader->checksum = 0;					
						} else if (uup_file_type == UPFILE_TYPE_ANIMATION) {
							BANIHEADER *pheader = (BANIHEADER *)uup_buf;
							pheader->checksum = 0;
						} else if (uup_file_type == UPFILE_TYPE_APP) {
							unsigned int *checksum = (unsigned int *)(uup_buf + APPLDR_CHECKSUM_OFFSET);
							*checksum = 0;						
						}
					}
					calc_checksum = xcrc32(uup_buf, uup_buf_len, calc_checksum);
				}
				if (calc_checksum == checksum) {
					SendUartString("update finish!\n");
					update_progress_set(100);
					sysinfo->update_status = UPDATE_STATUS_END;
					SaveSysInfo(sysinfo);
					uart_send_ack(rx_frame.type, UUP_ACK_OK);
				} else {
					SendUartString("update checksum fail!\n");
					uart_send_ack(rx_frame.type, UUP_ACK_FAIL);
				}
			} else {
				unsigned int *tmp = (unsigned int *)(uup_buf + APPLDR_CHECKSUM_OFFSET);
				checksum = *tmp;
				*tmp = 0;
				calc_checksum = xcrc32(uup_buf, uup_buf_len, calc_checksum);
				if (calc_checksum == checksum) {
					if (!SpiNorBurn(uup_buf, uup_file_offset, uup_buf_len, 1)) {
						if (uup_file_type == UPFILE_TYPE_STEPLDR)
							sysinfo->stepldr_size = uup_buf_len;
						sysinfo->update_status = UPDATE_STATUS_END;
						SaveSysInfo(sysinfo);
						uart_send_ack(rx_frame.type, UUP_ACK_OK);
					} else {
						SendUartString("burn loader fail!\n");
						uart_send_ack(rx_frame.type, UUP_ACK_FAIL);
					}
				} else {
					SendUartString("update checksum fail!\n");
					uart_send_ack(rx_frame.type, UUP_ACK_FAIL);
				}
			}
			uup_status = UUP_STATE_END;		
			break;
		}
	} while (uup_status != UUP_STATE_END);
}