From 66d54ea8c0f6eae5713985a7fffd099ef3eea621 Mon Sep 17 00:00:00 2001 From: hydevcode Date: Mon, 30 Sep 2024 08:47:39 +0800 Subject: [PATCH] [bsp][nxp][rsoc] Fix compilation issues with bsp of nxp/lxp series --- .github/workflows/bsp_buildings.yml | 4 +- .../Device/startup/gcc_startup_lpc5410x.c | 272 ++-- .../lpc_chip/chip_5410x/hw_i2cmond.c | 296 ++-- .../Libraries/lpc_chip/chip_5410x/hw_uart.c | 916 ++++++------ .../Libraries/lpc_chip/chip_5410x/pll_5410x.c | 1264 +++++++++-------- .../chip_5410x/power_lib/keil/lib_power.lib | Bin 0 -> 14156 bytes .../power_lib/lpcxpresso/libpower.a | Bin 0 -> 6054 bytes .../lpc_chip/chip_5410x/romapi_5410x.h | 46 +- .../Libraries/lpc_chip/chip_common/iap.h | 2 +- bsp/nxp/lpc/lpc5410x/applications/board.h | 11 - bsp/nxp/lpc/lpc5410x/drivers/drv_uart.c | 1 + .../devices/LPC54114/arm/keil_lib_power.lib | Bin 0 -> 9650 bytes .../LPC54114/gcc/libpower_cm4_hardabi.a | Bin 0 -> 18500 bytes .../devices/LPC54114/iar/iar_lib_power.a | Bin 0 -> 9512 bytes bsp/nxp/lpc/lpc54114-lite/drivers/drv_spi.c | 2 +- components/drivers/include/drivers/adc.h | 30 +- components/drivers/include/drivers/dac.h | 36 +- 17 files changed, 1491 insertions(+), 1389 deletions(-) create mode 100644 bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/power_lib/keil/lib_power.lib create mode 100644 bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/power_lib/lpcxpresso/libpower.a create mode 100644 bsp/nxp/lpc/lpc54114-lite/Libraries/devices/LPC54114/arm/keil_lib_power.lib create mode 100644 bsp/nxp/lpc/lpc54114-lite/Libraries/devices/LPC54114/gcc/libpower_cm4_hardabi.a create mode 100644 bsp/nxp/lpc/lpc54114-lite/Libraries/devices/LPC54114/iar/iar_lib_power.a diff --git a/.github/workflows/bsp_buildings.yml b/.github/workflows/bsp_buildings.yml index b3eea5bebdf..d773276eb16 100644 --- a/.github/workflows/bsp_buildings.yml +++ b/.github/workflows/bsp_buildings.yml @@ -209,8 +209,8 @@ jobs: - "nxp/lpc/lpc1114" - "nxp/lpc/lpc2148" - "nxp/lpc/lpc2478" - # - "nxp/lpc/lpc5410x" - # - "nxp/lpc/lpc54114-lite" + - "nxp/lpc/lpc5410x" + - "nxp/lpc/lpc54114-lite" - "nxp/lpc/lpc176x" #- "nxp/lpc/lpc43xx/M4" - "nxp/imx/imx6sx/cortex-a9" diff --git a/bsp/nxp/lpc/lpc5410x/Libraries/Device/startup/gcc_startup_lpc5410x.c b/bsp/nxp/lpc/lpc5410x/Libraries/Device/startup/gcc_startup_lpc5410x.c index 1cd349e94db..fcc48208609 100644 --- a/bsp/nxp/lpc/lpc5410x/Libraries/Device/startup/gcc_startup_lpc5410x.c +++ b/bsp/nxp/lpc/lpc5410x/Libraries/Device/startup/gcc_startup_lpc5410x.c @@ -1,23 +1,9 @@ -//***************************************************************************** -// -// Startup code for use with GNU tools. -// -//***************************************************************************** - - -//***************************************************************************** -// -// Forward declaration of the default fault handlers. -// -//***************************************************************************** +/* Startup code for use with GNU tools.*/ +/* Forward declaration of the default fault handlers.*/ static void Reset_Handler(void); static void Default_Handler(void); -//***************************************************************************** -// -// External declaration for the interrupt handler used by the application. -// -//***************************************************************************** +/* External declaration for the interrupt handler used by the application.*/ void NMI_Handler(void) __attribute__((weak, alias("Default_Handler"))); void HardFault_Handler(void) __attribute__((weak, alias("Default_Handler"))); void MemManage_Handler(void) __attribute__((weak, alias("Default_Handler"))); @@ -59,182 +45,161 @@ void ADC_SEQA_IRQHandler(void) __attribute__((weak, alias("Default_Handler" void ADC_SEQB_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); void ADC_THCMP_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); void RTC_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); -//void Reserved_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); +/*void Reserved_IRQHandler(void) __attribute__((weak, alias("Default_Handler")));*/ void MAILBOX_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); void GINT1_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); void PIN_INT4_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); void PIN_INT5_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); void PIN_INT6_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); void PIN_INT7_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); -//void Reserved_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); -//void Reserved_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); -//void Reserved_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); +/*void Reserved_IRQHandler(void) __attribute__((weak, alias("Default_Handler")));*/ +/*void Reserved_IRQHandler(void) __attribute__((weak, alias("Default_Handler")));*/ +/*void Reserved_IRQHandler(void) __attribute__((weak, alias("Default_Handler")));*/ void RIT_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); void Reserved41_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); void Reserved42_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); void Reserved43_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); void Reserved44_IRQHandler(void) __attribute__((weak, alias("Default_Handler"))); -//***************************************************************************** -// -// The entry point for the application. -// -//***************************************************************************** +/* The entry point for the application.*/ extern int main(void); -//***************************************************************************** -// -// Reserve space for the system stack. -// -//***************************************************************************** +/* Reserve space for the system stack.*/ static unsigned long pulStack[512]; -//***************************************************************************** -// -// The vector table. Note that the proper constructs must be placed on this to -// ensure that it ends up at physical address 0x0000.0000. -// -//***************************************************************************** +/* The vector table. Note that the proper constructs must be placed on this to*/ +/* ensure that it ends up at physical address 0x0000.0000.*/ __attribute__ ((section(".isr_vector"))) void (* const g_pfnVectors[])(void) = { (void (*)(void))((unsigned long)pulStack + sizeof(pulStack)), - // The initial stack pointer - Reset_Handler, // Reset Handler - NMI_Handler, // NMI Handler - HardFault_Handler, // Hard Fault Handler - MemManage_Handler, // MPU Fault Handler - BusFault_Handler, // Bus Fault Handler - UsageFault_Handler, // Usage Fault Handler - 0, // Reserved - 0, // Reserved - 0, // Reserved - 0, // Reserved - SVC_Handler, // SVCall Handler - DebugMon_Handler, // Debug Monitor Handler - 0, // Reserved - PendSV_Handler, // PendSV Handler - SysTick_Handler, // SysTick Handler + /* The initial stack pointer*/ + Reset_Handler, /* Reset Handler*/ + NMI_Handler, /* NMI Handler*/ + HardFault_Handler, /* Hard Fault Handler*/ + MemManage_Handler, /* MPU Fault Handler*/ + BusFault_Handler, /* Bus Fault Handler*/ + UsageFault_Handler, /* Usage Fault Handler*/ + 0, /* Reserved*/ + 0, /* Reserved*/ + 0, /* Reserved*/ + 0, /* Reserved*/ + SVC_Handler, /* SVCall Handler*/ + DebugMon_Handler, /* Debug Monitor Handler*/ + 0, /* Reserved*/ + PendSV_Handler, /* PendSV Handler*/ + SysTick_Handler, /* SysTick Handler*/ - // External Interrupts - WDT_IRQHandler, - BOD_IRQHandler, - Reserved_IRQHandler, - DMA_IRQHandler, - GINT0_IRQHandler, - PIN_INT0_IRQHandler, - PIN_INT1_IRQHandler, - PIN_INT2_IRQHandler, - PIN_INT3_IRQHandler, - UTICK_IRQHandler, - MRT_IRQHandler, - CT32B0_IRQHandler, - CT32B1_IRQHandler, - CT32B2_IRQHandler, - CT32B3_IRQHandler, - CT32B4_IRQHandler, - SCT0_IRQHandler, - UART0_IRQHandler, - UART1_IRQHandler, - UART2_IRQHandler, - UART3_IRQHandler, - I2C0_IRQHandler, - I2C1_IRQHandler, - I2C2_IRQHandler, - SPI0_IRQHandler, - SPI1_IRQHandler, - ADC_SEQA_IRQHandler, - ADC_SEQB_IRQHandler, - ADC_THCMP_IRQHandler, - RTC_IRQHandler, - Reserved_IRQHandler, - MAILBOX_IRQHandler, - GINT1_IRQHandler, - PIN_INT4_IRQHandler, - PIN_INT5_IRQHandler, - PIN_INT6_IRQHandler, - PIN_INT7_IRQHandler, - Reserved_IRQHandler, - Reserved_IRQHandler, - Reserved_IRQHandler, - RIT_IRQHandler, - Reserved41_IRQHandler, - Reserved42_IRQHandler, - Reserved43_IRQHandler, - Reserved44_IRQHandler, + /* External Interrupts*/ + WDT_IRQHandler, + BOD_IRQHandler, + Reserved_IRQHandler, + DMA_IRQHandler, + GINT0_IRQHandler, + PIN_INT0_IRQHandler, + PIN_INT1_IRQHandler, + PIN_INT2_IRQHandler, + PIN_INT3_IRQHandler, + UTICK_IRQHandler, + MRT_IRQHandler, + CT32B0_IRQHandler, + CT32B1_IRQHandler, + CT32B2_IRQHandler, + CT32B3_IRQHandler, + CT32B4_IRQHandler, + SCT0_IRQHandler, + UART0_IRQHandler, + UART1_IRQHandler, + UART2_IRQHandler, + UART3_IRQHandler, + I2C0_IRQHandler, + I2C1_IRQHandler, + I2C2_IRQHandler, + SPI0_IRQHandler, + SPI1_IRQHandler, + ADC_SEQA_IRQHandler, + ADC_SEQB_IRQHandler, + ADC_THCMP_IRQHandler, + RTC_IRQHandler, + Reserved_IRQHandler, + MAILBOX_IRQHandler, + GINT1_IRQHandler, + PIN_INT4_IRQHandler, + PIN_INT5_IRQHandler, + PIN_INT6_IRQHandler, + PIN_INT7_IRQHandler, + Reserved_IRQHandler, + Reserved_IRQHandler, + Reserved_IRQHandler, + RIT_IRQHandler, + Reserved41_IRQHandler, + Reserved42_IRQHandler, + Reserved43_IRQHandler, + Reserved44_IRQHandler, }; -//**RIT_IRQHandler *************************************************************************** -// Reserved41_IRQHandler -// TReserved42_IRQHandler he following are constructs created by the linker, indicating where the -// tReserved43_IRQHandler he "data" and "bss" segments reside in memory. The initializers for the -// fReserved44_IRQHandler or the "data" segment resides immediately following the "text" segment. -// -//***************************************************************************** +/* RIT_IRQHandler */ +/* Reserved41_IRQHandler*/ +/* TReserved42_IRQHandler he following are constructs created by the linker, indicating where the*/ +/* tReserved43_IRQHandler he "data" and "bss" segments reside in memory. The initializers for the*/ +/* fReserved44_IRQHandler or the "data" segment resides immediately following the "text" segment.*/ extern unsigned long _etext; extern unsigned long _data; extern unsigned long _edata; extern unsigned long _bss; extern unsigned long _ebss; -//***************************************************************************** -// -// This is the code that gets called when the processor first starts execution -// following a reset event. Only the absolutely necessary set is performed, -// after which the application supplied entry() routine is called. Any fancy -// actions (such as making decisions based on the reset cause register, and -// resetting the bits in that register) are left solely in the hands of the -// application. -// -//***************************************************************************** +/* This is the code that gets called when the processor first starts execution*/ +/* following a reset event. Only the absolutely necessary set is performed,*/ +/* after which the application supplied entry() routine is called. Any fancy*/ +/* actions (such as making decisions based on the reset cause register, and*/ +/* resetting the bits in that register) are left solely in the hands of the*/ +/* application.*/ static void Reset_Handler(void) { unsigned long *pulSrc, *pulDest; - // - // Copy the data segment initializers from flash to SRAM. - // + /* Copy the data segment initializers from flash to SRAM.*/ pulSrc = &_etext; + /* cppcheck-suppress comparePointers */ for(pulDest = &_data; pulDest < &_edata; ) { *pulDest++ = *pulSrc++; } - - + + #if !defined (__USE_LPCOPEN) -// LPCOpen init code deals with FP and VTOR initialisation +/* LPCOpen init code deals with FP and VTOR initialisation*/ #if defined (__VFP_FP__) && !defined (__SOFTFP__) /* * Code to enable the Cortex-M4 FPU only included * if appropriate build options have been selected. * Code taken from Section 7.1, Cortex-M4 TRM (DDI0439C) */ - // CPACR is located at address 0xE000ED88 + /* CPACR is located at address 0xE000ED88*/ asm("LDR.W R0, =0xE000ED88"); - // Read CPACR + /* Read CPACR*/ asm("LDR R1, [R0]"); - // Set bits 20-23 to enable CP10 and CP11 coprocessors + /* Set bits 20-23 to enable CP10 and CP11 coprocessors*/ asm(" ORR R1, R1, #(0xF << 20)"); - // Write back the modified value to the CPACR + /* Write back the modified value to the CPACR*/ asm("STR R1, [R0]"); -#endif // (__VFP_FP__) && !(__SOFTFP__) - // ****************************** - // Check to see if we are running the code from a non-zero - // address (eg RAM, external flash), in which case we need - // to modify the VTOR register to tell the CPU that the - // vector table is located at a non-0x0 address. +#endif /* (__VFP_FP__) && !(__SOFTFP__)*/ + /* Check to see if we are running the code from a non-zero*/ + /* address (eg RAM, external flash), in which case we need*/ + /* to modify the VTOR register to tell the CPU that the*/ + /* vector table is located at a non-0x0 address.*/ - // Note that we do not use the CMSIS register access mechanism, - // as there is no guarantee that the project has been configured - // to use CMSIS. + /* Note that we do not use the CMSIS register access mechanism,*/ + /* as there is no guarantee that the project has been configured*/ + /* to use CMSIS.*/ unsigned int * pSCB_VTOR = (unsigned int *) 0xE000ED08; - if ((unsigned int *) g_pfnVectors != (unsigned int *) 0x00000000) { - // CMSIS : SCB->VTOR =
+ if ((unsigned int *) g_pfnVectors != (unsigned int *) 0x00000000) + { + /* CMSIS : SCB->VTOR =
*/ *pSCB_VTOR = (unsigned int) g_pfnVectors; } #endif - - // - // Zero fill the bss segment. - // + + /* Zero fill the bss segment.*/ __asm(" ldr r0, =_bss\n" " ldr r1, =_ebss\n" " mov r2, #0\n" @@ -245,28 +210,21 @@ static void Reset_Handler(void) " strlt r2, [r0], #4\n" " blt zero_loop"); - // call system init. - SystemInit(); + /* call system init.*/ + extern void SystemInit(void); + SystemInit(); - // - // Call the application's entry point. - // + /* Call the application's entry point.*/ main(); } -//***************************************************************************** -// -// This is the code that gets called when the processor receives an unexpected -// interrupt. This simply enters an infinite loop, preserving the system state -// for examination by a debugger. -// -//***************************************************************************** +/* This is the code that gets called when the processor receives an unexpected*/ +/* interrupt. This simply enters an infinite loop, preserving the system state*/ +/* for examination by a debugger.*/ static void Default_Handler(void) { - // - // Go into an infinite loop. - // + /* Go into an infinite loop.*/ while(1) { } -} +} \ No newline at end of file diff --git a/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/hw_i2cmond.c b/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/hw_i2cmond.c index 775200c1fcb..4f7aa8c5e9d 100644 --- a/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/hw_i2cmond.c +++ b/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/hw_i2cmond.c @@ -38,171 +38,189 @@ /* Private data structure used for the I2C monitor driver, holds the driver and peripheral context */ typedef struct { - void *pUserData; /*!< Pointer to user data used by driver instance, use NULL if not used */ - LPC_I2C_T *base; /*!< Base address of I2C peripheral to use */ - i2cMonCapReadyCB pCapCompCB; /*!< Capture complete callback */ - i2cMonSetupDMACB pDmaSetupCB; /*!< DMA setup callback */ - ROM_I2CMON_CAP_T *pCap; /*!< Pointer to current capture descriptor */ - ErrorCode_t pendingStatus; /*!< Pending monitor transfer status before clocking transfer */ + void *pUserData; /*!< Pointer to user data used by driver instance, use NULL if not used */ + LPC_I2C_T *base; /*!< Base address of I2C peripheral to use */ + i2cMonCapReadyCB pCapCompCB; /*!< Capture complete callback */ + i2cMonSetupDMACB pDmaSetupCB; /*!< DMA setup callback */ + ROM_I2CMON_CAP_T *pCap; /*!< Pointer to current capture descriptor */ + ErrorCode_t pendingStatus; /*!< Pending monitor transfer status before clocking transfer */ } I2CMON_DATACONTEXT_T; void i2cmon_transfer_handler(ROM_I2CMON_HANDLE_T pHandle) ; -// ********************************************************** +/* ********************************************************** */ uint32_t i2cmon_get_mem_size(void) { - return sizeof(I2CMON_DATACONTEXT_T); + return sizeof(I2CMON_DATACONTEXT_T); } ROM_I2CMON_HANDLE_T i2cmon_init(void *mem, const ROM_I2CMON_INIT_T *pInit) { - I2CMON_DATACONTEXT_T *pDrv; - uint32_t reg; - - /* Verify alignment is at least 4 bytes */ - if (((uint32_t) mem & 0x3) != 0) { - return NULL; - } - - pDrv = (I2CMON_DATACONTEXT_T *) mem; - memset(pDrv, 0, sizeof(I2CMON_DATACONTEXT_T)); - - /* Save base of peripheral and pointer to user data */ - pDrv->pUserData = pInit->pUserData; - pDrv->base = (LPC_I2C_T *) pInit->base; - - /* Clear pending monitor statuses */ - pDrv->base->STAT = (I2C_STAT_MONIDLE | I2C_STAT_MONOV); - while ((pDrv->base->STAT & I2C_STAT_MONRDY) != 0) { - /* Toss input data */ - reg = pDrv->base->MONRXDAT; - } - - /* Enable I2C monitor interface */ - reg = pDrv->base->CFG | I2C_CFG_MONEN; - if (pInit->stretch != 0) { - reg |= I2C_CFG_MONCLKSTR; - } - pDrv->base->CFG = reg; - - return pDrv; + I2CMON_DATACONTEXT_T *pDrv; + uint32_t reg; + + /* Verify alignment is at least 4 bytes */ + if (((uint32_t) mem & 0x3) != 0) + { + return NULL; + } + + pDrv = (I2CMON_DATACONTEXT_T *) mem; + memset(pDrv, 0, sizeof(I2CMON_DATACONTEXT_T)); + + /* Save base of peripheral and pointer to user data */ + pDrv->pUserData = pInit->pUserData; + pDrv->base = (LPC_I2C_T *) pInit->base; + + /* Clear pending monitor statuses */ + pDrv->base->STAT = (I2C_STAT_MONIDLE | I2C_STAT_MONOV); + while ((pDrv->base->STAT & I2C_STAT_MONRDY) != 0) + { + /* Toss input data */ + reg = pDrv->base->MONRXDAT; + } + + /* Enable I2C monitor interface */ + reg = pDrv->base->CFG | I2C_CFG_MONEN; + if (pInit->stretch != 0) + { + reg |= I2C_CFG_MONCLKSTR; + } + pDrv->base->CFG = reg; + + return pDrv; } void i2cmom_register_callback(ROM_I2CMON_HANDLE_T pHandle, uint32_t cbIndex, void *pCB) { - I2CMON_DATACONTEXT_T *pDrv = (I2CMON_DATACONTEXT_T *) pHandle; - - if (cbIndex == ROM_I2CMON_CAPTUREREADY_CB) { - pDrv->pCapCompCB = (i2cMonCapReadyCB) pCB; - } - else if (cbIndex == ROM_I2CMON_DMASETUP_CB) { - pDrv->pDmaSetupCB = (i2cMonSetupDMACB) pCB; - } + I2CMON_DATACONTEXT_T *pDrv = (I2CMON_DATACONTEXT_T *) pHandle; + + if (cbIndex == ROM_I2CMON_CAPTUREREADY_CB) + { + pDrv->pCapCompCB = (i2cMonCapReadyCB) pCB; + } + else if (cbIndex == ROM_I2CMON_DMASETUP_CB) + { + pDrv->pDmaSetupCB = (i2cMonSetupDMACB) pCB; + } } ErrorCode_t i2cmom_start_log(ROM_I2CMON_HANDLE_T pHandle, ROM_I2CMON_CAP_T *pCap) { - I2CMON_DATACONTEXT_T *pDrv = (I2CMON_DATACONTEXT_T *) pHandle; - - /* I2C master controller should be pending and idle */ - if (pCap == NULL) { - return ERR_I2C_PARAM; - } - - /* Verify receive buffer alignment */ - if ((pCap->startBuff == NULL) || ((((uint32_t) pCap->startBuff) & 0x1) != 0) || (pCap->startBuffSz == 0)) { - pCap->status = ERR_I2C_PARAM; - return ERR_I2C_PARAM; - } - - pDrv->pCap = pCap; - pCap->capStartBuffSz = 0; - pDrv->pendingStatus = LPC_OK; - pCap->status = ERR_I2C_BUSY; - - if ((pCap->flags & ROM_I2CMON_FLAG_FLUSH) != 0) { - while ((pDrv->base->STAT & I2C_STAT_MONRDY) != 0) { - /* Toss input data */ - volatile uint32_t reg = pDrv->base->MONRXDAT; - } - } - - /* Clear controller state */ - pDrv->base->STAT = (I2C_STAT_MONIDLE | I2C_STAT_MONOV); - - if (((pCap->flags & ROM_I2CMON_FLAG_DMARX) != 0) && (pDrv->pDmaSetupCB)) { - pDrv->pDmaSetupCB(pHandle, pCap); - - /* Enable supported monitor interrupts */ - pDrv->base->INTENSET = (I2C_INTENSET_MONOV | I2C_INTENSET_MONIDLE); - } - else { - pCap->flags &= ~ROM_I2CMON_FLAG_DMARX; - - /* Enable supported monitor interrupts */ - pDrv->base->INTENSET = (I2C_INTENSET_MONRDY | I2C_INTENSET_MONOV | I2C_INTENSET_MONIDLE); - } - - /* Is transfer blocking? */ - if ((pCap->flags & ROM_I2CMON_FLAG_BLOCKING) != 0) { - while (pCap->status == ERR_I2C_BUSY) { - i2cmon_transfer_handler(pHandle); - } - } - - return pCap->status; + I2CMON_DATACONTEXT_T *pDrv = (I2CMON_DATACONTEXT_T *) pHandle; + + /* I2C master controller should be pending and idle */ + if (pCap == NULL) + { + return ERR_I2C_PARAM; + } + + /* Verify receive buffer alignment */ + if ((pCap->startBuff == NULL) || ((((uint32_t) pCap->startBuff) & 0x1) != 0) || (pCap->startBuffSz == 0)) + { + pCap->status = ERR_I2C_PARAM; + return ERR_I2C_PARAM; + } + + pDrv->pCap = pCap; + pCap->capStartBuffSz = 0; + pDrv->pendingStatus = LPC_OK; + pCap->status = ERR_I2C_BUSY; + + if ((pCap->flags & ROM_I2CMON_FLAG_FLUSH) != 0) + { + while ((pDrv->base->STAT & I2C_STAT_MONRDY) != 0) + { + /* Toss input data */ + volatile uint32_t reg = pDrv->base->MONRXDAT; + (void)reg; + } + } + + /* Clear controller state */ + pDrv->base->STAT = (I2C_STAT_MONIDLE | I2C_STAT_MONOV); + + if (((pCap->flags & ROM_I2CMON_FLAG_DMARX) != 0) && (pDrv->pDmaSetupCB)) + { + pDrv->pDmaSetupCB(pHandle, pCap); + + /* Enable supported monitor interrupts */ + pDrv->base->INTENSET = (I2C_INTENSET_MONOV | I2C_INTENSET_MONIDLE); + } + else { + pCap->flags &= ~ROM_I2CMON_FLAG_DMARX; + + /* Enable supported monitor interrupts */ + pDrv->base->INTENSET = (I2C_INTENSET_MONRDY | I2C_INTENSET_MONOV | I2C_INTENSET_MONIDLE); + } + + /* Is transfer blocking? */ + if ((pCap->flags & ROM_I2CMON_FLAG_BLOCKING) != 0) + { + while (pCap->status == ERR_I2C_BUSY) + { + i2cmon_transfer_handler(pHandle); + } + } + + return pCap->status; } -// Otime = "optimize for speed of code execution" -// ...add this pragma 1 line above the interrupt service routine function. +/* Otime = "optimize for speed of code execution"*/ +/* ...add this pragma 1 line above the interrupt service routine function.*/ void i2cmon_transfer_handler(ROM_I2CMON_HANDLE_T pHandle) { - I2CMON_DATACONTEXT_T *pDrv = (I2CMON_DATACONTEXT_T *) pHandle; - ROM_I2CMON_CAP_T *pCap = pDrv->pCap; - uint16_t data = 0, *pData; - - uint32_t status = pDrv->base->STAT; - - if (status & I2C_STAT_MONOV) { - /* Monitor data overflow */ - data = pDrv->base->MONRXDAT; - pDrv->pendingStatus = ERR_I2C_BUFFER_OVERFLOW; - - /* Clear Status Flags */ - pDrv->base->STAT = I2C_STAT_MONOV; - } - else if (status & I2C_STAT_MONRDY) { - /* Monitor ready */ - data = pDrv->base->MONRXDAT; - - /* Enough room to place this data? */ - if (pCap->capStartBuffSz >= pCap->startBuffSz) { - /* Data overflow */ - pDrv->pendingStatus = ERR_I2C_BUFFER_OVERFLOW; - } - else { - pData = (uint16_t *) pCap->startBuff; - - pData[pCap->capStartBuffSz] = data; - pCap->capStartBuffSz++; - } - } - - /* Capture complete? */ - if ((status & I2C_INTSTAT_MONIDLE) != 0) { - pDrv->base->INTENCLR = (I2C_INTENCLR_MONRDY | I2C_INTENCLR_MONOV | - I2C_INTENCLR_MONIDLE); - pCap->status = pDrv->pendingStatus; - if (pDrv->pCapCompCB) { - pDrv->pCapCompCB(pHandle, pCap); - } - } + I2CMON_DATACONTEXT_T *pDrv = (I2CMON_DATACONTEXT_T *) pHandle; + ROM_I2CMON_CAP_T *pCap = pDrv->pCap; + uint16_t data = 0, *pData; + + uint32_t status = pDrv->base->STAT; + + if (status & I2C_STAT_MONOV) + { + /* Monitor data overflow */ + data = pDrv->base->MONRXDAT; + pDrv->pendingStatus = ERR_I2C_BUFFER_OVERFLOW; + + /* Clear Status Flags */ + pDrv->base->STAT = I2C_STAT_MONOV; + } + else if (status & I2C_STAT_MONRDY) + { + /* Monitor ready */ + data = pDrv->base->MONRXDAT; + + /* Enough room to place this data? */ + if (pCap->capStartBuffSz >= pCap->startBuffSz) + { + /* Data overflow */ + pDrv->pendingStatus = ERR_I2C_BUFFER_OVERFLOW; + } + else { + pData = (uint16_t *) pCap->startBuff; + + pData[pCap->capStartBuffSz] = data; + pCap->capStartBuffSz++; + } + } + + /* Capture complete? */ + if ((status & I2C_INTSTAT_MONIDLE) != 0) + { + pDrv->base->INTENCLR = (I2C_INTENCLR_MONRDY | I2C_INTENCLR_MONOV | + I2C_INTENCLR_MONIDLE); + pCap->status = pDrv->pendingStatus; + if (pDrv->pCapCompCB) + { + pDrv->pCapCompCB(pHandle, pCap); + } + } } uint32_t i2cmon_get_driver_version(void) { - return DRVVERSION; + return DRVVERSION; } -// ********************************************************* +/* ********************************************************** */ diff --git a/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/hw_uart.c b/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/hw_uart.c index f8fcf0207b0..b9bf27c518f 100644 --- a/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/hw_uart.c +++ b/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/hw_uart.c @@ -32,564 +32,638 @@ #include "error.h" #include "hw_uart_rom_api.h" -#define UART_IDLE_FIX /* Remove once IDLE problem is fixed */ +#define UART_IDLE_FIX /* Remove once IDLE problem is fixed */ /* UART Driver internal data structure */ typedef struct { - void *pUserData; /* Pointer to user data */ - UART_REGS_T *pREGS; /* Pointer to Registers */ - UART_DATA_T xfer[2]; /* TX/RX transfer data */ + void *pUserData; /* Pointer to user data */ + UART_REGS_T *pREGS; /* Pointer to Registers */ + UART_DATA_T xfer[2]; /* TX/RX transfer data */ #ifdef UART_IDLE_FIX - uint32_t dly; /* Delay to count 1 bit time; REMOVE: when H/W is fixed */ + uint32_t dly; /* Delay to count 1 bit time; REMOVE: when H/W is fixed */ #endif - void(*cbTable[UART_CB_RESERVED]) (UART_HANDLE_T, UART_EVENT_T, void *); /* Call-back index table */ + void(*cbTable[UART_CB_RESERVED]) (UART_HANDLE_T, UART_EVENT_T, void *); /* Call-back index table */ } UART_DRIVER_T; /* PRIVATE: Division logic to divide without integer overflow */ static uint32_t _UART_DivClk(uint32_t pclk, uint32_t m) { - uint32_t q, r, u = pclk >> 24, l = pclk << 8; - m = m + 256; - q = (1 << 24) / m; - r = (1 << 24) - (q * m); - return ((q * u) << 8) + (((r * u) << 8) + l) / m; + uint32_t q, r, u = pclk >> 24, l = pclk << 8; + m = m + 256; + q = (1 << 24) / m; + r = (1 << 24) - (q * m); + return ((q * u) << 8) + (((r * u) << 8) + l) / m; } /* PRIVATE: Get highest Over sampling value */ static uint32_t _UART_GetHighDiv(uint32_t val, uint8_t strict) { - int32_t i, max = strict ? 16 : 5; - for (i = 16; i >= max; i--) { - if (!(val % i)) { - return i; - } - } - return 0; + int32_t i, max = strict ? 16 : 5; + for (i = 16; i >= max; i--) + { + if (!(val % i)) + { + return i; + } + } + return 0; } /* PRIVATE: Queue a transfer in UART */ static ErrorCode_t _UART_Xfer(UART_DRIVER_T *pUART, void *buff, uint16_t len, uint8_t op) { - UART_DATA_T *xfr = &pUART->xfer[op]; - - /* Xfer of 0 bytes in a UART should always be successful */ - if (!len) { - return LPC_OK; - } - - /* Check if a Xfer is alredy in progress */ - if (xfr->count > xfr->offset) { - return ERR_BUSY; - } - - xfr->buf = (void *) buff; - xfr->count = len; - xfr->offset = 0; - xfr->state = UART_ST_BUSY; - if (!op) { - pUART->pREGS->INTENSET = UART_INT_TXRDY; - } - else { - pUART->pREGS->INTENSET = UART_INT_RXRDY | UART_INT_FRMERR | UART_INT_RXNOISE | UART_INT_START | UART_INT_OVR; - } - - return LPC_OK; + UART_DATA_T *xfr = &pUART->xfer[op]; + + /* Xfer of 0 bytes in a UART should always be successful */ + if (!len) + { + return LPC_OK; + } + + /* Check if a Xfer is alredy in progress */ + if (xfr->count > xfr->offset) + { + return ERR_BUSY; + } + + xfr->buf = (void *) buff; + xfr->count = len; + xfr->offset = 0; + xfr->state = UART_ST_BUSY; + if (!op) + { + pUART->pREGS->INTENSET = UART_INT_TXRDY; + } + else { + pUART->pREGS->INTENSET = UART_INT_RXRDY | UART_INT_FRMERR | UART_INT_RXNOISE | UART_INT_START | UART_INT_OVR; + } + + return LPC_OK; } /* Calculate error difference */ static int32_t _CalcErr(uint32_t n, uint32_t d, uint32_t *prev) { - uint32_t err = n - (n / d) * d; - uint32_t herr = ((n / d) + 1) * d - n; - if (herr < err) { - err = herr; - } - - if (*prev <= err) { - return 0; - } - *prev = err; - return (herr == err) + 1; + uint32_t err = n - (n / d) * d; + uint32_t herr = ((n / d) + 1) * d - n; + if (herr < err) + { + err = herr; + } + + if (*prev <= err) + { + return 0; + } + *prev = err; + return (herr == err) + 1; } /* Calculate the base DIV value */ static ErrorCode_t _UART_CalcDiv(UART_BAUD_T *ub) { - int32_t i = 0; - uint32_t perr = ~0UL; - - if (!ub->div) { - i = ub->ovr ? ub->ovr : 16; - } - - for (; i > 4; i--) { - int32_t tmp = _CalcErr(ub->clk, ub->baud * i, &perr); - - /* Continue when no improvement seen in err value */ - if (!tmp) { - continue; - } - - ub->div = tmp - 1; - if (ub->ovr == i) { - break; - } - ub->ovr = i; - } - - if (!ub->ovr) { - return ERR_UART_BAUDRATE; - } - - ub->div += ub->clk / (ub->baud * ub->ovr); - if (!ub->div) { - return ERR_UART_BAUDRATE; - } - - ub->baud = ub->clk / (ub->div * ub->ovr); - return LPC_OK; + int32_t i = 0; + uint32_t perr = ~0UL; + + if (!ub->div) + { + i = ub->ovr ? ub->ovr : 16; + } + + for (; i > 4; i--) + { + int32_t tmp = _CalcErr(ub->clk, ub->baud * i, &perr); + + /* Continue when no improvement seen in err value */ + if (!tmp) + { + continue; + } + + ub->div = tmp - 1; + if (ub->ovr == i) + { + break; + } + ub->ovr = i; + } + + if (!ub->ovr) + { + return ERR_UART_BAUDRATE; + } + + ub->div += ub->clk / (ub->baud * ub->ovr); + if (!ub->div) + { + return ERR_UART_BAUDRATE; + } + + ub->baud = ub->clk / (ub->div * ub->ovr); + return LPC_OK; } /* Calculate the best MUL value */ static void _UART_CalcMul(UART_BAUD_T *ub) { - uint32_t m, perr = ~0UL, pclk = ub->clk, ovr = ub->ovr; - - /* If clock is UART's base clock calculate only the divider */ - for (m = 0; m < 256; m++) { - uint32_t ov = ovr, x, v, tmp; - - /* Get clock and calculate error */ - x = _UART_DivClk(pclk, m); - tmp = _CalcErr(x, ub->baud, &perr); - v = (x / ub->baud) + tmp - 1; - - /* Update if new error is better than previous best */ - if (!tmp || (ovr && (v % ovr)) || - (!ovr && ((ov = _UART_GetHighDiv(v, ovr)) == 0))) { - continue; - } - - ub->ovr = ov; - ub->mul = m; - ub->clk = x; - ub->div = tmp - 1; - } + uint32_t m, perr = ~0UL, pclk = ub->clk, ovr = ub->ovr; + + /* If clock is UART's base clock calculate only the divider */ + for (m = 0; m < 256; m++) + { + uint32_t ov = ovr, x, v, tmp; + + /* Get clock and calculate error */ + x = _UART_DivClk(pclk, m); + tmp = _CalcErr(x, ub->baud, &perr); + v = (x / ub->baud) + tmp - 1; + + /* Update if new error is better than previous best */ + if (!tmp || (ovr && (v % ovr)) || + (!ovr && ((ov = _UART_GetHighDiv(v, ovr)) == 0))) + { + continue; + } + + ub->ovr = ov; + ub->mul = m; + ub->clk = x; + ub->div = tmp - 1; + } } /* PRIVATE: Invoke UART Call back functions */ static void _UART_InvokeCB(UART_DRIVER_T *pUART, UART_EVENT_T event, void *arg) { - void (*cbfn)(UART_HANDLE_T, UART_EVENT_T, void *); - cbfn = pUART->cbTable[(uint32_t) event >> 1]; - if (cbfn != NULL) { - cbfn((UART_HANDLE_T) pUART, event, arg); - } + void (*cbfn)(UART_HANDLE_T, UART_EVENT_T, void *); + cbfn = pUART->cbTable[(uint32_t) event >> 1]; + if (cbfn != NULL) + { + cbfn((UART_HANDLE_T) pUART, event, arg); + } } /* PRIVATE: Handler for data transfers */ static void _UART_HandleTxRx(UART_HANDLE_T hUART, UART_EVENT_T event, void *arg) { - UART_DATA_T *dat = (UART_DATA_T *) arg; - UART_DRIVER_T *pUART = (UART_DRIVER_T *) hUART; - uint16_t *buf16 = dat->buf; - uint8_t *buf8 = dat->buf; - - /* Transmit data */ - if (event == UART_TX_DATA) { - while (dat->count && (pUART->pREGS->INTSTAT & UART_INT_TXRDY)) { - if (dat->dwidth) { - pUART->pREGS->TXDAT = *buf16++; - } - else { - pUART->pREGS->TXDAT = *buf8++; - } - dat->count--; - } - return; - } - - /* Receive data */ - while (dat->count && (pUART->pREGS->INTSTAT & UART_INT_RXRDY)) { - if (dat->dwidth) { - *buf16++ = pUART->pREGS->RXDAT & 0x1FF; - } - else { - *buf8++ = pUART->pREGS->RXDAT & 0xFF; - } - dat->count--; - } + UART_DATA_T *dat = (UART_DATA_T *) arg; + UART_DRIVER_T *pUART = (UART_DRIVER_T *) hUART; + uint16_t *buf16 = dat->buf; + uint8_t *buf8 = dat->buf; + + /* Transmit data */ + if (event == UART_TX_DATA) + { + while (dat->count && (pUART->pREGS->INTSTAT & UART_INT_TXRDY)) + { + if (dat->dwidth) + { + pUART->pREGS->TXDAT = *buf16++; + } + else { + pUART->pREGS->TXDAT = *buf8++; + } + dat->count--; + } + return; + } + + /* Receive data */ + while (dat->count && (pUART->pREGS->INTSTAT & UART_INT_RXRDY)) + { + if (dat->dwidth) + { + *buf16++ = pUART->pREGS->RXDAT & 0x1FF; + } + else { + *buf8++ = pUART->pREGS->RXDAT & 0xFF; + } + dat->count--; + } } /* Handle UART Receive event */ static int32_t _UART_HandleXfer(UART_DRIVER_T *pUART, uint8_t op) { - UART_DATA_T dat; - UART_DATA_T *xfr = &pUART->xfer[op]; - - /* See if the transfer is already complete */ - if (xfr->offset >= xfr->count) { - return 2; - } - - /* Fill the buffer data structure */ - dat.count = xfr->count - xfr->offset; - dat.dwidth = ((pUART->pREGS->CFG >> 2) & 3) > 1; - if (dat.dwidth) { - dat.buf = &((uint16_t *) xfr->buf)[xfr->offset]; - } - else { - dat.buf = &((uint8_t *) xfr->buf)[xfr->offset]; - } - - if (!xfr->offset && xfr->count) { - _UART_InvokeCB(pUART, UART_TX_START, xfr); - } - - pUART->cbTable[UART_CB_DATA]((UART_HANDLE_T) pUART, (UART_EVENT_T) (UART_TX_DATA + op), &dat); - xfr->offset = (xfr->count - dat.count); - - if (xfr->offset >= xfr->count) { - if (!op) { - pUART->pREGS->INTENCLR = UART_INT_TXRDY; - } - else { - pUART->pREGS->INTENCLR = UART_INT_RXRDY; - } - - _UART_InvokeCB(pUART, (UART_EVENT_T) (UART_TX_DONE + op), xfr); - if (xfr->state == UART_ST_BUSY) { - xfr->state = UART_ST_DONE; - } - return 1; - } - return 0; + UART_DATA_T dat; + UART_DATA_T *xfr = &pUART->xfer[op]; + + /* See if the transfer is already complete */ + if (xfr->offset >= xfr->count) + { + return 2; + } + + /* Fill the buffer data structure */ + dat.count = xfr->count - xfr->offset; + dat.dwidth = ((pUART->pREGS->CFG >> 2) & 3) > 1; + if (dat.dwidth) + { + dat.buf = &((uint16_t *) xfr->buf)[xfr->offset]; + } + else { + dat.buf = &((uint8_t *) xfr->buf)[xfr->offset]; + } + + if (!xfr->offset && xfr->count) + { + _UART_InvokeCB(pUART, UART_TX_START, xfr); + } + + pUART->cbTable[UART_CB_DATA]((UART_HANDLE_T) pUART, (UART_EVENT_T) (UART_TX_DATA + op), &dat); + xfr->offset = (xfr->count - dat.count); + + if (xfr->offset >= xfr->count) + { + if (!op) + { + pUART->pREGS->INTENCLR = UART_INT_TXRDY; + } + else { + pUART->pREGS->INTENCLR = UART_INT_RXRDY; + } + + _UART_InvokeCB(pUART, (UART_EVENT_T) (UART_TX_DONE + op), xfr); + if (xfr->state == UART_ST_BUSY) + { + xfr->state = UART_ST_DONE; + } + return 1; + } + return 0; } /* STOP Receive under progress */ static void _UART_StopRx(UART_HANDLE_T hUART) { - UART_DRIVER_T *pUART = (UART_DRIVER_T *) hUART; - UART_DATA_T *rx = &pUART->xfer[1]; - volatile uint16_t *idx = (volatile uint16_t *) &rx->offset; - - if (*idx >= rx->count) { - return; - } - - /* Disable further receive interrupts */ - pUART->pREGS->INTENCLR = UART_INT_RXRDY; - rx->count = *idx; - _UART_InvokeCB(pUART, UART_RX_DONE, rx); + UART_DRIVER_T *pUART = (UART_DRIVER_T *) hUART; + UART_DATA_T *rx = &pUART->xfer[1]; + volatile uint16_t *idx = (volatile uint16_t *) &rx->offset; + + if (*idx >= rx->count) + { + return; + } + + /* Disable further receive interrupts */ + pUART->pREGS->INTENCLR = UART_INT_RXRDY; + rx->count = *idx; + _UART_InvokeCB(pUART, UART_RX_DONE, rx); } /* EXPROTED API: Returns memory required for UART ROM driver */ uint32_t UART_GetMemSize(void) { - return sizeof(UART_DRIVER_T); + return sizeof(UART_DRIVER_T); } /* EXPORTED API: Calculate UART Baudrate divisors */ ErrorCode_t UART_CalculateBaud(UART_BAUD_T *ub) { - if (!ub->mul) { - _UART_CalcMul(ub); - } + if (!ub->mul) + { + _UART_CalcMul(ub); + } - return _UART_CalcDiv(ub); + return _UART_CalcDiv(ub); } /* EXPORTED API: UART Initialization function */ UART_HANDLE_T UART_Init(void *mem, uint32_t base_addr, void *args) { - UART_DRIVER_T *pUART; + UART_DRIVER_T *pUART; - /* Check if the memory is word aligned */ - if ((uint32_t) mem & 0x3) { - return NULL; - } + /* Check if the memory is word aligned */ + if ((uint32_t) mem & 0x3) + { + return NULL; + } - /* Assign memory provided by application */ - pUART = (UART_DRIVER_T *) mem; - memset(pUART, 0, sizeof(UART_DRIVER_T)); + /* Assign memory provided by application */ + pUART = (UART_DRIVER_T *) mem; + memset(pUART, 0, sizeof(UART_DRIVER_T)); - /* Assign the base address */ - pUART->pREGS = (UART_REGS_T *) base_addr; - pUART->pUserData = args; + /* Assign the base address */ + pUART->pREGS = (UART_REGS_T *) base_addr; + pUART->pUserData = args; - /* Set default handler for TX and RX */ - pUART->cbTable[UART_CB_DATA] = _UART_HandleTxRx; - return (UART_HANDLE_T) pUART; + /* Set default handler for TX and RX */ + pUART->cbTable[UART_CB_DATA] = _UART_HandleTxRx; + return (UART_HANDLE_T) pUART; } /* EXPORTED API: Configure UART parameters */ ErrorCode_t UART_Configure(UART_HANDLE_T hUART, const UART_CFG_T *cfg) { - UART_DRIVER_T *pUART = (UART_DRIVER_T *) hUART; - UART_REGS_T *pREGS = pUART->pREGS; - - if (((cfg->cfg & UART_PAR_MASK) == (1 << 4)) || - ( (cfg->cfg & UART_DATA_MASK) == (3 << 2)) ) { - return ERR_UART_PARAM; - } - - /* Enable parity error when parity is enabled */ - if ((cfg->cfg & UART_PAR_MASK) >> 4) { - pREGS->INTENSET = UART_INT_PARERR; - } - - if (((int32_t) cfg->div <= 0) || ((int32_t) cfg->ovr <= 0)) { - return ERR_UART_PARAM; - } - - pREGS->OSR = (cfg->ovr - 1) & 0x0F; - pREGS->BRG = (cfg->div - 1) & 0xFFFF; - pREGS->CFG = UART_CFG_ENABLE | (cfg->cfg & ~UART_CFG_RES); - - /* Enabled RX of BREAK event */ - if (cfg->cfg & UART_CFG_BRKRX) { - pREGS->INTENSET = UART_INT_BREAK; - } - - /* Enable CTS interrupt if requested */ - if (cfg->cfg & UART_CFG_CTSEV) { - pREGS->INTENSET = UART_INT_CTS; - } + UART_DRIVER_T *pUART = (UART_DRIVER_T *) hUART; + UART_REGS_T *pREGS = pUART->pREGS; + + if (((cfg->cfg & UART_PAR_MASK) == (1 << 4)) || + ( (cfg->cfg & UART_DATA_MASK) == (3 << 2)) ) + { + return ERR_UART_PARAM; + } + + /* Enable parity error when parity is enabled */ + if ((cfg->cfg & UART_PAR_MASK) >> 4) + { + pREGS->INTENSET = UART_INT_PARERR; + } + + if (((int32_t) cfg->div <= 0) || ((int32_t) cfg->ovr <= 0)) + { + return ERR_UART_PARAM; + } + + pREGS->OSR = (cfg->ovr - 1) & 0x0F; + pREGS->BRG = (cfg->div - 1) & 0xFFFF; + pREGS->CFG = UART_CFG_ENABLE | (cfg->cfg & ~UART_CFG_RES); + + /* Enabled RX of BREAK event */ + if (cfg->cfg & UART_CFG_BRKRX) + { + pREGS->INTENSET = UART_INT_BREAK; + } + + /* Enable CTS interrupt if requested */ + if (cfg->cfg & UART_CFG_CTSEV) + { + pREGS->INTENSET = UART_INT_CTS; + } #ifdef UART_IDLE_FIX - /* REMOVE: if/else block after H/W idle is fixed */ - if (cfg->res > 224) { - pUART->dly = 3072 * (cfg->res - 224); - } - else { - pUART->dly = cfg->res << 2; - } + /* REMOVE: if/else block after H/W idle is fixed */ + if (cfg->res > 224) + { + pUART->dly = 3072 * (cfg->res - 224); + } + else { + pUART->dly = cfg->res << 2; + } #endif - return LPC_OK; + return LPC_OK; } /* EXPORTED API: UART setup special operation like BREAK etc. */ void UART_SetControl(UART_HANDLE_T hUART, uint32_t cfg) { - uint32_t en, dis; - UART_REGS_T *pREGS = ((UART_DRIVER_T *) hUART)->pREGS; - - /* Get list of enabled and disabled options */ - en = ((cfg >> 16) & (cfg & 0xFFFF)) << 1; - dis = ((cfg >> 16) & ~(cfg & 0xFFFF)) << 1; - - /* See if it is RX Stop request */ - if (cfg & UART_RX_STOP) { - _UART_StopRx(hUART); - } - - /* See if any IDLEs are enabled */ - if (cfg & (UART_IDLE_MASK << 16)) { - pREGS->INTENSET = (en >> 1) & UART_IDLE_MASK; - pREGS->INTENCLR = (dis >> 1) & UART_IDLE_MASK; - } - - /* See if it is a request BREAK after TX */ - if (en & UART_CTL_TXDIS) { - if (en & UART_CTL_TXBRKEN) { - pREGS->CTL = (pREGS->CTL & ~UART_CTL_RES) | UART_CTL_TXDIS; - while (!(pREGS->STAT & UART_INT_TXDIS)) {} + uint32_t en, dis; + UART_REGS_T *pREGS = ((UART_DRIVER_T *) hUART)->pREGS; + + /* Get list of enabled and disabled options */ + en = ((cfg >> 16) & (cfg & 0xFFFF)) << 1; + dis = ((cfg >> 16) & ~(cfg & 0xFFFF)) << 1; + + /* See if it is RX Stop request */ + if (cfg & UART_RX_STOP) + { + _UART_StopRx(hUART); + } + + /* See if any IDLEs are enabled */ + if (cfg & (UART_IDLE_MASK << 16)) + { + pREGS->INTENSET = (en >> 1) & UART_IDLE_MASK; + pREGS->INTENCLR = (dis >> 1) & UART_IDLE_MASK; + } + + /* See if it is a request BREAK after TX */ + if (en & UART_CTL_TXDIS) + { + if (en & UART_CTL_TXBRKEN) + { + pREGS->CTL = (pREGS->CTL & ~UART_CTL_RES) | UART_CTL_TXDIS; + while (!(pREGS->STAT & UART_INT_TXDIS)) + {} #ifdef UART_IDLE_FIX - if (1) { - volatile uint32_t dly = ((UART_DRIVER_T *) hUART)->dly; - while (dly--) {}/* Provide some idling time H/W does not do this */ - } + if (1) + { + volatile uint32_t dly = ((UART_DRIVER_T *) hUART)->dly; + while (dly--) + {}/* Provide some idling time H/W does not do this */ + } #endif - } - else { - pREGS->INTENSET = UART_INT_TXDIS; - } - } - - /* See if we are releasing break and resume TX operation */ - if ((dis & UART_CTL_TXDIS) && (dis & UART_CTL_TXBRKEN)) { - pREGS->CTL = pREGS->CTL & ~(UART_CTL_RES | UART_CTL_TXBRKEN); + } + else { + pREGS->INTENSET = UART_INT_TXDIS; + } + } + + /* See if we are releasing break and resume TX operation */ + if ((dis & UART_CTL_TXDIS) && (dis & UART_CTL_TXBRKEN)) + { + pREGS->CTL = pREGS->CTL & ~(UART_CTL_RES | UART_CTL_TXBRKEN); #ifdef UART_IDLE_FIX - if (1) { - volatile uint32_t dly = ((UART_DRIVER_T *) hUART)->dly; - while (dly--) {} /* Provide some idling time H/W does not do this */ - } + if (1) + { + volatile uint32_t dly = ((UART_DRIVER_T *) hUART)->dly; + while (dly--) + {} /* Provide some idling time H/W does not do this */ + } #endif - } + } - /* Check for autobaud and enable autobaud err interrupt */ - if (en & UART_CTL_AUTOBAUD) { - pREGS->INTENSET = UART_INT_ABAUDERR; - } + /* Check for autobaud and enable autobaud err interrupt */ + if (en & UART_CTL_AUTOBAUD) + { + pREGS->INTENSET = UART_INT_ABAUDERR; + } - pREGS->CTL = ((pREGS->CTL | en) & ~dis) & ~UART_CTL_RES; + pREGS->CTL = ((pREGS->CTL | en) & ~dis) & ~UART_CTL_RES; } /* EXPORTED API: Register a call-back function */ ErrorCode_t UART_RegisterCB(UART_HANDLE_T hUART, - UART_CBINDEX_T idx, - void (*cb_func)(UART_HANDLE_T, UART_EVENT_T, void *)) + UART_CBINDEX_T idx, + void (*cb_func)(UART_HANDLE_T, UART_EVENT_T, void *)) { - if (idx < UART_CB_RESERVED) { - ((UART_DRIVER_T *) hUART)->cbTable[idx] = cb_func; - } - else { - return ERR_UART_PARAM; - } - - /* Restore internal data handlers when external ones are un-registered */ - if ((idx == UART_CB_DATA) && (cb_func == NULL)) { - ((UART_DRIVER_T *) hUART)->cbTable[idx] = _UART_HandleTxRx; - } - - return LPC_OK; + if (idx < UART_CB_RESERVED) + { + ((UART_DRIVER_T *) hUART)->cbTable[idx] = cb_func; + } + else { + return ERR_UART_PARAM; + } + + /* Restore internal data handlers when external ones are un-registered */ + if ((idx == UART_CB_DATA) && (cb_func == NULL)) + { + ((UART_DRIVER_T *) hUART)->cbTable[idx] = _UART_HandleTxRx; + } + + return LPC_OK; } /* EXPORTED API: UART Event handler */ void UART_Handler(UART_HANDLE_T hUART) { - UART_DRIVER_T *pUART = (UART_DRIVER_T *) hUART; - uint32_t flags = pUART->pREGS->INTENSET & pUART->pREGS->INTSTAT; - - if (flags & UART_INT_TXRDY) { - _UART_HandleXfer(pUART, 0); - } - - if (flags & UART_INT_FRMERR) { - pUART->pREGS->STAT = UART_INT_FRMERR; - if (pUART->xfer[1].state == UART_ST_BUSY) { - pUART->xfer[1].state = UART_ST_ERRFRM; - } - _UART_InvokeCB(pUART, UART_EV_ERROR, (void *) UART_ERROR_FRAME); - } - - if (flags & UART_INT_PARERR) { - pUART->pREGS->STAT = UART_INT_PARERR; - if (pUART->xfer[1].state == UART_ST_BUSY) { - pUART->xfer[1].state = UART_ST_ERRPAR; - } - _UART_InvokeCB(pUART, UART_EV_ERROR, (void *) UART_ERROR_PARITY); - } - - if (flags & UART_INT_ABAUDERR) { - pUART->pREGS->STAT = UART_INT_ABAUDERR; - if (pUART->xfer[1].state == UART_ST_BUSY) { - pUART->xfer[1].state = UART_ST_ERR; - } - _UART_InvokeCB(pUART, UART_EV_ERROR, (void *) UART_ERROR_AUTOBAUD); - } - - if (flags & UART_INT_RXNOISE) { - pUART->pREGS->STAT = UART_INT_RXNOISE; - if (pUART->xfer[1].state == UART_ST_BUSY) { - pUART->xfer[1].state = UART_ST_ERRNOISE; - } - _UART_InvokeCB(pUART, UART_EV_ERROR, (void *) UART_ERROR_RXNOISE); - } - - if (flags & UART_INT_OVR) { - pUART->pREGS->STAT = UART_INT_OVR; - if (pUART->xfer[1].state == UART_ST_BUSY) { - pUART->xfer[1].state = UART_ST_ERROVR; - } - _UART_InvokeCB(pUART, UART_EV_ERROR, (void *) UART_ERROR_OVERRUN); - } - - if (flags & UART_INT_RXRDY) { - _UART_HandleXfer(pUART, 1); + UART_DRIVER_T *pUART = (UART_DRIVER_T *) hUART; + uint32_t flags = pUART->pREGS->INTENSET & pUART->pREGS->INTSTAT; + + if (flags & UART_INT_TXRDY) + { + _UART_HandleXfer(pUART, 0); + } + + if (flags & UART_INT_FRMERR) + { + pUART->pREGS->STAT = UART_INT_FRMERR; + if (pUART->xfer[1].state == UART_ST_BUSY) + { + pUART->xfer[1].state = UART_ST_ERRFRM; + } + _UART_InvokeCB(pUART, UART_EV_ERROR, (void *) UART_ERROR_FRAME); + } + + if (flags & UART_INT_PARERR) + { + pUART->pREGS->STAT = UART_INT_PARERR; + if (pUART->xfer[1].state == UART_ST_BUSY) + { + pUART->xfer[1].state = UART_ST_ERRPAR; + } + _UART_InvokeCB(pUART, UART_EV_ERROR, (void *) UART_ERROR_PARITY); + } + + if (flags & UART_INT_ABAUDERR) + { + pUART->pREGS->STAT = UART_INT_ABAUDERR; + if (pUART->xfer[1].state == UART_ST_BUSY) + { + pUART->xfer[1].state = UART_ST_ERR; + } + _UART_InvokeCB(pUART, UART_EV_ERROR, (void *) UART_ERROR_AUTOBAUD); + } + + if (flags & UART_INT_RXNOISE) + { + pUART->pREGS->STAT = UART_INT_RXNOISE; + if (pUART->xfer[1].state == UART_ST_BUSY) + { + pUART->xfer[1].state = UART_ST_ERRNOISE; + } + _UART_InvokeCB(pUART, UART_EV_ERROR, (void *) UART_ERROR_RXNOISE); + } + + if (flags & UART_INT_OVR) + { + pUART->pREGS->STAT = UART_INT_OVR; + if (pUART->xfer[1].state == UART_ST_BUSY) + { + pUART->xfer[1].state = UART_ST_ERROVR; + } + _UART_InvokeCB(pUART, UART_EV_ERROR, (void *) UART_ERROR_OVERRUN); + } + + if (flags & UART_INT_RXRDY) + { + _UART_HandleXfer(pUART, 1); #ifdef UART_IDLE_FIX - if (1) { - volatile uint32_t dly = ((UART_DRIVER_T *) hUART)->dly; - while ((pUART->pREGS->STAT & UART_STAT_RXIDLE) && dly--) {} - } + if (1) + { + volatile uint32_t dly = ((UART_DRIVER_T *) hUART)->dly; + while ((pUART->pREGS->STAT & UART_STAT_RXIDLE) && dly--) + {} + } #else - while (pUART->pREGS->STAT & UART_STAT_RXIDLE) {} + while (pUART->pREGS->STAT & UART_STAT_RXIDLE) + {} #endif - _UART_InvokeCB(pUART, (UART_EVENT_T) (UART_RX_INPROG + ((pUART->pREGS->STAT >> 1) & 1)), &pUART->xfer[1]); - } - - if (flags & UART_INT_TXIDLE) { - _UART_InvokeCB(pUART, UART_EV_EVENT, (void *) UART_EVENT_TXIDLE); - } - - if (flags & UART_INT_TXDIS) { - pUART->pREGS->INTENCLR = UART_INT_TXDIS;/* Disable interrupt */ - _UART_InvokeCB(pUART, UART_EV_EVENT, (void *) UART_EVENT_TXPAUSED); - } - - if (flags & UART_INT_CTS) { - pUART->pREGS->STAT = UART_INT_CTS; - _UART_InvokeCB(pUART, UART_EV_EVENT, - (void *) ((pUART->pREGS->STAT & UART_STAT_CTS) ? UART_EVENT_CTSHI : UART_EVENT_CTSLO)); - } - - if (flags & UART_INT_BREAK) { - pUART->pREGS->STAT = UART_INT_BREAK | UART_INT_FRMERR; - _UART_InvokeCB(pUART, UART_EV_EVENT, - (void *) ((pUART->pREGS->STAT & UART_STAT_BREAK) ? UART_EVENT_BREAK : UART_EVENT_NOBREAK)); - } - - if (flags & UART_INT_START) { - pUART->pREGS->STAT = UART_INT_START; - _UART_InvokeCB(pUART, UART_RX_START, &pUART->xfer[1]); - } + _UART_InvokeCB(pUART, (UART_EVENT_T) (UART_RX_INPROG + ((pUART->pREGS->STAT >> 1) & 1)), &pUART->xfer[1]); + } + + if (flags & UART_INT_TXIDLE) + { + _UART_InvokeCB(pUART, UART_EV_EVENT, (void *) UART_EVENT_TXIDLE); + } + + if (flags & UART_INT_TXDIS) + { + pUART->pREGS->INTENCLR = UART_INT_TXDIS;/* Disable interrupt */ + _UART_InvokeCB(pUART, UART_EV_EVENT, (void *) UART_EVENT_TXPAUSED); + } + + if (flags & UART_INT_CTS) + { + pUART->pREGS->STAT = UART_INT_CTS; + _UART_InvokeCB(pUART, UART_EV_EVENT, + (void *) ((pUART->pREGS->STAT & UART_STAT_CTS) ? UART_EVENT_CTSHI : UART_EVENT_CTSLO)); + } + + if (flags & UART_INT_BREAK) + { + pUART->pREGS->STAT = UART_INT_BREAK | UART_INT_FRMERR; + _UART_InvokeCB(pUART, UART_EV_EVENT, + (void *) ((pUART->pREGS->STAT & UART_STAT_BREAK) ? UART_EVENT_BREAK : UART_EVENT_NOBREAK)); + } + + if (flags & UART_INT_START) + { + pUART->pREGS->STAT = UART_INT_START; + _UART_InvokeCB(pUART, UART_RX_START, &pUART->xfer[1]); + } } /* EXPORTED API: UART Transmit API */ ErrorCode_t UART_Tx(UART_HANDLE_T hUART, const void *buff, uint16_t len) { - return _UART_Xfer((UART_DRIVER_T *) hUART, (void *) buff, len, 0); + return _UART_Xfer((UART_DRIVER_T *) hUART, (void *) buff, len, 0); } /* EXPORTED API: UART Receive API */ ErrorCode_t UART_Rx(UART_HANDLE_T hUART, void *buff, uint16_t len) { - return _UART_Xfer((UART_DRIVER_T *) hUART, buff, len, 1); + return _UART_Xfer((UART_DRIVER_T *) hUART, buff, len, 1); } /* EXPORTED API: Flush the TX buffer */ void UART_WaitTX(UART_HANDLE_T hUART) { - while (!_UART_HandleXfer(hUART, 0)) {} + while (!_UART_HandleXfer(hUART, 0)) + {} } /* EXPORTED API: Fetch the data from UART into RX buffer */ void UART_WaitRX(UART_HANDLE_T hUART) { - UART_REGS_T *pREGS = ((UART_DRIVER_T *) hUART)->pREGS; - /* See if the data needs to be discarded */ - if (_UART_HandleXfer(hUART, 1) == 2) { - volatile uint32_t dummy; - while ((pREGS->STAT & UART_INT_RXRDY) || !(pREGS->STAT & UART_STAT_RXIDLE)) { - dummy = pREGS->RXDAT; - } - } - while (!_UART_HandleXfer(hUART, 1)) {} + UART_REGS_T *pREGS = ((UART_DRIVER_T *) hUART)->pREGS; + /* See if the data needs to be discarded */ + if (_UART_HandleXfer(hUART, 1) == 2) + { + volatile uint32_t dummy; + while ((pREGS->STAT & UART_INT_RXRDY) || !(pREGS->STAT & UART_STAT_RXIDLE)) + { + dummy = pREGS->RXDAT; + (void)dummy; + } + } + while (!_UART_HandleXfer(hUART, 1)) + {} } /* EXPORTED API: Function to Get the firmware Version */ uint32_t UART_GetDriverVersion(void) { - return UART_DRIVER_VERSION; + return UART_DRIVER_VERSION; } /** - * @brief Table of the addresses of all the UART ROM APIs - * @note This table of function pointers is the API interface. + * @brief Table of the addresses of all the UART ROM APIs + * @note This table of function pointers is the API interface. */ const ROM_UART_API_T uartrom_api = { - UART_GetMemSize, - UART_CalculateBaud, - UART_Init, - UART_Configure, - UART_SetControl, - UART_RegisterCB, - UART_Handler, - UART_Tx, - UART_Rx, - UART_WaitTX, - UART_WaitRX, - UART_GetDriverVersion, + UART_GetMemSize, + UART_CalculateBaud, + UART_Init, + UART_Configure, + UART_SetControl, + UART_RegisterCB, + UART_Handler, + UART_Tx, + UART_Rx, + UART_WaitTX, + UART_WaitRX, + UART_GetDriverVersion, }; diff --git a/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/pll_5410x.c b/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/pll_5410x.c index d99fd859166..242bed455f9 100644 --- a/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/pll_5410x.c +++ b/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/pll_5410x.c @@ -40,44 +40,44 @@ #define MVALMAX (0x8000) /* SYS PLL related bit fields */ -#define SYS_PLL_SELR(d) (((d) & 0xf) << 0) /*!< Bandwidth select R value */ -#define SYS_PLL_SELI(d) (((d) & 0x3f) << 4) /*!< Bandwidth select I value */ -#define SYS_PLL_SELP(d) (((d) & 0x1f) << 10) /*!< Bandwidth select P value */ -#define SYS_PLL_BYPASS (1 << 15) /*!< Enable PLL bypass */ -#define SYS_PLL_BYPASSCCODIV2 (1 << 16) /*!< Enable bypass of extra divider by 2 */ -#define SYS_PLL_UPLIMOFF (1 << 17) /*!< Enable spread spectrum/fractional mode */ -#define SYS_PLL_BANDSEL (1 << 18) /*!< Enable MDEC control */ -#define SYS_PLL_DIRECTI (1 << 19) /*!< PLL0 direct input enable */ -#define SYS_PLL_DIRECTO (1 << 20) /*!< PLL0 direct output enable */ - -// #define FRAC_BITS_SELI (8) // For retaining fractions in divisions -#define PLL_SSCG0_MDEC_VAL_P (0) // MDEC is in bits 16 downto 0 -#define PLL_SSCG0_MDEC_VAL_M (0x1FFFFUL << PLL_SSCG0_MDEC_VAL_P) // NDEC is in bits 9 downto 0 -#define PLL_NDEC_VAL_P (0) // NDEC is in bits 9:0 +#define SYS_PLL_SELR(d) (((d) & 0xf) << 0) /*!< Bandwidth select R value */ +#define SYS_PLL_SELI(d) (((d) & 0x3f) << 4) /*!< Bandwidth select I value */ +#define SYS_PLL_SELP(d) (((d) & 0x1f) << 10) /*!< Bandwidth select P value */ +#define SYS_PLL_BYPASS (1 << 15) /*!< Enable PLL bypass */ +#define SYS_PLL_BYPASSCCODIV2 (1 << 16) /*!< Enable bypass of extra divider by 2 */ +#define SYS_PLL_UPLIMOFF (1 << 17) /*!< Enable spread spectrum/fractional mode */ +#define SYS_PLL_BANDSEL (1 << 18) /*!< Enable MDEC control */ +#define SYS_PLL_DIRECTI (1 << 19) /*!< PLL0 direct input enable */ +#define SYS_PLL_DIRECTO (1 << 20) /*!< PLL0 direct output enable */ + +/* #define FRAC_BITS_SELI (8) // For retaining fractions in divisions*/ +#define PLL_SSCG0_MDEC_VAL_P (0) /* MDEC is in bits 16 downto 0*/ +#define PLL_SSCG0_MDEC_VAL_M (0x1FFFFUL << PLL_SSCG0_MDEC_VAL_P) /* NDEC is in bits 9 downto 0*/ +#define PLL_NDEC_VAL_P (0) /* NDEC is in bits 9:0*/ #define PLL_NDEC_VAL_M (0x3FFUL << PLL_NDEC_VAL_P) -#define PLL_PDEC_VAL_P (0) // PDEC is in bits 6:0 +#define PLL_PDEC_VAL_P (0) /* PDEC is in bits 6:0*/ #define PLL_PDEC_VAL_M (0x3FFUL << PLL_PDEC_VAL_P) #define PLL_MIN_CCO_FREQ_MHZ (75000000) #define PLL_MAX_CCO_FREQ_MHZ (150000000) -#define PLL_LOWER_IN_LIMIT (4000) /*!< Minimum PLL input rate */ +#define PLL_LOWER_IN_LIMIT (4000) /*!< Minimum PLL input rate */ #define PLL_MIN_IN_SSMODE (2000000) #define PLL_MAX_IN_SSMODE (4000000) -// Middle of the range values for spread-spectrum +/* Middle of the range values for spread-spectrum*/ #define PLL_SSCG_MF_FREQ_VALUE 4 #define PLL_SSCG_MC_COMP_VALUE 2 #define PLL_SSCG_MR_DEPTH_VALUE 4 #define PLL_SSCG_DITHER_VALUE 0 -// pll SYSPLLCTRL Bits +/* pll SYSPLLCTRL Bits*/ #define SYSCON_SYSPLLCTRL_SELR_P 0 #define SYSCON_SYSPLLCTRL_SELR_M (0xFUL << SYSCON_SYSPLLCTRL_SELR_P) #define SYSCON_SYSPLLCTRL_SELI_P 4 #define SYSCON_SYSPLLCTRL_SELI_M (0x3FUL << SYSCON_SYSPLLCTRL_SELI_P) #define SYSCON_SYSPLLCTRL_SELP_P 10 #define SYSCON_SYSPLLCTRL_SELP_M (0x1FUL << SYSCON_SYSPLLCTRL_SELP_P) -#define SYSCON_SYSPLLCTRL_BYPASS_P 15 // sys_pll150_ctrl +#define SYSCON_SYSPLLCTRL_BYPASS_P 15 /* sys_pll150_ctrl*/ #define SYSCON_SYSPLLCTRL_BYPASS (1UL << SYSCON_SYSPLLCTRL_BYPASS_P) #define SYSCON_SYSPLLCTRL_BYPASS_FBDIV2_P 16 #define SYSCON_SYSPLLCTRL_BYPASS_FBDIV2 (1UL << SYSCON_SYSPLLCTRL_BYPASS_FBDIV2_P) @@ -93,7 +93,7 @@ #define SYSCON_SYSPLLSTAT_LOCK_P 0 #define SYSCON_SYSPLLSTAT_LOCK (1UL << SYSCON_SYSPLLSTAT_LOCK_P) -#define PLL_CTRL_BYPASS_P 15 // sys_pll150_ctrl +#define PLL_CTRL_BYPASS_P 15 /* sys_pll150_ctrl*/ #define PLL_CTRL_BYPASS_FBDIV2_P 16 #define PLL_CTRL_UPLIMOFF_P 17 #define PLL_CTRL_BANDSEL_SSCGREG_N_P 18 @@ -107,14 +107,14 @@ #define PLL_CTRL_BANDSEL_SSCGREG_N (1 << PLL_CTRL_BANDSEL_SSCGREG_N_P) #define PLL_CTRL_BYPASS_FBDIV2 (1 << PLL_CTRL_BYPASS_FBDIV2_P) -// SSCG control[0] -// #define PLL_SSCG0_MDEC_VAL_P 0 // MDEC is in bits 16 downto 0 +/* SSCG control[0]*/ +/* #define PLL_SSCG0_MDEC_VAL_P 0 // MDEC is in bits 16 downto 0*/ #define PLL_SSCG0_MREQ_P 17 #define PLL_SSCG0_SEL_EXT_SSCG_N_P 18 #define PLL_SSCG0_SEL_EXT_SSCG_N (1 << PLL_SSCG0_SEL_EXT_SSCG_N_P) #define PLL_SSCG0_MREQ (1 << PLL_SSCG0_MREQ_P) -// SSCG control[1] +/* SSCG control[1]*/ #define PLL_SSCG1_MD_REQ_P 19 #define PLL_SSCG1_MOD_PD_SSCGCLK_N_P 28 #define PLL_SSCG1_DITHER_P 29 @@ -122,24 +122,24 @@ #define PLL_SSCG1_DITHER (1 << PLL_SSCG1_DITHER_P) #define PLL_SSCG1_MD_REQ (1 << PLL_SSCG1_MD_REQ_P) -// PLL NDEC reg +/* PLL NDEC reg*/ #define PLL_NDEC_VAL_SET(value) (((unsigned long) (value) << PLL_NDEC_VAL_P) & PLL_NDEC_VAL_M) #define PLL_NDEC_NREQ_P 10 #define PLL_NDEC_NREQ (1 << PLL_NDEC_NREQ_P) -// PLL PDEC reg +/* PLL PDEC reg*/ #define PLL_PDEC_VAL_SET(value) (((unsigned long) (value) << PLL_PDEC_VAL_P) & PLL_PDEC_VAL_M) #define PLL_PDEC_PREQ_P 7 #define PLL_PDEC_PREQ (1 << PLL_PDEC_PREQ_P) -// SSCG control[0] +/* SSCG control[0]*/ #define PLL_SSCG0_MDEC_VAL_SET(value) (((unsigned long) (value) << PLL_SSCG0_MDEC_VAL_P) & PLL_SSCG0_MDEC_VAL_M) #define PLL_SSCG0_MREQ_P 17 #define PLL_SSCG0_MREQ (1 << PLL_SSCG0_MREQ_P) #define PLL_SSCG0_SEL_EXT_SSCG_N_P 18 #define PLL_SSCG0_SEL_EXT_SSCG_N (1 << PLL_SSCG0_SEL_EXT_SSCG_N_P) -// SSCG control[1] +/* SSCG control[1]*/ #define PLL_SSCG1_MD_FRACT_P 0 #define PLL_SSCG1_MD_INT_P 11 #define PLL_SSCG1_MF_P 20 @@ -153,17 +153,20 @@ #define PLL_SSCG1_MR_M (0x7UL << PLL_SSCG1_MR_P) #define PLL_SSCG1_MD_FRACT_SET(value) (((unsigned long) (value) << \ - PLL_SSCG1_MD_FRACT_P) & PLL_SSCG1_MD_FRACT_M) + PLL_SSCG1_MD_FRACT_P) & PLL_SSCG1_MD_FRACT_M) #define PLL_SSCG1_MD_INT_SET(value) (((unsigned long) (value) << \ - PLL_SSCG1_MD_INT_P) & PLL_SSCG1_MD_INT_M) -// #define PLL_SSCG1_MF_SET(value) (((unsigned long) (value) << \ -// // PLL_SSCG1_MF_P) & PLL_SSCG1_MF_M) -// #define PLL_SSCG1_MC_SET(value) (((unsigned long) (value) << \ -// // PLL_SSCG1_MC_P) & PLL_SSCG1_MC_M) -// #define PLL_SSCG1_MR_SET(value) (((unsigned long) (value) << \ -// // PLL_SSCG1_MR_P) & PLL_SSCG1_MR_M) - -// Middle of the range values for spread-spectrum + PLL_SSCG1_MD_INT_P) & PLL_SSCG1_MD_INT_M) +/* +#define PLL_SSCG1_MF_SET(value) (((unsigned long) (value) << \ + PLL_SSCG1_MF_P) & PLL_SSCG1_MF_M) +#define PLL_SSCG1_MC_SET(value) (((unsigned long) (value) << \ + PLL_SSCG1_MC_P) & PLL_SSCG1_MC_M) +#define PLL_SSCG1_MR_SET(value) (((unsigned long) (value) << \ + PLL_SSCG1_MR_P) & PLL_SSCG1_MR_M) +*/ + +/* Middle of the range values for spread-spectrum*/ + #define PLL0_SSCG_MF_FREQ_VALUE 4 #define PLL0_SSCG_MC_COMP_VALUE 2 #define PLL0_SSCG_MR_DEPTH_VALUE 4 @@ -186,469 +189,514 @@ static uint32_t curPllRate; /* Find encoded NDEC value for raw N value, max N = NVALMAX */ static uint32_t pllEncodeN(uint32_t N) { - uint32_t x, i; - - /* Find NDec */ - switch (N) { - case 0: - x = 0xFFF; - break; - - case 1: - x = 0x302; - break; - - case 2: - x = 0x202; - break; - - default: - x = 0x080; - for (i = N; i <= NVALMAX; i++) { - x = (((x ^ (x >> 2) ^ (x >> 3) ^ (x >> 4)) & 1) << 7) | ((x >> 1) & 0x7F); - } - break; - } - - return x & (PLL_NDEC_VAL_M >> PLL_NDEC_VAL_P); + uint32_t x, i; + + /* Find NDec */ + switch (N) + { + case 0: + x = 0xFFF; + break; + + case 1: + x = 0x302; + break; + + case 2: + x = 0x202; + break; + + default: + x = 0x080; + for (i = N; i <= NVALMAX; i++) + { + x = (((x ^ (x >> 2) ^ (x >> 3) ^ (x >> 4)) & 1) << 7) | ((x >> 1) & 0x7F); + } + break; + } + + return x & (PLL_NDEC_VAL_M >> PLL_NDEC_VAL_P); } /* Find decoded N value for raw NDEC value */ static uint32_t pllDecodeN(uint32_t NDEC) { - uint32_t n, x, i; - - /* Find NDec */ - switch (NDEC) { - case 0xFFF: - n = 0; - break; - - case 0x302: - n = 1; - break; - - case 0x202: - n = 2; - break; - - default: - x = 0x080; - n = 0xFFFFFFFF; - for (i = NVALMAX; ((i >= 3) && (n == 0xFFFFFFFF)); i--) { - x = (((x ^ (x >> 2) ^ (x >> 3) ^ (x >> 4)) & 1) << 7) | ((x >> 1) & 0x7F); - if ((x & (PLL_NDEC_VAL_M >> PLL_NDEC_VAL_P)) == NDEC) { - /* Decoded value of NDEC */ - n = i; - } - } - break; - } - - return n; + uint32_t n, x, i; + + /* Find NDec */ + switch (NDEC) + { + case 0xFFF: + n = 0; + break; + + case 0x302: + n = 1; + break; + + case 0x202: + n = 2; + break; + + default: + x = 0x080; + n = 0xFFFFFFFF; + for (i = NVALMAX; ((i >= 3) && (n == 0xFFFFFFFF)); i--) + { + x = (((x ^ (x >> 2) ^ (x >> 3) ^ (x >> 4)) & 1) << 7) | ((x >> 1) & 0x7F); + if ((x & (PLL_NDEC_VAL_M >> PLL_NDEC_VAL_P)) == NDEC) + { + /* Decoded value of NDEC */ + n = i; + } + } + break; + } + + return n; } /* Find encoded PDEC value for raw P value, max P = PVALMAX */ static uint32_t pllEncodeP(uint32_t P) { - uint32_t x, i; - - /* Find PDec */ - switch (P) { - case 0: - x = 0xFF; - break; - - case 1: - x = 0x62; - break; - - case 2: - x = 0x42; - break; - - default: - x = 0x10; - for (i = P; i <= PVALMAX; i++) { - x = (((x ^ (x >> 2)) & 1) << 4) | ((x >> 1) & 0xF); - } - break; - } - - return x & (PLL_PDEC_VAL_M >> PLL_PDEC_VAL_P); + uint32_t x, i; + + /* Find PDec */ + switch (P) + { + case 0: + x = 0xFF; + break; + + case 1: + x = 0x62; + break; + + case 2: + x = 0x42; + break; + + default: + x = 0x10; + for (i = P; i <= PVALMAX; i++) + { + x = (((x ^ (x >> 2)) & 1) << 4) | ((x >> 1) & 0xF); + } + break; + } + + return x & (PLL_PDEC_VAL_M >> PLL_PDEC_VAL_P); } /* Find decoded P value for raw PDEC value */ static uint32_t pllDecodeP(uint32_t PDEC) { - uint32_t p, x, i; - - /* Find PDec */ - switch (PDEC) { - case 0xFF: - p = 0; - break; - - case 0x62: - p = 1; - break; - - case 0x42: - p = 2; - break; - - default: - x = 0x10; - p = 0xFFFFFFFF; - for (i = PVALMAX; ((i >= 3) && (p == 0xFFFFFFFF)); i--) { - x = (((x ^ (x >> 2)) & 1) << 4) | ((x >> 1) & 0xF); - if ((x & (PLL_PDEC_VAL_M >> PLL_PDEC_VAL_P)) == PDEC) { - /* Decoded value of PDEC */ - p = i; - } - } - break; - } - - return p; + uint32_t p, x, i; + + /* Find PDec */ + switch (PDEC) + { + case 0xFF: + p = 0; + break; + + case 0x62: + p = 1; + break; + + case 0x42: + p = 2; + break; + + default: + x = 0x10; + p = 0xFFFFFFFF; + for (i = PVALMAX; ((i >= 3) && (p == 0xFFFFFFFF)); i--) + { + x = (((x ^ (x >> 2)) & 1) << 4) | ((x >> 1) & 0xF); + if ((x & (PLL_PDEC_VAL_M >> PLL_PDEC_VAL_P)) == PDEC) + { + /* Decoded value of PDEC */ + p = i; + } + } + break; + } + + return p; } /* Find encoded MDEC value for raw M value, max M = MVALMAX */ static uint32_t pllEncodeM(uint32_t M) { - uint32_t i, x; - - /* Find MDec */ - switch (M) { - case 0: - x = 0xFFFFF; - break; - - case 1: - x = 0x18003; - break; - - case 2: - x = 0x10003; - break; - - default: - x = 0x04000; - for (i = M; i <= MVALMAX; i++) { - x = (((x ^ (x >> 1)) & 1) << 14) | ((x >> 1) & 0x3FFF); - } - break; - } - - return x & (PLL_SSCG0_MDEC_VAL_M >> PLL_SSCG0_MDEC_VAL_P); + uint32_t i, x; + + /* Find MDec */ + switch (M) + { + case 0: + x = 0xFFFFF; + break; + + case 1: + x = 0x18003; + break; + + case 2: + x = 0x10003; + break; + + default: + x = 0x04000; + for (i = M; i <= MVALMAX; i++) + { + x = (((x ^ (x >> 1)) & 1) << 14) | ((x >> 1) & 0x3FFF); + } + break; + } + + return x & (PLL_SSCG0_MDEC_VAL_M >> PLL_SSCG0_MDEC_VAL_P); } /* Find decoded M value for raw MDEC value */ static uint32_t pllDecodeM(uint32_t MDEC) { - uint32_t m, i, x; - - /* Find MDec */ - switch (MDEC) { - case 0xFFFFF: - m = 0; - break; - - case 0x18003: - m = 1; - break; - - case 0x10003: - m = 2; - break; - - default: - x = 0x04000; - m = 0xFFFFFFFF; - for (i = MVALMAX; ((i >= 3) && (m == 0xFFFFFFFF)); i--) { - x = (((x ^ (x >> 1)) & 1) << 14) | ((x >> 1) & 0x3FFF); - if ((x & (PLL_SSCG0_MDEC_VAL_M >> PLL_SSCG0_MDEC_VAL_P)) == MDEC) { - /* Decoded value of MDEC */ - m = i; - } - } - break; - } - - return m; + uint32_t m, i, x; + + /* Find MDec */ + switch (MDEC) + { + case 0xFFFFF: + m = 0; + break; + + case 0x18003: + m = 1; + break; + + case 0x10003: + m = 2; + break; + + default: + x = 0x04000; + m = 0xFFFFFFFF; + for (i = MVALMAX; ((i >= 3) && (m == 0xFFFFFFFF)); i--) + { + x = (((x ^ (x >> 1)) & 1) << 14) | ((x >> 1) & 0x3FFF); + if ((x & (PLL_SSCG0_MDEC_VAL_M >> PLL_SSCG0_MDEC_VAL_P)) == MDEC) + { + /* Decoded value of MDEC */ + m = i; + } + } + break; + } + + return m; } /* Find SELP, SELI, and SELR values for raw M value, max M = MVALMAX */ static void pllFindSel(uint32_t M, bool bypassFBDIV2, uint32_t *pSelP, uint32_t *pSelI, uint32_t *pSelR) { - /* Bypass divider? */ - if (bypassFBDIV2) { - M = M / 2; - } - - /* bandwidth: compute selP from Multiplier */ - if (M < 60) { - *pSelP = (M >> 1) + 1; - } - else { - *pSelP = PVALMAX - 1; - } - - /* bandwidth: compute selI from Multiplier */ - if (M > 16384) { - *pSelI = 1; - } - else if (M > 8192) { - *pSelI = 2; - } - else if (M > 2048) { - *pSelI = 4; - } - else if (M >= 501) { - *pSelI = 8; - } - else if (M >= 60) { - *pSelI = 4 * (1024 / (M + 9)); - } - else { - *pSelI = (M & 0x3C) + 4; - } - - if (*pSelI > (SYSCON_SYSPLLCTRL_SELI_M >> SYSCON_SYSPLLCTRL_SELI_P)) { - *pSelI = (SYSCON_SYSPLLCTRL_SELI_M >> SYSCON_SYSPLLCTRL_SELI_P); - } - - *pSelR = 0; + /* Bypass divider? */ + if (bypassFBDIV2) + { + M = M / 2; + } + + /* bandwidth: compute selP from Multiplier */ + if (M < 60) + { + *pSelP = (M >> 1) + 1; + } + else { + *pSelP = PVALMAX - 1; + } + + /* bandwidth: compute selI from Multiplier */ + if (M > 16384) + { + *pSelI = 1; + } + else if (M > 8192) + { + *pSelI = 2; + } + else if (M > 2048) + { + *pSelI = 4; + } + else if (M >= 501) + { + *pSelI = 8; + } + else if (M >= 60) + { + *pSelI = 4 * (1024 / (M + 9)); + } + else { + *pSelI = (M & 0x3C) + 4; + } + + if (*pSelI > (SYSCON_SYSPLLCTRL_SELI_M >> SYSCON_SYSPLLCTRL_SELI_P)) + { + *pSelI = (SYSCON_SYSPLLCTRL_SELI_M >> SYSCON_SYSPLLCTRL_SELI_P); + } + + *pSelR = 0; } /* Get predivider (N) from PLL NDEC setting */ uint32_t findPllPreDiv(uint32_t ctrlReg, uint32_t nDecReg) { - uint32_t preDiv = 1; - - /* Direct input is not used? */ - if ((ctrlReg & SYSCON_SYSPLLCTRL_DIRECTI) == 0) { - /* Decode NDEC value to get (N) pre divider */ - preDiv = pllDecodeN(nDecReg & 0x3FF); - if (preDiv == 0) { - preDiv = 1; - } - } - - /* Adjusted by 1, directi is used to bypass */ - return preDiv; + uint32_t preDiv = 1; + + /* Direct input is not used? */ + if ((ctrlReg & SYSCON_SYSPLLCTRL_DIRECTI) == 0) + { + /* Decode NDEC value to get (N) pre divider */ + preDiv = pllDecodeN(nDecReg & 0x3FF); + if (preDiv == 0) + { + preDiv = 1; + } + } + + /* Adjusted by 1, directi is used to bypass */ + return preDiv; } /* Get postdivider (P) from PLL PDEC setting */ uint32_t findPllPostDiv(uint32_t ctrlReg, uint32_t pDecReg) { - uint32_t postDiv = 1; - - /* Direct input is not used? */ - if ((ctrlReg & SYS_PLL_DIRECTO) == 0) { - /* Decode PDEC value to get (P) post divider */ - postDiv = 2 * pllDecodeP(pDecReg & 0x7F); - if (postDiv == 0) { - postDiv = 2; - } - } - - /* Adjusted by 1, directo is used to bypass */ - return postDiv; + uint32_t postDiv = 1; + + /* Direct input is not used? */ + if ((ctrlReg & SYS_PLL_DIRECTO) == 0) + { + /* Decode PDEC value to get (P) post divider */ + postDiv = 2 * pllDecodeP(pDecReg & 0x7F); + if (postDiv == 0) + { + postDiv = 2; + } + } + + /* Adjusted by 1, directo is used to bypass */ + return postDiv; } /* Get multiplier (M) from PLL MDEC and BYPASS_FBDIV2 settings */ uint32_t findPllMMult(uint32_t ctrlReg, uint32_t mDecReg) { - uint32_t mMult = 1; + uint32_t mMult = 1; - /* Decode MDEC value to get (M) multiplier */ - mMult = pllDecodeM(mDecReg & 0x1FFFF); + /* Decode MDEC value to get (M) multiplier */ + mMult = pllDecodeM(mDecReg & 0x1FFFF); - /* Extra divided by 2 needed? */ - if ((ctrlReg & SYSCON_SYSPLLCTRL_BYPASS_FBDIV2) == 0) { - mMult = mMult >> 1; - } + /* Extra divided by 2 needed? */ + if ((ctrlReg & SYSCON_SYSPLLCTRL_BYPASS_FBDIV2) == 0) + { + mMult = mMult >> 1; + } - if (mMult == 0) { - mMult = 1; - } + if (mMult == 0) + { + mMult = 1; + } - return mMult; + return mMult; } static uint32_t FindGreatestCommonDivisor(uint32_t m, uint32_t n) { - uint32_t tmp; + uint32_t tmp; - while (n != 0) { - tmp = n; - n = m % n; - m = tmp; - } + while (n != 0) + { + tmp = n; + n = m % n; + m = tmp; + } - return m; + return m; } /* Set PLL output based on desired output rate */ static PLL_ERROR_T Chip_Clock_GetPllConfig(uint32_t finHz, uint32_t foutHz, PLL_SETUP_T *pSetup, - bool useFeedbackDiv2, bool useSS) + bool useFeedbackDiv2, bool useSS) { - uint32_t nDivOutHz, fccoHz, multFccoDiv; - uint32_t pllPreDivider, pllMultiplier, pllBypassFBDIV2, pllPostDivider; - uint32_t pllDirectInput, pllDirectOutput; - uint32_t pllSelP, pllSelI, pllSelR, bandsel, uplimoff; - - /* Baseline parameters (no input or output dividers) */ - pllPreDivider = 1; /* 1 implies pre-divider will be disabled */ - pllPostDivider = 0; /* 0 implies post-divider will be disabled */ - pllDirectOutput = 1; - if (useFeedbackDiv2) { - /* Using feedback divider for M, so disable bypass */ - pllBypassFBDIV2 = 0; - } - else { - pllBypassFBDIV2 = 1; - } - multFccoDiv = (2 - pllBypassFBDIV2); - - /* Verify output rate parameter */ - if (foutHz > PLL_MAX_CCO_FREQ_MHZ) { - /* Maximum PLL output with post divider=1 cannot go above this frequency */ - return PLL_ERROR_OUTPUT_TOO_HIGH; - } - if (foutHz < (PLL_MIN_CCO_FREQ_MHZ / (PVALMAX << 1))) { - /* Minmum PLL output with maximum post divider cannot go below this frequency */ - return PLL_ERROR_OUTPUT_TOO_LOW; - } - - /* If using SS mode, input clock needs to be between 2MHz and 4MHz */ - if (useSS) { - /* Verify input rate parameter */ - if (finHz < PLL_MIN_IN_SSMODE) { - /* Input clock into the PLL cannot be lower than this */ - return PLL_ERROR_INPUT_TOO_LOW; - } - - /* PLL input in SS mode must be under 4MHz */ - pllPreDivider = finHz / ((PLL_MIN_IN_SSMODE + PLL_MAX_IN_SSMODE) / 2); - if (pllPreDivider > NVALMAX) { - return PLL_ERROR_INPUT_TOO_HIGH; - } - } - else { - /* Verify input rate parameter */ - if (finHz < PLL_LOWER_IN_LIMIT) { - /* Input clock into the PLL cannot be lower than this */ - return PLL_ERROR_INPUT_TOO_LOW; - } - } - - /* Find the optimal CCO frequency for the output and input that - will keep it inside the PLL CCO range. This may require - tweaking the post-divider for the PLL. */ - fccoHz = foutHz; - while (fccoHz < PLL_MIN_CCO_FREQ_MHZ) { - /* CCO output is less than minimum CCO range, so the CCO output - needs to be bumped up and the post-divider is used to bring - the PLL output back down. */ - pllPostDivider++; - if (pllPostDivider > PVALMAX) { - return PLL_ERROR_OUTSIDE_INTLIMIT; - } - - /* Target CCO goes up, PLL output goes down */ - fccoHz = foutHz * (pllPostDivider * 2); - pllDirectOutput = 0; - } - - /* Determine if a pre-divider is needed to get the best frequency */ - if ((finHz > PLL_LOWER_IN_LIMIT) && (fccoHz >= finHz) && (useSS == false)) { - uint32_t a = FindGreatestCommonDivisor(fccoHz, (multFccoDiv * finHz)); - - if (a > 20000) { - a = (multFccoDiv * finHz) / a; - if ((a != 0) && (a < PLL_MAX_N_DIV)) { - pllPreDivider = a; - } - } - } - - /* Bypass pre-divider hardware if pre-divider is 1 */ - if (pllPreDivider > 1) { - pllDirectInput = 0; - } - else { - pllDirectInput = 1; - } - - /* Determine PLL multipler */ - nDivOutHz = (finHz / pllPreDivider); - pllMultiplier = (fccoHz / nDivOutHz) / multFccoDiv; - - /* Find optimal values for filter */ - if (useSS == false) { - /* Will bumping up M by 1 get us closer to the desired CCO frequency? */ - if ((nDivOutHz * ((multFccoDiv * pllMultiplier * 2) + 1)) < (fccoHz * 2)) { - pllMultiplier++; - } - - /* Setup filtering */ - pllFindSel(pllMultiplier, pllBypassFBDIV2, &pllSelP, &pllSelI, &pllSelR); - bandsel = 1; - uplimoff = 0; - - /* Get encoded value for M (mult) and use manual filter, disable SS mode */ - pSetup->SYSPLLSSCTRL[0] = (PLL_SSCG0_MDEC_VAL_SET(pllEncodeM(pllMultiplier)) | - (1 << PLL_SSCG0_SEL_EXT_SSCG_N_P)); - - /* Power down SSC, not used */ - pSetup->SYSPLLSSCTRL[1] = PLL_SSCG1_MOD_PD_SSCGCLK_N; - } - else { - uint64_t fc; - - /* Filtering will be handled by SSC */ - pllSelR = pllSelI = pllSelP = 0; - bandsel = 0; - uplimoff = 1; - - /* The PLL multiplier will get very close and slightly under the - desired target frequency. A small fractional component can be - added to fine tune the frequency upwards to the target. */ - fc = ((uint64_t) (fccoHz % (multFccoDiv * nDivOutHz)) << 11) / (multFccoDiv * nDivOutHz); - - /* MDEC set by SSC */ - pSetup->SYSPLLSSCTRL[0] = 0; - - /* Set multiplier */ - pSetup->SYSPLLSSCTRL[1] = PLL_SSCG1_MD_INT_SET(pllMultiplier) | - PLL_SSCG1_MD_FRACT_SET((uint32_t) fc); - } - - /* Get encoded values for N (prediv) and P (postdiv) */ - pSetup->SYSPLLNDEC = PLL_NDEC_VAL_SET(pllEncodeN(pllPreDivider)); - pSetup->SYSPLLPDEC = PLL_PDEC_VAL_SET(pllEncodeP(pllPostDivider)); - - /* PLL control */ - pSetup->SYSPLLCTRL = - (pllSelR << SYSCON_SYSPLLCTRL_SELR_P) | /* Filter coefficient */ - (pllSelI << SYSCON_SYSPLLCTRL_SELI_P) | /* Filter coefficient */ - (pllSelP << SYSCON_SYSPLLCTRL_SELP_P) | /* Filter coefficient */ - (0 << SYSCON_SYSPLLCTRL_BYPASS_P) | /* PLL bypass mode disabled */ - (pllBypassFBDIV2 << SYSCON_SYSPLLCTRL_BYPASS_FBDIV2_P) | /* Extra M / 2 divider? */ - (uplimoff << SYSCON_SYSPLLCTRL_UPLIMOFF_P) | /* SS/fractional mode disabled */ - (bandsel << SYSCON_SYSPLLCTRL_BANDSEL_SSCGREG_N_P) | /* Manual bandwidth selection enabled */ - (pllDirectInput << SYSCON_SYSPLLCTRL_DIRECTI_P) | /* Bypass pre-divider? */ - (pllDirectOutput << SYSCON_SYSPLLCTRL_DIRECTO_P); /* Bypass post-divider? */ - - return PLL_ERROR_SUCCESS; + uint32_t nDivOutHz, fccoHz, multFccoDiv; + uint32_t pllPreDivider, pllMultiplier, pllBypassFBDIV2, pllPostDivider; + uint32_t pllDirectInput, pllDirectOutput; + uint32_t pllSelP, pllSelI, pllSelR, bandsel, uplimoff; + + /* Baseline parameters (no input or output dividers) */ + pllPreDivider = 1; /* 1 implies pre-divider will be disabled */ + pllPostDivider = 0; /* 0 implies post-divider will be disabled */ + pllDirectOutput = 1; + if (useFeedbackDiv2) + { + /* Using feedback divider for M, so disable bypass */ + pllBypassFBDIV2 = 0; + } + else { + pllBypassFBDIV2 = 1; + } + multFccoDiv = (2 - pllBypassFBDIV2); + + /* Verify output rate parameter */ + if (foutHz > PLL_MAX_CCO_FREQ_MHZ) + { + /* Maximum PLL output with post divider=1 cannot go above this frequency */ + return PLL_ERROR_OUTPUT_TOO_HIGH; + } + if (foutHz < (PLL_MIN_CCO_FREQ_MHZ / (PVALMAX << 1))) + { + /* Minmum PLL output with maximum post divider cannot go below this frequency */ + return PLL_ERROR_OUTPUT_TOO_LOW; + } + + /* If using SS mode, input clock needs to be between 2MHz and 4MHz */ + if (useSS) + { + /* Verify input rate parameter */ + if (finHz < PLL_MIN_IN_SSMODE) + { + /* Input clock into the PLL cannot be lower than this */ + return PLL_ERROR_INPUT_TOO_LOW; + } + + /* PLL input in SS mode must be under 4MHz */ + pllPreDivider = finHz / ((PLL_MIN_IN_SSMODE + PLL_MAX_IN_SSMODE) / 2); + if (pllPreDivider > NVALMAX) + { + return PLL_ERROR_INPUT_TOO_HIGH; + } + } + else { + /* Verify input rate parameter */ + if (finHz < PLL_LOWER_IN_LIMIT) + { + /* Input clock into the PLL cannot be lower than this */ + return PLL_ERROR_INPUT_TOO_LOW; + } + } + + /* Find the optimal CCO frequency for the output and input that + will keep it inside the PLL CCO range. This may require + tweaking the post-divider for the PLL. */ + fccoHz = foutHz; + while (fccoHz < PLL_MIN_CCO_FREQ_MHZ) + { + /* CCO output is less than minimum CCO range, so the CCO output + needs to be bumped up and the post-divider is used to bring + the PLL output back down. */ + pllPostDivider++; + if (pllPostDivider > PVALMAX) + { + return PLL_ERROR_OUTSIDE_INTLIMIT; + } + + /* Target CCO goes up, PLL output goes down */ + fccoHz = foutHz * (pllPostDivider * 2); + pllDirectOutput = 0; + } + + /* Determine if a pre-divider is needed to get the best frequency */ + if ((finHz > PLL_LOWER_IN_LIMIT) && (fccoHz >= finHz) && (useSS == false)) + { + uint32_t a = FindGreatestCommonDivisor(fccoHz, (multFccoDiv * finHz)); + + if (a > 20000) + { + a = (multFccoDiv * finHz) / a; + if ((a != 0) && (a < PLL_MAX_N_DIV)) + { + pllPreDivider = a; + } + } + } + + /* Bypass pre-divider hardware if pre-divider is 1 */ + if (pllPreDivider > 1) + { + pllDirectInput = 0; + } + else { + pllDirectInput = 1; + } + + /* Determine PLL multipler */ + nDivOutHz = (finHz / pllPreDivider); + pllMultiplier = (fccoHz / nDivOutHz) / multFccoDiv; + + /* Find optimal values for filter */ + if (useSS == false) + { + /* Will bumping up M by 1 get us closer to the desired CCO frequency? */ + if ((nDivOutHz * ((multFccoDiv * pllMultiplier * 2) + 1)) < (fccoHz * 2)) + { + pllMultiplier++; + } + + /* Setup filtering */ + pllFindSel(pllMultiplier, pllBypassFBDIV2, &pllSelP, &pllSelI, &pllSelR); + bandsel = 1; + uplimoff = 0; + + /* Get encoded value for M (mult) and use manual filter, disable SS mode */ + pSetup->SYSPLLSSCTRL[0] = (PLL_SSCG0_MDEC_VAL_SET(pllEncodeM(pllMultiplier)) | + (1 << PLL_SSCG0_SEL_EXT_SSCG_N_P)); + + /* Power down SSC, not used */ + pSetup->SYSPLLSSCTRL[1] = PLL_SSCG1_MOD_PD_SSCGCLK_N; + } + else { + uint64_t fc; + + /* Filtering will be handled by SSC */ + pllSelR = pllSelI = pllSelP = 0; + bandsel = 0; + uplimoff = 1; + + /* The PLL multiplier will get very close and slightly under the + desired target frequency. A small fractional component can be + added to fine tune the frequency upwards to the target. */ + fc = ((uint64_t) (fccoHz % (multFccoDiv * nDivOutHz)) << 11) / (multFccoDiv * nDivOutHz); + + /* MDEC set by SSC */ + pSetup->SYSPLLSSCTRL[0] = 0; + + /* Set multiplier */ + pSetup->SYSPLLSSCTRL[1] = PLL_SSCG1_MD_INT_SET(pllMultiplier) | + PLL_SSCG1_MD_FRACT_SET((uint32_t) fc); + } + + /* Get encoded values for N (prediv) and P (postdiv) */ + pSetup->SYSPLLNDEC = PLL_NDEC_VAL_SET(pllEncodeN(pllPreDivider)); + pSetup->SYSPLLPDEC = PLL_PDEC_VAL_SET(pllEncodeP(pllPostDivider)); + + /* PLL control */ + pSetup->SYSPLLCTRL = + (pllSelR << SYSCON_SYSPLLCTRL_SELR_P) | /* Filter coefficient */ + (pllSelI << SYSCON_SYSPLLCTRL_SELI_P) | /* Filter coefficient */ + (pllSelP << SYSCON_SYSPLLCTRL_SELP_P) | /* Filter coefficient */ + (0 << SYSCON_SYSPLLCTRL_BYPASS_P) | /* PLL bypass mode disabled */ + (pllBypassFBDIV2 << SYSCON_SYSPLLCTRL_BYPASS_FBDIV2_P) | /* Extra M / 2 divider? */ + (uplimoff << SYSCON_SYSPLLCTRL_UPLIMOFF_P) | /* SS/fractional mode disabled */ + (bandsel << SYSCON_SYSPLLCTRL_BANDSEL_SSCGREG_N_P) | /* Manual bandwidth selection enabled */ + (pllDirectInput << SYSCON_SYSPLLCTRL_DIRECTI_P) | /* Bypass pre-divider? */ + (pllDirectOutput << SYSCON_SYSPLLCTRL_DIRECTO_P); /* Bypass post-divider? */ + + return PLL_ERROR_SUCCESS; } /* Update local PLL rate variable */ static void Chip_Clock_GetSystemPLLOutFromSetupUpdate(PLL_SETUP_T *pSetup) { - curPllRate = Chip_Clock_GetSystemPLLOutFromSetup(pSetup); + curPllRate = Chip_Clock_GetSystemPLLOutFromSetup(pSetup); } /***************************************************************************** @@ -658,209 +706,223 @@ static void Chip_Clock_GetSystemPLLOutFromSetupUpdate(PLL_SETUP_T *pSetup) /* Return System PLL input clock rate */ uint32_t Chip_Clock_GetSystemPLLInClockRate(void) { - uint32_t clkRate = 0; + uint32_t clkRate = 0; - switch ((CHIP_SYSCON_PLLCLKSRC_T) (LPC_SYSCON->SYSPLLCLKSEL & 0x3)) { - case SYSCON_PLLCLKSRC_IRC: - clkRate = Chip_Clock_GetIntOscRate(); - break; + switch ((CHIP_SYSCON_PLLCLKSRC_T) (LPC_SYSCON->SYSPLLCLKSEL & 0x3)) + { + case SYSCON_PLLCLKSRC_IRC: + clkRate = Chip_Clock_GetIntOscRate(); + break; - case SYSCON_PLLCLKSRC_CLKIN: - clkRate = Chip_Clock_GetExtClockInRate(); - break; + case SYSCON_PLLCLKSRC_CLKIN: + clkRate = Chip_Clock_GetExtClockInRate(); + break; - case SYSCON_PLLCLKSRC_WDTOSC: - clkRate = Chip_Clock_GetWDTOSCRate(); - break; + case SYSCON_PLLCLKSRC_WDTOSC: + clkRate = Chip_Clock_GetWDTOSCRate(); + break; - case SYSCON_PLLCLKSRC_RTC: - clkRate = Chip_Clock_GetRTCOscRate(); - break; - } + case SYSCON_PLLCLKSRC_RTC: + clkRate = Chip_Clock_GetRTCOscRate(); + break; + } - return clkRate; + return clkRate; } /* Return System PLL output clock rate from setup structure */ uint32_t Chip_Clock_GetSystemPLLOutFromSetup(PLL_SETUP_T *pSetup) { - uint32_t prediv, postdiv, mMult, inPllRate; - uint64_t workRate; - - inPllRate = Chip_Clock_GetSystemPLLInClockRate(); - if ((pSetup->SYSPLLCTRL & SYSCON_SYSPLLCTRL_BYPASS_P) == 0) { - /* PLL is not in bypass mode, get pre-divider, post-divider, and M divider */ - prediv = findPllPreDiv(pSetup->SYSPLLCTRL, pSetup->SYSPLLNDEC); - postdiv = findPllPostDiv(pSetup->SYSPLLCTRL, pSetup->SYSPLLPDEC); - - /* Adjust input clock */ - inPllRate = inPllRate / prediv; - - /* If using the SS, use the multiplier */ - if (pSetup->SYSPLLSSCTRL[1] & PLL_SSCG1_MOD_PD_SSCGCLK_N) { - /* MDEC used for rate */ - mMult = findPllMMult(pSetup->SYSPLLCTRL, pSetup->SYSPLLSSCTRL[0]); - workRate = (uint64_t) inPllRate * (uint64_t) mMult; - } - else { - uint64_t fract; - - /* SS multipler used for rate */ - mMult = (pSetup->SYSPLLSSCTRL[1] & PLL_SSCG1_MD_INT_M) >> PLL_SSCG1_MD_INT_P; - workRate = (uint64_t) inPllRate * (uint64_t) mMult; - - /* Adjust by fractional */ - fract = (uint64_t) (pSetup->SYSPLLSSCTRL[1] & PLL_SSCG1_MD_FRACT_M) >> PLL_SSCG1_MD_FRACT_P; - workRate = workRate + ((inPllRate * fract) / 0x7FF); - } - - workRate = workRate / ((uint64_t) postdiv); - } - else { - /* In bypass mode */ - workRate = (uint64_t) inPllRate; - } - - return (uint32_t) workRate; + uint32_t prediv, postdiv, mMult, inPllRate; + uint64_t workRate; + + inPllRate = Chip_Clock_GetSystemPLLInClockRate(); + if ((pSetup->SYSPLLCTRL & SYSCON_SYSPLLCTRL_BYPASS_P) == 0) + { + /* PLL is not in bypass mode, get pre-divider, post-divider, and M divider */ + prediv = findPllPreDiv(pSetup->SYSPLLCTRL, pSetup->SYSPLLNDEC); + postdiv = findPllPostDiv(pSetup->SYSPLLCTRL, pSetup->SYSPLLPDEC); + + /* Adjust input clock */ + inPllRate = inPllRate / prediv; + + /* If using the SS, use the multiplier */ + if (pSetup->SYSPLLSSCTRL[1] & PLL_SSCG1_MOD_PD_SSCGCLK_N) + { + /* MDEC used for rate */ + mMult = findPllMMult(pSetup->SYSPLLCTRL, pSetup->SYSPLLSSCTRL[0]); + workRate = (uint64_t) inPllRate * (uint64_t) mMult; + } + else { + uint64_t fract; + + /* SS multipler used for rate */ + mMult = (pSetup->SYSPLLSSCTRL[1] & PLL_SSCG1_MD_INT_M) >> PLL_SSCG1_MD_INT_P; + workRate = (uint64_t) inPllRate * (uint64_t) mMult; + + /* Adjust by fractional */ + fract = (uint64_t) (pSetup->SYSPLLSSCTRL[1] & PLL_SSCG1_MD_FRACT_M) >> PLL_SSCG1_MD_FRACT_P; + workRate = workRate + ((inPllRate * fract) / 0x7FF); + } + + workRate = workRate / ((uint64_t) postdiv); + } + else { + /* In bypass mode */ + workRate = (uint64_t) inPllRate; + } + + return (uint32_t) workRate; } /* Return System PLL output clock rate */ uint32_t Chip_Clock_GetSystemPLLOutClockRate(bool recompute) { - PLL_SETUP_T Setup; - uint32_t rate; + PLL_SETUP_T Setup; + uint32_t rate; - if ((recompute) || (curPllRate == 0)) { - Setup.SYSPLLCTRL = LPC_SYSCON->SYSPLLCTRL; - Setup.SYSPLLNDEC = LPC_SYSCON->SYSPLLNDEC; - Setup.SYSPLLPDEC = LPC_SYSCON->SYSPLLPDEC; - Setup.SYSPLLSSCTRL[0] = LPC_SYSCON->SYSPLLSSCTRL[0]; - Setup.SYSPLLSSCTRL[1] = LPC_SYSCON->SYSPLLSSCTRL[1]; + if ((recompute) || (curPllRate == 0)) + { + Setup.SYSPLLCTRL = LPC_SYSCON->SYSPLLCTRL; + Setup.SYSPLLNDEC = LPC_SYSCON->SYSPLLNDEC; + Setup.SYSPLLPDEC = LPC_SYSCON->SYSPLLPDEC; + Setup.SYSPLLSSCTRL[0] = LPC_SYSCON->SYSPLLSSCTRL[0]; + Setup.SYSPLLSSCTRL[1] = LPC_SYSCON->SYSPLLSSCTRL[1]; - Chip_Clock_GetSystemPLLOutFromSetupUpdate(&Setup); - } + Chip_Clock_GetSystemPLLOutFromSetupUpdate(&Setup); + } - rate = curPllRate; + rate = curPllRate; - return rate; + return rate; } /* Enables and disables PLL bypass mode */ void Chip_Clock_SetBypassPLL(bool bypass) { - if (bypass) { - LPC_SYSCON->SYSPLLCTRL |= SYSCON_SYSPLLCTRL_BYPASS_P; - } - else { - LPC_SYSCON->SYSPLLCTRL &= ~SYSCON_SYSPLLCTRL_BYPASS_P; - } + if (bypass) + { + LPC_SYSCON->SYSPLLCTRL |= SYSCON_SYSPLLCTRL_BYPASS_P; + } + else { + LPC_SYSCON->SYSPLLCTRL &= ~SYSCON_SYSPLLCTRL_BYPASS_P; + } } /* Set PLL output based on the passed PLL setup data */ PLL_ERROR_T Chip_Clock_SetupPLLData(PLL_CONFIG_T *pControl, PLL_SETUP_T *pSetup) { - uint32_t inRate; - bool useSS = (bool) ((pControl->flags & PLL_CONFIGFLAG_FORCENOFRACT) == 0); - PLL_ERROR_T pllError; - - /* Determine input rate for the PLL */ - if ((pControl->flags & PLL_CONFIGFLAG_USEINRATE) != 0) { - inRate = pControl->InputRate; - } - else { - inRate = Chip_Clock_GetSystemPLLInClockRate(); - } - - /* PLL flag options */ - pllError = Chip_Clock_GetPllConfig(inRate, pControl->desiredRate, pSetup, false, useSS); - if ((useSS) && (pllError == PLL_ERROR_SUCCESS)) { - /* If using SS mode, then some tweaks are made to the generated setup */ - pSetup->SYSPLLSSCTRL[1] |= (uint32_t) pControl->ss_mf | (uint32_t) pControl->ss_mr | - (uint32_t) pControl->ss_mc; - if (pControl->mfDither) { - pSetup->SYSPLLSSCTRL[1] |= PLL_SSCG1_DITHER; - } - } - - return pllError; + uint32_t inRate; + bool useSS = (bool) ((pControl->flags & PLL_CONFIGFLAG_FORCENOFRACT) == 0); + PLL_ERROR_T pllError; + + /* Determine input rate for the PLL */ + if ((pControl->flags & PLL_CONFIGFLAG_USEINRATE) != 0) + { + inRate = pControl->InputRate; + } + else { + inRate = Chip_Clock_GetSystemPLLInClockRate(); + } + + /* PLL flag options */ + pllError = Chip_Clock_GetPllConfig(inRate, pControl->desiredRate, pSetup, false, useSS); + if ((useSS) && (pllError == PLL_ERROR_SUCCESS)) + { + /* If using SS mode, then some tweaks are made to the generated setup */ + pSetup->SYSPLLSSCTRL[1] |= (uint32_t) pControl->ss_mf | (uint32_t) pControl->ss_mr | + (uint32_t) pControl->ss_mc; + if (pControl->mfDither) + { + pSetup->SYSPLLSSCTRL[1] |= PLL_SSCG1_DITHER; + } + } + + return pllError; } /* Set PLL output from PLL setup structure */ PLL_ERROR_T Chip_Clock_SetupSystemPLLPrec(PLL_SETUP_T *pSetup) { - /* Power off PLL during setup changes */ - Chip_SYSCON_PowerDown(SYSCON_PDRUNCFG_PD_SYS_PLL); - - /* Write PLL setup data */ - LPC_SYSCON->SYSPLLCTRL = pSetup->SYSPLLCTRL; - LPC_SYSCON->SYSPLLNDEC = pSetup->SYSPLLNDEC; - LPC_SYSCON->SYSPLLNDEC = pSetup->SYSPLLNDEC | PLL_NDEC_NREQ;/* latch */ - LPC_SYSCON->SYSPLLPDEC = pSetup->SYSPLLPDEC; - LPC_SYSCON->SYSPLLPDEC = pSetup->SYSPLLPDEC | PLL_PDEC_PREQ;/* latch */ - LPC_SYSCON->SYSPLLSSCTRL[0] = pSetup->SYSPLLSSCTRL[0]; - LPC_SYSCON->SYSPLLSSCTRL[0] = pSetup->SYSPLLSSCTRL[0] | PLL_SSCG0_MREQ; /* latch */ - LPC_SYSCON->SYSPLLSSCTRL[1] = pSetup->SYSPLLSSCTRL[1]; - LPC_SYSCON->SYSPLLSSCTRL[1] = pSetup->SYSPLLSSCTRL[1] | PLL_SSCG1_MD_REQ; /* latch */ - - /* Flags for lock or power on */ - if ((pSetup->flags & (PLL_SETUPFLAG_POWERUP | PLL_SETUPFLAG_WAITLOCK)) != 0) { - Chip_SYSCON_PowerUp(SYSCON_PDRUNCFG_PD_SYS_PLL); - } - if ((pSetup->flags & PLL_SETUPFLAG_WAITLOCK) != 0) { - while (Chip_Clock_IsSystemPLLLocked() == false) {} - } - - /* Update current programmed PLL rate var */ - Chip_Clock_GetSystemPLLOutFromSetupUpdate(pSetup); - - /* System voltage adjustment, occurs prior to setting main system clock */ - if ((pSetup->flags & PLL_SETUPFLAG_ADGVOLT) != 0) { - Chip_POWER_SetVoltage(POWER_LOW_POWER_MODE, curPllRate); - } - - return PLL_ERROR_SUCCESS; + /* Power off PLL during setup changes */ + Chip_SYSCON_PowerDown(SYSCON_PDRUNCFG_PD_SYS_PLL); + + /* Write PLL setup data */ + LPC_SYSCON->SYSPLLCTRL = pSetup->SYSPLLCTRL; + LPC_SYSCON->SYSPLLNDEC = pSetup->SYSPLLNDEC; + LPC_SYSCON->SYSPLLNDEC = pSetup->SYSPLLNDEC | PLL_NDEC_NREQ;/* latch */ + LPC_SYSCON->SYSPLLPDEC = pSetup->SYSPLLPDEC; + LPC_SYSCON->SYSPLLPDEC = pSetup->SYSPLLPDEC | PLL_PDEC_PREQ;/* latch */ + LPC_SYSCON->SYSPLLSSCTRL[0] = pSetup->SYSPLLSSCTRL[0]; + LPC_SYSCON->SYSPLLSSCTRL[0] = pSetup->SYSPLLSSCTRL[0] | PLL_SSCG0_MREQ; /* latch */ + LPC_SYSCON->SYSPLLSSCTRL[1] = pSetup->SYSPLLSSCTRL[1]; + LPC_SYSCON->SYSPLLSSCTRL[1] = pSetup->SYSPLLSSCTRL[1] | PLL_SSCG1_MD_REQ; /* latch */ + + /* Flags for lock or power on */ + if ((pSetup->flags & (PLL_SETUPFLAG_POWERUP | PLL_SETUPFLAG_WAITLOCK)) != 0) + { + Chip_SYSCON_PowerUp(SYSCON_PDRUNCFG_PD_SYS_PLL); + } + if ((pSetup->flags & PLL_SETUPFLAG_WAITLOCK) != 0) + { + while (Chip_Clock_IsSystemPLLLocked() == false) + {} + } + + /* Update current programmed PLL rate var */ + Chip_Clock_GetSystemPLLOutFromSetupUpdate(pSetup); + + /* System voltage adjustment, occurs prior to setting main system clock */ + if ((pSetup->flags & PLL_SETUPFLAG_ADGVOLT) != 0) + { + Chip_POWER_SetVoltage(POWER_LOW_POWER_MODE, curPllRate); + } + + return PLL_ERROR_SUCCESS; } /* Set System PLL clock based on the input frequency and multiplier */ void Chip_Clock_SetupSystemPLL(uint32_t multiply_by, uint32_t input_freq) { - uint32_t cco_freq = input_freq * multiply_by; - uint32_t pdec = 1; - uint32_t selr; - uint32_t seli; - uint32_t selp; - uint32_t mdec, ndec; - - uint32_t directo = SYS_PLL_DIRECTO; - - while (cco_freq < 75000000) { - multiply_by <<= 1; /* double value in each iteration */ - pdec <<= 1; /* correspondingly double pdec to cancel effect of double msel */ - cco_freq = input_freq * multiply_by; - } - selr = 0; - seli = (multiply_by & 0x3c) + 4; - selp = (multiply_by >> 1) + 1; - - if (pdec > 1) { - directo = 0; /* use post divider */ - pdec = pdec / 2; /* Account for minus 1 encoding */ - /* Translate P value */ - pdec = (pdec == 1) ? 0x62 : /* 1 * 2 */ - (pdec == 2) ? 0x42 : /* 2 * 2 */ - (pdec == 4) ? 0x02 : /* 4 * 2 */ - (pdec == 8) ? 0x0b : /* 8 * 2 */ - (pdec == 16) ? 0x11 : /* 16 * 2 */ - (pdec == 32) ? 0x08 : 0x08; /* 32 * 2 */ - } - - /* Only support values of 2 to 16 (to keep driver simple) */ - mdec = 0x7fff >> (16 - (multiply_by - 1)); - ndec = 0x202; /* pre divide by 2 (hardcoded) */ - - LPC_SYSCON->SYSPLLCTRL = SYS_PLL_BANDSEL | directo | (selr << SYSCON_SYSPLLCTRL_SELR_P) | - (seli << SYSCON_SYSPLLCTRL_SELI_P) | (selp << SYSCON_SYSPLLCTRL_SELP_P); - LPC_SYSCON->SYSPLLPDEC = pdec | (1 << 7); /* set Pdec value and assert preq */ - LPC_SYSCON->SYSPLLNDEC = ndec | (1 << 10); /* set Pdec value and assert preq */ - LPC_SYSCON->SYSPLLSSCTRL[0] = (1 << 18) | (1 << 17) | mdec; /* select non sscg MDEC value, assert mreq and select mdec value */ + uint32_t cco_freq = input_freq * multiply_by; + uint32_t pdec = 1; + uint32_t selr; + uint32_t seli; + uint32_t selp; + uint32_t mdec, ndec; + + uint32_t directo = SYS_PLL_DIRECTO; + + while (cco_freq < 75000000) + { + multiply_by <<= 1; /* double value in each iteration */ + pdec <<= 1; /* correspondingly double pdec to cancel effect of double msel */ + cco_freq = input_freq * multiply_by; + } + selr = 0; + seli = (multiply_by & 0x3c) + 4; + selp = (multiply_by >> 1) + 1; + + if (pdec > 1) + { + directo = 0; /* use post divider */ + pdec = pdec / 2; /* Account for minus 1 encoding */ + /* Translate P value */ + pdec = (pdec == 1) ? 0x62 : /* 1 * 2 */ + (pdec == 2) ? 0x42 : /* 2 * 2 */ + (pdec == 4) ? 0x02 : /* 4 * 2 */ + (pdec == 8) ? 0x0b : /* 8 * 2 */ + (pdec == 16) ? 0x11 : /* 16 * 2 */ + (pdec == 32) ? 0x08 : 0x08; /* 32 * 2 */ + } + + /* Only support values of 2 to 16 (to keep driver simple) */ + mdec = 0x7fff >> (16 - (multiply_by - 1)); + ndec = 0x202; /* pre divide by 2 (hardcoded) */ + + LPC_SYSCON->SYSPLLCTRL = SYS_PLL_BANDSEL | directo | (selr << SYSCON_SYSPLLCTRL_SELR_P) | + (seli << SYSCON_SYSPLLCTRL_SELI_P) | (selp << SYSCON_SYSPLLCTRL_SELP_P); + LPC_SYSCON->SYSPLLPDEC = pdec | (1 << 7); /* set Pdec value and assert preq */ + LPC_SYSCON->SYSPLLNDEC = ndec | (1 << 10); /* set Pdec value and assert preq */ + LPC_SYSCON->SYSPLLSSCTRL[0] = (1 << 18) | (1 << 17) | mdec; /* select non sscg MDEC value, assert mreq and select mdec value */ } diff --git a/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/power_lib/keil/lib_power.lib b/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/power_lib/keil/lib_power.lib new file mode 100644 index 0000000000000000000000000000000000000000..d6271384a44b6e0a15a9e8320591e37bbeb6e916 GIT binary patch literal 14156 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 literal 0 HcmV?d00001 diff --git a/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/power_lib/lpcxpresso/libpower.a b/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/power_lib/lpcxpresso/libpower.a new file mode 100644 index 0000000000000000000000000000000000000000..f5064ec2ef3f71a60ae2a254947db8e2eab1a800 GIT binary patch literal 6054 zcmbtYeN0=|6~FJp*w`T@4;UW~&a~e5e#J%qiemfoJz9Zr zJ0WBbASk0ht$!E|h9 zbawhIjW{M}Bg4Zc%S*}WZ0t3ewiYvyBcsR1j`bgoN@GWYtwmZ#k=9nEwHIlfG(WVX zFE|{EWs7PJ8CJT+F1jROj*gDJB&Rcp!cK}#CnnOd^jTl>;7%ji>i2hbb%|nUXPY*ZB?h{=6i|l=N@@p`-*o7B0td(q_Mr|3 zH(7znF-&0dy9~)O#1`ap9M6S&H~GfBQ@ItgN(k3WuCu+Pxw)X|DPO*suk@s^mJRJm z^yPSFPwZa4JYXMm2i=>5xtS+|Z4eN`ocsML|LRTfRU{g6JXaB$xLUqKJ|-J~dGEu| zM8cDvWnL0A$4j5S8Qr}mN==G3`e=@z73;f~|4r+C>;K-hZdk(3`2DyjIpa;z zLa1kjh>%tZ^h3|GMcP&1d36oTbq(Fj*Lb?ZmjllA&fx|qNkmq1CM@oS5NeF*OgP-c zqiSrC#(`#W*Kc^Cv}=7oRl4*kN;?yrSgJ5%3u}}XR8bs`r{KUAINTpRun+XClqhj~ zr4wg-4DSvu4Q2T!-tj}YpZMbgzFNX9M9Ip zIycf+_kjkz)E7`JYx#24Im8A%n>_#fJPG($1;BhMTs>HqP!WI)+yxW^W6bk66wD3K zb<^$GCpJv8{^FzOtWLHzUA5V8jL*m3}-puS%;b5RuQh*V4I!bt6Sfr`M9sJ2ZZ%q;oU=Z zb@9NX>%dAH*$uXlY%q<7M2uOKxF!FJ{_gUy+LS|EwBD## z2&jE5N*7iyz3x1<5Q2A884Cl!DWh;<_5SN8zz-u~@>||lIW8$)MpVWMFxVTma9zCj zKaIf~pE!hz0qm7~dBWlPQnNY-zo`)PAIt;vSfRgc6*u!dhZxHs8)RVa5U`L2#M#KL z>t0AtgXIBN35kS)!52ht=*XCOJei!%h_5EoV&Bmbv43Vlo|=-U#7H_hDQ7atbf!t{ z@b&mQ#5R9xhrhe6Q}m|gX*rgWo5T}P!D<`+PCk9> z-_~zB1gPBf#@tGba1=WpP z4i_e$e#F>fRu3A!$>hw8JPU&l)6W;nX48p@H?nd@IU79Pj}u^cz9`Y)>bb%w%W98q z$PveBx*3N)lrKZVBg&I-IQ7l-ieS?P)j65YOUf?`91CVKlWgHH4H0w0z~KD6t6*WsDw zn}PxOE!cF?`F;lmns0#ObAV6h+kj`9Z!Zjt7i_xde0ea?xWj;3&_R&vxJU3z*BgO) z%fW_m?ACA?S2>W;d>;VcF0kvO^X&o<%{NZPfxLPgjV8W_z=wWabiNl&xIEx~q=O*W zaXqGb<5V0K8V=()ZsI!!1dZG9MNE8Ws5s!U5J%R;cLn&wZTM0qzB!7on&P`);``$c z?VC68y-D%aQhdKO@%;n%;J+aHdT_NT)n`t;5K z9l202r_7`rUW#7eYy|t)AYmLhZ*k5;y#@wJohLkAy!v%xB z3#kSUR@!2`)r7~D*bokSwHRNj;By5Cz0zR(4iny?;BlQ-MfDr;tNtsx8_Ltdkunos znZhR)KxKs|eBfZkEN<^^1wUUv;fiVq2Q#M_U#{TsJyQi|mLVJwOn5=T8|$!OfZ>TF z6()Rzf}bm(aAh=vBUL7Rm4X)w5M22T;YhU!U#;Mc{>7Ee5RTNE@U

T)7P4h|`3} zmB&e@ij(ddw<8`Y@hyE`97&l28v&3{WYMdflu0_Ez_8C|o4oNF6&1-wbC8Uqp|+ax6G{B&vKt9ZS()9RaOhm3FMR=xgT}{7R~}v41u; zF)c^rbRrd3EZT=mC4j?;%(hNsyMdXfeKdr_Cp!edk>5? z?i6-d{&Byu2h=^v9yIK_A8*@;n}FN}8!+yOF2LcMX%7=}8uMXwUq&4I=^Rwz0{i~~ D1|n9y literal 0 HcmV?d00001 diff --git a/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/romapi_5410x.h b/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/romapi_5410x.h index e173bd4fb46..68b7e2622ae 100644 --- a/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/romapi_5410x.h +++ b/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_5410x/romapi_5410x.h @@ -63,27 +63,27 @@ extern "C" { * @brief High level ROM API structure */ typedef struct { - const uint32_t reserved_usb; /*!< Reserved */ - const uint32_t reserved_clib; /*!< Reserved */ - const uint32_t reserved_can; /*!< Reserved */ - const PWRD_API_T *pPWRD; /*!< Power API function table base address */ - const uint32_t reserved_div; /*!< Reserved */ - const uint32_t reserved_i2cd; /*!< Reserved */ - const uint32_t reserved_dmad; /*!< Reserved */ - const uint32_t reserved_spid; /*!< Reserved */ - const uint32_t reserved_adcd; /*!< Reserved */ - const uint32_t reserved_uartd; /*!< Reserved */ - const uint32_t reserved_vfifo; /*!< Reserved */ - const uint32_t reserved_usart; /*!< Reserved */ - /* v2 drivers - only present in some LPC5410x devices */ - const ROM_I2CMD_API_T *pI2CMD; /*!< v2 I2C master only driver API function table base address */ - const ROM_I2CSD_API_T *pI2CSD; /*!< v2 I2C slave only driver API function table base address */ - const ROM_I2CMOND_API_T *pI2CMOND; /*!< v2 I2C bus monitor driver API function table base address */ - const ROM_SPIMD_API_T *pSPIMD; /*!< v2 SPI master only driver API function table base address */ - const ROM_SPISD_API_T *pSPISD; /*!< v2 SPI slave only driver API function table base address */ - const ROM_DMAALTD_API_T *pDMAALT; /*!< v2 abstract DMA driver API function table base address */ - const ROM_ADC_API_T *pADCALT; /*!< v2 ADC driver API function table base address */ - const ROM_UART_API_T *pUARTALT; /*!< v2 UART driver API function table base address */ + const uint32_t reserved_usb; /*!< Reserved */ + const uint32_t reserved_clib; /*!< Reserved */ + const uint32_t reserved_can; /*!< Reserved */ + const PWRD_API_T *pPWRD; /*!< Power API function table base address */ + const uint32_t reserved_div; /*!< Reserved */ + const uint32_t reserved_i2cd; /*!< Reserved */ + const uint32_t reserved_dmad; /*!< Reserved */ + const uint32_t reserved_spid; /*!< Reserved */ + const uint32_t reserved_adcd; /*!< Reserved */ + const uint32_t reserved_uartd; /*!< Reserved */ + const uint32_t reserved_vfifo; /*!< Reserved */ + const uint32_t reserved_usart; /*!< Reserved */ + /* v2 drivers - only present in some LPC5410x devices */ + const ROM_I2CMD_API_T *pI2CMD; /*!< v2 I2C master only driver API function table base address */ + const ROM_I2CSD_API_T *pI2CSD; /*!< v2 I2C slave only driver API function table base address */ + const ROM_I2CMOND_API_T *pI2CMOND; /*!< v2 I2C bus monitor driver API function table base address */ + const ROM_SPIMD_API_T *pSPIMD; /*!< v2 SPI master only driver API function table base address */ + const ROM_SPISD_API_T *pSPISD; /*!< v2 SPI slave only driver API function table base address */ + const ROM_DMAALTD_API_T *pDMAALT; /*!< v2 abstract DMA driver API function table base address */ + const ROM_ADC_API_T *pADCALT; /*!< v2 ADC driver API function table base address */ + const ROM_UART_API_T *pUARTALT; /*!< v2 UART driver API function table base address */ } LPC_ROM_API_T; /* Pointer to ROM API function address */ @@ -123,9 +123,9 @@ typedef struct { /** * @brief LPC5410x IAP_ENTRY API function type */ -static INLINE void iap_entry(unsigned int cmd_param[5], unsigned int status_result[4]) +static INLINE void iap_entry(uint32_t cmd_param[5], uint32_t status_result[4]) { - ((IAP_ENTRY_T) IAP_ENTRY_LOCATION)(cmd_param, status_result); + ((IAP_ENTRY_T) IAP_ENTRY_LOCATION)(cmd_param, status_result); } /** diff --git a/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_common/iap.h b/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_common/iap.h index a90e87c9b7b..78b167f1e8b 100644 --- a/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_common/iap.h +++ b/bsp/nxp/lpc/lpc5410x/Libraries/lpc_chip/chip_common/iap.h @@ -78,7 +78,7 @@ extern "C" { #define IAP_CRP_ENABLED 19 /*!< Code read protection enabled */ /* IAP_ENTRY API function type */ -typedef void (*IAP_ENTRY_T)(unsigned int[5], unsigned int[4]); +typedef void (*IAP_ENTRY_T)(uint32_t[5], uint32_t[4]); /** * @brief Prepare sector for write operation diff --git a/bsp/nxp/lpc/lpc5410x/applications/board.h b/bsp/nxp/lpc/lpc5410x/applications/board.h index 03f6a284e79..df35e83732e 100644 --- a/bsp/nxp/lpc/lpc5410x/applications/board.h +++ b/bsp/nxp/lpc/lpc5410x/applications/board.h @@ -25,21 +25,10 @@ #endif // - // #define LPC_EXT_SDRAM_BEGIN 0xA0000000 // #define LPC_EXT_SDRAM_END 0xA2000000 - -// -#define RT_USING_UART0 -// -//#define RT_USING_UART1 -// -#define RT_USING_UART2 -// -#define RT_CONSOLE_DEVICE_NAME "uart0" - // #ifdef __CC_ARM diff --git a/bsp/nxp/lpc/lpc5410x/drivers/drv_uart.c b/bsp/nxp/lpc/lpc5410x/drivers/drv_uart.c index 826e659eb41..6d981161db7 100644 --- a/bsp/nxp/lpc/lpc5410x/drivers/drv_uart.c +++ b/bsp/nxp/lpc/lpc5410x/drivers/drv_uart.c @@ -157,6 +157,7 @@ void UART0_IRQHandler(void) break; default : tmp = LPC_USART0->INTSTAT; + RT_UNUSED(tmp); break; } /* leave interrupt */ diff --git a/bsp/nxp/lpc/lpc54114-lite/Libraries/devices/LPC54114/arm/keil_lib_power.lib b/bsp/nxp/lpc/lpc54114-lite/Libraries/devices/LPC54114/arm/keil_lib_power.lib new file mode 100644 index 0000000000000000000000000000000000000000..304a63f82f273711d3af451b7019f516a2ca7bfa GIT binary patch literal 9650 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 literal 0 HcmV?d00001 diff --git a/bsp/nxp/lpc/lpc54114-lite/Libraries/devices/LPC54114/gcc/libpower_cm4_hardabi.a b/bsp/nxp/lpc/lpc54114-lite/Libraries/devices/LPC54114/gcc/libpower_cm4_hardabi.a new file mode 100644 index 0000000000000000000000000000000000000000..1f40c8ccf66f0edc47a20916c951ce8f09acc463 GIT binary patch literal 18500 zcmb_^4SZD9nfJN(&P;|RWD+jQ5I!8fQzVm_B!qx~OeP5g5;7(ssHF}enLspO%?F~j zmVHH+y4Y2zA62Z@wN_i(wQfbXYNgtu)m=-~cIlVxR=c{cwp6XMRm=YW=RSAllH%{( z_t*FSnEOA^$9bM}p7VL{Jz>tuu95B?tMe-&CtvZUvFc?@Yhue{kqG|b^4=qn`0`50 zur*&Pm8X>9`>0>4b#p^ox?ylEGt%Cl$qXwGqaO4rnW>?RGb8mw7Y};1HM3=?CnL=E z%vk48|5(@dOykf<<4ER{Iezod#ajE6^0k?<=Duy6nUT@Hp+VI<+Mgb#yL5lww&+lW zTlbpfC)YY2i`CTBpzgKtS|=J?^FPzj+-MjELf~A6DpNU1sc$7T-(RhvOwCnu)aZl1 zf4lgqk%KeW&uX#zW;G{|`7FDu_1NyDf6WWWi%*|(ENB!a=fCdvJ$YO;wjNv4@#OLO zjl1VRc|4McJ&t>w!hKDm^_YUBy75Wmc`}gqqTM%7Te|A);=Shm!;h(X#(v}0d1t+Kzwy+}D*ted?Y# zUL45TeE-CWr;IZH5%UGJEO2CaEi67>+&I0_i;O~e{q&|MkH;2Te^gZkbNAMrzx9@_ zrCrw1z}(WUKifLIc1qLUI^$^G-1lBB(W&6vw_XkD)TFs@zFMSH`Ey@;wGgS_{*?FM z{Ip>GwRN9=ym0Ph*tliu&tFAntyMD~QmSUqQ0FW#RsSzc^|$*ib?17Ydd%>vqYwM@ zHx#VDxlXsskx8&J=?F_TymrmI9mRpBU=Lctp;Cw}Z25{|lXjH3ru7{aLnPJnQP=)-A3XuO%xWlC)-ru zJDMmiPLgbKf zO~gXillZTz-_2KE1=_5pb8kK0OPaL zWg4n*3DN~*Cy#i$~tALpi#0AkqiCauT;=1VXsl4`{5*Ll`yX_^a>?DEh!E?LWy5znHs7` zeS!fkSra-;NnQ!dUmq$*M+pYCWL;<()h218IrJl{<(JgJXDU=jqM)P^a45u_!NQV% z0X!Yzpbkzh*#P25=v7LJN?5g{_H`Iu!B7cXW^89Ysw@R(uSl%1|?|BhjQ0Sy?O=J+%1{qzua z{F(LvmSwu*&$KtvL#gA>v@fO28IC{G{u=YmEa{{_(>_d_v$Vh6rv2{>)@)7f0Y&d; zXlk!%Kg4_y9o2oN-9vwKwCq~bev-1ex}2Xk?JF@HgY&fP4%0r3-sfxTF4Hb&$rfnp z9@G9CdS9q*-e=nPP`0Rqlgs_4{S(?OD`BrXV%lG%m5=Fszc%e_m~XMp_ljwMmYQd3 z*=wf#1idfO)ElOKjIwfV<(O&zhE!C`lx05(N5KkBVOg$W8^uc4tAmz(Ga;^JyDd9F zf0dfrW7%J&hbrAY_FDE?ELpXdU2ECrGcHRt^?A!~rj;5^-E7$hnQxgc^#RLXOU+s> zyTh{olU9~%*LV75nTkH51z3RGawZq(F1zx@_V-Kwc;{q`qWmXxMG@3*g}m2*n2 zLOE~t+n=GV%^5iX`$o#zb(DeuyN%vEw5&K_-$~gfEei+iyBYaTXH*63Z&0>b%gO@w zFIb0jwJa8}zfIYBB{#xfZNPq?6V>@zwmV=SrtIT-H0}-9=d+h@(Xu-N_Vbi|Ld)(6 z*j23G1zL6}V829Jy5w%yd^%wN5D?s|>$f}4Ud*_3l^g_fPo6!{56p2mEuf?ZglA(hwgOg zuQ+tCOD}Wioi5$#&{w(i&mH|Nt$_e4>it9lmd zYf2evqnhdZ(t7GFWqMudZ1QWEZY~{yOJf<+snQf})-v5uT8CN~%b7mc*%8o{ZX%y5 zV9E40fj%|UR0Z7G=D$x9D^?;oEgvQKar0KAK;PX7BjGr84hDBMQM?Z%7H=F{k!aqipjc`AzV1_%u zux3;vjSHC%p{T~M-b3bD+%RI}d`OEB44`pf_PvanA0liLHRlg7d`2F1{aM|}k4oSN zVt7)|hXaUU}tFhW=rbTOYb4v~{uun4(PFnt+EjFpp7q}AZ< z1ZPea5?50cq1x$4u+GMhjBZ!$i=egI14uY(ETdL?-niOTJM60cEUU)qXtf_3-*nY} z=c<`3w01h%ReRew>Z+X%sdlmH7*^x3U6iAwzz7?jYpw2 zkF8KRk4+%%wz>*`HePn^1Q0@PrVLv*MjR5;L% z{&2=09WE!qD74O)g-#BwUqE9A=tady9L8-C8@7~*2olVyW}m?xcCWU$1hjF0a>v5G z+QJc7DC@$__?qrBSFf;h9eW zNW-w2^dS77xgH#jP83KP-!K-ofo9)9pp@|~V@VqH!mB;ZNzWKdZUT*K_9L)m+~%pq zm$TKlO;_VM9F-4K>vn@OzniQX--wChPk&#Iar>7`RgF7FjD3i?&tW& z)uazfD~vWPAH|Q&htA}a@~OZf@E$}SJ&m7GaoVmV6AxD8&;A;cc$q{Fhmdig3ZuQu z&-w2LC&b%FKWCfQ_3MUZgRvY&w{bVi<s(s+|l82q)jusG0dGCm$nGb{$-qpLV2YHRpl& zthMS}C<}l2bCgkHEGV)ItfCo3o2Hc*#nYfMUlkOr1`CChBwYBal~uH&;H-is`|Rl} zr=t%G!|yTzhS6jjcz(&7gDM0=u+ju-(rIcD)bmfz=Et(XR8ds8P{ZUofC?0}$TkWJ z;KNTVp~+4L*sq1G7-Wz#hb$3uAeEYed;vF~?a7C2`cw~zu$`uTfq%MAfHTc!SVb%< zD@VuSGB}5c(CB~G%n($3^sQT=v zk&|TkbajS5TSpU-kIXXSI^($o=jj;C@vFE^$y`d>j7`%h!Q@UpozC|d!2G(vt40S4 zy%sU`e)j(us>HaVZh9QTvRn&dC>5Y9OhJVfSHm_2(kuWuj>jeRh)FD$#e}~o>>*oR zH+#j^Fm8sgtAikxb+n&k{4`_Hbe5;muUot-ikP#(7EM1X9@QT6sP$5i(&qG5!;&$v zESEi^8>coG28=+F7A%_XNLPqdcgM4$(hn)cNXwaOvK{qRY{-?<2aBBk&hdy#PnIf0 zScsoby=|m!XKFEihDs4uW(7#-3x(A=O;vfju=FO3W=s`71uvH6aW--GOlO^fm&;2X z`Y}~bFULFCZ|MX*=5u(}SsyH$vu&z51us`V>O}DK`pxljdeoV(^;Tu=<#<(D9wQjl zddp71%h}`Zs#fdOX7zHsoZf2a)M>rtS-l)Dr?(C|&023oRxiiP>1~BhkJii8Bgf0> zK}BKeWv3u8#7=KuW3S z43?ofHH}*beq5EEwOA+AUI+9TVUpH)xfs!uQu_os!gyhx%3g&?G0;=-V@=$P{WyXj z2dSG6NqznQ@Y}_;R+XSirtyB!WQC8128`op)UT*$xn%Ru$VC+c-Q(q>Jr|W%=2FpE zMNejDUw3A-qB)gZS{;v9SDf_WQbnT`6aFPz+MC)dng+Z3$MMN@f)M0i80;D8+lh~& zs(Zzj!Ck{!P>fx}Bbm|Bp}w9>Iv$J0qRZ1uD{InS{lh!Dwt%^1Y-p%|bjwJl2cJ&2 z^f{ikj9&8Bn)qK7_7p0^{as_dLn8wfQjd!6p@9K>;GOV=x0})K9vJN#O>gh+j_zRp z%7zjoS_rl29vbZJ+g{!^G60rOsnM|>e3nBRD{1%8NG9DqQ0?SJb;mLTX}4KKfX?=p z9J+A|g{;_DjgF1<4Q_XgVsoTBy7iK2_)IGjvG!da#Wv&TMr6T^1v6I1XSJMF*>d*0 zih1#tm^CR1ozQy7N2AuRs4{(4AfoThyw5iC(Y0KQ`z>0$$PkOyn33~*=3LY7QMt`B z7JO{M`06?3C$aCRE)$!AP8Eil>|+8f$B8|u@QRVtUR_N143(lws+GEchJlU}YG zn>IF}jnkd!6b=HY{^9ga=jcJYKeIE_FDDO1aU!9oSu;9g%a_K~aAu@$ct>WW3k^Ru z(ytl@ySDXb*7gr=>*{Z6JI8yv!8r%f(UwRyB%3$XH+8DEj$~_lGTG7AjJ}la#A%F} zO4YY*+L&xyn`~}Vf8C66^869)R_*7tr<$AFI}#l#(cFRFOUL~~gWDteHaQyqesi{5}!K#=i9rvUwJ!wyCRe4&g z%F|j^p4O^brkdIlZ5{*5l@zgiN7snz<%y8aSS^|%jWTCOM#hK7M$<#Ry=r)*Z=h@R zB2QLNYsZ(XR8wmT)k&n(ruI5%4JSMs>l>07w_RfyCo~L3&(J_u-(Y%7?d+*+9(J1F zIplKkNt47n*H$j7%%AO}o*;Q*E7|d?lGK*8CCTyO-Z*8x?`!@Q@HB5s%u2#rH{x+&=p4%oRH~$luT*p zoX|Ns<5lP~b*=Tfi?t`~(jAu!XVgWhf$=nt1f`v^kWO#UjHOd;O)ZJ`4XUxN;hdHR zodacS-PF87rCWvXjX~# z^EM(=ol~gu+B=dPl8NSA#N%;=+O%~vw6!;MsLqboHsy@{kqj)gWCm1YO18JDL{l41Gt@UC*?4ZUwFPxSMbtoMpnLcd?|hIu8-?6Z&Q3rZTQ@eS zwHr4@lFOGzYNA!qc%(8GUlyyWj77>&mQ2@Z=3|kMC)!#nGHBqQo=i`9P5HKwuEFjd zkrC`7c@(@HRxW@y~8`J%SVUHd*U_Z^bd87m3M9H zTZM7e1IE}6be%}~_DFf_Xrvr#v$9AlWIpS^O zef?v7gCN}QRz8|>x*d2uU1MEddKAlJf2JI}kZxUSSRcgT!Top(W9@(djpJDxJonlN}_^w4+CpGf1dj z-_Y5VY)CiNW14o8ac8v2Ky%K&4d7@U_9xuk+fFC+>Fl?1UEgOil4+Y&4WgYp3h5byTQoRVAvL9jAKYMr9G%TqP5#eI196GqLFG zO&u-iwq14Oy}cQ>QYC^jx&wV!FHQ^-`h~M#VybW9RG+Bll*Xavt!(dhJ#E*zC2vnP zH8w$yVH?S8Psuvrwv`(08Nn=xTsyn^G4GEfFseRPzd5m?fxReKK~4Y(wraf-zTA?} z(n(32*1|Eyk2tRAOl!KroQ0bHRDA^gMjT094 zFui?)nF$*iCydz!;rf*8<1M<6qjk`IvvZxE4V|f++Y~*@lBon{xyCl^Q*_L;C5^}2 z<#MoVAd~G->9}W=i+eT#@oKehGsEjqtzkVonlL@fKFM99;vsEs-Nn%;Nd0BseB810+$PS-ej+Bo-h$Ql}mBo(?2|+Q0v&k z-LA=5BHP83JCZo!@DMrPk5TRp_r#`-*5q2OpV@9vnVV74m2r0i!n|s2GPxpB#`Ug) zPn!`u;zh8wMH*yni=;+|@LW7PG%^~gDd$R9{>jSn@nNhbSO)*v_0joKc>)*SQ(jh7 zI9b0QkT(MQRYamFyvKK?b(Q%!V^aNj-P?``_bB z626jfFY0*d$OL-d1e&iZy!w3Ak*LM3D}z;A8Brwt*z<6WZ>d&+$$2f4%>2L<-&Er? zW11BWk3}dD-+c%f*BPL#6o=^SZgjbFyE-#7aXXk~D%e44J?YS&GPUAC-=kn>- zFtox~EGFdhfR|-8@c8YyEIfjroZqkY`6A1?@QCiYa58a%en9K<<&$%HUku^<1r9fz zY(F?bKj>!EXsJmP^zi}9b6Kijg1kW6+mY2_kI7v))j2`GQ0uc#IG4AjS>DML^zkv; zb6I#D$9U$hBK>+x(+I7hU)SZNmf|bK++|I$Zs`|iUO8W)$G|;W)kE!g`=d7;tdob-e&jnHJ z&9Pwqul^3=)XxFAHOgZpw-0cbAGOkb^!~!hck)9j>W2?+2o%Q$-ty@0`X&Nh2zoZ& zx3jfppXtPYcDeIf)r>fDa{&%MF(2?WL43?oCK`MW5k|{|Um>_kuwJl9knezL=M#e4 z1a}L5PH?~Amj&+={HEY{1&<2;QZRrHLHo8~M6g`2OOQv4sP`$sy@EFg-YNKxf-ej5 z5E%1)D436Fk@O9MUlRPfV3Xy@I|aK1d6bFyJ}t=8dZcd>yi4$#g5ME*R`96cZv}Zm zlKJ^olUO7;Q*g0htze^Ihu}6r9!+5W%LVrd-Xh48yObXk{GQw?Dx0~qwI$5g?&f-%9>g3W^b zn+xji5Zo!aNAP;VI|RQW_^9ABf=31aL+~9zj!D|*c}wDK!6kw#1lI|63i5~`^+yDE z3w}=UfFS<_gnADP@-#T<7X^PK$U}JK|5>mQ%OdGg!7{-b!FoZSt)<>p!9l^x1g{pn zS@3SbZwWpjctr3e!8ZhXTAucUScZwG3-Yuo>HK^LLxMa{ME(N7GX*OJ8wAf0{Dfei z;JD!52wo%j1;H;1epB!Q-c1tWrs1(yo0 zA>y0o2BF)C_pWKFNOaHq5mZ4 z!$Skh8787Ua|F*6{@FsW6KoTHuh2t+mk9qFp>GttL-^kn{IT#~5`0bgCbo-=(2sJ%&?|}XlMs3%5&NEYp|=t-*KHU6AQAbm7ra^I{Nm1hPZ8ngIU?qs zUkd%E&>sqxV8cZD9KmWL@|{KWE45zea|OGJDCZ8LuOve62EnfhJ|g%m5&F*)VfR;p z|0VdIpoKP}JR~?nuuQO8@NB^ig6)D^1qTE#7yLWHn+3ltcu??3!Dj`3D2N@39-r72 zXvB1)5lyI3?<+BWX9+!DuuO1;AdhcwoNp9t6Wk`)E4Y)0@x*5X;?;tm6a1p!oq`Vt z9uzz*_>ADs1YZ*To#0!7rs4R}`%w7f31j*#734u<(osPkEhb$j$P>n-I|X^BnDm8$ zJX%cpazP#@CVjo2-nW9jTWFplrksDZLgZm$;&XyLK1}*If;>e``dvXD3ns1ixj>!{ zCOun_2Yos2D+QMet`b};$Umy1UYj8Q+J`g`1{3=QcL`o5xL0tWApcs6`UeE>5xh_E zVZlcQd2E>T!;6By7JNmJ=W#jS`Nv>H{*4}ye~d1Bf0z9|!@YcT9J zpHIac_YorU>wXLWG14e^EfMisLqz{wN5p!_i+nvUfY|P68YVPqyU@oJr1M1t-SMIA zqg>VG1GOKNV|#f(dn*j+wcWad8GUj;UT;5nR0sukz+KRJb%gQ$Ln#| zB0{gC{OFj$mkLj=-VuIZh~iCgv}+9KY_^S$!R-IT#kWqF+Oo&Sswd<{_te)M+^L7| zsjrE8l<`6r)MNGkrndxo6aDU`0l7Htc_r}k>OBg2CIxc2dRsty^^St35BGBQIF2zK z)fy4J7<0xL4+L`VqFxZci}CZ?^MN>(y;~;e#h@1f&%NCE-3W%)?;9S!;fS*_I7a&$rAeUR;{|4>V3!^}+r+c~O3g@B%GZ`}mF8DXUwPoY;o!S9x{ z_(#-^Ul!Ai^X3Wmx-byfH{8qh+djeG5^S_M_p%-+YSte2BW@nr_-EML#e`h0jQbaF zT*hGU5Oiqobo|`%T{gj99GyOMiu&%FV6XaYr*G39LX@?~_j&l2{VzFggu=gavndy4 z{PFK!yn5YdDz#g52(I28qUVZUf!@O|0d%|00qC7nUzBe*du&_P8UOCJYu`Lt+>}S41#a3fQfOSi64Fw@shcJ#NgG<)PQ#ny*f))bU)WA* zH^u^#@){jt2%+)N#Mp!;&=3NKCOVh|Y-7??0h9QHP1&>u+js;~9%38b?>qNg_c$a| zq!F~!UjNST`_BE&ch33F>!xi}vXq**xN*H%pMqV1$OTN63V{hNiL|?vQm9|(`ainlHGKH)2G)u873#}>?C5H=XOBJf6`mM@P zW^9jDDrX9gxm}PIt`@KEDP$|jeb&}OX=};4N*aNFmVCUNO%&OwL^d<#FRZV%y=U&W zZ>TkXwDFsLLt8aXLl@XdqYgU3h^EdI@+A>6k?Ekdto4^C%9T zuaG~JEcr{792%b`f5kcg(O9`GSg3(tvMc10u(U6eA1~PQI*Hw4@X$?pc9glC!Lj{rsDP(#f98e}b=jd-4A4*TLUV^f%P$Poq1*^_t8>_tx^<-qYzv3gCiBp5YI)Y5NxuU>P?LG+FSR`D&!+dmuhAWcJ@iSPzKxbbcTCZptb*~q`9@DAi(S9lQlX@ze@{!a>zA^(QLhme0$;k%KaQTSJoKd$h7$bY2pBJ%%I z_(9IQPPF%WaJRy512+_Y7kIP6?+5oO{Df2#hxI=wL~UJbfX z(YK(Rw}GFJm|2Z{3+7u2+y%~ajQIg@o^$IYza9K<$e$tk1K@plc)j8Bk0bvLv~j28 zFM}V%`))j}r!5=f!w2^kN>|2nsmacA`pVAGiJU(WPh0ylDXSbG8i{p9g270gXM~qE4Q~}v7gLZ#CxRJlj<_|%Hp2%khLGXjBN)ZM<8~A?z$}{7@&6SM7%vDBK4ZE z6nE8&K}G3Vb}o=&pt55HH%M_$oj4SfVyKnUA*V`sRVVMF_OyH>h*#BDoO*+ydbv|^ z5H^+aVW;L`eQU$Ds-5-)(LmAAV66%?!j?G3L-12bY7Gj(4O`+E451=h;#dwjmP3x^ zkYhRISPnauYYvAU%QaWSj^(gpIqX;tJC?(a<*;Kp;#iJ2T@i6CM;xCcvpNU%Ij~P0 zQ+g2UNh>*)N#v|ts(5gAbpGER32Cr*r`fxG*Pt0&A3OhiGginIGg+%-?&$p0g#+DzcyF<|C0R+vhYG1=Hh#I4E5`fw zZr%{=@mF$1v*WW}P0Y?MW^BjKzQk}uWJh)$yYLS|>d{2!gdxW`dToX5W~St(9d;ycE^ic0f^M5=7rnaO;qkj>ip zOg@{*OL+>X-9)ZX!C~H3R>qP^`EGU+t7IvY-)Hl3YQn;5X>%)&Cgm^6W-65|n@SZY zFNzgPm`0u487vxyXwTM>{gFhu2%5%8Kancr$20rP)fl#sQehvC%;r`Ma@p)S(9^v( z&LObNUYp~6xiKr9w$dgq{$o}?HDUJn1D$<)G4h=vB*F-Z?ye1;y+b1dz42rz7a!an zi>KmSa6w7LL`{k9g;Fk=^-rueI|o0jj`sWG_W#AOnJ#7ab38AGZQJW&Hd(<8%Eg_k z_ySbOFJg_c;a!8f;)D5Ab~0_Do*mh>Se@*F##oh-rGvzS2BC-&?f|}BcGElW`KC%w z75k^&^W9wRuMW_}$c&q+gT`pFfBDQwT6Npzk4#^&Kk$TppX+|#j7GQ6@)@^g#9FkL z8K3Tp-K(vbiMm>2?fS{brz&RbQT>$TQL7`yHUiHS`*FN`0<~OMdaAmuWn$-yTd!Vv z#wh2jm#&CahuqQc$HFs)t2(r1G%*w1#W=Nwe*@3jND>n>B($L!L)duE)9_m|=?>R4 zJxljQSJ54GPkYBluW%~@+=^|!(d*EzO-y70q&!wHqB&xQ=2Z)EwDOpXtVLMr;P;j zw7CSPrfs=b%Dqy)SIP}3H>CVhDQ}SS1}VQp${VG;QOd(o-X!HsQhx3{@|8l~{BpA_ z-z;0vEZ=LIUMe+9rDmzr_>R((H#}Ayym_IiwsKlGwL3J7sJ2F1t;zT7Uh+-5 z=GE!&fqT+>6jzP6Xc`yBXcUjnL(%s?tbTmQAA)=yj<(}5H9R^+qreC_$@I@^^%uB- z_XHr*R{n&v?!2a5c8;!PU)QypzT?s!+~(GfYD=`&o?b%G6Xb3m^_VE1I8FhMbK=84 z{>}Ys2)X?$%ILTj`E-8A1+f1!F?6#3vmN9Z>~hF_5w%p2T%=#KtYs-Kyk5<#dtHXx zSYmh#uVEMsMx)W>Z8ny9r*!Xiy7zkBdxP#hq0!U{$wzUM{lyP?>c`G;{?Rb0rv;{ih-#EACQ*VpD6g-21G*1*BM$) zw1N@eKw23=PG>{~XEB~axKtzITGGyV8qqn7m*N`Fh{ESH4ibeK(a#Y^e3R&69I!u? zus;_uhaXW!+-!OoQORb;ZQ@m77g=F%m=W)9XEcd+FoImp2!D4ot|r>Uh{9Je!tXdE zjDDGMi0Jbg6TZ@o;?eQFCe4VB{=DkuPeh__pR60>{CU;QaVhFXK#6uErWUjAR@CPt z{tVZ<;@U&{joK9}==m2$!S$1+ABg3}^y5^=3E&|-?1!dD;l?PK4z=hF%%H{eLR}U3 zBZH_LT_ozpY+cN{VZN3+kn3G>%^~-VuEY8fZ4^|8Kf(odN;ut@o9jx5VA2`tpl{Ac6%ewQtxns-soAXE!SGy zt=j3@8LpMuD%WaloyH-LizaDUU`f|;($*XGWg4%)P3=UyCNP?eUm*Gtg6JN`PNMHI`iUN9Tu<~EV}R&sM%a0k5%s<<@okA8 zNNh$pG~t-l!iYwn3T(t)eTL+#q&~oMH;F$hG@|o1vK$+Glo9o8Wj*%rI3vyg(KC`iFYzUo_n@7Uzb^5Q zEZ=}n>XILq_%X||Ik-dMah53$OkDGq74s!+Sk3{ zn$F2Bes%YMOFB%Ta$!Oo{xH1aZ(JBgasJ~u!sk9V%jZ3~Db9Ilt~lS}RdJqcV#E?A z=9ekYk*npOrx1HQBM32%BM1>&jELP;jEG4r>*BBpm&9RHoKq1~CUeA48zW){E)pR|)-WO_;3^Sf z;2cJbIb0TpQ@BioF@wuQ7&Evm4y$k(i-tVsZe~)S5bkp(4N?qOEpfSD)!2y)_p2Bq zDf%}M*JJT+zm##G^75|QdkX{j4^<$`azAn1PI?Uk`Su*;xF6JVFXFr^`oeipBD!9b z6LEt4n<&SB25}Nx6$xD~V#iT+a{xF>C5tYvtC!0u#cKJXS>-mO+!$oDQyc=d9rvLe zueY;P1_E?NEg1+*?pN-65#vCP{jcFs%eA6hD=Oe}j-1QQt~Y=IT1dV3p`24Mx>BUM z>^-tTd##vIjy*94VR0^d9VoXD|L#)k@ep#F%icpMcfeNH{m$;^Rha0Ge;mV{=CZdA z<@Vd^y5HIM9#rg!HDn%pk3+eT_MU|W$nj6CLG#%2qukYXp4nu!e?L&{i8X8v4+lL?5mYtikixi=td*0rs9y?6t}A zbH&T^D7TRD4PX!)|JEq>jv$YExample * @code {.c} - * #define ADC_DEV_NAME "adc1" - * #define ADC_DEV_CHANNEL 5 - * #define REFER_VOLTAGE 330 - * #define CONVERT_BITS (1 << 12) - * + * #define ADC_DEV_NAME "adc1" + * #define ADC_DEV_CHANNEL 5 + * #define REFER_VOLTAGE 330 + * #define CONVERT_BITS (1 << 12) + * * static int adc_vol_sample(int argc, char *argv[]) * { * rt_adc_device_t adc_dev; * rt_uint32_t value, vol; - * + * * rt_err_t ret = RT_EOK; - * + * * adc_dev = (rt_adc_device_t)rt_device_find(ADC_DEV_NAME); * if (adc_dev == RT_NULL) * { * rt_kprintf("adc sample run failed! can't find %s device!\n", ADC_DEV_NAME); - * return RT_ERROR; + * return -RT_ERROR; * } - * + * * ret = rt_adc_enable(adc_dev, ADC_DEV_CHANNEL); - * + * * value = rt_adc_read(adc_dev, ADC_DEV_CHANNEL); * rt_kprintf("the value is :%d \n", value); - * + * * vol = value * REFER_VOLTAGE / CONVERT_BITS; * rt_kprintf("the voltage is :%d.%02d \n", vol / 100, vol % 100); - * + * * ret = rt_adc_disable(adc_dev, ADC_DEV_CHANNEL); - * + * * return ret; * } * MSH_CMD_EXPORT(adc_vol_sample, adc voltage convert sample); - * + * * @endcode * * @ingroup Drivers diff --git a/components/drivers/include/drivers/dac.h b/components/drivers/include/drivers/dac.h index f3635d50b62..b1360c35887 100644 --- a/components/drivers/include/drivers/dac.h +++ b/components/drivers/include/drivers/dac.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006-2023, RT-Thread Development Team + * Copyright (c) 2006-2024 RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 * @@ -19,47 +19,47 @@ * * Example * @code {.c} - * + * * #include * #include * #include - * #define DAC_DEV_NAME "dac1" - * #define DAC_DEV_CHANNEL 1 - * #define REFER_VOLTAGE 330 - * #define CONVERT_BITS (1 << 12) - * + * #define DAC_DEV_NAME "dac1" + * #define DAC_DEV_CHANNEL 1 + * #define REFER_VOLTAGE 330 + * #define CONVERT_BITS (1 << 12) + * * static int dac_vol_sample(int argc, char *argv[]) * { * rt_dac_device_t dac_dev; * rt_uint32_t value, vol; * rt_err_t ret = RT_EOK; - * + * * dac_dev = (rt_dac_device_t)rt_device_find(DAC_DEV_NAME); * if (dac_dev == RT_NULL) * { * rt_kprintf("dac sample run failed! can't find %s device!\n", DAC_DEV_NAME); - * return RT_ERROR; + * return -RT_ERROR; * } - * + * * ret = rt_dac_enable(dac_dev, DAC_DEV_CHANNEL); - * + * * value = atoi(argv[1]); * rt_dac_write(dac_dev, DAC_DEV_NAME, DAC_DEV_CHANNEL, value); * rt_kprintf("the value is :%d \n", value); - * + * * vol = value * REFER_VOLTAGE / CONVERT_BITS; * rt_kprintf("the voltage is :%d.%02d \n", vol / 100, vol % 100); - * + * * rt_thread_mdelay(500); - * + * * ret = rt_dac_disable(dac_dev, DAC_DEV_CHANNEL); - * + * * return ret; * } * MSH_CMD_EXPORT(dac_vol_sample, dac voltage convert sample); - * + * * @endcode - * + * * @ingroup Drivers */ @@ -80,7 +80,7 @@ struct rt_dac_ops }; /** * @brief DAC device structure - * + * */ struct rt_dac_device {