liyepan/La1c102TmpProject
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
liyp
2026-08-25 21:47:54 -04:00
commit c83cd9040d
9 changed files with 2304 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.vscode/launch.json
Vendored
+21
View File
@@ -0,0 +1,21 @@
{
"configurations": [
{
"showDevDebugOutput": "parsed",
"cwd": "${workspaceRoot}",
"executable": "./build/ls1c102_demo.elf",
"name": "Debug LoongArch",
"request": "launch",
"type": "debugger-for-loongarch",
"servertype": "openocd",
"toolchainPrefix":"loongarch32-newlib-elf",
"toolchainPath": "C:/Users/anonymous/Desktop/Embedded/LOONG/LA1C102/LAIDE/buildtool/la32-tool/bin",
"serverpath": "C:/Users/anonymous/Desktop/Embedded/LOONG/LA1C102/LAIDE/openocd/openocd.exe",
"device": "ls1c102",
"configFiles": [
"C:/Users/anonymous/Desktop/Embedded/LOONG/LA1C102/LAIDE/openocd/lalink.cfg",
"C:/Users/anonymous/Desktop/Embedded/LOONG/LA1C102/LAIDE/openocd/ls1c102.cfg"
]
}
]
}
App/Src/main.c
+499
View File
@@ -0,0 +1,499 @@
#include "calIn8M.h"
#include "Config.h"
#include "ls1x_pmu.h"
#include "ls1x_clock.h"
#include "ls1x_common.h"
#include "ls1x_uart.h"
#include "ls1x_wdg.h"
#include "ls1x_string.h"
#include "UserGpio.h"
extern void wakeup_reset(void);
extern int do_d1(int argc,void *argv[]);
extern int do_d4(int argc,void *argv[]);
extern int do_m1(int argc,void *argv[]);
extern int do_m4(int argc,void *argv[]);
extern int v_play(int argc,void *argv[]);
extern int hpet(int argc,void *argv[]);
extern int latimer(int argc,void *argv[]);
extern int delay(int argc, void *argv[]);
extern int wakeup(int argc, void *argv[]);
extern int date(int argc, void* argv[]);
extern int touch_test(int argc, void *argv[]);
extern int watch_dog(int argc, void *argv[]);
extern int i2cp (int argc, void *argv[]);
extern int i2cw (int argc, void *argv[]);
extern int i2cr (int argc, void *argv[]);
extern int adc(int argc, void* argv[]);
extern int batdet(int argc, void* argv[]);
extern int tmp(int argc, void* argv[]);
extern int uart_init (int argc, void *argv[]);
extern int spi_init(int argc, void* argv[]);
extern int spi_erase(int argc, void* argv[]);
extern int spi_write(int argc, void* argv[]);
extern int spi_read(int argc, void* argv[]);
extern int spi_flash(int argc, void* argv[]);
extern int gpio_int(int argc, void* argv[]);
extern int do_nothing();
extern int copy();
extern int copy_iram(int argc, void *argv[]);
extern unsigned int str2num(unsigned char);
// add
int do_help(int argc, void *argv[]);
int do_exit(int argc, void *argv[]);
unsigned int nmi_caller;
static struct cmd_struct {
const char *cmdname;
int (*func)(int, void *[]);
const char *usage;
const char *expression;
} cmd[] __attribute__((section(".rodata"))) = {
{"exit", do_exit, "[exit]", ""},
{"d1", do_d1, "[d1 <addr> <num>]", "--dump address byte"},
{"d4", do_d4, "[d4 <addr> <num>]", "--dump address word"},
{"help", do_help, "[help <command>]", "--cmd list"},
{"m1", do_m1, "[m1 <addr> <value>]", "--modify address byte"},
{"m4", do_m4, "[m4 <addr> <value>]", "--modify address word"},
{"v", v_play, "[v]", "--v1"},
{"touch", touch_test, "[touch]", "--v1"},
{"hpet", hpet, "[timer test]", "--v1"},
{"latimer", latimer, "[core timer test]", "--v1"},
{"delay", delay, "[delay test]", "--v1"},
{"wakeup", wakeup, "[wakeup test]", "--v1"},
{"date", date, "[rtc test]", "--v1"},
{"wdg", watch_dog, "[wdg test]", "--v1"},
{"i2cp", i2cp, "[i2cp <prescale>]", "--i2c prescale"},
{"i2cw", i2cw, "[i2cw <chipaddr> <regaddr> <wdata>]", "--i2c write"},
{"i2cr", i2cr, "[i2cr <chipaddr> <regaddr>]", "--i2c read"},
{"adc", adc, "[adc]", "--adc"},
{"batdet", batdet, "[batdet <n>]", "--v1"},
{"copy", copy, "[spi_flash=>in_flash]", "--v1"},
{"copy_iram", copy_iram, "[copy]", "--batdet <n>"},
{"uinit", uart_init, "[uart init]", "--v1"},
{"spinit", spi_init, "[spi_init]", "--v1"},
{"sperase", spi_erase, "[spi_erase]", "--v1"},
{"spwr", spi_write, "[spi_write]", "--v1"},
{"sprd", spi_read, "[spi_read]", "--v1"},
{"sflash", spi_flash, "[spi_flash]", "--v1"},
{"gpio_int", gpio_int, "[exti]", "--v1"},
{"t", tmp, "[exti]", "--v1"},
//add
{"NULL", do_nothing, "[NULL]", "NULL"}
};
int do_exit(int argc, void *argv[])
{
}
int do_help(int argc, void *argv[])
{
unsigned int i;
char *s;
switch(argc)
{
case 1:
{
printf("\ncommands:\n\n");
for(i=0;strcmp("NULL", cmd[i].cmdname)!=0; i++)
{
printf("\t %2d:%s\n\r",i+1, cmd[i].cmdname);
}
}
break;
case 2:
{
s = (char *)argv[1];
for(i=0; strcmp("NULL", cmd[i].cmdname)!=0; i++)
{
if(strcmp(s, cmd[i].cmdname)==0)
{
printf("\n\t%s\t%s\t%s\n", cmd[i].cmdname, cmd[i].usage, cmd[i].expression);
break;
}
}
if(strcmp("NULL", cmd[i].cmdname)==0)
{
printf("\n\tERROR: undefine command!!!\n");
}
}
break;
default:
printf("\n usage: help <cmd>\n\r");
break;
}
return 0;
}
int cmdline(void)
{
char c;
char cmdbuffer[80];
char cmdpara[8][30];
int (*op)(int argc, void *argv[]);
char *p[8];
char *cmdptr;
short cp, i, j, k, num;
short h = 0;
int tmp = 11;
char history_str[13][80];
for(j=0;j<13;j++)
{
for(i=0; i<80; i++)
{
history_str[j][i] = '\0';
}
}
while(1)
{
START:
for(i=0; i<80; i++)
{
cmdbuffer[i] = '\0';
}
printf("\n$ ");
cmdptr = cmdpara[0];
cp = 0;
while(1)
{
c = getchar();
if((c>0x1f)&&(c<0x7f))
{
if(h > 0)
{
for(i=0; i<h ; i++)
{
cmdbuffer[cp-i] = cmdbuffer[cp-i-1];
}
cmdbuffer[cp-h] = c;
cp++;
for(i=h; i>=0; i--)
{
putchar(cmdbuffer[cp-i]);
}
for(i=0; i<cp-1; i++)
{
putchar(0x8);
putchar(0x20);
putchar(0x8);
}
for(i=0; cmdbuffer[i]; i++)
{
putchar(cmdbuffer[i]);
}
for(i=h; i>0; i--)
{
putchar(0x08);
}
}
else
{
cmdbuffer[cp++] = c;
putchar(c);
}
}
else if(c == 0x8)
{
if((h != 0) && (cp-h > 0))
{
for(i=h; i>=0; i--)
{
putchar(cmdbuffer[cp-i]);
}
for(i=0; i<cp; i++)
{
putchar(0x8);
putchar(0x20);
putchar(0x8);
}
for(i=h; i>0 ; i--)
{
cmdbuffer[cp-i-1] = cmdbuffer[cp-i];
}
cmdbuffer[--cp] = '\0';
for(i=0; cmdbuffer[i]; i++)
{
putchar(cmdbuffer[i]);
}
for(i=h; i>0; i--)
{
putchar(0x08);
}
}
else
{
if((cp != 0) && (h == 0))
{
cmdbuffer[--cp] = '\0';
putchar(0x8);
putchar(0x20);
putchar(0x8);
}
}
}
else if((c==0xa) || (c==0xd))
{
if(cmdbuffer[0] == '\0')
{
goto START;
}
h = 0;
tmp = 11;
for(j=0;cmdbuffer[j];j++)
{
history_str[11][j] = cmdbuffer[j];
}
break;
}
/****************************************************************************/
else if(c==0x1b)
{
c = getchar();
if(c==0x5b)
{
c = getchar();
switch(c)
{
case 0x44:
if(h < cp)
{
putchar(0x8);
h++;
}
else
h = cp;
break;
case 0x41:
if(tmp>=1)
{
if(tmp==1)
{
tmp = 1;
break;
}
else
tmp--;
for(; h != 0; h--)
{
putchar(cmdbuffer[cp-h]);
}
if((cmdbuffer[0] != 0)||(cp == 0))
{
for(i=0;cmdbuffer[i];i++)
{
putchar(0x8);
putchar(0x20);
putchar(0x8);
cmdbuffer[i] = '\0';
}
}
else
{
for(i=0;history_str[tmp+1][i];i++)
{
putchar(0x8);
putchar(0x20);
putchar(0x8);
}
}
for(j=0;history_str[tmp][j];j++)
{
cmdbuffer[j] = history_str[tmp][j];
putchar(cmdbuffer[j]);
}
}
cp = j;
break;
case 0x43:
if(h > 0)
{
putchar(cmdbuffer[cp-h]);
h--;
}
else
h = 0;
break;
case 0x42:
if(tmp <= 11)
{
if(tmp == 11)
{
tmp = 11;
break;
}
else
tmp++;
for(; h != 0; h--)
{
putchar(cmdbuffer[cp-h]);
}
if((cmdbuffer[0] != 0)||(cp == 0))
{
for(i=0;cmdbuffer[i];i++)
{
putchar(0x8);
putchar(0x20);
putchar(0x8);
cmdbuffer[i] = '\0';
}
}
else
{
for(i=0;history_str[tmp-1][i];i++)
{
putchar(0x8);
putchar(0x20);
putchar(0x8);
}
}
for(j=0;history_str[tmp][j];j++)
{
cmdbuffer[j] = history_str[tmp][j];
putchar(cmdbuffer[j]);
}
}
cp = j;
break;
default :
break;
}
}
c = 0;
}
/***********************************************************************/
}
/***********************************************************************/
if(tmp == 11)
{
for(j=1;j<12;j++)
{
for(i=0;i<30;i++)
history_str[j][i]=history_str[j+1][i];
}
for(i=0; i<30; i++)
{
history_str[11][i] = '\0';
}
}
/***********************************************************************/
if(cp == 0)
{
goto START;
}
else
{
for(i=0; i<8; i++)
for(j=0; j<30; j++)
cmdpara[i][j] = '\0';
num = 0; //argc
// printf("\ncmd:%s\n", cmdbuffer);
for(j = 0,i=0; i<cp; i++) //xpj
{
if(cmdbuffer[i] == 0x20) //space
{
if((cmdbuffer[i+1] != 0x20) && ((cmdbuffer[i+1] != '\0')))
{
j = 0;
num++;
cmdptr = cmdpara[num];
}
}
else
{
*(cmdptr + j) = cmdbuffer[i];
j++;
}
}
cmdptr = cmdpara[0];
if(strcmp(cmdptr, cmd[0].cmdname)==0)
{
break;
}
else
{
for(k=1; strcmp("NULL", cmd[k].cmdname)!=0; k++)
{
if(strcmp(cmdptr, cmd[k].cmdname)==0)
{
op = cmd[k].func;
for(j=0; j<=num; j++)
{
p[j] = (char *)(cmdpara[j]);
// printf("cmdpara[%d]: %s\n", j, cmdpara[j]);
}
op(j, (void *)p);
break;
}
}
if(strcmp("NULL", cmd[k].cmdname)==0)
{
printf("\n\tERROR: undefine command!!!\n");
}
}
}
}
return 0;
}
int attest=0;
int main(void)
{
INT8U rstSrc = (PMU_CMDSTS >> 26) & 0x3;
if ((rstSrc == 0x03) && ((PMU_CMDSTS & 0x01ff0000) == 0x00010000) ) // ??PMU_CmdSts?????24:16λ?е?16λ?1???????0??????????????μ?1??????????????ι????????NB?????
{
//休眠定时唤醒
}
else
{
if(rstSrc == 0x0)
{
//外部复位：需要等待内部32k稳定
delay_ms(1000);
}
else if(rstSrc == 0x03)
{
//休眠唤醒
}
else
{
//看门狗复位
}
}
/*Clock Init*/
SystemClockInit(); //时钟等系统配置
/*IoRemap Init*/
//GPIOInit(); //io配置
/*WDT Init*/
WdgInit(); //看门狗配置
/*Cal In8M*/
int g_f = cal_in8m_touch(); //计算内部8M时钟频率
/*Uart Init*/
Uart0_init_buad(g_f*1000); //串口配置
//EnableInt(); //开总中断
PMU_GPIOA_OE|=(0x01<<20);
attest=0;
while(1){
PMU_GPIOA_O|=(0x01<<20);
delay_ms(500);
PMU_GPIOA_O&=~(0x01<<20);
delay_ms(500);
WDG_DogFeed();
attest++;
printf("test....\n");
}
return 0;
}
System/Startup/serial.S
+77
View File
@@ -0,0 +1,77 @@
#include "start.h"
#include "regdef.h"
#include "csrdef.h"
#include "tools-asm.h"
.global serial_out
serial_out:
//v0 > a4
10: li.w a4, UART0_BASEADDR
ld.bu a4, a4, 0x5
andi a4, a4, 0x20
beqz a4, 10b
li.w t0, UART0_BASEADDR
st.b a0, t0, 0x0
jr ra
.global outputaddr
outputaddr:
addi.w sp, sp, -4
st.w ra, sp, 0
la a2, hexdecarr
li.w t1, 0xf0000000
li.w t2, 8
li.w t3, 28
ori a1, a0, 0
1:
beq t2, zero, 1f
and t0, a1, t1
srl.w t0, t0, t3
add.w t0, t0, a2
ld.bu t4, t0, 0
ori a0, t4, 0
bl serial_out
srli.w t1, t1, 4
addi.w t3, t3, -4
addi.w t2, t2, -1
b 1b
1:
li.w a0, 0xa
bl serial_out
ld.w ra, sp, 0
addi.w sp, sp, 4
jr ra
.global outputstring
outputstring:
// v1 > a5
// v0 > a4
move a5, a0
1:
ld.bu t0, a5, 0
beq t0, zero, 1f
10:
li.w a4, UART_BASEADDR
ld.bu a4, a4, 0x5
andi a4, a4, 0x20
beqz a4, 10b
li.w a3, UART_BASEADDR
st.b t0, a3, 0
addi.w a5, a5, 1
b 1b
1:
li.w a4, UART_BASEADDR
ld.bu a4, a4, 0x5
andi a4, a4, 0x40
beqz a4, 1b
jr ra
.section .rodata
.align 5
.global msg_wakeup
msg_wakeup:
.asciz "wakeup!\n"
hexdecarr:
.asciz "0123456789abcdef"
System/Startup/start.S
+141
View File
@@ -0,0 +1,141 @@
#include "regdef.h"
#include "csrdef.h"
#include "tools-asm.h"
#include "start.h"
/* start address for the initialization values of the .data section. defined in ld.script */
.word _sidata
/* start address for the .data section. defined in ld.script */
.word _sdata
/* end address for the .data section. defined in ld.script */
.word _edata
/* start address for the .bss section. defined in ld.script */
.word _sbss
/* end address for the .bss section. defined in ld.script */
.word _ebss
.globl _RAM_BSS
_RAM_BSS = BSS_BASE
.globl _RAM_DATA
_RAM_DATA = DATA_BASE
.section .text._start # begin code segment
.weak _start
.type _start, %function
.globl _start
#All Exception Entries
_start:
move t1 , zero
b LoopCopyDataInit
CopyDataInit:
la.abs t3, _sidata
add.w t4, t3, t1
ld.w t3, t4, 0x0
add.w t4, t0, t1
st.w t3, t4, 0x0
addi.w t1, t1, 0x4
LoopCopyDataInit:
la.abs t0, _sdata
la.abs t3, _edata
add.w t2, t0, t1
bne t2, t3, CopyDataInit
/* clear bss */
la.abs t0, _sbss
la.abs t1, _ebss
beq t1, t0, cpu_init_start
LoopFillZerobss:
st.w zero, t0, 0
addi.w t0, t0, 4
bne t1, t0, LoopFillZerobss
#set up basic system function
/* cpu init*/
cpu_init_start:
### reset normal exception base and Ex config
li.w t0, 0x1c001000
csrwr t0, CSR_EBase
li.w t0, (0<<S_CSR_ExConfig_VS)|(0x0000<<S_CSR_ExConfig_IM) # 4 instruction gap
csrwr t0, CSR_ExConfig
#set int masks
li.w t0, 0x1fff
csrxchg t0, t0, CSR_ExConfig
##set VSEG4(0x80000000~0x9fffffff) to cached, other VSEG to uncached
li.w t0, CACHE_OP
csrwr t0, CSR_SEGCA
##set VSEG4(0x80000000~0x9fffffff) to PSEG0(0x00000000~0x1fffffff), other VSEG unchanged
li.w t0, ADDR_MAP
csrwr t0, CSR_SEGPA
##set DA=0(change DA-mode to AD-mode)
li.w t0, 0x8
csrxchg zero, t0, CSR_CRMD
li.w sp, SP_BASE
bl main
jirl zero, ra, 0
.globl cpu_wait
cpu_wait:
idle 0
jr ra
.org 0x1000
DEFAULT_INT_HANDLER:
SAVE_REGS_FAST(REGS_MEM)
csrrd t0, CSR_ExStatus
andi t1, t0, INT_VECTOR
beqz t1, exception_core_check
exception_pmu:
andi t1,t0,0x4
bnez t1,wake_label
andi t1,t0,0x8
bnez t1,touch_label
andi t1,t0,0x10
bnez t1,uart2_label
andi t1,t0,0x20
bnez t1,bcc_label
andi t1,t0,0x80
bnez t1,exint_label
andi t1,t0,0x800
bnez t1,timer_label
wake_label:
bl TIMER_WAKE_INT
b exception_exit
touch_label:
bl TOUCH
b exception_exit
uart2_label:
bl UART2_INT
b exception_exit
bcc_label:
bl BAT_FAIL
b exception_exit
exint_label:
bl ext_handler
b exception_exit
timer_label:
bl TIMER_HANDLER
b exception_exit
exception_core_check:
andi t1, t0, INTC_VECTOR
beqz t1, exception_exit
bl intc_handler
b exception_exit
exception_exit:
RESTORE_REGS_FAST(REGS_MEM)
ertn
System/Startup/wakeup.S
+28
View File
@@ -0,0 +1,28 @@
#include "regdef.h"
#include "csrdef.h"
#include "tools-asm.h"
#include "start.h"
.global cpu_sleep
cpu_sleep:
SAVE_REGS_ALL(REGS_MEM)
dbar 0
li.w t1, PMU_BASE
1: ld.w t0, t1,PMU_CommandW
andi t0, t0, 0x1
beqz t0, 1b
st.w t0, t1,PMU_CommandW
idle 0
.global wakeup_reset
wakeup_reset:
la a0, msg_wakeup
bl outputstring
RESTORE_REGS_ALL(REGS_MEM)
csrwr t0, CSR_KScratch1
/*enable interrupt*/
li.w t0, 0x4
csrxchg t0, t0, CSR_CRMD //enter pmu_handler
csrrd t0, CSR_KScratch1
jirl zero, ra, 0
System/Sys/ls1c102_Interrupt.c
+409
View File
@@ -0,0 +1,409 @@
#include "../driver/calIn8M.h"
#include"ls1x.h"
#include"ls1x_gpio.h"
#include"ls1x_wdg.h"
#include"ls1x_common.h"
#include"ls1x_exti.h"
#include"ls1c102_interrupt.h"
#include"ls1c102_touch.h"
#include"ls1c102_ptimer.h"
#include"ls1c102_i2c.h"
#include"Config.h"
#define BEBUG_IRQ() printf("\r\n < line: %d func:%s >\r\n",__LINE__,__FUNCTION__)
void (* const exti_irq_handle[32])(void);
void exti_gpioa0_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A0);
}
void exti_gpioa1_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A1);
}
void exti_gpioa2_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A2);
}
void exti_gpioa3_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A3);
}
void exti_gpioa4_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A4);
}
void exti_gpioa5_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A5);
}
void exti_gpioa6_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A6);
}
void exti_gpioa7_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A7);
}
void exti_gpiob0_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B0);
}
void exti_gpiob1_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B1);
}
void exti_gpiob2_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B2);
}
void exti_gpiob3_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B3);
}
void exti_gpiob4_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B4);
}
void exti_gpiob5_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B5);
}
void exti_gpiob6_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B6);
}
void exti_gpiob7_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B7);
}
void exti_gpioc0_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C0);
}
void exti_gpioc1_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C1);
}
void exti_gpioc2_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C2);
}
void exti_gpioc3_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C3);
}
void exti_gpioc4_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C4);
}
void exti_gpioc5_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C5);
}
void exti_gpioc6_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C6);
}
void exti_gpioc7_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C7);
}
void exti_gpiod0_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D0);
}
void exti_gpiod1_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D1);
}
void exti_gpiod2_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D2);
}
void exti_gpiod3_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D3);
}
void exti_gpiod4_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D4);
}
void exti_gpiod5_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D5);
}
void exti_gpiod6_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D6);
}
void exti_gpiod7_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D7);
}
void (* const Ext_IrqHandle[32])(void) = {
exti_gpioa0_irq_handler,
exti_gpioa1_irq_handler,
exti_gpioa2_irq_handler,
exti_gpioa3_irq_handler,
exti_gpioa4_irq_handler,
exti_gpioa5_irq_handler,
exti_gpioa6_irq_handler,
exti_gpioa7_irq_handler,
exti_gpiob0_irq_handler,
exti_gpiob1_irq_handler,
exti_gpiob2_irq_handler,
exti_gpiob3_irq_handler,
exti_gpiob4_irq_handler,
exti_gpiob5_irq_handler,
exti_gpiob6_irq_handler,
exti_gpiob7_irq_handler,
exti_gpioc0_irq_handler,
exti_gpioc1_irq_handler,
exti_gpioc2_irq_handler,
exti_gpioc3_irq_handler,
exti_gpioc4_irq_handler,
exti_gpioc5_irq_handler,
exti_gpioc6_irq_handler,
exti_gpioc7_irq_handler,
exti_gpiod0_irq_handler,
exti_gpiod1_irq_handler,
exti_gpiod2_irq_handler,
exti_gpiod3_irq_handler,
exti_gpiod4_irq_handler,
exti_gpiod5_irq_handler,
exti_gpiod6_irq_handler,
exti_gpiod7_irq_handler,
};
void ext_handler(void)
{
PMU_CMDW = (1 << 24);
INT32U regsrc;// = EXTI->EXINT_SRC;
INT32U regen;// = EXTI->EXINT_SRC;
INT32U irq_no;
BEBUG_IRQ();
regsrc = EXTI->EXINT_SRC;
regen = EXTI->EXINT_EN;
regsrc = (regsrc & regen);
asm("nop");
for(irq_no = 0; irq_no < 32; irq_no++)
{
if((regsrc>>irq_no) & 0x1)
{
Ext_IrqHandle[irq_no]();
}
}
}
void SOFT_INT(void)
{
printf("\n.............SOFT_INT..............\n\r");
Set_soft_stop();
}
/***********************************************************************
函数功能: 8M定时器中断处理函数
@param: 无
@other: 无
@return: 无
@auther : 朱晓宇
@time : 2020年4月9日
***********************************************************************/
void TIMER_8M_INT(void)
{
PMU_CMDW = (1 << 21); // 清除中断标志
Set_Timer_clear();
Set_Timer_Init(8 * 10000); // 1.25ms
}
/***********************************************************************
函数功能: 定时唤醒中断处理函数
@param: 无
@other: 睡眠下定时喂狗，防止系统复位
@return: 无
@auther : 朱晓宇
@time : 2020年4月9日
***********************************************************************/
void TIMER_WAKE_INT(void)
{
//printf("\n.............TIMER_WAKE_INT..............\n\r");
PMU_CMDW = (1 << 16); // 清除中断标志
INT32U SleepEn = PMU_CMDSTS & 0xffffffff;
WDG_DogFeed();
//睡眠后，定时喂狗，否则会不断重启
}
/***********************************************************************
函数功能: 触摸按键中断处理函数
@param: 无
@other: 无
@return: 无
@auther : 朱晓宇
@time : 2020年4月9日
***********************************************************************/
#define KEY_CANCLE 8
void TOUCH(void)
{
INT8U i;
INT16U KeyChannel;
INT8U KeyType;
KeyChannel = (TS_STAT >> 16) & 0xfff;
KeyType = TS_STAT & 0xf;
PMU_CMDW = (1 << 17); // 清除中断标志
TS_STAT = 0xf;
printf("\n---touchInt:KeyChannel:0x%x\n",KeyChannel);
// Printf_KeyType(KeyType);
// Printf_KeyChannel(KeyChannel);
// Printf_KeyVal();
}
/***********************************************************************
函数功能: 串口2接收中断处理函数
@param: 无
@other: 无
@return: 无
@auther : 朱晓宇
@time : 2020年4月9日
***********************************************************************/
void UART2_INT(void)
{
PMU_CMDW = (1 << 18);
INT8U uart_sr = UART2_IIR;
}
/***********************************************************************
函数功能: 电量检测中断处理函数
@param: 无
@other: 该中断可查看用户手册
@return: 无
@auther : 朱晓宇
@time : 2020年4月9日
***********************************************************************/
void BAT_FAIL(void)
{
uint32_t tmp = (PMU_CMDSTS & 0xf80000)>>19;
PMU_CMDW = (PMU_CMDSTS & 0xf80000);
switch(tmp){
case 0x1:
printf("\n.............BAT_FAIL..............\n\r");
PMU_CMDSTS = 0x0; // IT config
break;
case 0x2:
break;
case 0x4:
break;
case 0x8:
break;
case 0x10:
printf("\n.............ADC..............\n\r");
PMU_CMDSTS &= (~0x8000); // IT dis
break;
default:
break;
}
}
/***********************************************************************
函数功能: INTC中断处理函数
@param: 无
@other: 该中断可查看用户手册
@return: 无
@auther : 朱晓宇
@time : 2020年4月9日
***********************************************************************/
void intc_handler(void)
{
INT8U IntReg = INT_OUT;
if(IntReg & IRQ_TIMER)//Timer
{
if(TIM_GetITStatus(TIM_FLAG_Trigger))
{
TIM_ClearIT(TIM_FLAG_Trigger);
printf("Peripherals Timer clear interrupt..\n");
}
}
if (IntReg & UART1_INT_OUT) //Uart1
{
uint8_t chr = UART1_RxData ;
printf("uart1 recv:0x%x\n",chr);
INT_CLR = UART1_INT_CLR;
}
if (IntReg & UART0_INT_OUT) //Uart0
{
uint8_t chr = UART0_RxData ;
// printf("uart0 recv:0x%x\n",chr);
recv_dat_int(chr);
INT_CLR = UART0_INT_CLR;
}
INT_CLR = 0xff;
}
void TIMER_HANDLER(void)
{
Set_Timer_clear();
printf("Core Timer clear interrupt..\n");
Set_Timer_stop();
}
System/Sys/ls1c102_cmd.c
+996
View File
@@ -0,0 +1,996 @@
#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"
#include "ls1c102_touch.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;
}
build/Makefile
+97
View File
@@ -0,0 +1,97 @@
# **********************************************
# ls1x project
# **********************************************
# Name of application
# **********************************************
# Tools
# **********************************************
#CROSS_COMPILE = loongarch32-linux-gnu-
#CROSS_COMPILE = loongarch32-linux-gnusf-
#CROSS_COMPILE = /opt/loongarch32-linux-gnu-2022-04-15/bin/loongarch32-linux-gnu-
CC = $(CROSS_COMPILE)gcc$(EXE)
LD = $(CROSS_COMPILE)ld$(EXE)
OBJCOPY = $(CROSS_COMPILE)objcopy$(EXE)
OBJDUMP = $(CROSS_COMPILE)objdump$(EXE)
STRIP = $(CROSS_COMPILE)strip$(EXE)
SIZE = $(CROSS_COMPILE)size$(EXE)
# **********************************************
# Directories
# **********************************************
BUILD_DIR = $(ROOT_DIR)/build
TARGET = $(ROOT_DIR)/target
APP = $(ROOT_DIR)/App/Src
USER = $(ROOT_DIR)/user
DRIVER = $(ROOT_DIR)/driver
TOOL = $(ROOT_DIR)/tool
BOARD = $(MCU)
BOARDNAME = $(MCU)
IMAGENAME = $(MCU)_demo
PRIVATE = $(ROOT_DIR)/private
#BCMDLINE = $(ROOT_DIR)/user/$(BOARD)_cmdline.o
BCMDLINE = $(ROOT_DIR)/user/main.o
BCOMMAND = $(ROOT_DIR)/user/$(BOARD)_cmd.o
BINT = $(ROOT_DIR)/user/$(BOARD)_Interrupt.o
SRCDIR = $(TARGET) $(PUBLIC) $(PRIVATE) $(DRIVER) $(TOOL)
VPATH = $(SRCDIR) $(USER)
# **********************************************
# Image file names and map file
# **********************************************
IMAGE_ELF = $(IMAGENAME).elf
IMAGE_BIN = $(IMAGENAME).bin
IMAGE_MAP = $(IMAGENAME).map
# **********************************************
# Compiler and linker options
# **********************************************
INCLUDE += -I$(ROOT_DIR)/include -I$(ROOT_DIR)/public -I$(PRIVATE) -I$(TARGET) -I$(DRIVER) -I$(TOOL)
FLAGS = -std=gnu99 -O0 -ffunction-sections -fdata-sections -msoft-float -fsched-pressure -fno-builtin -D $(BOARDNAME)
CC_OPTS = $(DEBUG) $(FLAGS) $(INCLUDE)
CC_COPTS = $(DEBUG) $(FLAGS) $(INCLUDE)
LD_SCRIPT = ld.script
LD_OPTS = -G 0 -static -T $(LD_SCRIPT) -Map $(IMAGE_MAP) --gc-sections
# **********************************************
# Files to be compiled
# **********************************************
SRC_C = $(foreach dir, $(SRCDIR), $(wildcard $(dir)/*.c))
SRC_S = $(foreach dir, $(SRCDIR), $(wildcard $(dir)/*.S))
SRC = $(SRC_C) $(SRC_S)
OBJ_C = $(notdir $(patsubst %.c, %.o, $(SRC_C)))
OBJ_C += $(notdir $(BCMDLINE))
OBJ_C += $(notdir $(BCOMMAND))
OBJ_C += $(notdir $(BINT))
OBJ_S = start.o $(filter-out start.o, $(notdir $(patsubst %.S, %.o, $(SRC_S))))
LS1C1X_OBJ = $(OBJ_S) $(OBJ_C)
# **********************************************
# Rules
# **********************************************
.PHONY : all
all : $(IMAGE_BIN)
$(IMAGE_BIN):$(LS1C1X_OBJ)
$(LD) $(LD_OPTS) -o $(IMAGE_ELF) $^ -Map $(IMAGE_MAP)
$(OBJCOPY) -O binary $(IMAGE_ELF) $(IMAGE_BIN)
$(SIZE) $(IMAGE_ELF)
$(OBJDUMP) -alD $(IMAGE_ELF) > $(IMAGENAME).s
$(OBJ_C) : %.o : %.c
$(CC) $(CC_COPTS) -g -Og -c -o $@ $^
$(OBJ_S) : %.o : %.S
$(CC) $(CC_OPTS) -g -Og -c -o $@ $^
.PHONY : clean
clean :
rm -rf *.o *.elf *.map *.bin *.s *.a
laide.makefile
+36
View File
@@ -0,0 +1,36 @@
ROOT_DIR = $(shell pwd)
#ROOT_DIR = $(PWD)
export
MCU := ls1c102
PHONY := all
PHONY += help
PHONY += flash
PHONY += clean
LAIDE_PATH = C:/Users/anonymous/Desktop/Embedded/LOONG/LA1C102/LAIDE
CROSS_COMPILE = $(LAIDE_PATH)/buildtool/la32-tool/bin/loongarch32-newlib-elf-
EXE = .exe
OPENOCD_PATH = $(LAIDE_PATH)/openocd/
OPENOCD_EXE = openocd.exe
OPENOCD_TOOL_CFG = lalink.cfg
OPENOCD_MCU_CFG = ls1c102.cfg
all:
@echo "***************************************************************************"
@echo "*"
@echo "* Welcome loongson $(@)"
@echo "* This is $(@).bin."
@echo "*"
@echo "***************************************************************************"
make -C build clean
make -C build all
clean:
make -C build clean
flash:
$(OPENOCD_PATH)$(OPENOCD_EXE) -f $(OPENOCD_PATH)$(OPENOCD_TOOL_CFG) -f $(OPENOCD_PATH)$(OPENOCD_MCU_CFG) -c "program build/ls1c102_demo.bin 0x1c000000 exit"
help:
@echo "this is help"
.PHONY: $(PHONY)