From ac18ffe01599aa538452e10ef048120aa417a9f9 Mon Sep 17 00:00:00 2001 From: Jeremy Brodt Date: Mon, 8 Aug 2016 16:20:41 -0500 Subject: [PATCH] Initial release. --- hal/targets.json | 9 + .../TOOLCHAIN_ARM_STD/MAX32620.sct | 22 + .../TOOLCHAIN_ARM_STD/startup_MAX32620.S | 262 +++++ .../TARGET_MAX32620/TOOLCHAIN_ARM_STD/sys.cpp | 57 ++ .../TOOLCHAIN_GCC_ARM/max32620.ld | 176 ++++ .../TOOLCHAIN_GCC_ARM/startup_max32620.S | 269 +++++ .../TOOLCHAIN_IAR/MAX32620.icf | 29 + .../TOOLCHAIN_IAR/startup_MAX32620.S | 401 ++++++++ .../TARGET_Maxim/TARGET_MAX32620/adc_regs.h | 252 +++++ .../TARGET_Maxim/TARGET_MAX32620/aes_regs.h | 163 +++ .../TARGET_MAX32620/clkman_regs.h | 426 ++++++++ .../TARGET_Maxim/TARGET_MAX32620/cmsis.h | 40 + .../TARGET_Maxim/TARGET_MAX32620/cmsis_nvic.c | 65 ++ .../TARGET_Maxim/TARGET_MAX32620/cmsis_nvic.h | 53 + .../TARGET_Maxim/TARGET_MAX32620/crc_regs.h | 106 ++ .../TARGET_Maxim/TARGET_MAX32620/flc_regs.h | 224 +++++ .../TARGET_Maxim/TARGET_MAX32620/gpio_regs.h | 638 ++++++++++++ .../TARGET_Maxim/TARGET_MAX32620/i2cm_regs.h | 205 ++++ .../TARGET_Maxim/TARGET_MAX32620/i2cs_regs.h | 242 +++++ .../TARGET_Maxim/TARGET_MAX32620/icc_regs.h | 112 +++ .../TARGET_Maxim/TARGET_MAX32620/ioman_regs.h | 940 ++++++++++++++++++ .../TARGET_Maxim/TARGET_MAX32620/maa_regs.h | 161 +++ .../TARGET_Maxim/TARGET_MAX32620/max32620.h | 766 ++++++++++++++ .../TARGET_Maxim/TARGET_MAX32620/owm_regs.h | 153 +++ .../TARGET_Maxim/TARGET_MAX32620/pmu_regs.h | 148 +++ .../TARGET_Maxim/TARGET_MAX32620/pt_regs.h | 314 ++++++ .../TARGET_MAX32620/pwrman_regs.h | 371 +++++++ .../TARGET_MAX32620/pwrseq_regs.h | 322 ++++++ .../TARGET_Maxim/TARGET_MAX32620/rtc_regs.h | 241 +++++ .../TARGET_Maxim/TARGET_MAX32620/spi_regs.h | 243 +++++ .../TARGET_Maxim/TARGET_MAX32620/spib_regs.h | 238 +++++ .../TARGET_Maxim/TARGET_MAX32620/spix_regs.h | 201 ++++ .../TARGET_MAX32620/system_max32620.c | 213 ++++ .../TARGET_MAX32620/system_max32620.h | 78 ++ .../TARGET_Maxim/TARGET_MAX32620/tmr_regs.h | 203 ++++ .../TARGET_Maxim/TARGET_MAX32620/tpu_regs.h | 98 ++ .../TARGET_Maxim/TARGET_MAX32620/trim_regs.h | 106 ++ .../TARGET_Maxim/TARGET_MAX32620/uart_regs.h | 226 +++++ .../TARGET_Maxim/TARGET_MAX32620/usb_regs.h | 296 ++++++ .../TARGET_Maxim/TARGET_MAX32620/wdt_regs.h | 238 +++++ .../TARGET_MAX32620/PeripheralPins.c | 186 ++++ .../TARGET_MAX32620/PeripheralPins.h | 63 ++ .../TARGET_Maxim/TARGET_MAX32620/PortNames.h | 54 + .../TARGET_MAX32620HSP/PeripheralNames.h | 90 ++ .../TARGET_MAX32620HSP/PinNames.h | 212 ++++ .../TARGET_MAX32620HSP/low_level_init.c | 51 + .../TOOLCHAIN_GCC_ARM/libexactLE.a | Bin 0 -> 970456 bytes .../TARGET_MAX32620/analogin_api.c | 146 +++ .../hal/TARGET_Maxim/TARGET_MAX32620/device.h | 40 + .../TARGET_Maxim/TARGET_MAX32620/gpio_api.c | 101 ++ .../TARGET_MAX32620/gpio_irq_api.c | 286 ++++++ .../TARGET_MAX32620/gpio_object.h | 71 ++ .../TARGET_Maxim/TARGET_MAX32620/i2c_api.c | 432 ++++++++ .../TARGET_Maxim/TARGET_MAX32620/objects.h | 126 +++ .../hal/TARGET_Maxim/TARGET_MAX32620/pinmap.c | 117 +++ .../TARGET_Maxim/TARGET_MAX32620/port_api.c | 95 ++ .../TARGET_Maxim/TARGET_MAX32620/pwmout_api.c | 211 ++++ .../TARGET_Maxim/TARGET_MAX32620/rtc_api.c | 303 ++++++ .../TARGET_Maxim/TARGET_MAX32620/serial_api.c | 508 ++++++++++ .../hal/TARGET_Maxim/TARGET_MAX32620/sleep.c | 157 +++ .../TARGET_Maxim/TARGET_MAX32620/spi_api.c | 562 +++++++++++ .../TARGET_MAX32620/spi_multi_api.h | 67 ++ .../TARGET_Maxim/TARGET_MAX32620/us_ticker.c | 291 ++++++ .../USBDevice/USBDevice/USBHAL_Maxim.cpp | 19 +- tools/build_travis.py | 1 + tools/export/gccarm.py | 1 + tools/export_test.py | 3 + 67 files changed, 13495 insertions(+), 5 deletions(-) create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_ARM_STD/MAX32620.sct create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_ARM_STD/startup_MAX32620.S create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_ARM_STD/sys.cpp create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_GCC_ARM/max32620.ld create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_GCC_ARM/startup_max32620.S create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_IAR/MAX32620.icf create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_IAR/startup_MAX32620.S create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/adc_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/aes_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/clkman_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/cmsis.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/cmsis_nvic.c create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/cmsis_nvic.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/crc_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/flc_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/gpio_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/i2cm_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/i2cs_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/icc_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/ioman_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/maa_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/max32620.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/owm_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pmu_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pt_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pwrman_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pwrseq_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/rtc_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/spi_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/spib_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/spix_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/system_max32620.c create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/system_max32620.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/tmr_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/tpu_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/trim_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/uart_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/usb_regs.h create mode 100644 hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/wdt_regs.h create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/PeripheralPins.c create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/PeripheralPins.h create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/PortNames.h create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/TARGET_MAX32620HSP/PeripheralNames.h create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/TARGET_MAX32620HSP/PinNames.h create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/TARGET_MAX32620HSP/low_level_init.c create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_GCC_ARM/libexactLE.a create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/analogin_api.c create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/device.h create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/gpio_api.c create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/gpio_irq_api.c create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/gpio_object.h create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/i2c_api.c create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/objects.h create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/pinmap.c create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/port_api.c create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/pwmout_api.c create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/rtc_api.c create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/serial_api.c create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/sleep.c create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/spi_api.c create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/spi_multi_api.h create mode 100644 hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/us_ticker.c diff --git a/hal/targets.json b/hal/targets.json index 2327109906..31aa44b2e2 100644 --- a/hal/targets.json +++ b/hal/targets.json @@ -1710,6 +1710,15 @@ "device_has": ["ANALOGIN", "ANALOGOUT", "ERROR_PATTERN", "I2C", "INTERRUPTIN", "LOWPOWERTIMER", "PORTIN", "PORTINOUT", "PORTOUT", "PWMOUT", "RTC", "SERIAL", "SERIAL_FC", "SLEEP", "SPI", "STDIO_MESSAGES"], "release_versions": ["2", "5"] }, + "MAX32620HSP": { + "inherits": ["Target"], + "core": "Cortex-M4F", + "extra_labels": ["Maxim", "MAX32620"], + "supported_toolchains": ["GCC_ARM", "IAR", "ARM"], + "progen": {"target": "max32620hsp"}, + "device_has": ["ANALOGIN", "ERROR_PATTERN", "I2C", "INTERRUPTIN", "LOWPOWERTIMER", "PORTIN", "PORTINOUT", "PORTOUT", "PWMOUT", "RTC", "SERIAL", "SERIAL_FC", "SLEEP", "SPI", "SPI_ASYNCH", "STDIO_MESSAGES"], + "release_versions": ["2", "5"] + }, "EFM32GG_STK3700": { "inherits": ["Target"], "core": "Cortex-M3", diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_ARM_STD/MAX32620.sct b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_ARM_STD/MAX32620.sct new file mode 100644 index 0000000000..9be03baf11 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_ARM_STD/MAX32620.sct @@ -0,0 +1,22 @@ +; MAX32620 +; 2MB FLASH (0x200000) @ 0x000000000 +; 256KB RAM (0x40000) @ 0x20000000 + + + +; MAX32620: 2MB FLASH (0x200000) + 256KB RAM (0x40000) + +LR_IROM1 0x00000000 0x200000 { ; load region size_region + ER_IROM1 0x00000000 0x200000 { ; load address = execution address + *.o (RESET, +First) + *(InRoot$$Sections) + .ANY (+RO) + } + + ; [RAM] Vector table dynamic copy: 65 vectors * 4 bytes = 260 (0x104) + 4 + ; for 8 byte alignment + RW_IRAM1 (0x20000000+0x108) (0x40000-0x108) { ; RW data + .ANY (+RW +ZI) + } + +} diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_ARM_STD/startup_MAX32620.S b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_ARM_STD/startup_MAX32620.S new file mode 100644 index 0000000000..c9742a0eac --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_ARM_STD/startup_MAX32620.S @@ -0,0 +1,262 @@ +;******************************************************************************* +; Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. +; +; Permission is hereby granted, free of charge, to any person obtaining a +; copy of this software and associated documentation files (the "Software"), +; to deal in the Software without restriction, including without limitation +; the rights to use, copy, modify, merge, publish, distribute, sublicense, +; and/or sell copies of the Software, and to permit persons to whom the +; Software is furnished to do so, subject to the following conditions: +; +; The above copyright notice and this permission notice shall be included +; in all copies or substantial portions of the Software. +; +; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +; OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +; IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES +; OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +; ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +; OTHER DEALINGS IN THE SOFTWARE. +; +; Except as contained in this notice, the name of Maxim Integrated +; Products, Inc. shall not be used except as stated in the Maxim Integrated +; Products, Inc. Branding Policy. +; +; The mere transfer of this software does not imply any licenses +; of trade secrets, proprietary technology, copyrights, patents, +; trademarks, maskwork rights, or any other form of intellectual +; property whatsoever. Maxim Integrated Products, Inc. retains all +; ownership rights. +;******************************************************************************* + +__initial_sp EQU 0x20040000 ; Top of RAM + + PRESERVE8 + THUMB + + +; Vector Table Mapped to Address 0 at Reset + + AREA RESET, DATA, READONLY + EXPORT __Vectors + EXPORT __Vectors_End + EXPORT __Vectors_Size + +__Vectors DCD __initial_sp ; Top of Stack + DCD Reset_Handler ; Reset Handler + DCD NMI_Handler ; NMI Handler + DCD HardFault_Handler ; Hard Fault Handler + DCD DefaultIRQ_Handler ; MPU Fault Handler + DCD DefaultIRQ_Handler ; Bus Fault Handler + DCD DefaultIRQ_Handler ; Usage Fault Handler + DCD 0 ; Reserved + DCD 0 ; Reserved + DCD 0 ; Reserved + DCD 0 ; Reserved + DCD DefaultIRQ_Handler ; SVCall Handler + DCD DebugMon_Handler ; Debug Monitor Handler + DCD 0 ; Reserved + DCD DefaultIRQ_Handler ; PendSV Handler + DCD SysTick_IRQHandler ; SysTick Handler + + ; Maxim 32620 Externals interrupts + DCD CLKMAN_IRQHandler /* 16:01 CLKMAN */ + DCD PWRMAN_IRQHandler /* 17:02 PWRMAN */ + DCD FLC_IRQHandler /* 18:03 Flash Controller */ + DCD RTC0_IRQHandler /* 19:04 RTC INT0 */ + DCD RTC1_IRQHandler /* 20:05 RTC INT1 */ + DCD RTC2_IRQHandler /* 21:06 RTC INT2 */ + DCD RTC3_IRQHandler /* 22:07 RTC INT3 */ + DCD PMU_IRQHandler /* 23:08 PMU */ + DCD USB_IRQHandler /* 24:09 USB */ + DCD AES_IRQHandler /* 25:10 AES */ + DCD MAA_IRQHandler /* 26:11 MAA */ + DCD WDT0_IRQHandler /* 27:12 WATCHDOG0 */ + DCD WDT0_P_IRQHandler /* 28:13 WATCHDOG0 PRE-WINDOW */ + DCD WDT1_IRQHandler /* 29:14 WATCHDOG1 */ + DCD WDT1_P_IRQHandler /* 30:15 WATCHDOG1 PRE-WINDOW */ + DCD GPIO_P0_IRQHandler /* 31:16 GPIO Port 0 */ + DCD GPIO_P1_IRQHandler /* 32:17 GPIO Port 1 */ + DCD GPIO_P2_IRQHandler /* 33:18 GPIO Port 2 */ + DCD GPIO_P3_IRQHandler /* 34:19 GPIO Port 3 */ + DCD GPIO_P4_IRQHandler /* 35:20 GPIO Port 4 */ + DCD GPIO_P5_IRQHandler /* 36:21 GPIO Port 5 */ + DCD GPIO_P6_IRQHandler /* 37:22 GPIO Port 6 */ + DCD TMR0_IRQHandler /* 38:23 Timer32-0 */ + DCD TMR16_0_IRQHandler /* 39:24 Timer16-s0 */ + DCD TMR1_IRQHandler /* 40:25 Timer32-1 */ + DCD TMR16_1_IRQHandler /* 41:26 Timer16-s1 */ + DCD TMR2_IRQHandler /* 42:27 Timer32-2 */ + DCD TMR16_2_IRQHandler /* 43:28 Timer16-s2 */ + DCD TMR3_IRQHandler /* 44:29 Timer32-3 */ + DCD TMR16_3_IRQHandler /* 45:30 Timer16-s3 */ + DCD TMR4_IRQHandler /* 46:31 Timer32-4 */ + DCD TMR16_4_IRQHandler /* 47:32 Timer16-s4 */ + DCD TMR5_IRQHandler /* 48:33 Timer32-5 */ + DCD TMR16_5_IRQHandler /* 49:34 Timer16-s5 */ + DCD UART0_IRQHandler /* 50:35 UART0 */ + DCD UART1_IRQHandler /* 51:36 UART1 */ + DCD UART2_IRQHandler /* 52:37 UART0 */ + DCD UART3_IRQHandler /* 53:38 UART1 */ + DCD PT_IRQHandler /* 54:39 PT */ + DCD I2CM0_IRQHandler /* 55:40 I2C Master 0 */ + DCD I2CM1_IRQHandler /* 56:41 I2C Master 1 */ + DCD I2CM2_IRQHandler /* 57:42 I2C Master 2 */ + DCD I2CS_IRQHandler /* 58:43 I2C Slave */ + DCD SPI0_IRQHandler /* 59:44 SPI0 */ + DCD SPI1_IRQHandler /* 60:45 SPI1 */ + DCD SPI2_IRQHandler /* 61:46 SPI2 */ + DCD SPIB_IRQHandler /* 62:47 SPI Bridge */ + DCD OWM_IRQHandler /* 63:48 1-Wire Master */ + DCD AFE_IRQHandler /* 64:49 AFE */ + +__Vectors_End + +__Vectors_Size EQU __Vectors_End - __Vectors + + AREA |.text|, CODE, READONLY + +Reset_Handler PROC + EXPORT Reset_Handler [WEAK] + IMPORT SystemInit + IMPORT __main + LDR R0, =SystemInit + BLX R0 + LDR R0, =__main + BX R0 + ENDP + +; Dummy Exception Handlers (infinite loops which can be modified) + +NMI_Handler PROC + EXPORT NMI_Handler [WEAK] + B NMI_Handler + ENDP + +HardFault_Handler PROC + EXPORT HardFault_Handler [WEAK] + B HardFault_Handler + ENDP + +DefaultIRQ_Handler PROC + EXPORT DefaultIRQ_Handler [WEAK] + B DefaultIRQ_Handler + ENDP + +DebugMon_Handler PROC + EXPORT DebugMon_Handler [WEAK] + B DebugMon_Handler + ENDP + +SysTick_IRQHandler PROC + EXPORT SysTick_IRQHandler [WEAK] + B SysTick_IRQHandler + ENDP + +Default_Handler PROC + + EXPORT CLKMAN_IRQHandler [WEAK] + EXPORT PWRMAN_IRQHandler [WEAK] + EXPORT FLC_IRQHandler [WEAK] + EXPORT RTC0_IRQHandler [WEAK] + EXPORT RTC1_IRQHandler [WEAK] + EXPORT RTC2_IRQHandler [WEAK] + EXPORT RTC3_IRQHandler [WEAK] + EXPORT PMU_IRQHandler [WEAK] + EXPORT USB_IRQHandler [WEAK] + EXPORT AES_IRQHandler [WEAK] + EXPORT MAA_IRQHandler [WEAK] + EXPORT WDT0_IRQHandler [WEAK] + EXPORT WDT0_P_IRQHandler [WEAK] + EXPORT WDT1_IRQHandler [WEAK] + EXPORT WDT1_P_IRQHandler [WEAK] + EXPORT GPIO_P0_IRQHandler [WEAK] + EXPORT GPIO_P1_IRQHandler [WEAK] + EXPORT GPIO_P2_IRQHandler [WEAK] + EXPORT GPIO_P3_IRQHandler [WEAK] + EXPORT GPIO_P4_IRQHandler [WEAK] + EXPORT GPIO_P5_IRQHandler [WEAK] + EXPORT GPIO_P6_IRQHandler [WEAK] + EXPORT TMR0_IRQHandler [WEAK] + EXPORT TMR16_0_IRQHandler [WEAK] + EXPORT TMR1_IRQHandler [WEAK] + EXPORT TMR16_1_IRQHandler [WEAK] + EXPORT TMR2_IRQHandler [WEAK] + EXPORT TMR16_2_IRQHandler [WEAK] + EXPORT TMR3_IRQHandler [WEAK] + EXPORT TMR16_3_IRQHandler [WEAK] + EXPORT TMR4_IRQHandler [WEAK] + EXPORT TMR16_4_IRQHandler [WEAK] + EXPORT TMR5_IRQHandler [WEAK] + EXPORT TMR16_5_IRQHandler [WEAK] + EXPORT UART0_IRQHandler [WEAK] + EXPORT UART1_IRQHandler [WEAK] + EXPORT UART2_IRQHandler [WEAK] + EXPORT UART3_IRQHandler [WEAK] + EXPORT PT_IRQHandler [WEAK] + EXPORT I2CM0_IRQHandler [WEAK] + EXPORT I2CM1_IRQHandler [WEAK] + EXPORT I2CM2_IRQHandler [WEAK] + EXPORT I2CS_IRQHandler [WEAK] + EXPORT SPI0_IRQHandler [WEAK] + EXPORT SPI1_IRQHandler [WEAK] + EXPORT SPI2_IRQHandler [WEAK] + EXPORT SPIB_IRQHandler [WEAK] + EXPORT OWM_IRQHandler [WEAK] + EXPORT AFE_IRQHandler [WEAK] + +CLKMAN_IRQHandler +PWRMAN_IRQHandler +FLC_IRQHandler +RTC0_IRQHandler +RTC1_IRQHandler +RTC2_IRQHandler +RTC3_IRQHandler +PMU_IRQHandler +USB_IRQHandler +AES_IRQHandler +MAA_IRQHandler +WDT0_IRQHandler +WDT0_P_IRQHandler +WDT1_IRQHandler +WDT1_P_IRQHandler +GPIO_P0_IRQHandler +GPIO_P1_IRQHandler +GPIO_P2_IRQHandler +GPIO_P3_IRQHandler +GPIO_P4_IRQHandler +GPIO_P5_IRQHandler +GPIO_P6_IRQHandler +TMR0_IRQHandler +TMR16_0_IRQHandler +TMR1_IRQHandler +TMR16_1_IRQHandler +TMR2_IRQHandler +TMR16_2_IRQHandler +TMR3_IRQHandler +TMR16_3_IRQHandler +TMR4_IRQHandler +TMR16_4_IRQHandler +TMR5_IRQHandler +TMR16_5_IRQHandler +UART0_IRQHandler +UART1_IRQHandler +UART2_IRQHandler +UART3_IRQHandler +PT_IRQHandler +I2CM0_IRQHandler +I2CM1_IRQHandler +I2CM2_IRQHandler +I2CS_IRQHandler +SPI0_IRQHandler +SPI1_IRQHandler +SPI2_IRQHandler +SPIB_IRQHandler +OWM_IRQHandler +AFE_IRQHandler + + B . + ENDP + ALIGN + END diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_ARM_STD/sys.cpp b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_ARM_STD/sys.cpp new file mode 100644 index 0000000000..b6c24b3836 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_ARM_STD/sys.cpp @@ -0,0 +1,57 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +extern char Image$$RW_IRAM1$$ZI$$Limit[]; + +extern __value_in_regs struct __initial_stackheap __user_setup_stackheap(uint32_t R0, uint32_t R1, uint32_t R2, uint32_t R3) { + uint32_t zi_limit = (uint32_t)Image$$RW_IRAM1$$ZI$$Limit; + uint32_t sp_limit = __current_sp(); + + zi_limit = (zi_limit + 7) & ~0x7; // ensure zi_limit is 8-byte aligned + + struct __initial_stackheap r; + r.heap_base = zi_limit; + r.heap_limit = sp_limit; + return r; +} + +#ifdef __cplusplus +} +#endif diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_GCC_ARM/max32620.ld b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_GCC_ARM/max32620.ld new file mode 100644 index 0000000000..44528cda5b --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_GCC_ARM/max32620.ld @@ -0,0 +1,176 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +MEMORY +{ + FLASH (rx) : ORIGIN = 0x00000000, LENGTH = 2M + RAM (rwx) : ORIGIN = 0x20000000, LENGTH = 256K +} + +/* Linker script to place sections and symbol values. Should be used together + * with other linker script that defines memory regions FLASH and RAM. + * It references following symbols, which must be defined in code: + * Reset_Handler : Entry of reset handler + * + * It defines following symbols, which code can use without definition: + * __exidx_start + * __exidx_end + * __etext + * __data_start__ + * __preinit_array_start + * __preinit_array_end + * __init_array_start + * __init_array_end + * __fini_array_start + * __fini_array_end + * __data_end__ + * __bss_start__ + * __bss_end__ + * __end__ + * end + * __HeapLimit + * __StackLimit + * __StackTop + * __stack + */ +ENTRY(Reset_Handler) + +SECTIONS +{ + .text : + { + KEEP(*(.isr_vector)) + *(.text*) + + KEEP(*(.init)) + KEEP(*(.fini)) + + /* .ctors */ + *crtbegin.o(.ctors) + *crtbegin?.o(.ctors) + *(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors) + *(SORT(.ctors.*)) + *(.ctors) + + /* .dtors */ + *crtbegin.o(.dtors) + *crtbegin?.o(.dtors) + *(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors) + *(SORT(.dtors.*)) + *(.dtors) + + *(.rodata*) + + KEEP(*(.eh_frame*)) + } > FLASH + + .ARM.extab : + { + *(.ARM.extab* .gnu.linkonce.armextab.*) + } > FLASH + + __exidx_start = .; + .ARM.exidx : + { + *(.ARM.exidx* .gnu.linkonce.armexidx.*) + } > FLASH + __exidx_end = .; + + __etext = .; + + .data : AT (__etext) + { + __data_start__ = .; + *(vtable) + *(.data*) + + . = ALIGN(4); + /* preinit data */ + PROVIDE_HIDDEN (__preinit_array_start = .); + KEEP(*(.preinit_array)) + PROVIDE_HIDDEN (__preinit_array_end = .); + + . = ALIGN(4); + /* init data */ + PROVIDE_HIDDEN (__init_array_start = .); + KEEP(*(SORT(.init_array.*))) + KEEP(*(.init_array)) + PROVIDE_HIDDEN (__init_array_end = .); + + + . = ALIGN(4); + /* finit data */ + PROVIDE_HIDDEN (__fini_array_start = .); + KEEP(*(SORT(.fini_array.*))) + KEEP(*(.fini_array)) + PROVIDE_HIDDEN (__fini_array_end = .); + + . = ALIGN(4); + /* All data end */ + __data_end__ = .; + + } > RAM + + .bss : + { + __bss_start__ = .; + *(.bss*) + *(COMMON) + __bss_end__ = .; + } > RAM + + .heap : + { + __end__ = .; + end = __end__; + *(.heap*) + __HeapLimit = .; + } > RAM + + /* .stack_dummy section doesn't contains any symbols. It is only + * used for linker to calculate size of stack sections, and assign + * values to stack symbols later */ + .stack_dummy : + { + *(.stack) + } > RAM + + /* Set stack top to end of RAM, and stack limit move down by + * size of stack_dummy section */ + __StackTop = ORIGIN(RAM) + LENGTH(RAM); + __StackLimit = __StackTop - SIZEOF(.stack_dummy); + PROVIDE(__stack = __StackTop); + + /* Check if data + heap + stack exceeds RAM limit */ + ASSERT(__StackLimit >= __HeapLimit, "region RAM overflowed with stack") +} diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_GCC_ARM/startup_max32620.S b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_GCC_ARM/startup_max32620.S new file mode 100644 index 0000000000..730788d41e --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_GCC_ARM/startup_max32620.S @@ -0,0 +1,269 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + + .syntax unified + .arch armv7-m + +/* Memory Model + The HEAP starts at the end of the DATA section and grows upward. + + The STACK starts at the end of the RAM and grows downward. + + The HEAP and stack STACK are only checked at compile time: + (DATA_SIZE + HEAP_SIZE + STACK_SIZE) < RAM_SIZE + + This is just a check for the bare minimum for the Heap+Stack area before + aborting compilation, it is not the run time limit: + Heap_Size + Stack_Size = 0x80 + 0x80 = 0x100 + */ + .section .stack + .align 3 +#ifdef __STACK_SIZE + .equ Stack_Size, __STACK_SIZE +#else + .equ Stack_Size, 0x00001000 +#endif + .globl __StackTop + .globl __StackLimit +__StackLimit: + .space Stack_Size + .size __StackLimit, . - __StackLimit +__StackTop: + .size __StackTop, . - __StackTop + + .section .heap + .align 3 +#ifdef __HEAP_SIZE + .equ Heap_Size, __HEAP_SIZE +#else + .equ Heap_Size, 0x00000C00 +#endif + .globl __HeapBase + .globl __HeapLimit +__HeapBase: + .space Heap_Size + .size __HeapBase, . - __HeapBase +__HeapLimit: + .size __HeapLimit, . - __HeapLimit + + .section .isr_vector + .align 2 + .globl __isr_vector +__isr_vector: + .long __StackTop /* Top of Stack */ + .long Reset_Handler /* Reset Handler */ + .long NMI_Handler /* NMI Handler */ + .long HardFault_Handler /* Hard Fault Handler */ + .long MemManage_Handler /* MPU Fault Handler */ + .long BusFault_Handler /* Bus Fault Handler */ + .long UsageFault_Handler /* Usage Fault Handler */ + .long 0 /* Reserved */ + .long 0 /* Reserved */ + .long 0 /* Reserved */ + .long 0 /* Reserved */ + .long SVC_Handler /* SVCall Handler */ + .long DebugMon_Handler /* Debug Monitor Handler */ + .long 0 /* Reserved */ + .long PendSV_Handler /* PendSV Handler */ + .long SysTick_Handler /* SysTick Handler */ + + /* Externals interrupts */ + .long CLKMAN_IRQHandler /* 16:01 CLKMAN */ + .long PWRMAN_IRQHandler /* 17:02 PWRMAN */ + .long FLC_IRQHandler /* 18:03 Flash Controller */ + .long RTC0_IRQHandler /* 19:04 RTC INT0 */ + .long RTC1_IRQHandler /* 20:05 RTC INT1 */ + .long RTC2_IRQHandler /* 21:06 RTC INT2 */ + .long RTC3_IRQHandler /* 22:07 RTC INT3 */ + .long PMU_IRQHandler /* 23:08 PMU */ + .long USB_IRQHandler /* 24:09 USB */ + .long AES_IRQHandler /* 25:10 AES */ + .long MAA_IRQHandler /* 26:11 MAA */ + .long WDT0_IRQHandler /* 27:12 WATCHDOG0 */ + .long WDT0_P_IRQHandler /* 28:13 WATCHDOG0 PRE-WINDOW */ + .long WDT1_IRQHandler /* 29:14 WATCHDOG1 */ + .long WDT1_P_IRQHandler /* 30:15 WATCHDOG1 PRE-WINDOW */ + .long GPIO_P0_IRQHandler /* 31:16 GPIO Port 0 */ + .long GPIO_P1_IRQHandler /* 32:17 GPIO Port 1 */ + .long GPIO_P2_IRQHandler /* 33:18 GPIO Port 2 */ + .long GPIO_P3_IRQHandler /* 34:19 GPIO Port 3 */ + .long GPIO_P4_IRQHandler /* 35:20 GPIO Port 4 */ + .long GPIO_P5_IRQHandler /* 36:21 GPIO Port 5 */ + .long GPIO_P6_IRQHandler /* 37:22 GPIO Port 6 */ + .long TMR0_IRQHandler /* 38:23 Timer32-0 */ + .long TMR16_0_IRQHandler /* 39:24 Timer16-s0 */ + .long TMR1_IRQHandler /* 40:25 Timer32-1 */ + .long TMR16_1_IRQHandler /* 41:26 Timer16-s1 */ + .long TMR2_IRQHandler /* 42:27 Timer32-2 */ + .long TMR16_2_IRQHandler /* 43:28 Timer16-s2 */ + .long TMR3_IRQHandler /* 44:29 Timer32-3 */ + .long TMR16_3_IRQHandler /* 45:30 Timer16-s3 */ + .long TMR4_IRQHandler /* 46:31 Timer32-4 */ + .long TMR16_4_IRQHandler /* 47:32 Timer16-s4 */ + .long TMR5_IRQHandler /* 48:33 Timer32-5 */ + .long TMR16_5_IRQHandler /* 49:34 Timer16-s5 */ + .long UART0_IRQHandler /* 50:35 UART0 */ + .long UART1_IRQHandler /* 51:36 UART1 */ + .long UART2_IRQHandler /* 52:37 UART0 */ + .long UART3_IRQHandler /* 53:38 UART1 */ + .long PT_IRQHandler /* 54:39 PT */ + .long I2CM0_IRQHandler /* 55:40 I2C Master 0 */ + .long I2CM1_IRQHandler /* 56:41 I2C Master 1 */ + .long I2CM2_IRQHandler /* 57:42 I2C Master 2 */ + .long I2CS_IRQHandler /* 58:43 I2C Slave */ + .long SPI0_IRQHandler /* 59:44 SPI0 */ + .long SPI1_IRQHandler /* 60:45 SPI1 */ + .long SPI2_IRQHandler /* 61:46 SPI2 */ + .long SPIB_IRQHandler /* 62:47 SPI Bridge */ + .long OWM_IRQHandler /* 63:48 1-Wire Master */ + .long AFE_IRQHandler /* 64:49 AFE */ + + .text + .thumb + .thumb_func + .align 2 + .globl Reset_Handler + .type Reset_Handler, %function +Reset_Handler: +/* In order to have the same boot sequence with all Toolchains, we must call + * SystemInit before initalizing the data segments, and calling the static + * initalization. */ + ldr r0, =SystemInit + blx r0 + +/* Loop to copy data from read only memory to RAM. The ranges + * of copy from/to are specified by following symbols evaluated in + * linker script. + * __etext: End of code section, i.e., begin of data sections to copy from. + * __data_start__/__data_end__: RAM address range that data should be + * copied to. Both must be aligned to 4 bytes boundary. */ + + ldr r1, =__etext + ldr r2, =__data_start__ + ldr r3, =__data_end__ + +.Lflash_to_ram_loop: + cmp r2, r3 + ittt lt + ldrlt r0, [r1], #4 + strlt r0, [r2], #4 + blt .Lflash_to_ram_loop + +.Lflash_to_ram_loop_end: + ldr r0, =_start + bx r0 + .pool + .size Reset_Handler, . - Reset_Handler + + .text +/* Macro to define default handlers. Default handler + * will be weak symbol and just dead loops. They can be + * overwritten by other handlers */ + .macro def_default_handler handler_name + .align 1 + .thumb_func + .weak \handler_name + .type \handler_name, %function +\handler_name : + b . + .size \handler_name, . - \handler_name + .endm + + def_default_handler NMI_Handler + def_default_handler HardFault_Handler + def_default_handler MemManage_Handler + def_default_handler BusFault_Handler + def_default_handler UsageFault_Handler + def_default_handler SVC_Handler + def_default_handler DebugMon_Handler + def_default_handler PendSV_Handler + def_default_handler SysTick_Handler + def_default_handler Default_Handler + + .macro def_irq_default_handler handler_name + .weak \handler_name + .set \handler_name, Default_Handler + .endm + + def_irq_default_handler CLKMAN_IRQHandler /* 16:01 CLKMAN */ + def_irq_default_handler PWRMAN_IRQHandler /* 17:02 PWRMAN */ + def_irq_default_handler FLC_IRQHandler /* 18:03 Flash Controller */ + def_irq_default_handler RTC0_IRQHandler /* 19:04 RTC INT0 */ + def_irq_default_handler RTC1_IRQHandler /* 20:05 RTC INT1 */ + def_irq_default_handler RTC2_IRQHandler /* 21:06 RTC INT2 */ + def_irq_default_handler RTC3_IRQHandler /* 22:07 RTC INT3 */ + def_irq_default_handler PMU_IRQHandler /* 23:08 PMU */ + def_irq_default_handler USB_IRQHandler /* 24:09 USB */ + def_irq_default_handler AES_IRQHandler /* 25:10 AES */ + def_irq_default_handler MAA_IRQHandler /* 26:11 MAA */ + def_irq_default_handler WDT0_IRQHandler /* 27:12 WATCHDOG0 */ + def_irq_default_handler WDT0_P_IRQHandler /* 28:13 WATCHDOG0 PRE-WINDOW */ + def_irq_default_handler WDT1_IRQHandler /* 29:14 WATCHDOG1 */ + def_irq_default_handler WDT1_P_IRQHandler /* 30:15 WATCHDOG1 PRE-WINDOW */ + def_irq_default_handler GPIO_P0_IRQHandler /* 31:16 GPIO Port 0 */ + def_irq_default_handler GPIO_P1_IRQHandler /* 32:17 GPIO Port 1 */ + def_irq_default_handler GPIO_P2_IRQHandler /* 33:18 GPIO Port 2 */ + def_irq_default_handler GPIO_P3_IRQHandler /* 34:19 GPIO Port 3 */ + def_irq_default_handler GPIO_P4_IRQHandler /* 35:20 GPIO Port 4 */ + def_irq_default_handler GPIO_P5_IRQHandler /* 36:21 GPIO Port 5 */ + def_irq_default_handler GPIO_P6_IRQHandler /* 37:22 GPIO Port 6 */ + def_irq_default_handler TMR0_IRQHandler /* 38:23 Timer32-0 */ + def_irq_default_handler TMR16_0_IRQHandler /* 39:24 Timer16-s0 */ + def_irq_default_handler TMR1_IRQHandler /* 40:25 Timer32-1 */ + def_irq_default_handler TMR16_1_IRQHandler /* 41:26 Timer16-s1 */ + def_irq_default_handler TMR2_IRQHandler /* 42:27 Timer32-2 */ + def_irq_default_handler TMR16_2_IRQHandler /* 43:28 Timer16-s2 */ + def_irq_default_handler TMR3_IRQHandler /* 44:29 Timer32-3 */ + def_irq_default_handler TMR16_3_IRQHandler /* 45:30 Timer16-s3 */ + def_irq_default_handler TMR4_IRQHandler /* 46:31 Timer32-4 */ + def_irq_default_handler TMR16_4_IRQHandler /* 47:32 Timer16-s4 */ + def_irq_default_handler TMR5_IRQHandler /* 48:33 Timer32-5 */ + def_irq_default_handler TMR16_5_IRQHandler /* 49:34 Timer16-s5 */ + def_irq_default_handler PT_IRQHandler /* 50:35 PT */ + def_irq_default_handler UART0_IRQHandler /* 51:36 UART0 */ + def_irq_default_handler UART1_IRQHandler /* 52:37 UART1 */ + def_irq_default_handler UART2_IRQHandler /* 53:38 UART0 */ + def_irq_default_handler UART3_IRQHandler /* 54:39 UART1 */ + def_irq_default_handler I2CM0_IRQHandler /* 55:40 I2C Master 0 */ + def_irq_default_handler I2CM1_IRQHandler /* 56:41 I2C Master 1 */ + def_irq_default_handler I2CM2_IRQHandler /* 57:42 I2C Master 2 */ + def_irq_default_handler I2CS_IRQHandler /* 58:43 I2C Slave */ + def_irq_default_handler SPI0_IRQHandler /* 59:44 SPI0 */ + def_irq_default_handler SPI1_IRQHandler /* 60:45 SPI1 */ + def_irq_default_handler SPI2_IRQHandler /* 61:46 SPI2 */ + def_irq_default_handler SPIB_IRQHandler /* 62:47 SPI Bridge */ + def_irq_default_handler OWM_IRQHandler /* 63:48 SPI Bridge */ + def_irq_default_handler AFE_IRQHandler /* 64:49 AFE */ + + .end + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_IAR/MAX32620.icf b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_IAR/MAX32620.icf new file mode 100644 index 0000000000..31545799e4 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_IAR/MAX32620.icf @@ -0,0 +1,29 @@ +/* [ROM] */ +define symbol __intvec_start__ = 0x0; +define symbol __region_ROM_start__ = 0x0; +define symbol __region_ROM_end__ = 0x001FFFFF; + +/* [RAM] Vector table dynamic copy: 65 vectors * 4 bytes = 260 (0x104) bytes + 4 for 8 byte align */ +define symbol __NVIC_start__ = 0x00000000; +define symbol __NVIC_end__ = 0x00000108; /* to be aligned on 8 bytes */ +define symbol __region_RAM_start__ = 0x20000000; +define symbol __region_RAM_end__ = 0x2003FFFF; + +/* Memory regions */ +define memory mem with size = 4G; +define region ROM_region = mem:[from __region_ROM_start__ to __region_ROM_end__]; +define region RAM_region = mem:[from __region_RAM_start__ to __region_RAM_end__]; + +/* Stack and Heap */ +define symbol __size_cstack__ = 0x800; +define symbol __size_heap__ = 0x800; +define block CSTACK with alignment = 8, size = __size_cstack__ { }; +define block HEAP with alignment = 8, size = __size_heap__ { }; + +initialize by copy { readwrite }; +do not initialize { section .noinit }; + +place at address mem:__intvec_start__ { readonly section .intvec }; +place in ROM_region { readonly }; +place in RAM_region { readwrite, + block CSTACK, block HEAP }; diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_IAR/startup_MAX32620.S b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_IAR/startup_MAX32620.S new file mode 100644 index 0000000000..000a28e7ea --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_IAR/startup_MAX32620.S @@ -0,0 +1,401 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + + MODULE ?cstartup + + ;; Forward declaration of sections. + SECTION CSTACK:DATA:NOROOT(3) + + SECTION .intvec:CODE:NOROOT(2) + + EXTERN __iar_program_start + EXTERN SystemInit + PUBLIC __vector_table + + DATA +__vector_table DCD sfe(CSTACK) /* Top of Stack */ + DCD Reset_Handler /* Reset Handler */ + DCD NMI_Handler /* NMI Handler */ + DCD HardFault_Handler /* Hard Fault Handler */ + DCD DefaultIRQ_Handler /* MPU Fault Handler */ + DCD DefaultIRQ_Handler /* Bus Fault Handler */ + DCD DefaultIRQ_Handler /* Usage Fault Handler */ + DCD 0 /* Reserved */ + DCD 0 /* Reserved */ + DCD 0 /* Reserved */ + DCD 0 /* Reserved */ + DCD DefaultIRQ_Handler /* SVCall Handler */ + DCD DebugMon_Handler /* Debug Monitor Handler */ + DCD 0 /* Reserved */ + DCD DefaultIRQ_Handler /* PendSV Handler */ + DCD SysTick_IRQHandler /* SysTick Handler */ + + /* Maxim 32620 NVIC Index */ + DCD CLKMAN_IRQHandler /* 16:01 CLKMAN */ + DCD PWRMAN_IRQHandler /* 17:02 PWRMAN */ + DCD FLC_IRQHandler /* 18:03 Flash Controller */ + DCD RTC0_IRQHandler /* 19:04 RTC INT0 */ + DCD RTC1_IRQHandler /* 20:05 RTC INT1 */ + DCD RTC2_IRQHandler /* 21:06 RTC INT2 */ + DCD RTC3_IRQHandler /* 22:07 RTC INT3 */ + DCD PMU_IRQHandler /* 23:08 PMU */ + DCD USB_IRQHandler /* 24:09 USB */ + DCD AES_IRQHandler /* 25:10 AES */ + DCD MAA_IRQHandler /* 26:11 MAA */ + DCD WDT0_IRQHandler /* 27:12 WATCHDOG0 */ + DCD WDT0_P_IRQHandler /* 28:13 WATCHDOG0 PRE-WINDOW */ + DCD WDT1_IRQHandler /* 29:14 WATCHDOG1 */ + DCD WDT1_P_IRQHandler /* 30:15 WATCHDOG1 PRE-WINDOW */ + DCD GPIO_P0_IRQHandler /* 31:16 GPIO Port 0 */ + DCD GPIO_P1_IRQHandler /* 32:17 GPIO Port 1 */ + DCD GPIO_P2_IRQHandler /* 33:18 GPIO Port 2 */ + DCD GPIO_P3_IRQHandler /* 34:19 GPIO Port 3 */ + DCD GPIO_P4_IRQHandler /* 35:20 GPIO Port 4 */ + DCD GPIO_P5_IRQHandler /* 36:21 GPIO Port 5 */ + DCD GPIO_P6_IRQHandler /* 37:22 GPIO Port 6 */ + DCD TMR0_IRQHandler /* 38:23 Timer32-0 */ + DCD TMR16_0_IRQHandler /* 39:24 Timer16-s0 */ + DCD TMR1_IRQHandler /* 40:25 Timer32-1 */ + DCD TMR16_1_IRQHandler /* 41:26 Timer16-s1 */ + DCD TMR2_IRQHandler /* 42:27 Timer32-2 */ + DCD TMR16_2_IRQHandler /* 43:28 Timer16-s2 */ + DCD TMR3_IRQHandler /* 44:29 Timer32-3 */ + DCD TMR16_3_IRQHandler /* 45:30 Timer16-s3 */ + DCD TMR4_IRQHandler /* 46:31 Timer32-4 */ + DCD TMR16_4_IRQHandler /* 47:32 Timer16-s4 */ + DCD TMR5_IRQHandler /* 48:33 Timer32-5 */ + DCD TMR16_5_IRQHandler /* 49:34 Timer16-s5 */ + DCD UART0_IRQHandler /* 50:35 UART0 */ + DCD UART1_IRQHandler /* 51:36 UART1 */ + DCD UART2_IRQHandler /* 52:37 UART0 */ + DCD UART3_IRQHandler /* 53:38 UART1 */ + DCD PT_IRQHandler /* 54:39 PT */ + DCD I2CM0_IRQHandler /* 55:40 I2C Master 0 */ + DCD I2CM1_IRQHandler /* 56:41 I2C Master 1 */ + DCD I2CM2_IRQHandler /* 57:42 I2C Master 2 */ + DCD I2CS_IRQHandler /* 58:43 I2C Slave */ + DCD SPI0_IRQHandler /* 59:44 SPI0 */ + DCD SPI1_IRQHandler /* 60:45 SPI1 */ + DCD SPI2_IRQHandler /* 61:46 SPI2 */ + DCD SPIB_IRQHandler /* 62:47 SPI Bridge */ + DCD OWM_IRQHandler /* 63:48 1-Wire Master */ + DCD AFE_IRQHandler /* 64:49 AFE */ + + THUMB + ;; Dummy Exception Handlers (infinite loops which can be modified) + ;; Generate with: + ;; awk '/DCD/ {print "\t\t\tPUBWEAK " $2 "\n" "\t\t\tSECTION .text:CODE:REORDER:NOROOT(1)\n" $2 "\n" "\t\t\tB\t\t" $2 "\n"}' + ;; Paste in DCD lines above, redirect output to file, then read it in below + ;; Note that Reset_Handler is NOROOT(2) while others are NOROOT(1), which is not handled by script + + + PUBWEAK Reset_Handler + SECTION .text:CODE:REORDER:NOROOT(2) +Reset_Handler + LDR R0, =SystemInit + BLX R0 + LDR R0, =__iar_program_start + BX R0 + + PUBWEAK NMI_Handler + SECTION .text:CODE:REORDER:NOROOT(1) +NMI_Handler + B NMI_Handler + + PUBWEAK HardFault_Handler + SECTION .text:CODE:REORDER:NOROOT(1) +HardFault_Handler + B HardFault_Handler + + PUBWEAK DefaultIRQ_Handler + SECTION .text:CODE:REORDER:NOROOT(1) +DefaultIRQ_Handler + B DefaultIRQ_Handler + + PUBWEAK DebugMon_Handler + SECTION .text:CODE:REORDER:NOROOT(1) +DebugMon_Handler + B DebugMon_Handler + + PUBWEAK SysTick_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +SysTick_IRQHandler + B SysTick_IRQHandler + + PUBWEAK CLKMAN_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +CLKMAN_IRQHandler + B CLKMAN_IRQHandler + + PUBWEAK PWRMAN_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +PWRMAN_IRQHandler + B PWRMAN_IRQHandler + + PUBWEAK FLC_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +FLC_IRQHandler + B FLC_IRQHandler + + PUBWEAK RTC0_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +RTC0_IRQHandler + B RTC0_IRQHandler + + PUBWEAK RTC1_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +RTC1_IRQHandler + B RTC1_IRQHandler + + PUBWEAK RTC2_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +RTC2_IRQHandler + B RTC2_IRQHandler + + PUBWEAK RTC3_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +RTC3_IRQHandler + B RTC3_IRQHandler + + PUBWEAK PMU_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +PMU_IRQHandler + B PMU_IRQHandler + + PUBWEAK USB_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +USB_IRQHandler + B USB_IRQHandler + + PUBWEAK AES_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +AES_IRQHandler + B AES_IRQHandler + + PUBWEAK MAA_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +MAA_IRQHandler + B MAA_IRQHandler + + PUBWEAK WDT0_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +WDT0_IRQHandler + B WDT0_IRQHandler + + PUBWEAK WDT0_P_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +WDT0_P_IRQHandler + B WDT0_P_IRQHandler + + PUBWEAK WDT1_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +WDT1_IRQHandler + B WDT1_IRQHandler + + PUBWEAK WDT1_P_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +WDT1_P_IRQHandler + B WDT1_P_IRQHandler + + PUBWEAK GPIO_P0_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +GPIO_P0_IRQHandler + B GPIO_P0_IRQHandler + + PUBWEAK GPIO_P1_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +GPIO_P1_IRQHandler + B GPIO_P1_IRQHandler + + PUBWEAK GPIO_P2_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +GPIO_P2_IRQHandler + B GPIO_P2_IRQHandler + + PUBWEAK GPIO_P3_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +GPIO_P3_IRQHandler + B GPIO_P3_IRQHandler + + PUBWEAK GPIO_P4_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +GPIO_P4_IRQHandler + B GPIO_P4_IRQHandler + + PUBWEAK GPIO_P5_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +GPIO_P5_IRQHandler + B GPIO_P5_IRQHandler + + PUBWEAK GPIO_P6_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +GPIO_P6_IRQHandler + B GPIO_P6_IRQHandler + + PUBWEAK TMR0_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +TMR0_IRQHandler + B TMR0_IRQHandler + + PUBWEAK TMR16_0_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +TMR16_0_IRQHandler + B TMR16_0_IRQHandler + + PUBWEAK TMR1_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +TMR1_IRQHandler + B TMR1_IRQHandler + + PUBWEAK TMR16_1_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +TMR16_1_IRQHandler + B TMR16_1_IRQHandler + + PUBWEAK TMR2_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +TMR2_IRQHandler + B TMR2_IRQHandler + + PUBWEAK TMR16_2_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +TMR16_2_IRQHandler + B TMR16_2_IRQHandler + + PUBWEAK TMR3_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +TMR3_IRQHandler + B TMR3_IRQHandler + + PUBWEAK TMR16_3_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +TMR16_3_IRQHandler + B TMR16_3_IRQHandler + + PUBWEAK TMR4_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +TMR4_IRQHandler + B TMR4_IRQHandler + + PUBWEAK TMR16_4_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +TMR16_4_IRQHandler + B TMR16_4_IRQHandler + + PUBWEAK TMR5_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +TMR5_IRQHandler + B TMR5_IRQHandler + + PUBWEAK TMR16_5_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +TMR16_5_IRQHandler + B TMR16_5_IRQHandler + + PUBWEAK UART0_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +UART0_IRQHandler + B UART0_IRQHandler + + PUBWEAK UART1_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +UART1_IRQHandler + B UART1_IRQHandler + + PUBWEAK UART2_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +UART2_IRQHandler + B UART2_IRQHandler + + PUBWEAK UART3_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +UART3_IRQHandler + B UART3_IRQHandler + + PUBWEAK PT_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +PT_IRQHandler + B PT_IRQHandler + + PUBWEAK I2CM0_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +I2CM0_IRQHandler + B I2CM0_IRQHandler + + PUBWEAK I2CM1_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +I2CM1_IRQHandler + B I2CM1_IRQHandler + + PUBWEAK I2CM2_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +I2CM2_IRQHandler + B I2CM2_IRQHandler + + PUBWEAK I2CS_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +I2CS_IRQHandler + B I2CS_IRQHandler + + PUBWEAK SPI0_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +SPI0_IRQHandler + B SPI0_IRQHandler + + PUBWEAK SPI1_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +SPI1_IRQHandler + B SPI1_IRQHandler + + PUBWEAK SPI2_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +SPI2_IRQHandler + B SPI2_IRQHandler + + PUBWEAK SPIB_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +SPIB_IRQHandler + B SPIB_IRQHandler + + PUBWEAK OWM_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +OWM_IRQHandler + B OWM_IRQHandler + + PUBWEAK AFE_IRQHandler + SECTION .text:CODE:REORDER:NOROOT(1) +AFE_IRQHandler + B AFE_IRQHandler + + END + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/adc_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/adc_regs.h new file mode 100644 index 0000000000..e633dbc316 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/adc_regs.h @@ -0,0 +1,252 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_ADC_REGS_H_ +#define _MXC_ADC_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t ctrl; /* 0x0000 ADC Control */ + __IO uint32_t status; /* 0x0004 ADC Status */ + __IO uint32_t data; /* 0x0008 ADC Output Data */ + __IO uint32_t intr; /* 0x000C ADC Interrupt Control Register */ + __IO uint32_t limit[4]; /* 0x0010-0x001C ADC Limit 0..3 */ + __IO uint32_t afe_ctrl; /* 0x0020 AFE Control Register */ + __IO uint32_t ro_cal0; /* 0x0024 RO Trim Calibration Register 0 */ + __IO uint32_t ro_cal1; /* 0x0028 RO Trim Calibration Register 1 */ + __IO uint32_t ro_cal2; /* 0x002C RO Trim Calibration Register 2 */ +} mxc_adc_regs_t; + + +/* + Register offsets for module ADC. +*/ + +#define MXC_R_ADC_OFFS_CTRL ((uint32_t)0x00000000UL) +#define MXC_R_ADC_OFFS_STATUS ((uint32_t)0x00000004UL) +#define MXC_R_ADC_OFFS_DATA ((uint32_t)0x00000008UL) +#define MXC_R_ADC_OFFS_INTR ((uint32_t)0x0000000CUL) +#define MXC_R_ADC_OFFS_LIMIT0 ((uint32_t)0x00000010UL) +#define MXC_R_ADC_OFFS_LIMIT1 ((uint32_t)0x00000014UL) +#define MXC_R_ADC_OFFS_LIMIT2 ((uint32_t)0x00000018UL) +#define MXC_R_ADC_OFFS_LIMIT3 ((uint32_t)0x0000001CUL) +#define MXC_R_ADC_OFFS_AFE_CTRL ((uint32_t)0x00000020UL) +#define MXC_R_ADC_OFFS_RO_CAL0 ((uint32_t)0x00000024UL) +#define MXC_R_ADC_OFFS_RO_CAL1 ((uint32_t)0x00000028UL) +#define MXC_R_ADC_OFFS_RO_CAL2 ((uint32_t)0x0000002CUL) + + +/* + Field positions and masks for module ADC. +*/ + +#define MXC_F_ADC_CTRL_CPU_ADC_START_POS 0 +#define MXC_F_ADC_CTRL_CPU_ADC_START ((uint32_t)(0x00000001UL << MXC_F_ADC_CTRL_CPU_ADC_START_POS)) +#define MXC_F_ADC_CTRL_ADC_PU_POS 1 +#define MXC_F_ADC_CTRL_ADC_PU ((uint32_t)(0x00000001UL << MXC_F_ADC_CTRL_ADC_PU_POS)) +#define MXC_F_ADC_CTRL_BUF_PU_POS 2 +#define MXC_F_ADC_CTRL_BUF_PU ((uint32_t)(0x00000001UL << MXC_F_ADC_CTRL_BUF_PU_POS)) +#define MXC_F_ADC_CTRL_ADC_REFBUF_PU_POS 3 +#define MXC_F_ADC_CTRL_ADC_REFBUF_PU ((uint32_t)(0x00000001UL << MXC_F_ADC_CTRL_ADC_REFBUF_PU_POS)) +#define MXC_F_ADC_CTRL_ADC_CHGPUMP_PU_POS 4 +#define MXC_F_ADC_CTRL_ADC_CHGPUMP_PU ((uint32_t)(0x00000001UL << MXC_F_ADC_CTRL_ADC_CHGPUMP_PU_POS)) +#define MXC_F_ADC_CTRL_BUF_CHOP_DIS_POS 5 +#define MXC_F_ADC_CTRL_BUF_CHOP_DIS ((uint32_t)(0x00000001UL << MXC_F_ADC_CTRL_BUF_CHOP_DIS_POS)) +#define MXC_F_ADC_CTRL_BUF_PUMP_DIS_POS 6 +#define MXC_F_ADC_CTRL_BUF_PUMP_DIS ((uint32_t)(0x00000001UL << MXC_F_ADC_CTRL_BUF_PUMP_DIS_POS)) +#define MXC_F_ADC_CTRL_BUF_BYPASS_POS 7 +#define MXC_F_ADC_CTRL_BUF_BYPASS ((uint32_t)(0x00000001UL << MXC_F_ADC_CTRL_BUF_BYPASS_POS)) +#define MXC_F_ADC_CTRL_ADC_REFSCL_POS 8 +#define MXC_F_ADC_CTRL_ADC_REFSCL ((uint32_t)(0x00000001UL << MXC_F_ADC_CTRL_ADC_REFSCL_POS)) +#define MXC_F_ADC_CTRL_ADC_SCALE_POS 9 +#define MXC_F_ADC_CTRL_ADC_SCALE ((uint32_t)(0x00000001UL << MXC_F_ADC_CTRL_ADC_SCALE_POS)) +#define MXC_F_ADC_CTRL_ADC_REFSEL_POS 10 +#define MXC_F_ADC_CTRL_ADC_REFSEL ((uint32_t)(0x00000001UL << MXC_F_ADC_CTRL_ADC_REFSEL_POS)) +#define MXC_F_ADC_CTRL_ADC_CLK_EN_POS 11 +#define MXC_F_ADC_CTRL_ADC_CLK_EN ((uint32_t)(0x00000001UL << MXC_F_ADC_CTRL_ADC_CLK_EN_POS)) +#define MXC_F_ADC_CTRL_ADC_CHSEL_POS 12 +#define MXC_F_ADC_CTRL_ADC_CHSEL ((uint32_t)(0x0000000FUL << MXC_F_ADC_CTRL_ADC_CHSEL_POS)) +#define MXC_F_ADC_CTRL_ADC_XREF_POS 16 +#define MXC_F_ADC_CTRL_ADC_XREF ((uint32_t)(0x00000001UL << MXC_F_ADC_CTRL_ADC_XREF_POS)) +#define MXC_F_ADC_CTRL_ADC_DATAALIGN_POS 17 +#define MXC_F_ADC_CTRL_ADC_DATAALIGN ((uint32_t)(0x00000001UL << MXC_F_ADC_CTRL_ADC_DATAALIGN_POS)) +#define MXC_F_ADC_CTRL_AFE_PWR_UP_DLY_POS 24 +#define MXC_F_ADC_CTRL_AFE_PWR_UP_DLY ((uint32_t)(0x000000FFUL << MXC_F_ADC_CTRL_AFE_PWR_UP_DLY_POS)) + +#define MXC_F_ADC_STATUS_ADC_ACTIVE_POS 0 +#define MXC_F_ADC_STATUS_ADC_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_ADC_STATUS_ADC_ACTIVE_POS)) +#define MXC_F_ADC_STATUS_RO_CAL_ATOMIC_ACTIVE_POS 1 +#define MXC_F_ADC_STATUS_RO_CAL_ATOMIC_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_ADC_STATUS_RO_CAL_ATOMIC_ACTIVE_POS)) +#define MXC_F_ADC_STATUS_AFE_PWR_UP_ACTIVE_POS 2 +#define MXC_F_ADC_STATUS_AFE_PWR_UP_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_ADC_STATUS_AFE_PWR_UP_ACTIVE_POS)) +#define MXC_F_ADC_STATUS_ADC_OVERFLOW_POS 3 +#define MXC_F_ADC_STATUS_ADC_OVERFLOW ((uint32_t)(0x00000001UL << MXC_F_ADC_STATUS_ADC_OVERFLOW_POS)) + +#define MXC_F_ADC_DATA_ADC_DATA_POS 0 +#define MXC_F_ADC_DATA_ADC_DATA ((uint32_t)(0x0000FFFFUL << MXC_F_ADC_DATA_ADC_DATA_POS)) + +#define MXC_F_ADC_INTR_ADC_DONE_IE_POS 0 +#define MXC_F_ADC_INTR_ADC_DONE_IE ((uint32_t)(0x00000001UL << MXC_F_ADC_INTR_ADC_DONE_IE_POS)) +#define MXC_F_ADC_INTR_ADC_REF_READY_IE_POS 1 +#define MXC_F_ADC_INTR_ADC_REF_READY_IE ((uint32_t)(0x00000001UL << MXC_F_ADC_INTR_ADC_REF_READY_IE_POS)) +#define MXC_F_ADC_INTR_ADC_HI_LIMIT_IE_POS 2 +#define MXC_F_ADC_INTR_ADC_HI_LIMIT_IE ((uint32_t)(0x00000001UL << MXC_F_ADC_INTR_ADC_HI_LIMIT_IE_POS)) +#define MXC_F_ADC_INTR_ADC_LO_LIMIT_IE_POS 3 +#define MXC_F_ADC_INTR_ADC_LO_LIMIT_IE ((uint32_t)(0x00000001UL << MXC_F_ADC_INTR_ADC_LO_LIMIT_IE_POS)) +#define MXC_F_ADC_INTR_ADC_OVERFLOW_IE_POS 4 +#define MXC_F_ADC_INTR_ADC_OVERFLOW_IE ((uint32_t)(0x00000001UL << MXC_F_ADC_INTR_ADC_OVERFLOW_IE_POS)) +#define MXC_F_ADC_INTR_RO_CAL_DONE_IE_POS 5 +#define MXC_F_ADC_INTR_RO_CAL_DONE_IE ((uint32_t)(0x00000001UL << MXC_F_ADC_INTR_RO_CAL_DONE_IE_POS)) +#define MXC_F_ADC_INTR_ADC_DONE_IF_POS 16 +#define MXC_F_ADC_INTR_ADC_DONE_IF ((uint32_t)(0x00000001UL << MXC_F_ADC_INTR_ADC_DONE_IF_POS)) +#define MXC_F_ADC_INTR_ADC_REF_READY_IF_POS 17 +#define MXC_F_ADC_INTR_ADC_REF_READY_IF ((uint32_t)(0x00000001UL << MXC_F_ADC_INTR_ADC_REF_READY_IF_POS)) +#define MXC_F_ADC_INTR_ADC_HI_LIMIT_IF_POS 18 +#define MXC_F_ADC_INTR_ADC_HI_LIMIT_IF ((uint32_t)(0x00000001UL << MXC_F_ADC_INTR_ADC_HI_LIMIT_IF_POS)) +#define MXC_F_ADC_INTR_ADC_LO_LIMIT_IF_POS 19 +#define MXC_F_ADC_INTR_ADC_LO_LIMIT_IF ((uint32_t)(0x00000001UL << MXC_F_ADC_INTR_ADC_LO_LIMIT_IF_POS)) +#define MXC_F_ADC_INTR_ADC_OVERFLOW_IF_POS 20 +#define MXC_F_ADC_INTR_ADC_OVERFLOW_IF ((uint32_t)(0x00000001UL << MXC_F_ADC_INTR_ADC_OVERFLOW_IF_POS)) +#define MXC_F_ADC_INTR_RO_CAL_DONE_IF_POS 21 +#define MXC_F_ADC_INTR_RO_CAL_DONE_IF ((uint32_t)(0x00000001UL << MXC_F_ADC_INTR_RO_CAL_DONE_IF_POS)) +#define MXC_F_ADC_INTR_ADC_INT_PENDING_POS 22 +#define MXC_F_ADC_INTR_ADC_INT_PENDING ((uint32_t)(0x00000001UL << MXC_F_ADC_INTR_ADC_INT_PENDING_POS)) + +#define MXC_F_ADC_LIMIT0_CH_LO_LIMIT_POS 0 +#define MXC_F_ADC_LIMIT0_CH_LO_LIMIT ((uint32_t)(0x000003FFUL << MXC_F_ADC_LIMIT0_CH_LO_LIMIT_POS)) +#define MXC_F_ADC_LIMIT0_CH_HI_LIMIT_POS 12 +#define MXC_F_ADC_LIMIT0_CH_HI_LIMIT ((uint32_t)(0x000003FFUL << MXC_F_ADC_LIMIT0_CH_HI_LIMIT_POS)) +#define MXC_F_ADC_LIMIT0_CH_SEL_POS 24 +#define MXC_F_ADC_LIMIT0_CH_SEL ((uint32_t)(0x0000000FUL << MXC_F_ADC_LIMIT0_CH_SEL_POS)) +#define MXC_F_ADC_LIMIT0_CH_LO_LIMIT_EN_POS 28 +#define MXC_F_ADC_LIMIT0_CH_LO_LIMIT_EN ((uint32_t)(0x00000001UL << MXC_F_ADC_LIMIT0_CH_LO_LIMIT_EN_POS)) +#define MXC_F_ADC_LIMIT0_CH_HI_LIMIT_EN_POS 29 +#define MXC_F_ADC_LIMIT0_CH_HI_LIMIT_EN ((uint32_t)(0x00000001UL << MXC_F_ADC_LIMIT0_CH_HI_LIMIT_EN_POS)) + +#define MXC_F_ADC_LIMIT1_CH_LO_LIMIT_POS 0 +#define MXC_F_ADC_LIMIT1_CH_LO_LIMIT ((uint32_t)(0x000003FFUL << MXC_F_ADC_LIMIT1_CH_LO_LIMIT_POS)) +#define MXC_F_ADC_LIMIT1_CH_HI_LIMIT_POS 12 +#define MXC_F_ADC_LIMIT1_CH_HI_LIMIT ((uint32_t)(0x000003FFUL << MXC_F_ADC_LIMIT1_CH_HI_LIMIT_POS)) +#define MXC_F_ADC_LIMIT1_CH_SEL_POS 24 +#define MXC_F_ADC_LIMIT1_CH_SEL ((uint32_t)(0x0000000FUL << MXC_F_ADC_LIMIT1_CH_SEL_POS)) +#define MXC_F_ADC_LIMIT1_CH_LO_LIMIT_EN_POS 28 +#define MXC_F_ADC_LIMIT1_CH_LO_LIMIT_EN ((uint32_t)(0x00000001UL << MXC_F_ADC_LIMIT1_CH_LO_LIMIT_EN_POS)) +#define MXC_F_ADC_LIMIT1_CH_HI_LIMIT_EN_POS 29 +#define MXC_F_ADC_LIMIT1_CH_HI_LIMIT_EN ((uint32_t)(0x00000001UL << MXC_F_ADC_LIMIT1_CH_HI_LIMIT_EN_POS)) + +#define MXC_F_ADC_LIMIT2_CH_LO_LIMIT_POS 0 +#define MXC_F_ADC_LIMIT2_CH_LO_LIMIT ((uint32_t)(0x000003FFUL << MXC_F_ADC_LIMIT2_CH_LO_LIMIT_POS)) +#define MXC_F_ADC_LIMIT2_CH_HI_LIMIT_POS 12 +#define MXC_F_ADC_LIMIT2_CH_HI_LIMIT ((uint32_t)(0x000003FFUL << MXC_F_ADC_LIMIT2_CH_HI_LIMIT_POS)) +#define MXC_F_ADC_LIMIT2_CH_SEL_POS 24 +#define MXC_F_ADC_LIMIT2_CH_SEL ((uint32_t)(0x0000000FUL << MXC_F_ADC_LIMIT2_CH_SEL_POS)) +#define MXC_F_ADC_LIMIT2_CH_LO_LIMIT_EN_POS 28 +#define MXC_F_ADC_LIMIT2_CH_LO_LIMIT_EN ((uint32_t)(0x00000001UL << MXC_F_ADC_LIMIT2_CH_LO_LIMIT_EN_POS)) +#define MXC_F_ADC_LIMIT2_CH_HI_LIMIT_EN_POS 29 +#define MXC_F_ADC_LIMIT2_CH_HI_LIMIT_EN ((uint32_t)(0x00000001UL << MXC_F_ADC_LIMIT2_CH_HI_LIMIT_EN_POS)) + +#define MXC_F_ADC_LIMIT3_CH_LO_LIMIT_POS 0 +#define MXC_F_ADC_LIMIT3_CH_LO_LIMIT ((uint32_t)(0x000003FFUL << MXC_F_ADC_LIMIT3_CH_LO_LIMIT_POS)) +#define MXC_F_ADC_LIMIT3_CH_HI_LIMIT_POS 12 +#define MXC_F_ADC_LIMIT3_CH_HI_LIMIT ((uint32_t)(0x000003FFUL << MXC_F_ADC_LIMIT3_CH_HI_LIMIT_POS)) +#define MXC_F_ADC_LIMIT3_CH_SEL_POS 24 +#define MXC_F_ADC_LIMIT3_CH_SEL ((uint32_t)(0x0000000FUL << MXC_F_ADC_LIMIT3_CH_SEL_POS)) +#define MXC_F_ADC_LIMIT3_CH_LO_LIMIT_EN_POS 28 +#define MXC_F_ADC_LIMIT3_CH_LO_LIMIT_EN ((uint32_t)(0x00000001UL << MXC_F_ADC_LIMIT3_CH_LO_LIMIT_EN_POS)) +#define MXC_F_ADC_LIMIT3_CH_HI_LIMIT_EN_POS 29 +#define MXC_F_ADC_LIMIT3_CH_HI_LIMIT_EN ((uint32_t)(0x00000001UL << MXC_F_ADC_LIMIT3_CH_HI_LIMIT_EN_POS)) + +#define MXC_F_ADC_AFE_CTRL_TMON_INTBIAS_EN_POS 8 +#define MXC_F_ADC_AFE_CTRL_TMON_INTBIAS_EN ((uint32_t)(0x00000001UL << MXC_F_ADC_AFE_CTRL_TMON_INTBIAS_EN_POS)) +#define MXC_F_ADC_AFE_CTRL_TMON_EXTBIAS_EN_POS 9 +#define MXC_F_ADC_AFE_CTRL_TMON_EXTBIAS_EN ((uint32_t)(0x00000001UL << MXC_F_ADC_AFE_CTRL_TMON_EXTBIAS_EN_POS)) + +#define MXC_F_ADC_RO_CAL0_RO_CAL_EN_POS 0 +#define MXC_F_ADC_RO_CAL0_RO_CAL_EN ((uint32_t)(0x00000001UL << MXC_F_ADC_RO_CAL0_RO_CAL_EN_POS)) +#define MXC_F_ADC_RO_CAL0_RO_CAL_RUN_POS 1 +#define MXC_F_ADC_RO_CAL0_RO_CAL_RUN ((uint32_t)(0x00000001UL << MXC_F_ADC_RO_CAL0_RO_CAL_RUN_POS)) +#define MXC_F_ADC_RO_CAL0_RO_CAL_LOAD_POS 2 +#define MXC_F_ADC_RO_CAL0_RO_CAL_LOAD ((uint32_t)(0x00000001UL << MXC_F_ADC_RO_CAL0_RO_CAL_LOAD_POS)) +#define MXC_F_ADC_RO_CAL0_RO_CAL_ATOMIC_POS 4 +#define MXC_F_ADC_RO_CAL0_RO_CAL_ATOMIC ((uint32_t)(0x00000001UL << MXC_F_ADC_RO_CAL0_RO_CAL_ATOMIC_POS)) +#define MXC_F_ADC_RO_CAL0_DUMMY_POS 5 +#define MXC_F_ADC_RO_CAL0_DUMMY ((uint32_t)(0x00000007UL << MXC_F_ADC_RO_CAL0_DUMMY_POS)) +#define MXC_F_ADC_RO_CAL0_TRM_MU_POS 8 +#define MXC_F_ADC_RO_CAL0_TRM_MU ((uint32_t)(0x00000FFFUL << MXC_F_ADC_RO_CAL0_TRM_MU_POS)) +#define MXC_F_ADC_RO_CAL0_RO_TRM_POS 23 +#define MXC_F_ADC_RO_CAL0_RO_TRM ((uint32_t)(0x000001FFUL << MXC_F_ADC_RO_CAL0_RO_TRM_POS)) + +#define MXC_F_ADC_RO_CAL1_TRM_INIT_POS 0 +#define MXC_F_ADC_RO_CAL1_TRM_INIT ((uint32_t)(0x000001FFUL << MXC_F_ADC_RO_CAL1_TRM_INIT_POS)) +#define MXC_F_ADC_RO_CAL1_TRM_MIN_POS 10 +#define MXC_F_ADC_RO_CAL1_TRM_MIN ((uint32_t)(0x000001FFUL << MXC_F_ADC_RO_CAL1_TRM_MIN_POS)) +#define MXC_F_ADC_RO_CAL1_TRM_MAX_POS 20 +#define MXC_F_ADC_RO_CAL1_TRM_MAX ((uint32_t)(0x000001FFUL << MXC_F_ADC_RO_CAL1_TRM_MAX_POS)) + +#define MXC_F_ADC_RO_CAL2_AUTO_CAL_DONE_CNT_POS 0 +#define MXC_F_ADC_RO_CAL2_AUTO_CAL_DONE_CNT ((uint32_t)(0x000000FFUL << MXC_F_ADC_RO_CAL2_AUTO_CAL_DONE_CNT_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_ADC_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/aes_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/aes_regs.h new file mode 100644 index 0000000000..035349ba8a --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/aes_regs.h @@ -0,0 +1,163 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_AES_REGS_H_ +#define _MXC_AES_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t ctrl; /* 0x0000 AES Control and Status */ + __I uint32_t rsv004; /* 0x0004 */ + __IO uint32_t erase_all; /* 0x0008 Write to Trigger AES Memory Erase */ +} mxc_aes_regs_t; + + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t inp[4]; /* 0x0000-0x000C AES Input (128 bits) */ + __IO uint32_t key[8]; /* 0x0010-0x002C AES Symmetric Key (up to 256 bits) */ + __IO uint32_t out[4]; /* 0x0030-0x003C AES Output Data (128 bits) */ + __IO uint32_t expkey[8]; /* 0x0040-0x005C AES Expanded Key Data (256 bits) */ +} mxc_aes_mem_regs_t; + + +/* + Register offsets for module AES. +*/ + +#define MXC_R_AES_OFFS_CTRL ((uint32_t)0x00000000UL) +#define MXC_R_AES_OFFS_ERASE_ALL ((uint32_t)0x00000008UL) +#define MXC_R_AES_MEM_OFFS_INP0 ((uint32_t)0x00000000UL) +#define MXC_R_AES_MEM_OFFS_INP1 ((uint32_t)0x00000004UL) +#define MXC_R_AES_MEM_OFFS_INP2 ((uint32_t)0x00000008UL) +#define MXC_R_AES_MEM_OFFS_INP3 ((uint32_t)0x0000000CUL) +#define MXC_R_AES_MEM_OFFS_KEY0 ((uint32_t)0x00000010UL) +#define MXC_R_AES_MEM_OFFS_KEY1 ((uint32_t)0x00000014UL) +#define MXC_R_AES_MEM_OFFS_KEY2 ((uint32_t)0x00000018UL) +#define MXC_R_AES_MEM_OFFS_KEY3 ((uint32_t)0x0000001CUL) +#define MXC_R_AES_MEM_OFFS_KEY4 ((uint32_t)0x00000020UL) +#define MXC_R_AES_MEM_OFFS_KEY5 ((uint32_t)0x00000024UL) +#define MXC_R_AES_MEM_OFFS_KEY6 ((uint32_t)0x00000028UL) +#define MXC_R_AES_MEM_OFFS_KEY7 ((uint32_t)0x0000002CUL) +#define MXC_R_AES_MEM_OFFS_OUT0 ((uint32_t)0x00000030UL) +#define MXC_R_AES_MEM_OFFS_OUT1 ((uint32_t)0x00000034UL) +#define MXC_R_AES_MEM_OFFS_OUT2 ((uint32_t)0x00000038UL) +#define MXC_R_AES_MEM_OFFS_OUT3 ((uint32_t)0x0000003CUL) +#define MXC_R_AES_MEM_OFFS_EXPKEY0 ((uint32_t)0x00000040UL) +#define MXC_R_AES_MEM_OFFS_EXPKEY1 ((uint32_t)0x00000044UL) +#define MXC_R_AES_MEM_OFFS_EXPKEY2 ((uint32_t)0x00000048UL) +#define MXC_R_AES_MEM_OFFS_EXPKEY3 ((uint32_t)0x0000004CUL) +#define MXC_R_AES_MEM_OFFS_EXPKEY4 ((uint32_t)0x00000050UL) +#define MXC_R_AES_MEM_OFFS_EXPKEY5 ((uint32_t)0x00000054UL) +#define MXC_R_AES_MEM_OFFS_EXPKEY6 ((uint32_t)0x00000058UL) +#define MXC_R_AES_MEM_OFFS_EXPKEY7 ((uint32_t)0x0000005CUL) + + +/* + Field positions and masks for module AES. +*/ + +#define MXC_F_AES_CTRL_START_POS 0 +#define MXC_F_AES_CTRL_START ((uint32_t)(0x00000001UL << MXC_F_AES_CTRL_START_POS)) +#define MXC_F_AES_CTRL_CRYPT_MODE_POS 1 +#define MXC_F_AES_CTRL_CRYPT_MODE ((uint32_t)(0x00000001UL << MXC_F_AES_CTRL_CRYPT_MODE_POS)) +#define MXC_F_AES_CTRL_EXP_KEY_MODE_POS 2 +#define MXC_F_AES_CTRL_EXP_KEY_MODE ((uint32_t)(0x00000001UL << MXC_F_AES_CTRL_EXP_KEY_MODE_POS)) +#define MXC_F_AES_CTRL_KEY_SIZE_POS 3 +#define MXC_F_AES_CTRL_KEY_SIZE ((uint32_t)(0x00000003UL << MXC_F_AES_CTRL_KEY_SIZE_POS)) +#define MXC_F_AES_CTRL_INTEN_POS 5 +#define MXC_F_AES_CTRL_INTEN ((uint32_t)(0x00000001UL << MXC_F_AES_CTRL_INTEN_POS)) +#define MXC_F_AES_CTRL_INTFL_POS 6 +#define MXC_F_AES_CTRL_INTFL ((uint32_t)(0x00000001UL << MXC_F_AES_CTRL_INTFL_POS)) + + + +/* + Field values and shifted values for module AES. +*/ + +#define MXC_V_AES_CTRL_ENCRYPT_MODE ((uint32_t)(0x00000000UL)) +#define MXC_V_AES_CTRL_DECRYPT_MODE ((uint32_t)(0x00000001UL)) + +#define MXC_S_AES_CTRL_ENCRYPT_MODE ((uint32_t)(MXC_V_AES_CTRL_ENCRYPT_MODE << MXC_F_AES_CTRL_CRYPT_MODE_POS)) +#define MXC_S_AES_CTRL_DECRYPT_MODE ((uint32_t)(MXC_V_AES_CTRL_DECRYPT_MODE << MXC_F_AES_CTRL_CRYPT_MODE_POS)) + +#define MXC_V_AES_CTRL_CALC_NEW_EXP_KEY ((uint32_t)(0x00000000UL)) +#define MXC_V_AES_CTRL_USE_LAST_EXP_KEY ((uint32_t)(0x00000001UL)) + +#define MXC_S_AES_CTRL_CALC_NEW_EXP_KEY ((uint32_t)(MXC_V_AES_CTRL_CALC_NEW_EXP_KEY << MXC_F_AES_CTRL_EXP_KEY_MODE_POS)) +#define MXC_S_AES_CTRL_USE_LAST_EXP_KEY ((uint32_t)(MXC_V_AES_CTRL_USE_LAST_EXP_KEY << MXC_F_AES_CTRL_EXP_KEY_MODE_POS)) + +#define MXC_V_AES_CTRL_KEY_SIZE_128 ((uint32_t)(0x00000000UL)) +#define MXC_V_AES_CTRL_KEY_SIZE_192 ((uint32_t)(0x00000001UL)) +#define MXC_V_AES_CTRL_KEY_SIZE_256 ((uint32_t)(0x00000002UL)) + +#define MXC_S_AES_CTRL_KEY_SIZE_128 ((uint32_t)(MXC_V_AES_CTRL_KEY_SIZE_128 << MXC_F_AES_CTRL_KEY_SIZE_POS)) +#define MXC_S_AES_CTRL_KEY_SIZE_192 ((uint32_t)(MXC_V_AES_CTRL_KEY_SIZE_192 << MXC_F_AES_CTRL_KEY_SIZE_POS)) +#define MXC_S_AES_CTRL_KEY_SIZE_256 ((uint32_t)(MXC_V_AES_CTRL_KEY_SIZE_256 << MXC_F_AES_CTRL_KEY_SIZE_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_AES_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/clkman_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/clkman_regs.h new file mode 100644 index 0000000000..cc1b5b3c8d --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/clkman_regs.h @@ -0,0 +1,426 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_CLKMAN_REGS_H_ +#define _MXC_CLKMAN_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t clk_config; /* 0x0000 System Clock Configuration */ + __IO uint32_t clk_ctrl; /* 0x0004 System Clock Controls */ + __IO uint32_t intfl; /* 0x0008 Interrupt Flags */ + __IO uint32_t inten; /* 0x000C Interrupt Enable/Disable Controls */ + __IO uint32_t trim_calc; /* 0x0010 Trim Calculation Controls */ + __IO uint32_t i2c_timer_ctrl; /* 0x0014 I2C Timer Control */ + __IO uint32_t cm4_start_clk_en0; /* 0x0018 CM4 Start Clock on Interrupt Enable 0 */ + __IO uint32_t cm4_start_clk_en1; /* 0x001C CM4 Start Clock on Interrupt Enable 1 */ + __I uint32_t rsv020[8]; /* 0x0020-0x003C */ + __IO uint32_t sys_clk_ctrl_0_cm4; /* 0x0040 Control Settings for CLK0 - Cortex M4 Clock */ + __IO uint32_t sys_clk_ctrl_1_sync; /* 0x0044 Control Settings for CLK1 - Synchronizer Clock */ + __IO uint32_t sys_clk_ctrl_2_spix; /* 0x0048 Control Settings for CLK2 - SPI XIP Clock */ + __IO uint32_t sys_clk_ctrl_3_prng; /* 0x004C Control Settings for CLK3 - PRNG Clock */ + __IO uint32_t sys_clk_ctrl_4_wdt0; /* 0x0050 Control Settings for CLK4 - Watchdog Timer 0 */ + __IO uint32_t sys_clk_ctrl_5_wdt1; /* 0x0054 Control Settings for CLK5 - Watchdog Timer 1 */ + __IO uint32_t sys_clk_ctrl_6_gpio; /* 0x0058 Control Settings for CLK6 - Clock for GPIO Ports */ + __IO uint32_t sys_clk_ctrl_7_pt; /* 0x005C Control Settings for CLK7 - Source Clock for All Pulse Trains */ + __IO uint32_t sys_clk_ctrl_8_uart; /* 0x0060 Control Settings for CLK8 - Source Clock for All UARTs */ + __IO uint32_t sys_clk_ctrl_9_i2cm; /* 0x0064 Control Settings for CLK9 - Source Clock for All I2C Masters */ + __IO uint32_t sys_clk_ctrl_10_i2cs; /* 0x0068 Control Settings for CLK10 - Source Clock for I2C Slave */ + __IO uint32_t sys_clk_ctrl_11_spi0; /* 0x006C Control Settings for CLK11 - SPI Master 0 */ + __IO uint32_t sys_clk_ctrl_12_spi1; /* 0x0070 Control Settings for CLK12 - SPI Master 1 */ + __IO uint32_t sys_clk_ctrl_13_spi2; /* 0x0074 Control Settings for CLK13 - SPI Master 2 */ + __IO uint32_t sys_clk_ctrl_14_spib; /* 0x0078 Control Settings for CLK14 - SPI Bridge Clock */ + __IO uint32_t sys_clk_ctrl_15_owm; /* 0x007C Control Settings for CLK15 - 1-Wire Master Clock */ + __I uint32_t rsv080[32]; /* 0x0080-0x00FC */ + __IO uint32_t crypt_clk_ctrl_0_aes; /* 0x0100 Control Settings for Crypto Clock 0 - AES */ + __IO uint32_t crypt_clk_ctrl_1_maa; /* 0x0104 Control Settings for Crypto Clock 1 - MAA */ + __IO uint32_t crypt_clk_ctrl_2_prng; /* 0x0108 Control Settings for Crypto Clock 2 - PRNG */ + __I uint32_t rsv10C[13]; /* 0x010C-0x013C */ + __IO uint32_t clk_gate_ctrl0; /* 0x0140 Dynamic Clock Gating Control Register 0 */ + __IO uint32_t clk_gate_ctrl1; /* 0x0144 Dynamic Clock Gating Control Register 1 */ + __IO uint32_t clk_gate_ctrl2; /* 0x0148 Dynamic Clock Gating Control Register 2 */ +} mxc_clkman_regs_t; + + +/* + Register offsets for module CLKMAN. +*/ + +#define MXC_R_CLKMAN_OFFS_CLK_CONFIG ((uint32_t)0x00000000UL) +#define MXC_R_CLKMAN_OFFS_CLK_CTRL ((uint32_t)0x00000004UL) +#define MXC_R_CLKMAN_OFFS_INTFL ((uint32_t)0x00000008UL) +#define MXC_R_CLKMAN_OFFS_INTEN ((uint32_t)0x0000000CUL) +#define MXC_R_CLKMAN_OFFS_TRIM_CALC ((uint32_t)0x00000010UL) +#define MXC_R_CLKMAN_OFFS_I2C_TIMER_CTRL ((uint32_t)0x00000014UL) +#define MXC_R_CLKMAN_OFFS_CM4_START_CLK_EN0 ((uint32_t)0x00000018UL) +#define MXC_R_CLKMAN_OFFS_CM4_START_CLK_EN1 ((uint32_t)0x0000001CUL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_0_CM4 ((uint32_t)0x00000040UL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_1_SYNC ((uint32_t)0x00000044UL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_2_SPIX ((uint32_t)0x00000048UL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_3_PRNG ((uint32_t)0x0000004CUL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_4_WDT0 ((uint32_t)0x00000050UL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_5_WDT1 ((uint32_t)0x00000054UL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_6_GPIO ((uint32_t)0x00000058UL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_7_PT ((uint32_t)0x0000005CUL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_8_UART ((uint32_t)0x00000060UL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_9_I2CM ((uint32_t)0x00000064UL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_10_I2CS ((uint32_t)0x00000068UL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_11_SPI0 ((uint32_t)0x0000006CUL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_12_SPI1 ((uint32_t)0x00000070UL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_13_SPI2 ((uint32_t)0x00000074UL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_14_SPIB ((uint32_t)0x00000078UL) +#define MXC_R_CLKMAN_OFFS_SYS_CLK_CTRL_15_OWM ((uint32_t)0x0000007CUL) +#define MXC_R_CLKMAN_OFFS_CRYPT_CLK_CTRL_0_AES ((uint32_t)0x00000100UL) +#define MXC_R_CLKMAN_OFFS_CRYPT_CLK_CTRL_1_MAA ((uint32_t)0x00000104UL) +#define MXC_R_CLKMAN_OFFS_CRYPT_CLK_CTRL_2_PRNG ((uint32_t)0x00000108UL) +#define MXC_R_CLKMAN_OFFS_CLK_GATE_CTRL0 ((uint32_t)0x00000140UL) +#define MXC_R_CLKMAN_OFFS_CLK_GATE_CTRL1 ((uint32_t)0x00000144UL) +#define MXC_R_CLKMAN_OFFS_CLK_GATE_CTRL2 ((uint32_t)0x00000148UL) + + +/* + Field positions and masks for module CLKMAN. +*/ + +#define MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_ENABLE_POS 0 +#define MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_ENABLE ((uint32_t)(0x00000001UL << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_ENABLE_POS)) +#define MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS 4 +#define MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) + +#define MXC_F_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT_POS 0 +#define MXC_F_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT_POS)) +#define MXC_F_CLKMAN_CLK_CTRL_USB_CLOCK_ENABLE_POS 4 +#define MXC_F_CLKMAN_CLK_CTRL_USB_CLOCK_ENABLE ((uint32_t)(0x00000001UL << MXC_F_CLKMAN_CLK_CTRL_USB_CLOCK_ENABLE_POS)) +#define MXC_F_CLKMAN_CLK_CTRL_USB_CLOCK_SELECT_POS 5 +#define MXC_F_CLKMAN_CLK_CTRL_USB_CLOCK_SELECT ((uint32_t)(0x00000001UL << MXC_F_CLKMAN_CLK_CTRL_USB_CLOCK_SELECT_POS)) +#define MXC_F_CLKMAN_CLK_CTRL_CRYPTO_CLOCK_ENABLE_POS 8 +#define MXC_F_CLKMAN_CLK_CTRL_CRYPTO_CLOCK_ENABLE ((uint32_t)(0x00000001UL << MXC_F_CLKMAN_CLK_CTRL_CRYPTO_CLOCK_ENABLE_POS)) +#define MXC_F_CLKMAN_CLK_CTRL_RTOS_MODE_POS 12 +#define MXC_F_CLKMAN_CLK_CTRL_RTOS_MODE ((uint32_t)(0x00000001UL << MXC_F_CLKMAN_CLK_CTRL_RTOS_MODE_POS)) +#define MXC_F_CLKMAN_CLK_CTRL_WDT0_CLOCK_ENABLE_POS 16 +#define MXC_F_CLKMAN_CLK_CTRL_WDT0_CLOCK_ENABLE ((uint32_t)(0x00000001UL << MXC_F_CLKMAN_CLK_CTRL_WDT0_CLOCK_ENABLE_POS)) +#define MXC_F_CLKMAN_CLK_CTRL_WDT0_CLOCK_SELECT_POS 17 +#define MXC_F_CLKMAN_CLK_CTRL_WDT0_CLOCK_SELECT ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_CTRL_WDT0_CLOCK_SELECT_POS)) +#define MXC_F_CLKMAN_CLK_CTRL_WDT1_CLOCK_ENABLE_POS 20 +#define MXC_F_CLKMAN_CLK_CTRL_WDT1_CLOCK_ENABLE ((uint32_t)(0x00000001UL << MXC_F_CLKMAN_CLK_CTRL_WDT1_CLOCK_ENABLE_POS)) +#define MXC_F_CLKMAN_CLK_CTRL_WDT1_CLOCK_SELECT_POS 21 +#define MXC_F_CLKMAN_CLK_CTRL_WDT1_CLOCK_SELECT ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_CTRL_WDT1_CLOCK_SELECT_POS)) +#define MXC_F_CLKMAN_CLK_CTRL_ADC_CLOCK_ENABLE_POS 24 +#define MXC_F_CLKMAN_CLK_CTRL_ADC_CLOCK_ENABLE ((uint32_t)(0x00000001UL << MXC_F_CLKMAN_CLK_CTRL_ADC_CLOCK_ENABLE_POS)) + +#define MXC_F_CLKMAN_INTFL_CRYPTO_STABLE_POS 0 +#define MXC_F_CLKMAN_INTFL_CRYPTO_STABLE ((uint32_t)(0x00000001UL << MXC_F_CLKMAN_INTFL_CRYPTO_STABLE_POS)) + +#define MXC_F_CLKMAN_INTEN_CRYPTO_STABLE_POS 0 +#define MXC_F_CLKMAN_INTEN_CRYPTO_STABLE ((uint32_t)(0x00000001UL << MXC_F_CLKMAN_INTEN_CRYPTO_STABLE_POS)) + +#define MXC_F_CLKMAN_TRIM_CALC_TRIM_CLK_SEL_POS 0 +#define MXC_F_CLKMAN_TRIM_CALC_TRIM_CLK_SEL ((uint32_t)(0x00000001UL << MXC_F_CLKMAN_TRIM_CALC_TRIM_CLK_SEL_POS)) +#define MXC_F_CLKMAN_TRIM_CALC_TRIM_CALC_START_POS 1 +#define MXC_F_CLKMAN_TRIM_CALC_TRIM_CALC_START ((uint32_t)(0x00000001UL << MXC_F_CLKMAN_TRIM_CALC_TRIM_CALC_START_POS)) +#define MXC_F_CLKMAN_TRIM_CALC_TRIM_CALC_COMPLETED_POS 2 +#define MXC_F_CLKMAN_TRIM_CALC_TRIM_CALC_COMPLETED ((uint32_t)(0x00000001UL << MXC_F_CLKMAN_TRIM_CALC_TRIM_CALC_COMPLETED_POS)) +#define MXC_F_CLKMAN_TRIM_CALC_TRIM_ENABLE_POS 3 +#define MXC_F_CLKMAN_TRIM_CALC_TRIM_ENABLE ((uint32_t)(0x00000001UL << MXC_F_CLKMAN_TRIM_CALC_TRIM_ENABLE_POS)) +#define MXC_F_CLKMAN_TRIM_CALC_TRIM_CALC_RESULTS_POS 16 +#define MXC_F_CLKMAN_TRIM_CALC_TRIM_CALC_RESULTS ((uint32_t)(0x000003FFUL << MXC_F_CLKMAN_TRIM_CALC_TRIM_CALC_RESULTS_POS)) + +#define MXC_F_CLKMAN_I2C_TIMER_CTRL_I2C_1MS_TIMER_EN_POS 0 +#define MXC_F_CLKMAN_I2C_TIMER_CTRL_I2C_1MS_TIMER_EN ((uint32_t)(0x00000001UL << MXC_F_CLKMAN_I2C_TIMER_CTRL_I2C_1MS_TIMER_EN_POS)) + +#define MXC_F_CLKMAN_CM4_START_CLK_EN0_INTS_POS 0 +#define MXC_F_CLKMAN_CM4_START_CLK_EN0_INTS ((uint32_t)(0xFFFFFFFFUL << MXC_F_CLKMAN_CM4_START_CLK_EN0_INTS_POS)) + +#define MXC_F_CLKMAN_CM4_START_CLK_EN1_INTS_POS 0 +#define MXC_F_CLKMAN_CM4_START_CLK_EN1_INTS ((uint32_t)(0xFFFFFFFFUL << MXC_F_CLKMAN_CM4_START_CLK_EN1_INTS_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_0_CM4_CM4_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_0_CM4_CM4_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_0_CM4_CM4_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_1_SYNC_SYNC_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_1_SYNC_SYNC_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_1_SYNC_SYNC_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_2_SPIX_SPIX_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_2_SPIX_SPIX_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_2_SPIX_SPIX_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_3_PRNG_PRNG_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_3_PRNG_PRNG_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_3_PRNG_PRNG_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_4_WDT0_WATCHDOG0_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_4_WDT0_WATCHDOG0_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_4_WDT0_WATCHDOG0_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_5_WDT1_WATCHDOG1_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_5_WDT1_WATCHDOG1_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_5_WDT1_WATCHDOG1_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_6_GPIO_GPIO_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_6_GPIO_GPIO_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_6_GPIO_GPIO_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_7_PT_PULSE_TRAIN_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_7_PT_PULSE_TRAIN_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_7_PT_PULSE_TRAIN_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_8_UART_UART_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_8_UART_UART_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_8_UART_UART_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_9_I2CM_I2CM_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_9_I2CM_I2CM_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_9_I2CM_I2CM_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_10_I2CS_I2CS_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_10_I2CS_I2CS_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_10_I2CS_I2CS_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_11_SPI0_SPI0_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_11_SPI0_SPI0_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_11_SPI0_SPI0_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_12_SPI1_SPI1_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_12_SPI1_SPI1_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_12_SPI1_SPI1_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_13_SPI2_SPI2_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_13_SPI2_SPI2_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_13_SPI2_SPI2_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_14_SPIB_SPIB_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_14_SPIB_SPIB_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_14_SPIB_SPIB_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_SYS_CLK_CTRL_15_OWM_OWM_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_SYS_CLK_CTRL_15_OWM_OWM_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_SYS_CLK_CTRL_15_OWM_OWM_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_CRYPT_CLK_CTRL_0_AES_AES_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_CRYPT_CLK_CTRL_0_AES_AES_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_CRYPT_CLK_CTRL_0_AES_AES_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_CRYPT_CLK_CTRL_1_MAA_MAA_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_CRYPT_CLK_CTRL_1_MAA_MAA_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_CRYPT_CLK_CTRL_1_MAA_MAA_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_CRYPT_CLK_CTRL_2_PRNG_PRNG_CLK_SCALE_POS 0 +#define MXC_F_CLKMAN_CRYPT_CLK_CTRL_2_PRNG_PRNG_CLK_SCALE ((uint32_t)(0x0000000FUL << MXC_F_CLKMAN_CRYPT_CLK_CTRL_2_PRNG_PRNG_CLK_SCALE_POS)) + +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_CM4_CLK_GATER_POS 0 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_CM4_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_CM4_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_AHB32_CLK_GATER_POS 2 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_AHB32_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_AHB32_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_ICACHE_CLK_GATER_POS 4 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_ICACHE_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_ICACHE_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_FLASH_CLK_GATER_POS 6 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_FLASH_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_FLASH_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_SRAM_CLK_GATER_POS 8 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_SRAM_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_SRAM_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_APB_BRIDGE_CLK_GATER_POS 10 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_APB_BRIDGE_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_APB_BRIDGE_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_SYSMAN_CLK_GATER_POS 12 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_SYSMAN_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_SYSMAN_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_PTP_CLK_GATER_POS 14 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_PTP_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_PTP_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_SSB_MUX_CLK_GATER_POS 16 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_SSB_MUX_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_SSB_MUX_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_PAD_CLK_GATER_POS 18 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_PAD_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_PAD_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_SPIX_CLK_GATER_POS 20 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_SPIX_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_SPIX_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_PMU_CLK_GATER_POS 22 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_PMU_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_PMU_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_USB_CLK_GATER_POS 24 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_USB_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_USB_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_CRC_CLK_GATER_POS 26 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_CRC_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_CRC_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_TPU_CLK_GATER_POS 28 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_TPU_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_TPU_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_WATCHDOG0_CLK_GATER_POS 30 +#define MXC_F_CLKMAN_CLK_GATE_CTRL0_WATCHDOG0_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL0_WATCHDOG0_CLK_GATER_POS)) + +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_WATCHDOG1_CLK_GATER_POS 0 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_WATCHDOG1_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_WATCHDOG1_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_GPIO_CLK_GATER_POS 2 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_GPIO_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_GPIO_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER0_CLK_GATER_POS 4 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER0_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER0_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER1_CLK_GATER_POS 6 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER1_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER1_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER2_CLK_GATER_POS 8 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER2_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER2_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER3_CLK_GATER_POS 10 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER3_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER3_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER4_CLK_GATER_POS 12 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER4_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER4_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER5_CLK_GATER_POS 14 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER5_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER5_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_PULSETRAIN_CLK_GATER_POS 16 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_PULSETRAIN_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_PULSETRAIN_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_UART0_CLK_GATER_POS 18 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_UART0_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_UART0_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_UART1_CLK_GATER_POS 20 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_UART1_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_UART1_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_UART2_CLK_GATER_POS 22 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_UART2_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_UART2_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_UART3_CLK_GATER_POS 24 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_UART3_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_UART3_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_I2CM0_CLK_GATER_POS 26 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_I2CM0_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_I2CM0_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_I2CM1_CLK_GATER_POS 28 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_I2CM1_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_I2CM1_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_I2CM2_CLK_GATER_POS 30 +#define MXC_F_CLKMAN_CLK_GATE_CTRL1_I2CM2_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL1_I2CM2_CLK_GATER_POS)) + +#define MXC_F_CLKMAN_CLK_GATE_CTRL2_I2CS_CLK_GATER_POS 0 +#define MXC_F_CLKMAN_CLK_GATE_CTRL2_I2CS_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL2_I2CS_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL2_SPI0_CLK_GATER_POS 2 +#define MXC_F_CLKMAN_CLK_GATE_CTRL2_SPI0_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL2_SPI0_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL2_SPI1_CLK_GATER_POS 4 +#define MXC_F_CLKMAN_CLK_GATE_CTRL2_SPI1_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL2_SPI1_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL2_SPI2_CLK_GATER_POS 6 +#define MXC_F_CLKMAN_CLK_GATE_CTRL2_SPI2_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL2_SPI2_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL2_SPI_BRIDGE_CLK_GATER_POS 8 +#define MXC_F_CLKMAN_CLK_GATE_CTRL2_SPI_BRIDGE_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL2_SPI_BRIDGE_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL2_OWM_CLK_GATER_POS 10 +#define MXC_F_CLKMAN_CLK_GATE_CTRL2_OWM_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL2_OWM_CLK_GATER_POS)) +#define MXC_F_CLKMAN_CLK_GATE_CTRL2_ADC_CLK_GATER_POS 12 +#define MXC_F_CLKMAN_CLK_GATE_CTRL2_ADC_CLK_GATER ((uint32_t)(0x00000003UL << MXC_F_CLKMAN_CLK_GATE_CTRL2_ADC_CLK_GATER_POS)) + + + +/* + Field values and shifted values for module CLKMAN. +*/ + +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_8_CLOCKS ((uint32_t)(0x00000000UL)) +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_9_CLOCKS ((uint32_t)(0x00000001UL)) +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_10_CLOCKS ((uint32_t)(0x00000002UL)) +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_11_CLOCKS ((uint32_t)(0x00000003UL)) +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_12_CLOCKS ((uint32_t)(0x00000004UL)) +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_13_CLOCKS ((uint32_t)(0x00000005UL)) +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_14_CLOCKS ((uint32_t)(0x00000006UL)) +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_15_CLOCKS ((uint32_t)(0x00000007UL)) +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_16_CLOCKS ((uint32_t)(0x00000008UL)) +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_17_CLOCKS ((uint32_t)(0x00000009UL)) +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_18_CLOCKS ((uint32_t)(0x0000000AUL)) +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_19_CLOCKS ((uint32_t)(0x0000000BUL)) +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_20_CLOCKS ((uint32_t)(0x0000000CUL)) +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_21_CLOCKS ((uint32_t)(0x0000000DUL)) +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_22_CLOCKS ((uint32_t)(0x0000000EUL)) +#define MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_23_CLOCKS ((uint32_t)(0x0000000FUL)) + +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_8_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_8_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_9_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_9_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_10_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_10_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_11_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_11_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_12_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_12_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_13_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_13_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_14_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_14_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_15_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_15_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_16_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_16_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_17_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_17_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_18_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_18_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_19_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_19_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_20_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_20_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_21_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_21_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_22_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_22_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) +#define MXC_S_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_23_CLOCKS ((uint32_t)(MXC_V_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_2_EXP_23_CLOCKS << MXC_F_CLKMAN_CLK_CONFIG_CRYPTO_STABILITY_COUNT_POS)) + +#define MXC_V_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT_96MHZ_RO_DIV_2 ((uint32_t)(0x00000000UL)) +#define MXC_V_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT_96MHZ_RO ((uint32_t)(0x00000001UL)) + +#define MXC_S_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT_96MHZ_RO_DIV_2 ((uint32_t)(MXC_V_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT_96MHZ_RO_DIV_2 << MXC_F_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT_POS)) +#define MXC_S_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT_96MHZ_RO ((uint32_t)(MXC_V_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT_96MHZ_RO << MXC_F_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT_POS)) + +#define MXC_V_CLKMAN_WDT0_CLOCK_SELECT_SCALED_SYS_CLK_CTRL_4_WDT0 ((uint32_t)(0x00000000UL)) +#define MXC_V_CLKMAN_WDT0_CLOCK_SELECT_32KHZ_RTC_OSCILLATOR ((uint32_t)(0x00000001UL)) +#define MXC_V_CLKMAN_WDT0_CLOCK_SELECT_96MHZ_OSCILLATOR ((uint32_t)(0x00000002UL)) +#define MXC_V_CLKMAN_WDT0_CLOCK_SELECT_NANO_RING_OSCILLATOR ((uint32_t)(0x00000003UL)) + +#define MXC_S_CLKMAN_WDT0_CLOCK_SELECT_SCALED_SYS_CLK_CTRL_4_WDT0 ((uint32_t)(MXC_V_CLKMAN_WDT0_CLOCK_SELECT_SCALED_SYS_CLK_CTRL_4_WDT0 << MXC_F_CLKMAN_CLK_CTRL_WDT0_CLOCK_SELECT_POS)) +#define MXC_S_CLKMAN_WDT0_CLOCK_SELECT_32KHZ_RTC_OSCILLATOR ((uint32_t)(MXC_V_CLKMAN_WDT0_CLOCK_SELECT_32KHZ_RTC_OSCILLATOR << MXC_F_CLKMAN_CLK_CTRL_WDT0_CLOCK_SELECT_POS)) +#define MXC_S_CLKMAN_WDT0_CLOCK_SELECT_96MHZ_OSCILLATOR ((uint32_t)(MXC_V_CLKMAN_WDT0_CLOCK_SELECT_96MHZ_OSCILLATOR << MXC_F_CLKMAN_CLK_CTRL_WDT0_CLOCK_SELECT_POS)) +#define MXC_S_CLKMAN_WDT0_CLOCK_SELECT_NANO_RING_OSCILLATOR ((uint32_t)(MXC_V_CLKMAN_WDT0_CLOCK_SELECT_NANO_RING_OSCILLATOR << MXC_F_CLKMAN_CLK_CTRL_WDT0_CLOCK_SELECT_POS)) + +#define MXC_V_CLKMAN_WDT1_CLOCK_SELECT_SCALED_SYS_CLK_CTRL_4_WDT1 ((uint32_t)(0x00000000UL)) +#define MXC_V_CLKMAN_WDT1_CLOCK_SELECT_32KHZ_RTC_OSCILLATOR ((uint32_t)(0x00000001UL)) +#define MXC_V_CLKMAN_WDT1_CLOCK_SELECT_96MHZ_OSCILLATOR ((uint32_t)(0x00000002UL)) +#define MXC_V_CLKMAN_WDT1_CLOCK_SELECT_NANO_RING_OSCILLATOR ((uint32_t)(0x00000003UL)) + +#define MXC_S_CLKMAN_WDT1_CLOCK_SELECT_SCALED_SYS_CLK_CTRL_4_WDT1 ((uint32_t)(MXC_V_CLKMAN_WDT1_CLOCK_SELECT_SCALED_SYS_CLK_CTRL_4_WDT1 << MXC_F_CLKMAN_CLK_CTRL_WDT1_CLOCK_SELECT_POS)) +#define MXC_S_CLKMAN_WDT1_CLOCK_SELECT_32KHZ_RTC_OSCILLATOR ((uint32_t)(MXC_V_CLKMAN_WDT1_CLOCK_SELECT_32KHZ_RTC_OSCILLATOR << MXC_F_CLKMAN_CLK_CTRL_WDT1_CLOCK_SELECT_POS)) +#define MXC_S_CLKMAN_WDT1_CLOCK_SELECT_96MHZ_OSCILLATOR ((uint32_t)(MXC_V_CLKMAN_WDT1_CLOCK_SELECT_96MHZ_OSCILLATOR << MXC_F_CLKMAN_CLK_CTRL_WDT1_CLOCK_SELECT_POS)) +#define MXC_S_CLKMAN_WDT1_CLOCK_SELECT_NANO_RING_OSCILLATOR ((uint32_t)(MXC_V_CLKMAN_WDT1_CLOCK_SELECT_NANO_RING_OSCILLATOR << MXC_F_CLKMAN_CLK_CTRL_WDT1_CLOCK_SELECT_POS)) + +#define MXC_V_CLKMAN_CLK_SCALE_DISABLED ((uint32_t)(0x00000000UL)) +#define MXC_V_CLKMAN_CLK_SCALE_DIV_1 ((uint32_t)(0x00000001UL)) +#define MXC_V_CLKMAN_CLK_SCALE_DIV_2 ((uint32_t)(0x00000002UL)) +#define MXC_V_CLKMAN_CLK_SCALE_DIV_4 ((uint32_t)(0x00000003UL)) +#define MXC_V_CLKMAN_CLK_SCALE_DIV_8 ((uint32_t)(0x00000004UL)) +#define MXC_V_CLKMAN_CLK_SCALE_DIV_16 ((uint32_t)(0x00000005UL)) +#define MXC_V_CLKMAN_CLK_SCALE_DIV_32 ((uint32_t)(0x00000006UL)) +#define MXC_V_CLKMAN_CLK_SCALE_DIV_64 ((uint32_t)(0x00000007UL)) +#define MXC_V_CLKMAN_CLK_SCALE_DIV_128 ((uint32_t)(0x00000008UL)) +#define MXC_V_CLKMAN_CLK_SCALE_DIV_256 ((uint32_t)(0x00000009UL)) + +#define MXC_S_CLKMAN_CLK_SCALE_DISABLED ((uint32_t)(MXC_V_CLKMAN_CLK_SCALE_DISABLED << MXC_F_CLKMAN_SYS_CLK_CTRL_0_CM4_CM4_CLK_SCALE_POS)) +#define MXC_S_CLKMAN_CLK_SCALE_DIV_1 ((uint32_t)(MXC_V_CLKMAN_CLK_SCALE_DIV_1 << MXC_F_CLKMAN_SYS_CLK_CTRL_0_CM4_CM4_CLK_SCALE_POS)) +#define MXC_S_CLKMAN_CLK_SCALE_DIV_2 ((uint32_t)(MXC_V_CLKMAN_CLK_SCALE_DIV_2 << MXC_F_CLKMAN_SYS_CLK_CTRL_0_CM4_CM4_CLK_SCALE_POS)) +#define MXC_S_CLKMAN_CLK_SCALE_DIV_4 ((uint32_t)(MXC_V_CLKMAN_CLK_SCALE_DIV_4 << MXC_F_CLKMAN_SYS_CLK_CTRL_0_CM4_CM4_CLK_SCALE_POS)) +#define MXC_S_CLKMAN_CLK_SCALE_DIV_8 ((uint32_t)(MXC_V_CLKMAN_CLK_SCALE_DIV_8 << MXC_F_CLKMAN_SYS_CLK_CTRL_0_CM4_CM4_CLK_SCALE_POS)) +#define MXC_S_CLKMAN_CLK_SCALE_DIV_16 ((uint32_t)(MXC_V_CLKMAN_CLK_SCALE_DIV_16 << MXC_F_CLKMAN_SYS_CLK_CTRL_0_CM4_CM4_CLK_SCALE_POS)) +#define MXC_S_CLKMAN_CLK_SCALE_DIV_32 ((uint32_t)(MXC_V_CLKMAN_CLK_SCALE_DIV_32 << MXC_F_CLKMAN_SYS_CLK_CTRL_0_CM4_CM4_CLK_SCALE_POS)) +#define MXC_S_CLKMAN_CLK_SCALE_DIV_64 ((uint32_t)(MXC_V_CLKMAN_CLK_SCALE_DIV_64 << MXC_F_CLKMAN_SYS_CLK_CTRL_0_CM4_CM4_CLK_SCALE_POS)) +#define MXC_S_CLKMAN_CLK_SCALE_DIV_128 ((uint32_t)(MXC_V_CLKMAN_CLK_SCALE_DIV_128 << MXC_F_CLKMAN_SYS_CLK_CTRL_0_CM4_CM4_CLK_SCALE_POS)) +#define MXC_S_CLKMAN_CLK_SCALE_DIV_256 ((uint32_t)(MXC_V_CLKMAN_CLK_SCALE_DIV_256 << MXC_F_CLKMAN_SYS_CLK_CTRL_0_CM4_CM4_CLK_SCALE_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_CLKMAN_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/cmsis.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/cmsis.h new file mode 100644 index 0000000000..075790296e --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/cmsis.h @@ -0,0 +1,40 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef MBED_CMSIS_H +#define MBED_CMSIS_H + +#include "max32620.h" +#include "cmsis_nvic.h" + +#endif diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/cmsis_nvic.c b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/cmsis_nvic.c new file mode 100644 index 0000000000..98cfd205a6 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/cmsis_nvic.c @@ -0,0 +1,65 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include "cmsis_nvic.h" + +#if defined(TOOLCHAIN_GCC_ARM) || defined(TOOLCHAIN_ARM_STD) +__attribute__((aligned(256))) +#endif +#if defined(TOOLCHAIN_IAR) +#pragma data_alignment=256 +#endif +static void (*ramVectorTable[MXC_IRQ_COUNT])(void); + +void NVIC_SetVector(IRQn_Type IRQn, uint32_t vector) +{ + uint32_t *vectors = (uint32_t*)SCB->VTOR; + uint32_t i; + + // Copy and switch to dynamic vectors if the first time called + if (SCB->VTOR != (uint32_t)ramVectorTable) { + uint32_t *old_vectors = (uint32_t*)SCB->VTOR; + vectors = (uint32_t*)ramVectorTable; + for (i = 0; i < NVIC_NUM_VECTORS; i++) { + vectors[i] = old_vectors[i]; + } + SCB->VTOR = (uint32_t)ramVectorTable; + } + vectors[IRQn + NVIC_USER_IRQ_OFFSET] = vector; +} + +uint32_t NVIC_GetVector(IRQn_Type IRQn) +{ + uint32_t *vectors = (uint32_t*)SCB->VTOR; + return vectors[IRQn + NVIC_USER_IRQ_OFFSET]; +} diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/cmsis_nvic.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/cmsis_nvic.h new file mode 100644 index 0000000000..91c94e7c9b --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/cmsis_nvic.h @@ -0,0 +1,53 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef MBED_CMSIS_NVIC_H +#define MBED_CMSIS_NVIC_H + +#include "cmsis.h" + +#define NVIC_NUM_VECTORS MXC_IRQ_COUNT +#define NVIC_USER_IRQ_OFFSET 16 + +#ifdef __cplusplus +extern "C" { +#endif + +void NVIC_SetVector(IRQn_Type IRQn, uint32_t vector); +uint32_t NVIC_GetVector(IRQn_Type IRQn); + +#ifdef __cplusplus +} +#endif + +#endif /* MBED_CMSIS_NVIC_H */ diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/crc_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/crc_regs.h new file mode 100644 index 0000000000..55e3d1ab3e --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/crc_regs.h @@ -0,0 +1,106 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_CRC_REGS_H_ +#define _MXC_CRC_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t reseed; /* 0x0000 CRC-16/CRC-32 Reseed Controls */ + __IO uint32_t seed16; /* 0x0004 Reseed Value for CRC-16 Calculations */ + __IO uint32_t seed32; /* 0x0008 Reseed Value for CRC-32 Calculations */ +} mxc_crc_regs_t; + + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t value16[512]; /* 0x0000-0x07FC Write Next CRC-16 Data Value / Read CRC-16 Result Value */ + __IO uint32_t value32[512]; /* 0x0800-0x0FFC Write Next CRC-32 Data Value / Read CRC-32 Result Value */ +} mxc_crc_data_regs_t; + + +/* + Register offsets for module CRC. +*/ + +#define MXC_R_CRC_OFFS_RESEED ((uint32_t)0x00000000UL) +#define MXC_R_CRC_OFFS_SEED16 ((uint32_t)0x00000004UL) +#define MXC_R_CRC_OFFS_SEED32 ((uint32_t)0x00000008UL) +#define MXC_R_CRC_DATA_OFFS_VALUE16 ((uint32_t)0x00000000UL) +#define MXC_R_CRC_DATA_OFFS_VALUE32 ((uint32_t)0x00000800UL) + + +/* + Field positions and masks for module CRC. +*/ + +#define MXC_F_CRC_RESEED_CRC16_POS 0 +#define MXC_F_CRC_RESEED_CRC16 ((uint32_t)(0x00000001UL << MXC_F_CRC_RESEED_CRC16_POS)) +#define MXC_F_CRC_RESEED_CRC32_POS 1 +#define MXC_F_CRC_RESEED_CRC32 ((uint32_t)(0x00000001UL << MXC_F_CRC_RESEED_CRC32_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_CRC_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/flc_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/flc_regs.h new file mode 100644 index 0000000000..e39bcf1832 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/flc_regs.h @@ -0,0 +1,224 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_FLC_REGS_H_ +#define _MXC_FLC_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +#define MXC_V_FLC_ERASE_CODE_PAGE_ERASE ((uint8_t)0x55) +#define MXC_V_FLC_ERASE_CODE_MASS_ERASE ((uint8_t)0xAA) +#define MXC_V_FLC_FLSH_UNLOCK_KEY ((uint8_t)0x2) + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t faddr; /* 0x0000 Flash Operation Address */ + __IO uint32_t fckdiv; /* 0x0004 Flash Clock Pulse Divisor */ + __IO uint32_t ctrl; /* 0x0008 Flash Control Register */ + __I uint32_t rsv00C[6]; /* 0x000C-0x0020 */ + __IO uint32_t intr; /* 0x0024 Flash Controller Interrupt Flags and Enable/Disable 0 */ + __I uint32_t rsv028[2]; /* 0x0028-0x002C */ + __IO uint32_t fdata; /* 0x0030 Flash Operation Data Register */ + __I uint32_t rsv034[7]; /* 0x0034-0x004C */ + __IO uint32_t perform; /* 0x0050 Flash Performance Settings */ + __I uint32_t rsv054[11]; /* 0x0054-0x007C */ + __IO uint32_t status; /* 0x0080 Security Status Flags */ + __I uint32_t rsv084; /* 0x0084 */ + __IO uint32_t security; /* 0x0088 Flash Controller Security Settings */ + __I uint32_t rsv08C[4]; /* 0x008C-0x0098 */ + __IO uint32_t bypass; /* 0x009C Status Flags for DSB Operations */ + __I uint32_t rsv0A0[24]; /* 0x00A0-0x00FC */ + __IO uint32_t user_option; /* 0x0100 Used to set DSB Access code and Auto-Lock in info block */ + __I uint32_t rsv104[15]; /* 0x0104-0x013C */ + __IO uint32_t ctrl2; /* 0x0140 Flash Control Register 2 */ + __IO uint32_t intfl1; /* 0x0144 Interrupt Flags Register 1 */ + __IO uint32_t inten1; /* 0x0148 Interrupt Enable/Disable Register 1 */ + __I uint32_t rsv14C[9]; /* 0x014C-0x016C */ + __IO uint32_t bl_ctrl; /* 0x0170 Bootloader Control Register */ + __IO uint32_t twk; /* 0x0174 FLC TWK Cycle Count */ + __I uint32_t rsv178; /* 0x0178 */ + __IO uint32_t slm; /* 0x017C Sleep Mode Register */ +} mxc_flc_regs_t; + + +/* + Register offsets for module FLC. +*/ + +#define MXC_R_FLC_OFFS_FADDR ((uint32_t)0x00000000UL) +#define MXC_R_FLC_OFFS_FCKDIV ((uint32_t)0x00000004UL) +#define MXC_R_FLC_OFFS_CTRL ((uint32_t)0x00000008UL) +#define MXC_R_FLC_OFFS_INTR ((uint32_t)0x00000024UL) +#define MXC_R_FLC_OFFS_FDATA ((uint32_t)0x00000030UL) +#define MXC_R_FLC_OFFS_PERFORM ((uint32_t)0x00000050UL) +#define MXC_R_FLC_OFFS_STATUS ((uint32_t)0x00000080UL) +#define MXC_R_FLC_OFFS_SECURITY ((uint32_t)0x00000088UL) +#define MXC_R_FLC_OFFS_BYPASS ((uint32_t)0x0000009CUL) +#define MXC_R_FLC_OFFS_USER_OPTION ((uint32_t)0x00000100UL) +#define MXC_R_FLC_OFFS_CTRL2 ((uint32_t)0x00000140UL) +#define MXC_R_FLC_OFFS_INTFL1 ((uint32_t)0x00000144UL) +#define MXC_R_FLC_OFFS_INTEN1 ((uint32_t)0x00000148UL) +#define MXC_R_FLC_OFFS_BL_CTRL ((uint32_t)0x00000170UL) +#define MXC_R_FLC_OFFS_TWK ((uint32_t)0x00000174UL) +#define MXC_R_FLC_OFFS_SLM ((uint32_t)0x0000017CUL) + + +/* + Field positions and masks for module FLC. +*/ + +#define MXC_F_FLC_FADDR_FADDR_POS 0 +#define MXC_F_FLC_FADDR_FADDR ((uint32_t)(0x003FFFFFUL << MXC_F_FLC_FADDR_FADDR_POS)) + +#define MXC_F_FLC_FCKDIV_FCKDIV_POS 0 +#define MXC_F_FLC_FCKDIV_FCKDIV ((uint32_t)(0x0000007FUL << MXC_F_FLC_FCKDIV_FCKDIV_POS)) + +#define MXC_F_FLC_CTRL_WRITE_POS 0 +#define MXC_F_FLC_CTRL_WRITE ((uint32_t)(0x00000001UL << MXC_F_FLC_CTRL_WRITE_POS)) +#define MXC_F_FLC_CTRL_MASS_ERASE_POS 1 +#define MXC_F_FLC_CTRL_MASS_ERASE ((uint32_t)(0x00000001UL << MXC_F_FLC_CTRL_MASS_ERASE_POS)) +#define MXC_F_FLC_CTRL_PAGE_ERASE_POS 2 +#define MXC_F_FLC_CTRL_PAGE_ERASE ((uint32_t)(0x00000001UL << MXC_F_FLC_CTRL_PAGE_ERASE_POS)) +#define MXC_F_FLC_CTRL_ERASE_CODE_POS 8 +#define MXC_F_FLC_CTRL_ERASE_CODE ((uint32_t)(0x000000FFUL << MXC_F_FLC_CTRL_ERASE_CODE_POS)) +#define MXC_F_FLC_CTRL_INFO_BLOCK_UNLOCK_POS 16 +#define MXC_F_FLC_CTRL_INFO_BLOCK_UNLOCK ((uint32_t)(0x00000001UL << MXC_F_FLC_CTRL_INFO_BLOCK_UNLOCK_POS)) +#define MXC_F_FLC_CTRL_WRITE_ENABLE_POS 17 +#define MXC_F_FLC_CTRL_WRITE_ENABLE ((uint32_t)(0x00000001UL << MXC_F_FLC_CTRL_WRITE_ENABLE_POS)) +#define MXC_F_FLC_CTRL_PENDING_POS 24 +#define MXC_F_FLC_CTRL_PENDING ((uint32_t)(0x00000001UL << MXC_F_FLC_CTRL_PENDING_POS)) +#define MXC_F_FLC_CTRL_INFO_BLOCK_VALID_POS 25 +#define MXC_F_FLC_CTRL_INFO_BLOCK_VALID ((uint32_t)(0x00000001UL << MXC_F_FLC_CTRL_INFO_BLOCK_VALID_POS)) +#define MXC_F_FLC_CTRL_AUTO_INCRE_MODE_POS 27 +#define MXC_F_FLC_CTRL_AUTO_INCRE_MODE ((uint32_t)(0x00000001UL << MXC_F_FLC_CTRL_AUTO_INCRE_MODE_POS)) +#define MXC_F_FLC_CTRL_FLSH_UNLOCK_POS 28 +#define MXC_F_FLC_CTRL_FLSH_UNLOCK ((uint32_t)(0x0000000FUL << MXC_F_FLC_CTRL_FLSH_UNLOCK_POS)) + +#define MXC_F_FLC_INTR_STARTED_IF_POS 0 +#define MXC_F_FLC_INTR_STARTED_IF ((uint32_t)(0x00000001UL << MXC_F_FLC_INTR_STARTED_IF_POS)) +#define MXC_F_FLC_INTR_FAILED_IF_POS 1 +#define MXC_F_FLC_INTR_FAILED_IF ((uint32_t)(0x00000001UL << MXC_F_FLC_INTR_FAILED_IF_POS)) +#define MXC_F_FLC_INTR_STARTED_IE_POS 8 +#define MXC_F_FLC_INTR_STARTED_IE ((uint32_t)(0x00000001UL << MXC_F_FLC_INTR_STARTED_IE_POS)) +#define MXC_F_FLC_INTR_FAILED_IE_POS 9 +#define MXC_F_FLC_INTR_FAILED_IE ((uint32_t)(0x00000001UL << MXC_F_FLC_INTR_FAILED_IE_POS)) + +#define MXC_F_FLC_PERFORM_DELAY_SE_EN_POS 0 +#define MXC_F_FLC_PERFORM_DELAY_SE_EN ((uint32_t)(0x00000001UL << MXC_F_FLC_PERFORM_DELAY_SE_EN_POS)) +#define MXC_F_FLC_PERFORM_FAST_READ_MODE_EN_POS 8 +#define MXC_F_FLC_PERFORM_FAST_READ_MODE_EN ((uint32_t)(0x00000001UL << MXC_F_FLC_PERFORM_FAST_READ_MODE_EN_POS)) + +#define MXC_F_FLC_STATUS_JTAG_LOCK_WINDOW_POS 0 +#define MXC_F_FLC_STATUS_JTAG_LOCK_WINDOW ((uint32_t)(0x00000001UL << MXC_F_FLC_STATUS_JTAG_LOCK_WINDOW_POS)) +#define MXC_F_FLC_STATUS_JTAG_LOCK_STATIC_POS 1 +#define MXC_F_FLC_STATUS_JTAG_LOCK_STATIC ((uint32_t)(0x00000001UL << MXC_F_FLC_STATUS_JTAG_LOCK_STATIC_POS)) +#define MXC_F_FLC_STATUS_AUTO_LOCK_POS 3 +#define MXC_F_FLC_STATUS_AUTO_LOCK ((uint32_t)(0x00000001UL << MXC_F_FLC_STATUS_AUTO_LOCK_POS)) +#define MXC_F_FLC_STATUS_TRIM_UPDATE_DONE_POS 29 +#define MXC_F_FLC_STATUS_TRIM_UPDATE_DONE ((uint32_t)(0x00000001UL << MXC_F_FLC_STATUS_TRIM_UPDATE_DONE_POS)) +#define MXC_F_FLC_STATUS_INFO_BLOCK_VALID_POS 30 +#define MXC_F_FLC_STATUS_INFO_BLOCK_VALID ((uint32_t)(0x00000001UL << MXC_F_FLC_STATUS_INFO_BLOCK_VALID_POS)) + +#define MXC_F_FLC_SECURITY_DEBUG_DISABLE_POS 0 +#define MXC_F_FLC_SECURITY_DEBUG_DISABLE ((uint32_t)(0x000000FFUL << MXC_F_FLC_SECURITY_DEBUG_DISABLE_POS)) +#define MXC_F_FLC_SECURITY_MASS_ERASE_LOCK_POS 8 +#define MXC_F_FLC_SECURITY_MASS_ERASE_LOCK ((uint32_t)(0x0000000FUL << MXC_F_FLC_SECURITY_MASS_ERASE_LOCK_POS)) +#define MXC_F_FLC_SECURITY_SECURITY_LOCK_POS 28 +#define MXC_F_FLC_SECURITY_SECURITY_LOCK ((uint32_t)(0x0000000FUL << MXC_F_FLC_SECURITY_SECURITY_LOCK_POS)) + +#define MXC_F_FLC_BYPASS_DESTRUCT_BYPASS_ERASE_POS 0 +#define MXC_F_FLC_BYPASS_DESTRUCT_BYPASS_ERASE ((uint32_t)(0x00000001UL << MXC_F_FLC_BYPASS_DESTRUCT_BYPASS_ERASE_POS)) +#define MXC_F_FLC_BYPASS_SUPERWIPE_ERASE_POS 1 +#define MXC_F_FLC_BYPASS_SUPERWIPE_ERASE ((uint32_t)(0x00000001UL << MXC_F_FLC_BYPASS_SUPERWIPE_ERASE_POS)) +#define MXC_F_FLC_BYPASS_DESTRUCT_BYPASS_COMPLETE_POS 2 +#define MXC_F_FLC_BYPASS_DESTRUCT_BYPASS_COMPLETE ((uint32_t)(0x00000001UL << MXC_F_FLC_BYPASS_DESTRUCT_BYPASS_COMPLETE_POS)) +#define MXC_F_FLC_BYPASS_SUPERWIPE_COMPLETE_POS 3 +#define MXC_F_FLC_BYPASS_SUPERWIPE_COMPLETE ((uint32_t)(0x00000001UL << MXC_F_FLC_BYPASS_SUPERWIPE_COMPLETE_POS)) + +#define MXC_F_FLC_CTRL2_FLASH_LVE_POS 0 +#define MXC_F_FLC_CTRL2_FLASH_LVE ((uint32_t)(0x00000001UL << MXC_F_FLC_CTRL2_FLASH_LVE_POS)) +#define MXC_F_FLC_CTRL2_FRC_FCLK1_ON_POS 1 +#define MXC_F_FLC_CTRL2_FRC_FCLK1_ON ((uint32_t)(0x00000001UL << MXC_F_FLC_CTRL2_FRC_FCLK1_ON_POS)) +#define MXC_F_FLC_CTRL2_BYPASS_AHB_FAIL_POS 8 +#define MXC_F_FLC_CTRL2_BYPASS_AHB_FAIL ((uint32_t)(0x000000FFUL << MXC_F_FLC_CTRL2_BYPASS_AHB_FAIL_POS)) + +#define MXC_F_FLC_INTFL1_SRAM_ADDR_WRAPPED_POS 0 +#define MXC_F_FLC_INTFL1_SRAM_ADDR_WRAPPED ((uint32_t)(0x00000001UL << MXC_F_FLC_INTFL1_SRAM_ADDR_WRAPPED_POS)) +#define MXC_F_FLC_INTFL1_INVALID_FLASH_ADDR_POS 1 +#define MXC_F_FLC_INTFL1_INVALID_FLASH_ADDR ((uint32_t)(0x00000001UL << MXC_F_FLC_INTFL1_INVALID_FLASH_ADDR_POS)) +#define MXC_F_FLC_INTFL1_FLASH_READ_LOCKED_POS 2 +#define MXC_F_FLC_INTFL1_FLASH_READ_LOCKED ((uint32_t)(0x00000001UL << MXC_F_FLC_INTFL1_FLASH_READ_LOCKED_POS)) +#define MXC_F_FLC_INTFL1_TRIM_UPDATE_DONE_POS 3 +#define MXC_F_FLC_INTFL1_TRIM_UPDATE_DONE ((uint32_t)(0x00000001UL << MXC_F_FLC_INTFL1_TRIM_UPDATE_DONE_POS)) + +#define MXC_F_FLC_INTEN1_SRAM_ADDR_WRAPPED_POS 0 +#define MXC_F_FLC_INTEN1_SRAM_ADDR_WRAPPED ((uint32_t)(0x00000001UL << MXC_F_FLC_INTEN1_SRAM_ADDR_WRAPPED_POS)) +#define MXC_F_FLC_INTEN1_INVALID_FLASH_ADDR_POS 1 +#define MXC_F_FLC_INTEN1_INVALID_FLASH_ADDR ((uint32_t)(0x00000001UL << MXC_F_FLC_INTEN1_INVALID_FLASH_ADDR_POS)) +#define MXC_F_FLC_INTEN1_FLASH_READ_LOCKED_POS 2 +#define MXC_F_FLC_INTEN1_FLASH_READ_LOCKED ((uint32_t)(0x00000001UL << MXC_F_FLC_INTEN1_FLASH_READ_LOCKED_POS)) +#define MXC_F_FLC_INTEN1_TRIM_UPDATE_DONE_POS 3 +#define MXC_F_FLC_INTEN1_TRIM_UPDATE_DONE ((uint32_t)(0x00000001UL << MXC_F_FLC_INTEN1_TRIM_UPDATE_DONE_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_FLC_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/gpio_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/gpio_regs.h new file mode 100644 index 0000000000..b2259b7434 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/gpio_regs.h @@ -0,0 +1,638 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_GPIO_REGS_H_ +#define _MXC_GPIO_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t rst_mode[7]; /* 0x0000-0x0018 Port P[0..6] Default (Power-On Reset) Output Drive Mode */ + __I uint32_t rsv01C[9]; /* 0x001C-0x003C */ + __IO uint32_t free[7]; /* 0x0040-0x0058 Port P[0..6] Free for GPIO Operation Flags */ + __I uint32_t rsv05C[9]; /* 0x005C-0x007C */ + __IO uint32_t out_mode[7]; /* 0x0080-0x0098 Port P[0..6] Output Drive Mode */ + __I uint32_t rsv09C[9]; /* 0x009C-0x00BC */ + __IO uint32_t out_val[7]; /* 0x00C0-0x00D8 Port P[0..6] GPIO Output Value */ + __I uint32_t rsv0DC[9]; /* 0x00DC-0x00FC */ + __IO uint32_t func_sel[7]; /* 0x0100-0x0118 Port P[0..6] GPIO Function Select */ + __I uint32_t rsv11C[9]; /* 0x011C-0x013C */ + __IO uint32_t in_mode[7]; /* 0x0140-0x0158 Port P[0..6] GPIO Input Monitoring Mode */ + __I uint32_t rsv15C[9]; /* 0x015C-0x017C */ + __IO uint32_t in_val[7]; /* 0x0180-0x0198 Port P[0..6] GPIO Input Value */ + __I uint32_t rsv19C[9]; /* 0x019C-0x01BC */ + __IO uint32_t int_mode[7]; /* 0x01C0-0x01D8 Port P[0..6] Interrupt Detection Mode */ + __I uint32_t rsv1DC[9]; /* 0x01DC-0x01FC */ + __IO uint32_t intfl[7]; /* 0x0200-0x0218 Port P[0..6] Interrupt Flags */ + __I uint32_t rsv21C[9]; /* 0x021C-0x023C */ + __IO uint32_t inten[7]; /* 0x0240-0x0258 Port P[0..6] Interrupt Enables */ +} mxc_gpio_regs_t; + + +/* + Register offsets for module GPIO. +*/ + +#define MXC_R_GPIO_OFFS_RST_MODE_P0 ((uint32_t)0x00000000UL) +#define MXC_R_GPIO_OFFS_RST_MODE_P1 ((uint32_t)0x00000004UL) +#define MXC_R_GPIO_OFFS_RST_MODE_P2 ((uint32_t)0x00000008UL) +#define MXC_R_GPIO_OFFS_RST_MODE_P3 ((uint32_t)0x0000000CUL) +#define MXC_R_GPIO_OFFS_RST_MODE_P4 ((uint32_t)0x00000010UL) +#define MXC_R_GPIO_OFFS_RST_MODE_P5 ((uint32_t)0x00000014UL) +#define MXC_R_GPIO_OFFS_RST_MODE_P6 ((uint32_t)0x00000018UL) +#define MXC_R_GPIO_OFFS_FREE_P0 ((uint32_t)0x00000040UL) +#define MXC_R_GPIO_OFFS_FREE_P1 ((uint32_t)0x00000044UL) +#define MXC_R_GPIO_OFFS_FREE_P2 ((uint32_t)0x00000048UL) +#define MXC_R_GPIO_OFFS_FREE_P3 ((uint32_t)0x0000004CUL) +#define MXC_R_GPIO_OFFS_FREE_P4 ((uint32_t)0x00000050UL) +#define MXC_R_GPIO_OFFS_FREE_P5 ((uint32_t)0x00000054UL) +#define MXC_R_GPIO_OFFS_FREE_P6 ((uint32_t)0x00000058UL) +#define MXC_R_GPIO_OFFS_OUT_MODE_P0 ((uint32_t)0x00000080UL) +#define MXC_R_GPIO_OFFS_OUT_MODE_P1 ((uint32_t)0x00000084UL) +#define MXC_R_GPIO_OFFS_OUT_MODE_P2 ((uint32_t)0x00000088UL) +#define MXC_R_GPIO_OFFS_OUT_MODE_P3 ((uint32_t)0x0000008CUL) +#define MXC_R_GPIO_OFFS_OUT_MODE_P4 ((uint32_t)0x00000090UL) +#define MXC_R_GPIO_OFFS_OUT_MODE_P5 ((uint32_t)0x00000094UL) +#define MXC_R_GPIO_OFFS_OUT_MODE_P6 ((uint32_t)0x00000098UL) +#define MXC_R_GPIO_OFFS_OUT_VAL_P0 ((uint32_t)0x000000C0UL) +#define MXC_R_GPIO_OFFS_OUT_VAL_P1 ((uint32_t)0x000000C4UL) +#define MXC_R_GPIO_OFFS_OUT_VAL_P2 ((uint32_t)0x000000C8UL) +#define MXC_R_GPIO_OFFS_OUT_VAL_P3 ((uint32_t)0x000000CCUL) +#define MXC_R_GPIO_OFFS_OUT_VAL_P4 ((uint32_t)0x000000D0UL) +#define MXC_R_GPIO_OFFS_OUT_VAL_P5 ((uint32_t)0x000000D4UL) +#define MXC_R_GPIO_OFFS_OUT_VAL_P6 ((uint32_t)0x000000D8UL) +#define MXC_R_GPIO_OFFS_FUNC_SEL_P0 ((uint32_t)0x00000100UL) +#define MXC_R_GPIO_OFFS_FUNC_SEL_P1 ((uint32_t)0x00000104UL) +#define MXC_R_GPIO_OFFS_FUNC_SEL_P2 ((uint32_t)0x00000108UL) +#define MXC_R_GPIO_OFFS_FUNC_SEL_P3 ((uint32_t)0x0000010CUL) +#define MXC_R_GPIO_OFFS_FUNC_SEL_P4 ((uint32_t)0x00000110UL) +#define MXC_R_GPIO_OFFS_FUNC_SEL_P5 ((uint32_t)0x00000114UL) +#define MXC_R_GPIO_OFFS_FUNC_SEL_P6 ((uint32_t)0x00000118UL) +#define MXC_R_GPIO_OFFS_IN_MODE_P0 ((uint32_t)0x00000140UL) +#define MXC_R_GPIO_OFFS_IN_MODE_P1 ((uint32_t)0x00000144UL) +#define MXC_R_GPIO_OFFS_IN_MODE_P2 ((uint32_t)0x00000148UL) +#define MXC_R_GPIO_OFFS_IN_MODE_P3 ((uint32_t)0x0000014CUL) +#define MXC_R_GPIO_OFFS_IN_MODE_P4 ((uint32_t)0x00000150UL) +#define MXC_R_GPIO_OFFS_IN_MODE_P5 ((uint32_t)0x00000154UL) +#define MXC_R_GPIO_OFFS_IN_MODE_P6 ((uint32_t)0x00000158UL) +#define MXC_R_GPIO_OFFS_IN_VAL_P0 ((uint32_t)0x00000180UL) +#define MXC_R_GPIO_OFFS_IN_VAL_P1 ((uint32_t)0x00000184UL) +#define MXC_R_GPIO_OFFS_IN_VAL_P2 ((uint32_t)0x00000188UL) +#define MXC_R_GPIO_OFFS_IN_VAL_P3 ((uint32_t)0x0000018CUL) +#define MXC_R_GPIO_OFFS_IN_VAL_P4 ((uint32_t)0x00000190UL) +#define MXC_R_GPIO_OFFS_IN_VAL_P5 ((uint32_t)0x00000194UL) +#define MXC_R_GPIO_OFFS_IN_VAL_P6 ((uint32_t)0x00000198UL) +#define MXC_R_GPIO_OFFS_INT_MODE_P0 ((uint32_t)0x000001C0UL) +#define MXC_R_GPIO_OFFS_INT_MODE_P1 ((uint32_t)0x000001C4UL) +#define MXC_R_GPIO_OFFS_INT_MODE_P2 ((uint32_t)0x000001C8UL) +#define MXC_R_GPIO_OFFS_INT_MODE_P3 ((uint32_t)0x000001CCUL) +#define MXC_R_GPIO_OFFS_INT_MODE_P4 ((uint32_t)0x000001D0UL) +#define MXC_R_GPIO_OFFS_INT_MODE_P5 ((uint32_t)0x000001D4UL) +#define MXC_R_GPIO_OFFS_INT_MODE_P6 ((uint32_t)0x000001D8UL) +#define MXC_R_GPIO_OFFS_INTFL_P0 ((uint32_t)0x00000200UL) +#define MXC_R_GPIO_OFFS_INTFL_P1 ((uint32_t)0x00000204UL) +#define MXC_R_GPIO_OFFS_INTFL_P2 ((uint32_t)0x00000208UL) +#define MXC_R_GPIO_OFFS_INTFL_P3 ((uint32_t)0x0000020CUL) +#define MXC_R_GPIO_OFFS_INTFL_P4 ((uint32_t)0x00000210UL) +#define MXC_R_GPIO_OFFS_INTFL_P5 ((uint32_t)0x00000214UL) +#define MXC_R_GPIO_OFFS_INTFL_P6 ((uint32_t)0x00000218UL) +#define MXC_R_GPIO_OFFS_INTEN_P0 ((uint32_t)0x00000240UL) +#define MXC_R_GPIO_OFFS_INTEN_P1 ((uint32_t)0x00000244UL) +#define MXC_R_GPIO_OFFS_INTEN_P2 ((uint32_t)0x00000248UL) +#define MXC_R_GPIO_OFFS_INTEN_P3 ((uint32_t)0x0000024CUL) +#define MXC_R_GPIO_OFFS_INTEN_P4 ((uint32_t)0x00000250UL) +#define MXC_R_GPIO_OFFS_INTEN_P5 ((uint32_t)0x00000254UL) +#define MXC_R_GPIO_OFFS_INTEN_P6 ((uint32_t)0x00000258UL) + + +/* + Field positions and masks for module GPIO. +*/ + +#define MXC_F_GPIO_RST_MODE_PIN0_POS 0 +#define MXC_F_GPIO_RST_MODE_PIN0 ((uint32_t)(0x00000007UL << MXC_F_GPIO_RST_MODE_PIN0_POS)) +#define MXC_F_GPIO_RST_MODE_PIN1_POS 4 +#define MXC_F_GPIO_RST_MODE_PIN1 ((uint32_t)(0x00000007UL << MXC_F_GPIO_RST_MODE_PIN1_POS)) +#define MXC_F_GPIO_RST_MODE_PIN2_POS 8 +#define MXC_F_GPIO_RST_MODE_PIN2 ((uint32_t)(0x00000007UL << MXC_F_GPIO_RST_MODE_PIN2_POS)) +#define MXC_F_GPIO_RST_MODE_PIN3_POS 12 +#define MXC_F_GPIO_RST_MODE_PIN3 ((uint32_t)(0x00000007UL << MXC_F_GPIO_RST_MODE_PIN3_POS)) +#define MXC_F_GPIO_RST_MODE_PIN4_POS 16 +#define MXC_F_GPIO_RST_MODE_PIN4 ((uint32_t)(0x00000007UL << MXC_F_GPIO_RST_MODE_PIN4_POS)) +#define MXC_F_GPIO_RST_MODE_PIN5_POS 20 +#define MXC_F_GPIO_RST_MODE_PIN5 ((uint32_t)(0x00000007UL << MXC_F_GPIO_RST_MODE_PIN5_POS)) +#define MXC_F_GPIO_RST_MODE_PIN6_POS 24 +#define MXC_F_GPIO_RST_MODE_PIN6 ((uint32_t)(0x00000007UL << MXC_F_GPIO_RST_MODE_PIN6_POS)) +#define MXC_F_GPIO_RST_MODE_PIN7_POS 28 +#define MXC_F_GPIO_RST_MODE_PIN7 ((uint32_t)(0x00000007UL << MXC_F_GPIO_RST_MODE_PIN7_POS)) + +#define MXC_F_GPIO_FREE_PIN0_POS 0 +#define MXC_F_GPIO_FREE_PIN0 ((uint32_t)(0x00000001UL << MXC_F_GPIO_FREE_PIN0_POS)) +#define MXC_F_GPIO_FREE_PIN1_POS 1 +#define MXC_F_GPIO_FREE_PIN1 ((uint32_t)(0x00000001UL << MXC_F_GPIO_FREE_PIN1_POS)) +#define MXC_F_GPIO_FREE_PIN2_POS 2 +#define MXC_F_GPIO_FREE_PIN2 ((uint32_t)(0x00000001UL << MXC_F_GPIO_FREE_PIN2_POS)) +#define MXC_F_GPIO_FREE_PIN3_POS 3 +#define MXC_F_GPIO_FREE_PIN3 ((uint32_t)(0x00000001UL << MXC_F_GPIO_FREE_PIN3_POS)) +#define MXC_F_GPIO_FREE_PIN4_POS 4 +#define MXC_F_GPIO_FREE_PIN4 ((uint32_t)(0x00000001UL << MXC_F_GPIO_FREE_PIN4_POS)) +#define MXC_F_GPIO_FREE_PIN5_POS 5 +#define MXC_F_GPIO_FREE_PIN5 ((uint32_t)(0x00000001UL << MXC_F_GPIO_FREE_PIN5_POS)) +#define MXC_F_GPIO_FREE_PIN6_POS 6 +#define MXC_F_GPIO_FREE_PIN6 ((uint32_t)(0x00000001UL << MXC_F_GPIO_FREE_PIN6_POS)) +#define MXC_F_GPIO_FREE_PIN7_POS 7 +#define MXC_F_GPIO_FREE_PIN7 ((uint32_t)(0x00000001UL << MXC_F_GPIO_FREE_PIN7_POS)) + +#define MXC_F_GPIO_OUT_MODE_PIN0_POS 0 +#define MXC_F_GPIO_OUT_MODE_PIN0 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_OUT_MODE_PIN0_POS)) +#define MXC_F_GPIO_OUT_MODE_PIN1_POS 4 +#define MXC_F_GPIO_OUT_MODE_PIN1 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_OUT_MODE_PIN1_POS)) +#define MXC_F_GPIO_OUT_MODE_PIN2_POS 8 +#define MXC_F_GPIO_OUT_MODE_PIN2 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_OUT_MODE_PIN2_POS)) +#define MXC_F_GPIO_OUT_MODE_PIN3_POS 12 +#define MXC_F_GPIO_OUT_MODE_PIN3 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_OUT_MODE_PIN3_POS)) +#define MXC_F_GPIO_OUT_MODE_PIN4_POS 16 +#define MXC_F_GPIO_OUT_MODE_PIN4 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_OUT_MODE_PIN4_POS)) +#define MXC_F_GPIO_OUT_MODE_PIN5_POS 20 +#define MXC_F_GPIO_OUT_MODE_PIN5 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_OUT_MODE_PIN5_POS)) +#define MXC_F_GPIO_OUT_MODE_PIN6_POS 24 +#define MXC_F_GPIO_OUT_MODE_PIN6 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_OUT_MODE_PIN6_POS)) +#define MXC_F_GPIO_OUT_MODE_PIN7_POS 28 +#define MXC_F_GPIO_OUT_MODE_PIN7 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_OUT_MODE_PIN7_POS)) + +#define MXC_F_GPIO_OUT_VAL_PIN0_POS 0 +#define MXC_F_GPIO_OUT_VAL_PIN0 ((uint32_t)(0x00000001UL << MXC_F_GPIO_OUT_VAL_PIN0_POS)) +#define MXC_F_GPIO_OUT_VAL_PIN1_POS 1 +#define MXC_F_GPIO_OUT_VAL_PIN1 ((uint32_t)(0x00000001UL << MXC_F_GPIO_OUT_VAL_PIN1_POS)) +#define MXC_F_GPIO_OUT_VAL_PIN2_POS 2 +#define MXC_F_GPIO_OUT_VAL_PIN2 ((uint32_t)(0x00000001UL << MXC_F_GPIO_OUT_VAL_PIN2_POS)) +#define MXC_F_GPIO_OUT_VAL_PIN3_POS 3 +#define MXC_F_GPIO_OUT_VAL_PIN3 ((uint32_t)(0x00000001UL << MXC_F_GPIO_OUT_VAL_PIN3_POS)) +#define MXC_F_GPIO_OUT_VAL_PIN4_POS 4 +#define MXC_F_GPIO_OUT_VAL_PIN4 ((uint32_t)(0x00000001UL << MXC_F_GPIO_OUT_VAL_PIN4_POS)) +#define MXC_F_GPIO_OUT_VAL_PIN5_POS 5 +#define MXC_F_GPIO_OUT_VAL_PIN5 ((uint32_t)(0x00000001UL << MXC_F_GPIO_OUT_VAL_PIN5_POS)) +#define MXC_F_GPIO_OUT_VAL_PIN6_POS 6 +#define MXC_F_GPIO_OUT_VAL_PIN6 ((uint32_t)(0x00000001UL << MXC_F_GPIO_OUT_VAL_PIN6_POS)) +#define MXC_F_GPIO_OUT_VAL_PIN7_POS 7 +#define MXC_F_GPIO_OUT_VAL_PIN7 ((uint32_t)(0x00000001UL << MXC_F_GPIO_OUT_VAL_PIN7_POS)) + +#define MXC_F_GPIO_FUNC_SEL_P0_PIN0_POS 0 +#define MXC_F_GPIO_FUNC_SEL_P0_PIN0 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P0_PIN0_POS)) +#define MXC_F_GPIO_FUNC_SEL_P0_PIN1_POS 4 +#define MXC_F_GPIO_FUNC_SEL_P0_PIN1 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P0_PIN1_POS)) +#define MXC_F_GPIO_FUNC_SEL_P0_PIN2_POS 8 +#define MXC_F_GPIO_FUNC_SEL_P0_PIN2 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P0_PIN2_POS)) +#define MXC_F_GPIO_FUNC_SEL_P0_PIN3_POS 12 +#define MXC_F_GPIO_FUNC_SEL_P0_PIN3 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P0_PIN3_POS)) +#define MXC_F_GPIO_FUNC_SEL_P0_PIN4_POS 16 +#define MXC_F_GPIO_FUNC_SEL_P0_PIN4 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P0_PIN4_POS)) +#define MXC_F_GPIO_FUNC_SEL_P0_PIN5_POS 20 +#define MXC_F_GPIO_FUNC_SEL_P0_PIN5 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P0_PIN5_POS)) +#define MXC_F_GPIO_FUNC_SEL_P0_PIN6_POS 24 +#define MXC_F_GPIO_FUNC_SEL_P0_PIN6 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P0_PIN6_POS)) +#define MXC_F_GPIO_FUNC_SEL_P0_PIN7_POS 28 +#define MXC_F_GPIO_FUNC_SEL_P0_PIN7 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P0_PIN7_POS)) + +#define MXC_F_GPIO_FUNC_SEL_P1_PIN0_POS 0 +#define MXC_F_GPIO_FUNC_SEL_P1_PIN0 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P1_PIN0_POS)) +#define MXC_F_GPIO_FUNC_SEL_P1_PIN1_POS 4 +#define MXC_F_GPIO_FUNC_SEL_P1_PIN1 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P1_PIN1_POS)) +#define MXC_F_GPIO_FUNC_SEL_P1_PIN2_POS 8 +#define MXC_F_GPIO_FUNC_SEL_P1_PIN2 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P1_PIN2_POS)) +#define MXC_F_GPIO_FUNC_SEL_P1_PIN3_POS 12 +#define MXC_F_GPIO_FUNC_SEL_P1_PIN3 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P1_PIN3_POS)) +#define MXC_F_GPIO_FUNC_SEL_P1_PIN4_POS 16 +#define MXC_F_GPIO_FUNC_SEL_P1_PIN4 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P1_PIN4_POS)) +#define MXC_F_GPIO_FUNC_SEL_P1_PIN5_POS 20 +#define MXC_F_GPIO_FUNC_SEL_P1_PIN5 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P1_PIN5_POS)) +#define MXC_F_GPIO_FUNC_SEL_P1_PIN6_POS 24 +#define MXC_F_GPIO_FUNC_SEL_P1_PIN6 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P1_PIN6_POS)) +#define MXC_F_GPIO_FUNC_SEL_P1_PIN7_POS 28 +#define MXC_F_GPIO_FUNC_SEL_P1_PIN7 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P1_PIN7_POS)) + +#define MXC_F_GPIO_FUNC_SEL_P2_PIN0_POS 0 +#define MXC_F_GPIO_FUNC_SEL_P2_PIN0 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P2_PIN0_POS)) +#define MXC_F_GPIO_FUNC_SEL_P2_PIN1_POS 4 +#define MXC_F_GPIO_FUNC_SEL_P2_PIN1 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P2_PIN1_POS)) +#define MXC_F_GPIO_FUNC_SEL_P2_PIN2_POS 8 +#define MXC_F_GPIO_FUNC_SEL_P2_PIN2 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P2_PIN2_POS)) +#define MXC_F_GPIO_FUNC_SEL_P2_PIN3_POS 12 +#define MXC_F_GPIO_FUNC_SEL_P2_PIN3 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P2_PIN3_POS)) +#define MXC_F_GPIO_FUNC_SEL_P2_PIN4_POS 16 +#define MXC_F_GPIO_FUNC_SEL_P2_PIN4 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P2_PIN4_POS)) +#define MXC_F_GPIO_FUNC_SEL_P2_PIN5_POS 20 +#define MXC_F_GPIO_FUNC_SEL_P2_PIN5 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P2_PIN5_POS)) +#define MXC_F_GPIO_FUNC_SEL_P2_PIN6_POS 24 +#define MXC_F_GPIO_FUNC_SEL_P2_PIN6 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P2_PIN6_POS)) +#define MXC_F_GPIO_FUNC_SEL_P2_PIN7_POS 28 +#define MXC_F_GPIO_FUNC_SEL_P2_PIN7 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P2_PIN7_POS)) + +#define MXC_F_GPIO_FUNC_SEL_P3_PIN0_POS 0 +#define MXC_F_GPIO_FUNC_SEL_P3_PIN0 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P3_PIN0_POS)) +#define MXC_F_GPIO_FUNC_SEL_P3_PIN1_POS 4 +#define MXC_F_GPIO_FUNC_SEL_P3_PIN1 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P3_PIN1_POS)) +#define MXC_F_GPIO_FUNC_SEL_P3_PIN2_POS 8 +#define MXC_F_GPIO_FUNC_SEL_P3_PIN2 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P3_PIN2_POS)) +#define MXC_F_GPIO_FUNC_SEL_P3_PIN3_POS 12 +#define MXC_F_GPIO_FUNC_SEL_P3_PIN3 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P3_PIN3_POS)) +#define MXC_F_GPIO_FUNC_SEL_P3_PIN4_POS 16 +#define MXC_F_GPIO_FUNC_SEL_P3_PIN4 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P3_PIN4_POS)) +#define MXC_F_GPIO_FUNC_SEL_P3_PIN5_POS 20 +#define MXC_F_GPIO_FUNC_SEL_P3_PIN5 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P3_PIN5_POS)) +#define MXC_F_GPIO_FUNC_SEL_P3_PIN6_POS 24 +#define MXC_F_GPIO_FUNC_SEL_P3_PIN6 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P3_PIN6_POS)) +#define MXC_F_GPIO_FUNC_SEL_P3_PIN7_POS 28 +#define MXC_F_GPIO_FUNC_SEL_P3_PIN7 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P3_PIN7_POS)) + +#define MXC_F_GPIO_FUNC_SEL_P4_PIN0_POS 0 +#define MXC_F_GPIO_FUNC_SEL_P4_PIN0 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P4_PIN0_POS)) +#define MXC_F_GPIO_FUNC_SEL_P4_PIN1_POS 4 +#define MXC_F_GPIO_FUNC_SEL_P4_PIN1 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P4_PIN1_POS)) +#define MXC_F_GPIO_FUNC_SEL_P4_PIN2_POS 8 +#define MXC_F_GPIO_FUNC_SEL_P4_PIN2 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P4_PIN2_POS)) +#define MXC_F_GPIO_FUNC_SEL_P4_PIN3_POS 12 +#define MXC_F_GPIO_FUNC_SEL_P4_PIN3 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P4_PIN3_POS)) +#define MXC_F_GPIO_FUNC_SEL_P4_PIN4_POS 16 +#define MXC_F_GPIO_FUNC_SEL_P4_PIN4 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P4_PIN4_POS)) +#define MXC_F_GPIO_FUNC_SEL_P4_PIN5_POS 20 +#define MXC_F_GPIO_FUNC_SEL_P4_PIN5 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P4_PIN5_POS)) +#define MXC_F_GPIO_FUNC_SEL_P4_PIN6_POS 24 +#define MXC_F_GPIO_FUNC_SEL_P4_PIN6 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P4_PIN6_POS)) +#define MXC_F_GPIO_FUNC_SEL_P4_PIN7_POS 28 +#define MXC_F_GPIO_FUNC_SEL_P4_PIN7 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P4_PIN7_POS)) + +#define MXC_F_GPIO_FUNC_SEL_P5_PIN0_POS 0 +#define MXC_F_GPIO_FUNC_SEL_P5_PIN0 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P5_PIN0_POS)) +#define MXC_F_GPIO_FUNC_SEL_P5_PIN1_POS 4 +#define MXC_F_GPIO_FUNC_SEL_P5_PIN1 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P5_PIN1_POS)) +#define MXC_F_GPIO_FUNC_SEL_P5_PIN2_POS 8 +#define MXC_F_GPIO_FUNC_SEL_P5_PIN2 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P5_PIN2_POS)) +#define MXC_F_GPIO_FUNC_SEL_P5_PIN3_POS 12 +#define MXC_F_GPIO_FUNC_SEL_P5_PIN3 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P5_PIN3_POS)) +#define MXC_F_GPIO_FUNC_SEL_P5_PIN4_POS 16 +#define MXC_F_GPIO_FUNC_SEL_P5_PIN4 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P5_PIN4_POS)) +#define MXC_F_GPIO_FUNC_SEL_P5_PIN5_POS 20 +#define MXC_F_GPIO_FUNC_SEL_P5_PIN5 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P5_PIN5_POS)) +#define MXC_F_GPIO_FUNC_SEL_P5_PIN6_POS 24 +#define MXC_F_GPIO_FUNC_SEL_P5_PIN6 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P5_PIN6_POS)) +#define MXC_F_GPIO_FUNC_SEL_P5_PIN7_POS 28 +#define MXC_F_GPIO_FUNC_SEL_P5_PIN7 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P5_PIN7_POS)) + +#define MXC_F_GPIO_FUNC_SEL_P6_PIN0_POS 0 +#define MXC_F_GPIO_FUNC_SEL_P6_PIN0 ((uint32_t)(0x0000000FUL << MXC_F_GPIO_FUNC_SEL_P6_PIN0_POS)) + +#define MXC_F_GPIO_IN_MODE_PIN0_POS 0 +#define MXC_F_GPIO_IN_MODE_PIN0 ((uint32_t)(0x00000003UL << MXC_F_GPIO_IN_MODE_PIN0_POS)) +#define MXC_F_GPIO_IN_MODE_PIN1_POS 4 +#define MXC_F_GPIO_IN_MODE_PIN1 ((uint32_t)(0x00000003UL << MXC_F_GPIO_IN_MODE_PIN1_POS)) +#define MXC_F_GPIO_IN_MODE_PIN2_POS 8 +#define MXC_F_GPIO_IN_MODE_PIN2 ((uint32_t)(0x00000003UL << MXC_F_GPIO_IN_MODE_PIN2_POS)) +#define MXC_F_GPIO_IN_MODE_PIN3_POS 12 +#define MXC_F_GPIO_IN_MODE_PIN3 ((uint32_t)(0x00000003UL << MXC_F_GPIO_IN_MODE_PIN3_POS)) +#define MXC_F_GPIO_IN_MODE_PIN4_POS 16 +#define MXC_F_GPIO_IN_MODE_PIN4 ((uint32_t)(0x00000003UL << MXC_F_GPIO_IN_MODE_PIN4_POS)) +#define MXC_F_GPIO_IN_MODE_PIN5_POS 20 +#define MXC_F_GPIO_IN_MODE_PIN5 ((uint32_t)(0x00000003UL << MXC_F_GPIO_IN_MODE_PIN5_POS)) +#define MXC_F_GPIO_IN_MODE_PIN6_POS 24 +#define MXC_F_GPIO_IN_MODE_PIN6 ((uint32_t)(0x00000003UL << MXC_F_GPIO_IN_MODE_PIN6_POS)) +#define MXC_F_GPIO_IN_MODE_PIN7_POS 28 +#define MXC_F_GPIO_IN_MODE_PIN7 ((uint32_t)(0x00000003UL << MXC_F_GPIO_IN_MODE_PIN7_POS)) + +#define MXC_F_GPIO_IN_VAL_PIN0_POS 0 +#define MXC_F_GPIO_IN_VAL_PIN0 ((uint32_t)(0x00000001UL << MXC_F_GPIO_IN_VAL_PIN0_POS)) +#define MXC_F_GPIO_IN_VAL_PIN1_POS 1 +#define MXC_F_GPIO_IN_VAL_PIN1 ((uint32_t)(0x00000001UL << MXC_F_GPIO_IN_VAL_PIN1_POS)) +#define MXC_F_GPIO_IN_VAL_PIN2_POS 2 +#define MXC_F_GPIO_IN_VAL_PIN2 ((uint32_t)(0x00000001UL << MXC_F_GPIO_IN_VAL_PIN2_POS)) +#define MXC_F_GPIO_IN_VAL_PIN3_POS 3 +#define MXC_F_GPIO_IN_VAL_PIN3 ((uint32_t)(0x00000001UL << MXC_F_GPIO_IN_VAL_PIN3_POS)) +#define MXC_F_GPIO_IN_VAL_PIN4_POS 4 +#define MXC_F_GPIO_IN_VAL_PIN4 ((uint32_t)(0x00000001UL << MXC_F_GPIO_IN_VAL_PIN4_POS)) +#define MXC_F_GPIO_IN_VAL_PIN5_POS 5 +#define MXC_F_GPIO_IN_VAL_PIN5 ((uint32_t)(0x00000001UL << MXC_F_GPIO_IN_VAL_PIN5_POS)) +#define MXC_F_GPIO_IN_VAL_PIN6_POS 6 +#define MXC_F_GPIO_IN_VAL_PIN6 ((uint32_t)(0x00000001UL << MXC_F_GPIO_IN_VAL_PIN6_POS)) +#define MXC_F_GPIO_IN_VAL_PIN7_POS 7 +#define MXC_F_GPIO_IN_VAL_PIN7 ((uint32_t)(0x00000001UL << MXC_F_GPIO_IN_VAL_PIN7_POS)) + +#define MXC_F_GPIO_INT_MODE_PIN0_POS 0 +#define MXC_F_GPIO_INT_MODE_PIN0 ((uint32_t)(0x00000007UL << MXC_F_GPIO_INT_MODE_PIN0_POS)) +#define MXC_F_GPIO_INT_MODE_PIN1_POS 4 +#define MXC_F_GPIO_INT_MODE_PIN1 ((uint32_t)(0x00000007UL << MXC_F_GPIO_INT_MODE_PIN1_POS)) +#define MXC_F_GPIO_INT_MODE_PIN2_POS 8 +#define MXC_F_GPIO_INT_MODE_PIN2 ((uint32_t)(0x00000007UL << MXC_F_GPIO_INT_MODE_PIN2_POS)) +#define MXC_F_GPIO_INT_MODE_PIN3_POS 12 +#define MXC_F_GPIO_INT_MODE_PIN3 ((uint32_t)(0x00000007UL << MXC_F_GPIO_INT_MODE_PIN3_POS)) +#define MXC_F_GPIO_INT_MODE_PIN4_POS 16 +#define MXC_F_GPIO_INT_MODE_PIN4 ((uint32_t)(0x00000007UL << MXC_F_GPIO_INT_MODE_PIN4_POS)) +#define MXC_F_GPIO_INT_MODE_PIN5_POS 20 +#define MXC_F_GPIO_INT_MODE_PIN5 ((uint32_t)(0x00000007UL << MXC_F_GPIO_INT_MODE_PIN5_POS)) +#define MXC_F_GPIO_INT_MODE_PIN6_POS 24 +#define MXC_F_GPIO_INT_MODE_PIN6 ((uint32_t)(0x00000007UL << MXC_F_GPIO_INT_MODE_PIN6_POS)) +#define MXC_F_GPIO_INT_MODE_PIN7_POS 28 +#define MXC_F_GPIO_INT_MODE_PIN7 ((uint32_t)(0x00000007UL << MXC_F_GPIO_INT_MODE_PIN7_POS)) + +#define MXC_F_GPIO_INTFL_PIN0_POS 0 +#define MXC_F_GPIO_INTFL_PIN0 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTFL_PIN0_POS)) +#define MXC_F_GPIO_INTFL_PIN1_POS 1 +#define MXC_F_GPIO_INTFL_PIN1 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTFL_PIN1_POS)) +#define MXC_F_GPIO_INTFL_PIN2_POS 2 +#define MXC_F_GPIO_INTFL_PIN2 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTFL_PIN2_POS)) +#define MXC_F_GPIO_INTFL_PIN3_POS 3 +#define MXC_F_GPIO_INTFL_PIN3 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTFL_PIN3_POS)) +#define MXC_F_GPIO_INTFL_PIN4_POS 4 +#define MXC_F_GPIO_INTFL_PIN4 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTFL_PIN4_POS)) +#define MXC_F_GPIO_INTFL_PIN5_POS 5 +#define MXC_F_GPIO_INTFL_PIN5 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTFL_PIN5_POS)) +#define MXC_F_GPIO_INTFL_PIN6_POS 6 +#define MXC_F_GPIO_INTFL_PIN6 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTFL_PIN6_POS)) +#define MXC_F_GPIO_INTFL_PIN7_POS 7 +#define MXC_F_GPIO_INTFL_PIN7 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTFL_PIN7_POS)) + +#define MXC_F_GPIO_INTEN_PIN0_POS 0 +#define MXC_F_GPIO_INTEN_PIN0 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTEN_PIN0_POS)) +#define MXC_F_GPIO_INTEN_PIN1_POS 1 +#define MXC_F_GPIO_INTEN_PIN1 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTEN_PIN1_POS)) +#define MXC_F_GPIO_INTEN_PIN2_POS 2 +#define MXC_F_GPIO_INTEN_PIN2 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTEN_PIN2_POS)) +#define MXC_F_GPIO_INTEN_PIN3_POS 3 +#define MXC_F_GPIO_INTEN_PIN3 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTEN_PIN3_POS)) +#define MXC_F_GPIO_INTEN_PIN4_POS 4 +#define MXC_F_GPIO_INTEN_PIN4 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTEN_PIN4_POS)) +#define MXC_F_GPIO_INTEN_PIN5_POS 5 +#define MXC_F_GPIO_INTEN_PIN5 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTEN_PIN5_POS)) +#define MXC_F_GPIO_INTEN_PIN6_POS 6 +#define MXC_F_GPIO_INTEN_PIN6 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTEN_PIN6_POS)) +#define MXC_F_GPIO_INTEN_PIN7_POS 7 +#define MXC_F_GPIO_INTEN_PIN7 ((uint32_t)(0x00000001UL << MXC_F_GPIO_INTEN_PIN7_POS)) + + + +/* + Field values and shifted values for module GPIO. +*/ + +#define MXC_V_GPIO_RST_MODE_DRIVE_0 ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_RST_MODE_WEAK_PULLDOWN ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_RST_MODE_WEAK_PULLUP ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_RST_MODE_DRIVE_1 ((uint32_t)(0x00000003UL)) +#define MXC_V_GPIO_RST_MODE_HIGH_Z ((uint32_t)(0x00000004UL)) + +#define MXC_V_GPIO_FREE_PIN0_NOT_AVAILABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_FREE_PIN0_AVAILABLE ((uint32_t)(0x00000001UL)) + +#define MXC_S_GPIO_FREE_PIN0_AVAILABLE ((uint32_t)(MXC_V_GPIO_FREE_PIN0_AVAILABLE << MXC_F_GPIO_FREE_PIN0_POS)) + +#define MXC_V_GPIO_FREE_PIN1_NOT_AVAILABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_FREE_PIN1_AVAILABLE ((uint32_t)(0x00000001UL)) + +#define MXC_S_GPIO_FREE_PIN1_AVAILABLE ((uint32_t)(MXC_V_GPIO_FREE_PIN1_AVAILABLE << MXC_F_GPIO_FREE_PIN1_POS)) + +#define MXC_V_GPIO_FREE_PIN2_NOT_AVAILABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_FREE_PIN2_AVAILABLE ((uint32_t)(0x00000001UL)) + +#define MXC_S_GPIO_FREE_PIN2_AVAILABLE ((uint32_t)(MXC_V_GPIO_FREE_PIN2_AVAILABLE << MXC_F_GPIO_FREE_PIN2_POS)) + +#define MXC_V_GPIO_FREE_PIN3_NOT_AVAILABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_FREE_PIN3_AVAILABLE ((uint32_t)(0x00000001UL)) + +#define MXC_S_GPIO_FREE_PIN3_AVAILABLE ((uint32_t)(MXC_V_GPIO_FREE_PIN3_AVAILABLE << MXC_F_GPIO_FREE_PIN3_POS)) + +#define MXC_V_GPIO_FREE_PIN4_NOT_AVAILABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_FREE_PIN4_AVAILABLE ((uint32_t)(0x00000001UL)) + +#define MXC_S_GPIO_FREE_PIN4_AVAILABLE ((uint32_t)(MXC_V_GPIO_FREE_PIN4_AVAILABLE << MXC_F_GPIO_FREE_PIN4_POS)) + +#define MXC_V_GPIO_FREE_PIN5_NOT_AVAILABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_FREE_PIN5_AVAILABLE ((uint32_t)(0x00000001UL)) + +#define MXC_S_GPIO_FREE_PIN5_AVAILABLE ((uint32_t)(MXC_V_GPIO_FREE_PIN5_AVAILABLE << MXC_F_GPIO_FREE_PIN5_POS)) + +#define MXC_V_GPIO_FREE_PIN6_NOT_AVAILABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_FREE_PIN6_AVAILABLE ((uint32_t)(0x00000001UL)) + +#define MXC_S_GPIO_FREE_PIN6_AVAILABLE ((uint32_t)(MXC_V_GPIO_FREE_PIN6_AVAILABLE << MXC_F_GPIO_FREE_PIN6_POS)) + +#define MXC_V_GPIO_FREE_PIN7_NOT_AVAILABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_FREE_PIN7_AVAILABLE ((uint32_t)(0x00000001UL)) + +#define MXC_S_GPIO_FREE_PIN7_AVAILABLE ((uint32_t)(MXC_V_GPIO_FREE_PIN7_AVAILABLE << MXC_F_GPIO_FREE_PIN7_POS)) + +#define MXC_V_GPIO_OUT_MODE_HIGH_Z_WEAK_PULLUP ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_OUT_MODE_OPEN_DRAIN ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_OUT_MODE_OPEN_DRAIN_WEAK_PULLUP ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_OUT_MODE_NORMAL_HIGH_Z ((uint32_t)(0x00000004UL)) +#define MXC_V_GPIO_OUT_MODE_NORMAL ((uint32_t)(0x00000005UL)) +#define MXC_V_GPIO_OUT_MODE_SLOW_HIGH_Z ((uint32_t)(0x00000006UL)) +#define MXC_V_GPIO_OUT_MODE_SLOW_DRIVE ((uint32_t)(0x00000007UL)) +#define MXC_V_GPIO_OUT_MODE_FAST_HIGH_Z ((uint32_t)(0x00000008UL)) +#define MXC_V_GPIO_OUT_MODE_FAST_DRIVE ((uint32_t)(0x00000009UL)) +#define MXC_V_GPIO_OUT_MODE_HIGH_Z_WEAK_PULLDOWN ((uint32_t)(0x0000000AUL)) +#define MXC_V_GPIO_OUT_MODE_OPEN_SOURCE ((uint32_t)(0x0000000BUL)) +#define MXC_V_GPIO_OUT_MODE_OPEN_SOURCE_WEAK_PULLDOWN ((uint32_t)(0x0000000CUL)) +#define MXC_V_GPIO_OUT_MODE_HIGH_Z_INPUT_DISABLED ((uint32_t)(0x0000000FUL)) + +#define MXC_V_GPIO_IN_MODE_NORMAL ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_IN_MODE_INVERTED ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_IN_MODE_ALWAYS_ZERO ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_IN_MODE_ALWAYS_ONE ((uint32_t)(0x00000003UL)) + +#define MXC_V_GPIO_IN_MODE_PIN0_NORMAL ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_IN_MODE_PIN0_INVERTED ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_IN_MODE_PIN0_ALWAYS_ZERO ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_IN_MODE_PIN0_ALWAYS_ONE ((uint32_t)(0x00000003UL)) + +#define MXC_S_GPIO_IN_MODE_PIN0_ALWAYS_ONE ((uint32_t)(MXC_V_GPIO_IN_MODE_PIN0_ALWAYS_ONE << MXC_F_GPIO_IN_MODE_PIN0_POS)) + +#define MXC_V_GPIO_IN_MODE_PIN1_NORMAL ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_IN_MODE_PIN1_INVERTED ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_IN_MODE_PIN1_ALWAYS_ZERO ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_IN_MODE_PIN1_ALWAYS_ONE ((uint32_t)(0x00000003UL)) + +#define MXC_S_GPIO_IN_MODE_PIN1_ALWAYS_ONE ((uint32_t)(MXC_V_GPIO_IN_MODE_PIN1_ALWAYS_ONE << MXC_F_GPIO_IN_MODE_PIN1_POS)) + +#define MXC_V_GPIO_IN_MODE_PIN2_NORMAL ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_IN_MODE_PIN2_INVERTED ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_IN_MODE_PIN2_ALWAYS_ZERO ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_IN_MODE_PIN2_ALWAYS_ONE ((uint32_t)(0x00000003UL)) + +#define MXC_S_GPIO_IN_MODE_PIN2_ALWAYS_ONE ((uint32_t)(MXC_V_GPIO_IN_MODE_PIN2_ALWAYS_ONE << MXC_F_GPIO_IN_MODE_PIN2_POS)) + +#define MXC_V_GPIO_IN_MODE_PIN3_NORMAL ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_IN_MODE_PIN3_INVERTED ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_IN_MODE_PIN3_ALWAYS_ZERO ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_IN_MODE_PIN3_ALWAYS_ONE ((uint32_t)(0x00000003UL)) + +#define MXC_S_GPIO_IN_MODE_PIN3_ALWAYS_ONE ((uint32_t)(MXC_V_GPIO_IN_MODE_PIN3_ALWAYS_ONE << MXC_F_GPIO_IN_MODE_PIN3_POS)) + +#define MXC_V_GPIO_IN_MODE_PIN4_NORMAL ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_IN_MODE_PIN4_INVERTED ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_IN_MODE_PIN4_ALWAYS_ZERO ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_IN_MODE_PIN4_ALWAYS_ONE ((uint32_t)(0x00000003UL)) + +#define MXC_S_GPIO_IN_MODE_PIN4_ALWAYS_ONE ((uint32_t)(MXC_V_GPIO_IN_MODE_PIN4_ALWAYS_ONE << MXC_F_GPIO_IN_MODE_PIN4_POS)) + +#define MXC_V_GPIO_IN_MODE_PIN5_NORMAL ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_IN_MODE_PIN5_INVERTED ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_IN_MODE_PIN5_ALWAYS_ZERO ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_IN_MODE_PIN5_ALWAYS_ONE ((uint32_t)(0x00000003UL)) + +#define MXC_S_GPIO_IN_MODE_PIN5_ALWAYS_ONE ((uint32_t)(MXC_V_GPIO_IN_MODE_PIN5_ALWAYS_ONE << MXC_F_GPIO_IN_MODE_PIN5_POS)) + +#define MXC_V_GPIO_IN_MODE_PIN6_NORMAL ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_IN_MODE_PIN6_INVERTED ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_IN_MODE_PIN6_ALWAYS_ZERO ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_IN_MODE_PIN6_ALWAYS_ONE ((uint32_t)(0x00000003UL)) + +#define MXC_S_GPIO_IN_MODE_PIN6_ALWAYS_ONE ((uint32_t)(MXC_V_GPIO_IN_MODE_PIN6_ALWAYS_ONE << MXC_F_GPIO_IN_MODE_PIN6_POS)) + +#define MXC_V_GPIO_IN_MODE_PIN7_NORMAL ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_IN_MODE_PIN7_INVERTED ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_IN_MODE_PIN7_ALWAYS_ZERO ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_IN_MODE_PIN7_ALWAYS_ONE ((uint32_t)(0x00000003UL)) + +#define MXC_S_GPIO_IN_MODE_PIN7_ALWAYS_ONE ((uint32_t)(MXC_V_GPIO_IN_MODE_PIN7_ALWAYS_ONE << MXC_F_GPIO_IN_MODE_PIN7_POS)) + +#define MXC_V_GPIO_INT_MODE_DISABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_INT_MODE_FALLING_EDGE ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_INT_MODE_RISING_EDGE ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_INT_MODE_ANY_EDGE ((uint32_t)(0x00000003UL)) +#define MXC_V_GPIO_INT_MODE_LOW_LVL ((uint32_t)(0x00000004UL)) +#define MXC_V_GPIO_INT_MODE_HIGH_LVL ((uint32_t)(0x00000005UL)) + +#define MXC_V_GPIO_INT_MODE_PIN0_DISABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_INT_MODE_PIN0_FALLING_EDGE ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_INT_MODE_PIN0_RISING_EDGE ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_INT_MODE_PIN0_ANY_EDGE ((uint32_t)(0x00000003UL)) +#define MXC_V_GPIO_INT_MODE_PIN0_LOW_LVL ((uint32_t)(0x00000004UL)) +#define MXC_V_GPIO_INT_MODE_PIN0_HIGH_LVL ((uint32_t)(0x00000005UL)) + +#define MXC_S_GPIO_INT_MODE_PIN0_HIGH_LVL ((uint32_t)(MXC_V_GPIO_INT_MODE_PIN0_HIGH_LVL << MXC_F_GPIO_INT_MODE_PIN0_POS)) + +#define MXC_V_GPIO_INT_MODE_PIN1_DISABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_INT_MODE_PIN1_FALLING_EDGE ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_INT_MODE_PIN1_RISING_EDGE ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_INT_MODE_PIN1_ANY_EDGE ((uint32_t)(0x00000003UL)) +#define MXC_V_GPIO_INT_MODE_PIN1_LOW_LVL ((uint32_t)(0x00000004UL)) +#define MXC_V_GPIO_INT_MODE_PIN1_HIGH_LVL ((uint32_t)(0x00000005UL)) + +#define MXC_S_GPIO_INT_MODE_PIN1_HIGH_LVL ((uint32_t)(MXC_V_GPIO_INT_MODE_PIN1_HIGH_LVL << MXC_F_GPIO_INT_MODE_PIN1_POS)) + +#define MXC_V_GPIO_INT_MODE_PIN2_DISABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_INT_MODE_PIN2_FALLING_EDGE ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_INT_MODE_PIN2_RISING_EDGE ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_INT_MODE_PIN2_ANY_EDGE ((uint32_t)(0x00000003UL)) +#define MXC_V_GPIO_INT_MODE_PIN2_LOW_LVL ((uint32_t)(0x00000004UL)) +#define MXC_V_GPIO_INT_MODE_PIN2_HIGH_LVL ((uint32_t)(0x00000005UL)) + +#define MXC_S_GPIO_INT_MODE_PIN2_HIGH_LVL ((uint32_t)(MXC_V_GPIO_INT_MODE_PIN2_HIGH_LVL << MXC_F_GPIO_INT_MODE_PIN2_POS)) + +#define MXC_V_GPIO_INT_MODE_PIN3_DISABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_INT_MODE_PIN3_FALLING_EDGE ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_INT_MODE_PIN3_RISING_EDGE ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_INT_MODE_PIN3_ANY_EDGE ((uint32_t)(0x00000003UL)) +#define MXC_V_GPIO_INT_MODE_PIN3_LOW_LVL ((uint32_t)(0x00000004UL)) +#define MXC_V_GPIO_INT_MODE_PIN3_HIGH_LVL ((uint32_t)(0x00000005UL)) + +#define MXC_S_GPIO_INT_MODE_PIN3_HIGH_LVL ((uint32_t)(MXC_V_GPIO_INT_MODE_PIN3_HIGH_LVL << MXC_F_GPIO_INT_MODE_PIN3_POS)) + +#define MXC_V_GPIO_INT_MODE_PIN4_DISABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_INT_MODE_PIN4_FALLING_EDGE ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_INT_MODE_PIN4_RISING_EDGE ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_INT_MODE_PIN4_ANY_EDGE ((uint32_t)(0x00000003UL)) +#define MXC_V_GPIO_INT_MODE_PIN4_LOW_LVL ((uint32_t)(0x00000004UL)) +#define MXC_V_GPIO_INT_MODE_PIN4_HIGH_LVL ((uint32_t)(0x00000005UL)) + +#define MXC_S_GPIO_INT_MODE_PIN4_HIGH_LVL ((uint32_t)(MXC_V_GPIO_INT_MODE_PIN4_HIGH_LVL << MXC_F_GPIO_INT_MODE_PIN4_POS)) + +#define MXC_V_GPIO_INT_MODE_PIN5_DISABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_INT_MODE_PIN5_FALLING_EDGE ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_INT_MODE_PIN5_RISING_EDGE ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_INT_MODE_PIN5_ANY_EDGE ((uint32_t)(0x00000003UL)) +#define MXC_V_GPIO_INT_MODE_PIN5_LOW_LVL ((uint32_t)(0x00000004UL)) +#define MXC_V_GPIO_INT_MODE_PIN5_HIGH_LVL ((uint32_t)(0x00000005UL)) + +#define MXC_S_GPIO_INT_MODE_PIN5_HIGH_LVL ((uint32_t)(MXC_V_GPIO_INT_MODE_PIN5_HIGH_LVL << MXC_F_GPIO_INT_MODE_PIN5_POS)) + +#define MXC_V_GPIO_INT_MODE_PIN6_DISABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_INT_MODE_PIN6_FALLING_EDGE ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_INT_MODE_PIN6_RISING_EDGE ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_INT_MODE_PIN6_ANY_EDGE ((uint32_t)(0x00000003UL)) +#define MXC_V_GPIO_INT_MODE_PIN6_LOW_LVL ((uint32_t)(0x00000004UL)) +#define MXC_V_GPIO_INT_MODE_PIN6_HIGH_LVL ((uint32_t)(0x00000005UL)) + +#define MXC_S_GPIO_INT_MODE_PIN6_HIGH_LVL ((uint32_t)(MXC_V_GPIO_INT_MODE_PIN6_HIGH_LVL << MXC_F_GPIO_INT_MODE_PIN6_POS)) + +#define MXC_V_GPIO_INT_MODE_PIN7_DISABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_GPIO_INT_MODE_PIN7_FALLING_EDGE ((uint32_t)(0x00000001UL)) +#define MXC_V_GPIO_INT_MODE_PIN7_RISING_EDGE ((uint32_t)(0x00000002UL)) +#define MXC_V_GPIO_INT_MODE_PIN7_ANY_EDGE ((uint32_t)(0x00000003UL)) +#define MXC_V_GPIO_INT_MODE_PIN7_LOW_LVL ((uint32_t)(0x00000004UL)) +#define MXC_V_GPIO_INT_MODE_PIN7_HIGH_LVL ((uint32_t)(0x00000005UL)) + +#define MXC_S_GPIO_INT_MODE_PIN7_HIGH_LVL ((uint32_t)(MXC_V_GPIO_INT_MODE_PIN7_HIGH_LVL << MXC_F_GPIO_INT_MODE_PIN7_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_GPIO_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/i2cm_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/i2cm_regs.h new file mode 100644 index 0000000000..85c8df2593 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/i2cm_regs.h @@ -0,0 +1,205 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_I2CM_REGS_H_ +#define _MXC_I2CM_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +#define MXC_S_I2CM_TRANS_TAG_START 0x000 +#define MXC_S_I2CM_TRANS_TAG_TXDATA_ACK 0x100 +#define MXC_S_I2CM_TRANS_TAG_TXDATA_NACK 0x200 +#define MXC_S_I2CM_TRANS_TAG_RXDATA_COUNT 0x400 +#define MXC_S_I2CM_TRANS_TAG_RXDATA_NACK 0x500 +#define MXC_S_I2CM_TRANS_TAG_STOP 0x700 +#define MXC_S_I2CM_RSTLS_TAG_DATA 0x100 +#define MXC_S_I2CM_RSTLS_TAG_EMPTY 0x200 + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t fs_clk_div; /* 0x0000 I2C Master Full Speed SCL Clock Settings */ + __I uint32_t rsv004[2]; /* 0x0004-0x0008 */ + __IO uint32_t timeout; /* 0x000C I2C Master Timeout and Auto-Stop Settings */ + __IO uint32_t ctrl; /* 0x0010 I2C Master Control Register */ + __IO uint32_t trans; /* 0x0014 I2C Master Transaction Start and Status Flags */ + __IO uint32_t intfl; /* 0x0018 I2C Master Interrupt Flags */ + __IO uint32_t inten; /* 0x001C I2C Master Interrupt Enable/Disable Controls */ + __I uint32_t rsv020[2]; /* 0x0020-0x0024 */ + __IO uint32_t bb; /* 0x0028 I2C Master Bit-Bang Control Register */ +} mxc_i2cm_regs_t; + + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint16_t trans[1024]; /* 0x0000-0x07FC I2C Master 0 Transaction FIFO */ + __IO uint16_t rslts[1024]; /* 0x0800-0x0FFC I2C Master 0 Results FIFO */ +} mxc_i2cm_fifo_regs_t; + + +/* + Register offsets for module I2CM. +*/ + +#define MXC_R_I2CM_OFFS_FS_CLK_DIV ((uint32_t)0x00000000UL) +#define MXC_R_I2CM_OFFS_TIMEOUT ((uint32_t)0x0000000CUL) +#define MXC_R_I2CM_OFFS_CTRL ((uint32_t)0x00000010UL) +#define MXC_R_I2CM_OFFS_TRANS ((uint32_t)0x00000014UL) +#define MXC_R_I2CM_OFFS_INTFL ((uint32_t)0x00000018UL) +#define MXC_R_I2CM_OFFS_INTEN ((uint32_t)0x0000001CUL) +#define MXC_R_I2CM_OFFS_BB ((uint32_t)0x00000028UL) +#define MXC_R_I2CM_FIFO_OFFS_TRANS ((uint32_t)0x00000000UL) +#define MXC_R_I2CM_FIFO_OFFS_RSLTS ((uint32_t)0x00000800UL) + + +/* + Field positions and masks for module I2CM. +*/ + +#define MXC_F_I2CM_FS_CLK_DIV_FS_FILTER_CLK_DIV_POS 0 +#define MXC_F_I2CM_FS_CLK_DIV_FS_FILTER_CLK_DIV ((uint32_t)(0x000000FFUL << MXC_F_I2CM_FS_CLK_DIV_FS_FILTER_CLK_DIV_POS)) +#define MXC_F_I2CM_FS_CLK_DIV_FS_SCL_LO_CNT_POS 8 +#define MXC_F_I2CM_FS_CLK_DIV_FS_SCL_LO_CNT ((uint32_t)(0x00000FFFUL << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_LO_CNT_POS)) +#define MXC_F_I2CM_FS_CLK_DIV_FS_SCL_HI_CNT_POS 20 +#define MXC_F_I2CM_FS_CLK_DIV_FS_SCL_HI_CNT ((uint32_t)(0x00000FFFUL << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_HI_CNT_POS)) + +#define MXC_F_I2CM_TIMEOUT_TX_TIMEOUT_POS 16 +#define MXC_F_I2CM_TIMEOUT_TX_TIMEOUT ((uint32_t)(0x000000FFUL << MXC_F_I2CM_TIMEOUT_TX_TIMEOUT_POS)) +#define MXC_F_I2CM_TIMEOUT_AUTO_STOP_EN_POS 24 +#define MXC_F_I2CM_TIMEOUT_AUTO_STOP_EN ((uint32_t)(0x00000001UL << MXC_F_I2CM_TIMEOUT_AUTO_STOP_EN_POS)) + +#define MXC_F_I2CM_CTRL_TX_FIFO_EN_POS 2 +#define MXC_F_I2CM_CTRL_TX_FIFO_EN ((uint32_t)(0x00000001UL << MXC_F_I2CM_CTRL_TX_FIFO_EN_POS)) +#define MXC_F_I2CM_CTRL_RX_FIFO_EN_POS 3 +#define MXC_F_I2CM_CTRL_RX_FIFO_EN ((uint32_t)(0x00000001UL << MXC_F_I2CM_CTRL_RX_FIFO_EN_POS)) +#define MXC_F_I2CM_CTRL_MSTR_RESET_EN_POS 7 +#define MXC_F_I2CM_CTRL_MSTR_RESET_EN ((uint32_t)(0x00000001UL << MXC_F_I2CM_CTRL_MSTR_RESET_EN_POS)) + +#define MXC_F_I2CM_TRANS_TX_START_POS 0 +#define MXC_F_I2CM_TRANS_TX_START ((uint32_t)(0x00000001UL << MXC_F_I2CM_TRANS_TX_START_POS)) +#define MXC_F_I2CM_TRANS_TX_IN_PROGRESS_POS 1 +#define MXC_F_I2CM_TRANS_TX_IN_PROGRESS ((uint32_t)(0x00000001UL << MXC_F_I2CM_TRANS_TX_IN_PROGRESS_POS)) +#define MXC_F_I2CM_TRANS_TX_DONE_POS 2 +#define MXC_F_I2CM_TRANS_TX_DONE ((uint32_t)(0x00000001UL << MXC_F_I2CM_TRANS_TX_DONE_POS)) +#define MXC_F_I2CM_TRANS_TX_NACKED_POS 3 +#define MXC_F_I2CM_TRANS_TX_NACKED ((uint32_t)(0x00000001UL << MXC_F_I2CM_TRANS_TX_NACKED_POS)) +#define MXC_F_I2CM_TRANS_TX_LOST_ARBITR_POS 4 +#define MXC_F_I2CM_TRANS_TX_LOST_ARBITR ((uint32_t)(0x00000001UL << MXC_F_I2CM_TRANS_TX_LOST_ARBITR_POS)) +#define MXC_F_I2CM_TRANS_TX_TIMEOUT_POS 5 +#define MXC_F_I2CM_TRANS_TX_TIMEOUT ((uint32_t)(0x00000001UL << MXC_F_I2CM_TRANS_TX_TIMEOUT_POS)) + +#define MXC_F_I2CM_INTFL_TX_DONE_POS 0 +#define MXC_F_I2CM_INTFL_TX_DONE ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTFL_TX_DONE_POS)) +#define MXC_F_I2CM_INTFL_TX_NACKED_POS 1 +#define MXC_F_I2CM_INTFL_TX_NACKED ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTFL_TX_NACKED_POS)) +#define MXC_F_I2CM_INTFL_TX_LOST_ARBITR_POS 2 +#define MXC_F_I2CM_INTFL_TX_LOST_ARBITR ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTFL_TX_LOST_ARBITR_POS)) +#define MXC_F_I2CM_INTFL_TX_TIMEOUT_POS 3 +#define MXC_F_I2CM_INTFL_TX_TIMEOUT ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTFL_TX_TIMEOUT_POS)) +#define MXC_F_I2CM_INTFL_TX_FIFO_EMPTY_POS 4 +#define MXC_F_I2CM_INTFL_TX_FIFO_EMPTY ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTFL_TX_FIFO_EMPTY_POS)) +#define MXC_F_I2CM_INTFL_TX_FIFO_3Q_EMPTY_POS 5 +#define MXC_F_I2CM_INTFL_TX_FIFO_3Q_EMPTY ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTFL_TX_FIFO_3Q_EMPTY_POS)) +#define MXC_F_I2CM_INTFL_RX_FIFO_NOT_EMPTY_POS 6 +#define MXC_F_I2CM_INTFL_RX_FIFO_NOT_EMPTY ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTFL_RX_FIFO_NOT_EMPTY_POS)) +#define MXC_F_I2CM_INTFL_RX_FIFO_2Q_FULL_POS 7 +#define MXC_F_I2CM_INTFL_RX_FIFO_2Q_FULL ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTFL_RX_FIFO_2Q_FULL_POS)) +#define MXC_F_I2CM_INTFL_RX_FIFO_3Q_FULL_POS 8 +#define MXC_F_I2CM_INTFL_RX_FIFO_3Q_FULL ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTFL_RX_FIFO_3Q_FULL_POS)) +#define MXC_F_I2CM_INTFL_RX_FIFO_FULL_POS 9 +#define MXC_F_I2CM_INTFL_RX_FIFO_FULL ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTFL_RX_FIFO_FULL_POS)) + +#define MXC_F_I2CM_INTEN_TX_DONE_POS 0 +#define MXC_F_I2CM_INTEN_TX_DONE ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTEN_TX_DONE_POS)) +#define MXC_F_I2CM_INTEN_TX_NACKED_POS 1 +#define MXC_F_I2CM_INTEN_TX_NACKED ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTEN_TX_NACKED_POS)) +#define MXC_F_I2CM_INTEN_TX_LOST_ARBITR_POS 2 +#define MXC_F_I2CM_INTEN_TX_LOST_ARBITR ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTEN_TX_LOST_ARBITR_POS)) +#define MXC_F_I2CM_INTEN_TX_TIMEOUT_POS 3 +#define MXC_F_I2CM_INTEN_TX_TIMEOUT ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTEN_TX_TIMEOUT_POS)) +#define MXC_F_I2CM_INTEN_TX_FIFO_EMPTY_POS 4 +#define MXC_F_I2CM_INTEN_TX_FIFO_EMPTY ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTEN_TX_FIFO_EMPTY_POS)) +#define MXC_F_I2CM_INTEN_TX_FIFO_3Q_EMPTY_POS 5 +#define MXC_F_I2CM_INTEN_TX_FIFO_3Q_EMPTY ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTEN_TX_FIFO_3Q_EMPTY_POS)) +#define MXC_F_I2CM_INTEN_RX_FIFO_NOT_EMPTY_POS 6 +#define MXC_F_I2CM_INTEN_RX_FIFO_NOT_EMPTY ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTEN_RX_FIFO_NOT_EMPTY_POS)) +#define MXC_F_I2CM_INTEN_RX_FIFO_2Q_FULL_POS 7 +#define MXC_F_I2CM_INTEN_RX_FIFO_2Q_FULL ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTEN_RX_FIFO_2Q_FULL_POS)) +#define MXC_F_I2CM_INTEN_RX_FIFO_3Q_FULL_POS 8 +#define MXC_F_I2CM_INTEN_RX_FIFO_3Q_FULL ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTEN_RX_FIFO_3Q_FULL_POS)) +#define MXC_F_I2CM_INTEN_RX_FIFO_FULL_POS 9 +#define MXC_F_I2CM_INTEN_RX_FIFO_FULL ((uint32_t)(0x00000001UL << MXC_F_I2CM_INTEN_RX_FIFO_FULL_POS)) + +#define MXC_F_I2CM_BB_BB_SCL_OUT_POS 0 +#define MXC_F_I2CM_BB_BB_SCL_OUT ((uint32_t)(0x00000001UL << MXC_F_I2CM_BB_BB_SCL_OUT_POS)) +#define MXC_F_I2CM_BB_BB_SDA_OUT_POS 1 +#define MXC_F_I2CM_BB_BB_SDA_OUT ((uint32_t)(0x00000001UL << MXC_F_I2CM_BB_BB_SDA_OUT_POS)) +#define MXC_F_I2CM_BB_BB_SCL_IN_VAL_POS 2 +#define MXC_F_I2CM_BB_BB_SCL_IN_VAL ((uint32_t)(0x00000001UL << MXC_F_I2CM_BB_BB_SCL_IN_VAL_POS)) +#define MXC_F_I2CM_BB_BB_SDA_IN_VAL_POS 3 +#define MXC_F_I2CM_BB_BB_SDA_IN_VAL ((uint32_t)(0x00000001UL << MXC_F_I2CM_BB_BB_SDA_IN_VAL_POS)) +#define MXC_F_I2CM_BB_RX_FIFO_CNT_POS 16 +#define MXC_F_I2CM_BB_RX_FIFO_CNT ((uint32_t)(0x0000001FUL << MXC_F_I2CM_BB_RX_FIFO_CNT_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_I2CM_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/i2cs_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/i2cs_regs.h new file mode 100644 index 0000000000..7a4e4e8be5 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/i2cs_regs.h @@ -0,0 +1,242 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_I2CS_REGS_H_ +#define _MXC_I2CS_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t clk_div; /* 0x0000 I2C Slave Clock Divisor Control */ + __IO uint32_t dev_id; /* 0x0004 I2C Slave Device ID Register */ + __IO uint32_t intfl; /* 0x0008 I2CS Interrupt Flags */ + __IO uint32_t inten; /* 0x000C I2CS Interrupt Enable/Disable Controls */ + __IO uint32_t data_byte[32]; /* 0x0010-0x008C I2CS Data Byte */ +} mxc_i2cs_regs_t; + + +/* + Register offsets for module I2CS. +*/ + +#define MXC_R_I2CS_OFFS_CLK_DIV ((uint32_t)0x00000000UL) +#define MXC_R_I2CS_OFFS_DEV_ID ((uint32_t)0x00000004UL) +#define MXC_R_I2CS_OFFS_INTFL ((uint32_t)0x00000008UL) +#define MXC_R_I2CS_OFFS_INTEN ((uint32_t)0x0000000CUL) +#define MXC_R_I2CS_OFFS_DATA_BYTE ((uint32_t)0x00000010UL) + + +/* + Field positions and masks for module I2CS. +*/ + +#define MXC_F_I2CS_CLK_DIV_FS_FILTER_CLOCK_DIV_POS 0 +#define MXC_F_I2CS_CLK_DIV_FS_FILTER_CLOCK_DIV ((uint32_t)(0x000000FFUL << MXC_F_I2CS_CLK_DIV_FS_FILTER_CLOCK_DIV_POS)) + +#define MXC_F_I2CS_DEV_ID_SLAVE_DEV_ID_POS 0 +#define MXC_F_I2CS_DEV_ID_SLAVE_DEV_ID ((uint32_t)(0x000003FFUL << MXC_F_I2CS_DEV_ID_SLAVE_DEV_ID_POS)) +#define MXC_F_I2CS_DEV_ID_TEN_BIT_ID_MODE_POS 12 +#define MXC_F_I2CS_DEV_ID_TEN_BIT_ID_MODE ((uint32_t)(0x00000001UL << MXC_F_I2CS_DEV_ID_TEN_BIT_ID_MODE_POS)) +#define MXC_F_I2CS_DEV_ID_SLAVE_RESET_POS 14 +#define MXC_F_I2CS_DEV_ID_SLAVE_RESET ((uint32_t)(0x00000001UL << MXC_F_I2CS_DEV_ID_SLAVE_RESET_POS)) + +#define MXC_F_I2CS_INTFL_BYTE0_POS 0 +#define MXC_F_I2CS_INTFL_BYTE0 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE0_POS)) +#define MXC_F_I2CS_INTFL_BYTE1_POS 1 +#define MXC_F_I2CS_INTFL_BYTE1 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE1_POS)) +#define MXC_F_I2CS_INTFL_BYTE2_POS 2 +#define MXC_F_I2CS_INTFL_BYTE2 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE2_POS)) +#define MXC_F_I2CS_INTFL_BYTE3_POS 3 +#define MXC_F_I2CS_INTFL_BYTE3 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE3_POS)) +#define MXC_F_I2CS_INTFL_BYTE4_POS 4 +#define MXC_F_I2CS_INTFL_BYTE4 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE4_POS)) +#define MXC_F_I2CS_INTFL_BYTE5_POS 5 +#define MXC_F_I2CS_INTFL_BYTE5 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE5_POS)) +#define MXC_F_I2CS_INTFL_BYTE6_POS 6 +#define MXC_F_I2CS_INTFL_BYTE6 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE6_POS)) +#define MXC_F_I2CS_INTFL_BYTE7_POS 7 +#define MXC_F_I2CS_INTFL_BYTE7 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE7_POS)) +#define MXC_F_I2CS_INTFL_BYTE8_POS 8 +#define MXC_F_I2CS_INTFL_BYTE8 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE8_POS)) +#define MXC_F_I2CS_INTFL_BYTE9_POS 9 +#define MXC_F_I2CS_INTFL_BYTE9 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE9_POS)) +#define MXC_F_I2CS_INTFL_BYTE10_POS 10 +#define MXC_F_I2CS_INTFL_BYTE10 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE10_POS)) +#define MXC_F_I2CS_INTFL_BYTE11_POS 11 +#define MXC_F_I2CS_INTFL_BYTE11 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE11_POS)) +#define MXC_F_I2CS_INTFL_BYTE12_POS 12 +#define MXC_F_I2CS_INTFL_BYTE12 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE12_POS)) +#define MXC_F_I2CS_INTFL_BYTE13_POS 13 +#define MXC_F_I2CS_INTFL_BYTE13 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE13_POS)) +#define MXC_F_I2CS_INTFL_BYTE14_POS 14 +#define MXC_F_I2CS_INTFL_BYTE14 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE14_POS)) +#define MXC_F_I2CS_INTFL_BYTE15_POS 15 +#define MXC_F_I2CS_INTFL_BYTE15 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE15_POS)) +#define MXC_F_I2CS_INTFL_BYTE16_POS 16 +#define MXC_F_I2CS_INTFL_BYTE16 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE16_POS)) +#define MXC_F_I2CS_INTFL_BYTE17_POS 17 +#define MXC_F_I2CS_INTFL_BYTE17 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE17_POS)) +#define MXC_F_I2CS_INTFL_BYTE18_POS 18 +#define MXC_F_I2CS_INTFL_BYTE18 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE18_POS)) +#define MXC_F_I2CS_INTFL_BYTE19_POS 19 +#define MXC_F_I2CS_INTFL_BYTE19 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE19_POS)) +#define MXC_F_I2CS_INTFL_BYTE20_POS 20 +#define MXC_F_I2CS_INTFL_BYTE20 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE20_POS)) +#define MXC_F_I2CS_INTFL_BYTE21_POS 21 +#define MXC_F_I2CS_INTFL_BYTE21 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE21_POS)) +#define MXC_F_I2CS_INTFL_BYTE22_POS 22 +#define MXC_F_I2CS_INTFL_BYTE22 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE22_POS)) +#define MXC_F_I2CS_INTFL_BYTE23_POS 23 +#define MXC_F_I2CS_INTFL_BYTE23 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE23_POS)) +#define MXC_F_I2CS_INTFL_BYTE24_POS 24 +#define MXC_F_I2CS_INTFL_BYTE24 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE24_POS)) +#define MXC_F_I2CS_INTFL_BYTE25_POS 25 +#define MXC_F_I2CS_INTFL_BYTE25 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE25_POS)) +#define MXC_F_I2CS_INTFL_BYTE26_POS 26 +#define MXC_F_I2CS_INTFL_BYTE26 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE26_POS)) +#define MXC_F_I2CS_INTFL_BYTE27_POS 27 +#define MXC_F_I2CS_INTFL_BYTE27 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE27_POS)) +#define MXC_F_I2CS_INTFL_BYTE28_POS 28 +#define MXC_F_I2CS_INTFL_BYTE28 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE28_POS)) +#define MXC_F_I2CS_INTFL_BYTE29_POS 29 +#define MXC_F_I2CS_INTFL_BYTE29 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE29_POS)) +#define MXC_F_I2CS_INTFL_BYTE30_POS 30 +#define MXC_F_I2CS_INTFL_BYTE30 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE30_POS)) +#define MXC_F_I2CS_INTFL_BYTE31_POS 31 +#define MXC_F_I2CS_INTFL_BYTE31 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTFL_BYTE31_POS)) + +#define MXC_F_I2CS_INTEN_BYTE0_POS 0 +#define MXC_F_I2CS_INTEN_BYTE0 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE0_POS)) +#define MXC_F_I2CS_INTEN_BYTE1_POS 1 +#define MXC_F_I2CS_INTEN_BYTE1 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE1_POS)) +#define MXC_F_I2CS_INTEN_BYTE2_POS 2 +#define MXC_F_I2CS_INTEN_BYTE2 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE2_POS)) +#define MXC_F_I2CS_INTEN_BYTE3_POS 3 +#define MXC_F_I2CS_INTEN_BYTE3 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE3_POS)) +#define MXC_F_I2CS_INTEN_BYTE4_POS 4 +#define MXC_F_I2CS_INTEN_BYTE4 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE4_POS)) +#define MXC_F_I2CS_INTEN_BYTE5_POS 5 +#define MXC_F_I2CS_INTEN_BYTE5 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE5_POS)) +#define MXC_F_I2CS_INTEN_BYTE6_POS 6 +#define MXC_F_I2CS_INTEN_BYTE6 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE6_POS)) +#define MXC_F_I2CS_INTEN_BYTE7_POS 7 +#define MXC_F_I2CS_INTEN_BYTE7 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE7_POS)) +#define MXC_F_I2CS_INTEN_BYTE8_POS 8 +#define MXC_F_I2CS_INTEN_BYTE8 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE8_POS)) +#define MXC_F_I2CS_INTEN_BYTE9_POS 9 +#define MXC_F_I2CS_INTEN_BYTE9 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE9_POS)) +#define MXC_F_I2CS_INTEN_BYTE10_POS 10 +#define MXC_F_I2CS_INTEN_BYTE10 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE10_POS)) +#define MXC_F_I2CS_INTEN_BYTE11_POS 11 +#define MXC_F_I2CS_INTEN_BYTE11 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE11_POS)) +#define MXC_F_I2CS_INTEN_BYTE12_POS 12 +#define MXC_F_I2CS_INTEN_BYTE12 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE12_POS)) +#define MXC_F_I2CS_INTEN_BYTE13_POS 13 +#define MXC_F_I2CS_INTEN_BYTE13 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE13_POS)) +#define MXC_F_I2CS_INTEN_BYTE14_POS 14 +#define MXC_F_I2CS_INTEN_BYTE14 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE14_POS)) +#define MXC_F_I2CS_INTEN_BYTE15_POS 15 +#define MXC_F_I2CS_INTEN_BYTE15 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE15_POS)) +#define MXC_F_I2CS_INTEN_BYTE16_POS 16 +#define MXC_F_I2CS_INTEN_BYTE16 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE16_POS)) +#define MXC_F_I2CS_INTEN_BYTE17_POS 17 +#define MXC_F_I2CS_INTEN_BYTE17 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE17_POS)) +#define MXC_F_I2CS_INTEN_BYTE18_POS 18 +#define MXC_F_I2CS_INTEN_BYTE18 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE18_POS)) +#define MXC_F_I2CS_INTEN_BYTE19_POS 19 +#define MXC_F_I2CS_INTEN_BYTE19 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE19_POS)) +#define MXC_F_I2CS_INTEN_BYTE20_POS 20 +#define MXC_F_I2CS_INTEN_BYTE20 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE20_POS)) +#define MXC_F_I2CS_INTEN_BYTE21_POS 21 +#define MXC_F_I2CS_INTEN_BYTE21 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE21_POS)) +#define MXC_F_I2CS_INTEN_BYTE22_POS 22 +#define MXC_F_I2CS_INTEN_BYTE22 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE22_POS)) +#define MXC_F_I2CS_INTEN_BYTE23_POS 23 +#define MXC_F_I2CS_INTEN_BYTE23 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE23_POS)) +#define MXC_F_I2CS_INTEN_BYTE24_POS 24 +#define MXC_F_I2CS_INTEN_BYTE24 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE24_POS)) +#define MXC_F_I2CS_INTEN_BYTE25_POS 25 +#define MXC_F_I2CS_INTEN_BYTE25 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE25_POS)) +#define MXC_F_I2CS_INTEN_BYTE26_POS 26 +#define MXC_F_I2CS_INTEN_BYTE26 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE26_POS)) +#define MXC_F_I2CS_INTEN_BYTE27_POS 27 +#define MXC_F_I2CS_INTEN_BYTE27 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE27_POS)) +#define MXC_F_I2CS_INTEN_BYTE28_POS 28 +#define MXC_F_I2CS_INTEN_BYTE28 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE28_POS)) +#define MXC_F_I2CS_INTEN_BYTE29_POS 29 +#define MXC_F_I2CS_INTEN_BYTE29 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE29_POS)) +#define MXC_F_I2CS_INTEN_BYTE30_POS 30 +#define MXC_F_I2CS_INTEN_BYTE30 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE30_POS)) +#define MXC_F_I2CS_INTEN_BYTE31_POS 31 +#define MXC_F_I2CS_INTEN_BYTE31 ((uint32_t)(0x00000001UL << MXC_F_I2CS_INTEN_BYTE31_POS)) + +#define MXC_F_I2CS_DATA_BYTE_DATA_FIELD_POS 0 +#define MXC_F_I2CS_DATA_BYTE_DATA_FIELD ((uint32_t)(0x000000FFUL << MXC_F_I2CS_DATA_BYTE_DATA_FIELD_POS)) +#define MXC_F_I2CS_DATA_BYTE_READ_ONLY_FL_POS 8 +#define MXC_F_I2CS_DATA_BYTE_READ_ONLY_FL ((uint32_t)(0x00000001UL << MXC_F_I2CS_DATA_BYTE_READ_ONLY_FL_POS)) +#define MXC_F_I2CS_DATA_BYTE_DATA_UPDATED_FL_POS 9 +#define MXC_F_I2CS_DATA_BYTE_DATA_UPDATED_FL ((uint32_t)(0x00000001UL << MXC_F_I2CS_DATA_BYTE_DATA_UPDATED_FL_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_I2CS_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/icc_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/icc_regs.h new file mode 100644 index 0000000000..e181d1e899 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/icc_regs.h @@ -0,0 +1,112 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_ICC_REGS_H_ +#define _MXC_ICC_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t id; /* 0x0000 Cache ID Register (INTERNAL USE ONLY) */ + __IO uint32_t mem_cfg; /* 0x0004 Memory Configuration Register */ + __I uint32_t rsv008[62]; /* 0x0008-0x00FC */ + __IO uint32_t ctrl_stat; /* 0x0100 Control and Status */ + __I uint32_t rsv104[383]; /* 0x0104-0x06FC */ + __IO uint32_t invdt_all; /* 0x0700 Invalidate (Clear) Cache Control */ +} mxc_icc_regs_t; + + +/* + Register offsets for module ICC. +*/ + +#define MXC_R_ICC_OFFS_ID ((uint32_t)0x00000000UL) +#define MXC_R_ICC_OFFS_MEM_CFG ((uint32_t)0x00000004UL) +#define MXC_R_ICC_OFFS_CTRL_STAT ((uint32_t)0x00000100UL) +#define MXC_R_ICC_OFFS_INVDT_ALL ((uint32_t)0x00000700UL) + + +/* + Field positions and masks for module ICC. +*/ + +#define MXC_F_ICC_ID_RTL_VERSION_POS 0 +#define MXC_F_ICC_ID_RTL_VERSION ((uint32_t)(0x0000003FUL << MXC_F_ICC_ID_RTL_VERSION_POS)) +#define MXC_F_ICC_ID_PART_NUM_POS 6 +#define MXC_F_ICC_ID_PART_NUM ((uint32_t)(0x0000000FUL << MXC_F_ICC_ID_PART_NUM_POS)) +#define MXC_F_ICC_ID_CACHE_ID_POS 10 +#define MXC_F_ICC_ID_CACHE_ID ((uint32_t)(0x0000003FUL << MXC_F_ICC_ID_CACHE_ID_POS)) + +#define MXC_F_ICC_MEM_CFG_CACHE_SIZE_POS 0 +#define MXC_F_ICC_MEM_CFG_CACHE_SIZE ((uint32_t)(0x0000FFFFUL << MXC_F_ICC_MEM_CFG_CACHE_SIZE_POS)) +#define MXC_F_ICC_MEM_CFG_MAIN_MEMORY_SIZE_POS 16 +#define MXC_F_ICC_MEM_CFG_MAIN_MEMORY_SIZE ((uint32_t)(0x0000FFFFUL << MXC_F_ICC_MEM_CFG_MAIN_MEMORY_SIZE_POS)) + +#define MXC_F_ICC_CTRL_STAT_ENABLE_POS 0 +#define MXC_F_ICC_CTRL_STAT_ENABLE ((uint32_t)(0x00000001UL << MXC_F_ICC_CTRL_STAT_ENABLE_POS)) +#define MXC_F_ICC_CTRL_STAT_READY_POS 16 +#define MXC_F_ICC_CTRL_STAT_READY ((uint32_t)(0x00000001UL << MXC_F_ICC_CTRL_STAT_READY_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_ICC_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/ioman_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/ioman_regs.h new file mode 100644 index 0000000000..c20930418a --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/ioman_regs.h @@ -0,0 +1,940 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_IOMAN_REGS_H_ +#define _MXC_IOMAN_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + +/* + Enum type definitions for register fields in this module +*/ + +/** + * @brief Pin mapping define values common to all modules + */ +typedef enum { + /** Pin Mapping 'A' */ + MXC_E_IOMAN_MAPPING_A = 0, + /** Pin Mapping 'B' */ + MXC_E_IOMAN_MAPPING_B +} ioman_mapping_t; + + +/* + Bitfield structs for registers in this module +*/ + +typedef struct +{ + uint32_t wud_req_p0 : 8; + uint32_t wud_req_p1 : 8; + uint32_t wud_req_p2 : 8; + uint32_t wud_req_p3 : 8; +} mxc_ioman_wud_req0_t; + +typedef struct +{ + uint32_t wud_req_p4 : 8; + uint32_t wud_req_p5 : 8; + uint32_t wud_req_p6 : 1; + uint32_t : 15; +} mxc_ioman_wud_req1_t; + +typedef struct +{ + uint32_t wud_ack_p0 : 8; + uint32_t wud_ack_p1 : 8; + uint32_t wud_ack_p2 : 8; + uint32_t wud_ack_p3 : 8; +} mxc_ioman_wud_ack0_t; + +typedef struct +{ + uint32_t wud_ack_p4 : 8; + uint32_t wud_ack_p5 : 8; + uint32_t wud_ack_p6 : 1; + uint32_t : 15; +} mxc_ioman_wud_ack1_t; + +typedef struct +{ + uint32_t ali_req_p0 : 8; + uint32_t ali_req_p1 : 8; + uint32_t ali_req_p2 : 8; + uint32_t ali_req_p3 : 8; +} mxc_ioman_ali_req0_t; + +typedef struct +{ + uint32_t ali_req_p4 : 8; + uint32_t ali_req_p5 : 8; + uint32_t ali_req_p6 : 1; + uint32_t : 15; +} mxc_ioman_ali_req1_t; + +typedef struct +{ + uint32_t ali_ack_p0 : 8; + uint32_t ali_ack_p1 : 8; + uint32_t ali_ack_p2 : 8; + uint32_t ali_ack_p3 : 8; +} mxc_ioman_ali_ack0_t; + +typedef struct +{ + uint32_t ali_ack_p4 : 8; + uint32_t ali_ack_p5 : 8; + uint32_t ali_ack_p6 : 1; + uint32_t : 15; +} mxc_ioman_ali_ack1_t; + +typedef struct +{ + uint32_t : 4; + uint32_t core_io_req : 1; + uint32_t : 3; + uint32_t ss0_io_req : 1; + uint32_t ss1_io_req : 1; + uint32_t ss2_io_req : 1; + uint32_t : 1; + uint32_t quad_io_req : 1; + uint32_t : 3; + uint32_t fast_mode : 1; + uint32_t : 15; +} mxc_ioman_spix_req_t; + +typedef struct +{ + uint32_t : 4; + uint32_t core_io_ack : 1; + uint32_t : 3; + uint32_t ss0_io_ack : 1; + uint32_t ss1_io_ack : 1; + uint32_t ss2_io_ack : 1; + uint32_t : 1; + uint32_t quad_io_ack : 1; + uint32_t : 3; + uint32_t fast_mode : 1; + uint32_t : 15; +} mxc_ioman_spix_ack_t; + +typedef struct +{ + uint32_t io_map : 1; + uint32_t cts_map : 1; + uint32_t rts_map : 1; + uint32_t : 1; + uint32_t io_req : 1; + uint32_t cts_io_req : 1; + uint32_t rts_io_req : 1; + uint32_t : 25; +} mxc_ioman_uart0_req_t; + +typedef struct +{ + uint32_t io_map : 1; + uint32_t cts_map : 1; + uint32_t rts_map : 1; + uint32_t : 1; + uint32_t io_ack : 1; + uint32_t cts_io_ack : 1; + uint32_t rts_io_ack : 1; + uint32_t : 25; +} mxc_ioman_uart0_ack_t; + +typedef struct +{ + uint32_t io_map : 1; + uint32_t cts_map : 1; + uint32_t rts_map : 1; + uint32_t : 1; + uint32_t io_req : 1; + uint32_t cts_io_req : 1; + uint32_t rts_io_req : 1; + uint32_t : 25; +} mxc_ioman_uart1_req_t; + +typedef struct +{ + uint32_t io_map : 1; + uint32_t cts_map : 1; + uint32_t rts_map : 1; + uint32_t : 1; + uint32_t io_ack : 1; + uint32_t cts_io_ack : 1; + uint32_t rts_io_ack : 1; + uint32_t : 25; +} mxc_ioman_uart1_ack_t; + +typedef struct +{ + uint32_t io_map : 1; + uint32_t cts_map : 1; + uint32_t rts_map : 1; + uint32_t : 1; + uint32_t io_req : 1; + uint32_t cts_io_req : 1; + uint32_t rts_io_req : 1; + uint32_t : 25; +} mxc_ioman_uart2_req_t; + +typedef struct +{ + uint32_t io_map : 1; + uint32_t cts_map : 1; + uint32_t rts_map : 1; + uint32_t : 1; + uint32_t io_ack : 1; + uint32_t cts_io_ack : 1; + uint32_t rts_io_ack : 1; + uint32_t : 25; +} mxc_ioman_uart2_ack_t; + +typedef struct +{ + uint32_t io_map : 1; + uint32_t cts_map : 1; + uint32_t rts_map : 1; + uint32_t : 1; + uint32_t io_req : 1; + uint32_t cts_io_req : 1; + uint32_t rts_io_req : 1; + uint32_t : 25; +} mxc_ioman_uart3_req_t; + +typedef struct +{ + uint32_t io_map : 1; + uint32_t cts_map : 1; + uint32_t rts_map : 1; + uint32_t : 1; + uint32_t io_ack : 1; + uint32_t cts_io_ack : 1; + uint32_t rts_io_ack : 1; + uint32_t : 25; +} mxc_ioman_uart3_ack_t; + +typedef struct +{ + uint32_t : 4; + uint32_t mapping_req : 1; + uint32_t : 27; +} mxc_ioman_i2cm0_req_t; + +typedef struct +{ + uint32_t : 4; + uint32_t mapping_ack : 1; + uint32_t : 27; +} mxc_ioman_i2cm0_ack_t; + +typedef struct +{ + uint32_t : 4; + uint32_t mapping_req : 1; + uint32_t : 27; +} mxc_ioman_i2cm1_req_t; + +typedef struct +{ + uint32_t : 4; + uint32_t mapping_ack : 1; + uint32_t : 27; +} mxc_ioman_i2cm1_ack_t; + +typedef struct +{ + uint32_t : 4; + uint32_t mapping_req : 1; + uint32_t : 27; +} mxc_ioman_i2cm2_req_t; + +typedef struct +{ + uint32_t : 4; + uint32_t mapping_ack : 1; + uint32_t : 27; +} mxc_ioman_i2cm2_ack_t; + +typedef struct +{ + uint32_t io_sel : 2; + uint32_t : 2; + uint32_t mapping_req : 1; + uint32_t : 27; +} mxc_ioman_i2cs_req_t; + +typedef struct +{ + uint32_t io_sel : 2; + uint32_t : 2; + uint32_t mapping_ack : 1; + uint32_t : 27; +} mxc_ioman_i2cs_ack_t; + +typedef struct +{ + uint32_t : 4; + uint32_t core_io_req : 1; + uint32_t : 3; + uint32_t ss0_io_req : 1; + uint32_t ss1_io_req : 1; + uint32_t ss2_io_req : 1; + uint32_t ss3_io_req : 1; + uint32_t ss4_io_req : 1; + uint32_t : 7; + uint32_t quad_io_req : 1; + uint32_t : 3; + uint32_t fast_mode : 1; + uint32_t : 7; +} mxc_ioman_spim0_req_t; + +typedef struct +{ + uint32_t : 4; + uint32_t core_io_ack : 1; + uint32_t : 3; + uint32_t ss0_io_ack : 1; + uint32_t ss1_io_ack : 1; + uint32_t ss2_io_ack : 1; + uint32_t ss3_io_ack : 1; + uint32_t ss4_io_ack : 1; + uint32_t : 7; + uint32_t quad_io_ack : 1; + uint32_t : 3; + uint32_t fast_mode : 1; + uint32_t : 7; +} mxc_ioman_spim0_ack_t; + +typedef struct +{ + uint32_t : 4; + uint32_t core_io_req : 1; + uint32_t : 3; + uint32_t ss0_io_req : 1; + uint32_t ss1_io_req : 1; + uint32_t ss2_io_req : 1; + uint32_t : 9; + uint32_t quad_io_req : 1; + uint32_t : 3; + uint32_t fast_mode : 1; + uint32_t : 7; +} mxc_ioman_spim1_req_t; + +typedef struct +{ + uint32_t : 4; + uint32_t core_io_ack : 1; + uint32_t : 3; + uint32_t ss0_io_ack : 1; + uint32_t ss1_io_ack : 1; + uint32_t ss2_io_ack : 1; + uint32_t : 9; + uint32_t quad_io_ack : 1; + uint32_t : 3; + uint32_t fast_mode : 1; + uint32_t : 7; +} mxc_ioman_spim1_ack_t; + +typedef struct +{ + uint32_t mapping_req : 1; + uint32_t : 3; + uint32_t core_io_req : 1; + uint32_t : 3; + uint32_t ss0_io_req : 1; + uint32_t ss1_io_req : 1; + uint32_t ss2_io_req : 1; + uint32_t : 5; + uint32_t sr0_io_req : 1; + uint32_t sr1_io_req : 1; + uint32_t : 2; + uint32_t quad_io_req : 1; + uint32_t : 3; + uint32_t fast_mode : 1; + uint32_t : 7; +} mxc_ioman_spim2_req_t; + +typedef struct +{ + uint32_t mapping_ack : 1; + uint32_t : 3; + uint32_t core_io_ack : 1; + uint32_t : 3; + uint32_t ss0_io_ack : 1; + uint32_t ss1_io_ack : 1; + uint32_t ss2_io_ack : 1; + uint32_t : 5; + uint32_t sr0_io_req : 1; + uint32_t sr1_io_req : 1; + uint32_t : 2; + uint32_t quad_io_ack : 1; + uint32_t : 3; + uint32_t fast_mode : 1; + uint32_t : 7; +} mxc_ioman_spim2_ack_t; + +typedef struct +{ + uint32_t : 4; + uint32_t core_io_req : 1; + uint32_t : 3; + uint32_t quad_io_req : 1; + uint32_t : 3; + uint32_t fast_mode : 1; + uint32_t : 19; +} mxc_ioman_spib_req_t; + +typedef struct +{ + uint32_t : 4; + uint32_t core_io_ack : 1; + uint32_t : 3; + uint32_t quad_io_ack : 1; + uint32_t : 3; + uint32_t fast_mode : 1; + uint32_t : 19; +} mxc_ioman_spib_ack_t; + +typedef struct +{ + uint32_t : 4; + uint32_t mapping_req : 1; + uint32_t epu_io_req : 1; + uint32_t : 26; +} mxc_ioman_owm_req_t; + +typedef struct +{ + uint32_t : 4; + uint32_t mapping_ack : 1; + uint32_t epu_io_ack : 1; + uint32_t : 26; +} mxc_ioman_owm_ack_t; + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t wud_req0; /* 0x0000 Wakeup Detect Mode Request Register 0 (P0/P1/P2/P3) */ + __IO uint32_t wud_req1; /* 0x0004 Wakeup Detect Mode Request Register 1 (P4/P5/P6) */ + __IO uint32_t wud_ack0; /* 0x0008 Wakeup Detect Mode Acknowledge Register 0 (P0/P1/P2/P3) */ + __IO uint32_t wud_ack1; /* 0x000C Wakeup Detect Mode Acknowledge Register 1 (P4/P5/P6) */ + __IO uint32_t ali_req0; /* 0x0010 Analog Input Request Register 0 (P0/P1/P2/P3) */ + __IO uint32_t ali_req1; /* 0x0014 Analog Input Request Register 1 (P4/P5/P6) */ + __IO uint32_t ali_ack0; /* 0x0018 Analog Input Acknowledge Register 0 (P0/P1/P2/P3) */ + __IO uint32_t ali_ack1; /* 0x001C Analog Input Acknowledge Register 1 (P4/P5/P6) */ + __IO uint32_t ali_connect0; /* 0x0020 Analog I/O Connection Control Register 0 */ + __IO uint32_t ali_connect1; /* 0x0024 Analog I/O Connection Control Register 1 */ + __IO uint32_t spix_req; /* 0x0028 SPIX I/O Mode Request */ + __IO uint32_t spix_ack; /* 0x002C SPIX I/O Mode Acknowledge */ + __IO uint32_t uart0_req; /* 0x0030 UART0 I/O Mode Request */ + __IO uint32_t uart0_ack; /* 0x0034 UART0 I/O Mode Acknowledge */ + __IO uint32_t uart1_req; /* 0x0038 UART1 I/O Mode Request */ + __IO uint32_t uart1_ack; /* 0x003C UART1 I/O Mode Acknowledge */ + __IO uint32_t uart2_req; /* 0x0040 UART2 I/O Mode Request */ + __IO uint32_t uart2_ack; /* 0x0044 UART2 I/O Mode Acknowledge */ + __IO uint32_t uart3_req; /* 0x0048 UART3 I/O Mode Request */ + __IO uint32_t uart3_ack; /* 0x004C UART3 I/O Mode Acknowledge */ + __IO uint32_t i2cm0_req; /* 0x0050 I2C Master 0 I/O Request */ + __IO uint32_t i2cm0_ack; /* 0x0054 I2C Master 0 I/O Acknowledge */ + __IO uint32_t i2cm1_req; /* 0x0058 I2C Master 1 I/O Request */ + __IO uint32_t i2cm1_ack; /* 0x005C I2C Master 1 I/O Acknowledge */ + __IO uint32_t i2cm2_req; /* 0x0060 I2C Master 2 I/O Request */ + __IO uint32_t i2cm2_ack; /* 0x0064 I2C Master 2 I/O Acknowledge */ + __IO uint32_t i2cs_req; /* 0x0068 I2C Slave I/O Request */ + __IO uint32_t i2cs_ack; /* 0x006C I2C Slave I/O Acknowledge */ + __IO uint32_t spim0_req; /* 0x0070 SPI Master 0 I/O Mode Request */ + __IO uint32_t spim0_ack; /* 0x0074 SPI Master 0 I/O Mode Acknowledge */ + __IO uint32_t spim1_req; /* 0x0078 SPI Master 1 I/O Mode Request */ + __IO uint32_t spim1_ack; /* 0x007C SPI Master 1 I/O Mode Acknowledge */ + __IO uint32_t spim2_req; /* 0x0080 SPI Master 2 I/O Mode Request */ + __IO uint32_t spim2_ack; /* 0x0084 SPI Master 2 I/O Mode Acknowledge */ + __IO uint32_t spib_req; /* 0x0088 SPI Bridge I/O Mode Request */ + __IO uint32_t spib_ack; /* 0x008C SPI Bridge I/O Mode Acknowledge */ + __IO uint32_t owm_req; /* 0x0090 1-Wire Master I/O Mode Request */ + __IO uint32_t owm_ack; /* 0x0094 1-Wire Master I/O Mode Acknowledge */ +} mxc_ioman_regs_t; + + +/* + Register offsets for module IOMAN. +*/ + +#define MXC_R_IOMAN_OFFS_WUD_REQ0 ((uint32_t)0x00000000UL) +#define MXC_R_IOMAN_OFFS_WUD_REQ1 ((uint32_t)0x00000004UL) +#define MXC_R_IOMAN_OFFS_WUD_ACK0 ((uint32_t)0x00000008UL) +#define MXC_R_IOMAN_OFFS_WUD_ACK1 ((uint32_t)0x0000000CUL) +#define MXC_R_IOMAN_OFFS_ALI_REQ0 ((uint32_t)0x00000010UL) +#define MXC_R_IOMAN_OFFS_ALI_REQ1 ((uint32_t)0x00000014UL) +#define MXC_R_IOMAN_OFFS_ALI_ACK0 ((uint32_t)0x00000018UL) +#define MXC_R_IOMAN_OFFS_ALI_ACK1 ((uint32_t)0x0000001CUL) +#define MXC_R_IOMAN_OFFS_ALI_CONNECT0 ((uint32_t)0x00000020UL) +#define MXC_R_IOMAN_OFFS_ALI_CONNECT1 ((uint32_t)0x00000024UL) +#define MXC_R_IOMAN_OFFS_SPIX_REQ ((uint32_t)0x00000028UL) +#define MXC_R_IOMAN_OFFS_SPIX_ACK ((uint32_t)0x0000002CUL) +#define MXC_R_IOMAN_OFFS_UART0_REQ ((uint32_t)0x00000030UL) +#define MXC_R_IOMAN_OFFS_UART0_ACK ((uint32_t)0x00000034UL) +#define MXC_R_IOMAN_OFFS_UART1_REQ ((uint32_t)0x00000038UL) +#define MXC_R_IOMAN_OFFS_UART1_ACK ((uint32_t)0x0000003CUL) +#define MXC_R_IOMAN_OFFS_UART2_REQ ((uint32_t)0x00000040UL) +#define MXC_R_IOMAN_OFFS_UART2_ACK ((uint32_t)0x00000044UL) +#define MXC_R_IOMAN_OFFS_UART3_REQ ((uint32_t)0x00000048UL) +#define MXC_R_IOMAN_OFFS_UART3_ACK ((uint32_t)0x0000004CUL) +#define MXC_R_IOMAN_OFFS_I2CM0_REQ ((uint32_t)0x00000050UL) +#define MXC_R_IOMAN_OFFS_I2CM0_ACK ((uint32_t)0x00000054UL) +#define MXC_R_IOMAN_OFFS_I2CM1_REQ ((uint32_t)0x00000058UL) +#define MXC_R_IOMAN_OFFS_I2CM1_ACK ((uint32_t)0x0000005CUL) +#define MXC_R_IOMAN_OFFS_I2CM2_REQ ((uint32_t)0x00000060UL) +#define MXC_R_IOMAN_OFFS_I2CM2_ACK ((uint32_t)0x00000064UL) +#define MXC_R_IOMAN_OFFS_I2CS_REQ ((uint32_t)0x00000068UL) +#define MXC_R_IOMAN_OFFS_I2CS_ACK ((uint32_t)0x0000006CUL) +#define MXC_R_IOMAN_OFFS_SPIM0_REQ ((uint32_t)0x00000070UL) +#define MXC_R_IOMAN_OFFS_SPIM0_ACK ((uint32_t)0x00000074UL) +#define MXC_R_IOMAN_OFFS_SPIM1_REQ ((uint32_t)0x00000078UL) +#define MXC_R_IOMAN_OFFS_SPIM1_ACK ((uint32_t)0x0000007CUL) +#define MXC_R_IOMAN_OFFS_SPIM2_REQ ((uint32_t)0x00000080UL) +#define MXC_R_IOMAN_OFFS_SPIM2_ACK ((uint32_t)0x00000084UL) +#define MXC_R_IOMAN_OFFS_SPIB_REQ ((uint32_t)0x00000088UL) +#define MXC_R_IOMAN_OFFS_SPIB_ACK ((uint32_t)0x0000008CUL) +#define MXC_R_IOMAN_OFFS_OWM_REQ ((uint32_t)0x00000090UL) +#define MXC_R_IOMAN_OFFS_OWM_ACK ((uint32_t)0x00000094UL) + + +/* + Field positions and masks for module IOMAN. +*/ + +#define MXC_F_IOMAN_WUD_REQ0_WUD_REQ_P0_POS 0 +#define MXC_F_IOMAN_WUD_REQ0_WUD_REQ_P0 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_WUD_REQ0_WUD_REQ_P0_POS)) +#define MXC_F_IOMAN_WUD_REQ0_WUD_REQ_P1_POS 8 +#define MXC_F_IOMAN_WUD_REQ0_WUD_REQ_P1 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_WUD_REQ0_WUD_REQ_P1_POS)) +#define MXC_F_IOMAN_WUD_REQ0_WUD_REQ_P2_POS 16 +#define MXC_F_IOMAN_WUD_REQ0_WUD_REQ_P2 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_WUD_REQ0_WUD_REQ_P2_POS)) +#define MXC_F_IOMAN_WUD_REQ0_WUD_REQ_P3_POS 24 +#define MXC_F_IOMAN_WUD_REQ0_WUD_REQ_P3 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_WUD_REQ0_WUD_REQ_P3_POS)) + +#define MXC_F_IOMAN_WUD_REQ1_WUD_REQ_P4_POS 0 +#define MXC_F_IOMAN_WUD_REQ1_WUD_REQ_P4 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_WUD_REQ1_WUD_REQ_P4_POS)) +#define MXC_F_IOMAN_WUD_REQ1_WUD_REQ_P5_POS 8 +#define MXC_F_IOMAN_WUD_REQ1_WUD_REQ_P5 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_WUD_REQ1_WUD_REQ_P5_POS)) +#define MXC_F_IOMAN_WUD_REQ1_WUD_REQ_P6_POS 16 +#define MXC_F_IOMAN_WUD_REQ1_WUD_REQ_P6 ((uint32_t)(0x00000001UL << MXC_F_IOMAN_WUD_REQ1_WUD_REQ_P6_POS)) + +#define MXC_F_IOMAN_WUD_ACK0_WUD_ACK_P0_POS 0 +#define MXC_F_IOMAN_WUD_ACK0_WUD_ACK_P0 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_WUD_ACK0_WUD_ACK_P0_POS)) +#define MXC_F_IOMAN_WUD_ACK0_WUD_ACK_P1_POS 8 +#define MXC_F_IOMAN_WUD_ACK0_WUD_ACK_P1 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_WUD_ACK0_WUD_ACK_P1_POS)) +#define MXC_F_IOMAN_WUD_ACK0_WUD_ACK_P2_POS 16 +#define MXC_F_IOMAN_WUD_ACK0_WUD_ACK_P2 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_WUD_ACK0_WUD_ACK_P2_POS)) +#define MXC_F_IOMAN_WUD_ACK0_WUD_ACK_P3_POS 24 +#define MXC_F_IOMAN_WUD_ACK0_WUD_ACK_P3 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_WUD_ACK0_WUD_ACK_P3_POS)) + +#define MXC_F_IOMAN_WUD_ACK1_WUD_ACK_P4_POS 0 +#define MXC_F_IOMAN_WUD_ACK1_WUD_ACK_P4 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_WUD_ACK1_WUD_ACK_P4_POS)) +#define MXC_F_IOMAN_WUD_ACK1_WUD_ACK_P5_POS 8 +#define MXC_F_IOMAN_WUD_ACK1_WUD_ACK_P5 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_WUD_ACK1_WUD_ACK_P5_POS)) +#define MXC_F_IOMAN_WUD_ACK1_WUD_ACK_P6_POS 16 +#define MXC_F_IOMAN_WUD_ACK1_WUD_ACK_P6 ((uint32_t)(0x00000001UL << MXC_F_IOMAN_WUD_ACK1_WUD_ACK_P6_POS)) + +#define MXC_F_IOMAN_ALI_REQ0_ALI_REQ_P0_POS 0 +#define MXC_F_IOMAN_ALI_REQ0_ALI_REQ_P0 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_ALI_REQ0_ALI_REQ_P0_POS)) +#define MXC_F_IOMAN_ALI_REQ0_ALI_REQ_P1_POS 8 +#define MXC_F_IOMAN_ALI_REQ0_ALI_REQ_P1 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_ALI_REQ0_ALI_REQ_P1_POS)) +#define MXC_F_IOMAN_ALI_REQ0_ALI_REQ_P2_POS 16 +#define MXC_F_IOMAN_ALI_REQ0_ALI_REQ_P2 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_ALI_REQ0_ALI_REQ_P2_POS)) +#define MXC_F_IOMAN_ALI_REQ0_ALI_REQ_P3_POS 24 +#define MXC_F_IOMAN_ALI_REQ0_ALI_REQ_P3 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_ALI_REQ0_ALI_REQ_P3_POS)) + +#define MXC_F_IOMAN_ALI_REQ1_ALI_REQ_P4_POS 0 +#define MXC_F_IOMAN_ALI_REQ1_ALI_REQ_P4 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_ALI_REQ1_ALI_REQ_P4_POS)) +#define MXC_F_IOMAN_ALI_REQ1_ALI_REQ_P5_POS 8 +#define MXC_F_IOMAN_ALI_REQ1_ALI_REQ_P5 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_ALI_REQ1_ALI_REQ_P5_POS)) +#define MXC_F_IOMAN_ALI_REQ1_ALI_REQ_P6_POS 16 +#define MXC_F_IOMAN_ALI_REQ1_ALI_REQ_P6 ((uint32_t)(0x00000001UL << MXC_F_IOMAN_ALI_REQ1_ALI_REQ_P6_POS)) + +#define MXC_F_IOMAN_ALI_ACK0_ALI_ACK_P0_POS 0 +#define MXC_F_IOMAN_ALI_ACK0_ALI_ACK_P0 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_ALI_ACK0_ALI_ACK_P0_POS)) +#define MXC_F_IOMAN_ALI_ACK0_ALI_ACK_P1_POS 8 +#define MXC_F_IOMAN_ALI_ACK0_ALI_ACK_P1 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_ALI_ACK0_ALI_ACK_P1_POS)) +#define MXC_F_IOMAN_ALI_ACK0_ALI_ACK_P2_POS 16 +#define MXC_F_IOMAN_ALI_ACK0_ALI_ACK_P2 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_ALI_ACK0_ALI_ACK_P2_POS)) +#define MXC_F_IOMAN_ALI_ACK0_ALI_ACK_P3_POS 24 +#define MXC_F_IOMAN_ALI_ACK0_ALI_ACK_P3 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_ALI_ACK0_ALI_ACK_P3_POS)) + +#define MXC_F_IOMAN_ALI_ACK1_ALI_ACK_P4_POS 0 +#define MXC_F_IOMAN_ALI_ACK1_ALI_ACK_P4 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_ALI_ACK1_ALI_ACK_P4_POS)) +#define MXC_F_IOMAN_ALI_ACK1_ALI_ACK_P5_POS 8 +#define MXC_F_IOMAN_ALI_ACK1_ALI_ACK_P5 ((uint32_t)(0x000000FFUL << MXC_F_IOMAN_ALI_ACK1_ALI_ACK_P5_POS)) +#define MXC_F_IOMAN_ALI_ACK1_ALI_ACK_P6_POS 16 +#define MXC_F_IOMAN_ALI_ACK1_ALI_ACK_P6 ((uint32_t)(0x00000001UL << MXC_F_IOMAN_ALI_ACK1_ALI_ACK_P6_POS)) + +#define MXC_F_IOMAN_SPIX_REQ_CORE_IO_REQ_POS 4 +#define MXC_F_IOMAN_SPIX_REQ_CORE_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIX_REQ_CORE_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIX_REQ_SS0_IO_REQ_POS 8 +#define MXC_F_IOMAN_SPIX_REQ_SS0_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIX_REQ_SS0_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIX_REQ_SS1_IO_REQ_POS 9 +#define MXC_F_IOMAN_SPIX_REQ_SS1_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIX_REQ_SS1_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIX_REQ_SS2_IO_REQ_POS 10 +#define MXC_F_IOMAN_SPIX_REQ_SS2_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIX_REQ_SS2_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIX_REQ_QUAD_IO_REQ_POS 12 +#define MXC_F_IOMAN_SPIX_REQ_QUAD_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIX_REQ_QUAD_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIX_REQ_FAST_MODE_POS 16 +#define MXC_F_IOMAN_SPIX_REQ_FAST_MODE ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIX_REQ_FAST_MODE_POS)) + +#define MXC_F_IOMAN_SPIX_ACK_CORE_IO_ACK_POS 4 +#define MXC_F_IOMAN_SPIX_ACK_CORE_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIX_ACK_CORE_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIX_ACK_SS0_IO_ACK_POS 8 +#define MXC_F_IOMAN_SPIX_ACK_SS0_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIX_ACK_SS0_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIX_ACK_SS1_IO_ACK_POS 9 +#define MXC_F_IOMAN_SPIX_ACK_SS1_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIX_ACK_SS1_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIX_ACK_SS2_IO_ACK_POS 10 +#define MXC_F_IOMAN_SPIX_ACK_SS2_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIX_ACK_SS2_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIX_ACK_QUAD_IO_ACK_POS 12 +#define MXC_F_IOMAN_SPIX_ACK_QUAD_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIX_ACK_QUAD_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIX_ACK_FAST_MODE_POS 16 +#define MXC_F_IOMAN_SPIX_ACK_FAST_MODE ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIX_ACK_FAST_MODE_POS)) + +#define MXC_F_IOMAN_UART0_REQ_IO_MAP_POS 0 +#define MXC_F_IOMAN_UART0_REQ_IO_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_REQ_IO_MAP_POS)) +#define MXC_F_IOMAN_UART0_REQ_CTS_MAP_POS 1 +#define MXC_F_IOMAN_UART0_REQ_CTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_REQ_CTS_MAP_POS)) +#define MXC_F_IOMAN_UART0_REQ_RTS_MAP_POS 2 +#define MXC_F_IOMAN_UART0_REQ_RTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_REQ_RTS_MAP_POS)) +#define MXC_F_IOMAN_UART0_REQ_IO_REQ_POS 4 +#define MXC_F_IOMAN_UART0_REQ_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_REQ_IO_REQ_POS)) +#define MXC_F_IOMAN_UART0_REQ_CTS_IO_REQ_POS 5 +#define MXC_F_IOMAN_UART0_REQ_CTS_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_REQ_CTS_IO_REQ_POS)) +#define MXC_F_IOMAN_UART0_REQ_RTS_IO_REQ_POS 6 +#define MXC_F_IOMAN_UART0_REQ_RTS_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_REQ_RTS_IO_REQ_POS)) + +#define MXC_F_IOMAN_UART0_ACK_IO_MAP_POS 0 +#define MXC_F_IOMAN_UART0_ACK_IO_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_ACK_IO_MAP_POS)) +#define MXC_F_IOMAN_UART0_ACK_CTS_MAP_POS 1 +#define MXC_F_IOMAN_UART0_ACK_CTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_ACK_CTS_MAP_POS)) +#define MXC_F_IOMAN_UART0_ACK_RTS_MAP_POS 2 +#define MXC_F_IOMAN_UART0_ACK_RTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_ACK_RTS_MAP_POS)) +#define MXC_F_IOMAN_UART0_ACK_IO_ACK_POS 4 +#define MXC_F_IOMAN_UART0_ACK_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_ACK_IO_ACK_POS)) +#define MXC_F_IOMAN_UART0_ACK_CTS_IO_ACK_POS 5 +#define MXC_F_IOMAN_UART0_ACK_CTS_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_ACK_CTS_IO_ACK_POS)) +#define MXC_F_IOMAN_UART0_ACK_RTS_IO_ACK_POS 6 +#define MXC_F_IOMAN_UART0_ACK_RTS_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_ACK_RTS_IO_ACK_POS)) + +#define MXC_F_IOMAN_UART1_REQ_IO_MAP_POS 0 +#define MXC_F_IOMAN_UART1_REQ_IO_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART1_REQ_IO_MAP_POS)) +#define MXC_F_IOMAN_UART1_REQ_CTS_MAP_POS 1 +#define MXC_F_IOMAN_UART1_REQ_CTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART1_REQ_CTS_MAP_POS)) +#define MXC_F_IOMAN_UART1_REQ_RTS_MAP_POS 2 +#define MXC_F_IOMAN_UART1_REQ_RTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART1_REQ_RTS_MAP_POS)) +#define MXC_F_IOMAN_UART1_REQ_IO_REQ_POS 4 +#define MXC_F_IOMAN_UART1_REQ_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART1_REQ_IO_REQ_POS)) +#define MXC_F_IOMAN_UART1_REQ_CTS_IO_REQ_POS 5 +#define MXC_F_IOMAN_UART1_REQ_CTS_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART1_REQ_CTS_IO_REQ_POS)) +#define MXC_F_IOMAN_UART1_REQ_RTS_IO_REQ_POS 6 +#define MXC_F_IOMAN_UART1_REQ_RTS_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART1_REQ_RTS_IO_REQ_POS)) + +#define MXC_F_IOMAN_UART1_ACK_IO_MAP_POS 0 +#define MXC_F_IOMAN_UART1_ACK_IO_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART1_ACK_IO_MAP_POS)) +#define MXC_F_IOMAN_UART1_ACK_CTS_MAP_POS 1 +#define MXC_F_IOMAN_UART1_ACK_CTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART1_ACK_CTS_MAP_POS)) +#define MXC_F_IOMAN_UART1_ACK_RTS_MAP_POS 2 +#define MXC_F_IOMAN_UART1_ACK_RTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART1_ACK_RTS_MAP_POS)) +#define MXC_F_IOMAN_UART1_ACK_IO_ACK_POS 4 +#define MXC_F_IOMAN_UART1_ACK_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART1_ACK_IO_ACK_POS)) +#define MXC_F_IOMAN_UART1_ACK_CTS_IO_ACK_POS 5 +#define MXC_F_IOMAN_UART1_ACK_CTS_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART1_ACK_CTS_IO_ACK_POS)) +#define MXC_F_IOMAN_UART1_ACK_RTS_IO_ACK_POS 6 +#define MXC_F_IOMAN_UART1_ACK_RTS_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART1_ACK_RTS_IO_ACK_POS)) + +#define MXC_F_IOMAN_UART2_REQ_IO_MAP_POS 0 +#define MXC_F_IOMAN_UART2_REQ_IO_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART2_REQ_IO_MAP_POS)) +#define MXC_F_IOMAN_UART2_REQ_CTS_MAP_POS 1 +#define MXC_F_IOMAN_UART2_REQ_CTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART2_REQ_CTS_MAP_POS)) +#define MXC_F_IOMAN_UART2_REQ_RTS_MAP_POS 2 +#define MXC_F_IOMAN_UART2_REQ_RTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART2_REQ_RTS_MAP_POS)) +#define MXC_F_IOMAN_UART2_REQ_IO_REQ_POS 4 +#define MXC_F_IOMAN_UART2_REQ_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART2_REQ_IO_REQ_POS)) +#define MXC_F_IOMAN_UART2_REQ_CTS_IO_REQ_POS 5 +#define MXC_F_IOMAN_UART2_REQ_CTS_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART2_REQ_CTS_IO_REQ_POS)) +#define MXC_F_IOMAN_UART2_REQ_RTS_IO_REQ_POS 6 +#define MXC_F_IOMAN_UART2_REQ_RTS_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART2_REQ_RTS_IO_REQ_POS)) + +#define MXC_F_IOMAN_UART2_ACK_IO_MAP_POS 0 +#define MXC_F_IOMAN_UART2_ACK_IO_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART2_ACK_IO_MAP_POS)) +#define MXC_F_IOMAN_UART2_ACK_CTS_MAP_POS 1 +#define MXC_F_IOMAN_UART2_ACK_CTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART2_ACK_CTS_MAP_POS)) +#define MXC_F_IOMAN_UART2_ACK_RTS_MAP_POS 2 +#define MXC_F_IOMAN_UART2_ACK_RTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART2_ACK_RTS_MAP_POS)) +#define MXC_F_IOMAN_UART2_ACK_IO_ACK_POS 4 +#define MXC_F_IOMAN_UART2_ACK_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART2_ACK_IO_ACK_POS)) +#define MXC_F_IOMAN_UART2_ACK_CTS_IO_ACK_POS 5 +#define MXC_F_IOMAN_UART2_ACK_CTS_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART2_ACK_CTS_IO_ACK_POS)) +#define MXC_F_IOMAN_UART2_ACK_RTS_IO_ACK_POS 6 +#define MXC_F_IOMAN_UART2_ACK_RTS_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART2_ACK_RTS_IO_ACK_POS)) + +#define MXC_F_IOMAN_UART3_REQ_IO_MAP_POS 0 +#define MXC_F_IOMAN_UART3_REQ_IO_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART3_REQ_IO_MAP_POS)) +#define MXC_F_IOMAN_UART3_REQ_CTS_MAP_POS 1 +#define MXC_F_IOMAN_UART3_REQ_CTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART3_REQ_CTS_MAP_POS)) +#define MXC_F_IOMAN_UART3_REQ_RTS_MAP_POS 2 +#define MXC_F_IOMAN_UART3_REQ_RTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART3_REQ_RTS_MAP_POS)) +#define MXC_F_IOMAN_UART3_REQ_IO_REQ_POS 4 +#define MXC_F_IOMAN_UART3_REQ_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART3_REQ_IO_REQ_POS)) +#define MXC_F_IOMAN_UART3_REQ_CTS_IO_REQ_POS 5 +#define MXC_F_IOMAN_UART3_REQ_CTS_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART3_REQ_CTS_IO_REQ_POS)) +#define MXC_F_IOMAN_UART3_REQ_RTS_IO_REQ_POS 6 +#define MXC_F_IOMAN_UART3_REQ_RTS_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART3_REQ_RTS_IO_REQ_POS)) + +#define MXC_F_IOMAN_UART3_ACK_IO_MAP_POS 0 +#define MXC_F_IOMAN_UART3_ACK_IO_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART3_ACK_IO_MAP_POS)) +#define MXC_F_IOMAN_UART3_ACK_CTS_MAP_POS 1 +#define MXC_F_IOMAN_UART3_ACK_CTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART3_ACK_CTS_MAP_POS)) +#define MXC_F_IOMAN_UART3_ACK_RTS_MAP_POS 2 +#define MXC_F_IOMAN_UART3_ACK_RTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART3_ACK_RTS_MAP_POS)) +#define MXC_F_IOMAN_UART3_ACK_IO_ACK_POS 4 +#define MXC_F_IOMAN_UART3_ACK_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART3_ACK_IO_ACK_POS)) +#define MXC_F_IOMAN_UART3_ACK_CTS_IO_ACK_POS 5 +#define MXC_F_IOMAN_UART3_ACK_CTS_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART3_ACK_CTS_IO_ACK_POS)) +#define MXC_F_IOMAN_UART3_ACK_RTS_IO_ACK_POS 6 +#define MXC_F_IOMAN_UART3_ACK_RTS_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART3_ACK_RTS_IO_ACK_POS)) + +#define MXC_F_IOMAN_I2CM0_REQ_MAPPING_REQ_POS 4 +#define MXC_F_IOMAN_I2CM0_REQ_MAPPING_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_I2CM0_REQ_MAPPING_REQ_POS)) + +#define MXC_F_IOMAN_I2CM0_ACK_MAPPING_ACK_POS 4 +#define MXC_F_IOMAN_I2CM0_ACK_MAPPING_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_I2CM0_ACK_MAPPING_ACK_POS)) + +#define MXC_F_IOMAN_I2CM1_REQ_MAPPING_REQ_POS 4 +#define MXC_F_IOMAN_I2CM1_REQ_MAPPING_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_I2CM1_REQ_MAPPING_REQ_POS)) + +#define MXC_F_IOMAN_I2CM1_ACK_MAPPING_ACK_POS 4 +#define MXC_F_IOMAN_I2CM1_ACK_MAPPING_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_I2CM1_ACK_MAPPING_ACK_POS)) + +#define MXC_F_IOMAN_I2CM2_REQ_MAPPING_REQ_POS 4 +#define MXC_F_IOMAN_I2CM2_REQ_MAPPING_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_I2CM2_REQ_MAPPING_REQ_POS)) + +#define MXC_F_IOMAN_I2CM2_ACK_MAPPING_ACK_POS 4 +#define MXC_F_IOMAN_I2CM2_ACK_MAPPING_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_I2CM2_ACK_MAPPING_ACK_POS)) + +#define MXC_F_IOMAN_I2CS_REQ_IO_SEL_POS 0 +#define MXC_F_IOMAN_I2CS_REQ_IO_SEL ((uint32_t)(0x00000003UL << MXC_F_IOMAN_I2CS_REQ_IO_SEL_POS)) +#define MXC_F_IOMAN_I2CS_REQ_MAPPING_REQ_POS 4 +#define MXC_F_IOMAN_I2CS_REQ_MAPPING_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_I2CS_REQ_MAPPING_REQ_POS)) + +#define MXC_F_IOMAN_I2CS_ACK_IO_SEL_POS 0 +#define MXC_F_IOMAN_I2CS_ACK_IO_SEL ((uint32_t)(0x00000003UL << MXC_F_IOMAN_I2CS_ACK_IO_SEL_POS)) +#define MXC_F_IOMAN_I2CS_ACK_MAPPING_ACK_POS 4 +#define MXC_F_IOMAN_I2CS_ACK_MAPPING_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_I2CS_ACK_MAPPING_ACK_POS)) + +#define MXC_F_IOMAN_SPIM0_REQ_CORE_IO_REQ_POS 4 +#define MXC_F_IOMAN_SPIM0_REQ_CORE_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_REQ_CORE_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM0_REQ_SS0_IO_REQ_POS 8 +#define MXC_F_IOMAN_SPIM0_REQ_SS0_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_REQ_SS0_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM0_REQ_SS1_IO_REQ_POS 9 +#define MXC_F_IOMAN_SPIM0_REQ_SS1_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_REQ_SS1_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM0_REQ_SS2_IO_REQ_POS 10 +#define MXC_F_IOMAN_SPIM0_REQ_SS2_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_REQ_SS2_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM0_REQ_SS3_IO_REQ_POS 11 +#define MXC_F_IOMAN_SPIM0_REQ_SS3_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_REQ_SS3_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM0_REQ_SS4_IO_REQ_POS 12 +#define MXC_F_IOMAN_SPIM0_REQ_SS4_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_REQ_SS4_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM0_REQ_QUAD_IO_REQ_POS 20 +#define MXC_F_IOMAN_SPIM0_REQ_QUAD_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_REQ_QUAD_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM0_REQ_FAST_MODE_POS 24 +#define MXC_F_IOMAN_SPIM0_REQ_FAST_MODE ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_REQ_FAST_MODE_POS)) + +#define MXC_F_IOMAN_SPIM0_ACK_CORE_IO_ACK_POS 4 +#define MXC_F_IOMAN_SPIM0_ACK_CORE_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_ACK_CORE_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM0_ACK_SS0_IO_ACK_POS 8 +#define MXC_F_IOMAN_SPIM0_ACK_SS0_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_ACK_SS0_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM0_ACK_SS1_IO_ACK_POS 9 +#define MXC_F_IOMAN_SPIM0_ACK_SS1_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_ACK_SS1_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM0_ACK_SS2_IO_ACK_POS 10 +#define MXC_F_IOMAN_SPIM0_ACK_SS2_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_ACK_SS2_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM0_ACK_SS3_IO_ACK_POS 11 +#define MXC_F_IOMAN_SPIM0_ACK_SS3_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_ACK_SS3_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM0_ACK_SS4_IO_ACK_POS 12 +#define MXC_F_IOMAN_SPIM0_ACK_SS4_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_ACK_SS4_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM0_ACK_QUAD_IO_ACK_POS 20 +#define MXC_F_IOMAN_SPIM0_ACK_QUAD_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_ACK_QUAD_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM0_ACK_FAST_MODE_POS 24 +#define MXC_F_IOMAN_SPIM0_ACK_FAST_MODE ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_ACK_FAST_MODE_POS)) + +#define MXC_F_IOMAN_SPIM1_REQ_CORE_IO_REQ_POS 4 +#define MXC_F_IOMAN_SPIM1_REQ_CORE_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM1_REQ_CORE_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM1_REQ_SS0_IO_REQ_POS 8 +#define MXC_F_IOMAN_SPIM1_REQ_SS0_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM1_REQ_SS0_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM1_REQ_SS1_IO_REQ_POS 9 +#define MXC_F_IOMAN_SPIM1_REQ_SS1_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM1_REQ_SS1_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM1_REQ_SS2_IO_REQ_POS 10 +#define MXC_F_IOMAN_SPIM1_REQ_SS2_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM1_REQ_SS2_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM1_REQ_QUAD_IO_REQ_POS 20 +#define MXC_F_IOMAN_SPIM1_REQ_QUAD_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM1_REQ_QUAD_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM1_REQ_FAST_MODE_POS 24 +#define MXC_F_IOMAN_SPIM1_REQ_FAST_MODE ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM1_REQ_FAST_MODE_POS)) + +#define MXC_F_IOMAN_SPIM1_ACK_CORE_IO_ACK_POS 4 +#define MXC_F_IOMAN_SPIM1_ACK_CORE_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM1_ACK_CORE_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM1_ACK_SS0_IO_ACK_POS 8 +#define MXC_F_IOMAN_SPIM1_ACK_SS0_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM1_ACK_SS0_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM1_ACK_SS1_IO_ACK_POS 9 +#define MXC_F_IOMAN_SPIM1_ACK_SS1_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM1_ACK_SS1_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM1_ACK_SS2_IO_ACK_POS 10 +#define MXC_F_IOMAN_SPIM1_ACK_SS2_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM1_ACK_SS2_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM1_ACK_QUAD_IO_ACK_POS 20 +#define MXC_F_IOMAN_SPIM1_ACK_QUAD_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM1_ACK_QUAD_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM1_ACK_FAST_MODE_POS 24 +#define MXC_F_IOMAN_SPIM1_ACK_FAST_MODE ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM1_ACK_FAST_MODE_POS)) + +#define MXC_F_IOMAN_SPIM2_REQ_MAPPING_REQ_POS 0 +#define MXC_F_IOMAN_SPIM2_REQ_MAPPING_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_REQ_MAPPING_REQ_POS)) +#define MXC_F_IOMAN_SPIM2_REQ_CORE_IO_REQ_POS 4 +#define MXC_F_IOMAN_SPIM2_REQ_CORE_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_REQ_CORE_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM2_REQ_SS0_IO_REQ_POS 8 +#define MXC_F_IOMAN_SPIM2_REQ_SS0_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_REQ_SS0_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM2_REQ_SS1_IO_REQ_POS 9 +#define MXC_F_IOMAN_SPIM2_REQ_SS1_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_REQ_SS1_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM2_REQ_SS2_IO_REQ_POS 10 +#define MXC_F_IOMAN_SPIM2_REQ_SS2_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_REQ_SS2_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM2_REQ_SR0_IO_REQ_POS 16 +#define MXC_F_IOMAN_SPIM2_REQ_SR0_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_REQ_SR0_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM2_REQ_SR1_IO_REQ_POS 17 +#define MXC_F_IOMAN_SPIM2_REQ_SR1_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_REQ_SR1_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM2_REQ_QUAD_IO_REQ_POS 20 +#define MXC_F_IOMAN_SPIM2_REQ_QUAD_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_REQ_QUAD_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM2_REQ_FAST_MODE_POS 24 +#define MXC_F_IOMAN_SPIM2_REQ_FAST_MODE ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_REQ_FAST_MODE_POS)) + +#define MXC_F_IOMAN_SPIM2_ACK_MAPPING_ACK_POS 0 +#define MXC_F_IOMAN_SPIM2_ACK_MAPPING_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_ACK_MAPPING_ACK_POS)) +#define MXC_F_IOMAN_SPIM2_ACK_CORE_IO_ACK_POS 4 +#define MXC_F_IOMAN_SPIM2_ACK_CORE_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_ACK_CORE_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM2_ACK_SS0_IO_ACK_POS 8 +#define MXC_F_IOMAN_SPIM2_ACK_SS0_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_ACK_SS0_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM2_ACK_SS1_IO_ACK_POS 9 +#define MXC_F_IOMAN_SPIM2_ACK_SS1_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_ACK_SS1_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM2_ACK_SS2_IO_ACK_POS 10 +#define MXC_F_IOMAN_SPIM2_ACK_SS2_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_ACK_SS2_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM2_ACK_SR0_IO_ACK_POS 16 +#define MXC_F_IOMAN_SPIM2_ACK_SR0_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_ACK_SR0_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM2_ACK_SR1_IO_ACK_POS 17 +#define MXC_F_IOMAN_SPIM2_ACK_SR1_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_ACK_SR1_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM2_ACK_QUAD_IO_ACK_POS 20 +#define MXC_F_IOMAN_SPIM2_ACK_QUAD_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_ACK_QUAD_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM2_ACK_FAST_MODE_POS 24 +#define MXC_F_IOMAN_SPIM2_ACK_FAST_MODE ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_ACK_FAST_MODE_POS)) + +#define MXC_F_IOMAN_SPIB_REQ_CORE_IO_REQ_POS 4 +#define MXC_F_IOMAN_SPIB_REQ_CORE_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIB_REQ_CORE_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIB_REQ_QUAD_IO_REQ_POS 8 +#define MXC_F_IOMAN_SPIB_REQ_QUAD_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIB_REQ_QUAD_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIB_REQ_FAST_MODE_POS 12 +#define MXC_F_IOMAN_SPIB_REQ_FAST_MODE ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIB_REQ_FAST_MODE_POS)) + +#define MXC_F_IOMAN_SPIB_ACK_CORE_IO_ACK_POS 4 +#define MXC_F_IOMAN_SPIB_ACK_CORE_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIB_ACK_CORE_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIB_ACK_QUAD_IO_ACK_POS 8 +#define MXC_F_IOMAN_SPIB_ACK_QUAD_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIB_ACK_QUAD_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIB_ACK_FAST_MODE_POS 12 +#define MXC_F_IOMAN_SPIB_ACK_FAST_MODE ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIB_ACK_FAST_MODE_POS)) + +#define MXC_F_IOMAN_OWM_REQ_MAPPING_REQ_POS 4 +#define MXC_F_IOMAN_OWM_REQ_MAPPING_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_OWM_REQ_MAPPING_REQ_POS)) +#define MXC_F_IOMAN_OWM_REQ_EPU_IO_REQ_POS 5 +#define MXC_F_IOMAN_OWM_REQ_EPU_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_OWM_REQ_EPU_IO_REQ_POS)) + +#define MXC_F_IOMAN_OWM_ACK_MAPPING_ACK_POS 4 +#define MXC_F_IOMAN_OWM_ACK_MAPPING_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_OWM_ACK_MAPPING_ACK_POS)) +#define MXC_F_IOMAN_OWM_ACK_EPU_IO_ACK_POS 5 +#define MXC_F_IOMAN_OWM_ACK_EPU_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_OWM_ACK_EPU_IO_ACK_POS)) + +/* + Generic field positions and masks for module IOMAN. +*/ +#define MXC_F_IOMAN_UART_REQ_IO_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_REQ_IO_MAP_POS)) +#define MXC_F_IOMAN_UART_REQ_CTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_REQ_CTS_MAP_POS)) +#define MXC_F_IOMAN_UART_REQ_RTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_REQ_RTS_MAP_POS)) +#define MXC_F_IOMAN_UART_REQ_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_REQ_IO_REQ_POS)) +#define MXC_F_IOMAN_UART_REQ_CTS_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_REQ_CTS_IO_REQ_POS)) +#define MXC_F_IOMAN_UART_REQ_RTS_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_REQ_RTS_IO_REQ_POS)) + +#define MXC_F_IOMAN_UART_ACK_IO_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_ACK_IO_MAP_POS)) +#define MXC_F_IOMAN_UART_ACK_CTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_ACK_CTS_MAP_POS)) +#define MXC_F_IOMAN_UART_ACK_RTS_MAP ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_ACK_RTS_MAP_POS)) +#define MXC_F_IOMAN_UART_ACK_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_ACK_IO_ACK_POS)) +#define MXC_F_IOMAN_UART_ACK_CTS_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_ACK_CTS_IO_ACK_POS)) +#define MXC_F_IOMAN_UART_ACK_RTS_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_UART0_ACK_RTS_IO_ACK_POS)) + +#define MXC_F_IOMAN_I2CM_REQ_MAPPING_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_I2CM0_REQ_MAPPING_REQ_POS)) +#define MXC_F_IOMAN_I2CM_ACK_MAPPING_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_I2CM0_ACK_MAPPING_ACK_POS)) + +#define MXC_F_IOMAN_SPIM_REQ_CORE_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_REQ_CORE_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM_REQ_SS0_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_REQ_SS0_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM_REQ_SR0_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_REQ_SR0_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM_REQ_QUAD_IO_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_REQ_QUAD_IO_REQ_POS)) +#define MXC_F_IOMAN_SPIM_ACK_CORE_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_ACK_CORE_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM_ACK_SS0_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_ACK_SS0_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM_ACK_SR0_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_ACK_SR0_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM_ACK_QUAD_IO_ACK ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM0_ACK_QUAD_IO_ACK_POS)) +#define MXC_F_IOMAN_SPIM_REQ_MAPPING_REQ ((uint32_t)(0x00000001UL << MXC_F_IOMAN_SPIM2_REQ_MAPPING_REQ_POS)) + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_IOMAN_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/maa_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/maa_regs.h new file mode 100644 index 0000000000..e428b7535a --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/maa_regs.h @@ -0,0 +1,161 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_MAA_REGS_H_ +#define _MXC_MAA_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t ctrl; /* 0x0000 MAA Control, Configuration and Status */ + __IO uint32_t maws; /* 0x0004 MAA Word (Operand) Size, Big/Little Endian Mode Select */ +} mxc_maa_regs_t; + + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t seg0[32]; /* 0x0000-0x007C [128 bytes] MAA Memory Segment 0 */ + __IO uint32_t seg1[32]; /* 0x0080-0x00FC [128 bytes] MAA Memory Segment 1 */ + __IO uint32_t seg2[32]; /* 0x0100-0x017C [128 bytes] MAA Memory Segment 2 */ + __IO uint32_t seg3[32]; /* 0x0180-0x01FC [128 bytes] MAA Memory Segment 3 */ + __IO uint32_t seg4[32]; /* 0x0200-0x027C [128 bytes] MAA Memory Segment 4 */ + __IO uint32_t seg5[32]; /* 0x0280-0x02FC [128 bytes] MAA Memory Segment 5 */ +} mxc_maa_mem_regs_t; + + +/* + Register offsets for module MAA. +*/ + +#define MXC_R_MAA_OFFS_CTRL ((uint32_t)0x00000000UL) +#define MXC_R_MAA_OFFS_MAWS ((uint32_t)0x00000004UL) +#define MXC_R_MAA_MEM_OFFS_SEG0 ((uint32_t)0x00000000UL) +#define MXC_R_MAA_MEM_OFFS_SEG1 ((uint32_t)0x00000080UL) +#define MXC_R_MAA_MEM_OFFS_SEG2 ((uint32_t)0x00000100UL) +#define MXC_R_MAA_MEM_OFFS_SEG3 ((uint32_t)0x00000180UL) +#define MXC_R_MAA_MEM_OFFS_SEG4 ((uint32_t)0x00000200UL) +#define MXC_R_MAA_MEM_OFFS_SEG5 ((uint32_t)0x00000280UL) + + +/* + Field positions and masks for module MAA. +*/ + +#define MXC_F_MAA_CTRL_START_POS 0 +#define MXC_F_MAA_CTRL_START ((uint32_t)(0x00000001UL << MXC_F_MAA_CTRL_START_POS)) +#define MXC_F_MAA_CTRL_OPSEL_POS 1 +#define MXC_F_MAA_CTRL_OPSEL ((uint32_t)(0x00000007UL << MXC_F_MAA_CTRL_OPSEL_POS)) +#define MXC_F_MAA_CTRL_OCALC_POS 4 +#define MXC_F_MAA_CTRL_OCALC ((uint32_t)(0x00000001UL << MXC_F_MAA_CTRL_OCALC_POS)) +#define MXC_F_MAA_CTRL_IF_DONE_POS 5 +#define MXC_F_MAA_CTRL_IF_DONE ((uint32_t)(0x00000001UL << MXC_F_MAA_CTRL_IF_DONE_POS)) +#define MXC_F_MAA_CTRL_INTEN_POS 6 +#define MXC_F_MAA_CTRL_INTEN ((uint32_t)(0x00000001UL << MXC_F_MAA_CTRL_INTEN_POS)) +#define MXC_F_MAA_CTRL_IF_ERROR_POS 7 +#define MXC_F_MAA_CTRL_IF_ERROR ((uint32_t)(0x00000001UL << MXC_F_MAA_CTRL_IF_ERROR_POS)) +#define MXC_F_MAA_CTRL_OFS_A_POS 8 +#define MXC_F_MAA_CTRL_OFS_A ((uint32_t)(0x00000003UL << MXC_F_MAA_CTRL_OFS_A_POS)) +#define MXC_F_MAA_CTRL_OFS_B_POS 10 +#define MXC_F_MAA_CTRL_OFS_B ((uint32_t)(0x00000003UL << MXC_F_MAA_CTRL_OFS_B_POS)) +#define MXC_F_MAA_CTRL_OFS_EXP_POS 12 +#define MXC_F_MAA_CTRL_OFS_EXP ((uint32_t)(0x00000003UL << MXC_F_MAA_CTRL_OFS_EXP_POS)) +#define MXC_F_MAA_CTRL_OFS_MOD_POS 14 +#define MXC_F_MAA_CTRL_OFS_MOD ((uint32_t)(0x00000003UL << MXC_F_MAA_CTRL_OFS_MOD_POS)) +#define MXC_F_MAA_CTRL_SEG_A_POS 16 +#define MXC_F_MAA_CTRL_SEG_A ((uint32_t)(0x0000000FUL << MXC_F_MAA_CTRL_SEG_A_POS)) +#define MXC_F_MAA_CTRL_SEG_B_POS 20 +#define MXC_F_MAA_CTRL_SEG_B ((uint32_t)(0x0000000FUL << MXC_F_MAA_CTRL_SEG_B_POS)) +#define MXC_F_MAA_CTRL_SEG_RES_POS 24 +#define MXC_F_MAA_CTRL_SEG_RES ((uint32_t)(0x0000000FUL << MXC_F_MAA_CTRL_SEG_RES_POS)) +#define MXC_F_MAA_CTRL_SEG_TMP_POS 28 +#define MXC_F_MAA_CTRL_SEG_TMP ((uint32_t)(0x0000000FUL << MXC_F_MAA_CTRL_SEG_TMP_POS)) + +#define MXC_F_MAA_MAWS_MODLEN_POS 0 +#define MXC_F_MAA_MAWS_MODLEN ((uint32_t)(0x000003FFUL << MXC_F_MAA_MAWS_MODLEN_POS)) +#define MXC_F_MAA_MAWS_BYTESWAP_POS 15 +#define MXC_F_MAA_MAWS_BYTESWAP ((uint32_t)(0x00000001UL << MXC_F_MAA_MAWS_BYTESWAP_POS)) + + + +/* + Field values and shifted values for module MAA. +*/ + +#define MXC_V_MAA_OPSEL_EXP ((uint32_t)(0x00000000UL)) +#define MXC_V_MAA_OPSEL_SQR ((uint32_t)(0x00000001UL)) +#define MXC_V_MAA_OPSEL_MUL ((uint32_t)(0x00000002UL)) +#define MXC_V_MAA_OPSEL_SQRMUL ((uint32_t)(0x00000003UL)) +#define MXC_V_MAA_OPSEL_ADD ((uint32_t)(0x00000004UL)) +#define MXC_V_MAA_OPSEL_SUB ((uint32_t)(0x00000005UL)) + +#define MXC_S_MAA_OPSEL_EXP ((uint32_t)(MXC_V_MAA_OPSEL_EXP << MXC_F_MAA_CTRL_OPSEL_POS)) +#define MXC_S_MAA_OPSEL_SQR ((uint32_t)(MXC_V_MAA_OPSEL_SQR << MXC_F_MAA_CTRL_OPSEL_POS)) +#define MXC_S_MAA_OPSEL_MUL ((uint32_t)(MXC_V_MAA_OPSEL_MUL << MXC_F_MAA_CTRL_OPSEL_POS)) +#define MXC_S_MAA_OPSEL_SQRMUL ((uint32_t)(MXC_V_MAA_OPSEL_SQRMUL << MXC_F_MAA_CTRL_OPSEL_POS)) +#define MXC_S_MAA_OPSEL_ADD ((uint32_t)(MXC_V_MAA_OPSEL_ADD << MXC_F_MAA_CTRL_OPSEL_POS)) +#define MXC_S_MAA_OPSEL_SUB ((uint32_t)(MXC_V_MAA_OPSEL_SUB << MXC_F_MAA_CTRL_OPSEL_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_MAA_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/max32620.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/max32620.h new file mode 100644 index 0000000000..ead35a0db2 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/max32620.h @@ -0,0 +1,766 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MAX32620_H_ +#define _MAX32620_H_ + +#include + +#ifndef FALSE +#define FALSE (0) +#endif + +#ifndef TRUE +#define TRUE (1) +#endif + +/* COMPILER SPECIFIC DEFINES (IAR, ARMCC and GNUC) */ +#if defined ( __GNUC__ ) +#define __weak __attribute__((weak)) +#endif /* __GNUC__ */ + +typedef enum { + NonMaskableInt_IRQn = -14, + HardFault_IRQn = -13, + MemoryManagement_IRQn = -12, + BusFault_IRQn = -11, + UsageFault_IRQn = -10, + SVCall_IRQn = -5, + DebugMonitor_IRQn = -4, + PendSV_IRQn = -2, + SysTick_IRQn = -1, + + /* Device-specific interrupt sources (external to ARM core) */ + /* table entry number */ + /* |||| */ + /* |||| table offset address */ + /* vvvv vvvvvv */ + + CLKMAN_IRQn = 0, /* 0x10 0x0040 CLKMAN */ + PWRMAN_IRQn, /* 0x11 0x0044 PWRMAN */ + FLC_IRQn, /* 0x12 0x0048 Flash Controller */ + RTC0_IRQn, /* 0x13 0x004C RTC Counter match with Compare 0 */ + RTC1_IRQn, /* 0x14 0x0050 RTC Counter match with Compare 1 */ + RTC2_IRQn, /* 0x15 0x0054 RTC Prescaler interval compare match */ + RTC3_IRQn, /* 0x16 0x0058 RTC Overflow */ + PMU_IRQn, /* 0x17 0x005C Peripheral Management Unit (PMU/DMA) */ + USB_IRQn, /* 0x18 0x0060 USB */ + AES_IRQn, /* 0x19 0x0064 AES */ + MAA_IRQn, /* 0x1A 0x0068 MAA */ + WDT0_IRQn, /* 0x1B 0x006C Watchdog 0 timeout */ + WDT0_P_IRQn, /* 0x1C 0x0070 Watchdog 0 pre-window (fed too early) */ + WDT1_IRQn, /* 0x1D 0x0074 Watchdog 1 timeout */ + WDT1_P_IRQn, /* 0x1E 0x0078 Watchdog 1 pre-window (fed too early) */ + GPIO_P0_IRQn, /* 0x1F 0x007C GPIO Port 0 */ + GPIO_P1_IRQn, /* 0x20 0x0080 GPIO Port 1 */ + GPIO_P2_IRQn, /* 0x21 0x0084 GPIO Port 2 */ + GPIO_P3_IRQn, /* 0x22 0x0088 GPIO Port 3 */ + GPIO_P4_IRQn, /* 0x23 0x008C GPIO Port 4 */ + GPIO_P5_IRQn, /* 0x24 0x0090 GPIO Port 5 */ + GPIO_P6_IRQn, /* 0x25 0x0094 GPIO Port 6 */ + TMR0_0_IRQn, /* 0x26 0x0098 Timer 0 (32-bit, 16-bit #0) */ + TMR0_1_IRQn, /* 0x27 0x009C Timer 0 (16-bit #1) */ + TMR1_0_IRQn, /* 0x28 0x00A0 Timer 1 (32-bit, 16-bit #0) */ + TMR1_1_IRQn, /* 0x29 0x00A4 Timer 1 (16-bit #1) */ + TMR2_0_IRQn, /* 0x2A 0x00A8 Timer 2 (32-bit, 16-bit #0) */ + TMR2_1_IRQn, /* 0x2B 0x00AC Timer 2 (16-bit #1) */ + TMR3_0_IRQn, /* 0x2C 0x00B0 Timer 3 (32-bit, 16-bit #0) */ + TMR3_1_IRQn, /* 0x2D 0x00B4 Timer 3 (16-bit #1) */ + TMR4_0_IRQn, /* 0x2E 0x00B8 Timer 4 (32-bit, 16-bit #0) */ + TMR4_1_IRQn, /* 0x2F 0x00BC Timer 4 (16-bit #1) */ + TMR5_0_IRQn, /* 0x30 0x00C0 Timer 5 (32-bit, 16-bit #0) */ + TMR5_1_IRQn, /* 0x31 0x00C4 Timer 5 (16-bit #1) */ + UART0_IRQn, /* 0x32 0x00C8 UART 0 */ + UART1_IRQn, /* 0x33 0x00CC UART 1 */ + UART2_IRQn, /* 0x34 0x00D0 UART 2 */ + UART3_IRQn, /* 0x35 0x00D4 UART 3 */ + PT_IRQn, /* 0x36 0x00D8 Pulse Trains */ + I2CM0_IRQn, /* 0x37 0x00DC I2C Master 0 */ + I2CM1_IRQn, /* 0x38 0x00E0 I2C Master 1 */ + I2CM2_IRQn, /* 0x39 0x00E4 I2C Master 2 */ + I2CS0_IRQn, /* 0x3A 0x00E8 I2C Slave */ + SPI0_IRQn, /* 0x3B 0x00EC SPI Master 0 */ + SPI1_IRQn, /* 0x3C 0x00F0 SPI Master 1 */ + SPI2_IRQn, /* 0x3D 0x00F4 SPI Master 2 */ + SPIB_IRQn, /* 0x3E 0x00F8 SPI Bridge */ + OWM_IRQn, /* 0x3F 0x00FC 1-Wire Master */ + AFE_IRQn, /* 0x40 0x0100 Analog Front End, ADC */ + MXC_IRQ_EXT_COUNT, +} IRQn_Type; + +#define MXC_IRQ_COUNT (MXC_IRQ_EXT_COUNT + 16) + + +/* ================================================================================ */ +/* ================ Processor and Core Peripheral Section ================ */ +/* ================================================================================ */ + +/* ---------------------- Configuration of the Cortex-M Processor and Core Peripherals ---------------------- */ +#define __CM4_REV 0x0100 /*!< Cortex-M4 Core Revision */ +#define __MPU_PRESENT 0 /*!< MPU present or not */ +#define __NVIC_PRIO_BITS 3 /*!< Number of Bits used for Priority Levels */ +#define __Vendor_SysTickConfig 1 /*!< Set to 1 if different SysTick Config is used */ +#define __FPU_PRESENT 1 /*!< FPU present or not */ + +#include /*!< Cortex-M4 processor and core peripherals */ +#include "system_max32620.h" /*!< System Header */ + + +/* ================================================================================ */ +/* ================== Device Specific Memory Section ================== */ +/* ================================================================================ */ + +#define MXC_FLASH_MEM_BASE 0x00000000UL +#define MXC_FLASH_PAGE_SIZE 0x00002000UL +#define MXC_FLASH_MEM_SIZE 0x00100000UL +#define MXC_SYS_MEM_BASE 0x20000000UL + + +/* ================================================================================ */ +/* ================ Device Specific Peripheral Section ================ */ +/* ================================================================================ */ + + +/* + Base addresses and configuration settings for all MAX32620 peripheral modules. +*/ + + +/*******************************************************************************/ +/* System Clock Manager */ + +#define MXC_BASE_CLKMAN ((uint32_t)0x40000400UL) +#define MXC_CLKMAN ((mxc_clkman_regs_t *)MXC_BASE_CLKMAN) + + + +/*******************************************************************************/ +/* System Power Manager */ + +#define MXC_BASE_PWRMAN ((uint32_t)0x40000800UL) +#define MXC_PWRMAN ((mxc_pwrman_regs_t *)MXC_BASE_PWRMAN) + + + +/*******************************************************************************/ +/* Real Time Clock */ + +#define MXC_BASE_RTCTMR ((uint32_t)0x40000A00UL) +#define MXC_RTCTMR ((mxc_rtctmr_regs_t *)MXC_BASE_RTCTMR) +#define MXC_BASE_RTCCFG ((uint32_t)0x40000A70UL) +#define MXC_RTCCFG ((mxc_rtccfg_regs_t *)MXC_BASE_RTCCFG) + +#define MXC_RTCTMR_GET_IRQ(i) (i == 0 ? RTC0_IRQn : \ + i == 1 ? RTC1_IRQn : \ + i == 2 ? RTC2_IRQn : \ + i == 3 ? RTC3_IRQn : 0) + + + +/*******************************************************************************/ +/* Power Sequencer */ + +#define MXC_BASE_PWRSEQ ((uint32_t)0x40000A30UL) +#define MXC_PWRSEQ ((mxc_pwrseq_regs_t *)MXC_BASE_PWRSEQ) + + + +/*******************************************************************************/ +/* System I/O Manager */ + +#define MXC_BASE_IOMAN ((uint32_t)0x40000C00UL) +#define MXC_IOMAN ((mxc_ioman_regs_t *)MXC_BASE_IOMAN) + + + +/*******************************************************************************/ +/* Shadow Trim Registers */ + +#define MXC_BASE_TRIM ((uint32_t)0x40001000UL) +#define MXC_TRIM ((mxc_trim_regs_t *)MXC_BASE_TRIM) + + + +/*******************************************************************************/ +/* Flash Controller */ + +#define MXC_BASE_FLC ((uint32_t)0x40002000UL) +#define MXC_FLC ((mxc_flc_regs_t *)MXC_BASE_FLC) + +#define MXC_FLC_PAGE_SIZE_SHIFT (13) +#define MXC_FLC_PAGE_SIZE (1 << MXC_FLC_PAGE_SIZE_SHIFT) +#define MXC_FLC_PAGE_ERASE_MSK ((~(1 << (MXC_FLC_PAGE_SIZE_SHIFT - 1))) >> MXC_FLC_PAGE_SIZE_SHIFT) << MXC_FLC_PAGE_SIZE_SHIFT + + + +/*******************************************************************************/ +/* Instruction Cache */ + +#define MXC_BASE_ICC ((uint32_t)0x40003000UL) +#define MXC_ICC ((mxc_icc_regs_t *)MXC_BASE_ICC) + + + +/*******************************************************************************/ +/* SPI XIP Interface */ + +#define MXC_BASE_SPIX ((uint32_t)0x40004000UL) +#define MXC_SPIX ((mxc_spix_regs_t *)MXC_BASE_SPIX) + + + +/*******************************************************************************/ +/* Peripheral Management Unit */ + +#define MXC_CFG_PMU_CHANNELS (6) + +#define MXC_BASE_PMU0 ((uint32_t)0x40005000UL) +#define MXC_PMU0 ((mxc_pmu_regs_t *)MXC_BASE_PMU0) +#define MXC_BASE_PMU1 ((uint32_t)0x40005020UL) +#define MXC_PMU1 ((mxc_pmu_regs_t *)MXC_BASE_PMU1) +#define MXC_BASE_PMU2 ((uint32_t)0x40005040UL) +#define MXC_PMU2 ((mxc_pmu_regs_t *)MXC_BASE_PMU2) +#define MXC_BASE_PMU3 ((uint32_t)0x40005060UL) +#define MXC_PMU3 ((mxc_pmu_regs_t *)MXC_BASE_PMU3) +#define MXC_BASE_PMU4 ((uint32_t)0x40005080UL) +#define MXC_PMU4 ((mxc_pmu_regs_t *)MXC_BASE_PMU4) +#define MXC_BASE_PMU5 ((uint32_t)0x400050A0UL) +#define MXC_PMU5 ((mxc_pmu_regs_t *)MXC_BASE_PMU5) + +#define MXC_PMU_GET_BASE(i) ((i) == 0 ? MXC_BASE_PMU0 : \ + (i) == 1 ? MXC_BASE_PMU1 : \ + (i) == 2 ? MXC_BASE_PMU2 : \ + (i) == 3 ? MXC_BASE_PMU3 : \ + (i) == 4 ? MXC_BASE_PMU4 : \ + (i) == 5 ? MXC_BASE_PMU5 : 0) + +#define MXC_PMU_GET_PMU(i) ((i) == 0 ? MXC_PMU0 : \ + (i) == 1 ? MXC_PMU1 : \ + (i) == 2 ? MXC_PMU2 : \ + (i) == 3 ? MXC_PMU3 : \ + (i) == 4 ? MXC_PMU4 : \ + (i) == 5 ? MXC_PMU5 : 0) + +#define MXC_PMU_GET_IDX(p) ((p) == MXC_PMU0 ? 0 : \ + (p) == MXC_PMU1 ? 1 : \ + (p) == MXC_PMU2 ? 2 : \ + (p) == MXC_PMU3 ? 3 : \ + (p) == MXC_PMU4 ? 4 : \ + (p) == MXC_PMU5 ? 5 : -1) + + +/*******************************************************************************/ + + + + +/*******************************************************************************/ +/* USB Device Controller */ + +#define MXC_BASE_USB ((uint32_t)0x40100000UL) +#define MXC_USB ((mxc_usb_regs_t *)MXC_BASE_USB) + +#define MXC_USB_MAX_PACKET (64) +#define MXC_USB_NUM_EP (8) + + + +/*******************************************************************************/ +/* CRC-16/CRC-32 Engine */ + +#define MXC_BASE_CRC ((uint32_t)0x40006000UL) +#define MXC_CRC ((mxc_crc_regs_t *)MXC_BASE_CRC) +#define MXC_BASE_CRC_DATA ((uint32_t)0x40101000UL) +#define MXC_CRC_DATA ((mxc_crc_data_regs_t *)MXC_BASE_CRC_DATA) + + + +/*******************************************************************************/ +/* Trust Protection Unit (TPU) */ + +#define MXC_BASE_TPU ((uint32_t)0x40007000UL) +#define MXC_TPU ((mxc_tpu_regs_t *)MXC_BASE_TPU) +#define MXC_BASE_TPU_TSR ((uint32_t)0x40007C00UL) +#define MXC_TPU_TSR ((mxc_tpu_tsr_regs_t *)MXC_BASE_TPU_TSR) + + + +/*******************************************************************************/ +/* AES Cryptographic Engine */ + +#define MXC_BASE_AES ((uint32_t)0x40007400UL) +#define MXC_AES ((mxc_aes_regs_t *)MXC_BASE_AES) +#define MXC_BASE_AES_MEM ((uint32_t)0x40102000UL) +#define MXC_AES_MEM ((mxc_aes_mem_regs_t *)MXC_BASE_AES_MEM) + + + +/*******************************************************************************/ +/* MAA Cryptographic Engine */ + +#define MXC_BASE_MAA ((uint32_t)0x40007800UL) +#define MXC_MAA ((mxc_maa_regs_t *)MXC_BASE_MAA) +#define MXC_BASE_MAA_MEM ((uint32_t)0x40102800UL) +#define MXC_MAA_MEM ((mxc_maa_mem_regs_t *)MXC_BASE_MAA_MEM) + + + +/*******************************************************************************/ +/* Watchdog Timers */ + +#define MXC_CFG_WDT_INSTANCES (2) + +#define MXC_BASE_WDT0 ((uint32_t)0x40008000UL) +#define MXC_WDT0 ((mxc_wdt_regs_t *)MXC_BASE_WDT0) +#define MXC_BASE_WDT1 ((uint32_t)0x40009000UL) +#define MXC_WDT1 ((mxc_wdt_regs_t *)MXC_BASE_WDT1) + +#define MXC_WDT_GET_IRQ(i) ((i) == 0 ? WDT0_IRQn : \ + (i) == 1 ? WDT1_IRQn : 0) + +#define MXC_WDT_GET_IRQ_P(i) ((i) == 0 ? WDT0_P_IRQn : \ + (i) == 1 ? WDT1_P_IRQn : 0) + +#define MXC_WDT_GET_BASE(i) ((i) == 0 ? MXC_BASE_WDT0 : \ + (i) == 1 ? MXC_BASE_WDT1 : 0) + +#define MXC_WDT_GET_WDT(i) ((i) == 0 ? MXC_WDT0 : \ + (i) == 1 ? MXC_WDT1 : 0) + +#define MXC_WDT_GET_IDX(i) ((i) == MXC_WDT0 ? 0: (i) == MXC_WDT1 ? 1: -1) + + + +/*******************************************************************************/ +/* General Purpose I/O Ports (GPIO) */ + +#define MXC_GPIO_NUM_PORTS (7) +#define MXC_GPIO_MAX_PINS_PER_PORT (8) + +#define MXC_BASE_GPIO ((uint32_t)0x4000A000UL) +#define MXC_GPIO ((mxc_gpio_regs_t *)MXC_BASE_GPIO) + +#define MXC_GPIO_GET_IRQ(i) ((i) == 0 ? GPIO_P0_IRQn : \ + (i) == 1 ? GPIO_P1_IRQn : \ + (i) == 2 ? GPIO_P2_IRQn : \ + (i) == 3 ? GPIO_P3_IRQn : \ + (i) == 4 ? GPIO_P4_IRQn : \ + (i) == 5 ? GPIO_P5_IRQn : \ + (i) == 6 ? GPIO_P6_IRQn : 0) + + + +/*******************************************************************************/ +/* 16/32 bit Timer/Counters */ + +#define MXC_CFG_TMR_INSTANCES (6) + +#define MXC_BASE_TMR0 ((uint32_t)0x4000B000UL) +#define MXC_TMR0 ((mxc_tmr_regs_t *)MXC_BASE_TMR0) +#define MXC_BASE_TMR1 ((uint32_t)0x4000C000UL) +#define MXC_TMR1 ((mxc_tmr_regs_t *)MXC_BASE_TMR1) +#define MXC_BASE_TMR2 ((uint32_t)0x4000D000UL) +#define MXC_TMR2 ((mxc_tmr_regs_t *)MXC_BASE_TMR2) +#define MXC_BASE_TMR3 ((uint32_t)0x4000E000UL) +#define MXC_TMR3 ((mxc_tmr_regs_t *)MXC_BASE_TMR3) +#define MXC_BASE_TMR4 ((uint32_t)0x4000F000UL) +#define MXC_TMR4 ((mxc_tmr_regs_t *)MXC_BASE_TMR4) +#define MXC_BASE_TMR5 ((uint32_t)0x40010000UL) +#define MXC_TMR5 ((mxc_tmr_regs_t *)MXC_BASE_TMR5) + +#define MXC_TMR_GET_IRQ_32(i) ((i) == 0 ? TMR0_0_IRQn : \ + (i) == 1 ? TMR1_0_IRQn : \ + (i) == 2 ? TMR2_0_IRQn : \ + (i) == 3 ? TMR3_0_IRQn : \ + (i) == 4 ? TMR4_0_IRQn : \ + (i) == 5 ? TMR5_0_IRQn : 0) + +#define MXC_TMR_GET_IRQ_16(i) ((i) == 0 ? TMR0_0_IRQn : \ + (i) == 1 ? TMR1_0_IRQn : \ + (i) == 2 ? TMR2_0_IRQn : \ + (i) == 3 ? TMR3_0_IRQn : \ + (i) == 4 ? TMR4_0_IRQn : \ + (i) == 5 ? TMR5_0_IRQn : \ + (i) == 6 ? TMR0_1_IRQn : \ + (i) == 7 ? TMR1_1_IRQn : \ + (i) == 8 ? TMR2_1_IRQn : \ + (i) == 9 ? TMR3_1_IRQn : \ + (i) == 10 ? TMR4_1_IRQn : \ + (i) == 11 ? TMR5_1_IRQn : 0) + +#define MXC_TMR_GET_BASE(i) ((i) == 0 ? MXC_BASE_TMR0 : \ + (i) == 1 ? MXC_BASE_TMR1 : \ + (i) == 2 ? MXC_BASE_TMR2 : \ + (i) == 3 ? MXC_BASE_TMR3 : \ + (i) == 4 ? MXC_BASE_TMR4 : \ + (i) == 5 ? MXC_BASE_TMR5 : 0) + +#define MXC_TMR_GET_TMR(i) ((i) == 0 ? MXC_TMR0 : \ + (i) == 1 ? MXC_TMR1 : \ + (i) == 2 ? MXC_TMR2 : \ + (i) == 3 ? MXC_TMR3 : \ + (i) == 4 ? MXC_TMR4 : \ + (i) == 5 ? MXC_TMR5 : 0) + +#define MXC_TMR_GET_IDX(p) ((p) == MXC_TMR0 ? 0 : \ + (p) == MXC_TMR1 ? 1 : \ + (p) == MXC_TMR2 ? 2 : \ + (p) == MXC_TMR3 ? 3 : \ + (p) == MXC_TMR4 ? 4 : \ + (p) == MXC_TMR5 ? 5 : -1) + + + + +/*******************************************************************************/ +/* Pulse Train Generation */ + +#define MXC_CFG_PT_INSTANCES (16) + +#define MXC_BASE_PTG ((uint32_t)0x40011000UL) +#define MXC_PTG ((mxc_ptg_regs_t *)MXC_BASE_PTG) +#define MXC_BASE_PT0 ((uint32_t)0x40011010UL) +#define MXC_PT0 ((mxc_pt_regs_t *)MXC_BASE_PT0) +#define MXC_BASE_PT1 ((uint32_t)0x4001101CUL) +#define MXC_PT1 ((mxc_pt_regs_t *)MXC_BASE_PT1) +#define MXC_BASE_PT2 ((uint32_t)0x40011028UL) +#define MXC_PT2 ((mxc_pt_regs_t *)MXC_BASE_PT2) +#define MXC_BASE_PT3 ((uint32_t)0x40011034UL) +#define MXC_PT3 ((mxc_pt_regs_t *)MXC_BASE_PT3) +#define MXC_BASE_PT4 ((uint32_t)0x40011040UL) +#define MXC_PT4 ((mxc_pt_regs_t *)MXC_BASE_PT4) +#define MXC_BASE_PT5 ((uint32_t)0x4001104CUL) +#define MXC_PT5 ((mxc_pt_regs_t *)MXC_BASE_PT5) +#define MXC_BASE_PT6 ((uint32_t)0x40011058UL) +#define MXC_PT6 ((mxc_pt_regs_t *)MXC_BASE_PT6) +#define MXC_BASE_PT7 ((uint32_t)0x40011064UL) +#define MXC_PT7 ((mxc_pt_regs_t *)MXC_BASE_PT7) +#define MXC_BASE_PT8 ((uint32_t)0x40011070UL) +#define MXC_PT8 ((mxc_pt_regs_t *)MXC_BASE_PT8) +#define MXC_BASE_PT9 ((uint32_t)0x4001107CUL) +#define MXC_PT9 ((mxc_pt_regs_t *)MXC_BASE_PT9) +#define MXC_BASE_PT10 ((uint32_t)0x40011088UL) +#define MXC_PT10 ((mxc_pt_regs_t *)MXC_BASE_PT10) +#define MXC_BASE_PT11 ((uint32_t)0x40011094UL) +#define MXC_PT11 ((mxc_pt_regs_t *)MXC_BASE_PT11) +#define MXC_BASE_PT12 ((uint32_t)0x400110A0UL) +#define MXC_PT12 ((mxc_pt_regs_t *)MXC_BASE_PT12) +#define MXC_BASE_PT13 ((uint32_t)0x400110ACUL) +#define MXC_PT13 ((mxc_pt_regs_t *)MXC_BASE_PT13) +#define MXC_BASE_PT14 ((uint32_t)0x400110B8UL) +#define MXC_PT14 ((mxc_pt_regs_t *)MXC_BASE_PT14) +#define MXC_BASE_PT15 ((uint32_t)0x400110C4UL) +#define MXC_PT15 ((mxc_pt_regs_t *)MXC_BASE_PT15) + +#define MXC_PT_GET_BASE(i) ((i) == 0 ? MXC_BASE_PT0 : \ + (i) == 1 ? MXC_BASE_PT1 : \ + (i) == 2 ? MXC_BASE_PT2 : \ + (i) == 3 ? MXC_BASE_PT3 : \ + (i) == 4 ? MXC_BASE_PT4 : \ + (i) == 5 ? MXC_BASE_PT5 : \ + (i) == 6 ? MXC_BASE_PT6 : \ + (i) == 7 ? MXC_BASE_PT7 : \ + (i) == 8 ? MXC_BASE_PT8 : \ + (i) == 9 ? MXC_BASE_PT9 : \ + (i) == 10 ? MXC_BASE_PT10 : \ + (i) == 11 ? MXC_BASE_PT11 : \ + (i) == 12 ? MXC_BASE_PT12 : \ + (i) == 13 ? MXC_BASE_PT13 : \ + (i) == 14 ? MXC_BASE_PT14 : \ + (i) == 15 ? MXC_BASE_PT15 : 0) + +#define MXC_PT_GET_PT(i) ((i) == 0 ? MXC_PT0 : \ + (i) == 1 ? MXC_PT1 : \ + (i) == 2 ? MXC_PT2 : \ + (i) == 3 ? MXC_PT3 : \ + (i) == 4 ? MXC_PT4 : \ + (i) == 5 ? MXC_PT5 : \ + (i) == 6 ? MXC_PT6 : \ + (i) == 7 ? MXC_PT7 : \ + (i) == 8 ? MXC_PT8 : \ + (i) == 9 ? MXC_PT9 : \ + (i) == 10 ? MXC_PT10 : \ + (i) == 11 ? MXC_PT11 : \ + (i) == 12 ? MXC_PT12 : \ + (i) == 13 ? MXC_PT13 : \ + (i) == 14 ? MXC_PT14 : \ + (i) == 15 ? MXC_PT15 : 0) + +#define MXC_PT_GET_IDX(p) ((p) == MXC_PT0 ? 0 : \ + (p) == MXC_PT1 ? 1 : \ + (p) == MXC_PT2 ? 2 : \ + (p) == MXC_PT3 ? 3 : \ + (p) == MXC_PT4 ? 4 : \ + (p) == MXC_PT5 ? 5 : \ + (p) == MXC_PT6 ? 6 : \ + (p) == MXC_PT7 ? 7 : \ + (p) == MXC_PT8 ? 8 : \ + (p) == MXC_PT9 ? 9 : \ + (p) == MXC_PT10 ? 10 : \ + (p) == MXC_PT11 ? 11 : \ + (p) == MXC_PT12 ? 12 : \ + (p) == MXC_PT13 ? 13 : \ + (p) == MXC_PT14 ? 14 : \ + (p) == MXC_PT15 ? 15 : -1) + + + +/*******************************************************************************/ +/* UART / Serial Port Interface */ + +#define MXC_CFG_UART_INSTANCES (4) +#define MXC_UART_FIFO_DEPTH (32) + +#define MXC_BASE_UART0 ((uint32_t)0x40012000UL) +#define MXC_UART0 ((mxc_uart_regs_t *)MXC_BASE_UART0) +#define MXC_BASE_UART1 ((uint32_t)0x40013000UL) +#define MXC_UART1 ((mxc_uart_regs_t *)MXC_BASE_UART1) +#define MXC_BASE_UART2 ((uint32_t)0x40014000UL) +#define MXC_UART2 ((mxc_uart_regs_t *)MXC_BASE_UART2) +#define MXC_BASE_UART3 ((uint32_t)0x40015000UL) +#define MXC_UART3 ((mxc_uart_regs_t *)MXC_BASE_UART3) +#define MXC_BASE_UART0_FIFO ((uint32_t)0x40103000UL) +#define MXC_UART0_FIFO ((mxc_uart_fifo_regs_t *)MXC_BASE_UART0_FIFO) +#define MXC_BASE_UART1_FIFO ((uint32_t)0x40104000UL) +#define MXC_UART1_FIFO ((mxc_uart_fifo_regs_t *)MXC_BASE_UART1_FIFO) +#define MXC_BASE_UART2_FIFO ((uint32_t)0x40105000UL) +#define MXC_UART2_FIFO ((mxc_uart_fifo_regs_t *)MXC_BASE_UART2_FIFO) +#define MXC_BASE_UART3_FIFO ((uint32_t)0x40106000UL) +#define MXC_UART3_FIFO ((mxc_uart_fifo_regs_t *)MXC_BASE_UART3_FIFO) + +#define MXC_UART_GET_IRQ(i) ((i) == 0 ? UART0_IRQn : \ + (i) == 1 ? UART1_IRQn : \ + (i) == 2 ? UART2_IRQn : \ + (i) == 3 ? UART3_IRQn : 0) + +#define MXC_UART_GET_BASE(i) ((i) == 0 ? MXC_BASE_UART0 : \ + (i) == 1 ? MXC_BASE_UART1 : \ + (i) == 2 ? MXC_BASE_UART2 : \ + (i) == 3 ? MXC_BASE_UART3 : 0) + +#define MXC_UART_GET_UART(i) ((i) == 0 ? MXC_UART0 : \ + (i) == 1 ? MXC_UART1 : \ + (i) == 2 ? MXC_UART2 : \ + (i) == 3 ? MXC_UART3 : 0) + +#define MXC_UART_GET_IDX(p) ((p) == MXC_UART0 ? 0 : \ + (p) == MXC_UART1 ? 1 : \ + (p) == MXC_UART2 ? 2 : \ + (p) == MXC_UART3 ? 3 : -1) + +#define MXC_UART_GET_BASE_FIFO(i) ((i) == 0 ? MXC_BASE_UART0_FIFO : \ + (i) == 1 ? MXC_BASE_UART1_FIFO : \ + (i) == 2 ? MXC_BASE_UART2_FIFO : \ + (i) == 3 ? MXC_BASE_UART3_FIFO : 0) + +#define MXC_UART_GET_FIFO(i) ((i) == 0 ? MXC_UART0_FIFO : \ + (i) == 1 ? MXC_UART1_FIFO : \ + (i) == 2 ? MXC_UART2_FIFO : \ + (i) == 3 ? MXC_UART3_FIFO : 0) + + + +/*******************************************************************************/ +/* I2C Master Interface */ + +#define MXC_CFG_I2CM_INSTANCES (3) +#define MXC_I2CM_FIFO_DEPTH (8) + +#define MXC_BASE_I2CM0 ((uint32_t)0x40016000UL) +#define MXC_I2CM0 ((mxc_i2cm_regs_t *)MXC_BASE_I2CM0) +#define MXC_BASE_I2CM1 ((uint32_t)0x40017000UL) +#define MXC_I2CM1 ((mxc_i2cm_regs_t *)MXC_BASE_I2CM1) +#define MXC_BASE_I2CM2 ((uint32_t)0x40018000UL) +#define MXC_I2CM2 ((mxc_i2cm_regs_t *)MXC_BASE_I2CM2) +#define MXC_BASE_I2CM0_FIFO ((uint32_t)0x40107000UL) +#define MXC_I2CM0_FIFO ((mxc_i2cm_fifo_regs_t *)MXC_BASE_I2CM0_FIFO) +#define MXC_BASE_I2CM1_FIFO ((uint32_t)0x40108000UL) +#define MXC_I2CM1_FIFO ((mxc_i2cm_fifo_regs_t *)MXC_BASE_I2CM1_FIFO) +#define MXC_BASE_I2CM2_FIFO ((uint32_t)0x40109000UL) +#define MXC_I2CM2_FIFO ((mxc_i2cm_fifo_regs_t *)MXC_BASE_I2CM2_FIFO) + +#define MXC_I2CM_GET_IRQ(i) ((i) == 0 ? I2CM0_IRQn : \ + (i) == 1 ? I2CM1_IRQn : \ + (i) == 2 ? I2CM2_IRQn : 0) + +#define MXC_I2CM_GET_BASE(i) ((i) == 0 ? MXC_BASE_I2CM0 : \ + (i) == 1 ? MXC_BASE_I2CM1 : \ + (i) == 2 ? MXC_BASE_I2CM2 : 0) + +#define MXC_I2CM_GET_I2CM(i) ((i) == 0 ? MXC_I2CM0 : \ + (i) == 1 ? MXC_I2CM1 : \ + (i) == 2 ? MXC_I2CM2 : 0) + +#define MXC_I2CM_GET_IDX(p) ((p) == MXC_I2CM0 ? 0 : \ + (p) == MXC_I2CM1 ? 1 : \ + (p) == MXC_I2CM2 ? 2 : -1) + +#define MXC_I2CM_GET_BASE_FIFO(i) ((i) == 0 ? MXC_BASE_I2CM0_FIFO : \ + (i) == 1 ? MXC_BASE_I2CM1_FIFO : \ + (i) == 2 ? MXC_BASE_I2CM2_FIFO : 0) + +#define MXC_I2CM_GET_FIFO(i) ((i) == 0 ? MXC_I2CM0_FIFO : \ + (i) == 1 ? MXC_I2CM1_FIFO : \ + (i) == 2 ? MXC_I2CM2_FIFO : 0) + + + +/*******************************************************************************/ +/* I2C Slave Interface (Mailbox type) */ + +#define MXC_BASE_I2CS ((uint32_t)0x40019000UL) +#define MXC_I2CS ((mxc_i2cs_regs_t *)MXC_BASE_I2CS) + + + +/*******************************************************************************/ +/* SPI Master Interface */ + +#define MXC_CFG_SPI_INSTANCES (3) +#define MXC_CFG_SPI_FIFO_DEPTH (16) + +#define MXC_BASE_SPI0 ((uint32_t)0x4001A000UL) +#define MXC_SPI0 ((mxc_spi_regs_t *)MXC_BASE_SPI0) +#define MXC_BASE_SPI1 ((uint32_t)0x4001B000UL) +#define MXC_SPI1 ((mxc_spi_regs_t *)MXC_BASE_SPI1) +#define MXC_BASE_SPI2 ((uint32_t)0x4001C000UL) +#define MXC_SPI2 ((mxc_spi_regs_t *)MXC_BASE_SPI2) +#define MXC_BASE_SPI0_FIFO ((uint32_t)0x4010A000UL) +#define MXC_SPI0_FIFO ((mxc_spi_fifo_regs_t *)MXC_BASE_SPI0_FIFO) +#define MXC_BASE_SPI1_FIFO ((uint32_t)0x4010B000UL) +#define MXC_SPI1_FIFO ((mxc_spi_fifo_regs_t *)MXC_BASE_SPI1_FIFO) +#define MXC_BASE_SPI2_FIFO ((uint32_t)0x4010C000UL) +#define MXC_SPI2_FIFO ((mxc_spi_fifo_regs_t *)MXC_BASE_SPI2_FIFO) + +#define MXC_SPI_GET_IRQ(i) ((i) == 0 ? SPI0_IRQn : \ + (i) == 1 ? SPI1_IRQn : \ + (i) == 2 ? SPI2_IRQn : 0) + +#define MXC_SPI_GET_BASE(i) ((i) == 0 ? MXC_BASE_SPI0 : \ + (i) == 1 ? MXC_BASE_SPI1 : \ + (i) == 2 ? MXC_BASE_SPI2 : 0) + +#define MXC_SPI_GET_SPI(i) ((i) == 0 ? MXC_SPI0 : \ + (i) == 1 ? MXC_SPI1 : \ + (i) == 2 ? MXC_SPI2 : 0) + +#define MXC_SPI_GET_IDX(p) ((p) == MXC_SPI0 ? 0 : \ + (p) == MXC_SPI1 ? 1 : \ + (p) == MXC_SPI2 ? 2 : -1) + +#define MXC_SPI_GET_BASE_FIFO(i) ((i) == 0 ? MXC_BASE_SPI0_FIFO : \ + (i) == 1 ? MXC_BASE_SPI1_FIFO : \ + (i) == 2 ? MXC_BASE_SPI2_FIFO : 0) + +#define MXC_SPI_GET_SPI_FIFO(i) ((i) == 0 ? MXC_SPI0_FIFO : \ + (i) == 1 ? MXC_SPI1_FIFO : \ + (i) == 2 ? MXC_SPI2_FIFO : 0) + + + +/*******************************************************************************/ +/* 1-Wire Master Interface */ + +#define MXC_BASE_OWM ((uint32_t)0x4001E000UL) +#define MXC_OWM ((mxc_owm_regs_t *)MXC_BASE_OWM) + + + +/*******************************************************************************/ +/* ADC / AFE */ + +#define MXC_CFG_ADC_FIFO_DEPTH (32) + +#define MXC_BASE_ADC ((uint32_t)0x4001F000UL) +#define MXC_ADC ((mxc_adc_regs_t *)MXC_BASE_ADC) + + + +/*******************************************************************************/ +/* SPIB AHB-to-SPI Bridge */ + +#define MXC_BASE_SPIB ((uint32_t)0x4000D000UL) +#define MXC_SPIB ((mxc_spib_regs_t *)MXC_BASE_SPIB) + + + +/*******************************************************************************/ +/* Bit Shifting */ + +#define MXC_F_BIT_0 (1 << 0) +#define MXC_F_BIT_1 (1 << 1) +#define MXC_F_BIT_2 (1 << 2) +#define MXC_F_BIT_3 (1 << 3) +#define MXC_F_BIT_4 (1 << 4) +#define MXC_F_BIT_5 (1 << 5) +#define MXC_F_BIT_6 (1 << 6) +#define MXC_F_BIT_7 (1 << 7) +#define MXC_F_BIT_8 (1 << 8) +#define MXC_F_BIT_9 (1 << 9) +#define MXC_F_BIT_10 (1 << 10) +#define MXC_F_BIT_11 (1 << 11) +#define MXC_F_BIT_12 (1 << 12) +#define MXC_F_BIT_13 (1 << 13) +#define MXC_F_BIT_14 (1 << 14) +#define MXC_F_BIT_15 (1 << 15) +#define MXC_F_BIT_16 (1 << 16) +#define MXC_F_BIT_17 (1 << 17) +#define MXC_F_BIT_18 (1 << 18) +#define MXC_F_BIT_19 (1 << 19) +#define MXC_F_BIT_20 (1 << 20) +#define MXC_F_BIT_21 (1 << 21) +#define MXC_F_BIT_22 (1 << 22) +#define MXC_F_BIT_23 (1 << 23) +#define MXC_F_BIT_24 (1 << 24) +#define MXC_F_BIT_25 (1 << 25) +#define MXC_F_BIT_26 (1 << 26) +#define MXC_F_BIT_27 (1 << 27) +#define MXC_F_BIT_28 (1 << 28) +#define MXC_F_BIT_29 (1 << 29) +#define MXC_F_BIT_30 (1 << 30) +#define MXC_F_BIT_31 (1 << 31) + + +/*******************************************************************************/ + +#define BITBAND(reg, bit) ((0xf0000000 & (uint32_t)(reg)) + 0x2000000 + (((uint32_t)(reg) & 0x0fffffff) << 5) + ((bit) << 2)) +#define MXC_CLRBIT(reg, bit) (*(volatile uint32_t *)BITBAND(reg, bit) = 0) +#define MXC_SETBIT(reg, bit) (*(volatile uint32_t *)BITBAND(reg, bit) = 1) +#define MXC_GETBIT(reg, bit) (*(volatile uint32_t *)BITBAND(reg, bit)) + +#define MXC_SET_FIELD(reg, clr, set) (*(volatile uint32_t *)reg = ((*(volatile uint32_t *)reg & ~clr) | set)) + + + +#endif /* _MAX32620_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/owm_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/owm_regs.h new file mode 100644 index 0000000000..2f941c3c04 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/owm_regs.h @@ -0,0 +1,153 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_OWM_REGS_H_ +#define _MXC_OWM_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t cfg; /* 0x0000 1-Wire Master Configuration */ + __IO uint32_t clk_div_1us; /* 0x0004 1-Wire Master Clock Divisor */ + __IO uint32_t ctrl_stat; /* 0x0008 1-Wire Master Control/Status */ + __IO uint32_t data; /* 0x000C 1-Wire Master Data Buffer */ + __IO uint32_t intfl; /* 0x0010 1-Wire Master Interrupt Flags */ + __IO uint32_t inten; /* 0x0014 1-Wire Master Interrupt Enables */ +} mxc_owm_regs_t; + + +/* + Register offsets for module OWM. +*/ + +#define MXC_R_OWM_OFFS_CFG ((uint32_t)0x00000000UL) +#define MXC_R_OWM_OFFS_CLK_DIV_1US ((uint32_t)0x00000004UL) +#define MXC_R_OWM_OFFS_CTRL_STAT ((uint32_t)0x00000008UL) +#define MXC_R_OWM_OFFS_DATA ((uint32_t)0x0000000CUL) +#define MXC_R_OWM_OFFS_INTFL ((uint32_t)0x00000010UL) +#define MXC_R_OWM_OFFS_INTEN ((uint32_t)0x00000014UL) + + +/* + Field positions and masks for module OWM. +*/ + +#define MXC_F_OWM_CFG_LONG_LINE_MODE_POS 0 +#define MXC_F_OWM_CFG_LONG_LINE_MODE ((uint32_t)(0x00000001UL << MXC_F_OWM_CFG_LONG_LINE_MODE_POS)) +#define MXC_F_OWM_CFG_FORCE_PRES_DET_POS 1 +#define MXC_F_OWM_CFG_FORCE_PRES_DET ((uint32_t)(0x00000001UL << MXC_F_OWM_CFG_FORCE_PRES_DET_POS)) +#define MXC_F_OWM_CFG_BIT_BANG_EN_POS 2 +#define MXC_F_OWM_CFG_BIT_BANG_EN ((uint32_t)(0x00000001UL << MXC_F_OWM_CFG_BIT_BANG_EN_POS)) +#define MXC_F_OWM_CFG_EXT_PULLUP_MODE_POS 3 +#define MXC_F_OWM_CFG_EXT_PULLUP_MODE ((uint32_t)(0x00000001UL << MXC_F_OWM_CFG_EXT_PULLUP_MODE_POS)) +#define MXC_F_OWM_CFG_EXT_PULLUP_ENABLE_POS 4 +#define MXC_F_OWM_CFG_EXT_PULLUP_ENABLE ((uint32_t)(0x00000001UL << MXC_F_OWM_CFG_EXT_PULLUP_ENABLE_POS)) +#define MXC_F_OWM_CFG_SINGLE_BIT_MODE_POS 5 +#define MXC_F_OWM_CFG_SINGLE_BIT_MODE ((uint32_t)(0x00000001UL << MXC_F_OWM_CFG_SINGLE_BIT_MODE_POS)) +#define MXC_F_OWM_CFG_OVERDRIVE_POS 6 +#define MXC_F_OWM_CFG_OVERDRIVE ((uint32_t)(0x00000001UL << MXC_F_OWM_CFG_OVERDRIVE_POS)) +#define MXC_F_OWM_CFG_INT_PULLUP_ENABLE_POS 7 +#define MXC_F_OWM_CFG_INT_PULLUP_ENABLE ((uint32_t)(0x00000001UL << MXC_F_OWM_CFG_INT_PULLUP_ENABLE_POS)) + +#define MXC_F_OWM_CLK_DIV_1US_DIVISOR_POS 0 +#define MXC_F_OWM_CLK_DIV_1US_DIVISOR ((uint32_t)(0x000000FFUL << MXC_F_OWM_CLK_DIV_1US_DIVISOR_POS)) + +#define MXC_F_OWM_CTRL_STAT_START_OW_RESET_POS 0 +#define MXC_F_OWM_CTRL_STAT_START_OW_RESET ((uint32_t)(0x00000001UL << MXC_F_OWM_CTRL_STAT_START_OW_RESET_POS)) +#define MXC_F_OWM_CTRL_STAT_SRA_MODE_POS 1 +#define MXC_F_OWM_CTRL_STAT_SRA_MODE ((uint32_t)(0x00000001UL << MXC_F_OWM_CTRL_STAT_SRA_MODE_POS)) +#define MXC_F_OWM_CTRL_STAT_BIT_BANG_OE_POS 2 +#define MXC_F_OWM_CTRL_STAT_BIT_BANG_OE ((uint32_t)(0x00000001UL << MXC_F_OWM_CTRL_STAT_BIT_BANG_OE_POS)) +#define MXC_F_OWM_CTRL_STAT_OW_INPUT_POS 3 +#define MXC_F_OWM_CTRL_STAT_OW_INPUT ((uint32_t)(0x00000001UL << MXC_F_OWM_CTRL_STAT_OW_INPUT_POS)) +#define MXC_F_OWM_CTRL_STAT_PRESENCE_DETECT_POS 7 +#define MXC_F_OWM_CTRL_STAT_PRESENCE_DETECT ((uint32_t)(0x00000001UL << MXC_F_OWM_CTRL_STAT_PRESENCE_DETECT_POS)) + +#define MXC_F_OWM_DATA_TX_RX_POS 0 +#define MXC_F_OWM_DATA_TX_RX ((uint32_t)(0x000000FFUL << MXC_F_OWM_DATA_TX_RX_POS)) + +#define MXC_F_OWM_INTFL_OW_RESET_DONE_POS 0 +#define MXC_F_OWM_INTFL_OW_RESET_DONE ((uint32_t)(0x00000001UL << MXC_F_OWM_INTFL_OW_RESET_DONE_POS)) +#define MXC_F_OWM_INTFL_TX_DATA_EMPTY_POS 1 +#define MXC_F_OWM_INTFL_TX_DATA_EMPTY ((uint32_t)(0x00000001UL << MXC_F_OWM_INTFL_TX_DATA_EMPTY_POS)) +#define MXC_F_OWM_INTFL_RX_DATA_READY_POS 2 +#define MXC_F_OWM_INTFL_RX_DATA_READY ((uint32_t)(0x00000001UL << MXC_F_OWM_INTFL_RX_DATA_READY_POS)) +#define MXC_F_OWM_INTFL_LINE_SHORT_POS 3 +#define MXC_F_OWM_INTFL_LINE_SHORT ((uint32_t)(0x00000001UL << MXC_F_OWM_INTFL_LINE_SHORT_POS)) +#define MXC_F_OWM_INTFL_LINE_LOW_POS 4 +#define MXC_F_OWM_INTFL_LINE_LOW ((uint32_t)(0x00000001UL << MXC_F_OWM_INTFL_LINE_LOW_POS)) + +#define MXC_F_OWM_INTEN_OW_RESET_DONE_POS 0 +#define MXC_F_OWM_INTEN_OW_RESET_DONE ((uint32_t)(0x00000001UL << MXC_F_OWM_INTEN_OW_RESET_DONE_POS)) +#define MXC_F_OWM_INTEN_TX_DATA_EMPTY_POS 1 +#define MXC_F_OWM_INTEN_TX_DATA_EMPTY ((uint32_t)(0x00000001UL << MXC_F_OWM_INTEN_TX_DATA_EMPTY_POS)) +#define MXC_F_OWM_INTEN_RX_DATA_READY_POS 2 +#define MXC_F_OWM_INTEN_RX_DATA_READY ((uint32_t)(0x00000001UL << MXC_F_OWM_INTEN_RX_DATA_READY_POS)) +#define MXC_F_OWM_INTEN_LINE_SHORT_POS 3 +#define MXC_F_OWM_INTEN_LINE_SHORT ((uint32_t)(0x00000001UL << MXC_F_OWM_INTEN_LINE_SHORT_POS)) +#define MXC_F_OWM_INTEN_LINE_LOW_POS 4 +#define MXC_F_OWM_INTEN_LINE_LOW ((uint32_t)(0x00000001UL << MXC_F_OWM_INTEN_LINE_LOW_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_OWM_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pmu_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pmu_regs.h new file mode 100644 index 0000000000..2c75d236cf --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pmu_regs.h @@ -0,0 +1,148 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_PMU_REGS_H_ +#define _MXC_PMU_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +typedef struct { + __IO uint32_t start_opcode[32]; + __IO uint32_t enable; + __IO uint32_t rsvd0; + __IO uint32_t ll_stopped; + __IO uint32_t manual; + __IO uint32_t bus_error; + __IO uint32_t rsvd1; + __IO uint32_t to_stat; + __IO uint32_t rsvd2[4]; + __IO uint32_t to_sel[3]; + __IO uint32_t ps_sel[2]; + __IO uint32_t interrupt; + __IO uint32_t int_enable; + __IO uint32_t rsvd3[6]; + __IO uint32_t burst_size[5]; + __IO uint32_t rsvd4[3]; + __IO uint32_t padding[192]; /* Offset to next channel */ +} mxc_pmu_bits_t; + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t dscadr; /* 0x0000 PMU Channel Next Descriptor Address */ + __IO uint32_t cfg; /* 0x0004 PMU Channel Configuration */ + __IO uint32_t loop; /* 0x0008 PMU Channel Loop Counters */ + __IO uint32_t op; /* 0x000C PMU Channel Current Descriptor DWORD 0 [INTERNAL TEST ONLY] */ + __IO uint32_t dsc1; /* 0x0010 PMU Channel Current Descriptor DWORD 1 [INTERNAL TEST ONLY] */ + __IO uint32_t dsc2; /* 0x0014 PMU Channel Current Descriptor DWORD 2 [INTERNAL TEST ONLY] */ + __IO uint32_t dsc3; /* 0x0018 PMU Channel Current Descriptor DWORD 3 [INTERNAL TEST ONLY] */ + __IO uint32_t dsc4; /* 0x001C PMU Channel Current Descriptor DWORD 4 [INTERNAL TEST ONLY] */ +} mxc_pmu_regs_t; + + +/* + Register offsets for module PMU. +*/ + +#define MXC_R_PMU_OFFS_DSCADR ((uint32_t)0x00000000UL) +#define MXC_R_PMU_OFFS_CFG ((uint32_t)0x00000004UL) +#define MXC_R_PMU_OFFS_LOOP ((uint32_t)0x00000008UL) +#define MXC_R_PMU_OFFS_OP ((uint32_t)0x0000000CUL) +#define MXC_R_PMU_OFFS_DSC1 ((uint32_t)0x00000010UL) +#define MXC_R_PMU_OFFS_DSC2 ((uint32_t)0x00000014UL) +#define MXC_R_PMU_OFFS_DSC3 ((uint32_t)0x00000018UL) +#define MXC_R_PMU_OFFS_DSC4 ((uint32_t)0x0000001CUL) + + +/* + Field positions and masks for module PMU. +*/ + +#define MXC_F_PMU_CFG_ENABLE_POS 0 +#define MXC_F_PMU_CFG_ENABLE ((uint32_t)(0x00000001UL << MXC_F_PMU_CFG_ENABLE_POS)) +#define MXC_F_PMU_CFG_LL_STOPPED_POS 2 +#define MXC_F_PMU_CFG_LL_STOPPED ((uint32_t)(0x00000001UL << MXC_F_PMU_CFG_LL_STOPPED_POS)) +#define MXC_F_PMU_CFG_MANUAL_POS 3 +#define MXC_F_PMU_CFG_MANUAL ((uint32_t)(0x00000001UL << MXC_F_PMU_CFG_MANUAL_POS)) +#define MXC_F_PMU_CFG_BUS_ERROR_POS 4 +#define MXC_F_PMU_CFG_BUS_ERROR ((uint32_t)(0x00000001UL << MXC_F_PMU_CFG_BUS_ERROR_POS)) +#define MXC_F_PMU_CFG_TO_STAT_POS 6 +#define MXC_F_PMU_CFG_TO_STAT ((uint32_t)(0x00000001UL << MXC_F_PMU_CFG_TO_STAT_POS)) +#define MXC_F_PMU_CFG_TO_SEL_POS 11 +#define MXC_F_PMU_CFG_TO_SEL ((uint32_t)(0x00000007UL << MXC_F_PMU_CFG_TO_SEL_POS)) +#define MXC_F_PMU_CFG_PS_SEL_POS 14 +#define MXC_F_PMU_CFG_PS_SEL ((uint32_t)(0x00000003UL << MXC_F_PMU_CFG_PS_SEL_POS)) +#define MXC_F_PMU_CFG_INTERRUPT_POS 16 +#define MXC_F_PMU_CFG_INTERRUPT ((uint32_t)(0x00000001UL << MXC_F_PMU_CFG_INTERRUPT_POS)) +#define MXC_F_PMU_CFG_INT_EN_POS 17 +#define MXC_F_PMU_CFG_INT_EN ((uint32_t)(0x00000001UL << MXC_F_PMU_CFG_INT_EN_POS)) +#define MXC_F_PMU_CFG_BURST_SIZE_POS 24 +#define MXC_F_PMU_CFG_BURST_SIZE ((uint32_t)(0x0000001FUL << MXC_F_PMU_CFG_BURST_SIZE_POS)) + +#define MXC_F_PMU_LOOP_COUNTER_0_POS 0 +#define MXC_F_PMU_LOOP_COUNTER_0 ((uint32_t)(0x0000FFFFUL << MXC_F_PMU_LOOP_COUNTER_0_POS)) +#define MXC_F_PMU_LOOP_COUNTER_1_POS 16 +#define MXC_F_PMU_LOOP_COUNTER_1 ((uint32_t)(0x0000FFFFUL << MXC_F_PMU_LOOP_COUNTER_1_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_PMU_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pt_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pt_regs.h new file mode 100644 index 0000000000..c55606ea49 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pt_regs.h @@ -0,0 +1,314 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_PT_REGS_H_ +#define _MXC_PT_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t enable; /* 0x0000 Global Enable/Disable Controls for All Pulse Trains */ + __IO uint32_t resync; /* 0x0004 Global Resync (All Pulse Trains) Control */ + __IO uint32_t intfl; /* 0x0008 Pulse Train Interrupt Flags */ + __IO uint32_t inten; /* 0x000C Pulse Train Interrupt Enable/Disable */ +} mxc_ptg_regs_t; + + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t rate_length; /* 0x0000 Pulse Train Configuration */ + __IO uint32_t train; /* 0x0004 Pulse Train Output Pattern */ + __IO uint32_t loop; /* 0x0008 Pulse Train Loop Count */ +} mxc_pt_regs_t; + + +/* + Register offsets for module PT. +*/ + +#define MXC_R_PTG_OFFS_ENABLE ((uint32_t)0x00000000UL) +#define MXC_R_PTG_OFFS_RESYNC ((uint32_t)0x00000004UL) +#define MXC_R_PTG_OFFS_INTFL ((uint32_t)0x00000008UL) +#define MXC_R_PTG_OFFS_INTEN ((uint32_t)0x0000000CUL) +#define MXC_R_PT_OFFS_RATE_LENGTH ((uint32_t)0x00000000UL) +#define MXC_R_PT_OFFS_TRAIN ((uint32_t)0x00000004UL) +#define MXC_R_PT_OFFS_LOOP ((uint32_t)0x00000008UL) + + +/* + Field positions and masks for module PT. +*/ + +#define MXC_F_PT_ENABLE_PT0_POS 0 +#define MXC_F_PT_ENABLE_PT0 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT0_POS)) +#define MXC_F_PT_ENABLE_PT1_POS 1 +#define MXC_F_PT_ENABLE_PT1 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT1_POS)) +#define MXC_F_PT_ENABLE_PT2_POS 2 +#define MXC_F_PT_ENABLE_PT2 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT2_POS)) +#define MXC_F_PT_ENABLE_PT3_POS 3 +#define MXC_F_PT_ENABLE_PT3 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT3_POS)) +#define MXC_F_PT_ENABLE_PT4_POS 4 +#define MXC_F_PT_ENABLE_PT4 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT4_POS)) +#define MXC_F_PT_ENABLE_PT5_POS 5 +#define MXC_F_PT_ENABLE_PT5 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT5_POS)) +#define MXC_F_PT_ENABLE_PT6_POS 6 +#define MXC_F_PT_ENABLE_PT6 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT6_POS)) +#define MXC_F_PT_ENABLE_PT7_POS 7 +#define MXC_F_PT_ENABLE_PT7 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT7_POS)) +#define MXC_F_PT_ENABLE_PT8_POS 8 +#define MXC_F_PT_ENABLE_PT8 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT8_POS)) +#define MXC_F_PT_ENABLE_PT9_POS 9 +#define MXC_F_PT_ENABLE_PT9 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT9_POS)) +#define MXC_F_PT_ENABLE_PT10_POS 10 +#define MXC_F_PT_ENABLE_PT10 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT10_POS)) +#define MXC_F_PT_ENABLE_PT11_POS 11 +#define MXC_F_PT_ENABLE_PT11 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT11_POS)) +#define MXC_F_PT_ENABLE_PT12_POS 12 +#define MXC_F_PT_ENABLE_PT12 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT12_POS)) +#define MXC_F_PT_ENABLE_PT13_POS 13 +#define MXC_F_PT_ENABLE_PT13 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT13_POS)) +#define MXC_F_PT_ENABLE_PT14_POS 14 +#define MXC_F_PT_ENABLE_PT14 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT14_POS)) +#define MXC_F_PT_ENABLE_PT15_POS 15 +#define MXC_F_PT_ENABLE_PT15 ((uint32_t)(0x00000001UL << MXC_F_PT_ENABLE_PT15_POS)) + +#define MXC_F_PT_RESYNC_PT0_POS 0 +#define MXC_F_PT_RESYNC_PT0 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT0_POS)) +#define MXC_F_PT_RESYNC_PT1_POS 1 +#define MXC_F_PT_RESYNC_PT1 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT1_POS)) +#define MXC_F_PT_RESYNC_PT2_POS 2 +#define MXC_F_PT_RESYNC_PT2 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT2_POS)) +#define MXC_F_PT_RESYNC_PT3_POS 3 +#define MXC_F_PT_RESYNC_PT3 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT3_POS)) +#define MXC_F_PT_RESYNC_PT4_POS 4 +#define MXC_F_PT_RESYNC_PT4 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT4_POS)) +#define MXC_F_PT_RESYNC_PT5_POS 5 +#define MXC_F_PT_RESYNC_PT5 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT5_POS)) +#define MXC_F_PT_RESYNC_PT6_POS 6 +#define MXC_F_PT_RESYNC_PT6 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT6_POS)) +#define MXC_F_PT_RESYNC_PT7_POS 7 +#define MXC_F_PT_RESYNC_PT7 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT7_POS)) +#define MXC_F_PT_RESYNC_PT8_POS 8 +#define MXC_F_PT_RESYNC_PT8 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT8_POS)) +#define MXC_F_PT_RESYNC_PT9_POS 9 +#define MXC_F_PT_RESYNC_PT9 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT9_POS)) +#define MXC_F_PT_RESYNC_PT10_POS 10 +#define MXC_F_PT_RESYNC_PT10 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT10_POS)) +#define MXC_F_PT_RESYNC_PT11_POS 11 +#define MXC_F_PT_RESYNC_PT11 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT11_POS)) +#define MXC_F_PT_RESYNC_PT12_POS 12 +#define MXC_F_PT_RESYNC_PT12 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT12_POS)) +#define MXC_F_PT_RESYNC_PT13_POS 13 +#define MXC_F_PT_RESYNC_PT13 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT13_POS)) +#define MXC_F_PT_RESYNC_PT14_POS 14 +#define MXC_F_PT_RESYNC_PT14 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT14_POS)) +#define MXC_F_PT_RESYNC_PT15_POS 15 +#define MXC_F_PT_RESYNC_PT15 ((uint32_t)(0x00000001UL << MXC_F_PT_RESYNC_PT15_POS)) + +#define MXC_F_PT_INTFL_PT0_POS 0 +#define MXC_F_PT_INTFL_PT0 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT0_POS)) +#define MXC_F_PT_INTFL_PT1_POS 1 +#define MXC_F_PT_INTFL_PT1 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT1_POS)) +#define MXC_F_PT_INTFL_PT2_POS 2 +#define MXC_F_PT_INTFL_PT2 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT2_POS)) +#define MXC_F_PT_INTFL_PT3_POS 3 +#define MXC_F_PT_INTFL_PT3 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT3_POS)) +#define MXC_F_PT_INTFL_PT4_POS 4 +#define MXC_F_PT_INTFL_PT4 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT4_POS)) +#define MXC_F_PT_INTFL_PT5_POS 5 +#define MXC_F_PT_INTFL_PT5 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT5_POS)) +#define MXC_F_PT_INTFL_PT6_POS 6 +#define MXC_F_PT_INTFL_PT6 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT6_POS)) +#define MXC_F_PT_INTFL_PT7_POS 7 +#define MXC_F_PT_INTFL_PT7 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT7_POS)) +#define MXC_F_PT_INTFL_PT8_POS 8 +#define MXC_F_PT_INTFL_PT8 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT8_POS)) +#define MXC_F_PT_INTFL_PT9_POS 9 +#define MXC_F_PT_INTFL_PT9 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT9_POS)) +#define MXC_F_PT_INTFL_PT10_POS 10 +#define MXC_F_PT_INTFL_PT10 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT10_POS)) +#define MXC_F_PT_INTFL_PT11_POS 11 +#define MXC_F_PT_INTFL_PT11 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT11_POS)) +#define MXC_F_PT_INTFL_PT12_POS 12 +#define MXC_F_PT_INTFL_PT12 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT12_POS)) +#define MXC_F_PT_INTFL_PT13_POS 13 +#define MXC_F_PT_INTFL_PT13 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT13_POS)) +#define MXC_F_PT_INTFL_PT14_POS 14 +#define MXC_F_PT_INTFL_PT14 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT14_POS)) +#define MXC_F_PT_INTFL_PT15_POS 15 +#define MXC_F_PT_INTFL_PT15 ((uint32_t)(0x00000001UL << MXC_F_PT_INTFL_PT15_POS)) + +#define MXC_F_PT_INTEN_PT0_POS 0 +#define MXC_F_PT_INTEN_PT0 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT0_POS)) +#define MXC_F_PT_INTEN_PT1_POS 1 +#define MXC_F_PT_INTEN_PT1 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT1_POS)) +#define MXC_F_PT_INTEN_PT2_POS 2 +#define MXC_F_PT_INTEN_PT2 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT2_POS)) +#define MXC_F_PT_INTEN_PT3_POS 3 +#define MXC_F_PT_INTEN_PT3 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT3_POS)) +#define MXC_F_PT_INTEN_PT4_POS 4 +#define MXC_F_PT_INTEN_PT4 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT4_POS)) +#define MXC_F_PT_INTEN_PT5_POS 5 +#define MXC_F_PT_INTEN_PT5 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT5_POS)) +#define MXC_F_PT_INTEN_PT6_POS 6 +#define MXC_F_PT_INTEN_PT6 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT6_POS)) +#define MXC_F_PT_INTEN_PT7_POS 7 +#define MXC_F_PT_INTEN_PT7 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT7_POS)) +#define MXC_F_PT_INTEN_PT8_POS 8 +#define MXC_F_PT_INTEN_PT8 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT8_POS)) +#define MXC_F_PT_INTEN_PT9_POS 9 +#define MXC_F_PT_INTEN_PT9 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT9_POS)) +#define MXC_F_PT_INTEN_PT10_POS 10 +#define MXC_F_PT_INTEN_PT10 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT10_POS)) +#define MXC_F_PT_INTEN_PT11_POS 11 +#define MXC_F_PT_INTEN_PT11 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT11_POS)) +#define MXC_F_PT_INTEN_PT12_POS 12 +#define MXC_F_PT_INTEN_PT12 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT12_POS)) +#define MXC_F_PT_INTEN_PT13_POS 13 +#define MXC_F_PT_INTEN_PT13 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT13_POS)) +#define MXC_F_PT_INTEN_PT14_POS 14 +#define MXC_F_PT_INTEN_PT14 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT14_POS)) +#define MXC_F_PT_INTEN_PT15_POS 15 +#define MXC_F_PT_INTEN_PT15 ((uint32_t)(0x00000001UL << MXC_F_PT_INTEN_PT15_POS)) + +#define MXC_F_PT_RATE_LENGTH_RATE_CONTROL_POS 0 +#define MXC_F_PT_RATE_LENGTH_RATE_CONTROL ((uint32_t)(0x07FFFFFFUL << MXC_F_PT_RATE_LENGTH_RATE_CONTROL_POS)) +#define MXC_F_PT_RATE_LENGTH_MODE_POS 27 +#define MXC_F_PT_RATE_LENGTH_MODE ((uint32_t)(0x0000001FUL << MXC_F_PT_RATE_LENGTH_MODE_POS)) + + + +/* + Field values and shifted values for module PT. +*/ + +#define MXC_V_PT_RATE_LENGTH_MODE_32_BIT ((uint32_t)(0x00000000UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_SQUARE_WAVE ((uint32_t)(0x00000001UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_2_BIT ((uint32_t)(0x00000002UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_3_BIT ((uint32_t)(0x00000003UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_4_BIT ((uint32_t)(0x00000004UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_5_BIT ((uint32_t)(0x00000005UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_6_BIT ((uint32_t)(0x00000006UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_7_BIT ((uint32_t)(0x00000007UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_8_BIT ((uint32_t)(0x00000008UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_9_BIT ((uint32_t)(0x00000009UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_10_BIT ((uint32_t)(0x0000000AUL)) +#define MXC_V_PT_RATE_LENGTH_MODE_11_BIT ((uint32_t)(0x0000000BUL)) +#define MXC_V_PT_RATE_LENGTH_MODE_12_BIT ((uint32_t)(0x0000000CUL)) +#define MXC_V_PT_RATE_LENGTH_MODE_13_BIT ((uint32_t)(0x0000000DUL)) +#define MXC_V_PT_RATE_LENGTH_MODE_14_BIT ((uint32_t)(0x0000000EUL)) +#define MXC_V_PT_RATE_LENGTH_MODE_15_BIT ((uint32_t)(0x0000000FUL)) +#define MXC_V_PT_RATE_LENGTH_MODE_16_BIT ((uint32_t)(0x00000010UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_17_BIT ((uint32_t)(0x00000011UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_18_BIT ((uint32_t)(0x00000012UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_19_BIT ((uint32_t)(0x00000013UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_20_BIT ((uint32_t)(0x00000014UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_21_BIT ((uint32_t)(0x00000015UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_22_BIT ((uint32_t)(0x00000016UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_23_BIT ((uint32_t)(0x00000017UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_24_BIT ((uint32_t)(0x00000018UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_25_BIT ((uint32_t)(0x00000019UL)) +#define MXC_V_PT_RATE_LENGTH_MODE_26_BIT ((uint32_t)(0x0000001AUL)) +#define MXC_V_PT_RATE_LENGTH_MODE_27_BIT ((uint32_t)(0x0000001BUL)) +#define MXC_V_PT_RATE_LENGTH_MODE_28_BIT ((uint32_t)(0x0000001CUL)) +#define MXC_V_PT_RATE_LENGTH_MODE_29_BIT ((uint32_t)(0x0000001DUL)) +#define MXC_V_PT_RATE_LENGTH_MODE_30_BIT ((uint32_t)(0x0000001EUL)) +#define MXC_V_PT_RATE_LENGTH_MODE_31_BIT ((uint32_t)(0x0000001FUL)) + +#define MXC_S_PT_RATE_LENGTH_MODE_32_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_32_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_SQUARE_WAVE ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_SQUARE_WAVE << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_2_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_2_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_3_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_3_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_4_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_4_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_5_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_5_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_6_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_6_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_7_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_7_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_8_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_8_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_9_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_9_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_10_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_10_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_11_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_11_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_12_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_12_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_13_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_13_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_14_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_14_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_15_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_15_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_16_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_16_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_17_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_17_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_18_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_18_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_19_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_19_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_20_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_20_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_21_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_21_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_22_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_22_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_23_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_23_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_24_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_24_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_25_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_25_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_26_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_26_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_27_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_27_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_28_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_28_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_29_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_29_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_30_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_30_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) +#define MXC_S_PT_RATE_LENGTH_MODE_31_BIT ((uint32_t)(MXC_V_PT_RATE_LENGTH_MODE_31_BIT << MXC_F_PT_RATE_LENGTH_MODE_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_PT_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pwrman_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pwrman_regs.h new file mode 100644 index 0000000000..4dc452d7dc --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pwrman_regs.h @@ -0,0 +1,371 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_PWRMAN_REGS_H_ +#define _MXC_PWRMAN_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/** + * @brief Defines PAD Modes for Wake Up Detection. + */ +typedef enum { + /** WUD Mode for Selected PAD = Clear/Activate */ + MXC_E_PWRMAN_PAD_MODE_CLEAR_SET, + /** WUD Mode for Selected PAD = Set WUD Act Hi/Set WUD Act Lo */ + MXC_E_PWRMAN_PAD_MODE_ACT_HI_LO, + /** WUD Mode for Selected PAD = Set Weak Hi/ Set Weak Lo */ + MXC_E_PWRMAN_PAD_MODE_WEAK_HI_LO, + /** WUD Mode for Selected PAD = No pad state change */ + MXC_E_PWRMAN_PAD_MODE_NONE +} mxc_pwrman_pad_mode_t; + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t pwr_rst_ctrl; /* 0x0000 Power Reset Control and Status */ + __IO uint32_t intfl; /* 0x0004 Interrupt Flags */ + __IO uint32_t inten; /* 0x0008 Interrupt Enable/Disable Controls */ + __IO uint32_t svm_events; /* 0x000C SVM Event Status Flags (read-only) */ + __IO uint32_t wud_ctrl; /* 0x0010 Wake-Up Detect Control */ + __IO uint32_t wud_pulse0; /* 0x0014 WUD Pulse To Mode Bit 0 */ + __IO uint32_t wud_pulse1; /* 0x0018 WUD Pulse To Mode Bit 1 */ + __IO uint32_t wud_seen0; /* 0x001C Wake-up Detect Status for P0/P1/P2/P3 */ + __IO uint32_t wud_seen1; /* 0x0020 Wake-up Detect Status for P4/P5/P6/P7 */ + __I uint32_t rsv024[5]; /* 0x0024-0x0034 */ + __IO uint32_t die_type; /* 0x0038 Die Type ID Register */ + __IO uint32_t base_part_num; /* 0x003C Base Part Number */ + __IO uint32_t mask_id0; /* 0x0040 Mask ID Register 0 */ + __IO uint32_t mask_id1; /* 0x0044 Mask ID Register 1 */ + __IO uint32_t peripheral_reset; /* 0x0048 Peripheral Reset Control Register */ +} mxc_pwrman_regs_t; + + +/* + Register offsets for module PWRMAN. +*/ + +#define MXC_R_PWRMAN_OFFS_PWR_RST_CTRL ((uint32_t)0x00000000UL) +#define MXC_R_PWRMAN_OFFS_INTFL ((uint32_t)0x00000004UL) +#define MXC_R_PWRMAN_OFFS_INTEN ((uint32_t)0x00000008UL) +#define MXC_R_PWRMAN_OFFS_SVM_EVENTS ((uint32_t)0x0000000CUL) +#define MXC_R_PWRMAN_OFFS_WUD_CTRL ((uint32_t)0x00000010UL) +#define MXC_R_PWRMAN_OFFS_WUD_PULSE0 ((uint32_t)0x00000014UL) +#define MXC_R_PWRMAN_OFFS_WUD_PULSE1 ((uint32_t)0x00000018UL) +#define MXC_R_PWRMAN_OFFS_WUD_SEEN0 ((uint32_t)0x0000001CUL) +#define MXC_R_PWRMAN_OFFS_WUD_SEEN1 ((uint32_t)0x00000020UL) +#define MXC_R_PWRMAN_OFFS_DIE_TYPE ((uint32_t)0x00000038UL) +#define MXC_R_PWRMAN_OFFS_BASE_PART_NUM ((uint32_t)0x0000003CUL) +#define MXC_R_PWRMAN_OFFS_MASK_ID0 ((uint32_t)0x00000040UL) +#define MXC_R_PWRMAN_OFFS_MASK_ID1 ((uint32_t)0x00000044UL) +#define MXC_R_PWRMAN_OFFS_PERIPHERAL_RESET ((uint32_t)0x00000048UL) + + +/* + Field positions and masks for module PWRMAN. +*/ + +#define MXC_F_PWRMAN_PWR_RST_CTRL_AFE_POWERED_POS 2 +#define MXC_F_PWRMAN_PWR_RST_CTRL_AFE_POWERED ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PWR_RST_CTRL_AFE_POWERED_POS)) +#define MXC_F_PWRMAN_PWR_RST_CTRL_IO_ACTIVE_POS 3 +#define MXC_F_PWRMAN_PWR_RST_CTRL_IO_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PWR_RST_CTRL_IO_ACTIVE_POS)) +#define MXC_F_PWRMAN_PWR_RST_CTRL_USB_POWERED_POS 4 +#define MXC_F_PWRMAN_PWR_RST_CTRL_USB_POWERED ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PWR_RST_CTRL_USB_POWERED_POS)) +#define MXC_F_PWRMAN_PWR_RST_CTRL_PULLUPS_ENABLED_POS 5 +#define MXC_F_PWRMAN_PWR_RST_CTRL_PULLUPS_ENABLED ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PWR_RST_CTRL_PULLUPS_ENABLED_POS)) +#define MXC_F_PWRMAN_PWR_RST_CTRL_FIRMWARE_RESET_POS 8 +#define MXC_F_PWRMAN_PWR_RST_CTRL_FIRMWARE_RESET ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PWR_RST_CTRL_FIRMWARE_RESET_POS)) +#define MXC_F_PWRMAN_PWR_RST_CTRL_ARM_LOCKUP_RESET_POS 9 +#define MXC_F_PWRMAN_PWR_RST_CTRL_ARM_LOCKUP_RESET ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PWR_RST_CTRL_ARM_LOCKUP_RESET_POS)) +#define MXC_F_PWRMAN_PWR_RST_CTRL_TAMPER_DETECT_POS 16 +#define MXC_F_PWRMAN_PWR_RST_CTRL_TAMPER_DETECT ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PWR_RST_CTRL_TAMPER_DETECT_POS)) +#define MXC_F_PWRMAN_PWR_RST_CTRL_ARM_LOCKUP_POS 17 +#define MXC_F_PWRMAN_PWR_RST_CTRL_ARM_LOCKUP ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PWR_RST_CTRL_ARM_LOCKUP_POS)) +#define MXC_F_PWRMAN_PWR_RST_CTRL_FW_COMMAND_ARM_POS 18 +#define MXC_F_PWRMAN_PWR_RST_CTRL_FW_COMMAND_ARM ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PWR_RST_CTRL_FW_COMMAND_ARM_POS)) +#define MXC_F_PWRMAN_PWR_RST_CTRL_WATCHDOG_TIMEOUT_POS 19 +#define MXC_F_PWRMAN_PWR_RST_CTRL_WATCHDOG_TIMEOUT ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PWR_RST_CTRL_WATCHDOG_TIMEOUT_POS)) +#define MXC_F_PWRMAN_PWR_RST_CTRL_FW_COMMAND_SYSMAN_POS 20 +#define MXC_F_PWRMAN_PWR_RST_CTRL_FW_COMMAND_SYSMAN ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PWR_RST_CTRL_FW_COMMAND_SYSMAN_POS)) +#define MXC_F_PWRMAN_PWR_RST_CTRL_SRSTN_ASSERTION_POS 21 +#define MXC_F_PWRMAN_PWR_RST_CTRL_SRSTN_ASSERTION ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PWR_RST_CTRL_SRSTN_ASSERTION_POS)) +#define MXC_F_PWRMAN_PWR_RST_CTRL_POR_POS 22 +#define MXC_F_PWRMAN_PWR_RST_CTRL_POR ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PWR_RST_CTRL_POR_POS)) +#define MXC_F_PWRMAN_PWR_RST_CTRL_LOW_POWER_MODE_POS 31 +#define MXC_F_PWRMAN_PWR_RST_CTRL_LOW_POWER_MODE ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PWR_RST_CTRL_LOW_POWER_MODE_POS)) + +#define MXC_F_PWRMAN_INTFL_V1_2_WARNING_POS 0 +#define MXC_F_PWRMAN_INTFL_V1_2_WARNING ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_INTFL_V1_2_WARNING_POS)) +#define MXC_F_PWRMAN_INTFL_V1_8_WARNING_POS 1 +#define MXC_F_PWRMAN_INTFL_V1_8_WARNING ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_INTFL_V1_8_WARNING_POS)) +#define MXC_F_PWRMAN_INTFL_RTC_WARNING_POS 2 +#define MXC_F_PWRMAN_INTFL_RTC_WARNING ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_INTFL_RTC_WARNING_POS)) +#define MXC_F_PWRMAN_INTFL_VDDA_WARNING_POS 3 +#define MXC_F_PWRMAN_INTFL_VDDA_WARNING ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_INTFL_VDDA_WARNING_POS)) +#define MXC_F_PWRMAN_INTFL_VDDB_WARNING_POS 4 +#define MXC_F_PWRMAN_INTFL_VDDB_WARNING ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_INTFL_VDDB_WARNING_POS)) + +#define MXC_F_PWRMAN_INTEN_V1_2_WARNING_POS 0 +#define MXC_F_PWRMAN_INTEN_V1_2_WARNING ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_INTEN_V1_2_WARNING_POS)) +#define MXC_F_PWRMAN_INTEN_V1_8_WARNING_POS 1 +#define MXC_F_PWRMAN_INTEN_V1_8_WARNING ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_INTEN_V1_8_WARNING_POS)) +#define MXC_F_PWRMAN_INTEN_RTC_WARNING_POS 2 +#define MXC_F_PWRMAN_INTEN_RTC_WARNING ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_INTEN_RTC_WARNING_POS)) +#define MXC_F_PWRMAN_INTEN_VDDA_WARNING_POS 3 +#define MXC_F_PWRMAN_INTEN_VDDA_WARNING ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_INTEN_VDDA_WARNING_POS)) +#define MXC_F_PWRMAN_INTEN_VDDB_WARNING_POS 4 +#define MXC_F_PWRMAN_INTEN_VDDB_WARNING ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_INTEN_VDDB_WARNING_POS)) + +#define MXC_F_PWRMAN_SVM_EVENTS_V1_2_WARNING_POS 0 +#define MXC_F_PWRMAN_SVM_EVENTS_V1_2_WARNING ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_SVM_EVENTS_V1_2_WARNING_POS)) +#define MXC_F_PWRMAN_SVM_EVENTS_V1_8_WARNING_POS 1 +#define MXC_F_PWRMAN_SVM_EVENTS_V1_8_WARNING ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_SVM_EVENTS_V1_8_WARNING_POS)) +#define MXC_F_PWRMAN_SVM_EVENTS_RTC_WARNING_POS 2 +#define MXC_F_PWRMAN_SVM_EVENTS_RTC_WARNING ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_SVM_EVENTS_RTC_WARNING_POS)) +#define MXC_F_PWRMAN_SVM_EVENTS_VDDA_WARNING_POS 3 +#define MXC_F_PWRMAN_SVM_EVENTS_VDDA_WARNING ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_SVM_EVENTS_VDDA_WARNING_POS)) +#define MXC_F_PWRMAN_SVM_EVENTS_VDDB_WARNING_POS 4 +#define MXC_F_PWRMAN_SVM_EVENTS_VDDB_WARNING ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_SVM_EVENTS_VDDB_WARNING_POS)) + +#define MXC_F_PWRMAN_WUD_CTRL_PAD_SELECT_POS 0 +#define MXC_F_PWRMAN_WUD_CTRL_PAD_SELECT ((uint32_t)(0x0000003FUL << MXC_F_PWRMAN_WUD_CTRL_PAD_SELECT_POS)) +#define MXC_F_PWRMAN_WUD_CTRL_PAD_MODE_POS 8 +#define MXC_F_PWRMAN_WUD_CTRL_PAD_MODE ((uint32_t)(0x00000003UL << MXC_F_PWRMAN_WUD_CTRL_PAD_MODE_POS)) +#define MXC_F_PWRMAN_WUD_CTRL_CLEAR_ALL_POS 12 +#define MXC_F_PWRMAN_WUD_CTRL_CLEAR_ALL ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_CTRL_CLEAR_ALL_POS)) +#define MXC_F_PWRMAN_WUD_CTRL_CTRL_ENABLE_POS 16 +#define MXC_F_PWRMAN_WUD_CTRL_CTRL_ENABLE ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_CTRL_CTRL_ENABLE_POS)) + +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO0_POS 0 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO0 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO0_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO1_POS 1 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO1 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO1_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO2_POS 2 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO2 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO2_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO3_POS 3 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO3 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO3_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO4_POS 4 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO4 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO4_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO5_POS 5 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO5 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO5_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO6_POS 6 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO6 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO6_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO7_POS 7 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO7 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO7_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO8_POS 8 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO8 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO8_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO9_POS 9 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO9 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO9_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO10_POS 10 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO10 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO10_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO11_POS 11 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO11 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO11_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO12_POS 12 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO12 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO12_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO13_POS 13 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO13 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO13_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO14_POS 14 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO14 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO14_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO15_POS 15 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO15 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO15_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO16_POS 16 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO16 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO16_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO17_POS 17 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO17 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO17_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO18_POS 18 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO18 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO18_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO19_POS 19 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO19 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO19_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO20_POS 20 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO20 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO20_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO21_POS 21 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO21 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO21_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO22_POS 22 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO22 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO22_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO23_POS 23 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO23 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO23_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO24_POS 24 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO24 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO24_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO25_POS 25 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO25 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO25_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO26_POS 26 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO26 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO26_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO27_POS 27 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO27 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO27_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO28_POS 28 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO28 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO28_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO29_POS 29 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO29 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO29_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO30_POS 30 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO30 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO30_POS)) +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO31_POS 31 +#define MXC_F_PWRMAN_WUD_SEEN0_GPIO31 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN0_GPIO31_POS)) + +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO32_POS 0 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO32 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO32_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO33_POS 1 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO33 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO33_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO34_POS 2 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO34 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO34_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO35_POS 3 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO35 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO35_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO36_POS 4 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO36 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO36_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO37_POS 5 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO37 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO37_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO38_POS 6 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO38 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO38_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO39_POS 7 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO39 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO39_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO40_POS 8 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO40 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO40_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO41_POS 9 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO41 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO41_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO42_POS 10 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO42 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO42_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO43_POS 11 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO43 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO43_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO44_POS 12 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO44 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO44_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO45_POS 13 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO45 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO45_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO46_POS 14 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO46 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO46_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO47_POS 15 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO47 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO47_POS)) +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO48_POS 16 +#define MXC_F_PWRMAN_WUD_SEEN1_GPIO48 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_WUD_SEEN1_GPIO48_POS)) + +#define MXC_F_PWRMAN_BASE_PART_NUM_BASE_PART_NUMBER_POS 0 +#define MXC_F_PWRMAN_BASE_PART_NUM_BASE_PART_NUMBER ((uint32_t)(0x0000FFFFUL << MXC_F_PWRMAN_BASE_PART_NUM_BASE_PART_NUMBER_POS)) + +#define MXC_F_PWRMAN_MASK_ID0_REVISION_ID_POS 0 +#define MXC_F_PWRMAN_MASK_ID0_REVISION_ID ((uint32_t)(0x0000000FUL << MXC_F_PWRMAN_MASK_ID0_REVISION_ID_POS)) +#define MXC_F_PWRMAN_MASK_ID0_MASK_ID_POS 4 +#define MXC_F_PWRMAN_MASK_ID0_MASK_ID ((uint32_t)(0x0FFFFFFFUL << MXC_F_PWRMAN_MASK_ID0_MASK_ID_POS)) + +#define MXC_F_PWRMAN_MASK_ID1_MASK_ID_POS 0 +#define MXC_F_PWRMAN_MASK_ID1_MASK_ID ((uint32_t)(0x7FFFFFFFUL << MXC_F_PWRMAN_MASK_ID1_MASK_ID_POS)) +#define MXC_F_PWRMAN_MASK_ID1_MASK_ID_ENABLE_POS 31 +#define MXC_F_PWRMAN_MASK_ID1_MASK_ID_ENABLE ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_MASK_ID1_MASK_ID_ENABLE_POS)) + +#define MXC_F_PWRMAN_PERIPHERAL_RESET_SSB_POS 0 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_SSB ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_SSB_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_SPIX_POS 1 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_SPIX ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_SPIX_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_PMU_POS 2 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_PMU ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_PMU_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_USB_POS 3 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_USB ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_USB_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_CRC_POS 4 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_CRC ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_CRC_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_TPU_POS 5 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_TPU ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_TPU_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_WATCHDOG0_POS 6 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_WATCHDOG0 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_WATCHDOG0_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_GPIO_POS 7 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_GPIO ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_GPIO_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER0_POS 8 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER0 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER0_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER1_POS 9 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER1 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER1_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER2_POS 10 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER2 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER2_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER3_POS 11 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER3 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER3_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER4_POS 12 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER4 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER4_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER5_POS 13 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER5 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_TIMER5_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_PULSE_TRAIN_POS 14 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_PULSE_TRAIN ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_PULSE_TRAIN_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_UART0_POS 15 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_UART0 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_UART0_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_UART1_POS 16 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_UART1 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_UART1_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_UART2_POS 17 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_UART2 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_UART2_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_UART3_POS 18 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_UART3 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_UART3_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_I2CM0_POS 19 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_I2CM0 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_I2CM0_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_I2CM1_POS 20 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_I2CM1 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_I2CM1_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_I2CM2_POS 21 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_I2CM2 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_I2CM2_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_I2CS_POS 22 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_I2CS ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_I2CS_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_SPIM0_POS 23 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_SPIM0 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_SPIM0_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_SPIM1_POS 24 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_SPIM1 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_SPIM1_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_SPIM2_POS 25 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_SPIM2 ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_SPIM2_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_SPIB_POS 26 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_SPIB ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_SPIB_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_OWM_POS 27 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_OWM ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_OWM_POS)) +#define MXC_F_PWRMAN_PERIPHERAL_RESET_ADC_POS 28 +#define MXC_F_PWRMAN_PERIPHERAL_RESET_ADC ((uint32_t)(0x00000001UL << MXC_F_PWRMAN_PERIPHERAL_RESET_ADC_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_PWRMAN_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pwrseq_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pwrseq_regs.h new file mode 100644 index 0000000000..dbe459f72e --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/pwrseq_regs.h @@ -0,0 +1,322 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_PWRSEQ_REGS_H_ +#define _MXC_PWRSEQ_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t reg0; /* 0x0000 Power Sequencer Control Register 0 */ + __IO uint32_t reg1; /* 0x0004 Power Sequencer Control Register 1 */ + __IO uint32_t reg2; /* 0x0008 Power Sequencer Control Register 2 */ + __IO uint32_t reg3; /* 0x000C Power Sequencer Control Register 3 */ + __IO uint32_t reg4; /* 0x0010 Power Sequencer Control Register 4 (Internal Test Only) */ + __IO uint32_t reg5; /* 0x0014 Power Sequencer Control Register 5 (Trim 0) */ + __IO uint32_t reg6; /* 0x0018 Power Sequencer Control Register 6 (Trim 1) */ + __IO uint32_t reg7; /* 0x001C Power Sequencer Control Register 7 (Trim 2) */ + __IO uint32_t flags; /* 0x0020 Power Sequencer Flags */ + __IO uint32_t msk_flags; /* 0x0024 Power Sequencer Flags Mask Register */ + __I uint32_t rsv028[2]; /* 0x0028-0x002C */ + __IO uint32_t retn_ctrl0; /* 0x0030 Retention Control Register 0 */ + __IO uint32_t retn_ctrl1; /* 0x0034 Retention Control Register 1 */ +} mxc_pwrseq_regs_t; + + +/* + Register offsets for module PWRSEQ. +*/ + +#define MXC_R_PWRSEQ_OFFS_REG0 ((uint32_t)0x00000000UL) +#define MXC_R_PWRSEQ_OFFS_REG1 ((uint32_t)0x00000004UL) +#define MXC_R_PWRSEQ_OFFS_REG2 ((uint32_t)0x00000008UL) +#define MXC_R_PWRSEQ_OFFS_REG3 ((uint32_t)0x0000000CUL) +#define MXC_R_PWRSEQ_OFFS_REG4 ((uint32_t)0x00000010UL) +#define MXC_R_PWRSEQ_OFFS_REG5 ((uint32_t)0x00000014UL) +#define MXC_R_PWRSEQ_OFFS_REG6 ((uint32_t)0x00000018UL) +#define MXC_R_PWRSEQ_OFFS_REG7 ((uint32_t)0x0000001CUL) +#define MXC_R_PWRSEQ_OFFS_FLAGS ((uint32_t)0x00000020UL) +#define MXC_R_PWRSEQ_OFFS_MSK_FLAGS ((uint32_t)0x00000024UL) +#define MXC_R_PWRSEQ_OFFS_RETN_CTRL0 ((uint32_t)0x00000030UL) +#define MXC_R_PWRSEQ_OFFS_RETN_CTRL1 ((uint32_t)0x00000034UL) + + +/* + Field positions and masks for module PWRSEQ. +*/ + +#define MXC_F_PWRSEQ_REG0_PWR_LP1_POS 0 +#define MXC_F_PWRSEQ_REG0_PWR_LP1 ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_LP1_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_FIRST_BOOT_POS 1 +#define MXC_F_PWRSEQ_REG0_PWR_FIRST_BOOT ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_FIRST_BOOT_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_SYS_REBOOT_POS 2 +#define MXC_F_PWRSEQ_REG0_PWR_SYS_REBOOT ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_SYS_REBOOT_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_FLASHEN_RUN_POS 3 +#define MXC_F_PWRSEQ_REG0_PWR_FLASHEN_RUN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_FLASHEN_RUN_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_FLASHEN_SLP_POS 4 +#define MXC_F_PWRSEQ_REG0_PWR_FLASHEN_SLP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_FLASHEN_SLP_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_RETREGEN_RUN_POS 5 +#define MXC_F_PWRSEQ_REG0_PWR_RETREGEN_RUN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_RETREGEN_RUN_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_RETREGEN_SLP_POS 6 +#define MXC_F_PWRSEQ_REG0_PWR_RETREGEN_SLP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_RETREGEN_SLP_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_ROEN_RUN_POS 7 +#define MXC_F_PWRSEQ_REG0_PWR_ROEN_RUN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_ROEN_RUN_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_ROEN_SLP_POS 8 +#define MXC_F_PWRSEQ_REG0_PWR_ROEN_SLP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_ROEN_SLP_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_NREN_RUN_POS 9 +#define MXC_F_PWRSEQ_REG0_PWR_NREN_RUN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_NREN_RUN_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_NREN_SLP_POS 10 +#define MXC_F_PWRSEQ_REG0_PWR_NREN_SLP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_NREN_SLP_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_RTCEN_RUN_POS 11 +#define MXC_F_PWRSEQ_REG0_PWR_RTCEN_RUN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_RTCEN_RUN_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_RTCEN_SLP_POS 12 +#define MXC_F_PWRSEQ_REG0_PWR_RTCEN_SLP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_RTCEN_SLP_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_SVM12EN_RUN_POS 13 +#define MXC_F_PWRSEQ_REG0_PWR_SVM12EN_RUN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_SVM12EN_RUN_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_SVM18EN_RUN_POS 15 +#define MXC_F_PWRSEQ_REG0_PWR_SVM18EN_RUN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_SVM18EN_RUN_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_SVMRTCEN_RUN_POS 17 +#define MXC_F_PWRSEQ_REG0_PWR_SVMRTCEN_RUN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_SVMRTCEN_RUN_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_SVM_VDDB_RUN_POS 19 +#define MXC_F_PWRSEQ_REG0_PWR_SVM_VDDB_RUN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_SVM_VDDB_RUN_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_SVMTVDD12EN_RUN_POS 21 +#define MXC_F_PWRSEQ_REG0_PWR_SVMTVDD12EN_RUN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_SVMTVDD12EN_RUN_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_VDD12_SWEN_RUN_POS 23 +#define MXC_F_PWRSEQ_REG0_PWR_VDD12_SWEN_RUN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_VDD12_SWEN_RUN_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_VDD12_SWEN_SLP_POS 24 +#define MXC_F_PWRSEQ_REG0_PWR_VDD12_SWEN_SLP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_VDD12_SWEN_SLP_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_VDD18_SWEN_RUN_POS 25 +#define MXC_F_PWRSEQ_REG0_PWR_VDD18_SWEN_RUN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_VDD18_SWEN_RUN_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_VDD18_SWEN_SLP_POS 26 +#define MXC_F_PWRSEQ_REG0_PWR_VDD18_SWEN_SLP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_VDD18_SWEN_SLP_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_TVDD12_SWEN_RUN_POS 27 +#define MXC_F_PWRSEQ_REG0_PWR_TVDD12_SWEN_RUN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_TVDD12_SWEN_RUN_POS)) +#define MXC_F_PWRSEQ_REG0_PWR_TVDD12_SWEN_SLP_POS 28 +#define MXC_F_PWRSEQ_REG0_PWR_TVDD12_SWEN_SLP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG0_PWR_TVDD12_SWEN_SLP_POS)) + +#define MXC_F_PWRSEQ_REG1_PWR_CLR_IO_EVENT_LATCH_POS 0 +#define MXC_F_PWRSEQ_REG1_PWR_CLR_IO_EVENT_LATCH ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG1_PWR_CLR_IO_EVENT_LATCH_POS)) +#define MXC_F_PWRSEQ_REG1_PWR_CLR_IO_CFG_LATCH_POS 1 +#define MXC_F_PWRSEQ_REG1_PWR_CLR_IO_CFG_LATCH ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG1_PWR_CLR_IO_CFG_LATCH_POS)) +#define MXC_F_PWRSEQ_REG1_PWR_MBUS_GATE_POS 2 +#define MXC_F_PWRSEQ_REG1_PWR_MBUS_GATE ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG1_PWR_MBUS_GATE_POS)) +#define MXC_F_PWRSEQ_REG1_PWR_DISCHARGE_EN_POS 3 +#define MXC_F_PWRSEQ_REG1_PWR_DISCHARGE_EN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG1_PWR_DISCHARGE_EN_POS)) +#define MXC_F_PWRSEQ_REG1_PWR_TVDD12_WELL_POS 4 +#define MXC_F_PWRSEQ_REG1_PWR_TVDD12_WELL ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG1_PWR_TVDD12_WELL_POS)) + +#define MXC_F_PWRSEQ_REG2_PWR_VDD12_HYST_POS 0 +#define MXC_F_PWRSEQ_REG2_PWR_VDD12_HYST ((uint32_t)(0x00000003UL << MXC_F_PWRSEQ_REG2_PWR_VDD12_HYST_POS)) +#define MXC_F_PWRSEQ_REG2_PWR_VDD18_HYST_POS 2 +#define MXC_F_PWRSEQ_REG2_PWR_VDD18_HYST ((uint32_t)(0x00000003UL << MXC_F_PWRSEQ_REG2_PWR_VDD18_HYST_POS)) +#define MXC_F_PWRSEQ_REG2_PWR_VRTC_HYST_POS 4 +#define MXC_F_PWRSEQ_REG2_PWR_VRTC_HYST ((uint32_t)(0x00000003UL << MXC_F_PWRSEQ_REG2_PWR_VRTC_HYST_POS)) +#define MXC_F_PWRSEQ_REG2_PWR_VDDB_HYST_POS 6 +#define MXC_F_PWRSEQ_REG2_PWR_VDDB_HYST ((uint32_t)(0x00000003UL << MXC_F_PWRSEQ_REG2_PWR_VDDB_HYST_POS)) +#define MXC_F_PWRSEQ_REG2_PWR_TVDD12_HYST_POS 8 +#define MXC_F_PWRSEQ_REG2_PWR_TVDD12_HYST ((uint32_t)(0x00000003UL << MXC_F_PWRSEQ_REG2_PWR_TVDD12_HYST_POS)) + +#define MXC_F_PWRSEQ_REG3_PWR_ROSEL_POS 0 +#define MXC_F_PWRSEQ_REG3_PWR_ROSEL ((uint32_t)(0x00000007UL << MXC_F_PWRSEQ_REG3_PWR_ROSEL_POS)) +#define MXC_F_PWRSEQ_REG3_PWR_FLTRROSEL_POS 3 +#define MXC_F_PWRSEQ_REG3_PWR_FLTRROSEL ((uint32_t)(0x00000007UL << MXC_F_PWRSEQ_REG3_PWR_FLTRROSEL_POS)) +#define MXC_F_PWRSEQ_REG3_PWR_SVM_CLK_MUX_POS 6 +#define MXC_F_PWRSEQ_REG3_PWR_SVM_CLK_MUX ((uint32_t)(0x00000003UL << MXC_F_PWRSEQ_REG3_PWR_SVM_CLK_MUX_POS)) +#define MXC_F_PWRSEQ_REG3_PWR_RO_CLK_MUX_POS 8 +#define MXC_F_PWRSEQ_REG3_PWR_RO_CLK_MUX ((uint32_t)(0x00000003UL << MXC_F_PWRSEQ_REG3_PWR_RO_CLK_MUX_POS)) +#define MXC_F_PWRSEQ_REG3_PWR_FAILSEL_POS 10 +#define MXC_F_PWRSEQ_REG3_PWR_FAILSEL ((uint32_t)(0x00000007UL << MXC_F_PWRSEQ_REG3_PWR_FAILSEL_POS)) + +#define MXC_F_PWRSEQ_REG4_PWR_TM_PS_2_GPIO_POS 0 +#define MXC_F_PWRSEQ_REG4_PWR_TM_PS_2_GPIO ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG4_PWR_TM_PS_2_GPIO_POS)) +#define MXC_F_PWRSEQ_REG4_PWR_TM_FAST_TIMERS_POS 1 +#define MXC_F_PWRSEQ_REG4_PWR_TM_FAST_TIMERS ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG4_PWR_TM_FAST_TIMERS_POS)) +#define MXC_F_PWRSEQ_REG4_PWR_USB_DIS_COMP_POS 3 +#define MXC_F_PWRSEQ_REG4_PWR_USB_DIS_COMP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG4_PWR_USB_DIS_COMP_POS)) +#define MXC_F_PWRSEQ_REG4_PWR_RO_TSTCLK_EN_POS 4 +#define MXC_F_PWRSEQ_REG4_PWR_RO_TSTCLK_EN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG4_PWR_RO_TSTCLK_EN_POS)) +#define MXC_F_PWRSEQ_REG4_PWR_NR_CLK_GATE_EN_POS 5 +#define MXC_F_PWRSEQ_REG4_PWR_NR_CLK_GATE_EN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG4_PWR_NR_CLK_GATE_EN_POS)) +#define MXC_F_PWRSEQ_REG4_PWR_EXT_CLK_IN_EN_POS 6 +#define MXC_F_PWRSEQ_REG4_PWR_EXT_CLK_IN_EN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG4_PWR_EXT_CLK_IN_EN_POS)) +#define MXC_F_PWRSEQ_REG4_PWR_PSEQ_32K_EN_POS 7 +#define MXC_F_PWRSEQ_REG4_PWR_PSEQ_32K_EN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG4_PWR_PSEQ_32K_EN_POS)) + +#define MXC_F_PWRSEQ_REG5_PWR_TRIM_SVM_BG_POS 0 +#define MXC_F_PWRSEQ_REG5_PWR_TRIM_SVM_BG ((uint32_t)(0x000001FFUL << MXC_F_PWRSEQ_REG5_PWR_TRIM_SVM_BG_POS)) +#define MXC_F_PWRSEQ_REG5_PWR_TRIM_BIAS_POS 9 +#define MXC_F_PWRSEQ_REG5_PWR_TRIM_BIAS ((uint32_t)(0x0000003FUL << MXC_F_PWRSEQ_REG5_PWR_TRIM_BIAS_POS)) +#define MXC_F_PWRSEQ_REG5_PWR_TRIM_RETREG_POS 15 +#define MXC_F_PWRSEQ_REG5_PWR_TRIM_RETREG ((uint32_t)(0x0000003FUL << MXC_F_PWRSEQ_REG5_PWR_TRIM_RETREG_POS)) +#define MXC_F_PWRSEQ_REG5_PWR_RTC_TRIM_POS 21 +#define MXC_F_PWRSEQ_REG5_PWR_RTC_TRIM ((uint32_t)(0x0000000FUL << MXC_F_PWRSEQ_REG5_PWR_RTC_TRIM_POS)) + +#define MXC_F_PWRSEQ_REG6_PWR_TRIM_USB_BIAS_POS 0 +#define MXC_F_PWRSEQ_REG6_PWR_TRIM_USB_BIAS ((uint32_t)(0x00000007UL << MXC_F_PWRSEQ_REG6_PWR_TRIM_USB_BIAS_POS)) +#define MXC_F_PWRSEQ_REG6_PWR_TRIM_USB_PM_RES_POS 3 +#define MXC_F_PWRSEQ_REG6_PWR_TRIM_USB_PM_RES ((uint32_t)(0x0000000FUL << MXC_F_PWRSEQ_REG6_PWR_TRIM_USB_PM_RES_POS)) +#define MXC_F_PWRSEQ_REG6_PWR_TRIM_USB_DM_RES_POS 7 +#define MXC_F_PWRSEQ_REG6_PWR_TRIM_USB_DM_RES ((uint32_t)(0x0000000FUL << MXC_F_PWRSEQ_REG6_PWR_TRIM_USB_DM_RES_POS)) +#define MXC_F_PWRSEQ_REG6_PWR_TRIM_OSC_VREF_POS 11 +#define MXC_F_PWRSEQ_REG6_PWR_TRIM_OSC_VREF ((uint32_t)(0x000001FFUL << MXC_F_PWRSEQ_REG6_PWR_TRIM_OSC_VREF_POS)) +#define MXC_F_PWRSEQ_REG6_PWR_TRIM_CRYPTO_OSC_POS 20 +#define MXC_F_PWRSEQ_REG6_PWR_TRIM_CRYPTO_OSC ((uint32_t)(0x000001FFUL << MXC_F_PWRSEQ_REG6_PWR_TRIM_CRYPTO_OSC_POS)) + +#define MXC_F_PWRSEQ_REG7_PWR_FLASH_PD_LOOKAHEAD_POS 0 +#define MXC_F_PWRSEQ_REG7_PWR_FLASH_PD_LOOKAHEAD ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_REG7_PWR_FLASH_PD_LOOKAHEAD_POS)) + +#define MXC_F_PWRSEQ_FLAGS_PWR_FIRST_BOOT_POS 0 +#define MXC_F_PWRSEQ_FLAGS_PWR_FIRST_BOOT ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_PWR_FIRST_BOOT_POS)) +#define MXC_F_PWRSEQ_FLAGS_PWR_SYS_REBOOT_POS 1 +#define MXC_F_PWRSEQ_FLAGS_PWR_SYS_REBOOT ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_PWR_SYS_REBOOT_POS)) +#define MXC_F_PWRSEQ_FLAGS_PWR_POWER_FAIL_POS 2 +#define MXC_F_PWRSEQ_FLAGS_PWR_POWER_FAIL ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_PWR_POWER_FAIL_POS)) +#define MXC_F_PWRSEQ_FLAGS_PWR_BOOT_FAIL_POS 3 +#define MXC_F_PWRSEQ_FLAGS_PWR_BOOT_FAIL ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_PWR_BOOT_FAIL_POS)) +#define MXC_F_PWRSEQ_FLAGS_PWR_FLASH_DISCHARGE_POS 4 +#define MXC_F_PWRSEQ_FLAGS_PWR_FLASH_DISCHARGE ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_PWR_FLASH_DISCHARGE_POS)) +#define MXC_F_PWRSEQ_FLAGS_PWR_IOWAKEUP_POS 5 +#define MXC_F_PWRSEQ_FLAGS_PWR_IOWAKEUP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_PWR_IOWAKEUP_POS)) +#define MXC_F_PWRSEQ_FLAGS_PWR_VDD12_RST_BAD_POS 6 +#define MXC_F_PWRSEQ_FLAGS_PWR_VDD12_RST_BAD ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_PWR_VDD12_RST_BAD_POS)) +#define MXC_F_PWRSEQ_FLAGS_PWR_VDD18_RST_BAD_POS 7 +#define MXC_F_PWRSEQ_FLAGS_PWR_VDD18_RST_BAD ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_PWR_VDD18_RST_BAD_POS)) +#define MXC_F_PWRSEQ_FLAGS_PWR_VRTC_RST_BAD_POS 8 +#define MXC_F_PWRSEQ_FLAGS_PWR_VRTC_RST_BAD ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_PWR_VRTC_RST_BAD_POS)) +#define MXC_F_PWRSEQ_FLAGS_PWR_VDDB_RST_BAD_POS 9 +#define MXC_F_PWRSEQ_FLAGS_PWR_VDDB_RST_BAD ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_PWR_VDDB_RST_BAD_POS)) +#define MXC_F_PWRSEQ_FLAGS_PWR_TVDD12_RST_BAD_POS 10 +#define MXC_F_PWRSEQ_FLAGS_PWR_TVDD12_RST_BAD ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_PWR_TVDD12_RST_BAD_POS)) +#define MXC_F_PWRSEQ_FLAGS_PWR_POR18Z_FAIL_LATCH_POS 11 +#define MXC_F_PWRSEQ_FLAGS_PWR_POR18Z_FAIL_LATCH ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_PWR_POR18Z_FAIL_LATCH_POS)) +#define MXC_F_PWRSEQ_FLAGS_RTC_CMPR0_POS 12 +#define MXC_F_PWRSEQ_FLAGS_RTC_CMPR0 ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_RTC_CMPR0_POS)) +#define MXC_F_PWRSEQ_FLAGS_RTC_CMPR1_POS 13 +#define MXC_F_PWRSEQ_FLAGS_RTC_CMPR1 ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_RTC_CMPR1_POS)) +#define MXC_F_PWRSEQ_FLAGS_RTC_PRESCALE_CMP_POS 14 +#define MXC_F_PWRSEQ_FLAGS_RTC_PRESCALE_CMP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_RTC_PRESCALE_CMP_POS)) +#define MXC_F_PWRSEQ_FLAGS_RTC_ROLLOVER_POS 15 +#define MXC_F_PWRSEQ_FLAGS_RTC_ROLLOVER ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_RTC_ROLLOVER_POS)) +#define MXC_F_PWRSEQ_FLAGS_PWR_USB_PLUG_WAKEUP_POS 16 +#define MXC_F_PWRSEQ_FLAGS_PWR_USB_PLUG_WAKEUP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_PWR_USB_PLUG_WAKEUP_POS)) +#define MXC_F_PWRSEQ_FLAGS_PWR_USB_REMOVE_WAKEUP_POS 17 +#define MXC_F_PWRSEQ_FLAGS_PWR_USB_REMOVE_WAKEUP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_PWR_USB_REMOVE_WAKEUP_POS)) +#define MXC_F_PWRSEQ_FLAGS_PWR_TVDD12_BAD_POS 18 +#define MXC_F_PWRSEQ_FLAGS_PWR_TVDD12_BAD ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_FLAGS_PWR_TVDD12_BAD_POS)) + +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_SYS_REBOOT_POS 1 +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_SYS_REBOOT ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_PWR_SYS_REBOOT_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_POWER_FAIL_POS 2 +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_POWER_FAIL ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_PWR_POWER_FAIL_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_BOOT_FAIL_POS 3 +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_BOOT_FAIL ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_PWR_BOOT_FAIL_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_FLASH_DISCHARGE_POS 4 +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_FLASH_DISCHARGE ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_PWR_FLASH_DISCHARGE_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_IOWAKEUP_POS 5 +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_IOWAKEUP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_PWR_IOWAKEUP_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_VDD12_RST_BAD_POS 6 +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_VDD12_RST_BAD ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_PWR_VDD12_RST_BAD_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_VDD18_RST_BAD_POS 7 +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_VDD18_RST_BAD ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_PWR_VDD18_RST_BAD_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_VRTC_RST_BAD_POS 8 +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_VRTC_RST_BAD ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_PWR_VRTC_RST_BAD_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_VDDB_RST_BAD_POS 9 +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_VDDB_RST_BAD ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_PWR_VDDB_RST_BAD_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_TVDD12_RST_BAD_POS 10 +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_TVDD12_RST_BAD ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_PWR_TVDD12_RST_BAD_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_POR18Z_FAIL_LATCH_POS 11 +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_POR18Z_FAIL_LATCH ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_PWR_POR18Z_FAIL_LATCH_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_RTC_CMPR0_POS 12 +#define MXC_F_PWRSEQ_MSK_FLAGS_RTC_CMPR0 ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_RTC_CMPR0_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_RTC_CMPR1_POS 13 +#define MXC_F_PWRSEQ_MSK_FLAGS_RTC_CMPR1 ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_RTC_CMPR1_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_RTC_PRESCALE_CMP_POS 14 +#define MXC_F_PWRSEQ_MSK_FLAGS_RTC_PRESCALE_CMP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_RTC_PRESCALE_CMP_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_RTC_ROLLOVER_POS 15 +#define MXC_F_PWRSEQ_MSK_FLAGS_RTC_ROLLOVER ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_RTC_ROLLOVER_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_USB_PLUG_WAKEUP_POS 16 +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_USB_PLUG_WAKEUP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_PWR_USB_PLUG_WAKEUP_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_USB_REMOVE_WAKEUP_POS 17 +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_USB_REMOVE_WAKEUP ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_PWR_USB_REMOVE_WAKEUP_POS)) +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_TVDD12_BAD_POS 18 +#define MXC_F_PWRSEQ_MSK_FLAGS_PWR_TVDD12_BAD ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_MSK_FLAGS_PWR_TVDD12_BAD_POS)) + +#define MXC_F_PWRSEQ_RETN_CTRL0_RETN_CTRL_EN_POS 0 +#define MXC_F_PWRSEQ_RETN_CTRL0_RETN_CTRL_EN ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_RETN_CTRL0_RETN_CTRL_EN_POS)) +#define MXC_F_PWRSEQ_RETN_CTRL0_RC_REL_CCG_EARLY_POS 1 +#define MXC_F_PWRSEQ_RETN_CTRL0_RC_REL_CCG_EARLY ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_RETN_CTRL0_RC_REL_CCG_EARLY_POS)) +#define MXC_F_PWRSEQ_RETN_CTRL0_RC_USE_FLC_TWK_POS 2 +#define MXC_F_PWRSEQ_RETN_CTRL0_RC_USE_FLC_TWK ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_RETN_CTRL0_RC_USE_FLC_TWK_POS)) +#define MXC_F_PWRSEQ_RETN_CTRL0_RC_POLL_FLASH_POS 3 +#define MXC_F_PWRSEQ_RETN_CTRL0_RC_POLL_FLASH ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_RETN_CTRL0_RC_POLL_FLASH_POS)) +#define MXC_F_PWRSEQ_RETN_CTRL0_RESTORE_OVERRIDE_POS 4 +#define MXC_F_PWRSEQ_RETN_CTRL0_RESTORE_OVERRIDE ((uint32_t)(0x00000001UL << MXC_F_PWRSEQ_RETN_CTRL0_RESTORE_OVERRIDE_POS)) + +#define MXC_F_PWRSEQ_RETN_CTRL1_RC_TWK_POS 0 +#define MXC_F_PWRSEQ_RETN_CTRL1_RC_TWK ((uint32_t)(0x0000000FUL << MXC_F_PWRSEQ_RETN_CTRL1_RC_TWK_POS)) +#define MXC_F_PWRSEQ_RETN_CTRL1_SRAM_FMS_POS 4 +#define MXC_F_PWRSEQ_RETN_CTRL1_SRAM_FMS ((uint32_t)(0x0000000FUL << MXC_F_PWRSEQ_RETN_CTRL1_SRAM_FMS_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_PWRSEQ_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/rtc_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/rtc_regs.h new file mode 100644 index 0000000000..031631f9e8 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/rtc_regs.h @@ -0,0 +1,241 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_RTC_REGS_H_ +#define _MXC_RTC_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t ctrl; /* 0x0000 RTC Timer Control */ + __IO uint32_t timer; /* 0x0004 RTC Timer Count Value */ + __IO uint32_t comp[2]; /* 0x0008-0x000C RTC Time of Day Alarm [0..1] Compare Register */ + __IO uint32_t flags; /* 0x0010 CPU Interrupt and RTC Domain Flags */ + __IO uint32_t snz_val; /* 0x0014 RTC Timer Alarm Snooze Value */ + __IO uint32_t inten; /* 0x0018 Interrupt Enable Controls */ + __IO uint32_t prescale; /* 0x001C RTC Timer Prescale Setting */ + __I uint32_t rsv020; /* 0x0020 */ + __IO uint32_t prescale_mask; /* 0x0024 RTC Timer Prescale Compare Mask */ + __IO uint32_t trim_ctrl; /* 0x0028 RTC Timer Trim Controls */ + __IO uint32_t trim_value; /* 0x002C RTC Timer Trim Adjustment Interval */ +} mxc_rtctmr_regs_t; + + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t nano_cntr; /* 0x0000 Nano Oscillator Counter Read Register */ + __IO uint32_t clk_ctrl; /* 0x0004 RTC Clock Control Settings */ + __I uint32_t rsv008; /* 0x0008 */ + __IO uint32_t osc_ctrl; /* 0x000C RTC Oscillator Control */ +} mxc_rtccfg_regs_t; + + +/* + Register offsets for module RTC. +*/ + +#define MXC_R_RTCTMR_OFFS_CTRL ((uint32_t)0x00000000UL) +#define MXC_R_RTCTMR_OFFS_TIMER ((uint32_t)0x00000004UL) +#define MXC_R_RTCTMR_OFFS_COMP0 ((uint32_t)0x00000008UL) +#define MXC_R_RTCTMR_OFFS_COMP1 ((uint32_t)0x0000000CUL) +#define MXC_R_RTCTMR_OFFS_FLAGS ((uint32_t)0x00000010UL) +#define MXC_R_RTCTMR_OFFS_SNZ_VAL ((uint32_t)0x00000014UL) +#define MXC_R_RTCTMR_OFFS_INTEN ((uint32_t)0x00000018UL) +#define MXC_R_RTCTMR_OFFS_PRESCALE ((uint32_t)0x0000001CUL) +#define MXC_R_RTCTMR_OFFS_PRESCALE_MASK ((uint32_t)0x00000024UL) +#define MXC_R_RTCTMR_OFFS_TRIM_CTRL ((uint32_t)0x00000028UL) +#define MXC_R_RTCTMR_OFFS_TRIM_VALUE ((uint32_t)0x0000002CUL) +#define MXC_R_RTCCFG_OFFS_NANO_CNTR ((uint32_t)0x00000000UL) +#define MXC_R_RTCCFG_OFFS_CLK_CTRL ((uint32_t)0x00000004UL) +#define MXC_R_RTCCFG_OFFS_OSC_CTRL ((uint32_t)0x0000000CUL) + + +/* + Field positions and masks for module RTC. +*/ + +#define MXC_F_RTC_CTRL_ENABLE_POS 0 +#define MXC_F_RTC_CTRL_ENABLE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_ENABLE_POS)) +#define MXC_F_RTC_CTRL_CLEAR_POS 1 +#define MXC_F_RTC_CTRL_CLEAR ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_CLEAR_POS)) +#define MXC_F_RTC_CTRL_PENDING_POS 2 +#define MXC_F_RTC_CTRL_PENDING ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_PENDING_POS)) +#define MXC_F_RTC_CTRL_USE_ASYNC_FLAGS_POS 3 +#define MXC_F_RTC_CTRL_USE_ASYNC_FLAGS ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_USE_ASYNC_FLAGS_POS)) +#define MXC_F_RTC_CTRL_AGGRESSIVE_RST_POS 4 +#define MXC_F_RTC_CTRL_AGGRESSIVE_RST ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_AGGRESSIVE_RST_POS)) +#define MXC_F_RTC_CTRL_AUTO_UPDATE_DISABLE_POS 5 +#define MXC_F_RTC_CTRL_AUTO_UPDATE_DISABLE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_AUTO_UPDATE_DISABLE_POS)) +#define MXC_F_RTC_CTRL_SNOOZE_ENABLE_POS 6 +#define MXC_F_RTC_CTRL_SNOOZE_ENABLE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_SNOOZE_ENABLE_POS)) +#define MXC_F_RTC_CTRL_RTC_ENABLE_ACTIVE_POS 16 +#define MXC_F_RTC_CTRL_RTC_ENABLE_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_RTC_ENABLE_ACTIVE_POS)) +#define MXC_F_RTC_CTRL_OSC_GOTO_LOW_ACTIVE_POS 17 +#define MXC_F_RTC_CTRL_OSC_GOTO_LOW_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_OSC_GOTO_LOW_ACTIVE_POS)) +#define MXC_F_RTC_CTRL_OSC_FRCE_SM_EN_ACTIVE_POS 18 +#define MXC_F_RTC_CTRL_OSC_FRCE_SM_EN_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_OSC_FRCE_SM_EN_ACTIVE_POS)) +#define MXC_F_RTC_CTRL_OSC_FRCE_ST_ACTIVE_POS 19 +#define MXC_F_RTC_CTRL_OSC_FRCE_ST_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_OSC_FRCE_ST_ACTIVE_POS)) +#define MXC_F_RTC_CTRL_RTC_SET_ACTIVE_POS 20 +#define MXC_F_RTC_CTRL_RTC_SET_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_RTC_SET_ACTIVE_POS)) +#define MXC_F_RTC_CTRL_RTC_CLR_ACTIVE_POS 21 +#define MXC_F_RTC_CTRL_RTC_CLR_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_RTC_CLR_ACTIVE_POS)) +#define MXC_F_RTC_CTRL_ROLLOVER_CLR_ACTIVE_POS 22 +#define MXC_F_RTC_CTRL_ROLLOVER_CLR_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_ROLLOVER_CLR_ACTIVE_POS)) +#define MXC_F_RTC_CTRL_PRESCALE_CMPR0_ACTIVE_POS 23 +#define MXC_F_RTC_CTRL_PRESCALE_CMPR0_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_PRESCALE_CMPR0_ACTIVE_POS)) +#define MXC_F_RTC_CTRL_PRESCALE_UPDATE_ACTIVE_POS 24 +#define MXC_F_RTC_CTRL_PRESCALE_UPDATE_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_PRESCALE_UPDATE_ACTIVE_POS)) +#define MXC_F_RTC_CTRL_CMPR1_CLR_ACTIVE_POS 25 +#define MXC_F_RTC_CTRL_CMPR1_CLR_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_CMPR1_CLR_ACTIVE_POS)) +#define MXC_F_RTC_CTRL_CMPR0_CLR_ACTIVE_POS 26 +#define MXC_F_RTC_CTRL_CMPR0_CLR_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_CMPR0_CLR_ACTIVE_POS)) +#define MXC_F_RTC_CTRL_TRIM_ENABLE_ACTIVE_POS 27 +#define MXC_F_RTC_CTRL_TRIM_ENABLE_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_TRIM_ENABLE_ACTIVE_POS)) +#define MXC_F_RTC_CTRL_TRIM_SLOWER_ACTIVE_POS 28 +#define MXC_F_RTC_CTRL_TRIM_SLOWER_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_TRIM_SLOWER_ACTIVE_POS)) +#define MXC_F_RTC_CTRL_TRIM_CLR_ACTIVE_POS 29 +#define MXC_F_RTC_CTRL_TRIM_CLR_ACTIVE ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_TRIM_CLR_ACTIVE_POS)) +#define MXC_F_RTC_CTRL_ACTIVE_TRANS_0_POS 30 +#define MXC_F_RTC_CTRL_ACTIVE_TRANS_0 ((uint32_t)(0x00000001UL << MXC_F_RTC_CTRL_ACTIVE_TRANS_0_POS)) + +#define MXC_F_RTC_FLAGS_COMP0_POS 0 +#define MXC_F_RTC_FLAGS_COMP0 ((uint32_t)(0x00000001UL << MXC_F_RTC_FLAGS_COMP0_POS)) +#define MXC_F_RTC_FLAGS_COMP1_POS 1 +#define MXC_F_RTC_FLAGS_COMP1 ((uint32_t)(0x00000001UL << MXC_F_RTC_FLAGS_COMP1_POS)) +#define MXC_F_RTC_FLAGS_PRESCALE_COMP_POS 2 +#define MXC_F_RTC_FLAGS_PRESCALE_COMP ((uint32_t)(0x00000001UL << MXC_F_RTC_FLAGS_PRESCALE_COMP_POS)) +#define MXC_F_RTC_FLAGS_OVERFLOW_POS 3 +#define MXC_F_RTC_FLAGS_OVERFLOW ((uint32_t)(0x00000001UL << MXC_F_RTC_FLAGS_OVERFLOW_POS)) +#define MXC_F_RTC_FLAGS_TRIM_POS 4 +#define MXC_F_RTC_FLAGS_TRIM ((uint32_t)(0x00000001UL << MXC_F_RTC_FLAGS_TRIM_POS)) +#define MXC_F_RTC_FLAGS_SNOOZE_POS 5 +#define MXC_F_RTC_FLAGS_SNOOZE ((uint32_t)(0x00000001UL << MXC_F_RTC_FLAGS_SNOOZE_POS)) +#define MXC_F_RTC_FLAGS_COMP0_FLAG_A_POS 8 +#define MXC_F_RTC_FLAGS_COMP0_FLAG_A ((uint32_t)(0x00000001UL << MXC_F_RTC_FLAGS_COMP0_FLAG_A_POS)) +#define MXC_F_RTC_FLAGS_COMP1_FLAG_A_POS 9 +#define MXC_F_RTC_FLAGS_COMP1_FLAG_A ((uint32_t)(0x00000001UL << MXC_F_RTC_FLAGS_COMP1_FLAG_A_POS)) +#define MXC_F_RTC_FLAGS_PRESCL_FLAG_A_POS 10 +#define MXC_F_RTC_FLAGS_PRESCL_FLAG_A ((uint32_t)(0x00000001UL << MXC_F_RTC_FLAGS_PRESCL_FLAG_A_POS)) +#define MXC_F_RTC_FLAGS_OVERFLOW_FLAG_A_POS 11 +#define MXC_F_RTC_FLAGS_OVERFLOW_FLAG_A ((uint32_t)(0x00000001UL << MXC_F_RTC_FLAGS_OVERFLOW_FLAG_A_POS)) +#define MXC_F_RTC_FLAGS_TRIM_FLAG_A_POS 12 +#define MXC_F_RTC_FLAGS_TRIM_FLAG_A ((uint32_t)(0x00000001UL << MXC_F_RTC_FLAGS_TRIM_FLAG_A_POS)) +#define MXC_F_RTC_FLAGS_ASYNC_CLR_FLAGS_POS 31 +#define MXC_F_RTC_FLAGS_ASYNC_CLR_FLAGS ((uint32_t)(0x00000001UL << MXC_F_RTC_FLAGS_ASYNC_CLR_FLAGS_POS)) + +#define MXC_F_RTC_SNZ_VAL_VALUE_POS 0 +#define MXC_F_RTC_SNZ_VAL_VALUE ((uint32_t)(0x000003FFUL << MXC_F_RTC_SNZ_VAL_VALUE_POS)) + +#define MXC_F_RTC_INTEN_COMP0_POS 0 +#define MXC_F_RTC_INTEN_COMP0 ((uint32_t)(0x00000001UL << MXC_F_RTC_INTEN_COMP0_POS)) +#define MXC_F_RTC_INTEN_COMP1_POS 1 +#define MXC_F_RTC_INTEN_COMP1 ((uint32_t)(0x00000001UL << MXC_F_RTC_INTEN_COMP1_POS)) +#define MXC_F_RTC_INTEN_PRESCALE_COMP_POS 2 +#define MXC_F_RTC_INTEN_PRESCALE_COMP ((uint32_t)(0x00000001UL << MXC_F_RTC_INTEN_PRESCALE_COMP_POS)) +#define MXC_F_RTC_INTEN_OVERFLOW_POS 3 +#define MXC_F_RTC_INTEN_OVERFLOW ((uint32_t)(0x00000001UL << MXC_F_RTC_INTEN_OVERFLOW_POS)) +#define MXC_F_RTC_INTEN_TRIM_POS 4 +#define MXC_F_RTC_INTEN_TRIM ((uint32_t)(0x00000001UL << MXC_F_RTC_INTEN_TRIM_POS)) + +#define MXC_F_RTC_PRESCALE_PRESCALE_POS 0 +#define MXC_F_RTC_PRESCALE_PRESCALE ((uint32_t)(0x0000000FUL << MXC_F_RTC_PRESCALE_PRESCALE_POS)) + +#define MXC_F_RTC_PRESCALE_MASK_PRESCALE_MASK_POS 0 +#define MXC_F_RTC_PRESCALE_MASK_PRESCALE_MASK ((uint32_t)(0x0000000FUL << MXC_F_RTC_PRESCALE_MASK_PRESCALE_MASK_POS)) + +#define MXC_F_RTC_TRIM_CTRL_TRIM_ENABLE_R_POS 0 +#define MXC_F_RTC_TRIM_CTRL_TRIM_ENABLE_R ((uint32_t)(0x00000001UL << MXC_F_RTC_TRIM_CTRL_TRIM_ENABLE_R_POS)) +#define MXC_F_RTC_TRIM_CTRL_TRIM_FASTER_OVR_R_POS 1 +#define MXC_F_RTC_TRIM_CTRL_TRIM_FASTER_OVR_R ((uint32_t)(0x00000001UL << MXC_F_RTC_TRIM_CTRL_TRIM_FASTER_OVR_R_POS)) +#define MXC_F_RTC_TRIM_CTRL_TRIM_SLOWER_R_POS 2 +#define MXC_F_RTC_TRIM_CTRL_TRIM_SLOWER_R ((uint32_t)(0x00000001UL << MXC_F_RTC_TRIM_CTRL_TRIM_SLOWER_R_POS)) + +#define MXC_F_RTC_TRIM_VALUE_TRIM_VALUE_POS 0 +#define MXC_F_RTC_TRIM_VALUE_TRIM_VALUE ((uint32_t)(0x0003FFFFUL << MXC_F_RTC_TRIM_VALUE_TRIM_VALUE_POS)) +#define MXC_F_RTC_TRIM_VALUE_TRIM_SLOWER_CONTROL_POS 18 +#define MXC_F_RTC_TRIM_VALUE_TRIM_SLOWER_CONTROL ((uint32_t)(0x00000001UL << MXC_F_RTC_TRIM_VALUE_TRIM_SLOWER_CONTROL_POS)) + +#define MXC_F_RTC_NANO_CNTR_NANORING_COUNTER_POS 0 +#define MXC_F_RTC_NANO_CNTR_NANORING_COUNTER ((uint32_t)(0x0000FFFFUL << MXC_F_RTC_NANO_CNTR_NANORING_COUNTER_POS)) + +#define MXC_F_RTC_CLK_CTRL_OSC1_EN_POS 0 +#define MXC_F_RTC_CLK_CTRL_OSC1_EN ((uint32_t)(0x00000001UL << MXC_F_RTC_CLK_CTRL_OSC1_EN_POS)) +#define MXC_F_RTC_CLK_CTRL_OSC2_EN_POS 1 +#define MXC_F_RTC_CLK_CTRL_OSC2_EN ((uint32_t)(0x00000001UL << MXC_F_RTC_CLK_CTRL_OSC2_EN_POS)) +#define MXC_F_RTC_CLK_CTRL_NANO_EN_POS 2 +#define MXC_F_RTC_CLK_CTRL_NANO_EN ((uint32_t)(0x00000001UL << MXC_F_RTC_CLK_CTRL_NANO_EN_POS)) + +#define MXC_F_RTC_OSC_CTRL_OSC_BYPASS_POS 0 +#define MXC_F_RTC_OSC_CTRL_OSC_BYPASS ((uint32_t)(0x00000001UL << MXC_F_RTC_OSC_CTRL_OSC_BYPASS_POS)) +#define MXC_F_RTC_OSC_CTRL_OSC_DISABLE_R_POS 1 +#define MXC_F_RTC_OSC_CTRL_OSC_DISABLE_R ((uint32_t)(0x00000001UL << MXC_F_RTC_OSC_CTRL_OSC_DISABLE_R_POS)) +#define MXC_F_RTC_OSC_CTRL_OSC_DISABLE_SEL_POS 2 +#define MXC_F_RTC_OSC_CTRL_OSC_DISABLE_SEL ((uint32_t)(0x00000001UL << MXC_F_RTC_OSC_CTRL_OSC_DISABLE_SEL_POS)) +#define MXC_F_RTC_OSC_CTRL_OSC_DISABLE_O_POS 3 +#define MXC_F_RTC_OSC_CTRL_OSC_DISABLE_O ((uint32_t)(0x00000001UL << MXC_F_RTC_OSC_CTRL_OSC_DISABLE_O_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_RTC_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/spi_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/spi_regs.h new file mode 100644 index 0000000000..86c948393a --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/spi_regs.h @@ -0,0 +1,243 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_SPI_REGS_H_ +#define _MXC_SPI_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t mstr_cfg; /* 0x0000 SPI Master Configuration Register */ + __IO uint32_t ss_sr_polarity; /* 0x0004 SPI Master Polarity Control for SS and SR Signals */ + __IO uint32_t gen_ctrl; /* 0x0008 SPI Master General Control Register */ + __IO uint32_t fifo_ctrl; /* 0x000C SPI Master FIFO Control Register */ + __IO uint32_t spcl_ctrl; /* 0x0010 SPI Master Special Mode Controls */ + __IO uint32_t intfl; /* 0x0014 SPI Master Interrupt Flags */ + __IO uint32_t inten; /* 0x0018 SPI Master Interrupt Enable/Disable Settings */ +} mxc_spi_regs_t; + + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + union { /* 0x0000-0x07FC SPI Master FIFO Write Space for Transaction Setup */ + __IO uint8_t trans_8[2048]; + __IO uint16_t trans_16[1024]; + __IO uint32_t trans_32[512]; + }; + union { /* 0x0800-0x0FFC SPI Master FIFO Read Space for Results Data */ + __IO uint8_t rslts_8[2048]; + __IO uint16_t rslts_16[1024]; + __IO uint32_t rslts_32[512]; + }; +} mxc_spi_fifo_regs_t; + + +/* + Register offsets for module SPI. +*/ + +#define MXC_R_SPI_OFFS_MSTR_CFG ((uint32_t)0x00000000UL) +#define MXC_R_SPI_OFFS_SS_SR_POLARITY ((uint32_t)0x00000004UL) +#define MXC_R_SPI_OFFS_GEN_CTRL ((uint32_t)0x00000008UL) +#define MXC_R_SPI_OFFS_FIFO_CTRL ((uint32_t)0x0000000CUL) +#define MXC_R_SPI_OFFS_SPCL_CTRL ((uint32_t)0x00000010UL) +#define MXC_R_SPI_OFFS_INTFL ((uint32_t)0x00000014UL) +#define MXC_R_SPI_OFFS_INTEN ((uint32_t)0x00000018UL) +#define MXC_R_SPI_FIFO_OFFS_TRANS ((uint32_t)0x00000000UL) +#define MXC_R_SPI_FIFO_OFFS_RSLTS ((uint32_t)0x00000800UL) + + +/* + Field positions and masks for module SPI. +*/ + +#define MXC_F_SPI_MSTR_CFG_SLAVE_SEL_POS 0 +#define MXC_F_SPI_MSTR_CFG_SLAVE_SEL ((uint32_t)(0x00000007UL << MXC_F_SPI_MSTR_CFG_SLAVE_SEL_POS)) +#define MXC_F_SPI_MSTR_CFG_THREE_WIRE_MODE_POS 3 +#define MXC_F_SPI_MSTR_CFG_THREE_WIRE_MODE ((uint32_t)(0x00000001UL << MXC_F_SPI_MSTR_CFG_THREE_WIRE_MODE_POS)) +#define MXC_F_SPI_MSTR_CFG_SPI_MODE_POS 4 +#define MXC_F_SPI_MSTR_CFG_SPI_MODE ((uint32_t)(0x00000003UL << MXC_F_SPI_MSTR_CFG_SPI_MODE_POS)) +#define MXC_F_SPI_MSTR_CFG_PAGE_SIZE_POS 6 +#define MXC_F_SPI_MSTR_CFG_PAGE_SIZE ((uint32_t)(0x00000003UL << MXC_F_SPI_MSTR_CFG_PAGE_SIZE_POS)) +#define MXC_F_SPI_MSTR_CFG_SCK_HI_CLK_POS 8 +#define MXC_F_SPI_MSTR_CFG_SCK_HI_CLK ((uint32_t)(0x0000000FUL << MXC_F_SPI_MSTR_CFG_SCK_HI_CLK_POS)) +#define MXC_F_SPI_MSTR_CFG_SCK_LO_CLK_POS 12 +#define MXC_F_SPI_MSTR_CFG_SCK_LO_CLK ((uint32_t)(0x0000000FUL << MXC_F_SPI_MSTR_CFG_SCK_LO_CLK_POS)) +#define MXC_F_SPI_MSTR_CFG_ACT_DELAY_POS 16 +#define MXC_F_SPI_MSTR_CFG_ACT_DELAY ((uint32_t)(0x00000003UL << MXC_F_SPI_MSTR_CFG_ACT_DELAY_POS)) +#define MXC_F_SPI_MSTR_CFG_INACT_DELAY_POS 18 +#define MXC_F_SPI_MSTR_CFG_INACT_DELAY ((uint32_t)(0x00000003UL << MXC_F_SPI_MSTR_CFG_INACT_DELAY_POS)) +#define MXC_F_SPI_MSTR_CFG_ALT_SCK_HI_CLK_POS 20 +#define MXC_F_SPI_MSTR_CFG_ALT_SCK_HI_CLK ((uint32_t)(0x0000000FUL << MXC_F_SPI_MSTR_CFG_ALT_SCK_HI_CLK_POS)) +#define MXC_F_SPI_MSTR_CFG_ALT_SCK_LO_CLK_POS 24 +#define MXC_F_SPI_MSTR_CFG_ALT_SCK_LO_CLK ((uint32_t)(0x0000000FUL << MXC_F_SPI_MSTR_CFG_ALT_SCK_LO_CLK_POS)) + +#define MXC_V_SPI_MSTR_CFG_PAGE_SIZE_4B ((uint32_t)0x00000000UL) +#define MXC_V_SPI_MSTR_CFG_PAGE_SIZE_8B ((uint32_t)0x00000001UL) +#define MXC_V_SPI_MSTR_CFG_PAGE_SIZE_16B ((uint32_t)0x00000002UL) +#define MXC_V_SPI_MSTR_CFG_PAGE_SIZE_32B ((uint32_t)0x00000003UL) + +#define MXC_S_SPI_MSTR_CFG_PAGE_4B (MXC_V_SPI_MSTR_CFG_PAGE_SIZE_4B << MXC_F_SPI_MSTR_CFG_PAGE_SIZE_POS) +#define MXC_S_SPI_MSTR_CFG_PAGE_8B (MXC_V_SPI_MSTR_CFG_PAGE_SIZE_8B << MXC_F_SPI_MSTR_CFG_PAGE_SIZE_POS) +#define MXC_S_SPI_MSTR_CFG_PAGE_16B (MXC_V_SPI_MSTR_CFG_PAGE_SIZE_16B << MXC_F_SPI_MSTR_CFG_PAGE_SIZE_POS) +#define MXC_S_SPI_MSTR_CFG_PAGE_32B (MXC_V_SPI_MSTR_CFG_PAGE_SIZE_32B << MXC_F_SPI_MSTR_CFG_PAGE_SIZE_POS) + +#define MXC_F_SPI_SS_SR_POLARITY_SS_POLARITY_POS 0 +#define MXC_F_SPI_SS_SR_POLARITY_SS_POLARITY ((uint32_t)(0x000000FFUL << MXC_F_SPI_SS_SR_POLARITY_SS_POLARITY_POS)) +#define MXC_F_SPI_SS_SR_POLARITY_FC_POLARITY_POS 8 +#define MXC_F_SPI_SS_SR_POLARITY_FC_POLARITY ((uint32_t)(0x000000FFUL << MXC_F_SPI_SS_SR_POLARITY_FC_POLARITY_POS)) + +#define MXC_F_SPI_GEN_CTRL_SPI_MSTR_EN_POS 0 +#define MXC_F_SPI_GEN_CTRL_SPI_MSTR_EN ((uint32_t)(0x00000001UL << MXC_F_SPI_GEN_CTRL_SPI_MSTR_EN_POS)) +#define MXC_F_SPI_GEN_CTRL_TX_FIFO_EN_POS 1 +#define MXC_F_SPI_GEN_CTRL_TX_FIFO_EN ((uint32_t)(0x00000001UL << MXC_F_SPI_GEN_CTRL_TX_FIFO_EN_POS)) +#define MXC_F_SPI_GEN_CTRL_RX_FIFO_EN_POS 2 +#define MXC_F_SPI_GEN_CTRL_RX_FIFO_EN ((uint32_t)(0x00000001UL << MXC_F_SPI_GEN_CTRL_RX_FIFO_EN_POS)) +#define MXC_F_SPI_GEN_CTRL_BIT_BANG_MODE_POS 3 +#define MXC_F_SPI_GEN_CTRL_BIT_BANG_MODE ((uint32_t)(0x00000001UL << MXC_F_SPI_GEN_CTRL_BIT_BANG_MODE_POS)) +#define MXC_F_SPI_GEN_CTRL_BB_SS_IN_OUT_POS 4 +#define MXC_F_SPI_GEN_CTRL_BB_SS_IN_OUT ((uint32_t)(0x00000001UL << MXC_F_SPI_GEN_CTRL_BB_SS_IN_OUT_POS)) +#define MXC_F_SPI_GEN_CTRL_BB_SR_IN_POS 5 +#define MXC_F_SPI_GEN_CTRL_BB_SR_IN ((uint32_t)(0x00000001UL << MXC_F_SPI_GEN_CTRL_BB_SR_IN_POS)) +#define MXC_F_SPI_GEN_CTRL_BB_SCK_IN_OUT_POS 6 +#define MXC_F_SPI_GEN_CTRL_BB_SCK_IN_OUT ((uint32_t)(0x00000001UL << MXC_F_SPI_GEN_CTRL_BB_SCK_IN_OUT_POS)) +#define MXC_F_SPI_GEN_CTRL_BB_SDIO_IN_POS 8 +#define MXC_F_SPI_GEN_CTRL_BB_SDIO_IN ((uint32_t)(0x0000000FUL << MXC_F_SPI_GEN_CTRL_BB_SDIO_IN_POS)) +#define MXC_F_SPI_GEN_CTRL_BB_SDIO_OUT_POS 12 +#define MXC_F_SPI_GEN_CTRL_BB_SDIO_OUT ((uint32_t)(0x0000000FUL << MXC_F_SPI_GEN_CTRL_BB_SDIO_OUT_POS)) +#define MXC_F_SPI_GEN_CTRL_BB_SDIO_DR_EN_POS 16 +#define MXC_F_SPI_GEN_CTRL_BB_SDIO_DR_EN ((uint32_t)(0x0000000FUL << MXC_F_SPI_GEN_CTRL_BB_SDIO_DR_EN_POS)) + +#define MXC_F_SPI_FIFO_CTRL_TX_FIFO_AE_LVL_POS 0 +#define MXC_F_SPI_FIFO_CTRL_TX_FIFO_AE_LVL ((uint32_t)(0x0000000FUL << MXC_F_SPI_FIFO_CTRL_TX_FIFO_AE_LVL_POS)) +#define MXC_F_SPI_FIFO_CTRL_TX_FIFO_USED_POS 8 +#define MXC_F_SPI_FIFO_CTRL_TX_FIFO_USED ((uint32_t)(0x0000001FUL << MXC_F_SPI_FIFO_CTRL_TX_FIFO_USED_POS)) +#define MXC_F_SPI_FIFO_CTRL_RX_FIFO_AF_LVL_POS 16 +#define MXC_F_SPI_FIFO_CTRL_RX_FIFO_AF_LVL ((uint32_t)(0x0000001FUL << MXC_F_SPI_FIFO_CTRL_RX_FIFO_AF_LVL_POS)) +#define MXC_F_SPI_FIFO_CTRL_RX_FIFO_USED_POS 24 +#define MXC_F_SPI_FIFO_CTRL_RX_FIFO_USED ((uint32_t)(0x0000003FUL << MXC_F_SPI_FIFO_CTRL_RX_FIFO_USED_POS)) + +#define MXC_F_SPI_SPCL_CTRL_SS_SAMPLE_MODE_POS 0 +#define MXC_F_SPI_SPCL_CTRL_SS_SAMPLE_MODE ((uint32_t)(0x00000001UL << MXC_F_SPI_SPCL_CTRL_SS_SAMPLE_MODE_POS)) +#define MXC_F_SPI_SPCL_CTRL_MISO_FC_EN_POS 1 +#define MXC_F_SPI_SPCL_CTRL_MISO_FC_EN ((uint32_t)(0x00000001UL << MXC_F_SPI_SPCL_CTRL_MISO_FC_EN_POS)) +#define MXC_F_SPI_SPCL_CTRL_SS_SA_SDIO_OUT_POS 4 +#define MXC_F_SPI_SPCL_CTRL_SS_SA_SDIO_OUT ((uint32_t)(0x0000000FUL << MXC_F_SPI_SPCL_CTRL_SS_SA_SDIO_OUT_POS)) +#define MXC_F_SPI_SPCL_CTRL_SS_SA_SDIO_DR_EN_POS 8 +#define MXC_F_SPI_SPCL_CTRL_SS_SA_SDIO_DR_EN ((uint32_t)(0x0000000FUL << MXC_F_SPI_SPCL_CTRL_SS_SA_SDIO_DR_EN_POS)) + +#define MXC_F_SPI_INTFL_TX_STALLED_POS 0 +#define MXC_F_SPI_INTFL_TX_STALLED ((uint32_t)(0x00000001UL << MXC_F_SPI_INTFL_TX_STALLED_POS)) +#define MXC_F_SPI_INTFL_RX_STALLED_POS 1 +#define MXC_F_SPI_INTFL_RX_STALLED ((uint32_t)(0x00000001UL << MXC_F_SPI_INTFL_RX_STALLED_POS)) +#define MXC_F_SPI_INTFL_TX_READY_POS 2 +#define MXC_F_SPI_INTFL_TX_READY ((uint32_t)(0x00000001UL << MXC_F_SPI_INTFL_TX_READY_POS)) +#define MXC_F_SPI_INTFL_RX_DONE_POS 3 +#define MXC_F_SPI_INTFL_RX_DONE ((uint32_t)(0x00000001UL << MXC_F_SPI_INTFL_RX_DONE_POS)) +#define MXC_F_SPI_INTFL_TX_FIFO_AE_POS 4 +#define MXC_F_SPI_INTFL_TX_FIFO_AE ((uint32_t)(0x00000001UL << MXC_F_SPI_INTFL_TX_FIFO_AE_POS)) +#define MXC_F_SPI_INTFL_RX_FIFO_AF_POS 5 +#define MXC_F_SPI_INTFL_RX_FIFO_AF ((uint32_t)(0x00000001UL << MXC_F_SPI_INTFL_RX_FIFO_AF_POS)) + +#define MXC_F_SPI_INTEN_TX_STALLED_POS 0 +#define MXC_F_SPI_INTEN_TX_STALLED ((uint32_t)(0x00000001UL << MXC_F_SPI_INTEN_TX_STALLED_POS)) +#define MXC_F_SPI_INTEN_RX_STALLED_POS 1 +#define MXC_F_SPI_INTEN_RX_STALLED ((uint32_t)(0x00000001UL << MXC_F_SPI_INTEN_RX_STALLED_POS)) +#define MXC_F_SPI_INTEN_TX_READY_POS 2 +#define MXC_F_SPI_INTEN_TX_READY ((uint32_t)(0x00000001UL << MXC_F_SPI_INTEN_TX_READY_POS)) +#define MXC_F_SPI_INTEN_RX_DONE_POS 3 +#define MXC_F_SPI_INTEN_RX_DONE ((uint32_t)(0x00000001UL << MXC_F_SPI_INTEN_RX_DONE_POS)) +#define MXC_F_SPI_INTEN_TX_FIFO_AE_POS 4 +#define MXC_F_SPI_INTEN_TX_FIFO_AE ((uint32_t)(0x00000001UL << MXC_F_SPI_INTEN_TX_FIFO_AE_POS)) +#define MXC_F_SPI_INTEN_RX_FIFO_AF_POS 5 +#define MXC_F_SPI_INTEN_RX_FIFO_AF ((uint32_t)(0x00000001UL << MXC_F_SPI_INTEN_RX_FIFO_AF_POS)) + +#define MXC_F_SPI_FIFO_DIR_POS 0 +#define MXC_F_SPI_FIFO_DIR ((uint32_t)(0x00000003UL << MXC_F_SPI_FIFO_DIR_POS)) +#define MXC_F_SPI_FIFO_UNIT_POS 2 +#define MXC_F_SPI_FIFO_UNIT ((uint32_t)(0x00000003UL << MXC_F_SPI_FIFO_UNIT_POS)) +#define MXC_F_SPI_FIFO_SIZE_POS 4 +#define MXC_F_SPI_FIFO_SIZE ((uint32_t)(0x0000000FUL << MXC_F_SPI_FIFO_SIZE_POS)) +#define MXC_F_SPI_FIFO_WIDTH_POS 9 +#define MXC_F_SPI_FIFO_WIDTH ((uint32_t)(0x00000001UL << MXC_F_SPI_FIFO_WIDTH_POS)) +#define MXC_F_SPI_FIFO_ALT_POS 11 +#define MXC_F_SPI_FIFO_ALT ((uint32_t)(0x00000001UL << MXC_F_SPI_FIFO_ALT_POS)) +#define MXC_F_SPI_FIFO_FLOW_POS 12 +#define MXC_F_SPI_FIFO_FLOW ((uint32_t)(0x00000001UL << MXC_F_SPI_FIFO_FLOW_POS)) +#define MXC_F_SPI_FIFO_DASS_POS 13 +#define MXC_F_SPI_FIFO_DASS ((uint32_t)(0x00000001UL << MXC_F_SPI_FIFO_DASS_POS)) + +#define MXC_S_SPI_FIFO_DIR_NONE ((uint32_t)(0X00000000UL << MXC_F_SPI_FIFO_DIR_POS)) +#define MXC_S_SPI_FIFO_DIR_TX ((uint32_t)(0X00000001UL << MXC_F_SPI_FIFO_DIR_POS)) +#define MXC_S_SPI_FIFO_DIR_RX ((uint32_t)(0X00000002UL << MXC_F_SPI_FIFO_DIR_POS)) +#define MXC_S_SPI_FIFO_DIR_BOTH ((uint32_t)(0X00000003UL << MXC_F_SPI_FIFO_DIR_POS)) + +#define MXC_S_SPI_FIFO_UNIT_BITS ((uint32_t)(0X00000000UL << MXC_F_SPI_FIFO_UNIT_POS)) +#define MXC_S_SPI_FIFO_UNIT_BYTES ((uint32_t)(0X00000001UL << MXC_F_SPI_FIFO_UNIT_POS)) +#define MXC_S_SPI_FIFO_UNIT_PAGES ((uint32_t)(0X00000002UL << MXC_F_SPI_FIFO_UNIT_POS)) + +#define MXC_S_SPI_FIFO_WIDTH_SINGLE ((uint32_t)(0X00000000UL << MXC_F_SPI_FIFO_WIDTH_POS)) +#define MXC_S_SPI_FIFO_WIDTH_DUAL ((uint32_t)(0X00000001UL << MXC_F_SPI_FIFO_WIDTH_POS)) +#define MXC_S_SPI_FIFO_WIDTH_QUAD ((uint32_t)(0X00000002UL << MXC_F_SPI_FIFO_WIDTH_POS)) + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_SPI_REGS_H_ */ diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/spib_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/spib_regs.h new file mode 100644 index 0000000000..3236a85c44 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/spib_regs.h @@ -0,0 +1,238 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_SPIB_REGS_H_ +#define _MXC_SPIB_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t master_cfg; /* 0x0000 SPIB Master Configuration */ + __IO uint32_t oob_ctrl; /* 0x0004 SPIB OOB Control */ + __IO uint32_t intfl; /* 0x0008 SPIB Interrupt Flags */ + __IO uint32_t inten; /* 0x000C SPIB Interrupt Enables */ + __IO uint32_t slave_reg; /* 0x0010 SPIB Slave Register Access */ +} mxc_spib_regs_t; + + +/* + Register offsets for module SPIB. +*/ + +#define MXC_R_SPIB_OFFS_MASTER_CFG ((uint32_t)0x00000000UL) +#define MXC_R_SPIB_OFFS_OOB_CTRL ((uint32_t)0x00000004UL) +#define MXC_R_SPIB_OFFS_INTFL ((uint32_t)0x00000008UL) +#define MXC_R_SPIB_OFFS_INTEN ((uint32_t)0x0000000CUL) +#define MXC_R_SPIB_OFFS_SLAVE_REG ((uint32_t)0x00000010UL) + + +/* + Field positions and masks for module SPIB. +*/ + +#define MXC_F_SPIB_MASTER_CFG_SPI_MODE_POS 0 +#define MXC_F_SPIB_MASTER_CFG_SPI_MODE ((uint32_t)(0x00000003UL << MXC_F_SPIB_MASTER_CFG_SPI_MODE_POS)) +#define MXC_F_SPIB_MASTER_CFG_SPI_WIDTH_POS 2 +#define MXC_F_SPIB_MASTER_CFG_SPI_WIDTH ((uint32_t)(0x00000003UL << MXC_F_SPIB_MASTER_CFG_SPI_WIDTH_POS)) +#define MXC_F_SPIB_MASTER_CFG_SCK_HI_CLK_POS 8 +#define MXC_F_SPIB_MASTER_CFG_SCK_HI_CLK ((uint32_t)(0x0000000FUL << MXC_F_SPIB_MASTER_CFG_SCK_HI_CLK_POS)) +#define MXC_F_SPIB_MASTER_CFG_SCK_LO_CLK_POS 12 +#define MXC_F_SPIB_MASTER_CFG_SCK_LO_CLK ((uint32_t)(0x0000000FUL << MXC_F_SPIB_MASTER_CFG_SCK_LO_CLK_POS)) +#define MXC_F_SPIB_MASTER_CFG_ACT_DELAY_POS 16 +#define MXC_F_SPIB_MASTER_CFG_ACT_DELAY ((uint32_t)(0x00000003UL << MXC_F_SPIB_MASTER_CFG_ACT_DELAY_POS)) +#define MXC_F_SPIB_MASTER_CFG_INACT_DELAY_POS 18 +#define MXC_F_SPIB_MASTER_CFG_INACT_DELAY ((uint32_t)(0x00000003UL << MXC_F_SPIB_MASTER_CFG_INACT_DELAY_POS)) + +#define MXC_F_SPIB_OOB_CTRL_MONITOR_SLAVE_INT0_POS 0 +#define MXC_F_SPIB_OOB_CTRL_MONITOR_SLAVE_INT0 ((uint32_t)(0x00000001UL << MXC_F_SPIB_OOB_CTRL_MONITOR_SLAVE_INT0_POS)) +#define MXC_F_SPIB_OOB_CTRL_MONITOR_SLAVE_INT1_POS 1 +#define MXC_F_SPIB_OOB_CTRL_MONITOR_SLAVE_INT1 ((uint32_t)(0x00000001UL << MXC_F_SPIB_OOB_CTRL_MONITOR_SLAVE_INT1_POS)) +#define MXC_F_SPIB_OOB_CTRL_MONITOR_SLAVE_INT2_POS 2 +#define MXC_F_SPIB_OOB_CTRL_MONITOR_SLAVE_INT2 ((uint32_t)(0x00000001UL << MXC_F_SPIB_OOB_CTRL_MONITOR_SLAVE_INT2_POS)) + +#define MXC_F_SPIB_INTFL_SLAVE_INT0_SYS_INT_POS 0 +#define MXC_F_SPIB_INTFL_SLAVE_INT0_SYS_INT ((uint32_t)(0x00000001UL << MXC_F_SPIB_INTFL_SLAVE_INT0_SYS_INT_POS)) +#define MXC_F_SPIB_INTFL_SLAVE_INT1_SYS_RST_POS 1 +#define MXC_F_SPIB_INTFL_SLAVE_INT1_SYS_RST ((uint32_t)(0x00000001UL << MXC_F_SPIB_INTFL_SLAVE_INT1_SYS_RST_POS)) +#define MXC_F_SPIB_INTFL_SLAVE_INT2_BAD_AHB_RESP_POS 2 +#define MXC_F_SPIB_INTFL_SLAVE_INT2_BAD_AHB_RESP ((uint32_t)(0x00000001UL << MXC_F_SPIB_INTFL_SLAVE_INT2_BAD_AHB_RESP_POS)) + +#define MXC_F_SPIB_INTEN_SLAVE_INT0_SYS_INT_POS 0 +#define MXC_F_SPIB_INTEN_SLAVE_INT0_SYS_INT ((uint32_t)(0x00000001UL << MXC_F_SPIB_INTEN_SLAVE_INT0_SYS_INT_POS)) +#define MXC_F_SPIB_INTEN_SLAVE_INT1_SYS_RST_POS 1 +#define MXC_F_SPIB_INTEN_SLAVE_INT1_SYS_RST ((uint32_t)(0x00000001UL << MXC_F_SPIB_INTEN_SLAVE_INT1_SYS_RST_POS)) +#define MXC_F_SPIB_INTEN_SLAVE_INT2_BAD_AHB_RESP_POS 2 +#define MXC_F_SPIB_INTEN_SLAVE_INT2_BAD_AHB_RESP ((uint32_t)(0x00000001UL << MXC_F_SPIB_INTEN_SLAVE_INT2_BAD_AHB_RESP_POS)) + +#define MXC_F_SPIB_SLAVE_REG_ENABLE_SLAVE_REG_ACCESS_POS 0 +#define MXC_F_SPIB_SLAVE_REG_ENABLE_SLAVE_REG_ACCESS ((uint32_t)(0x00000001UL << MXC_F_SPIB_SLAVE_REG_ENABLE_SLAVE_REG_ACCESS_POS)) +#define MXC_F_SPIB_SLAVE_REG_START_ACCESS_CYCLE_POS 1 +#define MXC_F_SPIB_SLAVE_REG_START_ACCESS_CYCLE ((uint32_t)(0x00000001UL << MXC_F_SPIB_SLAVE_REG_START_ACCESS_CYCLE_POS)) +#define MXC_F_SPIB_SLAVE_REG_ACCESS_TYPE_POS 2 +#define MXC_F_SPIB_SLAVE_REG_ACCESS_TYPE ((uint32_t)(0x00000001UL << MXC_F_SPIB_SLAVE_REG_ACCESS_TYPE_POS)) +#define MXC_F_SPIB_SLAVE_REG_SLAVE_REG_WRITE_DATA_POS 8 +#define MXC_F_SPIB_SLAVE_REG_SLAVE_REG_WRITE_DATA ((uint32_t)(0x000000FFUL << MXC_F_SPIB_SLAVE_REG_SLAVE_REG_WRITE_DATA_POS)) +#define MXC_F_SPIB_SLAVE_REG_SLAVE_REG_READ_DATA_POS 16 +#define MXC_F_SPIB_SLAVE_REG_SLAVE_REG_READ_DATA ((uint32_t)(0x000000FFUL << MXC_F_SPIB_SLAVE_REG_SLAVE_REG_READ_DATA_POS)) + + + +/* + Field values and shifted values for module SPIB. +*/ + +#define MXC_V_SPIB_MASTER_CFG_SPI_MODE_SCK_HI_SAMPLE_RISING ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIB_MASTER_CFG_SPI_MODE_SCK_LO_SAMPLE_FALLING ((uint32_t)(0x00000003UL)) + +#define MXC_S_SPIB_MASTER_CFG_SPI_MODE_SCK_HI_SAMPLE_RISING ((uint32_t)(MXC_V_SPIB_MASTER_CFG_SPI_MODE_SCK_HI_SAMPLE_RISING << MXC_F_SPIB_MASTER_CFG_SPI_MODE_POS)) +#define MXC_S_SPIB_MASTER_CFG_SPI_MODE_SCK_LO_SAMPLE_FALLING ((uint32_t)(MXC_V_SPIB_MASTER_CFG_SPI_MODE_SCK_LO_SAMPLE_FALLING << MXC_F_SPIB_MASTER_CFG_SPI_MODE_POS)) + +#define MXC_V_SPIB_MASTER_CFG_SPI_WIDTH_ACTIVE_HIGH ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIB_MASTER_CFG_SPI_WIDTH_ACTIVE_LOW ((uint32_t)(0x00000001UL)) + +#define MXC_S_SPIB_MASTER_CFG_SPI_WIDTH_ACTIVE_HIGH ((uint32_t)(MXC_V_SPIB_MASTER_CFG_SPI_WIDTH_ACTIVE_HIGH << MXC_F_SPIB_MASTER_CFG_SPI_WIDTH_POS)) +#define MXC_S_SPIB_MASTER_CFG_SPI_WIDTH_ACTIVE_LOW ((uint32_t)(MXC_V_SPIB_MASTER_CFG_SPI_WIDTH_ACTIVE_LOW << MXC_F_SPIB_MASTER_CFG_SPI_WIDTH_POS)) + +#define MXC_V_SPIB_MASTER_CFG_ACT_DELAY_OFF ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIB_MASTER_CFG_ACT_DELAY_FOR_2_MOD_CLK ((uint32_t)(0x00000001UL)) +#define MXC_V_SPIB_MASTER_CFG_ACT_DELAY_FOR_4_MOD_CLK ((uint32_t)(0x00000002UL)) +#define MXC_V_SPIB_MASTER_CFG_ACT_DELAY_FOR_8_MOD_CLK ((uint32_t)(0x00000003UL)) + +#define MXC_S_SPIB_MASTER_CFG_ACT_DELAY_OFF ((uint32_t)(MXC_V_SPIB_MASTER_CFG_ACT_DELAY_OFF << MXC_F_SPIB_MASTER_CFG_ACT_DELAY_POS)) +#define MXC_S_SPIB_MASTER_CFG_ACT_DELAY_FOR_2_MOD_CLK ((uint32_t)(MXC_V_SPIB_MASTER_CFG_ACT_DELAY_FOR_2_MOD_CLK << MXC_F_SPIB_MASTER_CFG_ACT_DELAY_POS)) +#define MXC_S_SPIB_MASTER_CFG_ACT_DELAY_FOR_4_MOD_CLK ((uint32_t)(MXC_V_SPIB_MASTER_CFG_ACT_DELAY_FOR_4_MOD_CLK << MXC_F_SPIB_MASTER_CFG_ACT_DELAY_POS)) +#define MXC_S_SPIB_MASTER_CFG_ACT_DELAY_FOR_8_MOD_CLK ((uint32_t)(MXC_V_SPIB_MASTER_CFG_ACT_DELAY_FOR_8_MOD_CLK << MXC_F_SPIB_MASTER_CFG_ACT_DELAY_POS)) + +#define MXC_V_SPIB_MASTER_CFG_INACT_DELAY_OFF ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIB_MASTER_CFG_INACT_DELAY_FOR_2_MOD_CLK ((uint32_t)(0x00000001UL)) +#define MXC_V_SPIB_MASTER_CFG_INACT_DELAY_FOR_4_MOD_CLK ((uint32_t)(0x00000002UL)) +#define MXC_V_SPIB_MASTER_CFG_INACT_DELAY_FOR_8_MOD_CLK ((uint32_t)(0x00000003UL)) + +#define MXC_S_SPIB_MASTER_CFG_INACT_DELAY_OFF ((uint32_t)(MXC_V_SPIB_MASTER_CFG_INACT_DELAY_OFF << MXC_F_SPIB_MASTER_CFG_INACT_DELAY_POS)) +#define MXC_S_SPIB_MASTER_CFG_INACT_DELAY_FOR_2_MOD_CLK ((uint32_t)(MXC_V_SPIB_MASTER_CFG_INACT_DELAY_FOR_2_MOD_CLK << MXC_F_SPIB_MASTER_CFG_INACT_DELAY_POS)) +#define MXC_S_SPIB_MASTER_CFG_INACT_DELAY_FOR_4_MOD_CLK ((uint32_t)(MXC_V_SPIB_MASTER_CFG_INACT_DELAY_FOR_4_MOD_CLK << MXC_F_SPIB_MASTER_CFG_INACT_DELAY_POS)) +#define MXC_S_SPIB_MASTER_CFG_INACT_DELAY_FOR_8_MOD_CLK ((uint32_t)(MXC_V_SPIB_MASTER_CFG_INACT_DELAY_FOR_8_MOD_CLK << MXC_F_SPIB_MASTER_CFG_INACT_DELAY_POS)) + +#define MXC_V_SPIB_OOB_CTRL_MONITOR_SLAVE_INT0_DISABLED ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIB_OOB_CTRL_MONITOR_SLAVE_INT0_ENABLED ((uint32_t)(0x00000001UL)) + +#define MXC_S_SPIB_OOB_CTRL_MONITOR_SLAVE_INT0_DISABLED ((uint32_t)(MXC_V_SPIB_OOB_CTRL_MONITOR_SLAVE_INT0_DISABLED << MXC_F_SPIB_OOB_CTRL_MONITOR_SLAVE_INT0_POS)) +#define MXC_S_SPIB_OOB_CTRL_MONITOR_SLAVE_INT0_ENABLED ((uint32_t)(MXC_V_SPIB_OOB_CTRL_MONITOR_SLAVE_INT0_ENABLED << MXC_F_SPIB_OOB_CTRL_MONITOR_SLAVE_INT0_POS)) + +#define MXC_V_SPIB_OOB_CTRL_MONITOR_SLAVE_INT1_DISABLED ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIB_OOB_CTRL_MONITOR_SLAVE_INT1_ENABLED ((uint32_t)(0x00000001UL)) + +#define MXC_S_SPIB_OOB_CTRL_MONITOR_SLAVE_INT1_DISABLED ((uint32_t)(MXC_V_SPIB_OOB_CTRL_MONITOR_SLAVE_INT1_DISABLED << MXC_F_SPIB_OOB_CTRL_MONITOR_SLAVE_INT1_POS)) +#define MXC_S_SPIB_OOB_CTRL_MONITOR_SLAVE_INT1_ENABLED ((uint32_t)(MXC_V_SPIB_OOB_CTRL_MONITOR_SLAVE_INT1_ENABLED << MXC_F_SPIB_OOB_CTRL_MONITOR_SLAVE_INT1_POS)) + +#define MXC_V_SPIB_OOB_CTRL_MONITOR_SLAVE_INT2_DISABLED ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIB_OOB_CTRL_MONITOR_SLAVE_INT2_ENABLED ((uint32_t)(0x00000001UL)) + +#define MXC_S_SPIB_OOB_CTRL_MONITOR_SLAVE_INT2_DISABLED ((uint32_t)(MXC_V_SPIB_OOB_CTRL_MONITOR_SLAVE_INT2_DISABLED << MXC_F_SPIB_OOB_CTRL_MONITOR_SLAVE_INT2_POS)) +#define MXC_S_SPIB_OOB_CTRL_MONITOR_SLAVE_INT2_ENABLED ((uint32_t)(MXC_V_SPIB_OOB_CTRL_MONITOR_SLAVE_INT2_ENABLED << MXC_F_SPIB_OOB_CTRL_MONITOR_SLAVE_INT2_POS)) + +#define MXC_V_SPIB_INTFL_SLAVE_INT0_SYS_INT_NONE ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIB_INTFL_SLAVE_INT0_SYS_INT_DETECTED ((uint32_t)(0x00000001UL)) + +#define MXC_S_SPIB_INTFL_SLAVE_INT0_SYS_INT_NONE ((uint32_t)(MXC_V_SPIB_INTFL_SLAVE_INT0_SYS_INT_NONE << MXC_F_SPIB_INTFL_SLAVE_INT0_SYS_INT_POS)) +#define MXC_S_SPIB_INTFL_SLAVE_INT0_SYS_INT_DETECTED ((uint32_t)(MXC_V_SPIB_INTFL_SLAVE_INT0_SYS_INT_DETECTED << MXC_F_SPIB_INTFL_SLAVE_INT0_SYS_INT_POS)) + +#define MXC_V_SPIB_INTFL_SLAVE_INT1_SYS_RST_NONE ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIB_INTFL_SLAVE_INT1_SYS_RST_DETECTED ((uint32_t)(0x00000001UL)) + +#define MXC_S_SPIB_INTFL_SLAVE_INT1_SYS_RST_NONE ((uint32_t)(MXC_V_SPIB_INTFL_SLAVE_INT1_SYS_RST_NONE << MXC_F_SPIB_INTFL_SLAVE_INT1_SYS_RST_POS)) +#define MXC_S_SPIB_INTFL_SLAVE_INT1_SYS_RST_DETECTED ((uint32_t)(MXC_V_SPIB_INTFL_SLAVE_INT1_SYS_RST_DETECTED << MXC_F_SPIB_INTFL_SLAVE_INT1_SYS_RST_POS)) + +#define MXC_V_SPIB_INTFL_SLAVE_INT2_BAD_AHB_RESP_NONE ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIB_INTFL_SLAVE_INT2_BAD_AHB_RESP_DETECTED ((uint32_t)(0x00000001UL)) + +#define MXC_S_SPIB_INTFL_SLAVE_INT2_BAD_AHB_RESP_NONE ((uint32_t)(MXC_V_SPIB_INTFL_SLAVE_INT2_BAD_AHB_RESP_NONE << MXC_F_SPIB_INTFL_SLAVE_INT2_BAD_AHB_RESP_POS)) +#define MXC_S_SPIB_INTFL_SLAVE_INT2_BAD_AHB_RESP_DETECTED ((uint32_t)(MXC_V_SPIB_INTFL_SLAVE_INT2_BAD_AHB_RESP_DETECTED << MXC_F_SPIB_INTFL_SLAVE_INT2_BAD_AHB_RESP_POS)) + +#define MXC_V_SPIB_INTEN_SLAVE_INT0_SYS_INT_DISABLED ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIB_INTEN_SLAVE_INT0_SYS_INT_ENABLED ((uint32_t)(0x00000001UL)) + +#define MXC_S_SPIB_INTEN_SLAVE_INT0_SYS_INT_DISABLED ((uint32_t)(MXC_V_SPIB_INTEN_SLAVE_INT0_SYS_INT_DISABLED << MXC_F_SPIB_INTEN_SLAVE_INT0_SYS_INT_POS)) +#define MXC_S_SPIB_INTEN_SLAVE_INT0_SYS_INT_ENABLED ((uint32_t)(MXC_V_SPIB_INTEN_SLAVE_INT0_SYS_INT_ENABLED << MXC_F_SPIB_INTEN_SLAVE_INT0_SYS_INT_POS)) + +#define MXC_V_SPIB_INTEN_SLAVE_INT1_SYS_RST_DISABLED ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIB_INTEN_SLAVE_INT1_SYS_RST_ENABLED ((uint32_t)(0x00000001UL)) + +#define MXC_S_SPIB_INTEN_SLAVE_INT1_SYS_RST_DISABLED ((uint32_t)(MXC_V_SPIB_INTEN_SLAVE_INT1_SYS_RST_DISABLED << MXC_F_SPIB_INTEN_SLAVE_INT1_SYS_RST_POS)) +#define MXC_S_SPIB_INTEN_SLAVE_INT1_SYS_RST_ENABLED ((uint32_t)(MXC_V_SPIB_INTEN_SLAVE_INT1_SYS_RST_ENABLED << MXC_F_SPIB_INTEN_SLAVE_INT1_SYS_RST_POS)) + +#define MXC_V_SPIB_INTEN_SLAVE_INT2_BAD_AHB_RESP_DISABLED ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIB_INTEN_SLAVE_INT2_BAD_AHB_RESP_ENABLED ((uint32_t)(0x00000001UL)) + +#define MXC_S_SPIB_INTEN_SLAVE_INT2_BAD_AHB_RESP_DISABLED ((uint32_t)(MXC_V_SPIB_INTEN_SLAVE_INT2_BAD_AHB_RESP_DISABLED << MXC_F_SPIB_INTEN_SLAVE_INT2_BAD_AHB_RESP_POS)) +#define MXC_S_SPIB_INTEN_SLAVE_INT2_BAD_AHB_RESP_ENABLED ((uint32_t)(MXC_V_SPIB_INTEN_SLAVE_INT2_BAD_AHB_RESP_ENABLED << MXC_F_SPIB_INTEN_SLAVE_INT2_BAD_AHB_RESP_POS)) + +#define MXC_V_SPIB_SLAVE_REG_ACCESS_TYPE_READ ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIB_SLAVE_REG_ACCESS_TYPE_WRITE ((uint32_t)(0x00000001UL)) + +#define MXC_S_SPIB_SLAVE_REG_ACCESS_TYPE_READ ((uint32_t)(MXC_V_SPIB_SLAVE_REG_ACCESS_TYPE_READ << MXC_F_SPIB_SLAVE_REG_ACCESS_TYPE_POS)) +#define MXC_S_SPIB_SLAVE_REG_ACCESS_TYPE_WRITE ((uint32_t)(MXC_V_SPIB_SLAVE_REG_ACCESS_TYPE_WRITE << MXC_F_SPIB_SLAVE_REG_ACCESS_TYPE_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_SPIB_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/spix_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/spix_regs.h new file mode 100644 index 0000000000..2d79ebd496 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/spix_regs.h @@ -0,0 +1,201 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_SPIX_REGS_H_ +#define _MXC_SPIX_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t master_cfg; /* 0x0000 SPIX Master Configuration */ + __IO uint32_t fetch_ctrl; /* 0x0004 SPIX Fetch Control */ + __IO uint32_t mode_ctrl; /* 0x0008 SPIX Mode Control */ + __IO uint32_t mode_data; /* 0x000C SPIX Mode Data */ +} mxc_spix_regs_t; + + +/* + Register offsets for module SPIX. +*/ + +#define MXC_R_SPIX_OFFS_MASTER_CFG ((uint32_t)0x00000000UL) +#define MXC_R_SPIX_OFFS_FETCH_CTRL ((uint32_t)0x00000004UL) +#define MXC_R_SPIX_OFFS_MODE_CTRL ((uint32_t)0x00000008UL) +#define MXC_R_SPIX_OFFS_MODE_DATA ((uint32_t)0x0000000CUL) + + +/* + Field positions and masks for module SPIX. +*/ + +#define MXC_F_SPIX_MASTER_CFG_SPI_MODE_POS 0 +#define MXC_F_SPIX_MASTER_CFG_SPI_MODE ((uint32_t)(0x00000003UL << MXC_F_SPIX_MASTER_CFG_SPI_MODE_POS)) +#define MXC_F_SPIX_MASTER_CFG_SS_ACT_LO_POS 2 +#define MXC_F_SPIX_MASTER_CFG_SS_ACT_LO ((uint32_t)(0x00000001UL << MXC_F_SPIX_MASTER_CFG_SS_ACT_LO_POS)) +#define MXC_F_SPIX_MASTER_CFG_ALT_TIMING_EN_POS 3 +#define MXC_F_SPIX_MASTER_CFG_ALT_TIMING_EN ((uint32_t)(0x00000001UL << MXC_F_SPIX_MASTER_CFG_ALT_TIMING_EN_POS)) +#define MXC_F_SPIX_MASTER_CFG_SLAVE_SEL_POS 4 +#define MXC_F_SPIX_MASTER_CFG_SLAVE_SEL ((uint32_t)(0x00000007UL << MXC_F_SPIX_MASTER_CFG_SLAVE_SEL_POS)) +#define MXC_F_SPIX_MASTER_CFG_SCK_HI_CLK_POS 8 +#define MXC_F_SPIX_MASTER_CFG_SCK_HI_CLK ((uint32_t)(0x0000000FUL << MXC_F_SPIX_MASTER_CFG_SCK_HI_CLK_POS)) +#define MXC_F_SPIX_MASTER_CFG_SCK_LO_CLK_POS 12 +#define MXC_F_SPIX_MASTER_CFG_SCK_LO_CLK ((uint32_t)(0x0000000FUL << MXC_F_SPIX_MASTER_CFG_SCK_LO_CLK_POS)) +#define MXC_F_SPIX_MASTER_CFG_ACT_DELAY_POS 16 +#define MXC_F_SPIX_MASTER_CFG_ACT_DELAY ((uint32_t)(0x00000003UL << MXC_F_SPIX_MASTER_CFG_ACT_DELAY_POS)) +#define MXC_F_SPIX_MASTER_CFG_INACT_DELAY_POS 18 +#define MXC_F_SPIX_MASTER_CFG_INACT_DELAY ((uint32_t)(0x00000003UL << MXC_F_SPIX_MASTER_CFG_INACT_DELAY_POS)) +#define MXC_F_SPIX_MASTER_CFG_ALT_SCK_HI_CLK_POS 20 +#define MXC_F_SPIX_MASTER_CFG_ALT_SCK_HI_CLK ((uint32_t)(0x0000000FUL << MXC_F_SPIX_MASTER_CFG_ALT_SCK_HI_CLK_POS)) +#define MXC_F_SPIX_MASTER_CFG_ALT_SCK_LO_CLK_POS 24 +#define MXC_F_SPIX_MASTER_CFG_ALT_SCK_LO_CLK ((uint32_t)(0x0000000FUL << MXC_F_SPIX_MASTER_CFG_ALT_SCK_LO_CLK_POS)) + +#define MXC_F_SPIX_FETCH_CTRL_CMD_VALUE_POS 0 +#define MXC_F_SPIX_FETCH_CTRL_CMD_VALUE ((uint32_t)(0x000000FFUL << MXC_F_SPIX_FETCH_CTRL_CMD_VALUE_POS)) +#define MXC_F_SPIX_FETCH_CTRL_CMD_WIDTH_POS 8 +#define MXC_F_SPIX_FETCH_CTRL_CMD_WIDTH ((uint32_t)(0x00000003UL << MXC_F_SPIX_FETCH_CTRL_CMD_WIDTH_POS)) +#define MXC_F_SPIX_FETCH_CTRL_ADDR_WIDTH_POS 10 +#define MXC_F_SPIX_FETCH_CTRL_ADDR_WIDTH ((uint32_t)(0x00000003UL << MXC_F_SPIX_FETCH_CTRL_ADDR_WIDTH_POS)) +#define MXC_F_SPIX_FETCH_CTRL_DATA_WIDTH_POS 12 +#define MXC_F_SPIX_FETCH_CTRL_DATA_WIDTH ((uint32_t)(0x00000003UL << MXC_F_SPIX_FETCH_CTRL_DATA_WIDTH_POS)) + +#define MXC_F_SPIX_MODE_CTRL_MODE_CLOCKS_POS 0 +#define MXC_F_SPIX_MODE_CTRL_MODE_CLOCKS ((uint32_t)(0x0000000FUL << MXC_F_SPIX_MODE_CTRL_MODE_CLOCKS_POS)) +#define MXC_F_SPIX_MODE_CTRL_NO_CMD_MODE_POS 8 +#define MXC_F_SPIX_MODE_CTRL_NO_CMD_MODE ((uint32_t)(0x00000001UL << MXC_F_SPIX_MODE_CTRL_NO_CMD_MODE_POS)) + +#define MXC_F_SPIX_MODE_DATA_MODE_DATA_BITS_POS 0 +#define MXC_F_SPIX_MODE_DATA_MODE_DATA_BITS ((uint32_t)(0x0000FFFFUL << MXC_F_SPIX_MODE_DATA_MODE_DATA_BITS_POS)) +#define MXC_F_SPIX_MODE_DATA_MODE_DATA_OE_POS 16 +#define MXC_F_SPIX_MODE_DATA_MODE_DATA_OE ((uint32_t)(0x0000FFFFUL << MXC_F_SPIX_MODE_DATA_MODE_DATA_OE_POS)) + + + +/* + Field values and shifted values for module SPIX. +*/ + +#define MXC_V_SPIX_MASTER_CFG_SPI_MODE_SCK_HI_SAMPLE_RISING ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIX_MASTER_CFG_SPI_MODE_SCK_LO_SAMPLE_FALLING ((uint32_t)(0x00000003UL)) + +#define MXC_S_SPIX_MASTER_CFG_SPI_MODE_SCK_HI_SAMPLE_RISING ((uint32_t)(MXC_V_SPIX_MASTER_CFG_SPI_MODE_SCK_HI_SAMPLE_RISING << MXC_F_SPIX_MASTER_CFG_SPI_MODE_POS)) +#define MXC_S_SPIX_MASTER_CFG_SPI_MODE_SCK_LO_SAMPLE_FALLING ((uint32_t)(MXC_V_SPIX_MASTER_CFG_SPI_MODE_SCK_LO_SAMPLE_FALLING << MXC_F_SPIX_MASTER_CFG_SPI_MODE_POS)) + +#define MXC_V_SPIX_MASTER_CFG_SS_ACT_LO_ACTIVE_HIGH ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIX_MASTER_CFG_SS_ACT_LO_ACTIVE_LOW ((uint32_t)(0x00000001UL)) + +#define MXC_S_SPIX_MASTER_CFG_SS_ACT_LO_ACTIVE_HIGH ((uint32_t)(MXC_V_SPIX_MASTER_CFG_SS_ACT_LO_ACTIVE_HIGH << MXC_F_SPIX_MASTER_CFG_SS_ACT_LO_POS)) +#define MXC_S_SPIX_MASTER_CFG_SS_ACT_LO_ACTIVE_LOW ((uint32_t)(MXC_V_SPIX_MASTER_CFG_SS_ACT_LO_ACTIVE_LOW << MXC_F_SPIX_MASTER_CFG_SS_ACT_LO_POS)) + +#define MXC_V_SPIX_MASTER_CFG_ALT_TIMING_EN_DISABLED ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIX_MASTER_CFG_ALT_TIMING_EN_ENABLED_AS_NEEDED ((uint32_t)(0x00000001UL)) + +#define MXC_S_SPIX_MASTER_CFG_ALT_TIMING_EN_DISABLED ((uint32_t)(MXC_V_SPIX_MASTER_CFG_ALT_TIMING_EN_DISABLED << MXC_F_SPIX_MASTER_CFG_ALT_TIMING_EN_POS)) +#define MXC_S_SPIX_MASTER_CFG_ALT_TIMING_EN_ENABLED_AS_NEEDED ((uint32_t)(MXC_V_SPIX_MASTER_CFG_ALT_TIMING_EN_ENABLED_AS_NEEDED << MXC_F_SPIX_MASTER_CFG_ALT_TIMING_EN_POS)) + +#define MXC_V_SPIX_MASTER_CFG_ACT_DELAY_OFF ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIX_MASTER_CFG_ACT_DELAY_FOR_2_MOD_CLK ((uint32_t)(0x00000001UL)) +#define MXC_V_SPIX_MASTER_CFG_ACT_DELAY_FOR_4_MOD_CLK ((uint32_t)(0x00000002UL)) +#define MXC_V_SPIX_MASTER_CFG_ACT_DELAY_FOR_8_MOD_CLK ((uint32_t)(0x00000003UL)) + +#define MXC_S_SPIX_MASTER_CFG_ACT_DELAY_OFF ((uint32_t)(MXC_V_SPIX_MASTER_CFG_ACT_DELAY_OFF << MXC_F_SPIX_MASTER_CFG_ACT_DELAY_POS)) +#define MXC_S_SPIX_MASTER_CFG_ACT_DELAY_FOR_2_MOD_CLK ((uint32_t)(MXC_V_SPIX_MASTER_CFG_ACT_DELAY_FOR_2_MOD_CLK << MXC_F_SPIX_MASTER_CFG_ACT_DELAY_POS)) +#define MXC_S_SPIX_MASTER_CFG_ACT_DELAY_FOR_4_MOD_CLK ((uint32_t)(MXC_V_SPIX_MASTER_CFG_ACT_DELAY_FOR_4_MOD_CLK << MXC_F_SPIX_MASTER_CFG_ACT_DELAY_POS)) +#define MXC_S_SPIX_MASTER_CFG_ACT_DELAY_FOR_8_MOD_CLK ((uint32_t)(MXC_V_SPIX_MASTER_CFG_ACT_DELAY_FOR_8_MOD_CLK << MXC_F_SPIX_MASTER_CFG_ACT_DELAY_POS)) + +#define MXC_V_SPIX_MASTER_CFG_INACT_DELAY_OFF ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIX_MASTER_CFG_INACT_DELAY_FOR_2_MOD_CLK ((uint32_t)(0x00000001UL)) +#define MXC_V_SPIX_MASTER_CFG_INACT_DELAY_FOR_4_MOD_CLK ((uint32_t)(0x00000002UL)) +#define MXC_V_SPIX_MASTER_CFG_INACT_DELAY_FOR_8_MOD_CLK ((uint32_t)(0x00000003UL)) + +#define MXC_S_SPIX_MASTER_CFG_INACT_DELAY_OFF ((uint32_t)(MXC_V_SPIX_MASTER_CFG_INACT_DELAY_OFF << MXC_F_SPIX_MASTER_CFG_INACT_DELAY_POS)) +#define MXC_S_SPIX_MASTER_CFG_INACT_DELAY_FOR_2_MOD_CLK ((uint32_t)(MXC_V_SPIX_MASTER_CFG_INACT_DELAY_FOR_2_MOD_CLK << MXC_F_SPIX_MASTER_CFG_INACT_DELAY_POS)) +#define MXC_S_SPIX_MASTER_CFG_INACT_DELAY_FOR_4_MOD_CLK ((uint32_t)(MXC_V_SPIX_MASTER_CFG_INACT_DELAY_FOR_4_MOD_CLK << MXC_F_SPIX_MASTER_CFG_INACT_DELAY_POS)) +#define MXC_S_SPIX_MASTER_CFG_INACT_DELAY_FOR_8_MOD_CLK ((uint32_t)(MXC_V_SPIX_MASTER_CFG_INACT_DELAY_FOR_8_MOD_CLK << MXC_F_SPIX_MASTER_CFG_INACT_DELAY_POS)) + +#define MXC_V_SPIX_FETCH_CTRL_CMD_WIDTH_SINGLE ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIX_FETCH_CTRL_CMD_WIDTH_DUAL_IO ((uint32_t)(0x00000001UL)) +#define MXC_V_SPIX_FETCH_CTRL_CMD_WIDTH_QUAD_IO ((uint32_t)(0x00000002UL)) + +#define MXC_S_SPIX_FETCH_CTRL_CMD_WIDTH_SINGLE ((uint32_t)(MXC_V_SPIX_FETCH_CTRL_CMD_WIDTH_SINGLE << MXC_F_SPIX_FETCH_CTRL_CMD_WIDTH_POS)) +#define MXC_S_SPIX_FETCH_CTRL_CMD_WIDTH_DUAL_IO ((uint32_t)(MXC_V_SPIX_FETCH_CTRL_CMD_WIDTH_DUAL_IO << MXC_F_SPIX_FETCH_CTRL_CMD_WIDTH_POS)) +#define MXC_S_SPIX_FETCH_CTRL_CMD_WIDTH_QUAD_IO ((uint32_t)(MXC_V_SPIX_FETCH_CTRL_CMD_WIDTH_QUAD_IO << MXC_F_SPIX_FETCH_CTRL_CMD_WIDTH_POS)) + +#define MXC_V_SPIX_FETCH_CTRL_ADDR_WIDTH_SINGLE ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIX_FETCH_CTRL_ADDR_WIDTH_DUAL_IO ((uint32_t)(0x00000001UL)) +#define MXC_V_SPIX_FETCH_CTRL_ADDR_WIDTH_QUAD_IO ((uint32_t)(0x00000002UL)) + +#define MXC_S_SPIX_FETCH_CTRL_ADDR_WIDTH_SINGLE ((uint32_t)(MXC_V_SPIX_FETCH_CTRL_ADDR_WIDTH_SINGLE << MXC_F_SPIX_FETCH_CTRL_ADDR_WIDTH_POS)) +#define MXC_S_SPIX_FETCH_CTRL_ADDR_WIDTH_DUAL_IO ((uint32_t)(MXC_V_SPIX_FETCH_CTRL_ADDR_WIDTH_DUAL_IO << MXC_F_SPIX_FETCH_CTRL_ADDR_WIDTH_POS)) +#define MXC_S_SPIX_FETCH_CTRL_ADDR_WIDTH_QUAD_IO ((uint32_t)(MXC_V_SPIX_FETCH_CTRL_ADDR_WIDTH_QUAD_IO << MXC_F_SPIX_FETCH_CTRL_ADDR_WIDTH_POS)) + +#define MXC_V_SPIX_FETCH_CTRL_DATA_WIDTH_SINGLE ((uint32_t)(0x00000000UL)) +#define MXC_V_SPIX_FETCH_CTRL_DATA_WIDTH_DUAL_IO ((uint32_t)(0x00000001UL)) +#define MXC_V_SPIX_FETCH_CTRL_DATA_WIDTH_QUAD_IO ((uint32_t)(0x00000002UL)) + +#define MXC_S_SPIX_FETCH_CTRL_DATA_WIDTH_SINGLE ((uint32_t)(MXC_V_SPIX_FETCH_CTRL_DATA_WIDTH_SINGLE << MXC_F_SPIX_FETCH_CTRL_DATA_WIDTH_POS)) +#define MXC_S_SPIX_FETCH_CTRL_DATA_WIDTH_DUAL_IO ((uint32_t)(MXC_V_SPIX_FETCH_CTRL_DATA_WIDTH_DUAL_IO << MXC_F_SPIX_FETCH_CTRL_DATA_WIDTH_POS)) +#define MXC_S_SPIX_FETCH_CTRL_DATA_WIDTH_QUAD_IO ((uint32_t)(MXC_V_SPIX_FETCH_CTRL_DATA_WIDTH_QUAD_IO << MXC_F_SPIX_FETCH_CTRL_DATA_WIDTH_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_SPIX_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/system_max32620.c b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/system_max32620.c new file mode 100644 index 0000000000..461e50d0d6 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/system_max32620.c @@ -0,0 +1,213 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include "max32620.h" +#include "clkman_regs.h" +#include "icc_regs.h" +#include "pwrseq_regs.h" +#include "pwrman_regs.h" +#include "adc_regs.h" +#include "flc_regs.h" +#include "trim_regs.h" +#include "rtc_regs.h" + +/* SCB CPACR Register Definitions */ +/* Note: Added by Maxim Integrated, as these are missing from CMSIS/Core/Include/core_cm4.h */ +#define SCB_CPACR_CP10_Pos 20 /* SCB CPACR: Coprocessor 10 Position */ +#define SCB_CPACR_CP10_Msk (0x3UL << SCB_CPACR_CP10_Pos) /* SCB CPACR: Coprocessor 10 Mask */ +#define SCB_CPACR_CP11_Pos 22 /* SCB CPACR: Coprocessor 11 Position */ +#define SCB_CPACR_CP11_Msk (0x3UL << SCB_CPACR_CP11_Pos) /* SCB CPACR: Coprocessor 11 Mask */ + +static uint8_t running; + +// NOTE: Setting the CMSIS SystemCoreClock value to the actual value it will +// be AFTER SystemInit() runs. This is required so the hal drivers will have +// the correct value when the DATA sections are initialized. +uint32_t SystemCoreClock = RO_FREQ; + +void SystemCoreClockUpdate(void) +{ + switch ((MXC_CLKMAN->clk_ctrl & MXC_F_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT) >> MXC_F_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT_POS) { + + case MXC_V_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT_96MHZ_RO_DIV_2: + default: + SystemCoreClock = RO_FREQ / 2; + break; + case MXC_V_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT_96MHZ_RO: + SystemCoreClock = RO_FREQ; + break; + } +} + +void Trim_ROAtomic(void) +{ + uint32_t trim; + + // Step 1: enable 32KHz RTC + running = MXC_PWRSEQ->reg0 & MXC_F_PWRSEQ_REG0_PWR_RTCEN_RUN; + MXC_PWRSEQ->reg0 |= MXC_F_PWRSEQ_REG0_PWR_RTCEN_RUN; + + // Step 2: enable RO calibration complete interrupt + MXC_ADC->intr = (MXC_ADC->intr & 0xFFFF) | MXC_F_ADC_INTR_RO_CAL_DONE_IE; + + // Step 3: clear RO calibration complete interrupt + MXC_ADC->intr = (MXC_ADC->intr & 0xFFFF) | MXC_F_ADC_INTR_RO_CAL_DONE_IF; + + /* Step 4: -- NO LONGER NEEDED / HANDLED BY STARTUP CODE -- */ + + /* Step 5: write initial trim to frequency calibration initial condition register */ + trim = (MXC_PWRSEQ->reg6 & MXC_F_PWRSEQ_REG6_PWR_TRIM_OSC_VREF) >> MXC_F_PWRSEQ_REG6_PWR_TRIM_OSC_VREF_POS; + MXC_ADC->ro_cal1 = (MXC_ADC->ro_cal1 & ~MXC_F_ADC_RO_CAL1_TRM_INIT) | + ((trim << MXC_F_ADC_RO_CAL1_TRM_INIT_POS) & MXC_F_ADC_RO_CAL1_TRM_INIT); + + // Step 6: load initial trim to active frequency trim register + MXC_ADC->ro_cal0 |= MXC_F_ADC_RO_CAL0_RO_CAL_LOAD; + + // Step 7: enable frequency loop to control RO trim + MXC_ADC->ro_cal0 |= MXC_F_ADC_RO_CAL0_RO_CAL_EN; + + // Step 8: run frequency calibration in atomic mode + MXC_ADC->ro_cal0 |= MXC_F_ADC_RO_CAL0_RO_CAL_ATOMIC; + + // Step 9: waiting for ro_cal_done flag + while (!(MXC_ADC->intr & MXC_F_ADC_INTR_RO_CAL_DONE_IF)); + + // Step 10: stop frequency calibration + MXC_ADC->ro_cal0 &= ~MXC_F_ADC_RO_CAL0_RO_CAL_RUN; + + // Step 11: disable RO calibration complete interrupt + MXC_ADC->intr = (MXC_ADC->intr & 0xFFFF) & ~MXC_F_ADC_INTR_RO_CAL_DONE_IE; + + // Step 12: read final frequency trim value + trim = (MXC_ADC->ro_cal0 & MXC_F_ADC_RO_CAL0_RO_TRM) >> MXC_F_ADC_RO_CAL0_RO_TRM_POS; + + /* Step 13: write final trim to RO flash trim shadow register */ + MXC_PWRSEQ->reg6 = (MXC_PWRSEQ->reg6 & ~MXC_F_PWRSEQ_REG6_PWR_TRIM_OSC_VREF) | + ((trim << MXC_F_PWRSEQ_REG6_PWR_TRIM_OSC_VREF_POS) & MXC_F_PWRSEQ_REG6_PWR_TRIM_OSC_VREF); + + // Step 14: restore RTC status + if (!running) { + MXC_PWRSEQ->reg0 &= ~MXC_F_PWRSEQ_REG0_PWR_RTCEN_RUN; + } + + // Step 15: disable frequency loop to control RO trim + MXC_ADC->ro_cal0 &= ~MXC_F_ADC_RO_CAL0_RO_CAL_EN; +} + +static void ICC_Enable(void) +{ + /* Invalidate cache and wait until ready */ + MXC_ICC->invdt_all = 1; + while (!(MXC_ICC->ctrl_stat & MXC_F_ICC_CTRL_STAT_READY)); + + /* Enable cache */ + MXC_ICC->ctrl_stat |= MXC_F_ICC_CTRL_STAT_ENABLE; + + /* Must invalidate a second time for proper use */ + MXC_ICC->invdt_all = 1; +} + +// This function to be implemented by the hal +extern void low_level_init(void); + +// Note: This is called before C run-time initialization. Do not use any initialized variables. +void SystemInit(void) +{ + ICC_Enable(); + + low_level_init(); + + // Select 96MHz ring oscillator as clock source + uint32_t reg = MXC_CLKMAN->clk_ctrl; + reg &= ~MXC_F_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT; + reg |= 1 << MXC_F_CLKMAN_CLK_CTRL_SYSTEM_SOURCE_SELECT_POS; + MXC_CLKMAN->clk_ctrl = reg; + + // Copy trim information from shadow registers into power manager registers + // NOTE: Checks have been added to prevent bad/missing trim values from being loaded + if ((MXC_FLC->ctrl & MXC_F_FLC_CTRL_INFO_BLOCK_VALID) && + (MXC_TRIM->for_pwr_reg5 != 0xffffffff) && + (MXC_TRIM->for_pwr_reg6 != 0xffffffff)) { + MXC_PWRSEQ->reg5 = MXC_TRIM->for_pwr_reg5; + MXC_PWRSEQ->reg6 = MXC_TRIM->for_pwr_reg6; + } else { + /* No valid info block, use some reasonable defaults */ + MXC_PWRSEQ->reg6 &= ~MXC_F_PWRSEQ_REG6_PWR_TRIM_OSC_VREF; + MXC_PWRSEQ->reg6 |= (0x1e0 << MXC_F_PWRSEQ_REG6_PWR_TRIM_OSC_VREF_POS); + } + + // Use ASYNC flags, and ASYNC Reset of flags to improve synchronization speed + // between RTC and ARM core. Also avoid delayed RTC interrupts after lp wake. + MXC_RTCTMR->ctrl |= (MXC_F_RTC_CTRL_USE_ASYNC_FLAGS | MXC_F_RTC_CTRL_AGGRESSIVE_RST); + + /* Clear the GPIO WUD event if not waking up from LP0 */ + /* this is necessary because WUD flops come up in undetermined state out of POR or SRST*/ + if (MXC_PWRSEQ->reg0 & MXC_F_PWRSEQ_REG0_PWR_FIRST_BOOT || !(MXC_PWRMAN->pwr_rst_ctrl & MXC_F_PWRMAN_PWR_RST_CTRL_POR)) { + /* Clear GPIO WUD event and configuration registers, globally */ + MXC_PWRSEQ->reg1 |= (MXC_F_PWRSEQ_REG1_PWR_CLR_IO_EVENT_LATCH | MXC_F_PWRSEQ_REG1_PWR_CLR_IO_CFG_LATCH); + MXC_PWRSEQ->reg1 &= ~(MXC_F_PWRSEQ_REG1_PWR_CLR_IO_EVENT_LATCH | MXC_F_PWRSEQ_REG1_PWR_CLR_IO_CFG_LATCH); + } else { + /* Unfreeze the GPIO by clearing MBUS_GATE, when returning from LP0 */ + MXC_PWRSEQ->reg1 &= ~(MXC_F_PWRSEQ_REG1_PWR_MBUS_GATE); + } + + // Turn on retention regulator + MXC_PWRSEQ->reg0 |= (MXC_F_PWRSEQ_REG0_PWR_RETREGEN_RUN | MXC_F_PWRSEQ_REG0_PWR_RETREGEN_SLP); + + // Clear all unused wakeup sources + // Beware! Do not change any flag not mentioned here, as they will gate important power sequencer signals + MXC_PWRSEQ->msk_flags &= ~(MXC_F_PWRSEQ_MSK_FLAGS_PWR_USB_PLUG_WAKEUP | + MXC_F_PWRSEQ_MSK_FLAGS_PWR_USB_REMOVE_WAKEUP); + + // RTC sources are inverted, so a 1 will disable them + MXC_PWRSEQ->msk_flags |= (MXC_F_PWRSEQ_MSK_FLAGS_RTC_CMPR1 | + MXC_F_PWRSEQ_MSK_FLAGS_RTC_PRESCALE_CMP); + + /* Enable RTOS Mode: Enable 32kHz clock synchronizer to SysTick external clock input */ + MXC_CLKMAN->clk_ctrl |= MXC_F_CLKMAN_CLK_CTRL_RTOS_MODE; + + // Enable real-time clock during sleep mode + MXC_PWRSEQ->reg0 |= (MXC_F_PWRSEQ_REG0_PWR_RTCEN_RUN | MXC_F_PWRSEQ_REG0_PWR_RTCEN_SLP); + +#if (__FPU_PRESENT == 1) + /* Enable FPU on Cortex-M4, which occupies coprocessor slots 10 & 11 */ + /* Grant full access, per "Table B3-24 CPACR bit assignments". */ + /* DDI0403D "ARMv7-M Architecture Reference Manual" */ + SCB->CPACR |= SCB_CPACR_CP10_Msk | SCB_CPACR_CP11_Msk; + __DSB(); + __ISB(); +#endif + + // Trim ring oscillator + Trim_ROAtomic(); +} diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/system_max32620.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/system_max32620.h new file mode 100644 index 0000000000..3df2235fc2 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/system_max32620.h @@ -0,0 +1,78 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _SYSTEM_MAX32620_H_ +#define _SYSTEM_MAX32620_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/*---------------------------------------------------------------------------- + Define clocks + *----------------------------------------------------------------------------*/ +#ifndef RO_FREQ +#define RO_FREQ 96000000 +#endif + +extern uint32_t SystemCoreClock; /*!< System Clock Frequency (Core Clock) */ + +/** + * Initialize the system + * + * @param none + * @return none + * + * @brief Setup the microcontroller system. + * Initialize the System and update the SystemCoreClock variable. + */ +extern void SystemInit(void); + +/** + * Update SystemCoreClock variable + * + * @param none + * @return none + * + * @brief Updates the SystemCoreClock with current core Clock + * retrieved from cpu registers. + */ +extern void SystemCoreClockUpdate(void); + +#ifdef __cplusplus +} +#endif + +#endif /* _SYSTEM_MAX32620_H_ */ diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/tmr_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/tmr_regs.h new file mode 100644 index 0000000000..adae1555bd --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/tmr_regs.h @@ -0,0 +1,203 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_TMR_REGS_H_ +#define _MXC_TMR_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t ctrl; /* 0x0000 Timer Control Register */ + __IO uint32_t count32; /* 0x0004 Timer [32 bit] Current Count Value */ + __IO uint32_t term_cnt32; /* 0x0008 Timer [32 bit] Terminal Count Setting */ + __IO uint32_t pwm_cap32; /* 0x000C Timer [32 bit] PWM Compare Setting or Capture/Measure Value */ + __IO uint32_t count16_0; /* 0x0010 Timer [16 bit] Current Count Value, 16-bit Timer 0 */ + __IO uint32_t term_cnt16_0; /* 0x0014 Timer [16 bit] Terminal Count Setting, 16-bit Timer 0 */ + __IO uint32_t count16_1; /* 0x0018 Timer [16 bit] Current Count Value, 16-bit Timer 1 */ + __IO uint32_t term_cnt16_1; /* 0x001C Timer [16 bit] Terminal Count Setting, 16-bit Timer 1 */ + __IO uint32_t intfl; /* 0x0020 Timer Interrupt Flags */ + __IO uint32_t inten; /* 0x0024 Timer Interrupt Enable/Disable Settings */ +} mxc_tmr_regs_t; + + +/* + Register offsets for module TMR. +*/ + +#define MXC_R_TMR_OFFS_CTRL ((uint32_t)0x00000000UL) +#define MXC_R_TMR_OFFS_COUNT32 ((uint32_t)0x00000004UL) +#define MXC_R_TMR_OFFS_TERM_CNT32 ((uint32_t)0x00000008UL) +#define MXC_R_TMR_OFFS_PWM_CAP32 ((uint32_t)0x0000000CUL) +#define MXC_R_TMR_OFFS_COUNT16_0 ((uint32_t)0x00000010UL) +#define MXC_R_TMR_OFFS_TERM_CNT16_0 ((uint32_t)0x00000014UL) +#define MXC_R_TMR_OFFS_COUNT16_1 ((uint32_t)0x00000018UL) +#define MXC_R_TMR_OFFS_TERM_CNT16_1 ((uint32_t)0x0000001CUL) +#define MXC_R_TMR_OFFS_INTFL ((uint32_t)0x00000020UL) +#define MXC_R_TMR_OFFS_INTEN ((uint32_t)0x00000024UL) + + +/* + Field positions and masks for module TMR. +*/ + +#define MXC_F_TMR_CTRL_MODE_POS 0 +#define MXC_F_TMR_CTRL_MODE ((uint32_t)(0x00000007UL << MXC_F_TMR_CTRL_MODE_POS)) +#define MXC_F_TMR_CTRL_TMR2X16_POS 3 +#define MXC_F_TMR_CTRL_TMR2X16 ((uint32_t)(0x00000001UL << MXC_F_TMR_CTRL_TMR2X16_POS)) +#define MXC_F_TMR_CTRL_PRESCALE_POS 4 +#define MXC_F_TMR_CTRL_PRESCALE ((uint32_t)(0x0000000FUL << MXC_F_TMR_CTRL_PRESCALE_POS)) +#define MXC_F_TMR_CTRL_POLARITY_POS 8 +#define MXC_F_TMR_CTRL_POLARITY ((uint32_t)(0x00000001UL << MXC_F_TMR_CTRL_POLARITY_POS)) +#define MXC_F_TMR_CTRL_ENABLE0_POS 12 +#define MXC_F_TMR_CTRL_ENABLE0 ((uint32_t)(0x00000001UL << MXC_F_TMR_CTRL_ENABLE0_POS)) +#define MXC_F_TMR_CTRL_ENABLE1_POS 13 +#define MXC_F_TMR_CTRL_ENABLE1 ((uint32_t)(0x00000001UL << MXC_F_TMR_CTRL_ENABLE1_POS)) + +#define MXC_F_TMR_COUNT16_0_VALUE_POS 0 +#define MXC_F_TMR_COUNT16_0_VALUE ((uint32_t)(0x0000FFFFUL << MXC_F_TMR_COUNT16_0_VALUE_POS)) + +#define MXC_F_TMR_TERM_CNT16_0_TERM_COUNT_POS 0 +#define MXC_F_TMR_TERM_CNT16_0_TERM_COUNT ((uint32_t)(0x0000FFFFUL << MXC_F_TMR_TERM_CNT16_0_TERM_COUNT_POS)) + +#define MXC_F_TMR_COUNT16_1_VALUE_POS 0 +#define MXC_F_TMR_COUNT16_1_VALUE ((uint32_t)(0x0000FFFFUL << MXC_F_TMR_COUNT16_1_VALUE_POS)) + +#define MXC_F_TMR_TERM_CNT16_1_TERM_COUNT_POS 0 +#define MXC_F_TMR_TERM_CNT16_1_TERM_COUNT ((uint32_t)(0x0000FFFFUL << MXC_F_TMR_TERM_CNT16_1_TERM_COUNT_POS)) + +#define MXC_F_TMR_INTFL_TIMER0_POS 0 +#define MXC_F_TMR_INTFL_TIMER0 ((uint32_t)(0x00000001UL << MXC_F_TMR_INTFL_TIMER0_POS)) +#define MXC_F_TMR_INTFL_TIMER1_POS 1 +#define MXC_F_TMR_INTFL_TIMER1 ((uint32_t)(0x00000001UL << MXC_F_TMR_INTFL_TIMER1_POS)) + +#define MXC_F_TMR_INTEN_TIMER0_POS 0 +#define MXC_F_TMR_INTEN_TIMER0 ((uint32_t)(0x00000001UL << MXC_F_TMR_INTEN_TIMER0_POS)) +#define MXC_F_TMR_INTEN_TIMER1_POS 1 +#define MXC_F_TMR_INTEN_TIMER1 ((uint32_t)(0x00000001UL << MXC_F_TMR_INTEN_TIMER1_POS)) + + + +/* + Field values and shifted values for module TMR. +*/ + +#define MXC_V_TMR_CTRL_MODE_ONE_SHOT ((uint32_t)(0x00000000UL)) +#define MXC_V_TMR_CTRL_MODE_CONTINUOUS ((uint32_t)(0x00000001UL)) +#define MXC_V_TMR_CTRL_MODE_COUNTER ((uint32_t)(0x00000002UL)) +#define MXC_V_TMR_CTRL_MODE_PWM ((uint32_t)(0x00000003UL)) +#define MXC_V_TMR_CTRL_MODE_CAPTURE ((uint32_t)(0x00000004UL)) +#define MXC_V_TMR_CTRL_MODE_COMPARE ((uint32_t)(0x00000005UL)) +#define MXC_V_TMR_CTRL_MODE_GATED ((uint32_t)(0x00000006UL)) +#define MXC_V_TMR_CTRL_MODE_MEASURE ((uint32_t)(0x00000007UL)) + +#define MXC_S_TMR_CTRL_MODE_ONE_SHOT ((uint32_t)(MXC_V_TMR_CTRL_MODE_ONE_SHOT << MXC_F_TMR_CTRL_MODE_POS)) +#define MXC_S_TMR_CTRL_MODE_CONTINUOUS ((uint32_t)(MXC_V_TMR_CTRL_MODE_CONTINUOUS << MXC_F_TMR_CTRL_MODE_POS)) +#define MXC_S_TMR_CTRL_MODE_COUNTER ((uint32_t)(MXC_V_TMR_CTRL_MODE_COUNTER << MXC_F_TMR_CTRL_MODE_POS)) +#define MXC_S_TMR_CTRL_MODE_PWM ((uint32_t)(MXC_V_TMR_CTRL_MODE_PWM << MXC_F_TMR_CTRL_MODE_POS)) +#define MXC_S_TMR_CTRL_MODE_CAPTURE ((uint32_t)(MXC_V_TMR_CTRL_MODE_CAPTURE << MXC_F_TMR_CTRL_MODE_POS)) +#define MXC_S_TMR_CTRL_MODE_COMPARE ((uint32_t)(MXC_V_TMR_CTRL_MODE_COMPARE << MXC_F_TMR_CTRL_MODE_POS)) +#define MXC_S_TMR_CTRL_MODE_GATED ((uint32_t)(MXC_V_TMR_CTRL_MODE_GATED << MXC_F_TMR_CTRL_MODE_POS)) +#define MXC_S_TMR_CTRL_MODE_MEASURE ((uint32_t)(MXC_V_TMR_CTRL_MODE_MEASURE << MXC_F_TMR_CTRL_MODE_POS)) + +#define MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_1 ((uint32_t)(0x00000000UL)) +#define MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_2 ((uint32_t)(0x00000001UL)) +#define MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_4 ((uint32_t)(0x00000002UL)) +#define MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_8 ((uint32_t)(0x00000003UL)) +#define MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_16 ((uint32_t)(0x00000004UL)) +#define MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_32 ((uint32_t)(0x00000005UL)) +#define MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_64 ((uint32_t)(0x00000006UL)) +#define MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_128 ((uint32_t)(0x00000007UL)) +#define MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_256 ((uint32_t)(0x00000008UL)) +#define MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_512 ((uint32_t)(0x00000009UL)) +#define MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_1024 ((uint32_t)(0x0000000AUL)) +#define MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_2048 ((uint32_t)(0x0000000BUL)) +#define MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_4096 ((uint32_t)(0x0000000CUL)) + +#define MXC_S_TMR_CTRL_PRESCALE_DIVIDE_BY_1 ((uint32_t)(MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_1 << MXC_F_TMR_CTRL_PRESCALE_POS)) +#define MXC_S_TMR_CTRL_PRESCALE_DIVIDE_BY_2 ((uint32_t)(MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_2 << MXC_F_TMR_CTRL_PRESCALE_POS)) +#define MXC_S_TMR_CTRL_PRESCALE_DIVIDE_BY_4 ((uint32_t)(MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_4 << MXC_F_TMR_CTRL_PRESCALE_POS)) +#define MXC_S_TMR_CTRL_PRESCALE_DIVIDE_BY_8 ((uint32_t)(MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_8 << MXC_F_TMR_CTRL_PRESCALE_POS)) +#define MXC_S_TMR_CTRL_PRESCALE_DIVIDE_BY_16 ((uint32_t)(MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_16 << MXC_F_TMR_CTRL_PRESCALE_POS)) +#define MXC_S_TMR_CTRL_PRESCALE_DIVIDE_BY_32 ((uint32_t)(MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_32 << MXC_F_TMR_CTRL_PRESCALE_POS)) +#define MXC_S_TMR_CTRL_PRESCALE_DIVIDE_BY_64 ((uint32_t)(MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_64 << MXC_F_TMR_CTRL_PRESCALE_POS)) +#define MXC_S_TMR_CTRL_PRESCALE_DIVIDE_BY_128 ((uint32_t)(MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_128 << MXC_F_TMR_CTRL_PRESCALE_POS)) +#define MXC_S_TMR_CTRL_PRESCALE_DIVIDE_BY_256 ((uint32_t)(MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_256 << MXC_F_TMR_CTRL_PRESCALE_POS)) +#define MXC_S_TMR_CTRL_PRESCALE_DIVIDE_BY_512 ((uint32_t)(MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_512 << MXC_F_TMR_CTRL_PRESCALE_POS)) +#define MXC_S_TMR_CTRL_PRESCALE_DIVIDE_BY_1024 ((uint32_t)(MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_1024 << MXC_F_TMR_CTRL_PRESCALE_POS)) +#define MXC_S_TMR_CTRL_PRESCALE_DIVIDE_BY_2048 ((uint32_t)(MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_2048 << MXC_F_TMR_CTRL_PRESCALE_POS)) +#define MXC_S_TMR_CTRL_PRESCALE_DIVIDE_BY_4096 ((uint32_t)(MXC_V_TMR_CTRL_PRESCALE_DIVIDE_BY_4096 << MXC_F_TMR_CTRL_PRESCALE_POS)) + + +/* + * These two 1-bit fields replace the standard 3-bit mode field when the associated TMR module + * is in dual 16-bit timer mode. + */ + +#define MXC_F_TMR_CTRL_MODE_16_0_POS 0 +#define MXC_F_TMR_CTRL_MODE_16_0 ((uint32_t)(0x00000007UL << MXC_F_TMR_CTRL_MODE_16_0_POS)) + +#define MXC_F_TMR_CTRL_MODE_16_1_POS 1 +#define MXC_F_TMR_CTRL_MODE_16_1 ((uint32_t)(0x00000007UL << MXC_F_TMR_CTRL_MODE_16_1_POS)) + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_TMR_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/tpu_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/tpu_regs.h new file mode 100644 index 0000000000..dedd2e2b9f --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/tpu_regs.h @@ -0,0 +1,98 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_TPU_REGS_H_ +#define _MXC_TPU_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t prng_user_entropy; /* 0x0000 PRNG User Entropy Value */ + __IO uint32_t prng_rnd_num; /* 0x0004 PRNG Seed Output */ +} mxc_tpu_regs_t; + + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __I uint32_t rsv000[4]; /* 0x0000-0x000C */ + __IO uint32_t sks0; /* 0x0010 TPU Secure Key Storage Register 0 (Cleared on Tamper Detect) */ + __IO uint32_t sks1; /* 0x0014 TPU Secure Key Storage Register 1 (Cleared on Tamper Detect) */ + __IO uint32_t sks2; /* 0x0018 TPU Secure Key Storage Register 2 (Cleared on Tamper Detect) */ + __IO uint32_t sks3; /* 0x001C TPU Secure Key Storage Register 3 (Cleared on Tamper Detect) */ +} mxc_tpu_tsr_regs_t; + + +/* + Register offsets for module TPU. +*/ + +#define MXC_R_TPU_OFFS_PRNG_USER_ENTROPY ((uint32_t)0x00000000UL) +#define MXC_R_TPU_OFFS_PRNG_RND_NUM ((uint32_t)0x00000004UL) +#define MXC_R_TPU_TSR_OFFS_SKS0 ((uint32_t)0x00000010UL) +#define MXC_R_TPU_TSR_OFFS_SKS1 ((uint32_t)0x00000014UL) +#define MXC_R_TPU_TSR_OFFS_SKS2 ((uint32_t)0x00000018UL) +#define MXC_R_TPU_TSR_OFFS_SKS3 ((uint32_t)0x0000001CUL) + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_TPU_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/trim_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/trim_regs.h new file mode 100644 index 0000000000..c0e9658f1a --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/trim_regs.h @@ -0,0 +1,106 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_TRIM_REGS_H_ +#define _MXC_TRIM_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __I uint32_t rsv000[11]; /* 0x0000-0x0028 */ + __IO uint32_t reg11_adc_trim0; /* 0x002C Shadow Trim for ADC R0 */ + __IO uint32_t reg12_adc_trim1; /* 0x0030 Shadow Trim for ADC R1 */ + __IO uint32_t for_pwr_reg5; /* 0x0034 Shadow Trim for PWRSEQ Register REG5 */ + __IO uint32_t for_pwr_reg6; /* 0x0038 Shadow Trim for PWRSEQ Register REG6 */ +} mxc_trim_regs_t; + + +/* + Register offsets for module TRIM. +*/ + +#define MXC_R_TRIM_OFFS_REG11_ADC_TRIM0 ((uint32_t)0x0000002CUL) +#define MXC_R_TRIM_OFFS_REG12_ADC_TRIM1 ((uint32_t)0x00000030UL) +#define MXC_R_TRIM_OFFS_FOR_PWR_REG5 ((uint32_t)0x00000034UL) +#define MXC_R_TRIM_OFFS_FOR_PWR_REG6 ((uint32_t)0x00000038UL) + + +/* + Field positions and masks for module TRIM. +*/ + +#define MXC_F_TRIM_REG11_ADC_TRIM0_ADCTRIM_X0R0_POS 0 +#define MXC_F_TRIM_REG11_ADC_TRIM0_ADCTRIM_X0R0 ((uint32_t)(0x000003FFUL << MXC_F_TRIM_REG11_ADC_TRIM0_ADCTRIM_X0R0_POS)) +#define MXC_F_TRIM_REG11_ADC_TRIM0_ADCTRIM_X1R0_POS 16 +#define MXC_F_TRIM_REG11_ADC_TRIM0_ADCTRIM_X1R0 ((uint32_t)(0x000003FFUL << MXC_F_TRIM_REG11_ADC_TRIM0_ADCTRIM_X1R0_POS)) + +#define MXC_F_TRIM_REG12_ADC_TRIM1_ADCTRIM_X0R1_POS 0 +#define MXC_F_TRIM_REG12_ADC_TRIM1_ADCTRIM_X0R1 ((uint32_t)(0x000003FFUL << MXC_F_TRIM_REG12_ADC_TRIM1_ADCTRIM_X0R1_POS)) +#define MXC_F_TRIM_REG12_ADC_TRIM1_ADCTRIM_X1R1_POS 16 +#define MXC_F_TRIM_REG12_ADC_TRIM1_ADCTRIM_X1R1 ((uint32_t)(0x000003FFUL << MXC_F_TRIM_REG12_ADC_TRIM1_ADCTRIM_X1R1_POS)) +#define MXC_F_TRIM_REG12_ADC_TRIM1_ADCTRIM_DC_POS 28 +#define MXC_F_TRIM_REG12_ADC_TRIM1_ADCTRIM_DC ((uint32_t)(0x0000000FUL << MXC_F_TRIM_REG12_ADC_TRIM1_ADCTRIM_DC_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_TRIM_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/uart_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/uart_regs.h new file mode 100644 index 0000000000..276c95e8f2 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/uart_regs.h @@ -0,0 +1,226 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_UART_REGS_H_ +#define _MXC_UART_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t ctrl; /* 0x0000 UART Control Register */ + __IO uint32_t baud; /* 0x0004 UART Baud Control Register */ + __IO uint32_t tx_fifo_ctrl; /* 0x0008 UART TX FIFO Control Register */ + __IO uint32_t rx_fifo_ctrl; /* 0x000C UART RX FIFO Control Register */ + __IO uint32_t md_ctrl; /* 0x0010 UART Multidrop Control Register */ + __IO uint32_t intfl; /* 0x0014 UART Interrupt Flags */ + __IO uint32_t inten; /* 0x0018 UART Interrupt Enable/Disable Controls */ +} mxc_uart_regs_t; + + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + union { /* 0x0000-0x07FC FIFO Write Point for Data to Transmit */ + __IO uint8_t tx_8[2048]; + __IO uint16_t tx_16[1024]; + __IO uint32_t tx_32[512]; + }; + union { /* 0x0800-0x0FFC FIFO Read Point for Received Data */ + __IO uint8_t rx_8[2048]; + __IO uint16_t rx_16[1024]; + __IO uint32_t rx_32[512]; + }; +} mxc_uart_fifo_regs_t; + + +/* + Register offsets for module UART. +*/ + +#define MXC_R_UART_OFFS_CTRL ((uint32_t)0x00000000UL) +#define MXC_R_UART_OFFS_BAUD ((uint32_t)0x00000004UL) +#define MXC_R_UART_OFFS_TX_FIFO_CTRL ((uint32_t)0x00000008UL) +#define MXC_R_UART_OFFS_RX_FIFO_CTRL ((uint32_t)0x0000000CUL) +#define MXC_R_UART_OFFS_MD_CTRL ((uint32_t)0x00000010UL) +#define MXC_R_UART_OFFS_INTFL ((uint32_t)0x00000014UL) +#define MXC_R_UART_OFFS_INTEN ((uint32_t)0x00000018UL) +#define MXC_R_UART_FIFO_OFFS_TX ((uint32_t)0x00000000UL) +#define MXC_R_UART_FIFO_OFFS_RX ((uint32_t)0x00000800UL) + + +/* + Field positions and masks for module UART. +*/ + +#define MXC_F_UART_CTRL_UART_EN_POS 0 +#define MXC_F_UART_CTRL_UART_EN ((uint32_t)(0x00000001UL << MXC_F_UART_CTRL_UART_EN_POS)) +#define MXC_F_UART_CTRL_RX_FIFO_EN_POS 1 +#define MXC_F_UART_CTRL_RX_FIFO_EN ((uint32_t)(0x00000001UL << MXC_F_UART_CTRL_RX_FIFO_EN_POS)) +#define MXC_F_UART_CTRL_TX_FIFO_EN_POS 2 +#define MXC_F_UART_CTRL_TX_FIFO_EN ((uint32_t)(0x00000001UL << MXC_F_UART_CTRL_TX_FIFO_EN_POS)) +#define MXC_F_UART_CTRL_DATA_SIZE_POS 4 +#define MXC_F_UART_CTRL_DATA_SIZE ((uint32_t)(0x00000003UL << MXC_F_UART_CTRL_DATA_SIZE_POS)) +#define MXC_F_UART_CTRL_EXTRA_STOP_POS 8 +#define MXC_F_UART_CTRL_EXTRA_STOP ((uint32_t)(0x00000001UL << MXC_F_UART_CTRL_EXTRA_STOP_POS)) +#define MXC_F_UART_CTRL_PARITY_POS 12 +#define MXC_F_UART_CTRL_PARITY ((uint32_t)(0x00000003UL << MXC_F_UART_CTRL_PARITY_POS)) +#define MXC_F_UART_CTRL_CTS_EN_POS 16 +#define MXC_F_UART_CTRL_CTS_EN ((uint32_t)(0x00000001UL << MXC_F_UART_CTRL_CTS_EN_POS)) +#define MXC_F_UART_CTRL_CTS_POLARITY_POS 17 +#define MXC_F_UART_CTRL_CTS_POLARITY ((uint32_t)(0x00000001UL << MXC_F_UART_CTRL_CTS_POLARITY_POS)) +#define MXC_F_UART_CTRL_RTS_EN_POS 18 +#define MXC_F_UART_CTRL_RTS_EN ((uint32_t)(0x00000001UL << MXC_F_UART_CTRL_RTS_EN_POS)) +#define MXC_F_UART_CTRL_RTS_POLARITY_POS 19 +#define MXC_F_UART_CTRL_RTS_POLARITY ((uint32_t)(0x00000001UL << MXC_F_UART_CTRL_RTS_POLARITY_POS)) +#define MXC_F_UART_CTRL_RTS_LEVEL_POS 20 +#define MXC_F_UART_CTRL_RTS_LEVEL ((uint32_t)(0x0000003FUL << MXC_F_UART_CTRL_RTS_LEVEL_POS)) + +#define MXC_F_UART_BAUD_BAUD_DIVISOR_POS 0 +#define MXC_F_UART_BAUD_BAUD_DIVISOR ((uint32_t)(0x000000FFUL << MXC_F_UART_BAUD_BAUD_DIVISOR_POS)) + +#define MXC_F_UART_TX_FIFO_CTRL_FIFO_ENTRY_POS 0 +#define MXC_F_UART_TX_FIFO_CTRL_FIFO_ENTRY ((uint32_t)(0x0000003FUL << MXC_F_UART_TX_FIFO_CTRL_FIFO_ENTRY_POS)) +#define MXC_F_UART_TX_FIFO_CTRL_FIFO_AE_LVL_POS 16 +#define MXC_F_UART_TX_FIFO_CTRL_FIFO_AE_LVL ((uint32_t)(0x0000001FUL << MXC_F_UART_TX_FIFO_CTRL_FIFO_AE_LVL_POS)) + +#define MXC_F_UART_RX_FIFO_CTRL_FIFO_ENTRY_POS 0 +#define MXC_F_UART_RX_FIFO_CTRL_FIFO_ENTRY ((uint32_t)(0x0000003FUL << MXC_F_UART_RX_FIFO_CTRL_FIFO_ENTRY_POS)) +#define MXC_F_UART_RX_FIFO_CTRL_FIFO_AF_LVL_POS 16 +#define MXC_F_UART_RX_FIFO_CTRL_FIFO_AF_LVL ((uint32_t)(0x0000001FUL << MXC_F_UART_RX_FIFO_CTRL_FIFO_AF_LVL_POS)) + +#define MXC_F_UART_MD_CTRL_SLAVE_ADDR_POS 0 +#define MXC_F_UART_MD_CTRL_SLAVE_ADDR ((uint32_t)(0x000000FFUL << MXC_F_UART_MD_CTRL_SLAVE_ADDR_POS)) +#define MXC_F_UART_MD_CTRL_SLAVE_ADDR_MSK_POS 8 +#define MXC_F_UART_MD_CTRL_SLAVE_ADDR_MSK ((uint32_t)(0x000000FFUL << MXC_F_UART_MD_CTRL_SLAVE_ADDR_MSK_POS)) +#define MXC_F_UART_MD_CTRL_MD_MSTR_POS 16 +#define MXC_F_UART_MD_CTRL_MD_MSTR ((uint32_t)(0x00000001UL << MXC_F_UART_MD_CTRL_MD_MSTR_POS)) +#define MXC_F_UART_MD_CTRL_TX_ADDR_MARK_POS 17 +#define MXC_F_UART_MD_CTRL_TX_ADDR_MARK ((uint32_t)(0x00000001UL << MXC_F_UART_MD_CTRL_TX_ADDR_MARK_POS)) + +#define MXC_F_UART_INTFL_TX_DONE_POS 0 +#define MXC_F_UART_INTFL_TX_DONE ((uint32_t)(0x00000001UL << MXC_F_UART_INTFL_TX_DONE_POS)) +#define MXC_F_UART_INTFL_TX_UNSTALLED_POS 1 +#define MXC_F_UART_INTFL_TX_UNSTALLED ((uint32_t)(0x00000001UL << MXC_F_UART_INTFL_TX_UNSTALLED_POS)) +#define MXC_F_UART_INTFL_TX_FIFO_AE_POS 2 +#define MXC_F_UART_INTFL_TX_FIFO_AE ((uint32_t)(0x00000001UL << MXC_F_UART_INTFL_TX_FIFO_AE_POS)) +#define MXC_F_UART_INTFL_RX_FIFO_NOT_EMPTY_POS 3 +#define MXC_F_UART_INTFL_RX_FIFO_NOT_EMPTY ((uint32_t)(0x00000001UL << MXC_F_UART_INTFL_RX_FIFO_NOT_EMPTY_POS)) +#define MXC_F_UART_INTFL_RX_STALLED_POS 4 +#define MXC_F_UART_INTFL_RX_STALLED ((uint32_t)(0x00000001UL << MXC_F_UART_INTFL_RX_STALLED_POS)) +#define MXC_F_UART_INTFL_RX_FIFO_AF_POS 5 +#define MXC_F_UART_INTFL_RX_FIFO_AF ((uint32_t)(0x00000001UL << MXC_F_UART_INTFL_RX_FIFO_AF_POS)) +#define MXC_F_UART_INTFL_RX_FIFO_OVERFLOW_POS 6 +#define MXC_F_UART_INTFL_RX_FIFO_OVERFLOW ((uint32_t)(0x00000001UL << MXC_F_UART_INTFL_RX_FIFO_OVERFLOW_POS)) +#define MXC_F_UART_INTFL_RX_FRAMING_ERR_POS 7 +#define MXC_F_UART_INTFL_RX_FRAMING_ERR ((uint32_t)(0x00000001UL << MXC_F_UART_INTFL_RX_FRAMING_ERR_POS)) +#define MXC_F_UART_INTFL_RX_PARITY_ERR_POS 8 +#define MXC_F_UART_INTFL_RX_PARITY_ERR ((uint32_t)(0x00000001UL << MXC_F_UART_INTFL_RX_PARITY_ERR_POS)) + +#define MXC_F_UART_INTEN_TX_DONE_POS 0 +#define MXC_F_UART_INTEN_TX_DONE ((uint32_t)(0x00000001UL << MXC_F_UART_INTEN_TX_DONE_POS)) +#define MXC_F_UART_INTEN_TX_UNSTALLED_POS 1 +#define MXC_F_UART_INTEN_TX_UNSTALLED ((uint32_t)(0x00000001UL << MXC_F_UART_INTEN_TX_UNSTALLED_POS)) +#define MXC_F_UART_INTEN_TX_FIFO_AE_POS 2 +#define MXC_F_UART_INTEN_TX_FIFO_AE ((uint32_t)(0x00000001UL << MXC_F_UART_INTEN_TX_FIFO_AE_POS)) +#define MXC_F_UART_INTEN_RX_FIFO_NOT_EMPTY_POS 3 +#define MXC_F_UART_INTEN_RX_FIFO_NOT_EMPTY ((uint32_t)(0x00000001UL << MXC_F_UART_INTEN_RX_FIFO_NOT_EMPTY_POS)) +#define MXC_F_UART_INTEN_RX_STALLED_POS 4 +#define MXC_F_UART_INTEN_RX_STALLED ((uint32_t)(0x00000001UL << MXC_F_UART_INTEN_RX_STALLED_POS)) +#define MXC_F_UART_INTEN_RX_FIFO_AF_POS 5 +#define MXC_F_UART_INTEN_RX_FIFO_AF ((uint32_t)(0x00000001UL << MXC_F_UART_INTEN_RX_FIFO_AF_POS)) +#define MXC_F_UART_INTEN_RX_FIFO_OVERFLOW_POS 6 +#define MXC_F_UART_INTEN_RX_FIFO_OVERFLOW ((uint32_t)(0x00000001UL << MXC_F_UART_INTEN_RX_FIFO_OVERFLOW_POS)) +#define MXC_F_UART_INTEN_RX_FRAMING_ERR_POS 7 +#define MXC_F_UART_INTEN_RX_FRAMING_ERR ((uint32_t)(0x00000001UL << MXC_F_UART_INTEN_RX_FRAMING_ERR_POS)) +#define MXC_F_UART_INTEN_RX_PARITY_ERR_POS 8 +#define MXC_F_UART_INTEN_RX_PARITY_ERR ((uint32_t)(0x00000001UL << MXC_F_UART_INTEN_RX_PARITY_ERR_POS)) + + + +/* + Field values and shifted values for module UART. +*/ + +#define MXC_V_UART_CTRL_DATA_SIZE_5_BITS ((uint32_t)(0x00000000UL)) +#define MXC_V_UART_CTRL_DATA_SIZE_6_BITS ((uint32_t)(0x00000001UL)) +#define MXC_V_UART_CTRL_DATA_SIZE_7_BITS ((uint32_t)(0x00000002UL)) +#define MXC_V_UART_CTRL_DATA_SIZE_8_BITS ((uint32_t)(0x00000003UL)) + +#define MXC_S_UART_CTRL_DATA_SIZE_5_BITS ((uint32_t)(MXC_V_UART_CTRL_DATA_SIZE_5_BITS << MXC_F_UART_CTRL_DATA_SIZE_POS)) +#define MXC_S_UART_CTRL_DATA_SIZE_6_BITS ((uint32_t)(MXC_V_UART_CTRL_DATA_SIZE_6_BITS << MXC_F_UART_CTRL_DATA_SIZE_POS)) +#define MXC_S_UART_CTRL_DATA_SIZE_7_BITS ((uint32_t)(MXC_V_UART_CTRL_DATA_SIZE_7_BITS << MXC_F_UART_CTRL_DATA_SIZE_POS)) +#define MXC_S_UART_CTRL_DATA_SIZE_8_BITS ((uint32_t)(MXC_V_UART_CTRL_DATA_SIZE_8_BITS << MXC_F_UART_CTRL_DATA_SIZE_POS)) + +#define MXC_V_UART_CTRL_PARITY_DISABLE ((uint32_t)(0x00000000UL)) +#define MXC_V_UART_CTRL_PARITY_ODD ((uint32_t)(0x00000001UL)) +#define MXC_V_UART_CTRL_PARITY_EVEN ((uint32_t)(0x00000002UL)) +#define MXC_V_UART_CTRL_PARITY_MARK ((uint32_t)(0x00000003UL)) + +#define MXC_S_UART_CTRL_PARITY_DISABLE ((uint32_t)(MXC_V_UART_CTRL_PARITY_DISABLE << MXC_F_UART_CTRL_PARITY_POS)) +#define MXC_S_UART_CTRL_PARITY_ODD ((uint32_t)(MXC_V_UART_CTRL_PARITY_ODD << MXC_F_UART_CTRL_PARITY_POS)) +#define MXC_S_UART_CTRL_PARITY_EVEN ((uint32_t)(MXC_V_UART_CTRL_PARITY_EVEN << MXC_F_UART_CTRL_PARITY_POS)) +#define MXC_S_UART_CTRL_PARITY_MARK ((uint32_t)(MXC_V_UART_CTRL_PARITY_MARK << MXC_F_UART_CTRL_PARITY_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_UART_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/usb_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/usb_regs.h new file mode 100644 index 0000000000..05c39dda7d --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/usb_regs.h @@ -0,0 +1,296 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_USB_REGS_H_ +#define _MXC_USB_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif +#ifndef __I +#define __I volatile const +#endif + + +#define MXC_V_USB_EP_DIR_DISABLE ((uint32_t)0x00000000UL) +#define MXC_V_USB_EP_DIR_OUT ((uint32_t)0x00000001UL) +#define MXC_V_USB_EP_DIR_IN ((uint32_t)0x00000002UL) +#define MXC_V_USB_EP_DIR_CONTROL ((uint32_t)0x00000003UL) + +#define MXC_S_USB_EP_DIR_DISABLE (MXC_V_USB_EP_DIR_DISABLE << MXC_F_USB_EP_DIR_POS) +#define MXC_S_USB_EP_DIR_OUT (MXC_V_USB_EP_DIR_OUT << MXC_F_USB_EP_DIR_POS) +#define MXC_S_USB_EP_DIR_IN (MXC_V_USB_EP_DIR_IN << MXC_F_USB_EP_DIR_POS) +#define MXC_S_USB_EP_DIR_CONTROL (MXC_V_USB_EP_DIR_CONTROL << MXC_F_USB_EP_DIR_POS) + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t cn; /* 0x0000 USB Control Register */ + __I uint32_t rsv004[127]; /* 0x0004-0x01FC */ + __IO uint32_t dev_addr; /* 0x0200 USB Device Address Register */ + __IO uint32_t dev_cn; /* 0x0204 USB Device Control Register */ + __IO uint32_t dev_intfl; /* 0x0208 USB Device Interrupt */ + __IO uint32_t dev_inten; /* 0x020C USB Device Interrupt Enable */ + __I uint32_t rsv210[4]; /* 0x0210-0x021C */ + __IO uint32_t ep_base; /* 0x0220 USB Endpoint Descriptor Table Base Address */ + __IO uint32_t cur_buf; /* 0x0224 USB Current Endpoint Buffer Register */ + __IO uint32_t in_owner; /* 0x0228 USB IN Endpoint Buffer Owner Register */ + __IO uint32_t out_owner; /* 0x022C USB OUT Endpoint Buffer Owner Register */ + __IO uint32_t in_int; /* 0x0230 USB IN Endpoint Buffer Available Interrupt */ + __IO uint32_t out_int; /* 0x0234 USB OUT Endpoint Data Available Interrupt */ + __IO uint32_t nak_int; /* 0x0238 USB IN Endpoint NAK Interrupt */ + __IO uint32_t dma_err_int; /* 0x023C USB DMA Error Interrupt */ + __IO uint32_t buf_ovr_int; /* 0x0240 USB Buffer Overflow Interrupt */ + __I uint32_t rsv244[7]; /* 0x0244-0x025C */ + __IO uint32_t setup0; /* 0x0260 USB SETUP Packet Bytes 0 to 3 */ + __IO uint32_t setup1; /* 0x0264 USB SETUP Packet Bytes 4 to 7 */ + __I uint32_t rsv268[6]; /* 0x0268-0x027C */ + __IO uint32_t ep[8]; /* 0x0280-0x029C USB Endpoint[n] Control Register */ +} mxc_usb_regs_t; + + +/* + Register offsets for module USB. +*/ + +#define MXC_R_USB_OFFS_CN ((uint32_t)0x00000000UL) +#define MXC_R_USB_OFFS_DEV_ADDR ((uint32_t)0x00000200UL) +#define MXC_R_USB_OFFS_DEV_CN ((uint32_t)0x00000204UL) +#define MXC_R_USB_OFFS_DEV_INTFL ((uint32_t)0x00000208UL) +#define MXC_R_USB_OFFS_DEV_INTEN ((uint32_t)0x0000020CUL) +#define MXC_R_USB_OFFS_EP_BASE ((uint32_t)0x00000220UL) +#define MXC_R_USB_OFFS_CUR_BUF ((uint32_t)0x00000224UL) +#define MXC_R_USB_OFFS_IN_OWNER ((uint32_t)0x00000228UL) +#define MXC_R_USB_OFFS_OUT_OWNER ((uint32_t)0x0000022CUL) +#define MXC_R_USB_OFFS_IN_INT ((uint32_t)0x00000230UL) +#define MXC_R_USB_OFFS_OUT_INT ((uint32_t)0x00000234UL) +#define MXC_R_USB_OFFS_NAK_INT ((uint32_t)0x00000238UL) +#define MXC_R_USB_OFFS_DMA_ERR_INT ((uint32_t)0x0000023CUL) +#define MXC_R_USB_OFFS_BUF_OVR_INT ((uint32_t)0x00000240UL) +#define MXC_R_USB_OFFS_SETUP0 ((uint32_t)0x00000260UL) +#define MXC_R_USB_OFFS_SETUP1 ((uint32_t)0x00000264UL) +#define MXC_R_USB_OFFS_EP0 ((uint32_t)0x00000280UL) +#define MXC_R_USB_OFFS_EP1 ((uint32_t)0x00000284UL) +#define MXC_R_USB_OFFS_EP2 ((uint32_t)0x00000288UL) +#define MXC_R_USB_OFFS_EP3 ((uint32_t)0x0000028CUL) +#define MXC_R_USB_OFFS_EP4 ((uint32_t)0x00000290UL) +#define MXC_R_USB_OFFS_EP5 ((uint32_t)0x00000294UL) +#define MXC_R_USB_OFFS_EP6 ((uint32_t)0x00000298UL) +#define MXC_R_USB_OFFS_EP7 ((uint32_t)0x0000029CUL) + + +/* + Field positions and masks for module USB. +*/ + +#define MXC_F_USB_CN_USB_EN_POS 0 +#define MXC_F_USB_CN_USB_EN ((uint32_t)(0x00000001UL << MXC_F_USB_CN_USB_EN_POS)) +#define MXC_F_USB_CN_HOST_POS 1 +#define MXC_F_USB_CN_HOST ((uint32_t)(0x00000001UL << MXC_F_USB_CN_HOST_POS)) + +#define MXC_F_USB_DEV_ADDR_DEV_ADDR_POS 0 +#define MXC_F_USB_DEV_ADDR_DEV_ADDR ((uint32_t)(0x0000007FUL << MXC_F_USB_DEV_ADDR_DEV_ADDR_POS)) + +#define MXC_F_USB_DEV_CN_SIGRWU_POS 2 +#define MXC_F_USB_DEV_CN_SIGRWU ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_CN_SIGRWU_POS)) +#define MXC_F_USB_DEV_CN_CONNECT_POS 3 +#define MXC_F_USB_DEV_CN_CONNECT ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_CN_CONNECT_POS)) +#define MXC_F_USB_DEV_CN_ULPM_POS 4 +#define MXC_F_USB_DEV_CN_ULPM ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_CN_ULPM_POS)) +#define MXC_F_USB_DEV_CN_URST_POS 5 +#define MXC_F_USB_DEV_CN_URST ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_CN_URST_POS)) +#define MXC_F_USB_DEV_CN_VBGATE_POS 6 +#define MXC_F_USB_DEV_CN_VBGATE ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_CN_VBGATE_POS)) +#define MXC_F_USB_DEV_CN_OSCEN_POS 7 +#define MXC_F_USB_DEV_CN_OSCEN ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_CN_OSCEN_POS)) +#define MXC_F_USB_DEV_CN_BACT_OE_POS 8 +#define MXC_F_USB_DEV_CN_BACT_OE ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_CN_BACT_OE_POS)) +#define MXC_F_USB_DEV_CN_FIFO_MODE_POS 9 +#define MXC_F_USB_DEV_CN_FIFO_MODE ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_CN_FIFO_MODE_POS)) + +#define MXC_F_USB_DEV_INTFL_DPACT_POS 0 +#define MXC_F_USB_DEV_INTFL_DPACT ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTFL_DPACT_POS)) +#define MXC_F_USB_DEV_INTFL_RWU_DN_POS 1 +#define MXC_F_USB_DEV_INTFL_RWU_DN ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTFL_RWU_DN_POS)) +#define MXC_F_USB_DEV_INTFL_BACT_POS 2 +#define MXC_F_USB_DEV_INTFL_BACT ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTFL_BACT_POS)) +#define MXC_F_USB_DEV_INTFL_BRST_POS 3 +#define MXC_F_USB_DEV_INTFL_BRST ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTFL_BRST_POS)) +#define MXC_F_USB_DEV_INTFL_SUSP_POS 4 +#define MXC_F_USB_DEV_INTFL_SUSP ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTFL_SUSP_POS)) +#define MXC_F_USB_DEV_INTFL_NO_VBUS_POS 5 +#define MXC_F_USB_DEV_INTFL_NO_VBUS ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTFL_NO_VBUS_POS)) +#define MXC_F_USB_DEV_INTFL_VBUS_POS 6 +#define MXC_F_USB_DEV_INTFL_VBUS ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTFL_VBUS_POS)) +#define MXC_F_USB_DEV_INTFL_BRST_DN_POS 7 +#define MXC_F_USB_DEV_INTFL_BRST_DN ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTFL_BRST_DN_POS)) +#define MXC_F_USB_DEV_INTFL_SETUP_POS 8 +#define MXC_F_USB_DEV_INTFL_SETUP ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTFL_SETUP_POS)) +#define MXC_F_USB_DEV_INTFL_EP_IN_POS 9 +#define MXC_F_USB_DEV_INTFL_EP_IN ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTFL_EP_IN_POS)) +#define MXC_F_USB_DEV_INTFL_EP_OUT_POS 10 +#define MXC_F_USB_DEV_INTFL_EP_OUT ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTFL_EP_OUT_POS)) +#define MXC_F_USB_DEV_INTFL_EP_NAK_POS 11 +#define MXC_F_USB_DEV_INTFL_EP_NAK ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTFL_EP_NAK_POS)) +#define MXC_F_USB_DEV_INTFL_DMA_ERR_POS 12 +#define MXC_F_USB_DEV_INTFL_DMA_ERR ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTFL_DMA_ERR_POS)) +#define MXC_F_USB_DEV_INTFL_BUF_OVR_POS 13 +#define MXC_F_USB_DEV_INTFL_BUF_OVR ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTFL_BUF_OVR_POS)) +#define MXC_F_USB_DEV_INTFL_VBUS_ST_POS 16 +#define MXC_F_USB_DEV_INTFL_VBUS_ST ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTFL_VBUS_ST_POS)) + +#define MXC_F_USB_DEV_INTEN_DPACT_POS 0 +#define MXC_F_USB_DEV_INTEN_DPACT ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTEN_DPACT_POS)) +#define MXC_F_USB_DEV_INTEN_RWU_DN_POS 1 +#define MXC_F_USB_DEV_INTEN_RWU_DN ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTEN_RWU_DN_POS)) +#define MXC_F_USB_DEV_INTEN_BACT_POS 2 +#define MXC_F_USB_DEV_INTEN_BACT ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTEN_BACT_POS)) +#define MXC_F_USB_DEV_INTEN_BRST_POS 3 +#define MXC_F_USB_DEV_INTEN_BRST ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTEN_BRST_POS)) +#define MXC_F_USB_DEV_INTEN_SUSP_POS 4 +#define MXC_F_USB_DEV_INTEN_SUSP ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTEN_SUSP_POS)) +#define MXC_F_USB_DEV_INTEN_NO_VBUS_POS 5 +#define MXC_F_USB_DEV_INTEN_NO_VBUS ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTEN_NO_VBUS_POS)) +#define MXC_F_USB_DEV_INTEN_VBUS_POS 6 +#define MXC_F_USB_DEV_INTEN_VBUS ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTEN_VBUS_POS)) +#define MXC_F_USB_DEV_INTEN_BRST_DN_POS 7 +#define MXC_F_USB_DEV_INTEN_BRST_DN ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTEN_BRST_DN_POS)) +#define MXC_F_USB_DEV_INTEN_SETUP_POS 8 +#define MXC_F_USB_DEV_INTEN_SETUP ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTEN_SETUP_POS)) +#define MXC_F_USB_DEV_INTEN_EP_IN_POS 9 +#define MXC_F_USB_DEV_INTEN_EP_IN ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTEN_EP_IN_POS)) +#define MXC_F_USB_DEV_INTEN_EP_OUT_POS 10 +#define MXC_F_USB_DEV_INTEN_EP_OUT ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTEN_EP_OUT_POS)) +#define MXC_F_USB_DEV_INTEN_EP_NAK_POS 11 +#define MXC_F_USB_DEV_INTEN_EP_NAK ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTEN_EP_NAK_POS)) +#define MXC_F_USB_DEV_INTEN_DMA_ERR_POS 12 +#define MXC_F_USB_DEV_INTEN_DMA_ERR ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTEN_DMA_ERR_POS)) +#define MXC_F_USB_DEV_INTEN_BUF_OVR_POS 13 +#define MXC_F_USB_DEV_INTEN_BUF_OVR ((uint32_t)(0x00000001UL << MXC_F_USB_DEV_INTEN_BUF_OVR_POS)) + +#define MXC_F_USB_EP_BASE_EP_BASE_POS 9 +#define MXC_F_USB_EP_BASE_EP_BASE ((uint32_t)(0x007FFFFFUL << MXC_F_USB_EP_BASE_EP_BASE_POS)) + +#define MXC_F_USB_CUR_BUF_OUT_BUF_POS 0 +#define MXC_F_USB_CUR_BUF_OUT_BUF ((uint32_t)(0x0000FFFFUL << MXC_F_USB_CUR_BUF_OUT_BUF_POS)) +#define MXC_F_USB_CUR_BUF_IN_BUF_POS 16 +#define MXC_F_USB_CUR_BUF_IN_BUF ((uint32_t)(0x0000FFFFUL << MXC_F_USB_CUR_BUF_IN_BUF_POS)) + +#define MXC_F_USB_IN_OWNER_BUF0_OWNER_POS 0 +#define MXC_F_USB_IN_OWNER_BUF0_OWNER ((uint32_t)(0x0000FFFFUL << MXC_F_USB_IN_OWNER_BUF0_OWNER_POS)) +#define MXC_F_USB_IN_OWNER_BUF1_OWNER_POS 16 +#define MXC_F_USB_IN_OWNER_BUF1_OWNER ((uint32_t)(0x0000FFFFUL << MXC_F_USB_IN_OWNER_BUF1_OWNER_POS)) + +#define MXC_F_USB_OUT_OWNER_BUF0_OWNER_POS 0 +#define MXC_F_USB_OUT_OWNER_BUF0_OWNER ((uint32_t)(0x0000FFFFUL << MXC_F_USB_OUT_OWNER_BUF0_OWNER_POS)) +#define MXC_F_USB_OUT_OWNER_BUF1_OWNER_POS 16 +#define MXC_F_USB_OUT_OWNER_BUF1_OWNER ((uint32_t)(0x0000FFFFUL << MXC_F_USB_OUT_OWNER_BUF1_OWNER_POS)) + +#define MXC_F_USB_IN_INT_INBAV_POS 0 +#define MXC_F_USB_IN_INT_INBAV ((uint32_t)(0x000000FFUL << MXC_F_USB_IN_INT_INBAV_POS)) + +#define MXC_F_USB_OUT_INT_OUTDAV_POS 0 +#define MXC_F_USB_OUT_INT_OUTDAV ((uint32_t)(0x000000FFUL << MXC_F_USB_OUT_INT_OUTDAV_POS)) + +#define MXC_F_USB_NAK_INT_NAK_POS 0 +#define MXC_F_USB_NAK_INT_NAK ((uint32_t)(0x000000FFUL << MXC_F_USB_NAK_INT_NAK_POS)) + +#define MXC_F_USB_DMA_ERR_INT_DMA_ERR_POS 0 +#define MXC_F_USB_DMA_ERR_INT_DMA_ERR ((uint32_t)(0x000000FFUL << MXC_F_USB_DMA_ERR_INT_DMA_ERR_POS)) + +#define MXC_F_USB_BUF_OVR_INT_BUF_OVR_POS 0 +#define MXC_F_USB_BUF_OVR_INT_BUF_OVR ((uint32_t)(0x000000FFUL << MXC_F_USB_BUF_OVR_INT_BUF_OVR_POS)) + +#define MXC_F_USB_SETUP0_BYTE0_POS 0 +#define MXC_F_USB_SETUP0_BYTE0 ((uint32_t)(0x000000FFUL << MXC_F_USB_SETUP0_BYTE0_POS)) +#define MXC_F_USB_SETUP0_BYTE1_POS 8 +#define MXC_F_USB_SETUP0_BYTE1 ((uint32_t)(0x000000FFUL << MXC_F_USB_SETUP0_BYTE1_POS)) +#define MXC_F_USB_SETUP0_BYTE2_POS 16 +#define MXC_F_USB_SETUP0_BYTE2 ((uint32_t)(0x000000FFUL << MXC_F_USB_SETUP0_BYTE2_POS)) +#define MXC_F_USB_SETUP0_BYTE3_POS 24 +#define MXC_F_USB_SETUP0_BYTE3 ((uint32_t)(0x000000FFUL << MXC_F_USB_SETUP0_BYTE3_POS)) + +#define MXC_F_USB_SETUP1_BYTE0_POS 0 +#define MXC_F_USB_SETUP1_BYTE0 ((uint32_t)(0x000000FFUL << MXC_F_USB_SETUP1_BYTE0_POS)) +#define MXC_F_USB_SETUP1_BYTE1_POS 8 +#define MXC_F_USB_SETUP1_BYTE1 ((uint32_t)(0x000000FFUL << MXC_F_USB_SETUP1_BYTE1_POS)) +#define MXC_F_USB_SETUP1_BYTE2_POS 16 +#define MXC_F_USB_SETUP1_BYTE2 ((uint32_t)(0x000000FFUL << MXC_F_USB_SETUP1_BYTE2_POS)) +#define MXC_F_USB_SETUP1_BYTE3_POS 24 +#define MXC_F_USB_SETUP1_BYTE3 ((uint32_t)(0x000000FFUL << MXC_F_USB_SETUP1_BYTE3_POS)) + +#define MXC_F_USB_EP_DIR_POS 0 +#define MXC_F_USB_EP_DIR ((uint32_t)(0x00000003UL << MXC_F_USB_EP_DIR_POS)) +#define MXC_F_USB_EP_BUF2_POS 3 +#define MXC_F_USB_EP_BUF2 ((uint32_t)(0x00000001UL << MXC_F_USB_EP_BUF2_POS)) +#define MXC_F_USB_EP_INT_EN_POS 4 +#define MXC_F_USB_EP_INT_EN ((uint32_t)(0x00000001UL << MXC_F_USB_EP_INT_EN_POS)) +#define MXC_F_USB_EP_NAK_EN_POS 5 +#define MXC_F_USB_EP_NAK_EN ((uint32_t)(0x00000001UL << MXC_F_USB_EP_NAK_EN_POS)) +#define MXC_F_USB_EP_DT_POS 6 +#define MXC_F_USB_EP_DT ((uint32_t)(0x00000001UL << MXC_F_USB_EP_DT_POS)) +#define MXC_F_USB_EP_STALL_POS 8 +#define MXC_F_USB_EP_STALL ((uint32_t)(0x00000001UL << MXC_F_USB_EP_STALL_POS)) +#define MXC_F_USB_EP_ST_STALL_POS 9 +#define MXC_F_USB_EP_ST_STALL ((uint32_t)(0x00000001UL << MXC_F_USB_EP_ST_STALL_POS)) +#define MXC_F_USB_EP_ST_ACK_POS 10 +#define MXC_F_USB_EP_ST_ACK ((uint32_t)(0x00000001UL << MXC_F_USB_EP_ST_ACK_POS)) + + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_USB_REGS_H_ */ + diff --git a/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/wdt_regs.h b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/wdt_regs.h new file mode 100644 index 0000000000..f01895ff52 --- /dev/null +++ b/hal/targets/cmsis/TARGET_Maxim/TARGET_MAX32620/wdt_regs.h @@ -0,0 +1,238 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef _MXC_WDT_REGS_H_ +#define _MXC_WDT_REGS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + If types are not defined elsewhere (CMSIS) define them here +*/ +#ifndef __IO +#define __IO volatile +#endif +#ifndef __I +#define __I volatile const +#endif +#ifndef __O +#define __O volatile +#endif + + +/* + Typedefed structure(s) for module registers (per instance or section) with direct 32-bit + access to each register in module. +*/ + +/* Offset Register Description + ============= ============================================================================ */ +typedef struct { + __IO uint32_t ctrl; /* 0x0000 Watchdog Timer Control Register */ + __IO uint32_t clear; /* 0x0004 Watchdog Timer Clear Register (Feed Dog) */ + __IO uint32_t flags; /* 0x0008 Watchdog Timer Interrupt and Reset Flags */ + __IO uint32_t enable; /* 0x000C Watchdog Timer Interrupt/Reset Enable/Disable Controls */ + __I uint32_t rsv010; /* 0x0010 */ + __IO uint32_t lock_ctrl; /* 0x0014 Watchdog Timer Register Setting Lock for Control Register */ +} mxc_wdt_regs_t; + + +/* + Register offsets for module WDT. +*/ + +#define MXC_R_WDT_OFFS_CTRL ((uint32_t)0x00000000UL) +#define MXC_R_WDT_OFFS_CLEAR ((uint32_t)0x00000004UL) +#define MXC_R_WDT_OFFS_FLAGS ((uint32_t)0x00000008UL) +#define MXC_R_WDT_OFFS_ENABLE ((uint32_t)0x0000000CUL) +#define MXC_R_WDT_OFFS_LOCK_CTRL ((uint32_t)0x00000014UL) + + +/* + Field positions and masks for module WDT. +*/ + +#define MXC_F_WDT_CTRL_INT_PERIOD_POS 0 +#define MXC_F_WDT_CTRL_INT_PERIOD ((uint32_t)(0x0000000FUL << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_F_WDT_CTRL_RST_PERIOD_POS 4 +#define MXC_F_WDT_CTRL_RST_PERIOD ((uint32_t)(0x0000000FUL << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_F_WDT_CTRL_EN_TIMER_POS 8 +#define MXC_F_WDT_CTRL_EN_TIMER ((uint32_t)(0x00000001UL << MXC_F_WDT_CTRL_EN_TIMER_POS)) +#define MXC_F_WDT_CTRL_EN_CLOCK_POS 9 +#define MXC_F_WDT_CTRL_EN_CLOCK ((uint32_t)(0x00000001UL << MXC_F_WDT_CTRL_EN_CLOCK_POS)) +#define MXC_F_WDT_CTRL_WAIT_PERIOD_POS 12 +#define MXC_F_WDT_CTRL_WAIT_PERIOD ((uint32_t)(0x0000000FUL << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) + +#define MXC_F_WDT_FLAGS_TIMEOUT_POS 0 +#define MXC_F_WDT_FLAGS_TIMEOUT ((uint32_t)(0x00000001UL << MXC_F_WDT_FLAGS_TIMEOUT_POS)) +#define MXC_F_WDT_FLAGS_PRE_WIN_POS 1 +#define MXC_F_WDT_FLAGS_PRE_WIN ((uint32_t)(0x00000001UL << MXC_F_WDT_FLAGS_PRE_WIN_POS)) +#define MXC_F_WDT_FLAGS_RESET_OUT_POS 2 +#define MXC_F_WDT_FLAGS_RESET_OUT ((uint32_t)(0x00000001UL << MXC_F_WDT_FLAGS_RESET_OUT_POS)) + +#define MXC_F_WDT_ENABLE_TIMEOUT_POS 0 +#define MXC_F_WDT_ENABLE_TIMEOUT ((uint32_t)(0x00000001UL << MXC_F_WDT_ENABLE_TIMEOUT_POS)) +#define MXC_F_WDT_ENABLE_PRE_WIN_POS 1 +#define MXC_F_WDT_ENABLE_PRE_WIN ((uint32_t)(0x00000001UL << MXC_F_WDT_ENABLE_PRE_WIN_POS)) +#define MXC_F_WDT_ENABLE_RESET_OUT_POS 2 +#define MXC_F_WDT_ENABLE_RESET_OUT ((uint32_t)(0x00000001UL << MXC_F_WDT_ENABLE_RESET_OUT_POS)) + +#define MXC_F_WDT_LOCK_CTRL_WDLOCK_POS 0 +#define MXC_F_WDT_LOCK_CTRL_WDLOCK ((uint32_t)(0x000000FFUL << MXC_F_WDT_LOCK_CTRL_WDLOCK_POS)) + + + +/* + Field values and shifted values for module WDT. +*/ + +#define MXC_V_WDT_CTRL_INT_PERIOD_2_31_CLKS ((uint32_t)(0x00000000UL)) +#define MXC_V_WDT_CTRL_INT_PERIOD_2_30_CLKS ((uint32_t)(0x00000001UL)) +#define MXC_V_WDT_CTRL_INT_PERIOD_2_29_CLKS ((uint32_t)(0x00000002UL)) +#define MXC_V_WDT_CTRL_INT_PERIOD_2_28_CLKS ((uint32_t)(0x00000003UL)) +#define MXC_V_WDT_CTRL_INT_PERIOD_2_27_CLKS ((uint32_t)(0x00000004UL)) +#define MXC_V_WDT_CTRL_INT_PERIOD_2_26_CLKS ((uint32_t)(0x00000005UL)) +#define MXC_V_WDT_CTRL_INT_PERIOD_2_25_CLKS ((uint32_t)(0x00000006UL)) +#define MXC_V_WDT_CTRL_INT_PERIOD_2_24_CLKS ((uint32_t)(0x00000007UL)) +#define MXC_V_WDT_CTRL_INT_PERIOD_2_23_CLKS ((uint32_t)(0x00000008UL)) +#define MXC_V_WDT_CTRL_INT_PERIOD_2_22_CLKS ((uint32_t)(0x00000009UL)) +#define MXC_V_WDT_CTRL_INT_PERIOD_2_21_CLKS ((uint32_t)(0x0000000AUL)) +#define MXC_V_WDT_CTRL_INT_PERIOD_2_20_CLKS ((uint32_t)(0x0000000BUL)) +#define MXC_V_WDT_CTRL_INT_PERIOD_2_19_CLKS ((uint32_t)(0x0000000CUL)) +#define MXC_V_WDT_CTRL_INT_PERIOD_2_18_CLKS ((uint32_t)(0x0000000DUL)) +#define MXC_V_WDT_CTRL_INT_PERIOD_2_17_CLKS ((uint32_t)(0x0000000EUL)) +#define MXC_V_WDT_CTRL_INT_PERIOD_2_16_CLKS ((uint32_t)(0x0000000FUL)) + +#define MXC_S_WDT_CTRL_INT_PERIOD_2_31_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_31_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_INT_PERIOD_2_30_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_30_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_INT_PERIOD_2_29_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_29_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_INT_PERIOD_2_28_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_28_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_INT_PERIOD_2_27_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_27_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_INT_PERIOD_2_26_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_26_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_INT_PERIOD_2_25_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_25_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_INT_PERIOD_2_24_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_24_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_INT_PERIOD_2_23_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_23_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_INT_PERIOD_2_22_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_22_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_INT_PERIOD_2_21_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_21_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_INT_PERIOD_2_20_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_20_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_INT_PERIOD_2_19_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_19_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_INT_PERIOD_2_18_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_18_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_INT_PERIOD_2_17_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_17_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_INT_PERIOD_2_16_CLKS ((uint32_t)(MXC_V_WDT_CTRL_INT_PERIOD_2_16_CLKS << MXC_F_WDT_CTRL_INT_PERIOD_POS)) + +#define MXC_V_WDT_CTRL_RST_PERIOD_2_31_CLKS ((uint32_t)(0x00000000UL)) +#define MXC_V_WDT_CTRL_RST_PERIOD_2_30_CLKS ((uint32_t)(0x00000001UL)) +#define MXC_V_WDT_CTRL_RST_PERIOD_2_29_CLKS ((uint32_t)(0x00000002UL)) +#define MXC_V_WDT_CTRL_RST_PERIOD_2_28_CLKS ((uint32_t)(0x00000003UL)) +#define MXC_V_WDT_CTRL_RST_PERIOD_2_27_CLKS ((uint32_t)(0x00000004UL)) +#define MXC_V_WDT_CTRL_RST_PERIOD_2_26_CLKS ((uint32_t)(0x00000005UL)) +#define MXC_V_WDT_CTRL_RST_PERIOD_2_25_CLKS ((uint32_t)(0x00000006UL)) +#define MXC_V_WDT_CTRL_RST_PERIOD_2_24_CLKS ((uint32_t)(0x00000007UL)) +#define MXC_V_WDT_CTRL_RST_PERIOD_2_23_CLKS ((uint32_t)(0x00000008UL)) +#define MXC_V_WDT_CTRL_RST_PERIOD_2_22_CLKS ((uint32_t)(0x00000009UL)) +#define MXC_V_WDT_CTRL_RST_PERIOD_2_21_CLKS ((uint32_t)(0x0000000AUL)) +#define MXC_V_WDT_CTRL_RST_PERIOD_2_20_CLKS ((uint32_t)(0x0000000BUL)) +#define MXC_V_WDT_CTRL_RST_PERIOD_2_19_CLKS ((uint32_t)(0x0000000CUL)) +#define MXC_V_WDT_CTRL_RST_PERIOD_2_18_CLKS ((uint32_t)(0x0000000DUL)) +#define MXC_V_WDT_CTRL_RST_PERIOD_2_17_CLKS ((uint32_t)(0x0000000EUL)) +#define MXC_V_WDT_CTRL_RST_PERIOD_2_16_CLKS ((uint32_t)(0x0000000FUL)) + +#define MXC_S_WDT_CTRL_RST_PERIOD_2_31_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_31_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_S_WDT_CTRL_RST_PERIOD_2_30_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_30_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_S_WDT_CTRL_RST_PERIOD_2_29_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_29_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_S_WDT_CTRL_RST_PERIOD_2_28_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_28_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_S_WDT_CTRL_RST_PERIOD_2_27_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_27_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_S_WDT_CTRL_RST_PERIOD_2_26_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_26_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_S_WDT_CTRL_RST_PERIOD_2_25_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_25_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_S_WDT_CTRL_RST_PERIOD_2_24_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_24_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_S_WDT_CTRL_RST_PERIOD_2_23_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_23_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_S_WDT_CTRL_RST_PERIOD_2_22_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_22_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_S_WDT_CTRL_RST_PERIOD_2_21_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_21_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_S_WDT_CTRL_RST_PERIOD_2_20_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_20_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_S_WDT_CTRL_RST_PERIOD_2_19_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_19_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_S_WDT_CTRL_RST_PERIOD_2_18_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_18_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_S_WDT_CTRL_RST_PERIOD_2_17_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_17_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) +#define MXC_S_WDT_CTRL_RST_PERIOD_2_16_CLKS ((uint32_t)(MXC_V_WDT_CTRL_RST_PERIOD_2_16_CLKS << MXC_F_WDT_CTRL_RST_PERIOD_POS)) + +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_31_CLKS ((uint32_t)(0x00000000UL)) +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_30_CLKS ((uint32_t)(0x00000001UL)) +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_29_CLKS ((uint32_t)(0x00000002UL)) +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_28_CLKS ((uint32_t)(0x00000003UL)) +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_27_CLKS ((uint32_t)(0x00000004UL)) +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_26_CLKS ((uint32_t)(0x00000005UL)) +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_25_CLKS ((uint32_t)(0x00000006UL)) +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_24_CLKS ((uint32_t)(0x00000007UL)) +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_23_CLKS ((uint32_t)(0x00000008UL)) +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_22_CLKS ((uint32_t)(0x00000009UL)) +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_21_CLKS ((uint32_t)(0x0000000AUL)) +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_20_CLKS ((uint32_t)(0x0000000BUL)) +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_19_CLKS ((uint32_t)(0x0000000CUL)) +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_18_CLKS ((uint32_t)(0x0000000DUL)) +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_17_CLKS ((uint32_t)(0x0000000EUL)) +#define MXC_V_WDT_CTRL_WAIT_PERIOD_2_16_CLKS ((uint32_t)(0x0000000FUL)) + +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_31_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_31_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_30_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_30_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_29_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_29_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_28_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_28_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_27_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_27_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_26_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_26_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_25_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_25_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_24_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_24_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_23_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_23_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_22_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_22_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_21_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_21_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_20_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_20_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_19_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_19_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_18_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_18_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_17_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_17_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) +#define MXC_S_WDT_CTRL_WAIT_PERIOD_2_16_CLKS ((uint32_t)(MXC_V_WDT_CTRL_WAIT_PERIOD_2_16_CLKS << MXC_F_WDT_CTRL_WAIT_PERIOD_POS)) + + +#define MXC_V_WDT_LOCK_KEY 0x24 +#define MXC_V_WDT_UNLOCK_KEY 0x42 + +#define MXC_V_WDT_RESET_KEY_0 0xA5 +#define MXC_V_WDT_RESET_KEY_1 0x5A + + +#ifdef __cplusplus +} +#endif + +#endif /* _MXC_WDT_REGS_H_ */ + diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/PeripheralPins.c b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/PeripheralPins.c new file mode 100644 index 0000000000..de32811a76 --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/PeripheralPins.c @@ -0,0 +1,186 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include "device.h" +#include "PeripheralPins.h" +#include "ioman_regs.h" + +/* + * To select a peripheral function on Maxim microcontrollers, multiple + * configurations must be made. The mbed PinMap structure only includes one + * data member to hold this information. To extend the configuration storage, + * the "function" data member is used as a pointer to a pin_function_t + * structure. This structure is defined in objects.h. The definitions below + * include the creation of the pin_function_t structures and the assignment of + * the pointers to the "function" data members. + */ + +#ifdef TOOLCHAIN_ARM_STD +#pragma diag_suppress 1296 +#endif + +/************I2C***************/ +const PinMap PinMap_I2C_SDA[] = { + { P1_6, I2C_0, (int)&((pin_function_t){&MXC_IOMAN->i2cm0_req, &MXC_IOMAN->i2cm0_ack, MXC_F_IOMAN_I2CM_REQ_MAPPING_REQ, MXC_F_IOMAN_I2CM_ACK_MAPPING_ACK}) }, + { P3_4, I2C_1, (int)&((pin_function_t){&MXC_IOMAN->i2cm1_req, &MXC_IOMAN->i2cm1_ack, MXC_F_IOMAN_I2CM_REQ_MAPPING_REQ, MXC_F_IOMAN_I2CM_ACK_MAPPING_ACK}) }, + { P5_7, I2C_2, (int)&((pin_function_t){&MXC_IOMAN->i2cm2_req, &MXC_IOMAN->i2cm2_ack, MXC_F_IOMAN_I2CM_REQ_MAPPING_REQ, MXC_F_IOMAN_I2CM_ACK_MAPPING_ACK}) }, + { NC, NC, 0 } +}; + +const PinMap PinMap_I2C_SCL[] = { + { P1_7, I2C_0, (int)&((pin_function_t){&MXC_IOMAN->i2cm0_req, &MXC_IOMAN->i2cm0_ack, MXC_F_IOMAN_I2CM_REQ_MAPPING_REQ, MXC_F_IOMAN_I2CM_ACK_MAPPING_ACK}) }, + { P3_5, I2C_1, (int)&((pin_function_t){&MXC_IOMAN->i2cm1_req, &MXC_IOMAN->i2cm1_ack, MXC_F_IOMAN_I2CM_REQ_MAPPING_REQ, MXC_F_IOMAN_I2CM_ACK_MAPPING_ACK}) }, + { P6_0, I2C_2, (int)&((pin_function_t){&MXC_IOMAN->i2cm2_req, &MXC_IOMAN->i2cm2_ack, MXC_F_IOMAN_I2CM_REQ_MAPPING_REQ, MXC_F_IOMAN_I2CM_ACK_MAPPING_ACK}) }, + { NC, NC, 0 } +}; + +/************UART***************/ +/* +*/ +const PinMap PinMap_UART_TX[] = { + { P0_1, UART_0, (int)&((pin_function_t){&MXC_IOMAN->uart0_req, &MXC_IOMAN->uart0_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { P2_1, UART_1, (int)&((pin_function_t){&MXC_IOMAN->uart1_req, &MXC_IOMAN->uart1_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { P3_1, UART_2, (int)&((pin_function_t){&MXC_IOMAN->uart2_req, &MXC_IOMAN->uart2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { P5_4, UART_3, (int)&((pin_function_t){&MXC_IOMAN->uart3_req, &MXC_IOMAN->uart3_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { P0_0, UART_0, (int)&((pin_function_t){&MXC_IOMAN->uart0_req, &MXC_IOMAN->uart0_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { P2_0, UART_1, (int)&((pin_function_t){&MXC_IOMAN->uart1_req, &MXC_IOMAN->uart1_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { P3_0, UART_2, (int)&((pin_function_t){&MXC_IOMAN->uart2_req, &MXC_IOMAN->uart2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { P5_3, UART_3, (int)&((pin_function_t){&MXC_IOMAN->uart3_req, &MXC_IOMAN->uart3_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { NC, NC, 0 } +}; + +const PinMap PinMap_UART_RX[] = { + { P0_0, UART_0, (int)&((pin_function_t){&MXC_IOMAN->uart0_req, &MXC_IOMAN->uart0_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { P2_0, UART_1, (int)&((pin_function_t){&MXC_IOMAN->uart1_req, &MXC_IOMAN->uart1_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { P3_0, UART_2, (int)&((pin_function_t){&MXC_IOMAN->uart2_req, &MXC_IOMAN->uart2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { P5_3, UART_3, (int)&((pin_function_t){&MXC_IOMAN->uart3_req, &MXC_IOMAN->uart3_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { P0_1, UART_0, (int)&((pin_function_t){&MXC_IOMAN->uart0_req, &MXC_IOMAN->uart0_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { P2_1, UART_1, (int)&((pin_function_t){&MXC_IOMAN->uart1_req, &MXC_IOMAN->uart1_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { P3_1, UART_2, (int)&((pin_function_t){&MXC_IOMAN->uart2_req, &MXC_IOMAN->uart2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { P5_4, UART_3, (int)&((pin_function_t){&MXC_IOMAN->uart3_req, &MXC_IOMAN->uart3_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_IO_REQ), (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)}) }, + { NC, NC, 0 } +}; + +const PinMap PinMap_UART_CTS[] = { + { P0_2, UART_0, (int)&((pin_function_t){&MXC_IOMAN->uart0_req, &MXC_IOMAN->uart0_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_CTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_CTS_MAP | MXC_F_IOMAN_UART_ACK_CTS_IO_ACK)}) }, + { P2_2, UART_1, (int)&((pin_function_t){&MXC_IOMAN->uart1_req, &MXC_IOMAN->uart1_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_CTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_CTS_MAP | MXC_F_IOMAN_UART_ACK_CTS_IO_ACK)}) }, + { P3_2, UART_2, (int)&((pin_function_t){&MXC_IOMAN->uart2_req, &MXC_IOMAN->uart2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_CTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_CTS_MAP | MXC_F_IOMAN_UART_ACK_CTS_IO_ACK)}) }, + { P5_5, UART_3, (int)&((pin_function_t){&MXC_IOMAN->uart3_req, &MXC_IOMAN->uart3_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_CTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_CTS_MAP | MXC_F_IOMAN_UART_ACK_CTS_IO_ACK)}) }, + { P0_3, UART_0, (int)&((pin_function_t){&MXC_IOMAN->uart0_req, &MXC_IOMAN->uart0_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_CTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_CTS_MAP | MXC_F_IOMAN_UART_ACK_CTS_IO_ACK)}) }, + { P2_3, UART_1, (int)&((pin_function_t){&MXC_IOMAN->uart1_req, &MXC_IOMAN->uart1_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_CTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_CTS_MAP | MXC_F_IOMAN_UART_ACK_CTS_IO_ACK)}) }, + { P3_3, UART_2, (int)&((pin_function_t){&MXC_IOMAN->uart2_req, &MXC_IOMAN->uart2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_CTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_CTS_MAP | MXC_F_IOMAN_UART_ACK_CTS_IO_ACK)}) }, + { P5_6, UART_3, (int)&((pin_function_t){&MXC_IOMAN->uart3_req, &MXC_IOMAN->uart3_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_CTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_CTS_MAP | MXC_F_IOMAN_UART_ACK_CTS_IO_ACK)}) }, + { NC, NC, 0 } +}; + +const PinMap PinMap_UART_RTS[] = { + { P0_3, UART_0, (int)&((pin_function_t){&MXC_IOMAN->uart0_req, &MXC_IOMAN->uart0_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_RTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_RTS_MAP | MXC_F_IOMAN_UART_ACK_RTS_IO_ACK)}) }, + { P2_3, UART_1, (int)&((pin_function_t){&MXC_IOMAN->uart1_req, &MXC_IOMAN->uart1_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_RTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_RTS_MAP | MXC_F_IOMAN_UART_ACK_RTS_IO_ACK)}) }, + { P3_3, UART_2, (int)&((pin_function_t){&MXC_IOMAN->uart2_req, &MXC_IOMAN->uart2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_RTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_RTS_MAP | MXC_F_IOMAN_UART_ACK_RTS_IO_ACK)}) }, + { P5_6, UART_3, (int)&((pin_function_t){&MXC_IOMAN->uart3_req, &MXC_IOMAN->uart3_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_UART_REQ_RTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_RTS_MAP | MXC_F_IOMAN_UART_ACK_RTS_IO_ACK)}) }, + { P0_2, UART_0, (int)&((pin_function_t){&MXC_IOMAN->uart0_req, &MXC_IOMAN->uart0_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_RTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_RTS_MAP | MXC_F_IOMAN_UART_ACK_RTS_IO_ACK)}) }, + { P2_2, UART_1, (int)&((pin_function_t){&MXC_IOMAN->uart1_req, &MXC_IOMAN->uart1_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_RTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_RTS_MAP | MXC_F_IOMAN_UART_ACK_RTS_IO_ACK)}) }, + { P3_2, UART_2, (int)&((pin_function_t){&MXC_IOMAN->uart2_req, &MXC_IOMAN->uart2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_RTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_RTS_MAP | MXC_F_IOMAN_UART_ACK_RTS_IO_ACK)}) }, + { P5_5, UART_3, (int)&((pin_function_t){&MXC_IOMAN->uart3_req, &MXC_IOMAN->uart3_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_UART_REQ_RTS_IO_REQ), (MXC_F_IOMAN_UART_ACK_RTS_MAP | MXC_F_IOMAN_UART_ACK_RTS_IO_ACK)}) }, + { NC, NC, 0 } +}; + +/************SPI***************/ +const PinMap PinMap_SPI_SCLK[] = { + { P0_4, SPI_0, (int)&((pin_function_t){&MXC_IOMAN->spim0_req, &MXC_IOMAN->spim0_ack, MXC_F_IOMAN_SPIM_REQ_CORE_IO_REQ, MXC_F_IOMAN_SPIM_ACK_CORE_IO_ACK}) }, + { P1_0, SPI_1, (int)&((pin_function_t){&MXC_IOMAN->spim1_req, &MXC_IOMAN->spim1_ack, MXC_F_IOMAN_SPIM_REQ_CORE_IO_REQ, MXC_F_IOMAN_SPIM_ACK_CORE_IO_ACK}) }, + { P2_4, SPI_2, (int)&((pin_function_t){&MXC_IOMAN->spim2_req, &MXC_IOMAN->spim2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_SPIM_REQ_CORE_IO_REQ), (MXC_F_IOMAN_SPIM_REQ_MAPPING_REQ | MXC_F_IOMAN_SPIM_ACK_CORE_IO_ACK)}) }, + { P5_0, SPI_2, (int)&((pin_function_t){&MXC_IOMAN->spim2_req, &MXC_IOMAN->spim2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_SPIM_REQ_CORE_IO_REQ), (MXC_F_IOMAN_SPIM_REQ_MAPPING_REQ | MXC_F_IOMAN_SPIM_ACK_CORE_IO_ACK)}) }, + { NC, NC, 0 } +}; + +const PinMap PinMap_SPI_MOSI[] = { + { P0_5, SPI_0, (int)&((pin_function_t){&MXC_IOMAN->spim0_req, &MXC_IOMAN->spim0_ack, MXC_F_IOMAN_SPIM_REQ_CORE_IO_REQ, MXC_F_IOMAN_SPIM_ACK_CORE_IO_ACK}) }, + { P1_1, SPI_1, (int)&((pin_function_t){&MXC_IOMAN->spim1_req, &MXC_IOMAN->spim1_ack, MXC_F_IOMAN_SPIM_REQ_CORE_IO_REQ, MXC_F_IOMAN_SPIM_ACK_CORE_IO_ACK}) }, + { P2_5, SPI_2, (int)&((pin_function_t){&MXC_IOMAN->spim2_req, &MXC_IOMAN->spim2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_SPIM_REQ_CORE_IO_REQ), (MXC_F_IOMAN_SPIM_REQ_MAPPING_REQ | MXC_F_IOMAN_SPIM_ACK_CORE_IO_ACK)}) }, + { P5_1, SPI_2, (int)&((pin_function_t){&MXC_IOMAN->spim2_req, &MXC_IOMAN->spim2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_SPIM_REQ_CORE_IO_REQ), (MXC_F_IOMAN_SPIM_REQ_MAPPING_REQ | MXC_F_IOMAN_SPIM_ACK_CORE_IO_ACK)}) }, + { NC, NC, 0 } +}; + +const PinMap PinMap_SPI_MISO[] = { + { P0_6, SPI_0, (int)&((pin_function_t){&MXC_IOMAN->spim0_req, &MXC_IOMAN->spim0_ack, MXC_F_IOMAN_SPIM_REQ_CORE_IO_REQ, MXC_F_IOMAN_SPIM_ACK_CORE_IO_ACK}) }, + { P1_2, SPI_1, (int)&((pin_function_t){&MXC_IOMAN->spim1_req, &MXC_IOMAN->spim1_ack, MXC_F_IOMAN_SPIM_REQ_CORE_IO_REQ, MXC_F_IOMAN_SPIM_ACK_CORE_IO_ACK}) }, + { P2_6, SPI_2, (int)&((pin_function_t){&MXC_IOMAN->spim2_req, &MXC_IOMAN->spim2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_SPIM_REQ_CORE_IO_REQ), (MXC_F_IOMAN_SPIM_REQ_MAPPING_REQ | MXC_F_IOMAN_SPIM_ACK_CORE_IO_ACK)}) }, + { P5_2, SPI_2, (int)&((pin_function_t){&MXC_IOMAN->spim2_req, &MXC_IOMAN->spim2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_SPIM_REQ_CORE_IO_REQ), (MXC_F_IOMAN_SPIM_REQ_MAPPING_REQ | MXC_F_IOMAN_SPIM_ACK_CORE_IO_ACK)}) }, + { NC, NC, 0 } +}; + +const PinMap PinMap_SPI_SSEL[] = { + { P0_7, SPI_0, (int)&((pin_function_t){&MXC_IOMAN->spim0_req, &MXC_IOMAN->spim0_ack, MXC_F_IOMAN_SPIM_REQ_SS0_IO_REQ, MXC_F_IOMAN_SPIM_ACK_SS0_IO_ACK}) }, + { P1_3, SPI_1, (int)&((pin_function_t){&MXC_IOMAN->spim1_req, &MXC_IOMAN->spim1_ack, MXC_F_IOMAN_SPIM_REQ_SS0_IO_REQ, MXC_F_IOMAN_SPIM_ACK_SS0_IO_ACK}) }, + { P2_7, SPI_2, (int)&((pin_function_t){&MXC_IOMAN->spim2_req, &MXC_IOMAN->spim2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_A | MXC_F_IOMAN_SPIM_REQ_SS0_IO_REQ), (MXC_F_IOMAN_SPIM_REQ_MAPPING_REQ | MXC_F_IOMAN_SPIM_ACK_SS0_IO_ACK)}) }, + { P5_3, SPI_2, (int)&((pin_function_t){&MXC_IOMAN->spim2_req, &MXC_IOMAN->spim2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_SPIM_REQ_SS0_IO_REQ | MXC_F_IOMAN_SPIM_REQ_SR0_IO_REQ), (MXC_F_IOMAN_SPIM_REQ_MAPPING_REQ | MXC_F_IOMAN_SPIM_ACK_SS0_IO_ACK | MXC_F_IOMAN_SPIM_ACK_SR0_IO_ACK)}) }, + { NC, NC, 0 } +}; + +const PinMap PinMap_SPI_QUAD[] = { + { P0_4, SPI_0, (int)&((pin_function_t){&MXC_IOMAN->spim0_req, &MXC_IOMAN->spim0_ack, MXC_F_IOMAN_SPIM_REQ_QUAD_IO_REQ, MXC_F_IOMAN_SPIM_ACK_QUAD_IO_ACK}) }, + { P1_0, SPI_1, (int)&((pin_function_t){&MXC_IOMAN->spim1_req, &MXC_IOMAN->spim1_ack, MXC_F_IOMAN_SPIM_REQ_QUAD_IO_REQ, MXC_F_IOMAN_SPIM_ACK_QUAD_IO_ACK}) }, + { P5_0, SPI_2, (int)&((pin_function_t){&MXC_IOMAN->spim2_req, &MXC_IOMAN->spim2_ack, ((uint32_t)MXC_E_IOMAN_MAPPING_B | MXC_F_IOMAN_SPIM_REQ_CORE_IO_REQ | MXC_F_IOMAN_SPIM_REQ_QUAD_IO_REQ), (MXC_F_IOMAN_SPIM_REQ_MAPPING_REQ | MXC_F_IOMAN_SPIM_ACK_CORE_IO_ACK | MXC_F_IOMAN_SPIM_ACK_QUAD_IO_ACK)}) }, + { NC, NC, 0 } +}; + +/************PWM***************/ +const PinMap PinMap_PWM[] = { + { P0_0, PWM_0, 1 }, { P2_0, PWM_0, 1 }, { P4_0, PWM_0, 1 }, {P6_0, PWM_0, 1}, + { P0_1, PWM_1, 1 }, { P2_1, PWM_1, 1 }, { P4_1, PWM_1, 1 }, + { P0_2, PWM_2, 1 }, { P2_2, PWM_2, 1 }, { P4_2, PWM_2, 1 }, + { P0_3, PWM_3, 1 }, { P2_3, PWM_3, 1 }, { P4_3, PWM_3, 1 }, + { P0_4, PWM_4, 1 }, { P2_4, PWM_4, 1 }, { P4_4, PWM_4, 1 }, + { P0_5, PWM_5, 1 }, { P2_5, PWM_5, 1 }, { P4_5, PWM_5, 1 }, + { P0_6, PWM_6, 1 }, { P2_6, PWM_6, 1 }, { P4_6, PWM_6, 1 }, + { P0_7, PWM_7, 1 }, { P2_7, PWM_7, 1 }, { P4_7, PWM_7, 1 }, + { P1_0, PWM_8, 1 }, { P3_0, PWM_8, 1 }, { P5_0, PWM_8, 1 }, + { P1_1, PWM_9, 1 }, { P3_1, PWM_9, 1 }, { P5_1, PWM_9, 1 }, + { P1_2, PWM_10, 1 }, { P3_2, PWM_10, 1 }, { P5_2, PWM_10, 1 }, + { P1_3, PWM_11, 1 }, { P3_3, PWM_11, 1 }, { P5_3, PWM_11, 1 }, + { P1_4, PWM_12, 1 }, { P3_4, PWM_12, 1 }, { P5_4, PWM_12, 1 }, + { P1_5, PWM_13, 1 }, { P3_5, PWM_13, 1 }, { P5_5, PWM_13, 1 }, + { P1_6, PWM_14, 1 }, { P3_6, PWM_14, 1 }, { P5_6, PWM_14, 1 }, + { P1_7, PWM_15, 1 }, { P3_7, PWM_15, 1 }, { P5_7, PWM_15, 1 }, + { NC, NC, 0 } +}; + +/************ADC***************/ +const PinMap PinMap_ADC[] = { + { AIN_0, ADC, 0 }, + { AIN_1, ADC, 0 }, + { AIN_2, ADC, 0 }, + { AIN_3, ADC, 0 }, + { NC, NC, 0 } +}; diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/PeripheralPins.h b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/PeripheralPins.h new file mode 100644 index 0000000000..b0be1060db --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/PeripheralPins.h @@ -0,0 +1,63 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef MBED_PERIPHERALPINS_H +#define MBED_PERIPHERALPINS_H + +#include "pinmap.h" +#include "PeripheralNames.h" + +/************I2C***************/ +extern const PinMap PinMap_I2C_SDA[]; +extern const PinMap PinMap_I2C_SCL[]; + +/************UART***************/ +extern const PinMap PinMap_UART_TX[]; +extern const PinMap PinMap_UART_RX[]; +extern const PinMap PinMap_UART_CTS[]; +extern const PinMap PinMap_UART_RTS[]; + +/************SPI***************/ +extern const PinMap PinMap_SPI_SCLK[]; +extern const PinMap PinMap_SPI_MOSI[]; +extern const PinMap PinMap_SPI_MISO[]; +extern const PinMap PinMap_SPI_SSEL[]; +extern const PinMap PinMap_SPI_QUAD[]; + +/************PWM***************/ +extern const PinMap PinMap_PWM[]; + +/************ADC***************/ +extern const PinMap PinMap_ADC[]; + +#endif diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/PortNames.h b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/PortNames.h new file mode 100644 index 0000000000..56100a806a --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/PortNames.h @@ -0,0 +1,54 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef MBED_PORTNAMES_H +#define MBED_PORTNAMES_H + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + Port0 = 0, + Port1 = 1, + Port2 = 2, + Port3 = 3, + Port4 = 4, + Port5 = 5, + Port6 = 6, +} PortName; + +#ifdef __cplusplus +} +#endif +#endif diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/TARGET_MAX32620HSP/PeripheralNames.h b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/TARGET_MAX32620HSP/PeripheralNames.h new file mode 100644 index 0000000000..8e65efe61c --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/TARGET_MAX32620HSP/PeripheralNames.h @@ -0,0 +1,90 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef MBED_PERIPHERALNAMES_H +#define MBED_PERIPHERALNAMES_H + +#include "cmsis.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + UART_0 = MXC_BASE_UART0, + UART_1 = MXC_BASE_UART1, + UART_2 = MXC_BASE_UART2, + UART_3 = MXC_BASE_UART3, + STDIO_UART = UART_0 +} UARTName; + +typedef enum { + I2C_0 = MXC_BASE_I2CM0, + I2C_1 = MXC_BASE_I2CM1, + I2C_2 = MXC_BASE_I2CM2 +} I2CName; + +typedef enum { + SPI_0 = MXC_BASE_SPI0, + SPI_1 = MXC_BASE_SPI1, + SPI_2 = MXC_BASE_SPI2 +} SPIName; + +typedef enum { + PWM_0 = MXC_BASE_PT0, + PWM_1 = MXC_BASE_PT1, + PWM_2 = MXC_BASE_PT2, + PWM_3 = MXC_BASE_PT3, + PWM_4 = MXC_BASE_PT4, + PWM_5 = MXC_BASE_PT5, + PWM_6 = MXC_BASE_PT6, + PWM_7 = MXC_BASE_PT7, + PWM_8 = MXC_BASE_PT8, + PWM_9 = MXC_BASE_PT9, + PWM_10 = MXC_BASE_PT10, + PWM_11 = MXC_BASE_PT11, + PWM_12 = MXC_BASE_PT12, + PWM_13 = MXC_BASE_PT13, + PWM_14 = MXC_BASE_PT14, + PWM_15 = MXC_BASE_PT15 +} PWMName; + +typedef enum { + ADC = MXC_BASE_ADC +} ADCName; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/TARGET_MAX32620HSP/PinNames.h b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/TARGET_MAX32620HSP/PinNames.h new file mode 100644 index 0000000000..0ba72913b5 --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/TARGET_MAX32620HSP/PinNames.h @@ -0,0 +1,212 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef MBED_PINNAMES_H +#define MBED_PINNAMES_H + +#include "cmsis.h" +#include "gpio_regs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + PIN_INPUT = MXC_V_GPIO_OUT_MODE_NORMAL_HIGH_Z, + PIN_OUTPUT = MXC_V_GPIO_OUT_MODE_NORMAL +} PinDirection; + +#define PORT_SHIFT 12 +#define PINNAME_TO_PORT(name) ((unsigned int)(name) >> PORT_SHIFT) +#define PINNAME_TO_PIN(name) ((unsigned int)(name) & ~(0xFFFFFFFF << PORT_SHIFT)) + +#define NOT_CONNECTED (int)0xFFFFFFFF + +typedef enum { + P0_0 = (0 << PORT_SHIFT) | 0, + P0_1 = (0 << PORT_SHIFT) | 1, + P0_2 = (0 << PORT_SHIFT) | 2, + P0_3 = (0 << PORT_SHIFT) | 3, + P0_4 = (0 << PORT_SHIFT) | 4, + P0_5 = (0 << PORT_SHIFT) | 5, + P0_6 = (0 << PORT_SHIFT) | 6, + P0_7 = (0 << PORT_SHIFT) | 7, + + P1_0 = (1 << PORT_SHIFT) | 0, + P1_1 = (1 << PORT_SHIFT) | 1, + P1_2 = (1 << PORT_SHIFT) | 2, + P1_3 = (1 << PORT_SHIFT) | 3, + P1_4 = (1 << PORT_SHIFT) | 4, + P1_5 = (1 << PORT_SHIFT) | 5, + P1_6 = (1 << PORT_SHIFT) | 6, + P1_7 = (1 << PORT_SHIFT) | 7, + + P2_0 = (2 << PORT_SHIFT) | 0, + P2_1 = (2 << PORT_SHIFT) | 1, + P2_2 = (2 << PORT_SHIFT) | 2, + P2_3 = (2 << PORT_SHIFT) | 3, + P2_4 = (2 << PORT_SHIFT) | 4, + P2_5 = (2 << PORT_SHIFT) | 5, + P2_6 = (2 << PORT_SHIFT) | 6, + P2_7 = (2 << PORT_SHIFT) | 7, + + P3_0 = (3 << PORT_SHIFT) | 0, + P3_1 = (3 << PORT_SHIFT) | 1, + P3_2 = (3 << PORT_SHIFT) | 2, + P3_3 = (3 << PORT_SHIFT) | 3, + P3_4 = (3 << PORT_SHIFT) | 4, + P3_5 = (3 << PORT_SHIFT) | 5, + P3_6 = (3 << PORT_SHIFT) | 6, + P3_7 = (3 << PORT_SHIFT) | 7, + + P4_0 = (4 << PORT_SHIFT) | 0, + P4_1 = (4 << PORT_SHIFT) | 1, + P4_2 = (4 << PORT_SHIFT) | 2, + P4_3 = (4 << PORT_SHIFT) | 3, + P4_4 = (4 << PORT_SHIFT) | 4, + P4_5 = (4 << PORT_SHIFT) | 5, + P4_6 = (4 << PORT_SHIFT) | 6, + P4_7 = (4 << PORT_SHIFT) | 7, + + P5_0 = (5 << PORT_SHIFT) | 0, + P5_1 = (5 << PORT_SHIFT) | 1, + P5_2 = (5 << PORT_SHIFT) | 2, + P5_3 = (5 << PORT_SHIFT) | 3, + P5_4 = (5 << PORT_SHIFT) | 4, + P5_5 = (5 << PORT_SHIFT) | 5, + P5_6 = (5 << PORT_SHIFT) | 6, + P5_7 = (5 << PORT_SHIFT) | 7, + + P6_0 = (6 << PORT_SHIFT) | 0, + + // Analog input pins + AIN_0 = (0xA << PORT_SHIFT) | 0, + AIN_1 = (0xA << PORT_SHIFT) | 1, + AIN_2 = (0xA << PORT_SHIFT) | 2, + AIN_3 = (0xA << PORT_SHIFT) | 3, + + // LEDs + LED_RED = P2_0, + LED1 = LED_RED, + LED2 = NOT_CONNECTED, + LED3 = NOT_CONNECTED, + LED4 = NOT_CONNECTED, + + // Push button + SW1 = P2_1, + SW2 = NOT_CONNECTED, + SW3 = NOT_CONNECTED, + + // USB bridge connected UART pins + USBTX = P0_1, + USBRX = P0_0, + STDIO_UART_TX = USBTX, + STDIO_UART_RX = USBRX, + + // I2C pins + I2C0_SCL = NOT_CONNECTED, + I2C0_SDA = NOT_CONNECTED, + + I2C1_SCL = P3_5, + I2C1_SDA = P3_4, + + I2C2_SCL = P6_0, + I2C2_SDA = P5_7, + + // UART pins + UART0_RX = P0_0, + UART0_TX = P0_1, + UART0_CTS = NOT_CONNECTED, + UART0_RTS = NOT_CONNECTED, + + UART1_RX = P2_0, + UART1_TX = P2_1, + UART1_CTS = NOT_CONNECTED, + UART1_RTS = NOT_CONNECTED, + + UART2_RX = NOT_CONNECTED, + UART2_TX = NOT_CONNECTED, + UART2_CTS = NOT_CONNECTED, + UART2_RTS = NOT_CONNECTED, + + UART3_RX = NOT_CONNECTED, + UART3_TX = NOT_CONNECTED, + UART3_CTS = NOT_CONNECTED, + UART3_RTS = NOT_CONNECTED, + + // SPI pins + SPI0_SCK = P0_4, + SPI0_MOSI = P0_5, + SPI0_MISO = P0_6, + SPI0_SS = P0_7, + + SPI1_SCK = P1_0, + SPI1_MOSI = P1_1, + SPI1_MISO = P1_2, + SPI1_SS = P1_3, + + SPI2_SCK = NOT_CONNECTED, + SPI2_MOSI = NOT_CONNECTED, + SPI2_MISO = NOT_CONNECTED, + SPI2_SS = NOT_CONNECTED, + + // BTLE Radio HCI + HCI_SCK = P5_0, + HCI_MOSI = P5_1, + HCI_MISO = P5_2, + HCI_CSN = P5_3, + HCI_IRQ = P5_6, + HCI_RST = P4_2, + + // Not connected + NC = NOT_CONNECTED +} PinName; + +typedef enum { + PullUp, + PullDown, + OpenDrain, + PullNone, + PullDefault = PullUp +} PinMode; + +typedef enum { + LED_ON = 0, + LED_OFF = 1 +} LedStates; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/TARGET_MAX32620HSP/low_level_init.c b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/TARGET_MAX32620HSP/low_level_init.c new file mode 100644 index 0000000000..24ad45eb1c --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/TARGET_MAX32620HSP/low_level_init.c @@ -0,0 +1,51 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include "cmsis.h" +#include "pwrman_regs.h" + +//****************************************************************************** +// This function will get called early in system initialization +void low_level_init(void) +{ + /* HSP platform does not have an external HW reset. During development, + * debug triggered resets do not reset the entire system properly. This + * work-around ensures a proper system reset. + */ + if (*((volatile uint32_t*)MXC_SYS_MEM_BASE) != 0xDEADBEEF) { + *((volatile uint32_t*)MXC_SYS_MEM_BASE) = 0xDEADBEEF; + MXC_PWRMAN->pwr_rst_ctrl |= MXC_F_PWRMAN_PWR_RST_CTRL_FIRMWARE_RESET; + } else { + *((volatile uint32_t*)MXC_SYS_MEM_BASE) = 0; + } +} diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_GCC_ARM/libexactLE.a b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/TOOLCHAIN_GCC_ARM/libexactLE.a new file mode 100644 index 0000000000000000000000000000000000000000..89004fdddb9fe5ccf707969977b892955010019c GIT binary patch literal 970456 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¼P%Hs;^5Xk7Q}KD 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 literal 0 HcmV?d00001 diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/analogin_api.c b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/analogin_api.c new file mode 100644 index 0000000000..f102b6dbde --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/analogin_api.c @@ -0,0 +1,146 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include "mbed_assert.h" +#include "analogin_api.h" +#include "clkman_regs.h" +#include "pwrman_regs.h" +#include "PeripheralPins.h" + +#define UNTRIM +#define MXC_BASE_FTR_TRIM_REG11 0x4000102C +#define MXC_BASE_FTR_TRIM_REG12 0x40001030 + +#define PGA_TRK_CNT 0x1F +#define ADC_ACT_CNT 0x1 +#define ADC_PGA_CNT 0x1 +#define ADC_ACQ_CNT 0x1 +#define ADC_SLP_CNT 0x1 + +#define ADC_FULL_SCALE 0x3FF +#define ADC_EXTERNAL_LAST_INPUT 3 + +// Only allow initialization once +static int initialized = 0; + +//****************************************************************************** +void analogin_init(analogin_t *obj, PinName pin) +{ + // Make sure pin is an analog pin we can use for ADC + MBED_ASSERT((ADCName)pinmap_peripheral(pin, PinMap_ADC) != (ADCName)NC); + + // Set the object pointer + obj->adc = MXC_ADC; + obj->adc_pin = pin; + + if (initialized == 0) { + // Enable AFE power + MXC_PWRMAN->pwr_rst_ctrl |= MXC_F_PWRMAN_PWR_RST_CTRL_AFE_POWERED; + + // Enable the clock + MXC_CLKMAN->clk_ctrl |= MXC_F_CLKMAN_CLK_CTRL_ADC_CLOCK_ENABLE; + + // Enable clock gate + MXC_CLKMAN->clk_gate_ctrl2 |= MXC_F_CLKMAN_CLK_GATE_CTRL2_ADC_CLK_GATER; + + // Enable interface clock + obj->adc->ctrl |= MXC_F_ADC_CTRL_ADC_CLK_EN; + +#ifdef UNTRIM + *(volatile uint32_t *) MXC_BASE_FTR_TRIM_REG11 = 0x02000200; + *(volatile uint32_t *) MXC_BASE_FTR_TRIM_REG12 = 0x02000200; +#endif + + // Clear ADC ready interrupt (wite 1 to clr) + obj->adc->intr = (obj->adc->intr & 0xFFFF) | MXC_F_ADC_INTR_ADC_REF_READY_IF; + + // Using internal reference of 1.20V + + // Enable ADC power bypass the buffer + obj->adc->ctrl |= (MXC_F_ADC_CTRL_ADC_PU | MXC_F_ADC_CTRL_ADC_REFBUF_PU | + MXC_F_ADC_CTRL_ADC_CHGPUMP_PU | MXC_F_ADC_CTRL_BUF_BYPASS); + + // Wait for ADC ready + while ( !(obj->adc->intr & MXC_F_ADC_INTR_ADC_REF_READY_IF) ); + + initialized = 1; + } +} + +//****************************************************************************** +float analogin_read(analogin_t *obj) +{ + // Convert integer to float + return (((float)analogin_read_u16(obj)/(float)ADC_FULL_SCALE)); +} + +//****************************************************************************** +uint16_t analogin_read_u16(analogin_t *obj) +{ + // Set the pin to take readings from + uint32_t adc_input = PINNAME_TO_PIN(obj->adc_pin); + + // Select the channel + obj->adc->ctrl &= ~MXC_F_ADC_CTRL_ADC_CHSEL; + obj->adc->ctrl |= (adc_input << MXC_F_ADC_CTRL_ADC_CHSEL_POS) & MXC_F_ADC_CTRL_ADC_CHSEL; + + // We want unity gain, to get full 0-Vref range + // So, both ref and adc input scale should be enabled + obj->adc->ctrl |= MXC_F_ADC_CTRL_ADC_SCALE | MXC_F_ADC_CTRL_ADC_REFSCL; + + // Not using internal buffer, disable anyway + obj->adc->ctrl &= ~MXC_F_ADC_CTRL_BUF_PU; + obj->adc->ctrl |= MXC_F_ADC_CTRL_BUF_BYPASS; + + // Normal LSB justified data alignment + + // Not using limits + + // Clear ADC done flag (wite 1 to clr) + obj->adc->intr = (obj->adc->intr & 0xFFFF) | MXC_F_ADC_INTR_ADC_DONE_IF; + + // Start the conversion + obj->adc->ctrl |= MXC_F_ADC_CTRL_CPU_ADC_START; + + // Wait for ADC done + while ( !(obj->adc->intr & MXC_F_ADC_INTR_ADC_DONE_IF) ); + + // Get sample from the fifo + uint16_t sample = (uint16_t)(obj->adc->data & 0xFFFF); + + // Check for overflow, hardware will report overflow as 0 + if ( (obj->adc->status & MXC_F_ADC_STATUS_ADC_OVERFLOW) == MXC_F_ADC_STATUS_ADC_OVERFLOW ) + sample = (uint16_t)ADC_FULL_SCALE; + + return sample; +} diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/device.h b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/device.h new file mode 100644 index 0000000000..af8fe76bb0 --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/device.h @@ -0,0 +1,40 @@ +// The 'features' section in 'target.json' is now used to create the device's hardware preprocessor switches. +// Check the 'features' section of the target description in 'targets.json' for more details. +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef MBED_DEVICE_H +#define MBED_DEVICE_H +#include "objects.h" + +#endif diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/gpio_api.c b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/gpio_api.c new file mode 100644 index 0000000000..2f745d7d9c --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/gpio_api.c @@ -0,0 +1,101 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include "mbed_assert.h" +#include "gpio_api.h" +#include "pinmap.h" +#include "gpio_regs.h" +#include "clkman_regs.h" + +uint32_t gpio_set(PinName name) +{ + MBED_ASSERT(name != (PinName)NC); + pin_function(name, 0); + return 1 << PINNAME_TO_PIN(name); +} + +void gpio_init(gpio_t *obj, PinName name) +{ + obj->name = name; + if (name == (PinName)NC) { + return; + } + + unsigned int port = PINNAME_TO_PORT(name); + unsigned int pin = PINNAME_TO_PIN(name); + + obj->reg_out = (uint32_t*)BITBAND(&MXC_GPIO->out_val[port], pin); + obj->reg_in = (uint32_t*)BITBAND(&MXC_GPIO->in_val[port], pin); + + /* Ensure that the GPIO clock is enabled */ + MXC_CLKMAN->clk_gate_ctrl1 |= MXC_F_CLKMAN_CLK_GATE_CTRL1_GPIO_CLK_GATER; + + /* Ensure that the GPIO clock is enabled */ + MXC_CLKMAN->sys_clk_ctrl_6_gpio = MXC_S_CLKMAN_CLK_SCALE_DIV_1; +} + +void gpio_mode(gpio_t *obj, PinMode mode) +{ + pin_mode(obj->name, mode); +} + +void pin_dir(PinName name, PinDirection direction) +{ + MBED_ASSERT(name != (PinName)NC); + + unsigned int port = PINNAME_TO_PORT(name); + unsigned int pin = PINNAME_TO_PIN(name); + + /* Set function; Firmware Control (GPIO mode) */ + MXC_GPIO->func_sel[port] &= ~(0xF << (4 * pin)); + + /* Normal input is always enabled */ + MXC_GPIO->in_mode[port] &= ~(0xF << (4 * pin)); + + if (direction == PIN_INPUT) { + /* Set requested output mode */ + MXC_GPIO->out_mode[port] = (MXC_GPIO->out_mode[port] & ~(0xF << (4 * pin))) | (MXC_V_GPIO_OUT_MODE_HIGH_Z_WEAK_PULLUP << (4 * pin)); + + /* Enable default input weak pull-up by setting corresponding output */ + MXC_GPIO->out_val[port] |= 1 << pin; + } + else { + /* Set requested output mode */ + MXC_GPIO->out_mode[port] = (MXC_GPIO->out_mode[port] & ~(0xF << (4 * pin))) | (MXC_V_GPIO_OUT_MODE_NORMAL << (4 * pin)); + } +} + +void gpio_dir(gpio_t *obj, PinDirection direction) +{ + pin_dir(obj->name, direction); +} diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/gpio_irq_api.c b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/gpio_irq_api.c new file mode 100644 index 0000000000..07bf71e5fc --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/gpio_irq_api.c @@ -0,0 +1,286 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include +#include "cmsis.h" +#include "gpio_irq_api.h" +#include "mbed_error.h" +#include "ioman_regs.h" +#include "pwrman_regs.h" +#include "pwrseq_regs.h" + +static gpio_irq_t *objs[MXC_GPIO_NUM_PORTS][MXC_GPIO_MAX_PINS_PER_PORT] = {{0}}; +static gpio_irq_handler irq_handler; + +static void gpio_irq_wud_req(gpio_irq_t *obj) +{ + unsigned int port = obj->port; + unsigned int pin = obj->pin; + uint32_t pin_mask = 1 << pin; + + /* Ports 0-3 are controlled by wud_req0, while 4-7 are controlled by wud_req1 */ + /* During the time the WUD IOMAN requests are asserted (1), the GPIO Pad */ + /* is in HIGH Z mode, regardless of GPIO setting. This may cause bogus interrupts. */ + if (port < 4) { + uint32_t mask = pin_mask << (port << 3); + if (!(MXC_IOMAN->wud_ack0 & mask)) { + MXC_IOMAN->wud_req0 |= mask; + while(!(MXC_IOMAN->wud_ack0 & mask)); + } + } else if (port < 8) { + uint32_t mask = pin_mask << ((port-4) << 3); + if (!(MXC_IOMAN->wud_ack1 & mask)) { + MXC_IOMAN->wud_req1 |= mask; + while(!(MXC_IOMAN->wud_ack1 & mask)); + } + } +} + +/* Clear the selected pin from wake-up detect */ +static void gpio_irq_wud_clear(gpio_irq_t *obj) +{ + unsigned int port = obj->port; + unsigned int pin = obj->pin; + + /* Enable modifications to WUD configuration */ + MXC_PWRMAN->wud_ctrl = MXC_F_PWRMAN_WUD_CTRL_CTRL_ENABLE; + + /* Select pad in WUD control */ + /* Note: Pads are numbered from 0-48; {0-7} => {P0.0-P0.7}, {8-15} => {P1.0-P1.7}, etc. */ + MXC_PWRMAN->wud_ctrl |= (port * 8) + pin; + + /* Clear any existing WUD configuration for this pad */ + MXC_PWRMAN->wud_ctrl &= ~(MXC_F_PWRMAN_WUD_CTRL_PAD_MODE); + MXC_PWRMAN->wud_ctrl |= (MXC_E_PWRMAN_PAD_MODE_CLEAR_SET << MXC_F_PWRMAN_WUD_CTRL_PAD_MODE_POS); + /* Clear with PULSE0; PULSE1 enables WUD */ + MXC_PWRMAN->wud_pulse0 = 1; + + /* Disable configuration */ + MXC_PWRMAN->wud_ctrl = 0; + MXC_IOMAN->wud_req0 = 0; + MXC_IOMAN->wud_req1 = 0; +} + +/* Configure the selected pin for wake-up detect */ +static void gpio_irq_wud_config(gpio_irq_t *obj) +{ + unsigned int port = obj->port; + unsigned int pin = obj->pin; + uint32_t pin_mask = 1 << pin; + + /* Enable modifications to WUD configuration */ + MXC_PWRMAN->wud_ctrl = MXC_F_PWRMAN_WUD_CTRL_CTRL_ENABLE; + + /* Select pad in WUD control */ + /* Note: Pads are numbered from 0-48; {0-7} => {P0.0-P0.7}, {8-15} => {P1.0-P1.7}, etc. */ + MXC_PWRMAN->wud_ctrl |= (port * 8) + pin; + + /* First clear any existing WUD configuration for this pad */ + MXC_PWRMAN->wud_ctrl &= ~(MXC_F_PWRMAN_WUD_CTRL_PAD_MODE); + MXC_PWRMAN->wud_ctrl |= (MXC_E_PWRMAN_PAD_MODE_CLEAR_SET << MXC_F_PWRMAN_WUD_CTRL_PAD_MODE_POS); + /* Clear with PULSE0; PULSE1 enables WUD */ + MXC_PWRMAN->wud_pulse0 = 1; + + if (obj->fall_en || obj->rise_en) { + /* Configure sense level on this pad */ + MXC_PWRMAN->wud_ctrl &= ~(MXC_F_PWRMAN_WUD_CTRL_PAD_MODE); + MXC_PWRMAN->wud_ctrl |= (MXC_E_PWRMAN_PAD_MODE_ACT_HI_LO << MXC_F_PWRMAN_WUD_CTRL_PAD_MODE_POS); + + uint32_t in_val = MXC_GPIO->in_val[port] & pin_mask; + do { + if (in_val) { + /* Select active low with PULSE1 (backwards from what you'd expect) */ + MXC_PWRMAN->wud_pulse1 = 1; + } else { + /* Select active high with PULSE0 (backwards from what you'd expect) */ + MXC_PWRMAN->wud_pulse0 = 1; + } + } while ((MXC_GPIO->in_val[port] & pin_mask) != in_val); + + /* Select this pad to have the wake-up function enabled */ + MXC_PWRMAN->wud_ctrl &= ~(MXC_F_PWRMAN_WUD_CTRL_PAD_MODE); + MXC_PWRMAN->wud_ctrl |= (MXC_E_PWRMAN_PAD_MODE_CLEAR_SET << MXC_F_PWRMAN_WUD_CTRL_PAD_MODE_POS); + /* Activate with PULSE1 */ + MXC_PWRMAN->wud_pulse1 = 1; + + // NOTE: Low Power Pullup/down is not normally needed in addition to + // standard GPIO Pullup/downs. + + /* Enable IOWakeup, as there is at least 1 GPIO pin configured as a wake source */ + MXC_PWRSEQ->msk_flags |= MXC_F_PWRSEQ_MSK_FLAGS_PWR_IOWAKEUP; + } + + /* Disable configuration */ + MXC_PWRMAN->wud_ctrl = 0; + MXC_IOMAN->wud_req0 = 0; + MXC_IOMAN->wud_req1 = 0; +} + +static void handle_irq(unsigned int port) +{ + uint32_t intfl, in_val; + uint32_t mask; + unsigned int pin; + + /* Read pin state */ + in_val = MXC_GPIO->in_val[port]; + + /* Read interrupts */ + intfl = MXC_GPIO->intfl[port] & MXC_GPIO->inten[port]; + + mask = 1; + + for (pin = 0; pin < MXC_GPIO_MAX_PINS_PER_PORT; pin++) { + if (intfl & mask) { + MXC_GPIO->intfl[port] = mask; /* clear interrupt */ + gpio_irq_event event = (in_val & mask) ? IRQ_RISE : IRQ_FALL; + gpio_irq_t *obj = objs[port][pin]; + if (obj && obj->id) { + if ((event == IRQ_RISE) && obj->rise_en) { + irq_handler(obj->id, IRQ_RISE); + } else if ((event == IRQ_FALL) && obj->fall_en) { + irq_handler(obj->id, IRQ_FALL); + } + } + + gpio_irq_wud_config(obj); + } + mask <<= 1; + } +} + +void gpio_irq_0(void) { handle_irq(0); } +void gpio_irq_1(void) { handle_irq(1); } +void gpio_irq_2(void) { handle_irq(2); } +void gpio_irq_3(void) { handle_irq(3); } +void gpio_irq_4(void) { handle_irq(4); } +void gpio_irq_5(void) { handle_irq(5); } +void gpio_irq_6(void) { handle_irq(6); } + +int gpio_irq_init(gpio_irq_t *obj, PinName name, gpio_irq_handler handler, uint32_t id) +{ + if (name == NC) { + return -1; + } + + uint8_t port = PINNAME_TO_PORT(name); + uint8_t pin = PINNAME_TO_PIN(name); + + if ((port > MXC_GPIO_NUM_PORTS) || (pin > MXC_GPIO_MAX_PINS_PER_PORT)) { + return 1; + } + + obj->port = port; + obj->pin = pin; + obj->id = id; + objs[port][pin] = obj; + + /* register handlers */ + irq_handler = handler; + NVIC_SetVector(GPIO_P0_IRQn, (uint32_t)gpio_irq_0); + NVIC_SetVector(GPIO_P1_IRQn, (uint32_t)gpio_irq_1); + NVIC_SetVector(GPIO_P2_IRQn, (uint32_t)gpio_irq_2); + NVIC_SetVector(GPIO_P3_IRQn, (uint32_t)gpio_irq_3); + NVIC_SetVector(GPIO_P4_IRQn, (uint32_t)gpio_irq_4); + NVIC_SetVector(GPIO_P5_IRQn, (uint32_t)gpio_irq_5); + NVIC_SetVector(GPIO_P6_IRQn, (uint32_t)gpio_irq_6); + + /* request WUD in case the application is going to sleep */ + gpio_irq_wud_req(obj); + + /* disable the interrupt locally */ + MXC_GPIO->int_mode[port] &= ~(0xF << (pin*4)); + + /* clear a pending request */ + MXC_GPIO->intfl[port] = 1 << pin; + + /* enable the requested interrupt */ + MXC_GPIO->inten[port] |= (1 << pin); + NVIC_EnableIRQ((IRQn_Type)((uint32_t)GPIO_P0_IRQn + port)); + + return 0; +} + +void gpio_irq_free(gpio_irq_t *obj) +{ + /* disable interrupt */ + MXC_GPIO->inten[obj->port] &= ~(1 << obj->pin); + MXC_GPIO->int_mode[obj->port] &= ~(MXC_V_GPIO_INT_MODE_ANY_EDGE << (obj->pin*4)); + objs[obj->port][obj->pin] = NULL; + gpio_irq_wud_clear(obj); +} + +void gpio_irq_set(gpio_irq_t *obj, gpio_irq_event event, uint32_t enable) +{ + if (event == IRQ_FALL) { + obj->fall_en = enable; + } else if (event == IRQ_RISE) { + obj->rise_en = enable; + } + + if (obj->fall_en || obj->rise_en) { + MXC_GPIO->int_mode[obj->port] |= (MXC_V_GPIO_INT_MODE_ANY_EDGE << (obj->pin*4)); + gpio_irq_wud_config(obj); /* enable WUD for this pin so we may wake from deepsleep as well */ + } else { + MXC_GPIO->int_mode[obj->port] &= (MXC_V_GPIO_INT_MODE_ANY_EDGE << (obj->pin*4)); + gpio_irq_wud_clear(obj); + } +} + +void gpio_irq_enable(gpio_irq_t *obj) +{ + MXC_GPIO->inten[obj->port] |= (1 << obj->pin); + gpio_irq_wud_config(obj); +} + +void gpio_irq_disable(gpio_irq_t *obj) +{ + MXC_GPIO->inten[obj->port] &= ~(1 << obj->pin); + gpio_irq_wud_clear(obj); +} + +gpio_irq_t *gpio_irq_get_obj(PinName name) +{ + if (name == NC) { + return NULL; + } + + unsigned int port = PINNAME_TO_PORT(name); + unsigned int pin = PINNAME_TO_PIN(name); + + if ((port > MXC_GPIO_NUM_PORTS) || (pin > MXC_GPIO_MAX_PINS_PER_PORT)) { + return NULL; + } + + return objs[port][pin]; +} diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/gpio_object.h b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/gpio_object.h new file mode 100644 index 0000000000..01107a86af --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/gpio_object.h @@ -0,0 +1,71 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef MBED_GPIO_OBJECT_H +#define MBED_GPIO_OBJECT_H + +#include "mbed_assert.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + PinName name; + __IO uint32_t *reg_out; + __I uint32_t *reg_in; +} gpio_t; + +static inline void gpio_write(gpio_t *obj, int value) +{ + MBED_ASSERT(obj->name != (PinName)NC); + *obj->reg_out = !!value; +} + +static inline int gpio_read(gpio_t *obj) +{ + MBED_ASSERT(obj->name != (PinName)NC); + return *obj->reg_in; +} + +void pin_dir(PinName name, PinDirection direction); + +static inline int gpio_is_connected(const gpio_t *obj) { + return obj->name != (PinName)NC; +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/i2c_api.c b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/i2c_api.c new file mode 100644 index 0000000000..2c5916485f --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/i2c_api.c @@ -0,0 +1,432 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include "mbed_assert.h" +#include "i2c_api.h" +#include "cmsis.h" +#include "i2cm_regs.h" +#include "clkman_regs.h" +#include "ioman_regs.h" +#include "PeripheralPins.h" + +#define I2C_SLAVE_ADDR_READ_BIT 0x0001 + +#ifndef MXC_I2CM_TX_TIMEOUT +#define MXC_I2CM_TX_TIMEOUT 0x5000 +#endif + +#ifndef MXC_I2CM_RX_TIMEOUT +#define MXC_I2CM_RX_TIMEOUT 0x5000 +#endif + +typedef enum { + /** 100KHz */ + MXC_E_I2CM_SPEED_100KHZ = 0, + /** 400KHz */ + MXC_E_I2CM_SPEED_400KHZ +} i2cm_speed_t; + +/* Clock divider lookup table */ +static const uint32_t clk_div_table[2][8] = { + /* MXC_E_I2CM_SPEED_100KHZ */ + { + /* 0: 12MHz */ ((6 << MXC_F_I2CM_FS_CLK_DIV_FS_FILTER_CLK_DIV_POS) | + (17 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_HI_CNT_POS) | + (72 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_LO_CNT_POS)), + /* 1: 24MHz */ ((12 << MXC_F_I2CM_FS_CLK_DIV_FS_FILTER_CLK_DIV_POS) | + (38 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_HI_CNT_POS) | + (144 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_LO_CNT_POS)), + /* 2: */ 0, /* not supported */ + /* 3: 48MHz */ ((24 << MXC_F_I2CM_FS_CLK_DIV_FS_FILTER_CLK_DIV_POS) | + (80 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_HI_CNT_POS) | + (288 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_LO_CNT_POS)), + /* 4: */ 0, /* not supported */ + /* 5: */ 0, /* not supported */ + /* 6: */ 0, /* not supported */ + /* 7: 96MHz */ ((48 << MXC_F_I2CM_FS_CLK_DIV_FS_FILTER_CLK_DIV_POS) | + (164 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_HI_CNT_POS) | + (576 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_LO_CNT_POS)), + }, + /* MXC_E_I2CM_SPEED_400KHZ */ + { + /* 0: 12MHz */ ((2 << MXC_F_I2CM_FS_CLK_DIV_FS_FILTER_CLK_DIV_POS) | + (1 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_HI_CNT_POS) | + (18 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_LO_CNT_POS)), + /* 1: 24MHz */ ((3 << MXC_F_I2CM_FS_CLK_DIV_FS_FILTER_CLK_DIV_POS) | + (5 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_HI_CNT_POS) | + (36 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_LO_CNT_POS)), + /* 2: */ 0, /* not supported */ + /* 3: 48MHz */ ((6 << MXC_F_I2CM_FS_CLK_DIV_FS_FILTER_CLK_DIV_POS) | + (15 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_HI_CNT_POS) | + (72 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_LO_CNT_POS)), + /* 4: */ 0, /* not supported */ + /* 5: */ 0, /* not supported */ + /* 6: */ 0, /* not supported */ + /* 7: 96MHz */ ((12 << MXC_F_I2CM_FS_CLK_DIV_FS_FILTER_CLK_DIV_POS) | + (33 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_HI_CNT_POS) | + (144 << MXC_F_I2CM_FS_CLK_DIV_FS_SCL_LO_CNT_POS)), + }, +}; + +void i2c_init(i2c_t *obj, PinName sda, PinName scl) +{ + // determine the I2C to use + I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA); + I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL); + mxc_i2cm_regs_t *i2c = (mxc_i2cm_regs_t*)pinmap_merge(i2c_sda, i2c_scl); + MBED_ASSERT((int)i2c != NC); + + obj->i2c = i2c; + obj->fifos = (mxc_i2cm_fifo_regs_t*)MXC_I2CM_GET_BASE_FIFO(MXC_I2CM_GET_IDX(i2c)); + obj->start_pending = 0; + obj->stop_pending = 0; + + // configure the pins + pinmap_pinout(sda, PinMap_I2C_SDA); + pinmap_pinout(scl, PinMap_I2C_SCL); + + // enable the clock + MXC_CLKMAN->sys_clk_ctrl_9_i2cm = MXC_S_CLKMAN_CLK_SCALE_DIV_1; + + // reset module + i2c->ctrl = MXC_F_I2CM_CTRL_MSTR_RESET_EN; + i2c->ctrl = 0; + + // set default frequency at 100k + i2c_frequency(obj, 100000); + + // set timeout to 255 ms and turn on the auto-stop option + i2c->timeout = (0xFF << MXC_F_I2CM_TIMEOUT_TX_TIMEOUT_POS) | MXC_F_I2CM_TIMEOUT_AUTO_STOP_EN; + + // enable tx_fifo and rx_fifo + i2c->ctrl |= (MXC_F_I2CM_CTRL_TX_FIFO_EN | MXC_F_I2CM_CTRL_RX_FIFO_EN); +} + +void i2c_frequency(i2c_t *obj, int hz) +{ + // compute clock array index + // (96Mhz/12M) -1 = 7 + // (48Mhz/12M) -1 = 3 + // (24Mhz/12M) -1 = 1 + // (12Mhz/12M) -1 = 0 + int clki = (SystemCoreClock / 12000000) - 1; + + // get clock divider settings from lookup table + if ((hz < 400000) && (clk_div_table[MXC_E_I2CM_SPEED_100KHZ][clki] > 0)) { + obj->i2c->fs_clk_div = clk_div_table[MXC_E_I2CM_SPEED_100KHZ][clki]; + } else if ((hz >= 400000) && (clk_div_table[MXC_E_I2CM_SPEED_400KHZ][clki] > 0)) { + obj->i2c->fs_clk_div = clk_div_table[MXC_E_I2CM_SPEED_400KHZ][clki]; + } +} + +static int write_tx_fifo(i2c_t *obj, const uint16_t data) +{ + int timeout = MXC_I2CM_TX_TIMEOUT; + + while (*obj->fifos->trans) { + uint32_t intfl = obj->i2c->intfl; + if (intfl & MXC_F_I2CM_INTFL_TX_NACKED) { + return I2C_ERROR_NO_SLAVE; + } + if (!timeout || (intfl & (MXC_F_I2CM_INTFL_TX_TIMEOUT | MXC_F_I2CM_INTFL_TX_LOST_ARBITR))) { + return I2C_ERROR_BUS_BUSY; + } + timeout--; + } + *obj->fifos->trans = data; + + return 0; +} + +static int wait_tx_in_progress(i2c_t *obj) +{ + int timeout = MXC_I2CM_TX_TIMEOUT; + + while ((obj->i2c->trans & MXC_F_I2CM_TRANS_TX_IN_PROGRESS) && --timeout); + + uint32_t intfl = obj->i2c->intfl; + + if (intfl & MXC_F_I2CM_INTFL_TX_NACKED) { + i2c_reset(obj); + return I2C_ERROR_NO_SLAVE; + } + + if (!timeout || (intfl & (MXC_F_I2CM_INTFL_TX_TIMEOUT | MXC_F_I2CM_INTFL_TX_LOST_ARBITR))) { + i2c_reset(obj); + return I2C_ERROR_BUS_BUSY; + } + + return 0; +} + +int i2c_start(i2c_t *obj) +{ + obj->start_pending = 1; + return 0; +} + +int i2c_stop(i2c_t *obj) +{ + obj->start_pending = 0; + write_tx_fifo(obj, MXC_S_I2CM_TRANS_TAG_STOP); + + return wait_tx_in_progress(obj); +} + +void i2c_reset(i2c_t *obj) +{ + obj->i2c->ctrl = MXC_F_I2CM_CTRL_MSTR_RESET_EN; + obj->i2c->intfl = 0x3FF; // clear all interrupts + obj->i2c->ctrl = MXC_F_I2CM_CTRL_TX_FIFO_EN | MXC_F_I2CM_CTRL_RX_FIFO_EN; + obj->start_pending = 0; +} + +int i2c_byte_write(i2c_t *obj, int data) +{ + int err; + + // clear all interrupts + obj->i2c->intfl = 0x3FF; + + if (obj->start_pending) { + obj->start_pending = 0; + data = (data & 0xFF) | MXC_S_I2CM_TRANS_TAG_START; + } else { + data = (data & 0xFF) | MXC_S_I2CM_TRANS_TAG_TXDATA_ACK; + } + + if ((err = write_tx_fifo(obj, data)) != 0) { + return err; + } + + obj->i2c->trans |= MXC_F_I2CM_TRANS_TX_START; + + // Wait for the FIFO to be empty + while (!(obj->i2c->intfl & MXC_F_I2CM_INTFL_TX_FIFO_EMPTY)); + + if (obj->i2c->intfl & MXC_F_I2CM_INTFL_TX_NACKED) { + i2c_reset(obj); + return 0; + } + + if (obj->i2c->intfl & (MXC_F_I2CM_INTFL_TX_TIMEOUT | MXC_F_I2CM_INTFL_TX_LOST_ARBITR)) { + i2c_reset(obj); + return 2; + } + + return 1; +} + +int i2c_byte_read(i2c_t *obj, int last) +{ + uint16_t fifo_value; + int err; + + // clear all interrupts + obj->i2c->intfl = 0x3FF; + + if (last) { + fifo_value = MXC_S_I2CM_TRANS_TAG_RXDATA_NACK; + } else { + fifo_value = MXC_S_I2CM_TRANS_TAG_RXDATA_COUNT; + } + + if ((err = write_tx_fifo(obj, fifo_value)) != 0) { + i2c_reset(obj); + return err; + } + + obj->i2c->trans |= MXC_F_I2CM_TRANS_TX_START; + + int timeout = MXC_I2CM_RX_TIMEOUT; + while (!(obj->i2c->intfl & MXC_F_I2CM_INTFL_RX_FIFO_NOT_EMPTY) && + (!(obj->i2c->bb & MXC_F_I2CM_BB_RX_FIFO_CNT))) { + if ((--timeout < 0) || (obj->i2c->trans & (MXC_F_I2CM_TRANS_TX_TIMEOUT | + MXC_F_I2CM_TRANS_TX_LOST_ARBITR | MXC_F_I2CM_TRANS_TX_NACKED))) { + break; + } + } + + if (obj->i2c->intfl & MXC_F_I2CM_INTFL_RX_FIFO_NOT_EMPTY) { + obj->i2c->intfl = MXC_F_I2CM_INTFL_RX_FIFO_NOT_EMPTY; + return *obj->fifos->rslts; + } + + i2c_reset(obj); + + return -1; +} + +int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop) +{ + int err, retval = 0; + int i; + + if (!(obj->stop_pending) && (obj->i2c->trans & MXC_F_I2CM_TRANS_TX_IN_PROGRESS)) { + return 0; + } + + // clear all interrupts + obj->i2c->intfl = 0x3FF; + + // write the address to the fifo + if ((err = write_tx_fifo(obj, (MXC_S_I2CM_TRANS_TAG_START | address))) != 0) { // start + addr (write) + i2c_reset(obj); + return err; + } + obj->start_pending = 0; + + // start the transaction + obj->i2c->trans |= MXC_F_I2CM_TRANS_TX_START; + + // load as much of the cmd into the FIFO as possible + for (i = 0; i < length; i++) { + if ((err = write_tx_fifo(obj, (MXC_S_I2CM_TRANS_TAG_TXDATA_ACK | data[i]))) != 0) { // cmd (expect ACK) + retval = (retval ? retval : err); + break; + } + } + + if (stop) { + obj->stop_pending = 0; + if ((err = write_tx_fifo(obj, MXC_S_I2CM_TRANS_TAG_STOP)) != 0) { // stop condition + retval = (retval ? retval : err); + } + + if ((err = wait_tx_in_progress(obj)) != 0) { + retval = (retval ? retval : err); + } + } else { + obj->stop_pending = 1; + int timeout = MXC_I2CM_TX_TIMEOUT; + // Wait for TX fifo to be empty + while (!(obj->i2c->intfl & MXC_F_I2CM_INTFL_TX_FIFO_EMPTY) && timeout--); + } + + if (retval == 0) { + return length; + } + + i2c_reset(obj); + + return retval; +} + +int i2c_read(i2c_t *obj, int address, char *data, int length, int stop) +{ + int err, retval = 0; + int i = length; + int timeout; + + if (!(obj->stop_pending) && (obj->i2c->trans & MXC_F_I2CM_TRANS_TX_IN_PROGRESS)) { + return 0; + } + + // clear all interrupts + obj->i2c->intfl = 0x3FF; + + // start + addr (read) + if ((retval = write_tx_fifo(obj, (MXC_S_I2CM_TRANS_TAG_START | address | I2C_SLAVE_ADDR_READ_BIT))) != 0) { + goto read_done; + } + obj->start_pending = 0; + + while (i > 256) { + if ((retval = write_tx_fifo(obj, (MXC_S_I2CM_TRANS_TAG_RXDATA_COUNT | 255))) != 0) { + goto read_done; + } + i -= 256; + } + + if (i > 1) { + if ((retval = write_tx_fifo(obj, (MXC_S_I2CM_TRANS_TAG_RXDATA_COUNT | (i - 2)))) != 0) { + goto read_done; + } + } + + // start the transaction + obj->i2c->trans |= MXC_F_I2CM_TRANS_TX_START; + + if ((retval = write_tx_fifo(obj, MXC_S_I2CM_TRANS_TAG_RXDATA_NACK)) != 0) { // NACK last data byte + goto read_done; + } + + if (stop) { + if ((retval = write_tx_fifo(obj, MXC_S_I2CM_TRANS_TAG_STOP)) != 0) { // stop condition + goto read_done; + } + } + + timeout = MXC_I2CM_RX_TIMEOUT; + i = 0; + while (i < length) { + while (!(obj->i2c->intfl & MXC_F_I2CM_INTFL_RX_FIFO_NOT_EMPTY) && + (!(obj->i2c->bb & MXC_F_I2CM_BB_RX_FIFO_CNT))) { + if ((--timeout < 0) || (obj->i2c->trans & (MXC_F_I2CM_TRANS_TX_TIMEOUT | + MXC_F_I2CM_TRANS_TX_LOST_ARBITR | MXC_F_I2CM_TRANS_TX_NACKED))) { + retval = -3; + goto read_done; + } + } + + timeout = MXC_I2CM_RX_TIMEOUT; + + obj->i2c->intfl = MXC_F_I2CM_INTFL_RX_FIFO_NOT_EMPTY; + + uint16_t temp = *obj->fifos->rslts; + + if (temp & MXC_S_I2CM_RSTLS_TAG_EMPTY) { + continue; + } + data[i++] = (uint8_t) temp; + } + +read_done: + + if (stop) { + obj->stop_pending = 0; + if ((err = wait_tx_in_progress(obj)) != 0) { + retval = (retval ? retval : err); + } + } else { + obj->stop_pending = 1; + } + + if (retval == 0) { + return length; + } + + i2c_reset(obj); + + return retval; +} diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/objects.h b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/objects.h new file mode 100644 index 0000000000..7a2892477b --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/objects.h @@ -0,0 +1,126 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef MBED_OBJECTS_H +#define MBED_OBJECTS_H + +#include "cmsis.h" +#include "PortNames.h" +#include "PeripheralNames.h" +#include "PinNames.h" +#include "gpio_object.h" +#include "gpio_regs.h" +#include "uart_regs.h" +#include "i2cm_regs.h" +#include "spi_regs.h" +#include "pt_regs.h" +#include "adc_regs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct port_s { + PortName port; + uint32_t mask; + __IO uint32_t *reg_out; + __I uint32_t *reg_in; +}; + +struct gpio_irq_s { + uint8_t port; + uint8_t pin; + uint8_t rise_en; + uint8_t fall_en; + uint32_t id; +}; + +struct serial_s { + int index; + mxc_uart_regs_t *uart; + mxc_uart_fifo_regs_t *fifo; +}; + +struct i2c_s { + int index; + mxc_i2cm_regs_t *i2c; + mxc_i2cm_fifo_regs_t *fifos; + int start_pending; + int stop_pending; +}; + +struct spi_s { + int index; + mxc_spi_regs_t *spi; + mxc_spi_fifo_regs_t *fifo; + int bits; + int ssel; + uint32_t width; // SPI data width (number of data lines to use) + PinName sclk; // PinName saved to use in Quad SPI pin mapping table +#if DEVICE_SPI_ASYNCH + // Async transaction state + uint8_t deass; // De-assert slave select at the end of the transaction + const uint8_t *tx_data; // TX buffer + uint8_t *rx_data; // RX buffer + unsigned len; // Number of bytes to send + unsigned read_num; // Number of bytes read + unsigned write_num; // Number of bytes written + void (*callback)(); // Callback for asynchronous request + unsigned head_rem; // Remaining count for current header + uint32_t event; // Callback response events +#endif +}; + +struct pwmout_s { + mxc_pt_regs_t *pwm; + int period; + int pulse_width; +}; + +struct analogin_s { + mxc_adc_regs_t *adc; + PinName adc_pin; +}; + +typedef struct { + volatile uint32_t *reg_req; + volatile uint32_t *reg_ack; + uint32_t req_val; + uint32_t ack_mask; +} pin_function_t; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/pinmap.c b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/pinmap.c new file mode 100644 index 0000000000..2b0b75bfdf --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/pinmap.c @@ -0,0 +1,117 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include "mbed_assert.h" +#include "pinmap.h" +#include "objects.h" +#include "gpio_regs.h" +#include "ioman_regs.h" + +void pin_function(PinName name, int function) +{ + MBED_ASSERT(name != (PinName)NC); + + if ((function >= 0) && (function <= 0xF)) { + unsigned int port = PINNAME_TO_PORT(name); + unsigned int pin = PINNAME_TO_PIN(name); + uint32_t temp = MXC_GPIO->func_sel[port] & ~(0xF << (pin*4)); + MXC_GPIO->func_sel[port] = temp | ((uint32_t)function << (pin*4)); + } else { + /* Assume this is a pointer to a pin function object */ + pin_function_t *obj = (pin_function_t*)function; + + if ((*obj->reg_ack & obj->ack_mask) != obj->req_val) { + /* Request pin mapping */ + *obj->reg_req |= obj->req_val; + + /* Check for acknowledgment */ + MBED_ASSERT((*obj->reg_ack & obj->ack_mask) == obj->req_val); + } + } +} + +void pin_mode(PinName name, PinMode mode) +{ + MBED_ASSERT(name != (PinName)NC); + unsigned int port = PINNAME_TO_PORT(name); + unsigned int pin = PINNAME_TO_PIN(name); + + /* Must set mode while retaining direction */ + + /* Get the current direction */ + uint32_t out_mode = MXC_GPIO->out_mode[port]; + uint32_t curr_mode = (out_mode >> (pin * 4)) & 0xF; + PinDirection dir = PIN_OUTPUT; + if ((curr_mode == MXC_V_GPIO_OUT_MODE_HIGH_Z_WEAK_PULLUP) || + (curr_mode == MXC_V_GPIO_OUT_MODE_HIGH_Z_WEAK_PULLDOWN) || + (curr_mode == MXC_V_GPIO_OUT_MODE_NORMAL_HIGH_Z)) { + dir = PIN_INPUT; + } + + /* Set mode based on current direction */ + uint32_t new_mode; + if (dir == PIN_OUTPUT) { + // PullUp = not valid, + // PullDown = not valid, + // OpenDrain = MXC_V_GPIO_OUT_MODE_OD, + // PullNone = MXC_V_GPIO_OUT_MODE_NORMAL, + if (mode == OpenDrain) { + new_mode = MXC_V_GPIO_OUT_MODE_OPEN_DRAIN; + } else { + new_mode = MXC_V_GPIO_OUT_MODE_NORMAL; + } + } else { + // PullUp = MXC_V_GPIO_OUT_MODE_HIGH_Z_WEAK_PULLUP + // PullDown = MXC_V_GPIO_OUT_MODE_HIGH_Z_WEAK_PULLDOWN + // OpenDrain = MXC_V_GPIO_OUT_MODE_OD + // PullNone = MXC_V_GPIO_OUT_MODE_NORMAL_HIGH_Z + if (mode == PullUp) { + new_mode = MXC_V_GPIO_OUT_MODE_HIGH_Z_WEAK_PULLUP; + MXC_GPIO->out_val[port] |= 1 << pin; + } else if (mode == PullDown) { + new_mode = MXC_V_GPIO_OUT_MODE_HIGH_Z_WEAK_PULLDOWN; + MXC_GPIO->out_val[port] &= ~(1 << pin); + } else if (mode == OpenDrain) { + new_mode = MXC_V_GPIO_OUT_MODE_OPEN_DRAIN; + MXC_GPIO->out_val[port] |= 1 << pin; + } else { + new_mode = MXC_V_GPIO_OUT_MODE_NORMAL_HIGH_Z; + MXC_GPIO->out_val[port] &= ~(1 << pin); + } + } + + /* Set new mode */ + out_mode &= ~(0xF << (pin * 4)); + out_mode |= (new_mode << (pin * 4)); + MXC_GPIO->out_mode[port] = out_mode; +} diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/port_api.c b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/port_api.c new file mode 100644 index 0000000000..58dc6bbbf4 --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/port_api.c @@ -0,0 +1,95 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include "port_api.h" +#include "pinmap.h" +#include "gpio_api.h" +#include "gpio_regs.h" +#include "clkman_regs.h" + +PinName port_pin(PortName port, int pin_n) +{ + return (PinName)((port << PORT_SHIFT) | pin_n); +} + +void port_init(port_t *obj, PortName port, int mask, PinDirection dir) +{ + obj->port = port; + obj->mask = mask; + obj->reg_out = &MXC_GPIO->out_val[port]; + obj->reg_in = &MXC_GPIO->in_val[port]; + + /* Ensure that the GPIO clock is enabled */ + MXC_CLKMAN->sys_clk_ctrl_6_gpio = MXC_S_CLKMAN_CLK_SCALE_DIV_1; + + uint32_t i; + // The function is set per pin: reuse gpio logic + for (i=0; i<32; i++) { + if (obj->mask & (1<port, i)); + pin_dir(port_pin(obj->port, i), dir); + } + } +} + +void port_mode(port_t *obj, PinMode mode) +{ + uint32_t i; + // The mode is set per pin: reuse pinmap logic + for (i=0; i<32; i++) { + if (obj->mask & (1<port, i), mode); + } + } +} + +void port_dir(port_t *obj, PinDirection dir) +{ + uint32_t i; + // The mode is set per pin: reuse gpio logic + for (i=0; i<32; i++) { + if (obj->mask & (1<port, i), dir); + } + } +} + +void port_write(port_t *obj, int value) +{ + *obj->reg_out = (*obj->reg_out & ~obj->mask) | (value & obj->mask); +} + +int port_read(port_t *obj) +{ + return (*obj->reg_in & obj->mask); +} diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/pwmout_api.c b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/pwmout_api.c new file mode 100644 index 0000000000..5e6c8f1472 --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/pwmout_api.c @@ -0,0 +1,211 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include "mbed_assert.h" +#include "cmsis.h" +#include "pwmout_api.h" +#include "pinmap.h" +#include "clkman_regs.h" +#include "PeripheralPins.h" + +//****************************************************************************** +void pwmout_init(pwmout_t* obj, PinName pin) +{ + // Make sure the pin is free for GPIO use + unsigned int port = (unsigned int)pin >> PORT_SHIFT; + unsigned int port_pin = (unsigned int)pin & ~(0xFFFFFFFF << PORT_SHIFT); + MBED_ASSERT(MXC_GPIO->free[port] & (0x1 << port_pin)); + + int i = 0; + PinMap pwm = PinMap_PWM[0]; + + // Check if there is a pulse train already active on this port + int pin_func = (MXC_GPIO->func_sel[port] & (0xF << (port_pin*4))) >> (port_pin*4); + MBED_ASSERT((pin_func < 1) || (pin_func > 3)); + + // Search through PinMap_PWM to find the pin + while (pwm.pin != pin) { + pwm = PinMap_PWM[++i]; + } + + // Find a free PT instance on this pin + while (pwm.pin == pin) { + + // Check to see if this PT instance is free + if (((mxc_pt_regs_t*)pwm.peripheral)->rate_length & MXC_F_PT_RATE_LENGTH_MODE) { + break; + } + + pwm = PinMap_PWM[++i]; + + // Raise an assertion if we can not allocate another PT instance. + MBED_ASSERT(pwm.pin == pin); + } + + // Enable the clock + MXC_CLKMAN->sys_clk_ctrl_7_pt = MXC_S_CLKMAN_CLK_SCALE_DIV_1; + + // Set the obj pointer to the propper PWM instance + obj->pwm = (mxc_pt_regs_t*)pwm.peripheral; + + // Initialize object period and pulse width + obj->period = -1; + obj->pulse_width = -1; + + // Disable the output + obj->pwm->train = 0x0; + obj->pwm->rate_length = 0x0; + + // Configure the pin + pin_mode(pin, (PinMode)PullNone); + pin_function(pin, pwm.function); + + // default to 20ms: standard for servos, and fine for e.g. brightness control + pwmout_period_us(obj, 20000); + pwmout_write (obj, 0); + + // Set the drive mode to normal + MXC_SET_FIELD(&MXC_GPIO->out_mode[port], (0x7 << (port_pin*4)), (MXC_V_GPIO_OUT_MODE_NORMAL << (port_pin*4))); + + // Enable this PWM channel + MXC_PTG->enable |= (1 << MXC_PT_GET_IDX(obj->pwm)); +} + +//****************************************************************************** +void pwmout_free(pwmout_t* obj) +{ + // Set the registers to the reset value + obj->pwm->train = 0; + obj->pwm->rate_length = 0x08000000; +} + +//****************************************************************************** +static void pwmout_update(pwmout_t* obj) +{ + // Calculate and set the divider ratio + int div = (obj->period * (SystemCoreClock/1000000))/32; + if (div < 2){ + div = 2; + } + MXC_SET_FIELD(&obj->pwm->rate_length, MXC_F_PT_RATE_LENGTH_RATE_CONTROL, div); + + // Change the duty cycle to adjust the pulse width + obj->pwm->train = (0xFFFFFFFF << (32-((32*obj->pulse_width)/obj->period))); +} + + +//****************************************************************************** +void pwmout_write(pwmout_t* obj, float percent) +{ + // Saturate percent if outside of range + if (percent < 0.0f) { + percent = 0.0f; + } else if(percent > 1.0f) { + percent = 1.0f; + } + + // Resize the pulse width to set the duty cycle + pwmout_pulsewidth_us(obj, (int)(percent*obj->period)); +} + +//****************************************************************************** +float pwmout_read(pwmout_t* obj) +{ + // Check for when pulsewidth or period equals 0 + if ((obj->pulse_width == 0) || (obj->period == 0)){ + return 0; + } + + // Return the duty cycle + return ((float)obj->pulse_width / (float)obj->period); +} + +//****************************************************************************** +void pwmout_period(pwmout_t* obj, float seconds) +{ + pwmout_period_us(obj, (int)(seconds * 1000000.0f)); +} + +//****************************************************************************** +void pwmout_period_ms(pwmout_t* obj, int ms) +{ + pwmout_period_us(obj, ms*1000); +} + +//****************************************************************************** +void pwmout_period_us(pwmout_t* obj, int us) +{ + // Check the range of the period + MBED_ASSERT((us >= 0) && (us <= (int)(SystemCoreClock/32))); + + // Set pulse width to half the period if uninitialized + if (obj->pulse_width == -1) { + obj->pulse_width = us/2; + } + + // Save the period + obj->period = us; + + // Update the registers + pwmout_update(obj); +} + +//****************************************************************************** +void pwmout_pulsewidth(pwmout_t* obj, float seconds) +{ + pwmout_pulsewidth_us(obj, (int)(seconds * 1000000.0f)); +} + +//****************************************************************************** +void pwmout_pulsewidth_ms(pwmout_t* obj, int ms) +{ + pwmout_pulsewidth_us(obj, ms*1000); +} + +//****************************************************************************** +void pwmout_pulsewidth_us(pwmout_t* obj, int us) +{ + // Check the range of the pulsewidth + MBED_ASSERT((us >= 0) && (us <= (int)(SystemCoreClock/32))); + + // Initialize period to double the pulsewidth if uninitialized + if (obj->period == -1) { + obj->period = 2*us; + } + + // Save the pulsewidth + obj->pulse_width = us; + + // Update the register + pwmout_update(obj); +} diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/rtc_api.c b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/rtc_api.c new file mode 100644 index 0000000000..dd9c402fc6 --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/rtc_api.c @@ -0,0 +1,303 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include "rtc_api.h" +#include "lp_ticker_api.h" +#include "cmsis.h" +#include "rtc_regs.h" +#include "pwrseq_regs.h" +#include "clkman_regs.h" + +/** + * Defines clock divider for 4096Hz input clock. + */ +typedef enum { + /** (4kHz) divide input clock by 2^0 = 1 */ + MXC_E_RTC_PRESCALE_DIV_2_0 = 0, + /** (2kHz) divide input clock by 2^1 = 2 */ + MXC_E_RTC_PRESCALE_DIV_2_1, + /** (1kHz) divide input clock by 2^2 = 4 */ + MXC_E_RTC_PRESCALE_DIV_2_2, + /** (512Hz) divide input clock by 2^3 = 8 */ + MXC_E_RTC_PRESCALE_DIV_2_3, + /** (256Hz) divide input clock by 2^4 = 16 */ + MXC_E_RTC_PRESCALE_DIV_2_4, + /** (128Hz) divide input clock by 2^5 = 32 */ + MXC_E_RTC_PRESCALE_DIV_2_5, + /** (64Hz) divide input clock by 2^6 = 64 */ + MXC_E_RTC_PRESCALE_DIV_2_6, + /** (32Hz) divide input clock by 2^7 = 128 */ + MXC_E_RTC_PRESCALE_DIV_2_7, + /** (16Hz) divide input clock by 2^8 = 256 */ + MXC_E_RTC_PRESCALE_DIV_2_8, + /** (8Hz) divide input clock by 2^9 = 512 */ + MXC_E_RTC_PRESCALE_DIV_2_9, + /** (4Hz) divide input clock by 2^10 = 1024 */ + MXC_E_RTC_PRESCALE_DIV_2_10, + /** (2Hz) divide input clock by 2^11 = 2048 */ + MXC_E_RTC_PRESCALE_DIV_2_11, + /** (1Hz) divide input clock by 2^12 = 4096 */ + MXC_E_RTC_PRESCALE_DIV_2_12, +} mxc_rtc_prescale_t; + +#define PRESCALE_VAL MXC_E_RTC_PRESCALE_DIV_2_0 // Set the divider for the 4kHz clock +#define SHIFT_AMT (MXC_E_RTC_PRESCALE_DIV_2_12 - PRESCALE_VAL) + +#define WINDOW 1000 + +static int rtc_inited = 0; +static volatile uint32_t overflow_cnt = 0; + +static uint64_t rtc_read64(void); + +//****************************************************************************** +static void overflow_handler(void) +{ + MXC_RTCTMR->flags |= MXC_F_RTC_FLAGS_ASYNC_CLR_FLAGS; + overflow_cnt++; + + // Wait for pending transactions + while (MXC_RTCTMR->ctrl & MXC_F_RTC_CTRL_PENDING); +} + +//****************************************************************************** +void rtc_init(void) +{ + if (rtc_inited) { + return; + } + rtc_inited = 1; + + overflow_cnt = 0; + + // Enable the clock to the synchronizer + MXC_CLKMAN->sys_clk_ctrl_1_sync = MXC_S_CLKMAN_CLK_SCALE_DIV_1; + + // Enable the clock to the RTC + MXC_PWRSEQ->reg0 |= MXC_F_PWRSEQ_REG0_PWR_RTCEN_RUN; + + // Prepare interrupt handlers + NVIC_SetVector(RTC0_IRQn, (uint32_t)lp_ticker_irq_handler); + NVIC_EnableIRQ(RTC0_IRQn); + NVIC_SetVector(RTC3_IRQn, (uint32_t)overflow_handler); + NVIC_EnableIRQ(RTC3_IRQn); + + // Enable wakeup on RTC rollover + MXC_PWRSEQ->msk_flags &= ~MXC_F_PWRSEQ_MSK_FLAGS_RTC_ROLLOVER; + + /* RTC registers are only reset on a power cycle. Do not reconfigure the RTC + * if it is already running. + */ + if (!(MXC_RTCTMR->ctrl & MXC_F_RTC_CTRL_ENABLE)) { + // Set the clock divider + MXC_RTCTMR->prescale = PRESCALE_VAL; + + // Enable the overflow interrupt + MXC_RTCTMR->inten |= MXC_F_RTC_FLAGS_OVERFLOW; + + // Restart the timer from 0 + MXC_RTCTMR->timer = 0; + + // Enable the RTC + MXC_RTCTMR->ctrl |= MXC_F_RTC_CTRL_ENABLE; + } +} + +//****************************************************************************** +void lp_ticker_init(void) +{ + rtc_init(); +} + +//****************************************************************************** +void rtc_free(void) +{ + if (MXC_RTCTMR->ctrl & MXC_F_RTC_CTRL_ENABLE) { + // Clear and disable RTC + MXC_RTCTMR->ctrl |= MXC_F_RTC_CTRL_CLEAR; + MXC_RTCTMR->ctrl &= ~MXC_F_RTC_CTRL_ENABLE; + + // Wait for pending transactions + while (MXC_RTCTMR->ctrl & MXC_F_RTC_CTRL_PENDING); + } + + // Disable the clock to the RTC + MXC_PWRSEQ->reg0 &= ~(MXC_F_PWRSEQ_REG0_PWR_RTCEN_RUN | MXC_F_PWRSEQ_REG0_PWR_RTCEN_SLP); + + // Disable the clock to the synchronizer + MXC_CLKMAN->sys_clk_ctrl_1_sync = MXC_S_CLKMAN_CLK_SCALE_DISABLED; +} + +//****************************************************************************** +int rtc_isenabled(void) +{ + return (MXC_RTCTMR->ctrl & MXC_F_RTC_CTRL_ENABLE); +} + +//****************************************************************************** +time_t rtc_read(void) +{ + uint32_t ovf_cnt_1, ovf_cnt_2, timer_cnt; + uint32_t ovf1, ovf2; + + // Make sure RTC is setup before trying to read + if (!rtc_inited) { + rtc_init(); + } + + // Ensure coherency between overflow_cnt and timer + do { + ovf_cnt_1 = overflow_cnt; + ovf1 = MXC_RTCTMR->flags & MXC_F_RTC_FLAGS_OVERFLOW; + timer_cnt = MXC_RTCTMR->timer; + ovf2 = MXC_RTCTMR->flags & MXC_F_RTC_FLAGS_OVERFLOW; + ovf_cnt_2 = overflow_cnt; + } while ((ovf_cnt_1 != ovf_cnt_2) || (ovf1 != ovf2)); + + // Account for an unserviced interrupt + if (ovf1) { + ovf_cnt_1++; + } + + return (timer_cnt >> SHIFT_AMT) + (ovf_cnt_1 << (32 - SHIFT_AMT)); +} + +//****************************************************************************** +static uint64_t rtc_read64(void) +{ + uint32_t ovf_cnt_1, ovf_cnt_2, timer_cnt; + uint32_t ovf1, ovf2; + uint64_t current_us; + + // Make sure RTC is setup before trying to read + if (!rtc_inited) { + rtc_init(); + } + + // Ensure coherency between overflow_cnt and timer + do { + ovf_cnt_1 = overflow_cnt; + ovf1 = MXC_RTCTMR->flags & MXC_F_RTC_FLAGS_OVERFLOW; + timer_cnt = MXC_RTCTMR->timer; + ovf2 = MXC_RTCTMR->flags & MXC_F_RTC_FLAGS_OVERFLOW; + ovf_cnt_2 = overflow_cnt; + } while ((ovf_cnt_1 != ovf_cnt_2) || (ovf1 != ovf2)); + + // Account for an unserviced interrupt + if (ovf1) { + ovf_cnt_1++; + } + + current_us = (((uint64_t)timer_cnt * 1000000) >> SHIFT_AMT) + (((uint64_t)ovf_cnt_1 * 1000000) << (32 - SHIFT_AMT)); + + return current_us; +} + +//****************************************************************************** +void rtc_write(time_t t) +{ + // Make sure RTC is setup before accessing + if (!rtc_inited) { + rtc_init(); + } + + MXC_RTCTMR->ctrl &= ~MXC_F_RTC_CTRL_ENABLE; // disable the timer while updating + MXC_RTCTMR->timer = t << SHIFT_AMT; + overflow_cnt = t >> (32 - SHIFT_AMT); + MXC_RTCTMR->ctrl |= MXC_F_RTC_CTRL_ENABLE; // enable the timer while updating +} + +//****************************************************************************** +void lp_ticker_set_interrupt(timestamp_t timestamp) +{ + uint32_t comp_value; + uint64_t curr_ts64; + uint64_t ts64; + + // Note: interrupts are disabled before this function is called. + + // Disable the alarm while it is prepared + MXC_RTCTMR->inten &= ~MXC_F_RTC_INTEN_COMP0; + + curr_ts64 = rtc_read64(); + ts64 = (uint64_t)timestamp | (curr_ts64 & 0xFFFFFFFF00000000ULL); + + // If this event is older than a recent window, it must be in the future + if ((ts64 < (curr_ts64 - WINDOW)) && ((curr_ts64 - WINDOW) < curr_ts64)) { + ts64 += 0x100000000ULL; + } + + uint32_t timer = MXC_RTCTMR->timer; + if (ts64 <= curr_ts64) { + // This event has already occurred. Set the alarm to expire immediately. + comp_value = timer + 1; + } else { + comp_value = (ts64 << SHIFT_AMT) / 1000000; + } + + // Ensure that the compare value is far enough in the future to guarantee the interrupt occurs. + if ((comp_value < (timer + 2)) && (comp_value > (timer - 10))) { + comp_value = timer + 2; + } + + MXC_RTCTMR->comp[0] = comp_value; + MXC_RTCTMR->flags |= MXC_F_RTC_FLAGS_ASYNC_CLR_FLAGS; + MXC_RTCTMR->inten |= MXC_F_RTC_INTEN_COMP0; // enable the interrupt + + // Enable wakeup from RTC + MXC_PWRSEQ->msk_flags &= ~MXC_F_PWRSEQ_MSK_FLAGS_RTC_CMPR0; + + // Wait for pending transactions + while(MXC_RTCTMR->ctrl & MXC_F_RTC_CTRL_PENDING); +} + +//****************************************************************************** +inline void lp_ticker_disable_interrupt(void) +{ + MXC_RTCTMR->inten &= ~MXC_F_RTC_INTEN_COMP0; +} + +//****************************************************************************** +inline void lp_ticker_clear_interrupt(void) +{ + MXC_RTCTMR->flags |= MXC_F_RTC_FLAGS_ASYNC_CLR_FLAGS; + + // Wait for pending transactions + while (MXC_RTCTMR->ctrl & MXC_F_RTC_CTRL_PENDING); +} + +//****************************************************************************** +inline uint32_t lp_ticker_read(void) +{ + return rtc_read64(); +} diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/serial_api.c b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/serial_api.c new file mode 100644 index 0000000000..f213ab7b00 --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/serial_api.c @@ -0,0 +1,508 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include +#include "mbed_assert.h" +#include "cmsis.h" +#include "serial_api.h" +#include "uart_regs.h" +#include "ioman_regs.h" +#include "gpio_api.h" +#include "clkman_regs.h" +#include "PeripheralPins.h" + +#define DEFAULT_BAUD 9600 +#define DEFAULT_STOP 1 +#define DEFAULT_PARITY ParityNone + +#define UART_ERRORS (MXC_F_UART_INTFL_RX_FRAMING_ERR | \ + MXC_F_UART_INTFL_RX_PARITY_ERR | \ + MXC_F_UART_INTFL_RX_FIFO_OVERFLOW) + +// Variables for managing the stdio UART +int stdio_uart_inited; +serial_t stdio_uart; + +// Variables for interrupt driven +static uart_irq_handler irq_handler; +static uint32_t serial_irq_ids[MXC_CFG_UART_INSTANCES]; + +//****************************************************************************** +void serial_init(serial_t *obj, PinName tx, PinName rx) +{ + // Determine which uart is associated with each pin + UARTName uart_tx = (UARTName)pinmap_peripheral(tx, PinMap_UART_TX); + UARTName uart_rx = (UARTName)pinmap_peripheral(rx, PinMap_UART_RX); + UARTName uart = (UARTName)pinmap_merge(uart_tx, uart_rx); + + // Make sure that both pins are pointing to the same uart + MBED_ASSERT(uart != (UARTName)NC); + + // Ensure that the UART clock is enabled + switch (uart) { + case UART_0: + MXC_CLKMAN->clk_gate_ctrl1 |= MXC_F_CLKMAN_CLK_GATE_CTRL1_UART0_CLK_GATER; + break; + case UART_1: + MXC_CLKMAN->clk_gate_ctrl1 |= MXC_F_CLKMAN_CLK_GATE_CTRL1_UART1_CLK_GATER; + break; + case UART_2: + MXC_CLKMAN->clk_gate_ctrl1 |= MXC_F_CLKMAN_CLK_GATE_CTRL1_UART2_CLK_GATER; + break; + case UART_3: + MXC_CLKMAN->clk_gate_ctrl1 |= MXC_F_CLKMAN_CLK_GATE_CTRL1_UART3_CLK_GATER; + break; + default: + break; + } + + // Ensure that the UART clock is enabled + // But don't override the scaler + // + // To support the most common baud rates, 9600 and 115200, we need to + // scale down the uart input clock. + if (!(MXC_CLKMAN->sys_clk_ctrl_8_uart & MXC_F_CLKMAN_SYS_CLK_CTRL_8_UART_UART_CLK_SCALE)) { + + switch (SystemCoreClock) { + case RO_FREQ: + MXC_CLKMAN->sys_clk_ctrl_8_uart = MXC_S_CLKMAN_CLK_SCALE_DIV_4; + break; + case (RO_FREQ / 2): + MXC_CLKMAN->sys_clk_ctrl_8_uart = MXC_S_CLKMAN_CLK_SCALE_DIV_2; + break; + default: + MXC_CLKMAN->sys_clk_ctrl_8_uart = MXC_S_CLKMAN_CLK_SCALE_DIV_4; + break; + } + } + + // Set the obj pointer to the proper uart + obj->uart = (mxc_uart_regs_t*)uart; + + // Set the uart index + obj->index = MXC_UART_GET_IDX(obj->uart); + obj->fifo = (mxc_uart_fifo_regs_t*)MXC_UART_GET_BASE_FIFO(obj->index); + + // Configure the pins + pinmap_pinout(tx, PinMap_UART_TX); + pinmap_pinout(rx, PinMap_UART_RX); + + // Flush the RX and TX FIFOs, clear the settings + obj->uart->ctrl &= ~(MXC_F_UART_CTRL_RX_FIFO_EN | MXC_F_UART_CTRL_TX_FIFO_EN); + obj->uart->ctrl |= (MXC_F_UART_CTRL_RX_FIFO_EN | MXC_F_UART_CTRL_TX_FIFO_EN); + + // Disable interrupts + obj->uart->inten = 0; + obj->uart->intfl = obj->uart->intfl; + + // Configure to default settings + serial_baud(obj, DEFAULT_BAUD); + serial_format(obj, 8, ParityNone, 1); + + // Manage stdio UART + if (uart == STDIO_UART) { + stdio_uart_inited = 1; + memcpy(&stdio_uart, obj, sizeof(serial_t)); + } + + // Enable UART + obj->uart->ctrl |= MXC_F_UART_CTRL_UART_EN; +} + +//****************************************************************************** +void serial_baud(serial_t *obj, int baudrate) +{ + uint32_t baud_setting = 0; + + MBED_ASSERT(MXC_CLKMAN->sys_clk_ctrl_8_uart > MXC_S_CLKMAN_CLK_SCALE_DISABLED); + + // Calculate the integer and decimal portions + baud_setting = SystemCoreClock / (1<<(MXC_CLKMAN->sys_clk_ctrl_8_uart-1)); + baud_setting = baud_setting / (baudrate * 16); + + // If the result doesn't fit in the register + MBED_ASSERT(baud_setting <= UINT8_MAX); + + obj->uart->baud = baud_setting; +} + +//****************************************************************************** +void serial_format(serial_t *obj, int data_bits, SerialParity parity, int stop_bits) +{ + // Check the validity of the inputs + MBED_ASSERT((data_bits > 4) && (data_bits < 9)); + MBED_ASSERT((parity == ParityNone) || (parity == ParityOdd) || + (parity == ParityEven) || (parity == ParityForced1) || + (parity == ParityForced0)); + MBED_ASSERT((stop_bits == 1) || (stop_bits == 2)); + + // Adjust the stop and data bits + stop_bits -= 1; + data_bits -= 5; + + // Adjust the parity setting + int mode = 0; + switch (parity) { + case ParityNone: + mode = 0; + break; + case ParityOdd : + mode = 1; + break; + case ParityEven: + mode = 2; + break; + case ParityForced1: + // Hardware does not support forced parity + MBED_ASSERT(0); + break; + case ParityForced0: + // Hardware does not support forced parity + MBED_ASSERT(0); + break; + default: + mode = 0; + break; + } + + int temp = obj->uart->ctrl; + temp &= ~(MXC_F_UART_CTRL_DATA_SIZE | MXC_F_UART_CTRL_EXTRA_STOP | MXC_F_UART_CTRL_PARITY); + temp |= (data_bits << MXC_F_UART_CTRL_DATA_SIZE_POS); + temp |= (stop_bits << MXC_F_UART_CTRL_EXTRA_STOP_POS); + temp |= (mode << MXC_F_UART_CTRL_PARITY_POS); + obj->uart->ctrl = temp; +} + +//****************************************************************************** +void uart_handler(mxc_uart_regs_t* uart, int id) +{ + // Check for errors or RX Threshold + if (uart->intfl & (MXC_F_UART_INTFL_RX_FIFO_NOT_EMPTY | UART_ERRORS)) { + if (serial_irq_ids[id]) { + irq_handler(serial_irq_ids[id], RxIrq); + } + uart->intfl = (MXC_F_UART_INTFL_RX_FIFO_NOT_EMPTY | UART_ERRORS); + } + + // Check for TX Threshold + if (uart->intfl & MXC_F_UART_INTFL_TX_FIFO_AE) { + if (serial_irq_ids[id]) { + irq_handler(serial_irq_ids[id], TxIrq); + } + uart->intfl = MXC_F_UART_INTFL_TX_FIFO_AE; + } +} + +void uart0_handler(void) { uart_handler(MXC_UART0, 0); } +void uart1_handler(void) { uart_handler(MXC_UART1, 1); } +void uart2_handler(void) { uart_handler(MXC_UART2, 2); } +void uart3_handler(void) { uart_handler(MXC_UART3, 3); } + +//****************************************************************************** +void serial_irq_handler(serial_t *obj, uart_irq_handler handler, uint32_t id) +{ + irq_handler = handler; + serial_irq_ids[obj->index] = id; +} + +//****************************************************************************** +void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable) +{ + switch (obj->index) { + case 0: + NVIC_SetVector(UART0_IRQn, (uint32_t)uart0_handler); + NVIC_EnableIRQ(UART0_IRQn); + break; + case 1: + NVIC_SetVector(UART1_IRQn, (uint32_t)uart1_handler); + NVIC_EnableIRQ(UART1_IRQn); + break; + case 2: + NVIC_SetVector(UART2_IRQn, (uint32_t)uart2_handler); + NVIC_EnableIRQ(UART2_IRQn); + break; + case 3: + NVIC_SetVector(UART3_IRQn, (uint32_t)uart3_handler); + NVIC_EnableIRQ(UART3_IRQn); + break; + default: + MBED_ASSERT(0); + } + + if (irq == RxIrq) { + // Enable RX FIFO Threshold Interrupt + if (enable) { + // Clear pending interrupts + obj->uart->intfl = obj->uart->intfl; + obj->uart->inten |= (MXC_F_UART_INTFL_RX_FIFO_NOT_EMPTY | UART_ERRORS); + } else { + // Clear pending interrupts + obj->uart->intfl = obj->uart->intfl; + obj->uart->inten &= ~(MXC_F_UART_INTFL_RX_FIFO_NOT_EMPTY | UART_ERRORS); + } + + } else if (irq == TxIrq) { + // Set TX Almost Empty level to interrupt when empty + MXC_SET_FIELD(&obj->uart->tx_fifo_ctrl, MXC_F_UART_RX_FIFO_CTRL_FIFO_AF_LVL, + (MXC_UART_FIFO_DEPTH - 1) << MXC_F_UART_TX_FIFO_CTRL_FIFO_AE_LVL_POS); + + // Enable TX Almost Empty Interrupt + if (enable) { + // Clear pending interrupts + obj->uart->intfl = obj->uart->intfl; + obj->uart->inten |= MXC_F_UART_INTFL_TX_FIFO_AE; + } else { + // Clear pending interrupts + obj->uart->intfl = obj->uart->intfl; + obj->uart->inten &= ~MXC_F_UART_INTFL_TX_FIFO_AE; + } + + } else { + MBED_ASSERT(0); + } +} + + +//****************************************************************************** +int serial_getc(serial_t *obj) +{ + int c; + + // Wait for data to be available + while ((obj->uart->rx_fifo_ctrl & MXC_F_UART_RX_FIFO_CTRL_FIFO_ENTRY) == 0); + + c = *obj->fifo->rx_8; + + // Echo characters for stdio + if (obj->uart == (mxc_uart_regs_t*)STDIO_UART) { + *obj->fifo->tx_8 = (uint8_t)c; + } + + return c; +} + +//****************************************************************************** +void serial_putc(serial_t *obj, int c) +{ + // Append a carriage return for stdio + if ((c == (int)'\n') && (obj->uart == (mxc_uart_regs_t*)STDIO_UART)) { + while ( ((obj->uart->tx_fifo_ctrl & MXC_F_UART_TX_FIFO_CTRL_FIFO_ENTRY) + >> MXC_F_UART_TX_FIFO_CTRL_FIFO_ENTRY_POS) + >= MXC_UART_FIFO_DEPTH ); + + // Must clear before every write to the buffer to know that the fifo + // is empty when the TX DONE bit is set + obj->uart->intfl = MXC_F_UART_INTFL_TX_DONE; + *obj->fifo->tx_8 = (uint8_t)'\r'; + } + + // Wait for TXFIFO to not be full + while ( ((obj->uart->tx_fifo_ctrl & MXC_F_UART_TX_FIFO_CTRL_FIFO_ENTRY) + >> MXC_F_UART_TX_FIFO_CTRL_FIFO_ENTRY_POS) + >= MXC_UART_FIFO_DEPTH ); + + // Must clear before every write to the buffer to know that the fifo + // is empty when the TX DONE bit is set + obj->uart->intfl = MXC_F_UART_INTFL_TX_DONE; + *obj->fifo->tx_8 = (uint8_t)c; +} + +//****************************************************************************** +int serial_readable(serial_t *obj) +{ + return (obj->uart->intfl & MXC_F_UART_INTFL_RX_FIFO_NOT_EMPTY); +} + +//****************************************************************************** +int serial_writable(serial_t *obj) +{ + return ( ((obj->uart->tx_fifo_ctrl & MXC_F_UART_TX_FIFO_CTRL_FIFO_ENTRY) + >> MXC_F_UART_TX_FIFO_CTRL_FIFO_ENTRY_POS) + < MXC_UART_FIFO_DEPTH ); +} + +//****************************************************************************** +void serial_clear(serial_t *obj) +{ + // Clear the rx and tx fifos + obj->uart->ctrl &= ~(MXC_F_UART_CTRL_RX_FIFO_EN | MXC_F_UART_CTRL_TX_FIFO_EN); + obj->uart->ctrl |= (MXC_F_UART_CTRL_RX_FIFO_EN | MXC_F_UART_CTRL_TX_FIFO_EN); +} + + +//****************************************************************************** +void serial_break_set(serial_t *obj) +{ + // Make sure that nothing is being sent + while ( ((obj->uart->tx_fifo_ctrl & MXC_F_UART_TX_FIFO_CTRL_FIFO_ENTRY) + >> MXC_F_UART_TX_FIFO_CTRL_FIFO_ENTRY_POS) > 0); + while (!(obj->uart->intfl & MXC_F_UART_INTFL_TX_DONE)); + + // Configure the GPIO to output 0 + gpio_t tx_gpio; + switch (((UARTName)(obj->uart))) { + case UART_0: + gpio_init_out(&tx_gpio, UART0_TX); + break; + case UART_1: + gpio_init_out(&tx_gpio, UART1_TX); + break; + case UART_2: + gpio_init_out(&tx_gpio, UART2_TX); + break; + case UART_3: + gpio_init_out(&tx_gpio, UART3_TX); + break; + default: + gpio_init_out(&tx_gpio, (PinName)NC); + break; + } + + gpio_write(&tx_gpio, 0); + + // GPIO is setup now, but we need to map GPIO to the pin + switch (((UARTName)(obj->uart))) { + case UART_0: + MXC_IOMAN->uart0_req &= ~MXC_F_IOMAN_UART_REQ_IO_REQ; + MBED_ASSERT((MXC_IOMAN->uart0_ack & (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)) == 0); + break; + case UART_1: + MXC_IOMAN->uart1_req &= ~MXC_F_IOMAN_UART_REQ_IO_REQ; + MBED_ASSERT((MXC_IOMAN->uart1_ack & (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)) == 0); + break; + case UART_2: + MXC_IOMAN->uart2_req &= ~MXC_F_IOMAN_UART_REQ_IO_REQ; + MBED_ASSERT((MXC_IOMAN->uart2_ack & (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)) == 0); + break; + case UART_3: + MXC_IOMAN->uart3_req &= ~MXC_F_IOMAN_UART_REQ_IO_REQ; + MBED_ASSERT((MXC_IOMAN->uart3_ack & (MXC_F_IOMAN_UART_ACK_IO_MAP | MXC_F_IOMAN_UART_ACK_IO_ACK)) == 0); + break; + default: + break; + } +} + +//****************************************************************************** +void serial_break_clear(serial_t *obj) +{ + // Configure the GPIO to output 1 + gpio_t tx_gpio; + switch (((UARTName)(obj->uart))) { + case UART_0: + gpio_init_out(&tx_gpio, UART0_TX); + break; + case UART_1: + gpio_init_out(&tx_gpio, UART1_TX); + break; + case UART_2: + gpio_init_out(&tx_gpio, UART2_TX); + break; + case UART_3: + gpio_init_out(&tx_gpio, UART3_TX); + break; + default: + gpio_init_out(&tx_gpio, (PinName)NC); + break; + } + + gpio_write(&tx_gpio, 1); + + // Renable UART + switch (((UARTName)(obj->uart))) { + case UART_0: + serial_pinout_tx(UART0_TX); + break; + case UART_1: + serial_pinout_tx(UART1_TX); + break; + case UART_2: + serial_pinout_tx(UART2_TX); + break; + case UART_3: + serial_pinout_tx(UART3_TX); + break; + default: + serial_pinout_tx((PinName)NC); + break; + } +} + +//****************************************************************************** +void serial_pinout_tx(PinName tx) +{ + pinmap_pinout(tx, PinMap_UART_TX); +} + +//****************************************************************************** +void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, PinName txflow) +{ + uint32_t ctrl = obj->uart->ctrl; + + // Disable hardware flow control + ctrl &= ~(MXC_F_UART_CTRL_RTS_EN | MXC_F_UART_CTRL_CTS_EN); + + if (FlowControlNone != type) { + // Check to see if we can use HW flow control + UARTName uart_cts = (UARTName)pinmap_peripheral(txflow, PinMap_UART_CTS); + UARTName uart_rts = (UARTName)pinmap_peripheral(rxflow, PinMap_UART_RTS); + UARTName uart = (UARTName)pinmap_merge(uart_cts, uart_rts); + + // Make sure that the pins are pointing to the same UART + MBED_ASSERT(uart != (UARTName)NC); + + if ((FlowControlCTS == type) || (FlowControlRTSCTS == type)) { + // Make sure pin is in the PinMap + MBED_ASSERT(uart_cts != (UARTName)NC); + + // Enable the pin for CTS function + pinmap_pinout(txflow, PinMap_UART_CTS); + + // Enable active-low hardware flow control + ctrl |= (MXC_F_UART_CTRL_CTS_EN | MXC_F_UART_CTRL_CTS_POLARITY); + } + + if ((FlowControlRTS == type) || (FlowControlRTSCTS == type)) { + // Make sure pin is in the PinMap + MBED_ASSERT(uart_rts != (UARTName)NC); + + // Enable the pin for RTS function + pinmap_pinout(rxflow, PinMap_UART_RTS); + + // Enable active-low hardware flow control + ctrl |= (MXC_F_UART_CTRL_RTS_EN | MXC_F_UART_CTRL_RTS_POLARITY); + } + } + + obj->uart->ctrl = ctrl; +} diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/sleep.c b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/sleep.c new file mode 100644 index 0000000000..0ab40fa518 --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/sleep.c @@ -0,0 +1,157 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include "sleep_api.h" +#include "cmsis.h" +#include "pwrman_regs.h" +#include "pwrseq_regs.h" +#include "clkman_regs.h" +#include "ioman_regs.h" +#include "rtc_regs.h" +#include "wait_api.h" + +#define REVISION_A3 2 +#define REVISION_A4 3 + +static mxc_uart_regs_t *stdio_uart = (mxc_uart_regs_t*)STDIO_UART; + +void sleep(void) +{ + // Normal sleep mode for ARM core + SCB->SCR = 0; + + __DSB(); + __WFI(); +} + +// Low-power stop mode +void deepsleep(void) +{ + /* Deep Sleep is not yet supported. */ + sleep(); + +#if 0 + unsigned int part_rev = MXC_PWRMAN->mask_id0 & MXC_F_PWRMAN_MASK_ID0_REVISION_ID; + + // Deep sleep is not working properly on Revisions A3 and earlier + if (part_rev <= REVISION_A3) { + sleep(); + return; + } + + // Wait for all STDIO characters to be sent. The UART clock will stop. + while ( (((stdio_uart->tx_fifo_ctrl & MXC_F_UART_TX_FIFO_CTRL_FIFO_ENTRY) + >> MXC_F_UART_TX_FIFO_CTRL_FIFO_ENTRY_POS) > 0) || + (!(stdio_uart->intfl & MXC_F_UART_INTFL_TX_DONE)) ); + + __disable_irq(); + + // Make sure RTC is not pending before sleeping, if its still synchronizing + // we might not wake up. + while (MXC_RTCTMR->ctrl & MXC_F_RTC_CTRL_PENDING); + + // Clear any active GPIO Wake Up Events + if (MXC_PWRSEQ->flags & MXC_F_PWRSEQ_FLAGS_PWR_IOWAKEUP) { + // NOTE: These must be cleared before clearing IOWAKEUP + MXC_PWRSEQ->reg1 |= MXC_F_PWRSEQ_REG1_PWR_CLR_IO_EVENT_LATCH; + MXC_PWRSEQ->reg1 &= ~MXC_F_PWRSEQ_REG1_PWR_CLR_IO_EVENT_LATCH; + + MXC_PWRSEQ->flags |= MXC_F_PWRSEQ_FLAGS_PWR_IOWAKEUP; + } + + // Set the LP1 select bit so CPU goes to LP1 during SLEEPDEEP + if (part_rev == REVISION_A4) { + MXC_PWRSEQ->reg0 &= ~MXC_F_PWRSEQ_REG0_PWR_LP1; // A4 requires part to go to pseudo LP0 + } else { + MXC_PWRSEQ->reg0 |= MXC_F_PWRSEQ_REG0_PWR_LP1; + } + + // The SLEEPDEEP bit will cause a WFE() to trigger LP0/LP1 (depending on ..._REG0_PWR_LP1 state) + SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk; + + if (part_rev == REVISION_A4) { + // WORKAROUND: Toggle SVM bits, which send extra clocks to the power sequencer to fix retention controller + MXC_PWRSEQ->msk_flags |= MXC_F_PWRSEQ_MSK_FLAGS_PWR_TVDD12_RST_BAD; + MXC_PWRSEQ->reg0 &= ~(MXC_F_PWRSEQ_REG0_PWR_SVMTVDD12EN_RUN); + MXC_PWRSEQ->reg0 |= MXC_F_PWRSEQ_REG0_PWR_SVMTVDD12EN_RUN; + MXC_PWRSEQ->msk_flags &= ~(MXC_F_PWRSEQ_MSK_FLAGS_PWR_TVDD12_RST_BAD); + } + + // Enable Retention controller + MXC_PWRSEQ->retn_ctrl0 |= MXC_F_PWRSEQ_RETN_CTRL0_RETN_CTRL_EN; + + // Freeze GPIO using MBUS so that it doesn't flail while digital core is asleep + MXC_PWRSEQ->reg1 |= MXC_F_PWRSEQ_REG1_PWR_MBUS_GATE; + + // Dummy read to make sure SSB writes are complete + if (MXC_PWRSEQ->reg0 & MXC_F_PWRSEQ_REG0_PWR_SYS_REBOOT) {} + + if (part_rev == REVISION_A4) { + // Note: ARM deep-sleep requires a specific sequence to clear event latches, + // otherwise the CPU will not enter sleep. + __SEV(); + __WFE(); + __WFI(); + } + else { + // Note: ARM deep-sleep requires a specific sequence to clear event latches, + // otherwise the CPU will not enter sleep. + __SEV(); + __WFE(); + __WFE(); + } + + // We'll wakeup here ... + + // Unfreeze the GPIO by clearing MBUS_GATE + MXC_PWRSEQ->reg1 &= ~(MXC_F_PWRSEQ_REG1_PWR_MBUS_GATE); + + // Clear power sequencer event flags (write-1-to-clear) + // RTC and GPIO flags are cleared in their interrupts handlers + // NOTE: We are ignoring all of these potential wake up types + MXC_PWRSEQ->flags = (MXC_F_PWRSEQ_FLAGS_PWR_POWER_FAIL | + MXC_F_PWRSEQ_FLAGS_PWR_BOOT_FAIL | + MXC_F_PWRSEQ_FLAGS_PWR_FLASH_DISCHARGE | + MXC_F_PWRSEQ_FLAGS_PWR_VDD12_RST_BAD | + MXC_F_PWRSEQ_FLAGS_PWR_VDD18_RST_BAD | + MXC_F_PWRSEQ_FLAGS_PWR_VRTC_RST_BAD | + MXC_F_PWRSEQ_FLAGS_PWR_VDDB_RST_BAD | + MXC_F_PWRSEQ_FLAGS_PWR_TVDD12_RST_BAD | + MXC_F_PWRSEQ_FLAGS_PWR_POR18Z_FAIL_LATCH | + MXC_F_PWRSEQ_FLAGS_PWR_USB_PLUG_WAKEUP | + MXC_F_PWRSEQ_FLAGS_PWR_USB_REMOVE_WAKEUP | + MXC_F_PWRSEQ_FLAGS_PWR_TVDD12_BAD); + + __enable_irq(); +#endif +} diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/spi_api.c b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/spi_api.c new file mode 100644 index 0000000000..9e4179f4f9 --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/spi_api.c @@ -0,0 +1,562 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include +#include "mbed_assert.h" +#include "cmsis.h" +#include "spi_api.h" +#include "spi_multi_api.h" +#include "pinmap.h" +#include "ioman_regs.h" +#include "clkman_regs.h" +#include "PeripheralPins.h" + +#define DEFAULT_CHAR 8 +#define DEFAULT_MODE 0 +#define DEFAULT_FREQ 1000000 + +// BYTE maximums for FIFO and page writes; FIFO depth spec'd as 16-bit words +#define SPI_MAX_BYTE_LEN (MXC_CFG_SPI_FIFO_DEPTH * 2) +#define SPI_MAX_PAGE_LEN (MXC_CFG_SPI_FIFO_DEPTH * 2) + +#if DEVICE_SPI_ASYNCH +// Instance references for async transactions +static struct spi_s *state[MXC_CFG_SPI_INSTANCES] = {NULL}; +#endif + +//****************************************************************************** +void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel) +{ + // Make sure pins are pointing to the same SPI instance + SPIName spi_mosi = (SPIName)pinmap_peripheral(mosi, PinMap_SPI_MOSI); + SPIName spi_miso = (SPIName)pinmap_peripheral(miso, PinMap_SPI_MISO); + SPIName spi_sclk = (SPIName)pinmap_peripheral(sclk, PinMap_SPI_SCLK); + SPIName spi_ssel = (SPIName)pinmap_peripheral(ssel, PinMap_SPI_SSEL); + + SPIName spi_data = (SPIName)pinmap_merge(spi_mosi, spi_miso); + SPIName spi_cntl; + + // Give the application the option to manually control Slave Select + if ((SPIName)spi_ssel != (SPIName)NC) { + spi_cntl = (SPIName)pinmap_merge(spi_sclk, spi_ssel); + // Slave select is currently limited to slave select zero. If others are + // to be supported a function to map PinName to a value suitable for use + // in mstr_cfg.slave_sel will be required. + obj->spi.ssel = 0; + } else { + spi_cntl = spi_sclk; + obj->spi.ssel = -1; + } + + SPIName spi = (SPIName)pinmap_merge(spi_data, spi_cntl); + + MBED_ASSERT((SPIName)spi != (SPIName)NC); + + // Set the obj pointer to the proper SPI Instance + obj->spi.spi = (mxc_spi_regs_t*)spi; + + // Set the SPI index and FIFOs + obj->spi.index = MXC_SPI_GET_IDX(obj->spi.spi); + obj->spi.fifo = MXC_SPI_GET_SPI_FIFO(obj->spi.index); + + // Configure the pins + pinmap_pinout(mosi, PinMap_SPI_MOSI); + pinmap_pinout(miso, PinMap_SPI_MISO); + pinmap_pinout(sclk, PinMap_SPI_SCLK); + pinmap_pinout(ssel, PinMap_SPI_SSEL); + +#if DEVICE_SPI_ASYNCH + // Configure default page size; size is known to async interface + obj->spi.spi->mstr_cfg = (obj->spi.spi->mstr_cfg & ~MXC_F_SPI_MSTR_CFG_PAGE_SIZE) | MXC_S_SPI_MSTR_CFG_PAGE_32B; +#endif + + // Enable SPI and FIFOs + obj->spi.spi->gen_ctrl = (MXC_F_SPI_GEN_CTRL_SPI_MSTR_EN | + MXC_F_SPI_GEN_CTRL_TX_FIFO_EN | + MXC_F_SPI_GEN_CTRL_RX_FIFO_EN ); + + obj->spi.sclk = sclk; // save the sclk PinName in the object as a key for Quad SPI pin mapping lookup + spi_master_width(obj, 0); // default this for Single SPI communications +} + +//****************************************************************************** +void spi_format(spi_t *obj, int bits, int mode, int slave) +{ + // Check the validity of the inputs + MBED_ASSERT(((bits >= 1) && (bits <= 32)) && ((mode >= 0) && (mode <= 3))); + + // Only supports master mode + MBED_ASSERT(!slave); + + // Save formatting data + obj->spi.bits = bits; + + // Set the mode + MXC_SET_FIELD(&obj->spi.spi->mstr_cfg, MXC_F_SPI_MSTR_CFG_SPI_MODE, mode << MXC_F_SPI_MSTR_CFG_SPI_MODE_POS); +} + +//****************************************************************************** +void spi_frequency(spi_t *obj, int hz) +{ + // Maximum frequency is half the system frequency + MBED_ASSERT((unsigned int)hz <= (SystemCoreClock / 2)); + unsigned clocks = ((SystemCoreClock / 2) / hz); + + // Figure out the divider ratio + int clk_div = 1; + while (clk_div < 10) { + if (clocks < 0x10) { + break; + } + clk_div++; + clocks = clocks >> 1; + } + + // Turn on the SPI clock + if (obj->spi.index == 0) { + MXC_CLKMAN->sys_clk_ctrl_11_spi0 = clk_div; + } else if (obj->spi.index == 1) { + MXC_CLKMAN->sys_clk_ctrl_12_spi1 = clk_div; + } else if (obj->spi.index == 2) { + MXC_CLKMAN->sys_clk_ctrl_13_spi2 = clk_div; + } else { + MBED_ASSERT(0); + } + + // Set the number of clocks to hold sclk high and low + MXC_SET_FIELD(&obj->spi.spi->mstr_cfg, (MXC_F_SPI_MSTR_CFG_SCK_HI_CLK | MXC_F_SPI_MSTR_CFG_SCK_LO_CLK), + ((clocks << MXC_F_SPI_MSTR_CFG_SCK_HI_CLK_POS) | (clocks << MXC_F_SPI_MSTR_CFG_SCK_LO_CLK_POS))); +} + +//****************************************************************************** +void spi_master_width(spi_t *obj, SpiWidth width) +{ + // Save the width to be used in the SPI header + switch (width) { + case WidthSingle: + obj->spi.width = MXC_S_SPI_FIFO_WIDTH_SINGLE; + break; + case WidthDual: + obj->spi.width = MXC_S_SPI_FIFO_WIDTH_DUAL; + break; + case WidthQuad: + obj->spi.width = MXC_S_SPI_FIFO_WIDTH_QUAD; + // do pin mapping for SDIO[2] and SDIO[3] if Quad SPI is selected + pinmap_pinout(obj->spi.sclk, PinMap_SPI_QUAD); + break; + default: + MBED_ASSERT(0); + } +} + +//****************************************************************************** +/** Performs a master write or read transaction + * + * @param[in] obj The SPI peripheral to use for sending + * @param[in] value The value to send + * @param[in] direction Direction of the transaction, TX, RX or both + * @return Returns the value received during send + */ +static int spi_master_transaction(spi_t *obj, int value, uint32_t direction) +{ + int bits; + + // Create the header + uint16_t header = (direction | // direction based on SPI object + MXC_S_SPI_FIFO_UNIT_BITS | // unit size + ((obj->spi.bits == 32) ? 0 : obj->spi.bits << MXC_F_SPI_FIFO_SIZE_POS) | // Number of units + obj->spi.width | // I/O width + ((obj->spi.ssel == -1) ? 0 : 1 << MXC_F_SPI_FIFO_DASS_POS)); + + // Send the message header + *obj->spi.fifo->trans_16 = header; + + // Send the data + if (obj->spi.bits < 17) { + *obj->spi.fifo->trans_16 = (uint16_t)value; + } else { + *obj->spi.fifo->trans_32 = (uint32_t)value; + } + + // Get the data + bits = obj->spi.bits; + int result = 0; + int i = 0; + while (bits > 0) { + // Wait for data + while (((obj->spi.spi->fifo_ctrl & MXC_F_SPI_FIFO_CTRL_RX_FIFO_USED) + >> MXC_F_SPI_FIFO_CTRL_RX_FIFO_USED_POS) < 1); + + result |= (*obj->spi.fifo->rslts_8 << (i++*8)); + bits-=8; + } + + return result; +} + +//****************************************************************************** +int spi_master_write(spi_t *obj, int value) +{ + // set the fifo direction for full duplex, TX and RX simultaneously + return spi_master_transaction(obj, value, MXC_S_SPI_FIFO_DIR_BOTH); +} + +//****************************************************************************** +int spi_master_read(spi_t *obj) +{ + return spi_master_transaction(obj, 0xFF, MXC_S_SPI_FIFO_DIR_RX); +} + +//****************************************************************************** +// spi_busy() is part of the synchronous API, it is not used by the asynchronous API. +int spi_busy(spi_t *obj) +{ + return !(obj->spi.spi->intfl & MXC_F_SPI_INTFL_TX_READY); +} + +#if DEVICE_SPI_ASYNCH +//****************************************************************************** +static uint32_t spi_master_read_rxfifo(mxc_spi_regs_t *spim, mxc_spi_fifo_regs_t *fifo, uint8_t *data, uint32_t len) +{ + uint32_t num = 0; + uint32_t avail = ((spim->fifo_ctrl & MXC_F_SPI_FIFO_CTRL_RX_FIFO_USED) >> MXC_F_SPI_FIFO_CTRL_RX_FIFO_USED_POS); + + // Get data from the RXFIFO + while (avail && (len - num)) { + // Save data from the RXFIFO + if ((avail >= 4) && ((len - num) >= 4)) { + uint32_t temp = *fifo->rslts_32; + data[num++] = temp; + data[num++] = temp >> 8; + data[num++] = temp >> 16; + data[num++] = temp >> 24; + avail -= 4; + } else if ((avail >= 2) && ((len - num) >= 2)) { + uint16_t temp = *fifo->rslts_16; + data[num++] = temp; + data[num++] = temp >> 8; + avail -= 2; + } else { + data[num++] = *fifo->rslts_8; + avail--; + } + + // Check to see if there is more data in the FIFO + if (avail == 0) { + avail = ((spim->fifo_ctrl & MXC_F_SPI_FIFO_CTRL_RX_FIFO_USED) >> MXC_F_SPI_FIFO_CTRL_RX_FIFO_USED_POS); + } + } + + return num; +} + +//****************************************************************************** +static uint32_t spi_master_transfer_handler(spi_t *obj) +{ + uint8_t read; + uint8_t write; + uint16_t header; + uint32_t pages; + uint32_t bytes; + uint32_t inten; + unsigned remain; + unsigned bytes_read; + unsigned head_rem_temp; + unsigned avail; + struct spi_s *req = &obj->spi; + mxc_spi_regs_t *spim = obj->spi.spi; + mxc_spi_fifo_regs_t *fifo = obj->spi.fifo; + + inten = 0; + + // Figure out if we're reading + read = (req->rx_data != NULL) ? 1 : 0; + + // Figure out if we're writing + write = (req->tx_data != NULL) ? 1 : 0; + + // Read byte from the FIFO if we are reading + if (read) { + + // Read all of the data in the RXFIFO, or until we don't need anymore + bytes_read = spi_master_read_rxfifo(spim, fifo, &req->rx_data[req->read_num], (req->len - req->read_num)); + + req->read_num += bytes_read; + + // Adjust head_rem if we are only reading + if (!write && (req->head_rem > 0)) { + req->head_rem -= bytes_read; + } + + // Figure out how many byte we have left to read + if (req->head_rem > 0) { + remain = req->head_rem; + } else { + remain = req->len - req->read_num; + } + + if (remain) { + + // Set the RX interrupts + if (remain > MXC_CFG_SPI_FIFO_DEPTH) { + spim->fifo_ctrl = ((spim->fifo_ctrl & ~MXC_F_SPI_FIFO_CTRL_RX_FIFO_AF_LVL) | + ((MXC_CFG_SPI_FIFO_DEPTH - 2) << MXC_F_SPI_FIFO_CTRL_RX_FIFO_AF_LVL_POS)); + } else { + spim->fifo_ctrl = ((spim->fifo_ctrl & ~MXC_F_SPI_FIFO_CTRL_RX_FIFO_AF_LVL) | + ((remain - 1) << MXC_F_SPI_FIFO_CTRL_RX_FIFO_AF_LVL_POS)); + } + + inten |= MXC_F_SPI_INTEN_RX_FIFO_AF; + } + } + + // Figure out how many bytes we have left to send headers for + if (write) { + remain = req->len - req->write_num; + } else { + remain = req->len - req->read_num; + } + + // See if we need to send a new header + if ((req->head_rem <= 0) && remain) { + + // Set the transaction configuration in the header + header = ((write | (read << 1)) << MXC_F_SPI_FIFO_DIR_POS) | (req->width << MXC_F_SPI_FIFO_WIDTH_POS); + + if (remain >= SPI_MAX_BYTE_LEN) { + + // Send a 32 byte header + if (remain == SPI_MAX_BYTE_LEN) { + + header |= (MXC_S_SPI_FIFO_UNIT_BYTES | (req->deass << MXC_F_SPI_FIFO_DASS_POS)); + + // Save the number of bytes we need to write to the FIFO + bytes = SPI_MAX_BYTE_LEN; + + } else { + // Send in increments of 32 byte pages + header |= MXC_S_SPI_FIFO_UNIT_PAGES; + pages = remain / SPI_MAX_PAGE_LEN; + + if (pages >= 32) { + // 0 maps to 32 in the header + bytes = 32 * SPI_MAX_PAGE_LEN; + } else { + header |= (pages << MXC_F_SPI_FIFO_SIZE_POS); + bytes = pages * SPI_MAX_PAGE_LEN; + } + + // Check if this is the last header we will send + if((remain - bytes) == 0) { + header |= (req->deass << MXC_F_SPI_FIFO_DASS_POS); + } + } + + fifo->trans_16[0] = header; + + // Save the number of bytes we need to write to the FIFO + req->head_rem = bytes; + + } else { + // Send final header with the number of bytes remaining and if + // we want to de-assert the SS at the end of the transaction + header |= (MXC_S_SPI_FIFO_UNIT_BYTES | (remain << MXC_F_SPI_FIFO_SIZE_POS) | (req->deass << MXC_F_SPI_FIFO_DASS_POS)); + fifo->trans_16[0] = header; + req->head_rem = remain; + } + } + + // Put data into the FIFO if we are writing + remain = req->len - req->write_num; + head_rem_temp = req->head_rem; + if (write && head_rem_temp) { + + // Fill the FIFO + avail = (MXC_CFG_SPI_FIFO_DEPTH - ((spim->fifo_ctrl & MXC_F_SPI_FIFO_CTRL_TX_FIFO_USED) >> MXC_F_SPI_FIFO_CTRL_TX_FIFO_USED_POS)); + + // Use memcpy for everything except the last byte in odd length transactions + while ((avail >= 2) && (head_rem_temp >= 2)) { + + unsigned length; + if (head_rem_temp < avail) { + length = head_rem_temp; + } else { + length = avail; + } + + // Only memcpy even numbers + length = ((length / 2) * 2); + + memcpy((void*)fifo->trans_32, &(req->tx_data[req->write_num]), length); + + head_rem_temp -= length; + req->write_num += length; + + avail = (MXC_CFG_SPI_FIFO_DEPTH - ((spim->fifo_ctrl & MXC_F_SPI_FIFO_CTRL_TX_FIFO_USED) >> MXC_F_SPI_FIFO_CTRL_TX_FIFO_USED_POS)); + } + + // Copy the last byte and pad with 0xF0 to not get confused as header + if ((avail >= 1) && (head_rem_temp == 1)) { + + // Write the last byte + fifo->trans_16[0] = (0xF000 | req->tx_data[req->write_num]); + + avail -= 1; + req->write_num += 1; + head_rem_temp -= 1; + } + + req->head_rem = head_rem_temp; + remain = req->len - req->write_num; + + // Set the TX interrupts + if (remain) { + + // Set the TX FIFO almost empty interrupt if we have to refill + spim->fifo_ctrl = ((spim->fifo_ctrl & ~MXC_F_SPI_FIFO_CTRL_TX_FIFO_AE_LVL) | + ((MXC_CFG_SPI_FIFO_DEPTH - 2) << MXC_F_SPI_FIFO_CTRL_TX_FIFO_AE_LVL_POS)); + + inten |= MXC_F_SPI_INTEN_TX_FIFO_AE; + } + } + + // Check to see if we've finished reading and writing + if (((read && (req->read_num == req->len)) || !read) && + ((req->write_num == req->len) || !write)) { + + // Disable interrupts + spim->inten = 0; + } + + // Enable the SPIM interrupts + return inten; +} + +//****************************************************************************** +void spi_master_transfer(spi_t *obj, const void *tx, size_t tx_length, void *rx, size_t rx_length, uint8_t bit_width, uint32_t handler, uint32_t event, DMAUsage hint) +{ + MBED_ASSERT(tx_length == rx_length); + MBED_ASSERT(bit_width == obj->spi.bits); + + // Save object reference for callback + state[obj->spi.index] = &obj->spi; + + // Initialize request info + obj->spi.deass = 1; + obj->spi.tx_data = tx; + obj->spi.rx_data = rx; + obj->spi.len = tx_length; + obj->spi.callback = (void(*)())handler; + obj->spi.event = event; + // Clear transfer state + obj->spi.read_num = 0; + obj->spi.write_num = 0; + obj->spi.head_rem = 0; + + NVIC_EnableIRQ(MXC_SPI_GET_IRQ(obj->spi.index)); + + obj->spi.spi->inten = spi_master_transfer_handler(obj); +} + +//****************************************************************************** +uint32_t spi_irq_handler_asynch(spi_t *obj) +{ + mxc_spi_regs_t *spim = obj->spi.spi; + uint32_t flags; + + // Clear the interrupt flags + spim->inten = 0; + flags = spim->intfl; + spim->intfl = flags; + + // Figure out if this SPIM has an active request + if (flags) { + if ((spim->inten = spi_master_transfer_handler(obj)) != 0) { + return 0; + } + } + + state[obj->spi.index] = NULL; + + return SPI_EVENT_COMPLETE; +} + +//****************************************************************************** +uint8_t spi_active(spi_t *obj) +{ + mxc_spi_regs_t *spim = obj->spi.spi; + + // Check to see if there are any ongoing transactions + if((state[obj->spi.index] == NULL) && + !(spim->fifo_ctrl & MXC_F_SPI_FIFO_CTRL_TX_FIFO_USED)) { + return 0; + } + + return 1; +} + +//****************************************************************************** +void spi_abort_asynch(spi_t *obj) +{ + mxc_spi_regs_t *spim = obj->spi.spi; + + // Disable interrupts, clear the flags + spim->inten = 0; + spim->intfl = spim->intfl; + + // Reset the SPIM to cancel the on ongoing transaction + spim->gen_ctrl &= ~(MXC_F_SPI_GEN_CTRL_SPI_MSTR_EN); + spim->gen_ctrl |= (MXC_F_SPI_GEN_CTRL_SPI_MSTR_EN); + + state[obj->spi.index] = NULL; +} + +//****************************************************************************** +static void SPI_IRQHandler(int spim_num) +{ + if (state[spim_num] != NULL) { + if (state[spim_num]->callback != NULL) { + state[spim_num]->callback(); + return; + } + } + mxc_spi_regs_t *spim = MXC_SPI_GET_SPI(spim_num); + spim->inten = 0; +} + +//****************************************************************************** +void SPI0_IRQHandler(void) { SPI_IRQHandler(0); } +void SPI1_IRQHandler(void) { SPI_IRQHandler(1); } +void SPI2_IRQHandler(void) { SPI_IRQHandler(2); } + +#endif diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/spi_multi_api.h b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/spi_multi_api.h new file mode 100644 index 0000000000..9e6e37318f --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/spi_multi_api.h @@ -0,0 +1,67 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#ifndef MBED_SPI_MULTI_H +#define MBED_SPI_MULTI_H + +#include "spi_api.h" + +typedef enum { + WidthSingle = 0, + WidthDual = 1, + WidthQuad = 2, +} SpiWidth; + +#ifdef __cplusplus +extern "C" { +#endif + +/** Read a byte in master mode, this is use for Dual or Quad SPI when a simplex transfer is needed + * + * @param[in] obj The SPI peripheral to use for sending + * @return Returns the value received + */ +int spi_master_read(spi_t *obj); + +/** Specify I/O width of SPI transaction + * + * @param[in] obj The SPI peripheral to use for sending + * @param[in] width The I/O width of SPI transaction + */ +void spi_master_width(spi_t *obj, SpiWidth width); + +#ifdef __cplusplus +} +#endif // __cplusplus + +#endif // MBED_SPI_MULTI_H diff --git a/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/us_ticker.c b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/us_ticker.c new file mode 100644 index 0000000000..747243e1e7 --- /dev/null +++ b/hal/targets/hal/TARGET_Maxim/TARGET_MAX32620/us_ticker.c @@ -0,0 +1,291 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#include "mbed_error.h" +#include "us_ticker_api.h" +#include "PeripheralNames.h" +#include "tmr_regs.h" +#include "clkman_regs.h" + +#define US_TIMER MXC_TMR0 +#define US_TIMER_IRQn TMR0_0_IRQn + +/** + * Defines timer modes for 16 and 32-bit timers + */ +typedef enum { + /** 32-bit or 16-bit timer one-shot mode */ + MXC_E_TMR_MODE_ONE_SHOT = 0, + /** 32-bit or 16-bit timer one-shot mode */ + MXC_E_TMR_MODE_CONTINUOUS, + /** 32-bit timer counter mode */ + MXC_E_TMR_MODE_COUNTER, + /** 32-bit timer pulse width modulation mode */ + MXC_E_TMR_MODE_PWM, + /** 32-bit timer capture mode */ + MXC_E_TMR_MODE_CAPTURE, + /** 32-bit timer compare mode */ + MXC_E_TMR_MODE_COMPARE, + /** 32-bit timer gated mode */ + MXC_E_TMR_MODE_GATED, + /** 32-bit timer measure mode */ + MXC_E_TMR_MODE_MEASURE +} mxc_tmr_mode_t; + +static int us_ticker_inited = 0; +static uint32_t ticks_per_us; +static uint32_t tick_win; +static volatile uint64_t current_cnt; // Hold the current ticks +static volatile uint64_t event_cnt; // Holds the value of the next event + +#define ticks_to_us(ticks) ((ticks) / ticks_per_us); +#define MAX_TICK_VAL ((uint64_t)0xFFFFFFFF * ticks_per_us) + +//****************************************************************************** +static inline void inc_current_cnt(uint32_t inc) { + + // Overflow the ticker when the us ticker overflows + current_cnt += inc; + if (current_cnt > MAX_TICK_VAL) { + current_cnt -= (MAX_TICK_VAL + 1); + } +} + +//****************************************************************************** +static inline int event_passed(uint64_t current, uint64_t event) { + + // Determine if the event has already happened. + // If the event is behind the current ticker, within a window, + // then the event has already happened. + if (((current < tick_win) && ((event < current) || + (event > (MAX_TICK_VAL - (tick_win - current))))) || + ((event < current) && (event > (current - tick_win)))) { + return 1; + } + + return 0; +} + +//****************************************************************************** +static inline uint64_t event_diff(uint64_t current, uint64_t event) { + + // Check to see if the ticker will overflow before the event + if(current <= event) { + return (event - current); + } + + return ((MAX_TICK_VAL - current) + event); +} + +//****************************************************************************** +static void tmr_handler(void) +{ + uint32_t term_cnt32 = US_TIMER->term_cnt32; + US_TIMER->term_cnt32 = 0xFFFFFFFF; // reset to max value to prevent further interrupts + US_TIMER->intfl = (MXC_F_TMR_INTFL_TIMER0 | MXC_F_TMR_INTFL_TIMER1); // clear interrupt + NVIC_ClearPendingIRQ(US_TIMER_IRQn); + + inc_current_cnt(term_cnt32); + + if (event_passed(current_cnt + US_TIMER->count32, event_cnt )) { + // the timestamp has expired + event_cnt = 0xFFFFFFFFFFFFFFFFULL; // reset to max value + us_ticker_irq_handler(); + } else { + + uint64_t diff = event_diff(current_cnt, event_cnt); + if (diff < (uint64_t)0xFFFFFFFF) { + // the event occurs before the next overflow + US_TIMER->term_cnt32 = diff; + + // Since the timer keeps counting after the terminal value is reached, it is possible that the new + // terminal value is in the past. + if (US_TIMER->term_cnt32 < US_TIMER->count32) { + // the timestamp has expired + US_TIMER->term_cnt32 = 0xFFFFFFFF; // reset to max value to prevent further interrupts + US_TIMER->intfl = (MXC_F_TMR_INTFL_TIMER0 | MXC_F_TMR_INTFL_TIMER1); // clear interrupt + NVIC_ClearPendingIRQ(US_TIMER_IRQn); + event_cnt = 0xFFFFFFFFFFFFFFFFULL; // reset to max value + us_ticker_irq_handler(); + } + } + } +} + +//****************************************************************************** +void us_ticker_init(void) +{ + if (us_ticker_inited) + return; + us_ticker_inited = 1; + + /* Ensure that the TIMER0 clock is enabled */ + if (!(MXC_CLKMAN->clk_gate_ctrl1 & MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER0_CLK_GATER)) { + MXC_CLKMAN->clk_gate_ctrl1 |= (2 << MXC_F_CLKMAN_CLK_GATE_CTRL1_TIMER0_CLK_GATER_POS); + } + + current_cnt = 0; + event_cnt = 0xFFFFFFFFFFFFFFFFULL; // reset to max value + + if (SystemCoreClock <= 1000000) { + error("us_ticker cannot operate at this SystemCoreClock"); + return; + } + + // Configure timer for 32-bit continuous mode with /1 prescaler + US_TIMER->ctrl = MXC_E_TMR_MODE_CONTINUOUS << MXC_F_TMR_CTRL_MODE_POS | (0 << MXC_F_TMR_CTRL_PRESCALE_POS); + ticks_per_us = SystemCoreClock / 1000000; + + // Set the tick window to 10ms + tick_win = SystemCoreClock/100; + + // Set timer overflow to the max + US_TIMER->term_cnt32 = 0xFFFFFFFF; + US_TIMER->pwm_cap32 = 0xFFFFFFFF; + US_TIMER->count32 = 0; + + US_TIMER->intfl = (MXC_F_TMR_INTFL_TIMER0 | MXC_F_TMR_INTFL_TIMER1); // clear pending interrupts + + NVIC_SetVector(US_TIMER_IRQn, (uint32_t)tmr_handler); + NVIC_EnableIRQ(US_TIMER_IRQn); + + US_TIMER->inten |= MXC_F_TMR_INTEN_TIMER0; // enable interrupts + US_TIMER->ctrl |= MXC_F_TMR_CTRL_ENABLE0; // enable timer +} + +//****************************************************************************** +void us_ticker_deinit(void) +{ + US_TIMER->ctrl = 0; // disable timer + US_TIMER->inten = 0; // disable interrupts + US_TIMER->intfl = (MXC_F_TMR_INTFL_TIMER0 | MXC_F_TMR_INTFL_TIMER1); // clear interrupts + us_ticker_inited = 0; +} + +//****************************************************************************** +uint32_t us_ticker_read(void) +{ + uint64_t current_cnt1, current_cnt2; + uint32_t term_cnt, tmr_cnt; + uint32_t intfl1, intfl2; + + if (!us_ticker_inited) + us_ticker_init(); + + // Ensure coherency between current_cnt and US_TIMER->count32 + do { + current_cnt1 = current_cnt; + intfl1 = US_TIMER->intfl; + term_cnt = US_TIMER->term_cnt32; + tmr_cnt = US_TIMER->count32; + intfl2 = US_TIMER->intfl; + current_cnt2 = current_cnt; + } while ((current_cnt1 != current_cnt2) || (intfl1 != intfl2)); + + // Account for an unserviced interrupt + if (intfl1) { + current_cnt1 += term_cnt; + } + + current_cnt1 += tmr_cnt; + + return (current_cnt1 / ticks_per_us); +} + +//****************************************************************************** +void us_ticker_set_interrupt(timestamp_t timestamp) +{ + // Note: interrupts are disabled before this function is called. + + US_TIMER->ctrl &= ~MXC_F_TMR_CTRL_ENABLE0; // disable timer + + if (US_TIMER->intfl) { + US_TIMER->intfl = (MXC_F_TMR_INTFL_TIMER0 | MXC_F_TMR_INTFL_TIMER1); // clear interrupt + NVIC_ClearPendingIRQ(US_TIMER_IRQn); + inc_current_cnt(US_TIMER->term_cnt32); + } + + // add and reset the current count value + inc_current_cnt(US_TIMER->count32); + US_TIMER->count32 = 0; + + // add the number of cycles that the timer is disabled here for + inc_current_cnt(200); + + event_cnt = (uint64_t)timestamp * ticks_per_us; + + // Check to see if the event has already passed + if (!event_passed(current_cnt, event_cnt)) { + uint64_t diff = event_diff(current_cnt, event_cnt); + if (diff < (uint64_t)0xFFFFFFFF) { + // the event occurs before the next overflow + US_TIMER->term_cnt32 = diff; + } else { + // the event occurs after the next overflow + US_TIMER->term_cnt32 = 0xFFFFFFFF; // set to max + } + } else { + // the requested timestamp occurs in the past + // set the timer up to immediately expire + US_TIMER->term_cnt32 = 1; + } + US_TIMER->ctrl |= MXC_F_TMR_CTRL_ENABLE0; // enable timer +} + +//****************************************************************************** +void us_ticker_disable_interrupt(void) +{ + // There are no more events, set timer overflow to the max + US_TIMER->term_cnt32 = 0xFFFFFFFF; +} + +//****************************************************************************** +void us_ticker_clear_interrupt(void) +{ + // cleared in the local handler +} + +//****************************************************************************** +void us_ticker_set(timestamp_t timestamp) +{ + US_TIMER->ctrl &= ~MXC_F_TMR_CTRL_ENABLE0; // disable timer + current_cnt = (uint64_t)timestamp * ticks_per_us; + US_TIMER->count32 = 0; + US_TIMER->term_cnt32 = 0xFFFFFFFF; + US_TIMER->ctrl |= MXC_F_TMR_CTRL_ENABLE0; // enable timer + + if (((uint64_t)timestamp * ticks_per_us) >= event_cnt) { + // The next timestamp has elapsed. Trigger the interrupt to handle it. + NVIC_SetPendingIRQ(US_TIMER_IRQn); + } +} diff --git a/libraries/USBDevice/USBDevice/USBHAL_Maxim.cpp b/libraries/USBDevice/USBDevice/USBHAL_Maxim.cpp index 13e193cd2c..d8fc0756d8 100644 --- a/libraries/USBDevice/USBDevice/USBHAL_Maxim.cpp +++ b/libraries/USBDevice/USBDevice/USBHAL_Maxim.cpp @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (C) 2015 Maxim Integrated Products, Inc., All Rights Reserved. + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -58,7 +58,7 @@ typedef struct { ep_buffer_t ep[MXC_USB_NUM_EP - 1]; } ep_buffer_descriptor_t; -// Static storage for endpoint buffer descriptor table. Must be 512 byte alligned for DMA. +// Static storage for endpoint buffer descriptor table. Must be 512 byte aligned for DMA. #ifdef __IAR_SYSTEMS_ICC__ #pragma data_alignment = 512 #else @@ -66,7 +66,7 @@ __attribute__ ((aligned (512))) #endif ep_buffer_descriptor_t ep_buffer_descriptor; -// static storage for temporary data buffers. Must be 32 byte alligned. +// static storage for temporary data buffers. Must be 32 byte aligned. #ifdef __IAR_SYSTEMS_ICC__ #pragma data_alignment = 4 #else @@ -74,7 +74,7 @@ __attribute__ ((aligned (4))) #endif static uint8_t aligned_buffer[NUMBER_OF_LOGICAL_ENDPOINTS][MXC_USB_MAX_PACKET]; -// contorl packet state +// control packet state static enum { CTRL_NONE = 0, CTRL_SETUP, @@ -86,11 +86,16 @@ USBHAL::USBHAL(void) { NVIC_DisableIRQ(USB_IRQn); +#if defined(TARGET_MAX32600) // The PLL must be enabled for USB MBED_ASSERT(MXC_CLKMAN->clk_config & MXC_F_CLKMAN_CLK_CONFIG_PLL_ENABLE); // Enable the USB clock MXC_CLKMAN->clk_ctrl |= MXC_F_CLKMAN_CLK_CTRL_USB_GATE_N; +#elif defined(TARGET_MAX32620) + // Enable the USB clock + MXC_CLKMAN->clk_ctrl |= MXC_F_CLKMAN_CLK_CTRL_USB_CLOCK_ENABLE; +#endif // reset the device MXC_USB->cn = 0; @@ -203,7 +208,11 @@ static ep_buffer_t *get_desc(uint8_t endpoint) void USBHAL::EP0setup(uint8_t *buffer) { - memcpy(buffer, (void*)&MXC_USB->setup0, 8); // setup packet is fixed at 8 bytes + // Setup packet is fixed at 8 bytes + // Setup registers cannot be read in byte mode + uint32_t *ptr32 = (uint32_t*)buffer; + ptr32[0] = (uint32_t)MXC_USB->setup0; + ptr32[1] = (uint32_t)MXC_USB->setup1; } void USBHAL::EP0read(void) diff --git a/tools/build_travis.py b/tools/build_travis.py index 93a32a9b2e..3ebfc67e30 100644 --- a/tools/build_travis.py +++ b/tools/build_travis.py @@ -113,6 +113,7 @@ build_list = ( { "target": "MAXWSNENV", "toolchains": "GCC_ARM", "libs": ["dsp", "fat"] }, { "target": "MAX32600MBED", "toolchains": "GCC_ARM", "libs": ["dsp", "fat"] }, + { "target": "MAX32620HSP", "toolchains": "GCC_ARM", "libs": ["dsp", "fat"] }, { "target": "RZ_A1H", "toolchains": "GCC_ARM", "libs": ["fat"] }, diff --git a/tools/export/gccarm.py b/tools/export/gccarm.py index d1e955a8b6..3cdb0477ff 100644 --- a/tools/export/gccarm.py +++ b/tools/export/gccarm.py @@ -99,6 +99,7 @@ class GccArm(Exporter): 'DISCO_F334C8', 'MAX32600MBED', 'MAXWSNENV', + 'MAX32620HSP', 'MTS_MDOT_F405RG', 'MTS_MDOT_F411RE', 'NUCLEO_L152RE', diff --git a/tools/export_test.py b/tools/export_test.py index 384932e118..c668e79c24 100644 --- a/tools/export_test.py +++ b/tools/export_test.py @@ -155,6 +155,7 @@ if __name__ == '__main__': ('uvision', 'MTS_MDOT_F405RG'), ('uvision', 'MAXWSNENV'), ('uvision', 'MAX32600MBED'), + ('uvision', 'MAX32620HSP'), ('uvision', 'DISCO_F051R8'), ('uvision', 'DISCO_F103RB'), ('uvision', 'DISCO_F303VC'), @@ -226,6 +227,7 @@ if __name__ == '__main__': ('gcc_arm', 'RZ_A1H'), ('gcc_arm', 'MAXWSNENV'), ('gcc_arm', 'MAX32600MBED'), + ('gcc_arm', 'MAX32620HSP'), ('gcc_arm', 'ARCH_BLE'), ('gcc_arm', 'ARCH_MAX'), ('gcc_arm', 'ARCH_PRO'), @@ -287,6 +289,7 @@ if __name__ == '__main__': ('iar', 'MTS_MDOT_F411RE'), ('iar', 'MAXWSNENV'), ('iar', 'MAX32600MBED'), + ('iar', 'MAX32620HSP'), ('iar', 'MOTE_L152RC'), ('iar', 'RZ_A1H'),

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