995 lines
22 KiB
C
995 lines
22 KiB
C
#include "ls1c102_ptimer.h"
|
|
#include "ls1x_common.h"
|
|
#include "ls1x_gpio.h"
|
|
#include "ls1x_exti.h"
|
|
#include "ls1x_latimer.h"
|
|
#include "ls1x_rtc.h"
|
|
#include "ls1c102_touch.h"
|
|
#include "ls1x_string.h"
|
|
#include "ls1x_wdg.h"
|
|
#include "ls1x_uart.h"
|
|
#include "ls1x_spi.h"
|
|
#include "ls1c102_i2c.h"
|
|
#include "Config.h"
|
|
extern void cpu_sleep(void);
|
|
extern void dma_start(INT32U source, INT32U count, INT32U mode);
|
|
extern void dma_reset(void);
|
|
unsigned int str2num(unsigned char *);
|
|
int do_nothing()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int do_d1(int argc, void *argv[])
|
|
{
|
|
if((argc < 2)||(argc > 3))
|
|
{
|
|
printf("\n usage: d1 <addr> <num>\n\r");
|
|
return 1;
|
|
}
|
|
uint32_t addr;
|
|
int i, num;
|
|
addr = str2num(argv[1]);
|
|
if(argc == 2) num = 1;
|
|
else num = str2num(argv[2]);
|
|
|
|
for(i=0; i<num; i++)
|
|
{
|
|
if((i%8) == 0)
|
|
printf("\n 0x%08x:\t", addr+i);
|
|
printf(" %02x ", *(volatile uint8_t*)(addr+i));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int do_d4(int argc, void *argv[])
|
|
{
|
|
if((argc < 2)||(argc > 3))
|
|
{
|
|
printf("\n usage: d4 <addr> <num>\n\r");
|
|
return 1;
|
|
}
|
|
unsigned int addr;
|
|
int i, num;
|
|
|
|
addr = str2num(argv[1]);
|
|
if(argc == 2) num = 1;
|
|
else num = str2num(argv[2]);
|
|
|
|
for(i=0; i<num; i++)
|
|
{
|
|
if((i%4) == 0)
|
|
printf("\n0x%08x:\t", addr+i*4);
|
|
printf(" %08x ", *(volatile unsigned int*)(addr+i*4));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int do_m1(int argc, void *argv[])
|
|
{
|
|
unsigned int addr;
|
|
unsigned char value;
|
|
if(argc != 3)
|
|
{
|
|
printf("\n usage: m1 <addr> <value>\n\r");
|
|
return 1;
|
|
}
|
|
addr = str2num(argv[1]);
|
|
value = (unsigned char)str2num(argv[2]);
|
|
*(volatile unsigned char*)(addr) = value;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int do_m4(int argc, void *argv[])
|
|
{
|
|
unsigned int addr;
|
|
unsigned int value;
|
|
if(argc != 3)
|
|
{
|
|
printf("\n usage: m4 <addr> <value>\n\r");
|
|
return 1;
|
|
}
|
|
addr = str2num(argv[1]);
|
|
value = str2num(argv[2]);
|
|
*(volatile unsigned int*)(addr) = value;
|
|
|
|
return 0;
|
|
}
|
|
|
|
unsigned int str2num(unsigned char *s)
|
|
{
|
|
unsigned int num = 0;
|
|
unsigned int radix;
|
|
unsigned int chr;
|
|
|
|
unsigned int i;
|
|
if((*(s)=='0') && (*(s+1)=='x' || *(s+1)=='X'))
|
|
{
|
|
i = 2;
|
|
radix = 16;
|
|
}
|
|
else if(*(s)=='0')
|
|
{
|
|
i = 1;
|
|
radix = 8;
|
|
}
|
|
else
|
|
{
|
|
i = 0;
|
|
radix = 10;
|
|
}
|
|
|
|
for(; *(s+i)!='\0'; i++)
|
|
{
|
|
chr = *(s+i);
|
|
switch(radix){
|
|
case 16:
|
|
if(chr>='0' && chr<='9')
|
|
num = num*radix + (chr - '0');
|
|
else if(chr>='a' && chr<='f')
|
|
num = num*radix + (chr - 'a' + 10);
|
|
else if(chr>='A' && chr<='F')
|
|
num = num*radix + (chr - 'A' + 10);
|
|
else
|
|
printf("illegal hex number...\n");
|
|
break;
|
|
case 10:
|
|
case 8:
|
|
if(chr>='0' && chr<('0'+radix))
|
|
num = num*radix + (chr - '0');
|
|
else
|
|
printf("illegal number...\n");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return num;
|
|
}
|
|
|
|
/*VPWM:0xbfec0020 0x309817b0 single signal period/2 */
|
|
/*VPWM:0xbfec0020 0x70a817b0 double signal period/2*/
|
|
/*VPWM:0xbfec0020 0x72980ff0 16Khz*/
|
|
|
|
int v_play(int argc, void *argv[])
|
|
{
|
|
if(argc != 3)
|
|
{
|
|
printf("\n usage: v <addr> <num>\n\r");
|
|
return 1;
|
|
}
|
|
unsigned int addr, count;
|
|
addr = str2num(argv[1]);
|
|
count = str2num(argv[2]);
|
|
|
|
dma_reset();
|
|
printf("VPWM dma ad test started \n");
|
|
dma_start(addr, count, 0x1);
|
|
printf("VPWM dma ad test end\n");
|
|
return 0;
|
|
}
|
|
// touch show
|
|
int touch_reg_show()
|
|
{
|
|
printf("\nTsensor:\n");
|
|
printf("TS_Ctrl = 0x%8x\n", TS_CTRL);
|
|
printf("TS_OscTh = 0x%8x\n", TS_OSCTH);
|
|
printf("TS_PollTim = 0x%8x\n", TS_POLLTIM);
|
|
printf(" ChnAttr CntRes\n");
|
|
int i;
|
|
for (i=0; i<12; i++)
|
|
printf("[%2d] = 0x%8x 0x%8x\n", i, TS_CHNATTR(i), TS_CNTRES(i));
|
|
return 0;
|
|
}
|
|
int touch_value_show()
|
|
{
|
|
printf("\n 00 01 02 03 04 05 06 07 08 09 10 11\n");
|
|
int i;
|
|
printf("basval");
|
|
for (i=0; i<12 ; i++)
|
|
printf(" %4d", TOUCH_GetBaseVal(i));
|
|
printf("\ncntval");
|
|
for (i=0; i<12; i++)
|
|
printf(" %4d", TOUCH_GetCountValue(i));
|
|
return 0;
|
|
}
|
|
|
|
int touch_test(int argc, void *argv[])
|
|
{
|
|
if (!strcmp("init",argv[1]))
|
|
{
|
|
if (argc != 3)
|
|
{
|
|
printf("\n touch init <down_th>.");
|
|
return 1;
|
|
}
|
|
printf("\n Touch Init");
|
|
INT8U down_th = str2num(argv[2]);
|
|
TOUCH_Init(down_th);
|
|
}
|
|
else if (!strcmp("scan",argv[1]) & argc==2)
|
|
{
|
|
printf("\n Touch Scan");
|
|
TOUCH_EnableSingleScan();
|
|
Printf_CountVal();
|
|
}
|
|
else if (!strcmp("down",argv[1]))
|
|
{
|
|
printf("\n Touch DownTh");
|
|
INT8U down_th = str2num(argv[2]);
|
|
INT8U channel;
|
|
if(argc == 3) //All Channel
|
|
{
|
|
for(channel=0; channel<CHANNEL_NUM; channel++)
|
|
{
|
|
TOUCH_SetDownTh(channel, down_th);
|
|
}
|
|
}
|
|
else if (argc == 4) //Single Channel
|
|
{
|
|
channel = str2num(argv[3]);
|
|
{
|
|
TOUCH_SetDownTh(channel, down_th);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf("\n touch down <down_th> <channel>");
|
|
return 1;
|
|
}
|
|
}
|
|
else if (!strcmp("poll",argv[1]) & argc==2)
|
|
{
|
|
printf("\n Touch Poll.");
|
|
TOUCH_EnablePollScan();
|
|
}
|
|
else if (!strcmp("show",argv[1]) & argc==2)
|
|
{
|
|
touch_reg_show();
|
|
touch_value_show();
|
|
}
|
|
else
|
|
{
|
|
printf("\n Input Error.");
|
|
printf("\nUsage: touch init <down_th> \
|
|
\n touch down <down_th> <channel> \
|
|
\n touch scan \
|
|
\n touch poll \
|
|
\n touch show");
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int hpet(int argc, void *argv[])
|
|
{
|
|
printf("\r\n hpet timer start....\n");
|
|
|
|
uint32_t periodic,cmp,stp;
|
|
if(argc < 4)
|
|
{
|
|
TIM_Cmd(0);
|
|
TIM_ITConfig(0);
|
|
printf("\r\n Usage: hpet <periodic> <start_ms> <sec>");
|
|
return 1;
|
|
}
|
|
|
|
periodic = str2num(argv[1]);
|
|
cmp = str2num(argv[2]);
|
|
stp = str2num(argv[3]);
|
|
|
|
TIM_InitTypeDef TIM_InitStruct;
|
|
|
|
TIM_StructInit(&TIM_InitStruct);
|
|
|
|
TIM_InitStruct.TIME_PERIODIC = periodic << 2;
|
|
TIM_InitStruct.TIME_CMP = cmp * 7999;
|
|
TIM_InitStruct.TIME_STP = stp * 8000000;
|
|
|
|
TIM_Init(&TIM_InitStruct);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
int latimer(int argc, void *argv[])
|
|
{
|
|
uint32_t sec;
|
|
printf("\r\n core timer start....argc:%d\n",argc);
|
|
|
|
if(argc < 2)
|
|
{
|
|
Set_Timer_stop();
|
|
printf("\r\n Usage: latimer <sec>");
|
|
return 1;
|
|
}
|
|
|
|
sec = str2num(argv[1]);
|
|
//Set_Timer_Init(sec*8000000);
|
|
Set_Timer_Init(sec*10667000);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int delay(int argc, void *argv[])
|
|
{
|
|
|
|
uint32_t flags,val;
|
|
|
|
if(argc < 3)
|
|
{
|
|
printf("\r\n Usage: delay <mode:1:us,2:ms,3:s> <val>");
|
|
return 1;
|
|
}
|
|
|
|
flags = str2num(argv[1]);
|
|
val = str2num(argv[2]);
|
|
|
|
if (flags == 1)
|
|
{
|
|
delay_us(val);
|
|
printf("\r\n%dus",val);
|
|
}
|
|
else if (flags == 2) {
|
|
|
|
delay_ms(val);
|
|
printf("\r\n%dms",val);
|
|
}else if (flags == 3){
|
|
|
|
delay_s(val);
|
|
printf("\r\n%ds",val);
|
|
}else {
|
|
printf("\r\n Usage: delay <mode:1:us,2:ms,3:s> <val>");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int wakeup(int argc, void *argv[])
|
|
{
|
|
uint32_t sec;
|
|
printf("\r\nTimer Wake Up start....argc:%d\n",argc);
|
|
DisableInt();
|
|
if(argc < 2)
|
|
{
|
|
Wake_Set(0);
|
|
printf("\r\n Usage: wakeup <sec>");
|
|
return 1;
|
|
}
|
|
|
|
sec = str2num(argv[1]);
|
|
Wake_Set(sec);
|
|
cpu_sleep();
|
|
|
|
return 0;
|
|
}
|
|
|
|
uint32_t a_to_n(uint8_t chr) //ascii to number
|
|
{
|
|
if (chr < 0x30 || chr > 0x39)
|
|
{
|
|
printf("\r\nwrong range of number!\r\n");
|
|
return -1;
|
|
}
|
|
return (chr & 0x0f);
|
|
}
|
|
|
|
|
|
/***rtc test***/
|
|
int date (int argc, void* argv[])
|
|
{
|
|
printf("\r\n");
|
|
char *param_str [4] = {"-h", "-s", "-i", "-f"};
|
|
if (!strcmp(argv[1], param_str[0]))
|
|
{
|
|
printf("date to display time. \r\n");
|
|
printf("date -s yy-mm-dd hh:mm:ss to set time.\r\n");
|
|
printf("date -i mm-dd hh:mm:ss to set int.\r\n");
|
|
printf("date -f Hz :input freqency in integer to set prescale.\r\n");
|
|
return 0;
|
|
}
|
|
if (!strcmp(argv[1], param_str[1])) //set time
|
|
{
|
|
if (argc != 4)
|
|
{
|
|
printf("check parameter\r\n");
|
|
return 1;
|
|
}
|
|
uint32_t rtc0, rtc1;
|
|
uint32_t yy, mm, dd, h, m, s;
|
|
uint32_t invalid_param;
|
|
uint8_t *rtc1_str, *rtc0_str;
|
|
tsRtcTime rtc_param;
|
|
rtc1_str = (uint8_t*) argv[2];
|
|
rtc0_str = (uint8_t*) argv[3];
|
|
yy = 10*a_to_n(*(rtc1_str+0))+a_to_n(*(rtc1_str+1));
|
|
mm = 10*a_to_n(*(rtc1_str+3))+a_to_n(*(rtc1_str+4));
|
|
dd = 10*a_to_n(*(rtc1_str+6))+a_to_n(*(rtc1_str+7));
|
|
h = 10*a_to_n(*(rtc0_str+0))+a_to_n(*(rtc0_str+1));
|
|
m = 10*a_to_n(*(rtc0_str+3))+a_to_n(*(rtc0_str+4));
|
|
s = 10*a_to_n(*(rtc0_str+6))+a_to_n(*(rtc0_str+7));
|
|
invalid_param = mm > 12 || mm == 0 || dd > 31 ||
|
|
dd == 0 ||(mm == 2) && (dd > 29) ||
|
|
h > 24 || m > 60 || s > 60 ;
|
|
if (invalid_param)
|
|
{
|
|
printf("invalid param");
|
|
return 1;
|
|
}
|
|
|
|
rtc_param.sec = s;
|
|
rtc_param.min = m;
|
|
rtc_param.hour = h;
|
|
rtc_param.day = dd;
|
|
rtc_param.mon = mm;
|
|
rtc_param.year = yy;
|
|
|
|
RtcUpdateData(0, &rtc_param);
|
|
|
|
}
|
|
else if (!strcmp(argv[1], param_str[2])) //set int
|
|
{
|
|
if (argc != 4)
|
|
{
|
|
printf("check parameter\r\n");
|
|
return 1;
|
|
}
|
|
uint32_t mm, dd, h, m, s;
|
|
uint32_t invalid_param;
|
|
uint8_t *cfg_str0,*cfg_str1;
|
|
tsRtcTime rtc_param;
|
|
cfg_str0 = (uint8_t*) argv[2];
|
|
cfg_str1 = (uint8_t*) argv[3];
|
|
mm = 10*a_to_n(*(cfg_str0+0))+a_to_n(*(cfg_str0+1));
|
|
dd = 10*a_to_n(*(cfg_str0+3))+a_to_n(*(cfg_str0+4));
|
|
h = 10*a_to_n(*(cfg_str1+0))+a_to_n(*(cfg_str1+1));
|
|
m = 10*a_to_n(*(cfg_str1+3))+a_to_n(*(cfg_str1+4));
|
|
s = 10*a_to_n(*(cfg_str1+6))+a_to_n(*(cfg_str1+7));
|
|
invalid_param = mm > 12 || mm == 0 || dd > 31 ||
|
|
dd == 0 ||(mm == 2) && (dd > 29) ||
|
|
h > 24 || m > 60 || s > 60 ;
|
|
if (invalid_param)
|
|
{
|
|
printf("invalid param");
|
|
return 1;
|
|
}
|
|
|
|
rtc_param.sec = s;
|
|
rtc_param.min = m;
|
|
rtc_param.hour = h;
|
|
rtc_param.day = dd;
|
|
rtc_param.mon = mm;
|
|
|
|
// bsp_rtc_alarm_set(&rtc_param);
|
|
return 0;
|
|
}
|
|
else if (!strcmp(argv[1], param_str[3])) //set prescale
|
|
{
|
|
uint32_t freq_in = str2num(argv[2]);
|
|
if (freq_in <30000 | freq_in > 50000)
|
|
{
|
|
printf("\r\nshould be close to 32768 Hz\r\n");
|
|
return 1;
|
|
}
|
|
uint32_t freq, freq_int, freq_frac;
|
|
freq_int=freq_in >> 4;
|
|
freq_frac = freq_in%16;
|
|
//RTC_FREQ = freq;
|
|
return 0;
|
|
}
|
|
else // or display time
|
|
{
|
|
if (argc != 1)
|
|
printf("date -h for usage\r\n");
|
|
uint32_t yy, mm, dd, h, m, s;
|
|
tsRtcTime rtc_param;
|
|
|
|
RtcUpdateData(1,&rtc_param);
|
|
|
|
yy = rtc_param.year;
|
|
mm = rtc_param.mon;
|
|
dd = rtc_param.day;
|
|
h = rtc_param.hour;
|
|
m = rtc_param.min;
|
|
s = rtc_param.sec;
|
|
printf("20%02d-%02d-%02d ", yy, mm, dd);
|
|
printf("%02d:%02d:%02d", h, m, s);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int watch_dog(int argc, void *argv[])
|
|
{
|
|
uint32_t sec;
|
|
printf("\r\nwdg test start....argc:%d\n",argc);
|
|
|
|
if(argc < 2)
|
|
{
|
|
WDG_DogFeed();
|
|
printf("\r\n Usage: wdg <sec>");
|
|
return 1;
|
|
}
|
|
|
|
sec = str2num(argv[1]);
|
|
WDG_SetWatchDog(sec);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int i2cp (int argc, void *argv[])
|
|
{
|
|
I2C_InitTypeDef I2C_InitStruct;
|
|
I2C_StructInit(&I2C_InitStruct);
|
|
I2C_Init(I2C,&I2C_InitStruct);
|
|
}
|
|
|
|
int i2cw (int argc, void *argv[])
|
|
{
|
|
if (argc !=4)
|
|
{
|
|
printf("\n usage: i2cw <chipaddr> <regaddr> <wdata>\n");
|
|
return 1;
|
|
}
|
|
printf ("\r\n");
|
|
|
|
unsigned char chipaddr, regaddr, wdata;
|
|
chipaddr = str2num(argv[1]);
|
|
regaddr = str2num(argv[2]);
|
|
wdata = str2num(argv[3]);
|
|
unsigned short addr = ((chipaddr & 0xff) <<7) | regaddr & 0xff;
|
|
printf("wdata=0x%x",wdata);
|
|
printf("addr=0x%x",addr);
|
|
CAT24_Write(addr,wdata);
|
|
return 0;
|
|
}
|
|
|
|
int i2cr (int argc, void *argv[])
|
|
{
|
|
if (argc !=3)
|
|
{
|
|
printf("\n usage: i2cr<chipaddr><regaddr>\n");
|
|
return 1;
|
|
}
|
|
|
|
unsigned int chipaddr, regaddr, rdata;
|
|
chipaddr = str2num(argv[1]);
|
|
regaddr = str2num(argv[2]);
|
|
uint8_t read_data;
|
|
unsigned short addr = ((chipaddr & 0xff) <<7) | regaddr & 0xff;
|
|
read_data = CAT24_Read(addr);
|
|
printf("\r\n rdata 0x%02x\r\n", read_data);
|
|
return 0;
|
|
}
|
|
|
|
int adc(int argc, void* argv[])
|
|
{
|
|
uint32_t sel = str2num(argv[1]);
|
|
uint32_t div = str2num(argv[2]);
|
|
uint32_t wrong = ( sel>7 || div>2 || (argc<3 || argc>4) );
|
|
volatile uint32_t times = str2num(argv[3]);
|
|
uint32_t r;
|
|
if (wrong) {
|
|
printf("\r\nADC <sel> <div> <times>");
|
|
printf("\r\nsel: (0)ADC_I0, (1)ADC_I1, (2)VRCAP, (3)1.0V, (4)VROUT, (5)1.0V(vr1), (6)vref, (7)dacamc");
|
|
printf("\r\ndiv: 0: d2, 1: d4");
|
|
return 1;
|
|
}
|
|
PMU_CMDSTS = 0x8000; // IT en
|
|
while(times){
|
|
PMU_AdcCtrl = (div << 4) + sel; // ADC config
|
|
PMU_AdcCtrl |= 0x100; // run
|
|
uint32_t res = PMU_AdcDat;
|
|
printf("\r\ncalculate%d", (res*3350)>>12); // VDD: 3350 mV
|
|
times--;
|
|
}
|
|
PMU_CMDSTS &= (~0x8000); // IT dis
|
|
return 0;
|
|
}
|
|
|
|
int batdet (int argc, void* argv[])
|
|
{
|
|
if (argc != 2)
|
|
{
|
|
printf("\n usage: batdet <n> 0 ADC_I0, 1 GPIO0, 2 GPIO1\n");
|
|
return 1;
|
|
}
|
|
uint32_t bat_det_sel = str2num(argv[1]);
|
|
if (bat_det_sel ==0)
|
|
{
|
|
PMU_CHIPCTRL |= 0x20000;
|
|
}
|
|
if (bat_det_sel < 3)
|
|
{
|
|
switch (bat_det_sel) {
|
|
case 0:
|
|
PMU_CHIPCTRL &= 0xFCFFFFFF;
|
|
break;
|
|
case 1:
|
|
PMU_CHIPCTRL &= 0xFCFFFFFF;
|
|
PMU_CHIPCTRL |= (2 << 24);
|
|
break;
|
|
case 2:
|
|
PMU_CHIPCTRL &= 0xFCFFFFFF;
|
|
PMU_CHIPCTRL |= (3 << 24);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf("\r\nwrong parameter");
|
|
return 1;
|
|
}
|
|
PMU_CMDSTS = 0x800; // IT config
|
|
return 0;
|
|
}
|
|
|
|
#define ERASE_CMD 0xa0000000
|
|
#define PAGE_CMD 0xe0000000
|
|
#define CLRPL_CMD 0x40000000
|
|
#define UPKEY_CMD 0xf0000000
|
|
#define UPBND_CMD 0x90000000
|
|
#define VERIF_CMD 0x10000000
|
|
#define TESTK_CMD 0x20000000
|
|
#define INTCLR_CMD 0x30000000
|
|
#define SLEEP_CMD 0xc0000000
|
|
int copy()
|
|
{
|
|
FLASH_CAH_REG = 0xffffffff;
|
|
FLASH_CAL_REG = 0xffffffff;
|
|
int i, j;
|
|
FLASH_PET_REG = 0x10;
|
|
for (i=0xbf000000;i<0xbf020000;i=i+0x80)
|
|
{
|
|
FLASH_CMD_REG = ERASE_CMD|(i & 0x3ffff);
|
|
WDG_DogFeed();
|
|
printf(".");
|
|
FLASH_CMD_REG = CLRPL_CMD;
|
|
for (j=i;j<i+0x80;j=j+4)
|
|
{
|
|
*(volatile unsigned int*)(j) = *(volatile unsigned int*)(j-0x1000000);
|
|
if (j == 0xbf000000)
|
|
{
|
|
// printf("0xbf000000: %x\n",*(volatile unsigned int*)(j));
|
|
}
|
|
}
|
|
FLASH_CMD_REG = PAGE_CMD|(i & 0x3ffff);
|
|
}
|
|
|
|
for (i=0xbf000000;i<0xbf020000;i=i+0x80)
|
|
{
|
|
for (j=i;j<i+0x80;j=j+4)
|
|
{
|
|
if (*(volatile unsigned int*)(j) != *(volatile unsigned int*)(j-0x1000000))
|
|
{
|
|
printf("copy error\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int uart_init(int argc, void *argv[])
|
|
{
|
|
if (argc != 2)
|
|
{
|
|
printf("\n usage: uinit <1/2> \n");
|
|
return 1;
|
|
}
|
|
|
|
uint32_t num = str2num(argv[1]);
|
|
if(num == 1)
|
|
{
|
|
Uart_init(UART1);
|
|
}
|
|
else if(num == 2)
|
|
{
|
|
Uart_init(UART2);
|
|
}
|
|
else
|
|
{
|
|
printf("\n usage: uinit <1/2> \n");
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if 0
|
|
int uart_tx(int argc, void *argv[])
|
|
{
|
|
if (argc != 2)
|
|
{
|
|
printf("\n usage: uart_tx <1/2> \n");
|
|
return 1;
|
|
}
|
|
uint32_t num = str2num(argv[1]);
|
|
|
|
if(num == 1)
|
|
{
|
|
uart1_printf("\r\nThis uart 1 tx test");
|
|
}else if(num == 2)
|
|
{
|
|
uart2_printf("\r\nThis uart 2 tx test");
|
|
}
|
|
else
|
|
{
|
|
printf("\n usage: utx <1/2> \n");
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
int uart_rx(int argc, void *argv[])
|
|
{
|
|
if (argc != 2)
|
|
{
|
|
printf("\n usage: uart_rx <1/2> \n");
|
|
return 1;
|
|
}
|
|
uint32_t num = str2num(argv[1]);
|
|
|
|
if(num == 1)
|
|
{
|
|
while(1)
|
|
{
|
|
char c1;
|
|
c1 = uart1_getchar();
|
|
if (c1 == 0x3)
|
|
{
|
|
printf("\r\nThis uart 1 rx test exit");
|
|
break;
|
|
}
|
|
}
|
|
|
|
}else if(num == 2)
|
|
{
|
|
while(1)
|
|
{
|
|
char c2;
|
|
c2 = uart2_getchar();
|
|
if (c2 == 0x3)
|
|
{
|
|
printf("\r\nThis uart 2 rx test exit");
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
printf("\n usage: urx <1/2> \n");
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|
|
void sleep(uint8_t sflags)
|
|
{
|
|
|
|
while(!(PMU_CMDSTS & 0x1));/*wail till can sleep*/
|
|
|
|
PMU_CMDW = 0x1ff0000;/*clear int*/
|
|
|
|
/*sflags=1 wakeup immediately,others do not wakeup*/
|
|
if(sflags)
|
|
{
|
|
Wake_Set(5);/*5s*/
|
|
}
|
|
else
|
|
{
|
|
#ifdef ATE_RUN
|
|
PMU_GPIOA_O = 0xffffffff;
|
|
PMU_GPIOB_OE = 0xfc;
|
|
PMU_GPIOB_O = PMU_GPIOB_O | 0xffffff03;
|
|
|
|
#else
|
|
PMU_GPIOA_OE = 0x0;
|
|
PMU_GPIOB_OE = 0x0;
|
|
PMU_GPIOA_OE = 0xffffffff;
|
|
PMU_GPIOB_OE = 0xffffffff;
|
|
#endif
|
|
|
|
}
|
|
|
|
cpu_sleep();
|
|
}
|
|
|
|
int spi_init(int argc, void* argv[])
|
|
{
|
|
uint16_t flash_id;
|
|
SPI->SPCR = 0x52; // enable mstr
|
|
SPI->PARAM = 0x20; // ~memory_en
|
|
|
|
flash_id = Spiflash_Rdid();
|
|
printf("\r\nid=0x%x\r\n",flash_id);
|
|
// SPI->PARAM = 0x23; // ~memory_en
|
|
}
|
|
|
|
int spi_write(int argc, void* argv[])
|
|
{
|
|
if (argc != 2)
|
|
{
|
|
printf("\n usage: swrite <addr> \n");
|
|
return 1;
|
|
}
|
|
uint32_t addr = str2num(argv[1]);
|
|
uint32_t i,k,j=0,count;
|
|
uint8_t *data;
|
|
|
|
printf("\n write start\n");
|
|
count = 512;
|
|
for(k=0;k<count;k++)
|
|
{
|
|
j=k*0x100;
|
|
for(i=0;i<0x100;i++)
|
|
{
|
|
data[i] = *(volatile uint8_t*)(0xbf000000+j+i);
|
|
}
|
|
printf(". ");
|
|
Spiflash_Page_Program(addr+j,data,0x100);
|
|
}
|
|
printf("\n");
|
|
return 0;
|
|
|
|
}
|
|
int spi_read(int argc, void* argv[])
|
|
{
|
|
if (argc != 2)
|
|
{
|
|
printf("\n usage: sread <addr> \n");
|
|
return 1;
|
|
}
|
|
uint32_t addr = str2num(argv[1]);
|
|
uint32_t i,j=0,k,count;
|
|
uint8_t* data;
|
|
printf("\n read start\n");
|
|
count = 512;
|
|
for(k=0;k<count;k++)
|
|
{
|
|
j=k*0x100;
|
|
Spiflash_Read_Bytes(addr+j, data, 0x100);
|
|
for(i=0;i<0x100;i++)
|
|
{
|
|
if(data[i] != *(volatile uint8_t*)(0xbf000000+j+i))
|
|
{
|
|
printf("\ncheck error rdata=%x iaddr=%x\n",data[i],0xbf000000+j+i);
|
|
break;
|
|
}
|
|
}
|
|
printf(". ");
|
|
}
|
|
|
|
printf("\n");
|
|
return 0;
|
|
}
|
|
|
|
|
|
int spi_erase(int argc, void* argv[])
|
|
{
|
|
if (argc != 2)
|
|
{
|
|
printf("\n usage: serase <addr> \n");
|
|
return 1;
|
|
}
|
|
uint32_t addr = str2num(argv[1]);
|
|
printf("\n erase start\n");
|
|
Spiflash_Block64k_Erase(addr);
|
|
Spiflash_Block64k_Erase(addr+0x10000);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int spi_flash(int argc, void* argv[])
|
|
{
|
|
uint8_t *data;
|
|
uint16_t flash_id;
|
|
uint32_t addr = 0x0;
|
|
uint32_t i,k,j=0,count;
|
|
|
|
SPI->SPCR = 0x52; // enable mstr
|
|
SPI->PARAM = 0x20; // ~memory_en
|
|
/*Get flash id*/
|
|
flash_id = Spiflash_Rdid();
|
|
printf("\r\nid=0x%x\r\n",flash_id);
|
|
/*Erase chip*/
|
|
Spiflash_Block64k_Erase(addr);
|
|
Spiflash_Block64k_Erase(addr+0x10000);
|
|
/*Program */
|
|
printf("program start\n");
|
|
count = 512;
|
|
for(k=0;k<count;k++)
|
|
{
|
|
j=k*0x100;
|
|
for(i=0;i<0x100;i++)
|
|
{
|
|
data[i] = *(volatile uint8_t*)(0xbf000000+j+i);
|
|
}
|
|
Spiflash_Page_Program(addr+j,data,0x100);
|
|
printf(". ");
|
|
}
|
|
printf("\r\nprogram done\n");
|
|
printf("\r\ncheckout start\n");
|
|
count = 512;
|
|
for(k=0;k<count;k++)
|
|
{
|
|
j=k*0x100;
|
|
Spiflash_Read_Bytes(addr+j, data, 0x100);
|
|
for(i=0;i<0x100;i++)
|
|
{
|
|
if(data[i] != *(volatile uint8_t*)(0xbf000000+j+i))
|
|
{
|
|
printf("\ncheck error rdata=%x iaddr=%x\n",data[i],0xbf000000+j+i);
|
|
break;
|
|
}
|
|
}
|
|
printf(". ");
|
|
}
|
|
printf("\r\ncheck done\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int gpio_int_test(void)
|
|
{
|
|
AFIO_RemapConfig(AFIOA, GPIO_Pin_1, GPIO_FUNC_GPIO);
|
|
AFIO_RemapConfig(AFIOC, GPIO_Pin_3, GPIO_FUNC_GPIO);
|
|
EXTI_InitTypeDef exti_gpio;
|
|
EXTI_StructInit(&exti_gpio);
|
|
|
|
exti_gpio.EXTI_GPIO = IRQ_GPIO_A1|IRQ_GPIO_C3;/*GPIOA1,GPIOC3*/
|
|
exti_gpio.EXTI_Mode = EXTI_Mode_Edge;
|
|
exti_gpio.EXTI_Trigger = EXTI_Trigger_Rising_High;
|
|
exti_gpio.EXTI_GpioCmd = ENABLE;
|
|
|
|
EXTI_Init(EXTI, &exti_gpio);
|
|
}
|
|
|
|
int gpio_int (int argc, void *argv[])
|
|
{
|
|
gpio_int_test();
|
|
return 0;
|
|
}
|
|
|
|
int tmp(int argc, void *argv[])
|
|
{
|
|
uint32_t tmp =0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int copy_iram(int argc, void *argv[])
|
|
{
|
|
unsigned int j;
|
|
printf("\r\ncopyiram start\r\n");
|
|
for (j = 0x0;j < 0x2000; j=j + 4)
|
|
{
|
|
*(volatile unsigned int*)(0x80000000+j) = 0x0;
|
|
}
|
|
|
|
for (j = 0x0;j < 0x2000; j=j + 4)
|
|
{
|
|
*(volatile unsigned int*)(0x80000000+j) = *(volatile unsigned int*)(0xbe010000 + j);
|
|
}
|
|
for (j = 0x0;j < 0x2000; j=j + 4)
|
|
{
|
|
if(*(volatile unsigned int*)(0x80000000+j) != *(volatile unsigned int*)(0xbe010000 + j))
|
|
{
|
|
printf("copy error %x,%x,%x\n",j,*(volatile unsigned int*)(0x80000000+j), *(volatile unsigned int*)(0xbe010000 + j));
|
|
}
|
|
}
|
|
asm volatile (\
|
|
"li.w $r12, 0x80000000;\n" \
|
|
"jirl $r0, $r12 , 0x0;\n"\
|
|
);
|
|
|
|
return 0;
|
|
}
|