void mtk_uart_init (U32 uartclk, U32 baudrate)
{
//#define AP_PERI_GLOBALCON_RST0 (PERI_CON_BASE+0x0)
#define AP_PERI_GLOBALCON_PDN0 (0x10000084)
/* uartclk != 0, means use custom bus clock; uartclk == 0, means use defaul bus clk */
if(0 == uartclk){ // default bus clk
//uartclk = mtk_get_bus_freq()*1000/4;
uartclk = UART_SRC_CLK;
}
mtk_serial_set_current_uart(CFG_UART_META);
//PDN_Power_CONA_DOWN(PDN_PERI_UART1, 0);
//UART_CLR_BITS(1 << 0, AP_PERI_GLOBALCON_RST0); /* Release UART1 reset signal */
//UART_SET_BITS(1 << 24, AP_PERI_GLOBALCON_PDN0); /* Power on UART1 */
//UART_CLR_BITS(1 << 10, AP_PERI_GLOBALCON_PDN0); /* Power on UART1 */
mtk_uart_power_on(CFG_UART_META);
UART_SET_BITS(UART_FCR_FIFO_INIT, UART_FCR(g_uart)); /* clear fifo */
UART_WRITE16(UART_NONE_PARITY | UART_WLS_8 | UART_1_STOP, UART_LCR(g_uart));
serial_setbrg(uartclk, CFG_META_BAUDRATE);
mtk_serial_set_current_uart(CFG_UART_LOG);
//PDN_Power_CONA_DOWN(PDN_PERI_UART4, 0);
//UART_SET_BITS(1 << 12, APMCU_CG_CLR0);
//UART_CLR_BITS(1 << 3, AP_PERI_GLOBALCON_RST0); /* Release UART2 reset signal */
//UART_SET_BITS(1 << 27, AP_PERI_GLOBALCON_PDN0); /* Power on UART2 */
//UART_CLR_BITS(1 << 11, AP_PERI_GLOBALCON_PDN0); /* Power on UART2 */
mtk_uart_power_on(CFG_UART_LOG);
UART_SET_BITS(UART_FCR_FIFO_INIT, UART_FCR(g_uart)); /* clear fifo */
UART_WRITE16(UART_NONE_PARITY | UART_WLS_8 | UART_1_STOP, UART_LCR(g_uart));
serial_setbrg(uartclk, baudrate);
}
/*============================================================================*/
void uart_handshake_init(void)
{
/* switch to meta port */
mtk_serial_set_current_uart(CFG_UART_META);
/* if meta and log ports are SAME, need to re-init meta port with
* different baudrate and disable log output during handshake to avoid
* influence.
*/
if (CFG_UART_META == CFG_UART_LOG) {
/* to prevent sync error with PC */
gpt_busy_wait_us(160);
/* init to meta baudrate */
mtk_uart_init(UART_SRC_CLK_FRQ, CFG_META_BAUDRATE);
/* disable log so that log message will be kept in log buffer */
log_buf_ctrl(0);
log_ctrl(0);
}
/* send meta ready to tool via meta port first then let meta port to listen
* meta response in the background to reduce the handshake wait time later.
*/
uart_send((u8*)HSHK_COM_READY, strlen(HSHK_COM_READY));
mtk_serial_set_current_uart(CFG_UART_LOG);
g_meta_ready_start_time = get_timer(0);
}
static int uart_send(u8 *buf, u32 len)
{
if (CFG_UART_META != CFG_UART_LOG)
mtk_serial_set_current_uart(CFG_UART_META);
while (len--) {
PutUARTByte(*buf++);
}
if (CFG_UART_META != CFG_UART_LOG)
mtk_serial_set_current_uart(CFG_UART_LOG);
return 0;
}
static int uart_recv(u8 *buf, u32 size, u32 tmo_ms)
{
int ret;
if (CFG_UART_META != CFG_UART_LOG)
mtk_serial_set_current_uart(CFG_UART_META);
ret = GetUARTBytes(buf, size, tmo_ms);
if (CFG_UART_META != CFG_UART_LOG)
mtk_serial_set_current_uart(CFG_UART_LOG);
return ret;
}
static bool uart_handshake_handler(struct bldr_command_handler *handler)
{
bool result = TRUE;
bool avail;
int sync_time;
uint8 buf[HSHK_TOKEN_SZ + 1] = {'\0'};
struct bldr_command cmd;
struct bldr_comport comport;
struct comport_ops uart_ops = {.send = uart_send, .recv = uart_recv};
comport.type = COM_UART;
comport.tmo = UART_SYNC_TIME;
comport.ops = &uart_ops;
sync_time = UART_SYNC_TIME - get_timer(g_meta_ready_start_time);
sync_time = sync_time <= 0 ? 5 : sync_time;
sync_time = sync_time > UART_SYNC_TIME ? UART_SYNC_TIME : sync_time;
/* detect tool existence */
mtk_serial_set_current_uart(CFG_UART_META);
avail = uart_listen(&comport, buf, HSHK_TOKEN_SZ, 1, sync_time);
mtk_serial_set_current_uart(CFG_UART_LOG);
if (!avail) {
result = FALSE;
goto exit;
}
cmd.data = buf;
cmd.len = HSHK_TOKEN_SZ;
result = handler->cb(handler, &cmd, &comport);
exit:
if (CFG_UART_META == CFG_UART_LOG) {
/* enable log message again since no tool is connected */
if (result != TRUE) {
/* init to log baudrate */
mtk_uart_init(UART_SRC_CLK_FRQ, CFG_LOG_BAUDRATE);
/* enable log and flush the log buffer if log message available */
log_ctrl(1);
}
}
print("\n");
print("%s <UART> wait sync time %dms->%dms\n", MOD, UART_SYNC_TIME, sync_time);
print("%s <UART> receieved data: (%s)\n", MOD, buf);
return result;
}
static bool meta_listen_tool(int listen_byte_cnt, int retry_cnt, int wait_time, char* buf)
{
unsigned int start_time = get_timer(0); /* calculate wait time */
char c = 0;
int i = 0;
int rx_cnt = 0;
ulong begin_time = 0;
for(i=0;i<retry_cnt;i++)
{
begin_time = get_timer(0);
while(get_timer(begin_time) < wait_time)
{
/* detect data from tool */
c = serial_nonblock_getc();
if(c!=NULL)
{
buf[rx_cnt]=c;
#ifdef META_DEBUG
mtk_serial_set_current_uart(UART4);
printf("%s rx_cnt : %d\n",META_STR_MOD_PREF,rx_cnt);
printf("%s Receieve data from uart: %c\n",META_STR_MOD_PREF,buf[rx_cnt]);
mtk_serial_set_current_uart(UART1);
#endif
rx_cnt++;
}
if (rx_cnt == listen_byte_cnt)
return TRUE;
}
}
return FALSE;
}
BOOL meta_check_pc_trigger(void)
{
ulong begin = 0;
int i = 0, j =0;
char buf[META_SZ_MAX_PBUF] = "";
int meta_lock = 0;
printf("\n%s Check pc meta boot\n",META_STR_MOD_PREF);
// delay for a while (it could be removed)
for(i=0;i<200;i++);
/* send "READY" to notify tool side */
//printf("%s Send 'READY' to notify tool\n",META_STR_MOD_PREF);
// set uart port to UART1
//mt6577_serial_set_current_uart(UART1);
//puts(META_STR_READY);
mtk_serial_set_current_uart(UART1);//added by Hong-Rong
/* detect tool existence */
meta_listen_tool(META_SZ_MAX_PBUF-1,1,10,buf);
if(buf==NULL)
{
mtk_serial_set_current_uart(UART4);
printf("%s Response timeout\n",META_STR_MOD_PREF);
return;
}
mtk_serial_set_current_uart(UART4);
printf("%s Receieve data from uart1: %s\n",META_STR_MOD_PREF,buf);
/* check "METAMETA", judge whether META mode indicated */
for(i=0;i<META_SZ_MAX_PBUF-sizeof(META_STR_REQ);i++)
{
if (buf[i]!=NULL && !strcmp(buf+i, META_STR_REQ) )
{
//Call API to check if META locked */
meta_lock = UBoot_MetaLock_Check();
if (meta_lock)
{
/* return "LOCK" to ack tool */
mtk_serial_set_current_uart(UART1);
puts(META_LOCK);
for(i=0;i<200;i++);
/* Reset the Target */
printf("META LOCK! Rebooting...");
mtk_wdt_reset();
}
/* return "ATEMATEM" to ack tool */
mtk_serial_set_current_uart(UART1);
puts(META_STR_ACK);
for(i=0;i<200;i++);
mtk_serial_set_current_uart(UART4);
printf("\n");
printf("%s Enable meta mode\n",META_STR_MOD_PREF);
g_boot_mode = META_BOOT;
//video_printf("%s : detect meta mode !\n",META_STR_MOD_PREF);
return TRUE;
}
}
/* check "ADVMETA", judge whether META mode indicated */
for(i=0;i<META_SZ_MAX_PBUF-sizeof(META_ADV_REQ);i++)
{
if (buf[i]!=NULL && !strcmp(buf+i, META_ADV_REQ) )
{
/* Call API to check if META locked */
meta_lock = UBoot_MetaLock_Check();
if (meta_lock)
{
/* return "LOCK" to ack tool */
mtk_serial_set_current_uart(UART1);
puts(META_LOCK);
for(i=0;i<200;i++);
/* Reset the Target */
printf("META LOCK! Rebooting...");
WDT_HW_Reset();
}
/* return "ATEMVDA" to ack tool */
mtk_serial_set_current_uart(UART1);
puts(META_ADV_ACK);
for(i=0;i<200;i++);
mtk_serial_set_current_uart(UART4);
printf("\n");
printf("%s Enable meta mode\n",META_STR_MOD_PREF);
g_boot_mode = ADVMETA_BOOT;
//video_printf("%s : detect meta mode !\n",META_STR_MOD_PREF);
return TRUE;
}
}
/* check "FACTORYM", judge whether ATE mode indicated */
for(i=0;i<ATE_SZ_MAX_PBUF-sizeof(ATE_STR_REQ);i++)
{
if (buf[i]!=NULL && !strcmp(buf+i, ATE_STR_REQ) )
{
/* return "MYROTCAF" to ack tool */
mtk_serial_set_current_uart(UART1);
puts(ATE_STR_ACK);
for(i=0;i<200;i++);
mtk_serial_set_current_uart(UART4);
printf("\n");
printf("%s Enable ate_factory mode\n",ATE_STR_MOD_PREF);
g_boot_mode = ATE_FACTORY_BOOT;
return TRUE;
}
}
return FALSE;
}
