/**
\brief Test case: TC_CoreFunc_PRIMASK
\details
- Check if __get_PRIMASK and __set_PRIMASK intrinsic can be used to manipulate PRIMASK.
- Check if __enable_irq and __disable_irq are reflected in PRIMASK.
*/
void TC_CoreFunc_PRIMASK (void) {
uint32_t orig = __get_PRIMASK();
// toggle primask
uint32_t primask = (orig & ~0x01U) | (~orig & 0x01U);
__set_PRIMASK(primask);
uint32_t result = __get_PRIMASK();
ASSERT_TRUE(result == primask);
__disable_irq();
result = __get_PRIMASK();
ASSERT_TRUE((result & 0x01U) == 1U);
__enable_irq();
result = __get_PRIMASK();
ASSERT_TRUE((result & 0x01U) == 0U);
__disable_irq();
result = __get_PRIMASK();
ASSERT_TRUE((result & 0x01U) == 1U);
__set_PRIMASK(orig);
}
//void SD_TEST(void)
//{
// u8 res;
// UINT bw,index;
// res=f_mount( &fatfs_SDCARD,"0:/",1 );
// res=f_open(&file_sdif, "0:/sdif.dat",FA_OPEN_EXISTING|FA_WRITE|FA_READ);
// res=f_write(&file_sdif,SDTEST_WriteBuffer,512,&bw);
// res=f_close(&file_sdif);
// res=f_open(&file_sdif, "0:/sdif.dat",FA_OPEN_EXISTING |FA_WRITE);
// res=f_write(&file_sdif,SDTEST_WriteBuffer,512,&bw);
// res=f_close(&file_sdif);
// res=f_open(&file_sdif, "0:/sdif.dat",FA_OPEN_EXISTING | FA_READ);
// index=0;
// while(SDTEST_ReadBuffer[31]!=0x04)
// {
// index++;
// res=f_read(&file_sdif,SDTEST_ReadBuffer,512,&bw);
// }
// f_close(&file_sdif);
//
//
//}
u8 bsp_ChangeAPPtoRun(u8 App_Select)
{
u8 status=0;
u8 Flash_status=0;
FLASH_Unlock(); //解锁
FLASH_DataCacheCmd(DISABLE);//FLASH擦除期间,必须禁止数据缓存
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_OPERR|FLASH_FLAG_WRPERR| FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
status=FLASH_EraseSector(FLASH_Sector_3 ,VoltageRange_3);//VCC=2.7~3.6V之间!!
if(status==FLASH_COMPLETE)
{
__set_PRIMASK(1);
status=FLASH_ProgramByte(App_ToRun_Flag,App_Select); //SysID
__set_PRIMASK(0);
}
FLASH_DataCacheCmd(ENABLE); //FLASH擦除结束,开启数据缓存
FLASH_Lock();//上锁
if(status==FLASH_COMPLETE)
{
Flash_status=0;
}
else
{
Flash_status=status;
}
return Flash_status;
}
u8* bsp_Firmware_Write(u8* writebuffer,u32 writeaddress,u16 writelength)
{
u8 status=0;
u16 index=0;
SleepTime=0;
FLASH_Unlock(); //解锁
FLASH_DataCacheCmd(DISABLE);//FLASH擦除期间,必须禁止数据缓存
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_OPERR|FLASH_FLAG_WRPERR| FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
__set_PRIMASK(1);
for(index=0;index<writelength;index++)
{
status=FLASH_ProgramByte(writeaddress+index,writebuffer[index]);
}
__set_PRIMASK(0);
FLASH_DataCacheCmd(ENABLE); //FLASH擦除结束,开启数据缓存
FLASH_Lock();//上锁
if(status==FLASH_COMPLETE)
{
MCU_WriteStatus=0;
}
else
{
MCU_WriteStatus=status;
}
return &MCU_WriteStatus;
}
/***************************************************************************//**
* @brief
* Try to lock the given SPI bus.
*
* @param[in] id
* The unique ID used for SPI bus locking.
*
* @param[in] callback
* Pointer to the call-back function that will be called when the bus is unlocked.
*
* @return
* true if bus was successfully locked, false otherwise
******************************************************************************/
bool TD_SPI_Lock(uint8_t id, TD_SPI_LockedCallback callback)
{
uint8_t msk, ret, top, bus;
DEBUG_PRINTF("Lck%d\r\n", id);
EFM_ASSERT(id <= CONFIG_MAX_SPI_ID);
bus = TD_SPI_Conf[id].bus;
EFM_ASSERT(bus < MAX_SPI_BUS);
EFM_ASSERT(SPI[bus].lock != 0xFF);
msk = __get_PRIMASK();
if (!msk) {
__set_PRIMASK(1);
}
// We have already locked this bus for this usage, just increment lock count
if (SPI[bus].lock && (SPI[bus].lock_id == id || SPI[bus].lock_id == TD_SPI_Conf[id].friend_id)) {
SPI[bus].lock++;
ret = true;
// Bus is not actually locked, lock it
} else if (!SPI[bus].lock) {
SPI[bus].lock_id = id;
SPI[bus].lock = 1;
TD_SPI_UpdateConf(id);
ret = true;
} else {
// Bus is locked, but for another usage
if (callback) {
// We should append callback to queue
top = SPI[bus].top + 1;
if (top >= MAX_LOCKED_CALLBACK) {
top = 0;
}
// Enough room
if (top != SPI[bus].bottom) {
SPI[bus].cb[SPI[bus].top] = callback;
#ifdef SPI_DEBUG_STAMP
SPI[bus].lock_stamp[SPI[bus].top] = RTC->CNT;
#endif
SPI[bus].top = top;
} else {
TD_Trap(TRAP_SPI_MAX_LOCK, (bus << 8) | id);
}
DEBUG_PRINTF("Lock add 0x%08X, lbyid:%d cnt:%d\r\n", callback, SPI[bus].lock_id, SPI[bus].lock);
}
ret = false;
}
DEBUG_PRINTF_INFO("Cnt%d\r\n", SPI[bus].lock);
if (!msk) {
__set_PRIMASK(0);
}
return ret;
}
/**
* Sends a data buffer asynchronously over the USB virtual COM port.
* This is an internal function.
*
* @param buf Data buffer.
* @param size Number of bytes to send.
*/
static void USB_VirtualCOM_SendAsync(const uint8_t *buf, uint32_t size) {
USB_VirtualCOM_TxTransfer_t *transfer;
uint32_t partialSize;
if(size == 0) {
return;
}
// Enter critical section
__set_PRIMASK(1);
partialSize = 0;
if(USB_VirtualCOM_bulkInWaiting) {
// Transfer first packet right away
// If size is a multiple of USB_VCOM_BULK_IN_MAX_PKT_SIZE it will stay that way
partialSize = Minimum(size, USB_VCOM_BULK_IN_MAX_PKT_SIZE);
USB_VirtualCOM_SendBulkInPayload(buf, partialSize);
buf += partialSize;
size -= partialSize;
}
if(partialSize != 0 && partialSize < USB_VCOM_BULK_IN_MAX_PKT_SIZE) {
// We already transferred the whole packet
__set_PRIMASK(0);
return;
}
// Allocate memory for transfer + buffer
// If the buffer was exactly USB_VCOM_BULK_IN_MAX_PKT_SIZE bytes and
// it has already been transferred, the transfer info still needs to be
// allocated for the bulk IN handler to send the zero packet.
transfer = (USB_VirtualCOM_TxTransfer_t *) malloc(sizeof(USB_VirtualCOM_TxTransfer_t) + size);
if(transfer == NULL) {
__set_PRIMASK(0);
return;
}
// Fill in transfer data
transfer->next = NULL;
transfer->size = size;
transfer->txSize = 0;
if(size != 0) {
memcpy(transfer->buffer, buf, size);
}
// Append transfer to queue
if(USB_VirtualCOM_txQueue.head == NULL) {
USB_VirtualCOM_txQueue.head = USB_VirtualCOM_txQueue.tail = transfer;
}
else {
USB_VirtualCOM_txQueue.tail->next = transfer;
USB_VirtualCOM_txQueue.tail = transfer;
}
// Exit critical section
__set_PRIMASK(0);
}
uint16_t USB_VirtualCOM_Read(uint8_t *buf, uint16_t size) {
uint16_t readSize;
// Read in critical section
__set_PRIMASK(1);
readSize = USB_VirtualCOM_RxBuffer_Read(buf, size);
__set_PRIMASK(0);
return readSize;
}
/*
*********************************************************************************************************
* 函 数 名: bsp_GetRunTime
* 功能说明: 获取CPU运行时间，单位10ms
* 形 参：无
* 返 回 值: CPU运行时间，单位10ms
*********************************************************************************************************
*/
int32_t bsp_GetRunTime(void)
{
int runtime;
__set_PRIMASK(1); /* 关中断 */
runtime = g_iRunTime; /* 由于在Systick中断被改写，因此关中断进行保护 */
__set_PRIMASK(0); /* 开中断 */
return runtime;
}
void System_Init ( void )
{
__set_PRIMASK ( 1 ); //¹Ø±Õ×ÜÖжÏ
SYS_Init();
IO_Init();
I2C_Init();
// WDT_Init();
UART1_Init();
ADC_Init();
TMR0_Init();
__set_PRIMASK ( 0 );
}
/*
*********************************************************************************************************
* 函 数 名: bsp_WriteCpuFlash
* 功能说明: 写数据到CPU 内部Flash。
* 形 参: _ulFlashAddr : Flash地址
* _ucpSrc : 数据缓冲区
* _ulSize : 数据大小（单位是字节）
* 返 回 值: 0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)
*********************************************************************************************************
*/
uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)
{
uint32_t i;
uint8_t ucRet;
/* 如果偏移地址超过芯片容量，则不改写输出缓冲区 */
if (_ulFlashAddr + _ulSize > FLASH_BASE_ADDR + FLASH_SIZE)
{
return 1;
}
/* 长度为0时不继续操作 */
if (_ulSize == 0)
{
return 0;
}
ucRet = bsp_CmpCpuFlash(_ulFlashAddr, _ucpSrc, _ulSize);
if (ucRet == FLASH_IS_EQU)
{
return 0;
}
__set_PRIMASK(1); /* 关中断 */
/* FLASH 解锁 */
FLASH_Unlock();
/* Clear pending flags (if any) */
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
/* 需要擦除 */
if (ucRet == FLASH_REQ_ERASE)
{
FLASH_EraseSector(bsp_GetSector(_ulFlashAddr), VoltageRange_3);
}
/* 按字节模式编程（为提高效率，可以按字编程，一次写入4字节） */
for (i = 0; i < _ulSize; i++)
{
FLASH_ProgramByte(_ulFlashAddr++, *_ucpSrc++);
}
/* Flash 加锁，禁止写Flash控制寄存器 */
FLASH_Lock();
__set_PRIMASK(0); /* 开中断 */
return 0;
}
/*
*********************************************************************************************************
* 函 数 名: bsp_StartTimer
* 功能说明: 启动一个定时器，并设置定时周期。
* 形 参： _id : 定时器ID，值域【1,TMR_COUNT-1】。用户必须自行维护定时器ID，以避免定时器ID冲突。
* 定时器ID = 0 已用于bsp_DelayMS()函数
* _period : 定时周期，单位1ms
* 返 回 值: 无
*********************************************************************************************************
*/
void bsp_StartTimer(uint8_t _id, uint32_t _period)
{
if (_id >= TMR_COUNT)
{
/* while(1); 死机 */
return;
}
__set_PRIMASK(1); /* 关中断 */
g_Tmr[_id].count = _period;
g_Tmr[_id].flag = 0;
__set_PRIMASK(0); /* 开中断 */
}
/***************************************************************************//**
* @brief
* Unlock the given SPI bus.
*
* @param[in] id
* The unique ID used for SPI bus locking.
******************************************************************************/
void TD_SPI_UnLock(uint8_t id)
{
TD_SPI_LockedCallback temp;
uint32_t msk;
uint8_t bus;
EFM_ASSERT(id <= CONFIG_MAX_SPI_ID);
bus = TD_SPI_Conf[id].bus;
EFM_ASSERT(bus < MAX_SPI_BUS);
EFM_ASSERT(SPI[bus].lock && SPI[bus].lock_id == id);
DEBUG_PRINTF("UnL%d\r\n", id);
DEBUG_PRINTF_INFO("Cnt%d\r\n", SPI[bus].lock);
msk = __get_PRIMASK();
__set_PRIMASK(1);
if (SPI[bus].lock && (SPI[bus].lock_id == id || SPI[bus].lock_id == TD_SPI_Conf[id].friend_id)) {
// Bus not locked, and no flushing of queue in callstack
if ((--SPI[bus].lock) == 0 && !SPI[bus].flush_in_progress) {
// Now, we are flushing queue
SPI[bus].flush_in_progress = true;
// Process all callback to flush in queue
while (SPI[bus].top != SPI[bus].bottom) {
// There is callback to call, get it
temp = SPI[bus].cb[SPI[bus].bottom];
// Remove it
SPI[bus].bottom++;
if (SPI[bus].bottom >= MAX_LOCKED_CALLBACK) {
SPI[bus].bottom = 0;
}
__set_PRIMASK(msk);
// Call it, IRQ available if needed
DEBUG_PRINTF("Lock feed 0x%08X\r\n", temp);
(*temp)();
msk = __get_PRIMASK();
__set_PRIMASK(1);
}
SPI[bus].flush_in_progress = false;
}
} else {
TD_Trap(TRAP_SPI_INVALID_UNLOCK, (bus << 8) | id);
}
__set_PRIMASK(msk);
}
void Init_Cpu(void)
{
__set_PSP((uint32_t)msp_top);
__set_PRIMASK(1);
__set_FAULTMASK(1);
__set_CONTROL(0);
#if (CN_CPU_OPTIONAL_FPU == 1)
pg_scb_reg->CPACR = (3UL << 20)|(3UL << 22); //使能FPU
pg_scb_reg->FPCCR = (1UL << 31); //关闭lazy stacking
#endif
switch(pg_scb_reg->CPUID)
{
// case cn_revision_r0p1://todo
// break; //好像没什么要做的
}
extern void WDT_Disable(void);
WDT_Disable(); //关狗
extern void SysClockInit(void);
SysClockInit();
extern void SDRAM_Init(void);
SDRAM_Init();
extern void Cache_Init(void);
Cache_Init();
Load_Preload();
}
int main()
{
/* Unlock protected register */
SYS_UnlockReg();
SYS_Init();
UART_Init();
printf("\n\n");
printf("M451 FMC IAP Sample Code [LDROM code]\n");
/* Enable FMC ISP function */
FMC_Open();
printf("\n\nPress any key to branch to APROM...\n");
getchar();
printf("\n\nChange VECMAP and branch to LDROM...\n");
UART_WAIT_TX_EMPTY(UART0);
/* Mask all interrupt before changing VECMAP to avoid wrong interrupt handler fetched */
__set_PRIMASK(1);
/* Change VECMAP for booting to APROM */
FMC_SetVectorPageAddr(FMC_APROM_BASE);
/* Lock protected Register */
SYS_LockReg();
/* Software reset to boot to APROM */
NVIC_SystemReset();
while(1);
}
u8* bsp_MCU_Read(u8 blockid,u16 readlength)
{
__set_PRIMASK(1);
SleepTime=0;
if(blockid==1)
{
memcpy(&MCU_ROM_Read[1],(u8*)ADDR_FLASH_SECTOR_7,readlength);
}
if(blockid==2)
{
memcpy(&MCU_ROM_Read[1],(u8*)(ADDR_FLASH_SECTOR_7+512),readlength);
}
MCU_ROM_Read[0]=0;
__set_PRIMASK(0);
return MCU_ROM_Read;
}
void Init_Cpu(void)
{
__set_PSP((uint32_t)msp_top);
__set_PRIMASK(1);
__set_FAULTMASK(1);
__set_CONTROL(0);
#if (CN_CPU_OPTIONAL_FPU == 1)
startup_scb_reg->CPACR = (3UL << 20)|(3UL << 22); //使能FPU
startup_scb_reg->FPCCR = (1UL << 31); //关闭lazy stacking
#endif
switch(startup_scb_reg->CPUID)
{
}
extern void SysClockInit(void);
SysClockInit();
#ifdef USE_HAL_DRIVER
HAL_TickInit();
#endif
extern void SRAM_Init(void);
SRAM_Init();
IAP_SelectLoadProgam();
}
uint32_t ulSetInterruptMaskFromISR( void )
{
uint32 primask = __get_PRIMASK();
__set_PRIMASK(1);
DBG_CONFIGURE_HIGH(CMN_TIMING_DEBUG, CMNDBG_CRITICAL_SECTION);
return primask;
}
//============================================================================
// u32addr : 0-1024
//============================================================================
uint32_t DATA_FLASH_Read(uint32_t u32add)
{
uint32_t u32data;
#ifdef M451
u32data = FMC_Read(u32add*4+DATA_Flash_Start_ADD);
#else
__set_PRIMASK(1);
UNLOCKREG();
DrvFMC_EnableISP();
DrvFMC_Read(u32add*4+DATA_Flash_Start_ADD, &u32data);
DrvFMC_DisableISP();
LOCKREG();
__set_PRIMASK(0);
#endif
return u32data;
}
void vClearInterruptMaskFromISR( uint32_t ulMask )
{
if (!ulMask) {
DBG_CONFIGURE_LOW(CMN_TIMING_DEBUG, CMNDBG_CRITICAL_SECTION);
}
__set_PRIMASK(ulMask);
}
/**
* @brief calls Stm32F1xx on-chip bootloader for flashing
* @param None
* @retval None - shall not ever return
*/
void enter_bootloader(void) {
USART_DeInit(USART1);
RCC_DeInit();
SysTick->CTRL = 0;
SysTick->LOAD = 0;
SysTick->VAL = 0;
__ASM volatile (
"MOVS r4,#1\n"
"MSR primask, r4\n"
"LDR r4,=#0x1FFFF000\n"
"LDR r3,[r4]\n"
"MSR msp,r3\n"
"LDR r3,[r4, #4]\n"
"blx r3\n"
);
// the above ASM does the same but is much shorter
// and does not need core_cm3.c (for the __set_XXXX())
#if 0
__set_PRIMASK(1);
// changing stack point would invalidate all local var on stack!
#define SYSMEM ((uint32_t*)0x1FFFF000) /*specific to STM32F1xx*/
register const uint32_t SP = SYSMEM[0];
__set_MSP(SYSMEM[0]/*sp addr*/);
register const uint32_t BL = SYSMEM[1];
typedef void (*BLFUNC)();
((BLFUNC)SYSMEM[1]/*bootloader addr*/)();
#endif
}
u8* bsp_MCU_Write(u8* writebuffer,u8 blockid,u16 writelength)
{
u8 status=0;
u16 index=0;
SleepTime=0;
__set_PRIMASK(1);
memcpy(MCU_ROM_Write,(u8*)ADDR_FLASH_SECTOR_7,1024+16); //在擦除之前，先把数据读出来放在内存buffer
__set_PRIMASK(0);
if(blockid==1)
{
memcpy(MCU_ROM_Write,writebuffer,writelength); //将512byte数据写入第一个block区域
}
if(blockid==2)
{
memcpy(MCU_ROM_Write+512,writebuffer,writelength); //将512byte数据写入第二个block区域
}
FLASH_Unlock(); //解锁
FLASH_DataCacheCmd(DISABLE);//FLASH擦除期间,必须禁止数据缓存
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_OPERR|FLASH_FLAG_WRPERR| FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
status=FLASH_EraseSector(FLASH_Sector_7 ,VoltageRange_3);//VCC=2.7~3.6V之间!!
if(status==FLASH_COMPLETE)
{
__set_PRIMASK(1);
for(index=0;index<(1024+16);index++)
{
status=FLASH_ProgramByte(ADDR_FLASH_SECTOR_7+index,MCU_ROM_Write[index]); //SysID
}
__set_PRIMASK(0);
}
FLASH_DataCacheCmd(ENABLE); //FLASH擦除结束,开启数据缓存
FLASH_Lock();//上锁
if(status==FLASH_COMPLETE)
{
MCU_WriteStatus=0;
}
else
{
MCU_WriteStatus=status;
}
return &MCU_WriteStatus;
}
int __atomic_fetch_sub_4(int *d, int val, int mem)
{
uint32_t primask = __get_PRIMASK();
__disable_irq();
*d -= val;
__set_PRIMASK(primask);
return *d;
}
//-------------------------------------------------------------------
void cSystem::enableInterrupt( void )
{
if(cntInterrupt > 0)
{
cntInterrupt--;
}
if(cntInterrupt == 0)
{
__set_PRIMASK(0); //__enable_irq();
}
}
/**
* @brief Function for setting the Primask variable. Only necessary if ARMCC
* compiler skips __set_PRIMASK at high optimization levels.
*
* @param primask The primask value. 1 to disable interrupts, 0 otherwise.
*/
static void nrf_gzp_set_primask(uint32_t primask)
{
#if defined(__CC_ARM)
//lint -save -e10 -e618 -e438 -e550 -e526 -e628 -e526
volatile register uint32_t __regPriMask __ASM("primask");
__regPriMask = (primask);
#else
__set_PRIMASK(primask);
#endif
//lint -restore
}
//============================================================================
// DATA FLASH OPERATION
// u32addr : 0-1024 (For 4KBytes Data Flash)
// u32data : 0-0xFFFFFFFF (4Bytes)
//============================================================================
void DATA_FLASH_Write(uint32_t u32addr,uint32_t u32data)
{
uint32_t i=0;
#ifdef M451
SYS_UnlockReg();
FMC_Open();
for(i=0; i<PAGE_SIZE; i++)
data_buff[i] = FMC_Read(DATA_Flash_Start_ADD+i*4+ u32addr/PAGE_SIZE*2048);
FMC_Erase(DATA_Flash_Start_ADD+u32addr/PAGE_SIZE*2048);
data_buff[u32addr%PAGE_SIZE]=u32data;
for(i=0; i<PAGE_SIZE; i++)
FMC_Write(DATA_Flash_Start_ADD+i*4+ u32addr/PAGE_SIZE*2048, data_buff[i]);
FMC_Close();
SYS_LockReg();
#else
uint32_t data_buff[PAGE_SIZE];
__set_PRIMASK(1);//Avoid interrupt
UNLOCKREG();
DrvFMC_EnableISP();
for(i=0; i<PAGE_SIZE; i++)
DrvFMC_Read(DATA_Flash_Start_ADD+i*4+ u32addr/128*512, &data_buff[i]);
DrvFMC_Erase(DATA_Flash_Start_ADD+u32addr/128*512);
data_buff[u32addr%128]=u32data;
for(i=0; i<PAGE_SIZE; i++)
DrvFMC_Write(DATA_Flash_Start_ADD+i*4+ u32addr/128*512, data_buff[i]);
DrvFMC_DisableISP();
LOCKREG();
__set_PRIMASK(0);
#endif
}
int32_t DrvFMC_Erase(uint32_t u32addr)
{
FMC->ISPCMD.FCTRL = 2;
FMC->ISPCMD.FCEN = 0;
FMC->ISPCMD.FOEN = 1;
FMC->ISPADR = u32addr;
__set_PRIMASK(1);
FMC->ISPTRG.ISPGO = 1;
__ISB();
while (FMC->ISPTRG.ISPGO);
__set_PRIMASK(0);
if (FMC->ISPCON.ISPFF == 1)
{
FMC->ISPCON.ISPFF = 1;
// return E_DRVFMC_ERR_ISP_FAIL;
return 0;
}
return 0;
}
void restoreInterruptMasking(const InterruptMask interruptMask)
{
#if CONFIG_ARCHITECTURE_ARMV7_M_KERNEL_BASEPRI != 0
__set_BASEPRI(interruptMask);
#else // CONFIG_ARCHITECTURE_ARMV7_M_KERNEL_BASEPRI == 0
__set_PRIMASK(interruptMask);
#endif // CONFIG_ARCHITECTURE_ARMV7_M_KERNEL_BASEPRI == 0
}
void bootloader (void) {
SysBootLoader = (void (*)(void)) (*((u32 *) 0x1fff0004));
RCC_DeInit();
SysTick->CTRL = 0;
SysTick->LOAD = 0;
SysTick->VAL = 0;
__set_PRIMASK(1);
__set_MSP(0x20001000);
SysBootLoader();
}
void Init_Cpu(void)
{
__set_PSP((uint32_t)msp_top);
__set_PRIMASK(1);
__set_FAULTMASK(1);
__set_CONTROL(0);
switch(pg_scb_reg->CPUID)
{
case cn_revision_r0p0:
break; //市场没有版本0的芯片
case cn_revision_r1p0:
pg_scb_reg->CCR |= 1<<bo_scb_ccr_stkalign;
break;
case cn_revision_r1p1:
pg_scb_reg->CCR |= 1<<bo_scb_ccr_stkalign;
break;
case cn_revision_r2p0:break; //好像没什么要做的
}
pg_inflash_fpec_reg->ACR &= ~(u32)0x1f;
pg_inflash_fpec_reg->ACR |= (CN_CFG_MCLK-1)/24000000; //设置等待周期。
pg_inflash_fpec_reg->ACR |= 0x10; //开启预取
if(((pg_rcc_reg->CR & cn_cr_check_mask) != cn_cr_check)
|| ((pg_rcc_reg->CFGR & cn_cfgr_check_mask) != cn_cfgr_check))
{
//开始初始化时钟
//step1:复位时钟控制寄存器
pg_rcc_reg->CR |= (uint32_t)0x00000001;
// 复位 SW[1:0], HPRE[3:0], PPRE1[2:0], PPRE2[2:0], ADCPRE[1:0] MCO[2:0] 位
pg_rcc_reg->CFGR &= (uint32_t)0xF8FF0000;
// 复位 HSEON, CSSON and PLLON 位
pg_rcc_reg->CR &= (uint32_t)0xFEF6FFFF;
// 复位 HSEBYP 位
pg_rcc_reg->CR &= (uint32_t)0xFFFBFFFF;
// 复位 PLLSRC, PLLXTPRE, PLLMUL[3:0] and USBPRE 位
pg_rcc_reg->CFGR &= (uint32_t)0xFF80FFFF;
// 禁止所有中断
pg_rcc_reg->CIR = 0x00000000;
//step2:设置各时钟控制位以及倍频、分频值
pg_rcc_reg->CFGR = cn_cfgr_set+(7<<24); // set clock configuration register
pg_rcc_reg->CR = cn_cr_set; // set clock control register
while(bb_rcc_cr_hserdy ==0);
while(bb_rcc_cr_pllrdy ==0);
}
SRAM_Init();
Load_Preload();
}
void send_keyboard(report_keyboard_t *report)
{
uint32_t irqflags;
#ifdef NKRO_ENABLE
if (!keymap_config.nkro)
{
#endif //NKRO_ENABLE
while (udi_hid_kbd_b_report_trans_ongoing) { main_subtasks(); } //Run other tasks while waiting for USB to be free
irqflags = __get_PRIMASK();
__disable_irq();
__DMB();
memcpy(udi_hid_kbd_report, report->raw, UDI_HID_KBD_REPORT_SIZE);
udi_hid_kbd_b_report_valid = 1;
udi_hid_kbd_send_report();
__DMB();
__set_PRIMASK(irqflags);
#ifdef NKRO_ENABLE
}
else
{
while (udi_hid_nkro_b_report_trans_ongoing) { main_subtasks(); } //Run other tasks while waiting for USB to be free
irqflags = __get_PRIMASK();
__disable_irq();
__DMB();
memcpy(udi_hid_nkro_report, report->raw, UDI_HID_NKRO_REPORT_SIZE);
udi_hid_nkro_b_report_valid = 1;
udi_hid_nkro_send_report();
__DMB();
__set_PRIMASK(irqflags);
}
#endif //NKRO_ENABLE
}
/**
* \brief Schedules an rtimer task to be triggered at time t
* \param t The time when the task will need executed. This is an absolute
* time, in other words the task will be executed AT time \e t,
* not IN \e t ticks
*/
void
rtimer_arch_schedule(rtimer_clock_t t)
{
rtimer_clock_t now;
uint32_t primask = __get_PRIMASK();
__set_PRIMASK(1);
now = RTIMER_NOW();
/*
* New value must be a few ticks in the future.
*/
if((int32_t)(t - now) < 20) {
t = now + 20;
}
LPC_RITIMER->COMPVAL = t;
__set_PRIMASK(primask);
NVIC_EnableIRQ(RIT_IRQn);
}
