From a9563f6d39e8e426c10e74e3b653d9210b64a11f Mon Sep 17 00:00:00 2001 From: Frank Voorburg Date: Sat, 3 Mar 2012 20:39:31 +0000 Subject: [PATCH] - Added support for the GCC compiler on target ARMCM3_LM3S, including demos. git-svn-id: https://svn.code.sf.net/p/openblt/code/trunk@29 5dc33758-31d5-4daf-9ae8-b24bf3d40d73 --- .../Boot/bin/openbtl_ek_lm3s6965.bin | Bin 0 -> 14282 bytes .../Boot/bin/openbtl_ek_lm3s6965.elf | Bin 0 -> 147597 bytes .../Boot/bin/openbtl_ek_lm3s6965.map | 334 + .../Boot/cmd/build.bat | 2 + .../Boot/cmd/clean.bat | 2 + .../ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/config.h | 108 + .../ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/hooks.c | 179 + .../Boot/ide/DemoBoot.project | 149 + .../Boot/ide/DemoBoot.tags | Bin 0 -> 4195328 bytes .../Boot/ide/DemoBoot.workspace | 12 + .../Boot/ide/DemoBoot.workspace.session | 16 + .../Boot/ide/readme.txt | 4 + .../Boot/lib/EULA.txt | 400 + .../Boot/lib/driverlib/cpulib.c | 442 + .../Boot/lib/driverlib/cpulib.h | 60 + .../Boot/lib/driverlib/debug.h | 58 + .../Boot/lib/driverlib/flashlib.c | 912 + .../Boot/lib/driverlib/flashlib.h | 106 + .../Boot/lib/driverlib/gpio.c | 1600 ++ .../Boot/lib/driverlib/gpio.h | 767 + .../Boot/lib/driverlib/interrupt.c | 723 + .../Boot/lib/driverlib/interrupt.h | 77 + .../Boot/lib/driverlib/sysctl.c | 2366 ++ .../Boot/lib/driverlib/sysctl.h | 466 + .../Boot/lib/driverlib/uartlib.c | 1611 ++ .../Boot/lib/driverlib/uartlib.h | 243 + .../Boot/lib/inc/hw_flash.h | 381 + .../Boot/lib/inc/hw_gpio.h | 592 + .../Boot/lib/inc/hw_ints.h | 141 + .../Boot/lib/inc/hw_memmap.h | 115 + .../Boot/lib/inc/hw_nvic.h | 1189 + .../Boot/lib/inc/hw_sysctl.h | 1687 ++ .../Boot/lib/inc/hw_types.h | 185 + .../Boot/lib/inc/hw_uart.h | 458 + .../ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/main.c | 100 + .../ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/makefile | 192 + .../Prog/bin/demoprog_ek_lm3s6965.elf | Bin 0 -> 294121 bytes .../Prog/bin/demoprog_ek_lm3s6965.map | 687 + .../Prog/bin/demoprog_ek_lm3s6965.srec | 3181 +++ .../ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/boot.c | 172 + .../ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/boot.h | 42 + .../Prog/cmd/build.bat | 2 + .../Prog/cmd/clean.bat | 2 + .../ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/cstart.c | 94 + .../ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/header.h | 56 + .../Prog/ide/DemoProg.project | 177 + .../Prog/ide/DemoProg.tags | Bin 0 -> 9706496 bytes .../Prog/ide/DemoProg.workspace | 12 + .../Prog/ide/DemoProg.workspace.session | 16 + .../Prog/ide/readme.txt | 4 + .../ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/irq.c | 97 + .../ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/irq.h | 43 + .../ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/led.c | 101 + .../ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/led.h | 42 + .../Prog/lib/EULA.txt | 400 + .../Prog/lib/driverlib/adc.c | 1470 ++ .../Prog/lib/driverlib/adc.h | 258 + .../Prog/lib/driverlib/comp.c | 436 + .../Prog/lib/driverlib/comp.h | 130 + .../Prog/lib/driverlib/cpu.c | 442 + .../Prog/lib/driverlib/cpu.h | 60 + .../Prog/lib/driverlib/debug.h | 53 + .../Prog/lib/driverlib/epi.c | 1176 + .../Prog/lib/driverlib/epi.h | 304 + .../Prog/lib/driverlib/ethernet.c | 1327 + .../Prog/lib/driverlib/ethernet.h | 171 + .../Prog/lib/driverlib/flash.c | 912 + .../Prog/lib/driverlib/flash.h | 106 + .../Prog/lib/driverlib/gpio.c | 1600 ++ .../Prog/lib/driverlib/gpio.h | 767 + .../Prog/lib/driverlib/hibernate.c | 962 + .../Prog/lib/driverlib/hibernate.h | 127 + .../Prog/lib/driverlib/i2c.c | 1106 + .../Prog/lib/driverlib/i2c.h | 179 + .../Prog/lib/driverlib/i2s.c | 1136 + .../Prog/lib/driverlib/i2s.h | 154 + .../Prog/lib/driverlib/interrupt.c | 723 + .../Prog/lib/driverlib/interrupt.h | 77 + .../Prog/lib/driverlib/mpu.c | 446 + .../Prog/lib/driverlib/mpu.h | 147 + .../Prog/lib/driverlib/pin_map.h | 20413 ++++++++++++++++ .../Prog/lib/driverlib/pwm.c | 1748 ++ .../Prog/lib/driverlib/pwm.h | 283 + .../Prog/lib/driverlib/qei.c | 616 + .../Prog/lib/driverlib/qei.h | 112 + .../Prog/lib/driverlib/rom.h | 3584 +++ .../Prog/lib/driverlib/rom_map.h | 3444 +++ .../Prog/lib/driverlib/ssi.c | 706 + .../Prog/lib/driverlib/ssi.h | 125 + .../Prog/lib/driverlib/sysctl.c | 2366 ++ .../Prog/lib/driverlib/sysctl.h | 466 + .../Prog/lib/driverlib/systick.c | 259 + .../Prog/lib/driverlib/systick.h | 63 + .../Prog/lib/driverlib/timer.c | 1161 + .../Prog/lib/driverlib/timer.h | 165 + .../Prog/lib/driverlib/uart.c | 1611 ++ .../Prog/lib/driverlib/uart.h | 243 + .../Prog/lib/driverlib/udma.c | 1178 + .../Prog/lib/driverlib/udma.h | 442 + .../Prog/lib/driverlib/usb.c | 3871 +++ .../Prog/lib/driverlib/usb.h | 567 + .../Prog/lib/driverlib/watchdog.c | 564 + .../Prog/lib/driverlib/watchdog.h | 71 + .../Prog/lib/inc/asmdefs.h | 212 + .../Prog/lib/inc/hw_adc.h | 1193 + .../Prog/lib/inc/hw_comp.h | 277 + .../Prog/lib/inc/hw_epi.h | 499 + .../Prog/lib/inc/hw_ethernet.h | 679 + .../Prog/lib/inc/hw_flash.h | 381 + .../Prog/lib/inc/hw_gpio.h | 592 + .../Prog/lib/inc/hw_hibernate.h | 242 + .../Prog/lib/inc/hw_i2c.h | 407 + .../Prog/lib/inc/hw_i2s.h | 224 + .../Prog/lib/inc/hw_ints.h | 141 + .../Prog/lib/inc/hw_memmap.h | 115 + .../Prog/lib/inc/hw_nvic.h | 1189 + .../Prog/lib/inc/hw_pwm.h | 756 + .../Prog/lib/inc/hw_qei.h | 201 + .../Prog/lib/inc/hw_ssi.h | 217 + .../Prog/lib/inc/hw_sysctl.h | 1687 ++ .../Prog/lib/inc/hw_timer.h | 474 + .../Prog/lib/inc/hw_types.h | 185 + .../Prog/lib/inc/hw_uart.h | 458 + .../Prog/lib/inc/hw_udma.h | 331 + .../Prog/lib/inc/hw_usb.h | 4620 ++++ .../Prog/lib/inc/hw_watchdog.h | 175 + .../Prog/lib/inc/lm3s6965.h | 4795 ++++ .../ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/main.c | 120 + .../ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/makefile | 226 + .../ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/memory.x | 37 + .../ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/time.c | 118 + .../ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/time.h | 44 + .../Prog/vectors.c | 142 + Target/Source/ARMCM3_LM3S/GCC/cstart.c | 151 + Target/Source/ARMCM3_LM3S/GCC/memory.x | 39 + Target/Source/ARMCM3_LM3S/GCC/vectors.c | 137 + 136 files changed, 100196 insertions(+) create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/bin/openbtl_ek_lm3s6965.bin create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/bin/openbtl_ek_lm3s6965.elf create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/bin/openbtl_ek_lm3s6965.map create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/cmd/build.bat create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/cmd/clean.bat create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/config.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/hooks.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/DemoBoot.project create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/DemoBoot.tags create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/DemoBoot.workspace create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/DemoBoot.workspace.session create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/readme.txt create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/EULA.txt create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/cpulib.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/cpulib.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/debug.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/flashlib.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/flashlib.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/gpio.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/gpio.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/interrupt.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/interrupt.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/sysctl.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/sysctl.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/uartlib.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/uartlib.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_flash.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_gpio.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_ints.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_memmap.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_nvic.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_sysctl.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_types.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_uart.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/main.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/makefile create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/bin/demoprog_ek_lm3s6965.elf create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/bin/demoprog_ek_lm3s6965.map create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/bin/demoprog_ek_lm3s6965.srec create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/boot.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/boot.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/cmd/build.bat create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/cmd/clean.bat create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/cstart.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/header.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/DemoProg.project create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/DemoProg.tags create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/DemoProg.workspace create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/DemoProg.workspace.session create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/readme.txt create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/irq.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/irq.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/led.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/led.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/EULA.txt create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/adc.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/adc.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/comp.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/comp.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/cpu.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/cpu.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/debug.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/epi.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/epi.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ethernet.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ethernet.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/flash.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/flash.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/gpio.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/gpio.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/hibernate.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/hibernate.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2c.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2c.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2s.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2s.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/interrupt.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/interrupt.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/mpu.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/mpu.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/pin_map.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/pwm.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/pwm.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/qei.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/qei.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/rom.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/rom_map.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ssi.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ssi.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/sysctl.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/sysctl.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/systick.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/systick.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/timer.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/timer.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/uart.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/uart.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/udma.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/udma.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/usb.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/usb.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/watchdog.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/watchdog.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/asmdefs.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_adc.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_comp.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_epi.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_ethernet.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_flash.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_gpio.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_hibernate.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_i2c.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_i2s.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_ints.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_memmap.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_nvic.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_pwm.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_qei.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_ssi.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_sysctl.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_timer.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_types.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_uart.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_udma.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_usb.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_watchdog.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/lm3s6965.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/main.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/makefile create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/memory.x create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/time.c create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/time.h create mode 100644 Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/vectors.c create mode 100644 Target/Source/ARMCM3_LM3S/GCC/cstart.c create mode 100644 Target/Source/ARMCM3_LM3S/GCC/memory.x create mode 100644 Target/Source/ARMCM3_LM3S/GCC/vectors.c diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/bin/openbtl_ek_lm3s6965.bin b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/bin/openbtl_ek_lm3s6965.bin new file mode 100644 index 0000000000000000000000000000000000000000..93a8f9b7a48e9eca976a9fba4f0048d65642a816 GIT binary patch literal 14282 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 vn|IQBx)Nu=SWQm)|I^HG7_JWqr5|^;3^Id|7 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 literal 0 HcmV?d00001 diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/bin/openbtl_ek_lm3s6965.map b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/bin/openbtl_ek_lm3s6965.map new file mode 100644 index 00000000..9f6b06d5 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/bin/openbtl_ek_lm3s6965.map @@ -0,0 +1,334 @@ + +bin/openbtl_ek_lm3s6965.elf: file format elf32-littlearm +bin/openbtl_ek_lm3s6965.elf +architecture: arm, flags 0x00000112: +EXEC_P, HAS_SYMS, D_PAGED +start address 0x00000000 + +Program Header: + LOAD off 0x00008000 vaddr 0x00000000 paddr 0x00000000 align 2**15 + filesz 0x000036ae memsz 0x000036ae flags r-x + LOAD off 0x00010000 vaddr 0x20000000 paddr 0x000036ae align 2**15 + filesz 0x0000011c memsz 0x00000708 flags rw- +private flags = 5000000: [Version5 EABI] + +Sections: +Idx Name Size VMA LMA File off Algn + 0 .text 000036ae 00000000 00000000 00008000 2**2 + CONTENTS, ALLOC, LOAD, READONLY, CODE + 1 .data 0000011c 20000000 000036ae 00010000 2**2 + CONTENTS, ALLOC, LOAD, DATA + 2 .bss 000005ec 2000011c 000037ca 0001011c 2**2 + ALLOC + 3 .debug_abbrev 00001319 00000000 00000000 0001011c 2**0 + CONTENTS, READONLY, DEBUGGING + 4 .debug_info 00003c91 00000000 00000000 00011435 2**0 + CONTENTS, READONLY, DEBUGGING + 5 .debug_line 000023cc 00000000 00000000 000150c6 2**0 + CONTENTS, READONLY, DEBUGGING + 6 .debug_pubtypes 000003ef 00000000 00000000 00017492 2**0 + CONTENTS, READONLY, DEBUGGING + 7 .debug_str 000017f3 00000000 00000000 00017881 2**0 + CONTENTS, READONLY, DEBUGGING + 8 .comment 0000002a 00000000 00000000 00019074 2**0 + CONTENTS, READONLY + 9 .ARM.attributes 00000031 00000000 00000000 0001909e 2**0 + CONTENTS, READONLY + 10 .debug_loc 000036c2 00000000 00000000 000190cf 2**0 + CONTENTS, READONLY, DEBUGGING + 11 .debug_pubnames 000010f0 00000000 00000000 0001c791 2**0 + CONTENTS, READONLY, DEBUGGING + 12 .debug_aranges 00000878 00000000 00000000 0001d881 2**0 + CONTENTS, READONLY, DEBUGGING + 13 .debug_ranges 00000768 00000000 00000000 0001e0f9 2**0 + CONTENTS, READONLY, DEBUGGING + 14 .debug_frame 000016d0 00000000 00000000 0001e864 2**2 + CONTENTS, READONLY, DEBUGGING +SYMBOL TABLE: +00000000 l d .text 00000000 .text +20000000 l d .data 00000000 .data +2000011c l d .bss 00000000 .bss +00000000 l d .debug_abbrev 00000000 .debug_abbrev +00000000 l d .debug_info 00000000 .debug_info +00000000 l d .debug_line 00000000 .debug_line +00000000 l d .debug_pubtypes 00000000 .debug_pubtypes +00000000 l d .debug_str 00000000 .debug_str +00000000 l d .comment 00000000 .comment +00000000 l d .ARM.attributes 00000000 .ARM.attributes +00000000 l d .debug_loc 00000000 .debug_loc +00000000 l d .debug_pubnames 00000000 .debug_pubnames +00000000 l d .debug_aranges 00000000 .debug_aranges +00000000 l d .debug_ranges 00000000 .debug_ranges +00000000 l d .debug_frame 00000000 .debug_frame +00000000 l df *ABS* 00000000 vectors.c +00000000 l df *ABS* 00000000 cstart.c +0000011a l F .text 00000000 zero_loop2 +00003366 l F .text 00000000 zero_loop +00000000 l df *ABS* 00000000 hooks.c +00000000 l df *ABS* 00000000 main.c +00000000 l df *ABS* 00000000 cpulib.c +00000000 l df *ABS* 00000000 flashlib.c +00003388 l O .text 00000010 g_pulFMPPERegs +000033b4 l O .text 00000010 g_pulFMPRERegs +000033c4 l O .text 00000003 CSWTCH.4 +00000000 l df *ABS* 00000000 sysctl.c +00000664 l F .text 00000168 SysCtlPeripheralValid +000033c8 l O .text 00000010 g_pulDCRegs +000033d8 l O .text 0000005c g_pulXtals +00003450 l O .text 0000000c g_pulDCGCRegs +0000345c l O .text 0000000c g_pulRCGCRegs +00003468 l O .text 0000000c g_pulSCGCRegs +00003474 l O .text 0000000c g_pulSRCRRegs +00000000 l df *ABS* 00000000 interrupt.c +000012d0 l F .text 00000002 IntDefaultHandler +20000000 l O .data 0000011c g_pfnRAMVectors +0000349c l O .text 00000020 g_pulPriority +000034bc l O .text 00000048 g_pulRegs +00000000 l df *ABS* 00000000 gpio.c +00001628 l F .text 000000c4 GPIOBaseValid +000016ec l F .text 000000f4 GPIOGetIntNumber +0000351c l O .text 00000048 g_pulGPIOBaseAddrs +00000000 l df *ABS* 00000000 uartlib.c +00002044 l F .text 0000002c UARTBaseValid +00000000 l df *ABS* 00000000 boot.c +00000000 l df *ABS* 00000000 com.c +2000011c l O .bss 00000001 comEntryStateConnect +2000011d l O .bss 00000040 xcpCtoReqPacket.1375 +00000000 l df *ABS* 00000000 xcp.c +00002b48 l F .text 0000000c XcpProtectResources +00002b54 l F .text 00000014 XcpSetCtoError +0000357e l O .text 00000008 xcpStationId +20000160 l O .bss 0000004c xcpInfo +00000000 l df *ABS* 00000000 backdoor.c +200001ac l O .bss 00000001 backdoorOpen +00000000 l df *ABS* 00000000 cop.c +00000000 l df *ABS* 00000000 assert.c +200001b0 l O .bss 00000004 assert_failure_file +200001b4 l O .bss 00000004 assert_failure_line +00000000 l df *ABS* 00000000 cpu.c +00000000 l df *ABS* 00000000 uart.c +00002e38 l F .text 00000020 UartReceiveByte +00002e58 l F .text 00000024 UartTransmitByte +200001b8 l O .bss 00000041 xcpCtoReqPacket.1577 +200001f9 l O .bss 00000001 xcpCtoRxLength.1578 +200001fa l O .bss 00000001 xcpCtoRxInProgress.1579 +00000000 l df *ABS* 00000000 nvm.c +00000000 l df *ABS* 00000000 timer.c +200001fc l O .bss 00000002 millisecond_counter +00000000 l df *ABS* 00000000 flash.c +00002fe4 l F .text 00000038 FlashGetSector +0000301c l F .text 00000030 FlashGetSectorBaseAddr +0000304c l F .text 0000004e FlashWriteBlock +0000309a l F .text 00000026 FlashInitBlock +000030c0 l F .text 00000040 FlashSwitchBlock +00003100 l F .text 00000080 FlashAddToBlock +000035ac l O .text 000000d8 flashLayout +20000200 l O .bss 00000204 bootBlockInfo +20000404 l O .bss 00000204 blockInfo +000020b0 g F .text 00000020 UARTParityModeGet +00002ac4 g F .text 0000002c ComInit +00003198 g F .text 00000048 FlashWrite +00000b88 g F .text 0000000c SysCtlLDOGet +00000b3c g F .text 00000018 SysCtlIntStatus +00002dd8 g F .text 00000018 AssertFailure +00001cfc g F .text 00000034 GPIOPinTypeGPIOInput +00001e34 g F .text 00000034 GPIOPinTypeSSI +00002a38 g F .text 00000024 UARTDMADisable +00003348 g F .text 00000038 reset_handler +00001158 g F .text 0000005c SysCtlGPIOAHBDisable +0000106c g F .text 0000002c SysCtlADCSpeedGet +00001bec g F .text 00000030 GPIOPortIntUnregister +00002f88 g F .text 0000001c TimerUpdate +00002b94 g F .text 00000010 XcpPacketTransmitted +000029ac g F .text 00000024 UARTIntDisable +00002af0 g F .text 0000001c ComTask +000029f4 g F .text 00000020 UARTIntClear +00000c3c g F .text 00000006 SysCtlDelay +00000630 g F .text 00000010 FlashIntDisable +00002b20 g F .text 0000000c ComSetConnectEntryState +00000fdc g F .text 00000034 SysCtlPWMClockGet +00002a9c g F .text 00000016 BootInit +00000620 g F .text 00000010 FlashIntEnable +00001bb8 g F .text 00000034 GPIOPortIntRegister +00002dbc g F .text 00000018 BackDoorInit +00002dd6 g F .text 00000002 CopService +000036ae g .text 00000000 _etext +0000091c g F .text 00000054 SysCtlPeripheralReset +00000bc4 g F .text 00000004 SysCtlSleep +00000be8 g F .text 0000000c SysCtlResetCauseGet +000013fc g F .text 00000034 IntPriorityGet +00001398 g F .text 00000024 IntPriorityGroupingGet +00001b20 g F .text 00000028 GPIOPinIntEnable +000028a8 g F .text 00000034 UARTBreakCtl +00001c3c g F .text 00000024 GPIOPinWrite +0000019c g F .text 00000006 CPUbasepriGet +000027e0 g F .text 00000028 UARTSpaceAvail +00000a58 g F .text 00000038 SysCtlPeripheralDeepSleepEnable +00001540 g F .text 00000078 IntPendSet +00002f7c g F .text 0000000c TimerReset +000028fc g F .text 00000048 UARTIntRegister +00002854 g F .text 0000002c UARTCharPutNonBlocking +00002ab2 g F .text 00000012 BootTask +00002988 g F .text 00000024 UARTIntEnable +0000327c g F .text 00000044 FlashWriteChecksum +00002b0e g F .text 00000010 ComTransmitPacket +0000234c g F .text 00000024 UARTDisableSIR +00001a7c g F .text 000000a4 GPIOPadConfigGet +000025f0 g F .text 00000078 UARTModemStatusGet +00001dcc g F .text 00000034 GPIOPinTypePWM +000009e4 g F .text 00000038 SysCtlPeripheralSleepEnable +00000970 g F .text 00000038 SysCtlPeripheralEnable +00002880 g F .text 00000028 UARTCharPut +00002370 g F .text 00000080 UARTSmartCardEnable +00001620 g F .text 00000004 IntPriorityMaskSet +00002b84 g F .text 00000010 XcpIsConnected +00002144 g F .text 00000044 UARTConfigGetExpClk +00002f58 g F .text 00000004 NvmInit +00000bb4 g F .text 00000010 SysCtlReset +00003180 g F .text 00000018 FlashInit +00001b48 g F .text 00000028 GPIOPinIntDisable +00002464 g F .text 0000008c UARTModemControlSet +20000608 g .bss 00000000 _ebss +00000b20 g F .text 00000010 SysCtlIntDisable +000007e0 g F .text 00000014 SysCtlFlashSizeGet +00000100 g *ABS* 00000000 __STACKSIZE__ +00000bf4 g F .text 00000010 SysCtlResetCauseClear +0000333c g F .text 0000000c UnusedISR +00001f04 g F .text 00000034 GPIOPinTypeUSBAnalog +000007cc g F .text 00000014 SysCtlSRAMSizeGet +00001c1c g F .text 00000020 GPIOPinRead +00002b0c g F .text 00000002 ComFree +00000a1c g F .text 0000003c SysCtlPeripheralSleepDisable +00001f6c g F .text 00000034 GPIOPinTypeEthernetLED +00001834 g F .text 0000004c GPIODirModeGet +00001c60 g F .text 00000034 GPIOPinTypeADC +00002668 g F .text 00000088 UARTFlowControlSet +000010fc g F .text 0000005c SysCtlGPIOAHBEnable +00000acc g F .text 0000001c SysCtlPeripheralClockGating +000027b8 g F .text 00000028 UARTCharsAvail +00002e7c g F .text 00000028 UartInit +000007f4 g F .text 000000cc SysCtlPinPresent +000023f0 g F .text 00000074 UARTSmartCardDisable +00002f60 g F .text 00000004 NvmErase +00001d98 g F .text 00000034 GPIOPinTypeI2C +00002808 g F .text 00000028 UARTCharGetNonBlocking +000015b8 g F .text 00000068 IntPendClear +00001d64 g F .text 00000034 GPIOPinTypeGPIOOutputOD +2000011c g .bss 00000000 _bss +00002ba4 g F .text 000001e8 XcpPacketReceived +000022f8 g F .text 00000024 UARTFIFODisable +00000b94 g F .text 00000020 SysCtlLDOConfigSet +00000554 g F .text 0000003c FlashUserSet +00003308 g F .text 00000034 FlashDone +00001e00 g F .text 00000034 GPIOPinTypeQEI +00002b2c g F .text 0000000c ComSetDisconnectEntryState +000000f0 g F .text 0000004c EntryFromProg +00001364 g F .text 00000034 IntPriorityGroupingSet +00002b38 g F .text 0000000c ComIsConnectEntryState +00001880 g F .text 00000080 GPIOIntTypeSet +000001a4 g F .text 0000000c FlashUsecGet +000024f0 g F .text 0000008c UARTModemControlClear +0000017c g F .text 00000008 CPUcpsid +00000658 g F .text 0000000c FlashIntClear +00000192 g F .text 00000004 CPUwfi +00000bc8 g F .text 00000020 SysCtlDeepSleep +00000184 g F .text 00000006 CPUprimask +0000257c g F .text 00000074 UARTModemControlGet +0000020c g F .text 000000cc FlashProgram +00002b68 g F .text 0000001c XcpInit +00002118 g F .text 0000002c UARTFIFOLevelGet +0000049c g F .text 00000050 FlashProtectSave +000031e0 g F .text 0000009c FlashErase +00000b54 g F .text 00000034 SysCtlLDOSet +00000150 g F .text 0000002c main +00000d9c g F .text 000001dc SysCtlClockGet +000011d4 g F .text 000000fc SysCtlI2SMClkSet +00001098 g F .text 0000001c SysCtlIOSCVerificationSet +0000060c g F .text 00000012 FlashIntUnregister +00002760 g F .text 00000038 UARTTxIntModeSet +000021b8 g F .text 00000038 UARTDisable +00002f68 g F .text 00000012 NvmDone +00002ea4 g F .text 00000050 UartTransmitPacket +00002f64 g F .text 00000004 NvmVerifyChecksum +00002e14 g F .text 00000020 CpuMemCopy +00000ae8 g F .text 00000014 SysCtlIntRegister +00002fa4 g F .text 0000000c TimerSet +000011b4 g F .text 00000010 SysCtlUSBPLLEnable +0000133c g F .text 00000028 IntUnregister +00001c94 g F .text 00000034 GPIOPinTypeCAN +00000afc g F .text 00000012 SysCtlIntUnregister +00001fa0 g F .text 00000034 GPIOPinTypeEPI +00000640 g F .text 00000018 FlashIntStatus +000029d0 g F .text 00000024 UARTIntStatus +00001f38 g F .text 00000034 GPIOPinTypeI2S +000012d2 g F .text 0000000a IntMasterEnable +00002ef4 g F .text 00000064 UartReceivePacket +000012e8 g F .text 00000054 IntRegister +00002a5c g F .text 00000020 UARTRxErrorGet +00001010 g F .text 0000005c SysCtlADCSpeedSet +00000c04 g F .text 00000038 SysCtlBrownOutConfigSet +000012dc g F .text 0000000a IntMasterDisable +00001ed0 g F .text 00000034 GPIOPinTypeUSBDigital +000014b8 g F .text 00000088 IntDisable +000013bc g F .text 00000040 IntPrioritySet +00001b98 g F .text 00000020 GPIOPinIntClear +000005f8 g F .text 00000014 FlashIntRegister +20000000 g .data 00000000 _data +00002dd4 g F .text 00000002 CopInit +00002e34 g F .text 00000004 CpuReset +00002830 g F .text 00000024 UARTCharGet +000020d0 g F .text 00000048 UARTFIFOLevelSet +00002f5c g F .text 00000004 NvmWrite +000022d4 g F .text 00000024 UARTFIFOEnable +00000590 g F .text 00000068 FlashUserSave +00002df0 g F .text 00000024 CpuStartUserProgram +000010b4 g F .text 0000001c SysCtlMOSCVerificationSet +00000b10 g F .text 00000010 SysCtlIntEnable +000026f0 g F .text 00000070 UARTFlowControlGet +20000708 g .bss 00000000 _estack +00002798 g F .text 00000020 UARTTxIntModeGet +000032c0 g F .text 00000046 FlashVerifyChecksum +2000011c g .data 00000000 _edata +000001b0 g F .text 0000000c FlashUsecSet +00000000 g O .text 000000f0 _vectab +000004ec g F .text 00000068 FlashUserGet +00001624 g F .text 00000004 IntPriorityMaskGet +00001e68 g F .text 00000034 GPIOPinTypeTimer +000010d0 g F .text 0000001c SysCtlPLLVerificationSet +00001e9c g F .text 00000034 GPIOPinTypeUART +00001cc8 g F .text 00000034 GPIOPinTypeComparator +00000196 g F .text 00000006 CPUbasepriSet +00001d30 g F .text 00000034 GPIOPinTypeGPIOOutput +00000f78 g F .text 00000064 SysCtlPWMClockSet +000002d8 g F .text 0000009c FlashProtectGet +00002b44 g F .text 00000004 ComIsConnected +00000b30 g F .text 0000000c SysCtlIntClear +00001430 g F .text 00000088 IntEnable +000028dc g F .text 00000020 UARTBusy +00001fd4 g F .text 00000070 GPIOPinConfigure +000010ec g F .text 00000010 SysCtlClkVerificationClear +0000018a g F .text 00000008 CPUcpsie +000017e0 g F .text 00000054 GPIODirModeSet +00002944 g F .text 00000044 UARTIntUnregister +00002d8c g F .text 00000030 BackDoorCheck +00000a90 g F .text 0000003c SysCtlPeripheralDeepSleepDisable +20000608 g .bss 00000000 _stack +00001900 g F .text 0000005c GPIOIntTypeGet +00000374 g F .text 00000128 FlashProtectSet +00002fd4 g F .text 00000010 TimerGet +00002a7c g F .text 00000020 UARTRxErrorClear +000009a8 g F .text 0000003c SysCtlPeripheralDisable +00002a14 g F .text 00000024 UARTDMAEnable +000021f0 g F .text 000000e4 UARTConfigSetExpClk +00001b70 g F .text 00000028 GPIOPinIntStatus +000011c4 g F .text 00000010 SysCtlUSBPLLDisable +00000c44 g F .text 00000158 SysCtlClockSet +000008c0 g F .text 0000005c SysCtlPeripheralPresent +0000195c g F .text 00000120 GPIOPadConfigSet +00002fb0 g F .text 00000024 TimerInit +0000231c g F .text 00000030 UARTEnableSIR +000001bc g F .text 00000050 FlashClear +00002188 g F .text 00000030 UARTEnable +00002070 g F .text 00000040 UARTParityModeSet + + diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/cmd/build.bat b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/cmd/build.bat new file mode 100644 index 00000000..44c0c1b8 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/cmd/build.bat @@ -0,0 +1,2 @@ +@echo off +make --directory=../ all diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/cmd/clean.bat b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/cmd/clean.bat new file mode 100644 index 00000000..32c4b5f2 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/cmd/clean.bat @@ -0,0 +1,2 @@ +@echo off +make --directory=../ clean diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/config.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/config.h new file mode 100644 index 00000000..cb42489d --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/config.h @@ -0,0 +1,108 @@ +/**************************************************************************************** +| Description: bootloader configuration header file +| File Name: config.h +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ +#ifndef CONFIG_H +#define CONFIG_H + +/**************************************************************************************** +* C P U D R I V E R C O N F I G U R A T I O N +****************************************************************************************/ +/* To properly initialize the baudrate clocks of the communication interface, typically + * the speed of the crystal oscillator and/or the speed at which the system runs is + * needed. Set these through configurables BOOT_CPU_XTAL_SPEED_KHZ and + * BOOT_CPU_SYSTEM_SPEED_KHZ, respectively. To enable data exchange with the host that is + * not dependent on the targets architecture, the byte ordering needs to be known. + * Setting BOOT_CPU_BYTE_ORDER_MOTOROLA to 1 selects little endian mode and 0 selects + * big endian mode. + */ +#define BOOT_CPU_XTAL_SPEED_KHZ (8000) +#define BOOT_CPU_SYSTEM_SPEED_KHZ (50000) +#define BOOT_CPU_BYTE_ORDER_MOTOROLA (0) + + +/**************************************************************************************** +* C O M M U N I C A T I O N I N T E R F A C E C O N F I G U R A T I O N +****************************************************************************************/ +/* The UART communication interface is selected by setting the BOOT_COM_UART_ENABLE + * configurable to 1. Configurable BOOT_COM_UART_BAUDRATE selects the communication speed + * in bits/second. The maximum amount of data bytes in a message for data transmission + * and reception is set through BOOT_COM_UART_TX_MAX_DATA and BOOT_COM_UART_RX_MAX_DATA, + * respectively. It is common for a microcontroller to have more than 1 UART interface + * on board. The zero-based BOOT_COM_UART_CHANNEL_INDEX selects the UART interface. + * + */ +#define BOOT_COM_UART_ENABLE (1) +#define BOOT_COM_UART_BAUDRATE (57600) +#define BOOT_COM_UART_TX_MAX_DATA (64) +#define BOOT_COM_UART_RX_MAX_DATA (64) +#define BOOT_COM_UART_CHANNEL_INDEX (0) + + +/**************************************************************************************** +* B A C K D O O R E N T R Y C O N F I G U R A T I O N +****************************************************************************************/ +/* It is possible to implement an application specific method to force the bootloader to + * stay active after a reset. Such a backdoor entry into the bootloader is desired in + * situations where the user program does not run properly and therefore cannot + * reactivate the bootloader. By enabling these hook functions, the application can + * implement the backdoor, which overrides the default backdoor entry that is programmed + * into the bootloader. When desired for security purposes, these hook functions can + * also be implemented in a way that disables the backdoor entry altogether. + */ +#define BOOT_BACKDOOR_HOOKS_ENABLE (0) + + +/**************************************************************************************** +* N O N - V O L A T I L E M E M O R Y D R I V E R C O N F I G U R A T I O N +****************************************************************************************/ +/* The NVM driver typically supports erase and program operations of the internal memory + * present on the microcontroller. Through these hook functions the NVM driver can be + * extended to support additional memory types such as external flash memory and serial + * eeproms. The size of the internal memory in kilobytes is specified with configurable + * BOOT_NVM_SIZE_KB. + */ +#define BOOT_NVM_HOOKS_ENABLE (0) +#define BOOT_NVM_SIZE_KB (256) + + +/**************************************************************************************** +* W A T C H D O G D R I V E R C O N F I G U R A T I O N +****************************************************************************************/ +/* The COP driver cannot be configured internally in the bootloader, because its use + * and configuration is application specific. The bootloader does need to service the + * watchdog in case it is used. When the application requires the use of a watchdog, + * set BOOT_COP_HOOKS_ENABLE to be able to initialize and service the watchdog through + * hook functions. + */ +#define BOOT_COP_HOOKS_ENABLE (0) + + +#endif /* CONFIG_H */ +/*********************************** end of config.h ***********************************/ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/hooks.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/hooks.c new file mode 100644 index 00000000..9b0be4a5 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/hooks.c @@ -0,0 +1,179 @@ +/**************************************************************************************** +| Description: bootloader callback source file +| File Name: hooks.c +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "boot.h" /* bootloader generic header */ + + +/**************************************************************************************** +* B A C K D O O R E N T R Y H O O K F U N C T I O N S +****************************************************************************************/ + +#if (BOOT_BACKDOOR_HOOKS_ENABLE > 0) +/**************************************************************************************** +** NAME: BackDoorInitHook +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Initializes the backdoor entry option. +** +****************************************************************************************/ +void BackDoorInitHook(void) +{ +} /*** end of BackDoorInitHook ***/ + + +/**************************************************************************************** +** NAME: BackDoorEntryHook +** PARAMETER: none +** RETURN VALUE: BLT_TRUE if the backdoor entry is requested, BLT_FALSE otherwise. +** DESCRIPTION: Checks if a backdoor entry is requested. +** +****************************************************************************************/ +blt_bool BackDoorEntryHook(void) +{ + /* default implementation always activates the bootloader after a reset */ + return BLT_TRUE; +} /*** end of BackDoorEntryHook ***/ +#endif /* BOOT_BACKDOOR_HOOKS_ENABLE > 0 */ + + +/**************************************************************************************** +* N O N - V O L A T I L E M E M O R Y D R I V E R H O O K F U N C T I O N S +****************************************************************************************/ + +#if (BOOT_NVM_HOOKS_ENABLE > 0) +/**************************************************************************************** +** NAME: NvmInitHook +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Callback that gets called at the start of the internal NVM driver +** initialization routine. +** +****************************************************************************************/ +void NvmInitHook(void) +{ +} /*** end of NvmInitHook ***/ + + +/**************************************************************************************** +** NAME: NvmWriteHook +** PARAMETER: addr start address +** len length in bytes +** data pointer to the data buffer. +** RETURN VALUE: BLT_NVM_OKAY if successful, BLT_NVM_NOT_IN_RANGE if the address is +** not within the supported memory range, or BLT_NVM_ERROR is the write +** operation failed. +** DESCRIPTION: Callback that gets called at the start of the NVM driver write +** routine. It allows additional memory to be operated on. If the address +** is not within the range of the additional memory, then +** BLT_NVM_NOT_IN_RANGE must be returned to indicate that the data hasn't +** been written yet. +** +** +****************************************************************************************/ +blt_int8u NvmWriteHook(blt_addr addr, blt_int32u len, blt_int8u *data) +{ + return BLT_NVM_NOT_IN_RANGE; +} /*** end of NvmWriteHook ***/ + + +/**************************************************************************************** +** NAME: NvmEraseHook +** PARAMETER: addr start address +** len length in bytes +** RETURN VALUE: BLT_NVM_OKAY if successful, BLT_NVM_NOT_IN_RANGE if the address is +** not within the supported memory range, or BLT_NVM_ERROR is the erase +** operation failed. +** DESCRIPTION: Callback that gets called at the start of the NVM driver erase +** routine. It allows additional memory to be operated on. If the address +** is not within the range of the additional memory, then +** BLT_NVM_NOT_IN_RANGE must be returned to indicate that the memory +** hasn't been erased yet. +** +****************************************************************************************/ +blt_int8u NvmEraseHook(blt_addr addr, blt_int32u len) +{ + return BLT_NVM_NOT_IN_RANGE; +} /*** end of NvmEraseHook ***/ + + +/**************************************************************************************** +** NAME: NvmDoneHook +** PARAMETER: none +** RETURN VALUE: BLT_TRUE is successful, BLT_FALSE otherwise. +** DESCRIPTION: Callback that gets called at the end of the NVM programming session. +** +****************************************************************************************/ +blt_bool NvmDoneHook(void) +{ + return BLT_TRUE; +} /*** end of NvmDoneHook ***/ +#endif /* BOOT_NVM_HOOKS_ENABLE > 0 */ + + +/**************************************************************************************** +* W A T C H D O G D R I V E R H O O K F U N C T I O N S +****************************************************************************************/ + +#if (BOOT_COP_HOOKS_ENABLE > 0) +/**************************************************************************************** +** NAME: CopInitHook +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Callback that gets called at the end of the internal COP driver +** initialization routine. It can be used to configure and enable the +** watchdog. +** +****************************************************************************************/ +void CopInitHook(void) +{ +} /*** end of CopInitHook ***/ + + +/**************************************************************************************** +** NAME: CopServiceHook +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Callback that gets called at the end of the internal COP driver +** service routine. This gets called upon initialization and during +** potential long lasting loops and routine. It can be used to service +** the watchdog to prevent a watchdog reset. +** +****************************************************************************************/ +void CopServiceHook(void) +{ +} /*** end of CopServiceHook ***/ +#endif /* BOOT_COP_HOOKS_ENABLE > 0 */ + + +/*********************************** end of hooks.c ************************************/ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/DemoBoot.project b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/DemoBoot.project new file mode 100644 index 00000000..ab881f9c --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/DemoBoot.project @@ -0,0 +1,149 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + break main +continue + + + + + + + make clean + make + + + + None + $(WorkspacePath)/.. + + + + + + + + + + + + + + + + + + + + + + + make clean + make + + + + None + $(WorkspacePath) + + + + + + + + diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/DemoBoot.tags b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/DemoBoot.tags new file mode 100644 index 0000000000000000000000000000000000000000..99c6896764092a811e73aecaa6bd22d0fc1ca287 GIT binary patch literal 4195328 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%0Aen?}I5S(I79HRXl9pYa0LpfzABFPsZHXUa2| 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

@&p7EvH=RM=gv@dwYr(@b> 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 literal 0 HcmV?d00001 diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/DemoBoot.workspace b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/DemoBoot.workspace new file mode 100644 index 00000000..7957a1d7 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/DemoBoot.workspace @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/DemoBoot.workspace.session b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/DemoBoot.workspace.session new file mode 100644 index 00000000..42d8c8f6 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/DemoBoot.workspace.session @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/readme.txt b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/readme.txt new file mode 100644 index 00000000..8a340a19 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/ide/readme.txt @@ -0,0 +1,4 @@ +Integrated Development Environment +---------------------------------- +Codelite was used as the editor during the development of this software program. This directory contains the Codelite +workspace and project files. Codelite is a cross platform open source C/C++ IDE, available at http://www.codelite.org/. \ No newline at end of file diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/EULA.txt b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/EULA.txt new file mode 100644 index 00000000..7c1cfc7a --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/EULA.txt @@ -0,0 +1,400 @@ +License Agreement + +Important - This is a legally binding agreement. Read it carefully. After you +read the following terms, you will be asked whether you are authorized to +commit your company to abide by the following terms. THIS AGREEMENT IS +DISPLAYED FOR YOU TO READ PRIOR TO DOWNLOADING OR USING THE "LICENSED +MATERIALS". + +DO NOT DOWNLOAD OR INSTALL the software programs unless you agree on behalf of +yourself and your company to be bound by the terms of this License Agreement. + +DO NOT CLICK "I AGREE" UNLESS: + +1. YOU ARE AUTHORIZED TO AGREE TO THE TERMS OF THIS LICENSE ON BEHALF OF +YOURSELF AND YOUR COMPANY; AND + +2. YOU INTEND TO ENTER THIS LEGALLY BINDING AGREEMENT ON BEHALF OF YOURSELF AND +YOUR COMPANY. + +Important - Read carefully: This software license agreement ("Agreement") is a +legal agreement between you (either an individual or entity) and Texas +Instruments Incorporated ("TI"). The "Licensed Materials" subject to this +Agreement include the software programs TI has granted you access to download +and any "on-line" or electronic documentation associated with these programs, +or any portion thereof, and may also include hardware, reference designs and +associated documentation. The Licensed Materials are specifically designed and +licensed for use solely and exclusively with microprocessor/microcontroller +devices manufactured by or for TI ("TI Devices"). By installing, copying or +otherwise using the Licensed Materials you agree to abide by the provisions set +forth herein. This Agreement is displayed for you to read prior to using the +Licensed Materials. If you choose not to accept or agree with these provisions, +do not download or install the Licensed Materials. + +1. Delivery. TI may deliver the Licensed Materials, or portions thereof, to you +electronically. + +2. License Grant and Use Restrictions. + +a. Limited Source Code License. Subject to the terms of this Agreement, and +commencing as of the Effective Date and continuing for the term of this +Agreement, TI hereby grants to you a limited, free, non-transferable, +non-exclusive, non-assignable, non-sub-licensable license to make copies, +prepare derivative works, display internally and use internally the Licensed +Materials provided to you in source code for the sole purposes of designing and +developing object and executable versions of such Licensed Materials or any +derivative thereof, that execute solely and exclusively on TI Devices used in +Customer Product(s), and maintaining and supporting such Licensed Materials, or +any derivative thereof, and Customer Product(s). "Customer Product" means a +final product distributed by or for you that consists of both hardware, +including one or more TI Devices, and software components, including only +executable versions of the Licensed Materials that execute solely and +exclusively on or with such TI Devices and not on devices manufactured by or +for an entity other than TI. + +b. Production and Distribution License. Subject to the terms of this Agreement, +and commencing as of the Effective Date and continuing for the term of this +Agreement, TI hereby grants to you a free, non-exclusive, non-transferable, +non-assignable, worldwide license to: + +(i). Use object code versions of the Licensed Materials, or any derivative +thereof, to make copies, display internally, evaluate, test, distribute +internally and use internally for the sole purposes of designing and developing +Customer Product(s), and maintaining and supporting the Licensed Materials and +Customer Product(s); + +(ii). Make copies, use, sell, offer to sell, and otherwise distribute object +code and executable versions of the Licensed Materials, or any derivative +thereof, for use in or with Customer Product(s), provided that such Licensed +Materials are embedded in or only used with Customer Product(s), and provided +further that such Licensed Materials execute solely and exclusively on a TI +Device and not on any device manufactured by or for an entity other than TI. + +c. Demonstration License. Subject to the terms of this Agreement, and +commencing as of the Effective Date and continuing for the term of this +Agreement, TI grants to you a free, non-transferable, non-exclusive, +non-assignable, non-sub-licensable worldwide license to demonstrate to third +parties the Licensed Materials as they are used in Customer Products executing +solely and exclusively on TI Devices, provided that such Licensed Materials are +demonstrated in object or executable versions only. + +d. Reference Design Use License. Subject to the terms of this Agreement, and +commencing as of the Effective Date and continuing for the term of this +Agreement, TI hereby grants to you a free, non-transferable, non-exclusive, +non-assignable, non-sub-licensable worldwide license to: + +(i). use the Licensed Materials to design, develop, manufacture or have +manufactured, sell, offer to sell, or otherwise distribute Customer Product(s) +or product designs, including portions or derivatives of the Licensed Materials +as they are incorporated in or used with Customer Product(s), provided such +Customer Products or product designs utilize a TI Device. + +e. Contractors and Suppliers. The licenses granted to you hereunder shall +include your on-site and off-site suppliers and independent contractors, while +such suppliers and independent contractors are performing work for or providing +services to you, provided that such suppliers and independent contractors have +executed work-for-hire agreements with you containing terms and conditions not +inconsistent with the terms and conditions set forth is this Agreement and +provided further that such contractors may provide work product to only you +under such work-for-hire agreements. + +f. No Other License. Notwithstanding anything to the contrary, nothing in this +Agreement shall be construed as a license to any intellectual property rights +of TI other than those rights embodied in the Licensed Materials provided to +you by TI. EXCEPT AS PROVIDED HEREIN, NO OTHER LICENSE, EXPRESS OR IMPLIED, BY +ESTOPPEL OR OTHERWISE, TO ANY OTHER TI INTELLECTUAL PROPERTY RIGHTS IS GRANTED +HEREIN. + +g. Restrictions. You shall maintain the source code versions of the Licensed +Materials under password control protection and shall not disclose such source +code versions of the Licensed Materials, or any derivative thereof, to any +person other than your employees and contractors whose job performance requires +access. You shall not use the Licensed Materials with a processing device +manufactured by or for an entity other than TI, and you agree that any such +unauthorized use of the Licensed Materials is a material breach of this +Agreement. Except as expressly provided in this Agreement, you shall not copy, +publish, disclose, display, provide, transfer or make available the Licensed +Materials to any third party and you shall not sublicense, transfer, or assign +the Licensed Materials or your rights under this Agreement to any third party. +You shall not mortgage, pledge or encumber the Licensed Materials in any way. +You shall not (i) incorporate, combine, or distribute the Licensed Materials, +or any derivative thereof, with any Public Software, or (ii) use Public +Software in the development of any derivatives of the Licensed Materials, each +in such a way that would cause the Licensed Materials, or any derivative +thereof, to be subject to all or part of the license obligations or other +intellectual property related terms with respect to such Public Software, +including but not limited to, the obligations that the Licensed Materials, or +any derivative thereof, incorporated into, combined, or distributed with such +Public Software (x) be disclosed or distributed in source code form, be +licensed for the purpose of making derivatives of such software, or be +redistributed free of charge, contrary to the terms and conditions of this +Agreement, (y) be used with devices other than TI Devices, or (z) be otherwise +used or distributed in a manner contrary to the terms and conditions of this +Agreement. As used in this Section 2(g), "Public Software" means any software +that contains, or is derived in whole or in part from, any software distributed +as open source software, including but not limited to software licensed under +the following or similar models: (A) GNU's General Public License (GPL) or +Lesser/Library GPL (LGPL), (B) the Artistic License (e.g., PERL), (C) the +Mozilla Public License, (D) the Netscape Public License, (E) the Sun Community +Source License (SCSL), (F) the Sun Industry Standards Source License (SISL), +(G) the Apache Server license, (H) QT Free Edition License, (I) IBM Public +License, and (J) BitKeeper. + +h. Termination. This Agreement is effective until terminated. You may terminate +this Agreement at any time by written notice to TI. Without prejudice to any +other rights, if you fail to comply with the terms of this Agreement, TI may +terminate your right to use the Licensed Materials upon written notice to you. +Upon termination of this Agreement, you will destroy any and all copies of the +Licensed Materials in your possession, custody or control and provide to TI a +written statement signed by your authorized representative certifying such +destruction. The following sections will survive any expiration or termination +of this Agreement: 2(h) (Termination), 3 (Licensed Materials Ownership), 6 +(Warranties and Limitations), 7 (Indemnification Disclaimer), 10 (Export +Control), 11 (Governing Law and Severability), 12 (PRC Provisions), and 13 +(Entire Agreement). The obligations set forth in Section 5 (Confidential +Information) will survive any expiration or termination of this Agreement for +three (3) years after such expiration or termination. + +3. Licensed Materials Ownership. The Licensed Materials are licensed, not sold +to you, and can only be used in accordance with the terms of this Agreement. +Subject to the licenses granted to you pursuant to this Agreement, TI and TI's +licensors own and shall continue to own all right, title, and interest in and +to the Licensed Materials, including all copies thereof. The parties agree that +all fixes, modifications and improvements to the Licensed Materials conceived +of or made by TI that are based, either in whole or in part, on your feedback, +suggestions or recommendations are the exclusive property of TI and all right, +title and interest in and to such fixes, modifications or improvements to the +Licensed Materials will vest solely in TI. Moreover, you acknowledge and agree +that when your independently developed software or hardware components are +combined, in whole or in part, with the Licensed Materials, your right to use +the Licensed Materials embodied in such resulting combined work shall remain +subject to the terms and conditions of this Agreement. + +4. Intellectual Property Rights. + +a. The Licensed Materials contain copyrighted material, trade secrets and other +proprietary information of TI and TI's licensors and are protected by copyright +laws, international copyright treaties, and trade secret laws, as well as other +intellectual property laws. To protect TI's and TI's licensors' rights in the +Licensed Materials, you agree, except as specifically permitted by statute by a +provision that cannot be waived by contract, not to "unlock", decompile, +reverse engineer, disassemble or otherwise translate any portions of the +Licensed Materials to a human-perceivable form nor to permit any person or +entity to do so. You shall not remove, alter, cover, or obscure any +confidentiality, trade secret, proprietary, or copyright notices, trade-marks, +proprietary, patent, or other identifying marks or designs from any component +of the Licensed Materials and you shall reproduce and include in all copies of +the Licensed Materials the copyright notice(s) and proprietary legend(s) of TI +and TI's licensors as they appear in the Licensed Materials. TI reserves all +rights not specifically granted under this Agreement. + +b. Third parties may claim to own patents, copyrights, or other intellectual +property rights that cover the implementation of certain Licensed Materials. +Certain Licensed Materials may also be based on industry recognized standards, +including but not limited to specifically the ISO MPEG and ITU standards, and +software programs published by industry recognized standards bodies and certain +third parties claim to own patents, copyrights, and other intellectual property +rights that cover implementation of those standards. You acknowledge and agree +that this Agreement does not convey a license to any such third party patents, +copyrights, and other intellectual property rights and that you are solely +responsible for any patent, copyright, or other intellectual property right +claims that relate to your use and distribution of the Licensed Materials, and +your use and distribution of your products that include or incorporate the +Licensed Materials. + +5. Confidential Information. You acknowledge and agree that the Licensed +Materials contain trade secrets and other confidential information of TI and +TI's licensors. You agree to use the Licensed Materials solely within the scope +of the licenses set forth herein, to maintain the Licensed Materials in strict +confidence, to use at least the same procedures and degree of care that you use +to prevent disclosure of your own confidential information of like importance +but in no instance less than reasonable care, and to prevent disclosure of the +Licensed Materials to any third party, except as may be necessary and required +in connection with your rights and obligations hereunder. You agree to obtain +executed confidentiality agreements with your employees and contractors having +access to the Licensed Materials and to diligently take steps to enforce such +agreements in this respect. TI agrees that the employment agreements used in +the normal course of your business shall satisfy the requirements of this +section. TI may disclose your contact information to TI's applicable licensors. + +6. Warranties and Limitations. YOU ACKNOWLEDGE AND AGREE THAT THE LICENSED +MATERIALS MAY NOT BE INTENDED FOR PRODUCTION APPLICATIONS AND MAY CONTAIN +IRREGULARITIES AND DEFECTS NOT FOUND IN PRODUCTION SOFTWARE. FURTHERMORE, YOU +ACKNOWLEDGE AND AGREE THAT THE LICENSED MATERIALS HAVE NOT BEEN TESTED OR +CERTIFIED BY ANY GOVERNMENT AGENCY OR INDUSTRY REGULATORY ORGANIZATION OR ANY +OTHER THIRD PARTY ORGANIZATION. YOU AGREE THAT PRIOR TO USING, INCORPORATING OR +DISTRIBUTING THE LICENSED MATERIALS IN OR WITH ANY COMMERCIAL PRODUCT THAT YOU +WILL THOROUGHLY TEST THE PRODUCT AND THE FUNCTIONALITY OF THE LICENSED +MATERIALS IN OR WITH THAT PRODUCT AND BE SOLELY RESPONSIBLE FOR ANY PROBLEMS OR +FAILURES. + +THE LICENSED MATERIALS AND ANY REALTED DOCUMENTATION ARE PROVIDED "AS IS" AND +WITH ALL FAULTS. TI MAKES NO WARRANTY OR REPRESENTATION, WHETHER EXPRESS, +IMPLIED OR STATUTORY, REGARDING THE LICENSED MATERIALS, INCLUDING BUT NOT +LIMITED TO, ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A +PARTICULAR PURPOSE, LACK OF VIRUSES, ACCURACY OR COMPLETENESS OF RESPONSES, +RESULTS AND LACK OF NEGLIGENCE. TI DISCLAIMS ANY WARRANTY OF TITLE, QUIET +ENJOYMENT, QUIET POSSESSION, AND NON-INFRINGEMENT OF ANY THIRD PARTY PATENTS, +COPYRIGHTS, TRADE SECRETS OR OTHER INTELLECTUAL PROPERTY RIGHTS. YOU AGREE TO +USE YOUR INDEPENDENT JUDGMENT IN DEVELOPING YOUR PRODUCTS. NOTHING CONTAINED IN +THIS AGREEMENT WILL BE CONSTRUED AS A WARRANTY OR REPRESENTATION BY TI TO +MAINTAIN PRODUCTION OF ANY TI SEMICONDUCTOR DEVICE OR OTHER HARDWARE OR +SOFTWARE WITH WHICH THE LICENSED MATERIALS MAY BE USED. + +IN NO EVENT SHALL TI, OR ANY APPLICABLE LICENSOR, BE LIABLE FOR ANY SPECIAL, +INDIRECT, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL DAMAGES, HOWEVER CAUSED, ON ANY +THEORY OF LIABILITY, IN CONNECTION WITH OR ARISING OUT OF THIS AGREEMENT OR THE +USE OF THE LICENSED MATERIALS, REGARDLESS OF WHETHER TI HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. EXCLUDED DAMAGES INCLUDE, BUT ARE NOT LIMITED TO, +COST OF REMOVAL OR REINSTALLATION, OUTSIDE COMPUTER TIME, LABOR COSTS, LOSS OF +DATA, LOSS OF GOODWILL, LOSS OF PROFITS, LOSS OF SAVINGS, OR LOSS OF USE OR +INTERRUPTION OF BUSINESS. IN NO EVENT WILL TI'S AGGREGATE LIABILITY UNDER THIS +AGREEMENT OR ARISING OUT OF YOUR USE OF THE LICENSED MATERIALS EXCEED FIVE +HUNDRED U.S. DOLLARS (US$500). THE EXISTENCE OF MORE THAN ONE CLAIM WILL NOT +ENLARGE OR EXTEND THESE LIMITS. + +Because some jurisdictions do not allow the exclusion or limitation of +incidental or consequential damages or limitation on how long an implied +warranty lasts, the above limitations or exclusions may not apply to you. + +7. Indemnification Disclaimer. YOU ACKNOWLEDGE AND AGREE THAT TI SHALL NOT BE +LIABLE FOR AND SHALL NOT DEFEND OR INDEMNIFY YOU AGAINST ANY THIRD PARTY +INFRINGEMENT CLAIM THAT RELATES TO OR IS BASED ON YOUR MANUFACTURE, USE, OR +DISTRIBUTION OF THE LICENSED MATERIALS OR YOUR MANUFACTURE, USE, OFFER FOR +SALE, SALE, IMPORTATION OR DISTRIBUTION OF YOUR PRODUCTS THAT INCLUDE OR +INCORPORATE THE LICENSED MATERIALS. + +You will defend and indemnify TI in the event of claim, liability or costs +(including reasonable attorney's fees related to Your use or any sub-licensee's +use of the Licensed Materials) relating in any way to Your violation of the +terms of the License Grants set forth in Section 2, or any other violation of +other terms and conditions of this Agreement. + +8. No Technical Support. TI and TI's licensors are under no obligation to +install, maintain or support the Licensed Materials. + +9. Notices. All notices to TI hereunder shall be delivered to Texas Instruments +Incorporated, AEC Software Operations, 12203 Southwest Freeway, Mail Station +701, Stafford, Texas 77477, Attention: Administrator, AEC Software Operations, +with a copy to Texas Instruments Incorporated, 12203 Southwest Freeway, Mail +Station 725, Stafford, Texas 77477, Attention: Legal Department. All notices +shall be deemed served when received by TI. + +10. Export Control. You hereby acknowledge that the Licensed Materials are +subject to export control under the U.S. Commerce Department's Export +Administration Regulations ("EAR"). You further hereby acknowledge and agree +that unless prior authorization is obtained from the U.S. Commerce Department, +neither you nor your customers will export, re-export, or release, directly or +indirectly, any technology, software, or software source code (as defined in +Part 772 of the EAR), received from TI, or export, directly or indirectly, any +direct product of such technology, software, or software source code (as +defined in Part 734 of the EAR), to any destination or country to which the +export, re-export, or release of the technology, software, or software source +code, or direct product is prohibited by the EAR. You agree that none of the +Licensed Materials may be downloaded or otherwise exported or reexported (i) +into (or to a national or resident of) Cuba, Iran, North Korea, Sudan and Syria +or any other country the U.S. has embargoed goods; or (ii) to anyone on the +U.S. Treasury Department's List of Specially Designated Nationals or the U.S. +Commerce Department's Denied Persons List or Entity List. You represent and +warrant that you are not located in, under the control of, or a national or +resident of any such country or on any such list and you will not use or +transfer the Licensed Materials for use in any sensitive nuclear, chemical or +biological weapons, or missile technology end-uses unless authorized by the +U.S. Government by regulation or specific license or for a military end-use in, +or by any military entity of Albania, Armenia, Azerbaijan, Belarus, Cambodia, +China, Georgia, Iran, Iraq, Kazakhstan, Kyrgyzstan, Laos, Libya, Macau, +Moldova, Mongolia, Russia, Tajikistan, Turkmenistan, Ukraine, Uzbekistan, and +Vietnam. Any software export classification made by TI shall be for TI's +internal use only and shall not be construed as a representation or warranty +regarding the proper export classification for such software or whether an +export license or other documentation is required for the exportation of such +software. + +11. Governing Law and Severability. This Agreement will be governed by and +interpreted in accordance with the laws of the State of Texas, without +reference to conflict of laws principles. If for any reason a court of +competent jurisdiction finds any provision of the Agreement to be +unenforceable, that provision will be enforced to the maximum extent possible +to effectuate the intent of the parties, and the remainder of the Agreement +shall continue in full force and effect. This Agreement shall not be governed +by the United Nations Convention on Contracts for the International Sale of +Goods, or by the Uniform Computer Information Transactions Act (UCITA), as it +may be enacted in the State of Texas. The parties agree that non-exclusive +jurisdiction for any dispute arising out of or relating to this Agreement lies +within the courts located in the State of Texas. Notwithstanding the foregoing, +any judgment may be enforced in any United States or foreign court, and either +party may seek injunctive relief in any United States or foreign court. + +12. PRC Provisions. If you are located in the People's Republic of China +("PRC") or if the Licensed Materials will be sent to the PRC, the following +provisions shall apply and shall supersede any other provisions in this +Agreement concerning the same subject matter as the following provisions: + +a. Registration Requirements. You shall be solely responsible for performing +all acts and obtaining all approvals that may be required in connection with +this Agreement by the government of the PRC, including but not limited to +registering pursuant to, and otherwise complying with, the PRC Measures on the +Administration of Software Products, Management Regulations on Technology +Import-Export, and Technology Import and Export Contract Registration +Management Rules. Upon receipt of such approvals from the government +authorities, you shall forward evidence of all such approvals to TI for its +records. In the event that you fail to obtain any such approval or +registration, you shall be solely responsible for any and all losses, damages +or costs resulting therefrom, and shall indemnify TI for all such losses, +damages or costs. + +b. Governing Language. This Agreement is written and executed in the English +language. If a translation of this Agreement is required for any purpose, +including but not limited to registration of the Agreement pursuant to any +governmental laws, regulations or rules, you shall be solely responsible for +creating such translation. Any translation of this Agreement into a language +other than English is intended solely in order to comply with such laws or for +reference purposes, and the English language version shall be authoritative and +controlling. + +c. Export Control. + +(i). Diversions of Technology. You hereby agree that unless prior authorization +is obtained from the U.S. Department of Commerce, neither you nor your +subsidiaries or affiliates shall knowingly export, re-export, or release, +directly or indirectly, any technology, software, or software source code (as +defined in Part 772 of the Export Administration Regulations of the U.S. +Department of Commerce ("EAR")), received from TI or any of its affiliated +companies, or export, directly or indirectly, any direct product of such +technology, software, or software source code (as defined in Part 734 of the +EAR), to any destination or country to which the export, re-export, or release +of the technology, software, software source code, or direct product is +prohibited by the EAR. + +(ii). Assurance of Compliance. You understand and acknowledge that products, +technology (regardless of the form in which it is provided), software or +software source code, received from TI or any of its affiliates under this +Agreement may be under export control of the United States or other countries. +You shall comply with the United States and other applicable non-U.S. laws and +regulations governing the export, re-export and release of any products, +technology, software, or software source code received under this Agreement +from TI or its affiliates. You shall not undertake any action that is +prohibited by the EAR. Without limiting the generality of the foregoing, you +specifically agree that you shall not transfer or release products, technology, +software, or software source code of TI or its affiliates to, or for use by, +military end users or for use in military, missile, nuclear, biological, or +chemical weapons end uses. + +(iii). Licenses. Each party shall secure at its own expense, such licenses and +export and import documents as are necessary for each respective party to +fulfill its obligations under this Agreement. If such licenses or government +approvals cannot be obtained, TI may terminate this Agreement, or shall +otherwise be excused from the performance of any obligations it may have under +this Agreement for which the licenses or government approvals are required. + +13. Entire Agreement. This is the entire Agreement between you and TI, and +absent a signed and effective software license agreement related to the subject +matter of this Agreement, this Agreement supersedes any prior agreement between +the parties related to the subject matter of this Agreement. Notwithstanding +the foregoing, any signed and effective software license agreement relating to +the subject matter hereof will supersede the terms of this Agreement. No +amendment or modification of this Agreement will be effective unless in writing +and signed by a duly authorized representative of TI. You hereby warrant and +represent that you have obtained all authorizations and other applicable +consents required empowering you to enter into this Agreement. + diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/cpulib.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/cpulib.c new file mode 100644 index 00000000..e3b6920c --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/cpulib.c @@ -0,0 +1,442 @@ +//***************************************************************************** +// +// cpu.c - Instruction wrappers for special CPU instructions needed by the +// drivers. +// +// Copyright (c) 2006-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#include "driverlib/cpulib.h" + +//***************************************************************************** +// +// Wrapper function for the CPSID instruction. Returns the state of PRIMASK +// on entry. +// +//***************************************************************************** +#if defined(codered) || defined(gcc) || defined(sourcerygxx) +unsigned long __attribute__((naked)) +CPUcpsid(void) +{ + unsigned long ulRet; + + // + // Read PRIMASK and disable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " cpsid i\n" + " bx lr\n" + : "=r" (ulRet)); + + // + // The return is handled in the inline assembly, but the compiler will + // still complain if there is not an explicit return here (despite the fact + // that this does not result in any code being produced because of the + // naked attribute). + // + return(ulRet); +} +#endif +#if defined(ewarm) +unsigned long +CPUcpsid(void) +{ + // + // Read PRIMASK and disable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " cpsid i\n"); + + // + // "Warning[Pe940]: missing return statement at end of non-void function" + // is suppressed here to avoid putting a "bx lr" in the inline assembly + // above and a superfluous return statement here. + // +#pragma diag_suppress=Pe940 +} +#pragma diag_default=Pe940 +#endif +#if defined(rvmdk) || defined(__ARMCC_VERSION) +__asm unsigned long +CPUcpsid(void) +{ + // + // Read PRIMASK and disable interrupts. + // + mrs r0, PRIMASK; + cpsid i; + bx lr +} +#endif +#if defined(ccs) +unsigned long +CPUcpsid(void) +{ + // + // Read PRIMASK and disable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " cpsid i\n" + " bx lr\n"); + + // + // The following keeps the compiler happy, because it wants to see a + // return value from this function. It will generate code to return + // a zero. However, the real return is the "bx lr" above, so the + // return(0) is never executed and the function returns with the value + // you expect in R0. + // + return(0); +} +#endif + +//***************************************************************************** +// +// Wrapper function returning the state of PRIMASK (indicating whether +// interrupts are enabled or disabled). +// +//***************************************************************************** +#if defined(codered) || defined(gcc) || defined(sourcerygxx) +unsigned long __attribute__((naked)) +CPUprimask(void) +{ + unsigned long ulRet; + + // + // Read PRIMASK and disable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " bx lr\n" + : "=r" (ulRet)); + + // + // The return is handled in the inline assembly, but the compiler will + // still complain if there is not an explicit return here (despite the fact + // that this does not result in any code being produced because of the + // naked attribute). + // + return(ulRet); +} +#endif +#if defined(ewarm) +unsigned long +CPUprimask(void) +{ + // + // Read PRIMASK and disable interrupts. + // + __asm(" mrs r0, PRIMASK\n"); + + // + // "Warning[Pe940]: missing return statement at end of non-void function" + // is suppressed here to avoid putting a "bx lr" in the inline assembly + // above and a superfluous return statement here. + // +#pragma diag_suppress=Pe940 +} +#pragma diag_default=Pe940 +#endif +#if defined(rvmdk) || defined(__ARMCC_VERSION) +__asm unsigned long +CPUprimask(void) +{ + // + // Read PRIMASK and disable interrupts. + // + mrs r0, PRIMASK; + bx lr +} +#endif +#if defined(ccs) +unsigned long +CPUprimask(void) +{ + // + // Read PRIMASK and disable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " bx lr\n"); + + // + // The following keeps the compiler happy, because it wants to see a + // return value from this function. It will generate code to return + // a zero. However, the real return is the "bx lr" above, so the + // return(0) is never executed and the function returns with the value + // you expect in R0. + // + return(0); +} +#endif + +//***************************************************************************** +// +// Wrapper function for the CPSIE instruction. Returns the state of PRIMASK +// on entry. +// +//***************************************************************************** +#if defined(codered) || defined(gcc) || defined(sourcerygxx) +unsigned long __attribute__((naked)) +CPUcpsie(void) +{ + unsigned long ulRet; + + // + // Read PRIMASK and enable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " cpsie i\n" + " bx lr\n" + : "=r" (ulRet)); + + // + // The return is handled in the inline assembly, but the compiler will + // still complain if there is not an explicit return here (despite the fact + // that this does not result in any code being produced because of the + // naked attribute). + // + return(ulRet); +} +#endif +#if defined(ewarm) +unsigned long +CPUcpsie(void) +{ + // + // Read PRIMASK and enable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " cpsie i\n"); + + // + // "Warning[Pe940]: missing return statement at end of non-void function" + // is suppressed here to avoid putting a "bx lr" in the inline assembly + // above and a superfluous return statement here. + // +#pragma diag_suppress=Pe940 +} +#pragma diag_default=Pe940 +#endif +#if defined(rvmdk) || defined(__ARMCC_VERSION) +__asm unsigned long +CPUcpsie(void) +{ + // + // Read PRIMASK and enable interrupts. + // + mrs r0, PRIMASK; + cpsie i; + bx lr +} +#endif +#if defined(ccs) +unsigned long +CPUcpsie(void) +{ + // + // Read PRIMASK and enable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " cpsie i\n" + " bx lr\n"); + + // + // The following keeps the compiler happy, because it wants to see a + // return value from this function. It will generate code to return + // a zero. However, the real return is the "bx lr" above, so the + // return(0) is never executed and the function returns with the value + // you expect in R0. + // + return(0); +} +#endif + +//***************************************************************************** +// +// Wrapper function for the WFI instruction. +// +//***************************************************************************** +#if defined(codered) || defined(gcc) || defined(sourcerygxx) +void __attribute__((naked)) +CPUwfi(void) +{ + // + // Wait for the next interrupt. + // + __asm(" wfi\n" + " bx lr\n"); +} +#endif +#if defined(ewarm) +void +CPUwfi(void) +{ + // + // Wait for the next interrupt. + // + __asm(" wfi\n"); +} +#endif +#if defined(rvmdk) || defined(__ARMCC_VERSION) +__asm void +CPUwfi(void) +{ + // + // Wait for the next interrupt. + // + wfi; + bx lr +} +#endif +#if defined(ccs) +void +CPUwfi(void) +{ + // + // Wait for the next interrupt. + // + __asm(" wfi\n"); +} +#endif + +//***************************************************************************** +// +// Wrapper function for writing the BASEPRI register. +// +//***************************************************************************** +#if defined(codered) || defined(gcc) || defined(sourcerygxx) +void __attribute__((naked)) +CPUbasepriSet(unsigned long ulNewBasepri) +{ + + // + // Set the BASEPRI register + // + __asm(" msr BASEPRI, r0\n" + " bx lr\n"); +} +#endif +#if defined(ewarm) +void +CPUbasepriSet(unsigned long ulNewBasepri) +{ + // + // Set the BASEPRI register + // + __asm(" msr BASEPRI, r0\n"); +} +#endif +#if defined(rvmdk) || defined(__ARMCC_VERSION) +__asm void +CPUbasepriSet(unsigned long ulNewBasepri) +{ + // + // Set the BASEPRI register + // + msr BASEPRI, r0; + bx lr +} +#endif +#if defined(ccs) +void +CPUbasepriSet(unsigned long ulNewBasepri) +{ + // + // Set the BASEPRI register + // + __asm(" msr BASEPRI, r0\n"); +} +#endif + +//***************************************************************************** +// +// Wrapper function for reading the BASEPRI register. +// +//***************************************************************************** +#if defined(codered) || defined(gcc) || defined(sourcerygxx) +unsigned long __attribute__((naked)) +CPUbasepriGet(void) +{ + unsigned long ulRet; + + // + // Read BASEPRI + // + __asm(" mrs r0, BASEPRI\n" + " bx lr\n" + : "=r" (ulRet)); + + // + // The return is handled in the inline assembly, but the compiler will + // still complain if there is not an explicit return here (despite the fact + // that this does not result in any code being produced because of the + // naked attribute). + // + return(ulRet); +} +#endif +#if defined(ewarm) +unsigned long +CPUbasepriGet(void) +{ + // + // Read BASEPRI + // + __asm(" mrs r0, BASEPRI\n"); + + // + // "Warning[Pe940]: missing return statement at end of non-void function" + // is suppressed here to avoid putting a "bx lr" in the inline assembly + // above and a superfluous return statement here. + // +#pragma diag_suppress=Pe940 +} +#pragma diag_default=Pe940 +#endif +#if defined(rvmdk) || defined(__ARMCC_VERSION) +__asm unsigned long +CPUbasepriGet(void) +{ + // + // Read BASEPRI + // + mrs r0, BASEPRI; + bx lr +} +#endif +#if defined(ccs) +unsigned long +CPUbasepriGet(void) +{ + // + // Read BASEPRI + // + __asm(" mrs r0, BASEPRI\n" + " bx lr\n"); + + // + // The following keeps the compiler happy, because it wants to see a + // return value from this function. It will generate code to return + // a zero. However, the real return is the "bx lr" above, so the + // return(0) is never executed and the function returns with the value + // you expect in R0. + // + return(0); +} +#endif diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/cpulib.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/cpulib.h new file mode 100644 index 00000000..c0e073e1 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/cpulib.h @@ -0,0 +1,60 @@ +//***************************************************************************** +// +// cpu.h - Prototypes for the CPU instruction wrapper functions. +// +// Copyright (c) 2006-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __CPU_H__ +#define __CPU_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Prototypes. +// +//***************************************************************************** +extern unsigned long CPUcpsid(void); +extern unsigned long CPUcpsie(void); +extern unsigned long CPUprimask(void); +extern void CPUwfi(void); +extern unsigned long CPUbasepriGet(void); +extern void CPUbasepriSet(unsigned long ulNewBasepri); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __CPU_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/debug.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/debug.h new file mode 100644 index 00000000..b94a8096 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/debug.h @@ -0,0 +1,58 @@ +//***************************************************************************** +// +// debug.h - Macros for assisting debug of the driver library. +// +// Copyright (c) 2006-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __DEBUG_H__ +#define __DEBUG_H__ + + +#include "boot.h" + +//***************************************************************************** +// +// Prototype for the function that is called when an invalid argument is passed +// to an API. This is only used when doing a DEBUG build. +// +//***************************************************************************** +#ifndef NDEBUG +extern void AssertFailure(blt_char *file, blt_int32u line); +#endif + +//***************************************************************************** +// +// The ASSERT macro, which does the actual assertion checking. Typically, this +// will be for procedure arguments. +// +//***************************************************************************** +#ifdef NDEBUG +#define ASSERT(expr) +#else +#define ASSERT(expr) { \ + if(!(expr)) \ + { \ + AssertFailure(__FILE__, __LINE__); \ + } \ + } +#endif + +#endif // __DEBUG_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/flashlib.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/flashlib.c new file mode 100644 index 00000000..ff8024f8 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/flashlib.c @@ -0,0 +1,912 @@ +//***************************************************************************** +// +// flash.c - Driver for programming the on-chip flash. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup flash_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_flash.h" +#include "inc/hw_ints.h" +#include "inc/hw_sysctl.h" +#include "inc/hw_types.h" +#include "driverlib/debug.h" +#include "driverlib/flashlib.h" +#include "driverlib/interrupt.h" + +//***************************************************************************** +// +// An array that maps the specified memory bank to the appropriate Flash +// Memory Protection Program Enable (FMPPE) register. +// +//***************************************************************************** +static const unsigned long g_pulFMPPERegs[] = +{ + FLASH_FMPPE, + FLASH_FMPPE1, + FLASH_FMPPE2, + FLASH_FMPPE3 +}; + +//***************************************************************************** +// +// An array that maps the specified memory bank to the appropriate Flash +// Memory Protection Read Enable (FMPRE) register. +// +//***************************************************************************** +static const unsigned long g_pulFMPRERegs[] = +{ + FLASH_FMPRE, + FLASH_FMPRE1, + FLASH_FMPRE2, + FLASH_FMPRE3 +}; + +//***************************************************************************** +// +//! Gets the number of processor clocks per micro-second. +//! +//! This function returns the number of clocks per micro-second, as presently +//! known by the flash controller. +//! +//! \return Returns the number of processor clocks per micro-second. +// +//***************************************************************************** +unsigned long +FlashUsecGet(void) +{ + // + // Return the number of clocks per micro-second. + // + return(HWREG(FLASH_USECRL) + 1); +} + +//***************************************************************************** +// +//! Sets the number of processor clocks per micro-second. +//! +//! \param ulClocks is the number of processor clocks per micro-second. +//! +//! This function is used to tell the flash controller the number of processor +//! clocks per micro-second. This value must be programmed correctly or the +//! flash most likely will not program correctly; it has no affect on reading +//! flash. +//! +//! \return None. +// +//***************************************************************************** +void +FlashUsecSet(unsigned long ulClocks) +{ + // + // Set the number of clocks per micro-second. + // + HWREG(FLASH_USECRL) = ulClocks - 1; +} + +//***************************************************************************** +// +//! Erases a block of flash. +//! +//! \param ulAddress is the start address of the flash block to be erased. +//! +//! This function will erase a 1 kB block of the on-chip flash. After erasing, +//! the block will be filled with 0xFF bytes. Read-only and execute-only +//! blocks cannot be erased. +//! +//! This function will not return until the block has been erased. +//! +//! \return Returns 0 on success, or -1 if an invalid block address was +//! specified or the block is write-protected. +// +//***************************************************************************** +long +FlashClear(unsigned long ulAddress) +{ + // + // Check the arguments. + // + ASSERT(!(ulAddress & (FLASH_ERASE_SIZE - 1))); + + // + // Clear the flash access interrupt. + // + HWREG(FLASH_FCMISC) = FLASH_FCMISC_AMISC; + + // + // Erase the block. + // + HWREG(FLASH_FMA) = ulAddress; + HWREG(FLASH_FMC) = FLASH_FMC_WRKEY | FLASH_FMC_ERASE; + + // + // Wait until the block has been erased. + // + while(HWREG(FLASH_FMC) & FLASH_FMC_ERASE) + { + } + + // + // Return an error if an access violation occurred. + // + if(HWREG(FLASH_FCRIS) & FLASH_FCRIS_ARIS) + { + return(-1); + } + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Programs flash. +//! +//! \param pulData is a pointer to the data to be programmed. +//! \param ulAddress is the starting address in flash to be programmed. Must +//! be a multiple of four. +//! \param ulCount is the number of bytes to be programmed. Must be a multiple +//! of four. +//! +//! This function will program a sequence of words into the on-chip flash. +//! Programming each location consists of the result of an AND operation +//! of the new data and the existing data; in other words bits that contain +//! 1 can remain 1 or be changed to 0, but bits that are 0 cannot be changed +//! to 1. Therefore, a word can be programmed multiple times as long as these +//! rules are followed; if a program operation attempts to change a 0 bit to +//! a 1 bit, that bit will not have its value changed. +//! +//! Since the flash is programmed one word at a time, the starting address and +//! byte count must both be multiples of four. It is up to the caller to +//! verify the programmed contents, if such verification is required. +//! +//! This function will not return until the data has been programmed. +//! +//! \return Returns 0 on success, or -1 if a programming error is encountered. +// +//***************************************************************************** +long +FlashProgram(unsigned long *pulData, unsigned long ulAddress, + unsigned long ulCount) +{ + // + // Check the arguments. + // + ASSERT(!(ulAddress & 3)); + ASSERT(!(ulCount & 3)); + + // + // Clear the flash access interrupt. + // + HWREG(FLASH_FCMISC) = FLASH_FCMISC_AMISC; + + // + // See if this device has a write buffer. + // + if(HWREG(SYSCTL_NVMSTAT) & SYSCTL_NVMSTAT_FWB) + { + // + // Loop over the words to be programmed. + // + while(ulCount) + { + // + // Set the address of this block of words. + // + HWREG(FLASH_FMA) = ulAddress & ~(0x7f); + + // + // Loop over the words in this 32-word block. + // + while(((ulAddress & 0x7c) || (HWREG(FLASH_FWBVAL) == 0)) && + (ulCount != 0)) + { + // + // Write this word into the write buffer. + // + HWREG(FLASH_FWBN + (ulAddress & 0x7c)) = *pulData++; + ulAddress += 4; + ulCount -= 4; + } + + // + // Program the contents of the write buffer into flash. + // + HWREG(FLASH_FMC2) = FLASH_FMC2_WRKEY | FLASH_FMC2_WRBUF; + + // + // Wait until the write buffer has been programmed. + // + while(HWREG(FLASH_FMC2) & FLASH_FMC2_WRBUF) + { + } + } + } + else + { + // + // Loop over the words to be programmed. + // + while(ulCount) + { + // + // Program the next word. + // + HWREG(FLASH_FMA) = ulAddress; + HWREG(FLASH_FMD) = *pulData; + HWREG(FLASH_FMC) = FLASH_FMC_WRKEY | FLASH_FMC_WRITE; + + // + // Wait until the word has been programmed. + // + while(HWREG(FLASH_FMC) & FLASH_FMC_WRITE) + { + } + + // + // Increment to the next word. + // + pulData++; + ulAddress += 4; + ulCount -= 4; + } + } + + // + // Return an error if an access violation occurred. + // + if(HWREG(FLASH_FCRIS) & FLASH_FCRIS_ARIS) + { + return(-1); + } + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Gets the protection setting for a block of flash. +//! +//! \param ulAddress is the start address of the flash block to be queried. +//! +//! This function will get the current protection for the specified 2 kB block +//! of flash. Each block can be read/write, read-only, or execute-only. +//! Read/write blocks can be read, executed, erased, and programmed. Read-only +//! blocks can be read and executed. Execute-only blocks can only be executed; +//! processor and debugger data reads are not allowed. +//! +//! \return Returns the protection setting for this block. See +//! FlashProtectSet() for possible values. +// +//***************************************************************************** +tFlashProtection +FlashProtectGet(unsigned long ulAddress) +{ + unsigned long ulFMPRE, ulFMPPE; + unsigned long ulBank; + + // + // Check the argument. + // + ASSERT(!(ulAddress & (FLASH_PROTECT_SIZE - 1))); + + // + // Calculate the Flash Bank from Base Address, and mask off the Bank + // from ulAddress for subsequent reference. + // + ulBank = (((ulAddress / FLASH_PROTECT_SIZE) / 32) % 4); + ulAddress &= ((FLASH_PROTECT_SIZE * 32) - 1); + + // + // Read the appropriate flash protection registers for the specified + // flash bank. + // + ulFMPRE = HWREG(g_pulFMPRERegs[ulBank]); + ulFMPPE = HWREG(g_pulFMPPERegs[ulBank]); + + // + // For Stellaris Sandstorm-class devices, revision C1 and C2, the upper + // bits of the FMPPE register are used for JTAG protect options, and are + // not available for the FLASH protection scheme. When Querying Block + // Protection, assume these bits are 1. + // + if(CLASS_IS_SANDSTORM && (REVISION_IS_C1 || REVISION_IS_C2)) + { + ulFMPRE |= (FLASH_FMP_BLOCK_31 | FLASH_FMP_BLOCK_30); + } + + // + // Check the appropriate protection bits for the block of memory that + // is specified by the address. + // + switch((((ulFMPRE >> (ulAddress / FLASH_PROTECT_SIZE)) & + FLASH_FMP_BLOCK_0) << 1) | + ((ulFMPPE >> (ulAddress / FLASH_PROTECT_SIZE)) & FLASH_FMP_BLOCK_0)) + { + // + // This block is marked as execute only (that is, it can not be erased + // or programmed, and the only reads allowed are via the instruction + // fetch interface). + // + case 0: + case 1: + { + return(FlashExecuteOnly); + } + + // + // This block is marked as read only (that is, it can not be erased or + // programmed). + // + case 2: + { + return(FlashReadOnly); + } + + // + // This block is read/write; it can be read, erased, and programmed. + // + case 3: + default: + { + return(FlashReadWrite); + } + } +} + +//***************************************************************************** +// +//! Sets the protection setting for a block of flash. +//! +//! \param ulAddress is the start address of the flash block to be protected. +//! \param eProtect is the protection to be applied to the block. Can be one +//! of \b FlashReadWrite, \b FlashReadOnly, or \b FlashExecuteOnly. +//! +//! This function will set the protection for the specified 2 kB block of +//! flash. Blocks which are read/write can be made read-only or execute-only. +//! Blocks which are read-only can be made execute-only. Blocks which are +//! execute-only cannot have their protection modified. Attempts to make the +//! block protection less stringent (that is, read-only to read/write) will +//! result in a failure (and be prevented by the hardware). +//! +//! Changes to the flash protection are maintained only until the next reset. +//! This allows the application to be executed in the desired flash protection +//! environment to check for inappropriate flash access (via the flash +//! interrupt). To make the flash protection permanent, use the +//! FlashProtectSave() function. +//! +//! \return Returns 0 on success, or -1 if an invalid address or an invalid +//! protection was specified. +// +//***************************************************************************** +long +FlashProtectSet(unsigned long ulAddress, tFlashProtection eProtect) +{ + unsigned long ulProtectRE, ulProtectPE; + unsigned long ulBank; + + // + // Check the argument. + // + ASSERT(!(ulAddress & (FLASH_PROTECT_SIZE - 1))); + ASSERT((eProtect == FlashReadWrite) || (eProtect == FlashReadOnly) || + (eProtect == FlashExecuteOnly)); + + // + // Convert the address into a block number. + // + ulAddress /= FLASH_PROTECT_SIZE; + + // + // ulAddress contains a "raw" block number. Derive the Flash Bank from + // the "raw" block number, and convert ulAddress to a "relative" + // block number. + // + ulBank = ((ulAddress / 32) % 4); + ulAddress %= 32; + + // + // Get the current protection for the specified flash bank. + // + ulProtectRE = HWREG(g_pulFMPRERegs[ulBank]); + ulProtectPE = HWREG(g_pulFMPPERegs[ulBank]); + + // + // For Stellaris Sandstorm-class devices, revision C1 and C2, the upper + // bits of the FMPPE register are used for JTAG protect options, and are + // not available for the FLASH protection scheme. When setting protection, + // check to see if block 30 or 31 and protection is FlashExecuteOnly. If + // so, return an error condition. + // + if(CLASS_IS_SANDSTORM && (REVISION_IS_C1 || REVISION_IS_C2)) + { + if((ulAddress >= 30) && (eProtect == FlashExecuteOnly)) + { + return(-1); + } + } + + // + // Set the protection based on the requested proection. + // + switch(eProtect) + { + // + // Make this block execute only. + // + case FlashExecuteOnly: + { + // + // Turn off the read and program bits for this block. + // + ulProtectRE &= ~(FLASH_FMP_BLOCK_0 << ulAddress); + ulProtectPE &= ~(FLASH_FMP_BLOCK_0 << ulAddress); + + // + // We're done handling this protection. + // + break; + } + + // + // Make this block read only. + // + case FlashReadOnly: + { + // + // The block can not be made read only if it is execute only. + // + if(((ulProtectRE >> ulAddress) & FLASH_FMP_BLOCK_0) != + FLASH_FMP_BLOCK_0) + { + return(-1); + } + + // + // Make this block read only. + // + ulProtectPE &= ~(FLASH_FMP_BLOCK_0 << ulAddress); + + // + // We're done handling this protection. + // + break; + } + + // + // Make this block read/write. + // + case FlashReadWrite: + default: + { + // + // The block can not be made read/write if it is not already + // read/write. + // + if((((ulProtectRE >> ulAddress) & FLASH_FMP_BLOCK_0) != + FLASH_FMP_BLOCK_0) || + (((ulProtectPE >> ulAddress) & FLASH_FMP_BLOCK_0) != + FLASH_FMP_BLOCK_0)) + { + return(-1); + } + + // + // The block is already read/write, so there is nothing to do. + // + return(0); + } + } + + // + // For Stellaris Sandstorm-class devices, revision C1 and C2, the upper + // bits of the FMPPE register are used for JTAG options, and are not + // available for the FLASH protection scheme. When setting block + // protection, ensure that these bits are not altered. + // + if(CLASS_IS_SANDSTORM && (REVISION_IS_C1 || REVISION_IS_C2)) + { + ulProtectRE &= ~(FLASH_FMP_BLOCK_31 | FLASH_FMP_BLOCK_30); + ulProtectRE |= (HWREG(g_pulFMPRERegs[ulBank]) & + (FLASH_FMP_BLOCK_31 | FLASH_FMP_BLOCK_30)); + } + + // + // Set the new protection for the specified flash bank. + // + HWREG(g_pulFMPRERegs[ulBank]) = ulProtectRE; + HWREG(g_pulFMPPERegs[ulBank]) = ulProtectPE; + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Saves the flash protection settings. +//! +//! This function will make the currently programmed flash protection settings +//! permanent. This is a non-reversible operation; a chip reset or power cycle +//! will not change the flash protection. +//! +//! This function will not return until the protection has been saved. +//! +//! \return Returns 0 on success, or -1 if a hardware error is encountered. +// +//***************************************************************************** +long +FlashProtectSave(void) +{ + int ulTemp, ulLimit; + + // + // If running on a Sandstorm-class device, only trigger a save of the first + // two protection registers (FMPRE and FMPPE). Otherwise, save the + // entire bank of flash protection registers. + // + ulLimit = CLASS_IS_SANDSTORM ? 2 : 8; + for(ulTemp = 0; ulTemp < ulLimit; ulTemp++) + { + // + // Tell the flash controller to write the flash protection register. + // + HWREG(FLASH_FMA) = ulTemp; + HWREG(FLASH_FMC) = FLASH_FMC_WRKEY | FLASH_FMC_COMT; + + // + // Wait until the write has completed. + // + while(HWREG(FLASH_FMC) & FLASH_FMC_COMT) + { + } + } + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Gets the user registers. +//! +//! \param pulUser0 is a pointer to the location to store USER Register 0. +//! \param pulUser1 is a pointer to the location to store USER Register 1. +//! +//! This function will read the contents of user registers (0 and 1), and +//! store them in the specified locations. +//! +//! \return Returns 0 on success, or -1 if a hardware error is encountered. +// +//***************************************************************************** +long +FlashUserGet(unsigned long *pulUser0, unsigned long *pulUser1) +{ + // + // Verify that the pointers are valid. + // + ASSERT(pulUser0 != 0); + ASSERT(pulUser1 != 0); + + // + // Verify that hardware supports user registers. + // + if(CLASS_IS_SANDSTORM) + { + return(-1); + } + + // + // Get and store the current value of the user registers. + // + *pulUser0 = HWREG(FLASH_USERREG0); + *pulUser1 = HWREG(FLASH_USERREG1); + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Sets the user registers. +//! +//! \param ulUser0 is the value to store in USER Register 0. +//! \param ulUser1 is the value to store in USER Register 1. +//! +//! This function will set the contents of the user registers (0 and 1) to +//! the specified values. +//! +//! \return Returns 0 on success, or -1 if a hardware error is encountered. +// +//***************************************************************************** +long +FlashUserSet(unsigned long ulUser0, unsigned long ulUser1) +{ + // + // Verify that hardware supports user registers. + // + if(CLASS_IS_SANDSTORM) + { + return(-1); + } + + // + // Save the new values into the user registers. + // + HWREG(FLASH_USERREG0) = ulUser0; + HWREG(FLASH_USERREG1) = ulUser1; + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Saves the user registers. +//! +//! This function will make the currently programmed user register settings +//! permanent. This is a non-reversible operation; a chip reset or power cycle +//! will not change this setting. +//! +//! This function will not return until the protection has been saved. +//! +//! \return Returns 0 on success, or -1 if a hardware error is encountered. +// +//***************************************************************************** +long +FlashUserSave(void) +{ + // + // Verify that hardware supports user registers. + // + if(CLASS_IS_SANDSTORM) + { + return(-1); + } + + // + // Setting the MSB of FMA will trigger a permanent save of a USER + // register. Bit 0 will indicate User 0 (0) or User 1 (1). + // + HWREG(FLASH_FMA) = 0x80000000; + HWREG(FLASH_FMC) = FLASH_FMC_WRKEY | FLASH_FMC_COMT; + + // + // Wait until the write has completed. + // + while(HWREG(FLASH_FMC) & FLASH_FMC_COMT) + { + } + + // + // Tell the flash controller to write the USER1 Register. + // + HWREG(FLASH_FMA) = 0x80000001; + HWREG(FLASH_FMC) = FLASH_FMC_WRKEY | FLASH_FMC_COMT; + + // + // Wait until the write has completed. + // + while(HWREG(FLASH_FMC) & FLASH_FMC_COMT) + { + } + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the flash interrupt. +//! +//! \param pfnHandler is a pointer to the function to be called when the flash +//! interrupt occurs. +//! +//! This sets the handler to be called when the flash interrupt occurs. The +//! flash controller can generate an interrupt when an invalid flash access +//! occurs, such as trying to program or erase a read-only block, or trying to +//! read from an execute-only block. It can also generate an interrupt when a +//! program or erase operation has completed. The interrupt will be +//! automatically enabled when the handler is registered. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +FlashIntRegister(void (*pfnHandler)(void)) +{ + // + // Register the interrupt handler, returning an error if an error occurs. + // + IntRegister(INT_FLASH, pfnHandler); + + // + // Enable the flash interrupt. + // + IntEnable(INT_FLASH); +} + +//***************************************************************************** +// +//! Unregisters the interrupt handler for the flash interrupt. +//! +//! This function will clear the handler to be called when the flash interrupt +//! occurs. This will also mask off the interrupt in the interrupt controller +//! so that the interrupt handler is no longer called. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +FlashIntUnregister(void) +{ + // + // Disable the interrupt. + // + IntDisable(INT_FLASH); + + // + // Unregister the interrupt handler. + // + IntUnregister(INT_FLASH); +} + +//***************************************************************************** +// +//! Enables individual flash controller interrupt sources. +//! +//! \param ulIntFlags is a bit mask of the interrupt sources to be enabled. +//! Can be any of the \b FLASH_INT_PROGRAM or \b FLASH_INT_ACCESS values. +//! +//! Enables the indicated flash controller interrupt sources. Only the sources +//! that are enabled can be reflected to the processor interrupt; disabled +//! sources have no effect on the processor. +//! +//! \return None. +// +//***************************************************************************** +void +FlashIntEnable(unsigned long ulIntFlags) +{ + // + // Enable the specified interrupts. + // + HWREG(FLASH_FCIM) |= ulIntFlags; +} + +//***************************************************************************** +// +//! Disables individual flash controller interrupt sources. +//! +//! \param ulIntFlags is a bit mask of the interrupt sources to be disabled. +//! Can be any of the \b FLASH_INT_PROGRAM or \b FLASH_INT_ACCESS values. +//! +//! Disables the indicated flash controller interrupt sources. Only the +//! sources that are enabled can be reflected to the processor interrupt; +//! disabled sources have no effect on the processor. +//! +//! \return None. +// +//***************************************************************************** +void +FlashIntDisable(unsigned long ulIntFlags) +{ + // + // Disable the specified interrupts. + // + HWREG(FLASH_FCIM) &= ~(ulIntFlags); +} + +//***************************************************************************** +// +//! Gets the current interrupt status. +//! +//! \param bMasked is false if the raw interrupt status is required and true if +//! the masked interrupt status is required. +//! +//! This returns the interrupt status for the flash controller. Either the raw +//! interrupt status or the status of interrupts that are allowed to reflect to +//! the processor can be returned. +//! +//! \return The current interrupt status, enumerated as a bit field of +//! \b FLASH_INT_PROGRAM and \b FLASH_INT_ACCESS. +// +//***************************************************************************** +unsigned long +FlashIntStatus(tBoolean bMasked) +{ + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + return(HWREG(FLASH_FCMISC)); + } + else + { + return(HWREG(FLASH_FCRIS)); + } +} + +//***************************************************************************** +// +//! Clears flash controller interrupt sources. +//! +//! \param ulIntFlags is the bit mask of the interrupt sources to be cleared. +//! Can be any of the \b FLASH_INT_PROGRAM or \b FLASH_INT_AMISC values. +//! +//! The specified flash controller interrupt sources are cleared, so that they +//! no longer assert. This must be done in the interrupt handler to keep it +//! from being called again immediately upon exit. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +FlashIntClear(unsigned long ulIntFlags) +{ + // + // Clear the flash interrupt. + // + HWREG(FLASH_FCMISC) = ulIntFlags; +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/flashlib.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/flashlib.h new file mode 100644 index 00000000..31e56412 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/flashlib.h @@ -0,0 +1,106 @@ +//***************************************************************************** +// +// flash.h - Prototypes for the flash driver. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __FLASH_H__ +#define __FLASH_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Values that can be passed to FlashProtectSet(), and returned by +// FlashProtectGet(). +// +//***************************************************************************** +typedef enum +{ + FlashReadWrite, // Flash can be read and written + FlashReadOnly, // Flash can only be read + FlashExecuteOnly // Flash can only be executed +} +tFlashProtection; + +//***************************************************************************** +// +// Values passed to FlashIntEnable(), FlashIntDisable() and FlashIntClear() and +// returned from FlashIntStatus(). +// +//***************************************************************************** +#define FLASH_INT_PROGRAM 0x00000002 // Programming Interrupt Mask +#define FLASH_INT_ACCESS 0x00000001 // Access Interrupt Mask + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern unsigned long FlashUsecGet(void); +extern void FlashUsecSet(unsigned long ulClocks); +extern long FlashClear(unsigned long ulAddress); +extern long FlashProgram(unsigned long *pulData, unsigned long ulAddress, + unsigned long ulCount); +extern tFlashProtection FlashProtectGet(unsigned long ulAddress); +extern long FlashProtectSet(unsigned long ulAddress, + tFlashProtection eProtect); +extern long FlashProtectSave(void); +extern long FlashUserGet(unsigned long *pulUser0, unsigned long *pulUser1); +extern long FlashUserSet(unsigned long ulUser0, unsigned long ulUser1); +extern long FlashUserSave(void); +extern void FlashIntRegister(void (*pfnHandler)(void)); +extern void FlashIntUnregister(void); +extern void FlashIntEnable(unsigned long ulIntFlags); +extern void FlashIntDisable(unsigned long ulIntFlags); +extern unsigned long FlashIntStatus(tBoolean bMasked); +extern void FlashIntClear(unsigned long ulIntFlags); + +//***************************************************************************** +// +// Deprecated function names. These definitions ensure backwards compatibility +// but new code should avoid using deprecated function names since these will +// be removed at some point in the future. +// +//***************************************************************************** +#ifndef DEPRECATED +#define FlashIntGetStatus FlashIntStatus +#endif + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __FLASH_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/gpio.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/gpio.c new file mode 100644 index 00000000..4e5afa7c --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/gpio.c @@ -0,0 +1,1600 @@ +//***************************************************************************** +// +// gpio.c - API for GPIO ports +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup gpio_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_gpio.h" +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_sysctl.h" +#include "inc/hw_types.h" +#include "driverlib/debug.h" +#include "driverlib/gpio.h" +#include "driverlib/interrupt.h" + +//***************************************************************************** +// +// The base addresses of all the GPIO modules. Both the APB and AHB apertures +// are provided. +// +//***************************************************************************** +static const unsigned long g_pulGPIOBaseAddrs[] = +{ + GPIO_PORTA_BASE, GPIO_PORTA_AHB_BASE, + GPIO_PORTB_BASE, GPIO_PORTB_AHB_BASE, + GPIO_PORTC_BASE, GPIO_PORTC_AHB_BASE, + GPIO_PORTD_BASE, GPIO_PORTD_AHB_BASE, + GPIO_PORTE_BASE, GPIO_PORTE_AHB_BASE, + GPIO_PORTF_BASE, GPIO_PORTF_AHB_BASE, + GPIO_PORTG_BASE, GPIO_PORTG_AHB_BASE, + GPIO_PORTH_BASE, GPIO_PORTH_AHB_BASE, + GPIO_PORTJ_BASE, GPIO_PORTJ_AHB_BASE, +}; + +//***************************************************************************** +// +//! \internal +//! Checks a GPIO base address. +//! +//! \param ulPort is the base address of the GPIO port. +//! +//! This function determines if a GPIO port base address is valid. +//! +//! \return Returns \b true if the base address is valid and \b false +//! otherwise. +// +//***************************************************************************** +#ifdef DEBUG +static tBoolean +GPIOBaseValid(unsigned long ulPort) +{ + return((ulPort == GPIO_PORTA_BASE) || (ulPort == GPIO_PORTA_AHB_BASE) || + (ulPort == GPIO_PORTB_BASE) || (ulPort == GPIO_PORTB_AHB_BASE) || + (ulPort == GPIO_PORTC_BASE) || (ulPort == GPIO_PORTC_AHB_BASE) || + (ulPort == GPIO_PORTD_BASE) || (ulPort == GPIO_PORTD_AHB_BASE) || + (ulPort == GPIO_PORTE_BASE) || (ulPort == GPIO_PORTE_AHB_BASE) || + (ulPort == GPIO_PORTF_BASE) || (ulPort == GPIO_PORTF_AHB_BASE) || + (ulPort == GPIO_PORTG_BASE) || (ulPort == GPIO_PORTG_AHB_BASE) || + (ulPort == GPIO_PORTH_BASE) || (ulPort == GPIO_PORTH_AHB_BASE) || + (ulPort == GPIO_PORTJ_BASE) || (ulPort == GPIO_PORTJ_AHB_BASE)); +} +#endif + +//***************************************************************************** +// +//! \internal +//! Gets the GPIO interrupt number. +//! +//! \param ulPort is the base address of the GPIO port. +//! +//! Given a GPIO base address, returns the corresponding interrupt number. +//! +//! \return Returns a GPIO interrupt number, or -1 if \e ulPort is invalid. +// +//***************************************************************************** +static long +GPIOGetIntNumber(unsigned long ulPort) +{ + unsigned int ulInt; + + // + // Determine the GPIO interrupt number for the given module. + // + switch(ulPort) + { + case GPIO_PORTA_BASE: + case GPIO_PORTA_AHB_BASE: + { + ulInt = INT_GPIOA; + break; + } + + case GPIO_PORTB_BASE: + case GPIO_PORTB_AHB_BASE: + { + ulInt = INT_GPIOB; + break; + } + + case GPIO_PORTC_BASE: + case GPIO_PORTC_AHB_BASE: + { + ulInt = INT_GPIOC; + break; + } + + case GPIO_PORTD_BASE: + case GPIO_PORTD_AHB_BASE: + { + ulInt = INT_GPIOD; + break; + } + + case GPIO_PORTE_BASE: + case GPIO_PORTE_AHB_BASE: + { + ulInt = INT_GPIOE; + break; + } + + case GPIO_PORTF_BASE: + case GPIO_PORTF_AHB_BASE: + { + ulInt = INT_GPIOF; + break; + } + + case GPIO_PORTG_BASE: + case GPIO_PORTG_AHB_BASE: + { + ulInt = INT_GPIOG; + break; + } + + case GPIO_PORTH_BASE: + case GPIO_PORTH_AHB_BASE: + { + ulInt = INT_GPIOH; + break; + } + + case GPIO_PORTJ_BASE: + case GPIO_PORTJ_AHB_BASE: + { + ulInt = INT_GPIOJ; + break; + } + + default: + { + return(-1); + } + } + + // + // Return GPIO interrupt number. + // + return(ulInt); +} + +//***************************************************************************** +// +//! Sets the direction and mode of the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port +//! \param ucPins is the bit-packed representation of the pin(s). +//! \param ulPinIO is the pin direction and/or mode. +//! +//! This function will set the specified pin(s) on the selected GPIO port +//! as either an input or output under software control, or it will set the +//! pin to be under hardware control. +//! +//! The parameter \e ulPinIO is an enumerated data type that can be one of +//! the following values: +//! +//! - \b GPIO_DIR_MODE_IN +//! - \b GPIO_DIR_MODE_OUT +//! - \b GPIO_DIR_MODE_HW +//! +//! where \b GPIO_DIR_MODE_IN specifies that the pin will be programmed as +//! a software controlled input, \b GPIO_DIR_MODE_OUT specifies that the pin +//! will be programmed as a software controlled output, and +//! \b GPIO_DIR_MODE_HW specifies that the pin will be placed under +//! hardware control. +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note GPIOPadConfigSet() must also be used to configure the corresponding +//! pad(s) in order for them to propagate the signal to/from the GPIO. +//! +//! \return None. +// +//***************************************************************************** +void +GPIODirModeSet(unsigned long ulPort, unsigned char ucPins, + unsigned long ulPinIO) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + ASSERT((ulPinIO == GPIO_DIR_MODE_IN) || (ulPinIO == GPIO_DIR_MODE_OUT) || + (ulPinIO == GPIO_DIR_MODE_HW)); + + // + // Set the pin direction and mode. + // + HWREG(ulPort + GPIO_O_DIR) = ((ulPinIO & 1) ? + (HWREG(ulPort + GPIO_O_DIR) | ucPins) : + (HWREG(ulPort + GPIO_O_DIR) & ~(ucPins))); + HWREG(ulPort + GPIO_O_AFSEL) = ((ulPinIO & 2) ? + (HWREG(ulPort + GPIO_O_AFSEL) | ucPins) : + (HWREG(ulPort + GPIO_O_AFSEL) & + ~(ucPins))); +} + +//***************************************************************************** +// +//! Gets the direction and mode of a pin. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPin is the pin number. +//! +//! This function gets the direction and control mode for a specified pin on +//! the selected GPIO port. The pin can be configured as either an input or +//! output under software control, or it can be under hardware control. The +//! type of control and direction are returned as an enumerated data type. +//! +//! \return Returns one of the enumerated data types described for +//! GPIODirModeSet(). +// +//***************************************************************************** +unsigned long +GPIODirModeGet(unsigned long ulPort, unsigned char ucPin) +{ + unsigned long ulDir, ulAFSEL; + + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + ASSERT(ucPin < 8); + + // + // Convert from a pin number to a bit position. + // + ucPin = 1 << ucPin; + + // + // Return the pin direction and mode. + // + ulDir = HWREG(ulPort + GPIO_O_DIR); + ulAFSEL = HWREG(ulPort + GPIO_O_AFSEL); + return(((ulDir & ucPin) ? 1 : 0) | ((ulAFSEL & ucPin) ? 2 : 0)); +} + +//***************************************************************************** +// +//! Sets the interrupt type for the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! \param ulIntType specifies the type of interrupt trigger mechanism. +//! +//! This function sets up the various interrupt trigger mechanisms for the +//! specified pin(s) on the selected GPIO port. +//! +//! The parameter \e ulIntType is an enumerated data type that can be one of +//! the following values: +//! +//! - \b GPIO_FALLING_EDGE +//! - \b GPIO_RISING_EDGE +//! - \b GPIO_BOTH_EDGES +//! - \b GPIO_LOW_LEVEL +//! - \b GPIO_HIGH_LEVEL +//! +//! where the different values describe the interrupt detection mechanism +//! (edge or level) and the particular triggering event (falling, rising, +//! or both edges for edge detect, low or high for level detect). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note In order to avoid any spurious interrupts, the user must +//! ensure that the GPIO inputs remain stable for the duration of +//! this function. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOIntTypeSet(unsigned long ulPort, unsigned char ucPins, + unsigned long ulIntType) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + ASSERT((ulIntType == GPIO_FALLING_EDGE) || + (ulIntType == GPIO_RISING_EDGE) || (ulIntType == GPIO_BOTH_EDGES) || + (ulIntType == GPIO_LOW_LEVEL) || (ulIntType == GPIO_HIGH_LEVEL)); + + // + // Set the pin interrupt type. + // + HWREG(ulPort + GPIO_O_IBE) = ((ulIntType & 1) ? + (HWREG(ulPort + GPIO_O_IBE) | ucPins) : + (HWREG(ulPort + GPIO_O_IBE) & ~(ucPins))); + HWREG(ulPort + GPIO_O_IS) = ((ulIntType & 2) ? + (HWREG(ulPort + GPIO_O_IS) | ucPins) : + (HWREG(ulPort + GPIO_O_IS) & ~(ucPins))); + HWREG(ulPort + GPIO_O_IEV) = ((ulIntType & 4) ? + (HWREG(ulPort + GPIO_O_IEV) | ucPins) : + (HWREG(ulPort + GPIO_O_IEV) & ~(ucPins))); +} + +//***************************************************************************** +// +//! Gets the interrupt type for a pin. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPin is the pin number. +//! +//! This function gets the interrupt type for a specified pin on the selected +//! GPIO port. The pin can be configured as a falling edge, rising edge, or +//! both edge detected interrupt, or it can be configured as a low level or +//! high level detected interrupt. The type of interrupt detection mechanism +//! is returned as an enumerated data type. +//! +//! \return Returns one of the enumerated data types described for +//! GPIOIntTypeSet(). +// +//***************************************************************************** +unsigned long +GPIOIntTypeGet(unsigned long ulPort, unsigned char ucPin) +{ + unsigned long ulIBE, ulIS, ulIEV; + + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + ASSERT(ucPin < 8); + + // + // Convert from a pin number to a bit position. + // + ucPin = 1 << ucPin; + + // + // Return the pin interrupt type. + // + ulIBE = HWREG(ulPort + GPIO_O_IBE); + ulIS = HWREG(ulPort + GPIO_O_IS); + ulIEV = HWREG(ulPort + GPIO_O_IEV); + return(((ulIBE & ucPin) ? 1 : 0) | ((ulIS & ucPin) ? 2 : 0) | + ((ulIEV & ucPin) ? 4 : 0)); +} + +//***************************************************************************** +// +//! Sets the pad configuration for the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! \param ulStrength specifies the output drive strength. +//! \param ulPinType specifies the pin type. +//! +//! This function sets the drive strength and type for the specified pin(s) +//! on the selected GPIO port. For pin(s) configured as input ports, the +//! pad is configured as requested, but the only real effect on the input +//! is the configuration of the pull-up or pull-down termination. +//! +//! The parameter \e ulStrength can be one of the following values: +//! +//! - \b GPIO_STRENGTH_2MA +//! - \b GPIO_STRENGTH_4MA +//! - \b GPIO_STRENGTH_8MA +//! - \b GPIO_STRENGTH_8MA_SC +//! +//! where \b GPIO_STRENGTH_xMA specifies either 2, 4, or 8 mA output drive +//! strength, and \b GPIO_OUT_STRENGTH_8MA_SC specifies 8 mA output drive with +//! slew control. +//! +//! The parameter \e ulPinType can be one of the following values: +//! +//! - \b GPIO_PIN_TYPE_STD +//! - \b GPIO_PIN_TYPE_STD_WPU +//! - \b GPIO_PIN_TYPE_STD_WPD +//! - \b GPIO_PIN_TYPE_OD +//! - \b GPIO_PIN_TYPE_OD_WPU +//! - \b GPIO_PIN_TYPE_OD_WPD +//! - \b GPIO_PIN_TYPE_ANALOG +//! +//! where \b GPIO_PIN_TYPE_STD* specifies a push-pull pin, \b GPIO_PIN_TYPE_OD* +//! specifies an open-drain pin, \b *_WPU specifies a weak pull-up, \b *_WPD +//! specifies a weak pull-down, and \b GPIO_PIN_TYPE_ANALOG specifies an +//! analog input (for the comparators). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPadConfigSet(unsigned long ulPort, unsigned char ucPins, + unsigned long ulStrength, unsigned long ulPinType) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + ASSERT((ulStrength == GPIO_STRENGTH_2MA) || + (ulStrength == GPIO_STRENGTH_4MA) || + (ulStrength == GPIO_STRENGTH_8MA) || + (ulStrength == GPIO_STRENGTH_8MA_SC)); + ASSERT((ulPinType == GPIO_PIN_TYPE_STD) || + (ulPinType == GPIO_PIN_TYPE_STD_WPU) || + (ulPinType == GPIO_PIN_TYPE_STD_WPD) || + (ulPinType == GPIO_PIN_TYPE_OD) || + (ulPinType == GPIO_PIN_TYPE_OD_WPU) || + (ulPinType == GPIO_PIN_TYPE_OD_WPD) || + (ulPinType == GPIO_PIN_TYPE_ANALOG)) + + // + // Set the output drive strength. + // + HWREG(ulPort + GPIO_O_DR2R) = ((ulStrength & 1) ? + (HWREG(ulPort + GPIO_O_DR2R) | ucPins) : + (HWREG(ulPort + GPIO_O_DR2R) & ~(ucPins))); + HWREG(ulPort + GPIO_O_DR4R) = ((ulStrength & 2) ? + (HWREG(ulPort + GPIO_O_DR4R) | ucPins) : + (HWREG(ulPort + GPIO_O_DR4R) & ~(ucPins))); + HWREG(ulPort + GPIO_O_DR8R) = ((ulStrength & 4) ? + (HWREG(ulPort + GPIO_O_DR8R) | ucPins) : + (HWREG(ulPort + GPIO_O_DR8R) & ~(ucPins))); + HWREG(ulPort + GPIO_O_SLR) = ((ulStrength & 8) ? + (HWREG(ulPort + GPIO_O_SLR) | ucPins) : + (HWREG(ulPort + GPIO_O_SLR) & ~(ucPins))); + + // + // Set the pin type. + // + HWREG(ulPort + GPIO_O_ODR) = ((ulPinType & 1) ? + (HWREG(ulPort + GPIO_O_ODR) | ucPins) : + (HWREG(ulPort + GPIO_O_ODR) & ~(ucPins))); + HWREG(ulPort + GPIO_O_PUR) = ((ulPinType & 2) ? + (HWREG(ulPort + GPIO_O_PUR) | ucPins) : + (HWREG(ulPort + GPIO_O_PUR) & ~(ucPins))); + HWREG(ulPort + GPIO_O_PDR) = ((ulPinType & 4) ? + (HWREG(ulPort + GPIO_O_PDR) | ucPins) : + (HWREG(ulPort + GPIO_O_PDR) & ~(ucPins))); + HWREG(ulPort + GPIO_O_DEN) = ((ulPinType & 8) ? + (HWREG(ulPort + GPIO_O_DEN) | ucPins) : + (HWREG(ulPort + GPIO_O_DEN) & ~(ucPins))); + + // + // Set the analog mode select register. This register only appears in + // DustDevil-class (and later) devices, but is a harmless write on + // Sandstorm- and Fury-class devices. + // + HWREG(ulPort + GPIO_O_AMSEL) = + ((ulPinType == GPIO_PIN_TYPE_ANALOG) ? + (HWREG(ulPort + GPIO_O_AMSEL) | ucPins) : + (HWREG(ulPort + GPIO_O_AMSEL) & ~(ucPins))); +} + +//***************************************************************************** +// +//! Gets the pad configuration for a pin. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPin is the pin number. +//! \param pulStrength is a pointer to storage for the output drive strength. +//! \param pulPinType is a pointer to storage for the output drive type. +//! +//! This function gets the pad configuration for a specified pin on the +//! selected GPIO port. The values returned in \e pulStrength and +//! \e pulPinType correspond to the values used in GPIOPadConfigSet(). This +//! function also works for pin(s) configured as input pin(s); however, the +//! only meaningful data returned is whether the pin is terminated with a +//! pull-up or down resistor. +//! +//! \return None +// +//***************************************************************************** +void +GPIOPadConfigGet(unsigned long ulPort, unsigned char ucPin, + unsigned long *pulStrength, unsigned long *pulPinType) +{ + unsigned long ulTemp1, ulTemp2, ulTemp3, ulTemp4; + + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + ASSERT(ucPin < 8); + + // + // Convert from a pin number to a bit position. + // + ucPin = (1 << ucPin); + + // + // Get the drive strength for this pin. + // + ulTemp1 = HWREG(ulPort + GPIO_O_DR2R); + ulTemp2 = HWREG(ulPort + GPIO_O_DR4R); + ulTemp3 = HWREG(ulPort + GPIO_O_DR8R); + ulTemp4 = HWREG(ulPort + GPIO_O_SLR); + *pulStrength = (((ulTemp1 & ucPin) ? 1 : 0) | ((ulTemp2 & ucPin) ? 2 : 0) | + ((ulTemp3 & ucPin) ? 4 : 0) | ((ulTemp4 & ucPin) ? 8 : 0)); + + // + // Get the pin type. + // + ulTemp1 = HWREG(ulPort + GPIO_O_ODR); + ulTemp2 = HWREG(ulPort + GPIO_O_PUR); + ulTemp3 = HWREG(ulPort + GPIO_O_PDR); + ulTemp4 = HWREG(ulPort + GPIO_O_DEN); + *pulPinType = (((ulTemp1 & ucPin) ? 1 : 0) | ((ulTemp2 & ucPin) ? 2 : 0) | + ((ulTemp3 & ucPin) ? 4 : 0) | ((ulTemp4 & ucPin) ? 8 : 0)); +} + +//***************************************************************************** +// +//! Enables interrupts for the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! Unmasks the interrupt for the specified pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinIntEnable(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Enable the interrupts. + // + HWREG(ulPort + GPIO_O_IM) |= ucPins; +} + +//***************************************************************************** +// +//! Disables interrupts for the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! Masks the interrupt for the specified pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinIntDisable(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Disable the interrupts. + // + HWREG(ulPort + GPIO_O_IM) &= ~(ucPins); +} + +//***************************************************************************** +// +//! Gets interrupt status for the specified GPIO port. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param bMasked specifies whether masked or raw interrupt status is +//! returned. +//! +//! If \e bMasked is set as \b true, then the masked interrupt status is +//! returned; otherwise, the raw interrupt status will be returned. +//! +//! \return Returns a bit-packed byte, where each bit that is set identifies +//! an active masked or raw interrupt, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! Bits 31:8 should be ignored. +// +//***************************************************************************** +long +GPIOPinIntStatus(unsigned long ulPort, tBoolean bMasked) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Return the interrupt status. + // + if(bMasked) + { + return(HWREG(ulPort + GPIO_O_MIS)); + } + else + { + return(HWREG(ulPort + GPIO_O_RIS)); + } +} + +//***************************************************************************** +// +//! Clears the interrupt for the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! Clears the interrupt for the specified pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinIntClear(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Clear the interrupts. + // + HWREG(ulPort + GPIO_O_ICR) = ucPins; +} + +//***************************************************************************** +// +//! Registers an interrupt handler for a GPIO port. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param pfnIntHandler is a pointer to the GPIO port interrupt handling +//! function. +//! +//! This function will ensure that the interrupt handler specified by +//! \e pfnIntHandler is called when an interrupt is detected from the selected +//! GPIO port. This function will also enable the corresponding GPIO interrupt +//! in the interrupt controller; individual pin interrupts and interrupt +//! sources must be enabled with GPIOPinIntEnable(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPortIntRegister(unsigned long ulPort, void (*pfnIntHandler)(void)) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Get the interrupt number associated with the specified GPIO. + // + ulPort = GPIOGetIntNumber(ulPort); + + // + // Register the interrupt handler. + // + IntRegister(ulPort, pfnIntHandler); + + // + // Enable the GPIO interrupt. + // + IntEnable(ulPort); +} + +//***************************************************************************** +// +//! Removes an interrupt handler for a GPIO port. +//! +//! \param ulPort is the base address of the GPIO port. +//! +//! This function will unregister the interrupt handler for the specified +//! GPIO port. This function will also disable the corresponding +//! GPIO port interrupt in the interrupt controller; individual GPIO interrupts +//! and interrupt sources must be disabled with GPIOPinIntDisable(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPortIntUnregister(unsigned long ulPort) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Get the interrupt number associated with the specified GPIO. + // + ulPort = GPIOGetIntNumber(ulPort); + + // + // Disable the GPIO interrupt. + // + IntDisable(ulPort); + + // + // Unregister the interrupt handler. + // + IntUnregister(ulPort); +} + +//***************************************************************************** +// +//! Reads the values present of the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The values at the specified pin(s) are read, as specified by \e ucPins. +//! Values are returned for both input and output pin(s), and the value +//! for pin(s) that are not specified by \e ucPins are set to 0. +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return Returns a bit-packed byte providing the state of the specified +//! pin, where bit 0 of the byte represents GPIO port pin 0, bit 1 represents +//! GPIO port pin 1, and so on. Any bit that is not specified by \e ucPins +//! is returned as a 0. Bits 31:8 should be ignored. +// +//***************************************************************************** +long +GPIOPinRead(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Return the pin value(s). + // + return(HWREG(ulPort + (GPIO_O_DATA + (ucPins << 2)))); +} + +//***************************************************************************** +// +//! Writes a value to the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! \param ucVal is the value to write to the pin(s). +//! +//! Writes the corresponding bit values to the output pin(s) specified by +//! \e ucPins. Writing to a pin configured as an input pin has no effect. +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinWrite(unsigned long ulPort, unsigned char ucPins, unsigned char ucVal) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Write the pins. + // + HWREG(ulPort + (GPIO_O_DATA + (ucPins << 2))) = ucVal; +} + +//***************************************************************************** +// +//! Configures pin(s) for use as analog-to-digital converter inputs. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The analog-to-digital converter input pins must be properly configured +//! to function correctly on DustDevil-class devices. This function provides +//! the proper configuration for those pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into an ADC input; it only +//! configures an ADC input pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeADC(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be inputs. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_IN); + + // + // Set the pad(s) for analog operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_ANALOG); +} + +//***************************************************************************** +// +//! Configures pin(s) for use as a CAN device. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The CAN pins must be properly configured for the CAN peripherals to +//! function correctly. This function provides a typical configuration for +//! those pin(s); other configurations may work as well depending upon the +//! board setup (for example, using the on-chip pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a CAN pin; it only +//! configures a CAN pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeCAN(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be inputs. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use as an analog comparator input. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The analog comparator input pins must be properly configured for the analog +//! comparator to function correctly. This function provides the proper +//! configuration for those pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into an analog comparator input; +//! it only configures an analog comparator pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeComparator(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be inputs. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_IN); + + // + // Set the pad(s) for analog operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_ANALOG); +} + +//***************************************************************************** +// +//! Configures pin(s) for use as GPIO inputs. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The GPIO pins must be properly configured in order to function correctly as +//! GPIO inputs; this is especially true of Fury-class devices where the +//! digital input enable is turned off by default. This function provides the +//! proper configuration for those pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeGPIOInput(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be inputs. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_IN); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use as GPIO outputs. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The GPIO pins must be properly configured in order to function correctly as +//! GPIO outputs; this is especially true of Fury-class devices where the +//! digital input enable is turned off by default. This function provides the +//! proper configuration for those pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeGPIOOutput(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be outputs. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_OUT); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use as GPIO open drain outputs. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The GPIO pins must be properly configured in order to function correctly as +//! GPIO outputs; this is especially true of Fury-class devices where the +//! digital input enable is turned off by default. This function provides the +//! proper configuration for those pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeGPIOOutputOD(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be outputs. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_OUT); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_OD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the I2C peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The I2C pins must be properly configured for the I2C peripheral to function +//! correctly. This function provides the proper configuration for those +//! pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into an I2C pin; it only +//! configures an I2C pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeI2C(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for open-drain operation with a weak pull-up. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_OD_WPU); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the PWM peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The PWM pins must be properly configured for the PWM peripheral to function +//! correctly. This function provides a typical configuration for those +//! pin(s); other configurations may work as well depending upon the board +//! setup (for example, using the on-chip pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a PWM pin; it only +//! configures a PWM pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypePWM(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the QEI peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The QEI pins must be properly configured for the QEI peripheral to function +//! correctly. This function provides a typical configuration for those +//! pin(s); other configurations may work as well depending upon the board +//! setup (for example, not using the on-chip pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a QEI pin; it only +//! configures a QEI pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeQEI(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation with a weak pull-up. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the SSI peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The SSI pins must be properly configured for the SSI peripheral to function +//! correctly. This function provides a typical configuration for those +//! pin(s); other configurations may work as well depending upon the board +//! setup (for example, using the on-chip pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a SSI pin; it only +//! configures a SSI pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeSSI(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the Timer peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The CCP pins must be properly configured for the timer peripheral to +//! function correctly. This function provides a typical configuration for +//! those pin(s); other configurations may work as well depending upon the +//! board setup (for example, using the on-chip pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a timer pin; it only +//! configures a timer pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeTimer(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the UART peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The UART pins must be properly configured for the UART peripheral to +//! function correctly. This function provides a typical configuration for +//! those pin(s); other configurations may work as well depending upon the +//! board setup (for example, using the on-chip pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a UART pin; it only +//! configures a UART pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeUART(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the USB peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! Some USB digital pins must be properly configured for the USB peripheral to +//! function correctly. This function provides a typical configuration for +//! the digital USB pin(s); other configurations may work as well depending +//! upon the board setup (for example, using the on-chip pull-ups). +//! +//! This function should only be used with EPEN and PFAULT pins as all other +//! USB pins are analog in nature or are not used in devices without OTG +//! functionality. +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a USB pin; it only +//! configures a USB pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeUSBDigital(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the USB peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! Some USB analog pins must be properly configured for the USB peripheral to +//! function correctly. This function provides the proper configuration for +//! any USB pin(s). This can also be used to configure the EPEN and PFAULT pins +//! so that they are no longer used by the USB controller. +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a USB pin; it only +//! configures a USB pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeUSBAnalog(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be inputs. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_IN); + + // + // Set the pad(s) for analog operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_ANALOG); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the I2S peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! Some I2S pins must be properly configured for the I2S peripheral to +//! function correctly. This function provides a typical configuration for +//! the digital I2S pin(s); other configurations may work as well depending +//! upon the board setup (for example, using the on-chip pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a I2S pin; it only +//! configures a I2S pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeI2S(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the Ethernet peripheral as LED signals. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The Ethernet peripheral provides two signals that can be used to drive +//! an LED (e.g. for link status/activity). This function provides a typical +//! configuration for the pins. +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into an Ethernet LED pin; it only +//! configures an Ethernet LED pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeEthernetLED(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the external peripheral interface. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The external peripheral interface pins must be properly configured for the +//! external peripheral interface to function correctly. This function +//! provides a typica configuration for those pin(s); other configurations may +//! work as well depending upon the board setup (for exampe, using the on-chip +//! pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into an external peripheral +//! interface pin; it only configures an external peripheral interface pin for +//! proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeEPI(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures the alternate function of a GPIO pin. +//! +//! \param ulPinConfig is the pin configuration value, specified as only one of +//! the \b GPIO_P??_??? values. +//! +//! This function configures the pin mux that selects the peripheral function +//! associated with a particular GPIO pin. Only one peripheral function at a +//! time can be associated with a GPIO pin, and each peripheral function should +//! only be associated with a single GPIO pin at a time (despite the fact that +//! many of them can be associated with more than one GPIO pin). +//! +//! \note This function is only valid on Tempest-class devices. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinConfigure(unsigned long ulPinConfig) +{ + unsigned long ulBase, ulShift; + + // + // Check the argument. + // + ASSERT(((ulPinConfig >> 16) & 0xff) < 9); + ASSERT(((ulPinConfig >> 8) & 0xe3) == 0); + + // + // Extract the base address index from the input value. + // + ulBase = (ulPinConfig >> 16) & 0xff; + + // + // Get the base address of the GPIO module, selecting either the APB or the + // AHB aperture as appropriate. + // + if(HWREG(SYSCTL_GPIOHBCTL) & (1 << ulBase)) + { + ulBase = g_pulGPIOBaseAddrs[(ulBase << 1) + 1]; + } + else + { + ulBase = g_pulGPIOBaseAddrs[ulBase << 1]; + } + + // + // Extract the shift from the input value. + // + ulShift = (ulPinConfig >> 8) & 0xff; + + // + // Write the requested pin muxing value for this GPIO pin. + // + HWREG(ulBase + GPIO_O_PCTL) = ((HWREG(ulBase + GPIO_O_PCTL) & + ~(0xf << ulShift)) | + ((ulPinConfig & 0xf) << ulShift)); + +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/gpio.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/gpio.h new file mode 100644 index 00000000..3b60fc77 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/gpio.h @@ -0,0 +1,767 @@ +//***************************************************************************** +// +// gpio.h - Defines and Macros for GPIO API. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __GPIO_H__ +#define __GPIO_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// The following values define the bit field for the ucPins argument to several +// of the APIs. +// +//***************************************************************************** +#define GPIO_PIN_0 0x00000001 // GPIO pin 0 +#define GPIO_PIN_1 0x00000002 // GPIO pin 1 +#define GPIO_PIN_2 0x00000004 // GPIO pin 2 +#define GPIO_PIN_3 0x00000008 // GPIO pin 3 +#define GPIO_PIN_4 0x00000010 // GPIO pin 4 +#define GPIO_PIN_5 0x00000020 // GPIO pin 5 +#define GPIO_PIN_6 0x00000040 // GPIO pin 6 +#define GPIO_PIN_7 0x00000080 // GPIO pin 7 + +//***************************************************************************** +// +// Values that can be passed to GPIODirModeSet as the ulPinIO parameter, and +// returned from GPIODirModeGet. +// +//***************************************************************************** +#define GPIO_DIR_MODE_IN 0x00000000 // Pin is a GPIO input +#define GPIO_DIR_MODE_OUT 0x00000001 // Pin is a GPIO output +#define GPIO_DIR_MODE_HW 0x00000002 // Pin is a peripheral function + +//***************************************************************************** +// +// Values that can be passed to GPIOIntTypeSet as the ulIntType parameter, and +// returned from GPIOIntTypeGet. +// +//***************************************************************************** +#define GPIO_FALLING_EDGE 0x00000000 // Interrupt on falling edge +#define GPIO_RISING_EDGE 0x00000004 // Interrupt on rising edge +#define GPIO_BOTH_EDGES 0x00000001 // Interrupt on both edges +#define GPIO_LOW_LEVEL 0x00000002 // Interrupt on low level +#define GPIO_HIGH_LEVEL 0x00000007 // Interrupt on high level + +//***************************************************************************** +// +// Values that can be passed to GPIOPadConfigSet as the ulStrength parameter, +// and returned by GPIOPadConfigGet in the *pulStrength parameter. +// +//***************************************************************************** +#define GPIO_STRENGTH_2MA 0x00000001 // 2mA drive strength +#define GPIO_STRENGTH_4MA 0x00000002 // 4mA drive strength +#define GPIO_STRENGTH_8MA 0x00000004 // 8mA drive strength +#define GPIO_STRENGTH_8MA_SC 0x0000000C // 8mA drive with slew rate control + +//***************************************************************************** +// +// Values that can be passed to GPIOPadConfigSet as the ulPadType parameter, +// and returned by GPIOPadConfigGet in the *pulPadType parameter. +// +//***************************************************************************** +#define GPIO_PIN_TYPE_STD 0x00000008 // Push-pull +#define GPIO_PIN_TYPE_STD_WPU 0x0000000A // Push-pull with weak pull-up +#define GPIO_PIN_TYPE_STD_WPD 0x0000000C // Push-pull with weak pull-down +#define GPIO_PIN_TYPE_OD 0x00000009 // Open-drain +#define GPIO_PIN_TYPE_OD_WPU 0x0000000B // Open-drain with weak pull-up +#define GPIO_PIN_TYPE_OD_WPD 0x0000000D // Open-drain with weak pull-down +#define GPIO_PIN_TYPE_ANALOG 0x00000000 // Analog comparator + +//***************************************************************************** +// +// Values that can be passed to GPIOPinConfigure as the ulPinConfig parameter. +// +//***************************************************************************** +// +// GPIO pin A0 +// +#define GPIO_PA0_U0RX 0x00000001 +#define GPIO_PA0_I2C1SCL 0x00000008 +#define GPIO_PA0_U1RX 0x00000009 + +// +// GPIO pin A1 +// +#define GPIO_PA1_U0TX 0x00000401 +#define GPIO_PA1_I2C1SDA 0x00000408 +#define GPIO_PA1_U1TX 0x00000409 + +// +// GPIO pin A2 +// +#define GPIO_PA2_SSI0CLK 0x00000801 +#define GPIO_PA2_PWM4 0x00000804 +#define GPIO_PA2_I2S0RXSD 0x00000809 + +// +// GPIO pin A3 +// +#define GPIO_PA3_SSI0FSS 0x00000c01 +#define GPIO_PA3_PWM5 0x00000c04 +#define GPIO_PA3_I2S0RXMCLK 0x00000c09 + +// +// GPIO pin A4 +// +#define GPIO_PA4_SSI0RX 0x00001001 +#define GPIO_PA4_PWM6 0x00001004 +#define GPIO_PA4_CAN0RX 0x00001005 +#define GPIO_PA4_I2S0TXSCK 0x00001009 + +// +// GPIO pin A5 +// +#define GPIO_PA5_SSI0TX 0x00001401 +#define GPIO_PA5_PWM7 0x00001404 +#define GPIO_PA5_CAN0TX 0x00001405 +#define GPIO_PA5_I2S0TXWS 0x00001409 + +// +// GPIO pin A6 +// +#define GPIO_PA6_I2C1SCL 0x00001801 +#define GPIO_PA6_CCP1 0x00001802 +#define GPIO_PA6_PWM0 0x00001804 +#define GPIO_PA6_PWM4 0x00001805 +#define GPIO_PA6_CAN0RX 0x00001806 +#define GPIO_PA6_USB0EPEN 0x00001808 +#define GPIO_PA6_U1CTS 0x00001809 + +// +// GPIO pin A7 +// +#define GPIO_PA7_I2C1SDA 0x00001c01 +#define GPIO_PA7_CCP4 0x00001c02 +#define GPIO_PA7_PWM1 0x00001c04 +#define GPIO_PA7_PWM5 0x00001c05 +#define GPIO_PA7_CAN0TX 0x00001c06 +#define GPIO_PA7_CCP3 0x00001c07 +#define GPIO_PA7_USB0PFLT 0x00001c08 +#define GPIO_PA7_U1DCD 0x00001c09 + +// +// GPIO pin B0 +// +#define GPIO_PB0_CCP0 0x00010001 +#define GPIO_PB0_PWM2 0x00010002 +#define GPIO_PB0_U1RX 0x00010005 + +// +// GPIO pin B1 +// +#define GPIO_PB1_CCP2 0x00010401 +#define GPIO_PB1_PWM3 0x00010402 +#define GPIO_PB1_CCP1 0x00010404 +#define GPIO_PB1_U1TX 0x00010405 + +// +// GPIO pin B2 +// +#define GPIO_PB2_I2C0SCL 0x00010801 +#define GPIO_PB2_IDX0 0x00010802 +#define GPIO_PB2_CCP3 0x00010804 +#define GPIO_PB2_CCP0 0x00010805 +#define GPIO_PB2_USB0EPEN 0x00010808 + +// +// GPIO pin B3 +// +#define GPIO_PB3_I2C0SDA 0x00010c01 +#define GPIO_PB3_FAULT0 0x00010c02 +#define GPIO_PB3_FAULT3 0x00010c04 +#define GPIO_PB3_USB0PFLT 0x00010c08 + +// +// GPIO pin B4 +// +#define GPIO_PB4_U2RX 0x00011004 +#define GPIO_PB4_CAN0RX 0x00011005 +#define GPIO_PB4_IDX0 0x00011006 +#define GPIO_PB4_U1RX 0x00011007 +#define GPIO_PB4_EPI0S23 0x00011008 + +// +// GPIO pin B5 +// +#define GPIO_PB5_C0O 0x00011401 +#define GPIO_PB5_CCP5 0x00011402 +#define GPIO_PB5_CCP6 0x00011403 +#define GPIO_PB5_CCP0 0x00011404 +#define GPIO_PB5_CAN0TX 0x00011405 +#define GPIO_PB5_CCP2 0x00011406 +#define GPIO_PB5_U1TX 0x00011407 +#define GPIO_PB5_EPI0S22 0x00011408 + +// +// GPIO pin B6 +// +#define GPIO_PB6_CCP1 0x00011801 +#define GPIO_PB6_CCP7 0x00011802 +#define GPIO_PB6_C0O 0x00011803 +#define GPIO_PB6_FAULT1 0x00011804 +#define GPIO_PB6_IDX0 0x00011805 +#define GPIO_PB6_CCP5 0x00011806 +#define GPIO_PB6_I2S0TXSCK 0x00011809 + +// +// GPIO pin B7 +// +#define GPIO_PB7_NMI 0x00011c04 + +// +// GPIO pin C0 +// +#define GPIO_PC0_TCK 0x00020003 + +// +// GPIO pin C1 +// +#define GPIO_PC1_TMS 0x00020403 + +// +// GPIO pin C2 +// +#define GPIO_PC2_TDI 0x00020803 + +// +// GPIO pin C3 +// +#define GPIO_PC3_TDO 0x00020c03 + +// +// GPIO pin C4 +// +#define GPIO_PC4_CCP5 0x00021001 +#define GPIO_PC4_PHA0 0x00021002 +#define GPIO_PC4_PWM6 0x00021004 +#define GPIO_PC4_CCP2 0x00021005 +#define GPIO_PC4_CCP4 0x00021006 +#define GPIO_PC4_EPI0S2 0x00021008 +#define GPIO_PC4_CCP1 0x00021009 + +// +// GPIO pin C5 +// +#define GPIO_PC5_CCP1 0x00021401 +#define GPIO_PC5_C1O 0x00021402 +#define GPIO_PC5_C0O 0x00021403 +#define GPIO_PC5_FAULT2 0x00021404 +#define GPIO_PC5_CCP3 0x00021405 +#define GPIO_PC5_USB0EPEN 0x00021406 +#define GPIO_PC5_EPI0S3 0x00021408 + +// +// GPIO pin C6 +// +#define GPIO_PC6_CCP3 0x00021801 +#define GPIO_PC6_PHB0 0x00021802 +#define GPIO_PC6_C2O 0x00021803 +#define GPIO_PC6_PWM7 0x00021804 +#define GPIO_PC6_U1RX 0x00021805 +#define GPIO_PC6_CCP0 0x00021806 +#define GPIO_PC6_USB0PFLT 0x00021807 +#define GPIO_PC6_EPI0S4 0x00021808 + +// +// GPIO pin C7 +// +#define GPIO_PC7_CCP4 0x00021c01 +#define GPIO_PC7_PHB0 0x00021c02 +#define GPIO_PC7_CCP0 0x00021c04 +#define GPIO_PC7_U1TX 0x00021c05 +#define GPIO_PC7_USB0PFLT 0x00021c06 +#define GPIO_PC7_C1O 0x00021c07 +#define GPIO_PC7_EPI0S5 0x00021c08 + +// +// GPIO pin D0 +// +#define GPIO_PD0_PWM0 0x00030001 +#define GPIO_PD0_CAN0RX 0x00030002 +#define GPIO_PD0_IDX0 0x00030003 +#define GPIO_PD0_U2RX 0x00030004 +#define GPIO_PD0_U1RX 0x00030005 +#define GPIO_PD0_CCP6 0x00030006 +#define GPIO_PD0_I2S0RXSCK 0x00030008 +#define GPIO_PD0_U1CTS 0x00030009 + +// +// GPIO pin D1 +// +#define GPIO_PD1_PWM1 0x00030401 +#define GPIO_PD1_CAN0TX 0x00030402 +#define GPIO_PD1_PHA0 0x00030403 +#define GPIO_PD1_U2TX 0x00030404 +#define GPIO_PD1_U1TX 0x00030405 +#define GPIO_PD1_CCP7 0x00030406 +#define GPIO_PD1_I2S0RXWS 0x00030408 +#define GPIO_PD1_U1DCD 0x00030409 +#define GPIO_PD1_CCP2 0x0003040a +#define GPIO_PD1_PHB1 0x0003040b + +// +// GPIO pin D2 +// +#define GPIO_PD2_U1RX 0x00030801 +#define GPIO_PD2_CCP6 0x00030802 +#define GPIO_PD2_PWM2 0x00030803 +#define GPIO_PD2_CCP5 0x00030804 +#define GPIO_PD2_EPI0S20 0x00030808 + +// +// GPIO pin D3 +// +#define GPIO_PD3_U1TX 0x00030c01 +#define GPIO_PD3_CCP7 0x00030c02 +#define GPIO_PD3_PWM3 0x00030c03 +#define GPIO_PD3_CCP0 0x00030c04 +#define GPIO_PD3_EPI0S21 0x00030c08 + +// +// GPIO pin D4 +// +#define GPIO_PD4_CCP0 0x00031001 +#define GPIO_PD4_CCP3 0x00031002 +#define GPIO_PD4_I2S0RXSD 0x00031008 +#define GPIO_PD4_U1RI 0x00031009 +#define GPIO_PD4_EPI0S19 0x0003100a + +// +// GPIO pin D5 +// +#define GPIO_PD5_CCP2 0x00031401 +#define GPIO_PD5_CCP4 0x00031402 +#define GPIO_PD5_I2S0RXMCLK 0x00031408 +#define GPIO_PD5_U2RX 0x00031409 +#define GPIO_PD5_EPI0S28 0x0003140a + +// +// GPIO pin D6 +// +#define GPIO_PD6_FAULT0 0x00031801 +#define GPIO_PD6_I2S0TXSCK 0x00031808 +#define GPIO_PD6_U2TX 0x00031809 +#define GPIO_PD6_EPI0S29 0x0003180a + +// +// GPIO pin D7 +// +#define GPIO_PD7_IDX0 0x00031c01 +#define GPIO_PD7_C0O 0x00031c02 +#define GPIO_PD7_CCP1 0x00031c03 +#define GPIO_PD7_I2S0TXWS 0x00031c08 +#define GPIO_PD7_U1DTR 0x00031c09 +#define GPIO_PD7_EPI0S30 0x00031c0a + +// +// GPIO pin E0 +// +#define GPIO_PE0_PWM4 0x00040001 +#define GPIO_PE0_SSI1CLK 0x00040002 +#define GPIO_PE0_CCP3 0x00040003 +#define GPIO_PE0_EPI0S8 0x00040008 +#define GPIO_PE0_USB0PFLT 0x00040009 + +// +// GPIO pin E1 +// +#define GPIO_PE1_PWM5 0x00040401 +#define GPIO_PE1_SSI1FSS 0x00040402 +#define GPIO_PE1_FAULT0 0x00040403 +#define GPIO_PE1_CCP2 0x00040404 +#define GPIO_PE1_CCP6 0x00040405 +#define GPIO_PE1_EPI0S9 0x00040408 + +// +// GPIO pin E2 +// +#define GPIO_PE2_CCP4 0x00040801 +#define GPIO_PE2_SSI1RX 0x00040802 +#define GPIO_PE2_PHB1 0x00040803 +#define GPIO_PE2_PHA0 0x00040804 +#define GPIO_PE2_CCP2 0x00040805 +#define GPIO_PE2_EPI0S24 0x00040808 + +// +// GPIO pin E3 +// +#define GPIO_PE3_CCP1 0x00040c01 +#define GPIO_PE3_SSI1TX 0x00040c02 +#define GPIO_PE3_PHA1 0x00040c03 +#define GPIO_PE3_PHB0 0x00040c04 +#define GPIO_PE3_CCP7 0x00040c05 +#define GPIO_PE3_EPI0S25 0x00040c08 + +// +// GPIO pin E4 +// +#define GPIO_PE4_CCP3 0x00041001 +#define GPIO_PE4_FAULT0 0x00041004 +#define GPIO_PE4_U2TX 0x00041005 +#define GPIO_PE4_CCP2 0x00041006 +#define GPIO_PE4_I2S0TXWS 0x00041009 + +// +// GPIO pin E5 +// +#define GPIO_PE5_CCP5 0x00041401 +#define GPIO_PE5_I2S0TXSD 0x00041409 + +// +// GPIO pin E6 +// +#define GPIO_PE6_PWM4 0x00041801 +#define GPIO_PE6_C1O 0x00041802 +#define GPIO_PE6_U1CTS 0x00041809 + +// +// GPIO pin E7 +// +#define GPIO_PE7_PWM5 0x00041c01 +#define GPIO_PE7_C2O 0x00041c02 +#define GPIO_PE7_U1DCD 0x00041c09 + +// +// GPIO pin F0 +// +#define GPIO_PF0_CAN1RX 0x00050001 +#define GPIO_PF0_PHB0 0x00050002 +#define GPIO_PF0_PWM0 0x00050003 +#define GPIO_PF0_I2S0TXSD 0x00050008 +#define GPIO_PF0_U1DSR 0x00050009 + +// +// GPIO pin F1 +// +#define GPIO_PF1_CAN1TX 0x00050401 +#define GPIO_PF1_IDX1 0x00050402 +#define GPIO_PF1_PWM1 0x00050403 +#define GPIO_PF1_I2S0TXMCLK 0x00050408 +#define GPIO_PF1_U1RTS 0x00050409 +#define GPIO_PF1_CCP3 0x0005040a + +// +// GPIO pin F2 +// +#define GPIO_PF2_LED1 0x00050801 +#define GPIO_PF2_PWM4 0x00050802 +#define GPIO_PF2_PWM2 0x00050804 +#define GPIO_PF2_SSI1CLK 0x00050809 + +// +// GPIO pin F3 +// +#define GPIO_PF3_LED0 0x00050c01 +#define GPIO_PF3_PWM5 0x00050c02 +#define GPIO_PF3_PWM3 0x00050c04 +#define GPIO_PF3_SSI1FSS 0x00050c09 + +// +// GPIO pin F4 +// +#define GPIO_PF4_CCP0 0x00051001 +#define GPIO_PF4_C0O 0x00051002 +#define GPIO_PF4_FAULT0 0x00051004 +#define GPIO_PF4_EPI0S12 0x00051008 +#define GPIO_PF4_SSI1RX 0x00051009 + +// +// GPIO pin F5 +// +#define GPIO_PF5_CCP2 0x00051401 +#define GPIO_PF5_C1O 0x00051402 +#define GPIO_PF5_EPI0S15 0x00051408 +#define GPIO_PF5_SSI1TX 0x00051409 + +// +// GPIO pin F6 +// +#define GPIO_PF6_CCP1 0x00051801 +#define GPIO_PF6_C2O 0x00051802 +#define GPIO_PF6_PHA0 0x00051804 +#define GPIO_PF6_I2S0TXMCLK 0x00051809 +#define GPIO_PF6_U1RTS 0x0005180a + +// +// GPIO pin F7 +// +#define GPIO_PF7_CCP4 0x00051c01 +#define GPIO_PF7_PHB0 0x00051c04 +#define GPIO_PF7_EPI0S12 0x00051c08 +#define GPIO_PF7_FAULT1 0x00051c09 + +// +// GPIO pin G0 +// +#define GPIO_PG0_U2RX 0x00060001 +#define GPIO_PG0_PWM0 0x00060002 +#define GPIO_PG0_I2C1SCL 0x00060003 +#define GPIO_PG0_PWM4 0x00060004 +#define GPIO_PG0_USB0EPEN 0x00060007 +#define GPIO_PG0_EPI0S13 0x00060008 + +// +// GPIO pin G1 +// +#define GPIO_PG1_U2TX 0x00060401 +#define GPIO_PG1_PWM1 0x00060402 +#define GPIO_PG1_I2C1SDA 0x00060403 +#define GPIO_PG1_PWM5 0x00060404 +#define GPIO_PG1_EPI0S14 0x00060408 + +// +// GPIO pin G2 +// +#define GPIO_PG2_PWM0 0x00060801 +#define GPIO_PG2_FAULT0 0x00060804 +#define GPIO_PG2_IDX1 0x00060808 +#define GPIO_PG2_I2S0RXSD 0x00060809 + +// +// GPIO pin G3 +// +#define GPIO_PG3_PWM1 0x00060c01 +#define GPIO_PG3_FAULT2 0x00060c04 +#define GPIO_PG3_FAULT0 0x00060c08 +#define GPIO_PG3_I2S0RXMCLK 0x00060c09 + +// +// GPIO pin G4 +// +#define GPIO_PG4_CCP3 0x00061001 +#define GPIO_PG4_FAULT1 0x00061004 +#define GPIO_PG4_EPI0S15 0x00061008 +#define GPIO_PG4_PWM6 0x00061009 +#define GPIO_PG4_U1RI 0x0006100a + +// +// GPIO pin G5 +// +#define GPIO_PG5_CCP5 0x00061401 +#define GPIO_PG5_IDX0 0x00061404 +#define GPIO_PG5_FAULT1 0x00061405 +#define GPIO_PG5_PWM7 0x00061408 +#define GPIO_PG5_I2S0RXSCK 0x00061409 +#define GPIO_PG5_U1DTR 0x0006140a + +// +// GPIO pin G6 +// +#define GPIO_PG6_PHA1 0x00061801 +#define GPIO_PG6_PWM6 0x00061804 +#define GPIO_PG6_FAULT1 0x00061808 +#define GPIO_PG6_I2S0RXWS 0x00061809 +#define GPIO_PG6_U1RI 0x0006180a + +// +// GPIO pin G7 +// +#define GPIO_PG7_PHB1 0x00061c01 +#define GPIO_PG7_PWM7 0x00061c04 +#define GPIO_PG7_CCP5 0x00061c08 +#define GPIO_PG7_EPI0S31 0x00061c09 + +// +// GPIO pin H0 +// +#define GPIO_PH0_CCP6 0x00070001 +#define GPIO_PH0_PWM2 0x00070002 +#define GPIO_PH0_EPI0S6 0x00070008 +#define GPIO_PH0_PWM4 0x00070009 + +// +// GPIO pin H1 +// +#define GPIO_PH1_CCP7 0x00070401 +#define GPIO_PH1_PWM3 0x00070402 +#define GPIO_PH1_EPI0S7 0x00070408 +#define GPIO_PH1_PWM5 0x00070409 + +// +// GPIO pin H2 +// +#define GPIO_PH2_IDX1 0x00070801 +#define GPIO_PH2_C1O 0x00070802 +#define GPIO_PH2_FAULT3 0x00070804 +#define GPIO_PH2_EPI0S1 0x00070808 + +// +// GPIO pin H3 +// +#define GPIO_PH3_PHB0 0x00070c01 +#define GPIO_PH3_FAULT0 0x00070c02 +#define GPIO_PH3_USB0EPEN 0x00070c04 +#define GPIO_PH3_EPI0S0 0x00070c08 + +// +// GPIO pin H4 +// +#define GPIO_PH4_USB0PFLT 0x00071004 +#define GPIO_PH4_EPI0S10 0x00071008 +#define GPIO_PH4_SSI1CLK 0x0007100b + +// +// GPIO pin H5 +// +#define GPIO_PH5_EPI0S11 0x00071408 +#define GPIO_PH5_FAULT2 0x0007140a +#define GPIO_PH5_SSI1FSS 0x0007140b + +// +// GPIO pin H6 +// +#define GPIO_PH6_EPI0S26 0x00071808 +#define GPIO_PH6_PWM4 0x0007180a +#define GPIO_PH6_SSI1RX 0x0007180b + +// +// GPIO pin H7 +// +#define GPIO_PH7_EPI0S27 0x00071c08 +#define GPIO_PH7_PWM5 0x00071c0a +#define GPIO_PH7_SSI1TX 0x00071c0b + +// +// GPIO pin J0 +// +#define GPIO_PJ0_EPI0S16 0x00080008 +#define GPIO_PJ0_PWM0 0x0008000a +#define GPIO_PJ0_I2C1SCL 0x0008000b + +// +// GPIO pin J1 +// +#define GPIO_PJ1_EPI0S17 0x00080408 +#define GPIO_PJ1_USB0PFLT 0x00080409 +#define GPIO_PJ1_PWM1 0x0008040a +#define GPIO_PJ1_I2C1SDA 0x0008040b + +// +// GPIO pin J2 +// +#define GPIO_PJ2_EPI0S18 0x00080808 +#define GPIO_PJ2_CCP0 0x00080809 +#define GPIO_PJ2_FAULT0 0x0008080a + +// +// GPIO pin J3 +// +#define GPIO_PJ3_EPI0S19 0x00080c08 +#define GPIO_PJ3_U1CTS 0x00080c09 +#define GPIO_PJ3_CCP6 0x00080c0a + +// +// GPIO pin J4 +// +#define GPIO_PJ4_EPI0S28 0x00081008 +#define GPIO_PJ4_U1DCD 0x00081009 +#define GPIO_PJ4_CCP4 0x0008100a + +// +// GPIO pin J5 +// +#define GPIO_PJ5_EPI0S29 0x00081408 +#define GPIO_PJ5_U1DSR 0x00081409 +#define GPIO_PJ5_CCP2 0x0008140a + +// +// GPIO pin J6 +// +#define GPIO_PJ6_EPI0S30 0x00081808 +#define GPIO_PJ6_U1RTS 0x00081809 +#define GPIO_PJ6_CCP1 0x0008180a + +// +// GPIO pin J7 +// +#define GPIO_PJ7_U1DTR 0x00081c09 +#define GPIO_PJ7_CCP0 0x00081c0a + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern void GPIODirModeSet(unsigned long ulPort, unsigned char ucPins, + unsigned long ulPinIO); +extern unsigned long GPIODirModeGet(unsigned long ulPort, unsigned char ucPin); +extern void GPIOIntTypeSet(unsigned long ulPort, unsigned char ucPins, + unsigned long ulIntType); +extern unsigned long GPIOIntTypeGet(unsigned long ulPort, unsigned char ucPin); +extern void GPIOPadConfigSet(unsigned long ulPort, unsigned char ucPins, + unsigned long ulStrength, + unsigned long ulPadType); +extern void GPIOPadConfigGet(unsigned long ulPort, unsigned char ucPin, + unsigned long *pulStrength, + unsigned long *pulPadType); +extern void GPIOPinIntEnable(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinIntDisable(unsigned long ulPort, unsigned char ucPins); +extern long GPIOPinIntStatus(unsigned long ulPort, tBoolean bMasked); +extern void GPIOPinIntClear(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPortIntRegister(unsigned long ulPort, + void (*pfnIntHandler)(void)); +extern void GPIOPortIntUnregister(unsigned long ulPort); +extern long GPIOPinRead(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinWrite(unsigned long ulPort, unsigned char ucPins, + unsigned char ucVal); +extern void GPIOPinConfigure(unsigned long ulPinConfig); +extern void GPIOPinTypeADC(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeCAN(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeComparator(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeEPI(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeEthernetLED(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeGPIOInput(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeGPIOOutput(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeGPIOOutputOD(unsigned long ulPort, + unsigned char ucPins); +extern void GPIOPinTypeI2C(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeI2S(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypePWM(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeQEI(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeSSI(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeTimer(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeUART(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeUSBAnalog(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeUSBDigital(unsigned long ulPort, unsigned char ucPins); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __GPIO_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/interrupt.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/interrupt.c new file mode 100644 index 00000000..6f588ad7 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/interrupt.c @@ -0,0 +1,723 @@ +//***************************************************************************** +// +// interrupt.c - Driver for the NVIC Interrupt Controller. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup interrupt_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_ints.h" +#include "inc/hw_nvic.h" +#include "inc/hw_types.h" +#include "driverlib/cpulib.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" + +//***************************************************************************** +// +// This is a mapping between priority grouping encodings and the number of +// preemption priority bits. +// +//***************************************************************************** +static const unsigned long g_pulPriority[] = +{ + NVIC_APINT_PRIGROUP_0_8, NVIC_APINT_PRIGROUP_1_7, NVIC_APINT_PRIGROUP_2_6, + NVIC_APINT_PRIGROUP_3_5, NVIC_APINT_PRIGROUP_4_4, NVIC_APINT_PRIGROUP_5_3, + NVIC_APINT_PRIGROUP_6_2, NVIC_APINT_PRIGROUP_7_1 +}; + +//***************************************************************************** +// +// This is a mapping between interrupt number and the register that contains +// the priority encoding for that interrupt. +// +//***************************************************************************** +static const unsigned long g_pulRegs[] = +{ + 0, NVIC_SYS_PRI1, NVIC_SYS_PRI2, NVIC_SYS_PRI3, NVIC_PRI0, NVIC_PRI1, + NVIC_PRI2, NVIC_PRI3, NVIC_PRI4, NVIC_PRI5, NVIC_PRI6, NVIC_PRI7, + NVIC_PRI8, NVIC_PRI9, NVIC_PRI10, NVIC_PRI11, NVIC_PRI12, NVIC_PRI13 +}; + +//***************************************************************************** +// +//! \internal +//! The default interrupt handler. +//! +//! This is the default interrupt handler for all interrupts. It simply loops +//! forever so that the system state is preserved for observation by a +//! debugger. Since interrupts should be disabled before unregistering the +//! corresponding handler, this should never be called. +//! +//! \return None. +// +//***************************************************************************** +static void +IntDefaultHandler(void) +{ + // + // Go into an infinite loop. + // + while(1) + { + } +} + +//***************************************************************************** +// +// The processor vector table. +// +// This contains a list of the handlers for the various interrupt sources in +// the system. The layout of this list is defined by the hardware; assertion +// of an interrupt causes the processor to start executing directly at the +// address given in the corresponding location in this list. +// +//***************************************************************************** +#if defined(ewarm) +static __no_init void (*g_pfnRAMVectors[NUM_INTERRUPTS])(void) @ "VTABLE"; +#elif defined(sourcerygxx) +static __attribute__((section(".cs3.region-head.ram"))) +void (*g_pfnRAMVectors[NUM_INTERRUPTS])(void); +#elif defined(ccs) +#pragma DATA_SECTION(g_pfnRAMVectors, ".vtable") +void (*g_pfnRAMVectors[NUM_INTERRUPTS])(void); +#else +static __attribute__((section("vtable"))) +void (*g_pfnRAMVectors[NUM_INTERRUPTS])(void); +#endif + +//***************************************************************************** +// +//! Enables the processor interrupt. +//! +//! Allows the processor to respond to interrupts. This does not affect the +//! set of interrupts enabled in the interrupt controller; it just gates the +//! single interrupt from the controller to the processor. +//! +//! \note Previously, this function had no return value. As such, it was +//! possible to include interrupt.h and call this function without +//! having included hw_types.h. Now that the return is a +//! tBoolean, a compiler error will occur in this case. The solution +//! is to include hw_types.h before including interrupt.h. +//! +//! \return Returns \b true if interrupts were disabled when the function was +//! called or \b false if they were initially enabled. +// +//***************************************************************************** +tBoolean +IntMasterEnable(void) +{ + // + // Enable processor interrupts. + // + return(CPUcpsie()); +} + +//***************************************************************************** +// +//! Disables the processor interrupt. +//! +//! Prevents the processor from receiving interrupts. This does not affect the +//! set of interrupts enabled in the interrupt controller; it just gates the +//! single interrupt from the controller to the processor. +//! +//! \note Previously, this function had no return value. As such, it was +//! possible to include interrupt.h and call this function without +//! having included hw_types.h. Now that the return is a +//! tBoolean, a compiler error will occur in this case. The solution +//! is to include hw_types.h before including interrupt.h. +//! +//! \return Returns \b true if interrupts were already disabled when the +//! function was called or \b false if they were initially enabled. +// +//***************************************************************************** +tBoolean +IntMasterDisable(void) +{ + // + // Disable processor interrupts. + // + return(CPUcpsid()); +} + +//***************************************************************************** +// +//! Registers a function to be called when an interrupt occurs. +//! +//! \param ulInterrupt specifies the interrupt in question. +//! \param pfnHandler is a pointer to the function to be called. +//! +//! This function is used to specify the handler function to be called when the +//! given interrupt is asserted to the processor. When the interrupt occurs, +//! if it is enabled (via IntEnable()), the handler function will be called in +//! interrupt context. Since the handler function can preempt other code, care +//! must be taken to protect memory or peripherals that are accessed by the +//! handler and other non-handler code. +//! +//! \note The use of this function (directly or indirectly via a peripheral +//! driver interrupt register function) moves the interrupt vector table from +//! flash to SRAM. Therefore, care must be taken when linking the application +//! to ensure that the SRAM vector table is located at the beginning of SRAM; +//! otherwise NVIC will not look in the correct portion of memory for the +//! vector table (it requires the vector table be on a 1 kB memory alignment). +//! Normally, the SRAM vector table is so placed via the use of linker scripts. +//! See the discussion of compile-time versus run-time interrupt handler +//! registration in the introduction to this chapter. +//! +//! \return None. +// +//***************************************************************************** +void +IntRegister(unsigned long ulInterrupt, void (*pfnHandler)(void)) +{ + unsigned long ulIdx, ulValue; + + // + // Check the arguments. + // + ASSERT(ulInterrupt < NUM_INTERRUPTS); + + // + // Make sure that the RAM vector table is correctly aligned. + // + ASSERT(((unsigned long)g_pfnRAMVectors & 0x000003ff) == 0); + + // + // See if the RAM vector table has been initialized. + // + if(HWREG(NVIC_VTABLE) != (unsigned long)g_pfnRAMVectors) + { + // + // Copy the vector table from the beginning of FLASH to the RAM vector + // table. + // + ulValue = HWREG(NVIC_VTABLE); + for(ulIdx = 0; ulIdx < NUM_INTERRUPTS; ulIdx++) + { + g_pfnRAMVectors[ulIdx] = (void (*)(void))HWREG((ulIdx * 4) + + ulValue); + } + + // + // Point NVIC at the RAM vector table. + // + HWREG(NVIC_VTABLE) = (unsigned long)g_pfnRAMVectors; + } + + // + // Save the interrupt handler. + // + g_pfnRAMVectors[ulInterrupt] = pfnHandler; +} + +//***************************************************************************** +// +//! Unregisters the function to be called when an interrupt occurs. +//! +//! \param ulInterrupt specifies the interrupt in question. +//! +//! This function is used to indicate that no handler should be called when the +//! given interrupt is asserted to the processor. The interrupt source will be +//! automatically disabled (via IntDisable()) if necessary. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +IntUnregister(unsigned long ulInterrupt) +{ + // + // Check the arguments. + // + ASSERT(ulInterrupt < NUM_INTERRUPTS); + + // + // Reset the interrupt handler. + // + g_pfnRAMVectors[ulInterrupt] = IntDefaultHandler; +} + +//***************************************************************************** +// +//! Sets the priority grouping of the interrupt controller. +//! +//! \param ulBits specifies the number of bits of preemptable priority. +//! +//! This function specifies the split between preemptable priority levels and +//! subpriority levels in the interrupt priority specification. The range of +//! the grouping values are dependent upon the hardware implementation; on +//! the Stellaris family, three bits are available for hardware interrupt +//! prioritization and therefore priority grouping values of three through +//! seven have the same effect. +//! +//! \return None. +// +//***************************************************************************** +void +IntPriorityGroupingSet(unsigned long ulBits) +{ + // + // Check the arguments. + // + ASSERT(ulBits < NUM_PRIORITY); + + // + // Set the priority grouping. + // + HWREG(NVIC_APINT) = NVIC_APINT_VECTKEY | g_pulPriority[ulBits]; +} + +//***************************************************************************** +// +//! Gets the priority grouping of the interrupt controller. +//! +//! This function returns the split between preemptable priority levels and +//! subpriority levels in the interrupt priority specification. +//! +//! \return The number of bits of preemptable priority. +// +//***************************************************************************** +unsigned long +IntPriorityGroupingGet(void) +{ + unsigned long ulLoop, ulValue; + + // + // Read the priority grouping. + // + ulValue = HWREG(NVIC_APINT) & NVIC_APINT_PRIGROUP_M; + + // + // Loop through the priority grouping values. + // + for(ulLoop = 0; ulLoop < NUM_PRIORITY; ulLoop++) + { + // + // Stop looping if this value matches. + // + if(ulValue == g_pulPriority[ulLoop]) + { + break; + } + } + + // + // Return the number of priority bits. + // + return(ulLoop); +} + +//***************************************************************************** +// +//! Sets the priority of an interrupt. +//! +//! \param ulInterrupt specifies the interrupt in question. +//! \param ucPriority specifies the priority of the interrupt. +//! +//! This function is used to set the priority of an interrupt. When multiple +//! interrupts are asserted simultaneously, the ones with the highest priority +//! are processed before the lower priority interrupts. Smaller numbers +//! correspond to higher interrupt priorities; priority 0 is the highest +//! interrupt priority. +//! +//! The hardware priority mechanism will only look at the upper N bits of the +//! priority level (where N is 3 for the Stellaris family), so any +//! prioritization must be performed in those bits. The remaining bits can be +//! used to sub-prioritize the interrupt sources, and may be used by the +//! hardware priority mechanism on a future part. This arrangement allows +//! priorities to migrate to different NVIC implementations without changing +//! the gross prioritization of the interrupts. +//! +//! \return None. +// +//***************************************************************************** +void +IntPrioritySet(unsigned long ulInterrupt, unsigned char ucPriority) +{ + unsigned long ulTemp; + + // + // Check the arguments. + // + ASSERT((ulInterrupt >= 4) && (ulInterrupt < NUM_INTERRUPTS)); + + // + // Set the interrupt priority. + // + ulTemp = HWREG(g_pulRegs[ulInterrupt >> 2]); + ulTemp &= ~(0xFF << (8 * (ulInterrupt & 3))); + ulTemp |= ucPriority << (8 * (ulInterrupt & 3)); + HWREG(g_pulRegs[ulInterrupt >> 2]) = ulTemp; +} + +//***************************************************************************** +// +//! Gets the priority of an interrupt. +//! +//! \param ulInterrupt specifies the interrupt in question. +//! +//! This function gets the priority of an interrupt. See IntPrioritySet() for +//! a definition of the priority value. +//! +//! \return Returns the interrupt priority, or -1 if an invalid interrupt was +//! specified. +// +//***************************************************************************** +long +IntPriorityGet(unsigned long ulInterrupt) +{ + // + // Check the arguments. + // + ASSERT((ulInterrupt >= 4) && (ulInterrupt < NUM_INTERRUPTS)); + + // + // Return the interrupt priority. + // + return((HWREG(g_pulRegs[ulInterrupt >> 2]) >> (8 * (ulInterrupt & 3))) & + 0xFF); +} + +//***************************************************************************** +// +//! Enables an interrupt. +//! +//! \param ulInterrupt specifies the interrupt to be enabled. +//! +//! The specified interrupt is enabled in the interrupt controller. Other +//! enables for the interrupt (such as at the peripheral level) are unaffected +//! by this function. +//! +//! \return None. +// +//***************************************************************************** +void +IntEnable(unsigned long ulInterrupt) +{ + // + // Check the arguments. + // + ASSERT(ulInterrupt < NUM_INTERRUPTS); + + // + // Determine the interrupt to enable. + // + if(ulInterrupt == FAULT_MPU) + { + // + // Enable the MemManage interrupt. + // + HWREG(NVIC_SYS_HND_CTRL) |= NVIC_SYS_HND_CTRL_MEM; + } + else if(ulInterrupt == FAULT_BUS) + { + // + // Enable the bus fault interrupt. + // + HWREG(NVIC_SYS_HND_CTRL) |= NVIC_SYS_HND_CTRL_BUS; + } + else if(ulInterrupt == FAULT_USAGE) + { + // + // Enable the usage fault interrupt. + // + HWREG(NVIC_SYS_HND_CTRL) |= NVIC_SYS_HND_CTRL_USAGE; + } + else if(ulInterrupt == FAULT_SYSTICK) + { + // + // Enable the System Tick interrupt. + // + HWREG(NVIC_ST_CTRL) |= NVIC_ST_CTRL_INTEN; + } + else if((ulInterrupt >= 16) && (ulInterrupt <= 47)) + { + // + // Enable the general interrupt. + // + HWREG(NVIC_EN0) = 1 << (ulInterrupt - 16); + } + else if(ulInterrupt >= 48) + { + // + // Enable the general interrupt. + // + HWREG(NVIC_EN1) = 1 << (ulInterrupt - 48); + } +} + +//***************************************************************************** +// +//! Disables an interrupt. +//! +//! \param ulInterrupt specifies the interrupt to be disabled. +//! +//! The specified interrupt is disabled in the interrupt controller. Other +//! enables for the interrupt (such as at the peripheral level) are unaffected +//! by this function. +//! +//! \return None. +// +//***************************************************************************** +void +IntDisable(unsigned long ulInterrupt) +{ + // + // Check the arguments. + // + ASSERT(ulInterrupt < NUM_INTERRUPTS); + + // + // Determine the interrupt to disable. + // + if(ulInterrupt == FAULT_MPU) + { + // + // Disable the MemManage interrupt. + // + HWREG(NVIC_SYS_HND_CTRL) &= ~(NVIC_SYS_HND_CTRL_MEM); + } + else if(ulInterrupt == FAULT_BUS) + { + // + // Disable the bus fault interrupt. + // + HWREG(NVIC_SYS_HND_CTRL) &= ~(NVIC_SYS_HND_CTRL_BUS); + } + else if(ulInterrupt == FAULT_USAGE) + { + // + // Disable the usage fault interrupt. + // + HWREG(NVIC_SYS_HND_CTRL) &= ~(NVIC_SYS_HND_CTRL_USAGE); + } + else if(ulInterrupt == FAULT_SYSTICK) + { + // + // Disable the System Tick interrupt. + // + HWREG(NVIC_ST_CTRL) &= ~(NVIC_ST_CTRL_INTEN); + } + else if((ulInterrupt >= 16) && (ulInterrupt <= 47)) + { + // + // Disable the general interrupt. + // + HWREG(NVIC_DIS0) = 1 << (ulInterrupt - 16); + } + else if(ulInterrupt >= 48) + { + // + // Disable the general interrupt. + // + HWREG(NVIC_DIS1) = 1 << (ulInterrupt - 48); + } +} + +//***************************************************************************** +// +//! Pends an interrupt. +//! +//! \param ulInterrupt specifies the interrupt to be pended. +//! +//! The specified interrupt is pended in the interrupt controller. This will +//! cause the interrupt controller to execute the corresponding interrupt +//! handler at the next available time, based on the current interrupt state +//! priorities. For example, if called by a higher priority interrupt handler, +//! the specified interrupt handler will not be called until after the current +//! interrupt handler has completed execution. The interrupt must have been +//! enabled for it to be called. +//! +//! \return None. +// +//***************************************************************************** +void +IntPendSet(unsigned long ulInterrupt) +{ + // + // Check the arguments. + // + ASSERT(ulInterrupt < NUM_INTERRUPTS); + + // + // Determine the interrupt to pend. + // + if(ulInterrupt == FAULT_NMI) + { + // + // Pend the NMI interrupt. + // + HWREG(NVIC_INT_CTRL) |= NVIC_INT_CTRL_NMI_SET; + } + else if(ulInterrupt == FAULT_PENDSV) + { + // + // Pend the PendSV interrupt. + // + HWREG(NVIC_INT_CTRL) |= NVIC_INT_CTRL_PEND_SV; + } + else if(ulInterrupt == FAULT_SYSTICK) + { + // + // Pend the SysTick interrupt. + // + HWREG(NVIC_INT_CTRL) |= NVIC_INT_CTRL_PENDSTSET; + } + else if((ulInterrupt >= 16) && (ulInterrupt <= 47)) + { + // + // Pend the general interrupt. + // + HWREG(NVIC_PEND0) = 1 << (ulInterrupt - 16); + } + else if(ulInterrupt >= 48) + { + // + // Pend the general interrupt. + // + HWREG(NVIC_PEND1) = 1 << (ulInterrupt - 48); + } +} + +//***************************************************************************** +// +//! Unpends an interrupt. +//! +//! \param ulInterrupt specifies the interrupt to be unpended. +//! +//! The specified interrupt is unpended in the interrupt controller. This will +//! cause any previously generated interrupts that have not been handled yet +//! (due to higher priority interrupts or the interrupt no having been enabled +//! yet) to be discarded. +//! +//! \return None. +// +//***************************************************************************** +void +IntPendClear(unsigned long ulInterrupt) +{ + // + // Check the arguments. + // + ASSERT(ulInterrupt < NUM_INTERRUPTS); + + // + // Determine the interrupt to unpend. + // + if(ulInterrupt == FAULT_PENDSV) + { + // + // Unpend the PendSV interrupt. + // + HWREG(NVIC_INT_CTRL) |= NVIC_INT_CTRL_UNPEND_SV; + } + else if(ulInterrupt == FAULT_SYSTICK) + { + // + // Unpend the SysTick interrupt. + // + HWREG(NVIC_INT_CTRL) |= NVIC_INT_CTRL_PENDSTCLR; + } + else if((ulInterrupt >= 16) && (ulInterrupt <= 47)) + { + // + // Unpend the general interrupt. + // + HWREG(NVIC_UNPEND0) = 1 << (ulInterrupt - 16); + } + else if(ulInterrupt >= 48) + { + // + // Unpend the general interrupt. + // + HWREG(NVIC_UNPEND1) = 1 << (ulInterrupt - 48); + } +} + +//***************************************************************************** +// +//! Sets the priority masking level +//! +//! \param ulPriorityMask is the priority level that will be masked. +//! +//! This function sets the interrupt priority masking level so that all +//! interrupts at the specified or lesser priority level is masked. This +//! can be used to globally disable a set of interrupts with priority below +//! a predetermined threshold. A value of 0 disables priority +//! masking. +//! +//! Smaller numbers correspond to higher interrupt priorities. So for example +//! a priority level mask of 4 will allow interrupts of priority level 0-3, +//! and interrupts with a numerical priority of 4 and greater will be blocked. +//! +//! The hardware priority mechanism will only look at the upper N bits of the +//! priority level (where N is 3 for the Stellaris family), so any +//! prioritization must be performed in those bits. +//! +//! \return None. +// +//***************************************************************************** +void +IntPriorityMaskSet(unsigned long ulPriorityMask) +{ + CPUbasepriSet(ulPriorityMask); +} + +//***************************************************************************** +// +//! Gets the priority masking level +//! +//! This function gets the current setting of the interrupt priority masking +//! level. The value returned is the priority level such that all interrupts +//! of that and lesser priority are masked. A value of 0 means that priority +//! masking is disabled. +//! +//! Smaller numbers correspond to higher interrupt priorities. So for example +//! a priority level mask of 4 will allow interrupts of priority level 0-3, +//! and interrupts with a numerical priority of 4 and greater will be blocked. +//! +//! The hardware priority mechanism will only look at the upper N bits of the +//! priority level (where N is 3 for the Stellaris family), so any +//! prioritization must be performed in those bits. +//! +//! \return Returns the value of the interrupt priority level mask. +// +//***************************************************************************** +unsigned long +IntPriorityMaskGet(void) +{ + return(CPUbasepriGet()); +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/interrupt.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/interrupt.h new file mode 100644 index 00000000..954f5775 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/interrupt.h @@ -0,0 +1,77 @@ +//***************************************************************************** +// +// interrupt.h - Prototypes for the NVIC Interrupt Controller Driver. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __INTERRUPT_H__ +#define __INTERRUPT_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Macro to generate an interrupt priority mask based on the number of bits +// of priority supported by the hardware. +// +//***************************************************************************** +#define INT_PRIORITY_MASK ((0xFF << (8 - NUM_PRIORITY_BITS)) & 0xFF) + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern tBoolean IntMasterEnable(void); +extern tBoolean IntMasterDisable(void); +extern void IntRegister(unsigned long ulInterrupt, void (*pfnHandler)(void)); +extern void IntUnregister(unsigned long ulInterrupt); +extern void IntPriorityGroupingSet(unsigned long ulBits); +extern unsigned long IntPriorityGroupingGet(void); +extern void IntPrioritySet(unsigned long ulInterrupt, + unsigned char ucPriority); +extern long IntPriorityGet(unsigned long ulInterrupt); +extern void IntEnable(unsigned long ulInterrupt); +extern void IntDisable(unsigned long ulInterrupt); +extern void IntPendSet(unsigned long ulInterrupt); +extern void IntPendClear(unsigned long ulInterrupt); +extern void IntPriorityMaskSet(unsigned long ulPriorityMask); +extern unsigned long IntPriorityMaskGet(void); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __INTERRUPT_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/sysctl.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/sysctl.c new file mode 100644 index 00000000..0ac2747d --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/sysctl.c @@ -0,0 +1,2366 @@ +//***************************************************************************** +// +// sysctl.c - Driver for the system controller. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup sysctl_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_ints.h" +#include "inc/hw_nvic.h" +#include "inc/hw_sysctl.h" +#include "inc/hw_types.h" +#include "driverlib/cpulib.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" +#include "driverlib/sysctl.h" + +//***************************************************************************** +// +// This macro extracts the array index out of the peripheral number. +// +//***************************************************************************** +#define SYSCTL_PERIPH_INDEX(a) (((a) >> 28) & 0xf) + +//***************************************************************************** +// +// This macro constructs the peripheral bit mask from the peripheral number. +// +//***************************************************************************** +#define SYSCTL_PERIPH_MASK(a) (((a) & 0xffff) << (((a) & 0x001f0000) >> 16)) + +//***************************************************************************** +// +// An array that maps the "peripheral set" number (which is stored in the upper +// nibble of the SYSCTL_PERIPH_* defines) to the SYSCTL DC? register that +// contains the peripheral present bit for that peripheral. +// +//***************************************************************************** +static const unsigned long g_pulDCRegs[] = +{ + SYSCTL_DC1, + SYSCTL_DC2, + SYSCTL_DC4, + SYSCTL_DC1 +}; + +//***************************************************************************** +// +// An array that maps the "peripheral set" number (which is stored in the upper +// nibble of the SYSCTL_PERIPH_* defines) to the SYSCTL_SRCR? register that +// controls the software reset for that peripheral. +// +//***************************************************************************** +static const unsigned long g_pulSRCRRegs[] = +{ + SYSCTL_SRCR0, + SYSCTL_SRCR1, + SYSCTL_SRCR2 +}; + +//***************************************************************************** +// +// An array that maps the "peripheral set" number (which is stored in the upper +// nibble of the SYSCTL_PERIPH_* defines) to the SYSCTL_RCGC? register that +// controls the run-mode enable for that peripheral. +// +//***************************************************************************** +static const unsigned long g_pulRCGCRegs[] = +{ + SYSCTL_RCGC0, + SYSCTL_RCGC1, + SYSCTL_RCGC2 +}; + +//***************************************************************************** +// +// An array that maps the "peripheral set" number (which is stored in the upper +// nibble of the SYSCTL_PERIPH_* defines) to the SYSCTL_SCGC? register that +// controls the sleep-mode enable for that peripheral. +// +//***************************************************************************** +static const unsigned long g_pulSCGCRegs[] = +{ + SYSCTL_SCGC0, + SYSCTL_SCGC1, + SYSCTL_SCGC2 +}; + +//***************************************************************************** +// +// An array that maps the "peripheral set" number (which is stored in the upper +// nibble of the SYSCTL_PERIPH_* defines) to the SYSCTL_DCGC? register that +// controls the deep-sleep-mode enable for that peripheral. +// +//***************************************************************************** +static const unsigned long g_pulDCGCRegs[] = +{ + SYSCTL_DCGC0, + SYSCTL_DCGC1, + SYSCTL_DCGC2 +}; + +//***************************************************************************** +// +// An array that maps the crystal number in RCC to a frequency. +// +//***************************************************************************** +static const unsigned long g_pulXtals[] = +{ + 1000000, + 1843200, + 2000000, + 2457600, + 3579545, + 3686400, + 4000000, + 4096000, + 4915200, + 5000000, + 5120000, + 6000000, + 6144000, + 7372800, + 8000000, + 8192000, + 10000000, + 12000000, + 12288000, + 13560000, + 14318180, + 16000000, + 16384000 +}; + +//***************************************************************************** +// +//! \internal +//! Checks a peripheral identifier. +//! +//! \param ulPeripheral is the peripheral identifier. +//! +//! This function determines if a peripheral identifier is valid. +//! +//! \return Returns \b true if the peripheral identifier is valid and \b false +//! otherwise. +// +//***************************************************************************** +#ifdef DEBUG +static tBoolean +SysCtlPeripheralValid(unsigned long ulPeripheral) +{ + return((ulPeripheral == SYSCTL_PERIPH_ADC0) || + (ulPeripheral == SYSCTL_PERIPH_ADC1) || + (ulPeripheral == SYSCTL_PERIPH_CAN0) || + (ulPeripheral == SYSCTL_PERIPH_CAN1) || + (ulPeripheral == SYSCTL_PERIPH_CAN2) || + (ulPeripheral == SYSCTL_PERIPH_COMP0) || + (ulPeripheral == SYSCTL_PERIPH_COMP1) || + (ulPeripheral == SYSCTL_PERIPH_COMP2) || + (ulPeripheral == SYSCTL_PERIPH_EPI0) || + (ulPeripheral == SYSCTL_PERIPH_ETH) || + (ulPeripheral == SYSCTL_PERIPH_GPIOA) || + (ulPeripheral == SYSCTL_PERIPH_GPIOB) || + (ulPeripheral == SYSCTL_PERIPH_GPIOC) || + (ulPeripheral == SYSCTL_PERIPH_GPIOD) || + (ulPeripheral == SYSCTL_PERIPH_GPIOE) || + (ulPeripheral == SYSCTL_PERIPH_GPIOF) || + (ulPeripheral == SYSCTL_PERIPH_GPIOG) || + (ulPeripheral == SYSCTL_PERIPH_GPIOH) || + (ulPeripheral == SYSCTL_PERIPH_GPIOJ) || + (ulPeripheral == SYSCTL_PERIPH_HIBERNATE) || + (ulPeripheral == SYSCTL_PERIPH_I2C0) || + (ulPeripheral == SYSCTL_PERIPH_I2C1) || + (ulPeripheral == SYSCTL_PERIPH_I2S0) || + (ulPeripheral == SYSCTL_PERIPH_IEEE1588) || + (ulPeripheral == SYSCTL_PERIPH_MPU) || + (ulPeripheral == SYSCTL_PERIPH_PLL) || + (ulPeripheral == SYSCTL_PERIPH_PWM) || + (ulPeripheral == SYSCTL_PERIPH_QEI0) || + (ulPeripheral == SYSCTL_PERIPH_QEI1) || + (ulPeripheral == SYSCTL_PERIPH_SSI0) || + (ulPeripheral == SYSCTL_PERIPH_SSI1) || + (ulPeripheral == SYSCTL_PERIPH_TEMP) || + (ulPeripheral == SYSCTL_PERIPH_TIMER0) || + (ulPeripheral == SYSCTL_PERIPH_TIMER1) || + (ulPeripheral == SYSCTL_PERIPH_TIMER2) || + (ulPeripheral == SYSCTL_PERIPH_TIMER3) || + (ulPeripheral == SYSCTL_PERIPH_UART0) || + (ulPeripheral == SYSCTL_PERIPH_UART1) || + (ulPeripheral == SYSCTL_PERIPH_UART2) || + (ulPeripheral == SYSCTL_PERIPH_UDMA) || + (ulPeripheral == SYSCTL_PERIPH_USB0) || + (ulPeripheral == SYSCTL_PERIPH_WDOG0) || + (ulPeripheral == SYSCTL_PERIPH_WDOG1)); +} +#endif + +//***************************************************************************** +// +//! Gets the size of the SRAM. +//! +//! This function determines the size of the SRAM on the Stellaris device. +//! +//! \return The total number of bytes of SRAM. +// +//***************************************************************************** +unsigned long +SysCtlSRAMSizeGet(void) +{ + // + // Compute the size of the SRAM. + // + return(((HWREG(SYSCTL_DC0) & SYSCTL_DC0_SRAMSZ_M) >> 8) + 0x100); +} + +//***************************************************************************** +// +//! Gets the size of the flash. +//! +//! This function determines the size of the flash on the Stellaris device. +//! +//! \return The total number of bytes of flash. +// +//***************************************************************************** +unsigned long +SysCtlFlashSizeGet(void) +{ + // + // Compute the size of the flash. + // + return(((HWREG(SYSCTL_DC0) & SYSCTL_DC0_FLASHSZ_M) << 11) + 0x800); +} + +//***************************************************************************** +// +//! Determines if a pin is present. +//! +//! \param ulPin is the pin in question. +//! +//! Determines if a particular pin is present in the device. The PWM, analog +//! comparators, ADC, and timers have a varying number of pins across members +//! of the Stellaris family; this will determine which are present on this +//! device. +//! +//! The \e ulPin argument must be only one of the following values: +//! \b SYSCTL_PIN_PWM0, \b SYSCTL_PIN_PWM1, \b SYSCTL_PIN_PWM2, +//! \b SYSCTL_PIN_PWM3, \b SYSCTL_PIN_PWM4, \b SYSCTL_PIN_PWM5, +//! \b SYSCTL_PIN_C0MINUS, \b SYSCTL_PIN_C0PLUS, \b SYSCTL_PIN_C0O, +//! \b SYSCTL_PIN_C1MINUS, \b SYSCTL_PIN_C1PLUS, \b SYSCTL_PIN_C1O, +//! \b SYSCTL_PIN_C2MINUS, \b SYSCTL_PIN_C2PLUS, \b SYSCTL_PIN_C2O, +//! \b SYSCTL_PIN_ADC0, \b SYSCTL_PIN_ADC1, \b SYSCTL_PIN_ADC2, +//! \b SYSCTL_PIN_ADC3, \b SYSCTL_PIN_ADC4, \b SYSCTL_PIN_ADC5, +//! \b SYSCTL_PIN_ADC6, \b SYSCTL_PIN_ADC7, \b SYSCTL_PIN_CCP0, +//! \b SYSCTL_PIN_CCP1, \b SYSCTL_PIN_CCP2, \b SYSCTL_PIN_CCP3, +//! \b SYSCTL_PIN_CCP4, \b SYSCTL_PIN_CCP5, \b SYSCTL_PIN_CCP6, +//! \b SYSCTL_PIN_CCP7, \b SYSCTL_PIN_32KHZ, or \b SYSCTL_PIN_MC_FAULT0. +//! +//! \return Returns \b true if the specified pin is present and \b false if it +//! is not. +// +//***************************************************************************** +tBoolean +SysCtlPinPresent(unsigned long ulPin) +{ + // + // Check the arguments. + // + ASSERT((ulPin == SYSCTL_PIN_PWM0) || + (ulPin == SYSCTL_PIN_PWM1) || + (ulPin == SYSCTL_PIN_PWM2) || + (ulPin == SYSCTL_PIN_PWM3) || + (ulPin == SYSCTL_PIN_PWM4) || + (ulPin == SYSCTL_PIN_PWM5) || + (ulPin == SYSCTL_PIN_C0MINUS) || + (ulPin == SYSCTL_PIN_C0PLUS) || + (ulPin == SYSCTL_PIN_C0O) || + (ulPin == SYSCTL_PIN_C1MINUS) || + (ulPin == SYSCTL_PIN_C1PLUS) || + (ulPin == SYSCTL_PIN_C1O) || + (ulPin == SYSCTL_PIN_C2MINUS) || + (ulPin == SYSCTL_PIN_C2PLUS) || + (ulPin == SYSCTL_PIN_C2O) || + (ulPin == SYSCTL_PIN_MC_FAULT0) || + (ulPin == SYSCTL_PIN_ADC0) || + (ulPin == SYSCTL_PIN_ADC1) || + (ulPin == SYSCTL_PIN_ADC2) || + (ulPin == SYSCTL_PIN_ADC3) || + (ulPin == SYSCTL_PIN_ADC4) || + (ulPin == SYSCTL_PIN_ADC5) || + (ulPin == SYSCTL_PIN_ADC6) || + (ulPin == SYSCTL_PIN_ADC7) || + (ulPin == SYSCTL_PIN_CCP0) || + (ulPin == SYSCTL_PIN_CCP1) || + (ulPin == SYSCTL_PIN_CCP2) || + (ulPin == SYSCTL_PIN_CCP3) || + (ulPin == SYSCTL_PIN_CCP4) || + (ulPin == SYSCTL_PIN_CCP5) || + (ulPin == SYSCTL_PIN_32KHZ)); + + // + // Determine if this pin is present. + // + if(HWREG(SYSCTL_DC3) & ulPin) + { + return(true); + } + else + { + return(false); + } +} + +//***************************************************************************** +// +//! Determines if a peripheral is present. +//! +//! \param ulPeripheral is the peripheral in question. +//! +//! Determines if a particular peripheral is present in the device. Each +//! member of the Stellaris family has a different peripheral set; this will +//! determine which are present on this device. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_IEEE1588, +//! \b SYSCTL_PERIPH_MPU, \b SYSCTL_PERIPH_PLL, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \return Returns \b true if the specified peripheral is present and \b false +//! if it is not. +// +//***************************************************************************** +tBoolean +SysCtlPeripheralPresent(unsigned long ulPeripheral) +{ + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Read the correct DC register and determine if this peripheral exists. + // + if(ulPeripheral == SYSCTL_PERIPH_USB0) + { + // + // USB is a special case since the DC bit is missing for USB0. + // + if(HWREG(SYSCTL_DC6) & SYSCTL_DC6_USB0_M) + { + return(true); + } + else + { + return(false); + } + } + else if(HWREG(g_pulDCRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) & + SYSCTL_PERIPH_MASK(ulPeripheral)) + { + return(true); + } + else + { + return(false); + } +} + +//***************************************************************************** +// +//! Performs a software reset of a peripheral. +//! +//! \param ulPeripheral is the peripheral to reset. +//! +//! This function performs a software reset of the specified peripheral. An +//! individual peripheral reset signal is asserted for a brief period and then +//! deasserted, returning the internal state of the peripheral to its reset +//! condition. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralReset(unsigned long ulPeripheral) +{ + volatile unsigned long ulDelay; + + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Put the peripheral into the reset state. + // + HWREG(g_pulSRCRRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) |= + SYSCTL_PERIPH_MASK(ulPeripheral); + + // + // Delay for a little bit. + // + for(ulDelay = 0; ulDelay < 16; ulDelay++) + { + } + + // + // Take the peripheral out of the reset state. + // + HWREG(g_pulSRCRRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) &= + ~SYSCTL_PERIPH_MASK(ulPeripheral); +} + +//***************************************************************************** +// +//! Enables a peripheral. +//! +//! \param ulPeripheral is the peripheral to enable. +//! +//! Peripherals are enabled with this function. At power-up, all peripherals +//! are disabled; they must be enabled in order to operate or respond to +//! register reads/writes. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \note It takes five clock cycles after the write to enable a peripheral +//! before the the peripheral is actually enabled. During this time, attempts +//! to access the peripheral will result in a bus fault. Care should be taken +//! to ensure that the peripheral is not accessed during this brief time +//! period. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralEnable(unsigned long ulPeripheral) +{ + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Enable this peripheral. + // + HWREG(g_pulRCGCRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) |= + SYSCTL_PERIPH_MASK(ulPeripheral); +} + +//***************************************************************************** +// +//! Disables a peripheral. +//! +//! \param ulPeripheral is the peripheral to disable. +//! +//! Peripherals are disabled with this function. Once disabled, they will not +//! operate or respond to register reads/writes. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralDisable(unsigned long ulPeripheral) +{ + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Disable this peripheral. + // + HWREG(g_pulRCGCRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) &= + ~SYSCTL_PERIPH_MASK(ulPeripheral); +} + +//***************************************************************************** +// +//! Enables a peripheral in sleep mode. +//! +//! \param ulPeripheral is the peripheral to enable in sleep mode. +//! +//! This function allows a peripheral to continue operating when the processor +//! goes into sleep mode. Since the clocking configuration of the device does +//! not change, any peripheral can safely continue operating while the +//! processor is in sleep mode, and can therefore wake the processor from sleep +//! mode. +//! +//! Sleep mode clocking of peripherals must be enabled via +//! SysCtlPeripheralClockGating(); if disabled, the peripheral sleep mode +//! configuration is maintained but has no effect when sleep mode is entered. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralSleepEnable(unsigned long ulPeripheral) +{ + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Enable this peripheral in sleep mode. + // + HWREG(g_pulSCGCRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) |= + SYSCTL_PERIPH_MASK(ulPeripheral); +} + +//***************************************************************************** +// +//! Disables a peripheral in sleep mode. +//! +//! \param ulPeripheral is the peripheral to disable in sleep mode. +//! +//! This function causes a peripheral to stop operating when the processor goes +//! into sleep mode. Disabling peripherals while in sleep mode helps to lower +//! the current draw of the device. If enabled (via SysCtlPeripheralEnable()), +//! the peripheral will automatically resume operation when the processor +//! leaves sleep mode, maintaining its entire state from before sleep mode was +//! entered. +//! +//! Sleep mode clocking of peripherals must be enabled via +//! SysCtlPeripheralClockGating(); if disabled, the peripheral sleep mode +//! configuration is maintained but has no effect when sleep mode is entered. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralSleepDisable(unsigned long ulPeripheral) +{ + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Disable this peripheral in sleep mode. + // + HWREG(g_pulSCGCRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) &= + ~SYSCTL_PERIPH_MASK(ulPeripheral); +} + +//***************************************************************************** +// +//! Enables a peripheral in deep-sleep mode. +//! +//! \param ulPeripheral is the peripheral to enable in deep-sleep mode. +//! +//! This function allows a peripheral to continue operating when the processor +//! goes into deep-sleep mode. Since the clocking configuration of the device +//! may change, not all peripherals can safely continue operating while the +//! processor is in sleep mode. Those that must run at a particular frequency +//! (such as a UART) will not work as expected if the clock changes. It is the +//! responsibility of the caller to make sensible choices. +//! +//! Deep-sleep mode clocking of peripherals must be enabled via +//! SysCtlPeripheralClockGating(); if disabled, the peripheral deep-sleep mode +//! configuration is maintained but has no effect when deep-sleep mode is +//! entered. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralDeepSleepEnable(unsigned long ulPeripheral) +{ + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Enable this peripheral in deep-sleep mode. + // + HWREG(g_pulDCGCRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) |= + SYSCTL_PERIPH_MASK(ulPeripheral); +} + +//***************************************************************************** +// +//! Disables a peripheral in deep-sleep mode. +//! +//! \param ulPeripheral is the peripheral to disable in deep-sleep mode. +//! +//! This function causes a peripheral to stop operating when the processor goes +//! into deep-sleep mode. Disabling peripherals while in deep-sleep mode helps +//! to lower the current draw of the device, and can keep peripherals that +//! require a particular clock frequency from operating when the clock changes +//! as a result of entering deep-sleep mode. If enabled (via +//! SysCtlPeripheralEnable()), the peripheral will automatically resume +//! operation when the processor leaves deep-sleep mode, maintaining its entire +//! state from before deep-sleep mode was entered. +//! +//! Deep-sleep mode clocking of peripherals must be enabled via +//! SysCtlPeripheralClockGating(); if disabled, the peripheral deep-sleep mode +//! configuration is maintained but has no effect when deep-sleep mode is +//! entered. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralDeepSleepDisable(unsigned long ulPeripheral) +{ + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Disable this peripheral in deep-sleep mode. + // + HWREG(g_pulDCGCRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) &= + ~SYSCTL_PERIPH_MASK(ulPeripheral); +} + +//***************************************************************************** +// +//! Controls peripheral clock gating in sleep and deep-sleep mode. +//! +//! \param bEnable is a boolean that is \b true if the sleep and deep-sleep +//! peripheral configuration should be used and \b false if not. +//! +//! This function controls how peripherals are clocked when the processor goes +//! into sleep or deep-sleep mode. By default, the peripherals are clocked the +//! same as in run mode; if peripheral clock gating is enabled they are clocked +//! according to the configuration set by SysCtlPeripheralSleepEnable(), +//! SysCtlPeripheralSleepDisable(), SysCtlPeripheralDeepSleepEnable(), and +//! SysCtlPeripheralDeepSleepDisable(). +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralClockGating(tBoolean bEnable) +{ + // + // Enable peripheral clock gating as requested. + // + if(bEnable) + { + HWREG(SYSCTL_RCC) |= SYSCTL_RCC_ACG; + } + else + { + HWREG(SYSCTL_RCC) &= ~(SYSCTL_RCC_ACG); + } +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the system control interrupt. +//! +//! \param pfnHandler is a pointer to the function to be called when the system +//! control interrupt occurs. +//! +//! This sets the handler to be called when a system control interrupt occurs. +//! This will enable the global interrupt in the interrupt controller; specific +//! system control interrupts must be enabled via SysCtlIntEnable(). It is the +//! interrupt handler's responsibility to clear the interrupt source via +//! SysCtlIntClear(). +//! +//! System control can generate interrupts when the PLL achieves lock, if the +//! internal LDO current limit is exceeded, if the internal oscillator fails, +//! if the main oscillator fails, if the internal LDO output voltage droops too +//! much, if the external voltage droops too much, or if the PLL fails. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlIntRegister(void (*pfnHandler)(void)) +{ + // + // Register the interrupt handler, returning an error if an error occurs. + // + IntRegister(INT_SYSCTL, pfnHandler); + + // + // Enable the system control interrupt. + // + IntEnable(INT_SYSCTL); +} + +//***************************************************************************** +// +//! Unregisters the interrupt handler for the system control interrupt. +//! +//! This function will clear the handler to be called when a system control +//! interrupt occurs. This will also mask off the interrupt in the interrupt +//! controller so that the interrupt handler no longer is called. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlIntUnregister(void) +{ + // + // Disable the interrupt. + // + IntDisable(INT_SYSCTL); + + // + // Unregister the interrupt handler. + // + IntUnregister(INT_SYSCTL); +} + +//***************************************************************************** +// +//! Enables individual system control interrupt sources. +//! +//! \param ulInts is a bit mask of the interrupt sources to be enabled. Must +//! be a logical OR of \b SYSCTL_INT_PLL_LOCK, \b SYSCTL_INT_CUR_LIMIT, +//! \b SYSCTL_INT_IOSC_FAIL, \b SYSCTL_INT_MOSC_FAIL, \b SYSCTL_INT_POR, +//! \b SYSCTL_INT_BOR, and/or \b SYSCTL_INT_PLL_FAIL. +//! +//! Enables the indicated system control interrupt sources. Only the sources +//! that are enabled can be reflected to the processor interrupt; disabled +//! sources have no effect on the processor. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlIntEnable(unsigned long ulInts) +{ + // + // Enable the specified interrupts. + // + HWREG(SYSCTL_IMC) |= ulInts; +} + +//***************************************************************************** +// +//! Disables individual system control interrupt sources. +//! +//! \param ulInts is a bit mask of the interrupt sources to be disabled. Must +//! be a logical OR of \b SYSCTL_INT_PLL_LOCK, \b SYSCTL_INT_CUR_LIMIT, +//! \b SYSCTL_INT_IOSC_FAIL, \b SYSCTL_INT_MOSC_FAIL, \b SYSCTL_INT_POR, +//! \b SYSCTL_INT_BOR, and/or \b SYSCTL_INT_PLL_FAIL. +//! +//! Disables the indicated system control interrupt sources. Only the sources +//! that are enabled can be reflected to the processor interrupt; disabled +//! sources have no effect on the processor. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlIntDisable(unsigned long ulInts) +{ + // + // Disable the specified interrupts. + // + HWREG(SYSCTL_IMC) &= ~(ulInts); +} + +//***************************************************************************** +// +//! Clears system control interrupt sources. +//! +//! \param ulInts is a bit mask of the interrupt sources to be cleared. Must +//! be a logical OR of \b SYSCTL_INT_PLL_LOCK, \b SYSCTL_INT_CUR_LIMIT, +//! \b SYSCTL_INT_IOSC_FAIL, \b SYSCTL_INT_MOSC_FAIL, \b SYSCTL_INT_POR, +//! \b SYSCTL_INT_BOR, and/or \b SYSCTL_INT_PLL_FAIL. +//! +//! The specified system control interrupt sources are cleared, so that they no +//! longer assert. This must be done in the interrupt handler to keep it from +//! being called again immediately upon exit. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlIntClear(unsigned long ulInts) +{ + // + // Clear the requested interrupt sources. + // + HWREG(SYSCTL_MISC) = ulInts; +} + +//***************************************************************************** +// +//! Gets the current interrupt status. +//! +//! \param bMasked is false if the raw interrupt status is required and true if +//! the masked interrupt status is required. +//! +//! This returns the interrupt status for the system controller. Either the +//! raw interrupt status or the status of interrupts that are allowed to +//! reflect to the processor can be returned. +//! +//! \return The current interrupt status, enumerated as a bit field of +//! \b SYSCTL_INT_PLL_LOCK, \b SYSCTL_INT_CUR_LIMIT, \b SYSCTL_INT_IOSC_FAIL, +//! \b SYSCTL_INT_MOSC_FAIL, \b SYSCTL_INT_POR, \b SYSCTL_INT_BOR, and +//! \b SYSCTL_INT_PLL_FAIL. +// +//***************************************************************************** +unsigned long +SysCtlIntStatus(tBoolean bMasked) +{ + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + return(HWREG(SYSCTL_MISC)); + } + else + { + return(HWREG(SYSCTL_RIS)); + } +} + +//***************************************************************************** +// +//! Sets the output voltage of the LDO. +//! +//! \param ulVoltage is the required output voltage from the LDO. Must be one +//! of \b SYSCTL_LDO_2_25V, \b SYSCTL_LDO_2_30V, \b SYSCTL_LDO_2_35V, +//! \b SYSCTL_LDO_2_40V, \b SYSCTL_LDO_2_45V, \b SYSCTL_LDO_2_50V, +//! \b SYSCTL_LDO_2_55V, \b SYSCTL_LDO_2_60V, \b SYSCTL_LDO_2_65V, +//! \b SYSCTL_LDO_2_70V, or \b SYSCTL_LDO_2_75V. +//! +//! This function sets the output voltage of the LDO. The default voltage is +//! 2.5 V; it can be adjusted +/- 10%. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlLDOSet(unsigned long ulVoltage) +{ + // + // Check the arguments. + // + ASSERT((ulVoltage == SYSCTL_LDO_2_25V) || + (ulVoltage == SYSCTL_LDO_2_30V) || + (ulVoltage == SYSCTL_LDO_2_35V) || + (ulVoltage == SYSCTL_LDO_2_40V) || + (ulVoltage == SYSCTL_LDO_2_45V) || + (ulVoltage == SYSCTL_LDO_2_50V) || + (ulVoltage == SYSCTL_LDO_2_55V) || + (ulVoltage == SYSCTL_LDO_2_60V) || + (ulVoltage == SYSCTL_LDO_2_65V) || + (ulVoltage == SYSCTL_LDO_2_70V) || + (ulVoltage == SYSCTL_LDO_2_75V)); + + // + // Set the LDO voltage to the requested value. + // + HWREG(SYSCTL_LDOPCTL) = ulVoltage; +} + +//***************************************************************************** +// +//! Gets the output voltage of the LDO. +//! +//! This function determines the output voltage of the LDO, as specified by the +//! control register. +//! +//! \return Returns the current voltage of the LDO; will be one of +//! \b SYSCTL_LDO_2_25V, \b SYSCTL_LDO_2_30V, \b SYSCTL_LDO_2_35V, +//! \b SYSCTL_LDO_2_40V, \b SYSCTL_LDO_2_45V, \b SYSCTL_LDO_2_50V, +//! \b SYSCTL_LDO_2_55V, \b SYSCTL_LDO_2_60V, \b SYSCTL_LDO_2_65V, +//! \b SYSCTL_LDO_2_70V, or \b SYSCTL_LDO_2_75V. +// +//***************************************************************************** +unsigned long +SysCtlLDOGet(void) +{ + // + // Return the LDO voltage setting. + // + return(HWREG(SYSCTL_LDOPCTL)); +} + +//***************************************************************************** +// +//! Configures the LDO failure control. +//! +//! \param ulConfig is the required LDO failure control setting; can be either +//! \b SYSCTL_LDOCFG_ARST or \b SYSCTL_LDOCFG_NORST. +//! +//! This function allows the LDO to be configured to cause a processor reset +//! when the output voltage becomes unregulated. +//! +//! The LDO failure control is only available on Sandstorm-class devices. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlLDOConfigSet(unsigned long ulConfig) +{ + // + // Check the arguments. + // + ASSERT((ulConfig == SYSCTL_LDOCFG_ARST) || + (ulConfig == SYSCTL_LDOCFG_NORST)); + + // + // Set the reset control as requested. + // + HWREG(SYSCTL_LDOARST) = ulConfig; +} + +//***************************************************************************** +// +//! Resets the device. +//! +//! This function will perform a software reset of the entire device. The +//! processor and all peripherals will be reset and all device registers will +//! return to their default values (with the exception of the reset cause +//! register, which will maintain its current value but have the software reset +//! bit set as well). +//! +//! \return This function does not return. +// +//***************************************************************************** +void +SysCtlReset(void) +{ + // + // Perform a software reset request. This will cause the device to reset, + // no further code will be executed. + // + HWREG(NVIC_APINT) = NVIC_APINT_VECTKEY | NVIC_APINT_SYSRESETREQ; + + // + // The device should have reset, so this should never be reached. Just in + // case, loop forever. + // + while(1) + { + } +} + +//***************************************************************************** +// +//! Puts the processor into sleep mode. +//! +//! This function places the processor into sleep mode; it will not return +//! until the processor returns to run mode. The peripherals that are enabled +//! via SysCtlPeripheralSleepEnable() continue to operate and can wake up the +//! processor (if automatic clock gating is enabled with +//! SysCtlPeripheralClockGating(), otherwise all peripherals continue to +//! operate). +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlSleep(void) +{ + // + // Wait for an interrupt. + // + CPUwfi(); +} + +//***************************************************************************** +// +//! Puts the processor into deep-sleep mode. +//! +//! This function places the processor into deep-sleep mode; it will not return +//! until the processor returns to run mode. The peripherals that are enabled +//! via SysCtlPeripheralDeepSleepEnable() continue to operate and can wake up +//! the processor (if automatic clock gating is enabled with +//! SysCtlPeripheralClockGating(), otherwise all peripherals continue to +//! operate). +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlDeepSleep(void) +{ + // + // Enable deep-sleep. + // + HWREG(NVIC_SYS_CTRL) |= NVIC_SYS_CTRL_SLEEPDEEP; + + // + // Wait for an interrupt. + // + CPUwfi(); + + // + // Disable deep-sleep so that a future sleep will work correctly. + // + HWREG(NVIC_SYS_CTRL) &= ~(NVIC_SYS_CTRL_SLEEPDEEP); +} + +//***************************************************************************** +// +//! Gets the reason for a reset. +//! +//! This function will return the reason(s) for a reset. Since the reset +//! reasons are sticky until either cleared by software or an external reset, +//! multiple reset reasons may be returned if multiple resets have occurred. +//! The reset reason will be a logical OR of \b SYSCTL_CAUSE_LDO, +//! \b SYSCTL_CAUSE_SW, \b SYSCTL_CAUSE_WDOG, \b SYSCTL_CAUSE_BOR, +//! \b SYSCTL_CAUSE_POR, and/or \b SYSCTL_CAUSE_EXT. +//! +//! \return Returns the reason(s) for a reset. +// +//***************************************************************************** +unsigned long +SysCtlResetCauseGet(void) +{ + // + // Return the reset reasons. + // + return(HWREG(SYSCTL_RESC)); +} + +//***************************************************************************** +// +//! Clears reset reasons. +//! +//! \param ulCauses are the reset causes to be cleared; must be a logical OR of +//! \b SYSCTL_CAUSE_LDO, \b SYSCTL_CAUSE_SW, \b SYSCTL_CAUSE_WDOG, +//! \b SYSCTL_CAUSE_BOR, \b SYSCTL_CAUSE_POR, and/or \b SYSCTL_CAUSE_EXT. +//! +//! This function clears the specified sticky reset reasons. Once cleared, +//! another reset for the same reason can be detected, and a reset for a +//! different reason can be distinguished (instead of having two reset causes +//! set). If the reset reason is used by an application, all reset causes +//! should be cleared after they are retrieved with SysCtlResetCauseGet(). +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlResetCauseClear(unsigned long ulCauses) +{ + // + // Clear the given reset reasons. + // + HWREG(SYSCTL_RESC) &= ~(ulCauses); +} + +//***************************************************************************** +// +//! Configures the brown-out control. +//! +//! \param ulConfig is the desired configuration of the brown-out control. +//! Must be the logical OR of \b SYSCTL_BOR_RESET and/or +//! \b SYSCTL_BOR_RESAMPLE. +//! \param ulDelay is the number of internal oscillator cycles to wait before +//! resampling an asserted brown-out signal. This value only has meaning when +//! \b SYSCTL_BOR_RESAMPLE is set and must be less than 8192. +//! +//! This function configures how the brown-out control operates. It can detect +//! a brown-out by looking at only the brown-out output, or it can wait for it +//! to be active for two consecutive samples separated by a configurable time. +//! When it detects a brown-out condition, it can either reset the device or +//! generate a processor interrupt. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlBrownOutConfigSet(unsigned long ulConfig, unsigned long ulDelay) +{ + // + // Check the arguments. + // + ASSERT(!(ulConfig & ~(SYSCTL_BOR_RESET | SYSCTL_BOR_RESAMPLE))); + ASSERT(ulDelay < 8192); + + // + // Configure the brown-out reset control. + // + HWREG(SYSCTL_PBORCTL) = (ulDelay << SYSCTL_PBORCTL_BORTIM_S) | ulConfig; +} + +//***************************************************************************** +// +//! Provides a small delay. +//! +//! \param ulCount is the number of delay loop iterations to perform. +//! +//! This function provides a means of generating a constant length delay. It +//! is written in assembly to keep the delay consistent across tool chains, +//! avoiding the need to tune the delay based on the tool chain in use. +//! +//! The loop takes 3 cycles/loop. +//! +//! \return None. +// +//***************************************************************************** +#if defined(ewarm) || defined(DOXYGEN) +void +SysCtlDelay(unsigned long ulCount) +{ + __asm(" subs r0, #1\n" + " bne.n SysCtlDelay\n" + " bx lr"); +} +#endif +#if defined(codered) || defined(gcc) || defined(sourcerygxx) +void __attribute__((naked)) +SysCtlDelay(unsigned long ulCount) +{ + __asm(" subs r0, #1\n" + " bne SysCtlDelay\n" + " bx lr"); +} +#endif +#if defined(rvmdk) || defined(__ARMCC_VERSION) +__asm void +SysCtlDelay(unsigned long ulCount) +{ + subs r0, #1; + bne SysCtlDelay; + bx lr; +} +#endif +// +// For CCS implement this function in pure assembly. This prevents the TI +// compiler from doing funny things with the optimizer. +// +#if defined(ccs) + __asm(" .sect \".text:SysCtlDelay\"\n" + " .clink\n" + " .thumbfunc SysCtlDelay\n" + " .thumb\n" + " .global SysCtlDelay\n" + "SysCtlDelay:\n" + " subs r0, #1\n" + " bne.n SysCtlDelay\n" + " bx lr\n"); +#endif + + +//***************************************************************************** +// +//! Sets the clocking of the device. +//! +//! \param ulConfig is the required configuration of the device clocking. +//! +//! This function configures the clocking of the device. The input crystal +//! frequency, oscillator to be used, use of the PLL, and the system clock +//! divider are all configured with this function. +//! +//! The \e ulConfig parameter is the logical OR of several different values, +//! many of which are grouped into sets where only one can be chosen. +//! +//! The system clock divider is chosen with one of the following values: +//! \b SYSCTL_SYSDIV_1, \b SYSCTL_SYSDIV_2, \b SYSCTL_SYSDIV_3, ... +//! \b SYSCTL_SYSDIV_64. Only \b SYSCTL_SYSDIV_1 through \b SYSCTL_SYSDIV_16 +//! are valid on Sandstorm-class devices. +//! +//! The use of the PLL is chosen with either \b SYSCTL_USE_PLL or +//! \b SYSCTL_USE_OSC. +//! +//! The external crystal frequency is chosen with one of the following values: +//! \b SYSCTL_XTAL_1MHZ, \b SYSCTL_XTAL_1_84MHZ, \b SYSCTL_XTAL_2MHZ, +//! \b SYSCTL_XTAL_2_45MHZ, \b SYSCTL_XTAL_3_57MHZ, \b SYSCTL_XTAL_3_68MHZ, +//! \b SYSCTL_XTAL_4MHZ, \b SYSCTL_XTAL_4_09MHZ, \b SYSCTL_XTAL_4_91MHZ, +//! \b SYSCTL_XTAL_5MHZ, \b SYSCTL_XTAL_5_12MHZ, \b SYSCTL_XTAL_6MHZ, +//! \b SYSCTL_XTAL_6_14MHZ, \b SYSCTL_XTAL_7_37MHZ, \b SYSCTL_XTAL_8MHZ, +//! \b SYSCTL_XTAL_8_19MHZ, \b SYSCTL_XTAL_10MHZ, \b SYSCTL_XTAL_12MHZ, +//! \b SYSCTL_XTAL_12_2MHZ, \b SYSCTL_XTAL_13_5MHZ, \b SYSCTL_XTAL_14_3MHZ, +//! \b SYSCTL_XTAL_16MHZ, or \b SYSCTL_XTAL_16_3MHZ. Values below +//! \b SYSCTL_XTAL_3_57MHZ are not valid when the PLL is in operation. On +//! Sandstorm- and Fury-class devices, values above \b SYSCTL_XTAL_8_19MHZ are +//! not valid. +//! +//! The oscillator source is chosen with one of the following values: +//! \b SYSCTL_OSC_MAIN, \b SYSCTL_OSC_INT, \b SYSCTL_OSC_INT4, +//! \b SYSCTL_OSC_INT30, or \b SYSCTL_OSC_EXT32. On Sandstorm-class devices, +//! \b SYSCTL_OSC_INT30 and \b SYSCTL_OSC_EXT32 are not valid. +//! \b SYSCTL_OSC_EXT32 is only available on devices with the hibernate module, +//! and then only when the hibernate module has been enabled. +//! +//! The internal and main oscillators are disabled with the +//! \b SYSCTL_INT_OSC_DIS and \b SYSCTL_MAIN_OSC_DIS flags, respectively. +//! The external oscillator must be enabled in order to use an external clock +//! source. Note that attempts to disable the oscillator used to clock the +//! device will be prevented by the hardware. +//! +//! To clock the system from an external source (such as an external crystal +//! oscillator), use \b SYSCTL_USE_OSC \b | \b SYSCTL_OSC_MAIN. To clock the +//! system from the main oscillator, use \b SYSCTL_USE_OSC \b | +//! \b SYSCTL_OSC_MAIN. To clock the system from the PLL, use +//! \b SYSCTL_USE_PLL \b | \b SYSCTL_OSC_MAIN, and select the appropriate +//! crystal with one of the \b SYSCTL_XTAL_xxx values. +//! +//! \note If selecting the PLL as the system clock source (that is, via +//! \b SYSCTL_USE_PLL), this function will poll the PLL lock interrupt to +//! determine when the PLL has locked. If an interrupt handler for the +//! system control interrupt is in place, and it responds to and clears the +//! PLL lock interrupt, this function will delay until its timeout has occurred +//! instead of completing as soon as PLL lock is achieved. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlClockSet(unsigned long ulConfig) +{ + unsigned long ulDelay, ulRCC, ulRCC2; + + // + // See if this is a Sandstorm-class device and clocking features from newer + // devices were requested. + // + if(CLASS_IS_SANDSTORM && (ulConfig & SYSCTL_RCC2_USERCC2)) + { + // + // Return without changing the clocking since the requested + // configuration can not be achieved. + // + return; + } + + // + // Get the current value of the RCC and RCC2 registers. If using a + // Sandstorm-class device, the RCC2 register will read back as zero and the + // writes to it from within this function will be ignored. + // + ulRCC = HWREG(SYSCTL_RCC); + ulRCC2 = HWREG(SYSCTL_RCC2); + + // + // Bypass the PLL and system clock dividers for now. + // + ulRCC |= SYSCTL_RCC_BYPASS; + ulRCC &= ~(SYSCTL_RCC_USESYSDIV); + ulRCC2 |= SYSCTL_RCC2_BYPASS2; + + // + // Write the new RCC value. + // + HWREG(SYSCTL_RCC) = ulRCC; + HWREG(SYSCTL_RCC2) = ulRCC2; + + // + // See if either oscillator needs to be enabled. + // + if(((ulRCC & SYSCTL_RCC_IOSCDIS) && !(ulConfig & SYSCTL_RCC_IOSCDIS)) || + ((ulRCC & SYSCTL_RCC_MOSCDIS) && !(ulConfig & SYSCTL_RCC_MOSCDIS))) + { + // + // Make sure that the required oscillators are enabled. For now, the + // previously enabled oscillators must be enabled along with the newly + // requested oscillators. + // + ulRCC &= (~(SYSCTL_RCC_IOSCDIS | SYSCTL_RCC_MOSCDIS) | + (ulConfig & (SYSCTL_RCC_IOSCDIS | SYSCTL_RCC_MOSCDIS))); + + // + // Write the new RCC value. + // + HWREG(SYSCTL_RCC) = ulRCC; + + // + // Wait for a bit, giving the oscillator time to stabilize. The number + // of iterations is adjusted based on the current clock source; a + // smaller number of iterations is required for slower clock rates. + // + if(((ulRCC2 & SYSCTL_RCC2_USERCC2) && + (((ulRCC2 & SYSCTL_RCC2_OSCSRC2_M) == SYSCTL_RCC2_OSCSRC2_30) || + ((ulRCC2 & SYSCTL_RCC2_OSCSRC2_M) == SYSCTL_RCC2_OSCSRC2_32))) || + (!(ulRCC2 & SYSCTL_RCC2_USERCC2) && + ((ulRCC & SYSCTL_RCC_OSCSRC_M) == SYSCTL_RCC_OSCSRC_30))) + { + // + // Delay for 4096 iterations. + // + SysCtlDelay(4096); + } + else + { + // + // Delay for 524,288 iterations. + // + SysCtlDelay(524288); + } + } + + // + // Set the new crystal value, oscillator source, and PLL configuration. + // Since the OSCSRC2 field in RCC2 overlaps the XTAL field in RCC, the + // OSCSRC field has a special encoding within ulConfig to avoid the + // overlap. + // + ulRCC &= ~(SYSCTL_RCC_XTAL_M | SYSCTL_RCC_OSCSRC_M | + SYSCTL_RCC_PWRDN | SYSCTL_RCC_OEN); + ulRCC |= ulConfig & (SYSCTL_RCC_XTAL_M | SYSCTL_RCC_OSCSRC_M | + SYSCTL_RCC_PWRDN | SYSCTL_RCC_OEN); + ulRCC2 &= ~(SYSCTL_RCC2_USERCC2 | SYSCTL_RCC2_OSCSRC2_M | + SYSCTL_RCC2_PWRDN2); + ulRCC2 |= ulConfig & (SYSCTL_RCC2_USERCC2 | SYSCTL_RCC_OSCSRC_M | + SYSCTL_RCC2_PWRDN2); + ulRCC2 |= (ulConfig & 0x00000008) << 3; + + // + // Clear the PLL lock interrupt. + // + HWREG(SYSCTL_MISC) = SYSCTL_INT_PLL_LOCK; + + // + // Write the new RCC value. + // + if(ulRCC2 & SYSCTL_RCC2_USERCC2) + { + HWREG(SYSCTL_RCC2) = ulRCC2; + HWREG(SYSCTL_RCC) = ulRCC; + } + else + { + HWREG(SYSCTL_RCC) = ulRCC; + HWREG(SYSCTL_RCC2) = ulRCC2; + } + + // + // Wait for a bit so that new crystal value and oscillator source can take + // effect. + // + SysCtlDelay(16); + + // + // Set the requested system divider and disable the appropriate + // oscillators. This will not get written immediately. + // + ulRCC &= ~(SYSCTL_RCC_SYSDIV_M | SYSCTL_RCC_USESYSDIV | + SYSCTL_RCC_IOSCDIS | SYSCTL_RCC_MOSCDIS); + ulRCC |= ulConfig & (SYSCTL_RCC_SYSDIV_M | SYSCTL_RCC_USESYSDIV | + SYSCTL_RCC_IOSCDIS | SYSCTL_RCC_MOSCDIS); + ulRCC2 &= ~(SYSCTL_RCC2_SYSDIV2_M); + ulRCC2 |= ulConfig & SYSCTL_RCC2_SYSDIV2_M; + if(ulConfig & SYSCTL_RCC2_DIV400) + { + ulRCC |= SYSCTL_RCC_USESYSDIV; + ulRCC2 &= ~(SYSCTL_RCC_USESYSDIV); + ulRCC2 |= ulConfig & (SYSCTL_RCC2_DIV400 | SYSCTL_RCC2_SYSDIV2LSB); + } + else + { + ulRCC2 &= ~(SYSCTL_RCC2_DIV400); + } + + // + // See if the PLL output is being used to clock the system. + // + if(!(ulConfig & SYSCTL_RCC_BYPASS)) + { + // + // Wait until the PLL has locked. + // + for(ulDelay = 32768; ulDelay > 0; ulDelay--) + { + if(HWREG(SYSCTL_RIS) & SYSCTL_INT_PLL_LOCK) + { + break; + } + } + + // + // Enable use of the PLL. + // + ulRCC &= ~(SYSCTL_RCC_BYPASS); + ulRCC2 &= ~(SYSCTL_RCC2_BYPASS2); + } + + // + // Write the final RCC value. + // + HWREG(SYSCTL_RCC) = ulRCC; + HWREG(SYSCTL_RCC2) = ulRCC2; + + // + // Delay for a little bit so that the system divider takes effect. + // + SysCtlDelay(16); +} + +//***************************************************************************** +// +//! Gets the processor clock rate. +//! +//! This function determines the clock rate of the processor clock. This is +//! also the clock rate of all the peripheral modules (with the exception of +//! PWM, which has its own clock divider). +//! +//! \note This will not return accurate results if SysCtlClockSet() has not +//! been called to configure the clocking of the device, or if the device is +//! directly clocked from a crystal (or a clock source) that is not one of the +//! supported crystal frequencies. In the later case, this function should be +//! modified to directly return the correct system clock rate. +//! +//! \return The processor clock rate. +// +//***************************************************************************** +unsigned long +SysCtlClockGet(void) +{ + unsigned long ulRCC, ulRCC2, ulPLL, ulClk; + + // + // Read RCC and RCC2. For Sandstorm-class devices (which do not have + // RCC2), the RCC2 read will return 0, which indicates that RCC2 is + // disabled (since the SYSCTL_RCC2_USERCC2 bit is clear). + // + ulRCC = HWREG(SYSCTL_RCC); + ulRCC2 = HWREG(SYSCTL_RCC2); + + // + // Get the base clock rate. + // + switch((ulRCC2 & SYSCTL_RCC2_USERCC2) ? + (ulRCC2 & SYSCTL_RCC2_OSCSRC2_M) : + (ulRCC & SYSCTL_RCC_OSCSRC_M)) + { + // + // The main oscillator is the clock source. Determine its rate from + // the crystal setting field. + // + case SYSCTL_RCC_OSCSRC_MAIN: + { + ulClk = g_pulXtals[(ulRCC & SYSCTL_RCC_XTAL_M) >> + SYSCTL_RCC_XTAL_S]; + break; + } + + // + // The internal oscillator is the source clock. + // + case SYSCTL_RCC_OSCSRC_INT: + { + // + // See if this is a Sandstorm-class or Fury-class device. + // + if(CLASS_IS_SANDSTORM) + { + // + // The internal oscillator on a Sandstorm-class device is + // 15 MHz +/- 50%. + // + ulClk = 15000000; + } + else if((CLASS_IS_FURY && REVISION_IS_A2) || + (CLASS_IS_DUSTDEVIL && REVISION_IS_A0)) + { + // + // The internal oscillator on a rev A2 Fury-class device and a + // rev A0 Dustdevil-class device is 12 MHz +/- 30%. + // + ulClk = 12000000; + } + else + { + // + // The internal oscillator on all other devices is 16 MHz. + // + ulClk = 16000000; + } + break; + } + + // + // The internal oscillator divided by four is the source clock. + // + case SYSCTL_RCC_OSCSRC_INT4: + { + // + // See if this is a Sandstorm-class or Fury-class device. + // + if(CLASS_IS_SANDSTORM) + { + // + // The internal oscillator on a Sandstorm-class device is + // 15 MHz +/- 50%. + // + ulClk = 15000000 / 4; + } + else if((CLASS_IS_FURY && REVISION_IS_A2) || + (CLASS_IS_DUSTDEVIL && REVISION_IS_A0)) + { + // + // The internal oscillator on a rev A2 Fury-class device and a + // rev A0 Dustdevil-class device is 12 MHz +/- 30%. + // + ulClk = 12000000 / 4; + } + else + { + // + // The internal oscillator on a Tempest-class device is 16 MHz. + // + ulClk = 16000000 / 4; + } + break; + } + + // + // The internal 30 KHz oscillator is the source clock. + // + case SYSCTL_RCC_OSCSRC_30: + { + // + // The internal 30 KHz oscillator has an accuracy of +/- 30%. + // + ulClk = 30000; + break; + } + + // + // The 4.19 MHz clock from the hibernate module is the clock source. + // + case SYSCTL_RCC2_OSCSRC2_419: + { + ulClk = 4194304; + break; + } + + // + // The 32 KHz clock from the hibernate module is the source clock. + // + case SYSCTL_RCC2_OSCSRC2_32: + { + ulClk = 32768; + break; + } + + // + // An unknown setting, so return a zero clock (that is, an unknown + // clock rate). + // + default: + { + return(0); + } + } + + // + // See if the PLL is being used. + // + if(((ulRCC2 & SYSCTL_RCC2_USERCC2) && !(ulRCC2 & SYSCTL_RCC2_BYPASS2)) || + (!(ulRCC2 & SYSCTL_RCC2_USERCC2) && !(ulRCC & SYSCTL_RCC_BYPASS))) + { + // + // Get the PLL configuration. + // + ulPLL = HWREG(SYSCTL_PLLCFG); + + // + // See if this is a Sandstorm-class or Fury-class device. + // + if(CLASS_IS_SANDSTORM) + { + // + // Compute the PLL output frequency based on its input frequency. + // The formula for a Sandstorm-class devices is + // "(xtal * (f + 2)) / (r + 2)". + // + ulClk = ((ulClk * (((ulPLL & SYSCTL_PLLCFG_F_M) >> + SYSCTL_PLLCFG_F_S) + 2)) / + (((ulPLL & SYSCTL_PLLCFG_R_M) >> + SYSCTL_PLLCFG_R_S) + 2)); + } + else + { + // + // Compute the PLL output frequency based on its input frequency. + // The formula for a Fury-class device is + // "(xtal * f) / ((r + 1) * 2)". + // + ulClk = ((ulClk * ((ulPLL & SYSCTL_PLLCFG_F_M) >> + SYSCTL_PLLCFG_F_S)) / + ((((ulPLL & SYSCTL_PLLCFG_R_M) >> + SYSCTL_PLLCFG_R_S) + 1) * 2)); + } + + // + // See if the optional output divide by 2 is being used. + // + if(ulPLL & SYSCTL_PLLCFG_OD_2) + { + ulClk /= 2; + } + + // + // See if the optional output divide by 4 is being used. + // + if(ulPLL & SYSCTL_PLLCFG_OD_4) + { + ulClk /= 4; + } + + // + // Force the system divider to be enabled. It is always used when + // using the PLL, but in some cases it will not read as being enabled. + // + ulRCC |= SYSCTL_RCC_USESYSDIV; + } + + // + // See if the system divider is being used. + // + if(ulRCC & SYSCTL_RCC_USESYSDIV) + { + // + // Adjust the clock rate by the system clock divider. + // + if(ulRCC2 & SYSCTL_RCC2_USERCC2) + { + if((ulRCC2 & SYSCTL_RCC2_DIV400) && + (((ulRCC2 & SYSCTL_RCC2_USERCC2) && + !(ulRCC2 & SYSCTL_RCC2_BYPASS2)) || + (!(ulRCC2 & SYSCTL_RCC2_USERCC2) && + !(ulRCC & SYSCTL_RCC_BYPASS)))) + + { + ulClk = ((ulClk * 2) / (((ulRCC2 & (SYSCTL_RCC2_SYSDIV2_M | + SYSCTL_RCC2_SYSDIV2LSB)) >> + (SYSCTL_RCC2_SYSDIV2_S - 1)) + 1)); + } + else + { + ulClk /= (((ulRCC2 & SYSCTL_RCC2_SYSDIV2_M) >> + SYSCTL_RCC2_SYSDIV2_S) + 1); + } + } + else + { + ulClk /= (((ulRCC & SYSCTL_RCC_SYSDIV_M) >> SYSCTL_RCC_SYSDIV_S) + + 1); + } + } + + // + // Return the computed clock rate. + // + return(ulClk); +} + +//***************************************************************************** +// +//! Sets the PWM clock configuration. +//! +//! \param ulConfig is the configuration for the PWM clock; it must be one of +//! \b SYSCTL_PWMDIV_1, \b SYSCTL_PWMDIV_2, \b SYSCTL_PWMDIV_4, +//! \b SYSCTL_PWMDIV_8, \b SYSCTL_PWMDIV_16, \b SYSCTL_PWMDIV_32, or +//! \b SYSCTL_PWMDIV_64. +//! +//! This function sets the rate of the clock provided to the PWM module as a +//! ratio of the processor clock. This clock is used by the PWM module to +//! generate PWM signals; its rate forms the basis for all PWM signals. +//! +//! \note The clocking of the PWM is dependent upon the system clock rate as +//! configured by SysCtlClockSet(). +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPWMClockSet(unsigned long ulConfig) +{ + // + // Check the arguments. + // + ASSERT((ulConfig == SYSCTL_PWMDIV_1) || + (ulConfig == SYSCTL_PWMDIV_2) || + (ulConfig == SYSCTL_PWMDIV_4) || + (ulConfig == SYSCTL_PWMDIV_8) || + (ulConfig == SYSCTL_PWMDIV_16) || + (ulConfig == SYSCTL_PWMDIV_32) || + (ulConfig == SYSCTL_PWMDIV_64)); + + // + // Check that there is a PWM block on this part. + // + ASSERT(HWREG(SYSCTL_DC1) & SYSCTL_DC1_PWM); + + // + // Set the PWM clock configuration into the run-mode clock configuration + // register. + // + HWREG(SYSCTL_RCC) = ((HWREG(SYSCTL_RCC) & + ~(SYSCTL_RCC_USEPWMDIV | SYSCTL_RCC_PWMDIV_M)) | + ulConfig); +} + +//***************************************************************************** +// +//! Gets the current PWM clock configuration. +//! +//! This function returns the current PWM clock configuration. +//! +//! \return Returns the current PWM clock configuration; will be one of +//! \b SYSCTL_PWMDIV_1, \b SYSCTL_PWMDIV_2, \b SYSCTL_PWMDIV_4, +//! \b SYSCTL_PWMDIV_8, \b SYSCTL_PWMDIV_16, \b SYSCTL_PWMDIV_32, or +//! \b SYSCTL_PWMDIV_64. +// +//***************************************************************************** +unsigned long +SysCtlPWMClockGet(void) +{ + // + // Check that there is a PWM block on this part. + // + ASSERT(HWREG(SYSCTL_DC1) & SYSCTL_DC1_PWM); + + // + // Return the current PWM clock configuration. Make sure that + // SYSCTL_PWMDIV_1 is returned in all cases where the divider is disabled. + // + if(!(HWREG(SYSCTL_RCC) & SYSCTL_RCC_USEPWMDIV)) + { + // + // The divider is not active so reflect this in the value we return. + // + return(SYSCTL_PWMDIV_1); + } + else + { + // + // The divider is active so directly return the masked register value. + // + return(HWREG(SYSCTL_RCC) & + (SYSCTL_RCC_USEPWMDIV | SYSCTL_RCC_PWMDIV_M)); + } +} + +//***************************************************************************** +// +//! Sets the sample rate of the ADC. +//! +//! \param ulSpeed is the desired sample rate of the ADC; must be one of +//! \b SYSCTL_ADCSPEED_1MSPS, \b SYSCTL_ADCSPEED_500KSPS, +//! \b SYSCTL_ADCSPEED_250KSPS, or \b SYSCTL_ADCSPEED_125KSPS. +//! +//! This function sets the rate at which the ADC samples are captured by the +//! ADC block. The sampling speed may be limited by the hardware, so the +//! sample rate may end up being slower than requested. SysCtlADCSpeedGet() +//! will return the actual speed in use. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlADCSpeedSet(unsigned long ulSpeed) +{ + // + // Check the arguments. + // + ASSERT((ulSpeed == SYSCTL_ADCSPEED_1MSPS) || + (ulSpeed == SYSCTL_ADCSPEED_500KSPS) || + (ulSpeed == SYSCTL_ADCSPEED_250KSPS) || + (ulSpeed == SYSCTL_ADCSPEED_125KSPS)); + + // + // Check that there is an ADC block on this part. + // + ASSERT(HWREG(SYSCTL_DC1) & SYSCTL_DC1_ADC0); + + // + // Set the ADC speed in run, sleep, and deep-sleep mode. + // + HWREG(SYSCTL_RCGC0) = ((HWREG(SYSCTL_RCGC0) & ~(SYSCTL_RCGC0_ADCSPD_M)) | + ulSpeed); + HWREG(SYSCTL_SCGC0) = ((HWREG(SYSCTL_SCGC0) & ~(SYSCTL_SCGC0_ADCSPD_M)) | + ulSpeed); +} + +//***************************************************************************** +// +//! Gets the sample rate of the ADC. +//! +//! This function gets the current sample rate of the ADC. +//! +//! \return Returns the current ADC sample rate; will be one of +//! \b SYSCTL_ADCSPEED_1MSPS, \b SYSCTL_ADCSPEED_500KSPS, +//! \b SYSCTL_ADCSPEED_250KSPS, or \b SYSCTL_ADCSPEED_125KSPS. +// +//***************************************************************************** +unsigned long +SysCtlADCSpeedGet(void) +{ + // + // Check that there is an ADC block on this part. + // + ASSERT(HWREG(SYSCTL_DC1) & SYSCTL_DC1_ADC0); + + // + // Return the current ADC speed. + // + return(HWREG(SYSCTL_RCGC0) & SYSCTL_RCGC0_ADCSPD_M); +} + +//***************************************************************************** +// +//! Configures the internal oscillator verification timer. +//! +//! \param bEnable is a boolean that is \b true if the internal oscillator +//! verification timer should be enabled. +//! +//! This function allows the internal oscillator verification timer to be +//! enabled or disabled. When enabled, an interrupt will be generated if the +//! internal oscillator ceases to operate. +//! +//! The internal oscillator verification timer is only available on +//! Sandstorm-class devices. +//! +//! \note Both oscillators (main and internal) must be enabled for this +//! verification timer to operate as the main oscillator will verify the +//! internal oscillator. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlIOSCVerificationSet(tBoolean bEnable) +{ + // + // Enable or disable the internal oscillator verification timer as + // requested. + // + if(bEnable) + { + HWREG(SYSCTL_RCC) |= SYSCTL_RCC_IOSCVER; + } + else + { + HWREG(SYSCTL_RCC) &= ~(SYSCTL_RCC_IOSCVER); + } +} + +//***************************************************************************** +// +//! Configures the main oscillator verification timer. +//! +//! \param bEnable is a boolean that is \b true if the main oscillator +//! verification timer should be enabled. +//! +//! This function allows the main oscillator verification timer to be enabled +//! or disabled. When enabled, an interrupt will be generated if the main +//! oscillator ceases to operate. +//! +//! The main oscillator verification timer is only available on +//! Sandstorm-class devices. +//! +//! \note Both oscillators (main and internal) must be enabled for this +//! verification timer to operate as the internal oscillator will verify the +//! main oscillator. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlMOSCVerificationSet(tBoolean bEnable) +{ + // + // Enable or disable the main oscillator verification timer as requested. + // + if(bEnable) + { + HWREG(SYSCTL_RCC) |= SYSCTL_RCC_MOSCVER; + } + else + { + HWREG(SYSCTL_RCC) &= ~(SYSCTL_RCC_MOSCVER); + } +} + +//***************************************************************************** +// +//! Configures the PLL verification timer. +//! +//! \param bEnable is a boolean that is \b true if the PLL verification timer +//! should be enabled. +//! +//! This function allows the PLL verification timer to be enabled or disabled. +//! When enabled, an interrupt will be generated if the PLL ceases to operate. +//! +//! The PLL verification timer is only available on Sandstorm-class devices. +//! +//! \note The main oscillator must be enabled for this verification timer to +//! operate as it is used to check the PLL. Also, the verification timer +//! should be disabled while the PLL is being reconfigured via +//! SysCtlClockSet(). +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPLLVerificationSet(tBoolean bEnable) +{ + // + // Enable or disable the PLL verification timer as requested. + // + if(bEnable) + { + HWREG(SYSCTL_RCC) |= SYSCTL_RCC_PLLVER; + } + else + { + HWREG(SYSCTL_RCC) &= ~(SYSCTL_RCC_PLLVER); + } +} + +//***************************************************************************** +// +//! Clears the clock verification status. +//! +//! This function clears the status of the clock verification timers, allowing +//! them to assert another failure if detected. +//! +//! The clock verification timers are only available on Sandstorm-class +//! devices. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlClkVerificationClear(void) +{ + // + // Clear the clock verification. + // + HWREG(SYSCTL_CLKVCLR) = SYSCTL_CLKVCLR_VERCLR; + + // + // The bit does not self-reset, so clear it. + // + HWREG(SYSCTL_CLKVCLR) = 0; +} + +//***************************************************************************** +// +//! Enables a GPIO peripheral for access from the AHB. +//! +//! \param ulGPIOPeripheral is the GPIO peripheral to enable. +//! +//! This function is used to enable the specified GPIO peripheral to be +//! accessed from the Advanced Host Bus (AHB) instead of the legacy Advanced +//! Peripheral Bus (APB). When a GPIO peripheral is enabled for AHB access, +//! the \b _AHB_BASE form of the base address should be used for GPIO +//! functions. For example, instead of using \b GPIO_PORTA_BASE as the base +//! address for GPIO functions, use \b GPIO_PORTA_AHB_BASE instead. +//! +//! The \e ulGPIOPeripheral argument must be only one of the following values: +//! \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, \b SYSCTL_PERIPH_GPIOC, +//! \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, \b SYSCTL_PERIPH_GPIOF, +//! \b SYSCTL_PERIPH_GPIOG, or \b SYSCTL_PERIPH_GPIOH. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlGPIOAHBEnable(unsigned long ulGPIOPeripheral) +{ + // + // Check the arguments. + // + ASSERT((ulGPIOPeripheral == SYSCTL_PERIPH_GPIOA) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOB) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOC) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOD) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOE) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOF) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOG) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOH) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOJ)); + + // + // Enable this GPIO for AHB access. + // + HWREG(SYSCTL_GPIOHBCTL) |= ulGPIOPeripheral & 0xFFFF; +} + +//***************************************************************************** +// +//! Disables a GPIO peripheral for access from the AHB. +//! +//! \param ulGPIOPeripheral is the GPIO peripheral to disable. +//! +//! This function disables the specified GPIO peripheral for access from the +//! Advanced Host Bus (AHB). Once disabled, the GPIO peripheral is accessed +//! from the legacy Advanced Peripheral Bus (AHB). +//! +//! The \b ulGPIOPeripheral argument must be only one of the following values: +//! \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, \b SYSCTL_PERIPH_GPIOC, +//! \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, \b SYSCTL_PERIPH_GPIOF, +//! \b SYSCTL_PERIPH_GPIOG, or \b SYSCTL_PERIPH_GPIOH. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlGPIOAHBDisable(unsigned long ulGPIOPeripheral) +{ + // + // Check the arguments. + // + ASSERT((ulGPIOPeripheral == SYSCTL_PERIPH_GPIOA) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOB) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOC) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOD) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOE) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOF) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOG) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOH) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOJ)); + + // + // Disable this GPIO for AHB access. + // + HWREG(SYSCTL_GPIOHBCTL) &= ~(ulGPIOPeripheral & 0xFFFF); +} + +//***************************************************************************** +// +//! Powers up the USB PLL. +//! +//! This function will enable the USB controller's PLL which is used by it's +//! physical layer. This call is necessary before connecting to any external +//! devices. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlUSBPLLEnable(void) +{ + // + // Turn on the USB PLL. + // + HWREG(SYSCTL_RCC2) &= ~SYSCTL_RCC2_USBPWRDN; +} + +//***************************************************************************** +// +//! Powers down the USB PLL. +//! +//! This function will disable the USB controller's PLL which is used by it's +//! physical layer. The USB registers are still accessible, but the physical +//! layer will no longer function. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlUSBPLLDisable(void) +{ + // + // Turn of USB PLL. + // + HWREG(SYSCTL_RCC2) |= SYSCTL_RCC2_USBPWRDN; +} + +//***************************************************************************** +// +//! Sets the MCLK frequency provided to the I2S module. +//! +//! \param ulInputClock is the input clock to the MCLK divider. If this is +//! zero, the value is computed from the current PLL configuration. +//! \param ulMClk is the desired MCLK frequency. If this is zero, MCLK output +//! is disabled. +//! +//! This function sets the dividers to provide MCLK to the I2S module. A MCLK +//! divider will be chosen that produces the MCLK frequency that is the closest +//! possible to the requested frequency, which may be above or below the +//! requested frequency. +//! +//! The actual MCLK frequency will be returned. It is the responsibility of +//! the application to determine if the selected MCLK is acceptable; in general +//! the human ear can not discern the frequency difference if it is within 0.3% +//! of the desired frequency (though there is a very small percentage of the +//! population that can discern lower frequency deviations). +//! +//! \return Returns the actual MCLK frequency. +// +//***************************************************************************** +unsigned long +SysCtlI2SMClkSet(unsigned long ulInputClock, unsigned long ulMClk) +{ + unsigned long ulDivInt, ulDivFrac, ulPLL; + + // + // See if the I2S MCLK should be disabled. + // + if(ulMClk == 0) + { + // + // Disable the I2S MCLK and return. + // + HWREG(SYSCTL_I2SMCLKCFG) = 0; + return(0); + } + + // + // See if the input clock was specified. + // + if(ulInputClock == 0) + { + // + // The input clock was not specified, so compute the output frequency + // of the PLL. Get the current PLL configuration. + // + ulPLL = HWREG(SYSCTL_PLLCFG); + + // + // Get the frequency of the crystal in use. + // + ulInputClock = g_pulXtals[(HWREG(SYSCTL_RCC) & SYSCTL_RCC_XTAL_M) >> + SYSCTL_RCC_XTAL_S]; + + // + // Calculate the PLL output frequency. + // + ulInputClock = ((ulInputClock * ((ulPLL & SYSCTL_PLLCFG_F_M) >> + SYSCTL_PLLCFG_F_S)) / + ((((ulPLL & SYSCTL_PLLCFG_R_M) >> + SYSCTL_PLLCFG_R_S) + 1))); + + // + // See if the optional output divide by 2 is being used. + // + if(ulPLL & SYSCTL_PLLCFG_OD_2) + { + ulInputClock /= 2; + } + + // + // See if the optional output divide by 4 is being used. + // + if(ulPLL & SYSCTL_PLLCFG_OD_4) + { + ulInputClock /= 4; + } + } + + // + // Verify that the requested MCLK frequency is attainable. + // + ASSERT(ulMClk < ulInputClock); + + // + // Add a rounding factor to the input clock, so that the MCLK frequency + // that is closest to the desire value is selected. + // + ulInputClock += (ulMClk / 32) - 1; + + // + // Compute the integer portion of the MCLK divider. + // + ulDivInt = ulInputClock / ulMClk; + + // + // If the divisor is too large, then simply use the maximum divisor. + // + if(CLASS_IS_TEMPEST && REVISION_IS_B1 && (ulDivInt > 255)) + { + ulDivInt = 255; + ulDivFrac = 15; + } + else if(ulDivInt > 1023) + { + ulDivInt = 1023; + ulDivFrac = 15; + } + else + { + // + // Compute the fractional portion of the MCLK divider. + // + ulDivFrac = ((ulInputClock - (ulDivInt * ulMClk)) * 16) / ulMClk; + } + + // + // Set the divisor for the Tx and Rx MCLK generators and enable the clocks. + // + HWREG(SYSCTL_I2SMCLKCFG) = (SYSCTL_I2SMCLKCFG_RXEN | + (ulDivInt << SYSCTL_I2SMCLKCFG_RXI_S) | + (ulDivFrac << SYSCTL_I2SMCLKCFG_RXF_S) | + SYSCTL_I2SMCLKCFG_TXEN | + (ulDivInt << SYSCTL_I2SMCLKCFG_TXI_S) | + (ulDivFrac << SYSCTL_I2SMCLKCFG_TXF_S)); + + // + // Return the actual MCLK frequency. + // + ulInputClock -= (ulMClk / 32) - 1; + ulDivInt = (ulDivInt * 16) + ulDivFrac; + ulMClk = (ulInputClock / ulDivInt) * 16; + ulMClk += ((ulInputClock - ((ulMClk / 16) * ulDivInt)) * 16) / ulDivInt; + return(ulMClk); +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/sysctl.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/sysctl.h new file mode 100644 index 00000000..d5b00681 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/sysctl.h @@ -0,0 +1,466 @@ +//***************************************************************************** +// +// sysctl.h - Prototypes for the system control driver. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __SYSCTL_H__ +#define __SYSCTL_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// The following are values that can be passed to the +// SysCtlPeripheralPresent(), SysCtlPeripheralEnable(), +// SysCtlPeripheralDisable(), and SysCtlPeripheralReset() APIs as the +// ulPeripheral parameter. The peripherals in the fourth group (upper nibble +// is 3) can only be used with the SysCtlPeripheralPresent() API. +// +//***************************************************************************** +#ifndef DEPRECATED +#define SYSCTL_PERIPH_WDOG 0x00000008 // Watchdog +#endif +#define SYSCTL_PERIPH_WDOG0 0x00000008 // Watchdog 0 +#define SYSCTL_PERIPH_HIBERNATE 0x00000040 // Hibernation module +#ifndef DEPRECATED +#define SYSCTL_PERIPH_ADC 0x00100001 // ADC +#endif +#define SYSCTL_PERIPH_ADC0 0x00100001 // ADC0 +#define SYSCTL_PERIPH_ADC1 0x00100002 // ADC1 +#define SYSCTL_PERIPH_PWM 0x00100010 // PWM +#define SYSCTL_PERIPH_CAN0 0x00100100 // CAN 0 +#define SYSCTL_PERIPH_CAN1 0x00100200 // CAN 1 +#define SYSCTL_PERIPH_CAN2 0x00100400 // CAN 2 +#define SYSCTL_PERIPH_WDOG1 0x00101000 // Watchdog 1 +#define SYSCTL_PERIPH_UART0 0x10000001 // UART 0 +#define SYSCTL_PERIPH_UART1 0x10000002 // UART 1 +#define SYSCTL_PERIPH_UART2 0x10000004 // UART 2 +#ifndef DEPRECATED +#define SYSCTL_PERIPH_SSI 0x10000010 // SSI +#endif +#define SYSCTL_PERIPH_SSI0 0x10000010 // SSI 0 +#define SYSCTL_PERIPH_SSI1 0x10000020 // SSI 1 +#ifndef DEPRECATED +#define SYSCTL_PERIPH_QEI 0x10000100 // QEI +#endif +#define SYSCTL_PERIPH_QEI0 0x10000100 // QEI 0 +#define SYSCTL_PERIPH_QEI1 0x10000200 // QEI 1 +#ifndef DEPRECATED +#define SYSCTL_PERIPH_I2C 0x10001000 // I2C +#endif +#define SYSCTL_PERIPH_I2C0 0x10001000 // I2C 0 +#define SYSCTL_PERIPH_I2C1 0x10004000 // I2C 1 +#define SYSCTL_PERIPH_TIMER0 0x10100001 // Timer 0 +#define SYSCTL_PERIPH_TIMER1 0x10100002 // Timer 1 +#define SYSCTL_PERIPH_TIMER2 0x10100004 // Timer 2 +#define SYSCTL_PERIPH_TIMER3 0x10100008 // Timer 3 +#define SYSCTL_PERIPH_COMP0 0x10100100 // Analog comparator 0 +#define SYSCTL_PERIPH_COMP1 0x10100200 // Analog comparator 1 +#define SYSCTL_PERIPH_COMP2 0x10100400 // Analog comparator 2 +#define SYSCTL_PERIPH_I2S0 0x10101000 // I2S0 +#define SYSCTL_PERIPH_EPI0 0x10104000 // EPI0 +#define SYSCTL_PERIPH_GPIOA 0x20000001 // GPIO A +#define SYSCTL_PERIPH_GPIOB 0x20000002 // GPIO B +#define SYSCTL_PERIPH_GPIOC 0x20000004 // GPIO C +#define SYSCTL_PERIPH_GPIOD 0x20000008 // GPIO D +#define SYSCTL_PERIPH_GPIOE 0x20000010 // GPIO E +#define SYSCTL_PERIPH_GPIOF 0x20000020 // GPIO F +#define SYSCTL_PERIPH_GPIOG 0x20000040 // GPIO G +#define SYSCTL_PERIPH_GPIOH 0x20000080 // GPIO H +#define SYSCTL_PERIPH_GPIOJ 0x20000100 // GPIO J +#define SYSCTL_PERIPH_UDMA 0x20002000 // uDMA +#define SYSCTL_PERIPH_USB0 0x20100001 // USB0 +#define SYSCTL_PERIPH_ETH 0x20105000 // ETH +#define SYSCTL_PERIPH_IEEE1588 0x20100100 // IEEE1588 +#define SYSCTL_PERIPH_PLL 0x30000010 // PLL +#define SYSCTL_PERIPH_TEMP 0x30000020 // Temperature sensor +#define SYSCTL_PERIPH_MPU 0x30000080 // Cortex M3 MPU + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlPinPresent() API +// as the ulPin parameter. +// +//***************************************************************************** +#define SYSCTL_PIN_PWM0 0x00000001 // PWM0 pin +#define SYSCTL_PIN_PWM1 0x00000002 // PWM1 pin +#define SYSCTL_PIN_PWM2 0x00000004 // PWM2 pin +#define SYSCTL_PIN_PWM3 0x00000008 // PWM3 pin +#define SYSCTL_PIN_PWM4 0x00000010 // PWM4 pin +#define SYSCTL_PIN_PWM5 0x00000020 // PWM5 pin +#define SYSCTL_PIN_PWM6 0x00000040 // PWM6 pin +#define SYSCTL_PIN_PWM7 0x00000080 // PWM7 pin +#define SYSCTL_PIN_C0MINUS 0x00000040 // C0- pin +#define SYSCTL_PIN_C0PLUS 0x00000080 // C0+ pin +#define SYSCTL_PIN_C0O 0x00000100 // C0o pin +#define SYSCTL_PIN_C1MINUS 0x00000200 // C1- pin +#define SYSCTL_PIN_C1PLUS 0x00000400 // C1+ pin +#define SYSCTL_PIN_C1O 0x00000800 // C1o pin +#define SYSCTL_PIN_C2MINUS 0x00001000 // C2- pin +#define SYSCTL_PIN_C2PLUS 0x00002000 // C2+ pin +#define SYSCTL_PIN_C2O 0x00004000 // C2o pin +#define SYSCTL_PIN_MC_FAULT0 0x00008000 // MC0 Fault pin +#define SYSCTL_PIN_ADC0 0x00010000 // ADC0 pin +#define SYSCTL_PIN_ADC1 0x00020000 // ADC1 pin +#define SYSCTL_PIN_ADC2 0x00040000 // ADC2 pin +#define SYSCTL_PIN_ADC3 0x00080000 // ADC3 pin +#define SYSCTL_PIN_ADC4 0x00100000 // ADC4 pin +#define SYSCTL_PIN_ADC5 0x00200000 // ADC5 pin +#define SYSCTL_PIN_ADC6 0x00400000 // ADC6 pin +#define SYSCTL_PIN_ADC7 0x00800000 // ADC7 pin +#define SYSCTL_PIN_CCP0 0x01000000 // CCP0 pin +#define SYSCTL_PIN_CCP1 0x02000000 // CCP1 pin +#define SYSCTL_PIN_CCP2 0x04000000 // CCP2 pin +#define SYSCTL_PIN_CCP3 0x08000000 // CCP3 pin +#define SYSCTL_PIN_CCP4 0x10000000 // CCP4 pin +#define SYSCTL_PIN_CCP5 0x20000000 // CCP5 pin +#define SYSCTL_PIN_32KHZ 0x80000000 // 32kHz pin + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlLDOSet() API as +// the ulVoltage value, or returned by the SysCtlLDOGet() API. +// +//***************************************************************************** +#define SYSCTL_LDO_2_25V 0x00000005 // LDO output of 2.25V +#define SYSCTL_LDO_2_30V 0x00000004 // LDO output of 2.30V +#define SYSCTL_LDO_2_35V 0x00000003 // LDO output of 2.35V +#define SYSCTL_LDO_2_40V 0x00000002 // LDO output of 2.40V +#define SYSCTL_LDO_2_45V 0x00000001 // LDO output of 2.45V +#define SYSCTL_LDO_2_50V 0x00000000 // LDO output of 2.50V +#define SYSCTL_LDO_2_55V 0x0000001f // LDO output of 2.55V +#define SYSCTL_LDO_2_60V 0x0000001e // LDO output of 2.60V +#define SYSCTL_LDO_2_65V 0x0000001d // LDO output of 2.65V +#define SYSCTL_LDO_2_70V 0x0000001c // LDO output of 2.70V +#define SYSCTL_LDO_2_75V 0x0000001b // LDO output of 2.75V + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlLDOConfigSet() API. +// +//***************************************************************************** +#define SYSCTL_LDOCFG_ARST 0x00000001 // Allow LDO failure to reset +#define SYSCTL_LDOCFG_NORST 0x00000000 // Do not reset on LDO failure + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlIntEnable(), +// SysCtlIntDisable(), and SysCtlIntClear() APIs, or returned in the bit mask +// by the SysCtlIntStatus() API. +// +//***************************************************************************** +#define SYSCTL_INT_MOSC_PUP 0x00000100 // MOSC power-up interrupt +#define SYSCTL_INT_USBPLL_LOCK 0x00000080 // USB PLL lock interrupt +#define SYSCTL_INT_PLL_LOCK 0x00000040 // PLL lock interrupt +#define SYSCTL_INT_CUR_LIMIT 0x00000020 // Current limit interrupt +#define SYSCTL_INT_IOSC_FAIL 0x00000010 // Internal oscillator failure int +#define SYSCTL_INT_MOSC_FAIL 0x00000008 // Main oscillator failure int +#define SYSCTL_INT_POR 0x00000004 // Power on reset interrupt +#define SYSCTL_INT_BOR 0x00000002 // Brown out interrupt +#define SYSCTL_INT_PLL_FAIL 0x00000001 // PLL failure interrupt + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlResetCauseClear() +// API or returned by the SysCtlResetCauseGet() API. +// +//***************************************************************************** +#define SYSCTL_CAUSE_LDO 0x00000020 // LDO power not OK reset +#define SYSCTL_CAUSE_SW 0x00000010 // Software reset +#define SYSCTL_CAUSE_WDOG 0x00000008 // Watchdog reset +#define SYSCTL_CAUSE_BOR 0x00000004 // Brown-out reset +#define SYSCTL_CAUSE_POR 0x00000002 // Power on reset +#define SYSCTL_CAUSE_EXT 0x00000001 // External reset + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlBrownOutConfigSet() +// API as the ulConfig parameter. +// +//***************************************************************************** +#define SYSCTL_BOR_RESET 0x00000002 // Reset instead of interrupting +#define SYSCTL_BOR_RESAMPLE 0x00000001 // Resample BOR before asserting + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlPWMClockSet() API +// as the ulConfig parameter, and can be returned by the SysCtlPWMClockGet() +// API. +// +//***************************************************************************** +#define SYSCTL_PWMDIV_1 0x00000000 // PWM clock is processor clock /1 +#define SYSCTL_PWMDIV_2 0x00100000 // PWM clock is processor clock /2 +#define SYSCTL_PWMDIV_4 0x00120000 // PWM clock is processor clock /4 +#define SYSCTL_PWMDIV_8 0x00140000 // PWM clock is processor clock /8 +#define SYSCTL_PWMDIV_16 0x00160000 // PWM clock is processor clock /16 +#define SYSCTL_PWMDIV_32 0x00180000 // PWM clock is processor clock /32 +#define SYSCTL_PWMDIV_64 0x001A0000 // PWM clock is processor clock /64 + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlADCSpeedSet() API +// as the ulSpeed parameter, and can be returned by the SyCtlADCSpeedGet() +// API. +// +//***************************************************************************** +#define SYSCTL_ADCSPEED_1MSPS 0x00000F00 // 1,000,000 samples per second +#define SYSCTL_ADCSPEED_500KSPS 0x00000A00 // 500,000 samples per second +#define SYSCTL_ADCSPEED_250KSPS 0x00000500 // 250,000 samples per second +#define SYSCTL_ADCSPEED_125KSPS 0x00000000 // 125,000 samples per second + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlClockSet() API as +// the ulConfig parameter. +// +//***************************************************************************** +#define SYSCTL_SYSDIV_1 0x07800000 // Processor clock is osc/pll /1 +#define SYSCTL_SYSDIV_2 0x00C00000 // Processor clock is osc/pll /2 +#define SYSCTL_SYSDIV_3 0x01400000 // Processor clock is osc/pll /3 +#define SYSCTL_SYSDIV_4 0x01C00000 // Processor clock is osc/pll /4 +#define SYSCTL_SYSDIV_5 0x02400000 // Processor clock is osc/pll /5 +#define SYSCTL_SYSDIV_6 0x02C00000 // Processor clock is osc/pll /6 +#define SYSCTL_SYSDIV_7 0x03400000 // Processor clock is osc/pll /7 +#define SYSCTL_SYSDIV_8 0x03C00000 // Processor clock is osc/pll /8 +#define SYSCTL_SYSDIV_9 0x04400000 // Processor clock is osc/pll /9 +#define SYSCTL_SYSDIV_10 0x04C00000 // Processor clock is osc/pll /10 +#define SYSCTL_SYSDIV_11 0x05400000 // Processor clock is osc/pll /11 +#define SYSCTL_SYSDIV_12 0x05C00000 // Processor clock is osc/pll /12 +#define SYSCTL_SYSDIV_13 0x06400000 // Processor clock is osc/pll /13 +#define SYSCTL_SYSDIV_14 0x06C00000 // Processor clock is osc/pll /14 +#define SYSCTL_SYSDIV_15 0x07400000 // Processor clock is osc/pll /15 +#define SYSCTL_SYSDIV_16 0x07C00000 // Processor clock is osc/pll /16 +#define SYSCTL_SYSDIV_17 0x88400000 // Processor clock is osc/pll /17 +#define SYSCTL_SYSDIV_18 0x88C00000 // Processor clock is osc/pll /18 +#define SYSCTL_SYSDIV_19 0x89400000 // Processor clock is osc/pll /19 +#define SYSCTL_SYSDIV_20 0x89C00000 // Processor clock is osc/pll /20 +#define SYSCTL_SYSDIV_21 0x8A400000 // Processor clock is osc/pll /21 +#define SYSCTL_SYSDIV_22 0x8AC00000 // Processor clock is osc/pll /22 +#define SYSCTL_SYSDIV_23 0x8B400000 // Processor clock is osc/pll /23 +#define SYSCTL_SYSDIV_24 0x8BC00000 // Processor clock is osc/pll /24 +#define SYSCTL_SYSDIV_25 0x8C400000 // Processor clock is osc/pll /25 +#define SYSCTL_SYSDIV_26 0x8CC00000 // Processor clock is osc/pll /26 +#define SYSCTL_SYSDIV_27 0x8D400000 // Processor clock is osc/pll /27 +#define SYSCTL_SYSDIV_28 0x8DC00000 // Processor clock is osc/pll /28 +#define SYSCTL_SYSDIV_29 0x8E400000 // Processor clock is osc/pll /29 +#define SYSCTL_SYSDIV_30 0x8EC00000 // Processor clock is osc/pll /30 +#define SYSCTL_SYSDIV_31 0x8F400000 // Processor clock is osc/pll /31 +#define SYSCTL_SYSDIV_32 0x8FC00000 // Processor clock is osc/pll /32 +#define SYSCTL_SYSDIV_33 0x90400000 // Processor clock is osc/pll /33 +#define SYSCTL_SYSDIV_34 0x90C00000 // Processor clock is osc/pll /34 +#define SYSCTL_SYSDIV_35 0x91400000 // Processor clock is osc/pll /35 +#define SYSCTL_SYSDIV_36 0x91C00000 // Processor clock is osc/pll /36 +#define SYSCTL_SYSDIV_37 0x92400000 // Processor clock is osc/pll /37 +#define SYSCTL_SYSDIV_38 0x92C00000 // Processor clock is osc/pll /38 +#define SYSCTL_SYSDIV_39 0x93400000 // Processor clock is osc/pll /39 +#define SYSCTL_SYSDIV_40 0x93C00000 // Processor clock is osc/pll /40 +#define SYSCTL_SYSDIV_41 0x94400000 // Processor clock is osc/pll /41 +#define SYSCTL_SYSDIV_42 0x94C00000 // Processor clock is osc/pll /42 +#define SYSCTL_SYSDIV_43 0x95400000 // Processor clock is osc/pll /43 +#define SYSCTL_SYSDIV_44 0x95C00000 // Processor clock is osc/pll /44 +#define SYSCTL_SYSDIV_45 0x96400000 // Processor clock is osc/pll /45 +#define SYSCTL_SYSDIV_46 0x96C00000 // Processor clock is osc/pll /46 +#define SYSCTL_SYSDIV_47 0x97400000 // Processor clock is osc/pll /47 +#define SYSCTL_SYSDIV_48 0x97C00000 // Processor clock is osc/pll /48 +#define SYSCTL_SYSDIV_49 0x98400000 // Processor clock is osc/pll /49 +#define SYSCTL_SYSDIV_50 0x98C00000 // Processor clock is osc/pll /50 +#define SYSCTL_SYSDIV_51 0x99400000 // Processor clock is osc/pll /51 +#define SYSCTL_SYSDIV_52 0x99C00000 // Processor clock is osc/pll /52 +#define SYSCTL_SYSDIV_53 0x9A400000 // Processor clock is osc/pll /53 +#define SYSCTL_SYSDIV_54 0x9AC00000 // Processor clock is osc/pll /54 +#define SYSCTL_SYSDIV_55 0x9B400000 // Processor clock is osc/pll /55 +#define SYSCTL_SYSDIV_56 0x9BC00000 // Processor clock is osc/pll /56 +#define SYSCTL_SYSDIV_57 0x9C400000 // Processor clock is osc/pll /57 +#define SYSCTL_SYSDIV_58 0x9CC00000 // Processor clock is osc/pll /58 +#define SYSCTL_SYSDIV_59 0x9D400000 // Processor clock is osc/pll /59 +#define SYSCTL_SYSDIV_60 0x9DC00000 // Processor clock is osc/pll /60 +#define SYSCTL_SYSDIV_61 0x9E400000 // Processor clock is osc/pll /61 +#define SYSCTL_SYSDIV_62 0x9EC00000 // Processor clock is osc/pll /62 +#define SYSCTL_SYSDIV_63 0x9F400000 // Processor clock is osc/pll /63 +#define SYSCTL_SYSDIV_64 0x9FC00000 // Processor clock is osc/pll /64 +#define SYSCTL_SYSDIV_2_5 0xC1000000 // Processor clock is pll / 2.5 +#define SYSCTL_SYSDIV_3_5 0xC1800000 // Processor clock is pll / 3.5 +#define SYSCTL_SYSDIV_4_5 0xC2000000 // Processor clock is pll / 4.5 +#define SYSCTL_SYSDIV_5_5 0xC2800000 // Processor clock is pll / 5.5 +#define SYSCTL_SYSDIV_6_5 0xC3000000 // Processor clock is pll / 6.5 +#define SYSCTL_SYSDIV_7_5 0xC3800000 // Processor clock is pll / 7.5 +#define SYSCTL_SYSDIV_8_5 0xC4000000 // Processor clock is pll / 8.5 +#define SYSCTL_SYSDIV_9_5 0xC4800000 // Processor clock is pll / 9.5 +#define SYSCTL_SYSDIV_10_5 0xC5000000 // Processor clock is pll / 10.5 +#define SYSCTL_SYSDIV_11_5 0xC5800000 // Processor clock is pll / 11.5 +#define SYSCTL_SYSDIV_12_5 0xC6000000 // Processor clock is pll / 12.5 +#define SYSCTL_SYSDIV_13_5 0xC6800000 // Processor clock is pll / 13.5 +#define SYSCTL_SYSDIV_14_5 0xC7000000 // Processor clock is pll / 14.5 +#define SYSCTL_SYSDIV_15_5 0xC7800000 // Processor clock is pll / 15.5 +#define SYSCTL_SYSDIV_16_5 0xC8000000 // Processor clock is pll / 16.5 +#define SYSCTL_SYSDIV_17_5 0xC8800000 // Processor clock is pll / 17.5 +#define SYSCTL_SYSDIV_18_5 0xC9000000 // Processor clock is pll / 18.5 +#define SYSCTL_SYSDIV_19_5 0xC9800000 // Processor clock is pll / 19.5 +#define SYSCTL_SYSDIV_20_5 0xCA000000 // Processor clock is pll / 20.5 +#define SYSCTL_SYSDIV_21_5 0xCA800000 // Processor clock is pll / 21.5 +#define SYSCTL_SYSDIV_22_5 0xCB000000 // Processor clock is pll / 22.5 +#define SYSCTL_SYSDIV_23_5 0xCB800000 // Processor clock is pll / 23.5 +#define SYSCTL_SYSDIV_24_5 0xCC000000 // Processor clock is pll / 24.5 +#define SYSCTL_SYSDIV_25_5 0xCC800000 // Processor clock is pll / 25.5 +#define SYSCTL_SYSDIV_26_5 0xCD000000 // Processor clock is pll / 26.5 +#define SYSCTL_SYSDIV_27_5 0xCD800000 // Processor clock is pll / 27.5 +#define SYSCTL_SYSDIV_28_5 0xCE000000 // Processor clock is pll / 28.5 +#define SYSCTL_SYSDIV_29_5 0xCE800000 // Processor clock is pll / 29.5 +#define SYSCTL_SYSDIV_30_5 0xCF000000 // Processor clock is pll / 30.5 +#define SYSCTL_SYSDIV_31_5 0xCF800000 // Processor clock is pll / 31.5 +#define SYSCTL_SYSDIV_32_5 0xD0000000 // Processor clock is pll / 32.5 +#define SYSCTL_SYSDIV_33_5 0xD0800000 // Processor clock is pll / 33.5 +#define SYSCTL_SYSDIV_34_5 0xD1000000 // Processor clock is pll / 34.5 +#define SYSCTL_SYSDIV_35_5 0xD1800000 // Processor clock is pll / 35.5 +#define SYSCTL_SYSDIV_36_5 0xD2000000 // Processor clock is pll / 36.5 +#define SYSCTL_SYSDIV_37_5 0xD2800000 // Processor clock is pll / 37.5 +#define SYSCTL_SYSDIV_38_5 0xD3000000 // Processor clock is pll / 38.5 +#define SYSCTL_SYSDIV_39_5 0xD3800000 // Processor clock is pll / 39.5 +#define SYSCTL_SYSDIV_40_5 0xD4000000 // Processor clock is pll / 40.5 +#define SYSCTL_SYSDIV_41_5 0xD4800000 // Processor clock is pll / 41.5 +#define SYSCTL_SYSDIV_42_5 0xD5000000 // Processor clock is pll / 42.5 +#define SYSCTL_SYSDIV_43_5 0xD5800000 // Processor clock is pll / 43.5 +#define SYSCTL_SYSDIV_44_5 0xD6000000 // Processor clock is pll / 44.5 +#define SYSCTL_SYSDIV_45_5 0xD6800000 // Processor clock is pll / 45.5 +#define SYSCTL_SYSDIV_46_5 0xD7000000 // Processor clock is pll / 46.5 +#define SYSCTL_SYSDIV_47_5 0xD7800000 // Processor clock is pll / 47.5 +#define SYSCTL_SYSDIV_48_5 0xD8000000 // Processor clock is pll / 48.5 +#define SYSCTL_SYSDIV_49_5 0xD8800000 // Processor clock is pll / 49.5 +#define SYSCTL_SYSDIV_50_5 0xD9000000 // Processor clock is pll / 50.5 +#define SYSCTL_SYSDIV_51_5 0xD9800000 // Processor clock is pll / 51.5 +#define SYSCTL_SYSDIV_52_5 0xDA000000 // Processor clock is pll / 52.5 +#define SYSCTL_SYSDIV_53_5 0xDA800000 // Processor clock is pll / 53.5 +#define SYSCTL_SYSDIV_54_5 0xDB000000 // Processor clock is pll / 54.5 +#define SYSCTL_SYSDIV_55_5 0xDB800000 // Processor clock is pll / 55.5 +#define SYSCTL_SYSDIV_56_5 0xDC000000 // Processor clock is pll / 56.5 +#define SYSCTL_SYSDIV_57_5 0xDC800000 // Processor clock is pll / 57.5 +#define SYSCTL_SYSDIV_58_5 0xDD000000 // Processor clock is pll / 58.5 +#define SYSCTL_SYSDIV_59_5 0xDD800000 // Processor clock is pll / 59.5 +#define SYSCTL_SYSDIV_60_5 0xDE000000 // Processor clock is pll / 60.5 +#define SYSCTL_SYSDIV_61_5 0xDE800000 // Processor clock is pll / 61.5 +#define SYSCTL_SYSDIV_62_5 0xDF000000 // Processor clock is pll / 62.5 +#define SYSCTL_SYSDIV_63_5 0xDF800000 // Processor clock is pll / 63.5 +#define SYSCTL_USE_PLL 0x00000000 // System clock is the PLL clock +#define SYSCTL_USE_OSC 0x00003800 // System clock is the osc clock +#define SYSCTL_XTAL_1MHZ 0x00000000 // External crystal is 1MHz +#define SYSCTL_XTAL_1_84MHZ 0x00000040 // External crystal is 1.8432MHz +#define SYSCTL_XTAL_2MHZ 0x00000080 // External crystal is 2MHz +#define SYSCTL_XTAL_2_45MHZ 0x000000C0 // External crystal is 2.4576MHz +#define SYSCTL_XTAL_3_57MHZ 0x00000100 // External crystal is 3.579545MHz +#define SYSCTL_XTAL_3_68MHZ 0x00000140 // External crystal is 3.6864MHz +#define SYSCTL_XTAL_4MHZ 0x00000180 // External crystal is 4MHz +#define SYSCTL_XTAL_4_09MHZ 0x000001C0 // External crystal is 4.096MHz +#define SYSCTL_XTAL_4_91MHZ 0x00000200 // External crystal is 4.9152MHz +#define SYSCTL_XTAL_5MHZ 0x00000240 // External crystal is 5MHz +#define SYSCTL_XTAL_5_12MHZ 0x00000280 // External crystal is 5.12MHz +#define SYSCTL_XTAL_6MHZ 0x000002C0 // External crystal is 6MHz +#define SYSCTL_XTAL_6_14MHZ 0x00000300 // External crystal is 6.144MHz +#define SYSCTL_XTAL_7_37MHZ 0x00000340 // External crystal is 7.3728MHz +#define SYSCTL_XTAL_8MHZ 0x00000380 // External crystal is 8MHz +#define SYSCTL_XTAL_8_19MHZ 0x000003C0 // External crystal is 8.192MHz +#define SYSCTL_XTAL_10MHZ 0x00000400 // External crystal is 10 MHz +#define SYSCTL_XTAL_12MHZ 0x00000440 // External crystal is 12 MHz +#define SYSCTL_XTAL_12_2MHZ 0x00000480 // External crystal is 12.288 MHz +#define SYSCTL_XTAL_13_5MHZ 0x000004C0 // External crystal is 13.56 MHz +#define SYSCTL_XTAL_14_3MHZ 0x00000500 // External crystal is 14.31818 MHz +#define SYSCTL_XTAL_16MHZ 0x00000540 // External crystal is 16 MHz +#define SYSCTL_XTAL_16_3MHZ 0x00000580 // External crystal is 16.384 MHz +#define SYSCTL_OSC_MAIN 0x00000000 // Osc source is main osc +#define SYSCTL_OSC_INT 0x00000010 // Osc source is int. osc +#define SYSCTL_OSC_INT4 0x00000020 // Osc source is int. osc /4 +#define SYSCTL_OSC_INT30 0x00000030 // Osc source is int. 30 KHz +#define SYSCTL_OSC_EXT4_19 0x80000028 // Osc source is ext. 4.19 MHz +#define SYSCTL_OSC_EXT32 0x80000038 // Osc source is ext. 32 KHz +#define SYSCTL_INT_PIOSC_DIS 0x00000004 // Disable interal precision osc. +#define SYSCTL_INT_OSC_DIS 0x00000002 // Disable internal oscillator +#define SYSCTL_MAIN_OSC_DIS 0x00000001 // Disable main oscillator + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern unsigned long SysCtlSRAMSizeGet(void); +extern unsigned long SysCtlFlashSizeGet(void); +extern tBoolean SysCtlPinPresent(unsigned long ulPin); +extern tBoolean SysCtlPeripheralPresent(unsigned long ulPeripheral); +extern void SysCtlPeripheralReset(unsigned long ulPeripheral); +extern void SysCtlPeripheralEnable(unsigned long ulPeripheral); +extern void SysCtlPeripheralDisable(unsigned long ulPeripheral); +extern void SysCtlPeripheralSleepEnable(unsigned long ulPeripheral); +extern void SysCtlPeripheralSleepDisable(unsigned long ulPeripheral); +extern void SysCtlPeripheralDeepSleepEnable(unsigned long ulPeripheral); +extern void SysCtlPeripheralDeepSleepDisable(unsigned long ulPeripheral); +extern void SysCtlPeripheralClockGating(tBoolean bEnable); +extern void SysCtlIntRegister(void (*pfnHandler)(void)); +extern void SysCtlIntUnregister(void); +extern void SysCtlIntEnable(unsigned long ulInts); +extern void SysCtlIntDisable(unsigned long ulInts); +extern void SysCtlIntClear(unsigned long ulInts); +extern unsigned long SysCtlIntStatus(tBoolean bMasked); +extern void SysCtlLDOSet(unsigned long ulVoltage); +extern unsigned long SysCtlLDOGet(void); +extern void SysCtlLDOConfigSet(unsigned long ulConfig); +extern void SysCtlReset(void); +extern void SysCtlSleep(void); +extern void SysCtlDeepSleep(void); +extern unsigned long SysCtlResetCauseGet(void); +extern void SysCtlResetCauseClear(unsigned long ulCauses); +extern void SysCtlBrownOutConfigSet(unsigned long ulConfig, + unsigned long ulDelay); +extern void SysCtlDelay(unsigned long ulCount); +extern void SysCtlClockSet(unsigned long ulConfig); +extern unsigned long SysCtlClockGet(void); +extern void SysCtlPWMClockSet(unsigned long ulConfig); +extern unsigned long SysCtlPWMClockGet(void); +extern void SysCtlADCSpeedSet(unsigned long ulSpeed); +extern unsigned long SysCtlADCSpeedGet(void); +extern void SysCtlIOSCVerificationSet(tBoolean bEnable); +extern void SysCtlMOSCVerificationSet(tBoolean bEnable); +extern void SysCtlPLLVerificationSet(tBoolean bEnable); +extern void SysCtlClkVerificationClear(void); +extern void SysCtlGPIOAHBEnable(unsigned long ulGPIOPeripheral); +extern void SysCtlGPIOAHBDisable(unsigned long ulGPIOPeripheral); +extern void SysCtlUSBPLLEnable(void); +extern void SysCtlUSBPLLDisable(void); +extern unsigned long SysCtlI2SMClkSet(unsigned long ulInputClock, + unsigned long ulMClk); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __SYSCTL_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/uartlib.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/uartlib.c new file mode 100644 index 00000000..86ddc668 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/uartlib.c @@ -0,0 +1,1611 @@ +//***************************************************************************** +// +// uart.c - Driver for the UART. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup uart_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_sysctl.h" +#include "inc/hw_types.h" +#include "inc/hw_uart.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" +#include "driverlib/uartlib.h" + +//***************************************************************************** +// +// The system clock divider defining the maximum baud rate supported by the +// UART. +// +//***************************************************************************** +#define UART_CLK_DIVIDER ((CLASS_IS_SANDSTORM || \ + (CLASS_IS_FURY && REVISION_IS_A2) || \ + (CLASS_IS_DUSTDEVIL && REVISION_IS_A0)) ? \ + 16 : 8) + +//***************************************************************************** +// +//! \internal +//! Checks a UART base address. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function determines if a UART port base address is valid. +//! +//! \return Returns \b true if the base address is valid and \b false +//! otherwise. +// +//***************************************************************************** +#ifdef DEBUG +static tBoolean +UARTBaseValid(unsigned long ulBase) +{ + return((ulBase == UART0_BASE) || (ulBase == UART1_BASE) || + (ulBase == UART2_BASE)); +} +#endif + +//***************************************************************************** +// +//! Sets the type of parity. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulParity specifies the type of parity to use. +//! +//! Sets the type of parity to use for transmitting and expect when receiving. +//! The \e ulParity parameter must be one of \b UART_CONFIG_PAR_NONE, +//! \b UART_CONFIG_PAR_EVEN, \b UART_CONFIG_PAR_ODD, \b UART_CONFIG_PAR_ONE, +//! or \b UART_CONFIG_PAR_ZERO. The last two allow direct control of the +//! parity bit; it is always either one or zero based on the mode. +//! +//! \return None. +// +//***************************************************************************** +void +UARTParityModeSet(unsigned long ulBase, unsigned long ulParity) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + ASSERT((ulParity == UART_CONFIG_PAR_NONE) || + (ulParity == UART_CONFIG_PAR_EVEN) || + (ulParity == UART_CONFIG_PAR_ODD) || + (ulParity == UART_CONFIG_PAR_ONE) || + (ulParity == UART_CONFIG_PAR_ZERO)); + + // + // Set the parity mode. + // + HWREG(ulBase + UART_O_LCRH) = ((HWREG(ulBase + UART_O_LCRH) & + ~(UART_LCRH_SPS | UART_LCRH_EPS | + UART_LCRH_PEN)) | ulParity); +} + +//***************************************************************************** +// +//! Gets the type of parity currently being used. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function gets the type of parity used for transmitting data and +//! expected when receiving data. +//! +//! \return Returns the current parity settings, specified as one of +//! \b UART_CONFIG_PAR_NONE, \b UART_CONFIG_PAR_EVEN, \b UART_CONFIG_PAR_ODD, +//! \b UART_CONFIG_PAR_ONE, or \b UART_CONFIG_PAR_ZERO. +// +//***************************************************************************** +unsigned long +UARTParityModeGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Return the current parity setting. + // + return(HWREG(ulBase + UART_O_LCRH) & + (UART_LCRH_SPS | UART_LCRH_EPS | UART_LCRH_PEN)); +} + +//***************************************************************************** +// +//! Sets the FIFO level at which interrupts are generated. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulTxLevel is the transmit FIFO interrupt level, specified as one of +//! \b UART_FIFO_TX1_8, \b UART_FIFO_TX2_8, \b UART_FIFO_TX4_8, +//! \b UART_FIFO_TX6_8, or \b UART_FIFO_TX7_8. +//! \param ulRxLevel is the receive FIFO interrupt level, specified as one of +//! \b UART_FIFO_RX1_8, \b UART_FIFO_RX2_8, \b UART_FIFO_RX4_8, +//! \b UART_FIFO_RX6_8, or \b UART_FIFO_RX7_8. +//! +//! This function sets the FIFO level at which transmit and receive interrupts +//! are generated. +//! +//! \return None. +// +//***************************************************************************** +void +UARTFIFOLevelSet(unsigned long ulBase, unsigned long ulTxLevel, + unsigned long ulRxLevel) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + ASSERT((ulTxLevel == UART_FIFO_TX1_8) || + (ulTxLevel == UART_FIFO_TX2_8) || + (ulTxLevel == UART_FIFO_TX4_8) || + (ulTxLevel == UART_FIFO_TX6_8) || + (ulTxLevel == UART_FIFO_TX7_8)); + ASSERT((ulRxLevel == UART_FIFO_RX1_8) || + (ulRxLevel == UART_FIFO_RX2_8) || + (ulRxLevel == UART_FIFO_RX4_8) || + (ulRxLevel == UART_FIFO_RX6_8) || + (ulRxLevel == UART_FIFO_RX7_8)); + + // + // Set the FIFO interrupt levels. + // + HWREG(ulBase + UART_O_IFLS) = ulTxLevel | ulRxLevel; +} + +//***************************************************************************** +// +//! Gets the FIFO level at which interrupts are generated. +//! +//! \param ulBase is the base address of the UART port. +//! \param pulTxLevel is a pointer to storage for the transmit FIFO level, +//! returned as one of \b UART_FIFO_TX1_8, \b UART_FIFO_TX2_8, +//! \b UART_FIFO_TX4_8, \b UART_FIFO_TX6_8, or \b UART_FIFO_TX7_8. +//! \param pulRxLevel is a pointer to storage for the receive FIFO level, +//! returned as one of \b UART_FIFO_RX1_8, \b UART_FIFO_RX2_8, +//! \b UART_FIFO_RX4_8, \b UART_FIFO_RX6_8, or \b UART_FIFO_RX7_8. +//! +//! This function gets the FIFO level at which transmit and receive interrupts +//! are generated. +//! +//! \return None. +// +//***************************************************************************** +void +UARTFIFOLevelGet(unsigned long ulBase, unsigned long *pulTxLevel, + unsigned long *pulRxLevel) +{ + unsigned long ulTemp; + + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Read the FIFO level register. + // + ulTemp = HWREG(ulBase + UART_O_IFLS); + + // + // Extract the transmit and receive FIFO levels. + // + *pulTxLevel = ulTemp & UART_IFLS_TX_M; + *pulRxLevel = ulTemp & UART_IFLS_RX_M; +} + +//***************************************************************************** +// +//! Sets the configuration of a UART. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulUARTClk is the rate of the clock supplied to the UART module. +//! \param ulBaud is the desired baud rate. +//! \param ulConfig is the data format for the port (number of data bits, +//! number of stop bits, and parity). +//! +//! This function configures the UART for operation in the specified data +//! format. The baud rate is provided in the \e ulBaud parameter and the data +//! format in the \e ulConfig parameter. +//! +//! The \e ulConfig parameter is the logical OR of three values: the number of +//! data bits, the number of stop bits, and the parity. \b UART_CONFIG_WLEN_8, +//! \b UART_CONFIG_WLEN_7, \b UART_CONFIG_WLEN_6, and \b UART_CONFIG_WLEN_5 +//! select from eight to five data bits per byte (respectively). +//! \b UART_CONFIG_STOP_ONE and \b UART_CONFIG_STOP_TWO select one or two stop +//! bits (respectively). \b UART_CONFIG_PAR_NONE, \b UART_CONFIG_PAR_EVEN, +//! \b UART_CONFIG_PAR_ODD, \b UART_CONFIG_PAR_ONE, and \b UART_CONFIG_PAR_ZERO +//! select the parity mode (no parity bit, even parity bit, odd parity bit, +//! parity bit always one, and parity bit always zero, respectively). +//! +//! The peripheral clock will be the same as the processor clock. This will be +//! the value returned by SysCtlClockGet(), or it can be explicitly hard coded +//! if it is constant and known (to save the code/execution overhead of a call +//! to SysCtlClockGet()). +//! +//! This function replaces the original UARTConfigSet() API and performs the +//! same actions. A macro is provided in uart.h to map the original +//! API to this API. +//! +//! \return None. +// +//***************************************************************************** +void +UARTConfigSetExpClk(unsigned long ulBase, unsigned long ulUARTClk, + unsigned long ulBaud, unsigned long ulConfig) +{ + unsigned long ulDiv; + + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + ASSERT(ulBaud != 0); + ASSERT(ulUARTClk >= (ulBaud * UART_CLK_DIVIDER)); + + // + // Stop the UART. + // + UARTDisable(ulBase); + + // + // Is the required baud rate greater than the maximum rate supported + // without the use of high speed mode? + // + if((ulBaud * 16) > ulUARTClk) + { + // + // Enable high speed mode. + // + HWREG(ulBase + UART_O_CTL) |= UART_CTL_HSE; + + // + // Half the supplied baud rate to compensate for enabling high speed + // mode. This allows the following code to be common to both cases. + // + ulBaud /= 2; + } + else + { + // + // Disable high speed mode. + // + HWREG(ulBase + UART_O_CTL) &= ~(UART_CTL_HSE); + } + + // + // Compute the fractional baud rate divider. + // + ulDiv = (((ulUARTClk * 8) / ulBaud) + 1) / 2; + + // + // Set the baud rate. + // + HWREG(ulBase + UART_O_IBRD) = ulDiv / 64; + HWREG(ulBase + UART_O_FBRD) = ulDiv % 64; + + // + // Set parity, data length, and number of stop bits. + // + HWREG(ulBase + UART_O_LCRH) = ulConfig; + + // + // Clear the flags register. + // + HWREG(ulBase + UART_O_FR) = 0; + + // + // Start the UART. + // + UARTEnable(ulBase); +} + +//***************************************************************************** +// +//! Gets the current configuration of a UART. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulUARTClk is the rate of the clock supplied to the UART module. +//! \param pulBaud is a pointer to storage for the baud rate. +//! \param pulConfig is a pointer to storage for the data format. +//! +//! The baud rate and data format for the UART is determined, given an +//! explicitly provided peripheral clock (hence the ExpClk suffix). The +//! returned baud rate is the actual baud rate; it may not be the exact baud +//! rate requested or an ``official'' baud rate. The data format returned in +//! \e pulConfig is enumerated the same as the \e ulConfig parameter of +//! UARTConfigSetExpClk(). +//! +//! The peripheral clock will be the same as the processor clock. This will be +//! the value returned by SysCtlClockGet(), or it can be explicitly hard coded +//! if it is constant and known (to save the code/execution overhead of a call +//! to SysCtlClockGet()). +//! +//! This function replaces the original UARTConfigGet() API and performs the +//! same actions. A macro is provided in uart.h to map the original +//! API to this API. +//! +//! \return None. +// +//***************************************************************************** +void +UARTConfigGetExpClk(unsigned long ulBase, unsigned long ulUARTClk, + unsigned long *pulBaud, unsigned long *pulConfig) +{ + unsigned long ulInt, ulFrac; + + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Compute the baud rate. + // + ulInt = HWREG(ulBase + UART_O_IBRD); + ulFrac = HWREG(ulBase + UART_O_FBRD); + *pulBaud = (ulUARTClk * 4) / ((64 * ulInt) + ulFrac); + + // + // See if high speed mode enabled. + // + if(HWREG(ulBase + UART_O_CTL) & UART_CTL_HSE) + { + // + // High speed mode is enabled so the actual baud rate is actually + // double what was just calculated. + // + *pulBaud *= 2; + } + + // + // Get the parity, data length, and number of stop bits. + // + *pulConfig = (HWREG(ulBase + UART_O_LCRH) & + (UART_LCRH_SPS | UART_LCRH_WLEN_M | UART_LCRH_STP2 | + UART_LCRH_EPS | UART_LCRH_PEN)); +} + +//***************************************************************************** +// +//! Enables transmitting and receiving. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Sets the UARTEN, TXE, and RXE bits, and enables the transmit and receive +//! FIFOs. +//! +//! \return None. +// +//***************************************************************************** +void +UARTEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Enable the FIFO. + // + HWREG(ulBase + UART_O_LCRH) |= UART_LCRH_FEN; + + // + // Enable RX, TX, and the UART. + // + HWREG(ulBase + UART_O_CTL) |= (UART_CTL_UARTEN | UART_CTL_TXE | + UART_CTL_RXE); +} + +//***************************************************************************** +// +//! Disables transmitting and receiving. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Clears the UARTEN, TXE, and RXE bits, then waits for the end of +//! transmission of the current character, and flushes the transmit FIFO. +//! +//! \return None. +// +//***************************************************************************** +void +UARTDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Wait for end of TX. + // + while(HWREG(ulBase + UART_O_FR) & UART_FR_BUSY) + { + } + + // + // Disable the FIFO. + // + HWREG(ulBase + UART_O_LCRH) &= ~(UART_LCRH_FEN); + + // + // Disable the UART. + // + HWREG(ulBase + UART_O_CTL) &= ~(UART_CTL_UARTEN | UART_CTL_TXE | + UART_CTL_RXE); +} + +//***************************************************************************** +// +//! Enables the transmit and receive FIFOs. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This functions enables the transmit and receive FIFOs in the UART. +//! +//! \return None. +// +//***************************************************************************** +void +UARTFIFOEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Enable the FIFO. + // + HWREG(ulBase + UART_O_LCRH) |= UART_LCRH_FEN; +} + +//***************************************************************************** +// +//! Disables the transmit and receive FIFOs. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This functions disables the transmit and receive FIFOs in the UART. +//! +//! \return None. +// +//***************************************************************************** +void +UARTFIFODisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Disable the FIFO. + // + HWREG(ulBase + UART_O_LCRH) &= ~(UART_LCRH_FEN); +} + +//***************************************************************************** +// +//! Enables SIR (IrDA) mode on the specified UART. +//! +//! \param ulBase is the base address of the UART port. +//! \param bLowPower indicates if SIR Low Power Mode is to be used. +//! +//! Enables the SIREN control bit for IrDA mode on the UART. If the +//! \e bLowPower flag is set, then SIRLP bit will also be set. +//! +//! \note SIR (IrDA) operation is not supported on Sandstorm-class devices. +//! +//! \return None. +// +//***************************************************************************** +void +UARTEnableSIR(unsigned long ulBase, tBoolean bLowPower) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Enable SIR and SIRLP (if appropriate). + // + if(bLowPower) + { + HWREG(ulBase + UART_O_CTL) |= (UART_CTL_SIREN | UART_CTL_SIRLP); + } + else + { + HWREG(ulBase + UART_O_CTL) |= (UART_CTL_SIREN); + } +} + +//***************************************************************************** +// +//! Disables SIR (IrDA) mode on the specified UART. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Clears the SIREN (IrDA) and SIRLP (Low Power) bits. +//! +//! \note SIR (IrDA) operation is not supported on Sandstorm-class devices. +//! +//! \return None. +// +//***************************************************************************** +void +UARTDisableSIR(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Disable SIR and SIRLP (if appropriate). + // + HWREG(ulBase + UART_O_CTL) &= ~(UART_CTL_SIREN | UART_CTL_SIRLP); +} + +//***************************************************************************** +// +//! Enables ISO 7816 smart card mode on the specified UART. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Enables the SMART control bit for ISO 7816 smart card mode on the UART. +//! This call also sets 8 bit word length and even parity as required by ISO +//! 7816. +//! +//! \note The availability of ISO 7816 smart card mode varies with the +//! Stellaris part and UART in use. Please consult the datasheet for the part +//! you are using to determine whether this support is available. +//! +//! \return None. +// +//***************************************************************************** +void +UARTSmartCardEnable(unsigned long ulBase) +{ + unsigned long ulVal; + + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(UARTBaseValid(ulBase)); + + // + // Set 8 bit word length, even parity, 2 stop bits (even though the STP2 + // bit is ignored when in smartcard mode, this lets the caller read back + // the actual setting in use). + // + ulVal = HWREG(ulBase + UART_O_LCRH); + ulVal &= ~(UART_LCRH_SPS | UART_LCRH_EPS | UART_LCRH_PEN | + UART_LCRH_WLEN_M); + ulVal |= UART_LCRH_WLEN_8 | UART_LCRH_PEN | UART_LCRH_EPS | UART_LCRH_STP2; + HWREG(ulBase + UART_O_LCRH) = ulVal; + + // + // Enable SMART mode. + // + HWREG(ulBase + UART_O_CTL) |= UART_CTL_SMART; +} + +//***************************************************************************** +// +//! Disables ISO 7816 smart card mode on the specified UART. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Clears the SMART (ISO 7816 smart card) bits in the UART control register. +//! +//! \note The availability of ISO 7816 smart card mode varies with the +//! Stellaris part and UART in use. Please consult the datasheet for the part +//! you are using to determine whether this support is available. +//! +//! \return None. +// +//***************************************************************************** +void +UARTSmartCardDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(UARTBaseValid(ulBase)); + + // + // Disable the SMART bit. + // + HWREG(ulBase + UART_O_CTL) &= ~UART_CTL_SMART; +} + +//***************************************************************************** +// +//! Sets the states of the DTR and/or RTS modem control signals. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulControl is a bit-mapped flag indicating which modem control bits +//! should be set. +//! +//! Sets the states of the DTR or RTS modem handshake outputs from the UART. +//! +//! The \e ulControl parameter is the logical OR of any of the following: +//! +//! - \b UART_OUTPUT_DTR - The Modem Control DTR signal +//! - \b UART_OUTPUT_RTS - The Modem Control RTS signal +//! +//! \note The availability of hardware modem handshake signals varies with the +//! Stellaris part and UART in use. Please consult the datasheet for the part +//! you are using to determine whether this support is available. +//! +//! \return None. +// +//***************************************************************************** +void +UARTModemControlSet(unsigned long ulBase, unsigned long ulControl) +{ + unsigned long ulTemp; + + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(ulBase == UART1_BASE); + ASSERT((ulControl & ~(UART_OUTPUT_RTS | UART_OUTPUT_DTR)) == 0); + + // + // Set the appropriate modem control output bits. + // + ulTemp = HWREG(ulBase + UART_O_CTL); + ulTemp |= (ulControl & (UART_OUTPUT_RTS | UART_OUTPUT_DTR)); + HWREG(ulBase + UART_O_CTL) = ulTemp; +} + +//***************************************************************************** +// +//! Clears the states of the DTR and/or RTS modem control signals. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulControl is a bit-mapped flag indicating which modem control bits +//! should be set. +//! +//! Clears the states of the DTR or RTS modem handshake outputs from the UART. +//! +//! The \e ulControl parameter is the logical OR of any of the following: +//! +//! - \b UART_OUTPUT_DTR - The Modem Control DTR signal +//! - \b UART_OUTPUT_RTS - The Modem Control RTS signal +//! +//! \note The availability of hardware modem handshake signals varies with the +//! Stellaris part and UART in use. Please consult the datasheet for the part +//! you are using to determine whether this support is available. +//! +//! \return None. +// +//***************************************************************************** +void +UARTModemControlClear(unsigned long ulBase, unsigned long ulControl) +{ + unsigned long ulTemp; + + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(ulBase == UART1_BASE); + ASSERT((ulControl & ~(UART_OUTPUT_RTS | UART_OUTPUT_DTR)) == 0); + + // + // Set the appropriate modem control output bits. + // + ulTemp = HWREG(ulBase + UART_O_CTL); + ulTemp &= ~(ulControl & (UART_OUTPUT_RTS | UART_OUTPUT_DTR)); + HWREG(ulBase + UART_O_CTL) = ulTemp; +} + +//***************************************************************************** +// +//! Gets the states of the DTR and RTS modem control signals. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Returns the current states of each of the two UART modem control signals, +//! DTR and RTS. +//! +//! \note The availability of hardware modem handshake signals varies with the +//! Stellaris part and UART in use. Please consult the datasheet for the part +//! you are using to determine whether this support is available. +//! +//! \return Returns the states of the handshake output signals. This will be a +//! logical logical OR combination of values \b UART_OUTPUT_RTS and +//! \b UART_OUTPUT_DTR where the presence of each flag indicates that the +//! associated signal is asserted. +// +//***************************************************************************** +unsigned long +UARTModemControlGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(ulBase == UART1_BASE); + + return(HWREG(ulBase + UART_O_CTL) & (UART_OUTPUT_RTS | UART_OUTPUT_DTR)); +} + +//***************************************************************************** +// +//! Gets the states of the RI, DCD, DSR and CTS modem status signals. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Returns the current states of each of the four UART modem status signals, +//! RI, DCD, DSR and CTS. +//! +//! \note The availability of hardware modem handshake signals varies with the +//! Stellaris part and UART in use. Please consult the datasheet for the part +//! you are using to determine whether this support is available. +//! +//! \return Returns the states of the handshake output signals. This will be a +//! logical logical OR combination of values \b UART_INPUT_RI, \b +//! UART_INPUT_DCD, \b UART_INPUT_CTS and \b UART_INPUT_DSR where the +//! presence of each flag indicates that the associated signal is asserted. +// +//***************************************************************************** +unsigned long +UARTModemStatusGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(ulBase == UART1_BASE); + + return(HWREG(ulBase + UART_O_FR) & (UART_INPUT_RI | UART_INPUT_DCD | + UART_INPUT_CTS | UART_INPUT_DSR)); +} + +//***************************************************************************** +// +//! Sets the UART hardware flow control mode to be used. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulMode indicates the flow control modes to be used. This is a +//! logical OR combination of values \b UART_FLOWCONTROL_TX and \b +//! UART_FLOWCONTROL_RX to enable hardware transmit (CTS) and receive (RTS) +//! flow control or \b UART_FLOWCONTROL_NONE to disable hardware flow control. +//! +//! Sets the required hardware flow control modes. If \e ulMode contains +//! flag \b UART_FLOWCONTROL_TX, data is only transmitted if the incoming CTS +//! signal is asserted. If \e ulMode contains flag \b UART_FLOWCONTROL_RX, +//! the RTS output is controlled by the hardware and is asserted only when +//! there is space available in the receive FIFO. If no hardware flow control +//! is required, UART_FLOWCONTROL_NONE should be passed. +//! +//! \note The availability of hardware flow control varies with the Stellaris +//! part and UART in use. Please consult the datasheet for the part you are +//! using to determine whether this support is available. +//! +//! \return None. +// +//***************************************************************************** +void +UARTFlowControlSet(unsigned long ulBase, unsigned long ulMode) +{ + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(UARTBaseValid(ulBase)); + ASSERT((ulMode & ~(UART_FLOWCONTROL_TX | UART_FLOWCONTROL_RX)) == 0); + + // + // Set the flow control mode as requested. + // + HWREG(ulBase + UART_O_CTL) = ((HWREG(ulBase + UART_O_CTL) & + ~(UART_FLOWCONTROL_TX | + UART_FLOWCONTROL_RX)) | ulMode); +} + +//***************************************************************************** +// +//! Returns the UART hardware flow control mode currently in use. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Returns the current hardware flow control mode. +//! +//! \note The availability of hardware flow control varies with the Stellaris +//! part and UART in use. Please consult the datasheet for the part you are +//! using to determine whether this support is available. +//! +//! \return Returns the current flow control mode in use. This is a +//! logical OR combination of values \b UART_FLOWCONTROL_TX if transmit +//! (CTS) flow control is enabled and \b UART_FLOWCONTROL_RX if receive (RTS) +//! flow control is in use. If hardware flow control is disabled, \b +//! UART_FLOWCONTROL_NONE will be returned. +// +//***************************************************************************** +unsigned long +UARTFlowControlGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(UARTBaseValid(ulBase)); + + return(HWREG(ulBase + UART_O_CTL) & (UART_FLOWCONTROL_TX | + UART_FLOWCONTROL_RX)); +} + +//***************************************************************************** +// +//! Sets the operating mode for the UART transmit interrupt. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulMode is the operating mode for the transmit interrupt. It may be +//! \b UART_TXINT_MODE_EOT to trigger interrupts when the transmitter is idle +//! or \b UART_TXINT_MODE_FIFO to trigger based on the current transmit FIFO +//! level. +//! +//! This function allows the mode of the UART transmit interrupt to be set. By +//! default, the transmit interrupt is asserted when the FIFO level falls past +//! a threshold set via a call to UARTFIFOLevelSet(). Alternatively, if this +//! function is called with \e ulMode set to \b UART_TXINT_MODE_EOT, the +//! transmit interrupt will only be asserted once the transmitter is completely +//! idle - the transmit FIFO is empty and all bits, including any stop bits, +//! have cleared the transmitter. +//! +//! \note The availability of end-of-transmission mode varies with the +//! Stellaris part in use. Please consult the datasheet for the part you are +//! using to determine whether this support is available. +//! +//! \return None. +// +//***************************************************************************** +void +UARTTxIntModeSet(unsigned long ulBase, unsigned long ulMode) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + ASSERT((ulMode == UART_TXINT_MODE_EOT) || + (ulMode == UART_TXINT_MODE_FIFO)); + + // + // Set or clear the EOT bit of the UART control register as appropriate. + // + HWREG(ulBase + UART_O_CTL) = ((HWREG(ulBase + UART_O_CTL) & + ~(UART_TXINT_MODE_EOT | + UART_TXINT_MODE_FIFO)) | ulMode); +} + +//***************************************************************************** +// +//! Returns the current operating mode for the UART transmit interrupt. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function returns the current operating mode for the UART transmit +//! interrupt. The return value will be \b UART_TXINT_MODE_EOT if the +//! transmit interrupt is currently set to be asserted once the transmitter is +//! completely idle - the transmit FIFO is empty and all bits, including any +//! stop bits, have cleared the transmitter. The return value will be \b +//! UART_TXINT_MODE_FIFO if the interrupt is set to be asserted based upon the +//! level of the transmit FIFO. +//! +//! \note The availability of end-of-transmission mode varies with the +//! Stellaris part in use. Please consult the datasheet for the part you are +//! using to determine whether this support is available. +//! +//! \return Returns \b UART_TXINT_MODE_FIFO or \b UART_TXINT_MODE_EOT. +// +//***************************************************************************** +unsigned long +UARTTxIntModeGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Return the current transmit interrupt mode. + // + return(HWREG(ulBase + UART_O_CTL) & (UART_TXINT_MODE_EOT | + UART_TXINT_MODE_FIFO)); +} + +//***************************************************************************** +// +//! Determines if there are any characters in the receive FIFO. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function returns a flag indicating whether or not there is data +//! available in the receive FIFO. +//! +//! \return Returns \b true if there is data in the receive FIFO or \b false +//! if there is no data in the receive FIFO. +// +//***************************************************************************** +tBoolean +UARTCharsAvail(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Return the availability of characters. + // + return((HWREG(ulBase + UART_O_FR) & UART_FR_RXFE) ? false : true); +} + +//***************************************************************************** +// +//! Determines if there is any space in the transmit FIFO. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function returns a flag indicating whether or not there is space +//! available in the transmit FIFO. +//! +//! \return Returns \b true if there is space available in the transmit FIFO +//! or \b false if there is no space available in the transmit FIFO. +// +//***************************************************************************** +tBoolean +UARTSpaceAvail(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Return the availability of space. + // + return((HWREG(ulBase + UART_O_FR) & UART_FR_TXFF) ? false : true); +} + +//***************************************************************************** +// +//! Receives a character from the specified port. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Gets a character from the receive FIFO for the specified port. +//! +//! This function replaces the original UARTCharNonBlockingGet() API and +//! performs the same actions. A macro is provided in uart.h to map +//! the original API to this API. +//! +//! \return Returns the character read from the specified port, cast as a +//! \e long. A \b -1 is returned if there are no characters present in the +//! receive FIFO. The UARTCharsAvail() function should be called before +//! attempting to call this function. +// +//***************************************************************************** +long +UARTCharGetNonBlocking(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // See if there are any characters in the receive FIFO. + // + if(!(HWREG(ulBase + UART_O_FR) & UART_FR_RXFE)) + { + // + // Read and return the next character. + // + return(HWREG(ulBase + UART_O_DR)); + } + else + { + // + // There are no characters, so return a failure. + // + return(-1); + } +} + +//***************************************************************************** +// +//! Waits for a character from the specified port. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Gets a character from the receive FIFO for the specified port. If there +//! are no characters available, this function waits until a character is +//! received before returning. +//! +//! \return Returns the character read from the specified port, cast as a +//! \e long. +// +//***************************************************************************** +long +UARTCharGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Wait until a char is available. + // + while(HWREG(ulBase + UART_O_FR) & UART_FR_RXFE) + { + } + + // + // Now get the char. + // + return(HWREG(ulBase + UART_O_DR)); +} + +//***************************************************************************** +// +//! Sends a character to the specified port. +//! +//! \param ulBase is the base address of the UART port. +//! \param ucData is the character to be transmitted. +//! +//! Writes the character \e ucData to the transmit FIFO for the specified port. +//! This function does not block, so if there is no space available, then a +//! \b false is returned, and the application must retry the function later. +//! +//! This function replaces the original UARTCharNonBlockingPut() API and +//! performs the same actions. A macro is provided in uart.h to map +//! the original API to this API. +//! +//! \return Returns \b true if the character was successfully placed in the +//! transmit FIFO or \b false if there was no space available in the transmit +//! FIFO. +// +//***************************************************************************** +tBoolean +UARTCharPutNonBlocking(unsigned long ulBase, unsigned char ucData) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // See if there is space in the transmit FIFO. + // + if(!(HWREG(ulBase + UART_O_FR) & UART_FR_TXFF)) + { + // + // Write this character to the transmit FIFO. + // + HWREG(ulBase + UART_O_DR) = ucData; + + // + // Success. + // + return(true); + } + else + { + // + // There is no space in the transmit FIFO, so return a failure. + // + return(false); + } +} + +//***************************************************************************** +// +//! Waits to send a character from the specified port. +//! +//! \param ulBase is the base address of the UART port. +//! \param ucData is the character to be transmitted. +//! +//! Sends the character \e ucData to the transmit FIFO for the specified port. +//! If there is no space available in the transmit FIFO, this function waits +//! until there is space available before returning. +//! +//! \return None. +// +//***************************************************************************** +void +UARTCharPut(unsigned long ulBase, unsigned char ucData) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Wait until space is available. + // + while(HWREG(ulBase + UART_O_FR) & UART_FR_TXFF) + { + } + + // + // Send the char. + // + HWREG(ulBase + UART_O_DR) = ucData; +} + +//***************************************************************************** +// +//! Causes a BREAK to be sent. +//! +//! \param ulBase is the base address of the UART port. +//! \param bBreakState controls the output level. +//! +//! Calling this function with \e bBreakState set to \b true asserts a break +//! condition on the UART. Calling this function with \e bBreakState set to +//! \b false removes the break condition. For proper transmission of a break +//! command, the break must be asserted for at least two complete frames. +//! +//! \return None. +// +//***************************************************************************** +void +UARTBreakCtl(unsigned long ulBase, tBoolean bBreakState) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Set the break condition as requested. + // + HWREG(ulBase + UART_O_LCRH) = + (bBreakState ? + (HWREG(ulBase + UART_O_LCRH) | UART_LCRH_BRK) : + (HWREG(ulBase + UART_O_LCRH) & ~(UART_LCRH_BRK))); +} + +//***************************************************************************** +// +//! Determines whether the UART transmitter is busy or not. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Allows the caller to determine whether all transmitted bytes have cleared +//! the transmitter hardware. If \b false is returned, the transmit FIFO is +//! empty and all bits of the last transmitted character, including all stop +//! bits, have left the hardware shift register. +//! +//! \return Returns \b true if the UART is transmitting or \b false if all +//! transmissions are complete. +// +//***************************************************************************** +tBoolean +UARTBusy(unsigned long ulBase) +{ + // + // Check the argument. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Determine if the UART is busy. + // + return((HWREG(ulBase + UART_O_FR) & UART_FR_BUSY) ? true : false); +} + +//***************************************************************************** +// +//! Registers an interrupt handler for a UART interrupt. +//! +//! \param ulBase is the base address of the UART port. +//! \param pfnHandler is a pointer to the function to be called when the +//! UART interrupt occurs. +//! +//! This function does the actual registering of the interrupt handler. This +//! will enable the global interrupt in the interrupt controller; specific UART +//! interrupts must be enabled via UARTIntEnable(). It is the interrupt +//! handler's responsibility to clear the interrupt source. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +UARTIntRegister(unsigned long ulBase, void (*pfnHandler)(void)) +{ + unsigned long ulInt; + + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Determine the interrupt number based on the UART port. + // + ulInt = ((ulBase == UART0_BASE) ? INT_UART0 : + ((ulBase == UART1_BASE) ? INT_UART1 : INT_UART2)); + + // + // Register the interrupt handler. + // + IntRegister(ulInt, pfnHandler); + + // + // Enable the UART interrupt. + // + IntEnable(ulInt); +} + +//***************************************************************************** +// +//! Unregisters an interrupt handler for a UART interrupt. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function does the actual unregistering of the interrupt handler. It +//! will clear the handler to be called when a UART interrupt occurs. This +//! will also mask off the interrupt in the interrupt controller so that the +//! interrupt handler no longer is called. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +UARTIntUnregister(unsigned long ulBase) +{ + unsigned long ulInt; + + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Determine the interrupt number based on the UART port. + // + ulInt = ((ulBase == UART0_BASE) ? INT_UART0 : + ((ulBase == UART1_BASE) ? INT_UART1 : INT_UART2)); + + // + // Disable the interrupt. + // + IntDisable(ulInt); + + // + // Unregister the interrupt handler. + // + IntUnregister(ulInt); +} + +//***************************************************************************** +// +//! Enables individual UART interrupt sources. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulIntFlags is the bit mask of the interrupt sources to be enabled. +//! +//! Enables the indicated UART interrupt sources. Only the sources that are +//! enabled can be reflected to the processor interrupt; disabled sources have +//! no effect on the processor. +//! +//! The \e ulIntFlags parameter is the logical OR of any of the following: +//! +//! - \b UART_INT_OE - Overrun Error interrupt +//! - \b UART_INT_BE - Break Error interrupt +//! - \b UART_INT_PE - Parity Error interrupt +//! - \b UART_INT_FE - Framing Error interrupt +//! - \b UART_INT_RT - Receive Timeout interrupt +//! - \b UART_INT_TX - Transmit interrupt +//! - \b UART_INT_RX - Receive interrupt +//! - \b UART_INT_DSR - DSR interrupt +//! - \b UART_INT_DCD - DCD interrupt +//! - \b UART_INT_CTS - CTS interrupt +//! - \b UART_INT_RI - RI interrupt +//! +//! \return None. +// +//***************************************************************************** +void +UARTIntEnable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Enable the specified interrupts. + // + HWREG(ulBase + UART_O_IM) |= ulIntFlags; +} + +//***************************************************************************** +// +//! Disables individual UART interrupt sources. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulIntFlags is the bit mask of the interrupt sources to be disabled. +//! +//! Disables the indicated UART interrupt sources. Only the sources that are +//! enabled can be reflected to the processor interrupt; disabled sources have +//! no effect on the processor. +//! +//! The \e ulIntFlags parameter has the same definition as the \e ulIntFlags +//! parameter to UARTIntEnable(). +//! +//! \return None. +// +//***************************************************************************** +void +UARTIntDisable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Disable the specified interrupts. + // + HWREG(ulBase + UART_O_IM) &= ~(ulIntFlags); +} + +//***************************************************************************** +// +//! Gets the current interrupt status. +//! +//! \param ulBase is the base address of the UART port. +//! \param bMasked is \b false if the raw interrupt status is required and +//! \b true if the masked interrupt status is required. +//! +//! This returns the interrupt status for the specified UART. Either the raw +//! interrupt status or the status of interrupts that are allowed to reflect to +//! the processor can be returned. +//! +//! \return Returns the current interrupt status, enumerated as a bit field of +//! values described in UARTIntEnable(). +// +//***************************************************************************** +unsigned long +UARTIntStatus(unsigned long ulBase, tBoolean bMasked) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + return(HWREG(ulBase + UART_O_MIS)); + } + else + { + return(HWREG(ulBase + UART_O_RIS)); + } +} + +//***************************************************************************** +// +//! Clears UART interrupt sources. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulIntFlags is a bit mask of the interrupt sources to be cleared. +//! +//! The specified UART interrupt sources are cleared, so that they no longer +//! assert. This function must be called in the interrupt handler to keep the +//! interrupt from being recognized again immediately upon exit. +//! +//! The \e ulIntFlags parameter has the same definition as the \e ulIntFlags +//! parameter to UARTIntEnable(). +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +UARTIntClear(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Clear the requested interrupt sources. + // + HWREG(ulBase + UART_O_ICR) = ulIntFlags; +} + +//***************************************************************************** +// +//! Enable UART DMA operation. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulDMAFlags is a bit mask of the DMA features to enable. +//! +//! The specified UART DMA features are enabled. The UART can be +//! configured to use DMA for transmit or receive, and to disable +//! receive if an error occurs. The \e ulDMAFlags parameter is the +//! logical OR of any of the following values: +//! +//! - UART_DMA_RX - enable DMA for receive +//! - UART_DMA_TX - enable DMA for transmit +//! - UART_DMA_ERR_RXSTOP - disable DMA receive on UART error +//! +//! \note The uDMA controller must also be set up before DMA can be used +//! with the UART. +//! +//! \return None. +// +//***************************************************************************** +void +UARTDMAEnable(unsigned long ulBase, unsigned long ulDMAFlags) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Set the requested bits in the UART DMA control register. + // + HWREG(ulBase + UART_O_DMACTL) |= ulDMAFlags; +} + +//***************************************************************************** +// +//! Disable UART DMA operation. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulDMAFlags is a bit mask of the DMA features to disable. +//! +//! This function is used to disable UART DMA features that were enabled +//! by UARTDMAEnable(). The specified UART DMA features are disabled. The +//! \e ulDMAFlags parameter is the logical OR of any of the following values: +//! +//! - UART_DMA_RX - disable DMA for receive +//! - UART_DMA_TX - disable DMA for transmit +//! - UART_DMA_ERR_RXSTOP - do not disable DMA receive on UART error +//! +//! \return None. +// +//***************************************************************************** +void +UARTDMADisable(unsigned long ulBase, unsigned long ulDMAFlags) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Clear the requested bits in the UART DMA control register. + // + HWREG(ulBase + UART_O_DMACTL) &= ~ulDMAFlags; +} + +//***************************************************************************** +// +//! Gets current receiver errors. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function returns the current state of each of the 4 receiver error +//! sources. The returned errors are equivalent to the four error bits +//! returned via the previous call to UARTCharGet() or UARTCharGetNonBlocking() +//! with the exception that the overrun error is set immediately the overrun +//! occurs rather than when a character is next read. +//! +//! \return Returns a logical OR combination of the receiver error flags, +//! \b UART_RXERROR_FRAMING, \b UART_RXERROR_PARITY, \b UART_RXERROR_BREAK +//! and \b UART_RXERROR_OVERRUN. +// +//***************************************************************************** +unsigned long +UARTRxErrorGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Return the current value of the receive status register. + // + return(HWREG(ulBase + UART_O_RSR) & 0x0000000F); +} + +//***************************************************************************** +// +//! Clears all reported receiver errors. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function is used to clear all receiver error conditions reported via +//! UARTRxErrorGet(). If using the overrun, framing error, parity error or +//! break interrupts, this function must be called after clearing the interrupt +//! to ensure that later errors of the same type trigger another interrupt. +//! +//! \return None. +// +//***************************************************************************** +void +UARTRxErrorClear(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Any write to the Error Clear Register will clear all bits which are + // currently set. + // + HWREG(ulBase + UART_O_ECR) = 0; +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/uartlib.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/uartlib.h new file mode 100644 index 00000000..2a23fa63 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/driverlib/uartlib.h @@ -0,0 +1,243 @@ +//***************************************************************************** +// +// uart.h - Defines and Macros for the UART. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __UART_H__ +#define __UART_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Values that can be passed to UARTIntEnable, UARTIntDisable, and UARTIntClear +// as the ulIntFlags parameter, and returned from UARTIntStatus. +// +//***************************************************************************** +#define UART_INT_OE 0x400 // Overrun Error Interrupt Mask +#define UART_INT_BE 0x200 // Break Error Interrupt Mask +#define UART_INT_PE 0x100 // Parity Error Interrupt Mask +#define UART_INT_FE 0x080 // Framing Error Interrupt Mask +#define UART_INT_RT 0x040 // Receive Timeout Interrupt Mask +#define UART_INT_TX 0x020 // Transmit Interrupt Mask +#define UART_INT_RX 0x010 // Receive Interrupt Mask +#define UART_INT_DSR 0x008 // DSR Modem Interrupt Mask +#define UART_INT_DCD 0x004 // DCD Modem Interrupt Mask +#define UART_INT_CTS 0x002 // CTS Modem Interrupt Mask +#define UART_INT_RI 0x001 // RI Modem Interrupt Mask + +//***************************************************************************** +// +// Values that can be passed to UARTConfigSetExpClk as the ulConfig parameter +// and returned by UARTConfigGetExpClk in the pulConfig parameter. +// Additionally, the UART_CONFIG_PAR_* subset can be passed to +// UARTParityModeSet as the ulParity parameter, and are returned by +// UARTParityModeGet. +// +//***************************************************************************** +#define UART_CONFIG_WLEN_MASK 0x00000060 // Mask for extracting word length +#define UART_CONFIG_WLEN_8 0x00000060 // 8 bit data +#define UART_CONFIG_WLEN_7 0x00000040 // 7 bit data +#define UART_CONFIG_WLEN_6 0x00000020 // 6 bit data +#define UART_CONFIG_WLEN_5 0x00000000 // 5 bit data +#define UART_CONFIG_STOP_MASK 0x00000008 // Mask for extracting stop bits +#define UART_CONFIG_STOP_ONE 0x00000000 // One stop bit +#define UART_CONFIG_STOP_TWO 0x00000008 // Two stop bits +#define UART_CONFIG_PAR_MASK 0x00000086 // Mask for extracting parity +#define UART_CONFIG_PAR_NONE 0x00000000 // No parity +#define UART_CONFIG_PAR_EVEN 0x00000006 // Even parity +#define UART_CONFIG_PAR_ODD 0x00000002 // Odd parity +#define UART_CONFIG_PAR_ONE 0x00000082 // Parity bit is one +#define UART_CONFIG_PAR_ZERO 0x00000086 // Parity bit is zero + +//***************************************************************************** +// +// Values that can be passed to UARTFIFOLevelSet as the ulTxLevel parameter and +// returned by UARTFIFOLevelGet in the pulTxLevel. +// +//***************************************************************************** +#define UART_FIFO_TX1_8 0x00000000 // Transmit interrupt at 1/8 Full +#define UART_FIFO_TX2_8 0x00000001 // Transmit interrupt at 1/4 Full +#define UART_FIFO_TX4_8 0x00000002 // Transmit interrupt at 1/2 Full +#define UART_FIFO_TX6_8 0x00000003 // Transmit interrupt at 3/4 Full +#define UART_FIFO_TX7_8 0x00000004 // Transmit interrupt at 7/8 Full + +//***************************************************************************** +// +// Values that can be passed to UARTFIFOLevelSet as the ulRxLevel parameter and +// returned by UARTFIFOLevelGet in the pulRxLevel. +// +//***************************************************************************** +#define UART_FIFO_RX1_8 0x00000000 // Receive interrupt at 1/8 Full +#define UART_FIFO_RX2_8 0x00000008 // Receive interrupt at 1/4 Full +#define UART_FIFO_RX4_8 0x00000010 // Receive interrupt at 1/2 Full +#define UART_FIFO_RX6_8 0x00000018 // Receive interrupt at 3/4 Full +#define UART_FIFO_RX7_8 0x00000020 // Receive interrupt at 7/8 Full + +//***************************************************************************** +// +// Values that can be passed to UARTDMAEnable() and UARTDMADisable(). +// +//***************************************************************************** +#define UART_DMA_ERR_RXSTOP 0x00000004 // Stop DMA receive if UART error +#define UART_DMA_TX 0x00000002 // Enable DMA for transmit +#define UART_DMA_RX 0x00000001 // Enable DMA for receive + +//***************************************************************************** +// +// Values returned from UARTRxErrorGet(). +// +//***************************************************************************** +#define UART_RXERROR_OVERRUN 0x00000008 +#define UART_RXERROR_BREAK 0x00000004 +#define UART_RXERROR_PARITY 0x00000002 +#define UART_RXERROR_FRAMING 0x00000001 + +//***************************************************************************** +// +// Values that can be passed to UARTHandshakeOutputsSet() or returned from +// UARTHandshakeOutputGet(). +// +//***************************************************************************** +#define UART_OUTPUT_RTS 0x00000800 +#define UART_OUTPUT_DTR 0x00000400 + +//***************************************************************************** +// +// Values that can be returned from UARTHandshakeInputsGet(). +// +//***************************************************************************** +#define UART_INPUT_RI 0x00000100 +#define UART_INPUT_DCD 0x00000004 +#define UART_INPUT_DSR 0x00000002 +#define UART_INPUT_CTS 0x00000001 + +//***************************************************************************** +// +// Values that can be passed to UARTFlowControl() or returned from +// UARTFlowControlGet(). +// +//***************************************************************************** +#define UART_FLOWCONTROL_TX 0x00008000 +#define UART_FLOWCONTROL_RX 0x00004000 +#define UART_FLOWCONTROL_NONE 0x00000000 + +//***************************************************************************** +// +// Values that can be passed to UARTTxIntModeSet() or returned from +// UARTTxIntModeGet(). +// +//***************************************************************************** +#define UART_TXINT_MODE_FIFO 0x00000000 +#define UART_TXINT_MODE_EOT 0x00000010 + +//***************************************************************************** +// +// API Function prototypes +// +//***************************************************************************** +extern void UARTParityModeSet(unsigned long ulBase, unsigned long ulParity); +extern unsigned long UARTParityModeGet(unsigned long ulBase); +extern void UARTFIFOLevelSet(unsigned long ulBase, unsigned long ulTxLevel, + unsigned long ulRxLevel); +extern void UARTFIFOLevelGet(unsigned long ulBase, unsigned long *pulTxLevel, + unsigned long *pulRxLevel); +extern void UARTConfigSetExpClk(unsigned long ulBase, unsigned long ulUARTClk, + unsigned long ulBaud, unsigned long ulConfig); +extern void UARTConfigGetExpClk(unsigned long ulBase, unsigned long ulUARTClk, + unsigned long *pulBaud, + unsigned long *pulConfig); +extern void UARTEnable(unsigned long ulBase); +extern void UARTDisable(unsigned long ulBase); +extern void UARTFIFOEnable(unsigned long ulBase); +extern void UARTFIFODisable(unsigned long ulBase); +extern void UARTEnableSIR(unsigned long ulBase, tBoolean bLowPower); +extern void UARTDisableSIR(unsigned long ulBase); +extern tBoolean UARTCharsAvail(unsigned long ulBase); +extern tBoolean UARTSpaceAvail(unsigned long ulBase); +extern long UARTCharGetNonBlocking(unsigned long ulBase); +extern long UARTCharGet(unsigned long ulBase); +extern tBoolean UARTCharPutNonBlocking(unsigned long ulBase, + unsigned char ucData); +extern void UARTCharPut(unsigned long ulBase, unsigned char ucData); +extern void UARTBreakCtl(unsigned long ulBase, tBoolean bBreakState); +extern tBoolean UARTBusy(unsigned long ulBase); +extern void UARTIntRegister(unsigned long ulBase, void(*pfnHandler)(void)); +extern void UARTIntUnregister(unsigned long ulBase); +extern void UARTIntEnable(unsigned long ulBase, unsigned long ulIntFlags); +extern void UARTIntDisable(unsigned long ulBase, unsigned long ulIntFlags); +extern unsigned long UARTIntStatus(unsigned long ulBase, tBoolean bMasked); +extern void UARTIntClear(unsigned long ulBase, unsigned long ulIntFlags); +extern void UARTDMAEnable(unsigned long ulBase, unsigned long ulDMAFlags); +extern void UARTDMADisable(unsigned long ulBase, unsigned long ulDMAFlags); +extern unsigned long UARTRxErrorGet(unsigned long ulBase); +extern void UARTRxErrorClear(unsigned long ulBase); +extern void UARTSmartCardEnable(unsigned long ulBase); +extern void UARTSmartCardDisable(unsigned long ulBase); +extern void UARTModemControlSet(unsigned long ulBase, + unsigned long ulControl); +extern void UARTModemControlClear(unsigned long ulBase, + unsigned long ulControl); +extern unsigned long UARTModemControlGet(unsigned long ulBase); +extern unsigned long UARTModemStatusGet(unsigned long ulBase); +extern void UARTFlowControlSet(unsigned long ulBase, unsigned long ulMode); +extern unsigned long UARTFlowControlGet(unsigned long ulBase); +extern void UARTTxIntModeSet(unsigned long ulBase, unsigned long ulMode); +extern unsigned long UARTTxIntModeGet(unsigned long ulBase); + +//***************************************************************************** +// +// Several UART APIs have been renamed, with the original function name being +// deprecated. These defines provide backward compatibility. +// +//***************************************************************************** +#ifndef DEPRECATED +#include "driverlib/sysctl.h" +#define UARTConfigSet(a, b, c) \ + UARTConfigSetExpClk(a, SysCtlClockGet(), b, c) +#define UARTConfigGet(a, b, c) \ + UARTConfigGetExpClk(a, SysCtlClockGet(), b, c) +#define UARTCharNonBlockingGet(a) \ + UARTCharGetNonBlocking(a) +#define UARTCharNonBlockingPut(a, b) \ + UARTCharPutNonBlocking(a, b) +#endif + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __UART_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_flash.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_flash.h new file mode 100644 index 00000000..13a013e5 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_flash.h @@ -0,0 +1,381 @@ +//***************************************************************************** +// +// hw_flash.h - Macros used when accessing the flash controller. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_FLASH_H__ +#define __HW_FLASH_H__ + +//***************************************************************************** +// +// The following are defines for the FLASH register offsets. +// +//***************************************************************************** +#define FLASH_FMA 0x400FD000 // Flash Memory Address +#define FLASH_FMD 0x400FD004 // Flash Memory Data +#define FLASH_FMC 0x400FD008 // Flash Memory Control +#define FLASH_FCRIS 0x400FD00C // Flash Controller Raw Interrupt + // Status +#define FLASH_FCIM 0x400FD010 // Flash Controller Interrupt Mask +#define FLASH_FCMISC 0x400FD014 // Flash Controller Masked + // Interrupt Status and Clear +#define FLASH_FMC2 0x400FD020 // Flash Memory Control 2 +#define FLASH_FWBVAL 0x400FD030 // Flash Write Buffer Valid +#define FLASH_FCTL 0x400FD0F8 // Flash Control +#define FLASH_FWBN 0x400FD100 // Flash Write Buffer n +#define FLASH_RMCTL 0x400FE0F0 // ROM Control +#define FLASH_FMPRE 0x400FE130 // Flash Memory Protection Read + // Enable +#define FLASH_FMPPE 0x400FE134 // Flash Memory Protection Program + // Enable +#define FLASH_USECRL 0x400FE140 // USec Reload +#define FLASH_USERDBG 0x400FE1D0 // User Debug +#define FLASH_BOOTCFG 0x400FE1D0 // Boot Configuration +#define FLASH_USERREG0 0x400FE1E0 // User Register 0 +#define FLASH_USERREG1 0x400FE1E4 // User Register 1 +#define FLASH_USERREG2 0x400FE1E8 // User Register 2 +#define FLASH_USERREG3 0x400FE1EC // User Register 3 +#define FLASH_FMPRE0 0x400FE200 // Flash Memory Protection Read + // Enable 0 +#define FLASH_FMPRE1 0x400FE204 // Flash Memory Protection Read + // Enable 1 +#define FLASH_FMPRE2 0x400FE208 // Flash Memory Protection Read + // Enable 2 +#define FLASH_FMPRE3 0x400FE20C // Flash Memory Protection Read + // Enable 3 +#define FLASH_FMPPE0 0x400FE400 // Flash Memory Protection Program + // Enable 0 +#define FLASH_FMPPE1 0x400FE404 // Flash Memory Protection Program + // Enable 1 +#define FLASH_FMPPE2 0x400FE408 // Flash Memory Protection Program + // Enable 2 +#define FLASH_FMPPE3 0x400FE40C // Flash Memory Protection Program + // Enable 3 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FMA register. +// +//***************************************************************************** +#define FLASH_FMA_OFFSET_M 0x0003FFFF // Address Offset +#define FLASH_FMA_OFFSET_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FMD register. +// +//***************************************************************************** +#define FLASH_FMD_DATA_M 0xFFFFFFFF // Data Value +#define FLASH_FMD_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FMC register. +// +//***************************************************************************** +#define FLASH_FMC_WRKEY 0xA4420000 // FLASH write key +#define FLASH_FMC_COMT 0x00000008 // Commit Register Value +#define FLASH_FMC_MERASE 0x00000004 // Mass Erase Flash Memory +#define FLASH_FMC_ERASE 0x00000002 // Erase a Page of Flash Memory +#define FLASH_FMC_WRITE 0x00000001 // Write a Word into Flash Memory + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FCRIS register. +// +//***************************************************************************** +#define FLASH_FCRIS_PRIS 0x00000002 // Programming Raw Interrupt Status +#define FLASH_FCRIS_ARIS 0x00000001 // Access Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FCIM register. +// +//***************************************************************************** +#define FLASH_FCIM_PMASK 0x00000002 // Programming Interrupt Mask +#define FLASH_FCIM_AMASK 0x00000001 // Access Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FCMISC register. +// +//***************************************************************************** +#define FLASH_FCMISC_PMISC 0x00000002 // Programming Masked Interrupt + // Status and Clear +#define FLASH_FCMISC_AMISC 0x00000001 // Access Masked Interrupt Status + // and Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FMC2 register. +// +//***************************************************************************** +#define FLASH_FMC2_WRKEY 0xA4420000 // FLASH write key +#define FLASH_FMC2_WRBUF 0x00000001 // Buffered Flash Memory Write + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FWBVAL register. +// +//***************************************************************************** +#define FLASH_FWBVAL_FWB_M 0xFFFFFFFF // Flash Memory Write Buffer + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FCTL register. +// +//***************************************************************************** +#define FLASH_FCTL_USDACK 0x00000002 // User Shut Down Acknowledge +#define FLASH_FCTL_USDREQ 0x00000001 // User Shut Down Request + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FWBN register. +// +//***************************************************************************** +#define FLASH_FWBN_DATA_M 0xFFFFFFFF // Data + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_RMCTL register. +// +//***************************************************************************** +#define FLASH_RMCTL_BA 0x00000001 // Boot Alias + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USECRL register. +// +//***************************************************************************** +#define FLASH_USECRL_M 0x000000FF // Microsecond Reload Value +#define FLASH_USECRL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USERDBG register. +// +//***************************************************************************** +#define FLASH_USERDBG_NW 0x80000000 // User Debug Not Written +#define FLASH_USERDBG_DATA_M 0x7FFFFFFC // User Data +#define FLASH_USERDBG_DBG1 0x00000002 // Debug Control 1 +#define FLASH_USERDBG_DBG0 0x00000001 // Debug Control 0 +#define FLASH_USERDBG_DATA_S 2 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_BOOTCFG register. +// +//***************************************************************************** +#define FLASH_BOOTCFG_NW 0x80000000 // Not Written +#define FLASH_BOOTCFG_PORT_M 0x0000E000 // Boot GPIO Port +#define FLASH_BOOTCFG_PORT_A 0x00000000 // Port A +#define FLASH_BOOTCFG_PORT_B 0x00002000 // Port B +#define FLASH_BOOTCFG_PORT_C 0x00004000 // Port C +#define FLASH_BOOTCFG_PORT_D 0x00006000 // Port D +#define FLASH_BOOTCFG_PORT_E 0x00008000 // Port E +#define FLASH_BOOTCFG_PORT_F 0x0000A000 // Port F +#define FLASH_BOOTCFG_PORT_G 0x0000C000 // Port G +#define FLASH_BOOTCFG_PORT_H 0x0000E000 // Port H +#define FLASH_BOOTCFG_PIN_M 0x00001C00 // Boot GPIO Pin +#define FLASH_BOOTCFG_PIN_0 0x00000000 // Pin 0 +#define FLASH_BOOTCFG_PIN_1 0x00000400 // Pin 1 +#define FLASH_BOOTCFG_PIN_2 0x00000800 // Pin 2 +#define FLASH_BOOTCFG_PIN_3 0x00000C00 // Pin 3 +#define FLASH_BOOTCFG_PIN_4 0x00001000 // Pin 4 +#define FLASH_BOOTCFG_PIN_5 0x00001400 // Pin 5 +#define FLASH_BOOTCFG_PIN_6 0x00001800 // Pin 6 +#define FLASH_BOOTCFG_PIN_7 0x00001C00 // Pin 7 +#define FLASH_BOOTCFG_POL 0x00000200 // Boot GPIO Polarity +#define FLASH_BOOTCFG_EN 0x00000100 // Boot GPIO Enable +#define FLASH_BOOTCFG_DBG1 0x00000002 // Debug Control 1 +#define FLASH_BOOTCFG_DBG0 0x00000001 // Debug Control 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USERREG0 register. +// +//***************************************************************************** +#define FLASH_USERREG0_NW 0x80000000 // Not Written +#define FLASH_USERREG0_DATA_M 0x7FFFFFFF // User Data +#define FLASH_USERREG0_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USERREG1 register. +// +//***************************************************************************** +#define FLASH_USERREG1_NW 0x80000000 // Not Written +#define FLASH_USERREG1_DATA_M 0x7FFFFFFF // User Data +#define FLASH_USERREG1_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USERREG2 register. +// +//***************************************************************************** +#define FLASH_USERREG2_NW 0x80000000 // Not Written +#define FLASH_USERREG2_DATA_M 0x7FFFFFFF // User Data +#define FLASH_USERREG2_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USERREG3 register. +// +//***************************************************************************** +#define FLASH_USERREG3_NW 0x80000000 // Not Written +#define FLASH_USERREG3_DATA_M 0x7FFFFFFF // User Data +#define FLASH_USERREG3_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FMPRE and +// FLASH_FMPPE registers. +// +//***************************************************************************** +#define FLASH_FMP_BLOCK_31 0x80000000 // Enable for block 31 +#define FLASH_FMP_BLOCK_30 0x40000000 // Enable for block 30 +#define FLASH_FMP_BLOCK_29 0x20000000 // Enable for block 29 +#define FLASH_FMP_BLOCK_28 0x10000000 // Enable for block 28 +#define FLASH_FMP_BLOCK_27 0x08000000 // Enable for block 27 +#define FLASH_FMP_BLOCK_26 0x04000000 // Enable for block 26 +#define FLASH_FMP_BLOCK_25 0x02000000 // Enable for block 25 +#define FLASH_FMP_BLOCK_24 0x01000000 // Enable for block 24 +#define FLASH_FMP_BLOCK_23 0x00800000 // Enable for block 23 +#define FLASH_FMP_BLOCK_22 0x00400000 // Enable for block 22 +#define FLASH_FMP_BLOCK_21 0x00200000 // Enable for block 21 +#define FLASH_FMP_BLOCK_20 0x00100000 // Enable for block 20 +#define FLASH_FMP_BLOCK_19 0x00080000 // Enable for block 19 +#define FLASH_FMP_BLOCK_18 0x00040000 // Enable for block 18 +#define FLASH_FMP_BLOCK_17 0x00020000 // Enable for block 17 +#define FLASH_FMP_BLOCK_16 0x00010000 // Enable for block 16 +#define FLASH_FMP_BLOCK_15 0x00008000 // Enable for block 15 +#define FLASH_FMP_BLOCK_14 0x00004000 // Enable for block 14 +#define FLASH_FMP_BLOCK_13 0x00002000 // Enable for block 13 +#define FLASH_FMP_BLOCK_12 0x00001000 // Enable for block 12 +#define FLASH_FMP_BLOCK_11 0x00000800 // Enable for block 11 +#define FLASH_FMP_BLOCK_10 0x00000400 // Enable for block 10 +#define FLASH_FMP_BLOCK_9 0x00000200 // Enable for block 9 +#define FLASH_FMP_BLOCK_8 0x00000100 // Enable for block 8 +#define FLASH_FMP_BLOCK_7 0x00000080 // Enable for block 7 +#define FLASH_FMP_BLOCK_6 0x00000040 // Enable for block 6 +#define FLASH_FMP_BLOCK_5 0x00000020 // Enable for block 5 +#define FLASH_FMP_BLOCK_4 0x00000010 // Enable for block 4 +#define FLASH_FMP_BLOCK_3 0x00000008 // Enable for block 3 +#define FLASH_FMP_BLOCK_2 0x00000004 // Enable for block 2 +#define FLASH_FMP_BLOCK_1 0x00000002 // Enable for block 1 +#define FLASH_FMP_BLOCK_0 0x00000001 // Enable for block 0 + +//***************************************************************************** +// +// The following are defines for the erase size of the FLASH block that is +// erased by an erase operation, and the protect size is the size of the FLASH +// block that is protected by each protection register. +// +//***************************************************************************** +#define FLASH_PROTECT_SIZE 0x00000800 +#define FLASH_ERASE_SIZE 0x00000400 + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the FLASH register offsets. +// +//***************************************************************************** +#define FLASH_RMVER 0x400FE0F4 // ROM Version Register + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the FLASH_FMC +// register. +// +//***************************************************************************** +#define FLASH_FMC_WRKEY_MASK 0xFFFF0000 // FLASH write key mask +#define FLASH_FMC_WRKEY_M 0xFFFF0000 // Flash Memory Write Key +#define FLASH_FMC_WRKEY_S 16 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the FLASH_FCRIS +// register. +// +//***************************************************************************** +#define FLASH_FCRIS_PROGRAM 0x00000002 // Programming status +#define FLASH_FCRIS_ACCESS 0x00000001 // Invalid access status + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the FLASH_FCIM +// register. +// +//***************************************************************************** +#define FLASH_FCIM_PROGRAM 0x00000002 // Programming mask +#define FLASH_FCIM_ACCESS 0x00000001 // Invalid access mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the FLASH_FCMISC +// register. +// +//***************************************************************************** +#define FLASH_FCMISC_PROGRAM 0x00000002 // Programming status +#define FLASH_FCMISC_ACCESS 0x00000001 // Invalid access status + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the FLASH_RMVER +// register. +// +//***************************************************************************** +#define FLASH_RMVER_CONT_M 0xFF000000 // ROM Contents +#define FLASH_RMVER_CONT_LM 0x00000000 // Stellaris Boot Loader & + // DriverLib +#define FLASH_RMVER_CONT_LM_AES 0x02000000 // Stellaris Boot Loader & + // DriverLib with AES +#define FLASH_RMVER_CONT_LM_AES_SAFERTOS \ + 0x03000000 // Stellaris Boot Loader & + // DriverLib with AES and SAFERTOS +#define FLASH_RMVER_CONT_LM_AES2 \ + 0x05000000 // Stellaris Boot Loader & + // DriverLib with AES +#define FLASH_RMVER_VER_M 0x0000FF00 // ROM Version +#define FLASH_RMVER_REV_M 0x000000FF // ROM Revision +#define FLASH_RMVER_VER_S 8 +#define FLASH_RMVER_REV_S 0 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the FLASH_USECRL +// register. +// +//***************************************************************************** +#define FLASH_USECRL_MASK 0x000000FF // Clock per uSec +#define FLASH_USECRL_SHIFT 0 + +#endif + +#endif // __HW_FLASH_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_gpio.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_gpio.h new file mode 100644 index 00000000..acdb2984 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_gpio.h @@ -0,0 +1,592 @@ +//***************************************************************************** +// +// hw_gpio.h - Defines and Macros for GPIO hardware. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_GPIO_H__ +#define __HW_GPIO_H__ + +//***************************************************************************** +// +// The following are defines for the GPIO register offsets. +// +//***************************************************************************** +#define GPIO_O_DATA 0x00000000 // GPIO Data +#define GPIO_O_DIR 0x00000400 // GPIO Direction +#define GPIO_O_IS 0x00000404 // GPIO Interrupt Sense +#define GPIO_O_IBE 0x00000408 // GPIO Interrupt Both Edges +#define GPIO_O_IEV 0x0000040C // GPIO Interrupt Event +#define GPIO_O_IM 0x00000410 // GPIO Interrupt Mask +#define GPIO_O_RIS 0x00000414 // GPIO Raw Interrupt Status +#define GPIO_O_MIS 0x00000418 // GPIO Masked Interrupt Status +#define GPIO_O_ICR 0x0000041C // GPIO Interrupt Clear +#define GPIO_O_AFSEL 0x00000420 // GPIO Alternate Function Select +#define GPIO_O_DR2R 0x00000500 // GPIO 2-mA Drive Select +#define GPIO_O_DR4R 0x00000504 // GPIO 4-mA Drive Select +#define GPIO_O_DR8R 0x00000508 // GPIO 8-mA Drive Select +#define GPIO_O_ODR 0x0000050C // GPIO Open Drain Select +#define GPIO_O_PUR 0x00000510 // GPIO Pull-Up Select +#define GPIO_O_PDR 0x00000514 // GPIO Pull-Down Select +#define GPIO_O_SLR 0x00000518 // GPIO Slew Rate Control Select +#define GPIO_O_DEN 0x0000051C // GPIO Digital Enable +#define GPIO_O_LOCK 0x00000520 // GPIO Lock +#define GPIO_O_CR 0x00000524 // GPIO Commit +#define GPIO_O_AMSEL 0x00000528 // GPIO Analog Mode Select +#define GPIO_O_PCTL 0x0000052C // GPIO Port Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_O_LOCK register. +// +//***************************************************************************** +#define GPIO_LOCK_M 0xFFFFFFFF // GPIO Lock +#define GPIO_LOCK_UNLOCKED 0x00000000 // The GPIOCR register is unlocked + // and may be modified +#define GPIO_LOCK_LOCKED 0x00000001 // The GPIOCR register is locked + // and may not be modified +#define GPIO_LOCK_KEY 0x1ACCE551 // Unlocks the GPIO_CR register +#define GPIO_LOCK_KEY_DD 0x4C4F434B // Unlocks the GPIO_CR register on + // DustDevil-class devices and + // later + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port A. +// +//***************************************************************************** +#define GPIO_PCTL_PA0_M 0x0000000F // PA0 mask +#define GPIO_PCTL_PA0_U0RX 0x00000001 // U0RX on PA0 +#define GPIO_PCTL_PA0_I2C1SCL 0x00000008 // I2C1SCL on PA0 +#define GPIO_PCTL_PA0_U1RX 0x00000009 // U1RX on PA0 +#define GPIO_PCTL_PA1_M 0x000000F0 // PA1 mask +#define GPIO_PCTL_PA1_U0TX 0x00000010 // U0TX on PA1 +#define GPIO_PCTL_PA1_I2C1SDA 0x00000080 // I2C1SDA on PA1 +#define GPIO_PCTL_PA1_U1TX 0x00000090 // U1TX on PA1 +#define GPIO_PCTL_PA2_M 0x00000F00 // PA2 mask +#define GPIO_PCTL_PA2_SSI0CLK 0x00000100 // SSI0CLK on PA2 +#define GPIO_PCTL_PA2_PWM4 0x00000400 // PWM4 on PA2 +#define GPIO_PCTL_PA2_I2S0RXSD 0x00000900 // I2S0RXSD on PA2 +#define GPIO_PCTL_PA3_M 0x0000F000 // PA3 mask +#define GPIO_PCTL_PA3_SSI0FSS 0x00001000 // SSI0FSS on PA3 +#define GPIO_PCTL_PA3_PWM5 0x00004000 // PWM5 on PA3 +#define GPIO_PCTL_PA3_I2S0RXMCLK \ + 0x00009000 // I2S0RXMCLK on PA3 +#define GPIO_PCTL_PA4_M 0x000F0000 // PA4 mask +#define GPIO_PCTL_PA4_SSI0RX 0x00010000 // SSI0RX on PA4 +#define GPIO_PCTL_PA4_PWM6 0x00040000 // PWM6 on PA4 +#define GPIO_PCTL_PA4_CAN0RX 0x00050000 // CAN0RX on PA4 +#define GPIO_PCTL_PA4_I2S0TXSCK 0x00090000 // I2S0TXSCK on PA4 +#define GPIO_PCTL_PA5_M 0x00F00000 // PA5 mask +#define GPIO_PCTL_PA5_SSI0TX 0x00100000 // SSI0TX on PA5 +#define GPIO_PCTL_PA5_PWM7 0x00400000 // PWM7 on PA5 +#define GPIO_PCTL_PA5_CAN0TX 0x00500000 // CAN0TX on PA5 +#define GPIO_PCTL_PA5_I2S0TXWS 0x00900000 // I2S0TXWS on PA5 +#define GPIO_PCTL_PA6_M 0x0F000000 // PA6 mask +#define GPIO_PCTL_PA6_I2C1SCL 0x01000000 // I2C1SCL on PA6 +#define GPIO_PCTL_PA6_CCP1 0x02000000 // CCP1 on PA6 +#define GPIO_PCTL_PA6_PWM0 0x04000000 // PWM0 on PA6 +#define GPIO_PCTL_PA6_PWM4 0x05000000 // PWM4 on PA6 +#define GPIO_PCTL_PA6_CAN0RX 0x06000000 // CAN0RX on PA6 +#define GPIO_PCTL_PA6_USB0EPEN 0x08000000 // USB0EPEN on PA6 +#define GPIO_PCTL_PA6_U1CTS 0x09000000 // U1CTS on PA6 +#define GPIO_PCTL_PA7_M 0xF0000000 // PA7 mask +#define GPIO_PCTL_PA7_I2C1SDA 0x10000000 // I2C1SDA on PA7 +#define GPIO_PCTL_PA7_CCP4 0x20000000 // CCP4 on PA7 +#define GPIO_PCTL_PA7_PWM1 0x40000000 // PWM1 on PA7 +#define GPIO_PCTL_PA7_PWM5 0x50000000 // PWM5 on PA7 +#define GPIO_PCTL_PA7_CAN0TX 0x60000000 // CAN0TX on PA7 +#define GPIO_PCTL_PA7_CCP3 0x70000000 // CCP3 on PA7 +#define GPIO_PCTL_PA7_USB0PFLT 0x80000000 // USB0PFLT on PA7 +#define GPIO_PCTL_PA7_U1DCD 0x90000000 // U1DCD on PA7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port B. +// +//***************************************************************************** +#define GPIO_PCTL_PB0_M 0x0000000F // PB0 mask +#define GPIO_PCTL_PB0_CCP0 0x00000001 // CCP0 on PB0 +#define GPIO_PCTL_PB0_PWM2 0x00000002 // PWM2 on PB0 +#define GPIO_PCTL_PB0_U1RX 0x00000005 // U1RX on PB0 +#define GPIO_PCTL_PB1_M 0x000000F0 // PB1 mask +#define GPIO_PCTL_PB1_CCP2 0x00000010 // CCP2 on PB1 +#define GPIO_PCTL_PB1_PWM3 0x00000020 // PWM3 on PB1 +#define GPIO_PCTL_PB1_CCP1 0x00000040 // CCP1 on PB1 +#define GPIO_PCTL_PB1_U1TX 0x00000050 // U1TX on PB1 +#define GPIO_PCTL_PB2_M 0x00000F00 // PB2 mask +#define GPIO_PCTL_PB2_I2C0SCL 0x00000100 // I2C0SCL on PB2 +#define GPIO_PCTL_PB2_IDX0 0x00000200 // IDX0 on PB2 +#define GPIO_PCTL_PB2_CCP3 0x00000400 // CCP3 on PB2 +#define GPIO_PCTL_PB2_CCP0 0x00000500 // CCP0 on PB2 +#define GPIO_PCTL_PB2_USB0EPEN 0x00000800 // USB0EPEN on PB2 +#define GPIO_PCTL_PB3_M 0x0000F000 // PB3 mask +#define GPIO_PCTL_PB3_I2C0SDA 0x00001000 // I2C0SDA on PB3 +#define GPIO_PCTL_PB3_FAULT0 0x00002000 // FAULT0 on PB3 +#define GPIO_PCTL_PB3_FAULT3 0x00004000 // FAULT3 on PB3 +#define GPIO_PCTL_PB3_USB0PFLT 0x00008000 // USB0PFLT on PB3 +#define GPIO_PCTL_PB4_M 0x000F0000 // PB4 mask +#define GPIO_PCTL_PB4_U2RX 0x00040000 // U2RX on PB4 +#define GPIO_PCTL_PB4_CAN0RX 0x00050000 // CAN0RX on PB4 +#define GPIO_PCTL_PB4_IDX0 0x00060000 // IDX0 on PB4 +#define GPIO_PCTL_PB4_U1RX 0x00070000 // U1RX on PB4 +#define GPIO_PCTL_PB4_EPI0S23 0x00080000 // EPI0S23 on PB4 +#define GPIO_PCTL_PB5_M 0x00F00000 // PB5 mask +#define GPIO_PCTL_PB5_C0O 0x00100000 // C0O on PB5 +#define GPIO_PCTL_PB5_CCP5 0x00200000 // CCP5 on PB5 +#define GPIO_PCTL_PB5_CCP6 0x00300000 // CCP6 on PB5 +#define GPIO_PCTL_PB5_CCP0 0x00400000 // CCP0 on PB5 +#define GPIO_PCTL_PB5_CAN0TX 0x00500000 // CAN0TX on PB5 +#define GPIO_PCTL_PB5_CCP2 0x00600000 // CCP2 on PB5 +#define GPIO_PCTL_PB5_U1TX 0x00700000 // U1TX on PB5 +#define GPIO_PCTL_PB5_EPI0S22 0x00800000 // EPI0S22 on PB5 +#define GPIO_PCTL_PB6_M 0x0F000000 // PB6 mask +#define GPIO_PCTL_PB6_CCP1 0x01000000 // CCP1 on PB6 +#define GPIO_PCTL_PB6_CCP7 0x02000000 // CCP7 on PB6 +#define GPIO_PCTL_PB6_C0O 0x03000000 // C0O on PB6 +#define GPIO_PCTL_PB6_FAULT1 0x04000000 // FAULT1 on PB6 +#define GPIO_PCTL_PB6_IDX0 0x05000000 // IDX0 on PB6 +#define GPIO_PCTL_PB6_CCP5 0x06000000 // CCP5 on PB6 +#define GPIO_PCTL_PB6_I2S0TXSCK 0x09000000 // I2S0TXSCK on PB6 +#define GPIO_PCTL_PB7_M 0xF0000000 // PB7 mask +#define GPIO_PCTL_PB7_NMI 0x40000000 // NMI on PB7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port C. +// +//***************************************************************************** +#define GPIO_PCTL_PC0_M 0x0000000F // PC0 mask +#define GPIO_PCTL_PC0_TCK 0x00000003 // TCK on PC0 +#define GPIO_PCTL_PC1_M 0x000000F0 // PC1 mask +#define GPIO_PCTL_PC1_TMS 0x00000030 // TMS on PC1 +#define GPIO_PCTL_PC2_M 0x00000F00 // PC2 mask +#define GPIO_PCTL_PC2_TDI 0x00000300 // TDI on PC2 +#define GPIO_PCTL_PC3_M 0x0000F000 // PC3 mask +#define GPIO_PCTL_PC3_TDO 0x00003000 // TDO on PC3 +#define GPIO_PCTL_PC4_M 0x000F0000 // PC4 mask +#define GPIO_PCTL_PC4_CCP5 0x00010000 // CCP5 on PC4 +#define GPIO_PCTL_PC4_PHA0 0x00020000 // PHA0 on PC4 +#define GPIO_PCTL_PC4_PWM6 0x00040000 // PWM6 on PC4 +#define GPIO_PCTL_PC4_CCP2 0x00050000 // CCP2 on PC4 +#define GPIO_PCTL_PC4_CCP4 0x00060000 // CCP4 on PC4 +#define GPIO_PCTL_PC4_EPI0S2 0x00080000 // EPI0S2 on PC4 +#define GPIO_PCTL_PC4_CCP1 0x00090000 // CCP1 on PC4 +#define GPIO_PCTL_PC5_M 0x00F00000 // PC5 mask +#define GPIO_PCTL_PC5_CCP1 0x00100000 // CCP1 on PC5 +#define GPIO_PCTL_PC5_C1O 0x00200000 // C1O on PC5 +#define GPIO_PCTL_PC5_C0O 0x00300000 // C0O on PC5 +#define GPIO_PCTL_PC5_FAULT2 0x00400000 // FAULT2 on PC5 +#define GPIO_PCTL_PC5_CCP3 0x00500000 // CCP3 on PC5 +#define GPIO_PCTL_PC5_USB0EPEN 0x00600000 // USB0EPEN on PC5 +#define GPIO_PCTL_PC5_EPI0S3 0x00800000 // EPI0S3 on PC5 +#define GPIO_PCTL_PC6_M 0x0F000000 // PC6 mask +#define GPIO_PCTL_PC6_CCP3 0x01000000 // CCP3 on PC6 +#define GPIO_PCTL_PC6_PHB0 0x02000000 // PHB0 on PC6 +#define GPIO_PCTL_PC6_C2O 0x03000000 // C2O on PC6 +#define GPIO_PCTL_PC6_PWM7 0x04000000 // PWM7 on PC6 +#define GPIO_PCTL_PC6_U1RX 0x05000000 // U1RX on PC6 +#define GPIO_PCTL_PC6_CCP0 0x06000000 // CCP0 on PC6 +#define GPIO_PCTL_PC6_USB0PFLT 0x07000000 // USB0PFLT on PC6 +#define GPIO_PCTL_PC6_EPI0S4 0x08000000 // EPI0S4 on PC6 +#define GPIO_PCTL_PC7_M 0xF0000000 // PC7 mask +#define GPIO_PCTL_PC7_CCP4 0x10000000 // CCP4 on PC7 +#define GPIO_PCTL_PC7_PHB0 0x20000000 // PHB0 on PC7 +#define GPIO_PCTL_PC7_CCP0 0x40000000 // CCP0 on PC7 +#define GPIO_PCTL_PC7_U1TX 0x50000000 // U1TX on PC7 +#define GPIO_PCTL_PC7_USB0PFLT 0x60000000 // USB0PFLT on PC7 +#define GPIO_PCTL_PC7_C1O 0x70000000 // C1O on PC7 +#define GPIO_PCTL_PC7_EPI0S5 0x80000000 // EPI0S5 on PC7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port D. +// +//***************************************************************************** +#define GPIO_PCTL_PD0_M 0x0000000F // PD0 mask +#define GPIO_PCTL_PD0_PWM0 0x00000001 // PWM0 on PD0 +#define GPIO_PCTL_PD0_CAN0RX 0x00000002 // CAN0RX on PD0 +#define GPIO_PCTL_PD0_IDX0 0x00000003 // IDX0 on PD0 +#define GPIO_PCTL_PD0_U2RX 0x00000004 // U2RX on PD0 +#define GPIO_PCTL_PD0_U1RX 0x00000005 // U1RX on PD0 +#define GPIO_PCTL_PD0_CCP6 0x00000006 // CCP6 on PD0 +#define GPIO_PCTL_PD0_I2S0RXSCK 0x00000008 // I2S0RXSCK on PD0 +#define GPIO_PCTL_PD0_U1CTS 0x00000009 // U1CTS on PD0 +#define GPIO_PCTL_PD1_M 0x000000F0 // PD1 mask +#define GPIO_PCTL_PD1_PWM1 0x00000010 // PWM1 on PD1 +#define GPIO_PCTL_PD1_CAN0TX 0x00000020 // CAN0TX on PD1 +#define GPIO_PCTL_PD1_PHA0 0x00000030 // PHA0 on PD1 +#define GPIO_PCTL_PD1_U2TX 0x00000040 // U2TX on PD1 +#define GPIO_PCTL_PD1_U1TX 0x00000050 // U1TX on PD1 +#define GPIO_PCTL_PD1_CCP7 0x00000060 // CCP7 on PD1 +#define GPIO_PCTL_PD1_I2S0RXWS 0x00000080 // I2S0RXWS on PD1 +#define GPIO_PCTL_PD1_U1DCD 0x00000090 // U1DCD on PD1 +#define GPIO_PCTL_PD1_CCP2 0x000000A0 // CCP2 on PD1 +#define GPIO_PCTL_PD1_PHB1 0x000000B0 // PHB1 on PD1 +#define GPIO_PCTL_PD2_M 0x00000F00 // PD2 mask +#define GPIO_PCTL_PD2_U1RX 0x00000100 // U1RX on PD2 +#define GPIO_PCTL_PD2_CCP6 0x00000200 // CCP6 on PD2 +#define GPIO_PCTL_PD2_PWM2 0x00000300 // PWM2 on PD2 +#define GPIO_PCTL_PD2_CCP5 0x00000400 // CCP5 on PD2 +#define GPIO_PCTL_PD2_EPI0S20 0x00000800 // EPI0S20 on PD2 +#define GPIO_PCTL_PD3_M 0x0000F000 // PD3 mask +#define GPIO_PCTL_PD3_U1TX 0x00001000 // U1TX on PD3 +#define GPIO_PCTL_PD3_CCP7 0x00002000 // CCP7 on PD3 +#define GPIO_PCTL_PD3_PWM3 0x00003000 // PWM3 on PD3 +#define GPIO_PCTL_PD3_CCP0 0x00004000 // CCP0 on PD3 +#define GPIO_PCTL_PD3_EPI0S21 0x00008000 // EPI0S21 on PD3 +#define GPIO_PCTL_PD4_M 0x000F0000 // PD4 mask +#define GPIO_PCTL_PD4_CCP0 0x00010000 // CCP0 on PD4 +#define GPIO_PCTL_PD4_CCP3 0x00020000 // CCP3 on PD4 +#define GPIO_PCTL_PD4_I2S0RXSD 0x00080000 // I2S0RXSD on PD4 +#define GPIO_PCTL_PD4_U1RI 0x00090000 // U1RI on PD4 +#define GPIO_PCTL_PD4_EPI0S19 0x000A0000 // EPI0S19 on PD4 +#define GPIO_PCTL_PD5_M 0x00F00000 // PD5 mask +#define GPIO_PCTL_PD5_CCP2 0x00100000 // CCP2 on PD5 +#define GPIO_PCTL_PD5_CCP4 0x00200000 // CCP4 on PD5 +#define GPIO_PCTL_PD5_I2S0RXMCLK \ + 0x00800000 // I2S0RXMCLK on PD5 +#define GPIO_PCTL_PD5_U2RX 0x00900000 // U2RX on PD5 +#define GPIO_PCTL_PD5_EPI0S28 0x00A00000 // EPI0S28 on PD5 +#define GPIO_PCTL_PD6_M 0x0F000000 // PD6 mask +#define GPIO_PCTL_PD6_FAULT0 0x01000000 // FAULT0 on PD6 +#define GPIO_PCTL_PD6_I2S0TXSCK 0x08000000 // I2S0TXSCK on PD6 +#define GPIO_PCTL_PD6_U2TX 0x09000000 // U2TX on PD6 +#define GPIO_PCTL_PD6_EPI0S29 0x0A000000 // EPI0S29 on PD6 +#define GPIO_PCTL_PD7_M 0xF0000000 // PD7 mask +#define GPIO_PCTL_PD7_IDX0 0x10000000 // IDX0 on PD7 +#define GPIO_PCTL_PD7_C0O 0x20000000 // C0O on PD7 +#define GPIO_PCTL_PD7_CCP1 0x30000000 // CCP1 on PD7 +#define GPIO_PCTL_PD7_I2S0TXWS 0x80000000 // I2S0TXWS on PD7 +#define GPIO_PCTL_PD7_U1DTR 0x90000000 // U1DTR on PD7 +#define GPIO_PCTL_PD7_EPI0S30 0xA0000000 // EPI0S30 on PD7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port E. +// +//***************************************************************************** +#define GPIO_PCTL_PE0_M 0x0000000F // PE0 mask +#define GPIO_PCTL_PE0_PWM4 0x00000001 // PWM4 on PE0 +#define GPIO_PCTL_PE0_SSI1CLK 0x00000002 // SSI1CLK on PE0 +#define GPIO_PCTL_PE0_CCP3 0x00000003 // CCP3 on PE0 +#define GPIO_PCTL_PE0_EPI0S8 0x00000008 // EPI0S8 on PE0 +#define GPIO_PCTL_PE0_USB0PFLT 0x00000009 // USB0PFLT on PE0 +#define GPIO_PCTL_PE1_M 0x000000F0 // PE1 mask +#define GPIO_PCTL_PE1_PWM5 0x00000010 // PWM5 on PE1 +#define GPIO_PCTL_PE1_SSI1FSS 0x00000020 // SSI1FSS on PE1 +#define GPIO_PCTL_PE1_FAULT0 0x00000030 // FAULT0 on PE1 +#define GPIO_PCTL_PE1_CCP2 0x00000040 // CCP2 on PE1 +#define GPIO_PCTL_PE1_CCP6 0x00000050 // CCP6 on PE1 +#define GPIO_PCTL_PE1_EPI0S9 0x00000080 // EPI0S9 on PE1 +#define GPIO_PCTL_PE2_M 0x00000F00 // PE2 mask +#define GPIO_PCTL_PE2_CCP4 0x00000100 // CCP4 on PE2 +#define GPIO_PCTL_PE2_SSI1RX 0x00000200 // SSI1RX on PE2 +#define GPIO_PCTL_PE2_PHB1 0x00000300 // PHB1 on PE2 +#define GPIO_PCTL_PE2_PHA0 0x00000400 // PHA0 on PE2 +#define GPIO_PCTL_PE2_CCP2 0x00000500 // CCP2 on PE2 +#define GPIO_PCTL_PE2_EPI0S24 0x00000800 // EPI0S24 on PE2 +#define GPIO_PCTL_PE3_M 0x0000F000 // PE3 mask +#define GPIO_PCTL_PE3_CCP1 0x00001000 // CCP1 on PE3 +#define GPIO_PCTL_PE3_SSI1TX 0x00002000 // SSI1TX on PE3 +#define GPIO_PCTL_PE3_PHA1 0x00003000 // PHA1 on PE3 +#define GPIO_PCTL_PE3_PHB0 0x00004000 // PHB0 on PE3 +#define GPIO_PCTL_PE3_CCP7 0x00005000 // CCP7 on PE3 +#define GPIO_PCTL_PE3_EPI0S25 0x00008000 // EPI0S25 on PE3 +#define GPIO_PCTL_PE4_M 0x000F0000 // PE4 mask +#define GPIO_PCTL_PE4_CCP3 0x00010000 // CCP3 on PE4 +#define GPIO_PCTL_PE4_FAULT0 0x00040000 // FAULT0 on PE4 +#define GPIO_PCTL_PE4_U2TX 0x00050000 // U2TX on PE4 +#define GPIO_PCTL_PE4_CCP2 0x00060000 // CCP2 on PE4 +#define GPIO_PCTL_PE4_I2S0TXWS 0x00090000 // I2S0TXWS on PE4 +#define GPIO_PCTL_PE5_M 0x00F00000 // PE5 mask +#define GPIO_PCTL_PE5_CCP5 0x00100000 // CCP5 on PE5 +#define GPIO_PCTL_PE5_I2S0TXSD 0x00900000 // I2S0TXSD on PE5 +#define GPIO_PCTL_PE6_M 0x0F000000 // PE6 mask +#define GPIO_PCTL_PE6_PWM4 0x01000000 // PWM4 on PE6 +#define GPIO_PCTL_PE6_C1O 0x02000000 // C1O on PE6 +#define GPIO_PCTL_PE6_U1CTS 0x09000000 // U1CTS on PE6 +#define GPIO_PCTL_PE7_M 0xF0000000 // PE7 mask +#define GPIO_PCTL_PE7_PWM5 0x10000000 // PWM5 on PE7 +#define GPIO_PCTL_PE7_C2O 0x20000000 // C2O on PE7 +#define GPIO_PCTL_PE7_U1DCD 0x90000000 // U1DCD on PE7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port F. +// +//***************************************************************************** +#define GPIO_PCTL_PF0_M 0x0000000F // PF0 mask +#define GPIO_PCTL_PF0_CAN1RX 0x00000001 // CAN1RX on PF0 +#define GPIO_PCTL_PF0_PHB0 0x00000002 // PHB0 on PF0 +#define GPIO_PCTL_PF0_PWM0 0x00000003 // PWM0 on PF0 +#define GPIO_PCTL_PF0_I2S0TXSD 0x00000008 // I2S0TXSD on PF0 +#define GPIO_PCTL_PF0_U1DSR 0x00000009 // U1DSR on PF0 +#define GPIO_PCTL_PF1_M 0x000000F0 // PF1 mask +#define GPIO_PCTL_PF1_CAN1TX 0x00000010 // CAN1TX on PF1 +#define GPIO_PCTL_PF1_IDX1 0x00000020 // IDX1 on PF1 +#define GPIO_PCTL_PF1_PWM1 0x00000030 // PWM1 on PF1 +#define GPIO_PCTL_PF1_I2S0TXMCLK \ + 0x00000080 // I2S0TXMCLK on PF1 +#define GPIO_PCTL_PF1_U1RTS 0x00000090 // U1RTS on PF1 +#define GPIO_PCTL_PF1_CCP3 0x000000A0 // CCP3 on PF1 +#define GPIO_PCTL_PF2_M 0x00000F00 // PF2 mask +#define GPIO_PCTL_PF2_LED1 0x00000100 // LED1 on PF2 +#define GPIO_PCTL_PF2_PWM4 0x00000200 // PWM4 on PF2 +#define GPIO_PCTL_PF2_PWM2 0x00000400 // PWM2 on PF2 +#define GPIO_PCTL_PF2_SSI1CLK 0x00000900 // SSI1CLK on PF2 +#define GPIO_PCTL_PF3_M 0x0000F000 // PF3 mask +#define GPIO_PCTL_PF3_LED0 0x00001000 // LED0 on PF3 +#define GPIO_PCTL_PF3_PWM5 0x00002000 // PWM5 on PF3 +#define GPIO_PCTL_PF3_PWM3 0x00004000 // PWM3 on PF3 +#define GPIO_PCTL_PF3_SSI1FSS 0x00009000 // SSI1FSS on PF3 +#define GPIO_PCTL_PF4_M 0x000F0000 // PF4 mask +#define GPIO_PCTL_PF4_CCP0 0x00010000 // CCP0 on PF4 +#define GPIO_PCTL_PF4_C0O 0x00020000 // C0O on PF4 +#define GPIO_PCTL_PF4_FAULT0 0x00040000 // FAULT0 on PF4 +#define GPIO_PCTL_PF4_EPI0S12 0x00080000 // EPI0S12 on PF4 +#define GPIO_PCTL_PF4_SSI1RX 0x00090000 // SSI1RX on PF4 +#define GPIO_PCTL_PF5_M 0x00F00000 // PF5 mask +#define GPIO_PCTL_PF5_CCP2 0x00100000 // CCP2 on PF5 +#define GPIO_PCTL_PF5_C1O 0x00200000 // C1O on PF5 +#define GPIO_PCTL_PF5_EPI0S15 0x00800000 // EPI0S15 on PF5 +#define GPIO_PCTL_PF5_SSI1TX 0x00900000 // SSI1TX on PF5 +#define GPIO_PCTL_PF6_M 0x0F000000 // PF6 mask +#define GPIO_PCTL_PF6_CCP1 0x01000000 // CCP1 on PF6 +#define GPIO_PCTL_PF6_C2O 0x02000000 // C2O on PF6 +#define GPIO_PCTL_PF6_PHA0 0x04000000 // PHA0 on PF6 +#define GPIO_PCTL_PF6_I2S0TXMCLK \ + 0x09000000 // I2S0TXMCLK on PF6 +#define GPIO_PCTL_PF6_U1RTS 0x0A000000 // U1RTS on PF6 +#define GPIO_PCTL_PF7_M 0xF0000000 // PF7 mask +#define GPIO_PCTL_PF7_CCP4 0x10000000 // CCP4 on PF7 +#define GPIO_PCTL_PF7_PHB0 0x40000000 // PHB0 on PF7 +#define GPIO_PCTL_PF7_EPI0S12 0x80000000 // EPI0S12 on PF7 +#define GPIO_PCTL_PF7_FAULT1 0x90000000 // FAULT1 on PF7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port G. +// +//***************************************************************************** +#define GPIO_PCTL_PG0_M 0x0000000F // PG0 mask +#define GPIO_PCTL_PG0_U2RX 0x00000001 // U2RX on PG0 +#define GPIO_PCTL_PG0_PWM0 0x00000002 // PWM0 on PG0 +#define GPIO_PCTL_PG0_I2C1SCL 0x00000003 // I2C1SCL on PG0 +#define GPIO_PCTL_PG0_PWM4 0x00000004 // PWM4 on PG0 +#define GPIO_PCTL_PG0_USB0EPEN 0x00000007 // USB0EPEN on PG0 +#define GPIO_PCTL_PG0_EPI0S13 0x00000008 // EPI0S13 on PG0 +#define GPIO_PCTL_PG1_M 0x000000F0 // PG1 mask +#define GPIO_PCTL_PG1_U2TX 0x00000010 // U2TX on PG1 +#define GPIO_PCTL_PG1_PWM1 0x00000020 // PWM1 on PG1 +#define GPIO_PCTL_PG1_I2C1SDA 0x00000030 // I2C1SDA on PG1 +#define GPIO_PCTL_PG1_PWM5 0x00000040 // PWM5 on PG1 +#define GPIO_PCTL_PG1_EPI0S14 0x00000080 // EPI0S14 on PG1 +#define GPIO_PCTL_PG2_M 0x00000F00 // PG2 mask +#define GPIO_PCTL_PG2_PWM0 0x00000100 // PWM0 on PG2 +#define GPIO_PCTL_PG2_FAULT0 0x00000400 // FAULT0 on PG2 +#define GPIO_PCTL_PG2_IDX1 0x00000800 // IDX1 on PG2 +#define GPIO_PCTL_PG2_I2S0RXSD 0x00000900 // I2S0RXSD on PG2 +#define GPIO_PCTL_PG3_M 0x0000F000 // PG3 mask +#define GPIO_PCTL_PG3_PWM1 0x00001000 // PWM1 on PG3 +#define GPIO_PCTL_PG3_FAULT2 0x00004000 // FAULT2 on PG3 +#define GPIO_PCTL_PG3_FAULT0 0x00008000 // FAULT0 on PG3 +#define GPIO_PCTL_PG3_I2S0RXMCLK \ + 0x00009000 // I2S0RXMCLK on PG3 +#define GPIO_PCTL_PG4_M 0x000F0000 // PG4 mask +#define GPIO_PCTL_PG4_CCP3 0x00010000 // CCP3 on PG4 +#define GPIO_PCTL_PG4_FAULT1 0x00040000 // FAULT1 on PG4 +#define GPIO_PCTL_PG4_EPI0S15 0x00080000 // EPI0S15 on PG4 +#define GPIO_PCTL_PG4_PWM6 0x00090000 // PWM6 on PG4 +#define GPIO_PCTL_PG4_U1RI 0x000A0000 // U1RI on PG4 +#define GPIO_PCTL_PG5_M 0x00F00000 // PG5 mask +#define GPIO_PCTL_PG5_CCP5 0x00100000 // CCP5 on PG5 +#define GPIO_PCTL_PG5_IDX0 0x00400000 // IDX0 on PG5 +#define GPIO_PCTL_PG5_FAULT1 0x00500000 // FAULT1 on PG5 +#define GPIO_PCTL_PG5_PWM7 0x00800000 // PWM7 on PG5 +#define GPIO_PCTL_PG5_I2S0RXSCK 0x00900000 // I2S0RXSCK on PG5 +#define GPIO_PCTL_PG5_U1DTR 0x00A00000 // U1DTR on PG5 +#define GPIO_PCTL_PG6_M 0x0F000000 // PG6 mask +#define GPIO_PCTL_PG6_PHA1 0x01000000 // PHA1 on PG6 +#define GPIO_PCTL_PG6_PWM6 0x04000000 // PWM6 on PG6 +#define GPIO_PCTL_PG6_FAULT1 0x08000000 // FAULT1 on PG6 +#define GPIO_PCTL_PG6_I2S0RXWS 0x09000000 // I2S0RXWS on PG6 +#define GPIO_PCTL_PG6_U1RI 0x0A000000 // U1RI on PG6 +#define GPIO_PCTL_PG7_M 0xF0000000 // PG7 mask +#define GPIO_PCTL_PG7_PHB1 0x10000000 // PHB1 on PG7 +#define GPIO_PCTL_PG7_PWM7 0x40000000 // PWM7 on PG7 +#define GPIO_PCTL_PG7_CCP5 0x80000000 // CCP5 on PG7 +#define GPIO_PCTL_PG7_EPI0S31 0x90000000 // EPI0S31 on PG7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port H. +// +//***************************************************************************** +#define GPIO_PCTL_PH0_M 0x0000000F // PH0 mask +#define GPIO_PCTL_PH0_CCP6 0x00000001 // CCP6 on PH0 +#define GPIO_PCTL_PH0_PWM2 0x00000002 // PWM2 on PH0 +#define GPIO_PCTL_PH0_EPI0S6 0x00000008 // EPI0S6 on PH0 +#define GPIO_PCTL_PH0_PWM4 0x00000009 // PWM4 on PH0 +#define GPIO_PCTL_PH1_M 0x000000F0 // PH1 mask +#define GPIO_PCTL_PH1_CCP7 0x00000010 // CCP7 on PH1 +#define GPIO_PCTL_PH1_PWM3 0x00000020 // PWM3 on PH1 +#define GPIO_PCTL_PH1_EPI0S7 0x00000080 // EPI0S7 on PH1 +#define GPIO_PCTL_PH1_PWM5 0x00000090 // PWM5 on PH1 +#define GPIO_PCTL_PH2_M 0x00000F00 // PH2 mask +#define GPIO_PCTL_PH2_IDX1 0x00000100 // IDX1 on PH2 +#define GPIO_PCTL_PH2_C1O 0x00000200 // C1O on PH2 +#define GPIO_PCTL_PH2_FAULT3 0x00000400 // FAULT3 on PH2 +#define GPIO_PCTL_PH2_EPI0S1 0x00000800 // EPI0S1 on PH2 +#define GPIO_PCTL_PH3_M 0x0000F000 // PH3 mask +#define GPIO_PCTL_PH3_PHB0 0x00001000 // PHB0 on PH3 +#define GPIO_PCTL_PH3_FAULT0 0x00002000 // FAULT0 on PH3 +#define GPIO_PCTL_PH3_USB0EPEN 0x00004000 // USB0EPEN on PH3 +#define GPIO_PCTL_PH3_EPI0S0 0x00008000 // EPI0S0 on PH3 +#define GPIO_PCTL_PH4_M 0x000F0000 // PH4 mask +#define GPIO_PCTL_PH4_USB0PFLT 0x00040000 // USB0PFLT on PH4 +#define GPIO_PCTL_PH4_EPI0S10 0x00080000 // EPI0S10 on PH4 +#define GPIO_PCTL_PH4_SSI1CLK 0x000B0000 // SSI1CLK on PH4 +#define GPIO_PCTL_PH5_M 0x00F00000 // PH5 mask +#define GPIO_PCTL_PH5_EPI0S11 0x00800000 // EPI0S11 on PH5 +#define GPIO_PCTL_PH5_FAULT2 0x00A00000 // FAULT2 on PH5 +#define GPIO_PCTL_PH5_SSI1FSS 0x00B00000 // SSI1FSS on PH5 +#define GPIO_PCTL_PH6_M 0x0F000000 // PH6 mask +#define GPIO_PCTL_PH6_EPI0S26 0x08000000 // EPI0S26 on PH6 +#define GPIO_PCTL_PH6_PWM4 0x0A000000 // PWM4 on PH6 +#define GPIO_PCTL_PH6_SSI1RX 0x0B000000 // SSI1RX on PH6 +#define GPIO_PCTL_PH7_M 0xF0000000 // PH7 mask +#define GPIO_PCTL_PH7_EPI0S27 0x80000000 // EPI0S27 on PH7 +#define GPIO_PCTL_PH7_PWM5 0xA0000000 // PWM5 on PH7 +#define GPIO_PCTL_PH7_SSI1TX 0xB0000000 // SSI1TX on PH7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port J. +// +//***************************************************************************** +#define GPIO_PCTL_PJ0_M 0x0000000F // PJ0 mask +#define GPIO_PCTL_PJ0_EPI0S16 0x00000008 // EPI0S16 on PJ0 +#define GPIO_PCTL_PJ0_PWM0 0x0000000A // PWM0 on PJ0 +#define GPIO_PCTL_PJ0_I2C1SCL 0x0000000B // I2C1SCL on PJ0 +#define GPIO_PCTL_PJ1_M 0x000000F0 // PJ1 mask +#define GPIO_PCTL_PJ1_EPI0S17 0x00000080 // EPI0S17 on PJ1 +#define GPIO_PCTL_PJ1_USB0PFLT 0x00000090 // USB0PFLT on PJ1 +#define GPIO_PCTL_PJ1_PWM1 0x000000A0 // PWM1 on PJ1 +#define GPIO_PCTL_PJ1_I2C1SDA 0x000000B0 // I2C1SDA on PJ1 +#define GPIO_PCTL_PJ2_M 0x00000F00 // PJ2 mask +#define GPIO_PCTL_PJ2_EPI0S18 0x00000800 // EPI0S18 on PJ2 +#define GPIO_PCTL_PJ2_CCP0 0x00000900 // CCP0 on PJ2 +#define GPIO_PCTL_PJ2_FAULT0 0x00000A00 // FAULT0 on PJ2 +#define GPIO_PCTL_PJ3_M 0x0000F000 // PJ3 mask +#define GPIO_PCTL_PJ3_EPI0S19 0x00008000 // EPI0S19 on PJ3 +#define GPIO_PCTL_PJ3_U1CTS 0x00009000 // U1CTS on PJ3 +#define GPIO_PCTL_PJ3_CCP6 0x0000A000 // CCP6 on PJ3 +#define GPIO_PCTL_PJ4_M 0x000F0000 // PJ4 mask +#define GPIO_PCTL_PJ4_EPI0S28 0x00080000 // EPI0S28 on PJ4 +#define GPIO_PCTL_PJ4_U1DCD 0x00090000 // U1DCD on PJ4 +#define GPIO_PCTL_PJ4_CCP4 0x000A0000 // CCP4 on PJ4 +#define GPIO_PCTL_PJ5_M 0x00F00000 // PJ5 mask +#define GPIO_PCTL_PJ5_EPI0S29 0x00800000 // EPI0S29 on PJ5 +#define GPIO_PCTL_PJ5_U1DSR 0x00900000 // U1DSR on PJ5 +#define GPIO_PCTL_PJ5_CCP2 0x00A00000 // CCP2 on PJ5 +#define GPIO_PCTL_PJ6_M 0x0F000000 // PJ6 mask +#define GPIO_PCTL_PJ6_EPI0S30 0x08000000 // EPI0S30 on PJ6 +#define GPIO_PCTL_PJ6_U1RTS 0x09000000 // U1RTS on PJ6 +#define GPIO_PCTL_PJ6_CCP1 0x0A000000 // CCP1 on PJ6 +#define GPIO_PCTL_PJ7_M 0xF0000000 // PJ7 mask +#define GPIO_PCTL_PJ7_U1DTR 0x90000000 // U1DTR on PJ7 +#define GPIO_PCTL_PJ7_CCP0 0xA0000000 // CCP0 on PJ7 + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the GPIO register offsets. +// +//***************************************************************************** +#define GPIO_O_PeriphID4 0x00000FD0 +#define GPIO_O_PeriphID5 0x00000FD4 +#define GPIO_O_PeriphID6 0x00000FD8 +#define GPIO_O_PeriphID7 0x00000FDC +#define GPIO_O_PeriphID0 0x00000FE0 +#define GPIO_O_PeriphID1 0x00000FE4 +#define GPIO_O_PeriphID2 0x00000FE8 +#define GPIO_O_PeriphID3 0x00000FEC +#define GPIO_O_PCellID0 0x00000FF0 +#define GPIO_O_PCellID1 0x00000FF4 +#define GPIO_O_PCellID2 0x00000FF8 +#define GPIO_O_PCellID3 0x00000FFC + +//***************************************************************************** +// +// The following are deprecated defines for the GPIO Register reset values. +// +//***************************************************************************** +#define GPIO_RV_DEN 0x000000FF // Digital input enable reg RV +#define GPIO_RV_PUR 0x000000FF // Pull up select reg RV +#define GPIO_RV_DR2R 0x000000FF // 2ma drive select reg RV +#define GPIO_RV_PCellID1 0x000000F0 +#define GPIO_RV_PCellID3 0x000000B1 +#define GPIO_RV_PeriphID0 0x00000061 +#define GPIO_RV_PeriphID1 0x00000010 +#define GPIO_RV_PCellID0 0x0000000D +#define GPIO_RV_PCellID2 0x00000005 +#define GPIO_RV_PeriphID2 0x00000004 +#define GPIO_RV_LOCK 0x00000001 // Lock register RV +#define GPIO_RV_PeriphID7 0x00000000 +#define GPIO_RV_PDR 0x00000000 // Pull down select reg RV +#define GPIO_RV_IC 0x00000000 // Interrupt clear reg RV +#define GPIO_RV_SLR 0x00000000 // Slew rate control enable reg RV +#define GPIO_RV_ODR 0x00000000 // Open drain select reg RV +#define GPIO_RV_IBE 0x00000000 // Interrupt both edges reg RV +#define GPIO_RV_AFSEL 0x00000000 // Mode control select reg RV +#define GPIO_RV_IS 0x00000000 // Interrupt sense reg RV +#define GPIO_RV_IM 0x00000000 // Interrupt mask reg RV +#define GPIO_RV_PeriphID4 0x00000000 +#define GPIO_RV_PeriphID5 0x00000000 +#define GPIO_RV_DR8R 0x00000000 // 8ma drive select reg RV +#define GPIO_RV_RIS 0x00000000 // Raw interrupt status reg RV +#define GPIO_RV_DR4R 0x00000000 // 4ma drive select reg RV +#define GPIO_RV_IEV 0x00000000 // Intterupt event reg RV +#define GPIO_RV_DIR 0x00000000 // Data direction reg RV +#define GPIO_RV_PeriphID6 0x00000000 +#define GPIO_RV_PeriphID3 0x00000000 +#define GPIO_RV_DATA 0x00000000 // Data register reset value +#define GPIO_RV_MIS 0x00000000 // Masked interrupt status reg RV + +#endif + +#endif // __HW_GPIO_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_ints.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_ints.h new file mode 100644 index 00000000..1eb1e34e --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_ints.h @@ -0,0 +1,141 @@ +//***************************************************************************** +// +// hw_ints.h - Macros that define the interrupt assignment on Stellaris. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_INTS_H__ +#define __HW_INTS_H__ + +//***************************************************************************** +// +// The following are defines for the fault assignments. +// +//***************************************************************************** +#define FAULT_NMI 2 // NMI fault +#define FAULT_HARD 3 // Hard fault +#define FAULT_MPU 4 // MPU fault +#define FAULT_BUS 5 // Bus fault +#define FAULT_USAGE 6 // Usage fault +#define FAULT_SVCALL 11 // SVCall +#define FAULT_DEBUG 12 // Debug monitor +#define FAULT_PENDSV 14 // PendSV +#define FAULT_SYSTICK 15 // System Tick + +//***************************************************************************** +// +// The following are defines for the interrupt assignments. +// +//***************************************************************************** +#define INT_GPIOA 16 // GPIO Port A +#define INT_GPIOB 17 // GPIO Port B +#define INT_GPIOC 18 // GPIO Port C +#define INT_GPIOD 19 // GPIO Port D +#define INT_GPIOE 20 // GPIO Port E +#define INT_UART0 21 // UART0 Rx and Tx +#define INT_UART1 22 // UART1 Rx and Tx +#define INT_SSI0 23 // SSI0 Rx and Tx +#define INT_I2C0 24 // I2C0 Master and Slave +#define INT_PWM_FAULT 25 // PWM Fault +#define INT_PWM0 26 // PWM Generator 0 +#define INT_PWM1 27 // PWM Generator 1 +#define INT_PWM2 28 // PWM Generator 2 +#define INT_QEI0 29 // Quadrature Encoder 0 +#define INT_ADC0SS0 30 // ADC0 Sequence 0 +#define INT_ADC0SS1 31 // ADC0 Sequence 1 +#define INT_ADC0SS2 32 // ADC0 Sequence 2 +#define INT_ADC0SS3 33 // ADC0 Sequence 3 +#define INT_WATCHDOG 34 // Watchdog timer +#define INT_TIMER0A 35 // Timer 0 subtimer A +#define INT_TIMER0B 36 // Timer 0 subtimer B +#define INT_TIMER1A 37 // Timer 1 subtimer A +#define INT_TIMER1B 38 // Timer 1 subtimer B +#define INT_TIMER2A 39 // Timer 2 subtimer A +#define INT_TIMER2B 40 // Timer 2 subtimer B +#define INT_COMP0 41 // Analog Comparator 0 +#define INT_COMP1 42 // Analog Comparator 1 +#define INT_COMP2 43 // Analog Comparator 2 +#define INT_SYSCTL 44 // System Control (PLL, OSC, BO) +#define INT_FLASH 45 // FLASH Control +#define INT_GPIOF 46 // GPIO Port F +#define INT_GPIOG 47 // GPIO Port G +#define INT_GPIOH 48 // GPIO Port H +#define INT_UART2 49 // UART2 Rx and Tx +#define INT_SSI1 50 // SSI1 Rx and Tx +#define INT_TIMER3A 51 // Timer 3 subtimer A +#define INT_TIMER3B 52 // Timer 3 subtimer B +#define INT_I2C1 53 // I2C1 Master and Slave +#define INT_QEI1 54 // Quadrature Encoder 1 +#define INT_CAN0 55 // CAN0 +#define INT_CAN1 56 // CAN1 +#define INT_CAN2 57 // CAN2 +#define INT_ETH 58 // Ethernet +#define INT_HIBERNATE 59 // Hibernation module +#define INT_USB0 60 // USB 0 Controller +#define INT_PWM3 61 // PWM Generator 3 +#define INT_UDMA 62 // uDMA controller +#define INT_UDMAERR 63 // uDMA Error +#define INT_ADC1SS0 64 // ADC1 Sequence 0 +#define INT_ADC1SS1 65 // ADC1 Sequence 1 +#define INT_ADC1SS2 66 // ADC1 Sequence 2 +#define INT_ADC1SS3 67 // ADC1 Sequence 3 +#define INT_I2S0 68 // I2S0 +#define INT_EPI0 69 // EPI0 +#define INT_GPIOJ 70 // GPIO Port J + +//***************************************************************************** +// +// The following are defines for the total number of interrupts. +// +//***************************************************************************** +#define NUM_INTERRUPTS 71 + +//***************************************************************************** +// +// The following are defines for the total number of priority levels. +// +//***************************************************************************** +#define NUM_PRIORITY 8 +#define NUM_PRIORITY_BITS 3 + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the interrupt assignments. +// +//***************************************************************************** +#define INT_SSI 23 // SSI Rx and Tx +#define INT_I2C 24 // I2C Master and Slave +#define INT_QEI 29 // Quadrature Encoder +#define INT_ADC0 30 // ADC Sequence 0 +#define INT_ADC1 31 // ADC Sequence 1 +#define INT_ADC2 32 // ADC Sequence 2 +#define INT_ADC3 33 // ADC Sequence 3 + +#endif + +#endif // __HW_INTS_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_memmap.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_memmap.h new file mode 100644 index 00000000..144f9d25 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_memmap.h @@ -0,0 +1,115 @@ +//***************************************************************************** +// +// hw_memmap.h - Macros defining the memory map of Stellaris. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_MEMMAP_H__ +#define __HW_MEMMAP_H__ + +//***************************************************************************** +// +// The following are defines for the base address of the memories and +// peripherals. +// +//***************************************************************************** +#define FLASH_BASE 0x00000000 // FLASH memory +#define SRAM_BASE 0x20000000 // SRAM memory +#define WATCHDOG0_BASE 0x40000000 // Watchdog0 +#define WATCHDOG1_BASE 0x40001000 // Watchdog1 +#define GPIO_PORTA_BASE 0x40004000 // GPIO Port A +#define GPIO_PORTB_BASE 0x40005000 // GPIO Port B +#define GPIO_PORTC_BASE 0x40006000 // GPIO Port C +#define GPIO_PORTD_BASE 0x40007000 // GPIO Port D +#define SSI0_BASE 0x40008000 // SSI0 +#define SSI1_BASE 0x40009000 // SSI1 +#define UART0_BASE 0x4000C000 // UART0 +#define UART1_BASE 0x4000D000 // UART1 +#define UART2_BASE 0x4000E000 // UART2 +#define I2C0_MASTER_BASE 0x40020000 // I2C0 Master +#define I2C0_SLAVE_BASE 0x40020800 // I2C0 Slave +#define I2C1_MASTER_BASE 0x40021000 // I2C1 Master +#define I2C1_SLAVE_BASE 0x40021800 // I2C1 Slave +#define GPIO_PORTE_BASE 0x40024000 // GPIO Port E +#define GPIO_PORTF_BASE 0x40025000 // GPIO Port F +#define GPIO_PORTG_BASE 0x40026000 // GPIO Port G +#define GPIO_PORTH_BASE 0x40027000 // GPIO Port H +#define PWM_BASE 0x40028000 // PWM +#define QEI0_BASE 0x4002C000 // QEI0 +#define QEI1_BASE 0x4002D000 // QEI1 +#define TIMER0_BASE 0x40030000 // Timer0 +#define TIMER1_BASE 0x40031000 // Timer1 +#define TIMER2_BASE 0x40032000 // Timer2 +#define TIMER3_BASE 0x40033000 // Timer3 +#define ADC0_BASE 0x40038000 // ADC0 +#define ADC1_BASE 0x40039000 // ADC1 +#define COMP_BASE 0x4003C000 // Analog comparators +#define GPIO_PORTJ_BASE 0x4003D000 // GPIO Port J +#define CAN0_BASE 0x40040000 // CAN0 +#define CAN1_BASE 0x40041000 // CAN1 +#define CAN2_BASE 0x40042000 // CAN2 +#define ETH_BASE 0x40048000 // Ethernet +#define MAC_BASE 0x40048000 // Ethernet +#define USB0_BASE 0x40050000 // USB 0 Controller +#define I2S0_BASE 0x40054000 // I2S0 +#define GPIO_PORTA_AHB_BASE 0x40058000 // GPIO Port A (high speed) +#define GPIO_PORTB_AHB_BASE 0x40059000 // GPIO Port B (high speed) +#define GPIO_PORTC_AHB_BASE 0x4005A000 // GPIO Port C (high speed) +#define GPIO_PORTD_AHB_BASE 0x4005B000 // GPIO Port D (high speed) +#define GPIO_PORTE_AHB_BASE 0x4005C000 // GPIO Port E (high speed) +#define GPIO_PORTF_AHB_BASE 0x4005D000 // GPIO Port F (high speed) +#define GPIO_PORTG_AHB_BASE 0x4005E000 // GPIO Port G (high speed) +#define GPIO_PORTH_AHB_BASE 0x4005F000 // GPIO Port H (high speed) +#define GPIO_PORTJ_AHB_BASE 0x40060000 // GPIO Port J (high speed) +#define EPI0_BASE 0x400D0000 // EPI0 +#define HIB_BASE 0x400FC000 // Hibernation Module +#define FLASH_CTRL_BASE 0x400FD000 // FLASH Controller +#define SYSCTL_BASE 0x400FE000 // System Control +#define UDMA_BASE 0x400FF000 // uDMA Controller +#define ITM_BASE 0xE0000000 // Instrumentation Trace Macrocell +#define DWT_BASE 0xE0001000 // Data Watchpoint and Trace +#define FPB_BASE 0xE0002000 // FLASH Patch and Breakpoint +#define NVIC_BASE 0xE000E000 // Nested Vectored Interrupt Ctrl +#define TPIU_BASE 0xE0040000 // Trace Port Interface Unit + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the base address of the memories +// and peripherals. +// +//***************************************************************************** +#define WATCHDOG_BASE 0x40000000 // Watchdog +#define SSI_BASE 0x40008000 // SSI +#define I2C_MASTER_BASE 0x40020000 // I2C Master +#define I2C_SLAVE_BASE 0x40020800 // I2C Slave +#define QEI_BASE 0x4002C000 // QEI +#define ADC_BASE 0x40038000 // ADC + +#endif + +#endif // __HW_MEMMAP_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_nvic.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_nvic.h new file mode 100644 index 00000000..5ac7bafb --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_nvic.h @@ -0,0 +1,1189 @@ +//***************************************************************************** +// +// hw_nvic.h - Macros used when accessing the NVIC hardware. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_NVIC_H__ +#define __HW_NVIC_H__ + +//***************************************************************************** +// +// The following are defines for the NVIC register addresses. +// +//***************************************************************************** +#define NVIC_INT_TYPE 0xE000E004 // Interrupt Controller Type Reg +#define NVIC_ACTLR 0xE000E008 // Auxiliary Control +#define NVIC_ST_CTRL 0xE000E010 // SysTick Control and Status + // Register +#define NVIC_ST_RELOAD 0xE000E014 // SysTick Reload Value Register +#define NVIC_ST_CURRENT 0xE000E018 // SysTick Current Value Register +#define NVIC_ST_CAL 0xE000E01C // SysTick Calibration Value Reg +#define NVIC_EN0 0xE000E100 // Interrupt 0-31 Set Enable +#define NVIC_EN1 0xE000E104 // Interrupt 32-54 Set Enable +#define NVIC_DIS0 0xE000E180 // Interrupt 0-31 Clear Enable +#define NVIC_DIS1 0xE000E184 // Interrupt 32-54 Clear Enable +#define NVIC_PEND0 0xE000E200 // Interrupt 0-31 Set Pending +#define NVIC_PEND1 0xE000E204 // Interrupt 32-54 Set Pending +#define NVIC_UNPEND0 0xE000E280 // Interrupt 0-31 Clear Pending +#define NVIC_UNPEND1 0xE000E284 // Interrupt 32-54 Clear Pending +#define NVIC_ACTIVE0 0xE000E300 // Interrupt 0-31 Active Bit +#define NVIC_ACTIVE1 0xE000E304 // Interrupt 32-54 Active Bit +#define NVIC_PRI0 0xE000E400 // Interrupt 0-3 Priority +#define NVIC_PRI1 0xE000E404 // Interrupt 4-7 Priority +#define NVIC_PRI2 0xE000E408 // Interrupt 8-11 Priority +#define NVIC_PRI3 0xE000E40C // Interrupt 12-15 Priority +#define NVIC_PRI4 0xE000E410 // Interrupt 16-19 Priority +#define NVIC_PRI5 0xE000E414 // Interrupt 20-23 Priority +#define NVIC_PRI6 0xE000E418 // Interrupt 24-27 Priority +#define NVIC_PRI7 0xE000E41C // Interrupt 28-31 Priority +#define NVIC_PRI8 0xE000E420 // Interrupt 32-35 Priority +#define NVIC_PRI9 0xE000E424 // Interrupt 36-39 Priority +#define NVIC_PRI10 0xE000E428 // Interrupt 40-43 Priority +#define NVIC_PRI11 0xE000E42C // Interrupt 44-47 Priority +#define NVIC_PRI12 0xE000E430 // Interrupt 48-51 Priority +#define NVIC_PRI13 0xE000E434 // Interrupt 52-53 Priority +#define NVIC_CPUID 0xE000ED00 // CPU ID Base +#define NVIC_INT_CTRL 0xE000ED04 // Interrupt Control and State +#define NVIC_VTABLE 0xE000ED08 // Vector Table Offset +#define NVIC_APINT 0xE000ED0C // Application Interrupt and Reset + // Control +#define NVIC_SYS_CTRL 0xE000ED10 // System Control +#define NVIC_CFG_CTRL 0xE000ED14 // Configuration and Control +#define NVIC_SYS_PRI1 0xE000ED18 // System Handler Priority 1 +#define NVIC_SYS_PRI2 0xE000ED1C // System Handler Priority 2 +#define NVIC_SYS_PRI3 0xE000ED20 // System Handler Priority 3 +#define NVIC_SYS_HND_CTRL 0xE000ED24 // System Handler Control and State +#define NVIC_FAULT_STAT 0xE000ED28 // Configurable Fault Status +#define NVIC_HFAULT_STAT 0xE000ED2C // Hard Fault Status +#define NVIC_DEBUG_STAT 0xE000ED30 // Debug Status Register +#define NVIC_MM_ADDR 0xE000ED34 // Memory Management Fault Address +#define NVIC_FAULT_ADDR 0xE000ED38 // Bus Fault Address +#define NVIC_MPU_TYPE 0xE000ED90 // MPU Type +#define NVIC_MPU_CTRL 0xE000ED94 // MPU Control +#define NVIC_MPU_NUMBER 0xE000ED98 // MPU Region Number +#define NVIC_MPU_BASE 0xE000ED9C // MPU Region Base Address +#define NVIC_MPU_ATTR 0xE000EDA0 // MPU Region Attribute and Size +#define NVIC_MPU_BASE1 0xE000EDA4 // MPU Region Base Address Alias 1 +#define NVIC_MPU_ATTR1 0xE000EDA8 // MPU Region Attribute and Size + // Alias 1 +#define NVIC_MPU_BASE2 0xE000EDAC // MPU Region Base Address Alias 2 +#define NVIC_MPU_ATTR2 0xE000EDB0 // MPU Region Attribute and Size + // Alias 2 +#define NVIC_MPU_BASE3 0xE000EDB4 // MPU Region Base Address Alias 3 +#define NVIC_MPU_ATTR3 0xE000EDB8 // MPU Region Attribute and Size + // Alias 3 +#define NVIC_DBG_CTRL 0xE000EDF0 // Debug Control and Status Reg +#define NVIC_DBG_XFER 0xE000EDF4 // Debug Core Reg. Transfer Select +#define NVIC_DBG_DATA 0xE000EDF8 // Debug Core Register Data +#define NVIC_DBG_INT 0xE000EDFC // Debug Reset Interrupt Control +#define NVIC_SW_TRIG 0xE000EF00 // Software Trigger Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_INT_TYPE register. +// +//***************************************************************************** +#define NVIC_INT_TYPE_LINES_M 0x0000001F // Number of interrupt lines (x32) +#define NVIC_INT_TYPE_LINES_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ACTLR register. +// +//***************************************************************************** +#define NVIC_ACTLR_DISFOLD 0x00000004 // Disable IT Folding +#define NVIC_ACTLR_DISWBUF 0x00000002 // Disable Write Buffer +#define NVIC_ACTLR_DISMCYC 0x00000001 // Disable Interrupts of Multiple + // Cycle Instructions + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ST_CTRL register. +// +//***************************************************************************** +#define NVIC_ST_CTRL_COUNT 0x00010000 // Count Flag +#define NVIC_ST_CTRL_CLK_SRC 0x00000004 // Clock Source +#define NVIC_ST_CTRL_INTEN 0x00000002 // Interrupt Enable +#define NVIC_ST_CTRL_ENABLE 0x00000001 // Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ST_RELOAD register. +// +//***************************************************************************** +#define NVIC_ST_RELOAD_M 0x00FFFFFF // Reload Value +#define NVIC_ST_RELOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ST_CURRENT +// register. +// +//***************************************************************************** +#define NVIC_ST_CURRENT_M 0x00FFFFFF // Current Value +#define NVIC_ST_CURRENT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ST_CAL register. +// +//***************************************************************************** +#define NVIC_ST_CAL_NOREF 0x80000000 // No reference clock +#define NVIC_ST_CAL_SKEW 0x40000000 // Clock skew +#define NVIC_ST_CAL_ONEMS_M 0x00FFFFFF // 1ms reference value +#define NVIC_ST_CAL_ONEMS_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_EN0 register. +// +//***************************************************************************** +#define NVIC_EN0_INT_M 0xFFFFFFFF // Interrupt Enable +#define NVIC_EN0_INT0 0x00000001 // Interrupt 0 enable +#define NVIC_EN0_INT1 0x00000002 // Interrupt 1 enable +#define NVIC_EN0_INT2 0x00000004 // Interrupt 2 enable +#define NVIC_EN0_INT3 0x00000008 // Interrupt 3 enable +#define NVIC_EN0_INT4 0x00000010 // Interrupt 4 enable +#define NVIC_EN0_INT5 0x00000020 // Interrupt 5 enable +#define NVIC_EN0_INT6 0x00000040 // Interrupt 6 enable +#define NVIC_EN0_INT7 0x00000080 // Interrupt 7 enable +#define NVIC_EN0_INT8 0x00000100 // Interrupt 8 enable +#define NVIC_EN0_INT9 0x00000200 // Interrupt 9 enable +#define NVIC_EN0_INT10 0x00000400 // Interrupt 10 enable +#define NVIC_EN0_INT11 0x00000800 // Interrupt 11 enable +#define NVIC_EN0_INT12 0x00001000 // Interrupt 12 enable +#define NVIC_EN0_INT13 0x00002000 // Interrupt 13 enable +#define NVIC_EN0_INT14 0x00004000 // Interrupt 14 enable +#define NVIC_EN0_INT15 0x00008000 // Interrupt 15 enable +#define NVIC_EN0_INT16 0x00010000 // Interrupt 16 enable +#define NVIC_EN0_INT17 0x00020000 // Interrupt 17 enable +#define NVIC_EN0_INT18 0x00040000 // Interrupt 18 enable +#define NVIC_EN0_INT19 0x00080000 // Interrupt 19 enable +#define NVIC_EN0_INT20 0x00100000 // Interrupt 20 enable +#define NVIC_EN0_INT21 0x00200000 // Interrupt 21 enable +#define NVIC_EN0_INT22 0x00400000 // Interrupt 22 enable +#define NVIC_EN0_INT23 0x00800000 // Interrupt 23 enable +#define NVIC_EN0_INT24 0x01000000 // Interrupt 24 enable +#define NVIC_EN0_INT25 0x02000000 // Interrupt 25 enable +#define NVIC_EN0_INT26 0x04000000 // Interrupt 26 enable +#define NVIC_EN0_INT27 0x08000000 // Interrupt 27 enable +#define NVIC_EN0_INT28 0x10000000 // Interrupt 28 enable +#define NVIC_EN0_INT29 0x20000000 // Interrupt 29 enable +#define NVIC_EN0_INT30 0x40000000 // Interrupt 30 enable +#define NVIC_EN0_INT31 0x80000000 // Interrupt 31 enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_EN1 register. +// +//***************************************************************************** +#define NVIC_EN1_INT_M 0x007FFFFF // Interrupt Enable +#define NVIC_EN1_INT32 0x00000001 // Interrupt 32 enable +#define NVIC_EN1_INT33 0x00000002 // Interrupt 33 enable +#define NVIC_EN1_INT34 0x00000004 // Interrupt 34 enable +#define NVIC_EN1_INT35 0x00000008 // Interrupt 35 enable +#define NVIC_EN1_INT36 0x00000010 // Interrupt 36 enable +#define NVIC_EN1_INT37 0x00000020 // Interrupt 37 enable +#define NVIC_EN1_INT38 0x00000040 // Interrupt 38 enable +#define NVIC_EN1_INT39 0x00000080 // Interrupt 39 enable +#define NVIC_EN1_INT40 0x00000100 // Interrupt 40 enable +#define NVIC_EN1_INT41 0x00000200 // Interrupt 41 enable +#define NVIC_EN1_INT42 0x00000400 // Interrupt 42 enable +#define NVIC_EN1_INT43 0x00000800 // Interrupt 43 enable +#define NVIC_EN1_INT44 0x00001000 // Interrupt 44 enable +#define NVIC_EN1_INT45 0x00002000 // Interrupt 45 enable +#define NVIC_EN1_INT46 0x00004000 // Interrupt 46 enable +#define NVIC_EN1_INT47 0x00008000 // Interrupt 47 enable +#define NVIC_EN1_INT48 0x00010000 // Interrupt 48 enable +#define NVIC_EN1_INT49 0x00020000 // Interrupt 49 enable +#define NVIC_EN1_INT50 0x00040000 // Interrupt 50 enable +#define NVIC_EN1_INT51 0x00080000 // Interrupt 51 enable +#define NVIC_EN1_INT52 0x00100000 // Interrupt 52 enable +#define NVIC_EN1_INT53 0x00200000 // Interrupt 53 enable +#define NVIC_EN1_INT54 0x00400000 // Interrupt 54 enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DIS0 register. +// +//***************************************************************************** +#define NVIC_DIS0_INT_M 0xFFFFFFFF // Interrupt Disable +#define NVIC_DIS0_INT0 0x00000001 // Interrupt 0 disable +#define NVIC_DIS0_INT1 0x00000002 // Interrupt 1 disable +#define NVIC_DIS0_INT2 0x00000004 // Interrupt 2 disable +#define NVIC_DIS0_INT3 0x00000008 // Interrupt 3 disable +#define NVIC_DIS0_INT4 0x00000010 // Interrupt 4 disable +#define NVIC_DIS0_INT5 0x00000020 // Interrupt 5 disable +#define NVIC_DIS0_INT6 0x00000040 // Interrupt 6 disable +#define NVIC_DIS0_INT7 0x00000080 // Interrupt 7 disable +#define NVIC_DIS0_INT8 0x00000100 // Interrupt 8 disable +#define NVIC_DIS0_INT9 0x00000200 // Interrupt 9 disable +#define NVIC_DIS0_INT10 0x00000400 // Interrupt 10 disable +#define NVIC_DIS0_INT11 0x00000800 // Interrupt 11 disable +#define NVIC_DIS0_INT12 0x00001000 // Interrupt 12 disable +#define NVIC_DIS0_INT13 0x00002000 // Interrupt 13 disable +#define NVIC_DIS0_INT14 0x00004000 // Interrupt 14 disable +#define NVIC_DIS0_INT15 0x00008000 // Interrupt 15 disable +#define NVIC_DIS0_INT16 0x00010000 // Interrupt 16 disable +#define NVIC_DIS0_INT17 0x00020000 // Interrupt 17 disable +#define NVIC_DIS0_INT18 0x00040000 // Interrupt 18 disable +#define NVIC_DIS0_INT19 0x00080000 // Interrupt 19 disable +#define NVIC_DIS0_INT20 0x00100000 // Interrupt 20 disable +#define NVIC_DIS0_INT21 0x00200000 // Interrupt 21 disable +#define NVIC_DIS0_INT22 0x00400000 // Interrupt 22 disable +#define NVIC_DIS0_INT23 0x00800000 // Interrupt 23 disable +#define NVIC_DIS0_INT24 0x01000000 // Interrupt 24 disable +#define NVIC_DIS0_INT25 0x02000000 // Interrupt 25 disable +#define NVIC_DIS0_INT26 0x04000000 // Interrupt 26 disable +#define NVIC_DIS0_INT27 0x08000000 // Interrupt 27 disable +#define NVIC_DIS0_INT28 0x10000000 // Interrupt 28 disable +#define NVIC_DIS0_INT29 0x20000000 // Interrupt 29 disable +#define NVIC_DIS0_INT30 0x40000000 // Interrupt 30 disable +#define NVIC_DIS0_INT31 0x80000000 // Interrupt 31 disable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DIS1 register. +// +//***************************************************************************** +#define NVIC_DIS1_INT_M 0x00FFFFFF // Interrupt Disable +#define NVIC_DIS1_INT32 0x00000001 // Interrupt 32 disable +#define NVIC_DIS1_INT33 0x00000002 // Interrupt 33 disable +#define NVIC_DIS1_INT34 0x00000004 // Interrupt 34 disable +#define NVIC_DIS1_INT35 0x00000008 // Interrupt 35 disable +#define NVIC_DIS1_INT36 0x00000010 // Interrupt 36 disable +#define NVIC_DIS1_INT37 0x00000020 // Interrupt 37 disable +#define NVIC_DIS1_INT38 0x00000040 // Interrupt 38 disable +#define NVIC_DIS1_INT39 0x00000080 // Interrupt 39 disable +#define NVIC_DIS1_INT40 0x00000100 // Interrupt 40 disable +#define NVIC_DIS1_INT41 0x00000200 // Interrupt 41 disable +#define NVIC_DIS1_INT42 0x00000400 // Interrupt 42 disable +#define NVIC_DIS1_INT43 0x00000800 // Interrupt 43 disable +#define NVIC_DIS1_INT44 0x00001000 // Interrupt 44 disable +#define NVIC_DIS1_INT45 0x00002000 // Interrupt 45 disable +#define NVIC_DIS1_INT46 0x00004000 // Interrupt 46 disable +#define NVIC_DIS1_INT47 0x00008000 // Interrupt 47 disable +#define NVIC_DIS1_INT48 0x00010000 // Interrupt 48 disable +#define NVIC_DIS1_INT49 0x00020000 // Interrupt 49 disable +#define NVIC_DIS1_INT50 0x00040000 // Interrupt 50 disable +#define NVIC_DIS1_INT51 0x00080000 // Interrupt 51 disable +#define NVIC_DIS1_INT52 0x00100000 // Interrupt 52 disable +#define NVIC_DIS1_INT53 0x00200000 // Interrupt 53 disable +#define NVIC_DIS1_INT54 0x00400000 // Interrupt 54 disable +#define NVIC_DIS1_INT55 0x00800000 // Interrupt 55 disable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PEND0 register. +// +//***************************************************************************** +#define NVIC_PEND0_INT_M 0xFFFFFFFF // Interrupt Set Pending +#define NVIC_PEND0_INT0 0x00000001 // Interrupt 0 pend +#define NVIC_PEND0_INT1 0x00000002 // Interrupt 1 pend +#define NVIC_PEND0_INT2 0x00000004 // Interrupt 2 pend +#define NVIC_PEND0_INT3 0x00000008 // Interrupt 3 pend +#define NVIC_PEND0_INT4 0x00000010 // Interrupt 4 pend +#define NVIC_PEND0_INT5 0x00000020 // Interrupt 5 pend +#define NVIC_PEND0_INT6 0x00000040 // Interrupt 6 pend +#define NVIC_PEND0_INT7 0x00000080 // Interrupt 7 pend +#define NVIC_PEND0_INT8 0x00000100 // Interrupt 8 pend +#define NVIC_PEND0_INT9 0x00000200 // Interrupt 9 pend +#define NVIC_PEND0_INT10 0x00000400 // Interrupt 10 pend +#define NVIC_PEND0_INT11 0x00000800 // Interrupt 11 pend +#define NVIC_PEND0_INT12 0x00001000 // Interrupt 12 pend +#define NVIC_PEND0_INT13 0x00002000 // Interrupt 13 pend +#define NVIC_PEND0_INT14 0x00004000 // Interrupt 14 pend +#define NVIC_PEND0_INT15 0x00008000 // Interrupt 15 pend +#define NVIC_PEND0_INT16 0x00010000 // Interrupt 16 pend +#define NVIC_PEND0_INT17 0x00020000 // Interrupt 17 pend +#define NVIC_PEND0_INT18 0x00040000 // Interrupt 18 pend +#define NVIC_PEND0_INT19 0x00080000 // Interrupt 19 pend +#define NVIC_PEND0_INT20 0x00100000 // Interrupt 20 pend +#define NVIC_PEND0_INT21 0x00200000 // Interrupt 21 pend +#define NVIC_PEND0_INT22 0x00400000 // Interrupt 22 pend +#define NVIC_PEND0_INT23 0x00800000 // Interrupt 23 pend +#define NVIC_PEND0_INT24 0x01000000 // Interrupt 24 pend +#define NVIC_PEND0_INT25 0x02000000 // Interrupt 25 pend +#define NVIC_PEND0_INT26 0x04000000 // Interrupt 26 pend +#define NVIC_PEND0_INT27 0x08000000 // Interrupt 27 pend +#define NVIC_PEND0_INT28 0x10000000 // Interrupt 28 pend +#define NVIC_PEND0_INT29 0x20000000 // Interrupt 29 pend +#define NVIC_PEND0_INT30 0x40000000 // Interrupt 30 pend +#define NVIC_PEND0_INT31 0x80000000 // Interrupt 31 pend + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PEND1 register. +// +//***************************************************************************** +#define NVIC_PEND1_INT_M 0x00FFFFFF // Interrupt Set Pending +#define NVIC_PEND1_INT32 0x00000001 // Interrupt 32 pend +#define NVIC_PEND1_INT33 0x00000002 // Interrupt 33 pend +#define NVIC_PEND1_INT34 0x00000004 // Interrupt 34 pend +#define NVIC_PEND1_INT35 0x00000008 // Interrupt 35 pend +#define NVIC_PEND1_INT36 0x00000010 // Interrupt 36 pend +#define NVIC_PEND1_INT37 0x00000020 // Interrupt 37 pend +#define NVIC_PEND1_INT38 0x00000040 // Interrupt 38 pend +#define NVIC_PEND1_INT39 0x00000080 // Interrupt 39 pend +#define NVIC_PEND1_INT40 0x00000100 // Interrupt 40 pend +#define NVIC_PEND1_INT41 0x00000200 // Interrupt 41 pend +#define NVIC_PEND1_INT42 0x00000400 // Interrupt 42 pend +#define NVIC_PEND1_INT43 0x00000800 // Interrupt 43 pend +#define NVIC_PEND1_INT44 0x00001000 // Interrupt 44 pend +#define NVIC_PEND1_INT45 0x00002000 // Interrupt 45 pend +#define NVIC_PEND1_INT46 0x00004000 // Interrupt 46 pend +#define NVIC_PEND1_INT47 0x00008000 // Interrupt 47 pend +#define NVIC_PEND1_INT48 0x00010000 // Interrupt 48 pend +#define NVIC_PEND1_INT49 0x00020000 // Interrupt 49 pend +#define NVIC_PEND1_INT50 0x00040000 // Interrupt 50 pend +#define NVIC_PEND1_INT51 0x00080000 // Interrupt 51 pend +#define NVIC_PEND1_INT52 0x00100000 // Interrupt 52 pend +#define NVIC_PEND1_INT53 0x00200000 // Interrupt 53 pend +#define NVIC_PEND1_INT54 0x00400000 // Interrupt 54 pend +#define NVIC_PEND1_INT55 0x00800000 // Interrupt 55 pend + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_UNPEND0 register. +// +//***************************************************************************** +#define NVIC_UNPEND0_INT_M 0xFFFFFFFF // Interrupt Clear Pending +#define NVIC_UNPEND0_INT0 0x00000001 // Interrupt 0 unpend +#define NVIC_UNPEND0_INT1 0x00000002 // Interrupt 1 unpend +#define NVIC_UNPEND0_INT2 0x00000004 // Interrupt 2 unpend +#define NVIC_UNPEND0_INT3 0x00000008 // Interrupt 3 unpend +#define NVIC_UNPEND0_INT4 0x00000010 // Interrupt 4 unpend +#define NVIC_UNPEND0_INT5 0x00000020 // Interrupt 5 unpend +#define NVIC_UNPEND0_INT6 0x00000040 // Interrupt 6 unpend +#define NVIC_UNPEND0_INT7 0x00000080 // Interrupt 7 unpend +#define NVIC_UNPEND0_INT8 0x00000100 // Interrupt 8 unpend +#define NVIC_UNPEND0_INT9 0x00000200 // Interrupt 9 unpend +#define NVIC_UNPEND0_INT10 0x00000400 // Interrupt 10 unpend +#define NVIC_UNPEND0_INT11 0x00000800 // Interrupt 11 unpend +#define NVIC_UNPEND0_INT12 0x00001000 // Interrupt 12 unpend +#define NVIC_UNPEND0_INT13 0x00002000 // Interrupt 13 unpend +#define NVIC_UNPEND0_INT14 0x00004000 // Interrupt 14 unpend +#define NVIC_UNPEND0_INT15 0x00008000 // Interrupt 15 unpend +#define NVIC_UNPEND0_INT16 0x00010000 // Interrupt 16 unpend +#define NVIC_UNPEND0_INT17 0x00020000 // Interrupt 17 unpend +#define NVIC_UNPEND0_INT18 0x00040000 // Interrupt 18 unpend +#define NVIC_UNPEND0_INT19 0x00080000 // Interrupt 19 unpend +#define NVIC_UNPEND0_INT20 0x00100000 // Interrupt 20 unpend +#define NVIC_UNPEND0_INT21 0x00200000 // Interrupt 21 unpend +#define NVIC_UNPEND0_INT22 0x00400000 // Interrupt 22 unpend +#define NVIC_UNPEND0_INT23 0x00800000 // Interrupt 23 unpend +#define NVIC_UNPEND0_INT24 0x01000000 // Interrupt 24 unpend +#define NVIC_UNPEND0_INT25 0x02000000 // Interrupt 25 unpend +#define NVIC_UNPEND0_INT26 0x04000000 // Interrupt 26 unpend +#define NVIC_UNPEND0_INT27 0x08000000 // Interrupt 27 unpend +#define NVIC_UNPEND0_INT28 0x10000000 // Interrupt 28 unpend +#define NVIC_UNPEND0_INT29 0x20000000 // Interrupt 29 unpend +#define NVIC_UNPEND0_INT30 0x40000000 // Interrupt 30 unpend +#define NVIC_UNPEND0_INT31 0x80000000 // Interrupt 31 unpend + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_UNPEND1 register. +// +//***************************************************************************** +#define NVIC_UNPEND1_INT_M 0x00FFFFFF // Interrupt Clear Pending +#define NVIC_UNPEND1_INT32 0x00000001 // Interrupt 32 unpend +#define NVIC_UNPEND1_INT33 0x00000002 // Interrupt 33 unpend +#define NVIC_UNPEND1_INT34 0x00000004 // Interrupt 34 unpend +#define NVIC_UNPEND1_INT35 0x00000008 // Interrupt 35 unpend +#define NVIC_UNPEND1_INT36 0x00000010 // Interrupt 36 unpend +#define NVIC_UNPEND1_INT37 0x00000020 // Interrupt 37 unpend +#define NVIC_UNPEND1_INT38 0x00000040 // Interrupt 38 unpend +#define NVIC_UNPEND1_INT39 0x00000080 // Interrupt 39 unpend +#define NVIC_UNPEND1_INT40 0x00000100 // Interrupt 40 unpend +#define NVIC_UNPEND1_INT41 0x00000200 // Interrupt 41 unpend +#define NVIC_UNPEND1_INT42 0x00000400 // Interrupt 42 unpend +#define NVIC_UNPEND1_INT43 0x00000800 // Interrupt 43 unpend +#define NVIC_UNPEND1_INT44 0x00001000 // Interrupt 44 unpend +#define NVIC_UNPEND1_INT45 0x00002000 // Interrupt 45 unpend +#define NVIC_UNPEND1_INT46 0x00004000 // Interrupt 46 unpend +#define NVIC_UNPEND1_INT47 0x00008000 // Interrupt 47 unpend +#define NVIC_UNPEND1_INT48 0x00010000 // Interrupt 48 unpend +#define NVIC_UNPEND1_INT49 0x00020000 // Interrupt 49 unpend +#define NVIC_UNPEND1_INT50 0x00040000 // Interrupt 50 unpend +#define NVIC_UNPEND1_INT51 0x00080000 // Interrupt 51 unpend +#define NVIC_UNPEND1_INT52 0x00100000 // Interrupt 52 unpend +#define NVIC_UNPEND1_INT53 0x00200000 // Interrupt 53 unpend +#define NVIC_UNPEND1_INT54 0x00400000 // Interrupt 54 unpend +#define NVIC_UNPEND1_INT55 0x00800000 // Interrupt 55 unpend + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ACTIVE0 register. +// +//***************************************************************************** +#define NVIC_ACTIVE0_INT_M 0xFFFFFFFF // Interrupt Active +#define NVIC_ACTIVE0_INT0 0x00000001 // Interrupt 0 active +#define NVIC_ACTIVE0_INT1 0x00000002 // Interrupt 1 active +#define NVIC_ACTIVE0_INT2 0x00000004 // Interrupt 2 active +#define NVIC_ACTIVE0_INT3 0x00000008 // Interrupt 3 active +#define NVIC_ACTIVE0_INT4 0x00000010 // Interrupt 4 active +#define NVIC_ACTIVE0_INT5 0x00000020 // Interrupt 5 active +#define NVIC_ACTIVE0_INT6 0x00000040 // Interrupt 6 active +#define NVIC_ACTIVE0_INT7 0x00000080 // Interrupt 7 active +#define NVIC_ACTIVE0_INT8 0x00000100 // Interrupt 8 active +#define NVIC_ACTIVE0_INT9 0x00000200 // Interrupt 9 active +#define NVIC_ACTIVE0_INT10 0x00000400 // Interrupt 10 active +#define NVIC_ACTIVE0_INT11 0x00000800 // Interrupt 11 active +#define NVIC_ACTIVE0_INT12 0x00001000 // Interrupt 12 active +#define NVIC_ACTIVE0_INT13 0x00002000 // Interrupt 13 active +#define NVIC_ACTIVE0_INT14 0x00004000 // Interrupt 14 active +#define NVIC_ACTIVE0_INT15 0x00008000 // Interrupt 15 active +#define NVIC_ACTIVE0_INT16 0x00010000 // Interrupt 16 active +#define NVIC_ACTIVE0_INT17 0x00020000 // Interrupt 17 active +#define NVIC_ACTIVE0_INT18 0x00040000 // Interrupt 18 active +#define NVIC_ACTIVE0_INT19 0x00080000 // Interrupt 19 active +#define NVIC_ACTIVE0_INT20 0x00100000 // Interrupt 20 active +#define NVIC_ACTIVE0_INT21 0x00200000 // Interrupt 21 active +#define NVIC_ACTIVE0_INT22 0x00400000 // Interrupt 22 active +#define NVIC_ACTIVE0_INT23 0x00800000 // Interrupt 23 active +#define NVIC_ACTIVE0_INT24 0x01000000 // Interrupt 24 active +#define NVIC_ACTIVE0_INT25 0x02000000 // Interrupt 25 active +#define NVIC_ACTIVE0_INT26 0x04000000 // Interrupt 26 active +#define NVIC_ACTIVE0_INT27 0x08000000 // Interrupt 27 active +#define NVIC_ACTIVE0_INT28 0x10000000 // Interrupt 28 active +#define NVIC_ACTIVE0_INT29 0x20000000 // Interrupt 29 active +#define NVIC_ACTIVE0_INT30 0x40000000 // Interrupt 30 active +#define NVIC_ACTIVE0_INT31 0x80000000 // Interrupt 31 active + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ACTIVE1 register. +// +//***************************************************************************** +#define NVIC_ACTIVE1_INT_M 0x00FFFFFF // Interrupt Active +#define NVIC_ACTIVE1_INT32 0x00000001 // Interrupt 32 active +#define NVIC_ACTIVE1_INT33 0x00000002 // Interrupt 33 active +#define NVIC_ACTIVE1_INT34 0x00000004 // Interrupt 34 active +#define NVIC_ACTIVE1_INT35 0x00000008 // Interrupt 35 active +#define NVIC_ACTIVE1_INT36 0x00000010 // Interrupt 36 active +#define NVIC_ACTIVE1_INT37 0x00000020 // Interrupt 37 active +#define NVIC_ACTIVE1_INT38 0x00000040 // Interrupt 38 active +#define NVIC_ACTIVE1_INT39 0x00000080 // Interrupt 39 active +#define NVIC_ACTIVE1_INT40 0x00000100 // Interrupt 40 active +#define NVIC_ACTIVE1_INT41 0x00000200 // Interrupt 41 active +#define NVIC_ACTIVE1_INT42 0x00000400 // Interrupt 42 active +#define NVIC_ACTIVE1_INT43 0x00000800 // Interrupt 43 active +#define NVIC_ACTIVE1_INT44 0x00001000 // Interrupt 44 active +#define NVIC_ACTIVE1_INT45 0x00002000 // Interrupt 45 active +#define NVIC_ACTIVE1_INT46 0x00004000 // Interrupt 46 active +#define NVIC_ACTIVE1_INT47 0x00008000 // Interrupt 47 active +#define NVIC_ACTIVE1_INT48 0x00010000 // Interrupt 48 active +#define NVIC_ACTIVE1_INT49 0x00020000 // Interrupt 49 active +#define NVIC_ACTIVE1_INT50 0x00040000 // Interrupt 50 active +#define NVIC_ACTIVE1_INT51 0x00080000 // Interrupt 51 active +#define NVIC_ACTIVE1_INT52 0x00100000 // Interrupt 52 active +#define NVIC_ACTIVE1_INT53 0x00200000 // Interrupt 53 active +#define NVIC_ACTIVE1_INT54 0x00400000 // Interrupt 54 active +#define NVIC_ACTIVE1_INT55 0x00800000 // Interrupt 55 active + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI0 register. +// +//***************************************************************************** +#define NVIC_PRI0_INT3_M 0xE0000000 // Interrupt 3 Priority Mask +#define NVIC_PRI0_INT2_M 0x00E00000 // Interrupt 2 Priority Mask +#define NVIC_PRI0_INT1_M 0x0000E000 // Interrupt 1 Priority Mask +#define NVIC_PRI0_INT0_M 0x000000E0 // Interrupt 0 Priority Mask +#define NVIC_PRI0_INT3_S 29 +#define NVIC_PRI0_INT2_S 21 +#define NVIC_PRI0_INT1_S 13 +#define NVIC_PRI0_INT0_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI1 register. +// +//***************************************************************************** +#define NVIC_PRI1_INT7_M 0xE0000000 // Interrupt 7 Priority Mask +#define NVIC_PRI1_INT6_M 0x00E00000 // Interrupt 6 Priority Mask +#define NVIC_PRI1_INT5_M 0x0000E000 // Interrupt 5 Priority Mask +#define NVIC_PRI1_INT4_M 0x000000E0 // Interrupt 4 Priority Mask +#define NVIC_PRI1_INT7_S 29 +#define NVIC_PRI1_INT6_S 21 +#define NVIC_PRI1_INT5_S 13 +#define NVIC_PRI1_INT4_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI2 register. +// +//***************************************************************************** +#define NVIC_PRI2_INT11_M 0xE0000000 // Interrupt 11 Priority Mask +#define NVIC_PRI2_INT10_M 0x00E00000 // Interrupt 10 Priority Mask +#define NVIC_PRI2_INT9_M 0x0000E000 // Interrupt 9 Priority Mask +#define NVIC_PRI2_INT8_M 0x000000E0 // Interrupt 8 Priority Mask +#define NVIC_PRI2_INT11_S 29 +#define NVIC_PRI2_INT10_S 21 +#define NVIC_PRI2_INT9_S 13 +#define NVIC_PRI2_INT8_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI3 register. +// +//***************************************************************************** +#define NVIC_PRI3_INT15_M 0xE0000000 // Interrupt 15 Priority Mask +#define NVIC_PRI3_INT14_M 0x00E00000 // Interrupt 14 Priority Mask +#define NVIC_PRI3_INT13_M 0x0000E000 // Interrupt 13 Priority Mask +#define NVIC_PRI3_INT12_M 0x000000E0 // Interrupt 12 Priority Mask +#define NVIC_PRI3_INT15_S 29 +#define NVIC_PRI3_INT14_S 21 +#define NVIC_PRI3_INT13_S 13 +#define NVIC_PRI3_INT12_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI4 register. +// +//***************************************************************************** +#define NVIC_PRI4_INT19_M 0xE0000000 // Interrupt 19 Priority Mask +#define NVIC_PRI4_INT18_M 0x00E00000 // Interrupt 18 Priority Mask +#define NVIC_PRI4_INT17_M 0x0000E000 // Interrupt 17 Priority Mask +#define NVIC_PRI4_INT16_M 0x000000E0 // Interrupt 16 Priority Mask +#define NVIC_PRI4_INT19_S 29 +#define NVIC_PRI4_INT18_S 21 +#define NVIC_PRI4_INT17_S 13 +#define NVIC_PRI4_INT16_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI5 register. +// +//***************************************************************************** +#define NVIC_PRI5_INT23_M 0xE0000000 // Interrupt 23 Priority Mask +#define NVIC_PRI5_INT22_M 0x00E00000 // Interrupt 22 Priority Mask +#define NVIC_PRI5_INT21_M 0x0000E000 // Interrupt 21 Priority Mask +#define NVIC_PRI5_INT20_M 0x000000E0 // Interrupt 20 Priority Mask +#define NVIC_PRI5_INT23_S 29 +#define NVIC_PRI5_INT22_S 21 +#define NVIC_PRI5_INT21_S 13 +#define NVIC_PRI5_INT20_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI6 register. +// +//***************************************************************************** +#define NVIC_PRI6_INT27_M 0xE0000000 // Interrupt 27 Priority Mask +#define NVIC_PRI6_INT26_M 0x00E00000 // Interrupt 26 Priority Mask +#define NVIC_PRI6_INT25_M 0x0000E000 // Interrupt 25 Priority Mask +#define NVIC_PRI6_INT24_M 0x000000E0 // Interrupt 24 Priority Mask +#define NVIC_PRI6_INT27_S 29 +#define NVIC_PRI6_INT26_S 21 +#define NVIC_PRI6_INT25_S 13 +#define NVIC_PRI6_INT24_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI7 register. +// +//***************************************************************************** +#define NVIC_PRI7_INT31_M 0xE0000000 // Interrupt 31 Priority Mask +#define NVIC_PRI7_INT30_M 0x00E00000 // Interrupt 30 Priority Mask +#define NVIC_PRI7_INT29_M 0x0000E000 // Interrupt 29 Priority Mask +#define NVIC_PRI7_INT28_M 0x000000E0 // Interrupt 28 Priority Mask +#define NVIC_PRI7_INT31_S 29 +#define NVIC_PRI7_INT30_S 21 +#define NVIC_PRI7_INT29_S 13 +#define NVIC_PRI7_INT28_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI8 register. +// +//***************************************************************************** +#define NVIC_PRI8_INT35_M 0xE0000000 // Interrupt 35 Priority Mask +#define NVIC_PRI8_INT34_M 0x00E00000 // Interrupt 34 Priority Mask +#define NVIC_PRI8_INT33_M 0x0000E000 // Interrupt 33 Priority Mask +#define NVIC_PRI8_INT32_M 0x000000E0 // Interrupt 32 Priority Mask +#define NVIC_PRI8_INT35_S 29 +#define NVIC_PRI8_INT34_S 21 +#define NVIC_PRI8_INT33_S 13 +#define NVIC_PRI8_INT32_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI9 register. +// +//***************************************************************************** +#define NVIC_PRI9_INT39_M 0xE0000000 // Interrupt 39 Priority Mask +#define NVIC_PRI9_INT38_M 0x00E00000 // Interrupt 38 Priority Mask +#define NVIC_PRI9_INT37_M 0x0000E000 // Interrupt 37 Priority Mask +#define NVIC_PRI9_INT36_M 0x000000E0 // Interrupt 36 Priority Mask +#define NVIC_PRI9_INT39_S 29 +#define NVIC_PRI9_INT38_S 21 +#define NVIC_PRI9_INT37_S 13 +#define NVIC_PRI9_INT36_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI10 register. +// +//***************************************************************************** +#define NVIC_PRI10_INT43_M 0xE0000000 // Interrupt 43 Priority Mask +#define NVIC_PRI10_INT42_M 0x00E00000 // Interrupt 42 Priority Mask +#define NVIC_PRI10_INT41_M 0x0000E000 // Interrupt 41 Priority Mask +#define NVIC_PRI10_INT40_M 0x000000E0 // Interrupt 40 Priority Mask +#define NVIC_PRI10_INT43_S 29 +#define NVIC_PRI10_INT42_S 21 +#define NVIC_PRI10_INT41_S 13 +#define NVIC_PRI10_INT40_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI11 register. +// +//***************************************************************************** +#define NVIC_PRI11_INT47_M 0xE0000000 // Interrupt 47 Priority Mask +#define NVIC_PRI11_INT46_M 0x00E00000 // Interrupt 46 Priority Mask +#define NVIC_PRI11_INT45_M 0x0000E000 // Interrupt 45 Priority Mask +#define NVIC_PRI11_INT44_M 0x000000E0 // Interrupt 44 Priority Mask +#define NVIC_PRI11_INT47_S 29 +#define NVIC_PRI11_INT46_S 21 +#define NVIC_PRI11_INT45_S 13 +#define NVIC_PRI11_INT44_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI12 register. +// +//***************************************************************************** +#define NVIC_PRI12_INT51_M 0xE0000000 // Interrupt 51 Priority Mask +#define NVIC_PRI12_INT50_M 0x00E00000 // Interrupt 50 Priority Mask +#define NVIC_PRI12_INT49_M 0x0000E000 // Interrupt 49 Priority Mask +#define NVIC_PRI12_INT48_M 0x000000E0 // Interrupt 48 Priority Mask +#define NVIC_PRI12_INT51_S 29 +#define NVIC_PRI12_INT50_S 21 +#define NVIC_PRI12_INT49_S 13 +#define NVIC_PRI12_INT48_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI13 register. +// +//***************************************************************************** +#define NVIC_PRI13_INT55_M 0xE0000000 // Interrupt 55 Priority Mask +#define NVIC_PRI13_INT54_M 0x00E00000 // Interrupt 54 Priority Mask +#define NVIC_PRI13_INT53_M 0x0000E000 // Interrupt 53 Priority Mask +#define NVIC_PRI13_INT52_M 0x000000E0 // Interrupt 52 Priority Mask +#define NVIC_PRI13_INT55_S 29 +#define NVIC_PRI13_INT54_S 21 +#define NVIC_PRI13_INT53_S 13 +#define NVIC_PRI13_INT52_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_CPUID register. +// +//***************************************************************************** +#define NVIC_CPUID_IMP_M 0xFF000000 // Implementer Code +#define NVIC_CPUID_IMP_ARM 0x41000000 // ARM +#define NVIC_CPUID_VAR_M 0x00F00000 // Variant Number +#define NVIC_CPUID_CON_M 0x000F0000 // Constant +#define NVIC_CPUID_PARTNO_M 0x0000FFF0 // Part Number +#define NVIC_CPUID_PARTNO_CM3 0x0000C230 // Cortex-M3 processor +#define NVIC_CPUID_REV_M 0x0000000F // Revision Number + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_INT_CTRL register. +// +//***************************************************************************** +#define NVIC_INT_CTRL_NMI_SET 0x80000000 // NMI Set Pending +#define NVIC_INT_CTRL_PEND_SV 0x10000000 // PendSV Set Pending +#define NVIC_INT_CTRL_UNPEND_SV 0x08000000 // PendSV Clear Pending +#define NVIC_INT_CTRL_PENDSTSET 0x04000000 // SysTick Set Pending +#define NVIC_INT_CTRL_PENDSTCLR 0x02000000 // SysTick Clear Pending +#define NVIC_INT_CTRL_ISR_PRE 0x00800000 // Debug Interrupt Handling +#define NVIC_INT_CTRL_ISR_PEND 0x00400000 // Interrupt Pending +#define NVIC_INT_CTRL_VEC_PEN_M 0x0007F000 // Interrupt Pending Vector Number +#define NVIC_INT_CTRL_VEC_PEN_NMI \ + 0x00002000 // NMI +#define NVIC_INT_CTRL_VEC_PEN_HARD \ + 0x00003000 // Hard fault +#define NVIC_INT_CTRL_VEC_PEN_MEM \ + 0x00004000 // Memory management fault +#define NVIC_INT_CTRL_VEC_PEN_BUS \ + 0x00005000 // Bus fault +#define NVIC_INT_CTRL_VEC_PEN_USG \ + 0x00006000 // Usage fault +#define NVIC_INT_CTRL_VEC_PEN_SVC \ + 0x0000B000 // SVCall +#define NVIC_INT_CTRL_VEC_PEN_PNDSV \ + 0x0000E000 // PendSV +#define NVIC_INT_CTRL_VEC_PEN_TICK \ + 0x0000F000 // SysTick +#define NVIC_INT_CTRL_RET_BASE 0x00000800 // Return to Base +#define NVIC_INT_CTRL_VEC_ACT_M 0x0000007F // Interrupt Pending Vector Number +#define NVIC_INT_CTRL_VEC_PEN_S 12 +#define NVIC_INT_CTRL_VEC_ACT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_VTABLE register. +// +//***************************************************************************** +#define NVIC_VTABLE_BASE 0x20000000 // Vector Table Base +#define NVIC_VTABLE_OFFSET_M 0x1FFFFE00 // Vector Table Offset +#define NVIC_VTABLE_OFFSET_S 9 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_APINT register. +// +//***************************************************************************** +#define NVIC_APINT_VECTKEY_M 0xFFFF0000 // Register Key +#define NVIC_APINT_VECTKEY 0x05FA0000 // Vector key +#define NVIC_APINT_ENDIANESS 0x00008000 // Data Endianess +#define NVIC_APINT_PRIGROUP_M 0x00000700 // Interrupt Priority Grouping +#define NVIC_APINT_PRIGROUP_7_1 0x00000000 // Priority group 7.1 split +#define NVIC_APINT_PRIGROUP_6_2 0x00000100 // Priority group 6.2 split +#define NVIC_APINT_PRIGROUP_5_3 0x00000200 // Priority group 5.3 split +#define NVIC_APINT_PRIGROUP_4_4 0x00000300 // Priority group 4.4 split +#define NVIC_APINT_PRIGROUP_3_5 0x00000400 // Priority group 3.5 split +#define NVIC_APINT_PRIGROUP_2_6 0x00000500 // Priority group 2.6 split +#define NVIC_APINT_PRIGROUP_1_7 0x00000600 // Priority group 1.7 split +#define NVIC_APINT_PRIGROUP_0_8 0x00000700 // Priority group 0.8 split +#define NVIC_APINT_SYSRESETREQ 0x00000004 // System Reset Request +#define NVIC_APINT_VECT_CLR_ACT 0x00000002 // Clear Active NMI / Fault +#define NVIC_APINT_VECT_RESET 0x00000001 // System Reset + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SYS_CTRL register. +// +//***************************************************************************** +#define NVIC_SYS_CTRL_SEVONPEND 0x00000010 // Wake Up on Pending +#define NVIC_SYS_CTRL_SLEEPDEEP 0x00000004 // Deep Sleep Enable +#define NVIC_SYS_CTRL_SLEEPEXIT 0x00000002 // Sleep on ISR Exit + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_CFG_CTRL register. +// +//***************************************************************************** +#define NVIC_CFG_CTRL_STKALIGN 0x00000200 // Stack Alignment on Exception + // Entry +#define NVIC_CFG_CTRL_BFHFNMIGN 0x00000100 // Ignore Bus Fault in NMI and + // Fault +#define NVIC_CFG_CTRL_DIV0 0x00000010 // Trap on Divide by 0 +#define NVIC_CFG_CTRL_UNALIGNED 0x00000008 // Trap on Unaligned Access +#define NVIC_CFG_CTRL_MAIN_PEND 0x00000002 // Allow Main Interrupt Trigger +#define NVIC_CFG_CTRL_BASE_THR 0x00000001 // Thread State Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SYS_PRI1 register. +// +//***************************************************************************** +#define NVIC_SYS_PRI1_USAGE_M 0x00E00000 // Usage Fault Priority +#define NVIC_SYS_PRI1_BUS_M 0x0000E000 // Bus Fault Priority +#define NVIC_SYS_PRI1_MEM_M 0x000000E0 // Memory Management Fault Priority +#define NVIC_SYS_PRI1_USAGE_S 21 +#define NVIC_SYS_PRI1_BUS_S 13 +#define NVIC_SYS_PRI1_MEM_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SYS_PRI2 register. +// +//***************************************************************************** +#define NVIC_SYS_PRI2_SVC_M 0xE0000000 // SVCall Priority +#define NVIC_SYS_PRI2_SVC_S 29 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SYS_PRI3 register. +// +//***************************************************************************** +#define NVIC_SYS_PRI3_TICK_M 0xE0000000 // SysTick Exception Priority +#define NVIC_SYS_PRI3_PENDSV_M 0x00E00000 // PendSV Priority +#define NVIC_SYS_PRI3_DEBUG_M 0x000000E0 // Debug Priority +#define NVIC_SYS_PRI3_TICK_S 29 +#define NVIC_SYS_PRI3_PENDSV_S 21 +#define NVIC_SYS_PRI3_DEBUG_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SYS_HND_CTRL +// register. +// +//***************************************************************************** +#define NVIC_SYS_HND_CTRL_USAGE 0x00040000 // Usage Fault Enable +#define NVIC_SYS_HND_CTRL_BUS 0x00020000 // Bus Fault Enable +#define NVIC_SYS_HND_CTRL_MEM 0x00010000 // Memory Management Fault Enable +#define NVIC_SYS_HND_CTRL_SVC 0x00008000 // SVC Call Pending +#define NVIC_SYS_HND_CTRL_BUSP 0x00004000 // Bus Fault Pending +#define NVIC_SYS_HND_CTRL_MEMP 0x00002000 // Memory Management Fault Pending +#define NVIC_SYS_HND_CTRL_USAGEP \ + 0x00001000 // Usage Fault Pending +#define NVIC_SYS_HND_CTRL_TICK 0x00000800 // SysTick Exception Active +#define NVIC_SYS_HND_CTRL_PNDSV 0x00000400 // PendSV Exception Active +#define NVIC_SYS_HND_CTRL_MON 0x00000100 // Debug Monitor Active +#define NVIC_SYS_HND_CTRL_SVCA 0x00000080 // SVC Call Active +#define NVIC_SYS_HND_CTRL_USGA 0x00000008 // Usage Fault Active +#define NVIC_SYS_HND_CTRL_BUSA 0x00000002 // Bus Fault Active +#define NVIC_SYS_HND_CTRL_MEMA 0x00000001 // Memory Management Fault Active + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_FAULT_STAT +// register. +// +//***************************************************************************** +#define NVIC_FAULT_STAT_DIV0 0x02000000 // Divide-by-Zero Usage Fault +#define NVIC_FAULT_STAT_UNALIGN 0x01000000 // Unaligned Access Usage Fault +#define NVIC_FAULT_STAT_NOCP 0x00080000 // No Coprocessor Usage Fault +#define NVIC_FAULT_STAT_INVPC 0x00040000 // Invalid PC Load Usage Fault +#define NVIC_FAULT_STAT_INVSTAT 0x00020000 // Invalid State Usage Fault +#define NVIC_FAULT_STAT_UNDEF 0x00010000 // Undefined Instruction Usage + // Fault +#define NVIC_FAULT_STAT_BFARV 0x00008000 // Bus Fault Address Register Valid +#define NVIC_FAULT_STAT_BSTKE 0x00001000 // Stack Bus Fault +#define NVIC_FAULT_STAT_BUSTKE 0x00000800 // Unstack Bus Fault +#define NVIC_FAULT_STAT_IMPRE 0x00000400 // Imprecise Data Bus Error +#define NVIC_FAULT_STAT_PRECISE 0x00000200 // Precise Data Bus Error +#define NVIC_FAULT_STAT_IBUS 0x00000100 // Instruction Bus Error +#define NVIC_FAULT_STAT_MMARV 0x00000080 // Memory Management Fault Address + // Register Valid +#define NVIC_FAULT_STAT_MSTKE 0x00000010 // Stack Access Violation +#define NVIC_FAULT_STAT_MUSTKE 0x00000008 // Unstack Access Violation +#define NVIC_FAULT_STAT_DERR 0x00000002 // Data Access Violation +#define NVIC_FAULT_STAT_IERR 0x00000001 // Instruction Access Violation + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_HFAULT_STAT +// register. +// +//***************************************************************************** +#define NVIC_HFAULT_STAT_DBG 0x80000000 // Debug Event +#define NVIC_HFAULT_STAT_FORCED 0x40000000 // Forced Hard Fault +#define NVIC_HFAULT_STAT_VECT 0x00000002 // Vector Table Read Fault + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DEBUG_STAT +// register. +// +//***************************************************************************** +#define NVIC_DEBUG_STAT_EXTRNL 0x00000010 // EDBGRQ asserted +#define NVIC_DEBUG_STAT_VCATCH 0x00000008 // Vector catch +#define NVIC_DEBUG_STAT_DWTTRAP 0x00000004 // DWT match +#define NVIC_DEBUG_STAT_BKPT 0x00000002 // Breakpoint instruction +#define NVIC_DEBUG_STAT_HALTED 0x00000001 // Halt request + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MM_ADDR register. +// +//***************************************************************************** +#define NVIC_MM_ADDR_M 0xFFFFFFFF // Fault Address +#define NVIC_MM_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_FAULT_ADDR +// register. +// +//***************************************************************************** +#define NVIC_FAULT_ADDR_M 0xFFFFFFFF // Fault Address +#define NVIC_FAULT_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_TYPE register. +// +//***************************************************************************** +#define NVIC_MPU_TYPE_IREGION_M 0x00FF0000 // Number of I Regions +#define NVIC_MPU_TYPE_DREGION_M 0x0000FF00 // Number of D Regions +#define NVIC_MPU_TYPE_SEPARATE 0x00000001 // Separate or Unified MPU +#define NVIC_MPU_TYPE_IREGION_S 16 +#define NVIC_MPU_TYPE_DREGION_S 8 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_CTRL register. +// +//***************************************************************************** +#define NVIC_MPU_CTRL_PRIVDEFEN 0x00000004 // MPU Default Region +#define NVIC_MPU_CTRL_HFNMIENA 0x00000002 // MPU Enabled During Faults +#define NVIC_MPU_CTRL_ENABLE 0x00000001 // MPU Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_NUMBER +// register. +// +//***************************************************************************** +#define NVIC_MPU_NUMBER_M 0x00000007 // MPU Region to Access +#define NVIC_MPU_NUMBER_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_BASE register. +// +//***************************************************************************** +#define NVIC_MPU_BASE_ADDR_M 0xFFFFFFE0 // Base Address Mask +#define NVIC_MPU_BASE_VALID 0x00000010 // Region Number Valid +#define NVIC_MPU_BASE_REGION_M 0x00000007 // Region Number +#define NVIC_MPU_BASE_ADDR_S 5 +#define NVIC_MPU_BASE_REGION_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_ATTR register. +// +//***************************************************************************** +#define NVIC_MPU_ATTR_M 0xFFFF0000 // Attributes +#define NVIC_MPU_ATTR_XN 0x10000000 // Instruction Access Disable +#define NVIC_MPU_ATTR_AP_M 0x07000000 // Access Privilege +#define NVIC_MPU_ATTR_AP_NO_NO 0x00000000 // prv: no access, usr: no access +#define NVIC_MPU_ATTR_AP_RW_NO 0x01000000 // prv: rw, usr: none +#define NVIC_MPU_ATTR_AP_RW_RO 0x02000000 // prv: rw, usr: read-only +#define NVIC_MPU_ATTR_AP_RW_RW 0x03000000 // prv: rw, usr: rw +#define NVIC_MPU_ATTR_AP_RO_NO 0x05000000 // prv: ro, usr: none +#define NVIC_MPU_ATTR_AP_RO_RO 0x06000000 // prv: ro, usr: ro +#define NVIC_MPU_ATTR_TEX_M 0x00380000 // Type Extension Mask +#define NVIC_MPU_ATTR_SHAREABLE 0x00040000 // Shareable +#define NVIC_MPU_ATTR_CACHEABLE 0x00020000 // Cacheable +#define NVIC_MPU_ATTR_BUFFRABLE 0x00010000 // Bufferable +#define NVIC_MPU_ATTR_SRD_M 0x0000FF00 // Subregion Disable Bits +#define NVIC_MPU_ATTR_SRD_0 0x00000100 // Sub-region 0 disable +#define NVIC_MPU_ATTR_SRD_1 0x00000200 // Sub-region 1 disable +#define NVIC_MPU_ATTR_SRD_2 0x00000400 // Sub-region 2 disable +#define NVIC_MPU_ATTR_SRD_3 0x00000800 // Sub-region 3 disable +#define NVIC_MPU_ATTR_SRD_4 0x00001000 // Sub-region 4 disable +#define NVIC_MPU_ATTR_SRD_5 0x00002000 // Sub-region 5 disable +#define NVIC_MPU_ATTR_SRD_6 0x00004000 // Sub-region 6 disable +#define NVIC_MPU_ATTR_SRD_7 0x00008000 // Sub-region 7 disable +#define NVIC_MPU_ATTR_SIZE_M 0x0000003E // Region Size Mask +#define NVIC_MPU_ATTR_SIZE_32B 0x00000008 // Region size 32 bytes +#define NVIC_MPU_ATTR_SIZE_64B 0x0000000A // Region size 64 bytes +#define NVIC_MPU_ATTR_SIZE_128B 0x0000000C // Region size 128 bytes +#define NVIC_MPU_ATTR_SIZE_256B 0x0000000E // Region size 256 bytes +#define NVIC_MPU_ATTR_SIZE_512B 0x00000010 // Region size 512 bytes +#define NVIC_MPU_ATTR_SIZE_1K 0x00000012 // Region size 1 Kbytes +#define NVIC_MPU_ATTR_SIZE_2K 0x00000014 // Region size 2 Kbytes +#define NVIC_MPU_ATTR_SIZE_4K 0x00000016 // Region size 4 Kbytes +#define NVIC_MPU_ATTR_SIZE_8K 0x00000018 // Region size 8 Kbytes +#define NVIC_MPU_ATTR_SIZE_16K 0x0000001A // Region size 16 Kbytes +#define NVIC_MPU_ATTR_SIZE_32K 0x0000001C // Region size 32 Kbytes +#define NVIC_MPU_ATTR_SIZE_64K 0x0000001E // Region size 64 Kbytes +#define NVIC_MPU_ATTR_SIZE_128K 0x00000020 // Region size 128 Kbytes +#define NVIC_MPU_ATTR_SIZE_256K 0x00000022 // Region size 256 Kbytes +#define NVIC_MPU_ATTR_SIZE_512K 0x00000024 // Region size 512 Kbytes +#define NVIC_MPU_ATTR_SIZE_1M 0x00000026 // Region size 1 Mbytes +#define NVIC_MPU_ATTR_SIZE_2M 0x00000028 // Region size 2 Mbytes +#define NVIC_MPU_ATTR_SIZE_4M 0x0000002A // Region size 4 Mbytes +#define NVIC_MPU_ATTR_SIZE_8M 0x0000002C // Region size 8 Mbytes +#define NVIC_MPU_ATTR_SIZE_16M 0x0000002E // Region size 16 Mbytes +#define NVIC_MPU_ATTR_SIZE_32M 0x00000030 // Region size 32 Mbytes +#define NVIC_MPU_ATTR_SIZE_64M 0x00000032 // Region size 64 Mbytes +#define NVIC_MPU_ATTR_SIZE_128M 0x00000034 // Region size 128 Mbytes +#define NVIC_MPU_ATTR_SIZE_256M 0x00000036 // Region size 256 Mbytes +#define NVIC_MPU_ATTR_SIZE_512M 0x00000038 // Region size 512 Mbytes +#define NVIC_MPU_ATTR_SIZE_1G 0x0000003A // Region size 1 Gbytes +#define NVIC_MPU_ATTR_SIZE_2G 0x0000003C // Region size 2 Gbytes +#define NVIC_MPU_ATTR_SIZE_4G 0x0000003E // Region size 4 Gbytes +#define NVIC_MPU_ATTR_ENABLE 0x00000001 // Region Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_BASE1 register. +// +//***************************************************************************** +#define NVIC_MPU_BASE1_ADDR_M 0xFFFFFFE0 // Base Address Mask +#define NVIC_MPU_BASE1_VALID 0x00000010 // Region Number Valid +#define NVIC_MPU_BASE1_REGION_M 0x00000007 // Region Number +#define NVIC_MPU_BASE1_ADDR_S 5 +#define NVIC_MPU_BASE1_REGION_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_ATTR1 register. +// +//***************************************************************************** +#define NVIC_MPU_ATTR1_XN 0x10000000 // Instruction Access Disable +#define NVIC_MPU_ATTR1_AP_M 0x07000000 // Access Privilege +#define NVIC_MPU_ATTR1_TEX_M 0x00380000 // Type Extension Mask +#define NVIC_MPU_ATTR1_SHAREABLE \ + 0x00040000 // Shareable +#define NVIC_MPU_ATTR1_CACHEABLE \ + 0x00020000 // Cacheable +#define NVIC_MPU_ATTR1_BUFFRABLE \ + 0x00010000 // Bufferable +#define NVIC_MPU_ATTR1_SRD_M 0x0000FF00 // Subregion Disable Bits +#define NVIC_MPU_ATTR1_SIZE_M 0x0000003E // Region Size Mask +#define NVIC_MPU_ATTR1_ENABLE 0x00000001 // Region Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_BASE2 register. +// +//***************************************************************************** +#define NVIC_MPU_BASE2_ADDR_M 0xFFFFFFE0 // Base Address Mask +#define NVIC_MPU_BASE2_VALID 0x00000010 // Region Number Valid +#define NVIC_MPU_BASE2_REGION_M 0x00000007 // Region Number +#define NVIC_MPU_BASE2_ADDR_S 5 +#define NVIC_MPU_BASE2_REGION_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_ATTR2 register. +// +//***************************************************************************** +#define NVIC_MPU_ATTR2_XN 0x10000000 // Instruction Access Disable +#define NVIC_MPU_ATTR2_AP_M 0x07000000 // Access Privilege +#define NVIC_MPU_ATTR2_TEX_M 0x00380000 // Type Extension Mask +#define NVIC_MPU_ATTR2_SHAREABLE \ + 0x00040000 // Shareable +#define NVIC_MPU_ATTR2_CACHEABLE \ + 0x00020000 // Cacheable +#define NVIC_MPU_ATTR2_BUFFRABLE \ + 0x00010000 // Bufferable +#define NVIC_MPU_ATTR2_SRD_M 0x0000FF00 // Subregion Disable Bits +#define NVIC_MPU_ATTR2_SIZE_M 0x0000003E // Region Size Mask +#define NVIC_MPU_ATTR2_ENABLE 0x00000001 // Region Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_BASE3 register. +// +//***************************************************************************** +#define NVIC_MPU_BASE3_ADDR_M 0xFFFFFFE0 // Base Address Mask +#define NVIC_MPU_BASE3_VALID 0x00000010 // Region Number Valid +#define NVIC_MPU_BASE3_REGION_M 0x00000007 // Region Number +#define NVIC_MPU_BASE3_ADDR_S 5 +#define NVIC_MPU_BASE3_REGION_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_ATTR3 register. +// +//***************************************************************************** +#define NVIC_MPU_ATTR3_XN 0x10000000 // Instruction Access Disable +#define NVIC_MPU_ATTR3_AP_M 0x07000000 // Access Privilege +#define NVIC_MPU_ATTR3_TEX_M 0x00380000 // Type Extension Mask +#define NVIC_MPU_ATTR3_SHAREABLE \ + 0x00040000 // Shareable +#define NVIC_MPU_ATTR3_CACHEABLE \ + 0x00020000 // Cacheable +#define NVIC_MPU_ATTR3_BUFFRABLE \ + 0x00010000 // Bufferable +#define NVIC_MPU_ATTR3_SRD_M 0x0000FF00 // Subregion Disable Bits +#define NVIC_MPU_ATTR3_SIZE_M 0x0000003E // Region Size Mask +#define NVIC_MPU_ATTR3_ENABLE 0x00000001 // Region Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DBG_CTRL register. +// +//***************************************************************************** +#define NVIC_DBG_CTRL_DBGKEY_M 0xFFFF0000 // Debug key mask +#define NVIC_DBG_CTRL_DBGKEY 0xA05F0000 // Debug key +#define NVIC_DBG_CTRL_S_RESET_ST \ + 0x02000000 // Core has reset since last read +#define NVIC_DBG_CTRL_S_RETIRE_ST \ + 0x01000000 // Core has executed insruction + // since last read +#define NVIC_DBG_CTRL_S_LOCKUP 0x00080000 // Core is locked up +#define NVIC_DBG_CTRL_S_SLEEP 0x00040000 // Core is sleeping +#define NVIC_DBG_CTRL_S_HALT 0x00020000 // Core status on halt +#define NVIC_DBG_CTRL_S_REGRDY 0x00010000 // Register read/write available +#define NVIC_DBG_CTRL_C_SNAPSTALL \ + 0x00000020 // Breaks a stalled load/store +#define NVIC_DBG_CTRL_C_MASKINT 0x00000008 // Mask interrupts when stepping +#define NVIC_DBG_CTRL_C_STEP 0x00000004 // Step the core +#define NVIC_DBG_CTRL_C_HALT 0x00000002 // Halt the core +#define NVIC_DBG_CTRL_C_DEBUGEN 0x00000001 // Enable debug + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DBG_XFER register. +// +//***************************************************************************** +#define NVIC_DBG_XFER_REG_WNR 0x00010000 // Write or not read +#define NVIC_DBG_XFER_REG_SEL_M 0x0000001F // Register +#define NVIC_DBG_XFER_REG_R0 0x00000000 // Register R0 +#define NVIC_DBG_XFER_REG_R1 0x00000001 // Register R1 +#define NVIC_DBG_XFER_REG_R2 0x00000002 // Register R2 +#define NVIC_DBG_XFER_REG_R3 0x00000003 // Register R3 +#define NVIC_DBG_XFER_REG_R4 0x00000004 // Register R4 +#define NVIC_DBG_XFER_REG_R5 0x00000005 // Register R5 +#define NVIC_DBG_XFER_REG_R6 0x00000006 // Register R6 +#define NVIC_DBG_XFER_REG_R7 0x00000007 // Register R7 +#define NVIC_DBG_XFER_REG_R8 0x00000008 // Register R8 +#define NVIC_DBG_XFER_REG_R9 0x00000009 // Register R9 +#define NVIC_DBG_XFER_REG_R10 0x0000000A // Register R10 +#define NVIC_DBG_XFER_REG_R11 0x0000000B // Register R11 +#define NVIC_DBG_XFER_REG_R12 0x0000000C // Register R12 +#define NVIC_DBG_XFER_REG_R13 0x0000000D // Register R13 +#define NVIC_DBG_XFER_REG_R14 0x0000000E // Register R14 +#define NVIC_DBG_XFER_REG_R15 0x0000000F // Register R15 +#define NVIC_DBG_XFER_REG_FLAGS 0x00000010 // xPSR/Flags register +#define NVIC_DBG_XFER_REG_MSP 0x00000011 // Main SP +#define NVIC_DBG_XFER_REG_PSP 0x00000012 // Process SP +#define NVIC_DBG_XFER_REG_DSP 0x00000013 // Deep SP +#define NVIC_DBG_XFER_REG_CFBP 0x00000014 // Control/Fault/BasePri/PriMask + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DBG_DATA register. +// +//***************************************************************************** +#define NVIC_DBG_DATA_M 0xFFFFFFFF // Data temporary cache +#define NVIC_DBG_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DBG_INT register. +// +//***************************************************************************** +#define NVIC_DBG_INT_HARDERR 0x00000400 // Debug trap on hard fault +#define NVIC_DBG_INT_INTERR 0x00000200 // Debug trap on interrupt errors +#define NVIC_DBG_INT_BUSERR 0x00000100 // Debug trap on bus error +#define NVIC_DBG_INT_STATERR 0x00000080 // Debug trap on usage fault state +#define NVIC_DBG_INT_CHKERR 0x00000040 // Debug trap on usage fault check +#define NVIC_DBG_INT_NOCPERR 0x00000020 // Debug trap on coprocessor error +#define NVIC_DBG_INT_MMERR 0x00000010 // Debug trap on mem manage fault +#define NVIC_DBG_INT_RESET 0x00000008 // Core reset status +#define NVIC_DBG_INT_RSTPENDCLR 0x00000004 // Clear pending core reset +#define NVIC_DBG_INT_RSTPENDING 0x00000002 // Core reset is pending +#define NVIC_DBG_INT_RSTVCATCH 0x00000001 // Reset vector catch + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SW_TRIG register. +// +//***************************************************************************** +#define NVIC_SW_TRIG_INTID_M 0x0000003F // Interrupt ID +#define NVIC_SW_TRIG_INTID_S 0 + +#endif // __HW_NVIC_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_sysctl.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_sysctl.h new file mode 100644 index 00000000..2bcd8c71 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_sysctl.h @@ -0,0 +1,1687 @@ +//***************************************************************************** +// +// hw_sysctl.h - Macros used when accessing the system control hardware. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_SYSCTL_H__ +#define __HW_SYSCTL_H__ + +//***************************************************************************** +// +// The following are defines for the System Control register addresses. +// +//***************************************************************************** +#define SYSCTL_DID0 0x400FE000 // Device Identification 0 +#define SYSCTL_DID1 0x400FE004 // Device Identification 1 +#define SYSCTL_DC0 0x400FE008 // Device Capabilities 0 +#define SYSCTL_DC1 0x400FE010 // Device Capabilities 1 +#define SYSCTL_DC2 0x400FE014 // Device Capabilities 2 +#define SYSCTL_DC3 0x400FE018 // Device Capabilities 3 +#define SYSCTL_DC4 0x400FE01C // Device Capabilities 4 +#define SYSCTL_DC5 0x400FE020 // Device Capabilities 5 +#define SYSCTL_DC6 0x400FE024 // Device Capabilities 6 +#define SYSCTL_DC7 0x400FE028 // Device Capabilities 7 +#define SYSCTL_DC8 0x400FE02C // Device Capabilities 8 ADC + // Channels +#define SYSCTL_PBORCTL 0x400FE030 // Brown-Out Reset Control +#define SYSCTL_LDOPCTL 0x400FE034 // LDO Power Control +#define SYSCTL_SRCR0 0x400FE040 // Software Reset Control 0 +#define SYSCTL_SRCR1 0x400FE044 // Software Reset Control 1 +#define SYSCTL_SRCR2 0x400FE048 // Software Reset Control 2 +#define SYSCTL_RIS 0x400FE050 // Raw Interrupt Status +#define SYSCTL_IMC 0x400FE054 // Interrupt Mask Control +#define SYSCTL_MISC 0x400FE058 // Masked Interrupt Status and + // Clear +#define SYSCTL_RESC 0x400FE05C // Reset Cause +#define SYSCTL_RCC 0x400FE060 // Run-Mode Clock Configuration +#define SYSCTL_PLLCFG 0x400FE064 // XTAL to PLL Translation +#define SYSCTL_GPIOHBCTL 0x400FE06C // GPIO High-Performance Bus + // Control +#define SYSCTL_RCC2 0x400FE070 // Run-Mode Clock Configuration 2 +#define SYSCTL_MOSCCTL 0x400FE07C // Main Oscillator Control +#define SYSCTL_RCGC0 0x400FE100 // Run Mode Clock Gating Control + // Register 0 +#define SYSCTL_RCGC1 0x400FE104 // Run Mode Clock Gating Control + // Register 1 +#define SYSCTL_RCGC2 0x400FE108 // Run Mode Clock Gating Control + // Register 2 +#define SYSCTL_SCGC0 0x400FE110 // Sleep Mode Clock Gating Control + // Register 0 +#define SYSCTL_SCGC1 0x400FE114 // Sleep Mode Clock Gating Control + // Register 1 +#define SYSCTL_SCGC2 0x400FE118 // Sleep Mode Clock Gating Control + // Register 2 +#define SYSCTL_DCGC0 0x400FE120 // Deep Sleep Mode Clock Gating + // Control Register 0 +#define SYSCTL_DCGC1 0x400FE124 // Deep-Sleep Mode Clock Gating + // Control Register 1 +#define SYSCTL_DCGC2 0x400FE128 // Deep Sleep Mode Clock Gating + // Control Register 2 +#define SYSCTL_DSLPCLKCFG 0x400FE144 // Deep Sleep Clock Configuration +#define SYSCTL_PIOSCCAL 0x400FE150 // Precision Internal Oscillator + // Calibration +#define SYSCTL_CLKVCLR 0x400FE150 // Clock Verification Clear +#define SYSCTL_PIOSCSTAT 0x400FE154 // Precision Internal Oscillator + // Statistics +#define SYSCTL_LDOARST 0x400FE160 // Allow Unregulated LDO to Reset + // the Part +#define SYSCTL_I2SMCLKCFG 0x400FE170 // I2S MCLK Configuration +#define SYSCTL_DC9 0x400FE190 // Device Capabilities 9 ADC + // Digital Comparators +#define SYSCTL_NVMSTAT 0x400FE1A0 // Non-Volatile Memory Information + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DID0 register. +// +//***************************************************************************** +#define SYSCTL_DID0_VER_M 0x70000000 // DID0 Version +#define SYSCTL_DID0_VER_0 0x00000000 // Initial DID0 register format + // definition for Stellaris(R) + // Sandstorm-class devices +#define SYSCTL_DID0_VER_1 0x10000000 // Second version of the DID0 + // register format +#define SYSCTL_DID0_CLASS_M 0x00FF0000 // Device Class +#define SYSCTL_DID0_CLASS_SANDSTORM \ + 0x00000000 // Sandstorm-class Device +#define SYSCTL_DID0_CLASS_FURY 0x00010000 // Stellaris(R) Fury-class devices +#define SYSCTL_DID0_CLASS_DUSTDEVIL \ + 0x00030000 // Stellaris(R) DustDevil-class + // devices +#define SYSCTL_DID0_CLASS_TEMPEST \ + 0x00040000 // Stellaris(R) Tempest-class + // microcontrollers +#define SYSCTL_DID0_MAJ_M 0x0000FF00 // Major Revision +#define SYSCTL_DID0_MAJ_REVA 0x00000000 // Revision A (initial device) +#define SYSCTL_DID0_MAJ_REVB 0x00000100 // Revision B (first base layer + // revision) +#define SYSCTL_DID0_MAJ_REVC 0x00000200 // Revision C (second base layer + // revision) +#define SYSCTL_DID0_MIN_M 0x000000FF // Minor Revision +#define SYSCTL_DID0_MIN_0 0x00000000 // Initial device, or a major + // revision update +#define SYSCTL_DID0_MIN_1 0x00000001 // First metal layer change +#define SYSCTL_DID0_MIN_2 0x00000002 // Second metal layer change +#define SYSCTL_DID0_MIN_3 0x00000003 // Minor revision 3 +#define SYSCTL_DID0_MIN_4 0x00000004 // Minor revision 4 +#define SYSCTL_DID0_MIN_5 0x00000005 // Minor revision 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DID1 register. +// +//***************************************************************************** +#define SYSCTL_DID1_VER_M 0xF0000000 // DID1 Version +#define SYSCTL_DID1_VER_0 0x00000000 // Initial DID1 register format + // definition, indicating a + // Stellaris LM3Snnn device +#define SYSCTL_DID1_VER_1 0x10000000 // Second version of the DID1 + // register format +#define SYSCTL_DID1_FAM_M 0x0F000000 // Family +#define SYSCTL_DID1_FAM_STELLARIS \ + 0x00000000 // Stellaris family of + // microcontollers, that is, all + // devices with external part + // numbers starting with LM3S +#define SYSCTL_DID1_PRTNO_M 0x00FF0000 // Part Number +#define SYSCTL_DID1_PRTNO_101 0x00010000 // LM3S101 +#define SYSCTL_DID1_PRTNO_102 0x00020000 // LM3S102 +#define SYSCTL_DID1_PRTNO_300 0x00190000 // LM3S300 +#define SYSCTL_DID1_PRTNO_301 0x00110000 // LM3S301 +#define SYSCTL_DID1_PRTNO_308 0x001A0000 // LM3S308 +#define SYSCTL_DID1_PRTNO_310 0x00120000 // LM3S310 +#define SYSCTL_DID1_PRTNO_315 0x00130000 // LM3S315 +#define SYSCTL_DID1_PRTNO_316 0x00140000 // LM3S316 +#define SYSCTL_DID1_PRTNO_317 0x00170000 // LM3S317 +#define SYSCTL_DID1_PRTNO_328 0x00150000 // LM3S328 +#define SYSCTL_DID1_PRTNO_600 0x002A0000 // LM3S600 +#define SYSCTL_DID1_PRTNO_601 0x00210000 // LM3S601 +#define SYSCTL_DID1_PRTNO_608 0x002B0000 // LM3S608 +#define SYSCTL_DID1_PRTNO_610 0x00220000 // LM3S610 +#define SYSCTL_DID1_PRTNO_611 0x00230000 // LM3S611 +#define SYSCTL_DID1_PRTNO_612 0x00240000 // LM3S612 +#define SYSCTL_DID1_PRTNO_613 0x00250000 // LM3S613 +#define SYSCTL_DID1_PRTNO_615 0x00260000 // LM3S615 +#define SYSCTL_DID1_PRTNO_617 0x00280000 // LM3S617 +#define SYSCTL_DID1_PRTNO_618 0x00290000 // LM3S618 +#define SYSCTL_DID1_PRTNO_628 0x00270000 // LM3S628 +#define SYSCTL_DID1_PRTNO_800 0x00380000 // LM3S800 +#define SYSCTL_DID1_PRTNO_801 0x00310000 // LM3S801 +#define SYSCTL_DID1_PRTNO_808 0x00390000 // LM3S808 +#define SYSCTL_DID1_PRTNO_811 0x00320000 // LM3S811 +#define SYSCTL_DID1_PRTNO_812 0x00330000 // LM3S812 +#define SYSCTL_DID1_PRTNO_815 0x00340000 // LM3S815 +#define SYSCTL_DID1_PRTNO_817 0x00360000 // LM3S817 +#define SYSCTL_DID1_PRTNO_818 0x00370000 // LM3S818 +#define SYSCTL_DID1_PRTNO_828 0x00350000 // LM3S828 +#define SYSCTL_DID1_PRTNO_1110 0x00BF0000 // LM3S1110 +#define SYSCTL_DID1_PRTNO_1133 0x00C30000 // LM3S1133 +#define SYSCTL_DID1_PRTNO_1138 0x00C50000 // LM3S1138 +#define SYSCTL_DID1_PRTNO_1150 0x00C10000 // LM3S1150 +#define SYSCTL_DID1_PRTNO_1162 0x00C40000 // LM3S1162 +#define SYSCTL_DID1_PRTNO_1165 0x00C20000 // LM3S1165 +#define SYSCTL_DID1_PRTNO_1332 0x00C60000 // LM3S1332 +#define SYSCTL_DID1_PRTNO_1435 0x00BC0000 // LM3S1435 +#define SYSCTL_DID1_PRTNO_1439 0x00BA0000 // LM3S1439 +#define SYSCTL_DID1_PRTNO_1512 0x00BB0000 // LM3S1512 +#define SYSCTL_DID1_PRTNO_1538 0x00C70000 // LM3S1538 +#define SYSCTL_DID1_PRTNO_1601 0x00DB0000 // LM3S1601 +#define SYSCTL_DID1_PRTNO_1607 0x00060000 // LM3S1607 +#define SYSCTL_DID1_PRTNO_1608 0x00DA0000 // LM3S1608 +#define SYSCTL_DID1_PRTNO_1620 0x00C00000 // LM3S1620 +#define SYSCTL_DID1_PRTNO_1625 0x00030000 // LM3S1625 +#define SYSCTL_DID1_PRTNO_1626 0x00040000 // LM3S1626 +#define SYSCTL_DID1_PRTNO_1627 0x00050000 // LM3S1627 +#define SYSCTL_DID1_PRTNO_1635 0x00B30000 // LM3S1635 +#define SYSCTL_DID1_PRTNO_1637 0x00BD0000 // LM3S1637 +#define SYSCTL_DID1_PRTNO_1651 0x00B10000 // LM3S1651 +#define SYSCTL_DID1_PRTNO_1751 0x00B90000 // LM3S1751 +#define SYSCTL_DID1_PRTNO_1776 0x00100000 // LM3S1776 +#define SYSCTL_DID1_PRTNO_1811 0x00160000 // LM3S1811 +#define SYSCTL_DID1_PRTNO_1816 0x003D0000 // LM3S1816 +#define SYSCTL_DID1_PRTNO_1850 0x00B40000 // LM3S1850 +#define SYSCTL_DID1_PRTNO_1911 0x00DD0000 // LM3S1911 +#define SYSCTL_DID1_PRTNO_1918 0x00DC0000 // LM3S1918 +#define SYSCTL_DID1_PRTNO_1937 0x00B70000 // LM3S1937 +#define SYSCTL_DID1_PRTNO_1958 0x00BE0000 // LM3S1958 +#define SYSCTL_DID1_PRTNO_1960 0x00B50000 // LM3S1960 +#define SYSCTL_DID1_PRTNO_1968 0x00B80000 // LM3S1968 +#define SYSCTL_DID1_PRTNO_1J11 0x000F0000 // LM3S1J11 +#define SYSCTL_DID1_PRTNO_1J16 0x003C0000 // LM3S1J16 +#define SYSCTL_DID1_PRTNO_1N11 0x000E0000 // LM3S1N11 +#define SYSCTL_DID1_PRTNO_1N16 0x003B0000 // LM3S1N16 +#define SYSCTL_DID1_PRTNO_1P51 0x00B20000 // LM3S1P51 +#define SYSCTL_DID1_PRTNO_1R21 0x009E0000 // LM3S1R21 +#define SYSCTL_DID1_PRTNO_1W16 0x00300000 // LM3S1W16 +#define SYSCTL_DID1_PRTNO_1Z16 0x002F0000 // LM3S1Z16 +#define SYSCTL_DID1_PRTNO_2110 0x00510000 // LM3S2110 +#define SYSCTL_DID1_PRTNO_2139 0x00840000 // LM3S2139 +#define SYSCTL_DID1_PRTNO_2276 0x00390000 // LM3S2276 +#define SYSCTL_DID1_PRTNO_2410 0x00A20000 // LM3S2410 +#define SYSCTL_DID1_PRTNO_2412 0x00590000 // LM3S2412 +#define SYSCTL_DID1_PRTNO_2432 0x00560000 // LM3S2432 +#define SYSCTL_DID1_PRTNO_2533 0x005A0000 // LM3S2533 +#define SYSCTL_DID1_PRTNO_2601 0x00E10000 // LM3S2601 +#define SYSCTL_DID1_PRTNO_2608 0x00E00000 // LM3S2608 +#define SYSCTL_DID1_PRTNO_2616 0x00330000 // LM3S2616 +#define SYSCTL_DID1_PRTNO_2620 0x00570000 // LM3S2620 +#define SYSCTL_DID1_PRTNO_2637 0x00850000 // LM3S2637 +#define SYSCTL_DID1_PRTNO_2651 0x00530000 // LM3S2651 +#define SYSCTL_DID1_PRTNO_2671 0x00800000 // LM3S2671 +#define SYSCTL_DID1_PRTNO_2678 0x00500000 // LM3S2678 +#define SYSCTL_DID1_PRTNO_2730 0x00A40000 // LM3S2730 +#define SYSCTL_DID1_PRTNO_2739 0x00520000 // LM3S2739 +#define SYSCTL_DID1_PRTNO_2776 0x003A0000 // LM3S2776 +#define SYSCTL_DID1_PRTNO_2793 0x006D0000 // LM3S2793 +#define SYSCTL_DID1_PRTNO_2911 0x00E30000 // LM3S2911 +#define SYSCTL_DID1_PRTNO_2918 0x00E20000 // LM3S2918 +#define SYSCTL_DID1_PRTNO_2939 0x00540000 // LM3S2939 +#define SYSCTL_DID1_PRTNO_2948 0x008F0000 // LM3S2948 +#define SYSCTL_DID1_PRTNO_2950 0x00580000 // LM3S2950 +#define SYSCTL_DID1_PRTNO_2965 0x00550000 // LM3S2965 +#define SYSCTL_DID1_PRTNO_2B93 0x006C0000 // LM3S2B93 +#define SYSCTL_DID1_PRTNO_3634 0x00080000 // LM3S3634 +#define SYSCTL_DID1_PRTNO_3651 0x00430000 // LM3S3651 +#define SYSCTL_DID1_PRTNO_3739 0x00440000 // LM3S3739 +#define SYSCTL_DID1_PRTNO_3748 0x00490000 // LM3S3748 +#define SYSCTL_DID1_PRTNO_3749 0x00450000 // LM3S3749 +#define SYSCTL_DID1_PRTNO_3826 0x00420000 // LM3S3826 +#define SYSCTL_DID1_PRTNO_3J26 0x00410000 // LM3S3J26 +#define SYSCTL_DID1_PRTNO_3N26 0x00400000 // LM3S3N26 +#define SYSCTL_DID1_PRTNO_3W26 0x003F0000 // LM3S3W26 +#define SYSCTL_DID1_PRTNO_3Z26 0x003E0000 // LM3S3Z26 +#define SYSCTL_DID1_PRTNO_5632 0x00810000 // LM3S5632 +#define SYSCTL_DID1_PRTNO_5651 0x000C0000 // LM3S5651 +#define SYSCTL_DID1_PRTNO_5652 0x008A0000 // LM3S5652 +#define SYSCTL_DID1_PRTNO_5656 0x004D0000 // LM3S5656 +#define SYSCTL_DID1_PRTNO_5662 0x00910000 // LM3S5662 +#define SYSCTL_DID1_PRTNO_5732 0x00960000 // LM3S5732 +#define SYSCTL_DID1_PRTNO_5737 0x00970000 // LM3S5737 +#define SYSCTL_DID1_PRTNO_5739 0x00A00000 // LM3S5739 +#define SYSCTL_DID1_PRTNO_5747 0x00990000 // LM3S5747 +#define SYSCTL_DID1_PRTNO_5749 0x00A70000 // LM3S5749 +#define SYSCTL_DID1_PRTNO_5752 0x009A0000 // LM3S5752 +#define SYSCTL_DID1_PRTNO_5762 0x009C0000 // LM3S5762 +#define SYSCTL_DID1_PRTNO_5791 0x00690000 // LM3S5791 +#define SYSCTL_DID1_PRTNO_5951 0x000B0000 // LM3S5951 +#define SYSCTL_DID1_PRTNO_5956 0x004E0000 // LM3S5956 +#define SYSCTL_DID1_PRTNO_5B91 0x00680000 // LM3S5B91 +#define SYSCTL_DID1_PRTNO_5K31 0x00090000 // LM3S5K31 +#define SYSCTL_DID1_PRTNO_5K36 0x004A0000 // LM3S5K36 +#define SYSCTL_DID1_PRTNO_5P31 0x000A0000 // LM3S5P31 +#define SYSCTL_DID1_PRTNO_5P36 0x00480000 // LM3S5P36 +#define SYSCTL_DID1_PRTNO_5P51 0x000D0000 // LM3S5P51 +#define SYSCTL_DID1_PRTNO_5P56 0x004C0000 // LM3S5P56 +#define SYSCTL_DID1_PRTNO_5R31 0x00070000 // LM3S5R31 +#define SYSCTL_DID1_PRTNO_5R36 0x004B0000 // LM3S5R36 +#define SYSCTL_DID1_PRTNO_5T36 0x00470000 // LM3S5T36 +#define SYSCTL_DID1_PRTNO_5Y36 0x00460000 // LM3S5Y36 +#define SYSCTL_DID1_PRTNO_6100 0x00A10000 // LM3S6100 +#define SYSCTL_DID1_PRTNO_6110 0x00740000 // LM3S6110 +#define SYSCTL_DID1_PRTNO_6420 0x00A50000 // LM3S6420 +#define SYSCTL_DID1_PRTNO_6422 0x00820000 // LM3S6422 +#define SYSCTL_DID1_PRTNO_6432 0x00750000 // LM3S6432 +#define SYSCTL_DID1_PRTNO_6537 0x00760000 // LM3S6537 +#define SYSCTL_DID1_PRTNO_6610 0x00710000 // LM3S6610 +#define SYSCTL_DID1_PRTNO_6611 0x00E70000 // LM3S6611 +#define SYSCTL_DID1_PRTNO_6618 0x00E60000 // LM3S6618 +#define SYSCTL_DID1_PRTNO_6633 0x00830000 // LM3S6633 +#define SYSCTL_DID1_PRTNO_6637 0x008B0000 // LM3S6637 +#define SYSCTL_DID1_PRTNO_6730 0x00A30000 // LM3S6730 +#define SYSCTL_DID1_PRTNO_6753 0x00770000 // LM3S6753 +#define SYSCTL_DID1_PRTNO_6911 0x00E90000 // LM3S6911 +#define SYSCTL_DID1_PRTNO_6918 0x00E80000 // LM3S6918 +#define SYSCTL_DID1_PRTNO_6938 0x00890000 // LM3S6938 +#define SYSCTL_DID1_PRTNO_6950 0x00720000 // LM3S6950 +#define SYSCTL_DID1_PRTNO_6952 0x00780000 // LM3S6952 +#define SYSCTL_DID1_PRTNO_6965 0x00730000 // LM3S6965 +#define SYSCTL_DID1_PRTNO_8530 0x00640000 // LM3S8530 +#define SYSCTL_DID1_PRTNO_8538 0x008E0000 // LM3S8538 +#define SYSCTL_DID1_PRTNO_8630 0x00610000 // LM3S8630 +#define SYSCTL_DID1_PRTNO_8730 0x00630000 // LM3S8730 +#define SYSCTL_DID1_PRTNO_8733 0x008D0000 // LM3S8733 +#define SYSCTL_DID1_PRTNO_8738 0x00860000 // LM3S8738 +#define SYSCTL_DID1_PRTNO_8930 0x00650000 // LM3S8930 +#define SYSCTL_DID1_PRTNO_8933 0x008C0000 // LM3S8933 +#define SYSCTL_DID1_PRTNO_8938 0x00880000 // LM3S8938 +#define SYSCTL_DID1_PRTNO_8962 0x00A60000 // LM3S8962 +#define SYSCTL_DID1_PRTNO_8970 0x00620000 // LM3S8970 +#define SYSCTL_DID1_PRTNO_8971 0x00D70000 // LM3S8971 +#define SYSCTL_DID1_PRTNO_9790 0x00670000 // LM3S9790 +#define SYSCTL_DID1_PRTNO_9792 0x006B0000 // LM3S9792 +#define SYSCTL_DID1_PRTNO_9997 0x00200000 // LM3S9997 +#define SYSCTL_DID1_PRTNO_9B90 0x00660000 // LM3S9B90 +#define SYSCTL_DID1_PRTNO_9B92 0x006A0000 // LM3S9B92 +#define SYSCTL_DID1_PRTNO_9B95 0x006E0000 // LM3S9B95 +#define SYSCTL_DID1_PRTNO_9B96 0x006F0000 // LM3S9B96 +#define SYSCTL_DID1_PRTNO_9L97 0x00180000 // LM3S9L97 +#define SYSCTL_DID1_PINCNT_M 0x0000E000 // Package Pin Count +#define SYSCTL_DID1_PINCNT_28 0x00000000 // 28 pin package +#define SYSCTL_DID1_PINCNT_48 0x00002000 // 48-pin package +#define SYSCTL_DID1_PINCNT_100 0x00004000 // 100-pin package +#define SYSCTL_DID1_PINCNT_64 0x00006000 // 64-pin package +#define SYSCTL_DID1_TEMP_M 0x000000E0 // Temperature Range +#define SYSCTL_DID1_TEMP_C 0x00000000 // Commercial temperature range (0C + // to 70C) +#define SYSCTL_DID1_TEMP_I 0x00000020 // Industrial temperature range + // (-40C to 85C) +#define SYSCTL_DID1_TEMP_E 0x00000040 // Extended temperature range (-40C + // to 105C) +#define SYSCTL_DID1_PKG_M 0x00000018 // Package Type +#define SYSCTL_DID1_PKG_SOIC 0x00000000 // SOIC package +#define SYSCTL_DID1_PKG_QFP 0x00000008 // LQFP package +#define SYSCTL_DID1_PKG_BGA 0x00000010 // BGA package +#define SYSCTL_DID1_PKG_QFN 0x00000018 // QFN package +#define SYSCTL_DID1_ROHS 0x00000004 // RoHS-Compliance +#define SYSCTL_DID1_QUAL_M 0x00000003 // Qualification Status +#define SYSCTL_DID1_QUAL_ES 0x00000000 // Engineering Sample (unqualified) +#define SYSCTL_DID1_QUAL_PP 0x00000001 // Pilot Production (unqualified) +#define SYSCTL_DID1_QUAL_FQ 0x00000002 // Fully Qualified +#define SYSCTL_DID1_PRTNO_S 16 // Part number shift + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC0 register. +// +//***************************************************************************** +#define SYSCTL_DC0_SRAMSZ_M 0xFFFF0000 // SRAM Size +#define SYSCTL_DC0_SRAMSZ_2KB 0x00070000 // 2 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_4KB 0x000F0000 // 4 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_6KB 0x00170000 // 6 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_8KB 0x001F0000 // 8 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_12KB 0x002F0000 // 12 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_16KB 0x003F0000 // 16 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_20KB 0x004F0000 // 20 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_24KB 0x005F0000 // 24 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_32KB 0x007F0000 // 32 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_64KB 0x00FF0000 // 64 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_96KB 0x017F0000 // 96 KB of SRAM +#define SYSCTL_DC0_FLASHSZ_M 0x0000FFFF // Flash Size +#define SYSCTL_DC0_FLASHSZ_8KB 0x00000003 // 8 KB of Flash +#define SYSCTL_DC0_FLASHSZ_16KB 0x00000007 // 16 KB of Flash +#define SYSCTL_DC0_FLASHSZ_32KB 0x0000000F // 32 KB of Flash +#define SYSCTL_DC0_FLASHSZ_64KB 0x0000001F // 64 KB of Flash +#define SYSCTL_DC0_FLASHSZ_96KB 0x0000002F // 96 KB of Flash +#define SYSCTL_DC0_FLASHSZ_128K 0x0000003F // 128 KB of Flash +#define SYSCTL_DC0_FLASHSZ_256K 0x0000007F // 256 KB of Flash +#define SYSCTL_DC0_SRAMSZ_S 16 // SRAM size shift +#define SYSCTL_DC0_FLASHSZ_S 0 // Flash size shift + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC1 register. +// +//***************************************************************************** +#define SYSCTL_DC1_WDT1 0x10000000 // Watchdog Timer1 Present +#define SYSCTL_DC1_CAN2 0x04000000 // CAN Module 2 Present +#define SYSCTL_DC1_CAN1 0x02000000 // CAN Module 1 Present +#define SYSCTL_DC1_CAN0 0x01000000 // CAN Module 0 Present +#define SYSCTL_DC1_PWM 0x00100000 // PWM Module Present +#define SYSCTL_DC1_ADC1 0x00020000 // ADC Module 1 Present +#define SYSCTL_DC1_ADC0 0x00010000 // ADC Module 0 Present +#define SYSCTL_DC1_MINSYSDIV_M 0x0000F000 // System Clock Divider +#define SYSCTL_DC1_MINSYSDIV_100 \ + 0x00001000 // Divide VCO (400MHZ) by 5 minimum +#define SYSCTL_DC1_MINSYSDIV_66 0x00002000 // Divide VCO (400MHZ) by 2*2 + 2 = + // 6 minimum +#define SYSCTL_DC1_MINSYSDIV_50 0x00003000 // Specifies a 50-MHz CPU clock + // with a PLL divider of 4 +#define SYSCTL_DC1_MINSYSDIV_25 0x00007000 // Specifies a 25-MHz clock with a + // PLL divider of 8 +#define SYSCTL_DC1_MINSYSDIV_20 0x00009000 // Specifies a 20-MHz clock with a + // PLL divider of 10 +#define SYSCTL_DC1_ADCSPD_M 0x00000F00 // Max ADC Speed +#define SYSCTL_DC1_ADCSPD_125K 0x00000000 // 125Ksps ADC +#define SYSCTL_DC1_ADCSPD_250K 0x00000100 // 250K samples/second +#define SYSCTL_DC1_ADCSPD_500K 0x00000200 // 500K samples/second +#define SYSCTL_DC1_ADCSPD_1M 0x00000300 // 1M samples/second +#define SYSCTL_DC1_ADC1SPD_M 0x00000C00 // Max ADC1 Speed +#define SYSCTL_DC1_ADC1SPD_1M 0x00000C00 // 1M samples/second +#define SYSCTL_DC1_ADC0SPD_M 0x00000300 // Max ADC0 Speed +#define SYSCTL_DC1_ADC0SPD_1M 0x00000300 // 1M samples/second +#define SYSCTL_DC1_MPU 0x00000080 // MPU Present +#define SYSCTL_DC1_HIB 0x00000040 // Hibernation Module Present +#define SYSCTL_DC1_TEMP 0x00000020 // Temp Sensor Present +#define SYSCTL_DC1_PLL 0x00000010 // PLL Present +#define SYSCTL_DC1_WDT0 0x00000008 // Watchdog Timer 0 Present +#define SYSCTL_DC1_SWO 0x00000004 // SWO Trace Port Present +#define SYSCTL_DC1_SWD 0x00000002 // SWD Present +#define SYSCTL_DC1_JTAG 0x00000001 // JTAG Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC2 register. +// +//***************************************************************************** +#define SYSCTL_DC2_EPI0 0x40000000 // EPI Module 0 Present +#define SYSCTL_DC2_I2S0 0x10000000 // I2S Module 0 Present +#define SYSCTL_DC2_COMP2 0x04000000 // Analog Comparator 2 Present +#define SYSCTL_DC2_COMP1 0x02000000 // Analog Comparator 1 Present +#define SYSCTL_DC2_COMP0 0x01000000 // Analog Comparator 0 Present +#define SYSCTL_DC2_TIMER3 0x00080000 // Timer Module 3 Present +#define SYSCTL_DC2_TIMER2 0x00040000 // Timer Module 2 Present +#define SYSCTL_DC2_TIMER1 0x00020000 // Timer Module 1 Present +#define SYSCTL_DC2_TIMER0 0x00010000 // Timer Module 0 Present +#define SYSCTL_DC2_I2C1 0x00004000 // I2C Module 1 Present +#define SYSCTL_DC2_I2C0 0x00001000 // I2C Module 0 Present +#define SYSCTL_DC2_QEI1 0x00000200 // QEI Module 1 Present +#define SYSCTL_DC2_QEI0 0x00000100 // QEI Module 0 Present +#define SYSCTL_DC2_SSI1 0x00000020 // SSI Module 1 Present +#define SYSCTL_DC2_SSI0 0x00000010 // SSI Module 0 Present +#define SYSCTL_DC2_UART2 0x00000004 // UART Module 2 Present +#define SYSCTL_DC2_UART1 0x00000002 // UART Module 1 Present +#define SYSCTL_DC2_UART0 0x00000001 // UART Module 0 Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC3 register. +// +//***************************************************************************** +#define SYSCTL_DC3_32KHZ 0x80000000 // 32KHz Input Clock Available +#define SYSCTL_DC3_CCP5 0x20000000 // CCP5 Pin Present +#define SYSCTL_DC3_CCP4 0x10000000 // CCP4 Pin Present +#define SYSCTL_DC3_CCP3 0x08000000 // CCP3 Pin Present +#define SYSCTL_DC3_CCP2 0x04000000 // CCP2 Pin Present +#define SYSCTL_DC3_CCP1 0x02000000 // CCP1 Pin Present +#define SYSCTL_DC3_CCP0 0x01000000 // CCP0 Pin Present +#define SYSCTL_DC3_ADC0AIN7 0x00800000 // ADC Module 0 AIN7 Pin Present +#define SYSCTL_DC3_ADC0AIN6 0x00400000 // ADC Module 0 AIN6 Pin Present +#define SYSCTL_DC3_ADC0AIN5 0x00200000 // ADC Module 0 AIN5 Pin Present +#define SYSCTL_DC3_ADC0AIN4 0x00100000 // ADC Module 0 AIN4 Pin Present +#define SYSCTL_DC3_ADC0AIN3 0x00080000 // ADC Module 0 AIN3 Pin Present +#define SYSCTL_DC3_ADC0AIN2 0x00040000 // ADC Module 0 AIN2 Pin Present +#define SYSCTL_DC3_ADC0AIN1 0x00020000 // ADC Module 0 AIN1 Pin Present +#define SYSCTL_DC3_ADC0AIN0 0x00010000 // ADC Module 0 AIN0 Pin Present +#define SYSCTL_DC3_PWMFAULT 0x00008000 // PWM Fault Pin Present +#define SYSCTL_DC3_C2O 0x00004000 // C2o Pin Present +#define SYSCTL_DC3_C2PLUS 0x00002000 // C2+ Pin Present +#define SYSCTL_DC3_C2MINUS 0x00001000 // C2- Pin Present +#define SYSCTL_DC3_C1O 0x00000800 // C1o Pin Present +#define SYSCTL_DC3_C1PLUS 0x00000400 // C1+ Pin Present +#define SYSCTL_DC3_C1MINUS 0x00000200 // C1- Pin Present +#define SYSCTL_DC3_C0O 0x00000100 // C0o Pin Present +#define SYSCTL_DC3_C0PLUS 0x00000080 // C0+ Pin Present +#define SYSCTL_DC3_C0MINUS 0x00000040 // C0- Pin Present +#define SYSCTL_DC3_PWM5 0x00000020 // PWM5 Pin Present +#define SYSCTL_DC3_PWM4 0x00000010 // PWM4 Pin Present +#define SYSCTL_DC3_PWM3 0x00000008 // PWM3 Pin Present +#define SYSCTL_DC3_PWM2 0x00000004 // PWM2 Pin Present +#define SYSCTL_DC3_PWM1 0x00000002 // PWM1 Pin Present +#define SYSCTL_DC3_PWM0 0x00000001 // PWM0 Pin Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC4 register. +// +//***************************************************************************** +#define SYSCTL_DC4_ETH 0x50000000 // Ethernet present +#define SYSCTL_DC4_EPHY0 0x40000000 // Ethernet PHY Layer 0 Present +#define SYSCTL_DC4_EMAC0 0x10000000 // Ethernet MAC Layer 0 Present +#define SYSCTL_DC4_E1588 0x01000000 // 1588 Capable +#define SYSCTL_DC4_PICAL 0x00040000 // PIOSC Calibrate +#define SYSCTL_DC4_CCP7 0x00008000 // CCP7 Pin Present +#define SYSCTL_DC4_CCP6 0x00004000 // CCP6 Pin Present +#define SYSCTL_DC4_UDMA 0x00002000 // Micro-DMA Module Present +#define SYSCTL_DC4_ROM 0x00001000 // Internal Code ROM Present +#define SYSCTL_DC4_GPIOJ 0x00000100 // GPIO Port J Present +#define SYSCTL_DC4_GPIOH 0x00000080 // GPIO Port H Present +#define SYSCTL_DC4_GPIOG 0x00000040 // GPIO Port G Present +#define SYSCTL_DC4_GPIOF 0x00000020 // GPIO Port F Present +#define SYSCTL_DC4_GPIOE 0x00000010 // GPIO Port E Present +#define SYSCTL_DC4_GPIOD 0x00000008 // GPIO Port D Present +#define SYSCTL_DC4_GPIOC 0x00000004 // GPIO Port C Present +#define SYSCTL_DC4_GPIOB 0x00000002 // GPIO Port B Present +#define SYSCTL_DC4_GPIOA 0x00000001 // GPIO Port A Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC5 register. +// +//***************************************************************************** +#define SYSCTL_DC5_PWMFAULT3 0x08000000 // PWM Fault 3 Pin Present +#define SYSCTL_DC5_PWMFAULT2 0x04000000 // PWM Fault 2 Pin Present +#define SYSCTL_DC5_PWMFAULT1 0x02000000 // PWM Fault 1 Pin Present +#define SYSCTL_DC5_PWMFAULT0 0x01000000 // PWM Fault 0 Pin Present +#define SYSCTL_DC5_PWMEFLT 0x00200000 // PWM Extended Fault Active +#define SYSCTL_DC5_PWMESYNC 0x00100000 // PWM Extended SYNC Active +#define SYSCTL_DC5_PWM7 0x00000080 // PWM7 Pin Present +#define SYSCTL_DC5_PWM6 0x00000040 // PWM6 Pin Present +#define SYSCTL_DC5_PWM5 0x00000020 // PWM5 Pin Present +#define SYSCTL_DC5_PWM4 0x00000010 // PWM4 Pin Present +#define SYSCTL_DC5_PWM3 0x00000008 // PWM3 Pin Present +#define SYSCTL_DC5_PWM2 0x00000004 // PWM2 Pin Present +#define SYSCTL_DC5_PWM1 0x00000002 // PWM1 Pin Present +#define SYSCTL_DC5_PWM0 0x00000001 // PWM0 Pin Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC6 register. +// +//***************************************************************************** +#define SYSCTL_DC6_USB0PHY 0x00000010 // USB Module 0 PHY Present +#define SYSCTL_DC6_USB0_M 0x00000003 // USB Module 0 Present +#define SYSCTL_DC6_USB0_DEV 0x00000001 // USB0 is Device Only +#define SYSCTL_DC6_USB0_HOSTDEV 0x00000002 // USB is Device or Host +#define SYSCTL_DC6_USB0_OTG 0x00000003 // USB0 is OTG + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC7 register. +// +//***************************************************************************** +#define SYSCTL_DC7_SW 0x40000000 // Software transfer on uDMA Ch30 +#define SYSCTL_DC7_DMACH30 0x40000000 // SW +#define SYSCTL_DC7_DMACH29 0x20000000 // I2S0_TX / CAN1_TX +#define SYSCTL_DC7_DMACH28 0x10000000 // I2S0_RX / CAN1_RX +#define SYSCTL_DC7_DMACH27 0x08000000 // CAN1_TX / ADC1_SS3 +#define SYSCTL_DC7_DMACH26 0x04000000 // CAN1_RX / ADC1_SS2 +#define SYSCTL_DC7_DMACH25 0x02000000 // SSI1_TX / ADC1_SS1 +#define SYSCTL_DC7_SSI1_TX 0x02000000 // SSI1 TX on uDMA Ch25 +#define SYSCTL_DC7_SSI1_RX 0x01000000 // SSI1 RX on uDMA Ch24 +#define SYSCTL_DC7_DMACH24 0x01000000 // SSI1_RX / ADC1_SS0 +#define SYSCTL_DC7_UART1_TX 0x00800000 // UART1 TX on uDMA Ch23 +#define SYSCTL_DC7_DMACH23 0x00800000 // UART1_TX / CAN2_TX +#define SYSCTL_DC7_DMACH22 0x00400000 // UART1_RX / CAN2_RX +#define SYSCTL_DC7_UART1_RX 0x00400000 // UART1 RX on uDMA Ch22 +#define SYSCTL_DC7_DMACH21 0x00200000 // Timer1B / EPI0_WFIFO +#define SYSCTL_DC7_DMACH20 0x00100000 // Timer1A / EPI0_NBRFIFO +#define SYSCTL_DC7_DMACH19 0x00080000 // Timer0B / Timer1B +#define SYSCTL_DC7_DMACH18 0x00040000 // Timer0A / Timer1A +#define SYSCTL_DC7_DMACH17 0x00020000 // ADC0_SS3 +#define SYSCTL_DC7_DMACH16 0x00010000 // ADC0_SS2 +#define SYSCTL_DC7_DMACH15 0x00008000 // ADC0_SS1 / Timer2B +#define SYSCTL_DC7_DMACH14 0x00004000 // ADC0_SS0 / Timer2A +#define SYSCTL_DC7_DMACH13 0x00002000 // CAN0_TX / UART2_TX +#define SYSCTL_DC7_DMACH12 0x00001000 // CAN0_RX / UART2_RX +#define SYSCTL_DC7_SSI0_TX 0x00000800 // SSI0 TX on uDMA Ch11 +#define SYSCTL_DC7_DMACH11 0x00000800 // SSI0_TX / SSI1_TX +#define SYSCTL_DC7_SSI0_RX 0x00000400 // SSI0 RX on uDMA Ch10 +#define SYSCTL_DC7_DMACH10 0x00000400 // SSI0_RX / SSI1_RX +#define SYSCTL_DC7_UART0_TX 0x00000200 // UART0 TX on uDMA Ch9 +#define SYSCTL_DC7_DMACH9 0x00000200 // UART0_TX / UART1_TX +#define SYSCTL_DC7_DMACH8 0x00000100 // UART0_RX / UART1_RX +#define SYSCTL_DC7_UART0_RX 0x00000100 // UART0 RX on uDMA Ch8 +#define SYSCTL_DC7_DMACH7 0x00000080 // ETH_TX / Timer2B +#define SYSCTL_DC7_DMACH6 0x00000040 // ETH_RX / Timer2A +#define SYSCTL_DC7_DMACH5 0x00000020 // USB_EP3_TX / Timer2B +#define SYSCTL_DC7_USB_EP3_TX 0x00000020 // USB EP3 TX on uDMA Ch5 +#define SYSCTL_DC7_USB_EP3_RX 0x00000010 // USB EP3 RX on uDMA Ch4 +#define SYSCTL_DC7_DMACH4 0x00000010 // USB_EP3_RX / Timer2A +#define SYSCTL_DC7_USB_EP2_TX 0x00000008 // USB EP2 TX on uDMA Ch3 +#define SYSCTL_DC7_DMACH3 0x00000008 // USB_EP2_TX / Timer3B +#define SYSCTL_DC7_USB_EP2_RX 0x00000004 // USB EP2 RX on uDMA Ch2 +#define SYSCTL_DC7_DMACH2 0x00000004 // USB_EP2_RX / Timer3A +#define SYSCTL_DC7_USB_EP1_TX 0x00000002 // USB EP1 TX on uDMA Ch1 +#define SYSCTL_DC7_DMACH1 0x00000002 // USB_EP1_TX / UART2_TX +#define SYSCTL_DC7_DMACH0 0x00000001 // USB_EP1_RX / UART2_RX +#define SYSCTL_DC7_USB_EP1_RX 0x00000001 // USB EP1 RX on uDMA Ch0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC8 register. +// +//***************************************************************************** +#define SYSCTL_DC8_ADC1AIN15 0x80000000 // ADC Module 1 AIN15 Pin Present +#define SYSCTL_DC8_ADC1AIN14 0x40000000 // ADC Module 1 AIN14 Pin Present +#define SYSCTL_DC8_ADC1AIN13 0x20000000 // ADC Module 1 AIN13 Pin Present +#define SYSCTL_DC8_ADC1AIN12 0x10000000 // ADC Module 1 AIN12 Pin Present +#define SYSCTL_DC8_ADC1AIN11 0x08000000 // ADC Module 1 AIN11 Pin Present +#define SYSCTL_DC8_ADC1AIN10 0x04000000 // ADC Module 1 AIN10 Pin Present +#define SYSCTL_DC8_ADC1AIN9 0x02000000 // ADC Module 1 AIN9 Pin Present +#define SYSCTL_DC8_ADC1AIN8 0x01000000 // ADC Module 1 AIN8 Pin Present +#define SYSCTL_DC8_ADC1AIN7 0x00800000 // ADC Module 1 AIN7 Pin Present +#define SYSCTL_DC8_ADC1AIN6 0x00400000 // ADC Module 1 AIN6 Pin Present +#define SYSCTL_DC8_ADC1AIN5 0x00200000 // ADC Module 1 AIN5 Pin Present +#define SYSCTL_DC8_ADC1AIN4 0x00100000 // ADC Module 1 AIN4 Pin Present +#define SYSCTL_DC8_ADC1AIN3 0x00080000 // ADC Module 1 AIN3 Pin Present +#define SYSCTL_DC8_ADC1AIN2 0x00040000 // ADC Module 1 AIN2 Pin Present +#define SYSCTL_DC8_ADC1AIN1 0x00020000 // ADC Module 1 AIN1 Pin Present +#define SYSCTL_DC8_ADC1AIN0 0x00010000 // ADC Module 1 AIN0 Pin Present +#define SYSCTL_DC8_ADC0AIN15 0x00008000 // ADC Module 0 AIN15 Pin Present +#define SYSCTL_DC8_ADC0AIN14 0x00004000 // ADC Module 0 AIN14 Pin Present +#define SYSCTL_DC8_ADC0AIN13 0x00002000 // ADC Module 0 AIN13 Pin Present +#define SYSCTL_DC8_ADC0AIN12 0x00001000 // ADC Module 0 AIN12 Pin Present +#define SYSCTL_DC8_ADC0AIN11 0x00000800 // ADC Module 0 AIN11 Pin Present +#define SYSCTL_DC8_ADC0AIN10 0x00000400 // ADC Module 0 AIN10 Pin Present +#define SYSCTL_DC8_ADC0AIN9 0x00000200 // ADC Module 0 AIN9 Pin Present +#define SYSCTL_DC8_ADC0AIN8 0x00000100 // ADC Module 0 AIN8 Pin Present +#define SYSCTL_DC8_ADC0AIN7 0x00000080 // ADC Module 0 AIN7 Pin Present +#define SYSCTL_DC8_ADC0AIN6 0x00000040 // ADC Module 0 AIN6 Pin Present +#define SYSCTL_DC8_ADC0AIN5 0x00000020 // ADC Module 0 AIN5 Pin Present +#define SYSCTL_DC8_ADC0AIN4 0x00000010 // ADC Module 0 AIN4 Pin Present +#define SYSCTL_DC8_ADC0AIN3 0x00000008 // ADC Module 0 AIN3 Pin Present +#define SYSCTL_DC8_ADC0AIN2 0x00000004 // ADC Module 0 AIN2 Pin Present +#define SYSCTL_DC8_ADC0AIN1 0x00000002 // ADC Module 0 AIN1 Pin Present +#define SYSCTL_DC8_ADC0AIN0 0x00000001 // ADC Module 0 AIN0 Pin Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_PBORCTL register. +// +//***************************************************************************** +#define SYSCTL_PBORCTL_BORTIM_M 0x0000FFFC // BOR Time Delay +#define SYSCTL_PBORCTL_BORIOR 0x00000002 // BOR Interrupt or Reset +#define SYSCTL_PBORCTL_BORWT 0x00000001 // BOR Wait and Check for Noise +#define SYSCTL_PBORCTL_BORTIM_S 2 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_LDOPCTL register. +// +//***************************************************************************** +#define SYSCTL_LDOPCTL_M 0x0000003F // LDO Output Voltage +#define SYSCTL_LDOPCTL_2_50V 0x00000000 // 2.50 +#define SYSCTL_LDOPCTL_2_45V 0x00000001 // 2.45 +#define SYSCTL_LDOPCTL_2_40V 0x00000002 // 2.40 +#define SYSCTL_LDOPCTL_2_35V 0x00000003 // 2.35 +#define SYSCTL_LDOPCTL_2_30V 0x00000004 // 2.30 +#define SYSCTL_LDOPCTL_2_25V 0x00000005 // 2.25 +#define SYSCTL_LDOPCTL_2_75V 0x0000001B // 2.75 +#define SYSCTL_LDOPCTL_2_70V 0x0000001C // 2.70 +#define SYSCTL_LDOPCTL_2_65V 0x0000001D // 2.65 +#define SYSCTL_LDOPCTL_2_60V 0x0000001E // 2.60 +#define SYSCTL_LDOPCTL_2_55V 0x0000001F // 2.55 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SRCR0 register. +// +//***************************************************************************** +#define SYSCTL_SRCR0_WDT1 0x10000000 // WDT1 Reset Control +#define SYSCTL_SRCR0_CAN2 0x04000000 // CAN2 Reset Control +#define SYSCTL_SRCR0_CAN1 0x02000000 // CAN1 Reset Control +#define SYSCTL_SRCR0_CAN0 0x01000000 // CAN0 Reset Control +#define SYSCTL_SRCR0_PWM 0x00100000 // PWM Reset Control +#define SYSCTL_SRCR0_ADC1 0x00020000 // ADC1 Reset Control +#define SYSCTL_SRCR0_ADC0 0x00010000 // ADC0 Reset Control +#define SYSCTL_SRCR0_HIB 0x00000040 // HIB Reset Control +#define SYSCTL_SRCR0_WDT0 0x00000008 // WDT0 Reset Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SRCR1 register. +// +//***************************************************************************** +#define SYSCTL_SRCR1_EPI0 0x40000000 // EPI0 Reset Control +#define SYSCTL_SRCR1_I2S0 0x10000000 // I2S0 Reset Control +#define SYSCTL_SRCR1_COMP2 0x04000000 // Analog Comp 2 Reset Control +#define SYSCTL_SRCR1_COMP1 0x02000000 // Analog Comp 1 Reset Control +#define SYSCTL_SRCR1_COMP0 0x01000000 // Analog Comp 0 Reset Control +#define SYSCTL_SRCR1_TIMER3 0x00080000 // Timer 3 Reset Control +#define SYSCTL_SRCR1_TIMER2 0x00040000 // Timer 2 Reset Control +#define SYSCTL_SRCR1_TIMER1 0x00020000 // Timer 1 Reset Control +#define SYSCTL_SRCR1_TIMER0 0x00010000 // Timer 0 Reset Control +#define SYSCTL_SRCR1_I2C1 0x00004000 // I2C1 Reset Control +#define SYSCTL_SRCR1_I2C0 0x00001000 // I2C0 Reset Control +#define SYSCTL_SRCR1_QEI1 0x00000200 // QEI1 Reset Control +#define SYSCTL_SRCR1_QEI0 0x00000100 // QEI0 Reset Control +#define SYSCTL_SRCR1_SSI1 0x00000020 // SSI1 Reset Control +#define SYSCTL_SRCR1_SSI0 0x00000010 // SSI0 Reset Control +#define SYSCTL_SRCR1_UART2 0x00000004 // UART2 Reset Control +#define SYSCTL_SRCR1_UART1 0x00000002 // UART1 Reset Control +#define SYSCTL_SRCR1_UART0 0x00000001 // UART0 Reset Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SRCR2 register. +// +//***************************************************************************** +#define SYSCTL_SRCR2_EPHY0 0x40000000 // PHY0 Reset Control +#define SYSCTL_SRCR2_EMAC0 0x10000000 // MAC0 Reset Control +#define SYSCTL_SRCR2_USB0 0x00010000 // USB0 Reset Control +#define SYSCTL_SRCR2_UDMA 0x00002000 // Micro-DMA Reset Control +#define SYSCTL_SRCR2_GPIOJ 0x00000100 // Port J Reset Control +#define SYSCTL_SRCR2_GPIOH 0x00000080 // Port H Reset Control +#define SYSCTL_SRCR2_GPIOG 0x00000040 // Port G Reset Control +#define SYSCTL_SRCR2_GPIOF 0x00000020 // Port F Reset Control +#define SYSCTL_SRCR2_GPIOE 0x00000010 // Port E Reset Control +#define SYSCTL_SRCR2_GPIOD 0x00000008 // Port D Reset Control +#define SYSCTL_SRCR2_GPIOC 0x00000004 // Port C Reset Control +#define SYSCTL_SRCR2_GPIOB 0x00000002 // Port B Reset Control +#define SYSCTL_SRCR2_GPIOA 0x00000001 // Port A Reset Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RIS register. +// +//***************************************************************************** +#define SYSCTL_RIS_MOSCPUPRIS 0x00000100 // MOSC Power Up Raw Interrupt + // Status +#define SYSCTL_RIS_USBPLLLRIS 0x00000080 // USB PLL Lock Raw Interrupt + // Status +#define SYSCTL_RIS_PLLLRIS 0x00000040 // PLL Lock Raw Interrupt Status +#define SYSCTL_RIS_CLRIS 0x00000020 // Current Limit Raw Interrupt + // Status +#define SYSCTL_RIS_IOFRIS 0x00000010 // Internal Oscillator Fault Raw + // Interrupt Status +#define SYSCTL_RIS_MOFRIS 0x00000008 // Main Oscillator Fault Raw + // Interrupt Status +#define SYSCTL_RIS_LDORIS 0x00000004 // LDO Power Unregulated Raw + // Interrupt Status +#define SYSCTL_RIS_BORRIS 0x00000002 // Brown-Out Reset Raw Interrupt + // Status +#define SYSCTL_RIS_PLLFRIS 0x00000001 // PLL Fault Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_IMC register. +// +//***************************************************************************** +#define SYSCTL_IMC_MOSCPUPIM 0x00000100 // MOSC Power Up Interrupt Mask +#define SYSCTL_IMC_USBPLLLIM 0x00000080 // USB PLL Lock Interrupt Mask +#define SYSCTL_IMC_PLLLIM 0x00000040 // PLL Lock Interrupt Mask +#define SYSCTL_IMC_CLIM 0x00000020 // Current Limit Interrupt Mask +#define SYSCTL_IMC_IOFIM 0x00000010 // Internal Oscillator Fault + // Interrupt Mask +#define SYSCTL_IMC_MOFIM 0x00000008 // Main Oscillator Fault Interrupt + // Mask +#define SYSCTL_IMC_LDOIM 0x00000004 // LDO Power Unregulated Interrupt + // Mask +#define SYSCTL_IMC_BORIM 0x00000002 // Brown-Out Reset Interrupt Mask +#define SYSCTL_IMC_PLLFIM 0x00000001 // PLL Fault Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_MISC register. +// +//***************************************************************************** +#define SYSCTL_MISC_MOSCPUPMIS 0x00000100 // MOSC Power Up Masked Interrupt + // Status +#define SYSCTL_MISC_USBPLLLMIS 0x00000080 // USB PLL Lock Masked Interrupt + // Status +#define SYSCTL_MISC_PLLLMIS 0x00000040 // PLL Lock Masked Interrupt Status +#define SYSCTL_MISC_CLMIS 0x00000020 // Current Limit Masked Interrupt + // Status +#define SYSCTL_MISC_IOFMIS 0x00000010 // Internal Oscillator Fault Masked + // Interrupt Status +#define SYSCTL_MISC_MOFMIS 0x00000008 // Main Oscillator Fault Masked + // Interrupt Status +#define SYSCTL_MISC_LDOMIS 0x00000004 // LDO Power Unregulated Masked + // Interrupt Status +#define SYSCTL_MISC_BORMIS 0x00000002 // BOR Masked Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RESC register. +// +//***************************************************************************** +#define SYSCTL_RESC_MOSCFAIL 0x00010000 // MOSC Failure Reset +#define SYSCTL_RESC_LDO 0x00000020 // LDO Reset +#define SYSCTL_RESC_WDT1 0x00000020 // Watchdog Timer 1 Reset +#define SYSCTL_RESC_SW 0x00000010 // Software Reset +#define SYSCTL_RESC_WDT0 0x00000008 // Watchdog Timer 0 Reset +#define SYSCTL_RESC_BOR 0x00000004 // Brown-Out Reset +#define SYSCTL_RESC_POR 0x00000002 // Power-On Reset +#define SYSCTL_RESC_EXT 0x00000001 // External Reset + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RCC register. +// +//***************************************************************************** +#define SYSCTL_RCC_ACG 0x08000000 // Auto Clock Gating +#define SYSCTL_RCC_SYSDIV_M 0x07800000 // System Clock Divisor +#define SYSCTL_RCC_SYSDIV_2 0x00800000 // System clock /2 +#define SYSCTL_RCC_SYSDIV_3 0x01000000 // System clock /3 +#define SYSCTL_RCC_SYSDIV_4 0x01800000 // System clock /4 +#define SYSCTL_RCC_SYSDIV_5 0x02000000 // System clock /5 +#define SYSCTL_RCC_SYSDIV_6 0x02800000 // System clock /6 +#define SYSCTL_RCC_SYSDIV_7 0x03000000 // System clock /7 +#define SYSCTL_RCC_SYSDIV_8 0x03800000 // System clock /8 +#define SYSCTL_RCC_SYSDIV_9 0x04000000 // System clock /9 +#define SYSCTL_RCC_SYSDIV_10 0x04800000 // System clock /10 +#define SYSCTL_RCC_SYSDIV_11 0x05000000 // System clock /11 +#define SYSCTL_RCC_SYSDIV_12 0x05800000 // System clock /12 +#define SYSCTL_RCC_SYSDIV_13 0x06000000 // System clock /13 +#define SYSCTL_RCC_SYSDIV_14 0x06800000 // System clock /14 +#define SYSCTL_RCC_SYSDIV_15 0x07000000 // System clock /15 +#define SYSCTL_RCC_SYSDIV_16 0x07800000 // System clock /16 +#define SYSCTL_RCC_USESYSDIV 0x00400000 // Enable System Clock Divider +#define SYSCTL_RCC_USEPWMDIV 0x00100000 // Enable PWM Clock Divisor +#define SYSCTL_RCC_PWMDIV_M 0x000E0000 // PWM Unit Clock Divisor +#define SYSCTL_RCC_PWMDIV_2 0x00000000 // PWM clock /2 +#define SYSCTL_RCC_PWMDIV_4 0x00020000 // PWM clock /4 +#define SYSCTL_RCC_PWMDIV_8 0x00040000 // PWM clock /8 +#define SYSCTL_RCC_PWMDIV_16 0x00060000 // PWM clock /16 +#define SYSCTL_RCC_PWMDIV_32 0x00080000 // PWM clock /32 +#define SYSCTL_RCC_PWMDIV_64 0x000A0000 // PWM clock /64 +#define SYSCTL_RCC_PWRDN 0x00002000 // PLL Power Down +#define SYSCTL_RCC_OEN 0x00001000 // PLL Output Enable +#define SYSCTL_RCC_BYPASS 0x00000800 // PLL Bypass +#define SYSCTL_RCC_XTAL_M 0x000007C0 // Crystal Value +#define SYSCTL_RCC_XTAL_1MHZ 0x00000000 // 1 MHz +#define SYSCTL_RCC_XTAL_1_84MHZ 0x00000040 // 1.8432 MHz +#define SYSCTL_RCC_XTAL_2MHZ 0x00000080 // 2 MHz +#define SYSCTL_RCC_XTAL_2_45MHZ 0x000000C0 // 2.4576 MHz +#define SYSCTL_RCC_XTAL_3_57MHZ 0x00000100 // 3.579545 MHz +#define SYSCTL_RCC_XTAL_3_68MHZ 0x00000140 // 3.6864 MHz +#define SYSCTL_RCC_XTAL_4MHZ 0x00000180 // 4 MHz +#define SYSCTL_RCC_XTAL_4_09MHZ 0x000001C0 // 4.096 MHz +#define SYSCTL_RCC_XTAL_4_91MHZ 0x00000200 // 4.9152 MHz +#define SYSCTL_RCC_XTAL_5MHZ 0x00000240 // 5 MHz +#define SYSCTL_RCC_XTAL_5_12MHZ 0x00000280 // 5.12 MHz +#define SYSCTL_RCC_XTAL_6MHZ 0x000002C0 // 6 MHz +#define SYSCTL_RCC_XTAL_6_14MHZ 0x00000300 // 6.144 MHz +#define SYSCTL_RCC_XTAL_7_37MHZ 0x00000340 // 7.3728 MHz +#define SYSCTL_RCC_XTAL_8MHZ 0x00000380 // 8 MHz +#define SYSCTL_RCC_XTAL_8_19MHZ 0x000003C0 // 8.192 MHz +#define SYSCTL_RCC_XTAL_10MHZ 0x00000400 // 10 MHz +#define SYSCTL_RCC_XTAL_12MHZ 0x00000440 // 12 MHz +#define SYSCTL_RCC_XTAL_12_2MHZ 0x00000480 // 12.288 MHz +#define SYSCTL_RCC_XTAL_13_5MHZ 0x000004C0 // 13.56 MHz +#define SYSCTL_RCC_XTAL_14_3MHZ 0x00000500 // 14.31818 MHz +#define SYSCTL_RCC_XTAL_16MHZ 0x00000540 // 16 MHz +#define SYSCTL_RCC_XTAL_16_3MHZ 0x00000580 // 16.384 MHz +#define SYSCTL_RCC_PLLVER 0x00000400 // PLL Verification +#define SYSCTL_RCC_OSCSRC_M 0x00000030 // Oscillator Source +#define SYSCTL_RCC_OSCSRC_MAIN 0x00000000 // MOSC +#define SYSCTL_RCC_OSCSRC_INT 0x00000010 // IOSC +#define SYSCTL_RCC_OSCSRC_INT4 0x00000020 // IOSC/4 +#define SYSCTL_RCC_OSCSRC_30 0x00000030 // 30 kHz +#define SYSCTL_RCC_IOSCVER 0x00000008 // Internal Oscillator Verification + // Timer +#define SYSCTL_RCC_MOSCVER 0x00000004 // Main Oscillator Verification + // Timer +#define SYSCTL_RCC_IOSCDIS 0x00000002 // Internal Oscillator Disable +#define SYSCTL_RCC_MOSCDIS 0x00000001 // Main Oscillator Disable +#define SYSCTL_RCC_SYSDIV_S 23 +#define SYSCTL_RCC_PWMDIV_S 17 // Shift to the PWMDIV field +#define SYSCTL_RCC_XTAL_S 6 // Shift to the XTAL field +#define SYSCTL_RCC_OSCSRC_S 4 // Shift to the OSCSRC field + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_PLLCFG register. +// +//***************************************************************************** +#define SYSCTL_PLLCFG_OD_M 0x0000C000 // PLL OD Value +#define SYSCTL_PLLCFG_OD_1 0x00000000 // Divide by 1 +#define SYSCTL_PLLCFG_OD_2 0x00004000 // Divide by 2 +#define SYSCTL_PLLCFG_OD_4 0x00008000 // Divide by 4 +#define SYSCTL_PLLCFG_F_M 0x00003FE0 // PLL F Value +#define SYSCTL_PLLCFG_R_M 0x0000001F // PLL R Value +#define SYSCTL_PLLCFG_F_S 5 +#define SYSCTL_PLLCFG_R_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_GPIOHBCTL +// register. +// +//***************************************************************************** +#define SYSCTL_GPIOHBCTL_PORTJ 0x00000100 // Port J Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTH 0x00000080 // Port H Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTG 0x00000040 // Port G Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTF 0x00000020 // Port F Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTE 0x00000010 // Port E Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTD 0x00000008 // Port D Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTC 0x00000004 // Port C Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTB 0x00000002 // Port B Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTA 0x00000001 // Port A Advanced High-Performance + // Bus + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RCC2 register. +// +//***************************************************************************** +#define SYSCTL_RCC2_USERCC2 0x80000000 // Use RCC2 +#define SYSCTL_RCC2_DIV400 0x40000000 // Divide PLL as 400 MHz vs. 200 + // MHz +#define SYSCTL_RCC2_SYSDIV2_M 0x1F800000 // System Clock Divisor 2 +#define SYSCTL_RCC2_SYSDIV2_2 0x00800000 // System clock /2 +#define SYSCTL_RCC2_SYSDIV2_3 0x01000000 // System clock /3 +#define SYSCTL_RCC2_SYSDIV2_4 0x01800000 // System clock /4 +#define SYSCTL_RCC2_SYSDIV2_5 0x02000000 // System clock /5 +#define SYSCTL_RCC2_SYSDIV2_6 0x02800000 // System clock /6 +#define SYSCTL_RCC2_SYSDIV2_7 0x03000000 // System clock /7 +#define SYSCTL_RCC2_SYSDIV2_8 0x03800000 // System clock /8 +#define SYSCTL_RCC2_SYSDIV2_9 0x04000000 // System clock /9 +#define SYSCTL_RCC2_SYSDIV2_10 0x04800000 // System clock /10 +#define SYSCTL_RCC2_SYSDIV2_11 0x05000000 // System clock /11 +#define SYSCTL_RCC2_SYSDIV2_12 0x05800000 // System clock /12 +#define SYSCTL_RCC2_SYSDIV2_13 0x06000000 // System clock /13 +#define SYSCTL_RCC2_SYSDIV2_14 0x06800000 // System clock /14 +#define SYSCTL_RCC2_SYSDIV2_15 0x07000000 // System clock /15 +#define SYSCTL_RCC2_SYSDIV2_16 0x07800000 // System clock /16 +#define SYSCTL_RCC2_SYSDIV2_17 0x08000000 // System clock /17 +#define SYSCTL_RCC2_SYSDIV2_18 0x08800000 // System clock /18 +#define SYSCTL_RCC2_SYSDIV2_19 0x09000000 // System clock /19 +#define SYSCTL_RCC2_SYSDIV2_20 0x09800000 // System clock /20 +#define SYSCTL_RCC2_SYSDIV2_21 0x0A000000 // System clock /21 +#define SYSCTL_RCC2_SYSDIV2_22 0x0A800000 // System clock /22 +#define SYSCTL_RCC2_SYSDIV2_23 0x0B000000 // System clock /23 +#define SYSCTL_RCC2_SYSDIV2_24 0x0B800000 // System clock /24 +#define SYSCTL_RCC2_SYSDIV2_25 0x0C000000 // System clock /25 +#define SYSCTL_RCC2_SYSDIV2_26 0x0C800000 // System clock /26 +#define SYSCTL_RCC2_SYSDIV2_27 0x0D000000 // System clock /27 +#define SYSCTL_RCC2_SYSDIV2_28 0x0D800000 // System clock /28 +#define SYSCTL_RCC2_SYSDIV2_29 0x0E000000 // System clock /29 +#define SYSCTL_RCC2_SYSDIV2_30 0x0E800000 // System clock /30 +#define SYSCTL_RCC2_SYSDIV2_31 0x0F000000 // System clock /31 +#define SYSCTL_RCC2_SYSDIV2_32 0x0F800000 // System clock /32 +#define SYSCTL_RCC2_SYSDIV2_33 0x10000000 // System clock /33 +#define SYSCTL_RCC2_SYSDIV2_34 0x10800000 // System clock /34 +#define SYSCTL_RCC2_SYSDIV2_35 0x11000000 // System clock /35 +#define SYSCTL_RCC2_SYSDIV2_36 0x11800000 // System clock /36 +#define SYSCTL_RCC2_SYSDIV2_37 0x12000000 // System clock /37 +#define SYSCTL_RCC2_SYSDIV2_38 0x12800000 // System clock /38 +#define SYSCTL_RCC2_SYSDIV2_39 0x13000000 // System clock /39 +#define SYSCTL_RCC2_SYSDIV2_40 0x13800000 // System clock /40 +#define SYSCTL_RCC2_SYSDIV2_41 0x14000000 // System clock /41 +#define SYSCTL_RCC2_SYSDIV2_42 0x14800000 // System clock /42 +#define SYSCTL_RCC2_SYSDIV2_43 0x15000000 // System clock /43 +#define SYSCTL_RCC2_SYSDIV2_44 0x15800000 // System clock /44 +#define SYSCTL_RCC2_SYSDIV2_45 0x16000000 // System clock /45 +#define SYSCTL_RCC2_SYSDIV2_46 0x16800000 // System clock /46 +#define SYSCTL_RCC2_SYSDIV2_47 0x17000000 // System clock /47 +#define SYSCTL_RCC2_SYSDIV2_48 0x17800000 // System clock /48 +#define SYSCTL_RCC2_SYSDIV2_49 0x18000000 // System clock /49 +#define SYSCTL_RCC2_SYSDIV2_50 0x18800000 // System clock /50 +#define SYSCTL_RCC2_SYSDIV2_51 0x19000000 // System clock /51 +#define SYSCTL_RCC2_SYSDIV2_52 0x19800000 // System clock /52 +#define SYSCTL_RCC2_SYSDIV2_53 0x1A000000 // System clock /53 +#define SYSCTL_RCC2_SYSDIV2_54 0x1A800000 // System clock /54 +#define SYSCTL_RCC2_SYSDIV2_55 0x1B000000 // System clock /55 +#define SYSCTL_RCC2_SYSDIV2_56 0x1B800000 // System clock /56 +#define SYSCTL_RCC2_SYSDIV2_57 0x1C000000 // System clock /57 +#define SYSCTL_RCC2_SYSDIV2_58 0x1C800000 // System clock /58 +#define SYSCTL_RCC2_SYSDIV2_59 0x1D000000 // System clock /59 +#define SYSCTL_RCC2_SYSDIV2_60 0x1D800000 // System clock /60 +#define SYSCTL_RCC2_SYSDIV2_61 0x1E000000 // System clock /61 +#define SYSCTL_RCC2_SYSDIV2_62 0x1E800000 // System clock /62 +#define SYSCTL_RCC2_SYSDIV2_63 0x1F000000 // System clock /63 +#define SYSCTL_RCC2_SYSDIV2_64 0x1F800000 // System clock /64 +#define SYSCTL_RCC2_SYSDIV2LSB 0x00400000 // Additional LSB for SYSDIV2 +#define SYSCTL_RCC2_USBPWRDN 0x00004000 // Power-Down USB PLL +#define SYSCTL_RCC2_PWRDN2 0x00002000 // Power-Down PLL 2 +#define SYSCTL_RCC2_BYPASS2 0x00000800 // PLL Bypass 2 +#define SYSCTL_RCC2_OSCSRC2_M 0x00000070 // Oscillator Source 2 +#define SYSCTL_RCC2_OSCSRC2_MO 0x00000000 // MOSC +#define SYSCTL_RCC2_OSCSRC2_IO 0x00000010 // PIOSC +#define SYSCTL_RCC2_OSCSRC2_IO4 0x00000020 // PIOSC/4 +#define SYSCTL_RCC2_OSCSRC2_30 0x00000030 // 30 kHz +#define SYSCTL_RCC2_OSCSRC2_419 0x00000060 // 4.194304 MHz +#define SYSCTL_RCC2_OSCSRC2_32 0x00000070 // 32.768 kHz +#define SYSCTL_RCC2_SYSDIV2_S 23 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_MOSCCTL register. +// +//***************************************************************************** +#define SYSCTL_MOSCCTL_CVAL 0x00000001 // Clock Validation for MOSC + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RCGC0 register. +// +//***************************************************************************** +#define SYSCTL_RCGC0_WDT1 0x10000000 // WDT1 Clock Gating Control +#define SYSCTL_RCGC0_CAN2 0x04000000 // CAN2 Clock Gating Control +#define SYSCTL_RCGC0_CAN1 0x02000000 // CAN1 Clock Gating Control +#define SYSCTL_RCGC0_CAN0 0x01000000 // CAN0 Clock Gating Control +#define SYSCTL_RCGC0_PWM 0x00100000 // PWM Clock Gating Control +#define SYSCTL_RCGC0_ADC1 0x00020000 // ADC1 Clock Gating Control +#define SYSCTL_RCGC0_ADC0 0x00010000 // ADC0 Clock Gating Control +#define SYSCTL_RCGC0_ADCSPD_M 0x00000F00 // ADC Sample Speed +#define SYSCTL_RCGC0_ADCSPD125K 0x00000000 // 125K samples/second +#define SYSCTL_RCGC0_ADCSPD250K 0x00000100 // 250K samples/second +#define SYSCTL_RCGC0_ADCSPD500K 0x00000200 // 500K samples/second +#define SYSCTL_RCGC0_ADCSPD1M 0x00000300 // 1M samples/second +#define SYSCTL_RCGC0_ADC1SPD_M 0x00000C00 // ADC1 Sample Speed +#define SYSCTL_RCGC0_ADC1SPD_125K \ + 0x00000000 // 125K samples/second +#define SYSCTL_RCGC0_ADC1SPD_250K \ + 0x00000400 // 250K samples/second +#define SYSCTL_RCGC0_ADC1SPD_500K \ + 0x00000800 // 500K samples/second +#define SYSCTL_RCGC0_ADC1SPD_1M 0x00000C00 // 1M samples/second +#define SYSCTL_RCGC0_ADC0SPD_M 0x00000300 // ADC0 Sample Speed +#define SYSCTL_RCGC0_ADC0SPD_125K \ + 0x00000000 // 125K samples/second +#define SYSCTL_RCGC0_ADC0SPD_250K \ + 0x00000100 // 250K samples/second +#define SYSCTL_RCGC0_ADC0SPD_500K \ + 0x00000200 // 500K samples/second +#define SYSCTL_RCGC0_ADC0SPD_1M 0x00000300 // 1M samples/second +#define SYSCTL_RCGC0_HIB 0x00000040 // HIB Clock Gating Control +#define SYSCTL_RCGC0_WDT0 0x00000008 // WDT0 Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RCGC1 register. +// +//***************************************************************************** +#define SYSCTL_RCGC1_EPI0 0x40000000 // EPI0 Clock Gating +#define SYSCTL_RCGC1_I2S0 0x10000000 // I2S0 Clock Gating +#define SYSCTL_RCGC1_COMP2 0x04000000 // Analog Comparator 2 Clock Gating +#define SYSCTL_RCGC1_COMP1 0x02000000 // Analog Comparator 1 Clock Gating +#define SYSCTL_RCGC1_COMP0 0x01000000 // Analog Comparator 0 Clock Gating +#define SYSCTL_RCGC1_TIMER3 0x00080000 // Timer 3 Clock Gating Control +#define SYSCTL_RCGC1_TIMER2 0x00040000 // Timer 2 Clock Gating Control +#define SYSCTL_RCGC1_TIMER1 0x00020000 // Timer 1 Clock Gating Control +#define SYSCTL_RCGC1_TIMER0 0x00010000 // Timer 0 Clock Gating Control +#define SYSCTL_RCGC1_I2C1 0x00004000 // I2C1 Clock Gating Control +#define SYSCTL_RCGC1_I2C0 0x00001000 // I2C0 Clock Gating Control +#define SYSCTL_RCGC1_QEI1 0x00000200 // QEI1 Clock Gating Control +#define SYSCTL_RCGC1_QEI0 0x00000100 // QEI0 Clock Gating Control +#define SYSCTL_RCGC1_SSI1 0x00000020 // SSI1 Clock Gating Control +#define SYSCTL_RCGC1_SSI0 0x00000010 // SSI0 Clock Gating Control +#define SYSCTL_RCGC1_UART2 0x00000004 // UART2 Clock Gating Control +#define SYSCTL_RCGC1_UART1 0x00000002 // UART1 Clock Gating Control +#define SYSCTL_RCGC1_UART0 0x00000001 // UART0 Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RCGC2 register. +// +//***************************************************************************** +#define SYSCTL_RCGC2_EPHY0 0x40000000 // PHY0 Clock Gating Control +#define SYSCTL_RCGC2_EMAC0 0x10000000 // MAC0 Clock Gating Control +#define SYSCTL_RCGC2_USB0 0x00010000 // USB0 Clock Gating Control +#define SYSCTL_RCGC2_UDMA 0x00002000 // Micro-DMA Clock Gating Control +#define SYSCTL_RCGC2_GPIOJ 0x00000100 // Port J Clock Gating Control +#define SYSCTL_RCGC2_GPIOH 0x00000080 // Port H Clock Gating Control +#define SYSCTL_RCGC2_GPIOG 0x00000040 // Port G Clock Gating Control +#define SYSCTL_RCGC2_GPIOF 0x00000020 // Port F Clock Gating Control +#define SYSCTL_RCGC2_GPIOE 0x00000010 // Port E Clock Gating Control +#define SYSCTL_RCGC2_GPIOD 0x00000008 // Port D Clock Gating Control +#define SYSCTL_RCGC2_GPIOC 0x00000004 // Port C Clock Gating Control +#define SYSCTL_RCGC2_GPIOB 0x00000002 // Port B Clock Gating Control +#define SYSCTL_RCGC2_GPIOA 0x00000001 // Port A Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SCGC0 register. +// +//***************************************************************************** +#define SYSCTL_SCGC0_WDT1 0x10000000 // WDT1 Clock Gating Control +#define SYSCTL_SCGC0_CAN2 0x04000000 // CAN2 Clock Gating Control +#define SYSCTL_SCGC0_CAN1 0x02000000 // CAN1 Clock Gating Control +#define SYSCTL_SCGC0_CAN0 0x01000000 // CAN0 Clock Gating Control +#define SYSCTL_SCGC0_PWM 0x00100000 // PWM Clock Gating Control +#define SYSCTL_SCGC0_ADC1 0x00020000 // ADC1 Clock Gating Control +#define SYSCTL_SCGC0_ADC0 0x00010000 // ADC0 Clock Gating Control +#define SYSCTL_SCGC0_ADCSPD_M 0x00000F00 // ADC Sample Speed +#define SYSCTL_SCGC0_ADCSPD125K 0x00000000 // 125K samples/second +#define SYSCTL_SCGC0_ADCSPD250K 0x00000100 // 250K samples/second +#define SYSCTL_SCGC0_ADCSPD500K 0x00000200 // 500K samples/second +#define SYSCTL_SCGC0_ADCSPD1M 0x00000300 // 1M samples/second +#define SYSCTL_SCGC0_ADC1SPD_M 0x00000C00 // ADC1 Sample Speed +#define SYSCTL_SCGC0_ADC1SPD_125K \ + 0x00000000 // 125K samples/second +#define SYSCTL_SCGC0_ADC1SPD_250K \ + 0x00000400 // 250K samples/second +#define SYSCTL_SCGC0_ADC1SPD_500K \ + 0x00000800 // 500K samples/second +#define SYSCTL_SCGC0_ADC1SPD_1M 0x00000C00 // 1M samples/second +#define SYSCTL_SCGC0_ADC0SPD_M 0x00000300 // ADC0 Sample Speed +#define SYSCTL_SCGC0_ADC0SPD_125K \ + 0x00000000 // 125K samples/second +#define SYSCTL_SCGC0_ADC0SPD_250K \ + 0x00000100 // 250K samples/second +#define SYSCTL_SCGC0_ADC0SPD_500K \ + 0x00000200 // 500K samples/second +#define SYSCTL_SCGC0_ADC0SPD_1M 0x00000300 // 1M samples/second +#define SYSCTL_SCGC0_HIB 0x00000040 // HIB Clock Gating Control +#define SYSCTL_SCGC0_WDT0 0x00000008 // WDT0 Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SCGC1 register. +// +//***************************************************************************** +#define SYSCTL_SCGC1_EPI0 0x40000000 // EPI0 Clock Gating +#define SYSCTL_SCGC1_I2S0 0x10000000 // I2S0 Clock Gating +#define SYSCTL_SCGC1_COMP2 0x04000000 // Analog Comparator 2 Clock Gating +#define SYSCTL_SCGC1_COMP1 0x02000000 // Analog Comparator 1 Clock Gating +#define SYSCTL_SCGC1_COMP0 0x01000000 // Analog Comparator 0 Clock Gating +#define SYSCTL_SCGC1_TIMER3 0x00080000 // Timer 3 Clock Gating Control +#define SYSCTL_SCGC1_TIMER2 0x00040000 // Timer 2 Clock Gating Control +#define SYSCTL_SCGC1_TIMER1 0x00020000 // Timer 1 Clock Gating Control +#define SYSCTL_SCGC1_TIMER0 0x00010000 // Timer 0 Clock Gating Control +#define SYSCTL_SCGC1_I2C1 0x00004000 // I2C1 Clock Gating Control +#define SYSCTL_SCGC1_I2C0 0x00001000 // I2C0 Clock Gating Control +#define SYSCTL_SCGC1_QEI1 0x00000200 // QEI1 Clock Gating Control +#define SYSCTL_SCGC1_QEI0 0x00000100 // QEI0 Clock Gating Control +#define SYSCTL_SCGC1_SSI1 0x00000020 // SSI1 Clock Gating Control +#define SYSCTL_SCGC1_SSI0 0x00000010 // SSI0 Clock Gating Control +#define SYSCTL_SCGC1_UART2 0x00000004 // UART2 Clock Gating Control +#define SYSCTL_SCGC1_UART1 0x00000002 // UART1 Clock Gating Control +#define SYSCTL_SCGC1_UART0 0x00000001 // UART0 Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SCGC2 register. +// +//***************************************************************************** +#define SYSCTL_SCGC2_EPHY0 0x40000000 // PHY0 Clock Gating Control +#define SYSCTL_SCGC2_EMAC0 0x10000000 // MAC0 Clock Gating Control +#define SYSCTL_SCGC2_USB0 0x00010000 // USB0 Clock Gating Control +#define SYSCTL_SCGC2_UDMA 0x00002000 // Micro-DMA Clock Gating Control +#define SYSCTL_SCGC2_GPIOJ 0x00000100 // Port J Clock Gating Control +#define SYSCTL_SCGC2_GPIOH 0x00000080 // Port H Clock Gating Control +#define SYSCTL_SCGC2_GPIOG 0x00000040 // Port G Clock Gating Control +#define SYSCTL_SCGC2_GPIOF 0x00000020 // Port F Clock Gating Control +#define SYSCTL_SCGC2_GPIOE 0x00000010 // Port E Clock Gating Control +#define SYSCTL_SCGC2_GPIOD 0x00000008 // Port D Clock Gating Control +#define SYSCTL_SCGC2_GPIOC 0x00000004 // Port C Clock Gating Control +#define SYSCTL_SCGC2_GPIOB 0x00000002 // Port B Clock Gating Control +#define SYSCTL_SCGC2_GPIOA 0x00000001 // Port A Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DCGC0 register. +// +//***************************************************************************** +#define SYSCTL_DCGC0_WDT1 0x10000000 // WDT1 Clock Gating Control +#define SYSCTL_DCGC0_CAN2 0x04000000 // CAN2 Clock Gating Control +#define SYSCTL_DCGC0_CAN1 0x02000000 // CAN1 Clock Gating Control +#define SYSCTL_DCGC0_CAN0 0x01000000 // CAN0 Clock Gating Control +#define SYSCTL_DCGC0_PWM 0x00100000 // PWM Clock Gating Control +#define SYSCTL_DCGC0_ADC1 0x00020000 // ADC1 Clock Gating Control +#define SYSCTL_DCGC0_ADC0 0x00010000 // ADC0 Clock Gating Control +#define SYSCTL_DCGC0_HIB 0x00000040 // HIB Clock Gating Control +#define SYSCTL_DCGC0_WDT0 0x00000008 // WDT0 Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DCGC1 register. +// +//***************************************************************************** +#define SYSCTL_DCGC1_EPI0 0x40000000 // EPI0 Clock Gating +#define SYSCTL_DCGC1_I2S0 0x10000000 // I2S0 Clock Gating +#define SYSCTL_DCGC1_COMP2 0x04000000 // Analog Comparator 2 Clock Gating +#define SYSCTL_DCGC1_COMP1 0x02000000 // Analog Comparator 1 Clock Gating +#define SYSCTL_DCGC1_COMP0 0x01000000 // Analog Comparator 0 Clock Gating +#define SYSCTL_DCGC1_TIMER3 0x00080000 // Timer 3 Clock Gating Control +#define SYSCTL_DCGC1_TIMER2 0x00040000 // Timer 2 Clock Gating Control +#define SYSCTL_DCGC1_TIMER1 0x00020000 // Timer 1 Clock Gating Control +#define SYSCTL_DCGC1_TIMER0 0x00010000 // Timer 0 Clock Gating Control +#define SYSCTL_DCGC1_I2C1 0x00004000 // I2C1 Clock Gating Control +#define SYSCTL_DCGC1_I2C0 0x00001000 // I2C0 Clock Gating Control +#define SYSCTL_DCGC1_QEI1 0x00000200 // QEI1 Clock Gating Control +#define SYSCTL_DCGC1_QEI0 0x00000100 // QEI0 Clock Gating Control +#define SYSCTL_DCGC1_SSI1 0x00000020 // SSI1 Clock Gating Control +#define SYSCTL_DCGC1_SSI0 0x00000010 // SSI0 Clock Gating Control +#define SYSCTL_DCGC1_UART2 0x00000004 // UART2 Clock Gating Control +#define SYSCTL_DCGC1_UART1 0x00000002 // UART1 Clock Gating Control +#define SYSCTL_DCGC1_UART0 0x00000001 // UART0 Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DCGC2 register. +// +//***************************************************************************** +#define SYSCTL_DCGC2_EPHY0 0x40000000 // PHY0 Clock Gating Control +#define SYSCTL_DCGC2_EMAC0 0x10000000 // MAC0 Clock Gating Control +#define SYSCTL_DCGC2_USB0 0x00010000 // USB0 Clock Gating Control +#define SYSCTL_DCGC2_UDMA 0x00002000 // Micro-DMA Clock Gating Control +#define SYSCTL_DCGC2_GPIOJ 0x00000100 // Port J Clock Gating Control +#define SYSCTL_DCGC2_GPIOH 0x00000080 // Port H Clock Gating Control +#define SYSCTL_DCGC2_GPIOG 0x00000040 // Port G Clock Gating Control +#define SYSCTL_DCGC2_GPIOF 0x00000020 // Port F Clock Gating Control +#define SYSCTL_DCGC2_GPIOE 0x00000010 // Port E Clock Gating Control +#define SYSCTL_DCGC2_GPIOD 0x00000008 // Port D Clock Gating Control +#define SYSCTL_DCGC2_GPIOC 0x00000004 // Port C Clock Gating Control +#define SYSCTL_DCGC2_GPIOB 0x00000002 // Port B Clock Gating Control +#define SYSCTL_DCGC2_GPIOA 0x00000001 // Port A Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DSLPCLKCFG +// register. +// +//***************************************************************************** +#define SYSCTL_DSLPCLKCFG_D_M 0x1F800000 // Divider Field Override +#define SYSCTL_DSLPCLKCFG_D_1 0x00000000 // System clock /1 +#define SYSCTL_DSLPCLKCFG_D_2 0x00800000 // System clock /2 +#define SYSCTL_DSLPCLKCFG_D_3 0x01000000 // System clock /3 +#define SYSCTL_DSLPCLKCFG_D_4 0x01800000 // System clock /4 +#define SYSCTL_DSLPCLKCFG_D_5 0x02000000 // System clock /5 +#define SYSCTL_DSLPCLKCFG_D_6 0x02800000 // System clock /6 +#define SYSCTL_DSLPCLKCFG_D_7 0x03000000 // System clock /7 +#define SYSCTL_DSLPCLKCFG_D_8 0x03800000 // System clock /8 +#define SYSCTL_DSLPCLKCFG_D_9 0x04000000 // System clock /9 +#define SYSCTL_DSLPCLKCFG_D_10 0x04800000 // System clock /10 +#define SYSCTL_DSLPCLKCFG_D_11 0x05000000 // System clock /11 +#define SYSCTL_DSLPCLKCFG_D_12 0x05800000 // System clock /12 +#define SYSCTL_DSLPCLKCFG_D_13 0x06000000 // System clock /13 +#define SYSCTL_DSLPCLKCFG_D_14 0x06800000 // System clock /14 +#define SYSCTL_DSLPCLKCFG_D_15 0x07000000 // System clock /15 +#define SYSCTL_DSLPCLKCFG_D_16 0x07800000 // System clock /16 +#define SYSCTL_DSLPCLKCFG_D_17 0x08000000 // System clock /17 +#define SYSCTL_DSLPCLKCFG_D_18 0x08800000 // System clock /18 +#define SYSCTL_DSLPCLKCFG_D_19 0x09000000 // System clock /19 +#define SYSCTL_DSLPCLKCFG_D_20 0x09800000 // System clock /20 +#define SYSCTL_DSLPCLKCFG_D_21 0x0A000000 // System clock /21 +#define SYSCTL_DSLPCLKCFG_D_22 0x0A800000 // System clock /22 +#define SYSCTL_DSLPCLKCFG_D_23 0x0B000000 // System clock /23 +#define SYSCTL_DSLPCLKCFG_D_24 0x0B800000 // System clock /24 +#define SYSCTL_DSLPCLKCFG_D_25 0x0C000000 // System clock /25 +#define SYSCTL_DSLPCLKCFG_D_26 0x0C800000 // System clock /26 +#define SYSCTL_DSLPCLKCFG_D_27 0x0D000000 // System clock /27 +#define SYSCTL_DSLPCLKCFG_D_28 0x0D800000 // System clock /28 +#define SYSCTL_DSLPCLKCFG_D_29 0x0E000000 // System clock /29 +#define SYSCTL_DSLPCLKCFG_D_30 0x0E800000 // System clock /30 +#define SYSCTL_DSLPCLKCFG_D_31 0x0F000000 // System clock /31 +#define SYSCTL_DSLPCLKCFG_D_32 0x0F800000 // System clock /32 +#define SYSCTL_DSLPCLKCFG_D_33 0x10000000 // System clock /33 +#define SYSCTL_DSLPCLKCFG_D_34 0x10800000 // System clock /34 +#define SYSCTL_DSLPCLKCFG_D_35 0x11000000 // System clock /35 +#define SYSCTL_DSLPCLKCFG_D_36 0x11800000 // System clock /36 +#define SYSCTL_DSLPCLKCFG_D_37 0x12000000 // System clock /37 +#define SYSCTL_DSLPCLKCFG_D_38 0x12800000 // System clock /38 +#define SYSCTL_DSLPCLKCFG_D_39 0x13000000 // System clock /39 +#define SYSCTL_DSLPCLKCFG_D_40 0x13800000 // System clock /40 +#define SYSCTL_DSLPCLKCFG_D_41 0x14000000 // System clock /41 +#define SYSCTL_DSLPCLKCFG_D_42 0x14800000 // System clock /42 +#define SYSCTL_DSLPCLKCFG_D_43 0x15000000 // System clock /43 +#define SYSCTL_DSLPCLKCFG_D_44 0x15800000 // System clock /44 +#define SYSCTL_DSLPCLKCFG_D_45 0x16000000 // System clock /45 +#define SYSCTL_DSLPCLKCFG_D_46 0x16800000 // System clock /46 +#define SYSCTL_DSLPCLKCFG_D_47 0x17000000 // System clock /47 +#define SYSCTL_DSLPCLKCFG_D_48 0x17800000 // System clock /48 +#define SYSCTL_DSLPCLKCFG_D_49 0x18000000 // System clock /49 +#define SYSCTL_DSLPCLKCFG_D_50 0x18800000 // System clock /50 +#define SYSCTL_DSLPCLKCFG_D_51 0x19000000 // System clock /51 +#define SYSCTL_DSLPCLKCFG_D_52 0x19800000 // System clock /52 +#define SYSCTL_DSLPCLKCFG_D_53 0x1A000000 // System clock /53 +#define SYSCTL_DSLPCLKCFG_D_54 0x1A800000 // System clock /54 +#define SYSCTL_DSLPCLKCFG_D_55 0x1B000000 // System clock /55 +#define SYSCTL_DSLPCLKCFG_D_56 0x1B800000 // System clock /56 +#define SYSCTL_DSLPCLKCFG_D_57 0x1C000000 // System clock /57 +#define SYSCTL_DSLPCLKCFG_D_58 0x1C800000 // System clock /58 +#define SYSCTL_DSLPCLKCFG_D_59 0x1D000000 // System clock /59 +#define SYSCTL_DSLPCLKCFG_D_60 0x1D800000 // System clock /60 +#define SYSCTL_DSLPCLKCFG_D_61 0x1E000000 // System clock /61 +#define SYSCTL_DSLPCLKCFG_D_62 0x1E800000 // System clock /62 +#define SYSCTL_DSLPCLKCFG_D_63 0x1F000000 // System clock /63 +#define SYSCTL_DSLPCLKCFG_D_64 0x1F800000 // System clock /64 +#define SYSCTL_DSLPCLKCFG_O_M 0x00000070 // Clock Source +#define SYSCTL_DSLPCLKCFG_O_IGN 0x00000000 // MOSC +#define SYSCTL_DSLPCLKCFG_O_IO 0x00000010 // PIOSC +#define SYSCTL_DSLPCLKCFG_O_30 0x00000030 // 30 kHz +#define SYSCTL_DSLPCLKCFG_O_32 0x00000070 // 32.768 kHz +#define SYSCTL_DSLPCLKCFG_IOSC 0x00000001 // IOSC Clock Source +#define SYSCTL_DSLPCLKCFG_D_S 23 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_PIOSCCAL +// register. +// +//***************************************************************************** +#define SYSCTL_PIOSCCAL_UTEN 0x80000000 // Use User Trim Value +#define SYSCTL_PIOSCCAL_CAL 0x00000200 // Start Calibration +#define SYSCTL_PIOSCCAL_UPDATE 0x00000100 // Update Trim +#define SYSCTL_PIOSCCAL_UT_M 0x0000007F // User Trim Value +#define SYSCTL_PIOSCCAL_UT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_CLKVCLR register. +// +//***************************************************************************** +#define SYSCTL_CLKVCLR_VERCLR 0x00000001 // Clock Verification Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_PIOSCSTAT +// register. +// +//***************************************************************************** +#define SYSCTL_PIOSCSTAT_DT_M 0x007F0000 // Default Trim Value +#define SYSCTL_PIOSCSTAT_CR_M 0x00000300 // Calibration Result +#define SYSCTL_PIOSCSTAT_CRNONE 0x00000000 // Calibration has not been + // attempted +#define SYSCTL_PIOSCSTAT_CRPASS 0x00000100 // The last calibration operation + // completed to meet 1% accuracy +#define SYSCTL_PIOSCSTAT_CRFAIL 0x00000200 // The last calibration operation + // failed to meet 1% accuracy +#define SYSCTL_PIOSCSTAT_CT_M 0x0000007F // Calibration Trim Value +#define SYSCTL_PIOSCSTAT_DT_S 16 +#define SYSCTL_PIOSCSTAT_CT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_LDOARST register. +// +//***************************************************************************** +#define SYSCTL_LDOARST_LDOARST 0x00000001 // LDO Reset + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_I2SMCLKCFG +// register. +// +//***************************************************************************** +#define SYSCTL_I2SMCLKCFG_RXEN 0x80000000 // RX Clock Enable +#define SYSCTL_I2SMCLKCFG_RXI_M 0x3FF00000 // RX Clock Integer Input +#define SYSCTL_I2SMCLKCFG_RXF_M 0x000F0000 // RX Clock Fractional Input +#define SYSCTL_I2SMCLKCFG_TXEN 0x00008000 // TX Clock Enable +#define SYSCTL_I2SMCLKCFG_TXI_M 0x00003FF0 // TX Clock Integer Input +#define SYSCTL_I2SMCLKCFG_TXF_M 0x0000000F // TX Clock Fractional Input +#define SYSCTL_I2SMCLKCFG_RXI_S 20 +#define SYSCTL_I2SMCLKCFG_RXF_S 16 +#define SYSCTL_I2SMCLKCFG_TXI_S 4 +#define SYSCTL_I2SMCLKCFG_TXF_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC9 register. +// +//***************************************************************************** +#define SYSCTL_DC9_ADC1DC7 0x00800000 // ADC1 DC7 Present +#define SYSCTL_DC9_ADC1DC6 0x00400000 // ADC1 DC6 Present +#define SYSCTL_DC9_ADC1DC5 0x00200000 // ADC1 DC5 Present +#define SYSCTL_DC9_ADC1DC4 0x00100000 // ADC1 DC4 Present +#define SYSCTL_DC9_ADC1DC3 0x00080000 // ADC1 DC3 Present +#define SYSCTL_DC9_ADC1DC2 0x00040000 // ADC1 DC2 Present +#define SYSCTL_DC9_ADC1DC1 0x00020000 // ADC1 DC1 Present +#define SYSCTL_DC9_ADC1DC0 0x00010000 // ADC1 DC0 Present +#define SYSCTL_DC9_ADC0DC7 0x00000080 // ADC0 DC7 Present +#define SYSCTL_DC9_ADC0DC6 0x00000040 // ADC0 DC6 Present +#define SYSCTL_DC9_ADC0DC5 0x00000020 // ADC0 DC5 Present +#define SYSCTL_DC9_ADC0DC4 0x00000010 // ADC0 DC4 Present +#define SYSCTL_DC9_ADC0DC3 0x00000008 // ADC0 DC3 Present +#define SYSCTL_DC9_ADC0DC2 0x00000004 // ADC0 DC2 Present +#define SYSCTL_DC9_ADC0DC1 0x00000002 // ADC0 DC1 Present +#define SYSCTL_DC9_ADC0DC0 0x00000001 // ADC0 DC0 Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_NVMSTAT register. +// +//***************************************************************************** +#define SYSCTL_NVMSTAT_TPSW 0x00000010 // Third Party Software Present +#define SYSCTL_NVMSTAT_FWB 0x00000001 // 32 Word Flash Write Buffer + // Active + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the System Control register +// addresses. +// +//***************************************************************************** +#define SYSCTL_GPIOHSCTL 0x400FE06C // GPIO High-Speed Control +#define SYSCTL_USER0 0x400FE1E0 // NV User Register 0 +#define SYSCTL_USER1 0x400FE1E4 // NV User Register 1 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_DID0 +// register. +// +//***************************************************************************** +#define SYSCTL_DID0_VER_MASK 0x70000000 // DID0 version mask +#define SYSCTL_DID0_CLASS_MASK 0x00FF0000 // Device Class +#define SYSCTL_DID0_MAJ_MASK 0x0000FF00 // Major revision mask +#define SYSCTL_DID0_MAJ_A 0x00000000 // Major revision A +#define SYSCTL_DID0_MAJ_B 0x00000100 // Major revision B +#define SYSCTL_DID0_MAJ_C 0x00000200 // Major revision C +#define SYSCTL_DID0_MIN_MASK 0x000000FF // Minor revision mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_DID1 +// register. +// +//***************************************************************************** +#define SYSCTL_DID1_VER_MASK 0xF0000000 // Register version mask +#define SYSCTL_DID1_FAM_MASK 0x0F000000 // Family mask +#define SYSCTL_DID1_FAM_S 0x00000000 // Stellaris family +#define SYSCTL_DID1_PRTNO_MASK 0x00FF0000 // Part number mask +#define SYSCTL_DID1_PINCNT_MASK 0x0000E000 // Pin count +#define SYSCTL_DID1_TEMP_MASK 0x000000E0 // Temperature range mask +#define SYSCTL_DID1_PKG_MASK 0x00000018 // Package mask +#define SYSCTL_DID1_PKG_48QFP 0x00000008 // QFP package +#define SYSCTL_DID1_QUAL_MASK 0x00000003 // Qualification status mask +#define SYSCTL_DID1_PKG_28SOIC 0x00000000 // SOIC package +#define SYSCTL_DID1_PRTNO_SHIFT 16 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_DC0 +// register. +// +//***************************************************************************** +#define SYSCTL_DC0_SRAMSZ_MASK 0xFFFF0000 // SRAM size mask +#define SYSCTL_DC0_FLASHSZ_MASK 0x0000FFFF // Flash size mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_DC1 +// register. +// +//***************************************************************************** +#define SYSCTL_DC1_ADC 0x00010000 // ADC Module Present +#define SYSCTL_DC1_SYSDIV_MASK 0x0000F000 // Minimum system divider mask +#define SYSCTL_DC1_ADCSPD_MASK 0x00000F00 // ADC speed mask +#define SYSCTL_DC1_WDOG 0x00000008 // Watchdog present +#define SYSCTL_DC1_WDT 0x00000008 // Watchdog Timer Present + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_DC2 +// register. +// +//***************************************************************************** +#define SYSCTL_DC2_I2C 0x00001000 // I2C present +#define SYSCTL_DC2_QEI 0x00000100 // QEI present +#define SYSCTL_DC2_SSI 0x00000010 // SSI present + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_DC3 +// register. +// +//***************************************************************************** +#define SYSCTL_DC3_ADC7 0x00800000 // ADC7 Pin Present +#define SYSCTL_DC3_ADC6 0x00400000 // ADC6 Pin Present +#define SYSCTL_DC3_ADC5 0x00200000 // ADC5 Pin Present +#define SYSCTL_DC3_ADC4 0x00100000 // ADC4 Pin Present +#define SYSCTL_DC3_ADC3 0x00080000 // ADC3 Pin Present +#define SYSCTL_DC3_ADC2 0x00040000 // ADC2 Pin Present +#define SYSCTL_DC3_ADC1 0x00020000 // ADC1 Pin Present +#define SYSCTL_DC3_ADC0 0x00010000 // ADC0 Pin Present +#define SYSCTL_DC3_MC_FAULT0 0x00008000 // MC0 fault pin present + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// SYSCTL_PBORCTL register. +// +//***************************************************************************** +#define SYSCTL_PBORCTL_BOR_MASK 0x0000FFFC // BOR wait timer +#define SYSCTL_PBORCTL_BOR_SH 2 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// SYSCTL_LDOPCTL register. +// +//***************************************************************************** +#define SYSCTL_LDOPCTL_MASK 0x0000003F // Voltage adjust mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_SRCR0 +// register. +// +//***************************************************************************** +#define SYSCTL_SRCR0_ADC 0x00010000 // ADC0 Reset Control +#define SYSCTL_SRCR0_WDT 0x00000008 // WDT Reset Control + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_RESC +// register. +// +//***************************************************************************** +#define SYSCTL_RESC_WDOG 0x00000008 // Watchdog reset +#define SYSCTL_RESC_WDT 0x00000008 // Watchdog Timer Reset + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_RCC +// register. +// +//***************************************************************************** +#define SYSCTL_RCC_SYSDIV_MASK 0x07800000 // System clock divider +#define SYSCTL_RCC_USE_SYSDIV 0x00400000 // Use sytem clock divider +#define SYSCTL_RCC_USE_PWMDIV 0x00100000 // Use PWM clock divider +#define SYSCTL_RCC_PWMDIV_MASK 0x000E0000 // PWM clock divider +#define SYSCTL_RCC_OE 0x00001000 // PLL output enable +#define SYSCTL_RCC_XTAL_3_68MHz 0x00000140 // Using a 3.6864 MHz crystal +#define SYSCTL_RCC_XTAL_4MHz 0x00000180 // Using a 4 MHz crystal +#define SYSCTL_RCC_XTAL_MASK 0x000003C0 // Crystal attached to main osc +#define SYSCTL_RCC_OSCSRC_MASK 0x00000030 // Oscillator input select +#define SYSCTL_RCC_SYSDIV_SHIFT 23 // Shift to the SYSDIV field +#define SYSCTL_RCC_PWMDIV_SHIFT 17 // Shift to the PWMDIV field +#define SYSCTL_RCC_XTAL_SHIFT 6 // Shift to the XTAL field +#define SYSCTL_RCC_OSCSRC_SHIFT 4 // Shift to the OSCSRC field + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_PLLCFG +// register. +// +//***************************************************************************** +#define SYSCTL_PLLCFG_OD_MASK 0x0000C000 // Output divider +#define SYSCTL_PLLCFG_F_MASK 0x00003FE0 // PLL multiplier +#define SYSCTL_PLLCFG_R_MASK 0x0000001F // Input predivider +#define SYSCTL_PLLCFG_F_SHIFT 5 +#define SYSCTL_PLLCFG_R_SHIFT 0 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// SYSCTL_GPIOHSCTL register. +// +//***************************************************************************** +#define SYSCTL_GPIOHSCTL_PORTA 0x00000001 // Port A High-Speed +#define SYSCTL_GPIOHSCTL_PORTB 0x00000002 // Port B High-Speed +#define SYSCTL_GPIOHSCTL_PORTC 0x00000004 // Port C High-Speed +#define SYSCTL_GPIOHSCTL_PORTD 0x00000008 // Port D High-Speed +#define SYSCTL_GPIOHSCTL_PORTE 0x00000010 // Port E High-Speed +#define SYSCTL_GPIOHSCTL_PORTF 0x00000020 // Port F High-Speed +#define SYSCTL_GPIOHSCTL_PORTG 0x00000040 // Port G High-Speed +#define SYSCTL_GPIOHSCTL_PORTH 0x00000080 // Port H High-Speed + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_RCC2 +// register. +// +//***************************************************************************** +#define SYSCTL_RCC2_USEFRACT 0x40000000 // Use fractional divider +#define SYSCTL_RCC2_SYSDIV2_MSK 0x1F800000 // System clock divider +#define SYSCTL_RCC2_FRACT 0x00400000 // Fractional divide +#define SYSCTL_RCC2_OSCSRC2_MSK 0x00000070 // Oscillator input select + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_RCGC0 +// register. +// +//***************************************************************************** +#define SYSCTL_RCGC0_ADC 0x00010000 // ADC0 Clock Gating Control +#define SYSCTL_RCGC0_WDT 0x00000008 // WDT Clock Gating Control + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_SCGC0 +// register. +// +//***************************************************************************** +#define SYSCTL_SCGC0_ADC 0x00010000 // ADC0 Clock Gating Control +#define SYSCTL_SCGC0_WDT 0x00000008 // WDT Clock Gating Control + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_DCGC0 +// register. +// +//***************************************************************************** +#define SYSCTL_DCGC0_ADC 0x00010000 // ADC0 Clock Gating Control +#define SYSCTL_DCGC0_WDT 0x00000008 // WDT Clock Gating Control + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// SYSCTL_DSLPCLKCFG register. +// +//***************************************************************************** +#define SYSCTL_DSLPCLKCFG_D_MSK 0x1F800000 // Deep sleep system clock override +#define SYSCTL_DSLPCLKCFG_O_MSK 0x00000070 // Deep sleep oscillator override + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// SYSCTL_CLKVCLR register. +// +//***************************************************************************** +#define SYSCTL_CLKVCLR_CLR 0x00000001 // Clear clock verification fault + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// SYSCTL_LDOARST register. +// +//***************************************************************************** +#define SYSCTL_LDOARST_ARST 0x00000001 // Allow LDO to reset device + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_SRCR0, +// SYSCTL_RCGC0, SYSCTL_SCGC0, and SYSCTL_DCGC0 registers. +// +//***************************************************************************** +#define SYSCTL_SET0_CAN2 0x04000000 // CAN 2 module +#define SYSCTL_SET0_CAN1 0x02000000 // CAN 1 module +#define SYSCTL_SET0_CAN0 0x01000000 // CAN 0 module +#define SYSCTL_SET0_PWM 0x00100000 // PWM module +#define SYSCTL_SET0_ADC 0x00010000 // ADC module +#define SYSCTL_SET0_ADCSPD_MASK 0x00000F00 // ADC speed mask +#define SYSCTL_SET0_ADCSPD_125K 0x00000000 // 125Ksps ADC +#define SYSCTL_SET0_ADCSPD_250K 0x00000100 // 250Ksps ADC +#define SYSCTL_SET0_ADCSPD_500K 0x00000200 // 500Ksps ADC +#define SYSCTL_SET0_ADCSPD_1M 0x00000300 // 1Msps ADC +#define SYSCTL_SET0_HIB 0x00000040 // Hibernation module +#define SYSCTL_SET0_WDOG 0x00000008 // Watchdog module + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_SRCR1, +// SYSCTL_RCGC1, SYSCTL_SCGC1, and SYSCTL_DCGC1 registers. +// +//***************************************************************************** +#define SYSCTL_SET1_COMP2 0x04000000 // Analog comparator module 2 +#define SYSCTL_SET1_COMP1 0x02000000 // Analog comparator module 1 +#define SYSCTL_SET1_COMP0 0x01000000 // Analog comparator module 0 +#define SYSCTL_SET1_TIMER3 0x00080000 // Timer module 3 +#define SYSCTL_SET1_TIMER2 0x00040000 // Timer module 2 +#define SYSCTL_SET1_TIMER1 0x00020000 // Timer module 1 +#define SYSCTL_SET1_TIMER0 0x00010000 // Timer module 0 +#define SYSCTL_SET1_I2C1 0x00002000 // I2C module 1 +#define SYSCTL_SET1_I2C0 0x00001000 // I2C module 0 +#define SYSCTL_SET1_I2C 0x00001000 // I2C module +#define SYSCTL_SET1_QEI1 0x00000200 // QEI module 1 +#define SYSCTL_SET1_QEI 0x00000100 // QEI module +#define SYSCTL_SET1_QEI0 0x00000100 // QEI module 0 +#define SYSCTL_SET1_SSI1 0x00000020 // SSI module 1 +#define SYSCTL_SET1_SSI0 0x00000010 // SSI module 0 +#define SYSCTL_SET1_SSI 0x00000010 // SSI module +#define SYSCTL_SET1_UART2 0x00000004 // UART module 2 +#define SYSCTL_SET1_UART1 0x00000002 // UART module 1 +#define SYSCTL_SET1_UART0 0x00000001 // UART module 0 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_SRCR2, +// SYSCTL_RCGC2, SYSCTL_SCGC2, and SYSCTL_DCGC2 registers. +// +//***************************************************************************** +#define SYSCTL_SET2_ETH 0x50000000 // ETH module +#define SYSCTL_SET2_GPIOH 0x00000080 // GPIO H module +#define SYSCTL_SET2_GPIOG 0x00000040 // GPIO G module +#define SYSCTL_SET2_GPIOF 0x00000020 // GPIO F module +#define SYSCTL_SET2_GPIOE 0x00000010 // GPIO E module +#define SYSCTL_SET2_GPIOD 0x00000008 // GPIO D module +#define SYSCTL_SET2_GPIOC 0x00000004 // GPIO C module +#define SYSCTL_SET2_GPIOB 0x00000002 // GPIO B module +#define SYSCTL_SET2_GPIOA 0x00000001 // GIPO A module + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_RIS, +// SYSCTL_IMC, and SYSCTL_IMS registers. +// +//***************************************************************************** +#define SYSCTL_INT_PLL_LOCK 0x00000040 // PLL lock interrupt +#define SYSCTL_INT_CUR_LIMIT 0x00000020 // Current limit interrupt +#define SYSCTL_INT_IOSC_FAIL 0x00000010 // Internal oscillator failure int +#define SYSCTL_INT_MOSC_FAIL 0x00000008 // Main oscillator failure int +#define SYSCTL_INT_POR 0x00000004 // Power on reset interrupt +#define SYSCTL_INT_BOR 0x00000002 // Brown out interrupt +#define SYSCTL_INT_PLL_FAIL 0x00000001 // PLL failure interrupt + +#endif + +#endif // __HW_SYSCTL_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_types.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_types.h new file mode 100644 index 00000000..c62428aa --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_types.h @@ -0,0 +1,185 @@ +//***************************************************************************** +// +// hw_types.h - Common types and macros. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_TYPES_H__ +#define __HW_TYPES_H__ + +//***************************************************************************** +// +// Define a boolean type, and values for true and false. +// +//***************************************************************************** +typedef unsigned char tBoolean; + +#ifndef true +#define true 1 +#endif + +#ifndef false +#define false 0 +#endif + +//***************************************************************************** +// +// Macros for hardware access, both direct and via the bit-band region. +// +//***************************************************************************** +#define HWREG(x) \ + (*((volatile unsigned long *)(x))) +#define HWREGH(x) \ + (*((volatile unsigned short *)(x))) +#define HWREGB(x) \ + (*((volatile unsigned char *)(x))) +#define HWREGBITW(x, b) \ + HWREG(((unsigned long)(x) & 0xF0000000) | 0x02000000 | \ + (((unsigned long)(x) & 0x000FFFFF) << 5) | ((b) << 2)) +#define HWREGBITH(x, b) \ + HWREGH(((unsigned long)(x) & 0xF0000000) | 0x02000000 | \ + (((unsigned long)(x) & 0x000FFFFF) << 5) | ((b) << 2)) +#define HWREGBITB(x, b) \ + HWREGB(((unsigned long)(x) & 0xF0000000) | 0x02000000 | \ + (((unsigned long)(x) & 0x000FFFFF) << 5) | ((b) << 2)) + +//***************************************************************************** +// +// Helper Macros for determining silicon revisions, etc. +// +// These macros will be used by Driverlib at "run-time" to create necessary +// conditional code blocks that will allow a single version of the Driverlib +// "binary" code to support multiple(all) Stellaris silicon revisions. +// +// It is expected that these macros will be used inside of a standard 'C' +// conditional block of code, e.g. +// +// if(CLASS_IS_SANDSTORM) +// { +// do some Sandstorm-class specific code here. +// } +// +// By default, these macros will be defined as run-time checks of the +// appropriate register(s) to allow creation of run-time conditional code +// blocks for a common DriverLib across the entire Stellaris family. +// +// However, if code-space optimization is required, these macros can be "hard- +// coded" for a specific version of Stellaris silicon. Many compilers will +// then detect the "hard-coded" conditionals, and appropriately optimize the +// code blocks, eliminating any "unreachable" code. This would result in +// a smaller Driverlib, thus producing a smaller final application size, but +// at the cost of limiting the Driverlib binary to a specific Stellaris +// silicon revision. +// +//***************************************************************************** +#ifndef CLASS_IS_SANDSTORM +#define CLASS_IS_SANDSTORM \ + (((HWREG(SYSCTL_DID0) & SYSCTL_DID0_VER_M) == SYSCTL_DID0_VER_0) || \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_VER_M | SYSCTL_DID0_CLASS_M)) == \ + (SYSCTL_DID0_VER_1 | SYSCTL_DID0_CLASS_SANDSTORM))) +#endif + +#ifndef CLASS_IS_FURY +#define CLASS_IS_FURY \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_VER_M | SYSCTL_DID0_CLASS_M)) == \ + (SYSCTL_DID0_VER_1 | SYSCTL_DID0_CLASS_FURY)) +#endif + +#ifndef CLASS_IS_DUSTDEVIL +#define CLASS_IS_DUSTDEVIL \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_VER_M | SYSCTL_DID0_CLASS_M)) == \ + (SYSCTL_DID0_VER_1 | SYSCTL_DID0_CLASS_DUSTDEVIL)) +#endif + +#ifndef CLASS_IS_TEMPEST +#define CLASS_IS_TEMPEST \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_VER_M | SYSCTL_DID0_CLASS_M)) == \ + (SYSCTL_DID0_VER_1 | SYSCTL_DID0_CLASS_TEMPEST)) +#endif + +#ifndef REVISION_IS_A0 +#define REVISION_IS_A0 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVA | SYSCTL_DID0_MIN_0)) +#endif + +#ifndef REVISION_IS_A1 +#define REVISION_IS_A1 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVA | SYSCTL_DID0_MIN_0)) +#endif + +#ifndef REVISION_IS_A2 +#define REVISION_IS_A2 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVA | SYSCTL_DID0_MIN_2)) +#endif + +#ifndef REVISION_IS_B0 +#define REVISION_IS_B0 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVB | SYSCTL_DID0_MIN_0)) +#endif + +#ifndef REVISION_IS_B1 +#define REVISION_IS_B1 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVB | SYSCTL_DID0_MIN_1)) +#endif + +#ifndef REVISION_IS_C0 +#define REVISION_IS_C0 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVC | SYSCTL_DID0_MIN_0)) +#endif + +#ifndef REVISION_IS_C1 +#define REVISION_IS_C1 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVC | SYSCTL_DID0_MIN_1)) +#endif + +#ifndef REVISION_IS_C2 +#define REVISION_IS_C2 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVC | SYSCTL_DID0_MIN_2)) +#endif + +#ifndef REVISION_IS_C3 +#define REVISION_IS_C3 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVC | SYSCTL_DID0_MIN_3)) +#endif + +//***************************************************************************** +// +// Deprecated silicon class and revision detection macros. +// +//***************************************************************************** +#ifndef DEPRECATED +#define DEVICE_IS_SANDSTORM CLASS_IS_SANDSTORM +#define DEVICE_IS_FURY CLASS_IS_FURY +#define DEVICE_IS_REVA2 REVISION_IS_A2 +#define DEVICE_IS_REVC1 REVISION_IS_C1 +#define DEVICE_IS_REVC2 REVISION_IS_C2 +#endif + +#endif // __HW_TYPES_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_uart.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_uart.h new file mode 100644 index 00000000..b6613861 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/lib/inc/hw_uart.h @@ -0,0 +1,458 @@ +//***************************************************************************** +// +// hw_uart.h - Macros and defines used when accessing the UART hardware. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_UART_H__ +#define __HW_UART_H__ + +//***************************************************************************** +// +// The following are defines for the UART register offsets. +// +//***************************************************************************** +#define UART_O_DR 0x00000000 // UART Data +#define UART_O_RSR 0x00000004 // UART Receive Status/Error Clear +#define UART_O_ECR 0x00000004 // UART Receive Status/Error Clear +#define UART_O_FR 0x00000018 // UART Flag +#define UART_O_ILPR 0x00000020 // UART IrDA Low-Power Register +#define UART_O_IBRD 0x00000024 // UART Integer Baud-Rate Divisor +#define UART_O_FBRD 0x00000028 // UART Fractional Baud-Rate + // Divisor +#define UART_O_LCRH 0x0000002C // UART Line Control +#define UART_O_CTL 0x00000030 // UART Control +#define UART_O_IFLS 0x00000034 // UART Interrupt FIFO Level Select +#define UART_O_IM 0x00000038 // UART Interrupt Mask +#define UART_O_RIS 0x0000003C // UART Raw Interrupt Status +#define UART_O_MIS 0x00000040 // UART Masked Interrupt Status +#define UART_O_ICR 0x00000044 // UART Interrupt Clear +#define UART_O_DMACTL 0x00000048 // UART DMA Control +#define UART_O_LCTL 0x00000090 // UART LIN Control +#define UART_O_LSS 0x00000094 // UART LIN Snap Shot +#define UART_O_LTIM 0x00000098 // UART LIN Timer + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_DR register. +// +//***************************************************************************** +#define UART_DR_OE 0x00000800 // UART Overrun Error +#define UART_DR_BE 0x00000400 // UART Break Error +#define UART_DR_PE 0x00000200 // UART Parity Error +#define UART_DR_FE 0x00000100 // UART Framing Error +#define UART_DR_DATA_M 0x000000FF // Data Transmitted or Received +#define UART_DR_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_RSR register. +// +//***************************************************************************** +#define UART_RSR_OE 0x00000008 // UART Overrun Error +#define UART_RSR_BE 0x00000004 // UART Break Error +#define UART_RSR_PE 0x00000002 // UART Parity Error +#define UART_RSR_FE 0x00000001 // UART Framing Error + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_ECR register. +// +//***************************************************************************** +#define UART_ECR_DATA_M 0x000000FF // Error Clear +#define UART_ECR_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_FR register. +// +//***************************************************************************** +#define UART_FR_RI 0x00000100 // Ring Indicator +#define UART_FR_TXFE 0x00000080 // UART Transmit FIFO Empty +#define UART_FR_RXFF 0x00000040 // UART Receive FIFO Full +#define UART_FR_TXFF 0x00000020 // UART Transmit FIFO Full +#define UART_FR_RXFE 0x00000010 // UART Receive FIFO Empty +#define UART_FR_BUSY 0x00000008 // UART Busy +#define UART_FR_DCD 0x00000004 // Data Carrier Detect +#define UART_FR_DSR 0x00000002 // Data Set Ready +#define UART_FR_CTS 0x00000001 // Clear To Send + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_ILPR register. +// +//***************************************************************************** +#define UART_ILPR_ILPDVSR_M 0x000000FF // IrDA Low-Power Divisor +#define UART_ILPR_ILPDVSR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_IBRD register. +// +//***************************************************************************** +#define UART_IBRD_DIVINT_M 0x0000FFFF // Integer Baud-Rate Divisor +#define UART_IBRD_DIVINT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_FBRD register. +// +//***************************************************************************** +#define UART_FBRD_DIVFRAC_M 0x0000003F // Fractional Baud-Rate Divisor +#define UART_FBRD_DIVFRAC_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_LCRH register. +// +//***************************************************************************** +#define UART_LCRH_SPS 0x00000080 // UART Stick Parity Select +#define UART_LCRH_WLEN_M 0x00000060 // UART Word Length +#define UART_LCRH_WLEN_5 0x00000000 // 5 bits (default) +#define UART_LCRH_WLEN_6 0x00000020 // 6 bits +#define UART_LCRH_WLEN_7 0x00000040 // 7 bits +#define UART_LCRH_WLEN_8 0x00000060 // 8 bits +#define UART_LCRH_FEN 0x00000010 // UART Enable FIFOs +#define UART_LCRH_STP2 0x00000008 // UART Two Stop Bits Select +#define UART_LCRH_EPS 0x00000004 // UART Even Parity Select +#define UART_LCRH_PEN 0x00000002 // UART Parity Enable +#define UART_LCRH_BRK 0x00000001 // UART Send Break + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_CTL register. +// +//***************************************************************************** +#define UART_CTL_CTSEN 0x00008000 // Enable Clear To Send +#define UART_CTL_RTSEN 0x00004000 // Enable Request to Send +#define UART_CTL_RTS 0x00000800 // Request to Send +#define UART_CTL_DTR 0x00000400 // Data Terminal Ready +#define UART_CTL_RXE 0x00000200 // UART Receive Enable +#define UART_CTL_TXE 0x00000100 // UART Transmit Enable +#define UART_CTL_LBE 0x00000080 // UART Loop Back Enable +#define UART_CTL_LIN 0x00000040 // LIN Mode Enable +#define UART_CTL_HSE 0x00000020 // High-Speed Enable +#define UART_CTL_EOT 0x00000010 // End of Transmission +#define UART_CTL_SMART 0x00000008 // ISO 7816 Smart Card Support +#define UART_CTL_SIRLP 0x00000004 // UART SIR Low-Power Mode +#define UART_CTL_SIREN 0x00000002 // UART SIR Enable +#define UART_CTL_UARTEN 0x00000001 // UART Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_IFLS register. +// +//***************************************************************************** +#define UART_IFLS_RX_M 0x00000038 // UART Receive Interrupt FIFO + // Level Select +#define UART_IFLS_RX1_8 0x00000000 // RX FIFO >= 1/8 full +#define UART_IFLS_RX2_8 0x00000008 // RX FIFO >= 1/4 full +#define UART_IFLS_RX4_8 0x00000010 // RX FIFO >= 1/2 full (default) +#define UART_IFLS_RX6_8 0x00000018 // RX FIFO >= 3/4 full +#define UART_IFLS_RX7_8 0x00000020 // RX FIFO >= 7/8 full +#define UART_IFLS_TX_M 0x00000007 // UART Transmit Interrupt FIFO + // Level Select +#define UART_IFLS_TX1_8 0x00000000 // TX FIFO <= 1/8 full +#define UART_IFLS_TX2_8 0x00000001 // TX FIFO <= 1/4 full +#define UART_IFLS_TX4_8 0x00000002 // TX FIFO <= 1/2 full (default) +#define UART_IFLS_TX6_8 0x00000003 // TX FIFO <= 3/4 full +#define UART_IFLS_TX7_8 0x00000004 // TX FIFO <= 7/8 full + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_IM register. +// +//***************************************************************************** +#define UART_IM_LME5IM 0x00008000 // LIN Mode Edge 5 Interrupt Mask +#define UART_IM_LME1IM 0x00004000 // LIN Mode Edge 1 Interrupt Mask +#define UART_IM_LMSBIM 0x00002000 // LIN Mode Sync Break Interrupt + // Mask +#define UART_IM_OEIM 0x00000400 // UART Overrun Error Interrupt + // Mask +#define UART_IM_BEIM 0x00000200 // UART Break Error Interrupt Mask +#define UART_IM_PEIM 0x00000100 // UART Parity Error Interrupt Mask +#define UART_IM_FEIM 0x00000080 // UART Framing Error Interrupt + // Mask +#define UART_IM_RTIM 0x00000040 // UART Receive Time-Out Interrupt + // Mask +#define UART_IM_TXIM 0x00000020 // UART Transmit Interrupt Mask +#define UART_IM_RXIM 0x00000010 // UART Receive Interrupt Mask +#define UART_IM_DSRMIM 0x00000008 // UART Data Set Ready Modem + // Interrupt Mask +#define UART_IM_DCDMIM 0x00000004 // UART Data Carrier Detect Modem + // Interrupt Mask +#define UART_IM_CTSMIM 0x00000002 // UART Clear to Send Modem + // Interrupt Mask +#define UART_IM_RIMIM 0x00000001 // UART Ring Indicator Modem + // Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_RIS register. +// +//***************************************************************************** +#define UART_RIS_LME5RIS 0x00008000 // LIN Mode Edge 5 Raw Interrupt + // Status +#define UART_RIS_LME1RIS 0x00004000 // LIN Mode Edge 1 Raw Interrupt + // Status +#define UART_RIS_LMSBRIS 0x00002000 // LIN Mode Sync Break Raw + // Interrupt Status +#define UART_RIS_OERIS 0x00000400 // UART Overrun Error Raw Interrupt + // Status +#define UART_RIS_BERIS 0x00000200 // UART Break Error Raw Interrupt + // Status +#define UART_RIS_PERIS 0x00000100 // UART Parity Error Raw Interrupt + // Status +#define UART_RIS_FERIS 0x00000080 // UART Framing Error Raw Interrupt + // Status +#define UART_RIS_RTRIS 0x00000040 // UART Receive Time-Out Raw + // Interrupt Status +#define UART_RIS_TXRIS 0x00000020 // UART Transmit Raw Interrupt + // Status +#define UART_RIS_RXRIS 0x00000010 // UART Receive Raw Interrupt + // Status +#define UART_RIS_DSRRIS 0x00000008 // UART Data Set Ready Modem Raw + // Interrupt Status +#define UART_RIS_DCDRIS 0x00000004 // UART Data Carrier Detect Modem + // Raw Interrupt Status +#define UART_RIS_CTSRIS 0x00000002 // UART Clear to Send Modem Raw + // Interrupt Status +#define UART_RIS_RIRIS 0x00000001 // UART Ring Indicator Modem Raw + // Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_MIS register. +// +//***************************************************************************** +#define UART_MIS_LME5MIS 0x00008000 // LIN Mode Edge 5 Masked Interrupt + // Status +#define UART_MIS_LME1MIS 0x00004000 // LIN Mode Edge 1 Masked Interrupt + // Status +#define UART_MIS_LMSBMIS 0x00002000 // LIN Mode Sync Break Masked + // Interrupt Status +#define UART_MIS_OEMIS 0x00000400 // UART Overrun Error Masked + // Interrupt Status +#define UART_MIS_BEMIS 0x00000200 // UART Break Error Masked + // Interrupt Status +#define UART_MIS_PEMIS 0x00000100 // UART Parity Error Masked + // Interrupt Status +#define UART_MIS_FEMIS 0x00000080 // UART Framing Error Masked + // Interrupt Status +#define UART_MIS_RTMIS 0x00000040 // UART Receive Time-Out Masked + // Interrupt Status +#define UART_MIS_TXMIS 0x00000020 // UART Transmit Masked Interrupt + // Status +#define UART_MIS_RXMIS 0x00000010 // UART Receive Masked Interrupt + // Status +#define UART_MIS_DSRMIS 0x00000008 // UART Data Set Ready Modem Masked + // Interrupt Status +#define UART_MIS_DCDMIS 0x00000004 // UART Data Carrier Detect Modem + // Masked Interrupt Status +#define UART_MIS_CTSMIS 0x00000002 // UART Clear to Send Modem Masked + // Interrupt Status +#define UART_MIS_RIMIS 0x00000001 // UART Ring Indicator Modem Masked + // Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_ICR register. +// +//***************************************************************************** +#define UART_ICR_LME5MIC 0x00008000 // LIN Mode Edge 5 Interrupt Clear +#define UART_ICR_LME1MIC 0x00004000 // LIN Mode Edge 1 Interrupt Clear +#define UART_ICR_LMSBMIC 0x00002000 // LIN Mode Sync Break Interrupt + // Clear +#define UART_ICR_OEIC 0x00000400 // Overrun Error Interrupt Clear +#define UART_ICR_BEIC 0x00000200 // Break Error Interrupt Clear +#define UART_ICR_PEIC 0x00000100 // Parity Error Interrupt Clear +#define UART_ICR_FEIC 0x00000080 // Framing Error Interrupt Clear +#define UART_ICR_RTIC 0x00000040 // Receive Time-Out Interrupt Clear +#define UART_ICR_TXIC 0x00000020 // Transmit Interrupt Clear +#define UART_ICR_RXIC 0x00000010 // Receive Interrupt Clear +#define UART_ICR_DSRMIC 0x00000008 // UART Data Set Ready Modem + // Interrupt Clear +#define UART_ICR_DCDMIC 0x00000004 // UART Data Carrier Detect Modem + // Interrupt Clear +#define UART_ICR_CTSMIC 0x00000002 // UART Clear to Send Modem + // Interrupt Clear +#define UART_ICR_RIMIC 0x00000001 // UART Ring Indicator Modem + // Interrupt Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_DMACTL register. +// +//***************************************************************************** +#define UART_DMACTL_DMAERR 0x00000004 // DMA on Error +#define UART_DMACTL_TXDMAE 0x00000002 // Transmit DMA Enable +#define UART_DMACTL_RXDMAE 0x00000001 // Receive DMA Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_LCTL register. +// +//***************************************************************************** +#define UART_LCTL_BLEN_M 0x00000030 // Sync Break Length +#define UART_LCTL_BLEN_13T 0x00000000 // Sync break length is 13T bits + // (default) +#define UART_LCTL_BLEN_14T 0x00000010 // Sync break length is 14T bits +#define UART_LCTL_BLEN_15T 0x00000020 // Sync break length is 15T bits +#define UART_LCTL_BLEN_16T 0x00000030 // Sync break length is 16T bits +#define UART_LCTL_MASTER 0x00000001 // LIN Master Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_LSS register. +// +//***************************************************************************** +#define UART_LSS_TSS_M 0x0000FFFF // Timer Snap Shot +#define UART_LSS_TSS_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_LTIM register. +// +//***************************************************************************** +#define UART_LTIM_TIMER_M 0x0000FFFF // Timer Value +#define UART_LTIM_TIMER_S 0 + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the UART register offsets. +// +//***************************************************************************** +#define UART_O_LCR_H 0x0000002C // Line Control Register, HIGH byte +#define UART_O_PeriphID4 0x00000FD0 +#define UART_O_PeriphID5 0x00000FD4 +#define UART_O_PeriphID6 0x00000FD8 +#define UART_O_PeriphID7 0x00000FDC +#define UART_O_PeriphID0 0x00000FE0 +#define UART_O_PeriphID1 0x00000FE4 +#define UART_O_PeriphID2 0x00000FE8 +#define UART_O_PeriphID3 0x00000FEC +#define UART_O_PCellID0 0x00000FF0 +#define UART_O_PCellID1 0x00000FF4 +#define UART_O_PCellID2 0x00000FF8 +#define UART_O_PCellID3 0x00000FFC + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the UART_O_DR +// register. +// +//***************************************************************************** +#define UART_DR_DATA_MASK 0x000000FF // UART data + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the UART_O_IBRD +// register. +// +//***************************************************************************** +#define UART_IBRD_DIVINT_MASK 0x0000FFFF // Integer baud-rate divisor + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the UART_O_FBRD +// register. +// +//***************************************************************************** +#define UART_FBRD_DIVFRAC_MASK 0x0000003F // Fractional baud-rate divisor + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the UART_O_LCR_H +// register. +// +//***************************************************************************** +#define UART_LCR_H_SPS 0x00000080 // Stick Parity Select +#define UART_LCR_H_WLEN 0x00000060 // Word length +#define UART_LCR_H_WLEN_5 0x00000000 // 5 bit data +#define UART_LCR_H_WLEN_6 0x00000020 // 6 bit data +#define UART_LCR_H_WLEN_7 0x00000040 // 7 bit data +#define UART_LCR_H_WLEN_8 0x00000060 // 8 bit data +#define UART_LCR_H_FEN 0x00000010 // Enable FIFO +#define UART_LCR_H_STP2 0x00000008 // Two Stop Bits Select +#define UART_LCR_H_EPS 0x00000004 // Even Parity Select +#define UART_LCR_H_PEN 0x00000002 // Parity Enable +#define UART_LCR_H_BRK 0x00000001 // Send Break + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the UART_O_IFLS +// register. +// +//***************************************************************************** +#define UART_IFLS_RX_MASK 0x00000038 // RX FIFO level mask +#define UART_IFLS_TX_MASK 0x00000007 // TX FIFO level mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the UART_O_ICR +// register. +// +//***************************************************************************** +#define UART_RSR_ANY (UART_RSR_OE | UART_RSR_BE | UART_RSR_PE | \ + UART_RSR_FE) + +//***************************************************************************** +// +// The following are deprecated defines for the Reset Values for UART +// Registers. +// +//***************************************************************************** +#define UART_RV_CTL 0x00000300 +#define UART_RV_PCellID1 0x000000F0 +#define UART_RV_PCellID3 0x000000B1 +#define UART_RV_FR 0x00000090 +#define UART_RV_PeriphID2 0x00000018 +#define UART_RV_IFLS 0x00000012 +#define UART_RV_PeriphID0 0x00000011 +#define UART_RV_PCellID0 0x0000000D +#define UART_RV_PCellID2 0x00000005 +#define UART_RV_PeriphID3 0x00000001 +#define UART_RV_PeriphID4 0x00000000 +#define UART_RV_LCR_H 0x00000000 +#define UART_RV_PeriphID6 0x00000000 +#define UART_RV_DR 0x00000000 +#define UART_RV_RSR 0x00000000 +#define UART_RV_ECR 0x00000000 +#define UART_RV_PeriphID5 0x00000000 +#define UART_RV_RIS 0x00000000 +#define UART_RV_FBRD 0x00000000 +#define UART_RV_IM 0x00000000 +#define UART_RV_MIS 0x00000000 +#define UART_RV_ICR 0x00000000 +#define UART_RV_PeriphID1 0x00000000 +#define UART_RV_PeriphID7 0x00000000 +#define UART_RV_IBRD 0x00000000 + +#endif + +#endif // __HW_UART_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/main.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/main.c new file mode 100644 index 00000000..30ca0280 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/main.c @@ -0,0 +1,100 @@ +/**************************************************************************************** +| Description: bootloader application source file +| File Name: main.c +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "boot.h" /* bootloader generic header */ +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_nvic.h" +#include "inc/hw_sysctl.h" +#include "inc/hw_types.h" +#include "driverlib/sysctl.h" +#include "driverlib/gpio.h" + + +/**************************************************************************************** +* Function prototypes +****************************************************************************************/ +static void Init(void); + + +/**************************************************************************************** +** NAME: main +** PARAMETER: none +** RETURN VALUE: program return code +** DESCRIPTION: This is the entry point for the bootloader application and is called +** by the reset interrupt vector after the C-startup routines executed. +** +****************************************************************************************/ +int main(void) +{ + /* initialize the microcontroller */ + Init(); + /* initialize the bootloader */ + BootInit(); + + /* start the infinite program loop */ + while (1) + { + /* run the bootloader task */ + BootTask(); + } + + /* program should never get here */ + return 0; +} /*** end of main ***/ + + +/**************************************************************************************** +** NAME: Init +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Initializes the microcontroller. The interrupts are disabled, the +** clocks are configured and the flash wait states are configured. +** +****************************************************************************************/ +static void Init(void) +{ + /* set the clocking to run at 50MHz from the PLL */ + SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); +#if (BOOT_COM_UART_ENABLE > 0) + #if (BOOT_COM_UART_CHANNEL_INDEX == 0) + /* enable the and configure UART0 related peripherals and pins */ + SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); + GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); + #endif +#endif +} /*** end of Init ***/ + + +/*********************************** end of main.c *************************************/ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/makefile b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/makefile new file mode 100644 index 00000000..589eae5a --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/makefile @@ -0,0 +1,192 @@ +#**************************************************************************************** +#| Description: Makefile for STM32 using CodeSourcery GNU GCC compiler toolset +#| File Name: makefile +#| +#|--------------------------------------------------------------------------------------- +#| C O P Y R I G H T +#|--------------------------------------------------------------------------------------- +#| Copyright (c) 2012 by Feaser LLC http://www.feaser.com All rights reserved +#| +#|--------------------------------------------------------------------------------------- +#| L I C E N S E +#|--------------------------------------------------------------------------------------- +#| This file is part of OpenBTL. OpenBTL is free software: you can redistribute it and/or +#| modify it under the terms of the GNU General Public License as published by the Free +#| Software Foundation, either version 3 of the License, or (at your option) any later +#| version. +#| +#| OpenBTL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +#| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +#| PURPOSE. See the GNU General Public License for more details. +#| +#| You should have received a copy of the GNU General Public License along with OpenBTL. +#| If not, see . +#| +#**************************************************************************************** +SHELL = sh + +#|---------------------------------------------------------------------------------------| +#| Configure project name | +#|---------------------------------------------------------------------------------------| +PROJ_NAME=openbtl_ek_lm3s6965 + + +#|---------------------------------------------------------------------------------------| +#| Speficy project source files | +#|---------------------------------------------------------------------------------------| +PROJ_FILES= \ +config.h \ +hooks.c \ +main.c \ +./lib/inc/hw_flash.h \ +./lib/inc/hw_gpio.h \ +./lib/inc/hw_ints.h \ +./lib/inc/hw_memmap.h \ +./lib/inc/hw_nvic.h \ +./lib/inc/hw_sysctl.h \ +./lib/inc/hw_types.h \ +./lib/inc/hw_uart.h \ +./lib/driverlib/cpulib.c \ +./lib/driverlib/flashlib.c \ +./lib/driverlib/gpio.h \ +./lib/driverlib/sysctl.c \ +./lib/driverlib/uartlib.h \ +./lib/driverlib/cpulib.h \ +./lib/driverlib/flashlib.h \ +./lib/driverlib/interrupt.c \ +./lib/driverlib/sysctl.h \ +./lib/driverlib/debug.h \ +./lib/driverlib/gpio.c \ +./lib/driverlib/interrupt.h \ +./lib/driverlib/uartlib.c \ +../../../Source/boot.c \ +../../../Source/boot.h \ +../../../Source/com.c \ +../../../Source/com.h \ +../../../Source/xcp.c \ +../../../Source/xcp.h \ +../../../Source/backdoor.c \ +../../../Source/backdoor.h \ +../../../Source/cop.c \ +../../../Source/cop.h \ +../../../Source/assert.c \ +../../../Source/assert.h \ +../../../Source/plausibility.h \ +../../../Source/ARMCM3_LM3S/types.h \ +../../../Source/ARMCM3_LM3S/cpu.c \ +../../../Source/ARMCM3_LM3S/cpu.h \ +../../../Source/ARMCM3_LM3S/uart.c \ +../../../Source/ARMCM3_LM3S/uart.h \ +../../../Source/ARMCM3_LM3S/nvm.c \ +../../../Source/ARMCM3_LM3S/nvm.h \ +../../../Source/ARMCM3_LM3S/timer.c \ +../../../Source/ARMCM3_LM3S/timer.h \ +../../../Source/ARMCM3_LM3S/GCC/flash.c \ +../../../Source/ARMCM3_LM3S/GCC/flash.h \ +../../../Source/ARMCM3_LM3S/GCC/vectors.c \ +../../../Source/ARMCM3_LM3S/GCC/cstart.c + + +#|---------------------------------------------------------------------------------------| +#| Compiler binaries | +#|---------------------------------------------------------------------------------------| +CC = arm-none-eabi-gcc +LN = arm-none-eabi-gcc +OC = arm-none-eabi-objcopy +OD = arm-none-eabi-objdump +AS = arm-none-eabi-as +SZ = arm-none-eabi-size + + +#|---------------------------------------------------------------------------------------| +#| Extract file names | +#|---------------------------------------------------------------------------------------| +PROJ_ASRCS = $(filter %.s,$(foreach file,$(PROJ_FILES),$(notdir $(file)))) +PROJ_CSRCS = $(filter %.c,$(foreach file,$(PROJ_FILES),$(notdir $(file)))) +PROJ_CHDRS = $(filter %.h,$(foreach file,$(PROJ_FILES),$(notdir $(file)))) +PROJ_CCMPL = $(patsubst %.c,%.cpl,$(PROJ_CSRCS)) +PROJ_ACMPL = $(patsubst %.s,%.cpl,$(PROJ_ASRCS)) + + +#|---------------------------------------------------------------------------------------| +#| Set important path variables | +#|---------------------------------------------------------------------------------------| +VPATH = $(foreach path,$(sort $(foreach file,$(PROJ_FILES),$(dir $(file)))) $(subst \,/,$(OBJ_PATH)),$(path) :) +OBJ_PATH = obj +BIN_PATH = bin +INC_PATH = $(patsubst %,-I%,$(sort $(foreach file,$(filter %.h,$(PROJ_FILES)),$(dir $(file))))) +INC_PATH += -I. -I./lib +LIB_PATH = -L../../../Source/ARMCM3_LM3S/GCC/ + + +#|---------------------------------------------------------------------------------------| +#| Options for compiler binaries | +#|---------------------------------------------------------------------------------------| +CFLAGS = -g -D inline= -mthumb -mcpu=cortex-m3 -Os -T memory.x +CFLAGS += -D PACK_STRUCT_END=__attribute\(\(packed\)\) -Wno-main +CFLAGS += -D ALIGN_STRUCT_END=__attribute\(\(aligned\(4\)\)\) +CFLAGS += -ffunction-sections -fdata-sections $(INC_PATH) -D DEBUG -D gcc +CFLAGS += -Wa,-adhlns="$(OBJ_PATH)/$(subst .o,.lst,$@)" +LFLAGS = -nostartfiles -Xlinker -M -Xlinker -Map=$(BIN_PATH)/$(PROJ_NAME).map +LFLAGS += $(LIB_PATH) -Xlinker --no-gc-sections +OFLAGS = -O binary +ODFLAGS = -x +SZFLAGS = -B -d + + +#|---------------------------------------------------------------------------------------| +#| Specify library files | +#|---------------------------------------------------------------------------------------| +LIBS = + + +#|---------------------------------------------------------------------------------------| +#| Define targets | +#|---------------------------------------------------------------------------------------| +AOBJS = $(patsubst %.s,%.o,$(PROJ_ASRCS)) +COBJS = $(patsubst %.c,%.o,$(PROJ_CSRCS)) + + +#|---------------------------------------------------------------------------------------| +#| Make ALL | +#|---------------------------------------------------------------------------------------| +all : $(BIN_PATH)/$(PROJ_NAME).bin + + +$(BIN_PATH)/$(PROJ_NAME).bin : $(BIN_PATH)/$(PROJ_NAME).elf + @$(OC) $< $(OFLAGS) $@ + @$(OD) $(ODFLAGS) $< > $(BIN_PATH)/$(PROJ_NAME).map + @echo +++ Summary of memory consumption: + @$(SZ) $(SZFLAGS) $< + @echo +++ Build complete [$(notdir $@)] + +$(BIN_PATH)/$(PROJ_NAME).elf : $(AOBJS) $(COBJS) + @echo +++ Linking [$(notdir $@)] + @$(LN) $(CFLAGS) -o $@ $(patsubst %.o,$(OBJ_PATH)/%.o,$(^F)) $(LIBS) $(LFLAGS) + + +#|---------------------------------------------------------------------------------------| +#| Compile and assemble | +#|---------------------------------------------------------------------------------------| +$(AOBJS): %.o: %.s $(PROJ_CHDRS) + @echo +++ Assembling [$(notdir $<)] + @$(AS) $(AFLAGS) $< -o $(OBJ_PATH)/$(@F) + +$(COBJS): %.o: %.c $(PROJ_CHDRS) + @echo +++ Compiling [$(notdir $<)] + @$(CC) $(CFLAGS) -c $< -o $(OBJ_PATH)/$(@F) + + +#|---------------------------------------------------------------------------------------| +#| Make CLEAN | +#|---------------------------------------------------------------------------------------| +clean : + @echo +++ Cleaning build environment + @rm -f $(foreach file,$(AOBJS),$(OBJ_PATH)/$(file)) + @rm -f $(foreach file,$(COBJS),$(OBJ_PATH)/$(file)) + @rm -f $(patsubst %.o,%.lst,$(foreach file,$(COBJS),$(OBJ_PATH)/$(file))) + @rm -f $(BIN_PATH)/$(PROJ_NAME).elf $(BIN_PATH)/$(PROJ_NAME).map + @rm -f $(BIN_PATH)/$(PROJ_NAME).bin + @echo +++ Clean complete + + \ No newline at end of file diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/bin/demoprog_ek_lm3s6965.elf b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/bin/demoprog_ek_lm3s6965.elf new file mode 100644 index 0000000000000000000000000000000000000000..fd5db3e6c5d9b7d5631d33c0a8138d83458cd4ea GIT binary patch literal 294121 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⁢f#c5LLu++2`Z=0wm>PPP%w0aF%g_`>)`* zrnP|AbKLNo@$QRU;G26mZZu8_4E&U9`slaZ`kUY3xKai0A}RLU_JwUV+c!f6jw4^d z<;3N}Rfwwymjrzl;<^x*8_%V<%5Yh206yF6YBu#s^Y*&yHr&A2Tk&^P-=Jk#3Vi)_ z)eJpF&mG&=_2T{c>g_eP>$hC1;v)r_zl;Sk7RXp2V}XnXG8V{KAY*}y1u_=MSRiA8 zj0G|l$XFm_fs6$*7RXp2V}XnXG8V{KAY*}y1u_=MSRiA8j0G|l$XFm_fs6$*7RXp2 zV}XnXG8V{KAY*}y1u_=MSRiA8j0G|l$XFm_fs6$*7RXp2V}XnXG8V{KAY*}y1u_=M zSRiA8j0G|l$XFm_fs6$*7RXp2V}XnXG8V{KAY*}y1u_=MSRiA8j0G|l$XFm_fs6$* z7RXp2V}XnXG8V{KAY*}y1u_=MSRiA8j0G|l$XFm_fs6$*7RXp2V}XnXG8V{KAY*}y z1u_=MSRiA8j0G|l$XFm_fs6$*7RXp2V}XnXG8V{KAY*}y1^(+Tz~}Q5hZW=q!$uFw z=U4J;94>sI-B!xw(N6z~Kgv;&hV5q~w0mn?#zQI}gbi zfV4CgGRdM;o+gv@7BpuScsr6BQ$`L%l%Ah%SW`3$F*}HTEOLM{L(Lh7=21@aiPW4O zLK);Vc@*?A`2?9@i0)B2vyqPj(=#;}Q?zC7$VA(%q8(~@E`VGELgaQkFD-c391urRACSmQq9Y zhW41PYne<3@;q5|ax`YBW~hLf+EcWqCU3yIWI0ND4bu;;tI_x)CtbY_!CG9Cp1>Mz z#xnbHfoje|^ZU~@r)a8N?PXAM%usS#Qwy7P#{o1$utDDym2T(0%cm*Zz)3f*mQTa1 z*2zn@j}~+4`Z9x>7&3$E=}Ni}zy-bSNW_Jzl}8xHFiHr=jqF9jDu*-l>as|$E=O52 zzW6lT54{6nPFz3j2aMM{vzQ~Mt7+JaY?G-#uD2?h?JZfBEE;-QAS@VisGh^aRMYit zJ@T#Q7=C)@&~s5QrVwp6GQr5V)P6Rn|QB|vv#Q)0{= z5WQe9qw5X4RxtDiUVF?|6-^Ey%qdMeKx(JbjAgE=Qghg36)2w0@0pJI=2D{ZgC`8v zE7=0Qk}b5l>xh19m1Ktv1NGDa59MC!K;6(nHz0KW#1^t&ztP>p7`W>>XHcDnzYnB| zNT1+;*W0bx*@w^TX-;;L{+-08%eU0_(41J^dnkYZmy_FHHFuhwGPCB%(w3S&Q@0cz znObF=iUi8cX%=W}&RVk0Y|;O%DtkaKte2H!Ek~(0OqNm=_g7^nO`F==QD;ng4;NV{ zZ>XuK1krkvt~g+@C;Mt zgRW@6^`S1*RMQP`@!4fq0l7)qs@>uy$?WgXNpw52c3n+n za#(B5)zdEP{~O6k76#UGrZ(rgZze~$x?3@HeT1v^Ys|fRWSe;yM*eP2wAng&s&y>Q z`Dq%Zz&t8VPWjD&_~bZR&sC0XG>W}3tk^L$g4K|PqhOjuy5aDi87A_Magrnh+PYYeJpLy=j=X=X!m)xn(4 zsqK)pvOy8k9a@!2>DLPw85f!-2UeCW7@&8W6K2-S?58kZuX;IYy)no@bCy6QOO~h} zM2ed;1Xz|C7fm*+#z&Zy(j9Qn6_}hd_TnJ|T9=dhovR{lJ{*kTty#N>I5Q)ep z+MmV0EdEdU<(Kh=VDLFyEAZ%SA=ueG|2_QAK9?S*J%wLx2=5RHmczFZa6Nw|D4dlX zN6g3ZDC;i~{2IEo3vQls)3OuCUrQ40!dL?25ujEDi~(Ti{Qz`neE55Z>9={00R8|j z{J98yDwv|R=Qs(yP| z*1rM>KOrPt|BWPN7QY#~Z^!jE-U<9y3Am6az#d%P40tI4Kg$!~Fs@N}6u(HY$*S$w z!}i=m#G5-n?^L%tf?Kl!%Yje?n4!Q=@xagIiRJsa&Sj*>3Am6az)CO2U5>}yAhiF6 z;8m);&5&n*oB)g2JE0Z;$DasrApyRCJKfCONxJ7;Hbbu>+?w^O1wtJtbiIB?e3tXP z$d3mmEOZSJRzsItaXpNe^lY!d&!qrdkBk2dvesUA{dSarbBN|zo^Zd8%l1X?Wnel> z8JKSQ<<4pB;dOdgksTy)b^n70yHJmGWQ+86<6jtHJ6U#!_!=Id-jnoC^`0T(dw9s9 z7dga;dkL3~djYhX`6b+%lNkWQ3CPlu$uA~3i};72{ zB?Hqfzg$;A;IAU+Or8+m!u1DmaPVIzU^P#;1bkoRlEq(3@GU$&cd0PvjRcy^1PC`# zN?!(%jq?dcA}BrPL>vUdg@Eaa5P7c;AaOr&T0|9&y?*-*aFoyD7RqFa^jfo-^AW;Y zOgWd$zfAY%@?oeFQPml8kU-OjlIJZCIadKj#?PgndBl(EjG<2v!9`7g@pgfe(40Mt zdv0Pjr9u>qRNP~?rlJW*w}I9+1}|(AX5mp#OQp!W9pJWxk3px63pp+XIbXwj`)9$9 zUqiQNfYM$AO7(FzJ;q=%{?a{oy9$qvN9pZlgv_tu1g*Z|o#HnE5&1EMdN#rl&c_MoY*TVpN08>dXWTZbfNY&@xtE6W`I9ffP$j({JaUB3tc~VK& zGtvTRrb<%4s9gkr1zHr9RK6=Lab{+3fvBdj3h7@%%8Jhcc_@ zu=h=P=7#aVCfi+Y<7+@kqUv#t$l^G9R>fV-&}Rdtic_Cg;Tb;7x*R$D%_R3$8&A}) z;o6F~O{eWp{~v2_0;glu|Bv72KKFgkJ*%-VNi$+l%uM!bFle!F*+a67eaRM5$vT!N zM5t_)A|yqUHZ%!I9!Z;|k|-70DAoV{{(SE1+=JRq$!fn}ymGJ}tZ2{YXtR8E66Xq2^4gzd1THLiaiPheChK(be8ZyFT;%$WQEf z*ojBkj-Lp=d@SU{0dAyt!(L&ESQCKwV5F7^zTq+`Vu>08pO#PUSrmvjkFrs(w}!ML zEquOb;4T9>t=jcM-R-D1h<%v${mk=5v44l1*p@=|#BLEM()Y6TIo1?|Y}u9=WWqh# zN#_W37JOQ&eqwK;Egh`C*u~;uO9vYu_F&j3_1DaNlQon*jWiSP(@uJmK-Z8e`?1>Z z)0P%}(XvI)(3Tc`QSgN@=uF(rTD&Co4YUWb4r&j8jjTVX=TB>x?ZQ?*UoPA?ayO7e z$e%)84WBlU+B+#F4fMCfOC^fbI@Y2`z$}K$X{0)EPjgZ|WaD;%FQEYrJj<@hV8U}XYW<}AZ$HOtP=h=u#wgCtmocb3|EHzZxfm9B`?TD+| zQsV2w6_jltW;d7^VBSXF7P)rL12672pKm-Oe>(0KavvpEN+RZ4As^E+^34yivv4jVs?UMP^{lK@;1#l}kU$BG-} z_k9GK-!~q=kv91Xy!>s#OR#HjRxW72{0aN3X<&*$x+l_|#eKe!D2w*$2K@5@xPpHP zjOKEf(H*fgn%WF8q)tP64Z#;2eF*WN!4>?NH4*aNqp&2CWM@FwG ziJy>3W@&CUh8pXTu7`UTbYf&*ywwoe1-=*&Qu}V&qSQpnOb zzM2)5qnvH&Yv?z7kx^P_bRYmvy3861_;HF!W@_)HeH0+mNaEkZjur8n#15B{Cisil z=lD%!$PPui3htUXkZ2R+2($rwDy{ZF*ecau;<=QHGmBZu8GdQC;gEU(X*oiZo!kt8 zzv1N6{?^IO(vn>va-UM}S(V!asgGDXgkErR&uZxup2~{6t8hZwb@BPSBUBj2XRXY; z0>2kNZ5Op4qx~Dn`~1WnfgQV)_I|;~ltpRc1Kgf*rW5@ED^+Zd4E7;a2VjiLBw&eb z2cKr5_Hf$$*b{=5*p09?lNiAthK)=nAY}b9*CUrWlTG-In%92h)1)gjuJrl7ba~w< z+)D6iUTWV=dmbAv%MzOlTl1>LS$6(H9E6GvOh#f$+`NYys>7(ipgTQLZ^{7U)9wVk)sn zYHw2NR<`;t!9mhAgcRA`op`LYAwUe)sLcYdaf6_vdIvgn-p%@(7HRqp%-ikgs zrT%2AfH_#{vzT*gK)W=k3z64mOZ-L$d zX&~WpynR6EGYR*d1=jCt18n5n#usezpWBkLf2HEmqkwbUGC*m!#)8!bUn_OrjVal(=O&O^h{G&(0?Er^C0VAM4}m~up1Js zc1zgd0X|byqT^wC(;t!1YpitUz!aA5td=f-k}XDxFOTaCz6WAH9_~8QMmK+1KkZijP zjQZydE_5A(e==z24PK7%WOq6$8AHWJcldk@zil6xm9K)FZI9&8tZK z0_?(~e2v5-(*L6LZN}UL*=b1C(=Zlr(zgk<9egN7Z8poj#^eIF2WdFmg{@bLdj&d| z&?4p_RoCe_d@rEqkk%u_i#{#%I)U#~_$^d^N8yB~^~B67Lc<*V9f2oQ67{oGAE({2 zGN7}Ou0iN^2OlThtQmaTEyqc>>`z;|<#_3M(^PH=<<_VirM^X4iBMv|E9@GP%X4yT zMD9x`w^rnQm3^%H8TQCdR(9!AkZN-$Mp+1Tb8?+5w{(5@v~-;;H&{2?Qo7FeE!g8# z?jDvdSLGCN@A|vf6rWX({9rW7jLy?$FO0r2};gbS}uz^Sm z;coAsNddOQX83|~ic}8;agfUm7|N9Djbky~r9)nQa|QYt zd|C;$|4?cnR$^7akk$vO^tJfcQCA7|dia7Tn8zwP>UN^tAOZGji4TO0N-bukKGaH4 zYCTdeLQgum4+Xy3$$cntJ4sJApOGF4nhl`sNBS7A3Xp1s?^)7kmc4CRiTR zhJK%aBL1;8ZiGK%2IFtj+Khw2a`0X_u8!T!ry30B7`l@+v>KprX>pU(fd!2h0j4@57}MJ17xb z4dzilqHoe{4HI`-`6uS~NvdNE>rJ)(Ik>+Mz)Z*_NGa+_MR&rNc%0zt#r_d?(zd8= z+9i%lMDzxU;$;Jhw`cq@BgLigxqd!h3PR_d_+tXkhA&~Bf?1G9U?*l%ZmGoA(N2uo z-_e%rmPx!=hGf@=3U&RG9ka^mkCs8GE~>86tvC4j_pR_H?jl(29MTKvZS8o|g8AS& ziQAz+6iy(G1L8g~6Vk}a@w1U1fiK~usQnUE(4pgjn5%SBZx|rGV=LK}h@R_b%YOiL z;Vn_yw8g%33++wH%>wU;a*LXY4E*djN8$Jt=`XPVqN0ouf5yZkj^&w@HEe5^M|>nRUF`$hOMz z8y0R7(#;4qa|O(j4En;SbB?L&BId5J0n|^BzCkF@(Z>lrrZ(i{crngj1=xzPk@FX%ukxG2p#6nZ7j8bvpgFG+ zYG+cVqpgyh$0+q47J4_12P1F*Lz)5i4cOH>VOh9&k}l-m3sC8bQ)4?gw{FuRhHXf7<^jTtMKABrbS4P zH}zT12G-<)whn0p+`l<$1EFqn)CNL5LiP|=9DAZ$0UB&``Y)wzl9!2^M?yns6W1*J3-Yf9OLahZG1wO-E|F&icXorxRz+Eon z)%9yWu%2Brq^(#l+E>zqe zW(&W^Bgd(r84TLfNX6j((os(dwI+O8;8Q|vr_`I7YvGVt4O-Q^@nizr)iCafUB&h* z9AXPkg-`E_78UzR+AlLtwf9o05Rvu3OkR&a3i}H8XH#Uff+uK?;uucg)u)DW`fF8=u= zOXm%;OsS&q&ozW@Rd|fKof2!!tFV8iuRb~%HGZPTT6lcr;X;A$qGP8y2Upx!$sfI% zf*+d%*yYq0V;&*ytVx003Mm`x1PpCLUoxY!6zoaCu!$!SZ~;gLByP9wbv`~qq$p++CkIIJ2~Scw^` zLFfffV;Z5$jiDoZ9IknR|A-m`nCo)UDAPddQjE|%)gZJ561GsR`GJ8?jG<#LQeEK7 zV#K5xpNK|h)mTO7->O0A5>MlEW>>~<=s1To2Kb)T*vLwj@v{LJss=;@#jp*UhmkUXDT@Jy>OLyEt>IJMM@4rCY}H*Ny0c(oPQDqX4q~hVnIDj({nDBJ zX}>uQN11zkzBRyhqrO~koff@4!3?_zf8RoAl1T_KP{eGpDITj}j@rM>B0jD&LkMJ*YP z^_Q!+DVl9rW;@p!qIMuHg1ZWi30j%CQo@%A4V${G%!}5r-SYrFsKSN!Q-b?D4lEP- zT+AAr{rtWMa19qZrVPNAZil${Uw;4|Dhp5n$CPI56-y1pi%q~KHS+EQo=)U0<)6Q> zIPL)QY%$<(F~m+oD%uEBO%8tx@ipKIUN113ZE4mo4%V$zU`~J;`i+@3WpobAm=9<+ zqlxE_1Lk>}n@uj{4gkv0>y11%`hJDJ_3D>Vd5n= zz<6#f2NS%x%-{n<&S0eL;O*>qACT8pfsYgTgCS@$(lB@*aKIl3oI@bS=mg?RAzOe- zz7NMwxc2}VD>pbw8bUvXFIIY2NwXKR^RVOOTDG*rO?#Zm5(1=!%@r(jLtGw0tPfJj zo3O+9J;8=Tr~{u0H1-6-<`_$oV+=`8AawwUFBxb_as)UUKIHKgx6%E00tT>SNb}*o z(?RbS=thNZCln9M5SDg7o&$q>iGw~a&@=GG%08)fp_?U_-lT5D1tVxVNY&te+fla) zwWUJS2z?)qBmuS>X%O6J9rS&H&Qho$^sF(2eT(!A+?C>qvxmgbQ7&w%vY#x(`wft3 zf)sx%3LfyBiVz>R)IwJjxqb?7M0gX0cLVfMq^Stibnqque~R$18Owr>!G#ZCRVQP- z3HLAu9V5`M;ETn3_5`xvrl}OH13gQuY(r8fAzg*gdPiR(@CNWDy~lbj6T3UGIRLEUl$3(cR@an7Hnq(L zs2@Z65{iAGsi%h8{F4vIN6%JcN&w%{5L;xb&zFMW0*CKNd^YiTFNngEO)-G7k$S+p z*8wLJcpqGP>qg8acaYGF{TB7Ka|^N!v|V&@fpjshbUPG}pXk}Yw=e?!;pV$Y3jI`| zXW-LYIG-BE3bjIk;-vG%nne^SghM4tO@XxOIAs8^*@+aA16xb@RHTrfB7-OrV^*=b z8{^S0(4Iz`0rwe4Z7kGhNR`J1)P7s3eWXGBW;JNXkobgsRqGY~L7^tMhAmr4?R41K zQl&`6{cCP1Qj6r`$^xO=9es_^2P^zJ!uKh>7@#*G%|vLXgYOgg8p2~tSvLQ-ev<{* zD5PC*zv!Uf3iO0R4@>J=L)a5Yp*Gn54qC{vfNAhS^)^E5TeA|d%o%t}8SX0rUUlmW zv=4mRQfg09>Si|b{nn5+0ckDVIgWb2P~Rc-a|JTjld$!%j|U_k(^g8+hIM<&8p`A$ zT?6;yPU^XbCgXiQzu%sChzt+ELZcBQ@51N9r*>K$Dt< z^d&-91iktn6S^Nqys%sz9FtRC3Xgy>raKE=G+;=ZfK&tSj*ePXdh%_gN}<)hOQ|Q= zBDDjCv>ixu;GXBGwT1c|sWJqu9hi?8pIyhLd0c?NL~{)b-z8x3K>r!(DB*H6=^}LB zZGihaW2^gpos!%Eyho{v58!pfIFemm-~oIr>(|;){8uEI!Qj)UIP_M5^f~%w;i>`| z1b+o!Vdm95-xrAYscp>=fMoidpUWG zK1Wl=QewUd(>rD0*ckW>X2^74CV!g6$Y3YZA%K!_xrJ~Z$l7O;jfbP-w?32iVMx=B8wYe}db(1oOYYU93Uyje)@0KCQr zPA<~D0Br*?L25lfh)dy1ct?RXk;N;pljQlMK@#5w8<(sDh`@BmkDya(C(>^S(N?(` z0x#JCaQE&U?~R(LP*0$T{|kc#MEUryGM*Af2QuPKQU;(WjUlYmgFfFxxcQjALQe{G zg+iZWS+4UN!qy=}x%cCA1_po)hQ;gcdf<>A_8oL$C;~i?jftB6R!)PEr2Eu!E$aeTvm1zFHyd z1VM{OcYMXaL0G^Q;1h6RU$LiHfE#KFYBf>C@MjVBMcyzH)GfYZv#B-Y20F;Cu06PW=y)R^{&^OKyJQluO^;?rn|3ilMt4L=d^dhxy6hGlbI^oBfeJsRAL(plY zOn8qt;6?)55Ex^&6Ik6CqB_sTokO^*pjE>nSzU_oAbepy>u9Iat|2y`ABWUA zO5JG;WnM)(0XN=%k4W7q&~RtiH<5a$VT@0Mhf`?x68k3DzSsbBi7}s3aJDfNJC4)~ zL4Kb=516yfD*Qc(gg87c#X!7SLJA&*I|29wq!kSR8H;B1^-Ff!utnL6w_zB7qiFzL zJ{>dT3J5llLmu_6nI~H)2dcq4SnMYJa~pHjKyTcAz#yjj3Z=( z%t2ybGQ|9h^f$chk&%Hafmfj^G^dwn)}txonJqMPw4uhaBmrZnG3FtkZwlPku%YBs z5s+KFE8z=Ek=5QoyBZ6mcg??pjnickOH^NPU5|xS9#U#opL}3J>uSYrWc0)!wPptJ%^s@gfpvEs&1E{kfyglw1S1d%3Dz9yW4a zRT@-mb<$o%;*-*R#YGFePN+Rel?|ZweYE#p0pha~UjjSsVcO4$Z92uLm2uWvh@y3- zu)ThY+}KA(B^Ka%8ljh5WgIILV5)5A~-f_y{gN-+Lz(e4WagjwCj^t!%wWQJM6wuyC`h$A^jNBvn+t!{bm8w z4YDIN4cv1a^bG)Mr`K zrKlHZ?UBBNdyk_o6)L~kpj5T1z(%fHnCqKmbW%Tw)FCIO_RqA7veAAPsUml1sVH@=HK!ocaUmvr z;N~Nvx}mPMEXB?6X{priO?wDiqN)ryA5ba2_hRm}rZZ%oKw1FzuTJVtk=o>>)ILD_ zHA?josnaS|l~sNS!+yy8j%0gc9@Py%9}=mn;nR()c5T}7^uT<38?fzR$IG1P!-5|H z8w1qD0EJ>qeP+5FuQouw)gs)+KzOCgVz*E>z^7TL{U&Ucd`IG6z=qT@mKGQOZ6GrR z>2J6{cT&Cp+wiJ8z0&ytEM0Zjpw{LFsSq%vZ9?LcyKx~v<@i@YsKXWdHJi72zz|jn z2j$6dcW}_=0(}xbEwI}AXt!fcTS)wrN+r=V3XhvYW&%=NFPv|j)F^>o1D{H%-GR19 zjh6UG*f_4-&ALCP2WCp;AN-~Pmw-uuOfRH|;2!Oyei5k`NFB^7 zsJ&mQ%SkO6G<`sO8tDhPH#llZxe1)q$D^uU6*h7mOKRhwSq<8LB;Jbn)KMD?bs(X! z=1)R<={bzh3rM*LmBF}7>)T7J{Xb%}&x|OyAO=FA5sc>OP7|7q~k(>LQ_@ zC-n^TQM+Vcq0VQG-wYbk4kOiqn{Nqeu5Svp1AN-bYEPs+lA9+_;@fD?U>V*L`v`25 z>QiPG2pP)meGHX?J061+l@7>F@3J|bwAuq{pQlt%;<>a}vy5s#4IAxsj-Ey#ISo;| z)e>|!gt|KUMnXSEx*YY@uGG(yZ!GbfVMFc;*5zK6YXhktka{D;PfloQ?-lrD(nU_~ zV@~cqiMQ;{1MUwQEWuyUL}UR=Nc&^!(-o+V~!vX;$Cm5yTlXf^S27;z0ZaOm_nBH3aQMx)$C~9q?WPo5Q7}JuwH+oKKeAN}EoZkU79D z@TAN~?ShPdIR?pyL?=9-q|{pk^e&*n zD{!F<_g)}%;}?OdBuwK0Ufj#LNkMt%?4 zTA-ca3#TiP1sY9T2F5z&I-gRp=6U8iTBlsMLF#v;*Aa@&c#amiBZSA8Ruo)>=M(^I z|2R4`+aEd{q5L$TFJe46$TC%9b* zW1Ya8o?a4<%jBV3lM*HJkKA^EPwt=r^N4 z+kmv3Fgbg56xtiKWy($M&q(w232;BJS;Xz<=gM8YpKpmnf6V~s@(VrlKC|p)m|J)y z+7^nxLQ}hUFaCMOFqj7+X~evq<}{kU8SO+<-ijAeZ&w3Yt7&^y4V zbhSs4?j{zuPz4V+C4=1&X&#~vIE6BPZmH*~AP*{)@iX=w72*O6C7HSuXzG_@bcVna zNZ$jn(}^?{k;GA+NK+BH7BK zHzz>5W;ITQaPui>t^9m}zU8QDe?@8`lS%3ZeU6|ir~{GAXpg!p!?DbyoRC_Lfg{GeKzVfZ zDzFGmS&v6A5c-2~DbsL)&n7(9yiD~Mj3I0a(i*sHV>edl3j#d^Uz|w+a1(Z1Om2}H z&zi-W>*>ZE3c1^muDToZSdOprB@N&sR4U>(g#Cro9qxG!T28Le?^S3cwnZB})%hH@ zH_~Hpzv`fE1p10XJEQ_S8TZ%#8;|rc+}}9pWPzSn=mnPbCBK;f*cPOcV=)1PomlJo zl0fUghq4}E0lxPe!hS{S0CznH{a&D>2~99%S%5^m!~|Hm4YK|F0+}dN6p3;LkJpuA z&9juOWlah&wUOq7K9`a*W~gN!!rvPynPdtD7)UlFuLh;9HFW`Rf%I>L6HHxthgm~U z42_`w`=SgMHunw`NF414(`46DZAr%^j=c^$b{*A@@T4Xce!z*Qb z2#we4WkLhbOQmAX11Shxjd3mR{ z!0kRbZbF&`Y_h3R9$q}*PEQ}CweS`(Cs~L^S_pcFBcWvz%+(ZmK49pWq|Tdh2ui%3 zGS5pHWcw~)3HD*y0+^jh??84UfLhpn0{jlXuu-7wKjVGeqQxooE1rG_ZJ%bbnpqsh z=7K-6MPp4NGCSk#QeYn1h!+Pzw?Qw9&T`FpD}1`Mb``rX?dhzX+V{{N5w*|2#$kis zkuX>4mEQtLkJ*ggc@Jg@Ag}bRaGPHq1L*lk!&wTr_>Z)n0kdo`v4 zARBrKAE$wv-`j|6$rx5~J)y46-u_SNAm;`vLBVijC3!$xLcYPy7^ zRdHDk_jMH4m3pyZ(+!wOisM_#suvrM=oK|zqyU!|HdBCkRB^H9DQ40%Y?i>$;$_T? zpolBM4sR#AX*kD+6Bla~YZkLccZCgMe<9_<&G#}CdY3>~6I#?PXA3@rOUA9}*hr{i zQB#KHd^&83!I7rU7}JZ{>ut~O{!-^<0^7-0)4n}3YJ?@4CY1<1Q`_y}9$2Gas9+5-vOz?w1@;A?4m z!XBZ%fcb*BzGf8chmc-JOFe)LbrjxrGX6Zm#^cA6=?|MAMJAdB0B=CLfT%V5sj|e- zu>(nRn@-@=LbAC|O6wEtDImlI$~) z$r=9Hjiqx#sihS`X=w%nx)W(Uf=@YoOX44eE7(k6G`El*GFQ_v(Ch-I{A*|(ct3MI z&b;}4bv!YPO%&d%EaKCq0yvdl$KeCs;^-J!zNg7+2ba$Ah&dc4@|(r{zBc46M0yb3 zZjSdgdF$cQa*DZ^rrek~&I5?_h#2!BWnzt442{qm*wfJ=c-K@frSZu@AZx%EmI|xg zmbM(*;-qP(!p7mg6KjGOK*Eq2j-iXeXwDm?80>VMFQ}mg+V< zi~yMJX_?Dz$&6-G#(^M5@SSk=jMi2E5?{nJGvW;oj(^Hi*>C3N6km?Zyxmu+>Pt;XdM^ zy9GK~p|`NvPGI&0uu|JG`vrFu>lN^XK)1uE1yuWU+HC>C6B{``+`op6J!m`&Sj;aj zN)1N3VhRquKx%!9$td$i_*72qF0j#5iKOE@0;C;Ax*P6|j#^i!iyT$$7imjLu9x`x zl!`Tt1W@Kxe5$bYBRr@vCQjxO~|CCa( zW(B3Lhzyk>wFl`uLN`0PD`Ws%db(Ea3ulopIOmN7QssiwGvlpQ3w{iG|x3uwq%LzOLSMYEeVKn)mVXz$Y zTtTzQERk7F#~wq8p-7qV4s$Yl2y6pa@Keg{VPq)HE6I9?=4_Z@d93bTg4e*rQ$+kT z&P*YxAI>%q-iq`Zf1Rj zf&FyY$m$9*KF0%H$Yui4GPpl+S$!_0dR?KFS*mkbNCB`FNQdDLTCY^+1bRWCiBv7_ zH-sHPD)S)vj)NALgW?VF#UJN}D=v2hI>SbRa+pgUzc~onIix{w4|3ExLY<}1p3DU| z5C~hd2lpf4e%e7h3UoJo3HLFV&SHO~)b~hz08cf7*6tnbIdd?N;;0V@Gz&fyXc?hT z<7pJY%Iw811b5khSM8?-Iv&3GYZS=7wHS7S^wrf8->gzGtQ$^6Wg+t=(m}ZUIVnBu z{OqLEE;84XIv`S+urV35m{s~s&uYgYHTzv$6CH5cT@Ng)*}!w zX(5Hq1bjR~v~{-)$g%2C!XuOLNv1u^R83j4!FT~_3lQBLtD3Mr(oBvK-Z3C$+63rP zq+bzw%)vVfyu^HDD(^9Ml-Gr7!bV%yWtFA`3~Awi{@-q4smsDMFp9)E;S| zt_~Q|vXK_UT{y<8+G?S0A@vuw!)iI_9wIeK=A8Kv2R0m8-N+;p zprA!0{|1!zZ*Cc&K<3#bf`{uJsHj;i)HQnADgo2smyqmF{g4?!M5=nh9O z8{#JVi|}Og3gLA_CIDC(QrSgbE_DT#1se^9oz(BERniT^o<^&-Vftr685zTLe2bVL@HP@NSD12QcnK=24zMBl~ChChb^T9El4Q1$S?_uX&1OFgH zyN~+f%>%?vHMHjT8Tk1}w#CWy~zKBG}3PaGVNQ>dkcEA+`ZXqzyWE1#` z?6d@)MmmHD9|lp?R|x(!qFNQ;BZi>r2Qgc_80R4Zt@!z8O}KnXfjBdjy627f0L?~1 z3luUH=*Pi=0Xkb~AlZD(s^LixI>sWkgVN6c6_&bHmG&7y^<%Z!eoX8Nw71h?-Hs%Tm9l1pH}&vI0>jMbvui*}l2IeXIXpf>UM!7eHV zt8CdYOK5-2congqgUy{X1>7R$W0q+!K3)YUOYj2H4j@Ld6w>^Ir4(N})uE!|TMAXF z@GyxNg$=n1?Con+ZWE-+e2i%?gmyT&wE}NTx)kzRksIdZ)=PX648!?G^~I(6}X0!VD*_e!ye`(@1eeaQG|6&y>O+!6lnY#P!AvE?}l0tw1&{ z0W92G0|ah^udtk0dk0!0c7#PKiB&)eEM?jfnTwlQpf5n;^Kwehm3+!B1KiiNFbeB? zwUj&fPP*>mgYO9(eAnIz&}GxTk>h3HKn5~eZf=Ac^Z6a=257$sTdz;~{Uu*lxPrF` zl;&8PNts}-pt+DHKlZ8SCYYf`G@q!6C>Dj037RLxXyc11#Lyk)0LAi;xMu*VCs!-2#7FAlD<}~C!*^V%x3e`ejUg@JQ_MEO zo#&{TLM^?*qh`wCz7A~6cT8t{U;>u~A+-%sGlYI}^xGshP~i*N`SE54;e>8O%0;L; z_ChV_Oo^?AFVP)&k zi1wfzN9qXoYDcZ@XNkr*s@e;b+M0EohzChPYx5Zn0C0chs1t>Hz){sct<+Ae??%5N zZ7WjJ6Bs1oD64hdC{#X9rv+BK1#Glz?Q~Ev++e|81-0A}Y<+~fJG##@HWNN=D!p)sp|*riscH`* zHNo%`#b$vPn$$d`83+}@AxZ1JKY#nO|AxZFspCv~x(O;cn@u+XR}t z5>j&T*=AcKb~S7a5DNtej58(KY+vGu3eYQm?(;Q7cp@U2`I|4>D!Gz+MD5m)g^uhYPgy zQ=XLCb!baxy-VU9U_hC#WMuRy(xH)9o(t3a}ydARBT{&`@T@*En6l-P=jc z5oj+`MM~|7PHL{im#Ng7>o&~?^R(aMmVHa&pU@6cXs6hA4bJQ*XumBs&R>P4pLk{kB*7g{aeGSJXQnuyDqD4VP^FmrLY~uPSf9G@(e+Kcu*U;bSzO@;L{A%K16#mGb|(VziEHQ zMpgUDXVJ(~*DEBBMrKY`0q7EI+8~$ve!!LSS7;nSSd9!Gl;bLtw)sy#vb zFmqCykNjy)x4WE*n8Ms%i(<`0J)Z579#;a`!?b^( zSb7{AHu#*EU8eA_ru|Yn;%e81UG#j^mZhD8*zV{^9BIaxh0^G8h9x?720J$x{amRQ ziRxnbw32G)(XLF@#hf1UeF+;<1K20`#Tm+cau$;{a6jRs_K8&S4W5+R4Pm2wo@6J( zd;r_yFsP@0!i)<-S0w;0Th15H_PO8D)!so{+Q-DReZHeD!(1cy)aTJ2QhzIUC)h=O z8OSUUFC*=C$oz>+*zGlQX8gm?cq0SA`&{Pjh5Rsl+6-!Mr`?zvql3ghhn?7q;+@0} zzaY)hlMS^n-kgSPkzX-Q1ov(yy-=XHz^Bq`&!R26;v$JZqf&3PnSO{j#UR7a;k^xa zu|z3PntpI8l)pW zo%}eVw}DUP)gDS)rX)b6eV!BO9w(*t3EEQ94H6IG zs!pZVuE49j1XG!f@U@nd(x-mMcmbjLPX245_aa@6P-;(fa>pgUjB;_NExSqcL_?W& ze_*@-_dX}pJdw?R*iqH~U8&93pGGB`_MlBcDzzCyKt~-V)VlB?moHi9If;g_twE6w(5?xg@SO-CBWeQt0O_``aixVC64hyaV@m2Yp+h zX9-O(H?ROl6J`5W0JIrW@=KVEa`2-9&x8+!_?X-8LZWE_*lZ*|Re8)oF9>ufe0phl zA(024*`yXTtJx|kNs<$(3z2XFNlEsqkdkyGfXji_6NuWTElPQY73!wk#o+BgdIP}L zj@(VipEIjC^BmzblT039JO9M9GH|bP(3t|gatrd6ZlLy!v}LKmSrYF8J28&?;J?Ja z8#biV=-H8Ec0u+m(n`2LaMC*jny1hf++atO%+G+8`wItQx(j=?Jt|QD%kW`JkZtov zl1TyV8YHw!WgrX7Uh#(@F?CbitYhwl3z@3G)K;8g3KwGA0V6N!<28gbZZhRa^@}G{ zjzYLid*pH1WJ>8vV2rhQ` z+lar9_>j4q;v>vDfQ}=;-FntL;A`P$tz#~Wt5E# z5at_+_+D?OimA&dUx(~^Y6YJkIb6TsE}QEe@;z*444fd>Gxg5-^;S?J#y5Y zBl2Y&ZUnV$K2xE3xNDPIHg0Z)KMaYkB2l(Li2)<-iWYn@`87>yhF82%bf5>M_Rqwt zF3&q@oMrXQ%Z(LpFqSn_~1Ynk)HS;q(==H(l;u-fW)^@ z%M8~TE9iP34_kKeiocE?)aaFr%;ui&Bl^BzyI|jx4S$TDAHmZmtR-bg;qPS|bWGpg zqlS$b87;;+a<4ZcJ~7CifEK%)ICwy>j6Ndv^>qd=o&EjcIflXk|kOI!w@7 zW3n#;xlWUHGa$PPf^>H>ONhZ+ikB5AxBRr+>t=dIs&ETn>-+`e=C;cOLUt7daXs%N zLXH&#ab>Q1Df9BvRfiLDpp z7Js;Wb9M1YR4OzBWOKogh{^;)J_=sGwWjyzTeG1Z!=2F|Y8JZD7D@LSB+wk3heDU; z+$@ya7i;cl1qKuI3ceEn{zctVTU{EB+ICqeSF*?nwRIc5SPPI(hRnc%$o^0Y-RnqR z7n;$%haKO{7SFL`(=%**iXEAr+BCBowqUiZuFg!YW`}0k(&_%7mZ~g{a`wd-Gx+}^ zoHi%ps?=&g`qTJR#m1-GVa@yjl{!tSKVvSfV6-=|O9awGGsq2f4z*3SV_9&&9g*&B zpT(`9@p;&^g8!mMn(mH6{CKII9Q)6`SKBiyG`*kK^tr7;c`Eku{yMXd9hG8})63uP z4u%(q-5Y!9ro_?1?LXZx7`5LN1aW)e7D6V)nd)9Wrn}SS&kQYzi)IiFWwu4=^?V_B zY@0C29@azb8Nrn@e^govfykuxV0ZH7EXwnQTyH@BzPO%iSc;+VNyeNaQU3HlTB zpg+4%!>tJoJtti6ZSv>2-h2U#bM9-FDpxK`GIcVUrEg4c+9)t)>z4A z_g(Yf8{gM^_-Ji$p6E_cwSp<-c0k&-4F^i4yp}pg-*jVay(rGt0lq`A4v-^1)Lu^s`3`*#54l-H3S5JEdMOsKQwxoRAwj(q58w;2UC>bgO*eD$yEN z?hN$tK;-xw%>t5DYPiA5aH852f8`;r3-T6c5s8x~9-T|(C7x1TsE~(T1oxh*_SN{+Eng!?I1Q!+dckfj0m46cY zj90?BL@bPn*4;(6FtQnUeJXm$eByn z+tl3w-3ac3X$SZZ>^yZEO&d1`TmFTdEZg}`;Hje zm)CFw4$`?Ey`2*_hjB9OddS+^idR^+(Z&9ya{rdG-m|87T zueEXMQ&U#+;xAh+-~#miI#{`Zffd{Exl~U zGWff}^d84Bo>EF^Mm_w8!q&_14!XyPT;;zUnUP9ZYCR9g1=Q{P{^*8p-8!;ua2nu} z>Gscm2<~NYosBY6y^$Z+Lbvbai`4VZBb9q1@_XQtLt#o}7slbUogJT3%j=Z0iC!E0 zC$u!e^yooXe&nigkj_PyKV?Wb#b)OFg=9UJ}N z|Gs1EC3y6b+?O->&XN5K+RHW2-)A9@#y!ov-@}_1?ploBm9xj;af7X7dj9rBI&0_9 z^l@DtmdZ856Kb)eWTpdBQwV$0L{7fmsR5_{aRl3{lWdQy)@|C^A(L9C)yojySauZ~ z%EGTdJw0TT_?M|6vEH3+)tu(dC#K4wrlK9y%oa<(iTQDw3i)wKZHv#M)FK=gF1ZxZt(j6b0DWL!;d$oag?scVyY}PW32BKVvWvJ*IKNYdbe&Dnwme?HZT2ri2@L zb6souW_}M>ueP6tOv!v>?>6*Jj$y~+e#m!S|JMthe!~Y0E2xXJUvqV7`;N~P4cEi} zGNS*pW4GGa@K$f%) zDenU3Rd41f|GWSfL$;q36xqNCo+!(fvVfCs6vl;&?J92$2{AXu@{K@bcfLsL=v*Qf zAhu_{5i?k=qhoHaHf)!BW6u1FTuj)$;hin>N4Pey{W2eCklQb~_OG4g4Ix2_hPbvb zPmr!&(NIr@J}xlCwR!E|1%|lxu6@coBVLpj*VeV~78v5%x%SrrLtGozF89uD7YTCh zTf3{k5ZAV~X9^5)?OOY&H>q-wAlIg~Zx@7 zm_1csh-<&vc?prxWV6VQ)0xw-E2d$NtxC*iDv$OI0yDxTnuJ?;1H{#I;}wzUp_ps8a;99*By&T# z^E?SI)@pa=$8xDw`*D5`7izV*m!<5iQ0_=9$e}wgS7o(x{JhT*ndah>taiOO++7x$ zInrGpEn(>0{9vxV%GvM=J;EhtcnVx$)y}Zq8370J3-m0<(%1Q6+2i2E=e!~(4#2pA zs{P~=7}rU)Sim|8TSCvH-f0ybB){r826qPX!MPr){ldG7cV}VQ7Slt#F7aeh8v1;1ylQA z$Ze7tj?;vZ=MagWntRgq&P8YIQFNWaxw-tbDc-i^nxl5EH#*0-*X5SS2xg%pgTuEm zX8d30nFdt<#~VUiTa+`6(aBghpyx88yd>0XHQXzj-q9pE}rGF>={Y z`%k2DkU!MW&GK>?PrJxFHta*QE2KS`DgaoJ3})w@i*NRZ29+V}H^9E;0h+Oyt- z*F}O{^3u-rPOS*#mhaZW>mpeb5#0O_!PyKR_9n2%P zxcH;})jNwj;ppg$f8j-5e;|m#Qc`qcwCZFK@%^@FCrG=gz8#xo6SCala0)T+dZ+D+ zDzuHEZ@gXcq7c_RnhjFPxaG689-`o50&zM$a1PgPxk~BGtXa^;51q$cZ{mrf`v!jJ)pcLS9+0iR#s8F}h~g=0l@TeQ;Gj`?q%s)`K<+O>f~2TwJZsKIQE* zQAn=KFOP`4|Aa`G3B<7|A~)Z~13yAz=X<+QK7H2;6NuRC?MWU27v<53+B`x&4qrBh z^)2=pzpu&vG&meEbX4CFBSsJZ$C+Aw!iEz!-j+Q_8@rRK;N~&8I-XsY-;+$w4sSLU z9YglIxuNOf`5+K(pUZC(8=KX`H7r-UvwwOgL~xdSS#o7N-kj1dgUHujgp1f&yn9y4 z#*G?Q<7Qh3pHbFb6*>FkC5U{vRGx$QbHRKMEpc@?US38zbOqVk z*ZlXb?HiK+t|3=yv%9?mW&TkZ*JR@}ThZ|$S7Wp1@sv?l?_9>U*z803Hd1#tFnpDv zjRl6d+!{BN&SrR{RXnR;W9K%(V$|BMTuIG-c`3@9cjg{2$aNMjl4fUPC@vif+bOzt za4|Gad3$q5KL)v1H2UxDl<)DP;dc-Dr&AEuMYFpw;WMw38`*N@GkXNSjHX?icJ0*h zgjXdlb;euST5)e@Mu)42=|6jSicLzXRUdaP>U)<~T+@tGI+qjLNKG;2(N6y89GdL) zSuR{=U%&L^!%P}Bc4x9Yg7Cp+@3^mrc7WWWk1LVcneN09x*Wj;$1FZGqeaPAn}+pk zR`fPR#mwqn!MHe?{mHt?aHrTPHM4s8iuK*hI9L3#8v~czPW7&Yy=fi{w<@MqbmiqD zUiPy~Pgbar8%A@jF8k-D2wY#fGc1?nvP&;Lk>#I~=gM0)@6y{FS)rNbv%PJ`6}32j zdGR*82*Q=JIC-g%Ns+eoTJRz$SHj}N&VNu_NyvQfNgGcEHLqFM#-&8B6u3;4-R%t$ zFU3VK8n_0PoftjkX#`Hz(B)7YA(J1@N{|(C( zq3mPsCP=g&rj@TA?al-pxE!RJqe0z(hf6uxU%aUyub4o%j>Hw4>>_Wjry#^?BHr|# zy20qfsdEh``(>0nJzp8Q$dX;;P5DH1quq~dDcQH;BmMr;ZsGNR?_W#>#7=7Hj<;Mb z$xco9FJwK~`a>z)KY7|Up{e-AZTF}HvgKRbA$aP1=dq<6Bs=u(QS71`IlYmSRTT*SzJlAl%2 zyD65-&@cHzss6}}8NY~tujdz3$nXk;@XToenBUfk-|3CDYkt6@H$82CW7)seV-ss5pBxCf-ULW%`q4dc9$Q?Am z9TfMyrU(hAc=;CxcDiMcwV@1o05ju8-q^IVTiXzC?pc`(xsD9E=h-5oV)Km2?sjl^ zB}%k9fB$f8*@U6(1%`4N`pO%}U$X6vGWf55n26%)HFmSVpbf;;X`;{6U9|1^g198UfJ-L~T- zd#%5r@!FLOwb*Ykr$5g-=x~V^dtPSwBZncb&0?2%hlpKhRR31|SpEd~6XZ{bKQa6X z^Cy-+ar}wrox}wGB=RSTKZWqL;MJ45rgzb*q1Jfx%{>;_WeaMm)|+Y{>54L1^!q)b*F5A>&1(v=eatH{r5%F^IRIm z{+R#Pc~5$BF$M3&7hLYdu5mZcG2)v@52ily-(KhPCH8A?CNbX)-jFRc$vy1LRZHxw zaQ?d<&%^ViH|9(aQLR*9>V@S$)_I7D`1u1v!FhZUyRaQhb5B(Zpf zKYAaA3zFF9;c->s(j#`CHx|ryUE%ITaD@^3Ypf~i^7IdyJoU;)Zl7m`>NRe32T*zl?mM z!c|+Wa1r_E9&wH%&d>9Je=UD(k~r*$&Z#yr2e&w!R0{DSPl`{E@N6aj<1v+~iCD?`J3<&P$^P^d6)qrvHz$_kpvjy3YPDbCDpS zgc3^#u@os%!)pj4;iZHS7?G$&oO9=o#99K#Am})dVL)SuA(S8?#u95OrPQI;T5Bw^ z)DlB1CB#r)YAK1b(#-#QipfVv{MlXC+r0+! z01v&Rcz6Fxz8)VU@#mt8)=f4xlV>-%TeVfQH+_?1e zIAib>j`9m{)AL7G$3r*DKYY8$X`^n=g#0W%f3G?}nOs4{>(n}w|I?fD7>Yhu?sfY9 zmOyX0b+qQMO*|H({9t~iS-)Pkh-|wC`(MBK?1V>Rl)s+;zPB!{w{dvr1-}#Qeb0Q` zad_ZGc|-oWSlu`qrj3bt@F9v@NueE!|fe;qrcamFv@ zu{=Mbe5i;mPH#LOqWmwtDLnb1{H6T+Bz?4L<=Np?x7B&jL-}h(&*G~|p5svdtNc<- zSEe&AZTzK6?B7S6F7Y=|*^XvvbZHX)IQTai_!y3xl>rY2IkZh%j3s%b*SC~AT zffoz^s9S4tX>o$%(F$dK#6Qn6NW0{cdm9_$*V)e?|3-3v-w+>2^T31h*F&=Sd$U3x z{hajmMdtjY7Pz6GP5iV>T_))N7trq4pUvDK^Fn=2(0Jv%pKH4PBQq{7K1AVh2Iaqt zF_X_wczQwk&E6CqR#5)6;())mII;0Cg7Vjrw>WWP$3y7 zw=#PVK0)xm{g=fq?zb*Jed8Ge<<0)h^^Yue-KhMO;{~&*#ry(PnCkXH@LmYbXha@~K zfG@(|s_+Pb^1Aet^PxEOx%+?l4?@!#@HZau5e|3zFCR(HV>7P&xp-;ge*Wck@dmFx zmV5T|_Z9gI8Gnjgdofb{)Ob35^=s28KDH?L<1gz5ZR|mP^aDLVldvcCv-5Ai8!+Q~ zh`a5Ve@%aN@pj#3)O6<_`{n2JZxob0judX8U;ch?3U|jZe zd7r!6m;W|VVkB-}U;dBY6z)r3-Zrq8Rq6XzQl2i94ZZ-^mP@*H{-q!HHKX{;lH^i) z<)S+l_?5I-OO!CZ?}J9*%>=iRFJF=TISKcW=O!P;ADD3W`0`PC;?kdc$CtmK_TkR) z<k}eEE2;=)92c1X01n7t})^l<60) z)wiPD^qs$4E*F`;zlL|}?TZ$NySbM)$ zeLrs7Ue>d$d}q~23z`y;%Oc}H%%UjFq9 z`slUV=3R94Q%v5@&ty64&Dp#SA8o&L(u@yHnDW67P8{^Y#C-rdm@$x_9 z=ec}Ty@(fI;Bt3y{$gxG^=}1!dmsl>KPL5xHS?`N85R0r!p{ z(@?z%;D*%Yz4@!Pmaq6p4L6!DzufyDP3q&H@-xLBJo<9l=WP7XKfdGg)Gt@D-ogL+ z>ozk3*WM6+(R;rxy$vNjB>}^^83b(`9OL8+VZ92#@wh+GjGgy zGVUf_{@Vf7cdq%4Q>16L`trZ}71TSHfosR#p6B6K(&bI>tjm+1`igv5z2>tma_OB{ zcIFwmqjdSN>NEaWnfw!0UAmKIE#Ep- zw~Emx-81GjmIq!}zI&Wr7RFB*J^rensm#;I+~&B>9r?>Y_kS+$d)M3UIzM{b&Zrrt zQ3Fk!pSx@zbLDHx4WP@%2iJ|Ysrr&wY_%Uf<_$Bl4~?HUZTy_8^hxjhq%ki4r2+SS zF8}6`>b;2Gy0-sC{%`F2##i&t{JF7n`MX2ve)sibm%9D(pDkbbkp7>4Q?%wa<=gV^ zK0~iuoqr$p2(G>F?(?3)#Z8sV|Mc#X!b$nem1hjW^tIDeoN`_)4kaf9s2(xF+Nt$>l9SRd;azcq0s4d+F-@?0Dh_%5(6i z;$ZskovugSmFMA3$>q-tt-Eyi@#-0*?`N)?ZxbEGM5jzD-!ZlP?y2$N3wJ^;|Mk$i z-x>aR$p@|-HGSgz8ReBD%LC)efcqbpfBilG)76_de@2J?Bzs6$%;4xWv2?tM|^y~R;^d=wszmbr5n= z9qI&gWzbwRThrLV=Bhv*+m@@`*|k$(X7Dk$V`TI#f<}g(Gc$HL)a~ZVAcFgFzdZlP z4PlQ9)!)6UYs3bvx=tUm_?sgq-9?U2d)n z+GJ+r-lpb50=eN)vuf)`KOiVKgq-9?J#1Q!Dw3omG>b$~;h= z2U|cBG*Y;*w7jH`wBA*^q=%-D8%H`f#2q70HO$>_Wygx3HwnrOAtzO%&NWvC-DPH! zO6Pk7a>Lvq@- zJy9=R2bo@hJm-zjW5NZcJJZS0xu11zhF&qVtwDo(0dYEcNy-URGw3xlE6`~-q4RD+ zr07$+v9D;bnH9*B#`4e{DzH2-H#e3Ydp7!XL0b_*PPQWIHRj5o+sup&L+37m+%R`V zPIIGg6O)C?M7YUHN#7|&%9FPPa1HK=Fu0zk)|re@GV zGuxoULb3)EMrDwv)zR*Km31Zbt`-A_o)72G6yn7|BR?rkkQ&W-4^ z1kC{2VP-2t&!loX&M`HEo-wlp+9UMS6BD{hqkFKQ6D}xSK@)S3nxnFm>Jm_--Ef2KI%r=Og$uM+mGgk)fGc)!h)QRS*K!?n%DdKW- zHA6l~3q;3qsr$3Bv*S1_Xnj{|eP5J$-1=xyFxGH8{VEzn&;b&thdLZ{4Zf#}({)V*d=EF^soT89jxLozkgC(KoWT#a3d=4ru} zP0X#-)13x=qySZo&?{xWAgKD~gj^NK)tWlatA{o? zwAMPtiGj`=1*(L(iF;Zl`qP4{gpiZ-BI;gqWzZXD#{P`@khx-C!nN64vArHp^OV5m zgwMDP`DoFT=6Qiy;hS_il^t6a{WAGfD}P$W7=ar$~EGRdGoa9DbWUdTaZ)W7?e*5I8FTkgFQN|Iu71kQ-j_cGQi&N>FYHIjI}<9&=@o zt1|o_4{+EhkQ+YicH~CiE+{vIoa9D*%v>3?-^{iHqJwTi9wVa|@hhfQAnzFJ3$l&~ z)C2QCh;$v%Ulmjjgq*A+>KmqJ&}36vps8*`9wWp55%X^rQ-Qo=sB~@=s0Zee6KOr@ za|P7{At&{q&No*EJz{1H^q8BF$H?%1#N1+P1@exe(s_qKJ@5#fcx1;}4t>9%dLZOv zd!ZgQHG>A3+6oPE6B=q}8#LTa$TP|Ce`NZOWvW0PE~8L)o7xO{nuz5&9HRv00N>~rXo1kC|LPUe6*&0HDesy3Ye;|U(~1aiX%+>Z4@UnM9v^sJe2q@mtpt_&hL*_x=I zGgk$2HRg;Wf<{Qz$PhjC`ZG6Pf9U$EbhY=<5ZI4?S*XD@4zl@#%WM=^3=c%ozXCs;h2%9;C8M zV0@Uzr^t@0IP~WPjSnFwdnCGw5m#Sbk-1)6MKTOc1RrvH*uvhx0Ds+h#83L+`)JSR_pX)~X`ni3y$ zJ0^wRAt)R|P9}xgZLSP@%*-}uhhUT1C*wKyL(k{_w17KJuRu?k*#h}kF{zv7A}iHD zEhe$5f=HT9ipSC%Hs5EAdCZKqT1*Q46+z(;aF6YiuE~LVw5n451W9yJRe8^JQdD`J!0re0WSn$T=<@`HL&(XN zLS1aG401KrmgWNjx#3-I$AN+Vh@jjMaDi96x5TSIc=sN^OL&$Z}yUdkAuEtbp9ude5 z55L*$s0{rTLAmqE;CkI$8AL=f9FH#=;Yo~n#E_ClLiBM$l8`P<-p%=!EaakmK=ipD z0&O+38EQ~Z9e2y)tVP#XO^>xFWU;xLHj8$e*|uBsyqhnGPPmzmc(a;k%rzG}XJ#xw zx0*-Ibu&b4S&tg-!SIUi>>CwTO!~o)aB(^RS5G<$Xz1Q^#rdLzI+kARgM(&sW%(=P{*w6Z$|w8wf&9KHo)MXs+xw z(JD9Bh&H;JFCiU=m@D3Y4O4T3xtgHSZbEb1gj$3KeM<<>Gj|KL*iDFW`;=_>Zkcq3 zSDU*9q8#H&^5ZH9_-*a%p*= zo_uU;^JvPPP~7E>kmz;N9}r+3MYvj%#LplLwJ$ut(Kxk$J`-_T4S-GkXF{DgkjaN+sklSkvdqz6}*@Xp-5 zLO*y|C5LB=!<**a0=2-a-5v;^aC=z357Bp%pt>OBWaFT2F;@n;8n3N1PYR3!zvA{l zxbYL_k8$XGPS7|IaxxBTUvp)Ut1-^Sa*Z&xd9-Mv&`|nv2RzB$Q$;@Fmpk&A&6IDJ zKy~nXw_}T-&lOY=gq&;H%8Xhy>?1)AmD4(Js!}qxz2Ne2rLD3L$UGz2P${<%`FDLdFOszn! z#v4eQ_X~^+pK?1!Mt?-m$PjWeGU^lN${<%`WYn*kT7g`RkzbYTHGz>~p7$m@Mn>-| zpGJm|laWyenk$1`jge8`WoiX-HAbdc5f~ZX;dYFSzC_T-5OOjy>T+{skgG8=>IzdU zkgGBBlXC487#Tj}cI+kS&k7p3RQ-qRd2?kD5lJyT((bH4LYU{+$&Q5R1LR8*(q*i7 zGrrC3m_7P5K_L)wG9cY!91TY9S;4ppy43o zWH{8bre=_jF1?7g2liaA2%@tF@^Fco-*+p%)! zcMBR0LQaN5U2Cow?nyOw3M7ONxgC2Q`Zok6gpiYjG!F|z!>_v?(dge56b&IK(L6e^ zuOJn&=LT{`lpilRh6rSb*Sa0q(MJi2hme!(JYR5wKs3zr|76EYBKj6V(a=Sb_5K+e zD(EAI)jb#;?$2u?YP&^c&~Q^*An(|6kIeOgzH8~*gRw#Arz^;QKifBEMwZ{PEEQ;k zy6EK?n&l=m+sq0?QgwjV2ztx1x(9FSxR z-4VH_nk$3IqwC>(4fabtVX<*(PLJCJMuvHgVY=Aps|Ae=Z8Nh4dPLyUv=3j}gE>Wk zDrA;uuAB2jtKB>)B6CtHiPs59c{|mdZoMkdLN`hAf}7BbZbGNs%xAY(;WN$E2Hor? z!iAc>A+^EOnDCo&4KP=n zbkE5($XqdDp58fDpaPgDZOV=pJ@gL=ssKVxDk#*LaN(*H0s3CZ{}pO;p~eZ4><@SW z#&bVeTMYVdSp`iHa#Bp8X3tAKZXIJe3bj(i){N|#n+r9nKBQD9EnU-4jXBoFZOZ5L zf|OIHHV>CF&eYh+j!Jpc)NF*5sitOm?2A(RnX58NV6kUlNoMLQWDEYL+MDfvGzM62iyaj)dr67nBe}P7)Ss zmM7#XtH%Wr!sp$Ngy`QBln_Er5*BKfC)6i2r3Rpc@C3IbA^L@a5<>duhJ?`j-3t+v z3{%8p#JC!J8jpOPBrqbp(Cy;oOYIK}8WCzUvjzINdm)075qVVXVu76SdbeX1=ywRp z2_e@-yBf>F6J|FGB!qdctn5gL{;Pr#LdeONMTJ_E&;u&@(i5~pU<~-A+c5_E9}5}- zLQYPmg&Je^j{N{5JFB87HTBqiNps45*n|pT|@NmSe7QJL2{C?P$MDF zG1fz`Eg?M3?Whp_Cj?apAtwn7H4^gl<3@oB;k(_Agy`1_N(dn*2@5q6^33FW1QNo# z+>V6kpBI!6LQWDEY9!=I%ew^nG zLI^oYSg4VZr#esYB*wSZB}D&uK?xz`Bw?XOLY@WPDNrH&sM}E?`bt3wA><@sp+-WU zApN*NLYN0S%Z`NTPYX&2jgXwYDjb(fA2TpUgQ%aG%@BE#ui$VE68h<{QTqSq@E+_@ z)}<{!)$_#YwdQKdT|66lk3ezo8MotQ5dDat;-J%Jw&c+~8+w#LG(5-ch(;eLC>pxX z%!uY;(F+BlVV)2zJEGB73yOxem>JPLJ$i>gG|Ype(`fV)f}&4}{@KmEavmyuULYFg zdD3Y#`b7B@Jw@~pH}hzoH9bcl8s;(6X*BveLD3sUUve{#<`L8n2}Hv@bvlhke_T*B zgq-XUJdwJ;Ks3z5re%-Jv!h=mC>pxS%-97`FE&>O5!|Qr@jP~dngsCO=Q{CyCb#A? zy&o`HKl>2#%xVoCdoub%f`*0;m{}A3sJSwT;AC3Qs7U}r9}yojxj7&Dbu~|$tiKQv z5C60c9s3IUc|k)%LnSB4d0_Skk1*yj+3AX-j};UR%``LiGQ{9}yT3<}upo zfavE1MMKERQqdgh5ytD?j%|$IC@302u8Y3TTp4tinQhSBf_K~{^p8}Nsn;? z3E>X6qa5@$K?xz`Bq7aCfoOP_+YybvSx_|egqbZ6J@t2EFTE>1Yvw8By9IK=Ja{~v z8u|%AxuBBdq!QFuP0b*JlNT|XLp-1HBDbSX^eKXJLv3cp{zvb{0+qoJyB*Q!_X~=K zkdw+DQS(uOX!wNN5siLOP&9;`MAJMe5Dky{Z0)L`50+2S5OQ7gFmq+lC^KVMlaeqG>)Z5DlMlJ9cFB7X(E^$aT># znk$1&ni=!rneVR&<@C>PU0NK{8d%X#xr1jc!Lm^d*84LdZ!% z)aB-ig!id=zd%B`-{)#8M1NXPLI^oYh`QI*Ncg6j=gk!_F#Q!Y!1Eek<92Kx^a+B- zfRK|hXkI5!A-vx0h(_-c6b&IK(Hqpvk*{`cs0UA>_K~XUvsBuEy4-xnCeR zeDT`awL?EGC^v+h!CuEt?avr(Wjc)8n=8@)|XZU{NajXKX<8RTl@ zrr9Ns8$RH6j%f64f}$bhB>HJJcMC+rueu#;ihfW~G=y9ieZ*WDJ967t@+o(N2sz1(I>1~RA2+6sBcSYDbF1crfEyB))z&k{5Y zgq#e6I>%fYw93rL-Kl1mz|CVW{LA4z*q$IR4{6>bFg*OM+c7-)1A>N!kdxt2x0)-1 z_Lv#N(|Nx@Zg}9v+7(1UCMY+Aoa9D*+0+cu;}fMuZaNS0e8yAVj=IrD3Cay2C%I9_ znk!z8=`l^9Sa`MDkr2HiC?SNLl!JPcxiZMrctxOjk6?=|-sg7zd`CpzBq(?4+G4H@ zA|k2(SvB_ywzA?k+>V6kM}#Edn`)l*Zq8q{@CfOvc0czS5317#t39Nu!<*fX^+6vY zXh;Y-Ss&Cf=E@*fe#h3R~3NYTfjQ1>*f~#}v>X5flO;Cu{bc zng;~d3@+VQy8!4f2#SV~ljuQej1n*`%+3g6SJ*BF{3wzOL$)}W1o0+lkHmJE#pdk1ewyH@4bR2|SV zYVQ{`GK8G0*ehzD5{QP+xgF88M}66%M~g0VGoRJvYIeB`+932Tb?q(1xf9Puf%Nbj zZV%2Apl=sc9E6+{hx(YgGHAbP6?TA^&4=`N$#J(paqzQl#|oj}FQ_;O zIVlcxv$-<@C>KJonkgJiK<{W{#;b+{AZHK-{P;O|enKjWJ=E@*~lV9%;yUbh_Xp5OG z(35WFTb8WuYK1&a9G*1y2$Tp9eXw?E(GLqM5kgL;k9y41401Ila89m%7EsBHq1oSE z&;U1~i_C0-JWW#`b6#n@W4MN?*KmQV;RoD~g+-qrsA_1PnJsxj)G6l5AXi%<@+8xv z<44RD6TmgbT+Mm92i4pxPz?N{+p%||KQ5>k=&+fs5It*dLqXS_re_d(QVz}I0t3Or zeyw&}p`R8s5QJP8eb&?ray7OU&EcNUxW(<51o}8Zxgq2vH|ivFWss|_`2x{w6Q~=0 z$nD6D-XSPAgq-9??KW2iZ8ozt&3&i2ViRpw^I?JE;8SkLaOh798V*8EhC|(Jt_*tF z%+`E3)Nh$9hI>`b*93-x+cwv374-h{X*dWu84h)@xiV;unXUP7sP8sc3^!NJn*@e~ zA9g!thrV3Ua1e4b9O_->%Al=g#&D>gHdhSyh?MR|XN0B&4}sAR+ve+mR4`vyddD%P#L`JZy`F z$NHl`?;+42$y!c`p7tk0`O4Gv1?!qY=t*s;e`9I|y2#YFJeJPG1uBPEyB%eqj~7%q z)MaKXM9-Qs=sMZ-3_?%JK>e_}D$reKMj3RzN1zP&S+}DM^all%0qr(3wl?ZEb7hdL ztq^&VBIwv-t~d_pv0q?hc*JkiZU^)i1&s_1m#pmo(Nhc19ha4KJz-rl2t9dSNBu`r zE0C)(g^}t!N}vpQq1&+l=#vDM0U;;zLY-!=44P+V9Q}*bTr7|qe$?&AjefVF+z@h- z8+EO@GU#D5Bllx!J}!_OKIC@n`RLCG$_*hWxoI92h=$L(9hIS<6ci01*G0c(t}Nf3 z>2Y2lAv}4j*^v-^h}^Gwg6!)CTXM}&9iM#1`bR}T$h<=AVEbf^UqbX#7CKFOX&_F3j?hFrZdkEMBB zU>flAziD<%1O2R^X+Rq#>xRJ4{X)5P=jTLu8Qu zn%GRFc->ND5PGuAsQ+qe1#&gYYf|TmKzZ8fazWj&NUxwbmqqam&@Jc>5}|`;wn2x5ca&E7K1PGga`-+*#F0iXLVvtyS-A0(gF0(!{I8=;4VzNI@gNvtQm zrM19%O3^RAykC9L72O%eCHJZ}| zqT$tUM>P6kLD3L$5>4|SfoOQY+p!;`KQ1U5LavM6X|4>~Yi7)g*iGiDKpq<__MBV? z1V%R2t}Q$2Mn5fRWT-)MGBSUi-OnS8r@I|>qw|5Rq9NqE=*i~FAXlSqnvDXL!5iF; z%Fu5Ulp8`$a?{)>5Do8lJEGBd3W|o1lj!HvJRsPri2H9hJEGA~3#>|2PNL~Oz$1*W zsf$LRASfC_PNHdECond=$L&~C^i_hQA>_K~d(4$VPnj8OO6<+%szAHVY=cNs^WoH9 zIra&Z0iSg{mH_>fpfVujq>OWFo)?IQTYlT@m<0M|@+lgcX=WU#sN>C*K?El!I+|?) zx#7p$j>^#Q5tJL+YG&l7_u~T5@F};WGV~V&MMKERyii{>R|cIlGnV&NHD43R4Uc=c zcGl>_{oFqhj%v>4dY7|TJDS_N@|3}OoS*rd+KP4zPgq*zQqnKov3;jwf^;g})d$7;Aln(lw1vW!IXk4*9rOwX?eEqjy{Cw3uD1JfEiw4wS zGg;La_6+eR=TNmL8R&Y{qo7l6LcSEMVwqo(k7Rnu$_vfs(qD6#G@3s*VKzQmd~QZ_ zfEDu@<7?cGqX2z^pe2Tolg&r-I)M!YZ*V)J(YpjiL&!-q&5Z)l@JnvToY0>V6b&6R zGmb#iXUvsB1Sdx~&6fpo!xMkk?5GTVfPBggjWIKF(|eLYG`z~~s0@9+plAp=nHTC3 zb7fGMnXyyfrRLoNx#8VzM{e{-1m%X1lia9Jm@9*JnHjmCQFD(#Zuq?0ksJLLLAfF1 zBsc2o=8B`c^r(^nC4{HC9SPAd7nBe}P78pYC_CXgF`*zL%TzC=)N2sz1( zy4+kDIju&+N#Jen?Pm2sz1(deqbmay4=fR_7s}&$z8FH~LgTxgq2v zH|k7tWss|pd#+qJ3DgZg>~_?RzD`hX2sz1(dY`#6$koXGh+K~fwkG0}ZbxqPLjr43 zm6P14M@`M3m(7gauc&!SAU8brvD)=UzeqmihLDros27_ngT|N{xi439oIq~)Hn;od z=Q;E?LAfF1BzK3J_kYFIO`-?g+$`Ga<~GrGHy;)~>gHpjC*0g2+Ue#~qNm;5E!yMe zUeU8|?iU?!^Lf!BHxG-BxOr6cqMOG>FS~g{^opCOM6bE|y66oz&xp>tc}`S%!Y0%p z>gQ&@7?ahUBCuHS-ajzAf2wbnPm2X1CyPaMpFlJ`az|}6`kx7khK5K^qUk-#BaBB^ zqv3UK$IeFI_Y2AdwU`;_-$iOJ7j(13?k;h+$<2@_`f_(ZA=>K&N{08k9TP_XqM(7G zU1r8W^xh}fgvICGj%f5h6PU2*w3!iI`l=#<#)hZ59nt9T5EKnfFf*d*Jxw4QzT54H zM!!l>G}LKkM6Xu!9)W21X}2R9{g(wrLp#ijXnOA!h=$L&9nt82DkvH{WoAT=d{P@) zAR3oP-HzxrYTqX)`hL+CH}mbiP0fb{qTx5)j%f6k z1Vuy0$u8RW4|T){M8lW49nt861w}*1N%T}TrwK&EGu@78+Ow)Uyr@oJr}p})4)1q+ za6UKm2L+7|?KU%39d(hg6EK$hXrbbANV7)<8vGI)jKUWgq+N5rkeAGzNG=B zH9dJfgVk|_#bnSZH=%3HY=s_h6WV6xjZk09e`9~qP&c8mZbHl5gf_XEk2+l8V=Pk} z^oW~}iFTRU4DB|v6?$IiuU~~;IeMk;3QKFaC2WO8x(SVQ6PjXX6Ew|DsM}5GJ~yFX z5gL>}|M#HUo6V8Q9n!CG*mRgO=ygp&`dX*MDyH)I^2XP zT*>l*?^5$_f!z%5_qE#Dqwg0K0yRiZcC-F!4)6%$Id#!ZYFDZ{e54nBt$fN39X2x# zkfUlI6Q~Uy@N{i$+thx@ea5rD{#JdQe98{ZGBdK%dyYVM_`KV(-O-N=iiXaZ8PS*R z);1J~hOhgE*>UKjw+V{ATeQ~9R%oM}&|_{wV->HXADZfBzJvuCvR$4~r&HFkxv!LArZ!(Ln(1bq{G2+S_l$I$Y-&t$wiGY7IS=Sok5vNmh97V{ zRt}1b49<3kB(m zL`&SvYwu9AQ($y>zuU3R&{qnIhLDpJa-n908cX$@Iv)_o4UhU0vm-b9cLe2zkdxen zniXo~9<9z}JfHDpdunr|f4~wpLC8t&Ld{S|n;N<4Jl69WZ+1KCM!!-}-4Jq;yHGRK zyG?C@)|=V9LG*x|`Bo@m;)J+GJ+=xg9^CIwYbS{QJA#UUkdq<`HA6jR9b2F?W;VYm zYOt8tjfX z95}p(wx@2(7mQ|?!0N!q-HyW0KP{**2stUNP&3qhrnW!_&1^m-I_73NqGycNc}YE9 z7AOLqzqfW1p?_ac5fE}xM4@Jd8mm*NF&yy=eF)=qZpVoL{Z>K4LCDGJkLG%TV&TW! zj%f5R3W|o1lW3Zc3q-@izF9j}^gj|54Iw9=QWk1fs4>+-trTi&srrvp!+kX4j=GW2 zFA+2{gq$pLp=N~|Bh$H4U{>&pZpU7Pey5<^5OOlBLd^=bCb!2{3N>a$s^bD9!{hhW zt|$8U1dR+KC$lQltWaZQI#2L?#`o3bM*py&+z@gyt3u5RwI;X6Rthy{MXLJ+W(6N{ zJJu8Z*946WAt$pc)T~frRYudhW_`0azn^T?n2E9HFA$u=P{nocuiey z^bZQk4Iw8hR;XE_*5vlsN}y(@)JmboS)0zQ1S*1ue!I3J z^v?*Y2s&V9>#L&v>Z#(Oi-ekril~ezk|q@mQ**e$nD8{WV};Q#5i}-*To>(X22C+F zw%&9#8wGO1i`|ag=+_F$4IwAF3pGPsXlmqMqULP^x#9cWj@;;<6qFl6PI4D&TxV`l zj|T)2!cV##3DJK;P(lbfNm!^^p+>QE-YJk9?zi9U$c_FrLAfF1BzJ!`rLxj$c3*?3mxE(Kw=wB6-8$wR%eqPOk z0@3jFKdYTJ`rinOhLDrfMxkbf8Y^0;71XH~8+DVa(ML1xbUW4r{TBp{3?V0LQm9#> z*5vlsN}<^Q z<`|DKp8J0+I+h9j3JYn1kn5sd&7g^<#xfPL71Ya2ZG|SgnXgIFvAGx|R&1&|&k`=s zx2acL8mD|pxk+H&@M^dF=Sk5&A!yzZa#A_Xdjz84?QTaj`Y#KLhLDqJnhy&^!-w6D zJsth`1w}*1btpR%jHuvgq%cg zR&%SlnxTi>gdTPi@|4||=d1gKd^-e&ge!kuJ0$vO`7|VioDA8bW}84XJp6gHWBt$% z3W|o1>!OdCnn6QMjl*w{nnTUi40&v*7t1w5U}X4Zw_{}V&4NaTkdu*7A2L@49Wyg> zA5rtTxtbx54fTXvCj~}^@B0h0V1jow#2MMKC*G|edj z(ePQfW7g<91w}*1b7=0R)*d!pK?RUNp6}C3q-@Ox*e6F z|GuDT2swGpDAWw~6;tCigU+uBP7c3W|o1 zljx_^+$9hVzvTAd{K!ZD6G71sa$U5mac-l>%K{1E{@*csaGntTp9Cd@kduUk8VTt! zz>^qHcRLcI|D>RV5OR{RP_w)OdNc}D2rqOy77YDkf)YZ=Ny0^HE*6M}pL9FQLBB&# zG<3h2v6B{RhDvaYl3n^N6n1f^gb&P4Uaf%c2tJmM?OVE$jQ74 zHA5Y4Y8>_>)f^>|8=mEMCy*QNbUSjRXM%D=$Vu)( z&GHSrTs^u362hC@j)dr+5|j`^P7)SsR;W=dogWa$4exS0a-;u-pxh90lDkkd)SaeA z?x)qwe#Y&HM&BkV8hX;q zh^F@*foS-3w<8+;IYH6TNi!pw-lqkk;R!F89nt80)1jz~OS@SS{$! zZJ>3+1*K1x=3Lr?$>;;s{U`Z@k=4WHE$WGLc|OdAr7xHIG16!oigfS7Rg5;eCm+N5 zGR){0XR!B;p+?6WOXj~>U<<-6N6n76#ORL-S`cWg*zC%zngj^TB%Ul_B%FL*Y*sq(b0(org7pM=L+6=iG`_wtPO2@n| zxYO;Z3w^kJstZC+>Ovi5t_*53GwMRU)La$FW9Q~GMjd2oGc?c4sCv1YT>|R`Z*@CX z8-1Oix*+7Fu5D^QBoGb1;CAc>=sN{PL&$Z}yUi7+7N?;iHX18Ms z=#vBu10g5FpiVPa2DO+Ohd-U?3FL;ixE;CCy9DKikdxe~cbhANHklc@>AY1SH~g&I zu{`Kc2+9p1C%K2p?v}u8Pi8kA2VH#zq%w|_=(#uFbw>r+c6CKQ9;Axr!`zJ znJa^cNJgf4Rv;mK+25HR3DF10mn5XiSnp;$*VjlHbD zngh+%3=O8)>q1;4WvD>i@bJH{Edu>=L3KmONfD?MP0gT^sZj*#|2DM(y=i9KdC^7I zFK9$fRl$7#ZID4`#=! zBzmWyk)g$sH8OOY(6_Ym+-G{QR(tE;KhuM?Mo>3soeOL3>A@nsg8t((J*DbD23TbS zWDp&ay$bbHrdHB`h30C8JRn|Ow$J7esYK%kU$)NLJayiat{O=1RF@;Ka3Hw*d` z8sn|j^W)HCZayP=&dp<@mjyoEfL}Ft^P8fxZZblD8{y+aL?Z+`!cI#MyE;98-I<~l(cAR4! zn;{=B_L*VoJW^m@@K_6Oo+O&?Ce-NWT+t$d&Tyx@?-s3d6I$*sHbc zfxbh~dO*m@dZ6wyHG?*NAGP(6=%}0NFkiQh70A=XjzOA-O>Kr;jeT;fQaxwsnqL+T zwi252%yb^^MH^r2_C@fVf40etO#4ohUz355lY@jzQ%%jF*UfCXSe-^%$0&%7A2qcC zd779E>Sd-jL$1cztx2gW0_zRm^IGkCqu(Z|Lsr>gM133J6}-mB(5f#Kj+U$0#^^kagCgAPg7ehSf3_kWll7ZG%Q*}7)X3)VFb zIn?i&T7h0PwFM$kQY0M@TE}L{)mX$w)%h_Ch$-w-^MJb`&)f_h7j%QC&-P%P6!eEW zkWcc?d@ES{HThWt_{0xt*PQ-+<k^lh*X8AOL<@E6rQE-(`O`oEeT=VYW4-A@K4{)SRib#(mRz+Gyo^$Vc&yv~Q~e^V zqX|MzrhB=X;{+xIU;L)oap0iO5;P%bu;gSysB=usprNKlWvH2{6=;~LH|BMrPBFC^ zV&G)gr8z>NE_mR-*Df^rL_u{y=gn-*bE8f*R|b_7oXi>Zqo!6MQYRzR9OR=JpL2Uy zo*R9Pppl{1&5V&z$C)dG&X^f1f_jCyD$tu|#)_a0H&-*nz)4*+&kL*w{OZ}-6+yp9 zKGg*sH#6!&z1UnC^pcrT7wXTLs{)Za8JXs50wcqfAJ&d+mB^=&8$`&-YNHM?R|dHn zb+yRVCXgFm=XUJ9=t~6UhLDroG}jA6!@J#%X!I?Dq9NoY`WZF%2t>oLx*gHzhXh4K z$VoKK*92P?@u+iVM>Kj#K1D;wN%Uwn#|T8j*SQ_h=#vFSL&!<=Y&GWyM8o&F9Vd45 zg@U3X;OX!xYt5siLGP&9;`M8BfuDS>Es)PI^C z(dYx^Q#6E}M2}W;j6gIz&+UjtzeZ3rgq%drS9762H2jd;5ski1P&9;`L~mE~VS#A) zxZ4qp{;Z&A2sw#KLTj>^!d z3d#*3C%I|P5r~G@xE;~x%LPS4$VoKKwF1%bvu;N;`Xhp(^P>#c6XwbwB9eqO_X{M1 z`}Q$A5~80Jl7w{W=iQ8_)rFv6CMX0#P6nK=W~0D>@M^bX%b+h76b&KQMR%Gj&W`lB zM<5~ml-n@_^zDKYLdZ!%n!5y|;nQwMH2P6N(GYSH{f3%n1ft;y4Q59)`Y`zv4IwAd z)3u2jY%@*jqYnsWH7;A$ebur%uI*gfUD{E!uUgW6%k496>0Y{OLHE*Sot5@au54e? zZIL7O|ArFrdu5Fmy4qK?cYk8Zg3d)9?Oke@bg50BGwSm>S@gNK>yy`ZcDHwRtz6!H zb?1VG9qpy7>)bP!t}y>ib^eM*Ue?tvuRazL8cKI+4qIfAcy{|DE1qn!TbA8=t8(-2 zQlX*ruCiVbWc|Ew$AYDur8{JN;uET5S=T2%Av>y7$8W1e(w3!nw9jl`%A$~$W^;RY ziOFHxfcI7#ACu6N3(b{ll4bB}ztLAOE$XmTXzg6NLIpQhY_UJFs{NMk1qd!UhnKAP!Em@`g)}<@7aHWUB)!NyWJN3OlwO_t^@6)1tWObRF!_nNm zpnK(t(jSE5s*d&rU8PsN-OM)byrsPw_On`J<;lHy`gyhPtCn>xUV7_FZJn>z3eDZ^ z%L{R|CYL0;VO4wA;*Mo^mTv3a?{)odt=QVRs2X+RZ3GYd87+4**31Rn3)n>K+}+f* z?3VTwE0%S&bS=I0RxRtFR=Y1-+k z_lnR^dVG*xwzYe4Q1rGkU#Rh`1af|}#@V)@V`V#8b=8&RNRO}CIt+^JQj){$-g+%x zs(OFEy#G-zR2OizrcpD9ubzr3EfyL|<9TGJgW%-Jwi%Ogk)mYxO^o|89 zZZEAXw01j>NV{|K($crwzfeo7t}KE+>?W}4$yarpifAY`4$ZWV2U$)3L z+TGrqxpdW19d9Jr=^oz`n`c<#r|85eakeHI0+;O;_QG?}|w{znD5d)|8KP(%mx_ zEz--!it86Fr|%`IObO;J>ul^;cFXNcJ8!MDFIZF@1NZl;Yi+x_OaJsX+Op-Pi8^8Q zmUd-lcj=dV)n=?(u(YGJvsX>ac;$rBdvxA-YffobOe+2I+i833>R7O1N$ZOCTiB3mQU@FSvD|TWm(E(H7xSiGrf=<9a7XC_%4Zqm=+?y& zNjBE`$n)>@z6Gn=OCQxfk`LcSgvh`frsg%`OU037G=k@s-Z*^wR);N7`|C#%i zb?JOjT+uda7qPM2pRDX1xw2GmJ+vo2QM7$`{kOuwv~}fCnxK8XS~;$(X3QzwQRj-Q zs?uY%3USwVE??PQ`iHj)H>~VN8KJ#C$&cyE4Kqt0uhp)da8>EST36GJ*O&gX)|Fj- zZE1imsFI}3&DWN$u66N#qpP&0*4a9v(o*_Hov*oZ=F(f2b}#5Coq3BgqjN#WvRg}6 z=t3(Q?%D~>rH)!xeqxw?^~}=m)k#g)mR>Gg#jCRR%F=JyzT5c$?Yr7ETvJ@LbfI1$ z7Ie4U7UQC)qrJPmbVDln{#AYbxF=Qeo$P_sc@-B0&FvjJ5tP1>3YC_ts=Ml6*17XM z|B(7`TyVP`DFbz+6lKcE5pZehoW1PM#s%FRElqEA(|c*^RvC1Cu+B$6-gL!K>UaHu z?pv0Or}xob6=HtSn{ov)7i+cOlI;p&K2)dZZO$D;@XDG-;HUqmQa^80==_~}Cp|ga z6&b1@2wagmixbApb?$sC+*{|5E05iELUJxRR3}wWH0SHweyVxDcD^X`+7 z?s%y=HI(*Uq0csT7_x)vD7}6GZ>_7l&h4o$xvn|r{^kz7K2*Ev3o63RWgiB7P@5|9 z<+GjZPV1HXKIgvlGER-wD<{Yr0MB{^G{#5dTb+F(fzcQ*CnRE96Q+c%mmL4MtMBvl$$ zuJ}~x0-eXBWO>XvF?H(v)!ntMqqHn_>Z-Z4BXw{{==!eoPxVd?iDBB4^5Uzr|5)P6 zW7pRC2<0EI$_=IEll6zD%I>>lbIV;dyQA9q=6TR|IvmxSp09JH*RJofol2dHEAfxz zF5YF#UV6t;JFl&Mi_Tx6 z{&qO>gfE7tx*NRDc9&+w_#WLB?KtKAM!1s0p50=kR=J^c#Wa1xqdMoXkvqF<&Q!Oi zzPyGt?u`83^LCPa5Sy>FyQypGGQHXS)W^D(tz53R*qrgXZtq26ombXM^xj+Rq8Fd_ zDnWJM<$b(bd1-v=LH72}MTFZ<;Z0wihpT$EFwIr3^4+Dsc&nSC`1h31Q2NpgeIuiR z`N;PArq=4<^SzZ1PJl$#Wm)G{%c^g#?@PVaK(4r>XC8h$byC&)HDL6jp1a+l3C7y< zYOg+WCCjfwHl>DAc2%j=XMlf(tqa4CwX3fDbJV|6FZVUIYdvhi#wuOvV^l6Y+*hss zk#OXt|DAi9R(7mtzj5iJ?j@9ejTTjLg_C4obLUK5Yd7li>uSdLYWGvu+?%Iuad-2l zI&W!RzDO5%rC%vLT&_0qR_=iN{1Ta?qP_G}I!ct!UDtN%lU7}qq`p}TR(5pH=1{h` z%hA{Tr8C}DtCcSG$8{K~qkEIpe#HG2n)d&@T7METK&R=*#K*(cWoWJU=L@kt6{-jR zzob6jyQk=CTzOSQHQ~x|aZraDh9sMN|Q z$?KPzMS0(KN7J$uOZk$C(fcc%`s6N3o$fBZ4c29UwOhCQ>@zOHe%sq^?RtZtGh221 z=WD%r9sgGAF6wF2QJ}%|EF}JMfyHsI{oRQQ|XfxvL|MQHWakFgJKJt$16wl8XO2oYg#oH3j8K zD*lD=R4d*X4zKvz-p;Q_^cxYY#4k_Mm-<)os$4&#T2&t{16{A5 zkxy`{d+dTv3sK^AyP@>3zH%I`-JNgunm@JTs_u?vKB!)Lx4ozPe0c3+oZS6e;ci;m z*~HhF`aqbgD$l?Pc)332T+oqgKkP-**OQvkhgnV=w}`4vVR0`~KAA7~qBVE4w=b{8 zKJ#{Zp5PyQ=`d6AX_6sqrn=gqPoC%_y>zmxppWSr;Lcl1?V+c;)|S+p>|Hxje|0WL zQeQso`PAuq)fn~xD_0{`_dH&6+&6pX4V)D|n>yI1wxo_YVoKi%w{NGT(Y6&Ty%z0Q zky2mwFe|`fu3Dh)Y#HLGd+~e8SBKKrwd~GLy}}h0tO?D&?L-SQ_+QSzwy+vEtzev1D zuU?-2`d-wjp*GE)T_4H^$oU*@Peos$Ple3qPcyD*tnL(#)cf-tgAdC*Uu$!t#;f)} zQRmLP|9klLc0&th7mzwy?Qm`=?f<1x>F0E)aHXiMElY2?y_#@l;mLE&EnMlo{)HNM zva|Eed^M^1SM&0%S>eo6?=QT?Zre)xAOu2Hg^;+b3dib79$t$fc=8&<~ncnlA!c^b^fbYagsb;=hb1_(NW?Y z@_!k77XZ78D&PC$Xe4NP~^2?=(RCY?aQK+=zsq@iE*BP0sS zBY^}_0TBT~kqZc1L>LuO!HEbAFsS&vpy=R;&kwzzh~NNz|6f(DUF+;Vx!-qSrOv-r zJy$(;?bTDOaceto zefGD6n@7dcjUS}g@TSc{9BJ;S!KQ#Bl9ap_5*g=}V$$K{PbofiY(I@A$*fb&2^afg z%J#(+PaP@iPhFH{pP-&mTujooWJQHP?zswxIx|JJ_3H1!3-oJ?RNyV;cq{e$iGgf- z)2g832Wa3a+s8+-Z>YmTDp&dVIA}yal%f~uM=!2?{SGyh@1jZlt`xm;vu1;h*BRwV zQldkkfeSXa4-Un@YVs#xqTC-k|K?IDmp^YErs-n^P~aMeOMlk%@XO)y9OqWUV>vdB(*&L4D9Eja#vGNF!iRHA9Fni62pttuIe*PD zHqvvn9w=JcA^tv2m)F)t#lo}@&r1wUZy{AYIx|LN%H zSizqXLnGJMSM5nHezO)2m84iJoL3+hy<{jR@2d0~Bktt9cr$OW9vw|%?y8M$>XGi7 zKhTg3{-ef^ZL%Nzy;vLFG(0@m-7zw3y6|^NOs;VS+ZunyF8I`VTP@Emjlb7&Rt~oJ z4e6&v^zKHjR##zLXZx@^qGPI#>hPy)v3Y)a2N0r_|uB`RM5h{u7Un;9T7N?#~iVwg7L$G5sNAqdrQ_aN1;etRYW;qa-vo` z%a?lny%>u?YdLYj@gqKEYOZdo$E`-L&&=Ct`ZeiyBG)ozPAr-~1B@zK$Dz*p@i7yB zg^HOZ%0B+0`BV`jQFf-t@$8PF+4i@Nf2oOK0`$cg-*}a&-(^<*R;0DIM+VEJgWa)4 zAdyFjKa4yc#yP{WY?N*Db0jH0A0w^!yg~kP6vH-zcT4lBa*8aHb9{7NFq%OX2mDjH zp$tG%=b4oak>fjVtQ#ZCSHhoh-Zptu-ECDZy${8B`nITNWN2gM(HKF|X&+p&tTJtn zklRJ3x%V%bVZ(H7Z4@2(eU4f@(qRdk_bducv84S(j%__V{R*`5-I~atxl8N$mC+m% z_w*@6`6?-;UtSYwNk0%{7wMNb)ny~S`ujaixh=*nUwM3+eyOK7MSCzjo03atbcVDI zQ$uC8xh{{e7=_}=R=GWL5G9E#KaN<-Gr)>=NX?Pf#ita%I+|IE>SIr>Y}4j9wsOct zayX}L1%=tk{AInXf5VEAzCIKe{Vp!`p5Kla$xz><_-~ctO)zpPP-JM)ZxAYPRJB&Z zsy=>}P?_hVNW;{q1~t7UTp{&jeCa?}UmJ_?e&}M0myfa9kS(cy&Md5rciZDYEhqKu z)3vc_;&R4zrN^y_L$*aKU5}kk=9J@2Jd#dD6Ho)e2h#vPF~$r9a*UY;|RN5#8f z+plAH!M2}5j$+SIZTSaqHEayahW(G(w3HNO?cIO6UIBNDzx=J!Ui)cHO_4db{jgyd zZ2KegF4*?R#!>7zhW2;1T%G*|YgC3PT>E>#F4(5u-UZuqxue*zHKxnStubxLs0^_+ z_98rr9S6%!_%-a0tMp+`;_+m?GFYbM8toKUlP9xnKN`iJr8IGsX!7dwVxvs|6i#c> zFANo~QFw(u0Ot*4Dw7oe;;hU^5h4Vx*^eNI^DZZYZl^archeF!;WWvuX+*{Z_ zv45=OSkKGik2R)3exVhuVj}-l@o8sIa}1wW$oikRFoxGD)U%*6UBX0-caFj}3ZGO+ zy1B={QLA58HGIxZ&5g{MRHdD1D4ADhw$?X ziNAVT%=f%Po-*5)Yb+GLs*w8Ew8r}GRd|f>iwcq99R0=TRE3u+JWk=`3dO1%up*|@ z*YKe)(I6tqW3~7aLFGDyGZa3kaFN2vZLz$K3hCEQg~U%_Od<8&tFT$&t0`=Jf1LjV3gKU^kn#ADLh3m{0-vMMK2Ph**b2LU>{pBU_b6_> z^vhQ&yjtN=3ZGC&yBjs=a}{n@NdKNysQ)X?vOJ^x+f(?s!db#EE1a!x<~n&|Qh2FC z(m$7QYkS0ZDWrWbE2MohJ7Re~DZEP|?cx!L!uu2|X=P@=+NgAw4QP!EuRcqzFBEP~;aw?wTH(Qpr;|r0I8q_w(WQ|1?Fy$W zyhGtJ3V)YEIlByaT?(&D;gczxHXQk_DZDg=kEC$?NaQ!B@SGIho5B}UIA>E#*OS6q z6>e2K?DL|&jID51h;o{Bb{w~P3YmYmD%@M)eF|y+%Lz}`Vj;dkA^mMt$at?)$o#o3 z;X4#I3qP-r@p(1j#w`)ID1?7m!q+L(5~;kL@c0jCPQzE&qVQ>j)cd?b#^Znw#(BF~ zA@gLN!f6VJ6;4-pwL;Q8s4&b+edjYi%nuGhvEM%uzftki&WZDNyTTKMf244=!dd4= zevd-p?^Q_r)DLM7QP`#MIE6PUY*hHH!ubkkemKT&R7m`-3WKzwQ{vW>VHHb?V%Bba}~BK z+^&%Ec|_r@3I{$K!+k%d`xS)mP^hU>nfdYfJe-q4MTO5A{TqLe7TYsd{6iJjrI7i( zSt0XvyF%o5UkaaBxKVhu2EB`Th2;C4!f6WaGiwaxbLx)ezbZccnRR(wU)vS-2*0RM zQ>e08jc!r+pu%Q_lRgo{7KH=C_bFuD_q{UC(<>D+4o@p&9QXZX3|A^VLHLFgKBw>u z;ni2g_?r}-B>bwv6$)EF75leU;T+*FE2LlhULC`86o&CuNc|1h#P!pa!dn&2RQwYP zXDNJDA?=xat>%uxrxiZ0@bOQ_ezsmGHx9zjE1WDD*+)?F;x#16>-tKVPxF+xQM_{$ z(yvDp9;0ylXJb8$3TfYVg~!2H*r;&Q4KZA-aFg&(h2(ox;cA5|KNt6nTNTb1elCS` zZj5+XA^otA#9WEL^NH=dOMHGVK1rQy6mM|~w=1OlXB4hfc;wBoyv-@RFNGXFDSw{A z^$KrN$T&^?d|W@P71H0E6wX)pyA;m4HTF|c;lmHB;*V*@2izn6b>q~oJ2ZxhX;Ank zg>x11{N4El?a{>F8OL|4LfWxYA@ZwyF||t}_?(3AP55PnGZf!&S1MQGG~pJ7tebTy z99B44_&kOCE4)tO8ig;X`0;ngeQTyd^3PK^Nnx|X28CS;$v>cwa^a}_!))g zDO|TR%6)4JZ&f&;c&_1QzH((Ym`&r?YJ;|ewP!fnGh zD&*2$=1F4;x$YLsEwv2_xo`F)h4$gs4Dm1EvA>fZj`OftVV4r!s_gQh2ISRSqbFRYak7(_w%+-&^{&I)qbj5QUCG&wxB*9z<$#`=|<1GrgZBbQJ zxZRNOS%vhAI|c7h$nAgnxo2*MLT-$k zrI4%K;Bx~T?d4iE@^b|m<#CzWVuf5hM!tq0#E=WUz}&;tppZMWz}#;|_>4lz8UMo= z>TCEsu7Bg-M#l#{Q~as=HaCTf6;2jjnQ)gv+Id+Dxe4k>VeWLAukgqp#q^CSY*9#h zZdSTf;rJiNko%0z5a#Zn)e5=Pr%~g=jV?REPsaBEu0vTbe85w29nDE0HT_9gBq9EjUiDre|6EUEW`x&lK$XyDA+ED!6yltp@M?wh_d$h6D#U&L9EEtD|AWG5&uE`gKM(k&>Q%V%za%$> z_z3@<_;~DY5XLd~5eji}O?z>DLWtXG<_9jKrz^zy^217pJK~iJ@t?a@A+Bf9*y8y8l5bA)(_L;m=Co1+lVZAU4@2OAh~YT)Uw#(CPJuu=F@g}W=n0U7n+4s5LI z$5$5^uUmu-Y8>firBGkP=Q{lx|C}&BVEk+`&Unl^Mj^hh2=QV?IQ<_nT&M6jVSGdp z;_Zp{;hBl?#K#gLu92D*;^e4NA)bpU2OmW96yiFF`fvh7Ik@v7w9ku;n$Jy=r|47> z`a*Pq_Tl^K4xkh#?%+j|s|ej4gzgSH>UfQX2;Cio?hZnC z2cf%z(A`1jBpUlZ$ytQ%4%)j#`9$dMAar-oRm&tF5xP4F-5rGP4m!0}@)n`HgZ?Z+ ze~0c4x~xxGd9K_7=M4!TH$KJEu1^l|9oAarrifhSjj zKJHY7=;Iy}p^uxfT6>D9PlP`1Uq$HS(8WP3PSHFPeOH7&F6iP;)iWT`Jqppsp^Jmi z#X;!epsPga&BaMd;k@!}qbLsjnh*Z_sx|=--YzUFC_;y+P>Sp!sXHXNxWp zp?`Z!g#HcP8#H5``X#zF(H|5(CqnlI-6=x<_L2zw8@e~>3=#UbJ4NW<(7i$E-XL^u z(48XmZ|L5j=SB7j-@AlF=-QwQMCjYlwL$3GAarfedOcv!x1no;j_KBV68%DizU?Iu z`ZjcJ(1D@`(Geo_ZOcUH+t8`mhwtdtpp$y_tQFlOLcfM?4f?tW{o0Iv^s=+~|lpsgL!&=XxWg_%zmx$1>JuE`MHg-hwLv)-7{n`ga=-2KMpsgZOC=s*$rv}GdnY3R}*bZHQ}GzeW9gf0z2 zmjmjv{i)e4EnnW{n=4l z^&AnQJA>{N*#~{uvx)ZJrv8i2l|ksrpvOe$%O+l=_KDDyLFme$i$v(l?h&CcLstgP zxLExc-6BF?_H3fPx2qn}F(UM3=*plQMd-`Wl|ksrAarFAx-tk|8HBD3dO(D}44s&L z`2Laz{n*%#Xx@nS6rmrxN`!vwVG;VVaNxdFGD?JQ40>3Eehl3hgl-JFU4(uN-57*! z3_=HHAHH{p(1&djp$|hB2B8as(1k(h!XR{E&~HTO!_axzhwq18F1d@)eL?8HpiNh( zd=a`Y2;CQi?h8Wq1-lnjF9_WigzgLaj0pYLA4KTCPP$6%6Wu66|Mhnf z`mbf5()f$eeL?8HAaq|4x-aO#LlnjF9_WigzgJM_XVN*f|gyU z`b2*cq5pdIdXrB4j;;$r*9AQ+LfL}!TXgFXvg7KAPfI!c5-3tbk3 zE(=1J1)BF2wfI*foQAfVG;VQ?~2f8UGXK&Ytg2ABu~-Aud3go zWg_%hKM|qN+WlVbBcdZj=(A20q0hQNv{iJi2z?g1Ea-Jn&}V&J`<7^i2z}NG-!LgF zoxYzgS|=J5p})F9g#HTM74(1z{nbxI=&#US1^tym^jGMp?8EmnMChv?7NM^?_FlCjOiHDMD8T{X&GkYTeFATNOgLCPG&Qp{s(>RY7weh=i^R`iTgA)xqCZ zy&`l~&|@O>Rl^TPdecKHPjs9Jebssq`l^qK&{v_Wf+jv(DL&|@&`m+;rl7|}=%>(4 zL46|hQ(qUMpF%eUp__uxO+o0UAaqmE4@Bsv&`m+NKc@X!wBkRsmPPwNE?JBIOZ2P= z-4ujw3i`VU{S>+>2;CI4=Mx$y5xOY|-4t|*2>sN*iqKD?n}X0yLFlHS4iWk(bW;$z zDd@l-X#I#5iO^4R2R-^JbW;%5yx%M0N_O;9T%V49YKF)@=%dg@LFl3&bWsqxCm%XQ4qQ)2wfC}E($^y1#u}h`Y3c!5V|M`T@=L4!04m)e@b!|%@(1L znlC~hg)Rz0=VTwgbHOb7C$4)%|8%Vg{S&$;2;CEe?g>Ko1g&^l^@@HYLjQ#B3F2Z* z^iK!=Lh==%dxFqCLFk?!bWaevCur|yw9ZA`MTq_h-4k@xuar-O?g>Ko1aTW1`lr`L zLI3ny?ZYB;PY}8%i2K0MKcRbq&^x+jRMe$YRmdxFqCLEHg@ z{t4X^#GNGQpZ0!9?H6$~2E>&Yvqb2gAaqX{YHeo z>EM5;KGEqS^i8-gN8f}aa`a6&4M*REt_ecd1fgq!&^1B0$41|Tt_ecd1mS5KeG@*T z?X$UaV8L+zip?$6z74}0D+ZUyT3QbJ^mE|KD%n`AsCHJnH&y3v(GOlbATmqEPZ#|+J)~6;Za8)^`5oIFIcdKQY#~UL){zts$C78vVW@d^!IIO z!1CbuWvdz%G#okmJ+lwD7FW-Tt{Q{C>);iNALq_@&acz=T{ym0Rnsy(ht)s1I@U~?i|7^sU)#BM6Q+ZGr4N$9z07?-Wj$mJ%V>@AD4czt1_#>VfHem z;it?#js5m^82@lVIwCJ~?D=AJV7{ zuU#+irz3;awd=d(OS=@;)7@7Mp0rg*aHu`dxk$|UE1ln&Fz_s%sx`NKfzx;~hpP;dkiA)=~N}v(Mh>M~0RtT4~%5uU!Q;I*Q7! zj%oHtPxxhbxlGNjRG!OOZf*Q^_DBzIr%659A$2s?(8$3qd@;v*mvn8etyPUreO2Pz zK}E-k2G;l4fKXWyUEzj1CK5*(^eb^Zi~CBE(7;H~{E_uC+p2Wn)2G^{?o*M1;3Fnx zPK_ApY3l48=@rimhN<=c!{@e=Wcj8+sp*P|bHmz!k>{g9iWKym6~3Rkc>B zYRXK#Eq@zj%K1Ze7;}wA@1vZIn~fhMLF2NDnf>_sA|CM{5m4 zf7rRA!r}I4x6Wzv3La7;*U2tM*z|XqZ5K%%zDokC4s=UEapBf!X4|mbX@@zgC*sCB z3G&p?+{KP4?yn;~avVGq1?cRLX}YGD{6MLJF>Ce^uBg#Yv9*e|rPQq$Z{De&>4J&i z2s=$*aguD4uW?0`S`w|$6psl~oD9JjX{2Xq`(}I@sOQNtmx`Q=^sp3V+Oc5>Mz)Zv z(@xEzxkTGE3XanUa8SsymsN66jMhRiy=lTgB}!ChG4H=Q48P`9_ogD&=QM||ic6AE zEyEje*ljFtWmUul|JfxIaAT^hv}wDT^w1dT40|RUKMf5#XsN}~q$_tKIRIyUX?PRL zt+SRCF{Qc--`z!mR0Knq8(8=$x2Tve4*E!^M9ustG8Cn{Ns^i7HrvXQMEu%I-nEO> zm$0+RuiciaDS?)rm6%q8>q2aihD4QNxZP8vE!sMYqlj`NV!_BJ*doa_cd(icK*`f2 zF&IZRAU(Ov1-Eh2NNBsDm^l@mvOSBIwyszxaSpMKu;samaIx(RE1HoCZz~c+hu~IG zu@I^$VJwBYA00x6guvx}JzJ=l1|6;yrPj1AR2UpymNvWf_$Cj}gV5$!rW2WUr!{s* zPvt0rP+)M%GZgbI++6LHMSQ3`v_!Rc#vLSOS+Ovtq*+XK>zJE0MMn6XkowLXZ7&uQ zsm$OV9alPPF7B?$lRP`84WVsg_j)a;^?1v(bDZ=2tSv~DG%add*rHJ0)nfKhuDD$m zz7{U8U3`8bhcbAu>d~%yD^i*`LV(m*B$IfGNi&WJ^+FNR^wd(&JM5H`Z)9t zDGFuD^3t5&FwotvDIdzR9=Y+LINO5o0q*L=Z-!yX%k~wQLdQSqZsVUgE%lAZ0Sl4v zh!nm%g-0rE)s%}H2PH9i*oTvJ;&d!lzpD%1&0BBIOkng(Vs<{Q?I^n~6=Ut~ol)uwlp;3-^Z9PF8+Fv|&QidClQ#+=yjnjv55 z+Mu-a7x@Yw+(nF8j~5ZiyIJt+UPMOmCFejzY*Ay}TLt6W^r!^E7kUxvW@`~=?HFS01sCVde%Dnf~BgcQ#Fl274`I!z2=HLDoU+L_UP1TT0+79~uZWD#Zc zDx$`}xZzw&VCSQs99(OKw63UhB&}UdHN~uLThOv-uzD6ub2gr;lp}77G#MIpa@G!T z!~*8Mg6O;0oN!xWGUJk=NZ@i?8b!rzxg6mdQAaq=dArMKQ!3XOJQa;fQFN~;S+!|Z z^h$lvS-2f1l@hoOLlLp3MXNg&p^hu!ow#B`o%S=gD4Drk=%tTPjUE69n2C7wD` ztTg4w-)qXvF56=zIax7P^ri62P1$yxp5mz{-YV3x*lWnDmbHMtp zLr3zj9g>xtfQJs{HYjWGpvbPSH~ylqVjQe264ooPXqP4QiO58Sr739&*Dx{XcMli+ ziF<&$xxPR^$QW(v3rr0(xa>2wB* zkB%Zk;b9yt2`M?Jg*Qtrw$@c~k!s;dq(chix4N!R=jfa{`-oIMxSW!+nxX0tIcmIU z3%AyI`7RQKTyfFV#>KjWl*Nedvr$tPBOKhrCnwPS{`=eiiZ@8CoGV zJ`Cq9T*y3%TlS$vc#jOi2<^>9rRAtR>Ti6hh>Zy8+=)7hC+S(8fGB{!OT-dfcXM8` zLTSF`u98$H6CuVb9dR}#Vx&Xj*T_rQZHw_}to*68*pYA%XGb#{UevkptW9z9$6BHU zf}l7klT4+%x{))lH-W3i4^w7jU_i<`CR=aayF3TZ?$tV1nKl`$7g{FWeWBP~TAtiB!w^Li-E603 zmi%`+n8rjg=3Sh!1ZzBtyA0MKmjek2N-DWDHvkgAU=>9iZ#B`WImz{ykFEw|)?#@G z=2<9Uj>mIkt;o)*qMJn(xVfhIsO^k}J9#U@bwSOH;?nzStU#Sf=j*Ul@ir`8>X^RS z;Ua(ak6P&rmNvz`j|A!NUVRORs+30(_IVVmW)%I`n{MmkwQa4-lZWqAbyOPJTy0yh z0&z<5(%;!1TIhSCHdxg`E?VF#Sn#=izAA^4i>j3fbTo~e++iiN!fFLCuUGa=veK0{ z%{V#fmG?{i8Mi85qa#DrB;~TdZ4*$8&+f)!c2{+bh~BB=_i#jGvX)x4WvFwwM-7Xq zcmvLUm17($D0(mt?Mo@^`F0Lxh_)3AR%mqCDo*O}8E)Ue&KchnH3U+kxc0CVLZ;>g z$LmjxAycj{rOXk<*apF8k)?z>7n#%M*b*x=)+ndn#hgt!MmyR@i?vCDv}UD71tmct z2dl4G4WTJ&)M%I0Wf2w*!fnQshByvWd-zLz(QL#NL3zex*@UsSnWwe5V8IdTOlMLE zk*OT-*FKhvqqM?7cDdC!OvYn#(IO^NN|Zc{=a@W;iPM<3w4}8BWzQT=#@se9LUc-1 zh)8+EVi>ZjiUIJB>9u6@bjb3EPq{D;R?GdEm0?ZDB281?L>Jp7ITt%jjL|MNw9$P2 zr>+<6DVl7h@PHnW1NY$6EfrbE8G7VI(dVq1f%>bLElD+{cCI*A?x`K49jT`(Yql)K z;j&!iSyd?}7Y`p1_6MJ!qjrj6vEx>e3aZUn5?U@S2|HzSyJ%`asXZFHc+Yasv6@fn z0L*hYC58yCXkKljL-E=M52K+~b3;1cHjA)o0}e_kCaiJe793E1mKrl{+W}geYD);H zXl7PtkIqsgs%cN^*vU2C&!uz;YUd8sufuK!+}L3AL>~CH0<`uOol8Z>1AWMl#xZ

Buexh@ljO!on&6O!1I-%>PePrtzJuj8jw@r|rr( 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

EdeRlh=v`$sn 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

  • 2hVdr=rZYHTY99Ybz;r7QOcQ1UrdPON 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

    4&W_nf~0N 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

    >40I0{g}d2evrB5eaO| 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ȅ>eto#)lu~w?NGP_ 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

    9Y{|F|!zlvwZ)#|69M|qCEDf2( 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%0ALnHpym>f-(Lv?0=j!}1KkgSF^cSmkjBKj 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 + + + + + + + + + + + diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/DemoProg.workspace.session b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/DemoProg.workspace.session new file mode 100644 index 00000000..9e098eca --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/DemoProg.workspace.session @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/readme.txt b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/readme.txt new file mode 100644 index 00000000..8a340a19 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/readme.txt @@ -0,0 +1,4 @@ +Integrated Development Environment +---------------------------------- +Codelite was used as the editor during the development of this software program. This directory contains the Codelite +workspace and project files. Codelite is a cross platform open source C/C++ IDE, available at http://www.codelite.org/. \ No newline at end of file diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/irq.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/irq.c new file mode 100644 index 00000000..0f469a13 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/irq.c @@ -0,0 +1,97 @@ +/**************************************************************************************** +| Description: IRQ driver source file +| File Name: irq.c +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "header.h" /* generic header */ + + +/**************************************************************************************** +* Local data definitions +****************************************************************************************/ +static unsigned char interruptNesting = 0; /* used for global interrupt en/disable */ + + +/**************************************************************************************** +** NAME: IrqInterruptEnable +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Enables the generation IRQ interrupts. Typically called once during +** software startup after completion of the initialization. +** +****************************************************************************************/ +void IrqInterruptEnable(void) +{ + IntMasterEnable(); +} /*** end of IrqInterruptEnable ***/ + + +/**************************************************************************************** +** NAME: HwInterruptDisable +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Disables the generation IRQ interrupts and stores information on +** whether or not the interrupts were already disabled before explicitly +** disabling them with this function. Normally used as a pair together +** with IrqInterruptRestore during a critical section. +** +****************************************************************************************/ +void IrqInterruptDisable(void) +{ + if (interruptNesting == 0) + { + IntMasterDisable(); + } + interruptNesting++; +} /*** end of IrqInterruptDisable ***/ + + +/**************************************************************************************** +** NAME: IrqInterruptRestore +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Restore the generation IRQ interrupts to the setting it had prior to +** calling IrqInterruptDisable. Normally used as a pair together with +** IrqInterruptDisable during a critical section. +** +****************************************************************************************/ +void IrqInterruptRestore(void) +{ + interruptNesting--; + if (interruptNesting == 0) + { + IntMasterEnable(); + } +} /*** end of IrqInterruptRestore ***/ + + +/*********************************** end of irq.c **************************************/ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/irq.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/irq.h new file mode 100644 index 00000000..73e97bc3 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/irq.h @@ -0,0 +1,43 @@ +/**************************************************************************************** +| Description: IRQ driver header file +| File Name: irq.h +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ +#ifndef IRQ_H +#define IRQ_H + +/**************************************************************************************** +* Function prototypes +****************************************************************************************/ +void IrqInterruptEnable(void); +void IrqInterruptDisable(void); +void IrqInterruptRestore(void); + + +#endif /* IRQ_H */ +/*********************************** end of irq.h **************************************/ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/led.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/led.c new file mode 100644 index 00000000..9c854f68 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/led.c @@ -0,0 +1,101 @@ +/**************************************************************************************** +| Description: LED driver source file +| File Name: led.c +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "header.h" /* generic header */ + + +/**************************************************************************************** +* Macro definitions +****************************************************************************************/ +#define LED_TOGGLE_MS (500) /* toggle interval time in millisecodns */ + + +/**************************************************************************************** +** NAME: LedInit +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Initializes the LED. +** +****************************************************************************************/ +void LedInit(void) +{ + /* enable the peripherals used by the LED driver */ + SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); + /* configure the LED as digital output and turn off the LED */ + GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, 0x01); + GPIOPinWrite(GPIO_PORTF_BASE, 0x01, 0); +} /*** end of LedInit ***/ + + +/**************************************************************************************** +** NAME: LedToggle +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Toggles the LED at a fixed time interval. +** +****************************************************************************************/ +void LedToggle(void) +{ + static unsigned char led_toggle_state = 0; + static unsigned long timer_counter_last = 0; + unsigned long timer_counter_now; + + /* check if toggle interval time passed */ + timer_counter_now = TimeGet(); + if ( (timer_counter_now - timer_counter_last) < LED_TOGGLE_MS) + { + /* not yet time to toggle */ + return; + } + + /* determine toggle action */ + if (led_toggle_state == 0) + { + led_toggle_state = 1; + /* turn the LED on */ + GPIOPinWrite(GPIO_PORTF_BASE, 0x01, 1); + } + else + { + led_toggle_state = 0; + /* turn the LED off */ + GPIOPinWrite(GPIO_PORTF_BASE, 0x01, 0); + } + + /* store toggle time to determine next toggle interval */ + timer_counter_last = timer_counter_now; +} /*** end of LedToggle ***/ + + +/*********************************** end of led.c **************************************/ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/led.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/led.h new file mode 100644 index 00000000..b5126edb --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/led.h @@ -0,0 +1,42 @@ +/**************************************************************************************** +| Description: LED driver header file +| File Name: led.h +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ +#ifndef LED_H +#define LED_H + +/**************************************************************************************** +* Function prototypes +****************************************************************************************/ +void LedInit(void); +void LedToggle(void); + + +#endif /* LED_H */ +/*********************************** end of led.h **************************************/ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/EULA.txt b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/EULA.txt new file mode 100644 index 00000000..7c1cfc7a --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/EULA.txt @@ -0,0 +1,400 @@ +License Agreement + +Important - This is a legally binding agreement. Read it carefully. After you +read the following terms, you will be asked whether you are authorized to +commit your company to abide by the following terms. THIS AGREEMENT IS +DISPLAYED FOR YOU TO READ PRIOR TO DOWNLOADING OR USING THE "LICENSED +MATERIALS". + +DO NOT DOWNLOAD OR INSTALL the software programs unless you agree on behalf of +yourself and your company to be bound by the terms of this License Agreement. + +DO NOT CLICK "I AGREE" UNLESS: + +1. YOU ARE AUTHORIZED TO AGREE TO THE TERMS OF THIS LICENSE ON BEHALF OF +YOURSELF AND YOUR COMPANY; AND + +2. YOU INTEND TO ENTER THIS LEGALLY BINDING AGREEMENT ON BEHALF OF YOURSELF AND +YOUR COMPANY. + +Important - Read carefully: This software license agreement ("Agreement") is a +legal agreement between you (either an individual or entity) and Texas +Instruments Incorporated ("TI"). The "Licensed Materials" subject to this +Agreement include the software programs TI has granted you access to download +and any "on-line" or electronic documentation associated with these programs, +or any portion thereof, and may also include hardware, reference designs and +associated documentation. The Licensed Materials are specifically designed and +licensed for use solely and exclusively with microprocessor/microcontroller +devices manufactured by or for TI ("TI Devices"). By installing, copying or +otherwise using the Licensed Materials you agree to abide by the provisions set +forth herein. This Agreement is displayed for you to read prior to using the +Licensed Materials. If you choose not to accept or agree with these provisions, +do not download or install the Licensed Materials. + +1. Delivery. TI may deliver the Licensed Materials, or portions thereof, to you +electronically. + +2. License Grant and Use Restrictions. + +a. Limited Source Code License. Subject to the terms of this Agreement, and +commencing as of the Effective Date and continuing for the term of this +Agreement, TI hereby grants to you a limited, free, non-transferable, +non-exclusive, non-assignable, non-sub-licensable license to make copies, +prepare derivative works, display internally and use internally the Licensed +Materials provided to you in source code for the sole purposes of designing and +developing object and executable versions of such Licensed Materials or any +derivative thereof, that execute solely and exclusively on TI Devices used in +Customer Product(s), and maintaining and supporting such Licensed Materials, or +any derivative thereof, and Customer Product(s). "Customer Product" means a +final product distributed by or for you that consists of both hardware, +including one or more TI Devices, and software components, including only +executable versions of the Licensed Materials that execute solely and +exclusively on or with such TI Devices and not on devices manufactured by or +for an entity other than TI. + +b. Production and Distribution License. Subject to the terms of this Agreement, +and commencing as of the Effective Date and continuing for the term of this +Agreement, TI hereby grants to you a free, non-exclusive, non-transferable, +non-assignable, worldwide license to: + +(i). Use object code versions of the Licensed Materials, or any derivative +thereof, to make copies, display internally, evaluate, test, distribute +internally and use internally for the sole purposes of designing and developing +Customer Product(s), and maintaining and supporting the Licensed Materials and +Customer Product(s); + +(ii). Make copies, use, sell, offer to sell, and otherwise distribute object +code and executable versions of the Licensed Materials, or any derivative +thereof, for use in or with Customer Product(s), provided that such Licensed +Materials are embedded in or only used with Customer Product(s), and provided +further that such Licensed Materials execute solely and exclusively on a TI +Device and not on any device manufactured by or for an entity other than TI. + +c. Demonstration License. Subject to the terms of this Agreement, and +commencing as of the Effective Date and continuing for the term of this +Agreement, TI grants to you a free, non-transferable, non-exclusive, +non-assignable, non-sub-licensable worldwide license to demonstrate to third +parties the Licensed Materials as they are used in Customer Products executing +solely and exclusively on TI Devices, provided that such Licensed Materials are +demonstrated in object or executable versions only. + +d. Reference Design Use License. Subject to the terms of this Agreement, and +commencing as of the Effective Date and continuing for the term of this +Agreement, TI hereby grants to you a free, non-transferable, non-exclusive, +non-assignable, non-sub-licensable worldwide license to: + +(i). use the Licensed Materials to design, develop, manufacture or have +manufactured, sell, offer to sell, or otherwise distribute Customer Product(s) +or product designs, including portions or derivatives of the Licensed Materials +as they are incorporated in or used with Customer Product(s), provided such +Customer Products or product designs utilize a TI Device. + +e. Contractors and Suppliers. The licenses granted to you hereunder shall +include your on-site and off-site suppliers and independent contractors, while +such suppliers and independent contractors are performing work for or providing +services to you, provided that such suppliers and independent contractors have +executed work-for-hire agreements with you containing terms and conditions not +inconsistent with the terms and conditions set forth is this Agreement and +provided further that such contractors may provide work product to only you +under such work-for-hire agreements. + +f. No Other License. Notwithstanding anything to the contrary, nothing in this +Agreement shall be construed as a license to any intellectual property rights +of TI other than those rights embodied in the Licensed Materials provided to +you by TI. EXCEPT AS PROVIDED HEREIN, NO OTHER LICENSE, EXPRESS OR IMPLIED, BY +ESTOPPEL OR OTHERWISE, TO ANY OTHER TI INTELLECTUAL PROPERTY RIGHTS IS GRANTED +HEREIN. + +g. Restrictions. You shall maintain the source code versions of the Licensed +Materials under password control protection and shall not disclose such source +code versions of the Licensed Materials, or any derivative thereof, to any +person other than your employees and contractors whose job performance requires +access. You shall not use the Licensed Materials with a processing device +manufactured by or for an entity other than TI, and you agree that any such +unauthorized use of the Licensed Materials is a material breach of this +Agreement. Except as expressly provided in this Agreement, you shall not copy, +publish, disclose, display, provide, transfer or make available the Licensed +Materials to any third party and you shall not sublicense, transfer, or assign +the Licensed Materials or your rights under this Agreement to any third party. +You shall not mortgage, pledge or encumber the Licensed Materials in any way. +You shall not (i) incorporate, combine, or distribute the Licensed Materials, +or any derivative thereof, with any Public Software, or (ii) use Public +Software in the development of any derivatives of the Licensed Materials, each +in such a way that would cause the Licensed Materials, or any derivative +thereof, to be subject to all or part of the license obligations or other +intellectual property related terms with respect to such Public Software, +including but not limited to, the obligations that the Licensed Materials, or +any derivative thereof, incorporated into, combined, or distributed with such +Public Software (x) be disclosed or distributed in source code form, be +licensed for the purpose of making derivatives of such software, or be +redistributed free of charge, contrary to the terms and conditions of this +Agreement, (y) be used with devices other than TI Devices, or (z) be otherwise +used or distributed in a manner contrary to the terms and conditions of this +Agreement. As used in this Section 2(g), "Public Software" means any software +that contains, or is derived in whole or in part from, any software distributed +as open source software, including but not limited to software licensed under +the following or similar models: (A) GNU's General Public License (GPL) or +Lesser/Library GPL (LGPL), (B) the Artistic License (e.g., PERL), (C) the +Mozilla Public License, (D) the Netscape Public License, (E) the Sun Community +Source License (SCSL), (F) the Sun Industry Standards Source License (SISL), +(G) the Apache Server license, (H) QT Free Edition License, (I) IBM Public +License, and (J) BitKeeper. + +h. Termination. This Agreement is effective until terminated. You may terminate +this Agreement at any time by written notice to TI. Without prejudice to any +other rights, if you fail to comply with the terms of this Agreement, TI may +terminate your right to use the Licensed Materials upon written notice to you. +Upon termination of this Agreement, you will destroy any and all copies of the +Licensed Materials in your possession, custody or control and provide to TI a +written statement signed by your authorized representative certifying such +destruction. The following sections will survive any expiration or termination +of this Agreement: 2(h) (Termination), 3 (Licensed Materials Ownership), 6 +(Warranties and Limitations), 7 (Indemnification Disclaimer), 10 (Export +Control), 11 (Governing Law and Severability), 12 (PRC Provisions), and 13 +(Entire Agreement). The obligations set forth in Section 5 (Confidential +Information) will survive any expiration or termination of this Agreement for +three (3) years after such expiration or termination. + +3. Licensed Materials Ownership. The Licensed Materials are licensed, not sold +to you, and can only be used in accordance with the terms of this Agreement. +Subject to the licenses granted to you pursuant to this Agreement, TI and TI's +licensors own and shall continue to own all right, title, and interest in and +to the Licensed Materials, including all copies thereof. The parties agree that +all fixes, modifications and improvements to the Licensed Materials conceived +of or made by TI that are based, either in whole or in part, on your feedback, +suggestions or recommendations are the exclusive property of TI and all right, +title and interest in and to such fixes, modifications or improvements to the +Licensed Materials will vest solely in TI. Moreover, you acknowledge and agree +that when your independently developed software or hardware components are +combined, in whole or in part, with the Licensed Materials, your right to use +the Licensed Materials embodied in such resulting combined work shall remain +subject to the terms and conditions of this Agreement. + +4. Intellectual Property Rights. + +a. The Licensed Materials contain copyrighted material, trade secrets and other +proprietary information of TI and TI's licensors and are protected by copyright +laws, international copyright treaties, and trade secret laws, as well as other +intellectual property laws. To protect TI's and TI's licensors' rights in the +Licensed Materials, you agree, except as specifically permitted by statute by a +provision that cannot be waived by contract, not to "unlock", decompile, +reverse engineer, disassemble or otherwise translate any portions of the +Licensed Materials to a human-perceivable form nor to permit any person or +entity to do so. You shall not remove, alter, cover, or obscure any +confidentiality, trade secret, proprietary, or copyright notices, trade-marks, +proprietary, patent, or other identifying marks or designs from any component +of the Licensed Materials and you shall reproduce and include in all copies of +the Licensed Materials the copyright notice(s) and proprietary legend(s) of TI +and TI's licensors as they appear in the Licensed Materials. TI reserves all +rights not specifically granted under this Agreement. + +b. Third parties may claim to own patents, copyrights, or other intellectual +property rights that cover the implementation of certain Licensed Materials. +Certain Licensed Materials may also be based on industry recognized standards, +including but not limited to specifically the ISO MPEG and ITU standards, and +software programs published by industry recognized standards bodies and certain +third parties claim to own patents, copyrights, and other intellectual property +rights that cover implementation of those standards. You acknowledge and agree +that this Agreement does not convey a license to any such third party patents, +copyrights, and other intellectual property rights and that you are solely +responsible for any patent, copyright, or other intellectual property right +claims that relate to your use and distribution of the Licensed Materials, and +your use and distribution of your products that include or incorporate the +Licensed Materials. + +5. Confidential Information. You acknowledge and agree that the Licensed +Materials contain trade secrets and other confidential information of TI and +TI's licensors. You agree to use the Licensed Materials solely within the scope +of the licenses set forth herein, to maintain the Licensed Materials in strict +confidence, to use at least the same procedures and degree of care that you use +to prevent disclosure of your own confidential information of like importance +but in no instance less than reasonable care, and to prevent disclosure of the +Licensed Materials to any third party, except as may be necessary and required +in connection with your rights and obligations hereunder. You agree to obtain +executed confidentiality agreements with your employees and contractors having +access to the Licensed Materials and to diligently take steps to enforce such +agreements in this respect. TI agrees that the employment agreements used in +the normal course of your business shall satisfy the requirements of this +section. TI may disclose your contact information to TI's applicable licensors. + +6. Warranties and Limitations. YOU ACKNOWLEDGE AND AGREE THAT THE LICENSED +MATERIALS MAY NOT BE INTENDED FOR PRODUCTION APPLICATIONS AND MAY CONTAIN +IRREGULARITIES AND DEFECTS NOT FOUND IN PRODUCTION SOFTWARE. FURTHERMORE, YOU +ACKNOWLEDGE AND AGREE THAT THE LICENSED MATERIALS HAVE NOT BEEN TESTED OR +CERTIFIED BY ANY GOVERNMENT AGENCY OR INDUSTRY REGULATORY ORGANIZATION OR ANY +OTHER THIRD PARTY ORGANIZATION. YOU AGREE THAT PRIOR TO USING, INCORPORATING OR +DISTRIBUTING THE LICENSED MATERIALS IN OR WITH ANY COMMERCIAL PRODUCT THAT YOU +WILL THOROUGHLY TEST THE PRODUCT AND THE FUNCTIONALITY OF THE LICENSED +MATERIALS IN OR WITH THAT PRODUCT AND BE SOLELY RESPONSIBLE FOR ANY PROBLEMS OR +FAILURES. + +THE LICENSED MATERIALS AND ANY REALTED DOCUMENTATION ARE PROVIDED "AS IS" AND +WITH ALL FAULTS. TI MAKES NO WARRANTY OR REPRESENTATION, WHETHER EXPRESS, +IMPLIED OR STATUTORY, REGARDING THE LICENSED MATERIALS, INCLUDING BUT NOT +LIMITED TO, ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A +PARTICULAR PURPOSE, LACK OF VIRUSES, ACCURACY OR COMPLETENESS OF RESPONSES, +RESULTS AND LACK OF NEGLIGENCE. TI DISCLAIMS ANY WARRANTY OF TITLE, QUIET +ENJOYMENT, QUIET POSSESSION, AND NON-INFRINGEMENT OF ANY THIRD PARTY PATENTS, +COPYRIGHTS, TRADE SECRETS OR OTHER INTELLECTUAL PROPERTY RIGHTS. YOU AGREE TO +USE YOUR INDEPENDENT JUDGMENT IN DEVELOPING YOUR PRODUCTS. NOTHING CONTAINED IN +THIS AGREEMENT WILL BE CONSTRUED AS A WARRANTY OR REPRESENTATION BY TI TO +MAINTAIN PRODUCTION OF ANY TI SEMICONDUCTOR DEVICE OR OTHER HARDWARE OR +SOFTWARE WITH WHICH THE LICENSED MATERIALS MAY BE USED. + +IN NO EVENT SHALL TI, OR ANY APPLICABLE LICENSOR, BE LIABLE FOR ANY SPECIAL, +INDIRECT, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL DAMAGES, HOWEVER CAUSED, ON ANY +THEORY OF LIABILITY, IN CONNECTION WITH OR ARISING OUT OF THIS AGREEMENT OR THE +USE OF THE LICENSED MATERIALS, REGARDLESS OF WHETHER TI HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. EXCLUDED DAMAGES INCLUDE, BUT ARE NOT LIMITED TO, +COST OF REMOVAL OR REINSTALLATION, OUTSIDE COMPUTER TIME, LABOR COSTS, LOSS OF +DATA, LOSS OF GOODWILL, LOSS OF PROFITS, LOSS OF SAVINGS, OR LOSS OF USE OR +INTERRUPTION OF BUSINESS. IN NO EVENT WILL TI'S AGGREGATE LIABILITY UNDER THIS +AGREEMENT OR ARISING OUT OF YOUR USE OF THE LICENSED MATERIALS EXCEED FIVE +HUNDRED U.S. DOLLARS (US$500). THE EXISTENCE OF MORE THAN ONE CLAIM WILL NOT +ENLARGE OR EXTEND THESE LIMITS. + +Because some jurisdictions do not allow the exclusion or limitation of +incidental or consequential damages or limitation on how long an implied +warranty lasts, the above limitations or exclusions may not apply to you. + +7. Indemnification Disclaimer. YOU ACKNOWLEDGE AND AGREE THAT TI SHALL NOT BE +LIABLE FOR AND SHALL NOT DEFEND OR INDEMNIFY YOU AGAINST ANY THIRD PARTY +INFRINGEMENT CLAIM THAT RELATES TO OR IS BASED ON YOUR MANUFACTURE, USE, OR +DISTRIBUTION OF THE LICENSED MATERIALS OR YOUR MANUFACTURE, USE, OFFER FOR +SALE, SALE, IMPORTATION OR DISTRIBUTION OF YOUR PRODUCTS THAT INCLUDE OR +INCORPORATE THE LICENSED MATERIALS. + +You will defend and indemnify TI in the event of claim, liability or costs +(including reasonable attorney's fees related to Your use or any sub-licensee's +use of the Licensed Materials) relating in any way to Your violation of the +terms of the License Grants set forth in Section 2, or any other violation of +other terms and conditions of this Agreement. + +8. No Technical Support. TI and TI's licensors are under no obligation to +install, maintain or support the Licensed Materials. + +9. Notices. All notices to TI hereunder shall be delivered to Texas Instruments +Incorporated, AEC Software Operations, 12203 Southwest Freeway, Mail Station +701, Stafford, Texas 77477, Attention: Administrator, AEC Software Operations, +with a copy to Texas Instruments Incorporated, 12203 Southwest Freeway, Mail +Station 725, Stafford, Texas 77477, Attention: Legal Department. All notices +shall be deemed served when received by TI. + +10. Export Control. You hereby acknowledge that the Licensed Materials are +subject to export control under the U.S. Commerce Department's Export +Administration Regulations ("EAR"). You further hereby acknowledge and agree +that unless prior authorization is obtained from the U.S. Commerce Department, +neither you nor your customers will export, re-export, or release, directly or +indirectly, any technology, software, or software source code (as defined in +Part 772 of the EAR), received from TI, or export, directly or indirectly, any +direct product of such technology, software, or software source code (as +defined in Part 734 of the EAR), to any destination or country to which the +export, re-export, or release of the technology, software, or software source +code, or direct product is prohibited by the EAR. You agree that none of the +Licensed Materials may be downloaded or otherwise exported or reexported (i) +into (or to a national or resident of) Cuba, Iran, North Korea, Sudan and Syria +or any other country the U.S. has embargoed goods; or (ii) to anyone on the +U.S. Treasury Department's List of Specially Designated Nationals or the U.S. +Commerce Department's Denied Persons List or Entity List. You represent and +warrant that you are not located in, under the control of, or a national or +resident of any such country or on any such list and you will not use or +transfer the Licensed Materials for use in any sensitive nuclear, chemical or +biological weapons, or missile technology end-uses unless authorized by the +U.S. Government by regulation or specific license or for a military end-use in, +or by any military entity of Albania, Armenia, Azerbaijan, Belarus, Cambodia, +China, Georgia, Iran, Iraq, Kazakhstan, Kyrgyzstan, Laos, Libya, Macau, +Moldova, Mongolia, Russia, Tajikistan, Turkmenistan, Ukraine, Uzbekistan, and +Vietnam. Any software export classification made by TI shall be for TI's +internal use only and shall not be construed as a representation or warranty +regarding the proper export classification for such software or whether an +export license or other documentation is required for the exportation of such +software. + +11. Governing Law and Severability. This Agreement will be governed by and +interpreted in accordance with the laws of the State of Texas, without +reference to conflict of laws principles. If for any reason a court of +competent jurisdiction finds any provision of the Agreement to be +unenforceable, that provision will be enforced to the maximum extent possible +to effectuate the intent of the parties, and the remainder of the Agreement +shall continue in full force and effect. This Agreement shall not be governed +by the United Nations Convention on Contracts for the International Sale of +Goods, or by the Uniform Computer Information Transactions Act (UCITA), as it +may be enacted in the State of Texas. The parties agree that non-exclusive +jurisdiction for any dispute arising out of or relating to this Agreement lies +within the courts located in the State of Texas. Notwithstanding the foregoing, +any judgment may be enforced in any United States or foreign court, and either +party may seek injunctive relief in any United States or foreign court. + +12. PRC Provisions. If you are located in the People's Republic of China +("PRC") or if the Licensed Materials will be sent to the PRC, the following +provisions shall apply and shall supersede any other provisions in this +Agreement concerning the same subject matter as the following provisions: + +a. Registration Requirements. You shall be solely responsible for performing +all acts and obtaining all approvals that may be required in connection with +this Agreement by the government of the PRC, including but not limited to +registering pursuant to, and otherwise complying with, the PRC Measures on the +Administration of Software Products, Management Regulations on Technology +Import-Export, and Technology Import and Export Contract Registration +Management Rules. Upon receipt of such approvals from the government +authorities, you shall forward evidence of all such approvals to TI for its +records. In the event that you fail to obtain any such approval or +registration, you shall be solely responsible for any and all losses, damages +or costs resulting therefrom, and shall indemnify TI for all such losses, +damages or costs. + +b. Governing Language. This Agreement is written and executed in the English +language. If a translation of this Agreement is required for any purpose, +including but not limited to registration of the Agreement pursuant to any +governmental laws, regulations or rules, you shall be solely responsible for +creating such translation. Any translation of this Agreement into a language +other than English is intended solely in order to comply with such laws or for +reference purposes, and the English language version shall be authoritative and +controlling. + +c. Export Control. + +(i). Diversions of Technology. You hereby agree that unless prior authorization +is obtained from the U.S. Department of Commerce, neither you nor your +subsidiaries or affiliates shall knowingly export, re-export, or release, +directly or indirectly, any technology, software, or software source code (as +defined in Part 772 of the Export Administration Regulations of the U.S. +Department of Commerce ("EAR")), received from TI or any of its affiliated +companies, or export, directly or indirectly, any direct product of such +technology, software, or software source code (as defined in Part 734 of the +EAR), to any destination or country to which the export, re-export, or release +of the technology, software, software source code, or direct product is +prohibited by the EAR. + +(ii). Assurance of Compliance. You understand and acknowledge that products, +technology (regardless of the form in which it is provided), software or +software source code, received from TI or any of its affiliates under this +Agreement may be under export control of the United States or other countries. +You shall comply with the United States and other applicable non-U.S. laws and +regulations governing the export, re-export and release of any products, +technology, software, or software source code received under this Agreement +from TI or its affiliates. You shall not undertake any action that is +prohibited by the EAR. Without limiting the generality of the foregoing, you +specifically agree that you shall not transfer or release products, technology, +software, or software source code of TI or its affiliates to, or for use by, +military end users or for use in military, missile, nuclear, biological, or +chemical weapons end uses. + +(iii). Licenses. Each party shall secure at its own expense, such licenses and +export and import documents as are necessary for each respective party to +fulfill its obligations under this Agreement. If such licenses or government +approvals cannot be obtained, TI may terminate this Agreement, or shall +otherwise be excused from the performance of any obligations it may have under +this Agreement for which the licenses or government approvals are required. + +13. Entire Agreement. This is the entire Agreement between you and TI, and +absent a signed and effective software license agreement related to the subject +matter of this Agreement, this Agreement supersedes any prior agreement between +the parties related to the subject matter of this Agreement. Notwithstanding +the foregoing, any signed and effective software license agreement relating to +the subject matter hereof will supersede the terms of this Agreement. No +amendment or modification of this Agreement will be effective unless in writing +and signed by a duly authorized representative of TI. You hereby warrant and +represent that you have obtained all authorizations and other applicable +consents required empowering you to enter into this Agreement. + diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/adc.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/adc.c new file mode 100644 index 00000000..d6ef5ccc --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/adc.c @@ -0,0 +1,1470 @@ +//***************************************************************************** +// +// adc.c - Driver for the ADC. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup adc_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_adc.h" +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_types.h" +#include "driverlib/adc.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" + +//***************************************************************************** +// +// These defines are used by the ADC driver to simplify access to the ADC +// sequencer's registers. +// +//***************************************************************************** +#define ADC_SEQ (ADC_O_SSMUX0) +#define ADC_SEQ_STEP (ADC_O_SSMUX1 - ADC_O_SSMUX0) +#define ADC_SSMUX (ADC_O_SSMUX0 - ADC_O_SSMUX0) +#define ADC_SSCTL (ADC_O_SSCTL0 - ADC_O_SSMUX0) +#define ADC_SSFIFO (ADC_O_SSFIFO0 - ADC_O_SSMUX0) +#define ADC_SSFSTAT (ADC_O_SSFSTAT0 - ADC_O_SSMUX0) +#define ADC_SSOP (ADC_O_SSOP0 - ADC_O_SSMUX0) +#define ADC_SSDC (ADC_O_SSDC0 - ADC_O_SSMUX0) + +//***************************************************************************** +// +// The currently configured software oversampling factor for each of the ADC +// sequencers. +// +//***************************************************************************** +static unsigned char g_pucOversampleFactor[3]; + +//***************************************************************************** +// +//! Registers an interrupt handler for an ADC interrupt. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! \param pfnHandler is a pointer to the function to be called when the +//! ADC sample sequence interrupt occurs. +//! +//! This function sets the handler to be called when a sample sequence +//! interrupt occurs. This will enable the global interrupt in the interrupt +//! controller; the sequence interrupt must be enabled with ADCIntEnable(). It +//! is the interrupt handler's responsibility to clear the interrupt source via +//! ADCIntClear(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +ADCIntRegister(unsigned long ulBase, unsigned long ulSequenceNum, + void (*pfnHandler)(void)) +{ + unsigned long ulInt; + + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + + // + // Determine the interrupt to register based on the sequence number. + // + ulInt = ((ulBase == ADC0_BASE) ? (INT_ADC0SS0 + ulSequenceNum) : + (INT_ADC1SS0 + ulSequenceNum)); + + // + // Register the interrupt handler. + // + IntRegister(ulInt, pfnHandler); + + // + // Enable the timer interrupt. + // + IntEnable(ulInt); +} + +//***************************************************************************** +// +//! Unregisters the interrupt handler for an ADC interrupt. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! +//! This function unregisters the interrupt handler. This will disable the +//! global interrupt in the interrupt controller; the sequence interrupt must +//! be disabled via ADCIntDisable(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +ADCIntUnregister(unsigned long ulBase, unsigned long ulSequenceNum) +{ + unsigned long ulInt; + + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + + // + // Determine the interrupt to unregister based on the sequence number. + // + ulInt = ((ulBase == ADC0_BASE) ? (INT_ADC0SS0 + ulSequenceNum) : + (INT_ADC1SS0 + ulSequenceNum)); + + // + // Disable the interrupt. + // + IntDisable(ulInt); + + // + // Unregister the interrupt handler. + // + IntUnregister(ulInt); +} + +//***************************************************************************** +// +//! Disables a sample sequence interrupt. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! +//! This function disables the requested sample sequence interrupt. +//! +//! \return None. +// +//***************************************************************************** +void +ADCIntDisable(unsigned long ulBase, unsigned long ulSequenceNum) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + + // + // Disable this sample sequence interrupt. + // + HWREG(ulBase + ADC_O_IM) &= ~(1 << ulSequenceNum); +} + +//***************************************************************************** +// +//! Enables a sample sequence interrupt. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! +//! This function enables the requested sample sequence interrupt. Any +//! outstanding interrupts are cleared before enabling the sample sequence +//! interrupt. +//! +//! \return None. +// +//***************************************************************************** +void +ADCIntEnable(unsigned long ulBase, unsigned long ulSequenceNum) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + + // + // Clear any outstanding interrupts on this sample sequence. + // + HWREG(ulBase + ADC_O_ISC) = 1 << ulSequenceNum; + + // + // Enable this sample sequence interrupt. + // + HWREG(ulBase + ADC_O_IM) |= 1 << ulSequenceNum; +} + +//***************************************************************************** +// +//! Gets the current interrupt status. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! \param bMasked is false if the raw interrupt status is required and true if +//! the masked interrupt status is required. +//! +//! This returns the interrupt status for the specified sample sequence. +//! Either the raw interrupt status or the status of interrupts that are +//! allowed to reflect to the processor can be returned. +//! +//! \return The current raw or masked interrupt status. +// +//***************************************************************************** +unsigned long +ADCIntStatus(unsigned long ulBase, unsigned long ulSequenceNum, + tBoolean bMasked) +{ + unsigned long ulTemp; + + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + ulTemp = HWREG(ulBase + ADC_O_ISC) & (0x10001 << ulSequenceNum); + } + else + { + ulTemp = HWREG(ulBase + ADC_O_RIS) & (0x10000 | (1 << ulSequenceNum)); + + // + // If the digital comparator status bit is set, reflect it to the + // appropriate sequence bit. + // + if(ulTemp & 0x10000) + { + ulTemp |= 0xF0000; + ulTemp &= ~(0x10000 << ulSequenceNum); + } + } + + // + // Return the interrupt status + // + return(ulTemp); +} + +//***************************************************************************** +// +//! Clears sample sequence interrupt source. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! +//! The specified sample sequence interrupt is cleared, so that it no longer +//! asserts. This must be done in the interrupt handler to keep it from being +//! called again immediately upon exit. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +ADCIntClear(unsigned long ulBase, unsigned long ulSequenceNum) +{ + // + // Check the arugments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + + // + // Clear the interrupt. + // + HWREG(ulBase + ADC_O_ISC) = 1 << ulSequenceNum; +} + +//***************************************************************************** +// +//! Enables a sample sequence. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! +//! Allows the specified sample sequence to be captured when its trigger is +//! detected. A sample sequence must be configured before it is enabled. +//! +//! \return None. +// +//***************************************************************************** +void +ADCSequenceEnable(unsigned long ulBase, unsigned long ulSequenceNum) +{ + // + // Check the arugments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + + // + // Enable the specified sequence. + // + HWREG(ulBase + ADC_O_ACTSS) |= 1 << ulSequenceNum; +} + +//***************************************************************************** +// +//! Disables a sample sequence. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! +//! Prevents the specified sample sequence from being captured when its trigger +//! is detected. A sample sequence should be disabled before it is configured. +//! +//! \return None. +// +//***************************************************************************** +void +ADCSequenceDisable(unsigned long ulBase, unsigned long ulSequenceNum) +{ + // + // Check the arugments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + + // + // Disable the specified sequences. + // + HWREG(ulBase + ADC_O_ACTSS) &= ~(1 << ulSequenceNum); +} + +//***************************************************************************** +// +//! Configures the trigger source and priority of a sample sequence. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! \param ulTrigger is the trigger source that initiates the sample sequence; +//! must be one of the \b ADC_TRIGGER_* values. +//! \param ulPriority is the relative priority of the sample sequence with +//! respect to the other sample sequences. +//! +//! This function configures the initiation criteria for a sample sequence. +//! Valid sample sequences range from zero to three; sequence zero will capture +//! up to eight samples, sequences one and two will capture up to four samples, +//! and sequence three will capture a single sample. The trigger condition and +//! priority (with respect to other sample sequence execution) is set. +//! +//! The \e ulTrigger parameter can take on the following values: +//! +//! - \b ADC_TRIGGER_PROCESSOR - A trigger generated by the processor, via the +//! ADCProcessorTrigger() function. +//! - \b ADC_TRIGGER_COMP0 - A trigger generated by the first analog +//! comparator; configured with ComparatorConfigure(). +//! - \b ADC_TRIGGER_COMP1 - A trigger generated by the second analog +//! comparator; configured with ComparatorConfigure(). +//! - \b ADC_TRIGGER_COMP2 - A trigger generated by the third analog +//! comparator; configured with ComparatorConfigure(). +//! - \b ADC_TRIGGER_EXTERNAL - A trigger generated by an input from the Port +//! B4 pin. +//! - \b ADC_TRIGGER_TIMER - A trigger generated by a timer; configured with +//! TimerControlTrigger(). +//! - \b ADC_TRIGGER_PWM0 - A trigger generated by the first PWM generator; +//! configured with PWMGenIntTrigEnable(). +//! - \b ADC_TRIGGER_PWM1 - A trigger generated by the second PWM generator; +//! configured with PWMGenIntTrigEnable(). +//! - \b ADC_TRIGGER_PWM2 - A trigger generated by the third PWM generator; +//! configured with PWMGenIntTrigEnable(). +//! - \b ADC_TRIGGER_PWM3 - A trigger generated by the fourth PWM generator; +//! configured with PWMGenIntTrigEnable(). +//! - \b ADC_TRIGGER_ALWAYS - A trigger that is always asserted, causing the +//! sample sequence to capture repeatedly (so long as +//! there is not a higher priority source active). +//! +//! Note that not all trigger sources are available on all Stellaris family +//! members; consult the data sheet for the device in question to determine the +//! availability of triggers. +//! +//! The \e ulPriority parameter is a value between 0 and 3, where 0 represents +//! the highest priority and 3 the lowest. Note that when programming the +//! priority among a set of sample sequences, each must have unique priority; +//! it is up to the caller to guarantee the uniqueness of the priorities. +//! +//! \return None. +// +//***************************************************************************** +void +ADCSequenceConfigure(unsigned long ulBase, unsigned long ulSequenceNum, + unsigned long ulTrigger, unsigned long ulPriority) +{ + // + // Check the arugments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + ASSERT((ulTrigger == ADC_TRIGGER_PROCESSOR) || + (ulTrigger == ADC_TRIGGER_COMP0) || + (ulTrigger == ADC_TRIGGER_COMP1) || + (ulTrigger == ADC_TRIGGER_COMP2) || + (ulTrigger == ADC_TRIGGER_EXTERNAL) || + (ulTrigger == ADC_TRIGGER_TIMER) || + (ulTrigger == ADC_TRIGGER_PWM0) || + (ulTrigger == ADC_TRIGGER_PWM1) || + (ulTrigger == ADC_TRIGGER_PWM2) || + (ulTrigger == ADC_TRIGGER_PWM3) || + (ulTrigger == ADC_TRIGGER_ALWAYS)); + ASSERT(ulPriority < 4); + + // + // Compute the shift for the bits that control this sample sequence. + // + ulSequenceNum *= 4; + + // + // Set the trigger event for this sample sequence. + // + HWREG(ulBase + ADC_O_EMUX) = ((HWREG(ulBase + ADC_O_EMUX) & + ~(0xf << ulSequenceNum)) | + ((ulTrigger & 0xf) << ulSequenceNum)); + + // + // Set the priority for this sample sequence. + // + HWREG(ulBase + ADC_O_SSPRI) = ((HWREG(ulBase + ADC_O_SSPRI) & + ~(0xf << ulSequenceNum)) | + ((ulPriority & 0x3) << ulSequenceNum)); +} + +//***************************************************************************** +// +//! Configure a step of the sample sequencer. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! \param ulStep is the step to be configured. +//! \param ulConfig is the configuration of this step; must be a logical OR of +//! \b ADC_CTL_TS, \b ADC_CTL_IE, \b ADC_CTL_END, \b ADC_CTL_D, and one of the +//! input channel selects (\b ADC_CTL_CH0 through \b ADC_CTL_CH15). For parts +//! with the digital comparator feature, the follow values may also be OR'd +//! into the \e ulConfig value to enable the digital comparater feature: +//! \b ADC_CTL_CE and one of the comparater selects (\b ADC_CTL_CMP0 through +//! \b ADC_CTL_CMP7). +//! +//! This function will set the configuration of the ADC for one step of a +//! sample sequence. The ADC can be configured for single-ended or +//! differential operation (the \b ADC_CTL_D bit selects differential +//! operation when set), the channel to be sampled can be chosen (the +//! \b ADC_CTL_CH0 through \b ADC_CTL_CH15 values), and the internal +//! temperature sensor can be selected (the \b ADC_CTL_TS bit). Additionally, +//! this step can be defined as the last in the sequence (the \b ADC_CTL_END +//! bit) and it can be configured to cause an interrupt when the step is +//! complete (the \b ADC_CTL_IE bit). If the digital comparators are present +//! on the device, this step may also be configured send the ADC sample to +//! the selected comparator (the \b ADC_CTL_CMP0 through \b ADC_CTL_CMP7 +//! values) by using the \b ADC_CTL_CE bit. The configuration is used by the +//! ADC at the appropriate time when the trigger for this sequence occurs. +//! +//! \note If the Digitial Comparator is present and enabled using the +//! \b ADC_CTL_CE bit, the ADC sample will NOT be written into the ADC +//! sequence data FIFO. +//! +//! The \e ulStep parameter determines the order in which the samples are +//! captured by the ADC when the trigger occurs. It can range from zero to +//! seven for the first sample sequence, from zero to three for the second and +//! third sample sequence, and can only be zero for the fourth sample sequence. +//! +//! Differential mode only works with adjacent channel pairs (for example, 0 +//! and 1). The channel select must be the number of the channel pair to +//! sample (for example, \b ADC_CTL_CH0 for 0 and 1, or \b ADC_CTL_CH1 for 2 +//! and 3) or undefined results will be returned by the ADC. Additionally, if +//! differential mode is selected when the temperature sensor is being sampled, +//! undefined results will be returned by the ADC. +//! +//! It is the responsibility of the caller to ensure that a valid configuration +//! is specified; this function does not check the validity of the specified +//! configuration. +//! +//! \return None. +// +//***************************************************************************** +void +ADCSequenceStepConfigure(unsigned long ulBase, unsigned long ulSequenceNum, + unsigned long ulStep, unsigned long ulConfig) +{ + unsigned long ulTemp; + + // + // Check the arugments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + ASSERT(((ulSequenceNum == 0) && (ulStep < 8)) || + ((ulSequenceNum == 1) && (ulStep < 4)) || + ((ulSequenceNum == 2) && (ulStep < 4)) || + ((ulSequenceNum == 3) && (ulStep < 1))); + + // + // Get the offset of the sequence to be configured. + // + ulBase += ADC_SEQ + (ADC_SEQ_STEP * ulSequenceNum); + + // + // Compute the shift for the bits that control this step. + // + ulStep *= 4; + + // + // Set the analog mux value for this step. + // + HWREG(ulBase + ADC_SSMUX) = ((HWREG(ulBase + ADC_SSMUX) & + ~(0x0000000f << ulStep)) | + ((ulConfig & 0x0f) << ulStep)); + + // + // Set the control value for this step. + // + HWREG(ulBase + ADC_SSCTL) = ((HWREG(ulBase + ADC_SSCTL) & + ~(0x0000000f << ulStep)) | + (((ulConfig & 0xf0) >> 4) << ulStep)); + + // + // Enable digital comparator if specified in the ulConfig bit-fields. + // + if(ulConfig & 0x000F0000) + { + // + // Program the comparator for the specified step. + // + ulTemp = HWREG(ulBase + ADC_SSDC); + ulTemp &= ~(0xF << ulStep); + ulTemp |= (((ulConfig & 0x00070000) >> 16) << ulStep); + HWREG(ulBase + ADC_SSDC) = ulTemp; + + // + // Enable the comparator. + // + ulTemp = HWREG(ulBase + ADC_SSOP); + ulTemp |= (1 << ulStep); + HWREG(ulBase + ADC_SSOP) = ulTemp; + } + + // + // Disable digital comparator if not specified. + // + else + { + ulTemp = HWREG(ulBase + ADC_SSOP); + ulTemp &= ~(1 << ulStep); + HWREG(ulBase + ADC_SSOP) = ulTemp; + } +} + +//***************************************************************************** +// +//! Determines if a sample sequence overflow occurred. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! +//! This determines if a sample sequence overflow has occurred. This will +//! happen if the captured samples are not read from the FIFO before the next +//! trigger occurs. +//! +//! \return Returns zero if there was not an overflow, and non-zero if there +//! was. +// +//***************************************************************************** +long +ADCSequenceOverflow(unsigned long ulBase, unsigned long ulSequenceNum) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + + // + // Determine if there was an overflow on this sequence. + // + return(HWREG(ulBase + ADC_O_OSTAT) & (1 << ulSequenceNum)); +} + +//***************************************************************************** +// +//! Clears the overflow condition on a sample sequence. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! +//! This will clear an overflow condition on one of the sample sequences. The +//! overflow condition must be cleared in order to detect a subsequent overflow +//! condition (it otherwise causes no harm). +//! +//! \return None. +// +//***************************************************************************** +void +ADCSequenceOverflowClear(unsigned long ulBase, unsigned long ulSequenceNum) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + + // + // Clear the overflow condition for this sequence. + // + HWREG(ulBase + ADC_O_OSTAT) = 1 << ulSequenceNum; +} + +//***************************************************************************** +// +//! Determines if a sample sequence underflow occurred. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! +//! This determines if a sample sequence underflow has occurred. This will +//! happen if too many samples are read from the FIFO. +//! +//! \return Returns zero if there was not an underflow, and non-zero if there +//! was. +// +//***************************************************************************** +long +ADCSequenceUnderflow(unsigned long ulBase, unsigned long ulSequenceNum) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + + // + // Determine if there was an underflow on this sequence. + // + return(HWREG(ulBase + ADC_O_USTAT) & (1 << ulSequenceNum)); +} + +//***************************************************************************** +// +//! Clears the underflow condition on a sample sequence. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! +//! This will clear an underflow condition on one of the sample sequences. The +//! underflow condition must be cleared in order to detect a subsequent +//! underflow condition (it otherwise causes no harm). +//! +//! \return None. +// +//***************************************************************************** +void +ADCSequenceUnderflowClear(unsigned long ulBase, unsigned long ulSequenceNum) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + + // + // Clear the underflow condition for this sequence. + // + HWREG(ulBase + ADC_O_USTAT) = 1 << ulSequenceNum; +} + +//***************************************************************************** +// +//! Gets the captured data for a sample sequence. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! \param pulBuffer is the address where the data is stored. +//! +//! This function copies data from the specified sample sequence output FIFO to +//! a memory resident buffer. The number of samples available in the hardware +//! FIFO are copied into the buffer, which is assumed to be large enough to +//! hold that many samples. This will only return the samples that are +//! presently available, which may not be the entire sample sequence if it is +//! in the process of being executed. +//! +//! \return Returns the number of samples copied to the buffer. +// +//***************************************************************************** +long +ADCSequenceDataGet(unsigned long ulBase, unsigned long ulSequenceNum, + unsigned long *pulBuffer) +{ + unsigned long ulCount; + + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + + // + // Get the offset of the sequence to be read. + // + ulBase += ADC_SEQ + (ADC_SEQ_STEP * ulSequenceNum); + + // + // Read samples from the FIFO until it is empty. + // + ulCount = 0; + while(!(HWREG(ulBase + ADC_SSFSTAT) & ADC_SSFSTAT0_EMPTY) && (ulCount < 8)) + { + // + // Read the FIFO and copy it to the destination. + // + *pulBuffer++ = HWREG(ulBase + ADC_SSFIFO); + + // + // Increment the count of samples read. + // + ulCount++; + } + + // + // Return the number of samples read. + // + return(ulCount); +} + +//***************************************************************************** +// +//! Causes a processor trigger for a sample sequence. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number, with +//! \b ADC_TRIGGER_WAIT or \b ADC_TRIGGER_SIGNAL optionally ORed into it. +//! +//! This function triggers a processor-initiated sample sequence if the sample +//! sequence trigger is configured to \b ADC_TRIGGER_PROCESSOR. If +//! \b ADC_TRIGGER_WAIT is ORed into the sequence number, the +//! processor-initiated trigger is delayed until a later processor-initiated +//! trigger to a different ADC module that specifies \b ADC_TRIGGER_SIGNAL, +//! allowing multiple ADCs to start from a processor-initiated trigger in a +//! synchronous manner. +//! +//! \return None. +// +//***************************************************************************** +void +ADCProcessorTrigger(unsigned long ulBase, unsigned long ulSequenceNum) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT((ulSequenceNum & 0xf) < 4); + + // + // Generate a processor trigger for this sample sequence. + // + HWREG(ulBase + ADC_O_PSSI) = ((ulSequenceNum & 0xffff0000) | + (1 << (ulSequenceNum & 0xf))); +} + +//***************************************************************************** +// +//! Configures the software oversampling factor of the ADC. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! \param ulFactor is the number of samples to be averaged. +//! +//! This function configures the software oversampling for the ADC, which can +//! be used to provide better resolution on the sampled data. Oversampling is +//! accomplished by averaging multiple samples from the same analog input. +//! Three different oversampling rates are supported; 2x, 4x, and 8x. +//! +//! Oversampling is only supported on the sample sequencers that are more than +//! one sample in depth (that is, the fourth sample sequencer is not +//! supported). Oversampling by 2x (for example) divides the depth of the +//! sample sequencer by two; so 2x oversampling on the first sample sequencer +//! can only provide four samples per trigger. This also means that 8x +//! oversampling is only available on the first sample sequencer. +//! +//! \return None. +// +//***************************************************************************** +void +ADCSoftwareOversampleConfigure(unsigned long ulBase, + unsigned long ulSequenceNum, + unsigned long ulFactor) +{ + unsigned long ulValue; + + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 3); + ASSERT(((ulFactor == 2) || (ulFactor == 4) || (ulFactor == 8)) && + ((ulSequenceNum == 0) || (ulFactor != 8))); + + // + // Convert the oversampling factor to a shift factor. + // + for(ulValue = 0, ulFactor >>= 1; ulFactor; ulValue++, ulFactor >>= 1) + { + } + + // + // Save the sfiht factor. + // + g_pucOversampleFactor[ulSequenceNum] = ulValue; +} + +//***************************************************************************** +// +//! Configures a step of the software oversampled sequencer. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! \param ulStep is the step to be configured. +//! \param ulConfig is the configuration of this step. +//! +//! This function configures a step of the sample sequencer when using the +//! software oversampling feature. The number of steps available depends on +//! the oversampling factor set by ADCSoftwareOversampleConfigure(). The value +//! of \e ulConfig is the same as defined for ADCSequenceStepConfigure(). +//! +//! \return None. +// +//***************************************************************************** +void +ADCSoftwareOversampleStepConfigure(unsigned long ulBase, + unsigned long ulSequenceNum, + unsigned long ulStep, + unsigned long ulConfig) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 3); + ASSERT(((ulSequenceNum == 0) && + (ulStep < (8 >> g_pucOversampleFactor[ulSequenceNum]))) || + (ulStep < (4 >> g_pucOversampleFactor[ulSequenceNum]))); + + // + // Get the offset of the sequence to be configured. + // + ulBase += ADC_SEQ + (ADC_SEQ_STEP * ulSequenceNum); + + // + // Compute the shift for the bits that control this step. + // + ulStep *= 4 << g_pucOversampleFactor[ulSequenceNum]; + + // + // Loop through the hardware steps that make up this step of the software + // oversampled sequence. + // + for(ulSequenceNum = 1 << g_pucOversampleFactor[ulSequenceNum]; + ulSequenceNum; ulSequenceNum--) + { + // + // Set the analog mux value for this step. + // + HWREG(ulBase + ADC_SSMUX) = ((HWREG(ulBase + ADC_SSMUX) & + ~(0x0000000f << ulStep)) | + ((ulConfig & 0x0f) << ulStep)); + + // + // Set the control value for this step. + // + HWREG(ulBase + ADC_SSCTL) = ((HWREG(ulBase + ADC_SSCTL) & + ~(0x0000000f << ulStep)) | + (((ulConfig & 0xf0) >> 4) << ulStep)); + if(ulSequenceNum != 1) + { + HWREG(ulBase + ADC_SSCTL) &= ~((ADC_SSCTL0_IE0 | + ADC_SSCTL0_END0) << ulStep); + } + + // + // Go to the next hardware step. + // + ulStep += 4; + } +} + +//***************************************************************************** +// +//! Gets the captured data for a sample sequence using software oversampling. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! \param pulBuffer is the address where the data is stored. +//! \param ulCount is the number of samples to be read. +//! +//! This function copies data from the specified sample sequence output FIFO to +//! a memory resident buffer with software oversampling applied. The requested +//! number of samples are copied into the data buffer; if there are not enough +//! samples in the hardware FIFO to satisfy this many oversampled data items +//! then incorrect results will be returned. It is the caller's responsibility +//! to read only the samples that are available and wait until enough data is +//! available, for example as a result of receiving an interrupt. +//! +//! \return None. +// +//***************************************************************************** +void +ADCSoftwareOversampleDataGet(unsigned long ulBase, unsigned long ulSequenceNum, + unsigned long *pulBuffer, unsigned long ulCount) +{ + unsigned long ulIdx, ulAccum; + + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 3); + ASSERT(((ulSequenceNum == 0) && + (ulCount < (8 >> g_pucOversampleFactor[ulSequenceNum]))) || + (ulCount < (4 >> g_pucOversampleFactor[ulSequenceNum]))); + + // + // Get the offset of the sequence to be read. + // + ulBase += ADC_SEQ + (ADC_SEQ_STEP * ulSequenceNum); + + // + // Read the samples from the FIFO until it is empty. + // + while(ulCount--) + { + // + // Compute the sum of the samples. + // + ulAccum = 0; + for(ulIdx = 1 << g_pucOversampleFactor[ulSequenceNum]; ulIdx; ulIdx--) + { + // + // Read the FIFO and add it to the accumulator. + // + ulAccum += HWREG(ulBase + ADC_SSFIFO); + } + + // + // Write the averaged sample to the output buffer. + // + *pulBuffer++ = ulAccum >> g_pucOversampleFactor[ulSequenceNum]; + } +} + +//***************************************************************************** +// +//! Configures the hardware oversampling factor of the ADC. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulFactor is the number of samples to be averaged. +//! +//! This function configures the hardware oversampling for the ADC, which can +//! be used to provide better resolution on the sampled data. Oversampling is +//! accomplished by averaging multiple samples from the same analog input. Six +//! different oversampling rates are supported; 2x, 4x, 8x, 16x, 32x, and 64x. +//! Specifying an oversampling factor of zero will disable hardware +//! oversampling. +//! +//! Hardware oversampling applies uniformly to all sample sequencers. It does +//! not reduce the depth of the sample sequencers like the software +//! oversampling APIs; each sample written into the sample sequence FIFO is a +//! fully oversampled analog input reading. +//! +//! Enabling hardware averaging increases the precision of the ADC at the cost +//! of throughput. For example, enabling 4x oversampling reduces the +//! throughput of a 250 Ksps ADC to 62.5 Ksps. +//! +//! \note Hardware oversampling is available beginning with Rev C0 of the +//! Stellaris microcontroller. +//! +//! \return None. +// +//***************************************************************************** +void +ADCHardwareOversampleConfigure(unsigned long ulBase, unsigned long ulFactor) +{ + unsigned long ulValue; + + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(((ulFactor == 0) || (ulFactor == 2) || (ulFactor == 4) || + (ulFactor == 8) || (ulFactor == 16) || (ulFactor == 32) || + (ulFactor == 64))); + + // + // Convert the oversampling factor to a shift factor. + // + for(ulValue = 0, ulFactor >>= 1; ulFactor; ulValue++, ulFactor >>= 1) + { + } + + // + // Write the shift factor to the ADC to configure the hardware oversampler. + // + HWREG(ulBase + ADC_O_SAC) = ulValue; +} + +//***************************************************************************** +// +//! Configures an ADC digital comparator. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulComp is the index of the comparator to configure. +//! \param ulConfig is the configuration of the comparator. +//! +//! This function will configure a comparator. The \e ulConfig parameter is +//! the result of a logical OR operation between the \b ADC_COMP_TRIG_xxx, and +//! \b ADC_COMP_INT_xxx values. +//! +//! The \b ADC_COMP_TRIG_xxx term can take on the following values: +//! +//! - \b ADC_COMP_TRIG_NONE to never trigger PWM fault condition. +//! - \b ADC_COMP_TRIG_LOW_ALWAYS to always trigger PWM fault condition when +//! ADC output is in the low-band. +//! - \b ADC_COMP_TRIG_LOW_ONCE to trigger PWM fault condition once when ADC +//! output transitions into the low-band. +//! - \b ADC_COMP_TRIG_LOW_HALWAYS to always trigger PWM fault condition when +//! ADC output is in the low-band only if ADC output has been in the high-band +//! since the last trigger output. +//! - \b ADC_COMP_TRIG_LOW_HONCE to trigger PWM fault condition once when ADC +//! output transitions into low-band only if ADC output has been in the +//! high-band since the last trigger output. +//! - \b ADC_COMP_TRIG_MID_ALWAYS to always trigger PWM fault condition when +//! ADC output is in the mid-band. +//! - \b ADC_COMP_TRIG_MID_ONCE to trigger PWM fault condition once when ADC +//! output transitions into the mid-band. +//! - \b ADC_COMP_TRIG_HIGH_ALWAYS to always trigger PWM fault condition when +//! ADC output is in the high-band. +//! - \b ADC_COMP_TRIG_HIGH_ONCE to trigger PWM fault condition once when ADC +//! output transitions into the high-band. +//! - \b ADC_COMP_TRIG_HIGH_HALWAYS to always trigger PWM fault condition when +//! ADC output is in the high-band only if ADC output has been in the low-band +//! since the last trigger output. +//! - \b ADC_COMP_TRIG_HIGH_HONCE to trigger PWM fault condition once when ADC +//! output transitions into high-band only if ADC output has been in the +//! low-band since the last trigger output. +//! +//! The \b ADC_COMP_INT_xxx term can take on the following values: +//! +//! - \b ADC_COMP_INT_NONE to never generate ADC interrupt. +//! - \b ADC_COMP_INT_LOW_ALWAYS to always generate ADC interrupt when ADC +//! output is in the low-band. +//! - \b ADC_COMP_INT_LOW_ONCE to generate ADC interrupt once when ADC output +//! transitions into the low-band. +//! - \b ADC_COMP__INT_LOW_HALWAYS to always generate ADC interrupt when ADC +//! output is in the low-band only if ADC output has been in the high-band +//! since the last trigger output. +//! - \b ADC_COMP_INT_LOW_HONCE to generate ADC interrupt once when ADC output +//! transitions into low-band only if ADC output has been in the high-band +//! since the last trigger output. +//! - \b ADC_COMP_INT_MID_ALWAYS to always generate ADC interrupt when ADC +//! output is in the mid-band. +//! - \b ADC_COMP_INT_MID_ONCE to generate ADC interrupt once when ADC output +//! transitions into the mid-band. +//! - \b ADC_COMP_INT_HIGH_ALWAYS to always generate ADC interrupt when ADC +//! output is in the high-band. +//! - \b ADC_COMP_INT_HIGH_ONCE to generate ADC interrupt once when ADC output +//! transitions into the high-band. +//! - \b ADC_COMP_INT_HIGH_HALWAYS to always generate ADC interrupt when ADC +//! output is in the high-band only if ADC output has been in the low-band +//! since the last trigger output. +//! - \b ADC_COMP_INT_HIGH_HONCE to generate ADC interrupt once when ADC output +//! transitions into high-band only if ADC output has been in the low-band +//! since the last trigger output. +//! +//! \return None. +// +//***************************************************************************** +void +ADCComparatorConfigure(unsigned long ulBase, unsigned long ulComp, + unsigned long ulConfig) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulComp < 8); + + // + // Save the new setting. + // + HWREG(ulBase + ADC_O_DCCTL0 + (ulComp * 4)) = ulConfig; +} + +//***************************************************************************** +// +//! Defines the ADC digital comparator regions. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulComp is the index of the comparator to configure. +//! \param ulLowRef is the reference point for the low/mid band threshold. +//! \param ulHighRef is the reference point for the mid/high band threshold. +//! +//! The ADC digital comparator operation is based on three ADC value regions: +//! - \b low-band is defined as any ADC value less than or equal to the +//! \e ulLowRef value. +//! - \b mid-band is defined as any ADC value greater than the \e ulLowRef +//! value but less than or equal to the \e ulHighRef value. +//! - \b high-band is defined as any ADC value greater than the \e ulHighRef +//! value. +//! +//! \return None. +// +//***************************************************************************** +void +ADCComparatorRegionSet(unsigned long ulBase, unsigned long ulComp, + unsigned long ulLowRef, unsigned long ulHighRef) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulComp < 8); + ASSERT((ulLowRef < 1024) && (ulLowRef <= ulHighRef)); + ASSERT(ulHighRef < 1024); + + // + // Save the new region settings. + // + HWREG(ulBase + ADC_O_DCCMP0 + (ulComp * 4)) = (ulHighRef << 16) | ulLowRef; +} + +//***************************************************************************** +// +//! Resets the current ADC digital comparator conditions. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulComp is the index of the comparator. +//! \param bTrigger is the flag to indicate reset of Trigger conditions. +//! \param bInterrupt is the flag to indicate reset of Interrupt conditions. +//! +//! Because the digital comparator uses current and previous ADC values, this +//! function is provide to allow the comparator to be reset to its initial +//! value to prevent stale data from being used when a sequence is enabled. +//! +//! \return None. +// +//***************************************************************************** +void +ADCComparatorReset(unsigned long ulBase, unsigned long ulComp, + tBoolean bTrigger, tBoolean bInterrupt) +{ + unsigned long ulTemp = 0; + + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulComp < 8); + + // + // Set the appropriate bits to reset the trigger and/or interrupt + // comparator conditions. + // + if(bTrigger) + { + ulTemp |= (1 << (16 + ulComp)); + } + if(bInterrupt) + { + ulTemp |= (1 << ulComp); + } + + HWREG(ulBase + ADC_O_DCRIC) = ulTemp; +} + +//***************************************************************************** +// +//! Disables a sample sequence comparator interrupt. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! +//! This function disables the requested sample sequence comparator interrupt. +//! +//! \return None. +// +//***************************************************************************** +void +ADCComparatorIntDisable(unsigned long ulBase, unsigned long ulSequenceNum) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + + // + // Disable this sample sequence comparator interrupt. + // + HWREG(ulBase + ADC_O_IM) &= ~(0x10000 << ulSequenceNum); +} + +//***************************************************************************** +// +//! Enables a sample sequence comparator interrupt. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulSequenceNum is the sample sequence number. +//! +//! This function enables the requested sample sequence comparator interrupt. +//! +//! \return None. +// +//***************************************************************************** +void +ADCComparatorIntEnable(unsigned long ulBase, unsigned long ulSequenceNum) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT(ulSequenceNum < 4); + + // + // Enable this sample sequence interrupt. + // + HWREG(ulBase + ADC_O_IM) |= 0x10000 << ulSequenceNum; +} + +//***************************************************************************** +// +//! Gets the current comparator interrupt status. +//! +//! \param ulBase is the base address of the ADC module. +//! +//! This returns the digitial comparator interrupt status bits. This status +//! is sequence agnostic. +//! +//! \return The current comparator interrupt status. +// +//***************************************************************************** +unsigned long +ADCComparatorIntStatus(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + + // + // Return the digitial comparator interrupt status. + // + return(HWREG(ulBase + ADC_O_DCISC)); +} + +//***************************************************************************** +// +//! Clears sample sequence comparator interrupt source. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulStatus is the bit-mapped interrupts status to clear. +//! +//! The specified interrupt status is cleared. +//! +//! \return None. +// +//***************************************************************************** +void +ADCComparatorIntClear(unsigned long ulBase, unsigned long ulStatus) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + + // + // Clear the interrupt. + // + HWREG(ulBase + ADC_O_DCISC) = ulStatus; +} + +//***************************************************************************** +// +//! Selects the ADC reference. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulRef is the reference to use. +//! +//! The ADC reference is set as specified by \e ulRef. It must be one of +//! \b ADC_REF_INT or \b ADC_REF_EXT_3V, for internal or external reference. +//! If \b ADC_REF_INT is chosen, then an internal 3V reference is used and +//! no external reference is needed. If \b ADC_REF_EXT_3V is chosen, then a 3V +//! reference must be supplied to the AVREF pin. +//! +//! \note The ADC reference can only be selected on parts that have an external +//! reference. Consult the data sheet for your part to determine if there is +//! an external reference. +//! +//! \return None. +// +//***************************************************************************** +void +ADCReferenceSet(unsigned long ulBase, unsigned long ulRef) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT((ulRef == ADC_REF_INT) || (ulRef == ADC_REF_EXT_3V)); + + // + // Set the reference. + // + HWREG(ulBase + ADC_O_CTL) = (HWREG(ulBase + ADC_O_CTL) & ~ADC_CTL_VREF) | + ulRef; +} + +//***************************************************************************** +// +//! Returns the current setting of the ADC reference. +//! +//! \param ulBase is the base address of the ADC module. +//! +//! Returns the value of the ADC reference setting. The returned value will be +//! one of \b ADC_REF_INT or \b ADC_REF_EXT_3V. +//! +//! \note The value returned by this function is only meaningful if used on a +//! part that is capable of using an external reference. Consult the data +//! sheet for your part to determine if it has an external reference input. +//! +//! \return The current setting of the ADC reference. +// +//***************************************************************************** +unsigned long +ADCReferenceGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + + // + // Return the value of the reference. + // + return(HWREG(ulBase + ADC_O_CTL) & ADC_CTL_VREF); +} + +//***************************************************************************** +// +//! Sets the phase delay between a trigger and the start of a sequence. +//! +//! \param ulBase is the base address of the ADC module. +//! \param ulPhase is the phase delay, specified as one of \b ADC_PHASE_0, +//! \b ADC_PHASE_22_5, \b ADC_PHASE_45, \b ADC_PHASE_67_5, \b ADC_PHASE_90, +//! \b ADC_PHASE_112_5, \b ADC_PHASE_135, \b ADC_PHASE_157_5, \b ADC_PHASE_180, +//! \b ADC_PHASE_202_5, \b ADC_PHASE_225, \b ADC_PHASE_247_5, \b ADC_PHASE_270, +//! \b ADC_PHASE_292_5, \b ADC_PHASE_315, or \b ADC_PHASE_337_5. +//! +//! This function sets the phase delay between the detection of an ADC trigger +//! event and the start of the sample sequence. By selecting a different phase +//! delay for a pair of ADC modules (such as \b ADC_PHASE_0 and +//! \b ADC_PHASE_180) and having each ADC module sample the same analog input, +//! it is possible to increase the sampling rate of the analog input (with +//! samples N, N+2, N+4, and so on, coming from the first ADC and samples N+1, +//! N+3, N+5, and so on, coming from the second ADC). The ADC module has a +//! single phase delay that is applied to all sample sequences within that +//! module. +//! +//! \note This capability is not available on all parts. +//! +//! \return None. +// +//***************************************************************************** +void +ADCPhaseDelaySet(unsigned long ulBase, unsigned long ulPhase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + ASSERT((ulPhase == ADC_PHASE_0) || (ulPhase == ADC_PHASE_22_5) || + (ulPhase == ADC_PHASE_45) || (ulPhase == ADC_PHASE_67_5) || + (ulPhase == ADC_PHASE_90) || (ulPhase == ADC_PHASE_112_5) || + (ulPhase == ADC_PHASE_135) || (ulPhase == ADC_PHASE_157_5) || + (ulPhase == ADC_PHASE_180) || (ulPhase == ADC_PHASE_202_5) || + (ulPhase == ADC_PHASE_225) || (ulPhase == ADC_PHASE_247_5) || + (ulPhase == ADC_PHASE_270) || (ulPhase == ADC_PHASE_292_5) || + (ulPhase == ADC_PHASE_315) || (ulPhase == ADC_PHASE_337_5)); + + // + // Set the phase delay. + // + HWREG(ulBase + ADC_O_SPC) = ulPhase; +} + +//***************************************************************************** +// +//! Gets the phase delay between a trigger and the start of a sequence. +//! +//! \param ulBase is the base address of the ADC module. +//! +//! This function gets the current phase delay between the detection of an ADC +//! trigger event and the start of the sample sequence. +//! +//! \return Returns the phase delay, specified as one of \b ADC_PHASE_0, +//! \b ADC_PHASE_22_5, \b ADC_PHASE_45, \b ADC_PHASE_67_5, \b ADC_PHASE_90, +//! \b ADC_PHASE_112_5, \b ADC_PHASE_135, \b ADC_PHASE_157_5, \b ADC_PHASE_180, +//! \b ADC_PHASE_202_5, \b ADC_PHASE_225, \b ADC_PHASE_247_5, \b ADC_PHASE_270, +//! \b ADC_PHASE_292_5, \b ADC_PHASE_315, or \b ADC_PHASE_337_5. +// +//***************************************************************************** +unsigned long +ADCPhaseDelayGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == ADC0_BASE) || (ulBase == ADC1_BASE)); + + // + // Return the phase delay. + // + return(HWREG(ulBase + ADC_O_SPC)); +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/adc.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/adc.h new file mode 100644 index 00000000..f47a21f7 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/adc.h @@ -0,0 +1,258 @@ +//***************************************************************************** +// +// adc.h - ADC headers for using the ADC driver functions. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __ADC_H__ +#define __ADC_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Values that can be passed to ADCSequenceConfigure as the ulTrigger +// parameter. +// +//***************************************************************************** +#define ADC_TRIGGER_PROCESSOR 0x00000000 // Processor event +#define ADC_TRIGGER_COMP0 0x00000001 // Analog comparator 0 event +#define ADC_TRIGGER_COMP1 0x00000002 // Analog comparator 1 event +#define ADC_TRIGGER_COMP2 0x00000003 // Analog comparator 2 event +#define ADC_TRIGGER_EXTERNAL 0x00000004 // External event +#define ADC_TRIGGER_TIMER 0x00000005 // Timer event +#define ADC_TRIGGER_PWM0 0x00000006 // PWM0 event +#define ADC_TRIGGER_PWM1 0x00000007 // PWM1 event +#define ADC_TRIGGER_PWM2 0x00000008 // PWM2 event +#define ADC_TRIGGER_PWM3 0x00000009 // PWM3 event +#define ADC_TRIGGER_ALWAYS 0x0000000F // Always event + +//***************************************************************************** +// +// Values that can be passed to ADCSequenceStepConfigure as the ulConfig +// parameter. +// +//***************************************************************************** +#define ADC_CTL_TS 0x00000080 // Temperature sensor select +#define ADC_CTL_IE 0x00000040 // Interrupt enable +#define ADC_CTL_END 0x00000020 // Sequence end select +#define ADC_CTL_D 0x00000010 // Differential select +#define ADC_CTL_CH0 0x00000000 // Input channel 0 +#define ADC_CTL_CH1 0x00000001 // Input channel 1 +#define ADC_CTL_CH2 0x00000002 // Input channel 2 +#define ADC_CTL_CH3 0x00000003 // Input channel 3 +#define ADC_CTL_CH4 0x00000004 // Input channel 4 +#define ADC_CTL_CH5 0x00000005 // Input channel 5 +#define ADC_CTL_CH6 0x00000006 // Input channel 6 +#define ADC_CTL_CH7 0x00000007 // Input channel 7 +#define ADC_CTL_CH8 0x00000008 // Input channel 8 +#define ADC_CTL_CH9 0x00000009 // Input channel 9 +#define ADC_CTL_CH10 0x0000000A // Input channel 10 +#define ADC_CTL_CH11 0x0000000B // Input channel 11 +#define ADC_CTL_CH12 0x0000000C // Input channel 12 +#define ADC_CTL_CH13 0x0000000D // Input channel 13 +#define ADC_CTL_CH14 0x0000000E // Input channel 14 +#define ADC_CTL_CH15 0x0000000F // Input channel 15 +#define ADC_CTL_CMP0 0x00080000 // Select Comparator 0 +#define ADC_CTL_CMP1 0x00090000 // Select Comparator 1 +#define ADC_CTL_CMP2 0x000A0000 // Select Comparator 2 +#define ADC_CTL_CMP3 0x000B0000 // Select Comparator 3 +#define ADC_CTL_CMP4 0x000C0000 // Select Comparator 4 +#define ADC_CTL_CMP5 0x000D0000 // Select Comparator 5 +#define ADC_CTL_CMP6 0x000E0000 // Select Comparator 6 +#define ADC_CTL_CMP7 0x000F0000 // Select Comparator 7 + +//***************************************************************************** +// +// Values that can be passed to ADCComparatorConfigure as part of the +// ulConfig parameter. +// +//***************************************************************************** +#define ADC_COMP_TRIG_NONE 0x00000000 // Trigger Disabled +#define ADC_COMP_TRIG_LOW_ALWAYS \ + 0x00001000 // Trigger Low Always +#define ADC_COMP_TRIG_LOW_ONCE 0x00001100 // Trigger Low Once +#define ADC_COMP_TRIG_LOW_HALWAYS \ + 0x00001200 // Trigger Low Always (Hysteresis) +#define ADC_COMP_TRIG_LOW_HONCE 0x00001300 // Trigger Low Once (Hysteresis) +#define ADC_COMP_TRIG_MID_ALWAYS \ + 0x00001400 // Trigger Mid Always +#define ADC_COMP_TRIG_MID_ONCE 0x00001500 // Trigger Mid Once +#define ADC_COMP_TRIG_HIGH_ALWAYS \ + 0x00001C00 // Trigger High Always +#define ADC_COMP_TRIG_HIGH_ONCE 0x00001D00 // Trigger High Once +#define ADC_COMP_TRIG_HIGH_HALWAYS \ + 0x00001E00 // Trigger High Always (Hysteresis) +#define ADC_COMP_TRIG_HIGH_HONCE \ + 0x00001F00 // Trigger High Once (Hysteresis) + +#define ADC_COMP_INT_NONE 0x00000000 // Interrupt Disabled +#define ADC_COMP_INT_LOW_ALWAYS \ + 0x00000010 // Interrupt Low Always +#define ADC_COMP_INT_LOW_ONCE 0x00000011 // Interrupt Low Once +#define ADC_COMP_INT_LOW_HALWAYS \ + 0x00000012 // Interrupt Low Always + // (Hysteresis) +#define ADC_COMP_INT_LOW_HONCE 0x00000013 // Interrupt Low Once (Hysteresis) +#define ADC_COMP_INT_MID_ALWAYS \ + 0x00000014 // Interrupt Mid Always +#define ADC_COMP_INT_MID_ONCE 0x00000015 // Interrupt Mid Once +#define ADC_COMP_INT_HIGH_ALWAYS \ + 0x0000001C // Interrupt High Always +#define ADC_COMP_INT_HIGH_ONCE 0x0000001D // Interrupt High Once +#define ADC_COMP_INT_HIGH_HALWAYS \ + 0x0000001E // Interrupt High Always + // (Hysteresis) +#define ADC_COMP_INT_HIGH_HONCE \ + 0x0000001F // Interrupt High Once (Hysteresis) + +//***************************************************************************** +// +// Values that can be used to modify the sequence number passed to +// ADCProcessorTrigger in order to get cross-module synchronous processor +// triggers. +// +//***************************************************************************** +#define ADC_TRIGGER_WAIT 0x08000000 // Wait for the synchronous trigger +#define ADC_TRIGGER_SIGNAL 0x80000000 // Signal the synchronous trigger + +//***************************************************************************** +// +// Values that can be passed to ADCPhaseDelaySet as the ulPhase parameter and +// returned from ADCPhaseDelayGet. +// +//***************************************************************************** +#define ADC_PHASE_0 0x00000000 // 0 degrees +#define ADC_PHASE_22_5 0x00000001 // 22.5 degrees +#define ADC_PHASE_45 0x00000002 // 45 degrees +#define ADC_PHASE_67_5 0x00000003 // 67.5 degrees +#define ADC_PHASE_90 0x00000004 // 90 degrees +#define ADC_PHASE_112_5 0x00000005 // 112.5 degrees +#define ADC_PHASE_135 0x00000006 // 135 degrees +#define ADC_PHASE_157_5 0x00000007 // 157.5 degrees +#define ADC_PHASE_180 0x00000008 // 180 degrees +#define ADC_PHASE_202_5 0x00000009 // 202.5 degrees +#define ADC_PHASE_225 0x0000000A // 225 degrees +#define ADC_PHASE_247_5 0x0000000B // 247.5 degrees +#define ADC_PHASE_270 0x0000000C // 270 degrees +#define ADC_PHASE_292_5 0x0000000D // 292.5 degrees +#define ADC_PHASE_315 0x0000000E // 315 degrees +#define ADC_PHASE_337_5 0x0000000F // 337.5 degrees + +//***************************************************************************** +// +// Values that can be passed to ADCReferenceSet as the ulRef parameter. +// +//***************************************************************************** +#define ADC_REF_INT 0x00000000 // Internal reference +#define ADC_REF_EXT_3V 0x00000001 // External 3V reference + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern void ADCIntRegister(unsigned long ulBase, unsigned long ulSequenceNum, + void (*pfnHandler)(void)); +extern void ADCIntUnregister(unsigned long ulBase, + unsigned long ulSequenceNum); +extern void ADCIntDisable(unsigned long ulBase, unsigned long ulSequenceNum); +extern void ADCIntEnable(unsigned long ulBase, unsigned long ulSequenceNum); +extern unsigned long ADCIntStatus(unsigned long ulBase, + unsigned long ulSequenceNum, + tBoolean bMasked); +extern void ADCIntClear(unsigned long ulBase, unsigned long ulSequenceNum); +extern void ADCSequenceEnable(unsigned long ulBase, + unsigned long ulSequenceNum); +extern void ADCSequenceDisable(unsigned long ulBase, + unsigned long ulSequenceNum); +extern void ADCSequenceConfigure(unsigned long ulBase, + unsigned long ulSequenceNum, + unsigned long ulTrigger, + unsigned long ulPriority); +extern void ADCSequenceStepConfigure(unsigned long ulBase, + unsigned long ulSequenceNum, + unsigned long ulStep, + unsigned long ulConfig); +extern long ADCSequenceOverflow(unsigned long ulBase, + unsigned long ulSequenceNum); +extern void ADCSequenceOverflowClear(unsigned long ulBase, + unsigned long ulSequenceNum); +extern long ADCSequenceUnderflow(unsigned long ulBase, + unsigned long ulSequenceNum); +extern void ADCSequenceUnderflowClear(unsigned long ulBase, + unsigned long ulSequenceNum); +extern long ADCSequenceDataGet(unsigned long ulBase, + unsigned long ulSequenceNum, + unsigned long *pulBuffer); +extern void ADCProcessorTrigger(unsigned long ulBase, + unsigned long ulSequenceNum); +extern void ADCSoftwareOversampleConfigure(unsigned long ulBase, + unsigned long ulSequenceNum, + unsigned long ulFactor); +extern void ADCSoftwareOversampleStepConfigure(unsigned long ulBase, + unsigned long ulSequenceNum, + unsigned long ulStep, + unsigned long ulConfig); +extern void ADCSoftwareOversampleDataGet(unsigned long ulBase, + unsigned long ulSequenceNum, + unsigned long *pulBuffer, + unsigned long ulCount); +extern void ADCHardwareOversampleConfigure(unsigned long ulBase, + unsigned long ulFactor); +extern void ADCComparatorConfigure(unsigned long ulBase, unsigned long ulComp, + unsigned long ulConfig); +extern void ADCComparatorRegionSet(unsigned long ulBase, unsigned long ulComp, + unsigned long ulLowRef, + unsigned long ulHighRef); +extern void ADCComparatorReset(unsigned long ulBase, unsigned long ulComp, + tBoolean bTrigger, tBoolean bInterrupt); +extern void ADCComparatorIntDisable(unsigned long ulBase, + unsigned long ulSequenceNum); +extern void ADCComparatorIntEnable(unsigned long ulBase, + unsigned long ulSequenceNum); +extern unsigned long ADCComparatorIntStatus(unsigned long ulBase); +extern void ADCComparatorIntClear(unsigned long ulBase, + unsigned long ulStatus); +extern void ADCReferenceSet(unsigned long ulBase, unsigned long ulRef); +extern unsigned long ADCReferenceGet(unsigned long ulBase); +extern void ADCPhaseDelaySet(unsigned long ulBase, unsigned long ulPhase); +extern unsigned long ADCPhaseDelayGet(unsigned long ulBase); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __ADC_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/comp.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/comp.c new file mode 100644 index 00000000..313fe8e3 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/comp.c @@ -0,0 +1,436 @@ +//***************************************************************************** +// +// comp.c - Driver for the analog comparator. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup comp_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_comp.h" +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_types.h" +#include "driverlib/comp.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" + +//***************************************************************************** +// +//! Configures a comparator. +//! +//! \param ulBase is the base address of the comparator module. +//! \param ulComp is the index of the comparator to configure. +//! \param ulConfig is the configuration of the comparator. +//! +//! This function configures a comparator. The \e ulConfig parameter is the +//! result of a logical OR operation between the \b COMP_TRIG_xxx, +//! \b COMP_INT_xxx, \b COMP_ASRCP_xxx, and \b COMP_OUTPUT_xxx values. +//! +//! The \b COMP_TRIG_xxx term can take on the following values: +//! +//! - \b COMP_TRIG_NONE to have no trigger to the ADC. +//! - \b COMP_TRIG_HIGH to trigger the ADC when the comparator output is high. +//! - \b COMP_TRIG_LOW to trigger the ADC when the comparator output is low. +//! - \b COMP_TRIG_FALL to trigger the ADC when the comparator output goes low. +//! - \b COMP_TRIG_RISE to trigger the ADC when the comparator output goes +//! high. +//! - \b COMP_TRIG_BOTH to trigger the ADC when the comparator output goes low +//! or high. +//! +//! The \b COMP_INT_xxx term can take on the following values: +//! +//! - \b COMP_INT_HIGH to generate an interrupt when the comparator output is +//! high. +//! - \b COMP_INT_LOW to generate an interrupt when the comparator output is +//! low. +//! - \b COMP_INT_FALL to generate an interrupt when the comparator output goes +//! low. +//! - \b COMP_INT_RISE to generate an interrupt when the comparator output goes +//! high. +//! - \b COMP_INT_BOTH to generate an interrupt when the comparator output goes +//! low or high. +//! +//! The \b COMP_ASRCP_xxx term can take on the following values: +//! +//! - \b COMP_ASRCP_PIN to use the dedicated Comp+ pin as the reference +//! voltage. +//! - \b COMP_ASRCP_PIN0 to use the Comp0+ pin as the reference voltage (this +//! the same as \b COMP_ASRCP_PIN for the comparator 0). +//! - \b COMP_ASRCP_REF to use the internally generated voltage as the +//! reference voltage. +//! +//! The \b COMP_OUTPUT_xxx term can take on the following values: +//! +//! - \b COMP_OUTPUT_NORMAL to enable a non-inverted output from the comparator +//! to a device pin. +//! - \b COMP_OUTPUT_INVERT to enable an inverted output from the comparator to +//! a device pin. +//! - \b COMP_OUTPUT_NONE is deprecated and behaves the same as +//! \b COMP_OUTPUT_NORMAL. +//! +//! \return None. +// +//***************************************************************************** +void +ComparatorConfigure(unsigned long ulBase, unsigned long ulComp, + unsigned long ulConfig) +{ + // + // Check the arguments. + // + ASSERT(ulBase == COMP_BASE); + ASSERT(ulComp < 3); + + // + // Configure this comparator. + // + HWREG(ulBase + (ulComp * 0x20) + COMP_O_ACCTL0) = ulConfig; +} + +//***************************************************************************** +// +//! Sets the internal reference voltage. +//! +//! \param ulBase is the base address of the comparator module. +//! \param ulRef is the desired reference voltage. +//! +//! This function sets the internal reference voltage value. The voltage is +//! specified as one of the following values: +//! +//! - \b COMP_REF_OFF to turn off the reference voltage +//! - \b COMP_REF_0V to set the reference voltage to 0 V +//! - \b COMP_REF_0_1375V to set the reference voltage to 0.1375 V +//! - \b COMP_REF_0_275V to set the reference voltage to 0.275 V +//! - \b COMP_REF_0_4125V to set the reference voltage to 0.4125 V +//! - \b COMP_REF_0_55V to set the reference voltage to 0.55 V +//! - \b COMP_REF_0_6875V to set the reference voltage to 0.6875 V +//! - \b COMP_REF_0_825V to set the reference voltage to 0.825 V +//! - \b COMP_REF_0_928125V to set the reference voltage to 0.928125 V +//! - \b COMP_REF_0_9625V to set the reference voltage to 0.9625 V +//! - \b COMP_REF_1_03125V to set the reference voltage to 1.03125 V +//! - \b COMP_REF_1_134375V to set the reference voltage to 1.134375 V +//! - \b COMP_REF_1_1V to set the reference voltage to 1.1 V +//! - \b COMP_REF_1_2375V to set the reference voltage to 1.2375 V +//! - \b COMP_REF_1_340625V to set the reference voltage to 1.340625 V +//! - \b COMP_REF_1_375V to set the reference voltage to 1.375 V +//! - \b COMP_REF_1_44375V to set the reference voltage to 1.44375 V +//! - \b COMP_REF_1_5125V to set the reference voltage to 1.5125 V +//! - \b COMP_REF_1_546875V to set the reference voltage to 1.546875 V +//! - \b COMP_REF_1_65V to set the reference voltage to 1.65 V +//! - \b COMP_REF_1_753125V to set the reference voltage to 1.753125 V +//! - \b COMP_REF_1_7875V to set the reference voltage to 1.7875 V +//! - \b COMP_REF_1_85625V to set the reference voltage to 1.85625 V +//! - \b COMP_REF_1_925V to set the reference voltage to 1.925 V +//! - \b COMP_REF_1_959375V to set the reference voltage to 1.959375 V +//! - \b COMP_REF_2_0625V to set the reference voltage to 2.0625 V +//! - \b COMP_REF_2_165625V to set the reference voltage to 2.165625 V +//! - \b COMP_REF_2_26875V to set the reference voltage to 2.26875 V +//! - \b COMP_REF_2_371875V to set the reference voltage to 2.371875 V +//! +//! \return None. +// +//***************************************************************************** +void +ComparatorRefSet(unsigned long ulBase, unsigned long ulRef) +{ + // + // Check the arguments. + // + ASSERT(ulBase == COMP_BASE); + + // + // Set the voltage reference voltage as requested. + // + HWREG(ulBase + COMP_O_ACREFCTL) = ulRef; +} + +//***************************************************************************** +// +//! Gets the current comparator output value. +//! +//! \param ulBase is the base address of the comparator module. +//! \param ulComp is the index of the comparator. +//! +//! This function retrieves the current value of the comparator output. +//! +//! \return Returns \b true if the comparator output is high and \b false if +//! the comparator output is low. +// +//***************************************************************************** +tBoolean +ComparatorValueGet(unsigned long ulBase, unsigned long ulComp) +{ + // + // Check the arguments. + // + ASSERT(ulBase == COMP_BASE); + ASSERT(ulComp < 3); + + // + // Return the appropriate value based on the comparator's present output + // value. + // + if(HWREG(ulBase + (ulComp * 0x20) + COMP_O_ACSTAT0) & COMP_ACSTAT0_OVAL) + { + return(true); + } + else + { + return(false); + } +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the comparator interrupt. +//! +//! \param ulBase is the base address of the comparator module. +//! \param ulComp is the index of the comparator. +//! \param pfnHandler is a pointer to the function to be called when the +//! comparator interrupt occurs. +//! +//! This sets the handler to be called when the comparator interrupt occurs +//! and enables the interrupt in the interrupt controller. It is the interrupt +//! handler's responsibility to clear the interrupt source via +//! ComparatorIntClear(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +ComparatorIntRegister(unsigned long ulBase, unsigned long ulComp, + void (*pfnHandler)(void)) +{ + // + // Check the arguments. + // + ASSERT(ulBase == COMP_BASE); + ASSERT(ulComp < 3); + + // + // Register the interrupt handler, returning an error if an error occurs. + // + IntRegister(INT_COMP0 + ulComp, pfnHandler); + + // + // Enable the interrupt in the interrupt controller. + // + IntEnable(INT_COMP0 + ulComp); + + // + // Enable the comparator interrupt. + // + HWREG(ulBase + COMP_O_ACINTEN) |= 1 << ulComp; +} + +//***************************************************************************** +// +//! Unregisters an interrupt handler for a comparator interrupt. +//! +//! \param ulBase is the base address of the comparator module. +//! \param ulComp is the index of the comparator. +//! +//! This function clears the handler to be called when a comparator interrupt +//! occurs. This will also mask off the interrupt in the interrupt controller +//! so that the interrupt handler no longer is called. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +ComparatorIntUnregister(unsigned long ulBase, unsigned long ulComp) +{ + // + // Check the arguments. + // + ASSERT(ulBase == COMP_BASE); + ASSERT(ulComp < 3); + + // + // Disable the comparator interrupt. + // + HWREG(ulBase + COMP_O_ACINTEN) &= ~(1 << ulComp); + + // + // Disable the interrupt in the interrupt controller. + // + IntDisable(INT_COMP0 + ulComp); + + // + // Unregister the interrupt handler. + // + IntUnregister(INT_COMP0 + ulComp); +} + +//***************************************************************************** +// +//! Enables the comparator interrupt. +//! +//! \param ulBase is the base address of the comparator module. +//! \param ulComp is the index of the comparator. +//! +//! This function enables generation of an interrupt from the specified +//! comparator. Only comparators whose interrupts are enabled can be reflected +//! to the processor. +//! +//! \return None. +// +//***************************************************************************** +void +ComparatorIntEnable(unsigned long ulBase, unsigned long ulComp) +{ + // + // Check the arguments. + // + ASSERT(ulBase == COMP_BASE); + ASSERT(ulComp < 3); + + // + // Enable the comparator interrupt. + // + HWREG(ulBase + COMP_O_ACINTEN) |= 1 << ulComp; +} + +//***************************************************************************** +// +//! Disables the comparator interrupt. +//! +//! \param ulBase is the base address of the comparator module. +//! \param ulComp is the index of the comparator. +//! +//! This function disables generation of an interrupt from the specified +//! comparator. Only comparators whose interrupts are enabled can be reflected +//! to the processor. +//! +//! \return None. +// +//***************************************************************************** +void +ComparatorIntDisable(unsigned long ulBase, unsigned long ulComp) +{ + // + // Check the arguments. + // + ASSERT(ulBase == COMP_BASE); + ASSERT(ulComp < 3); + + // + // Disable the comparator interrupt. + // + HWREG(ulBase + COMP_O_ACINTEN) &= ~(1 << ulComp); +} + +//***************************************************************************** +// +//! Gets the current interrupt status. +//! +//! \param ulBase is the base address of the comparator module. +//! \param ulComp is the index of the comparator. +//! \param bMasked is \b false if the raw interrupt status is required and +//! \b true if the masked interrupt status is required. +//! +//! This returns the interrupt status for the comparator. Either the raw or +//! the masked interrupt status can be returned. +//! +//! \return \b true if the interrupt is asserted and \b false if it is not +//! asserted. +// +//***************************************************************************** +tBoolean +ComparatorIntStatus(unsigned long ulBase, unsigned long ulComp, + tBoolean bMasked) +{ + // + // Check the arguments. + // + ASSERT(ulBase == COMP_BASE); + ASSERT(ulComp < 3); + + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + return(((HWREG(ulBase + COMP_O_ACMIS) >> ulComp) & 1) ? true : false); + } + else + { + return(((HWREG(ulBase + COMP_O_ACRIS) >> ulComp) & 1) ? true : false); + } +} + +//***************************************************************************** +// +//! Clears a comparator interrupt. +//! +//! \param ulBase is the base address of the comparator module. +//! \param ulComp is the index of the comparator. +//! +//! The comparator interrupt is cleared, so that it no longer asserts. This +//! fucntion must be called in the interrupt handler to keep the handler from +//! being called again immediately upon exit. Note that for a level-triggered +//! interrupt, the interrupt cannot be cleared until it stops asserting. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +ComparatorIntClear(unsigned long ulBase, unsigned long ulComp) +{ + // + // Check the arguments. + // + ASSERT(ulBase == COMP_BASE); + ASSERT(ulComp < 3); + + // + // Clear the interrupt. + // + HWREG(ulBase + COMP_O_ACMIS) = 1 << ulComp; +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/comp.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/comp.h new file mode 100644 index 00000000..e02e9e25 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/comp.h @@ -0,0 +1,130 @@ +//***************************************************************************** +// +// comp.h - Prototypes for the analog comparator driver. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __COMP_H__ +#define __COMP_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Values that can be passed to ComparatorConfigure() as the ulConfig +// parameter. For each group (i.e. COMP_TRIG_xxx, COMP_INT_xxx, etc.), one of +// the values may be selected and combined together with values from the other +// groups via a logical OR. +// +//***************************************************************************** +#define COMP_TRIG_NONE 0x00000000 // No ADC trigger +#define COMP_TRIG_HIGH 0x00000880 // Trigger when high +#define COMP_TRIG_LOW 0x00000800 // Trigger when low +#define COMP_TRIG_FALL 0x00000820 // Trigger on falling edge +#define COMP_TRIG_RISE 0x00000840 // Trigger on rising edge +#define COMP_TRIG_BOTH 0x00000860 // Trigger on both edges +#define COMP_INT_HIGH 0x00000010 // Interrupt when high +#define COMP_INT_LOW 0x00000000 // Interrupt when low +#define COMP_INT_FALL 0x00000004 // Interrupt on falling edge +#define COMP_INT_RISE 0x00000008 // Interrupt on rising edge +#define COMP_INT_BOTH 0x0000000C // Interrupt on both edges +#define COMP_ASRCP_PIN 0x00000000 // Dedicated Comp+ pin +#define COMP_ASRCP_PIN0 0x00000200 // Comp0+ pin +#define COMP_ASRCP_REF 0x00000400 // Internal voltage reference +#ifndef DEPRECATED +#define COMP_OUTPUT_NONE 0x00000000 // No comparator output +#endif +#define COMP_OUTPUT_NORMAL 0x00000000 // Comparator output normal +#define COMP_OUTPUT_INVERT 0x00000002 // Comparator output inverted + +//***************************************************************************** +// +// Values that can be passed to ComparatorSetRef() as the ulRef parameter. +// +//***************************************************************************** +#define COMP_REF_OFF 0x00000000 // Turn off the internal reference +#define COMP_REF_0V 0x00000300 // Internal reference of 0V +#define COMP_REF_0_1375V 0x00000301 // Internal reference of 0.1375V +#define COMP_REF_0_275V 0x00000302 // Internal reference of 0.275V +#define COMP_REF_0_4125V 0x00000303 // Internal reference of 0.4125V +#define COMP_REF_0_55V 0x00000304 // Internal reference of 0.55V +#define COMP_REF_0_6875V 0x00000305 // Internal reference of 0.6875V +#define COMP_REF_0_825V 0x00000306 // Internal reference of 0.825V +#define COMP_REF_0_928125V 0x00000201 // Internal reference of 0.928125V +#define COMP_REF_0_9625V 0x00000307 // Internal reference of 0.9625V +#define COMP_REF_1_03125V 0x00000202 // Internal reference of 1.03125V +#define COMP_REF_1_134375V 0x00000203 // Internal reference of 1.134375V +#define COMP_REF_1_1V 0x00000308 // Internal reference of 1.1V +#define COMP_REF_1_2375V 0x00000309 // Internal reference of 1.2375V +#define COMP_REF_1_340625V 0x00000205 // Internal reference of 1.340625V +#define COMP_REF_1_375V 0x0000030A // Internal reference of 1.375V +#define COMP_REF_1_44375V 0x00000206 // Internal reference of 1.44375V +#define COMP_REF_1_5125V 0x0000030B // Internal reference of 1.5125V +#define COMP_REF_1_546875V 0x00000207 // Internal reference of 1.546875V +#define COMP_REF_1_65V 0x0000030C // Internal reference of 1.65V +#define COMP_REF_1_753125V 0x00000209 // Internal reference of 1.753125V +#define COMP_REF_1_7875V 0x0000030D // Internal reference of 1.7875V +#define COMP_REF_1_85625V 0x0000020A // Internal reference of 1.85625V +#define COMP_REF_1_925V 0x0000030E // Internal reference of 1.925V +#define COMP_REF_1_959375V 0x0000020B // Internal reference of 1.959375V +#define COMP_REF_2_0625V 0x0000030F // Internal reference of 2.0625V +#define COMP_REF_2_165625V 0x0000020D // Internal reference of 2.165625V +#define COMP_REF_2_26875V 0x0000020E // Internal reference of 2.26875V +#define COMP_REF_2_371875V 0x0000020F // Internal reference of 2.371875V + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern void ComparatorConfigure(unsigned long ulBase, unsigned long ulComp, + unsigned long ulConfig); +extern void ComparatorRefSet(unsigned long ulBase, unsigned long ulRef); +extern tBoolean ComparatorValueGet(unsigned long ulBase, unsigned long ulComp); +extern void ComparatorIntRegister(unsigned long ulBase, unsigned long ulComp, + void (*pfnHandler)(void)); +extern void ComparatorIntUnregister(unsigned long ulBase, + unsigned long ulComp); +extern void ComparatorIntEnable(unsigned long ulBase, unsigned long ulComp); +extern void ComparatorIntDisable(unsigned long ulBase, unsigned long ulComp); +extern tBoolean ComparatorIntStatus(unsigned long ulBase, unsigned long ulComp, + tBoolean bMasked); +extern void ComparatorIntClear(unsigned long ulBase, unsigned long ulComp); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __COMP_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/cpu.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/cpu.c new file mode 100644 index 00000000..a7d49bfc --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/cpu.c @@ -0,0 +1,442 @@ +//***************************************************************************** +// +// cpu.c - Instruction wrappers for special CPU instructions needed by the +// drivers. +// +// Copyright (c) 2006-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#include "driverlib/cpu.h" + +//***************************************************************************** +// +// Wrapper function for the CPSID instruction. Returns the state of PRIMASK +// on entry. +// +//***************************************************************************** +#if defined(codered) || defined(gcc) || defined(sourcerygxx) +unsigned long __attribute__((naked)) +CPUcpsid(void) +{ + unsigned long ulRet; + + // + // Read PRIMASK and disable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " cpsid i\n" + " bx lr\n" + : "=r" (ulRet)); + + // + // The return is handled in the inline assembly, but the compiler will + // still complain if there is not an explicit return here (despite the fact + // that this does not result in any code being produced because of the + // naked attribute). + // + return(ulRet); +} +#endif +#if defined(ewarm) +unsigned long +CPUcpsid(void) +{ + // + // Read PRIMASK and disable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " cpsid i\n"); + + // + // "Warning[Pe940]: missing return statement at end of non-void function" + // is suppressed here to avoid putting a "bx lr" in the inline assembly + // above and a superfluous return statement here. + // +#pragma diag_suppress=Pe940 +} +#pragma diag_default=Pe940 +#endif +#if defined(rvmdk) || defined(__ARMCC_VERSION) +__asm unsigned long +CPUcpsid(void) +{ + // + // Read PRIMASK and disable interrupts. + // + mrs r0, PRIMASK; + cpsid i; + bx lr +} +#endif +#if defined(ccs) +unsigned long +CPUcpsid(void) +{ + // + // Read PRIMASK and disable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " cpsid i\n" + " bx lr\n"); + + // + // The following keeps the compiler happy, because it wants to see a + // return value from this function. It will generate code to return + // a zero. However, the real return is the "bx lr" above, so the + // return(0) is never executed and the function returns with the value + // you expect in R0. + // + return(0); +} +#endif + +//***************************************************************************** +// +// Wrapper function returning the state of PRIMASK (indicating whether +// interrupts are enabled or disabled). +// +//***************************************************************************** +#if defined(codered) || defined(gcc) || defined(sourcerygxx) +unsigned long __attribute__((naked)) +CPUprimask(void) +{ + unsigned long ulRet; + + // + // Read PRIMASK and disable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " bx lr\n" + : "=r" (ulRet)); + + // + // The return is handled in the inline assembly, but the compiler will + // still complain if there is not an explicit return here (despite the fact + // that this does not result in any code being produced because of the + // naked attribute). + // + return(ulRet); +} +#endif +#if defined(ewarm) +unsigned long +CPUprimask(void) +{ + // + // Read PRIMASK and disable interrupts. + // + __asm(" mrs r0, PRIMASK\n"); + + // + // "Warning[Pe940]: missing return statement at end of non-void function" + // is suppressed here to avoid putting a "bx lr" in the inline assembly + // above and a superfluous return statement here. + // +#pragma diag_suppress=Pe940 +} +#pragma diag_default=Pe940 +#endif +#if defined(rvmdk) || defined(__ARMCC_VERSION) +__asm unsigned long +CPUprimask(void) +{ + // + // Read PRIMASK and disable interrupts. + // + mrs r0, PRIMASK; + bx lr +} +#endif +#if defined(ccs) +unsigned long +CPUprimask(void) +{ + // + // Read PRIMASK and disable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " bx lr\n"); + + // + // The following keeps the compiler happy, because it wants to see a + // return value from this function. It will generate code to return + // a zero. However, the real return is the "bx lr" above, so the + // return(0) is never executed and the function returns with the value + // you expect in R0. + // + return(0); +} +#endif + +//***************************************************************************** +// +// Wrapper function for the CPSIE instruction. Returns the state of PRIMASK +// on entry. +// +//***************************************************************************** +#if defined(codered) || defined(gcc) || defined(sourcerygxx) +unsigned long __attribute__((naked)) +CPUcpsie(void) +{ + unsigned long ulRet; + + // + // Read PRIMASK and enable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " cpsie i\n" + " bx lr\n" + : "=r" (ulRet)); + + // + // The return is handled in the inline assembly, but the compiler will + // still complain if there is not an explicit return here (despite the fact + // that this does not result in any code being produced because of the + // naked attribute). + // + return(ulRet); +} +#endif +#if defined(ewarm) +unsigned long +CPUcpsie(void) +{ + // + // Read PRIMASK and enable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " cpsie i\n"); + + // + // "Warning[Pe940]: missing return statement at end of non-void function" + // is suppressed here to avoid putting a "bx lr" in the inline assembly + // above and a superfluous return statement here. + // +#pragma diag_suppress=Pe940 +} +#pragma diag_default=Pe940 +#endif +#if defined(rvmdk) || defined(__ARMCC_VERSION) +__asm unsigned long +CPUcpsie(void) +{ + // + // Read PRIMASK and enable interrupts. + // + mrs r0, PRIMASK; + cpsie i; + bx lr +} +#endif +#if defined(ccs) +unsigned long +CPUcpsie(void) +{ + // + // Read PRIMASK and enable interrupts. + // + __asm(" mrs r0, PRIMASK\n" + " cpsie i\n" + " bx lr\n"); + + // + // The following keeps the compiler happy, because it wants to see a + // return value from this function. It will generate code to return + // a zero. However, the real return is the "bx lr" above, so the + // return(0) is never executed and the function returns with the value + // you expect in R0. + // + return(0); +} +#endif + +//***************************************************************************** +// +// Wrapper function for the WFI instruction. +// +//***************************************************************************** +#if defined(codered) || defined(gcc) || defined(sourcerygxx) +void __attribute__((naked)) +CPUwfi(void) +{ + // + // Wait for the next interrupt. + // + __asm(" wfi\n" + " bx lr\n"); +} +#endif +#if defined(ewarm) +void +CPUwfi(void) +{ + // + // Wait for the next interrupt. + // + __asm(" wfi\n"); +} +#endif +#if defined(rvmdk) || defined(__ARMCC_VERSION) +__asm void +CPUwfi(void) +{ + // + // Wait for the next interrupt. + // + wfi; + bx lr +} +#endif +#if defined(ccs) +void +CPUwfi(void) +{ + // + // Wait for the next interrupt. + // + __asm(" wfi\n"); +} +#endif + +//***************************************************************************** +// +// Wrapper function for writing the BASEPRI register. +// +//***************************************************************************** +#if defined(codered) || defined(gcc) || defined(sourcerygxx) +void __attribute__((naked)) +CPUbasepriSet(unsigned long ulNewBasepri) +{ + + // + // Set the BASEPRI register + // + __asm(" msr BASEPRI, r0\n" + " bx lr\n"); +} +#endif +#if defined(ewarm) +void +CPUbasepriSet(unsigned long ulNewBasepri) +{ + // + // Set the BASEPRI register + // + __asm(" msr BASEPRI, r0\n"); +} +#endif +#if defined(rvmdk) || defined(__ARMCC_VERSION) +__asm void +CPUbasepriSet(unsigned long ulNewBasepri) +{ + // + // Set the BASEPRI register + // + msr BASEPRI, r0; + bx lr +} +#endif +#if defined(ccs) +void +CPUbasepriSet(unsigned long ulNewBasepri) +{ + // + // Set the BASEPRI register + // + __asm(" msr BASEPRI, r0\n"); +} +#endif + +//***************************************************************************** +// +// Wrapper function for reading the BASEPRI register. +// +//***************************************************************************** +#if defined(codered) || defined(gcc) || defined(sourcerygxx) +unsigned long __attribute__((naked)) +CPUbasepriGet(void) +{ + unsigned long ulRet; + + // + // Read BASEPRI + // + __asm(" mrs r0, BASEPRI\n" + " bx lr\n" + : "=r" (ulRet)); + + // + // The return is handled in the inline assembly, but the compiler will + // still complain if there is not an explicit return here (despite the fact + // that this does not result in any code being produced because of the + // naked attribute). + // + return(ulRet); +} +#endif +#if defined(ewarm) +unsigned long +CPUbasepriGet(void) +{ + // + // Read BASEPRI + // + __asm(" mrs r0, BASEPRI\n"); + + // + // "Warning[Pe940]: missing return statement at end of non-void function" + // is suppressed here to avoid putting a "bx lr" in the inline assembly + // above and a superfluous return statement here. + // +#pragma diag_suppress=Pe940 +} +#pragma diag_default=Pe940 +#endif +#if defined(rvmdk) || defined(__ARMCC_VERSION) +__asm unsigned long +CPUbasepriGet(void) +{ + // + // Read BASEPRI + // + mrs r0, BASEPRI; + bx lr +} +#endif +#if defined(ccs) +unsigned long +CPUbasepriGet(void) +{ + // + // Read BASEPRI + // + __asm(" mrs r0, BASEPRI\n" + " bx lr\n"); + + // + // The following keeps the compiler happy, because it wants to see a + // return value from this function. It will generate code to return + // a zero. However, the real return is the "bx lr" above, so the + // return(0) is never executed and the function returns with the value + // you expect in R0. + // + return(0); +} +#endif diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/cpu.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/cpu.h new file mode 100644 index 00000000..c0e073e1 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/cpu.h @@ -0,0 +1,60 @@ +//***************************************************************************** +// +// cpu.h - Prototypes for the CPU instruction wrapper functions. +// +// Copyright (c) 2006-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __CPU_H__ +#define __CPU_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Prototypes. +// +//***************************************************************************** +extern unsigned long CPUcpsid(void); +extern unsigned long CPUcpsie(void); +extern unsigned long CPUprimask(void); +extern void CPUwfi(void); +extern unsigned long CPUbasepriGet(void); +extern void CPUbasepriSet(unsigned long ulNewBasepri); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __CPU_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/debug.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/debug.h new file mode 100644 index 00000000..6fe52fe5 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/debug.h @@ -0,0 +1,53 @@ +//***************************************************************************** +// +// debug.h - Macros for assisting debug of the driver library. +// +// Copyright (c) 2006-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __DEBUG_H__ +#define __DEBUG_H__ + +//***************************************************************************** +// +// Prototype for the function that is called when an invalid argument is passed +// to an API. This is only used when doing a DEBUG build. +// +//***************************************************************************** +extern void __error__(char *pcFilename, unsigned long ulLine); + +//***************************************************************************** +// +// The ASSERT macro, which does the actual assertion checking. Typically, this +// will be for procedure arguments. +// +//***************************************************************************** +#ifdef DEBUG +#define ASSERT(expr) { \ + if(!(expr)) \ + { \ + __error__(__FILE__, __LINE__); \ + } \ + } +#else +#define ASSERT(expr) +#endif + +#endif // __DEBUG_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/epi.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/epi.c new file mode 100644 index 00000000..ee53bd42 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/epi.c @@ -0,0 +1,1176 @@ +//***************************************************************************** +// +// epi.c - Driver for the EPI module. +// +// Copyright (c) 2008-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#include "inc/hw_epi.h" +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_types.h" +#include "driverlib/debug.h" +#include "driverlib/epi.h" +#include "driverlib/interrupt.h" + +//***************************************************************************** +// +//! \addtogroup epi_api +//! @{ +// +//***************************************************************************** + +//***************************************************************************** +// +//! Sets the usage mode of the EPI module. +//! +//! \param ulBase is the EPI module base address. +//! \param ulMode is the usage mode of the EPI module. +//! +//! This functions sets the operating mode of the EPI module. The parameter +//! \e ulMode must be one of the following: +//! +//! - \b EPI_MODE_GENERAL - use for general-purpose mode operation +//! - \b EPI_MODE_SDRAM - use with SDRAM device +//! - \b EPI_MODE_HB8 - use with host-bus 8-bit interface +//! - \b EPI_MODE_HB16 - use with host-bus 16-bit interface +//! - \b EPI_MODE_DISABLE - disable the EPI module +//! +//! Selection of any of the above modes will enable the EPI module, except +//! for \b EPI_MODE_DISABLE which should be used to disable the module. +//! +//! \return None. +// +//***************************************************************************** +void +EPIModeSet(unsigned long ulBase, unsigned long ulMode) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT((ulMode == EPI_MODE_GENERAL) || + (ulMode == EPI_MODE_SDRAM) || + (ulMode == EPI_MODE_HB8) || + (ulMode == EPI_MODE_HB16) || + (ulMode == EPI_MODE_DISABLE)); + + // + // Write the mode word to the register. + // + HWREG(ulBase + EPI_O_CFG) = ulMode; +} + +//***************************************************************************** +// +//! Sets the clock divider for the EPI module. +//! +//! \param ulBase is the EPI module base address. +//! \param ulDivider is the value of the clock divider to be applied to +//! the external interface (0-65535). +//! +//! This functions sets the clock divider(s) that will be used to determine the +//! clock rate of the external interface. The \e ulDivider value is used to +//! derive the EPI clock rate from the system clock based upon the following +//! formula. +//! +//! EPIClock = (Divider == 0) ? SysClk : (SysClk / (((Divider / 2) + 1) * 2)) +//! +//! For example, a divider value of 1 results in an EPI clock rate of half +//! the system clock, value of 2 or 3 yield one quarter of the system clock and +//! a value of 4 results in one sixth of the system clock rate. +//! +//! In cases where a dual chip select mode is in use and different clock rates +//! are required for each chip select, the \e ulDivider parameter must contain +//! two dividers. The lower 16 bits define the divider to be used with CS0n +//! and the upper 16 bits define the divider for CS1n. +//! +//! \return None. +// +//***************************************************************************** +void +EPIDividerSet(unsigned long ulBase, unsigned long ulDivider) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + + // + // Write the divider value to the register. + // + HWREG(ulBase + EPI_O_BAUD) = ulDivider; +} + +//***************************************************************************** +// +//! Configures the SDRAM mode of operation. +//! +//! \param ulBase is the EPI module base address. +//! \param ulConfig is the SDRAM interface configuration. +//! \param ulRefresh is the refresh count in core clocks (0-2047). +//! +//! This function is used to configure the SDRAM interface, when the SDRAM +//! mode is chosen with the function EPIModeSet(). The parameter \e ulConfig +//! is the logical OR of several sets of choices: +//! +//! The processor core frequency must be specified with one of the following: +//! +//! - \b EPI_SDRAM_CORE_FREQ_0_15 - core clock is 0 MHz < clk <= 15 MHz +//! - \b EPI_SDRAM_CORE_FREQ_15_30 - core clock is 15 MHz < clk <= 30 MHz +//! - \b EPI_SDRAM_CORE_FREQ_30_50 - core clock is 30 MHz < clk <= 50 MHz +//! - \b EPI_SDRAM_CORE_FREQ_50_100 - core clock is 50 MHz < clk <= 100 MHz +//! +//! The low power mode is specified with one of the following: +//! +//! - \b EPI_SDRAM_LOW_POWER - enter low power, self-refresh state +//! - \b EPI_SDRAM_FULL_POWER - normal operating state +//! +//! The SDRAM device size is specified with one of the following: +//! +//! - \b EPI_SDRAM_SIZE_64MBIT - 64 Mbit device (8 MB) +//! - \b EPI_SDRAM_SIZE_128MBIT - 128 Mbit device (16 MB) +//! - \b EPI_SDRAM_SIZE_256MBIT - 256 Mbit device (32 MB) +//! - \b EPI_SDRAM_SIZE_512MBIT - 512 Mbit device (64 MB) +//! +//! The parameter \e ulRefresh sets the refresh counter in units of core +//! clock ticks. It is an 11-bit value with a range of 0 - 2047 counts. +//! +//! \return None. +// +//***************************************************************************** +void +EPIConfigSDRAMSet(unsigned long ulBase, unsigned long ulConfig, + unsigned long ulRefresh) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulRefresh < 2048); + + // + // Fill in the refresh count field of the configuration word. + // + ulConfig &= ~EPI_SDRAMCFG_RFSH_M; + ulConfig |= ulRefresh << EPI_SDRAMCFG_RFSH_S; + + // + // Write the SDRAM configuration register. + // + HWREG(ulBase + EPI_O_SDRAMCFG) = ulConfig; +} + +//***************************************************************************** +// +//! Configures the interface for Host-bus 8 operation. +//! +//! \param ulBase is the EPI module base address. +//! \param ulConfig is the interface configuration. +//! \param ulMaxWait is the maximum number of external clocks to wait +//! if a FIFO ready signal is holding off the transaction. +//! +//! This function is used to configure the interface when used in Host-bus 8 +//! operation as chosen with the function EPIModeSet(). The parameter +//! \e ulConfig is the logical OR of any of the following: +//! +//! - one of \b EPI_HB8_MODE_ADMUX, \b EPI_HB8_MODE_ADDEMUX, +//! \b EPI_HB8_MODE_SRAM, or \b EPI_HB8_MODE_FIFO to select the HB8 mode +//! - \b EPI_HB8_USE_TXEMPTY - enable TXEMPTY signal with FIFO +//! - \b EPI_HB8_USE_RXFULL - enable RXFULL signal with FIFO +//! - \b EPI_HB8_WRHIGH - use active high write strobe, otherwise it is +//! active low +//! - \b EPI_HB8_RDHIGH - use active high read strobe, otherwise it is +//! active low +//! - one of \b EPI_HB8_WRWAIT_0, \b EPI_HB8_WRWAIT_1, \b EPI_HB8_WRWAIT_2, +//! or \b EPI_HB8_WRWAIT_3 to select the number of write wait states (default +//! is 0 wait states) +//! - one of \b EPI_HB8_RDWAIT_0, \b EPI_HB8_RDWAIT_1, \b EPI_HB8_RDWAIT_2, +//! or \b EPI_HB8_RDWAIT_3 to select the number of read wait states (default +//! is 0 wait states) +//! - \b EPI_HB8_WORD_ACCESS - use Word Access mode to route bytes to the +//! correct byte lanes allowing data to be stored in bits [31:8]. If absent, +//! all data transfers use bits [7:0]. +//! - \b EPI_HB8_CSBAUD_DUAL - use different baud rates when accessing devices +//! on each CSn. CS0n uses the baud rate specified by the lower 16 bits of the +//! divider passed to EPIDividerSet() and CS1n uses the divider passed in the +//! upper 16 bits. If this option is absent, both chip selects use the baud +//! rate resulting from the divider in the lower 16 bits of the parameter passed +//! to EPIDividerSet(). +//! - one of \b EPI_HB8_CSCFG_CS, \b EPI_HB8_CSCFG_ALE, +//! \b EPI_HB8_CSCFG_DUAL_CS or \b EPI_HB8_CSCFG_ALE_DUAL_CS. \b +//! EPI_HB8_CSCFG_CS sets EPI30 to operate as a Chip Select (CSn) signal. \b +//! EPI_HB8_CSCFG_ALE sets EPI30 to operate as an address latch (ALE). \b +//! EPI_HB8_CSCFG_DUAL_CS sets EPI30 to operate as CS0n and EPI27 as CS1n with +//! the asserted chip select determined from the most significant address bit +//! for the respective external address map. \b EPI_HB8_CSCFG_ALE_DUAL_CS sets +//! EPI30 as an address latch (ALE), EPI27 as CS0n and EPI26 as CS1n with the +//! asserted chip select determined from the most significant address bit for +//! the respective external address map. +//! +//! The parameter \e ulMaxWait is used if the FIFO mode is chosen. If a +//! FIFO is used along with RXFULL or TXEMPTY ready signals, then this +//! parameter determines the maximum number of clocks to wait when the +//! transaction is being held off by by the FIFO using one of these ready +//! signals. A value of 0 means to wait forever. +//! +//! \return None. +// +//***************************************************************************** +void +EPIConfigHB8Set(unsigned long ulBase, unsigned long ulConfig, + unsigned long ulMaxWait) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulMaxWait < 256); + + // + // Determine the CS and word access modes. + // + HWREG(ulBase + EPI_O_HB8CFG2) = (((ulConfig & EPI_HB8_WORD_ACCESS) ? + EPI_HB8CFG2_WORD : 0) | + ((ulConfig & EPI_HB8_CSBAUD_DUAL) ? + EPI_HB8CFG2_CSBAUD : 0) | + ((ulConfig & EPI_HB8_CSCFG_MASK) << 15)); + // + // Fill in the max wait field of the configuration word. + // + ulConfig &= ~EPI_HB8CFG_MAXWAIT_M; + ulConfig |= ulMaxWait << EPI_HB8CFG_MAXWAIT_S; + + // + // Write the main HostBus8 configuration register. + // + HWREG(ulBase + EPI_O_HB8CFG) = ulConfig; +} + +//***************************************************************************** +// +//! Configures the interface for Host-bus 16 operation. +//! +//! \param ulBase is the EPI module base address. +//! \param ulConfig is the interface configuration. +//! \param ulMaxWait is the maximum number of external clocks to wait +//! if a FIFO ready signal is holding off the transaction. +//! +//! This function is used to configure the interface when used in Host-bus 16 +//! operation as chosen with the function EPIModeSet(). The parameter +//! \e ulConfig is the logical OR of any of the following: +//! +//! - one of \b EPI_HB16_MODE_ADMUX, \b EPI_HB16_MODE_ADDEMUX, +//! \b EPI_HB16_MODE_SRAM, or \b EPI_HB16_MODE_FIFO to select the HB16 mode +//! - \b EPI_HB16_USE_TXEMPTY - enable TXEMPTY signal with FIFO +//! - \b EPI_HB16_USE_RXFULL - enable RXFULL signal with FIFO +//! - \b EPI_HB16_WRHIGH - use active high write strobe, otherwise it is +//! active low +//! - \b EPI_HB16_RDHIGH - use active high read strobe, otherwise it is +//! active low +//! - one of \b EPI_HB16_WRWAIT_0, \b EPI_HB16_WRWAIT_1, \b EPI_HB16_WRWAIT_2, +//! or \b EPI_HB16_WRWAIT_3 to select the number of write wait states (default +//! is 0 wait states) +//! - one of \b EPI_HB16_RDWAIT_0, \b EPI_HB16_RDWAIT_1, \b EPI_HB16_RDWAIT_2, +//! or \b EPI_HB16_RDWAIT_3 to select the number of read wait states (default +//! is 0 wait states) +//! - \b EPI_HB16_WORD_ACCESS - use Word Access mode to route bytes to the +//! correct byte lanes allowing data to be stored in bits [31:8]. If absent, +//! all data transfers use bits [7:0]. +//! - \b EPI_HB16_BSEL - enables byte selects. In this mode, two EPI signals +//! operate as byte selects allowing 8-bit transfers. If this flag is not +//! specified, data must be read and written using only 16-bit transfers. +//! - \b EPI_HB16_CSBAUD_DUAL - use different baud rates when accessing devices +//! on each CSn. CS0n uses the baud rate specified by the lower 16 bits of the +//! divider passed to EPIDividerSet() and CS1n uses the divider passed in the +//! upper 16 bits. If this option is absent, both chip selects use the baud +//! rate resulting from the divider in the lower 16 bits of the parameter passed +//! to EPIDividerSet(). +//! - one of \b EPI_HB16_CSCFG_CS, \b EPI_HB16_CSCFG_ALE, +//! \b EPI_HB16_CSCFG_DUAL_CS or \b EPI_HB16_CSCFG_ALE_DUAL_CS. \b +//! EPI_HB16_CSCFG_CS sets EPI30 to operate as a Chip Select (CSn) signal. \b +//! EPI_HB16_CSCFG_ALE sets EPI30 to operate as an address latch (ALE). +//! \b EPI_HB16_CSCFG_DUAL_CS sets EPI30 to operate as CS0n and EPI27 as CS1n +//! with the asserted chip select determined from the most significant address +//! bit for the respective external address map. \b EPI_HB16_CSCFG_ALE_DUAL_CS +//! sets EPI30 as an address latch (ALE), EPI27 as CS0n and EPI26 as CS1n with +//! the asserted chip select determined from the most significant address bit +//! for the respective external address map. +//! +//! The parameter \e ulMaxWait is used if the FIFO mode is chosen. If a +//! FIFO is used along with RXFULL or TXEMPTY ready signals, then this +//! parameter determines the maximum number of clocks to wait when the +//! transaction is being held off by by the FIFO using one of these ready +//! signals. A value of 0 means to wait forever. +//! +//! \return None. +// +//***************************************************************************** +void +EPIConfigHB16Set(unsigned long ulBase, unsigned long ulConfig, + unsigned long ulMaxWait) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulMaxWait < 256); + + // + // Determine the CS and word access modes. + // + HWREG(ulBase + EPI_O_HB16CFG2) = (((ulConfig & EPI_HB16_WORD_ACCESS) ? + EPI_HB16CFG2_WORD : 0) | + ((ulConfig & EPI_HB16_CSBAUD_DUAL) ? + EPI_HB16CFG2_CSBAUD : 0) | + ((ulConfig & EPI_HB16_CSCFG_MASK) << 15)); + + // + // Fill in the max wait field of the configuration word. + // + ulConfig &= ~EPI_HB16CFG_MAXWAIT_M; + ulConfig |= ulMaxWait << EPI_HB16CFG_MAXWAIT_S; + + // + // Write the main HostBus16 configuration register. + // + HWREG(ulBase + EPI_O_HB16CFG) = ulConfig; +} + +//***************************************************************************** +// +//! Configures the interface for general-purpose mode operation. +//! +//! \param ulBase is the EPI module base address. +//! \param ulConfig is the interface configuration. +//! \param ulFrameCount is the frame size in clocks, if the frame signal +//! is used (0-15). +//! \param ulMaxWait is the maximum number of external clocks to wait +//! when the external clock enable is holding off the transaction (0-255). +//! +//! This function is used to configure the interface when used in +//! general-purpose operation as chosen with the function EPIModeSet(). The +//! parameter +//! \e ulConfig is the logical OR of any of the following: +//! +//! - \b EPI_GPMODE_CLKPIN - interface clock is output on a pin +//! - \b EPI_GPMODE_CLKGATE - clock is stopped when there is no transaction, +//! otherwise it is free-running +//! - \b EPI_GPMODE_RDYEN - the external peripheral drives an iRDY signal into +//! pin EPI0S27. If absent, the peripheral is assumed to be ready at all times. +//! This flag may only be used with a free-running clock (\b EPI_GPMODE_CLKGATE +//! is absent). +//! - \b EPI_GPMODE_FRAMEPIN - framing signal is emitted on a pin +//! - \b EPI_GPMODE_FRAME50 - framing signal is 50/50 duty cycle, otherwise it +//! is a pulse +//! - \b EPI_GPMODE_READWRITE - read and write strobes are emitted on pins +//! - \b EPI_GPMODE_WRITE2CYCLE - a two cycle write is used, otherwise a +//! single-cycle write is used +//! - \b EPI_GPMODE_READ2CYCLE - a two cycle read is used, otherwise a +//! single-cycle read is used +//! - \b EPI_GPMODE_ASIZE_NONE, \b EPI_GPMODE_ASIZE_4, +//! \b EPI_GPMODE_ASIZE_12, or \b EPI_GPMODE_ASIZE_20 to choose no address +//! bus, or and address bus size of 4, 12, or 20 bits +//! - \b EPI_GPMODE_DSIZE_8, \b EPI_GPMODE_DSIZE_16, +//! \b EPI_GPMODE_DSIZE_24, or \b EPI_GPMODE_DSIZE_32 to select a data bus +//! size of 8, 16, 24, or 32 bits +//! - \b EPI_GPMODE_WORD_ACCESS - use Word Access mode to route bytes to the +//! correct byte lanes allowing data to be stored in the upper bits of the word +//! when necessary. +//! +//! The parameter \e ulFrameCount is the number of clocks used to form the +//! framing signal, if the framing signal is used. The behavior depends on +//! whether the frame signal is a pulse or a 50/50 duty cycle. This value +//! is not used if the framing signal is not enabled with the option +//! \b EPI_GPMODE_FRAMEPIN. +//! +//! The parameter \e ulMaxWait is used if the external clock enable is turned +//! on with the \b EPI_GPMODE_CLKENA option is used. In the case that +//! external clock enable is used, this parameter determines the maximum +//! number of clocks to wait when the external clock enable signal is holding +//! off a transaction. A value of 0 means to wait forever. If a non-zero +//! value is used and exceeded, an interrupt will occur and the transaction +//! aborted. +//! +//! \return None. +// +//***************************************************************************** +void +EPIConfigGPModeSet(unsigned long ulBase, unsigned long ulConfig, + unsigned long ulFrameCount, unsigned long ulMaxWait) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulFrameCount < 16); + ASSERT(ulMaxWait < 256); + + // + // Set the word access mode. + // + HWREG(ulBase + EPI_O_GPCFG2) = ((ulConfig & EPI_GPMODE_WORD_ACCESS) ? + EPI_GPCFG2_WORD : 0); + + // + // Fill in the frame count field of the configuration word. + // + ulConfig &= ~EPI_GPCFG_FRMCNT_M; + ulConfig |= ulFrameCount << EPI_GPCFG_FRMCNT_S; + + // + // Fill in the max wait field of the configuration word. + // + ulConfig &= ~EPI_GPCFG_MAXWAIT_M; + ulConfig |= ulMaxWait << EPI_GPCFG_MAXWAIT_S; + + // + // Write the non-moded configuration register. + // + HWREG(ulBase + EPI_O_GPCFG) = ulConfig; +} + +//***************************************************************************** +// +//! Configures the address map for the external interface. +//! +//! \param ulBase is the EPI module base address. +//! \param ulMap is the address mapping configuration. +//! +//! This function is used to configure the address mapping for the external +//! interface. This determines the base address of the external memory or +//! device within the processor peripheral and/or memory space. +//! +//! The parameter \e ulMap is the logical OR of the following: +//! +//! - \b EPI_ADDR_PER_SIZE_256B, \b EPI_ADDR_PER_SIZE_64KB, +//! \b EPI_ADDR_PER_SIZE_16MB, or \b EPI_ADDR_PER_SIZE_512MB to choose a +//! peripheral address space of 256 bytes, 64 Kbytes, 16 Mbytes or 512 Mbytes +//! - \b EPI_ADDR_PER_BASE_NONE, \b EPI_ADDR_PER_BASE_A, or +//! \b EPI_ADDR_PER_BASE_C to choose the base address of the peripheral +//! space as none, 0xA0000000, or 0xC0000000 +//! - \b EPI_ADDR_RAM_SIZE_256B, \b EPI_ADDR_RAM_SIZE_64KB, +//! \b EPI_ADDR_RAM_SIZE_16MB, or \b EPI_ADDR_RAM_SIZE_512MB to choose a +//! RAM address space of 256 bytes, 64 Kbytes, 16 Mbytes or 512 Mbytes +//! - \b EPI_ADDR_RAM_BASE_NONE, \b EPI_ADDR_RAM_BASE_6, or +//! \b EPI_ADDR_RAM_BASE_8 to choose the base address of the RAM space +//! as none, 0x60000000, or 0x80000000 +//! +//! \return None. +// +//***************************************************************************** +void +EPIAddressMapSet(unsigned long ulBase, unsigned long ulMap) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulMap < 0x100); + + // + // Set the value of the address mapping register. + // + HWREG(ulBase + EPI_O_ADDRMAP) = ulMap; +} + +//***************************************************************************** +// +//! Configures a non-blocking read transaction. +//! +//! \param ulBase is the EPI module base address. +//! \param ulChannel is the read channel (0 or 1). +//! \param ulDataSize is the size of the data items to read. +//! \param ulAddress is the starting address to read. +//! +//! This function is used to configure a non-blocking read channel for a +//! transaction. Two channels are available which can be used in a ping-pong +//! method for continuous reading. It is not necessary to use both channels +//! to perform a non-blocking read. +//! +//! The parameter \e ulDataSize is one of \b EPI_NBCONFIG_SIZE_8, +//! \b EPI_NBCONFIG_SIZE_16, or \b EPI_NBCONFIG_SIZE_32 for 8-bit, 16-bit, +//! or 32-bit sized data transfers. +//! +//! The parameter \e ulAddress is the starting address for the read, relative +//! to the external device. The start of the device is address 0. +//! +//! Once configured, the non-blocking read is started by calling +//! EPINonBlockingReadStart(). If the addresses to be read from the device +//! are in a sequence, it is not necessary to call this function multiple +//! times. Until it is changed, the EPI module will remember the last address +//! that was used for a non-blocking read (per channel). +//! +//! \return None. +// +//***************************************************************************** +void +EPINonBlockingReadConfigure(unsigned long ulBase, unsigned long ulChannel, + unsigned long ulDataSize, unsigned long ulAddress) +{ + unsigned long ulOffset; + + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulChannel < 2); + ASSERT(ulDataSize < 4); + ASSERT(ulAddress < 0x20000000); + + // + // Compute the offset needed to select the correct channel regs. + // + ulOffset = ulChannel * (EPI_O_RSIZE1 - EPI_O_RSIZE0); + + // + // Write the data size register for the channel. + // + HWREG(ulBase + EPI_O_RSIZE0 + ulOffset) = ulDataSize; + + // + // Write the starting address register for the channel. + // + HWREG(ulBase + EPI_O_RADDR0 + ulOffset) = ulAddress; +} + +//***************************************************************************** +// +//! Starts a non-blocking read transaction. +//! +//! \param ulBase is the EPI module base address. +//! \param ulChannel is the read channel (0 or 1). +//! \param ulCount is the number of items to read (1-4095). +//! +//! This function starts a non-blocking read that was previously configured +//! with the function EPINonBlockingReadConfigure(). Once this function is +//! called, the EPI module will begin reading data from the external device +//! into the read FIFO. The EPI will stop reading when the FIFO fills up +//! and resume reading when the application drains the FIFO, until the +//! total specified count of data items has been read. +//! +//! Once a read transaction is completed and the FIFO drained, another +//! transaction can be started from the next address by calling this +//! function again. +//! +//! \return None. +// +//***************************************************************************** +void +EPINonBlockingReadStart(unsigned long ulBase, unsigned long ulChannel, + unsigned long ulCount) +{ + unsigned long ulOffset; + + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulChannel < 2); + ASSERT(ulCount < 4096); + + // + // Compute the offset needed to select the correct channel regs. + // + ulOffset = ulChannel * (EPI_O_RPSTD1 - EPI_O_RPSTD0); + + // + // Write to the read count register. + // + HWREG(ulBase + EPI_O_RPSTD0 + ulOffset) = ulCount; +} + +//***************************************************************************** +// +//! Stops a non-blocking read transaction. +//! +//! \param ulBase is the EPI module base address. +//! \param ulChannel is the read channel (0 or 1). +//! +//! This function cancels a non-blocking read transaction that is already +//! in progress. +//! +//! \return None. +// +//***************************************************************************** +void +EPINonBlockingReadStop(unsigned long ulBase, unsigned long ulChannel) +{ + unsigned long ulOffset; + + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulChannel < 2); + + // + // Compute the offset needed to select the correct channel regs. + // + ulOffset = ulChannel * (EPI_O_RPSTD1 - EPI_O_RPSTD0); + + // + // Write a 0 to the read count register, which will cancel the transaction. + // + HWREG(ulBase + EPI_O_RPSTD0 + ulOffset) = 0; +} + +//***************************************************************************** +// +//! Get the count remaining for a non-blocking transaction. +//! +//! \param ulBase is the EPI module base address. +//! \param ulChannel is the read channel (0 or 1). +//! +//! This function gets the remaining count of items for a non-blocking read +//! transaction. +//! +//! \return The number of items remaining in the non-blocking read transaction. +// +//***************************************************************************** +unsigned long +EPINonBlockingReadCount(unsigned long ulBase, unsigned long ulChannel) +{ + unsigned long ulOffset; + + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulChannel < 2); + + // + // Compute the offset needed to select the correct channel regs. + // + ulOffset = ulChannel * (EPI_O_RPSTD1 - EPI_O_RPSTD0); + + // + // Read the count remaining and return the value to the caller. + // + return(HWREG(ulBase + EPI_O_RPSTD0 + ulOffset)); +} + +//***************************************************************************** +// +//! Get the count of items available in the read FIFO. +//! +//! \param ulBase is the EPI module base address. +//! +//! This function gets the number of items that are available to read in +//! the read FIFO. The read FIFO is filled by a non-blocking read transaction +//! which is configured by the functions EPINonBlockingReadConfigure() and +//! EPINonBlockingReadStart(). +//! +//! \return The number of items available to read in the read FIFO. +// +//***************************************************************************** +unsigned long +EPINonBlockingReadAvail(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + + // + // Read the FIFO count and return it to the caller. + // + return(HWREG(ulBase + EPI_O_RFIFOCNT)); +} + +//***************************************************************************** +// +//! Read available data from the read FIFO, as 32-bit data items. +//! +//! \param ulBase is the EPI module base address. +//! \param ulCount is the maximum count of items to read. +//! \param pulBuf is the caller supplied buffer where the read data should +//! be stored. +//! +//! This function reads 32-bit data items from the read FIFO and stores +//! the values in a caller supplied buffer. The function will read and store +//! data from the FIFO until there is no more data in the FIFO or the maximum +//! count is reached as specified in the parameter \e ulCount. The actual +//! count of items will be returned. +//! +//! \return The number of items read from the FIFO. +// +//***************************************************************************** +unsigned long +EPINonBlockingReadGet32(unsigned long ulBase, unsigned long ulCount, + unsigned long *pulBuf) +{ + unsigned long ulCountRead = 0; + + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulCount < 4096); + ASSERT(pulBuf); + + // + // Read from the FIFO while there are any items to read, and + // the callers specified count is not exceeded. + // + while(HWREG(ulBase + EPI_O_RFIFOCNT) && ulCount--) + { + // + // Read from the FIFO and store in the caller supplied buffer. + // + *pulBuf = HWREG(ulBase + EPI_O_READFIFO); + + // + // Update the caller's buffer pointer and the count of items read. + // + pulBuf++; + ulCountRead++; + } + + // + // Return the count of items read to the caller. + // + return(ulCountRead); +} + +//***************************************************************************** +// +//! Read available data from the read FIFO, as 16-bit data items. +//! +//! \param ulBase is the EPI module base address. +//! \param ulCount is the maximum count of items to read. +//! \param pusBuf is the caller supplied buffer where the read data should +//! be stored. +//! +//! This function reads 16-bit data items from the read FIFO and stores +//! the values in a caller supplied buffer. The function will read and store +//! data from the FIFO until there is no more data in the FIFO or the maximum +//! count is reached as specified in the parameter \e ulCount. The actual +//! count of items will be returned. +//! +//! \return The number of items read from the FIFO. +// +//***************************************************************************** +unsigned long +EPINonBlockingReadGet16(unsigned long ulBase, unsigned long ulCount, + unsigned short *pusBuf) +{ + unsigned long ulCountRead = 0; + + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulCount < 4096); + ASSERT(pusBuf); + + // + // Read from the FIFO while there are any items to read, and + // the callers specified count is not exceeded. + // + while(HWREG(ulBase + EPI_O_RFIFOCNT) && ulCount--) + { + // + // Read from the FIFO and store in the caller supplied buffer. + // + *pusBuf = (unsigned short)HWREG(ulBase + EPI_O_READFIFO); + + // + // Update the caller's buffer pointer and the count of items read. + // + pusBuf++; + ulCountRead++; + } + + // + // Return the count of items read to the caller. + // + return(ulCountRead); +} + +//***************************************************************************** +// +//! Read available data from the read FIFO, as 8-bit data items. +//! +//! \param ulBase is the EPI module base address. +//! \param ulCount is the maximum count of items to read. +//! \param pucBuf is the caller supplied buffer where the read data should +//! be stored. +//! +//! This function reads 8-bit data items from the read FIFO and stores +//! the values in a caller supplied buffer. The function will read and store +//! data from the FIFO until there is no more data in the FIFO or the maximum +//! count is reached as specified in the parameter \e ulCount. The actual +//! count of items will be returned. +//! +//! \return The number of items read from the FIFO. +// +//***************************************************************************** +unsigned long +EPINonBlockingReadGet8(unsigned long ulBase, unsigned long ulCount, + unsigned char *pucBuf) +{ + unsigned long ulCountRead = 0; + + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulCount < 4096); + ASSERT(pucBuf); + + // + // Read from the FIFO while there are any items to read, and + // the callers specified count is not exceeded. + // + while(HWREG(ulBase + EPI_O_RFIFOCNT) && ulCount--) + { + // + // Read from the FIFO and store in the caller supplied buffer. + // + *pucBuf = (unsigned char)HWREG(ulBase + EPI_O_READFIFO); + + // + // Update the caller's buffer pointer and the count of items read. + // + pucBuf++; + ulCountRead++; + } + + // + // Return the count of items read to the caller. + // + return(ulCountRead); +} + +//***************************************************************************** +// +//! Configures the read FIFO. +//! +//! \param ulBase is the EPI module base address. +//! \param ulConfig is the FIFO configuration. +//! +//! This function configures the FIFO trigger levels and error +//! generation. The parameter \e ulConfig is the logical OR of the +//! following: +//! +//! - \b EPI_FIFO_CONFIG_WTFULLERR - enables an error interrupt when a write is +//! attempted and the write FIFO is full +//! - \b EPI_FIFO_CONFIG_RSTALLERR - enables an error interrupt when a read is +//! stalled due to an interleaved write or other reason +//! - \b EPI_FIFO_CONFIG_TX_EMPTY, \b EPI_FIFO_CONFIG_TX_1_4, +//! \b EPI_FIFO_CONFIG_TX_1_2, or \b EPI_FIFO_CONFIG_TX_3_4 to set the +//! TX FIFO trigger level to empty, 1/4, 1/2, or 3/4 level +//! - \b EPI_FIFO_CONFIG_RX_1_8, \b EPI_FIFO_CONFIG_RX_1_4, +//! \b EPI_FIFO_CONFIG_RX_1_2, \b EPI_FIFO_CONFIG_RX_3_4, +//! \b EPI_FIFO_CONFIG_RX_7_8, or \b EPI_FIFO_CONFIG_RX_FULL to set the +//! RX FIFO trigger level to 1/8, 1/4, 1/2, 3/4, 7/8 or full level +//! +//! \return None. +// +//***************************************************************************** +void +EPIFIFOConfig(unsigned long ulBase, unsigned long ulConfig) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulConfig == (ulConfig & 0x00030077)); + + // + // Load the configuration into the FIFO config reg. + // + HWREG(ulBase + EPI_O_FIFOLVL) = ulConfig; +} + +//***************************************************************************** +// +//! Reads the number of empty slots in the write transaction FIFO. +//! +//! \param ulBase is the EPI module base address. +//! +//! This function returns the number of slots available in the transaction +//! FIFO. It can be used in a polling method to avoid attempting a write +//! that would stall. +//! +//! \return The number of empty slots in the transaction FIFO. +// +//***************************************************************************** +unsigned long +EPIWriteFIFOCountGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + + // + // Read the FIFO count and return it to the caller. + // + return(HWREG(ulBase + EPI_O_WFIFOCNT)); +} + +//***************************************************************************** +// +//! Enables EPI interrupt sources. +//! +//! \param ulBase is the EPI module base address. +//! \param ulIntFlags is a bit mask of the interrupt sources to be enabled. +//! +//! This function enables the specified EPI sources to generate interrupts. +//! The \e ulIntFlags parameter can be the logical OR of any of the following +//! values: +//! +//! - \b EPI_INT_TXREQ - transmit FIFO is below the trigger level +//! - \b EPI_INT_RXREQ - read FIFO is above the trigger level +//! - \b EPI_INT_ERR - an error condition occurred +//! +//! \return Returns None. +// +//***************************************************************************** +void +EPIIntEnable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulIntFlags < 16); + + // + // Write the interrupt flags mask to the mask register. + // + HWREG(ulBase + EPI_O_IM) |= ulIntFlags; +} + +//***************************************************************************** +// +//! Disables EPI interrupt sources. +//! +//! \param ulBase is the EPI module base address. +//! \param ulIntFlags is a bit mask of the interrupt sources to be disabled. +//! +//! This function disables the specified EPI sources for interrupt +//! generation. The \e ulIntFlags parameter can be the logical OR +//! of any of the following values: \b EPI_INT_RXREQ, \b EPI_INT_TXREQ, or +//! \b I2S_INT_ERR. +//! +//! \return Returns None. +// +//***************************************************************************** +void +EPIIntDisable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulIntFlags < 16); + + // + // Write the interrupt flags mask to the mask register. + // + HWREG(ulBase + EPI_O_IM) &= ~ulIntFlags; +} + +//***************************************************************************** +// +//! Gets the EPI interrupt status. +//! +//! \param ulBase is the EPI module base address. +//! \param bMasked is set \b true to get the masked interrupt status, or +//! \b false to get the raw interrupt status. +//! +//! This function returns the EPI interrupt status. It can return either +//! the raw or masked interrupt status. +//! +//! \return Returns the masked or raw EPI interrupt status, as a bit field +//! of any of the following values: \b EPI_INT_TXREQ, \b EPI_INT_RXREQ, +//! or \b EPI_INT_ERR +// +//***************************************************************************** +unsigned long +EPIIntStatus(unsigned long ulBase, tBoolean bMasked) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + return(HWREG(ulBase + EPI_O_MIS)); + } + else + { + return(HWREG(ulBase + EPI_O_RIS)); + } +} + +//***************************************************************************** +// +//! Gets the EPI error interrupt status. +//! +//! \param ulBase is the EPI module base address. +//! +//! This function returns the error status of the EPI. If the return value of +//! the function EPIIntStatus() has the flag \b EPI_INT_ERR set, then this +//! function can be used to determine the cause of the error. +//! +//! This function returns a bit mask of error flags, which can be the logical +//! OR of any of the following: +//! +//! - \b EPI_INT_ERR_WTFULL - occurs when a write stalled when the transaction +//! FIFO was full +//! - \b EPI_INT_ERR_RSTALL - occurs when a read stalled +//! - \b EPI_INT_ERR_TIMEOUT - occurs when the external clock enable held +//! off a transaction longer than the configured maximum wait time +//! +//! \return Returns the interrupt error flags as the logical OR of any of +//! the following: \b EPI_INT_ERR_WTFULL, \b EPI_INT_ERR_RSTALL, or +//! \b EPI_INT_ERR_TIMEOUT. +// +//***************************************************************************** +unsigned long +EPIIntErrorStatus(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + + // + // Read the error status and return to caller. + // + return(HWREG(ulBase + EPI_O_EISC)); +} + +//***************************************************************************** +// +//! Clears pending EPI error sources. +//! +//! \param ulBase is the EPI module base address. +//! \param ulErrFlags is a bit mask of the error sources to be cleared. +//! +//! This function clears the specified pending EPI errors. The \e ulErrFlags +//! parameter can be the logical OR of any of the following values: +//! \b EPI_INT_ERR_WTFULL, \b EPI_INT_ERR_RSTALL, or \b EPI_INT_ERR_TIMEOUT. +//! +//! \return Returns None. +// +//***************************************************************************** +void +EPIIntErrorClear(unsigned long ulBase, unsigned long ulErrFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(ulErrFlags < 16); + + // + // Write the error flags to the register to clear the pending errors. + // + HWREG(ulBase + EPI_O_EISC) = ulErrFlags; +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the EPI module. +//! +//! \param ulBase is the EPI module base address. +//! \param pfnHandler is a pointer to the function to be called when the +//! interrupt is activated. +//! +//! This sets and enables the handler to be called when the EPI module +//! generates an interrupt. Specific EPI interrupts must still be enabled +//! with the EPIIntEnable() function. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +EPIIntRegister(unsigned long ulBase, void (*pfnHandler)(void)) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + ASSERT(pfnHandler); + + // + // Register the interrupt handler. + // + IntRegister(INT_EPI0, pfnHandler); + + // + // Enable the EPI interface interrupt. + // + IntEnable(INT_EPI0); +} + +//***************************************************************************** +// +//! Unregisters an interrupt handler for the EPI module. +//! +//! \param ulBase is the EPI module base address. +//! +//! This function will disable and clear the handler to be called when the +//! EPI interrupt occurs. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +EPIIntUnregister(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == EPI0_BASE); + + // + // Disable the EPI interface interrupt. + // + IntDisable(INT_EPI0); + + // + // Unregister the interrupt handler. + // + IntUnregister(INT_EPI0); +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/epi.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/epi.h new file mode 100644 index 00000000..44ccb4dc --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/epi.h @@ -0,0 +1,304 @@ +//***************************************************************************** +// +// epi.h - Prototypes and macros for the EPI module. +// +// Copyright (c) 2008-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __EPI_H__ +#define __EPI_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Values that can be passed to EPIModeSet() +// +//***************************************************************************** +#define EPI_MODE_GENERAL 0x00000010 +#define EPI_MODE_SDRAM 0x00000011 +#define EPI_MODE_HB8 0x00000012 +#define EPI_MODE_HB16 0x00000013 +#define EPI_MODE_DISABLE 0x00000000 + +//***************************************************************************** +// +// Values that can be passed to EPIConfigSDRAMSet() +// +//***************************************************************************** +#define EPI_SDRAM_CORE_FREQ_0_15 0x00000000 +#define EPI_SDRAM_CORE_FREQ_15_30 0x40000000 +#define EPI_SDRAM_CORE_FREQ_30_50 0x80000000 +#define EPI_SDRAM_CORE_FREQ_50_100 0xC0000000 +#define EPI_SDRAM_LOW_POWER 0x00000200 +#define EPI_SDRAM_FULL_POWER 0x00000000 +#define EPI_SDRAM_SIZE_64MBIT 0x00000000 +#define EPI_SDRAM_SIZE_128MBIT 0x00000001 +#define EPI_SDRAM_SIZE_256MBIT 0x00000002 +#define EPI_SDRAM_SIZE_512MBIT 0x00000003 + +//***************************************************************************** +// +// Values that can be passed to EPIConfigGPModeSet() +// +//***************************************************************************** +#define EPI_GPMODE_CLKPIN 0x80000000 +#define EPI_GPMODE_CLKGATE 0x40000000 +#define EPI_GPMODE_RDYEN 0x10000000 +#define EPI_GPMODE_FRAMEPIN 0x08000000 +#define EPI_GPMODE_FRAME50 0x04000000 +#define EPI_GPMODE_READWRITE 0x00200000 +#define EPI_GPMODE_WRITE2CYCLE 0x00080000 +#define EPI_GPMODE_READ2CYCLE 0x00040000 +#define EPI_GPMODE_ASIZE_NONE 0x00000000 +#define EPI_GPMODE_ASIZE_4 0x00000010 +#define EPI_GPMODE_ASIZE_12 0x00000020 +#define EPI_GPMODE_ASIZE_20 0x00000030 +#define EPI_GPMODE_DSIZE_8 0x00000000 +#define EPI_GPMODE_DSIZE_16 0x00000001 +#define EPI_GPMODE_DSIZE_24 0x00000002 +#define EPI_GPMODE_DSIZE_32 0x00000003 +#define EPI_GPMODE_WORD_ACCESS 0x00000100 + +//***************************************************************************** +// +// Values that can be passed to EPIConfigHB8ModeSet() +// +//***************************************************************************** +#define EPI_HB8_USE_TXEMPTY 0x00800000 +#define EPI_HB8_USE_RXFULL 0x00400000 +#define EPI_HB8_WRHIGH 0x00200000 +#define EPI_HB8_RDHIGH 0x00100000 +#define EPI_HB8_WRWAIT_0 0x00000000 +#define EPI_HB8_WRWAIT_1 0x00000040 +#define EPI_HB8_WRWAIT_2 0x00000080 +#define EPI_HB8_WRWAIT_3 0x000000C0 +#define EPI_HB8_RDWAIT_0 0x00000000 +#define EPI_HB8_RDWAIT_1 0x00000010 +#define EPI_HB8_RDWAIT_2 0x00000020 +#define EPI_HB8_RDWAIT_3 0x00000030 +#define EPI_HB8_MODE_ADMUX 0x00000000 +#define EPI_HB8_MODE_ADDEMUX 0x00000001 +#define EPI_HB8_MODE_SRAM 0x00000002 +#define EPI_HB8_MODE_FIFO 0x00000003 +#define EPI_HB8_WORD_ACCESS 0x00000100 +#define EPI_HB8_CSCFG_ALE 0x00000000 +#define EPI_HB8_CSCFG_CS 0x00000200 +#define EPI_HB8_CSCFG_DUAL_CS 0x00000400 +#define EPI_HB8_CSCFG_ALE_DUAL_CS 0x00000600 +#define EPI_HB8_CSBAUD_DUAL 0x00000800 + +#define EPI_HB8_CSCFG_MASK 0x00000600 + +//***************************************************************************** +// +// Values that can be passed to EPIConfigHB16ModeSet() +// +//***************************************************************************** +#define EPI_HB16_USE_TXEMPTY 0x00800000 +#define EPI_HB16_USE_RXFULL 0x00400000 +#define EPI_HB16_WRHIGH 0x00200000 +#define EPI_HB16_RDHIGH 0x00100000 +#define EPI_HB16_WRWAIT_0 0x00000000 +#define EPI_HB16_WRWAIT_1 0x00000040 +#define EPI_HB16_WRWAIT_2 0x00000080 +#define EPI_HB16_WRWAIT_3 0x000000C0 +#define EPI_HB16_RDWAIT_0 0x00000000 +#define EPI_HB16_RDWAIT_1 0x00000010 +#define EPI_HB16_RDWAIT_2 0x00000020 +#define EPI_HB16_RDWAIT_3 0x00000030 +#define EPI_HB16_MODE_ADMUX 0x00000000 +#define EPI_HB16_MODE_ADDEMUX 0x00000001 +#define EPI_HB16_MODE_SRAM 0x00000002 +#define EPI_HB16_MODE_FIFO 0x00000003 +#define EPI_HB16_BSEL 0x00000004 +#define EPI_HB16_WORD_ACCESS 0x00000100 +#define EPI_HB16_CSCFG_ALE 0x00000000 +#define EPI_HB16_CSCFG_CS 0x00000200 +#define EPI_HB16_CSCFG_DUAL_CS 0x00000400 +#define EPI_HB16_CSCFG_ALE_DUAL_CS 0x00000600 +#define EPI_HB16_CSBAUD_DUAL 0x00000800 + +#define EPI_HB16_CSCFG_MASK 0x00000600 + +//***************************************************************************** +// +// Values that can be passed to EPIConfigSDRAMSet() +// +//***************************************************************************** +#define EPI_ADDR_PER_SIZE_256B 0x00000000 +#define EPI_ADDR_PER_SIZE_64KB 0x00000040 +#define EPI_ADDR_PER_SIZE_16MB 0x00000080 +#define EPI_ADDR_PER_SIZE_256MB 0x000000C0 +#define EPI_ADDR_PER_BASE_NONE 0x00000000 +#define EPI_ADDR_PER_BASE_A 0x00000010 +#define EPI_ADDR_PER_BASE_C 0x00000020 +#define EPI_ADDR_RAM_SIZE_256B 0x00000000 +#define EPI_ADDR_RAM_SIZE_64KB 0x00000004 +#define EPI_ADDR_RAM_SIZE_16MB 0x00000008 +#define EPI_ADDR_RAM_SIZE_256MB 0x0000000C +#define EPI_ADDR_RAM_BASE_NONE 0x00000000 +#define EPI_ADDR_RAM_BASE_6 0x00000001 +#define EPI_ADDR_RAM_BASE_8 0x00000002 + +//***************************************************************************** +// +// Values that can be passed to EPINonBlockingReadConfigure() +// +//***************************************************************************** +#define EPI_NBCONFIG_SIZE_8 1 +#define EPI_NBCONFIG_SIZE_16 2 +#define EPI_NBCONFIG_SIZE_32 3 + +//***************************************************************************** +// +// Values that can be passed to EPIFIFOConfig() +// +//***************************************************************************** +#define EPI_FIFO_CONFIG_WTFULLERR 0x00020000 +#define EPI_FIFO_CONFIG_RSTALLERR 0x00010000 +#define EPI_FIFO_CONFIG_TX_EMPTY 0x00000000 +#define EPI_FIFO_CONFIG_TX_1_4 0x00000020 +#define EPI_FIFO_CONFIG_TX_1_2 0x00000030 +#define EPI_FIFO_CONFIG_TX_3_4 0x00000040 +#define EPI_FIFO_CONFIG_RX_1_8 0x00000001 +#define EPI_FIFO_CONFIG_RX_1_4 0x00000002 +#define EPI_FIFO_CONFIG_RX_1_2 0x00000003 +#define EPI_FIFO_CONFIG_RX_3_4 0x00000004 +#define EPI_FIFO_CONFIG_RX_7_8 0x00000005 +#define EPI_FIFO_CONFIG_RX_FULL 0x00000006 + +//***************************************************************************** +// +// Values that can be passed to EPIIntEnable(), EPIIntDisable(), or returned +// as flags from EPIIntStatus() +// +//***************************************************************************** +#define EPI_INT_TXREQ 0x00000004 +#define EPI_INT_RXREQ 0x00000002 +#define EPI_INT_ERR 0x00000001 + +//***************************************************************************** +// +// Values that can be passed to EPIIntErrorClear(), or returned as flags from +// EPIIntErrorStatus() +// +//***************************************************************************** +#define EPI_INT_ERR_WTFULL 0x00000004 +#define EPI_INT_ERR_RSTALL 0x00000002 +#define EPI_INT_ERR_TIMEOUT 0x00000001 + +//***************************************************************************** +// +// API Function prototypes +// +//***************************************************************************** +extern void EPIModeSet(unsigned long ulBase, unsigned long ulMode); +extern void EPIDividerSet(unsigned long ulBase, unsigned long ulDivider); +extern void EPIConfigSDRAMSet(unsigned long ulBase, unsigned long ulConfig, + unsigned long ulRefresh); +extern void EPIConfigGPModeSet(unsigned long ulBase, unsigned long ulConfig, + unsigned long ulFrameCount, + unsigned long ulMaxWait); +extern void EPIConfigHB8Set(unsigned long ulBase, unsigned long ulConfig, + unsigned long ulMaxWait); +extern void EPIConfigHB16Set(unsigned long ulBase, unsigned long ulConfig, + unsigned long ulMaxWait); +extern void EPIAddressMapSet(unsigned long ulBase, unsigned long ulMap); +extern void EPINonBlockingReadConfigure(unsigned long ulBase, + unsigned long ulChannel, + unsigned long ulDataSize, + unsigned long ulAddress); +extern void EPINonBlockingReadStart(unsigned long ulBase, + unsigned long ulChannel, + unsigned long ulCount); +extern void EPINonBlockingReadStop(unsigned long ulBase, + unsigned long ulChannel); +extern unsigned long EPINonBlockingReadCount(unsigned long ulBase, + unsigned long ulChannel); +extern unsigned long EPINonBlockingReadAvail(unsigned long ulBase); +extern unsigned long EPINonBlockingReadGet32(unsigned long ulBase, + unsigned long ulCount, + unsigned long *pulBuf); +extern unsigned long EPINonBlockingReadGet16(unsigned long ulBase, + unsigned long ulCount, + unsigned short *pusBuf); +extern unsigned long EPINonBlockingReadGet8(unsigned long ulBase, + unsigned long ulCount, + unsigned char *pucBuf); +extern void EPIFIFOConfig(unsigned long ulBase, unsigned long ulConfig); +extern unsigned long EPIWriteFIFOCountGet(unsigned long ulBase); +extern void EPIIntEnable(unsigned long ulBase, unsigned long ulIntFlags); +extern void EPIIntDisable(unsigned long ulBase, unsigned long ulIntFlags); +extern unsigned long EPIIntStatus(unsigned long ulBase, tBoolean bMasked); +extern unsigned long EPIIntErrorStatus(unsigned long ulBase); +extern void EPIIntErrorClear(unsigned long ulBase, unsigned long ulErrFlags); +extern void EPIIntRegister(unsigned long ulBase, void (*pfnHandler)(void)); +extern void EPIIntUnregister(unsigned long ulBase); + +//***************************************************************************** +// +// Several EPI APIs and labels have been renamed, with the original definition +// name being deprecated. These defines provide backward compatibility. +// +//***************************************************************************** +#ifndef DEPRECATED +#define EPI_MODE_NONE EPI_MODE_GENERAL +#define EPI_NONMODE_CLKPIN EPI_GPMODE_CLKPIN +#define EPI_NONMODE_CLKSTOP EPI_GPMODE_CLKGATE +#define EPI_NONMODE_CLKENA EPI_GPMODE_RDYEN +#define EPI_NONMODE_FRAMEPIN EPI_GPMODE_FRAMEPIN +#define EPI_NONMODE_FRAME50 EPI_GPMODE_FRAME50 +#define EPI_NONMODE_READWRITE EPI_GPMODE_READWRITE +#define EPI_NONMODE_WRITE2CYCLE EPI_GPMODE_WRITE2CYCLE +#define EPI_NONMODE_READ2CYCLE EPI_GPMODE_READ2CYCLE +#define EPI_NONMODE_ASIZE_NONE EPI_GPMODE_ASIZE_NONE +#define EPI_NONMODE_ASIZE_4 EPI_GPMODE_ASIZE_4 +#define EPI_NONMODE_ASIZE_12 EPI_GPMODE_ASIZE_12 +#define EPI_NONMODE_ASIZE_20 EPI_GPMODE_ASIZE_20 +#define EPI_NONMODE_DSIZE_8 EPI_GPMODE_DSIZE_8 +#define EPI_NONMODE_DSIZE_16 EPI_GPMODE_DSIZE_16 +#define EPI_NONMODE_DSIZE_24 EPI_GPMODE_DSIZE_24 +#define EPI_NONMODE_DSIZE_32 EPI_GPMODE_DSIZE_32 +#define EPI_NONMODE_WORD_ACCESS EPI_GPMODE_WORD_ACCESS + +#define EPINonBlockingWriteCount(a) EPIWriteFIFOCountGet(a) +#define EPIConfigNoModeSet(a, b, c, d) EPIConfigGPModeSet((a), (b), (c), (d)) +#endif + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __EPI_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ethernet.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ethernet.c new file mode 100644 index 00000000..29ade99f --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ethernet.c @@ -0,0 +1,1327 @@ +//***************************************************************************** +// +// ethernet.c - Driver for the Integrated Ethernet Controller +// +// Copyright (c) 2006-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup ethernet_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_ethernet.h" +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_types.h" +#include "driverlib/debug.h" +#include "driverlib/ethernet.h" +#include "driverlib/interrupt.h" + +//***************************************************************************** +// +//! Initializes the Ethernet controller for operation. +//! +//! \param ulBase is the base address of the controller. +//! \param ulEthClk is the rate of the clock supplied to the Ethernet module. +//! +//! This function will prepare the Ethernet controller for first time use in +//! a given hardware/software configuration. This function should be called +//! before any other Ethernet API functions are called. +//! +//! The peripheral clock will be the same as the processor clock. This will be +//! the value returned by SysCtlClockGet(), or it can be explicitly hard-coded +//! if it is constant and known (to save the code/execution overhead of a call +//! to SysCtlClockGet()). +//! +//! This function replaces the original EthernetInit() API and performs the +//! same actions. A macro is provided in ethernet.h to map the +//! original API to this API. +//! +//! \note If the device configuration is changed (for example, the system clock +//! is reprogrammed to a different speed), then the Ethernet controller must be +//! disabled by calling the EthernetDisable() function and the controller must +//! be reinitialized by calling the EthernetInitExpClk() function again. After +//! the controller has been reinitialized, the controller should be +//! reconfigured using the appropriate Ethernet API calls. +//! +//! \return None. +// +//***************************************************************************** +void +EthernetInitExpClk(unsigned long ulBase, unsigned long ulEthClk) +{ + unsigned long ulDiv; + + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + + // + // Set the Management Clock Divider register for access to the PHY + // register set (via EthernetPHYRead/Write). + // + // The MDC clock divided down from the system clock using the following + // formula. A maximum of 2.5MHz is allowed for F(mdc). + // + // F(mdc) = F(sys) / (2 * (div + 1)) + // div = (F(sys) / (2 * F(mdc))) - 1 + // div = (F(sys) / 2 / F(mdc)) - 1 + // + // Note: Because we should round up, to ensure we don't violate the + // maximum clock speed, we can simplify this as follows: + // + // div = F(sys) / 2 / F(mdc) + // + // For example, given a system clock of 6.0MHz, and a div value of 1, + // the mdc clock would be programmed as 1.5 MHz. + // + ulDiv = (ulEthClk / 2) / 2500000; + HWREG(ulBase + MAC_O_MDV) = (ulDiv & MAC_MDV_DIV_M); +} + +//***************************************************************************** +// +//! Sets the configuration of the Ethernet controller. +//! +//! \param ulBase is the base address of the controller. +//! \param ulConfig is the configuration for the controller. +//! +//! After the EthernetInitExpClk() function has been called, this API function +//! can be used to configure the various features of the Ethernet controller. +//! +//! The Ethernet controller provides three control registers that are used +//! to configure the controller's operation. The transmit control register +//! provides settings to enable full duplex operation, to auto-generate the +//! frame check sequence, and to pad the transmit packets to the minimum +//! length as required by the IEEE standard. The receive control register +//! provides settings to enable reception of packets with bad frame check +//! sequence values and to enable multi-cast or promiscuous modes. The +//! timestamp control register provides settings that enable support logic in +//! the controller that allow the use of the General Purpose Timer 3 to capture +//! timestamps for the transmitted and received packets. +//! +//! The \e ulConfig parameter is the logical OR of the following values: +//! +//! - \b ETH_CFG_TS_TSEN - Enable TX and RX interrupt status as CCP timer +//! inputs +//! - \b ETH_CFG_RX_BADCRCDIS - Disable reception of packets with a bad CRC +//! - \b ETH_CFG_RX_PRMSEN - Enable promiscuous mode reception (all packets) +//! - \b ETH_CFG_RX_AMULEN - Enable reception of multicast packets +//! - \b ETH_CFG_TX_DPLXEN - Enable full duplex transmit mode +//! - \b ETH_CFG_TX_CRCEN - Enable transmit with auto CRC generation +//! - \b ETH_CFG_TX_PADEN - Enable padding of transmit data to minimum size +//! +//! These bit-mapped values are programmed into the transmit, receive, and/or +//! timestamp control register. +//! +//! \return None. +// +//***************************************************************************** +void +EthernetConfigSet(unsigned long ulBase, unsigned long ulConfig) +{ + unsigned long ulTemp; + + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + ASSERT((ulConfig & ~(ETH_CFG_TX_DPLXEN | ETH_CFG_TX_CRCEN | + ETH_CFG_TX_PADEN | ETH_CFG_RX_BADCRCDIS | + ETH_CFG_RX_PRMSEN | ETH_CFG_RX_AMULEN | + ETH_CFG_TS_TSEN)) == 0); + + // + // Setup the Transmit Control Register. + // + ulTemp = HWREG(ulBase + MAC_O_TCTL); + ulTemp &= ~(MAC_TCTL_DUPLEX | MAC_TCTL_CRC | MAC_TCTL_PADEN); + ulTemp |= ulConfig & 0x0FF; + HWREG(ulBase + MAC_O_TCTL) = ulTemp; + + // + // Setup the Receive Control Register. + // + ulTemp = HWREG(ulBase + MAC_O_RCTL); + ulTemp &= ~(MAC_RCTL_BADCRC | MAC_RCTL_PRMS | MAC_RCTL_AMUL); + ulTemp |= (ulConfig >> 8) & 0x0FF; + HWREG(ulBase + MAC_O_RCTL) = ulTemp; + + // + // Setup the Time Stamp Configuration register. + // + ulTemp = HWREG(ulBase + MAC_O_TS); + ulTemp &= ~(MAC_TS_TSEN); + ulTemp |= (ulConfig >> 16) & 0x0FF; + HWREG(ulBase + MAC_O_TS) = ulTemp; +} + +//***************************************************************************** +// +//! Gets the current configuration of the Ethernet controller. +//! +//! \param ulBase is the base address of the controller. +//! +//! This function will query the control registers of the Ethernet controller +//! and return a bit-mapped configuration value. +//! +//! \sa The description of the EthernetConfigSet() function provides detailed +//! information for the bit-mapped configuration values that will be returned. +//! +//! \return Returns the bit-mapped Ethernet controller configuration value. +// +//***************************************************************************** +unsigned long +EthernetConfigGet(unsigned long ulBase) +{ + unsigned long ulConfig; + + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + + // + // Read and return the Ethernet controller configuration parameters, + // properly shifted into the appropriate bit field positions. + // + ulConfig = HWREG(ulBase + MAC_O_TS) << 16; + ulConfig |= (HWREG(ulBase + MAC_O_RCTL) & ~(MAC_RCTL_RXEN)) << 8; + ulConfig |= HWREG(ulBase + MAC_O_TCTL) & ~(MAC_TCTL_TXEN); + return(ulConfig); +} + +//***************************************************************************** +// +//! Sets the MAC address of the Ethernet controller. +//! +//! \param ulBase is the base address of the controller. +//! \param pucMACAddr is the pointer to the array of MAC-48 address octets. +//! +//! This function will program the IEEE-defined MAC-48 address specified in +//! \e pucMACAddr into the Ethernet controller. This address is used by the +//! Ethernet controller for hardware-level filtering of incoming Ethernet +//! packets (when promiscuous mode is not enabled). +//! +//! The MAC-48 address is defined as 6 octets, illustrated by the following +//! example address. The numbers are shown in hexadecimal format. +//! +//! AC-DE-48-00-00-80 +//! +//! In this representation, the first three octets (AC-DE-48) are the +//! Organizationally Unique Identifier (OUI). This is a number assigned by +//! the IEEE to an organization that requests a block of MAC addresses. The +//! last three octets (00-00-80) are a 24-bit number managed by the OUI owner +//! to uniquely identify a piece of hardware within that organization that is +//! to be connected to the Ethernet. +//! +//! In this representation, the octets are transmitted from left to right, +//! with the ``AC'' octet being transmitted first and the ``80'' octet being +//! transmitted last. Within an octet, the bits are transmitted LSB to MSB. +//! For this address, the first bit to be transmitted would be ``0'', the LSB +//! of ``AC'', and the last bit to be transmitted would be ``1'', the MSB of +//! ``80''. +//! +//! \return None. +// +//***************************************************************************** +void +EthernetMACAddrSet(unsigned long ulBase, unsigned char *pucMACAddr) +{ + unsigned long ulTemp; + unsigned char *pucTemp = (unsigned char *)&ulTemp; + + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + ASSERT(pucMACAddr != 0); + + // + // Program the MAC Address into the device. The first four bytes of the + // MAC Address are placed into the IA0 register. The remaining two bytes + // of the MAC address are placed into the IA1 register. + // + pucTemp[0] = pucMACAddr[0]; + pucTemp[1] = pucMACAddr[1]; + pucTemp[2] = pucMACAddr[2]; + pucTemp[3] = pucMACAddr[3]; + HWREG(ulBase + MAC_O_IA0) = ulTemp; + ulTemp = 0; + pucTemp[0] = pucMACAddr[4]; + pucTemp[1] = pucMACAddr[5]; + HWREG(ulBase + MAC_O_IA1) = ulTemp; +} + +//***************************************************************************** +// +//! Gets the MAC address of the Ethernet controller. +//! +//! \param ulBase is the base address of the controller. +//! \param pucMACAddr is the pointer to the location in which to store the +//! array of MAC-48 address octets. +//! +//! This function will read the currently programmed MAC address into the +//! \e pucMACAddr buffer. +//! +//! \sa Refer to EthernetMACAddrSet() API description for more details about +//! the MAC address format. +//! +//! \return None. +// +//***************************************************************************** +void +EthernetMACAddrGet(unsigned long ulBase, unsigned char *pucMACAddr) +{ + unsigned long ulTemp; + unsigned char *pucTemp = (unsigned char *)&ulTemp; + + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + ASSERT(pucMACAddr != 0); + + // + // Read the MAC address from the device. The first four bytes of the + // MAC address are read from the IA0 register. The remaining two bytes + // of the MAC addres + // + ulTemp = HWREG(ulBase + MAC_O_IA0); + pucMACAddr[0] = pucTemp[0]; + pucMACAddr[1] = pucTemp[1]; + pucMACAddr[2] = pucTemp[2]; + pucMACAddr[3] = pucTemp[3]; + ulTemp = HWREG(ulBase + MAC_O_IA1); + pucMACAddr[4] = pucTemp[0]; + pucMACAddr[5] = pucTemp[1]; +} + +//***************************************************************************** +// +//! Enables the Ethernet controller for normal operation. +//! +//! \param ulBase is the base address of the controller. +//! +//! Once the Ethernet controller has been configured using the +//! EthernetConfigSet() function and the MAC address has been programmed using +//! the EthernetMACAddrSet() function, this API function can be called to +//! enable the controller for normal operation. +//! +//! This function will enable the controller's transmitter and receiver, and +//! will reset the receive FIFO. +//! +//! \return None. +// +//***************************************************************************** +void +EthernetEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + + // + // Reset the receive FIFO. + // + HWREG(ulBase + MAC_O_RCTL) |= MAC_RCTL_RSTFIFO; + + // + // Enable the Ethernet receiver. + // + HWREG(ulBase + MAC_O_RCTL) |= MAC_RCTL_RXEN; + + // + // Enable Ethernet transmitter. + // + HWREG(ulBase + MAC_O_TCTL) |= MAC_TCTL_TXEN; + + // + // Reset the receive FIFO again, after the receiver has been enabled. + // + HWREG(ulBase + MAC_O_RCTL) |= MAC_RCTL_RSTFIFO; +} + +//***************************************************************************** +// +//! Disables the Ethernet controller. +//! +//! \param ulBase is the base address of the controller. +//! +//! When terminating operations on the Ethernet interface, this function should +//! be called. This function will disable the transmitter and receiver, and +//! will clear out the receive FIFO. +//! +//! \return None. +// +//***************************************************************************** +void +EthernetDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + + // + // Reset the receive FIFO. + // + HWREG(ulBase + MAC_O_RCTL) |= MAC_RCTL_RSTFIFO; + + // + // Disable the Ethernet transmitter. + // + HWREG(ulBase + MAC_O_TCTL) &= ~(MAC_TCTL_TXEN); + + // + // Disable the Ethernet receiver. + // + HWREG(ulBase + MAC_O_RCTL) &= ~(MAC_RCTL_RXEN); + + // + // Reset the receive FIFO again, after the receiver has been disabled. + // + HWREG(ulBase + MAC_O_RCTL) |= MAC_RCTL_RSTFIFO; +} + +//***************************************************************************** +// +//! Check for packet available from the Ethernet controller. +//! +//! \param ulBase is the base address of the controller. +//! +//! The Ethernet controller provides a register that contains the number of +//! packets available in the receive FIFO. When the last bytes of a packet are +//! successfully received (that is, the frame check sequence bytes), the packet +//! count is incremented. Once the packet has been fully read (including the +//! frame check sequence bytes) from the FIFO, the packet count will be +//! decremented. +//! +//! \return Returns \b true if there are one or more packets available in the +//! receive FIFO, including the current packet being read, and \b false +//! otherwise. +// +//***************************************************************************** +tBoolean +EthernetPacketAvail(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + + // + // Return the availability of packets. + // + return((HWREG(ulBase + MAC_O_NP) & MAC_NP_NPR_M) ? true : false); +} + +//***************************************************************************** +// +//! Checks for packet space available in the Ethernet controller. +//! +//! \param ulBase is the base address of the controller. +//! +//! The Ethernet controller's transmit FIFO is designed to support a single +//! packet at a time. After the packet has been written into the FIFO, the +//! transmit request bit must be set to enable the transmission of the packet. +//! Only after the packet has been transmitted can a new packet be written +//! into the FIFO. This function will simply check to see if a packet is +//! in progress. If so, there is no space available in the transmit FIFO. +//! +//! \return Returns \b true if a space is available in the transmit FIFO, and +//! \b false otherwise. +// +//***************************************************************************** +tBoolean +EthernetSpaceAvail(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + + // + // Return the availability of space. + // + return((HWREG(ulBase + MAC_O_TR) & MAC_TR_NEWTX) ? false : true); +} + +//***************************************************************************** +// +//! \internal +//! +//! Internal function for reading a packet from the Ethernet controller. +//! +//! \param ulBase is the base address of the controller. +//! \param pucBuf is the pointer to the packet buffer. +//! \param lBufLen is the maximum number of bytes to be read into the buffer. +//! +//! Based on the following table of how the receive frame is stored in the +//! receive FIFO, this function will extract a packet from the FIFO and store +//! it in the packet buffer that was passed in. +//! +//! Format of the data in the RX FIFO is as follows: +//! +//! \verbatim +//! +---------+----------+----------+----------+----------+ +//! | | 31:24 | 23:16 | 15:8 | 7:0 | +//! +---------+----------+----------+----------+----------+ +//! | Word 0 | DA 2 | DA 1 | FL MSB | FL LSB | +//! +---------+----------+----------+----------+----------+ +//! | Word 1 | DA 6 | DA 5 | DA 4 | DA 3 | +//! +---------+----------+----------+----------+----------+ +//! | Word 2 | SA 4 | SA 3 | SA 2 | SA 1 | +//! +---------+----------+----------+----------+----------+ +//! | Word 3 | FT LSB | FT MSB | SA 6 | SA 5 | +//! +---------+----------+----------+----------+----------+ +//! | Word 4 | DATA 4 | DATA 3 | DATA 2 | DATA 1 | +//! +---------+----------+----------+----------+----------+ +//! | Word 5 | DATA 8 | DATA 7 | DATA 6 | DATA 5 | +//! +---------+----------+----------+----------+----------+ +//! | Word 6 | DATA 12 | DATA 11 | DATA 10 | DATA 9 | +//! +---------+----------+----------+----------+----------+ +//! | ... | | | | | +//! +---------+----------+----------+----------+----------+ +//! | Word X | DATA n | DATA n-1 | DATA n-2 | DATA n-3 | +//! +---------+----------+----------+----------+----------+ +//! | Word Y | FCS 4 | FCS 3 | FCS 2 | FCS 1 | +//! +---------+----------+----------+----------+----------+ +//! \endverbatim +//! +//! Where FL is Frame Length, (FL + DA + SA + FT + DATA + FCS) Bytes. +//! Where DA is Destination (MAC) Address. +//! Where SA is Source (MAC) Address. +//! Where FT is Frame Type (or Frame Length for Ethernet). +//! Where DATA is Payload Data for the Ethernet Frame. +//! Where FCS is the Frame Check Sequence. +//! +//! \return Returns the negated packet length \b -n if the packet is too large +//! for \e pucBuf, and returns the packet length \b n otherwise. +// +//***************************************************************************** +static long +EthernetPacketGetInternal(unsigned long ulBase, unsigned char *pucBuf, + long lBufLen) +{ + unsigned long ulTemp; + long lFrameLen, lTempLen; + long i = 0; + + // + // Read WORD 0 (see format above) from the FIFO, set the receive + // Frame Length and store the first two bytes of the destination + // address in the receive buffer. + // + ulTemp = HWREG(ulBase + MAC_O_DATA); + lFrameLen = (long)(ulTemp & 0xFFFF); + pucBuf[i++] = (unsigned char) ((ulTemp >> 16) & 0xff); + pucBuf[i++] = (unsigned char) ((ulTemp >> 24) & 0xff); + + // + // Read all but the last WORD into the receive buffer. + // + lTempLen = (lBufLen < (lFrameLen - 6)) ? lBufLen : (lFrameLen - 6); + while(i <= (lTempLen - 4)) + { + *(unsigned long *)&pucBuf[i] = HWREG(ulBase + MAC_O_DATA); + i += 4; + } + + // + // Read the last 1, 2, or 3 BYTES into the buffer + // + if(i < lTempLen) + { + ulTemp = HWREG(ulBase + MAC_O_DATA); + if(i == lTempLen - 3) + { + pucBuf[i++] = ((ulTemp >> 0) & 0xff); + pucBuf[i++] = ((ulTemp >> 8) & 0xff); + pucBuf[i++] = ((ulTemp >> 16) & 0xff); + i += 1; + } + else if(i == lTempLen - 2) + { + pucBuf[i++] = ((ulTemp >> 0) & 0xff); + pucBuf[i++] = ((ulTemp >> 8) & 0xff); + i += 2; + } + else if(i == lTempLen - 1) + { + pucBuf[i++] = ((ulTemp >> 0) & 0xff); + i += 3; + } + } + + // + // Read any remaining WORDS (that did not fit into the buffer). + // + while(i < (lFrameLen - 2)) + { + ulTemp = HWREG(ulBase + MAC_O_DATA); + i += 4; + } + + // + // If frame was larger than the buffer, return the "negative" frame length + // + lFrameLen -= 6; + if(lFrameLen > lBufLen) + { + return(-lFrameLen); + } + + // + // Return the Frame Length + // + return(lFrameLen); +} + +//***************************************************************************** +// +//! Receives a packet from the Ethernet controller. +//! +//! \param ulBase is the base address of the controller. +//! \param pucBuf is the pointer to the packet buffer. +//! \param lBufLen is the maximum number of bytes to be read into the buffer. +//! +//! This function reads a packet from the receive FIFO of the controller and +//! places it into \e pucBuf. If no packet is available the function will +//! return immediately. Otherwise, the function will read the entire packet +//! from the receive FIFO. If there are more bytes in the packet than will fit +//! into \e pucBuf (as specified by \e lBufLen), the function will return the +//! negated length of the packet and the buffer will contain \e lBufLen bytes +//! of the packet. Otherwise, the function will return the length of the +//! packet that was read and \e pucBuf will contain the entire packet +//! (excluding the frame check sequence bytes). +//! +//! This function replaces the original EthernetPacketNonBlockingGet() API and +//! performs the same actions. A macro is provided in ethernet.h to +//! map the original API to this API. +//! +//! \note This function will return immediately if no packet is available. +//! +//! \return Returns \b 0 if no packet is available, the negated packet length +//! \b -n if the packet is too large for \e pucBuf, and the packet length \b n +//! otherwise. +// +//***************************************************************************** +long +EthernetPacketGetNonBlocking(unsigned long ulBase, unsigned char *pucBuf, + long lBufLen) +{ + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + ASSERT(pucBuf != 0); + ASSERT(lBufLen > 0); + + // + // Check to see if any packets are available. + // + if((HWREG(ulBase + MAC_O_NP) & MAC_NP_NPR_M) == 0) + { + return(0); + } + + // + // Read the packet, and return. + // + return(EthernetPacketGetInternal(ulBase, pucBuf, lBufLen)); +} + +//***************************************************************************** +// +//! Waits for a packet from the Ethernet controller. +//! +//! \param ulBase is the base address of the controller. +//! \param pucBuf is the pointer to the packet buffer. +//! \param lBufLen is the maximum number of bytes to be read into the buffer. +//! +//! This function reads a packet from the receive FIFO of the controller and +//! places it into \e pucBuf. The function will wait until a packet is +//! available in the FIFO. Then the function will read the entire packet +//! from the receive FIFO. If there are more bytes in the packet than will +//! fit into \e pucBuf (as specified by \e lBufLen), the function will return +//! the negated length of the packet and the buffer will contain \e lBufLen +//! bytes of the packet. Otherwise, the function will return the length of +//! the packet that was read and \e pucBuf will contain the entire packet +//! (excluding the frame check sequence bytes). +//! +//! \note This function is blocking and will not return until a packet arrives. +//! +//! \return Returns the negated packet length \b -n if the packet is too large +//! for \e pucBuf, and returns the packet length \b n otherwise. +// +//***************************************************************************** +long +EthernetPacketGet(unsigned long ulBase, unsigned char *pucBuf, + long lBufLen) +{ + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + ASSERT(pucBuf != 0); + ASSERT(lBufLen > 0); + + // + // Wait for a packet to become available + // + while((HWREG(ulBase + MAC_O_NP) & MAC_NP_NPR_M) == 0) + { + } + + // + // Read the packet + // + return(EthernetPacketGetInternal(ulBase, pucBuf, lBufLen)); +} + +//***************************************************************************** +// +//! \internal +//! +//! Internal function for sending a packet to the Ethernet controller. +//! +//! \param ulBase is the base address of the controller. +//! \param pucBuf is the pointer to the packet buffer. +//! \param lBufLen is number of bytes in the packet to be transmitted. +//! +//! Puts a packet into the transmit FIFO of the controller. +//! +//! Format of the data in the TX FIFO is as follows: +//! +//! \verbatim +//! +---------+----------+----------+----------+----------+ +//! | | 31:24 | 23:16 | 15:8 | 7:0 | +//! +---------+----------+----------+----------+----------+ +//! | Word 0 | DA 2 | DA 1 | PL MSB | PL LSB | +//! +---------+----------+----------+----------+----------+ +//! | Word 1 | DA 6 | DA 5 | DA 4 | DA 3 | +//! +---------+----------+----------+----------+----------+ +//! | Word 2 | SA 4 | SA 3 | SA 2 | SA 1 | +//! +---------+----------+----------+----------+----------+ +//! | Word 3 | FT LSB | FT MSB | SA 6 | SA 5 | +//! +---------+----------+----------+----------+----------+ +//! | Word 4 | DATA 4 | DATA 3 | DATA 2 | DATA 1 | +//! +---------+----------+----------+----------+----------+ +//! | Word 5 | DATA 8 | DATA 7 | DATA 6 | DATA 5 | +//! +---------+----------+----------+----------+----------+ +//! | Word 6 | DATA 12 | DATA 11 | DATA 10 | DATA 9 | +//! +---------+----------+----------+----------+----------+ +//! | ... | | | | | +//! +---------+----------+----------+----------+----------+ +//! | Word X | DATA n | DATA n-1 | DATA n-2 | DATA n-3 | +//! +---------+----------+----------+----------+----------+ +//! \endverbatim +//! +//! Where PL is Payload Length, (DATA) only +//! Where DA is Destination (MAC) Address +//! Where SA is Source (MAC) Address +//! Where FT is Frame Type (or Frame Length for Ethernet) +//! Where DATA is Payload Data for the Ethernet Frame +//! +//! \return Returns the negated packet length \b -lBufLen if the packet is too +//! large for FIFO, and the packet length \b lBufLen otherwise. +// +//***************************************************************************** +static long +EthernetPacketPutInternal(unsigned long ulBase, unsigned char *pucBuf, + long lBufLen) +{ + unsigned long ulTemp; + long i = 0; + + // + // If the packet is too large, return the negative packet length as + // an error code. + // + if(lBufLen > (2048 - 2)) + { + return(-lBufLen); + } + + // + // Build and write WORD 0 (see format above) to the transmit FIFO. + // + ulTemp = (unsigned long)(lBufLen - 14); + ulTemp |= (pucBuf[i++] << 16); + ulTemp |= (pucBuf[i++] << 24); + HWREG(ulBase + MAC_O_DATA) = ulTemp; + + // + // Write each subsequent WORD n to the transmit FIFO, except for the last + // WORD (if the word does not contain 4 bytes). + // + while(i <= (lBufLen - 4)) + { + HWREG(ulBase + MAC_O_DATA) = *(unsigned long *)&pucBuf[i]; + i += 4; + } + + // + // Build the last word of the remaining 1, 2, or 3 bytes, and store + // the WORD into the transmit FIFO. + // + if(i != lBufLen) + { + if(i == (lBufLen - 3)) + { + ulTemp = (pucBuf[i++] << 0); + ulTemp |= (pucBuf[i++] << 8); + ulTemp |= (pucBuf[i++] << 16); + HWREG(ulBase + MAC_O_DATA) = ulTemp; + } + else if(i == (lBufLen - 2)) + { + ulTemp = (pucBuf[i++] << 0); + ulTemp |= (pucBuf[i++] << 8); + HWREG(ulBase + MAC_O_DATA) = ulTemp; + } + else if(i == (lBufLen - 1)) + { + ulTemp = (pucBuf[i++] << 0); + HWREG(ulBase + MAC_O_DATA) = ulTemp; + } + } + + // + // Activate the transmitter + // + HWREG(ulBase + MAC_O_TR) = MAC_TR_NEWTX; + + // + // Return the Buffer Length transmitted. + // + return(lBufLen); +} + +//***************************************************************************** +// +//! Sends a packet to the Ethernet controller. +//! +//! \param ulBase is the base address of the controller. +//! \param pucBuf is the pointer to the packet buffer. +//! \param lBufLen is number of bytes in the packet to be transmitted. +//! +//! This function writes \e lBufLen bytes of the packet contained in \e pucBuf +//! into the transmit FIFO of the controller and then activates the +//! transmitter for this packet. If no space is available in the FIFO, the +//! function will return immediately. If space is available, the +//! function will return once \e lBufLen bytes of the packet have been placed +//! into the FIFO and the transmitter has been started. The function will not +//! wait for the transmission to complete. The function will return the +//! negated \e lBufLen if the length is larger than the space available in +//! the transmit FIFO. +//! +//! This function replaces the original EthernetPacketNonBlockingPut() API and +//! performs the same actions. A macro is provided in ethernet.h to +//! map the original API to this API. +//! +//! \note This function does not block and will return immediately if no space +//! is available for the transmit packet. +//! +//! \return Returns \b 0 if no space is available in the transmit FIFO, the +//! negated packet length \b -lBufLen if the packet is too large for FIFO, and +//! the packet length \b lBufLen otherwise. +// +//***************************************************************************** +long +EthernetPacketPutNonBlocking(unsigned long ulBase, unsigned char *pucBuf, + long lBufLen) +{ + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + ASSERT(pucBuf != 0); + ASSERT(lBufLen > 0); + + // + // Check if the transmit FIFO is in use and return the appropriate code. + // + if(HWREG(ulBase + MAC_O_TR) & MAC_TR_NEWTX) + { + return(0); + } + + // + // Send the packet and return. + // + return(EthernetPacketPutInternal(ulBase, pucBuf, lBufLen)); +} + +//***************************************************************************** +// +//! Waits to send a packet from the Ethernet controller. +//! +//! \param ulBase is the base address of the controller. +//! \param pucBuf is the pointer to the packet buffer. +//! \param lBufLen is number of bytes in the packet to be transmitted. +//! +//! This function writes \e lBufLen bytes of the packet contained in \e pucBuf +//! into the transmit FIFO of the controller and then activates the transmitter +//! for this packet. This function will wait until the transmit FIFO is empty. +//! Once space is available, the function will return once \e lBufLen bytes of +//! the packet have been placed into the FIFO and the transmitter has been +//! started. The function will not wait for the transmission to complete. The +//! function will return the negated \e lBufLen if the length is larger than +//! the space available in the transmit FIFO. +//! +//! \note This function blocks and will wait until space is available for the +//! transmit packet before returning. +//! +//! \return Returns the negated packet length \b -lBufLen if the packet is too +//! large for FIFO, and the packet length \b lBufLen otherwise. +// +//***************************************************************************** +long +EthernetPacketPut(unsigned long ulBase, unsigned char *pucBuf, + long lBufLen) +{ + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + ASSERT(pucBuf != 0); + ASSERT(lBufLen > 0); + + // + // Wait for current packet (if any) to complete. + // + while(HWREG(ulBase + MAC_O_TR) & MAC_TR_NEWTX) + { + } + + // + // Send the packet and return. + // + return(EthernetPacketPutInternal(ulBase, pucBuf, lBufLen)); +} + +//***************************************************************************** +// +//! Registers an interrupt handler for an Ethernet interrupt. +//! +//! \param ulBase is the base address of the controller. +//! \param pfnHandler is a pointer to the function to be called when the +//! enabled Ethernet interrupts occur. +//! +//! This function sets the handler to be called when the Ethernet interrupt +//! occurs. This will enable the global interrupt in the interrupt controller; +//! specific Ethernet interrupts must be enabled via EthernetIntEnable(). It +//! is the interrupt handler's responsibility to clear the interrupt source. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +EthernetIntRegister(unsigned long ulBase, void (*pfnHandler)(void)) +{ + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + ASSERT(pfnHandler != 0); + + // + // Register the interrupt handler. + // + IntRegister(INT_ETH, pfnHandler); + + // + // Enable the Ethernet interrupt. + // + IntEnable(INT_ETH); +} + +//***************************************************************************** +// +//! Unregisters an interrupt handler for an Ethernet interrupt. +//! +//! \param ulBase is the base address of the controller. +//! +//! This function unregisters the interrupt handler. This will disable the +//! global interrupt in the interrupt controller so that the interrupt handler +//! no longer is called. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +EthernetIntUnregister(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + + // + // Disable the interrupt. + // + IntDisable(INT_ETH); + + // + // Unregister the interrupt handler. + // + IntUnregister(INT_ETH); +} + +//***************************************************************************** +// +//! Enables individual Ethernet interrupt sources. +//! +//! \param ulBase is the base address of the controller. +//! \param ulIntFlags is the bit mask of the interrupt sources to be enabled. +//! +//! Enables the indicated Ethernet interrupt sources. Only the sources that +//! are enabled can be reflected to the processor interrupt; disabled sources +//! have no effect on the processor. +//! +//! The \e ulIntFlags parameter is the logical OR of any of the following: +//! +//! - \b ETH_INT_PHY - An interrupt from the PHY has occurred. The integrated +//! PHY supports a number of interrupt conditions. The PHY register, PHY_MR17, +//! must be read to determine which PHY interrupt has occurred. This register +//! can be read using the EthernetPHYRead() API function. +//! - \b ETH_INT_MDIO - This interrupt indicates that a transaction on the +//! management interface has completed successfully. +//! - \b ETH_INT_RXER - This interrupt indicates that an error has occurred +//! during reception of a frame. This error can indicate a length mismatch, a +//! CRC failure, or an error indication from the PHY. +//! - \b ETH_INT_RXOF - This interrupt indicates that a frame has been received +//! that exceeds the available space in the RX FIFO. +//! - \b ETH_INT_TX - This interrupt indicates that the packet stored in the TX +//! FIFO has been successfully transmitted. +//! - \b ETH_INT_TXER - This interrupt indicates that an error has occurred +//! during the transmission of a packet. This error can be either a retry +//! failure during the back-off process, or an invalid length stored in the TX +//! FIFO. +//! - \b ETH_INT_RX - This interrupt indicates that one (or more) packets are +//! available in the RX FIFO for processing. +//! +//! \return None. +// +//***************************************************************************** +void +EthernetIntEnable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + ASSERT(!(ulIntFlags & ~(ETH_INT_PHY | ETH_INT_MDIO | ETH_INT_RXER | + ETH_INT_RXOF | ETH_INT_TX | ETH_INT_TXER | + ETH_INT_RX))); + + // + // Enable the specified interrupts. + // + HWREG(ulBase + MAC_O_IM) |= ulIntFlags; +} + +//***************************************************************************** +// +//! Disables individual Ethernet interrupt sources. +//! +//! \param ulBase is the base address of the controller. +//! \param ulIntFlags is the bit mask of the interrupt sources to be disabled. +//! +//! Disables the indicated Ethernet interrupt sources. Only the sources that +//! are enabled can be reflected to the processor interrupt; disabled sources +//! have no effect on the processor. +//! +//! The \e ulIntFlags parameter has the same definition as the \e ulIntFlags +//! parameter to EthernetIntEnable(). +//! +//! \return None. +// +//***************************************************************************** +void +EthernetIntDisable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + ASSERT(!(ulIntFlags & ~(ETH_INT_PHY | ETH_INT_MDIO | ETH_INT_RXER | + ETH_INT_RXOF | ETH_INT_TX | ETH_INT_TXER | + ETH_INT_RX))); + + // + // Disable the specified interrupts. + // + HWREG(ulBase + MAC_O_IM) &= ~ulIntFlags; +} + +//***************************************************************************** +// +//! Gets the current Ethernet interrupt status. +//! +//! \param ulBase is the base address of the controller. +//! \param bMasked is false if the raw interrupt status is required and true +//! if the masked interrupt status is required. +//! +//! This returns the interrupt status for the Ethernet controller. Either the +//! raw interrupt status or the status of interrupts that are allowed to +//! reflect to the processor can be returned. +//! +//! \return Returns the current interrupt status, enumerated as a bit field of +//! values described in EthernetIntEnable(). +// +//***************************************************************************** +unsigned long +EthernetIntStatus(unsigned long ulBase, tBoolean bMasked) +{ + unsigned long ulStatus; + + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + + // + // Read the unmasked status. + // + ulStatus = HWREG(ulBase + MAC_O_RIS); + + // + // If masked status is requested, mask it off. + // + if(bMasked) + { + ulStatus &= HWREG(ulBase + MAC_O_IM); + } + + // + // Return the interrupt status value. + // + return(ulStatus); +} + +//***************************************************************************** +// +//! Clears Ethernet interrupt sources. +//! +//! \param ulBase is the base address of the controller. +//! \param ulIntFlags is a bit mask of the interrupt sources to be cleared. +//! +//! The specified Ethernet interrupt sources are cleared so that they no longer +//! assert. This must be done in the interrupt handler to keep it from being +//! called again immediately upon exit. +//! +//! The \e ulIntFlags parameter has the same definition as the \e ulIntFlags +//! parameter to EthernetIntEnable(). +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +EthernetIntClear(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + ASSERT(!(ulIntFlags & ~(ETH_INT_PHY | ETH_INT_MDIO | ETH_INT_RXER | + ETH_INT_RXOF | ETH_INT_TX | ETH_INT_TXER | + ETH_INT_RX))); + + // + // Clear the requested interrupt sources. + // + HWREG(ulBase + MAC_O_IACK) = ulIntFlags; +} + +//***************************************************************************** +// +//! Writes to the PHY register. +//! +//! \param ulBase is the base address of the controller. +//! \param ucRegAddr is the address of the PHY register to be accessed. +//! \param ulData is the data to be written to the PHY register. +//! +//! This function will write the \e ulData to the PHY register specified by +//! \e ucRegAddr. +//! +//! \return None. +// +//***************************************************************************** +void +EthernetPHYWrite(unsigned long ulBase, unsigned char ucRegAddr, + unsigned long ulData) +{ + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + + // + // Wait for any pending transaction to complete. + // + while(HWREG(ulBase + MAC_O_MCTL) & MAC_MCTL_START) + { + } + + // + // Program the DATA to be written. + // + HWREG(ulBase + MAC_O_MTXD) = ulData & MAC_MTXD_MDTX_M; + + // + // Program the PHY register address and initiate the transaction. + // + HWREG(ulBase + MAC_O_MCTL) = (((ucRegAddr << 3) & MAC_MCTL_REGADR_M) | + MAC_MCTL_WRITE | MAC_MCTL_START); + + // + // Wait for the write transaction to complete. + // + while(HWREG(ulBase + MAC_O_MCTL) & MAC_MCTL_START) + { + } +} + +//***************************************************************************** +// +//! Reads from a PHY register. +//! +//! \param ulBase is the base address of the controller. +//! \param ucRegAddr is the address of the PHY register to be accessed. +//! +//! This function will return the contents of the PHY register specified by +//! \e ucRegAddr. +//! +//! \return Returns the 16-bit value read from the PHY. +// +//***************************************************************************** +unsigned long +EthernetPHYRead(unsigned long ulBase, unsigned char ucRegAddr) +{ + // + // Check the arguments. + // + ASSERT(ulBase == ETH_BASE); + + // + // Wait for any pending transaction to complete. + // + while(HWREG(ulBase + MAC_O_MCTL) & MAC_MCTL_START) + { + } + + // + // Program the PHY register address and initiate the transaction. + // + HWREG(ulBase + MAC_O_MCTL) = (((ucRegAddr << 3) & MAC_MCTL_REGADR_M) | + MAC_MCTL_START); + + // + // Wait for the transaction to complete. + // + while(HWREG(ulBase + MAC_O_MCTL) & MAC_MCTL_START) + { + } + + // + // Return the PHY data that was read. + // + return(HWREG(ulBase + MAC_O_MRXD) & MAC_MRXD_MDRX_M); +} + +//***************************************************************************** +// +//! Powers off the Ethernet PHY. +//! +//! \param ulBase is the base address of the controller. +//! +//! This function will power off the Ethernet PHY, reducing the current +//! consuption of the device. While in the powered off state, the Ethernet +//! controller will be unable to connect to the Ethernet. +//! +//! \return None. +// +//***************************************************************************** +void +EthernetPHYPowerOff(unsigned long ulBase) +{ + // + // Set the PWRDN bit and clear the ANEGEN bit in the PHY, putting it into + // its low power mode. + // + EthernetPHYWrite(ulBase, PHY_MR0, + (EthernetPHYRead(ulBase, PHY_MR0) & ~PHY_MR0_ANEGEN) | + PHY_MR0_PWRDN); +} + +//***************************************************************************** +// +//! Powers on the Ethernet PHY. +//! +//! \param ulBase is the base address of the controller. +//! +//! This function will power on the Ethernet PHY, enabling it return to normal +//! operation. By default, the PHY is powered on, so this function only needs +//! to be called if EthernetPHYPowerOff() has previously been called. +//! +//! \return None. +// +//***************************************************************************** +void +EthernetPHYPowerOn(unsigned long ulBase) +{ + // + // Clear the PWRDN bit and set the ANEGEN bit in the PHY, putting it into + // normal operating mode. + // + EthernetPHYWrite(ulBase, PHY_MR0, + (EthernetPHYRead(ulBase, PHY_MR0) & ~PHY_MR0_PWRDN) | + PHY_MR0_ANEGEN); +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ethernet.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ethernet.h new file mode 100644 index 00000000..860a1365 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ethernet.h @@ -0,0 +1,171 @@ +//***************************************************************************** +// +// ethernet.h - Defines and Macros for the ethernet module. +// +// Copyright (c) 2006-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __ETHERNET_H__ +#define __ETHERNET_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Values that can be passed to EthernetConfigSet as the ulConfig value, and +// returned from EthernetConfigGet. +// +//***************************************************************************** +#define ETH_CFG_TS_TSEN 0x010000 // Enable Timestamp (CCP) +#define ETH_CFG_RX_BADCRCDIS 0x000800 // Disable RX BAD CRC Packets +#define ETH_CFG_RX_PRMSEN 0x000400 // Enable RX Promiscuous +#define ETH_CFG_RX_AMULEN 0x000200 // Enable RX Multicast +#define ETH_CFG_TX_DPLXEN 0x000010 // Enable TX Duplex Mode +#define ETH_CFG_TX_CRCEN 0x000004 // Enable TX CRC Generation +#define ETH_CFG_TX_PADEN 0x000002 // Enable TX Padding + +//***************************************************************************** +// +// Values that can be passed to EthernetIntEnable, EthernetIntDisable, and +// EthernetIntClear as the ulIntFlags parameter, and returned from +// EthernetIntStatus. +// +//***************************************************************************** +#define ETH_INT_PHY 0x040 // PHY Event/Interrupt +#define ETH_INT_MDIO 0x020 // Management Transaction +#define ETH_INT_RXER 0x010 // RX Error +#define ETH_INT_RXOF 0x008 // RX FIFO Overrun +#define ETH_INT_TX 0x004 // TX Complete +#define ETH_INT_TXER 0x002 // TX Error +#define ETH_INT_RX 0x001 // RX Complete + +//***************************************************************************** +// +// Helper Macros for Ethernet Processing +// +//***************************************************************************** +// +// htonl/ntohl - big endian/little endian byte swapping macros for +// 32-bit (long) values +// +//***************************************************************************** +#ifndef htonl + #define htonl(a) \ + ((((a) >> 24) & 0x000000ff) | \ + (((a) >> 8) & 0x0000ff00) | \ + (((a) << 8) & 0x00ff0000) | \ + (((a) << 24) & 0xff000000)) +#endif + +#ifndef ntohl + #define ntohl(a) htonl((a)) +#endif + +//***************************************************************************** +// +// htons/ntohs - big endian/little endian byte swapping macros for +// 16-bit (short) values +// +//***************************************************************************** +#ifndef htons + #define htons(a) \ + ((((a) >> 8) & 0x00ff) | \ + (((a) << 8) & 0xff00)) +#endif + +#ifndef ntohs + #define ntohs(a) htons((a)) +#endif + +//***************************************************************************** +// +// API Function prototypes +// +//***************************************************************************** +extern void EthernetInitExpClk(unsigned long ulBase, unsigned long ulEthClk); +extern void EthernetConfigSet(unsigned long ulBase, unsigned long ulConfig); +extern unsigned long EthernetConfigGet(unsigned long ulBase); +extern void EthernetMACAddrSet(unsigned long ulBase, + unsigned char *pucMACAddr); +extern void EthernetMACAddrGet(unsigned long ulBase, + unsigned char *pucMACAddr); +extern void EthernetEnable(unsigned long ulBase); +extern void EthernetDisable(unsigned long ulBase); +extern tBoolean EthernetPacketAvail(unsigned long ulBase); +extern tBoolean EthernetSpaceAvail(unsigned long ulBase); +extern long EthernetPacketGetNonBlocking(unsigned long ulBase, + unsigned char *pucBuf, + long lBufLen); +extern long EthernetPacketGet(unsigned long ulBase, unsigned char *pucBuf, + long lBufLen); +extern long EthernetPacketPutNonBlocking(unsigned long ulBase, + unsigned char *pucBuf, + long lBufLen); +extern long EthernetPacketPut(unsigned long ulBase, unsigned char *pucBuf, + long lBufLen); +extern void EthernetIntRegister(unsigned long ulBase, + void (*pfnHandler)(void)); +extern void EthernetIntUnregister(unsigned long ulBase); +extern void EthernetIntEnable(unsigned long ulBase, unsigned long ulIntFlags); +extern void EthernetIntDisable(unsigned long ulBase, unsigned long ulIntFlags); +extern unsigned long EthernetIntStatus(unsigned long ulBase, tBoolean bMasked); +extern void EthernetIntClear(unsigned long ulBase, unsigned long ulIntFlags); +extern void EthernetPHYWrite(unsigned long ulBase, unsigned char ucRegAddr, + unsigned long ulData); +extern unsigned long EthernetPHYRead(unsigned long ulBase, + unsigned char ucRegAddr); +extern void EthernetPHYPowerOff(unsigned long ulBase); +extern void EthernetPHYPowerOn(unsigned long ulBase); + +//***************************************************************************** +// +// Several Ethernet APIs have been renamed, with the original function name +// being deprecated. These defines provide backward compatibility. +// +//***************************************************************************** +#ifndef DEPRECATED +#include "driverlib/sysctl.h" +#define EthernetInit(a) \ + EthernetInitExpClk(a, SysCtlClockGet()) +#define EthernetPacketNonBlockingGet(a, b, c) \ + EthernetPacketGetNonBlocking(a, b, c) +#define EthernetPacketNonBlockingPut(a, b, c) \ + EthernetPacketPutNonBlocking(a, b, c) +#endif + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __ETHERNET_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/flash.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/flash.c new file mode 100644 index 00000000..09585467 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/flash.c @@ -0,0 +1,912 @@ +//***************************************************************************** +// +// flash.c - Driver for programming the on-chip flash. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup flash_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_flash.h" +#include "inc/hw_ints.h" +#include "inc/hw_sysctl.h" +#include "inc/hw_types.h" +#include "driverlib/debug.h" +#include "driverlib/flash.h" +#include "driverlib/interrupt.h" + +//***************************************************************************** +// +// An array that maps the specified memory bank to the appropriate Flash +// Memory Protection Program Enable (FMPPE) register. +// +//***************************************************************************** +static const unsigned long g_pulFMPPERegs[] = +{ + FLASH_FMPPE, + FLASH_FMPPE1, + FLASH_FMPPE2, + FLASH_FMPPE3 +}; + +//***************************************************************************** +// +// An array that maps the specified memory bank to the appropriate Flash +// Memory Protection Read Enable (FMPRE) register. +// +//***************************************************************************** +static const unsigned long g_pulFMPRERegs[] = +{ + FLASH_FMPRE, + FLASH_FMPRE1, + FLASH_FMPRE2, + FLASH_FMPRE3 +}; + +//***************************************************************************** +// +//! Gets the number of processor clocks per micro-second. +//! +//! This function returns the number of clocks per micro-second, as presently +//! known by the flash controller. +//! +//! \return Returns the number of processor clocks per micro-second. +// +//***************************************************************************** +unsigned long +FlashUsecGet(void) +{ + // + // Return the number of clocks per micro-second. + // + return(HWREG(FLASH_USECRL) + 1); +} + +//***************************************************************************** +// +//! Sets the number of processor clocks per micro-second. +//! +//! \param ulClocks is the number of processor clocks per micro-second. +//! +//! This function is used to tell the flash controller the number of processor +//! clocks per micro-second. This value must be programmed correctly or the +//! flash most likely will not program correctly; it has no affect on reading +//! flash. +//! +//! \return None. +// +//***************************************************************************** +void +FlashUsecSet(unsigned long ulClocks) +{ + // + // Set the number of clocks per micro-second. + // + HWREG(FLASH_USECRL) = ulClocks - 1; +} + +//***************************************************************************** +// +//! Erases a block of flash. +//! +//! \param ulAddress is the start address of the flash block to be erased. +//! +//! This function will erase a 1 kB block of the on-chip flash. After erasing, +//! the block will be filled with 0xFF bytes. Read-only and execute-only +//! blocks cannot be erased. +//! +//! This function will not return until the block has been erased. +//! +//! \return Returns 0 on success, or -1 if an invalid block address was +//! specified or the block is write-protected. +// +//***************************************************************************** +long +FlashErase(unsigned long ulAddress) +{ + // + // Check the arguments. + // + ASSERT(!(ulAddress & (FLASH_ERASE_SIZE - 1))); + + // + // Clear the flash access interrupt. + // + HWREG(FLASH_FCMISC) = FLASH_FCMISC_AMISC; + + // + // Erase the block. + // + HWREG(FLASH_FMA) = ulAddress; + HWREG(FLASH_FMC) = FLASH_FMC_WRKEY | FLASH_FMC_ERASE; + + // + // Wait until the block has been erased. + // + while(HWREG(FLASH_FMC) & FLASH_FMC_ERASE) + { + } + + // + // Return an error if an access violation occurred. + // + if(HWREG(FLASH_FCRIS) & FLASH_FCRIS_ARIS) + { + return(-1); + } + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Programs flash. +//! +//! \param pulData is a pointer to the data to be programmed. +//! \param ulAddress is the starting address in flash to be programmed. Must +//! be a multiple of four. +//! \param ulCount is the number of bytes to be programmed. Must be a multiple +//! of four. +//! +//! This function will program a sequence of words into the on-chip flash. +//! Programming each location consists of the result of an AND operation +//! of the new data and the existing data; in other words bits that contain +//! 1 can remain 1 or be changed to 0, but bits that are 0 cannot be changed +//! to 1. Therefore, a word can be programmed multiple times as long as these +//! rules are followed; if a program operation attempts to change a 0 bit to +//! a 1 bit, that bit will not have its value changed. +//! +//! Since the flash is programmed one word at a time, the starting address and +//! byte count must both be multiples of four. It is up to the caller to +//! verify the programmed contents, if such verification is required. +//! +//! This function will not return until the data has been programmed. +//! +//! \return Returns 0 on success, or -1 if a programming error is encountered. +// +//***************************************************************************** +long +FlashProgram(unsigned long *pulData, unsigned long ulAddress, + unsigned long ulCount) +{ + // + // Check the arguments. + // + ASSERT(!(ulAddress & 3)); + ASSERT(!(ulCount & 3)); + + // + // Clear the flash access interrupt. + // + HWREG(FLASH_FCMISC) = FLASH_FCMISC_AMISC; + + // + // See if this device has a write buffer. + // + if(HWREG(SYSCTL_NVMSTAT) & SYSCTL_NVMSTAT_FWB) + { + // + // Loop over the words to be programmed. + // + while(ulCount) + { + // + // Set the address of this block of words. + // + HWREG(FLASH_FMA) = ulAddress & ~(0x7f); + + // + // Loop over the words in this 32-word block. + // + while(((ulAddress & 0x7c) || (HWREG(FLASH_FWBVAL) == 0)) && + (ulCount != 0)) + { + // + // Write this word into the write buffer. + // + HWREG(FLASH_FWBN + (ulAddress & 0x7c)) = *pulData++; + ulAddress += 4; + ulCount -= 4; + } + + // + // Program the contents of the write buffer into flash. + // + HWREG(FLASH_FMC2) = FLASH_FMC2_WRKEY | FLASH_FMC2_WRBUF; + + // + // Wait until the write buffer has been programmed. + // + while(HWREG(FLASH_FMC2) & FLASH_FMC2_WRBUF) + { + } + } + } + else + { + // + // Loop over the words to be programmed. + // + while(ulCount) + { + // + // Program the next word. + // + HWREG(FLASH_FMA) = ulAddress; + HWREG(FLASH_FMD) = *pulData; + HWREG(FLASH_FMC) = FLASH_FMC_WRKEY | FLASH_FMC_WRITE; + + // + // Wait until the word has been programmed. + // + while(HWREG(FLASH_FMC) & FLASH_FMC_WRITE) + { + } + + // + // Increment to the next word. + // + pulData++; + ulAddress += 4; + ulCount -= 4; + } + } + + // + // Return an error if an access violation occurred. + // + if(HWREG(FLASH_FCRIS) & FLASH_FCRIS_ARIS) + { + return(-1); + } + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Gets the protection setting for a block of flash. +//! +//! \param ulAddress is the start address of the flash block to be queried. +//! +//! This function will get the current protection for the specified 2 kB block +//! of flash. Each block can be read/write, read-only, or execute-only. +//! Read/write blocks can be read, executed, erased, and programmed. Read-only +//! blocks can be read and executed. Execute-only blocks can only be executed; +//! processor and debugger data reads are not allowed. +//! +//! \return Returns the protection setting for this block. See +//! FlashProtectSet() for possible values. +// +//***************************************************************************** +tFlashProtection +FlashProtectGet(unsigned long ulAddress) +{ + unsigned long ulFMPRE, ulFMPPE; + unsigned long ulBank; + + // + // Check the argument. + // + ASSERT(!(ulAddress & (FLASH_PROTECT_SIZE - 1))); + + // + // Calculate the Flash Bank from Base Address, and mask off the Bank + // from ulAddress for subsequent reference. + // + ulBank = (((ulAddress / FLASH_PROTECT_SIZE) / 32) % 4); + ulAddress &= ((FLASH_PROTECT_SIZE * 32) - 1); + + // + // Read the appropriate flash protection registers for the specified + // flash bank. + // + ulFMPRE = HWREG(g_pulFMPRERegs[ulBank]); + ulFMPPE = HWREG(g_pulFMPPERegs[ulBank]); + + // + // For Stellaris Sandstorm-class devices, revision C1 and C2, the upper + // bits of the FMPPE register are used for JTAG protect options, and are + // not available for the FLASH protection scheme. When Querying Block + // Protection, assume these bits are 1. + // + if(CLASS_IS_SANDSTORM && (REVISION_IS_C1 || REVISION_IS_C2)) + { + ulFMPRE |= (FLASH_FMP_BLOCK_31 | FLASH_FMP_BLOCK_30); + } + + // + // Check the appropriate protection bits for the block of memory that + // is specified by the address. + // + switch((((ulFMPRE >> (ulAddress / FLASH_PROTECT_SIZE)) & + FLASH_FMP_BLOCK_0) << 1) | + ((ulFMPPE >> (ulAddress / FLASH_PROTECT_SIZE)) & FLASH_FMP_BLOCK_0)) + { + // + // This block is marked as execute only (that is, it can not be erased + // or programmed, and the only reads allowed are via the instruction + // fetch interface). + // + case 0: + case 1: + { + return(FlashExecuteOnly); + } + + // + // This block is marked as read only (that is, it can not be erased or + // programmed). + // + case 2: + { + return(FlashReadOnly); + } + + // + // This block is read/write; it can be read, erased, and programmed. + // + case 3: + default: + { + return(FlashReadWrite); + } + } +} + +//***************************************************************************** +// +//! Sets the protection setting for a block of flash. +//! +//! \param ulAddress is the start address of the flash block to be protected. +//! \param eProtect is the protection to be applied to the block. Can be one +//! of \b FlashReadWrite, \b FlashReadOnly, or \b FlashExecuteOnly. +//! +//! This function will set the protection for the specified 2 kB block of +//! flash. Blocks which are read/write can be made read-only or execute-only. +//! Blocks which are read-only can be made execute-only. Blocks which are +//! execute-only cannot have their protection modified. Attempts to make the +//! block protection less stringent (that is, read-only to read/write) will +//! result in a failure (and be prevented by the hardware). +//! +//! Changes to the flash protection are maintained only until the next reset. +//! This allows the application to be executed in the desired flash protection +//! environment to check for inappropriate flash access (via the flash +//! interrupt). To make the flash protection permanent, use the +//! FlashProtectSave() function. +//! +//! \return Returns 0 on success, or -1 if an invalid address or an invalid +//! protection was specified. +// +//***************************************************************************** +long +FlashProtectSet(unsigned long ulAddress, tFlashProtection eProtect) +{ + unsigned long ulProtectRE, ulProtectPE; + unsigned long ulBank; + + // + // Check the argument. + // + ASSERT(!(ulAddress & (FLASH_PROTECT_SIZE - 1))); + ASSERT((eProtect == FlashReadWrite) || (eProtect == FlashReadOnly) || + (eProtect == FlashExecuteOnly)); + + // + // Convert the address into a block number. + // + ulAddress /= FLASH_PROTECT_SIZE; + + // + // ulAddress contains a "raw" block number. Derive the Flash Bank from + // the "raw" block number, and convert ulAddress to a "relative" + // block number. + // + ulBank = ((ulAddress / 32) % 4); + ulAddress %= 32; + + // + // Get the current protection for the specified flash bank. + // + ulProtectRE = HWREG(g_pulFMPRERegs[ulBank]); + ulProtectPE = HWREG(g_pulFMPPERegs[ulBank]); + + // + // For Stellaris Sandstorm-class devices, revision C1 and C2, the upper + // bits of the FMPPE register are used for JTAG protect options, and are + // not available for the FLASH protection scheme. When setting protection, + // check to see if block 30 or 31 and protection is FlashExecuteOnly. If + // so, return an error condition. + // + if(CLASS_IS_SANDSTORM && (REVISION_IS_C1 || REVISION_IS_C2)) + { + if((ulAddress >= 30) && (eProtect == FlashExecuteOnly)) + { + return(-1); + } + } + + // + // Set the protection based on the requested proection. + // + switch(eProtect) + { + // + // Make this block execute only. + // + case FlashExecuteOnly: + { + // + // Turn off the read and program bits for this block. + // + ulProtectRE &= ~(FLASH_FMP_BLOCK_0 << ulAddress); + ulProtectPE &= ~(FLASH_FMP_BLOCK_0 << ulAddress); + + // + // We're done handling this protection. + // + break; + } + + // + // Make this block read only. + // + case FlashReadOnly: + { + // + // The block can not be made read only if it is execute only. + // + if(((ulProtectRE >> ulAddress) & FLASH_FMP_BLOCK_0) != + FLASH_FMP_BLOCK_0) + { + return(-1); + } + + // + // Make this block read only. + // + ulProtectPE &= ~(FLASH_FMP_BLOCK_0 << ulAddress); + + // + // We're done handling this protection. + // + break; + } + + // + // Make this block read/write. + // + case FlashReadWrite: + default: + { + // + // The block can not be made read/write if it is not already + // read/write. + // + if((((ulProtectRE >> ulAddress) & FLASH_FMP_BLOCK_0) != + FLASH_FMP_BLOCK_0) || + (((ulProtectPE >> ulAddress) & FLASH_FMP_BLOCK_0) != + FLASH_FMP_BLOCK_0)) + { + return(-1); + } + + // + // The block is already read/write, so there is nothing to do. + // + return(0); + } + } + + // + // For Stellaris Sandstorm-class devices, revision C1 and C2, the upper + // bits of the FMPPE register are used for JTAG options, and are not + // available for the FLASH protection scheme. When setting block + // protection, ensure that these bits are not altered. + // + if(CLASS_IS_SANDSTORM && (REVISION_IS_C1 || REVISION_IS_C2)) + { + ulProtectRE &= ~(FLASH_FMP_BLOCK_31 | FLASH_FMP_BLOCK_30); + ulProtectRE |= (HWREG(g_pulFMPRERegs[ulBank]) & + (FLASH_FMP_BLOCK_31 | FLASH_FMP_BLOCK_30)); + } + + // + // Set the new protection for the specified flash bank. + // + HWREG(g_pulFMPRERegs[ulBank]) = ulProtectRE; + HWREG(g_pulFMPPERegs[ulBank]) = ulProtectPE; + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Saves the flash protection settings. +//! +//! This function will make the currently programmed flash protection settings +//! permanent. This is a non-reversible operation; a chip reset or power cycle +//! will not change the flash protection. +//! +//! This function will not return until the protection has been saved. +//! +//! \return Returns 0 on success, or -1 if a hardware error is encountered. +// +//***************************************************************************** +long +FlashProtectSave(void) +{ + int ulTemp, ulLimit; + + // + // If running on a Sandstorm-class device, only trigger a save of the first + // two protection registers (FMPRE and FMPPE). Otherwise, save the + // entire bank of flash protection registers. + // + ulLimit = CLASS_IS_SANDSTORM ? 2 : 8; + for(ulTemp = 0; ulTemp < ulLimit; ulTemp++) + { + // + // Tell the flash controller to write the flash protection register. + // + HWREG(FLASH_FMA) = ulTemp; + HWREG(FLASH_FMC) = FLASH_FMC_WRKEY | FLASH_FMC_COMT; + + // + // Wait until the write has completed. + // + while(HWREG(FLASH_FMC) & FLASH_FMC_COMT) + { + } + } + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Gets the user registers. +//! +//! \param pulUser0 is a pointer to the location to store USER Register 0. +//! \param pulUser1 is a pointer to the location to store USER Register 1. +//! +//! This function will read the contents of user registers (0 and 1), and +//! store them in the specified locations. +//! +//! \return Returns 0 on success, or -1 if a hardware error is encountered. +// +//***************************************************************************** +long +FlashUserGet(unsigned long *pulUser0, unsigned long *pulUser1) +{ + // + // Verify that the pointers are valid. + // + ASSERT(pulUser0 != 0); + ASSERT(pulUser1 != 0); + + // + // Verify that hardware supports user registers. + // + if(CLASS_IS_SANDSTORM) + { + return(-1); + } + + // + // Get and store the current value of the user registers. + // + *pulUser0 = HWREG(FLASH_USERREG0); + *pulUser1 = HWREG(FLASH_USERREG1); + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Sets the user registers. +//! +//! \param ulUser0 is the value to store in USER Register 0. +//! \param ulUser1 is the value to store in USER Register 1. +//! +//! This function will set the contents of the user registers (0 and 1) to +//! the specified values. +//! +//! \return Returns 0 on success, or -1 if a hardware error is encountered. +// +//***************************************************************************** +long +FlashUserSet(unsigned long ulUser0, unsigned long ulUser1) +{ + // + // Verify that hardware supports user registers. + // + if(CLASS_IS_SANDSTORM) + { + return(-1); + } + + // + // Save the new values into the user registers. + // + HWREG(FLASH_USERREG0) = ulUser0; + HWREG(FLASH_USERREG1) = ulUser1; + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Saves the user registers. +//! +//! This function will make the currently programmed user register settings +//! permanent. This is a non-reversible operation; a chip reset or power cycle +//! will not change this setting. +//! +//! This function will not return until the protection has been saved. +//! +//! \return Returns 0 on success, or -1 if a hardware error is encountered. +// +//***************************************************************************** +long +FlashUserSave(void) +{ + // + // Verify that hardware supports user registers. + // + if(CLASS_IS_SANDSTORM) + { + return(-1); + } + + // + // Setting the MSB of FMA will trigger a permanent save of a USER + // register. Bit 0 will indicate User 0 (0) or User 1 (1). + // + HWREG(FLASH_FMA) = 0x80000000; + HWREG(FLASH_FMC) = FLASH_FMC_WRKEY | FLASH_FMC_COMT; + + // + // Wait until the write has completed. + // + while(HWREG(FLASH_FMC) & FLASH_FMC_COMT) + { + } + + // + // Tell the flash controller to write the USER1 Register. + // + HWREG(FLASH_FMA) = 0x80000001; + HWREG(FLASH_FMC) = FLASH_FMC_WRKEY | FLASH_FMC_COMT; + + // + // Wait until the write has completed. + // + while(HWREG(FLASH_FMC) & FLASH_FMC_COMT) + { + } + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the flash interrupt. +//! +//! \param pfnHandler is a pointer to the function to be called when the flash +//! interrupt occurs. +//! +//! This sets the handler to be called when the flash interrupt occurs. The +//! flash controller can generate an interrupt when an invalid flash access +//! occurs, such as trying to program or erase a read-only block, or trying to +//! read from an execute-only block. It can also generate an interrupt when a +//! program or erase operation has completed. The interrupt will be +//! automatically enabled when the handler is registered. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +FlashIntRegister(void (*pfnHandler)(void)) +{ + // + // Register the interrupt handler, returning an error if an error occurs. + // + IntRegister(INT_FLASH, pfnHandler); + + // + // Enable the flash interrupt. + // + IntEnable(INT_FLASH); +} + +//***************************************************************************** +// +//! Unregisters the interrupt handler for the flash interrupt. +//! +//! This function will clear the handler to be called when the flash interrupt +//! occurs. This will also mask off the interrupt in the interrupt controller +//! so that the interrupt handler is no longer called. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +FlashIntUnregister(void) +{ + // + // Disable the interrupt. + // + IntDisable(INT_FLASH); + + // + // Unregister the interrupt handler. + // + IntUnregister(INT_FLASH); +} + +//***************************************************************************** +// +//! Enables individual flash controller interrupt sources. +//! +//! \param ulIntFlags is a bit mask of the interrupt sources to be enabled. +//! Can be any of the \b FLASH_INT_PROGRAM or \b FLASH_INT_ACCESS values. +//! +//! Enables the indicated flash controller interrupt sources. Only the sources +//! that are enabled can be reflected to the processor interrupt; disabled +//! sources have no effect on the processor. +//! +//! \return None. +// +//***************************************************************************** +void +FlashIntEnable(unsigned long ulIntFlags) +{ + // + // Enable the specified interrupts. + // + HWREG(FLASH_FCIM) |= ulIntFlags; +} + +//***************************************************************************** +// +//! Disables individual flash controller interrupt sources. +//! +//! \param ulIntFlags is a bit mask of the interrupt sources to be disabled. +//! Can be any of the \b FLASH_INT_PROGRAM or \b FLASH_INT_ACCESS values. +//! +//! Disables the indicated flash controller interrupt sources. Only the +//! sources that are enabled can be reflected to the processor interrupt; +//! disabled sources have no effect on the processor. +//! +//! \return None. +// +//***************************************************************************** +void +FlashIntDisable(unsigned long ulIntFlags) +{ + // + // Disable the specified interrupts. + // + HWREG(FLASH_FCIM) &= ~(ulIntFlags); +} + +//***************************************************************************** +// +//! Gets the current interrupt status. +//! +//! \param bMasked is false if the raw interrupt status is required and true if +//! the masked interrupt status is required. +//! +//! This returns the interrupt status for the flash controller. Either the raw +//! interrupt status or the status of interrupts that are allowed to reflect to +//! the processor can be returned. +//! +//! \return The current interrupt status, enumerated as a bit field of +//! \b FLASH_INT_PROGRAM and \b FLASH_INT_ACCESS. +// +//***************************************************************************** +unsigned long +FlashIntStatus(tBoolean bMasked) +{ + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + return(HWREG(FLASH_FCMISC)); + } + else + { + return(HWREG(FLASH_FCRIS)); + } +} + +//***************************************************************************** +// +//! Clears flash controller interrupt sources. +//! +//! \param ulIntFlags is the bit mask of the interrupt sources to be cleared. +//! Can be any of the \b FLASH_INT_PROGRAM or \b FLASH_INT_AMISC values. +//! +//! The specified flash controller interrupt sources are cleared, so that they +//! no longer assert. This must be done in the interrupt handler to keep it +//! from being called again immediately upon exit. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +FlashIntClear(unsigned long ulIntFlags) +{ + // + // Clear the flash interrupt. + // + HWREG(FLASH_FCMISC) = ulIntFlags; +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/flash.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/flash.h new file mode 100644 index 00000000..36203673 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/flash.h @@ -0,0 +1,106 @@ +//***************************************************************************** +// +// flash.h - Prototypes for the flash driver. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __FLASH_H__ +#define __FLASH_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Values that can be passed to FlashProtectSet(), and returned by +// FlashProtectGet(). +// +//***************************************************************************** +typedef enum +{ + FlashReadWrite, // Flash can be read and written + FlashReadOnly, // Flash can only be read + FlashExecuteOnly // Flash can only be executed +} +tFlashProtection; + +//***************************************************************************** +// +// Values passed to FlashIntEnable(), FlashIntDisable() and FlashIntClear() and +// returned from FlashIntStatus(). +// +//***************************************************************************** +#define FLASH_INT_PROGRAM 0x00000002 // Programming Interrupt Mask +#define FLASH_INT_ACCESS 0x00000001 // Access Interrupt Mask + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern unsigned long FlashUsecGet(void); +extern void FlashUsecSet(unsigned long ulClocks); +extern long FlashErase(unsigned long ulAddress); +extern long FlashProgram(unsigned long *pulData, unsigned long ulAddress, + unsigned long ulCount); +extern tFlashProtection FlashProtectGet(unsigned long ulAddress); +extern long FlashProtectSet(unsigned long ulAddress, + tFlashProtection eProtect); +extern long FlashProtectSave(void); +extern long FlashUserGet(unsigned long *pulUser0, unsigned long *pulUser1); +extern long FlashUserSet(unsigned long ulUser0, unsigned long ulUser1); +extern long FlashUserSave(void); +extern void FlashIntRegister(void (*pfnHandler)(void)); +extern void FlashIntUnregister(void); +extern void FlashIntEnable(unsigned long ulIntFlags); +extern void FlashIntDisable(unsigned long ulIntFlags); +extern unsigned long FlashIntStatus(tBoolean bMasked); +extern void FlashIntClear(unsigned long ulIntFlags); + +//***************************************************************************** +// +// Deprecated function names. These definitions ensure backwards compatibility +// but new code should avoid using deprecated function names since these will +// be removed at some point in the future. +// +//***************************************************************************** +#ifndef DEPRECATED +#define FlashIntGetStatus FlashIntStatus +#endif + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __FLASH_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/gpio.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/gpio.c new file mode 100644 index 00000000..4e5afa7c --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/gpio.c @@ -0,0 +1,1600 @@ +//***************************************************************************** +// +// gpio.c - API for GPIO ports +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup gpio_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_gpio.h" +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_sysctl.h" +#include "inc/hw_types.h" +#include "driverlib/debug.h" +#include "driverlib/gpio.h" +#include "driverlib/interrupt.h" + +//***************************************************************************** +// +// The base addresses of all the GPIO modules. Both the APB and AHB apertures +// are provided. +// +//***************************************************************************** +static const unsigned long g_pulGPIOBaseAddrs[] = +{ + GPIO_PORTA_BASE, GPIO_PORTA_AHB_BASE, + GPIO_PORTB_BASE, GPIO_PORTB_AHB_BASE, + GPIO_PORTC_BASE, GPIO_PORTC_AHB_BASE, + GPIO_PORTD_BASE, GPIO_PORTD_AHB_BASE, + GPIO_PORTE_BASE, GPIO_PORTE_AHB_BASE, + GPIO_PORTF_BASE, GPIO_PORTF_AHB_BASE, + GPIO_PORTG_BASE, GPIO_PORTG_AHB_BASE, + GPIO_PORTH_BASE, GPIO_PORTH_AHB_BASE, + GPIO_PORTJ_BASE, GPIO_PORTJ_AHB_BASE, +}; + +//***************************************************************************** +// +//! \internal +//! Checks a GPIO base address. +//! +//! \param ulPort is the base address of the GPIO port. +//! +//! This function determines if a GPIO port base address is valid. +//! +//! \return Returns \b true if the base address is valid and \b false +//! otherwise. +// +//***************************************************************************** +#ifdef DEBUG +static tBoolean +GPIOBaseValid(unsigned long ulPort) +{ + return((ulPort == GPIO_PORTA_BASE) || (ulPort == GPIO_PORTA_AHB_BASE) || + (ulPort == GPIO_PORTB_BASE) || (ulPort == GPIO_PORTB_AHB_BASE) || + (ulPort == GPIO_PORTC_BASE) || (ulPort == GPIO_PORTC_AHB_BASE) || + (ulPort == GPIO_PORTD_BASE) || (ulPort == GPIO_PORTD_AHB_BASE) || + (ulPort == GPIO_PORTE_BASE) || (ulPort == GPIO_PORTE_AHB_BASE) || + (ulPort == GPIO_PORTF_BASE) || (ulPort == GPIO_PORTF_AHB_BASE) || + (ulPort == GPIO_PORTG_BASE) || (ulPort == GPIO_PORTG_AHB_BASE) || + (ulPort == GPIO_PORTH_BASE) || (ulPort == GPIO_PORTH_AHB_BASE) || + (ulPort == GPIO_PORTJ_BASE) || (ulPort == GPIO_PORTJ_AHB_BASE)); +} +#endif + +//***************************************************************************** +// +//! \internal +//! Gets the GPIO interrupt number. +//! +//! \param ulPort is the base address of the GPIO port. +//! +//! Given a GPIO base address, returns the corresponding interrupt number. +//! +//! \return Returns a GPIO interrupt number, or -1 if \e ulPort is invalid. +// +//***************************************************************************** +static long +GPIOGetIntNumber(unsigned long ulPort) +{ + unsigned int ulInt; + + // + // Determine the GPIO interrupt number for the given module. + // + switch(ulPort) + { + case GPIO_PORTA_BASE: + case GPIO_PORTA_AHB_BASE: + { + ulInt = INT_GPIOA; + break; + } + + case GPIO_PORTB_BASE: + case GPIO_PORTB_AHB_BASE: + { + ulInt = INT_GPIOB; + break; + } + + case GPIO_PORTC_BASE: + case GPIO_PORTC_AHB_BASE: + { + ulInt = INT_GPIOC; + break; + } + + case GPIO_PORTD_BASE: + case GPIO_PORTD_AHB_BASE: + { + ulInt = INT_GPIOD; + break; + } + + case GPIO_PORTE_BASE: + case GPIO_PORTE_AHB_BASE: + { + ulInt = INT_GPIOE; + break; + } + + case GPIO_PORTF_BASE: + case GPIO_PORTF_AHB_BASE: + { + ulInt = INT_GPIOF; + break; + } + + case GPIO_PORTG_BASE: + case GPIO_PORTG_AHB_BASE: + { + ulInt = INT_GPIOG; + break; + } + + case GPIO_PORTH_BASE: + case GPIO_PORTH_AHB_BASE: + { + ulInt = INT_GPIOH; + break; + } + + case GPIO_PORTJ_BASE: + case GPIO_PORTJ_AHB_BASE: + { + ulInt = INT_GPIOJ; + break; + } + + default: + { + return(-1); + } + } + + // + // Return GPIO interrupt number. + // + return(ulInt); +} + +//***************************************************************************** +// +//! Sets the direction and mode of the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port +//! \param ucPins is the bit-packed representation of the pin(s). +//! \param ulPinIO is the pin direction and/or mode. +//! +//! This function will set the specified pin(s) on the selected GPIO port +//! as either an input or output under software control, or it will set the +//! pin to be under hardware control. +//! +//! The parameter \e ulPinIO is an enumerated data type that can be one of +//! the following values: +//! +//! - \b GPIO_DIR_MODE_IN +//! - \b GPIO_DIR_MODE_OUT +//! - \b GPIO_DIR_MODE_HW +//! +//! where \b GPIO_DIR_MODE_IN specifies that the pin will be programmed as +//! a software controlled input, \b GPIO_DIR_MODE_OUT specifies that the pin +//! will be programmed as a software controlled output, and +//! \b GPIO_DIR_MODE_HW specifies that the pin will be placed under +//! hardware control. +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note GPIOPadConfigSet() must also be used to configure the corresponding +//! pad(s) in order for them to propagate the signal to/from the GPIO. +//! +//! \return None. +// +//***************************************************************************** +void +GPIODirModeSet(unsigned long ulPort, unsigned char ucPins, + unsigned long ulPinIO) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + ASSERT((ulPinIO == GPIO_DIR_MODE_IN) || (ulPinIO == GPIO_DIR_MODE_OUT) || + (ulPinIO == GPIO_DIR_MODE_HW)); + + // + // Set the pin direction and mode. + // + HWREG(ulPort + GPIO_O_DIR) = ((ulPinIO & 1) ? + (HWREG(ulPort + GPIO_O_DIR) | ucPins) : + (HWREG(ulPort + GPIO_O_DIR) & ~(ucPins))); + HWREG(ulPort + GPIO_O_AFSEL) = ((ulPinIO & 2) ? + (HWREG(ulPort + GPIO_O_AFSEL) | ucPins) : + (HWREG(ulPort + GPIO_O_AFSEL) & + ~(ucPins))); +} + +//***************************************************************************** +// +//! Gets the direction and mode of a pin. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPin is the pin number. +//! +//! This function gets the direction and control mode for a specified pin on +//! the selected GPIO port. The pin can be configured as either an input or +//! output under software control, or it can be under hardware control. The +//! type of control and direction are returned as an enumerated data type. +//! +//! \return Returns one of the enumerated data types described for +//! GPIODirModeSet(). +// +//***************************************************************************** +unsigned long +GPIODirModeGet(unsigned long ulPort, unsigned char ucPin) +{ + unsigned long ulDir, ulAFSEL; + + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + ASSERT(ucPin < 8); + + // + // Convert from a pin number to a bit position. + // + ucPin = 1 << ucPin; + + // + // Return the pin direction and mode. + // + ulDir = HWREG(ulPort + GPIO_O_DIR); + ulAFSEL = HWREG(ulPort + GPIO_O_AFSEL); + return(((ulDir & ucPin) ? 1 : 0) | ((ulAFSEL & ucPin) ? 2 : 0)); +} + +//***************************************************************************** +// +//! Sets the interrupt type for the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! \param ulIntType specifies the type of interrupt trigger mechanism. +//! +//! This function sets up the various interrupt trigger mechanisms for the +//! specified pin(s) on the selected GPIO port. +//! +//! The parameter \e ulIntType is an enumerated data type that can be one of +//! the following values: +//! +//! - \b GPIO_FALLING_EDGE +//! - \b GPIO_RISING_EDGE +//! - \b GPIO_BOTH_EDGES +//! - \b GPIO_LOW_LEVEL +//! - \b GPIO_HIGH_LEVEL +//! +//! where the different values describe the interrupt detection mechanism +//! (edge or level) and the particular triggering event (falling, rising, +//! or both edges for edge detect, low or high for level detect). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note In order to avoid any spurious interrupts, the user must +//! ensure that the GPIO inputs remain stable for the duration of +//! this function. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOIntTypeSet(unsigned long ulPort, unsigned char ucPins, + unsigned long ulIntType) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + ASSERT((ulIntType == GPIO_FALLING_EDGE) || + (ulIntType == GPIO_RISING_EDGE) || (ulIntType == GPIO_BOTH_EDGES) || + (ulIntType == GPIO_LOW_LEVEL) || (ulIntType == GPIO_HIGH_LEVEL)); + + // + // Set the pin interrupt type. + // + HWREG(ulPort + GPIO_O_IBE) = ((ulIntType & 1) ? + (HWREG(ulPort + GPIO_O_IBE) | ucPins) : + (HWREG(ulPort + GPIO_O_IBE) & ~(ucPins))); + HWREG(ulPort + GPIO_O_IS) = ((ulIntType & 2) ? + (HWREG(ulPort + GPIO_O_IS) | ucPins) : + (HWREG(ulPort + GPIO_O_IS) & ~(ucPins))); + HWREG(ulPort + GPIO_O_IEV) = ((ulIntType & 4) ? + (HWREG(ulPort + GPIO_O_IEV) | ucPins) : + (HWREG(ulPort + GPIO_O_IEV) & ~(ucPins))); +} + +//***************************************************************************** +// +//! Gets the interrupt type for a pin. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPin is the pin number. +//! +//! This function gets the interrupt type for a specified pin on the selected +//! GPIO port. The pin can be configured as a falling edge, rising edge, or +//! both edge detected interrupt, or it can be configured as a low level or +//! high level detected interrupt. The type of interrupt detection mechanism +//! is returned as an enumerated data type. +//! +//! \return Returns one of the enumerated data types described for +//! GPIOIntTypeSet(). +// +//***************************************************************************** +unsigned long +GPIOIntTypeGet(unsigned long ulPort, unsigned char ucPin) +{ + unsigned long ulIBE, ulIS, ulIEV; + + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + ASSERT(ucPin < 8); + + // + // Convert from a pin number to a bit position. + // + ucPin = 1 << ucPin; + + // + // Return the pin interrupt type. + // + ulIBE = HWREG(ulPort + GPIO_O_IBE); + ulIS = HWREG(ulPort + GPIO_O_IS); + ulIEV = HWREG(ulPort + GPIO_O_IEV); + return(((ulIBE & ucPin) ? 1 : 0) | ((ulIS & ucPin) ? 2 : 0) | + ((ulIEV & ucPin) ? 4 : 0)); +} + +//***************************************************************************** +// +//! Sets the pad configuration for the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! \param ulStrength specifies the output drive strength. +//! \param ulPinType specifies the pin type. +//! +//! This function sets the drive strength and type for the specified pin(s) +//! on the selected GPIO port. For pin(s) configured as input ports, the +//! pad is configured as requested, but the only real effect on the input +//! is the configuration of the pull-up or pull-down termination. +//! +//! The parameter \e ulStrength can be one of the following values: +//! +//! - \b GPIO_STRENGTH_2MA +//! - \b GPIO_STRENGTH_4MA +//! - \b GPIO_STRENGTH_8MA +//! - \b GPIO_STRENGTH_8MA_SC +//! +//! where \b GPIO_STRENGTH_xMA specifies either 2, 4, or 8 mA output drive +//! strength, and \b GPIO_OUT_STRENGTH_8MA_SC specifies 8 mA output drive with +//! slew control. +//! +//! The parameter \e ulPinType can be one of the following values: +//! +//! - \b GPIO_PIN_TYPE_STD +//! - \b GPIO_PIN_TYPE_STD_WPU +//! - \b GPIO_PIN_TYPE_STD_WPD +//! - \b GPIO_PIN_TYPE_OD +//! - \b GPIO_PIN_TYPE_OD_WPU +//! - \b GPIO_PIN_TYPE_OD_WPD +//! - \b GPIO_PIN_TYPE_ANALOG +//! +//! where \b GPIO_PIN_TYPE_STD* specifies a push-pull pin, \b GPIO_PIN_TYPE_OD* +//! specifies an open-drain pin, \b *_WPU specifies a weak pull-up, \b *_WPD +//! specifies a weak pull-down, and \b GPIO_PIN_TYPE_ANALOG specifies an +//! analog input (for the comparators). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPadConfigSet(unsigned long ulPort, unsigned char ucPins, + unsigned long ulStrength, unsigned long ulPinType) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + ASSERT((ulStrength == GPIO_STRENGTH_2MA) || + (ulStrength == GPIO_STRENGTH_4MA) || + (ulStrength == GPIO_STRENGTH_8MA) || + (ulStrength == GPIO_STRENGTH_8MA_SC)); + ASSERT((ulPinType == GPIO_PIN_TYPE_STD) || + (ulPinType == GPIO_PIN_TYPE_STD_WPU) || + (ulPinType == GPIO_PIN_TYPE_STD_WPD) || + (ulPinType == GPIO_PIN_TYPE_OD) || + (ulPinType == GPIO_PIN_TYPE_OD_WPU) || + (ulPinType == GPIO_PIN_TYPE_OD_WPD) || + (ulPinType == GPIO_PIN_TYPE_ANALOG)) + + // + // Set the output drive strength. + // + HWREG(ulPort + GPIO_O_DR2R) = ((ulStrength & 1) ? + (HWREG(ulPort + GPIO_O_DR2R) | ucPins) : + (HWREG(ulPort + GPIO_O_DR2R) & ~(ucPins))); + HWREG(ulPort + GPIO_O_DR4R) = ((ulStrength & 2) ? + (HWREG(ulPort + GPIO_O_DR4R) | ucPins) : + (HWREG(ulPort + GPIO_O_DR4R) & ~(ucPins))); + HWREG(ulPort + GPIO_O_DR8R) = ((ulStrength & 4) ? + (HWREG(ulPort + GPIO_O_DR8R) | ucPins) : + (HWREG(ulPort + GPIO_O_DR8R) & ~(ucPins))); + HWREG(ulPort + GPIO_O_SLR) = ((ulStrength & 8) ? + (HWREG(ulPort + GPIO_O_SLR) | ucPins) : + (HWREG(ulPort + GPIO_O_SLR) & ~(ucPins))); + + // + // Set the pin type. + // + HWREG(ulPort + GPIO_O_ODR) = ((ulPinType & 1) ? + (HWREG(ulPort + GPIO_O_ODR) | ucPins) : + (HWREG(ulPort + GPIO_O_ODR) & ~(ucPins))); + HWREG(ulPort + GPIO_O_PUR) = ((ulPinType & 2) ? + (HWREG(ulPort + GPIO_O_PUR) | ucPins) : + (HWREG(ulPort + GPIO_O_PUR) & ~(ucPins))); + HWREG(ulPort + GPIO_O_PDR) = ((ulPinType & 4) ? + (HWREG(ulPort + GPIO_O_PDR) | ucPins) : + (HWREG(ulPort + GPIO_O_PDR) & ~(ucPins))); + HWREG(ulPort + GPIO_O_DEN) = ((ulPinType & 8) ? + (HWREG(ulPort + GPIO_O_DEN) | ucPins) : + (HWREG(ulPort + GPIO_O_DEN) & ~(ucPins))); + + // + // Set the analog mode select register. This register only appears in + // DustDevil-class (and later) devices, but is a harmless write on + // Sandstorm- and Fury-class devices. + // + HWREG(ulPort + GPIO_O_AMSEL) = + ((ulPinType == GPIO_PIN_TYPE_ANALOG) ? + (HWREG(ulPort + GPIO_O_AMSEL) | ucPins) : + (HWREG(ulPort + GPIO_O_AMSEL) & ~(ucPins))); +} + +//***************************************************************************** +// +//! Gets the pad configuration for a pin. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPin is the pin number. +//! \param pulStrength is a pointer to storage for the output drive strength. +//! \param pulPinType is a pointer to storage for the output drive type. +//! +//! This function gets the pad configuration for a specified pin on the +//! selected GPIO port. The values returned in \e pulStrength and +//! \e pulPinType correspond to the values used in GPIOPadConfigSet(). This +//! function also works for pin(s) configured as input pin(s); however, the +//! only meaningful data returned is whether the pin is terminated with a +//! pull-up or down resistor. +//! +//! \return None +// +//***************************************************************************** +void +GPIOPadConfigGet(unsigned long ulPort, unsigned char ucPin, + unsigned long *pulStrength, unsigned long *pulPinType) +{ + unsigned long ulTemp1, ulTemp2, ulTemp3, ulTemp4; + + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + ASSERT(ucPin < 8); + + // + // Convert from a pin number to a bit position. + // + ucPin = (1 << ucPin); + + // + // Get the drive strength for this pin. + // + ulTemp1 = HWREG(ulPort + GPIO_O_DR2R); + ulTemp2 = HWREG(ulPort + GPIO_O_DR4R); + ulTemp3 = HWREG(ulPort + GPIO_O_DR8R); + ulTemp4 = HWREG(ulPort + GPIO_O_SLR); + *pulStrength = (((ulTemp1 & ucPin) ? 1 : 0) | ((ulTemp2 & ucPin) ? 2 : 0) | + ((ulTemp3 & ucPin) ? 4 : 0) | ((ulTemp4 & ucPin) ? 8 : 0)); + + // + // Get the pin type. + // + ulTemp1 = HWREG(ulPort + GPIO_O_ODR); + ulTemp2 = HWREG(ulPort + GPIO_O_PUR); + ulTemp3 = HWREG(ulPort + GPIO_O_PDR); + ulTemp4 = HWREG(ulPort + GPIO_O_DEN); + *pulPinType = (((ulTemp1 & ucPin) ? 1 : 0) | ((ulTemp2 & ucPin) ? 2 : 0) | + ((ulTemp3 & ucPin) ? 4 : 0) | ((ulTemp4 & ucPin) ? 8 : 0)); +} + +//***************************************************************************** +// +//! Enables interrupts for the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! Unmasks the interrupt for the specified pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinIntEnable(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Enable the interrupts. + // + HWREG(ulPort + GPIO_O_IM) |= ucPins; +} + +//***************************************************************************** +// +//! Disables interrupts for the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! Masks the interrupt for the specified pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinIntDisable(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Disable the interrupts. + // + HWREG(ulPort + GPIO_O_IM) &= ~(ucPins); +} + +//***************************************************************************** +// +//! Gets interrupt status for the specified GPIO port. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param bMasked specifies whether masked or raw interrupt status is +//! returned. +//! +//! If \e bMasked is set as \b true, then the masked interrupt status is +//! returned; otherwise, the raw interrupt status will be returned. +//! +//! \return Returns a bit-packed byte, where each bit that is set identifies +//! an active masked or raw interrupt, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! Bits 31:8 should be ignored. +// +//***************************************************************************** +long +GPIOPinIntStatus(unsigned long ulPort, tBoolean bMasked) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Return the interrupt status. + // + if(bMasked) + { + return(HWREG(ulPort + GPIO_O_MIS)); + } + else + { + return(HWREG(ulPort + GPIO_O_RIS)); + } +} + +//***************************************************************************** +// +//! Clears the interrupt for the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! Clears the interrupt for the specified pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinIntClear(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Clear the interrupts. + // + HWREG(ulPort + GPIO_O_ICR) = ucPins; +} + +//***************************************************************************** +// +//! Registers an interrupt handler for a GPIO port. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param pfnIntHandler is a pointer to the GPIO port interrupt handling +//! function. +//! +//! This function will ensure that the interrupt handler specified by +//! \e pfnIntHandler is called when an interrupt is detected from the selected +//! GPIO port. This function will also enable the corresponding GPIO interrupt +//! in the interrupt controller; individual pin interrupts and interrupt +//! sources must be enabled with GPIOPinIntEnable(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPortIntRegister(unsigned long ulPort, void (*pfnIntHandler)(void)) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Get the interrupt number associated with the specified GPIO. + // + ulPort = GPIOGetIntNumber(ulPort); + + // + // Register the interrupt handler. + // + IntRegister(ulPort, pfnIntHandler); + + // + // Enable the GPIO interrupt. + // + IntEnable(ulPort); +} + +//***************************************************************************** +// +//! Removes an interrupt handler for a GPIO port. +//! +//! \param ulPort is the base address of the GPIO port. +//! +//! This function will unregister the interrupt handler for the specified +//! GPIO port. This function will also disable the corresponding +//! GPIO port interrupt in the interrupt controller; individual GPIO interrupts +//! and interrupt sources must be disabled with GPIOPinIntDisable(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPortIntUnregister(unsigned long ulPort) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Get the interrupt number associated with the specified GPIO. + // + ulPort = GPIOGetIntNumber(ulPort); + + // + // Disable the GPIO interrupt. + // + IntDisable(ulPort); + + // + // Unregister the interrupt handler. + // + IntUnregister(ulPort); +} + +//***************************************************************************** +// +//! Reads the values present of the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The values at the specified pin(s) are read, as specified by \e ucPins. +//! Values are returned for both input and output pin(s), and the value +//! for pin(s) that are not specified by \e ucPins are set to 0. +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return Returns a bit-packed byte providing the state of the specified +//! pin, where bit 0 of the byte represents GPIO port pin 0, bit 1 represents +//! GPIO port pin 1, and so on. Any bit that is not specified by \e ucPins +//! is returned as a 0. Bits 31:8 should be ignored. +// +//***************************************************************************** +long +GPIOPinRead(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Return the pin value(s). + // + return(HWREG(ulPort + (GPIO_O_DATA + (ucPins << 2)))); +} + +//***************************************************************************** +// +//! Writes a value to the specified pin(s). +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! \param ucVal is the value to write to the pin(s). +//! +//! Writes the corresponding bit values to the output pin(s) specified by +//! \e ucPins. Writing to a pin configured as an input pin has no effect. +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinWrite(unsigned long ulPort, unsigned char ucPins, unsigned char ucVal) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Write the pins. + // + HWREG(ulPort + (GPIO_O_DATA + (ucPins << 2))) = ucVal; +} + +//***************************************************************************** +// +//! Configures pin(s) for use as analog-to-digital converter inputs. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The analog-to-digital converter input pins must be properly configured +//! to function correctly on DustDevil-class devices. This function provides +//! the proper configuration for those pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into an ADC input; it only +//! configures an ADC input pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeADC(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be inputs. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_IN); + + // + // Set the pad(s) for analog operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_ANALOG); +} + +//***************************************************************************** +// +//! Configures pin(s) for use as a CAN device. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The CAN pins must be properly configured for the CAN peripherals to +//! function correctly. This function provides a typical configuration for +//! those pin(s); other configurations may work as well depending upon the +//! board setup (for example, using the on-chip pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a CAN pin; it only +//! configures a CAN pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeCAN(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be inputs. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use as an analog comparator input. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The analog comparator input pins must be properly configured for the analog +//! comparator to function correctly. This function provides the proper +//! configuration for those pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into an analog comparator input; +//! it only configures an analog comparator pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeComparator(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be inputs. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_IN); + + // + // Set the pad(s) for analog operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_ANALOG); +} + +//***************************************************************************** +// +//! Configures pin(s) for use as GPIO inputs. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The GPIO pins must be properly configured in order to function correctly as +//! GPIO inputs; this is especially true of Fury-class devices where the +//! digital input enable is turned off by default. This function provides the +//! proper configuration for those pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeGPIOInput(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be inputs. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_IN); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use as GPIO outputs. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The GPIO pins must be properly configured in order to function correctly as +//! GPIO outputs; this is especially true of Fury-class devices where the +//! digital input enable is turned off by default. This function provides the +//! proper configuration for those pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeGPIOOutput(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be outputs. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_OUT); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use as GPIO open drain outputs. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The GPIO pins must be properly configured in order to function correctly as +//! GPIO outputs; this is especially true of Fury-class devices where the +//! digital input enable is turned off by default. This function provides the +//! proper configuration for those pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeGPIOOutputOD(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be outputs. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_OUT); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_OD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the I2C peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The I2C pins must be properly configured for the I2C peripheral to function +//! correctly. This function provides the proper configuration for those +//! pin(s). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into an I2C pin; it only +//! configures an I2C pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeI2C(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for open-drain operation with a weak pull-up. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_OD_WPU); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the PWM peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The PWM pins must be properly configured for the PWM peripheral to function +//! correctly. This function provides a typical configuration for those +//! pin(s); other configurations may work as well depending upon the board +//! setup (for example, using the on-chip pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a PWM pin; it only +//! configures a PWM pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypePWM(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the QEI peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The QEI pins must be properly configured for the QEI peripheral to function +//! correctly. This function provides a typical configuration for those +//! pin(s); other configurations may work as well depending upon the board +//! setup (for example, not using the on-chip pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a QEI pin; it only +//! configures a QEI pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeQEI(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation with a weak pull-up. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the SSI peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The SSI pins must be properly configured for the SSI peripheral to function +//! correctly. This function provides a typical configuration for those +//! pin(s); other configurations may work as well depending upon the board +//! setup (for example, using the on-chip pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a SSI pin; it only +//! configures a SSI pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeSSI(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the Timer peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The CCP pins must be properly configured for the timer peripheral to +//! function correctly. This function provides a typical configuration for +//! those pin(s); other configurations may work as well depending upon the +//! board setup (for example, using the on-chip pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a timer pin; it only +//! configures a timer pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeTimer(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the UART peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The UART pins must be properly configured for the UART peripheral to +//! function correctly. This function provides a typical configuration for +//! those pin(s); other configurations may work as well depending upon the +//! board setup (for example, using the on-chip pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a UART pin; it only +//! configures a UART pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeUART(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the USB peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! Some USB digital pins must be properly configured for the USB peripheral to +//! function correctly. This function provides a typical configuration for +//! the digital USB pin(s); other configurations may work as well depending +//! upon the board setup (for example, using the on-chip pull-ups). +//! +//! This function should only be used with EPEN and PFAULT pins as all other +//! USB pins are analog in nature or are not used in devices without OTG +//! functionality. +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a USB pin; it only +//! configures a USB pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeUSBDigital(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the USB peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! Some USB analog pins must be properly configured for the USB peripheral to +//! function correctly. This function provides the proper configuration for +//! any USB pin(s). This can also be used to configure the EPEN and PFAULT pins +//! so that they are no longer used by the USB controller. +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a USB pin; it only +//! configures a USB pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeUSBAnalog(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be inputs. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_IN); + + // + // Set the pad(s) for analog operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_ANALOG); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the I2S peripheral. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! Some I2S pins must be properly configured for the I2S peripheral to +//! function correctly. This function provides a typical configuration for +//! the digital I2S pin(s); other configurations may work as well depending +//! upon the board setup (for example, using the on-chip pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into a I2S pin; it only +//! configures a I2S pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeI2S(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the Ethernet peripheral as LED signals. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The Ethernet peripheral provides two signals that can be used to drive +//! an LED (e.g. for link status/activity). This function provides a typical +//! configuration for the pins. +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into an Ethernet LED pin; it only +//! configures an Ethernet LED pin for proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeEthernetLED(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures pin(s) for use by the external peripheral interface. +//! +//! \param ulPort is the base address of the GPIO port. +//! \param ucPins is the bit-packed representation of the pin(s). +//! +//! The external peripheral interface pins must be properly configured for the +//! external peripheral interface to function correctly. This function +//! provides a typica configuration for those pin(s); other configurations may +//! work as well depending upon the board setup (for exampe, using the on-chip +//! pull-ups). +//! +//! The pin(s) are specified using a bit-packed byte, where each bit that is +//! set identifies the pin to be accessed, and where bit 0 of the byte +//! represents GPIO port pin 0, bit 1 represents GPIO port pin 1, and so on. +//! +//! \note This cannot be used to turn any pin into an external peripheral +//! interface pin; it only configures an external peripheral interface pin for +//! proper operation. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinTypeEPI(unsigned long ulPort, unsigned char ucPins) +{ + // + // Check the arguments. + // + ASSERT(GPIOBaseValid(ulPort)); + + // + // Make the pin(s) be peripheral controlled. + // + GPIODirModeSet(ulPort, ucPins, GPIO_DIR_MODE_HW); + + // + // Set the pad(s) for standard push-pull operation. + // + GPIOPadConfigSet(ulPort, ucPins, GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD); +} + +//***************************************************************************** +// +//! Configures the alternate function of a GPIO pin. +//! +//! \param ulPinConfig is the pin configuration value, specified as only one of +//! the \b GPIO_P??_??? values. +//! +//! This function configures the pin mux that selects the peripheral function +//! associated with a particular GPIO pin. Only one peripheral function at a +//! time can be associated with a GPIO pin, and each peripheral function should +//! only be associated with a single GPIO pin at a time (despite the fact that +//! many of them can be associated with more than one GPIO pin). +//! +//! \note This function is only valid on Tempest-class devices. +//! +//! \return None. +// +//***************************************************************************** +void +GPIOPinConfigure(unsigned long ulPinConfig) +{ + unsigned long ulBase, ulShift; + + // + // Check the argument. + // + ASSERT(((ulPinConfig >> 16) & 0xff) < 9); + ASSERT(((ulPinConfig >> 8) & 0xe3) == 0); + + // + // Extract the base address index from the input value. + // + ulBase = (ulPinConfig >> 16) & 0xff; + + // + // Get the base address of the GPIO module, selecting either the APB or the + // AHB aperture as appropriate. + // + if(HWREG(SYSCTL_GPIOHBCTL) & (1 << ulBase)) + { + ulBase = g_pulGPIOBaseAddrs[(ulBase << 1) + 1]; + } + else + { + ulBase = g_pulGPIOBaseAddrs[ulBase << 1]; + } + + // + // Extract the shift from the input value. + // + ulShift = (ulPinConfig >> 8) & 0xff; + + // + // Write the requested pin muxing value for this GPIO pin. + // + HWREG(ulBase + GPIO_O_PCTL) = ((HWREG(ulBase + GPIO_O_PCTL) & + ~(0xf << ulShift)) | + ((ulPinConfig & 0xf) << ulShift)); + +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/gpio.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/gpio.h new file mode 100644 index 00000000..3b60fc77 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/gpio.h @@ -0,0 +1,767 @@ +//***************************************************************************** +// +// gpio.h - Defines and Macros for GPIO API. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __GPIO_H__ +#define __GPIO_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// The following values define the bit field for the ucPins argument to several +// of the APIs. +// +//***************************************************************************** +#define GPIO_PIN_0 0x00000001 // GPIO pin 0 +#define GPIO_PIN_1 0x00000002 // GPIO pin 1 +#define GPIO_PIN_2 0x00000004 // GPIO pin 2 +#define GPIO_PIN_3 0x00000008 // GPIO pin 3 +#define GPIO_PIN_4 0x00000010 // GPIO pin 4 +#define GPIO_PIN_5 0x00000020 // GPIO pin 5 +#define GPIO_PIN_6 0x00000040 // GPIO pin 6 +#define GPIO_PIN_7 0x00000080 // GPIO pin 7 + +//***************************************************************************** +// +// Values that can be passed to GPIODirModeSet as the ulPinIO parameter, and +// returned from GPIODirModeGet. +// +//***************************************************************************** +#define GPIO_DIR_MODE_IN 0x00000000 // Pin is a GPIO input +#define GPIO_DIR_MODE_OUT 0x00000001 // Pin is a GPIO output +#define GPIO_DIR_MODE_HW 0x00000002 // Pin is a peripheral function + +//***************************************************************************** +// +// Values that can be passed to GPIOIntTypeSet as the ulIntType parameter, and +// returned from GPIOIntTypeGet. +// +//***************************************************************************** +#define GPIO_FALLING_EDGE 0x00000000 // Interrupt on falling edge +#define GPIO_RISING_EDGE 0x00000004 // Interrupt on rising edge +#define GPIO_BOTH_EDGES 0x00000001 // Interrupt on both edges +#define GPIO_LOW_LEVEL 0x00000002 // Interrupt on low level +#define GPIO_HIGH_LEVEL 0x00000007 // Interrupt on high level + +//***************************************************************************** +// +// Values that can be passed to GPIOPadConfigSet as the ulStrength parameter, +// and returned by GPIOPadConfigGet in the *pulStrength parameter. +// +//***************************************************************************** +#define GPIO_STRENGTH_2MA 0x00000001 // 2mA drive strength +#define GPIO_STRENGTH_4MA 0x00000002 // 4mA drive strength +#define GPIO_STRENGTH_8MA 0x00000004 // 8mA drive strength +#define GPIO_STRENGTH_8MA_SC 0x0000000C // 8mA drive with slew rate control + +//***************************************************************************** +// +// Values that can be passed to GPIOPadConfigSet as the ulPadType parameter, +// and returned by GPIOPadConfigGet in the *pulPadType parameter. +// +//***************************************************************************** +#define GPIO_PIN_TYPE_STD 0x00000008 // Push-pull +#define GPIO_PIN_TYPE_STD_WPU 0x0000000A // Push-pull with weak pull-up +#define GPIO_PIN_TYPE_STD_WPD 0x0000000C // Push-pull with weak pull-down +#define GPIO_PIN_TYPE_OD 0x00000009 // Open-drain +#define GPIO_PIN_TYPE_OD_WPU 0x0000000B // Open-drain with weak pull-up +#define GPIO_PIN_TYPE_OD_WPD 0x0000000D // Open-drain with weak pull-down +#define GPIO_PIN_TYPE_ANALOG 0x00000000 // Analog comparator + +//***************************************************************************** +// +// Values that can be passed to GPIOPinConfigure as the ulPinConfig parameter. +// +//***************************************************************************** +// +// GPIO pin A0 +// +#define GPIO_PA0_U0RX 0x00000001 +#define GPIO_PA0_I2C1SCL 0x00000008 +#define GPIO_PA0_U1RX 0x00000009 + +// +// GPIO pin A1 +// +#define GPIO_PA1_U0TX 0x00000401 +#define GPIO_PA1_I2C1SDA 0x00000408 +#define GPIO_PA1_U1TX 0x00000409 + +// +// GPIO pin A2 +// +#define GPIO_PA2_SSI0CLK 0x00000801 +#define GPIO_PA2_PWM4 0x00000804 +#define GPIO_PA2_I2S0RXSD 0x00000809 + +// +// GPIO pin A3 +// +#define GPIO_PA3_SSI0FSS 0x00000c01 +#define GPIO_PA3_PWM5 0x00000c04 +#define GPIO_PA3_I2S0RXMCLK 0x00000c09 + +// +// GPIO pin A4 +// +#define GPIO_PA4_SSI0RX 0x00001001 +#define GPIO_PA4_PWM6 0x00001004 +#define GPIO_PA4_CAN0RX 0x00001005 +#define GPIO_PA4_I2S0TXSCK 0x00001009 + +// +// GPIO pin A5 +// +#define GPIO_PA5_SSI0TX 0x00001401 +#define GPIO_PA5_PWM7 0x00001404 +#define GPIO_PA5_CAN0TX 0x00001405 +#define GPIO_PA5_I2S0TXWS 0x00001409 + +// +// GPIO pin A6 +// +#define GPIO_PA6_I2C1SCL 0x00001801 +#define GPIO_PA6_CCP1 0x00001802 +#define GPIO_PA6_PWM0 0x00001804 +#define GPIO_PA6_PWM4 0x00001805 +#define GPIO_PA6_CAN0RX 0x00001806 +#define GPIO_PA6_USB0EPEN 0x00001808 +#define GPIO_PA6_U1CTS 0x00001809 + +// +// GPIO pin A7 +// +#define GPIO_PA7_I2C1SDA 0x00001c01 +#define GPIO_PA7_CCP4 0x00001c02 +#define GPIO_PA7_PWM1 0x00001c04 +#define GPIO_PA7_PWM5 0x00001c05 +#define GPIO_PA7_CAN0TX 0x00001c06 +#define GPIO_PA7_CCP3 0x00001c07 +#define GPIO_PA7_USB0PFLT 0x00001c08 +#define GPIO_PA7_U1DCD 0x00001c09 + +// +// GPIO pin B0 +// +#define GPIO_PB0_CCP0 0x00010001 +#define GPIO_PB0_PWM2 0x00010002 +#define GPIO_PB0_U1RX 0x00010005 + +// +// GPIO pin B1 +// +#define GPIO_PB1_CCP2 0x00010401 +#define GPIO_PB1_PWM3 0x00010402 +#define GPIO_PB1_CCP1 0x00010404 +#define GPIO_PB1_U1TX 0x00010405 + +// +// GPIO pin B2 +// +#define GPIO_PB2_I2C0SCL 0x00010801 +#define GPIO_PB2_IDX0 0x00010802 +#define GPIO_PB2_CCP3 0x00010804 +#define GPIO_PB2_CCP0 0x00010805 +#define GPIO_PB2_USB0EPEN 0x00010808 + +// +// GPIO pin B3 +// +#define GPIO_PB3_I2C0SDA 0x00010c01 +#define GPIO_PB3_FAULT0 0x00010c02 +#define GPIO_PB3_FAULT3 0x00010c04 +#define GPIO_PB3_USB0PFLT 0x00010c08 + +// +// GPIO pin B4 +// +#define GPIO_PB4_U2RX 0x00011004 +#define GPIO_PB4_CAN0RX 0x00011005 +#define GPIO_PB4_IDX0 0x00011006 +#define GPIO_PB4_U1RX 0x00011007 +#define GPIO_PB4_EPI0S23 0x00011008 + +// +// GPIO pin B5 +// +#define GPIO_PB5_C0O 0x00011401 +#define GPIO_PB5_CCP5 0x00011402 +#define GPIO_PB5_CCP6 0x00011403 +#define GPIO_PB5_CCP0 0x00011404 +#define GPIO_PB5_CAN0TX 0x00011405 +#define GPIO_PB5_CCP2 0x00011406 +#define GPIO_PB5_U1TX 0x00011407 +#define GPIO_PB5_EPI0S22 0x00011408 + +// +// GPIO pin B6 +// +#define GPIO_PB6_CCP1 0x00011801 +#define GPIO_PB6_CCP7 0x00011802 +#define GPIO_PB6_C0O 0x00011803 +#define GPIO_PB6_FAULT1 0x00011804 +#define GPIO_PB6_IDX0 0x00011805 +#define GPIO_PB6_CCP5 0x00011806 +#define GPIO_PB6_I2S0TXSCK 0x00011809 + +// +// GPIO pin B7 +// +#define GPIO_PB7_NMI 0x00011c04 + +// +// GPIO pin C0 +// +#define GPIO_PC0_TCK 0x00020003 + +// +// GPIO pin C1 +// +#define GPIO_PC1_TMS 0x00020403 + +// +// GPIO pin C2 +// +#define GPIO_PC2_TDI 0x00020803 + +// +// GPIO pin C3 +// +#define GPIO_PC3_TDO 0x00020c03 + +// +// GPIO pin C4 +// +#define GPIO_PC4_CCP5 0x00021001 +#define GPIO_PC4_PHA0 0x00021002 +#define GPIO_PC4_PWM6 0x00021004 +#define GPIO_PC4_CCP2 0x00021005 +#define GPIO_PC4_CCP4 0x00021006 +#define GPIO_PC4_EPI0S2 0x00021008 +#define GPIO_PC4_CCP1 0x00021009 + +// +// GPIO pin C5 +// +#define GPIO_PC5_CCP1 0x00021401 +#define GPIO_PC5_C1O 0x00021402 +#define GPIO_PC5_C0O 0x00021403 +#define GPIO_PC5_FAULT2 0x00021404 +#define GPIO_PC5_CCP3 0x00021405 +#define GPIO_PC5_USB0EPEN 0x00021406 +#define GPIO_PC5_EPI0S3 0x00021408 + +// +// GPIO pin C6 +// +#define GPIO_PC6_CCP3 0x00021801 +#define GPIO_PC6_PHB0 0x00021802 +#define GPIO_PC6_C2O 0x00021803 +#define GPIO_PC6_PWM7 0x00021804 +#define GPIO_PC6_U1RX 0x00021805 +#define GPIO_PC6_CCP0 0x00021806 +#define GPIO_PC6_USB0PFLT 0x00021807 +#define GPIO_PC6_EPI0S4 0x00021808 + +// +// GPIO pin C7 +// +#define GPIO_PC7_CCP4 0x00021c01 +#define GPIO_PC7_PHB0 0x00021c02 +#define GPIO_PC7_CCP0 0x00021c04 +#define GPIO_PC7_U1TX 0x00021c05 +#define GPIO_PC7_USB0PFLT 0x00021c06 +#define GPIO_PC7_C1O 0x00021c07 +#define GPIO_PC7_EPI0S5 0x00021c08 + +// +// GPIO pin D0 +// +#define GPIO_PD0_PWM0 0x00030001 +#define GPIO_PD0_CAN0RX 0x00030002 +#define GPIO_PD0_IDX0 0x00030003 +#define GPIO_PD0_U2RX 0x00030004 +#define GPIO_PD0_U1RX 0x00030005 +#define GPIO_PD0_CCP6 0x00030006 +#define GPIO_PD0_I2S0RXSCK 0x00030008 +#define GPIO_PD0_U1CTS 0x00030009 + +// +// GPIO pin D1 +// +#define GPIO_PD1_PWM1 0x00030401 +#define GPIO_PD1_CAN0TX 0x00030402 +#define GPIO_PD1_PHA0 0x00030403 +#define GPIO_PD1_U2TX 0x00030404 +#define GPIO_PD1_U1TX 0x00030405 +#define GPIO_PD1_CCP7 0x00030406 +#define GPIO_PD1_I2S0RXWS 0x00030408 +#define GPIO_PD1_U1DCD 0x00030409 +#define GPIO_PD1_CCP2 0x0003040a +#define GPIO_PD1_PHB1 0x0003040b + +// +// GPIO pin D2 +// +#define GPIO_PD2_U1RX 0x00030801 +#define GPIO_PD2_CCP6 0x00030802 +#define GPIO_PD2_PWM2 0x00030803 +#define GPIO_PD2_CCP5 0x00030804 +#define GPIO_PD2_EPI0S20 0x00030808 + +// +// GPIO pin D3 +// +#define GPIO_PD3_U1TX 0x00030c01 +#define GPIO_PD3_CCP7 0x00030c02 +#define GPIO_PD3_PWM3 0x00030c03 +#define GPIO_PD3_CCP0 0x00030c04 +#define GPIO_PD3_EPI0S21 0x00030c08 + +// +// GPIO pin D4 +// +#define GPIO_PD4_CCP0 0x00031001 +#define GPIO_PD4_CCP3 0x00031002 +#define GPIO_PD4_I2S0RXSD 0x00031008 +#define GPIO_PD4_U1RI 0x00031009 +#define GPIO_PD4_EPI0S19 0x0003100a + +// +// GPIO pin D5 +// +#define GPIO_PD5_CCP2 0x00031401 +#define GPIO_PD5_CCP4 0x00031402 +#define GPIO_PD5_I2S0RXMCLK 0x00031408 +#define GPIO_PD5_U2RX 0x00031409 +#define GPIO_PD5_EPI0S28 0x0003140a + +// +// GPIO pin D6 +// +#define GPIO_PD6_FAULT0 0x00031801 +#define GPIO_PD6_I2S0TXSCK 0x00031808 +#define GPIO_PD6_U2TX 0x00031809 +#define GPIO_PD6_EPI0S29 0x0003180a + +// +// GPIO pin D7 +// +#define GPIO_PD7_IDX0 0x00031c01 +#define GPIO_PD7_C0O 0x00031c02 +#define GPIO_PD7_CCP1 0x00031c03 +#define GPIO_PD7_I2S0TXWS 0x00031c08 +#define GPIO_PD7_U1DTR 0x00031c09 +#define GPIO_PD7_EPI0S30 0x00031c0a + +// +// GPIO pin E0 +// +#define GPIO_PE0_PWM4 0x00040001 +#define GPIO_PE0_SSI1CLK 0x00040002 +#define GPIO_PE0_CCP3 0x00040003 +#define GPIO_PE0_EPI0S8 0x00040008 +#define GPIO_PE0_USB0PFLT 0x00040009 + +// +// GPIO pin E1 +// +#define GPIO_PE1_PWM5 0x00040401 +#define GPIO_PE1_SSI1FSS 0x00040402 +#define GPIO_PE1_FAULT0 0x00040403 +#define GPIO_PE1_CCP2 0x00040404 +#define GPIO_PE1_CCP6 0x00040405 +#define GPIO_PE1_EPI0S9 0x00040408 + +// +// GPIO pin E2 +// +#define GPIO_PE2_CCP4 0x00040801 +#define GPIO_PE2_SSI1RX 0x00040802 +#define GPIO_PE2_PHB1 0x00040803 +#define GPIO_PE2_PHA0 0x00040804 +#define GPIO_PE2_CCP2 0x00040805 +#define GPIO_PE2_EPI0S24 0x00040808 + +// +// GPIO pin E3 +// +#define GPIO_PE3_CCP1 0x00040c01 +#define GPIO_PE3_SSI1TX 0x00040c02 +#define GPIO_PE3_PHA1 0x00040c03 +#define GPIO_PE3_PHB0 0x00040c04 +#define GPIO_PE3_CCP7 0x00040c05 +#define GPIO_PE3_EPI0S25 0x00040c08 + +// +// GPIO pin E4 +// +#define GPIO_PE4_CCP3 0x00041001 +#define GPIO_PE4_FAULT0 0x00041004 +#define GPIO_PE4_U2TX 0x00041005 +#define GPIO_PE4_CCP2 0x00041006 +#define GPIO_PE4_I2S0TXWS 0x00041009 + +// +// GPIO pin E5 +// +#define GPIO_PE5_CCP5 0x00041401 +#define GPIO_PE5_I2S0TXSD 0x00041409 + +// +// GPIO pin E6 +// +#define GPIO_PE6_PWM4 0x00041801 +#define GPIO_PE6_C1O 0x00041802 +#define GPIO_PE6_U1CTS 0x00041809 + +// +// GPIO pin E7 +// +#define GPIO_PE7_PWM5 0x00041c01 +#define GPIO_PE7_C2O 0x00041c02 +#define GPIO_PE7_U1DCD 0x00041c09 + +// +// GPIO pin F0 +// +#define GPIO_PF0_CAN1RX 0x00050001 +#define GPIO_PF0_PHB0 0x00050002 +#define GPIO_PF0_PWM0 0x00050003 +#define GPIO_PF0_I2S0TXSD 0x00050008 +#define GPIO_PF0_U1DSR 0x00050009 + +// +// GPIO pin F1 +// +#define GPIO_PF1_CAN1TX 0x00050401 +#define GPIO_PF1_IDX1 0x00050402 +#define GPIO_PF1_PWM1 0x00050403 +#define GPIO_PF1_I2S0TXMCLK 0x00050408 +#define GPIO_PF1_U1RTS 0x00050409 +#define GPIO_PF1_CCP3 0x0005040a + +// +// GPIO pin F2 +// +#define GPIO_PF2_LED1 0x00050801 +#define GPIO_PF2_PWM4 0x00050802 +#define GPIO_PF2_PWM2 0x00050804 +#define GPIO_PF2_SSI1CLK 0x00050809 + +// +// GPIO pin F3 +// +#define GPIO_PF3_LED0 0x00050c01 +#define GPIO_PF3_PWM5 0x00050c02 +#define GPIO_PF3_PWM3 0x00050c04 +#define GPIO_PF3_SSI1FSS 0x00050c09 + +// +// GPIO pin F4 +// +#define GPIO_PF4_CCP0 0x00051001 +#define GPIO_PF4_C0O 0x00051002 +#define GPIO_PF4_FAULT0 0x00051004 +#define GPIO_PF4_EPI0S12 0x00051008 +#define GPIO_PF4_SSI1RX 0x00051009 + +// +// GPIO pin F5 +// +#define GPIO_PF5_CCP2 0x00051401 +#define GPIO_PF5_C1O 0x00051402 +#define GPIO_PF5_EPI0S15 0x00051408 +#define GPIO_PF5_SSI1TX 0x00051409 + +// +// GPIO pin F6 +// +#define GPIO_PF6_CCP1 0x00051801 +#define GPIO_PF6_C2O 0x00051802 +#define GPIO_PF6_PHA0 0x00051804 +#define GPIO_PF6_I2S0TXMCLK 0x00051809 +#define GPIO_PF6_U1RTS 0x0005180a + +// +// GPIO pin F7 +// +#define GPIO_PF7_CCP4 0x00051c01 +#define GPIO_PF7_PHB0 0x00051c04 +#define GPIO_PF7_EPI0S12 0x00051c08 +#define GPIO_PF7_FAULT1 0x00051c09 + +// +// GPIO pin G0 +// +#define GPIO_PG0_U2RX 0x00060001 +#define GPIO_PG0_PWM0 0x00060002 +#define GPIO_PG0_I2C1SCL 0x00060003 +#define GPIO_PG0_PWM4 0x00060004 +#define GPIO_PG0_USB0EPEN 0x00060007 +#define GPIO_PG0_EPI0S13 0x00060008 + +// +// GPIO pin G1 +// +#define GPIO_PG1_U2TX 0x00060401 +#define GPIO_PG1_PWM1 0x00060402 +#define GPIO_PG1_I2C1SDA 0x00060403 +#define GPIO_PG1_PWM5 0x00060404 +#define GPIO_PG1_EPI0S14 0x00060408 + +// +// GPIO pin G2 +// +#define GPIO_PG2_PWM0 0x00060801 +#define GPIO_PG2_FAULT0 0x00060804 +#define GPIO_PG2_IDX1 0x00060808 +#define GPIO_PG2_I2S0RXSD 0x00060809 + +// +// GPIO pin G3 +// +#define GPIO_PG3_PWM1 0x00060c01 +#define GPIO_PG3_FAULT2 0x00060c04 +#define GPIO_PG3_FAULT0 0x00060c08 +#define GPIO_PG3_I2S0RXMCLK 0x00060c09 + +// +// GPIO pin G4 +// +#define GPIO_PG4_CCP3 0x00061001 +#define GPIO_PG4_FAULT1 0x00061004 +#define GPIO_PG4_EPI0S15 0x00061008 +#define GPIO_PG4_PWM6 0x00061009 +#define GPIO_PG4_U1RI 0x0006100a + +// +// GPIO pin G5 +// +#define GPIO_PG5_CCP5 0x00061401 +#define GPIO_PG5_IDX0 0x00061404 +#define GPIO_PG5_FAULT1 0x00061405 +#define GPIO_PG5_PWM7 0x00061408 +#define GPIO_PG5_I2S0RXSCK 0x00061409 +#define GPIO_PG5_U1DTR 0x0006140a + +// +// GPIO pin G6 +// +#define GPIO_PG6_PHA1 0x00061801 +#define GPIO_PG6_PWM6 0x00061804 +#define GPIO_PG6_FAULT1 0x00061808 +#define GPIO_PG6_I2S0RXWS 0x00061809 +#define GPIO_PG6_U1RI 0x0006180a + +// +// GPIO pin G7 +// +#define GPIO_PG7_PHB1 0x00061c01 +#define GPIO_PG7_PWM7 0x00061c04 +#define GPIO_PG7_CCP5 0x00061c08 +#define GPIO_PG7_EPI0S31 0x00061c09 + +// +// GPIO pin H0 +// +#define GPIO_PH0_CCP6 0x00070001 +#define GPIO_PH0_PWM2 0x00070002 +#define GPIO_PH0_EPI0S6 0x00070008 +#define GPIO_PH0_PWM4 0x00070009 + +// +// GPIO pin H1 +// +#define GPIO_PH1_CCP7 0x00070401 +#define GPIO_PH1_PWM3 0x00070402 +#define GPIO_PH1_EPI0S7 0x00070408 +#define GPIO_PH1_PWM5 0x00070409 + +// +// GPIO pin H2 +// +#define GPIO_PH2_IDX1 0x00070801 +#define GPIO_PH2_C1O 0x00070802 +#define GPIO_PH2_FAULT3 0x00070804 +#define GPIO_PH2_EPI0S1 0x00070808 + +// +// GPIO pin H3 +// +#define GPIO_PH3_PHB0 0x00070c01 +#define GPIO_PH3_FAULT0 0x00070c02 +#define GPIO_PH3_USB0EPEN 0x00070c04 +#define GPIO_PH3_EPI0S0 0x00070c08 + +// +// GPIO pin H4 +// +#define GPIO_PH4_USB0PFLT 0x00071004 +#define GPIO_PH4_EPI0S10 0x00071008 +#define GPIO_PH4_SSI1CLK 0x0007100b + +// +// GPIO pin H5 +// +#define GPIO_PH5_EPI0S11 0x00071408 +#define GPIO_PH5_FAULT2 0x0007140a +#define GPIO_PH5_SSI1FSS 0x0007140b + +// +// GPIO pin H6 +// +#define GPIO_PH6_EPI0S26 0x00071808 +#define GPIO_PH6_PWM4 0x0007180a +#define GPIO_PH6_SSI1RX 0x0007180b + +// +// GPIO pin H7 +// +#define GPIO_PH7_EPI0S27 0x00071c08 +#define GPIO_PH7_PWM5 0x00071c0a +#define GPIO_PH7_SSI1TX 0x00071c0b + +// +// GPIO pin J0 +// +#define GPIO_PJ0_EPI0S16 0x00080008 +#define GPIO_PJ0_PWM0 0x0008000a +#define GPIO_PJ0_I2C1SCL 0x0008000b + +// +// GPIO pin J1 +// +#define GPIO_PJ1_EPI0S17 0x00080408 +#define GPIO_PJ1_USB0PFLT 0x00080409 +#define GPIO_PJ1_PWM1 0x0008040a +#define GPIO_PJ1_I2C1SDA 0x0008040b + +// +// GPIO pin J2 +// +#define GPIO_PJ2_EPI0S18 0x00080808 +#define GPIO_PJ2_CCP0 0x00080809 +#define GPIO_PJ2_FAULT0 0x0008080a + +// +// GPIO pin J3 +// +#define GPIO_PJ3_EPI0S19 0x00080c08 +#define GPIO_PJ3_U1CTS 0x00080c09 +#define GPIO_PJ3_CCP6 0x00080c0a + +// +// GPIO pin J4 +// +#define GPIO_PJ4_EPI0S28 0x00081008 +#define GPIO_PJ4_U1DCD 0x00081009 +#define GPIO_PJ4_CCP4 0x0008100a + +// +// GPIO pin J5 +// +#define GPIO_PJ5_EPI0S29 0x00081408 +#define GPIO_PJ5_U1DSR 0x00081409 +#define GPIO_PJ5_CCP2 0x0008140a + +// +// GPIO pin J6 +// +#define GPIO_PJ6_EPI0S30 0x00081808 +#define GPIO_PJ6_U1RTS 0x00081809 +#define GPIO_PJ6_CCP1 0x0008180a + +// +// GPIO pin J7 +// +#define GPIO_PJ7_U1DTR 0x00081c09 +#define GPIO_PJ7_CCP0 0x00081c0a + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern void GPIODirModeSet(unsigned long ulPort, unsigned char ucPins, + unsigned long ulPinIO); +extern unsigned long GPIODirModeGet(unsigned long ulPort, unsigned char ucPin); +extern void GPIOIntTypeSet(unsigned long ulPort, unsigned char ucPins, + unsigned long ulIntType); +extern unsigned long GPIOIntTypeGet(unsigned long ulPort, unsigned char ucPin); +extern void GPIOPadConfigSet(unsigned long ulPort, unsigned char ucPins, + unsigned long ulStrength, + unsigned long ulPadType); +extern void GPIOPadConfigGet(unsigned long ulPort, unsigned char ucPin, + unsigned long *pulStrength, + unsigned long *pulPadType); +extern void GPIOPinIntEnable(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinIntDisable(unsigned long ulPort, unsigned char ucPins); +extern long GPIOPinIntStatus(unsigned long ulPort, tBoolean bMasked); +extern void GPIOPinIntClear(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPortIntRegister(unsigned long ulPort, + void (*pfnIntHandler)(void)); +extern void GPIOPortIntUnregister(unsigned long ulPort); +extern long GPIOPinRead(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinWrite(unsigned long ulPort, unsigned char ucPins, + unsigned char ucVal); +extern void GPIOPinConfigure(unsigned long ulPinConfig); +extern void GPIOPinTypeADC(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeCAN(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeComparator(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeEPI(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeEthernetLED(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeGPIOInput(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeGPIOOutput(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeGPIOOutputOD(unsigned long ulPort, + unsigned char ucPins); +extern void GPIOPinTypeI2C(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeI2S(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypePWM(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeQEI(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeSSI(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeTimer(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeUART(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeUSBAnalog(unsigned long ulPort, unsigned char ucPins); +extern void GPIOPinTypeUSBDigital(unsigned long ulPort, unsigned char ucPins); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __GPIO_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/hibernate.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/hibernate.c new file mode 100644 index 00000000..2e4f858e --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/hibernate.c @@ -0,0 +1,962 @@ +//***************************************************************************** +// +// hibernate.c - Driver for the Hibernation module +// +// Copyright (c) 2007-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup hibernate_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_hibernate.h" +#include "inc/hw_ints.h" +#include "inc/hw_sysctl.h" +#include "inc/hw_types.h" +#include "driverlib/debug.h" +#include "driverlib/hibernate.h" +#include "driverlib/interrupt.h" +#include "driverlib/sysctl.h" + +//***************************************************************************** +// +// The delay in microseconds for writing to the Hibernation module registers. +// +//***************************************************************************** +#define DELAY_USECS 95 + +//***************************************************************************** +// +// The number of processor cycles to execute one pass of the delay loop. +// +//***************************************************************************** +#define LOOP_CYCLES 3 + +//***************************************************************************** +// +// The calculated number of delay loops to achieve the write delay. +// +//***************************************************************************** +static unsigned long g_ulWriteDelay; + +//***************************************************************************** +// +//! \internal +//! +//! Polls until the write complete (WRC) bit in the hibernate control register +//! is set. +//! +//! \param None. +//! +//! On non-Fury-class devices, the hibernate module provides an indication when +//! any write is completed. This is used to pace writes to the module. This +//! function merely polls this bit and returns as soon as it is set. At this +//! point, it is safe to perform another write to the module. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateWriteComplete(void) +{ + // + // Spin until the write complete bit is set. + // + while(!(HWREG(HIB_CTL) & HIB_CTL_WRC)) + { + } +} + +//***************************************************************************** +// +//! Enables the Hibernation module for operation. +//! +//! \param ulHibClk is the rate of the clock supplied to the Hibernation +//! module. +//! +//! Enables the Hibernation module for operation. This function should be +//! called before any of the Hibernation module features are used. +//! +//! The peripheral clock will be the same as the processor clock. This will be +//! the value returned by SysCtlClockGet(), or it can be explicitly hard-coded +//! if it is constant and known (to save the code/execution overhead of a call +//! to SysCtlClockGet()). +//! +//! This function replaces the original HibernateEnable() API and performs the +//! same actions. A macro is provided in hibernate.h to map the +//! original API to this API. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateEnableExpClk(unsigned long ulHibClk) +{ + // + // Turn on the clock enable bit. + // + HWREG(HIB_CTL) |= HIB_CTL_CLK32EN; + + // + // For Fury-class devices, compute the number of delay loops that must be + // used to achieve the desired delay for writes to the hibernation + // registers. This value will be used in calls to SysCtlDelay(). + // + if(CLASS_IS_FURY) + { + g_ulWriteDelay = (((ulHibClk / 1000) * DELAY_USECS) / + (1000L * LOOP_CYCLES)); + g_ulWriteDelay++; + } +} + +//***************************************************************************** +// +//! Disables the Hibernation module for operation. +//! +//! Disables the Hibernation module for operation. After this function is +//! called, none of the Hibernation module features are available. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateDisable(void) +{ + // + // Turn off the clock enable bit. + // + HWREG(HIB_CTL) &= ~HIB_CTL_CLK32EN; +} + +//***************************************************************************** +// +//! Selects the clock input for the Hibernation module. +//! +//! \param ulClockInput specifies the clock input. +//! +//! Configures the clock input for the Hibernation module. The configuration +//! option chosen depends entirely on hardware design. The clock input for the +//! module will either be a 32.768 kHz oscillator or a 4.194304 MHz crystal. +//! The \e ulClockFlags parameter must be one of the following: +//! +//! - \b HIBERNATE_CLOCK_SEL_RAW - use the raw signal from a 32.768 kHz +//! oscillator. +//! - \b HIBERNATE_CLOCK_SEL_DIV128 - use the crystal input, divided by 128. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateClockSelect(unsigned long ulClockInput) +{ + // + // Check the arguments. + // + ASSERT((ulClockInput == HIBERNATE_CLOCK_SEL_RAW) || + (ulClockInput == HIBERNATE_CLOCK_SEL_DIV128)); + + // + // Set the clock selection bit according to the parameter. + // + HWREG(HIB_CTL) = ulClockInput | (HWREG(HIB_CTL) & ~HIB_CTL_CLKSEL); +} + +//***************************************************************************** +// +//! Enables the RTC feature of the Hibernation module. +//! +//! Enables the RTC in the Hibernation module. The RTC can be used to wake the +//! processor from hibernation at a certain time, or to generate interrupts at +//! certain times. This function must be called before using any of the RTC +//! features of the Hibernation module. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateRTCEnable(void) +{ + // + // Turn on the RTC enable bit. + // + HWREG(HIB_CTL) |= HIB_CTL_RTCEN; +} + +//***************************************************************************** +// +//! Disables the RTC feature of the Hibernation module. +//! +//! Disables the RTC in the Hibernation module. After calling this function +//! the RTC features of the Hibernation module will not be available. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateRTCDisable(void) +{ + // + // Turn off the RTC enable bit. + // + HWREG(HIB_CTL) &= ~HIB_CTL_RTCEN; +} + +//***************************************************************************** +// +//! Configures the wake conditions for the Hibernation module. +//! +//! \param ulWakeFlags specifies which conditions should be used for waking. +//! +//! Enables the conditions under which the Hibernation module will wake. The +//! \e ulWakeFlags parameter is the logical OR of any combination of the +//! following: +//! +//! - \b HIBERNATE_WAKE_PIN - wake when the external wake pin is asserted. +//! - \b HIBERNATE_WAKE_RTC - wake when one of the RTC matches occurs. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateWakeSet(unsigned long ulWakeFlags) +{ + // + // Check the arguments. + // + ASSERT(!(ulWakeFlags & ~(HIBERNATE_WAKE_PIN | HIBERNATE_WAKE_RTC))); + + // + // Set the specified wake flags in the control register. + // + HWREG(HIB_CTL) = (ulWakeFlags | + (HWREG(HIB_CTL) & + ~(HIBERNATE_WAKE_PIN | HIBERNATE_WAKE_RTC))); +} + +//***************************************************************************** +// +//! Gets the currently configured wake conditions for the Hibernation module. +//! +//! Returns the flags representing the wake configuration for the Hibernation +//! module. The return value will be a combination of the following flags: +//! +//! - \b HIBERNATE_WAKE_PIN - wake when the external wake pin is asserted. +//! - \b HIBERNATE_WAKE_RTC - wake when one of the RTC matches occurs. +//! +//! \return Returns flags indicating the configured wake conditions. +// +//***************************************************************************** +unsigned long +HibernateWakeGet(void) +{ + // + // Read the wake bits from the control register and return + // those bits to the caller. + // + return(HWREG(HIB_CTL) & (HIBERNATE_WAKE_PIN | HIBERNATE_WAKE_RTC)); +} + +//***************************************************************************** +// +//! Configures the low battery detection. +//! +//! \param ulLowBatFlags specifies behavior of low battery detection. +//! +//! Enables the low battery detection and whether hibernation is allowed if a +//! low battery is detected. If low battery detection is enabled, then a low +//! battery condition will be indicated in the raw interrupt status register, +//! and can also trigger an interrupt. Optionally, hibernation can be aborted +//! if a low battery is detected. +//! +//! The \e ulLowBatFlags parameter is one of the following values: +//! +//! - \b HIBERNATE_LOW_BAT_DETECT - detect a low battery condition. +//! - \b HIBERNATE_LOW_BAT_ABORT - detect a low battery condition, and abort +//! hibernation if low battery is detected. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateLowBatSet(unsigned long ulLowBatFlags) +{ + // + // Check the arguments. + // + ASSERT((ulLowBatFlags == HIBERNATE_LOW_BAT_DETECT) || + (ulLowBatFlags == HIBERNATE_LOW_BAT_ABORT)); + + // + // Set the low battery detect and abort bits in the control register, + // according to the parameter. + // + HWREG(HIB_CTL) = (ulLowBatFlags | + (HWREG(HIB_CTL) & ~HIBERNATE_LOW_BAT_ABORT)); +} + +//***************************************************************************** +// +//! Gets the currently configured low battery detection behavior. +//! +//! Returns a value representing the currently configured low battery detection +//! behavior. The return value will be one of the following: +//! +//! - \b HIBERNATE_LOW_BAT_DETECT - detect a low battery condition. +//! - \b HIBERNATE_LOW_BAT_ABORT - detect a low battery condition, and abort +//! hibernation if low battery is detected. +//! +//! \return Returns a value indicating the configured low battery detection. +// +//***************************************************************************** +unsigned long +HibernateLowBatGet(void) +{ + // + // Read the low bat bits from the control register and return those bits to + // the caller. + // + return(HWREG(HIB_CTL) & HIBERNATE_LOW_BAT_ABORT); +} + +//***************************************************************************** +// +//! Sets the value of the real time clock (RTC) counter. +//! +//! \param ulRTCValue is the new value for the RTC. +//! +//! Sets the value of the RTC. The RTC will count seconds if the hardware is +//! configured correctly. The RTC must be enabled by calling +//! HibernateRTCEnable() before calling this function. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateRTCSet(unsigned long ulRTCValue) +{ + // + // Write the new RTC value to the RTC load register. + // + HWREG(HIB_RTCLD) = ulRTCValue; + + // + // Add a delay here to enforce the required delay between write accesses to + // certain Hibernation module registers. + // + if(CLASS_IS_FURY) + { + // + // Delay a fixed time on Fury-class devices + // + SysCtlDelay(g_ulWriteDelay); + } + else + { + // + // Wait for write complete to be signaled on later devices. + // + HibernateWriteComplete(); + } +} + +//***************************************************************************** +// +//! Gets the value of the real time clock (RTC) counter. +//! +//! Gets the value of the RTC and returns it to the caller. +//! +//! \return Returns the value of the RTC. +// +//***************************************************************************** +unsigned long +HibernateRTCGet(void) +{ + // + // Return the value of the RTC counter register to the caller. + // + return(HWREG(HIB_RTCC)); +} + +//***************************************************************************** +// +//! Sets the value of the RTC match 0 register. +//! +//! \param ulMatch is the value for the match register. +//! +//! Sets the match 0 register for the RTC. The Hibernation module can be +//! configured to wake from hibernation, and/or generate an interrupt when the +//! value of the RTC counter is the same as the match register. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateRTCMatch0Set(unsigned long ulMatch) +{ + // + // Write the new match value to the match register. + // + HWREG(HIB_RTCM0) = ulMatch; + + // + // Add a delay here to enforce the required delay between write accesses to + // certain Hibernation module registers. + // + if(CLASS_IS_FURY) + { + // + // Delay a fixed time on Fury-class devices + // + SysCtlDelay(g_ulWriteDelay); + } + else + { + // + // Wait for write complete to be signaled on later devices. + // + HibernateWriteComplete(); + } +} + +//***************************************************************************** +// +//! Gets the value of the RTC match 0 register. +//! +//! Gets the value of the match 0 register for the RTC. +//! +//! \return Returns the value of the match register. +// +//***************************************************************************** +unsigned long +HibernateRTCMatch0Get(void) +{ + // + // Return the value of the match register to the caller. + // + return(HWREG(HIB_RTCM0)); +} + +//***************************************************************************** +// +//! Sets the value of the RTC match 1 register. +//! +//! \param ulMatch is the value for the match register. +//! +//! Sets the match 1 register for the RTC. The Hibernation module can be +//! configured to wake from hibernation, and/or generate an interrupt when the +//! value of the RTC counter is the same as the match register. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateRTCMatch1Set(unsigned long ulMatch) +{ + // + // Write the new match value to the match register. + // + HWREG(HIB_RTCM1) = ulMatch; + + // + // Add a delay here to enforce the required delay between write accesses to + // certain Hibernation module registers. + // + if(CLASS_IS_FURY) + { + // + // Delay a fixed time on Fury-class devices + // + SysCtlDelay(g_ulWriteDelay); + } + else + { + // + // Wait for write complete to be signaled on later devices. + // + HibernateWriteComplete(); + } +} + +//***************************************************************************** +// +//! Gets the value of the RTC match 1 register. +//! +//! Gets the value of the match 1 register for the RTC. +//! +//! \return Returns the value of the match register. +// +//***************************************************************************** +unsigned long +HibernateRTCMatch1Get(void) +{ + // + // Return the value of the match register to the caller. + // + return(HWREG(HIB_RTCM1)); +} + +//***************************************************************************** +// +//! Sets the value of the RTC predivider trim register. +//! +//! \param ulTrim is the new value for the pre-divider trim register. +//! +//! Sets the value of the pre-divider trim register. The input time source is +//! divided by the pre-divider to achieve a one-second clock rate. Once every +//! 64 seconds, the value of the pre-divider trim register is applied to the +//! predivider to allow fine-tuning of the RTC rate, in order to make +//! corrections to the rate. The software application can make adjustments to +//! the predivider trim register to account for variations in the accuracy of +//! the input time source. The nominal value is 0x7FFF, and it can be adjusted +//! up or down in order to fine-tune the RTC rate. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateRTCTrimSet(unsigned long ulTrim) +{ + // + // Check the arguments. + // + ASSERT(ulTrim < 0x10000); + + // + // Write the new trim value to the trim register. + // + HWREG(HIB_RTCT) = ulTrim; + + // + // Add a delay here to enforce the required delay between write accesses to + // certain Hibernation module registers. + // + if(CLASS_IS_FURY) + { + // + // Delay a fixed time on Fury-class devices + // + SysCtlDelay(g_ulWriteDelay); + } + else + { + // + // Wait for write complete to be signaled on later devices. + // + HibernateWriteComplete(); + } +} + +//***************************************************************************** +// +//! Gets the value of the RTC predivider trim register. +//! +//! Gets the value of the pre-divider trim register. This function can be used +//! to get the current value of the trim register prior to making an adjustment +//! by using the HibernateRTCTrimSet() function. +//! +//! \return None. +// +//***************************************************************************** +unsigned long +HibernateRTCTrimGet(void) +{ + // + // Return the value of the trim register to the caller. + // + return(HWREG(HIB_RTCT)); +} + +//***************************************************************************** +// +//! Stores data in the non-volatile memory of the Hibernation module. +//! +//! \param pulData points to the data that the caller wants to store in the +//! memory of the Hibernation module. +//! \param ulCount is the count of 32-bit words to store. +//! +//! Stores a set of data in the Hibernation module non-volatile memory. This +//! memory will be preserved when the power to the processor is turned off, and +//! can be used to store application state information which will be available +//! when the processor wakes. Up to 64 32-bit words can be stored in the +//! non-volatile memory. The data can be restored by calling the +//! HibernateDataGet() function. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateDataSet(unsigned long *pulData, unsigned long ulCount) +{ + unsigned int uIdx; + + // + // Check the arguments. + // + ASSERT(ulCount <= 64); + ASSERT(pulData != 0); + + // + // Loop through all the words to be stored, storing one at a time. + // + for(uIdx = 0; uIdx < ulCount; uIdx++) + { + // + // Write a word to the non-volatile storage area. + // + HWREG(HIB_DATA + (uIdx * 4)) = pulData[uIdx]; + + // + // Add a delay between writes to the data area. + // + if(CLASS_IS_FURY) + { + // + // Delay a fixed time on Fury-class devices + // + SysCtlDelay(g_ulWriteDelay); + } + else + { + // + // Wait for write complete to be signaled on later devices. + // + HibernateWriteComplete(); + } + } +} + +//***************************************************************************** +// +//! Reads a set of data from the non-volatile memory of the Hibernation module. +//! +//! \param pulData points to a location where the data that is read from the +//! Hibernation module will be stored. +//! \param ulCount is the count of 32-bit words to read. +//! +//! Retrieves a set of data from the Hibernation module non-volatile memory +//! that was previously stored with the HibernateDataSet() function. The +//! caller must ensure that \e pulData points to a large enough memory block to +//! hold all the data that is read from the non-volatile memory. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateDataGet(unsigned long *pulData, unsigned long ulCount) +{ + unsigned int uIdx; + + // + // Check the arguments. + // + ASSERT(ulCount <= 64); + ASSERT(pulData != 0); + + // + // Loop through all the words to be restored, reading one at a time. + // + for(uIdx = 0; uIdx < ulCount; uIdx++) + { + // + // Read a word from the non-volatile storage area. No delay is + // required between reads. + // + pulData[uIdx] = HWREG(HIB_DATA + (uIdx * 4)); + } +} + +//***************************************************************************** +// +//! Requests hibernation mode. +//! +//! This function requests the Hibernation module to disable the external +//! regulator, thus removing power from the processor and all peripherals. The +//! Hibernation module will remain powered from the battery or auxiliary power +//! supply. +//! +//! The Hibernation module will re-enable the external regulator when one of +//! the configured wake conditions occurs (such as RTC match or external +//! \b WAKE pin). When the power is restored the processor will go through a +//! normal power-on reset. The processor can retrieve saved state information +//! with the HibernateDataGet() function. Prior to calling the function to +//! request hibernation mode, the conditions for waking must have already been +//! set by using the HibernateWakeSet() function. +//! +//! Note that this function may return because some time may elapse before the +//! power is actually removed, or it may not be removed at all. For this +//! reason, the processor will continue to execute instructions for some time +//! and the caller should be prepared for this function to return. There are +//! various reasons why the power may not be removed. For example, if the +//! HibernateLowBatSet() function was used to configure an abort if low +//! battery is detected, then the power will not be removed if the battery +//! voltage is too low. There may be other reasons, related to the external +//! circuit design, that a request for hibernation may not actually occur. +//! +//! For all these reasons, the caller must be prepared for this function to +//! return. The simplest way to handle it is to just enter an infinite loop +//! and wait for the power to be removed. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateRequest(void) +{ + // + // Set the bit in the control register to cut main power to the processor. + // + HWREG(HIB_CTL) |= HIB_CTL_HIBREQ; +} + +//***************************************************************************** +// +//! Enables interrupts for the Hibernation module. +//! +//! \param ulIntFlags is the bit mask of the interrupts to be enabled. +//! +//! Enables the specified interrupt sources from the Hibernation module. +//! +//! The \e ulIntFlags parameter must be the logical OR of any combination of +//! the following: +//! +//! - \b HIBERNATE_INT_PIN_WAKE - wake from pin interrupt +//! - \b HIBERNATE_INT_LOW_BAT - low battery interrupt +//! - \b HIBERNATE_INT_RTC_MATCH_0 - RTC match 0 interrupt +//! - \b HIBERNATE_INT_RTC_MATCH_1 - RTC match 1 interrupt +//! +//! \return None. +// +//***************************************************************************** +void +HibernateIntEnable(unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(!(ulIntFlags & ~(HIBERNATE_INT_PIN_WAKE | HIBERNATE_INT_LOW_BAT | + HIBERNATE_INT_RTC_MATCH_0 | + HIBERNATE_INT_RTC_MATCH_1))); + + // + // Set the specified interrupt mask bits. + // + HWREG(HIB_IM) |= ulIntFlags; +} + +//***************************************************************************** +// +//! Disables interrupts for the Hibernation module. +//! +//! \param ulIntFlags is the bit mask of the interrupts to be disabled. +//! +//! Disables the specified interrupt sources from the Hibernation module. +//! +//! The \e ulIntFlags parameter has the same definition as the \e ulIntFlags +//! parameter to the HibernateIntEnable() function. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateIntDisable(unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(!(ulIntFlags & ~(HIBERNATE_INT_PIN_WAKE | HIBERNATE_INT_LOW_BAT | + HIBERNATE_INT_RTC_MATCH_0 | + HIBERNATE_INT_RTC_MATCH_1))); + + // + // Clear the specified interrupt mask bits. + // + HWREG(HIB_IM) &= ~ulIntFlags; +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the Hibernation module interrupt. +//! +//! \param pfnHandler points to the function to be called when a hibernation +//! interrupt occurs. +//! +//! Registers the interrupt handler in the system interrupt controller. The +//! interrupt is enabled at the global level, but individual interrupt sources +//! must still be enabled with a call to HibernateIntEnable(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateIntRegister(void (*pfnHandler)(void)) +{ + // + // Register the interrupt handler. + // + IntRegister(INT_HIBERNATE, pfnHandler); + + // + // Enable the hibernate module interrupt. + // + IntEnable(INT_HIBERNATE); +} + +//***************************************************************************** +// +//! Unregisters an interrupt handler for the Hibernation module interrupt. +//! +//! Unregisters the interrupt handler in the system interrupt controller. The +//! interrupt is disabled at the global level, and the interrupt handler will +//! no longer be called. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +HibernateIntUnregister(void) +{ + // + // Disable the hibernate interrupt. + // + IntDisable(INT_HIBERNATE); + + // + // Unregister the interrupt handler. + // + IntUnregister(INT_HIBERNATE); +} + +//***************************************************************************** +// +//! Gets the current interrupt status of the Hibernation module. +//! +//! \param bMasked is false to retrieve the raw interrupt status, and true to +//! retrieve the masked interrupt status. +//! +//! Returns the interrupt status of the Hibernation module. The caller can use +//! this to determine the cause of a hibernation interrupt. Either the masked +//! or raw interrupt status can be returned. +//! +//! \return Returns the interrupt status as a bit field with the values as +//! described in the HibernateIntEnable() function. +// +//***************************************************************************** +unsigned long +HibernateIntStatus(tBoolean bMasked) +{ + // + // Read and return the Hibernation module raw or masked interrupt status. + // + if(bMasked == true) + { + return(HWREG(HIB_MIS) & 0xf); + } + else + { + return(HWREG(HIB_RIS) & 0xf); + } +} + +//***************************************************************************** +// +//! Clears pending interrupts from the Hibernation module. +//! +//! \param ulIntFlags is the bit mask of the interrupts to be cleared. +//! +//! Clears the specified interrupt sources. This must be done from within the +//! interrupt handler or else the handler will be called again upon exit. +//! +//! The \e ulIntFlags parameter has the same definition as the \e ulIntFlags +//! parameter to the HibernateIntEnable() function. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +HibernateIntClear(unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(!(ulIntFlags & ~(HIBERNATE_INT_PIN_WAKE | HIBERNATE_INT_LOW_BAT | + HIBERNATE_INT_RTC_MATCH_0 | + HIBERNATE_INT_RTC_MATCH_1))); + + // + // Write the specified interrupt bits into the interrupt clear register. + // + HWREG(HIB_IC) |= ulIntFlags; +} + +//***************************************************************************** +// +//! Checks to see if the Hibernation module is already powered up. +//! +//! This function queries the control register to determine if the module is +//! already active. This function can be called at a power-on reset to help +//! determine if the reset is due to a wake from hibernation or a cold start. +//! If the Hibernation module is already active, then it does not need to be +//! re-enabled and its status can be queried immediately. +//! +//! The software application should also use the HibernateIntStatus() function +//! to read the raw interrupt status to determine the cause of the wake. The +//! HibernateDataGet() function can be used to restore state. These +//! combinations of functions can be used by the software to determine if the +//! processor is waking from hibernation and the appropriate action to take as +//! a result. +//! +//! \return Returns \b true if the module is already active, and \b false if +//! not. +// +//***************************************************************************** +unsigned int +HibernateIsActive(void) +{ + // + // Read the control register, and return true if the module is enabled. + // + return(HWREG(HIB_CTL) & HIB_CTL_CLK32EN ? 1 : 0); +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/hibernate.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/hibernate.h new file mode 100644 index 00000000..b5df6f2b --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/hibernate.h @@ -0,0 +1,127 @@ +//***************************************************************************** +// +// hibernate.h - API definition for the Hibernation module. +// +// Copyright (c) 2007-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __HIBERNATE_H__ +#define __HIBERNATE_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Macros needed for selecting the clock source for HibernateClockSelect() +// +//***************************************************************************** +#define HIBERNATE_CLOCK_SEL_RAW 0x04 +#define HIBERNATE_CLOCK_SEL_DIV128 0x00 + +//***************************************************************************** +// +// Macros need to configure wake events for HibernateWakeSet() +// +//***************************************************************************** +#define HIBERNATE_WAKE_PIN 0x10 +#define HIBERNATE_WAKE_RTC 0x08 + +//***************************************************************************** +// +// Macros needed to configure low battery detect for HibernateLowBatSet() +// +//***************************************************************************** +#define HIBERNATE_LOW_BAT_DETECT 0x20 +#define HIBERNATE_LOW_BAT_ABORT 0xA0 + +//***************************************************************************** +// +// Macros defining interrupt source bits for the interrupt functions. +// +//***************************************************************************** +#define HIBERNATE_INT_PIN_WAKE 0x08 +#define HIBERNATE_INT_LOW_BAT 0x04 +#define HIBERNATE_INT_RTC_MATCH_0 0x01 +#define HIBERNATE_INT_RTC_MATCH_1 0x02 + +//***************************************************************************** +// +// API Function prototypes +// +//***************************************************************************** +extern void HibernateEnableExpClk(unsigned long ulHibClk); +extern void HibernateDisable(void); +extern void HibernateClockSelect(unsigned long ulClockInput); +extern void HibernateRTCEnable(void); +extern void HibernateRTCDisable(void); +extern void HibernateWakeSet(unsigned long ulWakeFlags); +extern unsigned long HibernateWakeGet(void); +extern void HibernateLowBatSet(unsigned long ulLowBatFlags); +extern unsigned long HibernateLowBatGet(void); +extern void HibernateRTCSet(unsigned long ulRTCValue); +extern unsigned long HibernateRTCGet(void); +extern void HibernateRTCMatch0Set(unsigned long ulMatch); +extern unsigned long HibernateRTCMatch0Get(void); +extern void HibernateRTCMatch1Set(unsigned long ulMatch); +extern unsigned long HibernateRTCMatch1Get(void); +extern void HibernateRTCTrimSet(unsigned long ulTrim); +extern unsigned long HibernateRTCTrimGet(void); +extern void HibernateDataSet(unsigned long *pulData, unsigned long ulCount); +extern void HibernateDataGet(unsigned long *pulData, unsigned long ulCount); +extern void HibernateRequest(void); +extern void HibernateIntEnable(unsigned long ulIntFlags); +extern void HibernateIntDisable(unsigned long ulIntFlags); +extern void HibernateIntRegister(void (*pfnHandler)(void)); +extern void HibernateIntUnregister(void); +extern unsigned long HibernateIntStatus(tBoolean bMasked); +extern void HibernateIntClear(unsigned long ulIntFlags); +extern unsigned int HibernateIsActive(void); + +//***************************************************************************** +// +// Several Hibernate module APIs have been renamed, with the original function +// name being deprecated. These defines provide backward compatibility. +// +//***************************************************************************** +#ifndef DEPRECATED +#include "driverlib/sysctl.h" +#define HibernateEnable(a) \ + HibernateEnableExpClk(a, SysCtlClockGet()) +#endif + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __HIBERNATE_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2c.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2c.c new file mode 100644 index 00000000..ed9ef655 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2c.c @@ -0,0 +1,1106 @@ +//***************************************************************************** +// +// i2c.c - Driver for Inter-IC (I2C) bus block. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup i2c_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_i2c.h" +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_sysctl.h" +#include "inc/hw_types.h" +#include "driverlib/debug.h" +#include "driverlib/i2c.h" +#include "driverlib/interrupt.h" + +//***************************************************************************** +// +//! Initializes the I2C Master block. +//! +//! \param ulBase is the base address of the I2C Master module. +//! \param ulI2CClk is the rate of the clock supplied to the I2C module. +//! \param bFast set up for fast data transfers +//! +//! This function initializes operation of the I2C Master block. Upon +//! successful initialization of the I2C block, this function will have set the +//! bus speed for the master, and will have enabled the I2C Master block. +//! +//! If the parameter \e bFast is \b true, then the master block will be set up +//! to transfer data at 400 kbps; otherwise, it will be set up to transfer data +//! at 100 kbps. +//! +//! The peripheral clock will be the same as the processor clock. This will be +//! the value returned by SysCtlClockGet(), or it can be explicitly hard coded +//! if it is constant and known (to save the code/execution overhead of a call +//! to SysCtlClockGet()). +//! +//! This function replaces the original I2CMasterInit() API and performs the +//! same actions. A macro is provided in i2c.h to map the original +//! API to this API. +//! +//! \return None. +// +//***************************************************************************** +void +I2CMasterInitExpClk(unsigned long ulBase, unsigned long ulI2CClk, + tBoolean bFast) +{ + unsigned long ulSCLFreq; + unsigned long ulTPR; + + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + + // + // Must enable the device before doing anything else. + // + I2CMasterEnable(ulBase); + + // + // Get the desired SCL speed. + // + if(bFast == true) + { + ulSCLFreq = 400000; + } + else + { + ulSCLFreq = 100000; + } + + // + // Compute the clock divider that achieves the fastest speed less than or + // equal to the desired speed. The numerator is biased to favor a larger + // clock divider so that the resulting clock is always less than or equal + // to the desired clock, never greater. + // + ulTPR = ((ulI2CClk + (2 * 10 * ulSCLFreq) - 1) / (2 * 10 * ulSCLFreq)) - 1; + HWREG(ulBase + I2C_O_MTPR) = ulTPR; +} + +//***************************************************************************** +// +//! Initializes the I2C Slave block. +//! +//! \param ulBase is the base address of the I2C Slave module. +//! \param ucSlaveAddr 7-bit slave address +//! +//! This function initializes operation of the I2C Slave block. Upon +//! successful initialization of the I2C blocks, this function will have set +//! the slave address and have enabled the I2C Slave block. +//! +//! The parameter \e ucSlaveAddr is the value that will be compared against the +//! slave address sent by an I2C master. +//! +//! \return None. +// +//***************************************************************************** +void +I2CSlaveInit(unsigned long ulBase, unsigned char ucSlaveAddr) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_SLAVE_BASE) || (ulBase == I2C1_SLAVE_BASE)); + ASSERT(!(ucSlaveAddr & 0x80)); + + // + // Must enable the device before doing anything else. + // + I2CSlaveEnable(ulBase); + + // + // Set up the slave address. + // + HWREG(ulBase + I2C_O_SOAR) = ucSlaveAddr; +} + +//***************************************************************************** +// +//! Enables the I2C Master block. +//! +//! \param ulBase is the base address of the I2C Master module. +//! +//! This will enable operation of the I2C Master block. +//! +//! \return None. +// +//***************************************************************************** +void +I2CMasterEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + + // + // Enable the master block. + // + HWREG(ulBase + I2C_O_MCR) |= I2C_MCR_MFE; +} + +//***************************************************************************** +// +//! Enables the I2C Slave block. +//! +//! \param ulBase is the base address of the I2C Slave module. +//! +//! This will enable operation of the I2C Slave block. +//! +//! \return None. +// +//***************************************************************************** +void +I2CSlaveEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_SLAVE_BASE) || (ulBase == I2C1_SLAVE_BASE)); + + // + // Enable the clock to the slave block. + // + HWREG(ulBase - I2C0_SLAVE_BASE + I2C0_MASTER_BASE + I2C_O_MCR) |= + I2C_MCR_SFE; + + // + // Enable the slave. + // + HWREG(ulBase + I2C_O_SCSR) = I2C_SCSR_DA; +} + +//***************************************************************************** +// +//! Disables the I2C master block. +//! +//! \param ulBase is the base address of the I2C Master module. +//! +//! This will disable operation of the I2C master block. +//! +//! \return None. +// +//***************************************************************************** +void +I2CMasterDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + + // + // Disable the master block. + // + HWREG(ulBase + I2C_O_MCR) &= ~(I2C_MCR_MFE); +} + +//***************************************************************************** +// +//! Disables the I2C slave block. +//! +//! \param ulBase is the base address of the I2C Slave module. +//! +//! This will disable operation of the I2C slave block. +//! +//! \return None. +// +//***************************************************************************** +void +I2CSlaveDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_SLAVE_BASE) || (ulBase == I2C1_SLAVE_BASE)); + + // + // Disable the slave. + // + HWREG(ulBase + I2C_O_SCSR) = 0; + + // + // Disable the clock to the slave block. + // + HWREG(ulBase - I2C0_SLAVE_BASE + I2C0_MASTER_BASE + I2C_O_MCR) &= + ~(I2C_MCR_SFE); +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the I2C module. +//! +//! \param ulBase is the base address of the I2C Master module. +//! \param pfnHandler is a pointer to the function to be called when the +//! I2C interrupt occurs. +//! +//! This sets the handler to be called when an I2C interrupt occurs. This will +//! enable the global interrupt in the interrupt controller; specific I2C +//! interrupts must be enabled via I2CMasterIntEnable() and +//! I2CSlaveIntEnable(). If necessary, it is the interrupt handler's +//! responsibility to clear the interrupt source via I2CMasterIntClear() and +//! I2CSlaveIntClear(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +I2CIntRegister(unsigned long ulBase, void (*pfnHandler)(void)) +{ + unsigned long ulInt; + + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + + // + // Determine the interrupt number based on the I2C port. + // + ulInt = (ulBase == I2C0_MASTER_BASE) ? INT_I2C0 : INT_I2C1; + + // + // Register the interrupt handler, returning an error if an error occurs. + // + IntRegister(ulInt, pfnHandler); + + // + // Enable the I2C interrupt. + // + IntEnable(ulInt); +} + +//***************************************************************************** +// +//! Unregisters an interrupt handler for the I2C module. +//! +//! \param ulBase is the base address of the I2C Master module. +//! +//! This function will clear the handler to be called when an I2C interrupt +//! occurs. This will also mask off the interrupt in the interrupt controller +//! so that the interrupt handler no longer is called. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +I2CIntUnregister(unsigned long ulBase) +{ + unsigned long ulInt; + + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + + // + // Determine the interrupt number based on the I2C port. + // + ulInt = (ulBase == I2C0_MASTER_BASE) ? INT_I2C0 : INT_I2C1; + + // + // Disable the interrupt. + // + IntDisable(ulInt); + + // + // Unregister the interrupt handler. + // + IntUnregister(ulInt); +} + +//***************************************************************************** +// +//! Enables the I2C Master interrupt. +//! +//! \param ulBase is the base address of the I2C Master module. +//! +//! Enables the I2C Master interrupt source. +//! +//! \return None. +// +//***************************************************************************** +void +I2CMasterIntEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + + // + // Enable the master interrupt. + // + HWREG(ulBase + I2C_O_MIMR) = 1; +} + +//***************************************************************************** +// +//! Enables the I2C Slave interrupt. +//! +//! \param ulBase is the base address of the I2C Slave module. +//! +//! Enables the I2C Slave interrupt source. +//! +//! \return None. +// +//***************************************************************************** +void +I2CSlaveIntEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_SLAVE_BASE) || (ulBase == I2C1_SLAVE_BASE)); + + // + // Enable the slave interrupt. + // + HWREG(ulBase + I2C_O_SIMR) |= I2C_SLAVE_INT_DATA; +} + +//***************************************************************************** +// +//! Enables individual I2C Slave interrupt sources. +//! +//! \param ulBase is the base address of the I2C Slave module. +//! \param ulIntFlags is the bit mask of the interrupt sources to be enabled. +//! +//! Enables the indicated I2C Slave interrupt sources. Only the sources that +//! are enabled can be reflected to the processor interrupt; disabled sources +//! have no effect on the processor. +//! +//! The \e ulIntFlags parameter is the logical OR of any of the following: +//! +//! - \b I2C_SLAVE_INT_STOP - Stop condition detected interrupt +//! - \b I2C_SLAVE_INT_START - Start condition detected interrupt +//! - \b I2C_SLAVE_INT_DATA - Data interrupt +//! +//! \return None. +// +//***************************************************************************** +void +I2CSlaveIntEnableEx(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_SLAVE_BASE) || (ulBase == I2C1_SLAVE_BASE)); + + // + // Enable the slave interrupt. + // + HWREG(ulBase + I2C_O_SIMR) |= ulIntFlags; +} + +//***************************************************************************** +// +//! Disables the I2C Master interrupt. +//! +//! \param ulBase is the base address of the I2C Master module. +//! +//! Disables the I2C Master interrupt source. +//! +//! \return None. +// +//***************************************************************************** +void +I2CMasterIntDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + + // + // Disable the master interrupt. + // + HWREG(ulBase + I2C_O_MIMR) = 0; +} + +//***************************************************************************** +// +//! Disables the I2C Slave interrupt. +//! +//! \param ulBase is the base address of the I2C Slave module. +//! +//! Disables the I2C Slave interrupt source. +//! +//! \return None. +// +//***************************************************************************** +void +I2CSlaveIntDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_SLAVE_BASE) || (ulBase == I2C1_SLAVE_BASE)); + + // + // Disable the slave interrupt. + // + HWREG(ulBase + I2C_O_SIMR) &= ~I2C_SLAVE_INT_DATA; +} + +//***************************************************************************** +// +//! Disables individual I2C Slave interrupt sources. +//! +//! \param ulBase is the base address of the I2C Slave module. +//! \param ulIntFlags is the bit mask of the interrupt sources to be disabled. +//! +//! Disables the indicated I2C Slave interrupt sources. Only the sources that +//! are enabled can be reflected to the processor interrupt; disabled sources +//! have no effect on the processor. +//! +//! The \e ulIntFlags parameter has the same definition as the \e ulIntFlags +//! parameter to I2CSlaveIntEnableEx(). +//! +//! \return None. +// +//***************************************************************************** +void +I2CSlaveIntDisableEx(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_SLAVE_BASE) || (ulBase == I2C1_SLAVE_BASE)); + + // + // Disable the slave interrupt. + // + HWREG(ulBase + I2C_O_SIMR) &= ~ulIntFlags; +} + +//***************************************************************************** +// +//! Gets the current I2C Master interrupt status. +//! +//! \param ulBase is the base address of the I2C Master module. +//! \param bMasked is false if the raw interrupt status is requested and +//! true if the masked interrupt status is requested. +//! +//! This returns the interrupt status for the I2C Master module. Either the +//! raw interrupt status or the status of interrupts that are allowed to +//! reflect to the processor can be returned. +//! +//! \return The current interrupt status, returned as \b true if active +//! or \b false if not active. +// +//***************************************************************************** +tBoolean +I2CMasterIntStatus(unsigned long ulBase, tBoolean bMasked) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + return((HWREG(ulBase + I2C_O_MMIS)) ? true : false); + } + else + { + return((HWREG(ulBase + I2C_O_MRIS)) ? true : false); + } +} + +//***************************************************************************** +// +//! Gets the current I2C Slave interrupt status. +//! +//! \param ulBase is the base address of the I2C Slave module. +//! \param bMasked is false if the raw interrupt status is requested and +//! true if the masked interrupt status is requested. +//! +//! This returns the interrupt status for the I2C Slave module. Either the raw +//! interrupt status or the status of interrupts that are allowed to reflect to +//! the processor can be returned. +//! +//! \return The current interrupt status, returned as \b true if active +//! or \b false if not active. +// +//***************************************************************************** +tBoolean +I2CSlaveIntStatus(unsigned long ulBase, tBoolean bMasked) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_SLAVE_BASE) || (ulBase == I2C1_SLAVE_BASE)); + + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + return((HWREG(ulBase + I2C_O_SMIS)) ? true : false); + } + else + { + return((HWREG(ulBase + I2C_O_SRIS)) ? true : false); + } +} + +//***************************************************************************** +// +//! Gets the current I2C Slave interrupt status. +//! +//! \param ulBase is the base address of the I2C Slave module. +//! \param bMasked is false if the raw interrupt status is requested and +//! true if the masked interrupt status is requested. +//! +//! This returns the interrupt status for the I2C Slave module. Either the raw +//! interrupt status or the status of interrupts that are allowed to reflect to +//! the processor can be returned. +//! +//! \return Returns the current interrupt status, enumerated as a bit field of +//! values described in I2CSlaveIntEnableEx(). +// +//***************************************************************************** +unsigned long +I2CSlaveIntStatusEx(unsigned long ulBase, tBoolean bMasked) +{ + unsigned long ulValue; + + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_SLAVE_BASE) || (ulBase == I2C1_SLAVE_BASE)); + + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + // + // Workaround for I2C slave masked interrupt status register errata + // (7.1) for Dustdevil Rev A0 devices. + // + if(CLASS_IS_DUSTDEVIL && REVISION_IS_A0) + { + ulValue = HWREG(ulBase + I2C_O_SRIS); + return(ulValue & HWREG(ulBase + I2C_O_SIMR)); + } + else + { + return(HWREG(ulBase + I2C_O_SMIS)); + } + } + else + { + return(HWREG(ulBase + I2C_O_SRIS)); + } +} + +//***************************************************************************** +// +//! Clears I2C Master interrupt sources. +//! +//! \param ulBase is the base address of the I2C Master module. +//! +//! The I2C Master interrupt source is cleared, so that it no longer asserts. +//! This must be done in the interrupt handler to keep it from being called +//! again immediately upon exit. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +I2CMasterIntClear(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + + // + // Clear the I2C master interrupt source. + // + HWREG(ulBase + I2C_O_MICR) = I2C_MICR_IC; + + // + // Workaround for I2C master interrupt clear errata for rev B Stellaris + // devices. For later devices, this write is ignored and therefore + // harmless (other than the slight performance hit). + // + HWREG(ulBase + I2C_O_MMIS) = I2C_MICR_IC; +} + +//***************************************************************************** +// +//! Clears I2C Slave interrupt sources. +//! +//! \param ulBase is the base address of the I2C Slave module. +//! +//! The I2C Slave interrupt source is cleared, so that it no longer asserts. +//! This must be done in the interrupt handler to keep it from being called +//! again immediately upon exit. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +I2CSlaveIntClear(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_SLAVE_BASE) || (ulBase == I2C1_SLAVE_BASE)); + + // + // Clear the I2C slave interrupt source. + // + HWREG(ulBase + I2C_O_SICR) = I2C_SICR_DATAIC; +} + +//***************************************************************************** +// +//! Clears I2C Slave interrupt sources. +//! +//! \param ulBase is the base address of the I2C Slave module. +//! \param ulIntFlags is a bit mask of the interrupt sources to be cleared. +//! +//! The specified I2C Slave interrupt sources are cleared, so that they no +//! longer assert. This must be done in the interrupt handler to keep it from +//! being called again immediately upon exit. +//! +//! The \e ulIntFlags parameter has the same definition as the \e ulIntFlags +//! parameter to I2CSlaveIntEnableEx(). +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +I2CSlaveIntClearEx(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_SLAVE_BASE) || (ulBase == I2C1_SLAVE_BASE)); + + // + // Clear the I2C slave interrupt source. + // + HWREG(ulBase + I2C_O_SICR) = ulIntFlags; +} + +//***************************************************************************** +// +//! Sets the address that the I2C Master will place on the bus. +//! +//! \param ulBase is the base address of the I2C Master module. +//! \param ucSlaveAddr 7-bit slave address +//! \param bReceive flag indicating the type of communication with the slave +//! +//! This function will set the address that the I2C Master will place on the +//! bus when initiating a transaction. When the \e bReceive parameter is set +//! to \b true, the address will indicate that the I2C Master is initiating a +//! read from the slave; otherwise the address will indicate that the I2C +//! Master is initiating a write to the slave. +//! +//! \return None. +// +//***************************************************************************** +void +I2CMasterSlaveAddrSet(unsigned long ulBase, unsigned char ucSlaveAddr, + tBoolean bReceive) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + ASSERT(!(ucSlaveAddr & 0x80)); + + // + // Set the address of the slave with which the master will communicate. + // + HWREG(ulBase + I2C_O_MSA) = (ucSlaveAddr << 1) | bReceive; +} + +//***************************************************************************** +// +//! Indicates whether or not the I2C Master is busy. +//! +//! \param ulBase is the base address of the I2C Master module. +//! +//! This function returns an indication of whether or not the I2C Master is +//! busy transmitting or receiving data. +//! +//! \return Returns \b true if the I2C Master is busy; otherwise, returns +//! \b false. +// +//***************************************************************************** +tBoolean +I2CMasterBusy(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + + // + // Return the busy status. + // + if(HWREG(ulBase + I2C_O_MCS) & I2C_MCS_BUSY) + { + return(true); + } + else + { + return(false); + } +} + +//***************************************************************************** +// +//! Indicates whether or not the I2C bus is busy. +//! +//! \param ulBase is the base address of the I2C Master module. +//! +//! This function returns an indication of whether or not the I2C bus is busy. +//! This function can be used in a multi-master environment to determine if +//! another master is currently using the bus. +//! +//! \return Returns \b true if the I2C bus is busy; otherwise, returns +//! \b false. +// +//***************************************************************************** +tBoolean +I2CMasterBusBusy(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + + // + // Return the bus busy status. + // + if(HWREG(ulBase + I2C_O_MCS) & I2C_MCS_BUSBSY) + { + return(true); + } + else + { + return(false); + } +} + +//***************************************************************************** +// +//! Controls the state of the I2C Master module. +//! +//! \param ulBase is the base address of the I2C Master module. +//! \param ulCmd command to be issued to the I2C Master module +//! +//! This function is used to control the state of the Master module send and +//! receive operations. The \e ucCmd parameter can be one of the following +//! values: +//! +//! - \b I2C_MASTER_CMD_SINGLE_SEND +//! - \b I2C_MASTER_CMD_SINGLE_RECEIVE +//! - \b I2C_MASTER_CMD_BURST_SEND_START +//! - \b I2C_MASTER_CMD_BURST_SEND_CONT +//! - \b I2C_MASTER_CMD_BURST_SEND_FINISH +//! - \b I2C_MASTER_CMD_BURST_SEND_ERROR_STOP +//! - \b I2C_MASTER_CMD_BURST_RECEIVE_START +//! - \b I2C_MASTER_CMD_BURST_RECEIVE_CONT +//! - \b I2C_MASTER_CMD_BURST_RECEIVE_FINISH +//! - \b I2C_MASTER_CMD_BURST_RECEIVE_ERROR_STOP +//! +//! \return None. +// +//***************************************************************************** +void +I2CMasterControl(unsigned long ulBase, unsigned long ulCmd) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + ASSERT((ulCmd == I2C_MASTER_CMD_SINGLE_SEND) || + (ulCmd == I2C_MASTER_CMD_SINGLE_RECEIVE) || + (ulCmd == I2C_MASTER_CMD_BURST_SEND_START) || + (ulCmd == I2C_MASTER_CMD_BURST_SEND_CONT) || + (ulCmd == I2C_MASTER_CMD_BURST_SEND_FINISH) || + (ulCmd == I2C_MASTER_CMD_BURST_SEND_ERROR_STOP) || + (ulCmd == I2C_MASTER_CMD_BURST_RECEIVE_START) || + (ulCmd == I2C_MASTER_CMD_BURST_RECEIVE_CONT) || + (ulCmd == I2C_MASTER_CMD_BURST_RECEIVE_FINISH) || + (ulCmd == I2C_MASTER_CMD_BURST_RECEIVE_ERROR_STOP)); + + // + // Send the command. + // + HWREG(ulBase + I2C_O_MCS) = ulCmd; +} + +//***************************************************************************** +// +//! Gets the error status of the I2C Master module. +//! +//! \param ulBase is the base address of the I2C Master module. +//! +//! This function is used to obtain the error status of the Master module send +//! and receive operations. +//! +//! \return Returns the error status, as one of \b I2C_MASTER_ERR_NONE, +//! \b I2C_MASTER_ERR_ADDR_ACK, \b I2C_MASTER_ERR_DATA_ACK, or +//! \b I2C_MASTER_ERR_ARB_LOST. +// +//***************************************************************************** +unsigned long +I2CMasterErr(unsigned long ulBase) +{ + unsigned long ulErr; + + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + + // + // Get the raw error state + // + ulErr = HWREG(ulBase + I2C_O_MCS); + + // + // If the I2C master is busy, then all the other bit are invalid, and + // don't have an error to report. + // + if(ulErr & I2C_MCS_BUSY) + { + return(I2C_MASTER_ERR_NONE); + } + + // + // Check for errors. + // + if(ulErr & (I2C_MCS_ERROR | I2C_MCS_ARBLST)) + { + return(ulErr & (I2C_MCS_ARBLST | I2C_MCS_DATACK | I2C_MCS_ADRACK)); + } + else + { + return(I2C_MASTER_ERR_NONE); + } +} + +//***************************************************************************** +// +//! Transmits a byte from the I2C Master. +//! +//! \param ulBase is the base address of the I2C Master module. +//! \param ucData data to be transmitted from the I2C Master +//! +//! This function will place the supplied data into I2C Master Data Register. +//! +//! \return None. +// +//***************************************************************************** +void +I2CMasterDataPut(unsigned long ulBase, unsigned char ucData) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + + // + // Write the byte. + // + HWREG(ulBase + I2C_O_MDR) = ucData; +} + +//***************************************************************************** +// +//! Receives a byte that has been sent to the I2C Master. +//! +//! \param ulBase is the base address of the I2C Master module. +//! +//! This function reads a byte of data from the I2C Master Data Register. +//! +//! \return Returns the byte received from by the I2C Master, cast as an +//! unsigned long. +// +//***************************************************************************** +unsigned long +I2CMasterDataGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); + + // + // Read a byte. + // + return(HWREG(ulBase + I2C_O_MDR)); +} + +//***************************************************************************** +// +//! Gets the I2C Slave module status +//! +//! \param ulBase is the base address of the I2C Slave module. +//! +//! This function will return the action requested from a master, if any. +//! Possible values are: +//! +//! - \b I2C_SLAVE_ACT_NONE +//! - \b I2C_SLAVE_ACT_RREQ +//! - \b I2C_SLAVE_ACT_TREQ +//! - \b I2C_SLAVE_ACT_RREQ_FBR +//! +//! \return Returns \b I2C_SLAVE_ACT_NONE to indicate that no action has been +//! requested of the I2C Slave module, \b I2C_SLAVE_ACT_RREQ to indicate that +//! an I2C master has sent data to the I2C Slave module, \b I2C_SLAVE_ACT_TREQ +//! to indicate that an I2C master has requested that the I2C Slave module send +//! data, and \b I2C_SLAVE_ACT_RREQ_FBR to indicate that an I2C master has sent +//! data to the I2C slave and the first byte following the slave's own address +//! has been received. +// +//***************************************************************************** +unsigned long +I2CSlaveStatus(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_SLAVE_BASE) || (ulBase == I2C1_SLAVE_BASE)); + + // + // Return the slave status. + // + return(HWREG(ulBase + I2C_O_SCSR)); +} + +//***************************************************************************** +// +//! Transmits a byte from the I2C Slave. +//! +//! \param ulBase is the base address of the I2C Slave module. +//! \param ucData data to be transmitted from the I2C Slave +//! +//! This function will place the supplied data into I2C Slave Data Register. +//! +//! \return None. +// +//***************************************************************************** +void +I2CSlaveDataPut(unsigned long ulBase, unsigned char ucData) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_SLAVE_BASE) || (ulBase == I2C1_SLAVE_BASE)); + + // + // Write the byte. + // + HWREG(ulBase + I2C_O_SDR) = ucData; +} + +//***************************************************************************** +// +//! Receives a byte that has been sent to the I2C Slave. +//! +//! \param ulBase is the base address of the I2C Slave module. +//! +//! This function reads a byte of data from the I2C Slave Data Register. +//! +//! \return Returns the byte received from by the I2C Slave, cast as an +//! unsigned long. +// +//***************************************************************************** +unsigned long +I2CSlaveDataGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == I2C0_SLAVE_BASE) || (ulBase == I2C1_SLAVE_BASE)); + + // + // Read a byte. + // + return(HWREG(ulBase + I2C_O_SDR)); +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2c.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2c.h new file mode 100644 index 00000000..d277dce3 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2c.h @@ -0,0 +1,179 @@ +//***************************************************************************** +// +// i2c.h - Prototypes for the I2C Driver. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __I2C_H__ +#define __I2C_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Defines for the API. +// +//***************************************************************************** + +//***************************************************************************** +// +// Interrupt defines. +// +//***************************************************************************** +#define I2C_INT_MASTER 0x00000001 +#define I2C_INT_SLAVE 0x00000002 + +//***************************************************************************** +// +// I2C Master commands. +// +//***************************************************************************** +#define I2C_MASTER_CMD_SINGLE_SEND \ + 0x00000007 +#define I2C_MASTER_CMD_SINGLE_RECEIVE \ + 0x00000007 +#define I2C_MASTER_CMD_BURST_SEND_START \ + 0x00000003 +#define I2C_MASTER_CMD_BURST_SEND_CONT \ + 0x00000001 +#define I2C_MASTER_CMD_BURST_SEND_FINISH \ + 0x00000005 +#define I2C_MASTER_CMD_BURST_SEND_ERROR_STOP \ + 0x00000004 +#define I2C_MASTER_CMD_BURST_RECEIVE_START \ + 0x0000000b +#define I2C_MASTER_CMD_BURST_RECEIVE_CONT \ + 0x00000009 +#define I2C_MASTER_CMD_BURST_RECEIVE_FINISH \ + 0x00000005 +#define I2C_MASTER_CMD_BURST_RECEIVE_ERROR_STOP \ + 0x00000004 + +//***************************************************************************** +// +// I2C Master error status. +// +//***************************************************************************** +#define I2C_MASTER_ERR_NONE 0 +#define I2C_MASTER_ERR_ADDR_ACK 0x00000004 +#define I2C_MASTER_ERR_DATA_ACK 0x00000008 +#define I2C_MASTER_ERR_ARB_LOST 0x00000010 + +//***************************************************************************** +// +// I2C Slave action requests +// +//***************************************************************************** +#define I2C_SLAVE_ACT_NONE 0 +#define I2C_SLAVE_ACT_RREQ 0x00000001 // Master has sent data +#define I2C_SLAVE_ACT_TREQ 0x00000002 // Master has requested data +#define I2C_SLAVE_ACT_RREQ_FBR 0x00000005 // Master has sent first byte + +//***************************************************************************** +// +// Miscellaneous I2C driver definitions. +// +//***************************************************************************** +#define I2C_MASTER_MAX_RETRIES 1000 // Number of retries + + +//***************************************************************************** +// +// I2C Slave interrupts. +// +//***************************************************************************** +#define I2C_SLAVE_INT_STOP 0x00000004 // Stop Condition Interrupt. +#define I2C_SLAVE_INT_START 0x00000002 // Start Condition Interrupt. +#define I2C_SLAVE_INT_DATA 0x00000001 // Data Interrupt. + + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern void I2CIntRegister(unsigned long ulBase, void(fnHandler)(void)); +extern void I2CIntUnregister(unsigned long ulBase); +extern tBoolean I2CMasterBusBusy(unsigned long ulBase); +extern tBoolean I2CMasterBusy(unsigned long ulBase); +extern void I2CMasterControl(unsigned long ulBase, unsigned long ulCmd); +extern unsigned long I2CMasterDataGet(unsigned long ulBase); +extern void I2CMasterDataPut(unsigned long ulBase, unsigned char ucData); +extern void I2CMasterDisable(unsigned long ulBase); +extern void I2CMasterEnable(unsigned long ulBase); +extern unsigned long I2CMasterErr(unsigned long ulBase); +extern void I2CMasterInitExpClk(unsigned long ulBase, unsigned long ulI2CClk, + tBoolean bFast); +extern void I2CMasterIntClear(unsigned long ulBase); +extern void I2CMasterIntDisable(unsigned long ulBase); +extern void I2CMasterIntEnable(unsigned long ulBase); +extern tBoolean I2CMasterIntStatus(unsigned long ulBase, tBoolean bMasked); +extern void I2CMasterSlaveAddrSet(unsigned long ulBase, + unsigned char ucSlaveAddr, + tBoolean bReceive); +extern unsigned long I2CSlaveDataGet(unsigned long ulBase); +extern void I2CSlaveDataPut(unsigned long ulBase, unsigned char ucData); +extern void I2CSlaveDisable(unsigned long ulBase); +extern void I2CSlaveEnable(unsigned long ulBase); +extern void I2CSlaveInit(unsigned long ulBase, unsigned char ucSlaveAddr); +extern void I2CSlaveIntClear(unsigned long ulBase); +extern void I2CSlaveIntDisable(unsigned long ulBase); +extern void I2CSlaveIntEnable(unsigned long ulBase); +extern void I2CSlaveIntClearEx(unsigned long ulBase, unsigned long ulIntFlags); +extern void I2CSlaveIntDisableEx(unsigned long ulBase, + unsigned long ulIntFlags); +extern void I2CSlaveIntEnableEx(unsigned long ulBase, unsigned long ulIntFlags); +extern tBoolean I2CSlaveIntStatus(unsigned long ulBase, tBoolean bMasked); +extern unsigned long I2CSlaveIntStatusEx(unsigned long ulBase, + tBoolean bMasked); +extern unsigned long I2CSlaveStatus(unsigned long ulBase); + +//***************************************************************************** +// +// Several I2C APIs have been renamed, with the original function name being +// deprecated. These defines provide backward compatibility. +// +//***************************************************************************** +#ifndef DEPRECATED +#include "driverlib/sysctl.h" +#define I2CMasterInit(a, b) \ + I2CMasterInitExpClk(a, SysCtlClockGet(), b) +#endif + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __I2C_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2s.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2s.c new file mode 100644 index 00000000..42749354 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2s.c @@ -0,0 +1,1136 @@ +//***************************************************************************** +// +// i2s.c - Driver for the I2S controller. +// +// Copyright (c) 2008-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup i2s_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_i2s.h" +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_types.h" +#include "driverlib/debug.h" +#include "driverlib/i2s.h" +#include "driverlib/interrupt.h" + +//***************************************************************************** +// +//! Enables the I2S transmit module for operation. +//! +//! \param ulBase is the I2S module base address. +//! +//! This function enables the transmit module for operation. The module +//! should be enabled after configuration. When the module is disabled, +//! no data or clocks will be generated on the I2S signals. +//! +//! \return None. +// +//***************************************************************************** +void +I2STxEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Enable the tx FIFO service request. + // + HWREG(ulBase + I2S_O_TXISM) = I2S_TXISM_FFM; + + // + // Read-modify-write the enable bit. + // + HWREG(ulBase + I2S_O_CFG) |= I2S_CFG_TXEN; +} + +//***************************************************************************** +// +//! Disables the I2S transmit module for operation. +//! +//! \param ulBase is the I2S module base address. +//! +//! This function disables the transmit module for operation. The module +//! should be disabled before configuration. When the module is disabled, +//! no data or clocks will be generated on the I2S signals. +//! +//! \return None. +// +//***************************************************************************** +void +I2STxDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Read-modify-write the enable bit. + // + HWREG(ulBase + I2S_O_CFG) &= ~I2S_CFG_TXEN; +} + +//***************************************************************************** +// +//! Writes data samples to the I2S transmit FIFO with blocking. +//! +//! \param ulBase is the I2S module base address. +//! \param ulData is the single or dual channel I2S data. +//! +//! This function writes a single channel sample or combined left-right +//! samples to the I2S transmit FIFO. The format of the sample is determined +//! by the configuration that was used with the function I2STxConfigSet(). +//! If the transmit mode is I2S_MODE_DUAL_STEREO then the \e ulData parameter +//! contains either the left or right sample. The left and right sample +//! alternate with each write to the FIFO, left sample first. If the transmit +//! mode is I2S_MODE_COMPACT_STEREO_16 or I2S_MODE_COMPACT_STEREO_8, then the +//! \e ulData parameter contains both the left and right samples. If the +//! transmit mode is I2S_MODE_SINGLE_MONO then the \e ulData parameter +//! contains the single channel sample. +//! +//! For the compact modes, both the left and right samples are written at +//! the same time. If 16-bit compact mode is used, then the least significant +//! 16 bits contain the left sample, and the most significant 16 bits contain +//! the right sample. If 8-bit compact mode is used, then the lower 8 bits +//! contain the left sample, and the next 8 bits contain the right sample, +//! with the upper 16 bits unused. +//! +//! If there is no room in the transmit FIFO, then this function will wait +//! in a polling loop until the data can be written. +//! +//! \return None. +// +//***************************************************************************** +void +I2STxDataPut(unsigned long ulBase, unsigned long ulData) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Wait until there is space. + // + while(HWREG(ulBase + I2S_O_TXLEV) >= 16) + { + } + + // + // Write the data to the I2S. + // + HWREG(ulBase + I2S_O_TXFIFO) = ulData; +} + +//***************************************************************************** +// +//! Writes data samples to the I2S transmit FIFO without blocking. +//! +//! \param ulBase is the I2S module base address. +//! \param ulData is the single or dual channel I2S data. +//! +//! This function writes a single channel sample or combined left-right +//! samples to the I2S transmit FIFO. The format of the sample is determined +//! by the configuration that was used with the function I2STxConfigSet(). +//! If the transmit mode is I2S_MODE_DUAL_STEREO then the \e ulData parameter +//! contains either the left or right sample. The left and right sample +//! alternate with each write to the FIFO, left sample first. If the transmit +//! mode is I2S_MODE_COMPACT_STEREO_16 or I2S_MODE_COMPACT_STEREO_8, then the +//! \e ulData parameter contains both the left and right samples. If the +//! transmit mode is I2S_MODE_SINGLE_MONO then the \e ulData parameter +//! contains the single channel sample. +//! +//! For the compact modes, both the left and right samples are written at +//! the same time. If 16-bit compact mode is used, then the least significant +//! 16 bits contain the left sample, and the most significant 16 bits contain +//! the right sample. If 8-bit compact mode is used, then the lower 8 bits +//! contain the left sample, and the next 8 bits contain the right sample, +//! with the upper 16 bits unused. +//! +//! If there is no room in the transmit FIFO, then this function will return +//! immediately without writing any data to the FIFO. +//! +//! \return The number of elements written to the I2S transmit FIFO (1 or 0). +// +//***************************************************************************** +long +I2STxDataPutNonBlocking(unsigned long ulBase, unsigned long ulData) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Check for space to write. + // + if(HWREG(ulBase + I2S_O_TXLEV) < 16) + { + HWREG(ulBase + I2S_O_TXFIFO) = ulData; + return(1); + } + else + { + return(0); + } +} + +//***************************************************************************** +// +//! Configures the I2S transmit module. +//! +//! \param ulBase is the I2S module base address. +//! \param ulConfig is the logical OR of the configuration options. +//! +//! This function is used to configure the options for the I2S transmit +//! channel. The parameter \e ulConfig is the logical OR of the following +//! options: +//! +//! - \b I2S_CONFIG_FORMAT_I2S for standard I2S format, +//! \b I2S_CONFIG_FORMAT_LEFT_JUST for left justified format, or +//! \b I2S_CONFIG_FORMAT_RIGHT_JUST for right justified format. +//! - \b I2S_CONFIG_SCLK_INVERT to invert the polarity of the serial bit clock. +//! - \b I2S_CONFIG_MODE_DUAL for dual channel stereo, +//! \b I2S_CONFIG_MODE_COMPACT_16 for 16-bit compact stereo mode, +//! \b I2S_CONFIG_MODE_COMPACT_8 for 8-bit compact stereo mode, or +//! \b I2S_CONFIG_MODE_MONO for single channel mono format. +//! - \b I2S_CONFIG_CLK_MASTER or \b I2S_CONFIG_CLK_SLAVE to select whether +//! the I2S transmitter is the clock master or slave. +//! - \b I2S_CONFIG_SAMPLE_SIZE_32, \b _24, \b _20, \b _16, or \b _8 +//! to select the number of bits per sample. +//! - \b I2S_CONFIG_WIRE_SIZE_32, \b _24, \b _20, \b _16, or \b _8 +//! to select the number of bits per word that are transferred on the data +//! line. +//! - \b I2S_CONFIG_EMPTY_ZERO or \b I2S_CONFIG_EMPTY_REPEAT to select whether +//! the module transmits zeroes or repeats the last sample when the FIFO is +//! empty. +//! +//! \return None. +// +//***************************************************************************** +void +I2STxConfigSet(unsigned long ulBase, unsigned long ulConfig) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + ASSERT((ulConfig & (I2S_CONFIG_FORMAT_MASK | I2S_CONFIG_MODE_MASK | + I2S_CONFIG_EMPTY_MASK | I2S_CONFIG_CLK_MASK | + I2S_CONFIG_SAMPLE_SIZE_MASK | + I2S_CONFIG_WIRE_SIZE_MASK)) == ulConfig); + + // + // Check to see if a compact mode is used. + // + if((ulConfig & I2S_CONFIG_MODE_MASK) == I2S_CONFIG_MODE_COMPACT_8) + { + // + // If compact 8 mode is used, then need to adjust some bits + // before writing the config register. Also set the FIFO + // config register for 8 bit compact samples. + // + ulConfig &= ~I2S_CONFIG_MODE_MONO; + HWREG(ulBase + I2S_O_TXFIFOCFG) = I2S_TXFIFOCFG_CSS; + } + else + { + // + // If compact 8 mode is not used, then set the FIFO config + // register for 16 bit. This is okay if a compact mode is + // not used. + // + HWREG(ulBase + I2S_O_TXFIFOCFG) = 0; + } + + // + // Write the configuration register. Since all the fields are + // specified by the configuration parameter, it is not necessary + // to do a read-modify-write. + // + HWREG(ulBase + I2S_O_TXCFG) = ulConfig; +} + +//***************************************************************************** +// +//! Sets the FIFO level at which a service request is generated. +//! +//! \param ulBase is the I2S module base address. +//! \param ulLevel is the FIFO service request limit. +//! +//! This function is used to set the transmit FIFO fullness level at which +//! a service request will occur. The service request is used to generate +//! an interrupt or a DMA transfer request. The transmit FIFO will +//! generate a service request when the number of items in the FIFO is +//! less than the level specified in the \e ulLevel parameter. For example, +//! if \e ulLevel is 8, then a service request will be generated when +//! there are less than 8 samples remaining in the transmit FIFO. +//! +//! For the purposes of counting the FIFO level, a left-right sample pair +//! counts as 2, whether the mode is dual or compact stereo. When mono +//! mode is used, internally the mono sample is still treated as a sample +//! pair, so a single mono sample counts as 2. Since the FIFO always deals +//! with sample pairs, the level must be an even number from 0 to 16. The +//! maximum value is 16, which will cause a service request when there +//! is any room in the FIFO. The minimum value is 0, which disables the +//! service request. +//! +//! \return None. +// +//***************************************************************************** +void +I2STxFIFOLimitSet(unsigned long ulBase, unsigned long ulLevel) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + ASSERT(ulLevel <= 16); + + // + // Write the FIFO limit + // + HWREG(ulBase + I2S_O_TXLIMIT) = ulLevel; +} + +//***************************************************************************** +// +//! Gets the current setting of the FIFO service request level. +//! +//! \param ulBase is the I2S module base address. +//! +//! This function is used to get the value of the transmit FIFO service +//! request level. This value is set using the I2STxFIFOLimitSet() +//! function. +//! +//! \return Returns the current value of the FIFO service request limit. +// +//***************************************************************************** +unsigned long +I2STxFIFOLimitGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Read and return the FIFO limit + // + return(HWREG(ulBase + I2S_O_TXLIMIT)); +} + +//***************************************************************************** +// +//! Gets the number of samples in the transmit FIFO. +//! +//! \param ulBase is the I2S module base address. +//! +//! This function is used to get the number of samples in the transmit +//! FIFO. For the purposes of measuring the FIFO level, a left-right sample +//! pair counts as 2, whether the mode is dual or compact stereo. When mono +//! mode is used, internally the mono sample is still treated as a sample +//! pair, so a single mono sample counts as 2. Since the FIFO always deals +//! with sample pairs, normally the level will be an even number from 0 to +//! 16. If dual stereo mode is used and only the left sample has been +//! written without the matching right sample, then the FIFO level will be an +//! odd value. If the FIFO level is odd, it indicates a left-right sample +//! mismatch. +//! +//! \return Returns the number of samples in the transmit FIFO, which will +//! normally be an even number. +// +//***************************************************************************** +unsigned long +I2STxFIFOLevelGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Read and return the transmit FIFO level. + // + return(HWREG(ulBase + I2S_O_TXLEV)); +} + +//***************************************************************************** +// +//! Enables the I2S receive module for operation. +//! +//! \param ulBase is the I2S module base address. +//! +//! This function enables the receive module for operation. The module +//! should be enabled after configuration. When the module is disabled, +//! no data will be clocked in regardless of the signals on the I2S interface. +//! +//! \return None. +// +//***************************************************************************** +void +I2SRxEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Enable the tx FIFO service request. + // + HWREG(ulBase + I2S_O_RXISM) = I2S_RXISM_FFM; + + // + // Read-modify-write the enable bit. + // + HWREG(ulBase + I2S_O_CFG) |= I2S_CFG_RXEN; +} + +//***************************************************************************** +// +//! Disables the I2S receive module for operation. +//! +//! \param ulBase is the I2S module base address. +//! +//! This function disables the receive module for operation. The module +//! should be disabled before configuration. When the module is disabled, +//! no data will be clocked in regardless of the signals on the I2S interface. +//! +//! \return None. +// +//***************************************************************************** +void +I2SRxDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Read-modify-write the enable bit. + // + HWREG(ulBase + I2S_O_CFG) &= ~I2S_CFG_RXEN; +} + +//***************************************************************************** +// +//! Reads data samples from the I2S receive FIFO with blocking. +//! +//! \param ulBase is the I2S module base address. +//! \param pulData points to storage for the returned I2S sample data. +//! +//! This function reads a single channel sample or combined left-right +//! samples from the I2S receive FIFO. The format of the sample is determined +//! by the configuration that was used with the function I2SRxConfigSet(). +//! If the receive mode is I2S_MODE_DUAL_STEREO then the returned value +//! contains either the left or right sample. The left and right sample +//! alternate with each read from the FIFO, left sample first. If the receive +//! mode is I2S_MODE_COMPACT_STEREO_16 or I2S_MODE_COMPACT_STEREO_8, then the +//! returned data contains both the left and right samples. If the +//! receive mode is I2S_MODE_SINGLE_MONO then the returned data +//! contains the single channel sample. +//! +//! For the compact modes, both the left and right samples are read at +//! the same time. If 16-bit compact mode is used, then the least significant +//! 16 bits contain the left sample, and the most significant 16 bits contain +//! the right sample. If 8-bit compact mode is used, then the lower 8 bits +//! contain the left sample, and the next 8 bits contain the right sample, +//! with the upper 16 bits unused. +//! +//! If there is no data in the receive FIFO, then this function will wait +//! in a polling loop until data is available. +//! +//! \return None. +// +//***************************************************************************** +void +I2SRxDataGet(unsigned long ulBase, unsigned long *pulData) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Wait until there is data available. + // + while(HWREG(ulBase + I2S_O_RXLEV) == 0) + { + } + + // + // Read data from the I2S receive FIFO. + // + *pulData = HWREG(ulBase + I2S_O_RXFIFO); +} + +//***************************************************************************** +// +//! Reads data samples from the I2S receive FIFO without blocking. +//! +//! \param ulBase is the I2S module base address. +//! \param pulData points to storage for the returned I2S sample data. +//! +//! This function reads a single channel sample or combined left-right +//! samples from the I2S receive FIFO. The format of the sample is determined +//! by the configuration that was used with the function I2SRxConfigSet(). +//! If the receive mode is I2S_MODE_DUAL_STEREO then the received data +//! contains either the left or right sample. The left and right sample +//! alternate with each read from the FIFO, left sample first. If the receive +//! mode is I2S_MODE_COMPACT_STEREO_16 or I2S_MODE_COMPACT_STEREO_8, then the +//! received data contains both the left and right samples. If the +//! receive mode is I2S_MODE_SINGLE_MONO then the received data +//! contains the single channel sample. +//! +//! For the compact modes, both the left and right samples are read at +//! the same time. If 16-bit compact mode is used, then the least significant +//! 16 bits contain the left sample, and the most significant 16 bits contain +//! the right sample. If 8-bit compact mode is used, then the lower 8 bits +//! contain the left sample, and the next 8 bits contain the right sample, +//! with the upper 16 bits unused. +//! +//! If there is no data in the receive FIFO, then this function will return +//! immediately without reading any data from the FIFO. +//! +//! \return The number of elements read from the I2S receive FIFO (1 or 0). +// +//***************************************************************************** +long +I2SRxDataGetNonBlocking(unsigned long ulBase, unsigned long *pulData) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Check for available samples. + // + if(HWREG(ulBase + I2S_O_RXLEV) != 0) + { + *pulData = HWREG(ulBase + I2S_O_RXFIFO); + return(1); + } + else + { + return(0); + } +} + +//***************************************************************************** +// +//! Configures the I2S receive module. +//! +//! \param ulBase is the I2S module base address. +//! \param ulConfig is the logical OR of the configuration options. +//! +//! This function is used to configure the options for the I2S receive +//! channel. The parameter \e ulConfig is the logical OR of the following +//! options: +//! +//! - \b I2S_CONFIG_FORMAT_I2S for standard I2S format, +//! \b I2S_CONFIG_FORMAT_LEFT_JUST for left justified format, or +//! \b I2S_CONFIG_FORMAT_RIGHT_JUST for right justified format. +//! - \b I2S_CONFIG_SCLK_INVERT to invert the polarity of the serial bit clock. +//! - \b I2S_CONFIG_MODE_DUAL for dual channel stereo, +//! \b I2S_CONFIG_MODE_COMPACT_16 for 16-bit compact stereo mode, +//! \b I2S_CONFIG_MODE_COMPACT_8 for 8-bit compact stereo mode, or +//! \b I2S_CONFIG_MODE_MONO for single channel mono format. +//! - \b I2S_CONFIG_CLK_MASTER or \b I2S_CONFIG_CLK_SLAVE to select whether +//! the I2S receiver is the clock master or slave. +//! - \b I2S_CONFIG_SAMPLE_SIZE_32, \b _24, \b _20, \b _16, or \b _8 +//! to select the number of bits per sample. +//! - \b I2S_CONFIG_WIRE_SIZE_32, \b _24, \b _20, \b _16, or \b _8 +//! to select the number of bits per word that are transferred on the data +//! line. +//! +//! \return None. +// +//***************************************************************************** +void +I2SRxConfigSet(unsigned long ulBase, unsigned long ulConfig) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + ASSERT((ulConfig & (I2S_CONFIG_FORMAT_MASK | I2S_CONFIG_MODE_MASK | + I2S_CONFIG_CLK_MASK | I2S_CONFIG_SAMPLE_SIZE_MASK | + I2S_CONFIG_WIRE_SIZE_MASK)) == ulConfig); + + // + // Clear out any prior config of the RX FIFO config register. + // + HWREG(ulBase + I2S_O_RXFIFOCFG) = 0; + + // + // If mono mode is used, then the FMM bit needs to be set. + // + if((ulConfig & I2S_CONFIG_MODE_MASK) == I2S_CONFIG_MODE_MONO) + { + HWREG(ulBase + I2S_O_RXFIFOCFG) |= I2S_RXFIFOCFG_FMM; + } + + // + // If a compact mode is used, then the CSS bit needs to be set. + // + else if((ulConfig & I2S_CONFIG_MODE_MASK) == I2S_CONFIG_MODE_COMPACT_8) + { + HWREG(ulBase + I2S_O_RXFIFOCFG) |= I2S_RXFIFOCFG_CSS; + } + + // + // The "mono" bits needs to be removed from the configuration word + // prior to writing to hardware, because the RX configuration register + // does not actually use these bits. + // + ulConfig &= ~I2S_CONFIG_MODE_MONO; + + // + // Write the configuration register. Since all the fields are + // specified by the configuration parameter, it is not necessary + // to do a read-modify-write. + // + HWREG(ulBase + I2S_O_RXCFG) = ulConfig; +} + +//***************************************************************************** +// +//! Sets the FIFO level at which a service request is generated. +//! +//! \param ulBase is the I2S module base address. +//! \param ulLevel is the FIFO service request limit. +//! +//! This function is used to set the receive FIFO fullness level at which +//! a service request will occur. The service request is used to generate +//! an interrupt or a DMA transfer request. The receive FIFO will +//! generate a service request when the number of items in the FIFO is +//! greater than the level specified in the \e ulLevel parameter. For example, +//! if \e ulLevel is 4, then a service request will be generated when +//! there are more than 4 samples available in the receive FIFO. +//! +//! For the purposes of counting the FIFO level, a left-right sample pair +//! counts as 2, whether the mode is dual or compact stereo. When mono +//! mode is used, internally the mono sample is still treated as a sample +//! pair, so a single mono sample counts as 2. Since the FIFO always deals +//! with sample pairs, the level must be an even number from 0 to 16. The +//! minimum value is 0, which will cause a service request when there +//! is any data available in the FIFO. The maximum value is 16, which +//! disables the service request (because there cannot be more than 16 +//! items in the FIFO). +//! +//! \return None. +// +//***************************************************************************** +void +I2SRxFIFOLimitSet(unsigned long ulBase, unsigned long ulLevel) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + ASSERT(ulLevel <= 16); + + // + // Write the FIFO limit + // + HWREG(ulBase + I2S_O_RXLIMIT) = ulLevel; +} + +//***************************************************************************** +// +//! Gets the current setting of the FIFO service request level. +//! +//! \param ulBase is the I2S module base address. +//! +//! This function is used to get the value of the receive FIFO service +//! request level. This value is set using the I2SRxFIFOLimitSet() +//! function. +//! +//! \return Returns the current value of the FIFO service request limit. +// +//***************************************************************************** +unsigned long +I2SRxFIFOLimitGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Read and return the FIFO limit. The lower bit is masked + // because it always reads as 1, and has no meaning. + // + return(HWREG(ulBase + I2S_O_RXLIMIT) & 0xFFFE); +} + +//***************************************************************************** +// +//! Gets the number of samples in the receive FIFO. +//! +//! \param ulBase is the I2S module base address. +//! +//! This function is used to get the number of samples in the receive +//! FIFO. For the purposes of measuring the FIFO level, a left-right sample +//! pair counts as 2, whether the mode is dual or compact stereo. When mono +//! mode is used, internally the mono sample is still treated as a sample +//! pair, so a single mono sample counts as 2. Since the FIFO always deals +//! with sample pairs, normally the level will be an even number from 0 to +//! 16. If dual stereo mode is used and only the left sample has been +//! read without reading the matching right sample, then the FIFO level will +//! be an odd value. If the FIFO level is odd, it indicates a left-right +//! sample mismatch. +//! +//! \return Returns the number of samples in the transmit FIFO, which will +//! normally be an even number. +// +//***************************************************************************** +unsigned long +I2SRxFIFOLevelGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Read and return the receive FIFO level. + // + return(HWREG(ulBase + I2S_O_RXLEV)); +} + +//***************************************************************************** +// +//! Enables the I2S transmit and receive modules for operation. +//! +//! \param ulBase is the I2S module base address. +//! +//! This function simultaneously enables the transmit and receive modules for +//! operation, providing a synchronized SCLK and LRCLK. The module should be +//! enabled after configuration. When the module is disabled, no data or +//! clocks will be generated on the I2S signals. +//! +//! \return None. +// +//***************************************************************************** +void +I2STxRxEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Enable the Tx FIFO service request. + // + HWREG(ulBase + I2S_O_TXISM) = I2S_TXISM_FFM; + + // + // Enable the Rx FIFO service request. + // + HWREG(ulBase + I2S_O_RXISM) = I2S_RXISM_FFM; + + // + // Enable the transmit and receive modules. + // + HWREG(ulBase + I2S_O_CFG) |= I2S_CFG_TXEN | I2S_CFG_RXEN; +} + +//***************************************************************************** +// +//! Disables the I2S transmit and receive modules. +//! +//! \param ulBase is the I2S module base address. +//! +//! This function simultaneously disables the transmit and receive modules. +//! When the module is disabled, no data or clocks will be generated on the I2S +//! signals. +//! +//! \return None. +// +//***************************************************************************** +void +I2STxRxDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Disable the transmit and receive modules. + // + HWREG(ulBase + I2S_O_CFG) &= ~(I2S_CFG_TXEN | I2S_CFG_RXEN); +} + +//***************************************************************************** +// +//! Configures the I2S transmit and receive modules. +//! +//! \param ulBase is the I2S module base address. +//! \param ulConfig is the logical OR of the configuration options. +//! +//! This function is used to configure the options for the I2S transmit and +//! receive channels with identical parameters. The parameter \e ulConfig is +//! the logical OR of the following options: +//! +//! - \b I2S_CONFIG_FORMAT_I2S for standard I2S format, +//! \b I2S_CONFIG_FORMAT_LEFT_JUST for left justified format, or +//! \b I2S_CONFIG_FORMAT_RIGHT_JUST for right justified format. +//! - \b I2S_CONFIG_SCLK_INVERT to invert the polarity of the serial bit clock. +//! - \b I2S_CONFIG_MODE_DUAL for dual channel stereo, +//! \b I2S_CONFIG_MODE_COMPACT_16 for 16-bit compact stereo mode, +//! \b I2S_CONFIG_MODE_COMPACT_8 for 8-bit compact stereo mode, or +//! \b I2S_CONFIG_MODE_MONO for single channel mono format. +//! - \b I2S_CONFIG_CLK_MASTER or \b I2S_CONFIG_CLK_SLAVE to select whether +//! the I2S transmitter is the clock master or slave. +//! - \b I2S_CONFIG_SAMPLE_SIZE_32, \b _24, \b _20, \b _16, or \b _8 +//! to select the number of bits per sample. +//! - \b I2S_CONFIG_WIRE_SIZE_32, \b _24, \b _20, \b _16, or \b _8 +//! to select the number of bits per word that are transferred on the data +//! line. +//! - \b I2S_CONFIG_EMPTY_ZERO or \b I2S_CONFIG_EMPTY_REPEAT to select whether +//! the module transmits zeroes or repeats the last sample when the FIFO is +//! empty. +//! +//! \return None. +// +//***************************************************************************** +void +I2STxRxConfigSet(unsigned long ulBase, unsigned long ulConfig) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + ASSERT((ulConfig & (I2S_CONFIG_FORMAT_MASK | I2S_CONFIG_MODE_MASK | + I2S_CONFIG_EMPTY_MASK | I2S_CONFIG_CLK_MASK | + I2S_CONFIG_SAMPLE_SIZE_MASK | + I2S_CONFIG_WIRE_SIZE_MASK)) == ulConfig); + + // + // Clear out any prior configuration of the FIFO config registers. + // + HWREG(ulBase + I2S_O_TXFIFOCFG) = 0; + HWREG(ulBase + I2S_O_RXFIFOCFG) = 0; + + // + // If mono mode is used, then the FMM bit needs to be set. + // + if((ulConfig & I2S_CONFIG_MODE_MASK) == I2S_CONFIG_MODE_MONO) + { + HWREG(ulBase + I2S_O_RXFIFOCFG) |= I2S_RXFIFOCFG_FMM; + ulConfig &= ~(I2S_CONFIG_MODE_MONO); + } + + // + // If a compact mode is used, then the CSS bit needs to be set. + // + if((ulConfig & I2S_CONFIG_MODE_MASK) == I2S_CONFIG_MODE_COMPACT_8) + { + HWREG(ulBase + I2S_O_TXFIFOCFG) |= I2S_TXFIFOCFG_CSS; + HWREG(ulBase + I2S_O_RXFIFOCFG) |= I2S_RXFIFOCFG_CSS; + } + + // + // Write the configuration register. Since all the fields are specified by + // the configuration parameter, it is not necessary to do a + // read-modify-write. + // + HWREG(ulBase + I2S_O_TXCFG) = ulConfig; + HWREG(ulBase + I2S_O_RXCFG) = ulConfig; +} + +//***************************************************************************** +// +//! Selects the source of the master clock, internal or external. +//! +//! \param ulBase is the I2S module base address. +//! \param ulMClock is the logical OR of the master clock configuration +//! choices. +//! +//! This function selects whether the master clock is sourced from the device +//! internal PLL, or comes from an external pin. The I2S serial bit clock +//! (SCLK) and left-right word clock (LRCLK) are derived from the I2S master +//! clock. The transmit and receive modules can be configured independently. +//! The \e ulMClock parameter is chosen from the following: +//! +//! - one of \b I2S_TX_MCLK_EXT or \b I2S_TX_MCLK_INT +//! - one of \b I2S_RX_MCLK_EXT or \b I2S_RX_MCLK_INT +//! +//! \return Returns None. +// +//***************************************************************************** +void +I2SMasterClockSelect(unsigned long ulBase, unsigned long ulMClock) +{ + unsigned long ulConfig; + + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + ASSERT((ulMClock & (I2S_TX_MCLK_EXT | I2S_RX_MCLK_EXT)) == ulMClock); + + // + // Set the clock selection bits in the configuation word. + // + ulConfig = HWREG(ulBase + I2S_O_CFG) & + ~(I2S_TX_MCLK_EXT | I2S_RX_MCLK_EXT); + HWREG(ulBase + I2S_O_CFG) = ulConfig | ulMClock; +} + +//***************************************************************************** +// +//! Enables I2S interrupt sources. +//! +//! \param ulBase is the I2S module base address. +//! \param ulIntFlags is a bit mask of the interrupt sources to be enabled. +//! +//! This function enables the specified I2S sources to generate interrupts. +//! The \e ulIntFlags parameter can be the logical OR of any of the following +//! values: +//! +//! - \b I2S_INT_RXERR for receive errors +//! - \b I2S_INT_RXREQ for receive FIFO service requests +//! - \b I2S_INT_TXERR for transmit errors +//! - \b I2S_INT_TXREQ for transmit FIFO service requests +//! +//! \return Returns None. +// +//***************************************************************************** +void +I2SIntEnable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + ASSERT((ulIntFlags & (I2S_INT_RXERR | I2S_INT_RXREQ | + I2S_INT_TXERR | I2S_INT_TXREQ)) == ulIntFlags); + + // + // Enable the specified interrupts. + // + HWREG(ulBase + I2S_O_IM) |= ulIntFlags; +} + +//***************************************************************************** +// +//! Disables I2S interrupt sources. +//! +//! \param ulBase is the I2S module base address. +//! \param ulIntFlags is a bit mask of the interrupt sources to be disabled. +//! +//! This function disables the specified I2S sources for interrupt +//! generation. The \e ulIntFlags parameter can be the logical OR +//! of any of the following values: \b I2S_INT_RXERR, \b I2S_INT_RXREQ, +//! \b I2S_INT_TXERR, or \b I2S_INT_TXREQ. +//! +//! \return Returns None. +// +//***************************************************************************** +void +I2SIntDisable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + ASSERT((ulIntFlags & (I2S_INT_RXERR | I2S_INT_RXREQ | + I2S_INT_TXERR | I2S_INT_TXREQ)) == ulIntFlags); + + // + // Enable the specified interrupts. + // + HWREG(ulBase + I2S_O_IM) &= ~ulIntFlags; +} + +//***************************************************************************** +// +//! Gets the I2S interrupt status. +//! +//! \param ulBase is the I2S module base address. +//! \param bMasked is set \b true to get the masked interrupt status, or +//! \b false to get the raw interrupt status. +//! +//! This function returns the I2S interrupt status. It can return either +//! the raw or masked interrupt status. +//! +//! \return Returns the masked or raw I2S interrupt status, as a bit field +//! of any of the following values: \b I2S_INT_RXERR, \b I2S_INT_RXREQ, +//! \b I2S_INT_TXERR, or \b I2S_INT_TXREQ +// +//***************************************************************************** +unsigned long +I2SIntStatus(unsigned long ulBase, tBoolean bMasked) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + return(HWREG(ulBase + I2S_O_MIS)); + } + else + { + return(HWREG(ulBase + I2S_O_RIS)); + } +} + +//***************************************************************************** +// +//! Clears pending I2S interrupt sources. +//! +//! \param ulBase is the I2S module base address. +//! \param ulIntFlags is a bit mask of the interrupt sources to be cleared. +//! +//! This function clears the specified pending I2S interrupts. This must +//! be done in the interrupt handler to keep the handler from being called +//! again immediately upon exit. The \e ulIntFlags parameter can be the +//! logical OR of any of the following values: \b I2S_INT_RXERR, +//! \b I2S_INT_RXREQ, \b I2S_INT_TXERR, or \b I2S_INT_TXREQ. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return Returns None. +// +//***************************************************************************** +void +I2SIntClear(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + ASSERT((ulIntFlags & (I2S_INT_RXERR | I2S_INT_RXREQ | + I2S_INT_TXERR | I2S_INT_TXREQ)) == ulIntFlags); + + // + // Clear the requested interrupt sources. + // + HWREG(ulBase + I2S_O_IC) = ulIntFlags; +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the I2S controller. +//! +//! \param ulBase is the I2S module base address. +//! \param pfnHandler is a pointer to the function to be called when the +//! interrupt is activated. +//! +//! This sets and enables the handler to be called when the I2S controller +//! generates an interrupt. Specific I2S interrupts must still be enabled +//! with the I2SIntEnable() function. It is the responsibility of the +//! interrupt handler to clear any pending interrupts with I2SIntClear(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +I2SIntRegister(unsigned long ulBase, void (*pfnHandler)(void)) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + ASSERT(pfnHandler); + + // + // Register the interrupt handler. + // + IntRegister(INT_I2S0, pfnHandler); + + // + // Enable the I2S interface interrupt. + // + IntEnable(INT_I2S0); +} + +//***************************************************************************** +// +//! Unregisters an interrupt handler for the I2S controller. +//! +//! \param ulBase is the I2S module base address. +//! +//! This function will disable and clear the handler to be called when the +//! I2S interrupt occurs. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +I2SIntUnregister(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == I2S0_BASE); + + // + // Disable the I2S interface interrupt. + // + IntDisable(INT_I2S0); + + // + // Unregister the interrupt handler. + // + IntUnregister(INT_I2S0); +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2s.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2s.h new file mode 100644 index 00000000..5782c61b --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/i2s.h @@ -0,0 +1,154 @@ +//***************************************************************************** +// +// i2s.h - Prototypes and macros for the I2S controller. +// +// Copyright (c) 2008-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __I2S_H__ +#define __I2S_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Values that can be passed to I2STxConfigSet() and I2SRxConfigSet() +// +//***************************************************************************** +#define I2S_CONFIG_FORMAT_MASK 0x3C000000 // JST, DLY, SCP, LRP +#define I2S_CONFIG_FORMAT_I2S 0x14000000 // !JST, DLY, !SCP, LRP +#define I2S_CONFIG_FORMAT_LEFT_JUST \ + 0x00000000 // !JST, !DLY, !SCP, !LRP +#define I2S_CONFIG_FORMAT_RIGHT_JUST \ + 0x20000000 // JST, !DLY, !SCP, !LRP + +#define I2S_CONFIG_SCLK_INVERT 0x08000000 + +#define I2S_CONFIG_MODE_MASK 0x03000000 +#define I2S_CONFIG_MODE_DUAL 0x00000000 +#define I2S_CONFIG_MODE_COMPACT_16 \ + 0x01000000 +#define I2S_CONFIG_MODE_COMPACT_8 \ + 0x03000000 +#define I2S_CONFIG_MODE_MONO 0x02000000 + +#define I2S_CONFIG_EMPTY_MASK 0x00800000 +#define I2S_CONFIG_EMPTY_ZERO 0x00000000 +#define I2S_CONFIG_EMPTY_REPEAT 0x00800000 + +#define I2S_CONFIG_CLK_MASK 0x00400000 +#define I2S_CONFIG_CLK_MASTER 0x00400000 +#define I2S_CONFIG_CLK_SLAVE 0x00000000 + +#define I2S_CONFIG_SAMPLE_SIZE_MASK \ + 0x0000FC00 +#define I2S_CONFIG_SAMPLE_SIZE_32 \ + 0x00007C00 +#define I2S_CONFIG_SAMPLE_SIZE_24 \ + 0x00005C00 +#define I2S_CONFIG_SAMPLE_SIZE_20 \ + 0x00004C00 +#define I2S_CONFIG_SAMPLE_SIZE_16 \ + 0x00003C00 +#define I2S_CONFIG_SAMPLE_SIZE_8 \ + 0x00001C00 + +#define I2S_CONFIG_WIRE_SIZE_MASK \ + 0x000003F0 +#define I2S_CONFIG_WIRE_SIZE_32 0x000001F0 +#define I2S_CONFIG_WIRE_SIZE_24 0x00000170 +#define I2S_CONFIG_WIRE_SIZE_20 0x00000130 +#define I2S_CONFIG_WIRE_SIZE_16 0x000000F0 +#define I2S_CONFIG_WIRE_SIZE_8 0x00000070 + +//***************************************************************************** +// +// Values that can be passed to I2SMasterClockSelect() +// +//***************************************************************************** +#define I2S_TX_MCLK_EXT 0x00000010 +#define I2S_TX_MCLK_INT 0x00000000 +#define I2S_RX_MCLK_EXT 0x00000020 +#define I2S_RX_MCLK_INT 0x00000000 + +//***************************************************************************** +// +// Values that can be passed to I2SIntEnable(), I2SIntDisable(), and +// I2SIntClear() +// +//***************************************************************************** +#define I2S_INT_RXERR 0x00000020 +#define I2S_INT_RXREQ 0x00000010 +#define I2S_INT_TXERR 0x00000002 +#define I2S_INT_TXREQ 0x00000001 + +//***************************************************************************** +// +// API Function prototypes +// +//***************************************************************************** +extern void I2STxEnable(unsigned long ulBase); +extern void I2STxDisable(unsigned long ulBase); +extern void I2STxDataPut(unsigned long ulBase, unsigned long ulData); +extern long I2STxDataPutNonBlocking(unsigned long ulBase, + unsigned long ulData); +extern void I2STxConfigSet(unsigned long ulBase, unsigned long ulConfig); +extern void I2STxFIFOLimitSet(unsigned long ulBase, unsigned long ulLevel); +extern unsigned long I2STxFIFOLimitGet(unsigned long ulBase); +extern unsigned long I2STxFIFOLevelGet(unsigned long ulBase); +extern void I2SRxEnable(unsigned long ulBase); +extern void I2SRxDisable(unsigned long ulBase); +extern void I2SRxDataGet(unsigned long ulBase, unsigned long *pulData); +extern long I2SRxDataGetNonBlocking(unsigned long ulBase, + unsigned long *pulData); +extern void I2SRxConfigSet(unsigned long ulBase, unsigned long ulConfig); +extern void I2SRxFIFOLimitSet(unsigned long ulBase, unsigned long ulLevel); +extern unsigned long I2SRxFIFOLimitGet(unsigned long ulBase); +extern unsigned long I2SRxFIFOLevelGet(unsigned long ulBase); +extern void I2STxRxEnable(unsigned long ulBase); +extern void I2STxRxDisable(unsigned long ulBase); +extern void I2STxRxConfigSet(unsigned long ulBase, unsigned long ulConfig); +extern void I2SMasterClockSelect(unsigned long ulBase, unsigned long ulMClock); +extern void I2SIntEnable(unsigned long ulBase, unsigned long ulIntFlags); +extern void I2SIntDisable(unsigned long ulBase, unsigned long ulIntFlags); +extern unsigned long I2SIntStatus(unsigned long ulBase, tBoolean bMasked); +extern void I2SIntClear(unsigned long ulBase, unsigned long ulIntFlags); +extern void I2SIntRegister(unsigned long ulBase, void (*pfnHandler)(void)); +extern void I2SIntUnregister(unsigned long ulBase); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __I2S_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/interrupt.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/interrupt.c new file mode 100644 index 00000000..20e3a052 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/interrupt.c @@ -0,0 +1,723 @@ +//***************************************************************************** +// +// interrupt.c - Driver for the NVIC Interrupt Controller. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup interrupt_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_ints.h" +#include "inc/hw_nvic.h" +#include "inc/hw_types.h" +#include "driverlib/cpu.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" + +//***************************************************************************** +// +// This is a mapping between priority grouping encodings and the number of +// preemption priority bits. +// +//***************************************************************************** +static const unsigned long g_pulPriority[] = +{ + NVIC_APINT_PRIGROUP_0_8, NVIC_APINT_PRIGROUP_1_7, NVIC_APINT_PRIGROUP_2_6, + NVIC_APINT_PRIGROUP_3_5, NVIC_APINT_PRIGROUP_4_4, NVIC_APINT_PRIGROUP_5_3, + NVIC_APINT_PRIGROUP_6_2, NVIC_APINT_PRIGROUP_7_1 +}; + +//***************************************************************************** +// +// This is a mapping between interrupt number and the register that contains +// the priority encoding for that interrupt. +// +//***************************************************************************** +static const unsigned long g_pulRegs[] = +{ + 0, NVIC_SYS_PRI1, NVIC_SYS_PRI2, NVIC_SYS_PRI3, NVIC_PRI0, NVIC_PRI1, + NVIC_PRI2, NVIC_PRI3, NVIC_PRI4, NVIC_PRI5, NVIC_PRI6, NVIC_PRI7, + NVIC_PRI8, NVIC_PRI9, NVIC_PRI10, NVIC_PRI11, NVIC_PRI12, NVIC_PRI13 +}; + +//***************************************************************************** +// +//! \internal +//! The default interrupt handler. +//! +//! This is the default interrupt handler for all interrupts. It simply loops +//! forever so that the system state is preserved for observation by a +//! debugger. Since interrupts should be disabled before unregistering the +//! corresponding handler, this should never be called. +//! +//! \return None. +// +//***************************************************************************** +static void +IntDefaultHandler(void) +{ + // + // Go into an infinite loop. + // + while(1) + { + } +} + +//***************************************************************************** +// +// The processor vector table. +// +// This contains a list of the handlers for the various interrupt sources in +// the system. The layout of this list is defined by the hardware; assertion +// of an interrupt causes the processor to start executing directly at the +// address given in the corresponding location in this list. +// +//***************************************************************************** +#if defined(ewarm) +static __no_init void (*g_pfnRAMVectors[NUM_INTERRUPTS])(void) @ "VTABLE"; +#elif defined(sourcerygxx) +static __attribute__((section(".cs3.region-head.ram"))) +void (*g_pfnRAMVectors[NUM_INTERRUPTS])(void); +#elif defined(ccs) +#pragma DATA_SECTION(g_pfnRAMVectors, ".vtable") +void (*g_pfnRAMVectors[NUM_INTERRUPTS])(void); +#else +static __attribute__((section("vtable"))) +void (*g_pfnRAMVectors[NUM_INTERRUPTS])(void); +#endif + +//***************************************************************************** +// +//! Enables the processor interrupt. +//! +//! Allows the processor to respond to interrupts. This does not affect the +//! set of interrupts enabled in the interrupt controller; it just gates the +//! single interrupt from the controller to the processor. +//! +//! \note Previously, this function had no return value. As such, it was +//! possible to include interrupt.h and call this function without +//! having included hw_types.h. Now that the return is a +//! tBoolean, a compiler error will occur in this case. The solution +//! is to include hw_types.h before including interrupt.h. +//! +//! \return Returns \b true if interrupts were disabled when the function was +//! called or \b false if they were initially enabled. +// +//***************************************************************************** +tBoolean +IntMasterEnable(void) +{ + // + // Enable processor interrupts. + // + return(CPUcpsie()); +} + +//***************************************************************************** +// +//! Disables the processor interrupt. +//! +//! Prevents the processor from receiving interrupts. This does not affect the +//! set of interrupts enabled in the interrupt controller; it just gates the +//! single interrupt from the controller to the processor. +//! +//! \note Previously, this function had no return value. As such, it was +//! possible to include interrupt.h and call this function without +//! having included hw_types.h. Now that the return is a +//! tBoolean, a compiler error will occur in this case. The solution +//! is to include hw_types.h before including interrupt.h. +//! +//! \return Returns \b true if interrupts were already disabled when the +//! function was called or \b false if they were initially enabled. +// +//***************************************************************************** +tBoolean +IntMasterDisable(void) +{ + // + // Disable processor interrupts. + // + return(CPUcpsid()); +} + +//***************************************************************************** +// +//! Registers a function to be called when an interrupt occurs. +//! +//! \param ulInterrupt specifies the interrupt in question. +//! \param pfnHandler is a pointer to the function to be called. +//! +//! This function is used to specify the handler function to be called when the +//! given interrupt is asserted to the processor. When the interrupt occurs, +//! if it is enabled (via IntEnable()), the handler function will be called in +//! interrupt context. Since the handler function can preempt other code, care +//! must be taken to protect memory or peripherals that are accessed by the +//! handler and other non-handler code. +//! +//! \note The use of this function (directly or indirectly via a peripheral +//! driver interrupt register function) moves the interrupt vector table from +//! flash to SRAM. Therefore, care must be taken when linking the application +//! to ensure that the SRAM vector table is located at the beginning of SRAM; +//! otherwise NVIC will not look in the correct portion of memory for the +//! vector table (it requires the vector table be on a 1 kB memory alignment). +//! Normally, the SRAM vector table is so placed via the use of linker scripts. +//! See the discussion of compile-time versus run-time interrupt handler +//! registration in the introduction to this chapter. +//! +//! \return None. +// +//***************************************************************************** +void +IntRegister(unsigned long ulInterrupt, void (*pfnHandler)(void)) +{ + unsigned long ulIdx, ulValue; + + // + // Check the arguments. + // + ASSERT(ulInterrupt < NUM_INTERRUPTS); + + // + // Make sure that the RAM vector table is correctly aligned. + // + ASSERT(((unsigned long)g_pfnRAMVectors & 0x000003ff) == 0); + + // + // See if the RAM vector table has been initialized. + // + if(HWREG(NVIC_VTABLE) != (unsigned long)g_pfnRAMVectors) + { + // + // Copy the vector table from the beginning of FLASH to the RAM vector + // table. + // + ulValue = HWREG(NVIC_VTABLE); + for(ulIdx = 0; ulIdx < NUM_INTERRUPTS; ulIdx++) + { + g_pfnRAMVectors[ulIdx] = (void (*)(void))HWREG((ulIdx * 4) + + ulValue); + } + + // + // Point NVIC at the RAM vector table. + // + HWREG(NVIC_VTABLE) = (unsigned long)g_pfnRAMVectors; + } + + // + // Save the interrupt handler. + // + g_pfnRAMVectors[ulInterrupt] = pfnHandler; +} + +//***************************************************************************** +// +//! Unregisters the function to be called when an interrupt occurs. +//! +//! \param ulInterrupt specifies the interrupt in question. +//! +//! This function is used to indicate that no handler should be called when the +//! given interrupt is asserted to the processor. The interrupt source will be +//! automatically disabled (via IntDisable()) if necessary. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +IntUnregister(unsigned long ulInterrupt) +{ + // + // Check the arguments. + // + ASSERT(ulInterrupt < NUM_INTERRUPTS); + + // + // Reset the interrupt handler. + // + g_pfnRAMVectors[ulInterrupt] = IntDefaultHandler; +} + +//***************************************************************************** +// +//! Sets the priority grouping of the interrupt controller. +//! +//! \param ulBits specifies the number of bits of preemptable priority. +//! +//! This function specifies the split between preemptable priority levels and +//! subpriority levels in the interrupt priority specification. The range of +//! the grouping values are dependent upon the hardware implementation; on +//! the Stellaris family, three bits are available for hardware interrupt +//! prioritization and therefore priority grouping values of three through +//! seven have the same effect. +//! +//! \return None. +// +//***************************************************************************** +void +IntPriorityGroupingSet(unsigned long ulBits) +{ + // + // Check the arguments. + // + ASSERT(ulBits < NUM_PRIORITY); + + // + // Set the priority grouping. + // + HWREG(NVIC_APINT) = NVIC_APINT_VECTKEY | g_pulPriority[ulBits]; +} + +//***************************************************************************** +// +//! Gets the priority grouping of the interrupt controller. +//! +//! This function returns the split between preemptable priority levels and +//! subpriority levels in the interrupt priority specification. +//! +//! \return The number of bits of preemptable priority. +// +//***************************************************************************** +unsigned long +IntPriorityGroupingGet(void) +{ + unsigned long ulLoop, ulValue; + + // + // Read the priority grouping. + // + ulValue = HWREG(NVIC_APINT) & NVIC_APINT_PRIGROUP_M; + + // + // Loop through the priority grouping values. + // + for(ulLoop = 0; ulLoop < NUM_PRIORITY; ulLoop++) + { + // + // Stop looping if this value matches. + // + if(ulValue == g_pulPriority[ulLoop]) + { + break; + } + } + + // + // Return the number of priority bits. + // + return(ulLoop); +} + +//***************************************************************************** +// +//! Sets the priority of an interrupt. +//! +//! \param ulInterrupt specifies the interrupt in question. +//! \param ucPriority specifies the priority of the interrupt. +//! +//! This function is used to set the priority of an interrupt. When multiple +//! interrupts are asserted simultaneously, the ones with the highest priority +//! are processed before the lower priority interrupts. Smaller numbers +//! correspond to higher interrupt priorities; priority 0 is the highest +//! interrupt priority. +//! +//! The hardware priority mechanism will only look at the upper N bits of the +//! priority level (where N is 3 for the Stellaris family), so any +//! prioritization must be performed in those bits. The remaining bits can be +//! used to sub-prioritize the interrupt sources, and may be used by the +//! hardware priority mechanism on a future part. This arrangement allows +//! priorities to migrate to different NVIC implementations without changing +//! the gross prioritization of the interrupts. +//! +//! \return None. +// +//***************************************************************************** +void +IntPrioritySet(unsigned long ulInterrupt, unsigned char ucPriority) +{ + unsigned long ulTemp; + + // + // Check the arguments. + // + ASSERT((ulInterrupt >= 4) && (ulInterrupt < NUM_INTERRUPTS)); + + // + // Set the interrupt priority. + // + ulTemp = HWREG(g_pulRegs[ulInterrupt >> 2]); + ulTemp &= ~(0xFF << (8 * (ulInterrupt & 3))); + ulTemp |= ucPriority << (8 * (ulInterrupt & 3)); + HWREG(g_pulRegs[ulInterrupt >> 2]) = ulTemp; +} + +//***************************************************************************** +// +//! Gets the priority of an interrupt. +//! +//! \param ulInterrupt specifies the interrupt in question. +//! +//! This function gets the priority of an interrupt. See IntPrioritySet() for +//! a definition of the priority value. +//! +//! \return Returns the interrupt priority, or -1 if an invalid interrupt was +//! specified. +// +//***************************************************************************** +long +IntPriorityGet(unsigned long ulInterrupt) +{ + // + // Check the arguments. + // + ASSERT((ulInterrupt >= 4) && (ulInterrupt < NUM_INTERRUPTS)); + + // + // Return the interrupt priority. + // + return((HWREG(g_pulRegs[ulInterrupt >> 2]) >> (8 * (ulInterrupt & 3))) & + 0xFF); +} + +//***************************************************************************** +// +//! Enables an interrupt. +//! +//! \param ulInterrupt specifies the interrupt to be enabled. +//! +//! The specified interrupt is enabled in the interrupt controller. Other +//! enables for the interrupt (such as at the peripheral level) are unaffected +//! by this function. +//! +//! \return None. +// +//***************************************************************************** +void +IntEnable(unsigned long ulInterrupt) +{ + // + // Check the arguments. + // + ASSERT(ulInterrupt < NUM_INTERRUPTS); + + // + // Determine the interrupt to enable. + // + if(ulInterrupt == FAULT_MPU) + { + // + // Enable the MemManage interrupt. + // + HWREG(NVIC_SYS_HND_CTRL) |= NVIC_SYS_HND_CTRL_MEM; + } + else if(ulInterrupt == FAULT_BUS) + { + // + // Enable the bus fault interrupt. + // + HWREG(NVIC_SYS_HND_CTRL) |= NVIC_SYS_HND_CTRL_BUS; + } + else if(ulInterrupt == FAULT_USAGE) + { + // + // Enable the usage fault interrupt. + // + HWREG(NVIC_SYS_HND_CTRL) |= NVIC_SYS_HND_CTRL_USAGE; + } + else if(ulInterrupt == FAULT_SYSTICK) + { + // + // Enable the System Tick interrupt. + // + HWREG(NVIC_ST_CTRL) |= NVIC_ST_CTRL_INTEN; + } + else if((ulInterrupt >= 16) && (ulInterrupt <= 47)) + { + // + // Enable the general interrupt. + // + HWREG(NVIC_EN0) = 1 << (ulInterrupt - 16); + } + else if(ulInterrupt >= 48) + { + // + // Enable the general interrupt. + // + HWREG(NVIC_EN1) = 1 << (ulInterrupt - 48); + } +} + +//***************************************************************************** +// +//! Disables an interrupt. +//! +//! \param ulInterrupt specifies the interrupt to be disabled. +//! +//! The specified interrupt is disabled in the interrupt controller. Other +//! enables for the interrupt (such as at the peripheral level) are unaffected +//! by this function. +//! +//! \return None. +// +//***************************************************************************** +void +IntDisable(unsigned long ulInterrupt) +{ + // + // Check the arguments. + // + ASSERT(ulInterrupt < NUM_INTERRUPTS); + + // + // Determine the interrupt to disable. + // + if(ulInterrupt == FAULT_MPU) + { + // + // Disable the MemManage interrupt. + // + HWREG(NVIC_SYS_HND_CTRL) &= ~(NVIC_SYS_HND_CTRL_MEM); + } + else if(ulInterrupt == FAULT_BUS) + { + // + // Disable the bus fault interrupt. + // + HWREG(NVIC_SYS_HND_CTRL) &= ~(NVIC_SYS_HND_CTRL_BUS); + } + else if(ulInterrupt == FAULT_USAGE) + { + // + // Disable the usage fault interrupt. + // + HWREG(NVIC_SYS_HND_CTRL) &= ~(NVIC_SYS_HND_CTRL_USAGE); + } + else if(ulInterrupt == FAULT_SYSTICK) + { + // + // Disable the System Tick interrupt. + // + HWREG(NVIC_ST_CTRL) &= ~(NVIC_ST_CTRL_INTEN); + } + else if((ulInterrupt >= 16) && (ulInterrupt <= 47)) + { + // + // Disable the general interrupt. + // + HWREG(NVIC_DIS0) = 1 << (ulInterrupt - 16); + } + else if(ulInterrupt >= 48) + { + // + // Disable the general interrupt. + // + HWREG(NVIC_DIS1) = 1 << (ulInterrupt - 48); + } +} + +//***************************************************************************** +// +//! Pends an interrupt. +//! +//! \param ulInterrupt specifies the interrupt to be pended. +//! +//! The specified interrupt is pended in the interrupt controller. This will +//! cause the interrupt controller to execute the corresponding interrupt +//! handler at the next available time, based on the current interrupt state +//! priorities. For example, if called by a higher priority interrupt handler, +//! the specified interrupt handler will not be called until after the current +//! interrupt handler has completed execution. The interrupt must have been +//! enabled for it to be called. +//! +//! \return None. +// +//***************************************************************************** +void +IntPendSet(unsigned long ulInterrupt) +{ + // + // Check the arguments. + // + ASSERT(ulInterrupt < NUM_INTERRUPTS); + + // + // Determine the interrupt to pend. + // + if(ulInterrupt == FAULT_NMI) + { + // + // Pend the NMI interrupt. + // + HWREG(NVIC_INT_CTRL) |= NVIC_INT_CTRL_NMI_SET; + } + else if(ulInterrupt == FAULT_PENDSV) + { + // + // Pend the PendSV interrupt. + // + HWREG(NVIC_INT_CTRL) |= NVIC_INT_CTRL_PEND_SV; + } + else if(ulInterrupt == FAULT_SYSTICK) + { + // + // Pend the SysTick interrupt. + // + HWREG(NVIC_INT_CTRL) |= NVIC_INT_CTRL_PENDSTSET; + } + else if((ulInterrupt >= 16) && (ulInterrupt <= 47)) + { + // + // Pend the general interrupt. + // + HWREG(NVIC_PEND0) = 1 << (ulInterrupt - 16); + } + else if(ulInterrupt >= 48) + { + // + // Pend the general interrupt. + // + HWREG(NVIC_PEND1) = 1 << (ulInterrupt - 48); + } +} + +//***************************************************************************** +// +//! Unpends an interrupt. +//! +//! \param ulInterrupt specifies the interrupt to be unpended. +//! +//! The specified interrupt is unpended in the interrupt controller. This will +//! cause any previously generated interrupts that have not been handled yet +//! (due to higher priority interrupts or the interrupt no having been enabled +//! yet) to be discarded. +//! +//! \return None. +// +//***************************************************************************** +void +IntPendClear(unsigned long ulInterrupt) +{ + // + // Check the arguments. + // + ASSERT(ulInterrupt < NUM_INTERRUPTS); + + // + // Determine the interrupt to unpend. + // + if(ulInterrupt == FAULT_PENDSV) + { + // + // Unpend the PendSV interrupt. + // + HWREG(NVIC_INT_CTRL) |= NVIC_INT_CTRL_UNPEND_SV; + } + else if(ulInterrupt == FAULT_SYSTICK) + { + // + // Unpend the SysTick interrupt. + // + HWREG(NVIC_INT_CTRL) |= NVIC_INT_CTRL_PENDSTCLR; + } + else if((ulInterrupt >= 16) && (ulInterrupt <= 47)) + { + // + // Unpend the general interrupt. + // + HWREG(NVIC_UNPEND0) = 1 << (ulInterrupt - 16); + } + else if(ulInterrupt >= 48) + { + // + // Unpend the general interrupt. + // + HWREG(NVIC_UNPEND1) = 1 << (ulInterrupt - 48); + } +} + +//***************************************************************************** +// +//! Sets the priority masking level +//! +//! \param ulPriorityMask is the priority level that will be masked. +//! +//! This function sets the interrupt priority masking level so that all +//! interrupts at the specified or lesser priority level is masked. This +//! can be used to globally disable a set of interrupts with priority below +//! a predetermined threshold. A value of 0 disables priority +//! masking. +//! +//! Smaller numbers correspond to higher interrupt priorities. So for example +//! a priority level mask of 4 will allow interrupts of priority level 0-3, +//! and interrupts with a numerical priority of 4 and greater will be blocked. +//! +//! The hardware priority mechanism will only look at the upper N bits of the +//! priority level (where N is 3 for the Stellaris family), so any +//! prioritization must be performed in those bits. +//! +//! \return None. +// +//***************************************************************************** +void +IntPriorityMaskSet(unsigned long ulPriorityMask) +{ + CPUbasepriSet(ulPriorityMask); +} + +//***************************************************************************** +// +//! Gets the priority masking level +//! +//! This function gets the current setting of the interrupt priority masking +//! level. The value returned is the priority level such that all interrupts +//! of that and lesser priority are masked. A value of 0 means that priority +//! masking is disabled. +//! +//! Smaller numbers correspond to higher interrupt priorities. So for example +//! a priority level mask of 4 will allow interrupts of priority level 0-3, +//! and interrupts with a numerical priority of 4 and greater will be blocked. +//! +//! The hardware priority mechanism will only look at the upper N bits of the +//! priority level (where N is 3 for the Stellaris family), so any +//! prioritization must be performed in those bits. +//! +//! \return Returns the value of the interrupt priority level mask. +// +//***************************************************************************** +unsigned long +IntPriorityMaskGet(void) +{ + return(CPUbasepriGet()); +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/interrupt.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/interrupt.h new file mode 100644 index 00000000..954f5775 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/interrupt.h @@ -0,0 +1,77 @@ +//***************************************************************************** +// +// interrupt.h - Prototypes for the NVIC Interrupt Controller Driver. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __INTERRUPT_H__ +#define __INTERRUPT_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Macro to generate an interrupt priority mask based on the number of bits +// of priority supported by the hardware. +// +//***************************************************************************** +#define INT_PRIORITY_MASK ((0xFF << (8 - NUM_PRIORITY_BITS)) & 0xFF) + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern tBoolean IntMasterEnable(void); +extern tBoolean IntMasterDisable(void); +extern void IntRegister(unsigned long ulInterrupt, void (*pfnHandler)(void)); +extern void IntUnregister(unsigned long ulInterrupt); +extern void IntPriorityGroupingSet(unsigned long ulBits); +extern unsigned long IntPriorityGroupingGet(void); +extern void IntPrioritySet(unsigned long ulInterrupt, + unsigned char ucPriority); +extern long IntPriorityGet(unsigned long ulInterrupt); +extern void IntEnable(unsigned long ulInterrupt); +extern void IntDisable(unsigned long ulInterrupt); +extern void IntPendSet(unsigned long ulInterrupt); +extern void IntPendClear(unsigned long ulInterrupt); +extern void IntPriorityMaskSet(unsigned long ulPriorityMask); +extern unsigned long IntPriorityMaskGet(void); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __INTERRUPT_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/mpu.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/mpu.c new file mode 100644 index 00000000..cb570006 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/mpu.c @@ -0,0 +1,446 @@ +//***************************************************************************** +// +// mpu.c - Driver for the Cortex-M3 memory protection unit (MPU). +// +// Copyright (c) 2007-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup mpu_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_ints.h" +#include "inc/hw_nvic.h" +#include "inc/hw_types.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" +#include "driverlib/mpu.h" + +//***************************************************************************** +// +//! Enables and configures the MPU for use. +//! +//! \param ulMPUConfig is the logical OR of the possible configurations. +//! +//! This function enables the Cortex-M3 memory protection unit. It also +//! configures the default behavior when in privileged mode and while +//! handling a hard fault or NMI. Prior to enabling the MPU, at least one +//! region must be set by calling MPURegionSet() or else by enabling the +//! default region for privileged mode by passing the +//! \b MPU_CONFIG_PRIV_DEFAULT flag to MPUEnable(). +//! Once the MPU is enabled, a memory management fault will be generated +//! for any memory access violations. +//! +//! The \e ulMPUConfig parameter should be the logical OR of any of the +//! following: +//! +//! - \b MPU_CONFIG_PRIV_DEFAULT enables the default memory map when in +//! privileged mode and when no other regions are defined. If this option +//! is not enabled, then there must be at least one valid region already +//! defined when the MPU is enabled. +//! - \b MPU_CONFIG_HARDFLT_NMI enables the MPU while in a hard fault or NMI +//! exception handler. If this option is not enabled, then the MPU is +//! disabled while in one of these exception handlers and the default +//! memory map is applied. +//! - \b MPU_CONFIG_NONE chooses none of the above options. In this case, +//! no default memory map is provided in privileged mode, and the MPU will +//! not be enabled in the fault handlers. +//! +//! \return None. +// +//***************************************************************************** +void +MPUEnable(unsigned long ulMPUConfig) +{ + // + // Check the arguments. + // + ASSERT(!(ulMPUConfig & ~(MPU_CONFIG_PRIV_DEFAULT | + MPU_CONFIG_HARDFLT_NMI))); + + // + // Set the MPU control bits according to the flags passed by the user, + // and also set the enable bit. + // + HWREG(NVIC_MPU_CTRL) = ulMPUConfig | NVIC_MPU_CTRL_ENABLE; +} + +//***************************************************************************** +// +//! Disables the MPU for use. +//! +//! This function disables the Cortex-M3 memory protection unit. When the +//! MPU is disabled, the default memory map is used and memory management +//! faults are not generated. +//! +//! \return None. +// +//***************************************************************************** +void +MPUDisable(void) +{ + // + // Turn off the MPU enable bit. + // + HWREG(NVIC_MPU_CTRL) &= ~NVIC_MPU_CTRL_ENABLE; +} + +//***************************************************************************** +// +//! Gets the count of regions supported by the MPU. +//! +//! This function is used to get the number of regions that are supported by +//! the MPU. This is the total number that are supported, including regions +//! that are already programmed. +//! +//! \return The number of memory protection regions that are available +//! for programming using MPURegionSet(). +// +//***************************************************************************** +unsigned long +MPURegionCountGet(void) +{ + // + // Read the DREGION field of the MPU type register, and mask off + // the bits of interest to get the count of regions. + // + return((HWREG(NVIC_MPU_TYPE) & NVIC_MPU_TYPE_DREGION_M) + >> NVIC_MPU_TYPE_DREGION_S); +} + +//***************************************************************************** +// +//! Enables a specific region. +//! +//! \param ulRegion is the region number to enable. +//! +//! This function is used to enable a memory protection region. The region +//! should already be set up with the MPURegionSet() function. Once enabled, +//! the memory protection rules of the region will be applied and access +//! violations will cause a memory management fault. +//! +//! \return None. +// +//***************************************************************************** +void +MPURegionEnable(unsigned long ulRegion) +{ + // + // Check the arguments. + // + ASSERT(ulRegion < 8); + + // + // Select the region to modify. + // + HWREG(NVIC_MPU_NUMBER) = ulRegion; + + // + // Modify the enable bit in the region attributes. + // + HWREG(NVIC_MPU_ATTR) |= NVIC_MPU_ATTR_ENABLE; +} + +//***************************************************************************** +// +//! Disables a specific region. +//! +//! \param ulRegion is the region number to disable. +//! +//! This function is used to disable a previously enabled memory protection +//! region. The region will remain configured if it is not overwritten with +//! another call to MPURegionSet(), and can be enabled again by calling +//! MPURegionEnable(). +//! +//! \return None. +// +//***************************************************************************** +void +MPURegionDisable(unsigned long ulRegion) +{ + // + // Check the arguments. + // + ASSERT(ulRegion < 8); + + // + // Select the region to modify. + // + HWREG(NVIC_MPU_NUMBER) = ulRegion; + + // + // Modify the enable bit in the region attributes. + // + HWREG(NVIC_MPU_ATTR) &= ~NVIC_MPU_ATTR_ENABLE; +} + +//***************************************************************************** +// +//! Sets up the access rules for a specific region. +//! +//! \param ulRegion is the region number to set up. +//! \param ulAddr is the base address of the region. It must be aligned +//! according to the size of the region specified in ulFlags. +//! \param ulFlags is a set of flags to define the attributes of the region. +//! +//! This function sets up the protection rules for a region. The region has +//! a base address and a set of attributes including the size, which must +//! be a power of 2. The base address parameter, \e ulAddr, must be aligned +//! according to the size. +//! +//! The \e ulFlags parameter is the logical OR of all of the attributes +//! of the region. It is a combination of choices for region size, +//! execute permission, read/write permissions, disabled sub-regions, +//! and a flag to determine if the region is enabled. +//! +//! The size flag determines the size of a region, and must be one of the +//! following: +//! +//! - \b MPU_RGN_SIZE_32B +//! - \b MPU_RGN_SIZE_64B +//! - \b MPU_RGN_SIZE_128B +//! - \b MPU_RGN_SIZE_256B +//! - \b MPU_RGN_SIZE_512B +//! - \b MPU_RGN_SIZE_1K +//! - \b MPU_RGN_SIZE_2K +//! - \b MPU_RGN_SIZE_4K +//! - \b MPU_RGN_SIZE_8K +//! - \b MPU_RGN_SIZE_16K +//! - \b MPU_RGN_SIZE_32K +//! - \b MPU_RGN_SIZE_64K +//! - \b MPU_RGN_SIZE_128K +//! - \b MPU_RGN_SIZE_256K +//! - \b MPU_RGN_SIZE_512K +//! - \b MPU_RGN_SIZE_1M +//! - \b MPU_RGN_SIZE_2M +//! - \b MPU_RGN_SIZE_4M +//! - \b MPU_RGN_SIZE_8M +//! - \b MPU_RGN_SIZE_16M +//! - \b MPU_RGN_SIZE_32M +//! - \b MPU_RGN_SIZE_64M +//! - \b MPU_RGN_SIZE_128M +//! - \b MPU_RGN_SIZE_256M +//! - \b MPU_RGN_SIZE_512M +//! - \b MPU_RGN_SIZE_1G +//! - \b MPU_RGN_SIZE_2G +//! - \b MPU_RGN_SIZE_4G +//! +//! The execute permission flag must be one of the following: +//! +//! - \b MPU_RGN_PERM_EXEC enables the region for execution of code +//! - \b MPU_RGN_PERM_NOEXEC disables the region for execution of code +//! +//! The read/write access permissions are applied separately for the +//! privileged and user modes. The read/write access flags must be one +//! of the following: +//! +//! - \b MPU_RGN_PERM_PRV_NO_USR_NO - no access in privileged or user mode +//! - \b MPU_RGN_PERM_PRV_RW_USR_NO - privileged read/write, user no access +//! - \b MPU_RGN_PERM_PRV_RW_USR_RO - privileged read/write, user read-only +//! - \b MPU_RGN_PERM_PRV_RW_USR_RW - privileged read/write, user read/write +//! - \b MPU_RGN_PERM_PRV_RO_USR_NO - privileged read-only, user no access +//! - \b MPU_RGN_PERM_PRV_RO_USR_RO - privileged read-only, user read-only +//! +//! The region is automatically divided into 8 equally-sized sub-regions by +//! the MPU. Sub-regions can only be used in regions of size 256 bytes +//! or larger. Any of these 8 sub-regions can be disabled. This allows +//! for creation of ``holes'' in a region which can be left open, or overlaid +//! by another region with different attributes. Any of the 8 sub-regions +//! can be disabled with a logical OR of any of the following flags: +//! +//! - \b MPU_SUB_RGN_DISABLE_0 +//! - \b MPU_SUB_RGN_DISABLE_1 +//! - \b MPU_SUB_RGN_DISABLE_2 +//! - \b MPU_SUB_RGN_DISABLE_3 +//! - \b MPU_SUB_RGN_DISABLE_4 +//! - \b MPU_SUB_RGN_DISABLE_5 +//! - \b MPU_SUB_RGN_DISABLE_6 +//! - \b MPU_SUB_RGN_DISABLE_7 +//! +//! Finally, the region can be initially enabled or disabled with one of +//! the following flags: +//! +//! - \b MPU_RGN_ENABLE +//! - \b MPU_RGN_DISABLE +//! +//! As an example, to set a region with the following attributes: size of +//! 32 KB, execution enabled, read-only for both privileged and user, one +//! sub-region disabled, and initially enabled; the \e ulFlags parameter would +//! have the following value: +//! +//! +//! (MPU_RG_SIZE_32K | MPU_RGN_PERM_EXEC | MPU_RGN_PERM_PRV_RO_USR_RO | +//! MPU_SUB_RGN_DISABLE_2 | MPU_RGN_ENABLE) +//! +//! +//! \note This function will write to multiple registers and is not protected +//! from interrupts. It is possible that an interrupt which accesses a +//! region may occur while that region is in the process of being changed. +//! The safest way to handle this is to disable a region before changing it. +//! Refer to the discussion of this in the API Detailed Description section. +//! +//! \return None. +// +//***************************************************************************** +void +MPURegionSet(unsigned long ulRegion, unsigned long ulAddr, + unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulRegion < 8); + ASSERT((ulAddr & ~0 << (((ulFlags & NVIC_MPU_ATTR_SIZE_M) >> 1) + 1)) + == ulAddr); + + // + // Program the base address, use the region field to select the + // region at the same time. + // + HWREG(NVIC_MPU_BASE) = ulAddr | ulRegion | NVIC_MPU_BASE_VALID; + + // + // Program the region attributes. Set the TEX field and the S, C, + // and B bits to fixed values that are suitable for all Stellaris + // memory. + // + HWREG(NVIC_MPU_ATTR) = (ulFlags & ~(NVIC_MPU_ATTR_TEX_M | + NVIC_MPU_ATTR_CACHEABLE)) | + NVIC_MPU_ATTR_SHAREABLE | + NVIC_MPU_ATTR_BUFFRABLE; +} + +//***************************************************************************** +// +//! Gets the current settings for a specific region. +//! +//! \param ulRegion is the region number to get. +//! \param pulAddr points to storage for the base address of the region. +//! \param pulFlags points to the attribute flags for the region. +//! +//! This function retrieves the configuration of a specific region. The +//! meanings and format of the parameters is the same as that of the +//! MPURegionSet() function. +//! +//! This function can be used to save the configuration of a region for +//! later use with the MPURegionSet() function. The region's enable state +//! will be preserved in the attributes that are saved. +//! +//! \return None. +// +//***************************************************************************** +void +MPURegionGet(unsigned long ulRegion, unsigned long *pulAddr, + unsigned long *pulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulRegion < 8); + ASSERT(pulAddr); + ASSERT(pulFlags); + + // + // Select the region to get. + // + HWREG(NVIC_MPU_NUMBER) = ulRegion; + + // + // Read and store the base address for the region. + // + *pulAddr = HWREG(NVIC_MPU_BASE); + + // + // Read and store the region attributes. + // + *pulFlags = HWREG(NVIC_MPU_ATTR); +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the memory management fault. +//! +//! \param pfnHandler is a pointer to the function to be called when the +//! memory management fault occurs. +//! +//! This sets and enables the handler to be called when the MPU generates +//! a memory management fault due to a protection region access violation. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +MPUIntRegister(void (*pfnHandler)(void)) +{ + // + // Check the arguments. + // + ASSERT(pfnHandler); + + // + // Register the interrupt handler. + // + IntRegister(FAULT_MPU, pfnHandler); + + // + // Enable the memory management fault. + // + IntEnable(FAULT_MPU); +} + +//***************************************************************************** +// +//! Unregisters an interrupt handler for the memory management fault. +//! +//! This function will disable and clear the handler to be called when a +//! memory management fault occurs. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +MPUIntUnregister(void) +{ + // + // Disable the interrupt. + // + IntDisable(FAULT_MPU); + + // + // Unregister the interrupt handler. + // + IntUnregister(FAULT_MPU); +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/mpu.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/mpu.h new file mode 100644 index 00000000..744be354 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/mpu.h @@ -0,0 +1,147 @@ +//***************************************************************************** +// +// mpu.h - Defines and Macros for the memory protection unit. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __MPU_H__ +#define __MPU_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Flags that can be passed to MPUEnable. +// +//***************************************************************************** +#define MPU_CONFIG_PRIV_DEFAULT 4 +#define MPU_CONFIG_HARDFLT_NMI 2 +#define MPU_CONFIG_NONE 0 + +//***************************************************************************** +// +// Flags for the region size to be passed to MPURegionSet. +// +//***************************************************************************** +#define MPU_RGN_SIZE_32B (4 << 1) +#define MPU_RGN_SIZE_64B (5 << 1) +#define MPU_RGN_SIZE_128B (6 << 1) +#define MPU_RGN_SIZE_256B (7 << 1) +#define MPU_RGN_SIZE_512B (8 << 1) + +#define MPU_RGN_SIZE_1K (9 << 1) +#define MPU_RGN_SIZE_2K (10 << 1) +#define MPU_RGN_SIZE_4K (11 << 1) +#define MPU_RGN_SIZE_8K (12 << 1) +#define MPU_RGN_SIZE_16K (13 << 1) +#define MPU_RGN_SIZE_32K (14 << 1) +#define MPU_RGN_SIZE_64K (15 << 1) +#define MPU_RGN_SIZE_128K (16 << 1) +#define MPU_RGN_SIZE_256K (17 << 1) +#define MPU_RGN_SIZE_512K (18 << 1) + +#define MPU_RGN_SIZE_1M (19 << 1) +#define MPU_RGN_SIZE_2M (20 << 1) +#define MPU_RGN_SIZE_4M (21 << 1) +#define MPU_RGN_SIZE_8M (22 << 1) +#define MPU_RGN_SIZE_16M (23 << 1) +#define MPU_RGN_SIZE_32M (24 << 1) +#define MPU_RGN_SIZE_64M (25 << 1) +#define MPU_RGN_SIZE_128M (26 << 1) +#define MPU_RGN_SIZE_256M (27 << 1) +#define MPU_RGN_SIZE_512M (28 << 1) + +#define MPU_RGN_SIZE_1G (29 << 1) +#define MPU_RGN_SIZE_2G (30 << 1) +#define MPU_RGN_SIZE_4G (31 << 1) + +//***************************************************************************** +// +// Flags for the permissions to be passed to MPURegionSet. +// +//***************************************************************************** +#define MPU_RGN_PERM_EXEC 0x00000000 +#define MPU_RGN_PERM_NOEXEC 0x10000000 +#define MPU_RGN_PERM_PRV_NO_USR_NO 0x00000000 +#define MPU_RGN_PERM_PRV_RW_USR_NO 0x01000000 +#define MPU_RGN_PERM_PRV_RW_USR_RO 0x02000000 +#define MPU_RGN_PERM_PRV_RW_USR_RW 0x03000000 +#define MPU_RGN_PERM_PRV_RO_USR_NO 0x05000000 +#define MPU_RGN_PERM_PRV_RO_USR_RO 0x06000000 + +//***************************************************************************** +// +// Flags for the sub-region to be passed to MPURegionSet. +// +//***************************************************************************** +#define MPU_SUB_RGN_DISABLE_0 0x00000100 +#define MPU_SUB_RGN_DISABLE_1 0x00000200 +#define MPU_SUB_RGN_DISABLE_2 0x00000400 +#define MPU_SUB_RGN_DISABLE_3 0x00000800 +#define MPU_SUB_RGN_DISABLE_4 0x00001000 +#define MPU_SUB_RGN_DISABLE_5 0x00002000 +#define MPU_SUB_RGN_DISABLE_6 0x00004000 +#define MPU_SUB_RGN_DISABLE_7 0x00008000 + +//***************************************************************************** +// +// Flags to enable or disable a region, to be passed to MPURegionSet. +// +//***************************************************************************** +#define MPU_RGN_ENABLE 1 +#define MPU_RGN_DISABLE 0 + +//***************************************************************************** +// +// API Function prototypes +// +//***************************************************************************** +extern void MPUEnable(unsigned long ulMPUConfig); +extern void MPUDisable(void); +extern unsigned long MPURegionCountGet(void); +extern void MPURegionEnable(unsigned long ulRegion); +extern void MPURegionDisable(unsigned long ulRegion); +extern void MPURegionSet(unsigned long ulRegion, unsigned long ulAddr, + unsigned long ulFlags); +extern void MPURegionGet(unsigned long ulRegion, unsigned long *pulAddr, + unsigned long *pulFlags); +extern void MPUIntRegister(void (*pfnHandler)(void)); +extern void MPUIntUnregister(void); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __MPU_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/pin_map.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/pin_map.h new file mode 100644 index 00000000..d946c355 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/pin_map.h @@ -0,0 +1,20413 @@ +//***************************************************************************** +// +// pin_map.h - Mapping of peripherals to pins for all parts. +// +// Copyright (c) 2007-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __PIN_MAP_H__ +#define __PIN_MAP_H__ + +//***************************************************************************** +// +// LM3S101 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S101 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define 32KHZ_PERIPH (SYSCTL_PERIPH_GPIOB) +#define 32KHZ_PORT (GPIO_PORTB_BASE) +#define 32KHZ_PIN (GPIO_PIN_1) + +#endif // PART_LM3S101 + +//***************************************************************************** +// +// LM3S102 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S102 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP1_PORT (GPIO_PORTB_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define 32KHZ_PERIPH (SYSCTL_PERIPH_GPIOB) +#define 32KHZ_PORT (GPIO_PORTB_BASE) +#define 32KHZ_PIN (GPIO_PIN_1) + +#endif // PART_LM3S102 + +//***************************************************************************** +// +// LM3S300 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S300 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2O_PORT (GPIO_PORTC_BASE) +#define C2O_PIN (GPIO_PIN_6) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP1_PORT (GPIO_PORTE_BASE) +#define CCP1_PIN (GPIO_PIN_3) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP4_PORT (GPIO_PORTE_BASE) +#define CCP4_PIN (GPIO_PIN_2) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP5_PORT (GPIO_PORTE_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S300 + +//***************************************************************************** +// +// LM3S301 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S301 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S301 + +//***************************************************************************** +// +// LM3S308 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S308 + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S308 + +//***************************************************************************** +// +// LM3S310 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S310 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2O_PORT (GPIO_PORTC_BASE) +#define C2O_PIN (GPIO_PIN_6) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP1_PORT (GPIO_PORTE_BASE) +#define CCP1_PIN (GPIO_PIN_3) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP4_PORT (GPIO_PORTE_BASE) +#define CCP4_PIN (GPIO_PIN_2) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP5_PORT (GPIO_PORTE_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S310 + +//***************************************************************************** +// +// LM3S315 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S315 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S315 + +//***************************************************************************** +// +// LM3S316 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S316 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S316 + +//***************************************************************************** +// +// LM3S317 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S317 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOB) +#define FAULT_PORT (GPIO_PORTB_BASE) +#define FAULT_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S317 + +//***************************************************************************** +// +// LM3S328 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S328 + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S328 + +//***************************************************************************** +// +// LM3S600 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S600 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2O_PORT (GPIO_PORTC_BASE) +#define C2O_PIN (GPIO_PIN_6) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP1_PORT (GPIO_PORTE_BASE) +#define CCP1_PIN (GPIO_PIN_3) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP4_PORT (GPIO_PORTE_BASE) +#define CCP4_PIN (GPIO_PIN_2) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP5_PORT (GPIO_PORTE_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S600 + +//***************************************************************************** +// +// LM3S601 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S601 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP1_PORT (GPIO_PORTE_BASE) +#define CCP1_PIN (GPIO_PIN_3) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP4_PORT (GPIO_PORTE_BASE) +#define CCP4_PIN (GPIO_PIN_2) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP5_PORT (GPIO_PORTE_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define IDX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX_PORT (GPIO_PORTD_BASE) +#define IDX_PIN (GPIO_PIN_7) + +#define PHA_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA_PORT (GPIO_PORTC_BASE) +#define PHA_PIN (GPIO_PIN_4) + +#define PHB_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB_PORT (GPIO_PORTC_BASE) +#define PHB_PIN (GPIO_PIN_6) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S601 + +//***************************************************************************** +// +// LM3S608 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S608 + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S608 + +//***************************************************************************** +// +// LM3S610 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S610 + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP1_PORT (GPIO_PORTE_BASE) +#define CCP1_PIN (GPIO_PIN_3) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S610 + +//***************************************************************************** +// +// LM3S611 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S611 + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S611 + +//***************************************************************************** +// +// LM3S612 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S612 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP1_PORT (GPIO_PORTE_BASE) +#define CCP1_PIN (GPIO_PIN_3) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S612 + +//***************************************************************************** +// +// LM3S613 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S613 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S613 + +//***************************************************************************** +// +// LM3S615 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S615 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP1_PORT (GPIO_PORTE_BASE) +#define CCP1_PIN (GPIO_PIN_3) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP4_PORT (GPIO_PORTE_BASE) +#define CCP4_PIN (GPIO_PIN_2) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S615 + +//***************************************************************************** +// +// LM3S617 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S617 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOB) +#define FAULT_PORT (GPIO_PORTB_BASE) +#define FAULT_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S617 + +//***************************************************************************** +// +// LM3S618 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S618 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOB) +#define FAULT_PORT (GPIO_PORTB_BASE) +#define FAULT_PIN (GPIO_PIN_3) + +#define IDX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define IDX_PORT (GPIO_PORTB_BASE) +#define IDX_PIN (GPIO_PIN_2) + +#define PHA_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA_PORT (GPIO_PORTC_BASE) +#define PHA_PIN (GPIO_PIN_4) + +#define PHB_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB_PORT (GPIO_PORTC_BASE) +#define PHB_PIN (GPIO_PIN_6) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S618 + +//***************************************************************************** +// +// LM3S628 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S628 + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S628 + +//***************************************************************************** +// +// LM3S800 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S800 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2O_PORT (GPIO_PORTC_BASE) +#define C2O_PIN (GPIO_PIN_6) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP1_PORT (GPIO_PORTE_BASE) +#define CCP1_PIN (GPIO_PIN_3) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP4_PORT (GPIO_PORTE_BASE) +#define CCP4_PIN (GPIO_PIN_2) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP5_PORT (GPIO_PORTE_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S800 + +//***************************************************************************** +// +// LM3S801 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S801 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP1_PORT (GPIO_PORTE_BASE) +#define CCP1_PIN (GPIO_PIN_3) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP4_PORT (GPIO_PORTE_BASE) +#define CCP4_PIN (GPIO_PIN_2) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP5_PORT (GPIO_PORTE_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define IDX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX_PORT (GPIO_PORTD_BASE) +#define IDX_PIN (GPIO_PIN_7) + +#define PHA_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA_PORT (GPIO_PORTC_BASE) +#define PHA_PIN (GPIO_PIN_4) + +#define PHB_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB_PORT (GPIO_PORTC_BASE) +#define PHB_PIN (GPIO_PIN_6) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S801 + +//***************************************************************************** +// +// LM3S808 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S808 + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S808 + +//***************************************************************************** +// +// LM3S811 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S811 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S811 + +//***************************************************************************** +// +// LM3S812 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S812 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP1_PORT (GPIO_PORTE_BASE) +#define CCP1_PIN (GPIO_PIN_3) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S812 + +//***************************************************************************** +// +// LM3S815 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S815 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP1_PORT (GPIO_PORTE_BASE) +#define CCP1_PIN (GPIO_PIN_3) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP4_PORT (GPIO_PORTE_BASE) +#define CCP4_PIN (GPIO_PIN_2) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S815 + +//***************************************************************************** +// +// LM3S817 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S817 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOB) +#define FAULT_PORT (GPIO_PORTB_BASE) +#define FAULT_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S817 + +//***************************************************************************** +// +// LM3S818 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S818 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOB) +#define FAULT_PORT (GPIO_PORTB_BASE) +#define FAULT_PIN (GPIO_PIN_3) + +#define IDX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define IDX_PORT (GPIO_PORTB_BASE) +#define IDX_PIN (GPIO_PIN_2) + +#define PHA_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA_PORT (GPIO_PORTC_BASE) +#define PHA_PIN (GPIO_PIN_4) + +#define PHB_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB_PORT (GPIO_PORTC_BASE) +#define PHB_PIN (GPIO_PIN_6) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S818 + +//***************************************************************************** +// +// LM3S828 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S828 + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define I2CSCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSCL_PORT (GPIO_PORTB_BASE) +#define I2CSCL_PIN (GPIO_PIN_2) + +#define I2CSDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2CSDA_PORT (GPIO_PORTB_BASE) +#define I2CSDA_PIN (GPIO_PIN_3) + +#define SSICLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSICLK_PORT (GPIO_PORTA_BASE) +#define SSICLK_PIN (GPIO_PIN_2) + +#define SSIFSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIFSS_PORT (GPIO_PORTA_BASE) +#define SSIFSS_PIN (GPIO_PIN_3) + +#define SSIRX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSIRX_PORT (GPIO_PORTA_BASE) +#define SSIRX_PIN (GPIO_PIN_4) + +#define SSITX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSITX_PORT (GPIO_PORTA_BASE) +#define SSITX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S828 + +//***************************************************************************** +// +// LM3S1110 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1110 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C1O_PORT (GPIO_PORTE_BASE) +#define C1O_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S1110 + +//***************************************************************************** +// +// LM3S1133 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1133 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1133 + +//***************************************************************************** +// +// LM3S1138 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1138 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2O_PORT (GPIO_PORTC_BASE) +#define C2O_PIN (GPIO_PIN_6) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CCP1_PORT (GPIO_PORTF_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOG) +#define CCP3_PORT (GPIO_PORTG_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CCP4_PORT (GPIO_PORTF_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1138 + +//***************************************************************************** +// +// LM3S1150 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1150 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PHA0_PORT (GPIO_PORTD_BASE) +#define PHA0_PIN (GPIO_PIN_1) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PHB0_PORT (GPIO_PORTF_BASE) +#define PHB0_PIN (GPIO_PIN_0) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM1_PORT (GPIO_PORTF_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_6) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1150 + +//***************************************************************************** +// +// LM3S1162 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1162 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM4_PORT (GPIO_PORTF_BASE) +#define PWM4_PIN (GPIO_PIN_2) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM5_PORT (GPIO_PORTF_BASE) +#define PWM5_PIN (GPIO_PIN_3) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1162 + +//***************************************************************************** +// +// LM3S1165 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1165 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP6_PORT (GPIO_PORTB_BASE) +#define CCP6_PIN (GPIO_PIN_5) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM4_PORT (GPIO_PORTF_BASE) +#define PWM4_PIN (GPIO_PIN_2) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM5_PORT (GPIO_PORTF_BASE) +#define PWM5_PIN (GPIO_PIN_3) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1165 + +//***************************************************************************** +// +// LM3S1332 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1332 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S1332 + +//***************************************************************************** +// +// LM3S1435 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1435 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S1435 + +//***************************************************************************** +// +// LM3S1439 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1439 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB0_PORT (GPIO_PORTC_BASE) +#define PHB0_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM4_PORT (GPIO_PORTF_BASE) +#define PWM4_PIN (GPIO_PIN_2) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM5_PORT (GPIO_PORTF_BASE) +#define PWM5_PIN (GPIO_PIN_3) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S1439 + +//***************************************************************************** +// +// LM3S1512 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1512 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C2O_PORT (GPIO_PORTF_BASE) +#define C2O_PIN (GPIO_PIN_6) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP1_PORT (GPIO_PORTD_BASE) +#define CCP1_PIN (GPIO_PIN_7) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP4_PORT (GPIO_PORTD_BASE) +#define CCP4_PIN (GPIO_PIN_5) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_0) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PHA0_PORT (GPIO_PORTD_BASE) +#define PHA0_PIN (GPIO_PIN_1) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PHB0_PORT (GPIO_PORTF_BASE) +#define PHB0_PIN (GPIO_PIN_0) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1512 + +//***************************************************************************** +// +// LM3S1538 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1538 + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP1_PORT (GPIO_PORTB_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_0) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PHB0_PORT (GPIO_PORTF_BASE) +#define PHB0_PIN (GPIO_PIN_0) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1538 + +//***************************************************************************** +// +// LM3S1601 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1601 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C1O_PORT (GPIO_PORTE_BASE) +#define C1O_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP1_PORT (GPIO_PORTD_BASE) +#define CCP1_PIN (GPIO_PIN_7) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1601 + +//***************************************************************************** +// +// LM3S1607 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1607 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_3) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_2) + +#define ADC6_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC6_PORT (GPIO_PORTD_BASE) +#define ADC6_PIN (GPIO_PIN_1) + +#define ADC7_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC7_PORT (GPIO_PORTD_BASE) +#define ADC7_PIN (GPIO_PIN_0) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_5) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP2_PORT (GPIO_PORTC_BASE) +#define CCP2_PIN (GPIO_PIN_4) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1RX_PORT (GPIO_PORTB_BASE) +#define U1RX_PIN (GPIO_PIN_0) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1TX_PORT (GPIO_PORTB_BASE) +#define U1TX_PIN (GPIO_PIN_1) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U2RX_PORT (GPIO_PORTB_BASE) +#define U2RX_PIN (GPIO_PIN_4) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define U2TX_PORT (GPIO_PORTE_BASE) +#define U2TX_PIN (GPIO_PIN_4) + +#endif // PART_LM3S1607 + +//***************************************************************************** +// +// LM3S1608 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1608 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CCP1_PORT (GPIO_PORTF_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S1608 + +//***************************************************************************** +// +// LM3S1620 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1620 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PHB0_PORT (GPIO_PORTF_BASE) +#define PHB0_PIN (GPIO_PIN_0) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_6) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S1620 + +//***************************************************************************** +// +// LM3S1625 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1625 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_3) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_2) + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP0_PORT (GPIO_PORTC_BASE) +#define CCP0_PIN (GPIO_PIN_7) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP2_PORT (GPIO_PORTC_BASE) +#define CCP2_PIN (GPIO_PIN_4) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define FAULT0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define FAULT0_PORT (GPIO_PORTE_BASE) +#define FAULT0_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1625 + +//***************************************************************************** +// +// LM3S1626 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1626 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_3) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_2) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP0_PORT (GPIO_PORTC_BASE) +#define CCP0_PIN (GPIO_PIN_6) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP1_PORT (GPIO_PORTB_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP2_PORT (GPIO_PORTC_BASE) +#define CCP2_PIN (GPIO_PIN_4) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_5) + +#define FAULT0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define FAULT0_PORT (GPIO_PORTE_BASE) +#define FAULT0_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_0) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PHA0_PORT (GPIO_PORTD_BASE) +#define PHA0_PIN (GPIO_PIN_1) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB0_PORT (GPIO_PORTC_BASE) +#define PHB0_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM0_PORT (GPIO_PORTA_BASE) +#define PWM0_PIN (GPIO_PIN_6) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM1_PORT (GPIO_PORTA_BASE) +#define PWM1_PIN (GPIO_PIN_7) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1RX_PORT (GPIO_PORTB_BASE) +#define U1RX_PIN (GPIO_PIN_4) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1TX_PORT (GPIO_PORTB_BASE) +#define U1TX_PIN (GPIO_PIN_5) + +#endif // PART_LM3S1626 + +//***************************************************************************** +// +// LM3S1627 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1627 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP0_PORT (GPIO_PORTC_BASE) +#define CCP0_PIN (GPIO_PIN_6) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP1_PORT (GPIO_PORTB_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_5) + +#define FAULT0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define FAULT0_PORT (GPIO_PORTE_BASE) +#define FAULT0_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define IDX0_PORT (GPIO_PORTB_BASE) +#define IDX0_PIN (GPIO_PIN_4) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB0_PORT (GPIO_PORTC_BASE) +#define PHB0_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM2_PORT (GPIO_PORTD_BASE) +#define PWM2_PIN (GPIO_PIN_2) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM3_PORT (GPIO_PORTD_BASE) +#define PWM3_PIN (GPIO_PIN_3) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM4_PORT (GPIO_PORTA_BASE) +#define PWM4_PIN (GPIO_PIN_6) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM5_PORT (GPIO_PORTA_BASE) +#define PWM5_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1RX_PORT (GPIO_PORTB_BASE) +#define U1RX_PIN (GPIO_PIN_0) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1TX_PORT (GPIO_PORTB_BASE) +#define U1TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1627 + +//***************************************************************************** +// +// LM3S1635 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1635 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP1_PORT (GPIO_PORTD_BASE) +#define CCP1_PIN (GPIO_PIN_7) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM4_PORT (GPIO_PORTF_BASE) +#define PWM4_PIN (GPIO_PIN_2) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM5_PORT (GPIO_PORTF_BASE) +#define PWM5_PIN (GPIO_PIN_3) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1635 + +//***************************************************************************** +// +// LM3S1637 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1637 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB0_PORT (GPIO_PORTC_BASE) +#define PHB0_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1637 + +//***************************************************************************** +// +// LM3S1751 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1751 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1751 + +//***************************************************************************** +// +// LM3S1776 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1776 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_3) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_2) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP0_PORT (GPIO_PORTC_BASE) +#define CCP0_PIN (GPIO_PIN_7) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define FAULT0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define FAULT0_PORT (GPIO_PORTE_BASE) +#define FAULT0_PIN (GPIO_PIN_4) + +#define FAULT1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define FAULT1_PORT (GPIO_PORTB_BASE) +#define FAULT1_PIN (GPIO_PIN_6) + +#define FAULT2_PERIPH (SYSCTL_PERIPH_GPIOC) +#define FAULT2_PORT (GPIO_PORTC_BASE) +#define FAULT2_PIN (GPIO_PIN_5) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM4_PORT (GPIO_PORTA_BASE) +#define PWM4_PIN (GPIO_PIN_6) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM5_PORT (GPIO_PORTA_BASE) +#define PWM5_PIN (GPIO_PIN_7) + +#define PWM6_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PWM6_PORT (GPIO_PORTC_BASE) +#define PWM6_PIN (GPIO_PIN_4) + +#define PWM7_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PWM7_PORT (GPIO_PORTC_BASE) +#define PWM7_PIN (GPIO_PIN_6) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1776 + +//***************************************************************************** +// +// LM3S1850 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1850 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C1O_PORT (GPIO_PORTE_BASE) +#define C1O_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PHA0_PORT (GPIO_PORTD_BASE) +#define PHA0_PIN (GPIO_PIN_1) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PHB0_PORT (GPIO_PORTF_BASE) +#define PHB0_PIN (GPIO_PIN_0) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM1_PORT (GPIO_PORTF_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S1850 + +//***************************************************************************** +// +// LM3S1911 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1911 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C1O_PORT (GPIO_PORTE_BASE) +#define C1O_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP1_PORT (GPIO_PORTD_BASE) +#define CCP1_PIN (GPIO_PIN_7) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1911 + +//***************************************************************************** +// +// LM3S1918 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1918 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CCP1_PORT (GPIO_PORTF_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S1918 + +//***************************************************************************** +// +// LM3S1937 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1937 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S1937 + +//***************************************************************************** +// +// LM3S1958 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1958 + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP1_PORT (GPIO_PORTB_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1958 + +//***************************************************************************** +// +// LM3S1960 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1960 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C2O_PORT (GPIO_PORTF_BASE) +#define C2O_PIN (GPIO_PIN_6) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP1_PORT (GPIO_PORTD_BASE) +#define CCP1_PIN (GPIO_PIN_7) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CCP4_PORT (GPIO_PORTF_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_0) + +#define IDX1_PERIPH (SYSCTL_PERIPH_GPIOH) +#define IDX1_PORT (GPIO_PORTH_BASE) +#define IDX1_PIN (GPIO_PIN_2) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PHA0_PORT (GPIO_PORTD_BASE) +#define PHA0_PIN (GPIO_PIN_1) + +#define PHA1_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PHA1_PORT (GPIO_PORTG_BASE) +#define PHA1_PIN (GPIO_PIN_6) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PHB0_PORT (GPIO_PORTH_BASE) +#define PHB0_PIN (GPIO_PIN_3) + +#define PHB1_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PHB1_PORT (GPIO_PORTG_BASE) +#define PHB1_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM0_PORT (GPIO_PORTF_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM1_PORT (GPIO_PORTF_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_6) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1960 + +//***************************************************************************** +// +// LM3S1968 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S1968 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CCP1_PORT (GPIO_PORTF_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOG) +#define CCP3_PORT (GPIO_PORTG_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOH) +#define FAULT_PORT (GPIO_PORTH_BASE) +#define FAULT_PIN (GPIO_PIN_3) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_0) + +#define IDX1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define IDX1_PORT (GPIO_PORTF_BASE) +#define IDX1_PIN (GPIO_PIN_1) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHA1_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PHA1_PORT (GPIO_PORTG_BASE) +#define PHA1_PIN (GPIO_PIN_6) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PHB0_PORT (GPIO_PORTF_BASE) +#define PHB0_PIN (GPIO_PIN_0) + +#define PHB1_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PHB1_PORT (GPIO_PORTG_BASE) +#define PHB1_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM0_PORT (GPIO_PORTG_BASE) +#define PWM0_PIN (GPIO_PIN_2) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM4_PORT (GPIO_PORTF_BASE) +#define PWM4_PIN (GPIO_PIN_2) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM5_PORT (GPIO_PORTF_BASE) +#define PWM5_PIN (GPIO_PIN_3) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S1968 + +//***************************************************************************** +// +// LM3S2016 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2016 + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S2016 + +//***************************************************************************** +// +// LM3S2110 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2110 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM0_PORT (GPIO_PORTF_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM1_PORT (GPIO_PORTF_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2110 + +//***************************************************************************** +// +// LM3S2139 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2139 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S2139 + +//***************************************************************************** +// +// LM3S2276 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2276 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_3) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_2) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CAN0RX_PORT (GPIO_PORTB_BASE) +#define CAN0RX_PIN (GPIO_PIN_4) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CAN0TX_PORT (GPIO_PORTB_BASE) +#define CAN0TX_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP0_PORT (GPIO_PORTC_BASE) +#define CCP0_PIN (GPIO_PIN_7) + +#define FAULT0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define FAULT0_PORT (GPIO_PORTE_BASE) +#define FAULT0_PIN (GPIO_PIN_4) + +#define FAULT1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define FAULT1_PORT (GPIO_PORTB_BASE) +#define FAULT1_PIN (GPIO_PIN_6) + +#define FAULT2_PERIPH (SYSCTL_PERIPH_GPIOC) +#define FAULT2_PORT (GPIO_PORTC_BASE) +#define FAULT2_PIN (GPIO_PIN_5) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM4_PORT (GPIO_PORTA_BASE) +#define PWM4_PIN (GPIO_PIN_6) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM5_PORT (GPIO_PORTA_BASE) +#define PWM5_PIN (GPIO_PIN_7) + +#define PWM6_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PWM6_PORT (GPIO_PORTC_BASE) +#define PWM6_PIN (GPIO_PIN_4) + +#define PWM7_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PWM7_PORT (GPIO_PORTC_BASE) +#define PWM7_PIN (GPIO_PIN_6) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2276 + +//***************************************************************************** +// +// LM3S2410 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2410 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C1O_PORT (GPIO_PORTE_BASE) +#define C1O_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2410 + +//***************************************************************************** +// +// LM3S2412 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2412 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM0_PORT (GPIO_PORTF_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM1_PORT (GPIO_PORTF_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S2412 + +//***************************************************************************** +// +// LM3S2432 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2432 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM0_PORT (GPIO_PORTF_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM1_PORT (GPIO_PORTF_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S2432 + +//***************************************************************************** +// +// LM3S2533 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2533 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM0_PORT (GPIO_PORTF_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM1_PORT (GPIO_PORTF_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S2533 + +//***************************************************************************** +// +// LM3S2601 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2601 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C1O_PORT (GPIO_PORTE_BASE) +#define C1O_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP1_PORT (GPIO_PORTD_BASE) +#define CCP1_PIN (GPIO_PIN_7) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2601 + +//***************************************************************************** +// +// LM3S2608 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2608 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CCP1_PORT (GPIO_PORTF_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S2608 + +//***************************************************************************** +// +// LM3S2616 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2616 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_3) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_2) + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_7) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_7) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CAN0RX_PORT (GPIO_PORTA_BASE) +#define CAN0RX_PIN (GPIO_PIN_4) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CAN0TX_PORT (GPIO_PORTA_BASE) +#define CAN0TX_PIN (GPIO_PIN_5) + +#define FAULT0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define FAULT0_PORT (GPIO_PORTE_BASE) +#define FAULT0_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_0) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB0_PORT (GPIO_PORTC_BASE) +#define PHB0_PIN (GPIO_PIN_6) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM0_PORT (GPIO_PORTA_BASE) +#define PWM0_PIN (GPIO_PIN_6) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM1_PORT (GPIO_PORTA_BASE) +#define PWM1_PIN (GPIO_PIN_7) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM4_PORT (GPIO_PORTA_BASE) +#define PWM4_PIN (GPIO_PIN_2) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM5_PORT (GPIO_PORTA_BASE) +#define PWM5_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2616 + +//***************************************************************************** +// +// LM3S2620 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2620 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C1O_PORT (GPIO_PORTE_BASE) +#define C1O_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C2O_PORT (GPIO_PORTE_BASE) +#define C2O_PIN (GPIO_PIN_7) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CAN1RX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1RX_PORT (GPIO_PORTF_BASE) +#define CAN1RX_PIN (GPIO_PIN_0) + +#define CAN1TX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1TX_PORT (GPIO_PORTF_BASE) +#define CAN1TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP5_PORT (GPIO_PORTE_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PHB0_PORT (GPIO_PORTH_BASE) +#define PHB0_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM0_PORT (GPIO_PORTG_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM1_PORT (GPIO_PORTG_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM2_PORT (GPIO_PORTD_BASE) +#define PWM2_PIN (GPIO_PIN_2) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM3_PORT (GPIO_PORTD_BASE) +#define PWM3_PIN (GPIO_PIN_3) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2620 + +//***************************************************************************** +// +// LM3S2637 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2637 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S2637 + +//***************************************************************************** +// +// LM3S2651 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2651 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM0_PORT (GPIO_PORTF_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM1_PORT (GPIO_PORTF_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2651 + +//***************************************************************************** +// +// LM3S2671 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2671 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_6) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_7) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_7) + +#define C2O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2O_PORT (GPIO_PORTC_BASE) +#define C2O_PIN (GPIO_PIN_6) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_5) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP1_PORT (GPIO_PORTB_BASE) +#define CCP1_PIN (GPIO_PIN_1) + +#define FAULT0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define FAULT0_PORT (GPIO_PORTE_BASE) +#define FAULT0_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM0_PORT (GPIO_PORTA_BASE) +#define PWM0_PIN (GPIO_PIN_6) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM1_PORT (GPIO_PORTA_BASE) +#define PWM1_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2671 + +//***************************************************************************** +// +// LM3S2678 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2678 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_3) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_2) + +#define ADC6_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC6_PORT (GPIO_PORTD_BASE) +#define ADC6_PIN (GPIO_PIN_1) + +#define ADC7_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC7_PORT (GPIO_PORTD_BASE) +#define ADC7_PIN (GPIO_PIN_0) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CAN0RX_PORT (GPIO_PORTB_BASE) +#define CAN0RX_PIN (GPIO_PIN_4) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CAN0TX_PORT (GPIO_PORTB_BASE) +#define CAN0TX_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP0_PORT (GPIO_PORTC_BASE) +#define CCP0_PIN (GPIO_PIN_6) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP1_PORT (GPIO_PORTC_BASE) +#define CCP1_PIN (GPIO_PIN_5) + +#define FAULT0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define FAULT0_PORT (GPIO_PORTB_BASE) +#define FAULT0_PIN (GPIO_PIN_3) + +#define FAULT1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define FAULT1_PORT (GPIO_PORTB_BASE) +#define FAULT1_PIN (GPIO_PIN_6) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define IDX0_PORT (GPIO_PORTB_BASE) +#define IDX0_PIN (GPIO_PIN_2) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB0_PORT (GPIO_PORTC_BASE) +#define PHB0_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM0_PORT (GPIO_PORTA_BASE) +#define PWM0_PIN (GPIO_PIN_6) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM1_PORT (GPIO_PORTA_BASE) +#define PWM1_PIN (GPIO_PIN_7) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2678 + +//***************************************************************************** +// +// LM3S2730 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2730 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C1O_PORT (GPIO_PORTE_BASE) +#define C1O_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2730 + +//***************************************************************************** +// +// LM3S2739 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2739 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB0_PORT (GPIO_PORTC_BASE) +#define PHB0_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM0_PORT (GPIO_PORTF_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM1_PORT (GPIO_PORTF_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S2739 + +//***************************************************************************** +// +// LM3S2776 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2776 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_3) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_2) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CAN0RX_PORT (GPIO_PORTB_BASE) +#define CAN0RX_PIN (GPIO_PIN_4) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CAN0TX_PORT (GPIO_PORTB_BASE) +#define CAN0TX_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP0_PORT (GPIO_PORTC_BASE) +#define CCP0_PIN (GPIO_PIN_7) + +#define FAULT0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define FAULT0_PORT (GPIO_PORTE_BASE) +#define FAULT0_PIN (GPIO_PIN_4) + +#define FAULT1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define FAULT1_PORT (GPIO_PORTB_BASE) +#define FAULT1_PIN (GPIO_PIN_6) + +#define FAULT2_PERIPH (SYSCTL_PERIPH_GPIOC) +#define FAULT2_PORT (GPIO_PORTC_BASE) +#define FAULT2_PIN (GPIO_PIN_5) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM4_PORT (GPIO_PORTA_BASE) +#define PWM4_PIN (GPIO_PIN_6) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM5_PORT (GPIO_PORTA_BASE) +#define PWM5_PIN (GPIO_PIN_7) + +#define PWM6_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PWM6_PORT (GPIO_PORTC_BASE) +#define PWM6_PIN (GPIO_PIN_4) + +#define PWM7_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PWM7_PORT (GPIO_PORTC_BASE) +#define PWM7_PIN (GPIO_PIN_6) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2776 + +//***************************************************************************** +// +// LM3S2911 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2911 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C1O_PORT (GPIO_PORTE_BASE) +#define C1O_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP1_PORT (GPIO_PORTD_BASE) +#define CCP1_PIN (GPIO_PIN_7) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2911 + +//***************************************************************************** +// +// LM3S2918 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2918 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CCP1_PORT (GPIO_PORTF_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S2918 + +//***************************************************************************** +// +// LM3S2939 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2939 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PHB0_PORT (GPIO_PORTH_BASE) +#define PHB0_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM0_PORT (GPIO_PORTF_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM1_PORT (GPIO_PORTF_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2939 + +//***************************************************************************** +// +// LM3S2948 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2948 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CAN1RX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1RX_PORT (GPIO_PORTF_BASE) +#define CAN1RX_PIN (GPIO_PIN_0) + +#define CAN1TX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1TX_PORT (GPIO_PORTF_BASE) +#define CAN1TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOG) +#define CCP3_PORT (GPIO_PORTG_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2948 + +//***************************************************************************** +// +// LM3S2950 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2950 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C2O_PORT (GPIO_PORTF_BASE) +#define C2O_PIN (GPIO_PIN_6) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CAN1RX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1RX_PORT (GPIO_PORTF_BASE) +#define CAN1RX_PIN (GPIO_PIN_0) + +#define CAN1TX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1TX_PORT (GPIO_PORTF_BASE) +#define CAN1TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP5_PORT (GPIO_PORTE_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PHB0_PORT (GPIO_PORTH_BASE) +#define PHB0_PIN (GPIO_PIN_3) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM0_PORT (GPIO_PORTG_BASE) +#define PWM0_PIN (GPIO_PIN_2) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM1_PORT (GPIO_PORTG_BASE) +#define PWM1_PIN (GPIO_PIN_3) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_6) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2950 + +//***************************************************************************** +// +// LM3S2965 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S2965 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CAN1RX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1RX_PORT (GPIO_PORTF_BASE) +#define CAN1RX_PIN (GPIO_PIN_0) + +#define CAN1TX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1TX_PORT (GPIO_PORTF_BASE) +#define CAN1TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CCP1_PORT (GPIO_PORTF_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP4_PORT (GPIO_PORTD_BASE) +#define CCP4_PIN (GPIO_PIN_5) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOG) +#define CCP5_PORT (GPIO_PORTG_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_7) + +#define IDX1_PERIPH (SYSCTL_PERIPH_GPIOH) +#define IDX1_PORT (GPIO_PORTH_BASE) +#define IDX1_PIN (GPIO_PIN_2) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHA1_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PHA1_PORT (GPIO_PORTG_BASE) +#define PHA1_PIN (GPIO_PIN_6) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PHB0_PORT (GPIO_PORTH_BASE) +#define PHB0_PIN (GPIO_PIN_3) + +#define PHB1_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PHB1_PORT (GPIO_PORTG_BASE) +#define PHB1_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM0_PORT (GPIO_PORTG_BASE) +#define PWM0_PIN (GPIO_PIN_2) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM1_PORT (GPIO_PORTG_BASE) +#define PWM1_PIN (GPIO_PIN_3) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM4_PORT (GPIO_PORTF_BASE) +#define PWM4_PIN (GPIO_PIN_2) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM5_PORT (GPIO_PORTF_BASE) +#define PWM5_PIN (GPIO_PIN_3) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S2965 + +//***************************************************************************** +// +// LM3S3651 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S3651 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_6) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_7) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_3) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP2_PORT (GPIO_PORTC_BASE) +#define CCP2_PIN (GPIO_PIN_4) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP5_PORT (GPIO_PORTD_BASE) +#define CCP5_PIN (GPIO_PIN_2) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP6_PORT (GPIO_PORTD_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP7_PORT (GPIO_PORTD_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define USB0EPEN_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0EPEN_PORT (GPIO_PORTC_BASE) +#define USB0EPEN_PIN (GPIO_PIN_5) + +#define USB0ID_PERIPH (SYSCTL_PERIPH_GPIOB) +#define USB0ID_PORT (GPIO_PORTB_BASE) +#define USB0ID_PIN (GPIO_PIN_0) + +#define USB0PFLT_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0PFLT_PORT (GPIO_PORTC_BASE) +#define USB0PFLT_PIN (GPIO_PIN_6) + +#define USB0VBUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define USB0VBUS_PORT (GPIO_PORTB_BASE) +#define USB0VBUS_PIN (GPIO_PIN_1) + +#endif // PART_LM3S3651 + +//***************************************************************************** +// +// LM3S3739 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S3739 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_7) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_6) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_5) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_4) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_7) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_6) + +#define ADC6_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC6_PORT (GPIO_PORTD_BASE) +#define ADC6_PIN (GPIO_PIN_5) + +#define ADC7_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC7_PORT (GPIO_PORTD_BASE) +#define ADC7_PIN (GPIO_PIN_4) + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP0_PORT (GPIO_PORTC_BASE) +#define CCP0_PIN (GPIO_PIN_6) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CCP1_PORT (GPIO_PORTF_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP2_PORT (GPIO_PORTC_BASE) +#define CCP2_PIN (GPIO_PIN_4) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOG) +#define CCP3_PORT (GPIO_PORTG_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP5_PORT (GPIO_PORTD_BASE) +#define CCP5_PIN (GPIO_PIN_2) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP7_PORT (GPIO_PORTD_BASE) +#define CCP7_PIN (GPIO_PIN_3) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1RX_PORT (GPIO_PORTB_BASE) +#define U1RX_PIN (GPIO_PIN_0) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1TX_PORT (GPIO_PORTB_BASE) +#define U1TX_PIN (GPIO_PIN_1) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U2RX_PORT (GPIO_PORTD_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U2TX_PORT (GPIO_PORTD_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#define USB0EPEN_PERIPH (SYSCTL_PERIPH_GPIOH) +#define USB0EPEN_PORT (GPIO_PORTH_BASE) +#define USB0EPEN_PIN (GPIO_PIN_3) + +#define USB0PFLT_PERIPH (SYSCTL_PERIPH_GPIOH) +#define USB0PFLT_PORT (GPIO_PORTH_BASE) +#define USB0PFLT_PIN (GPIO_PIN_4) + +#endif // PART_LM3S3739 + +//***************************************************************************** +// +// LM3S3748 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S3748 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_7) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_6) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_5) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_4) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_7) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_6) + +#define ADC6_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC6_PORT (GPIO_PORTD_BASE) +#define ADC6_PIN (GPIO_PIN_5) + +#define ADC7_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC7_PORT (GPIO_PORTD_BASE) +#define ADC7_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_3) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CCP1_PORT (GPIO_PORTF_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CCP2_PORT (GPIO_PORTF_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOG) +#define CCP3_PORT (GPIO_PORTG_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_4) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP5_PORT (GPIO_PORTD_BASE) +#define CCP5_PIN (GPIO_PIN_2) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP7_PORT (GPIO_PORTH_BASE) +#define CCP7_PIN (GPIO_PIN_1) + +#define FAULT0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define FAULT0_PORT (GPIO_PORTF_BASE) +#define FAULT0_PIN (GPIO_PIN_4) + +#define FAULT1_PERIPH (SYSCTL_PERIPH_GPIOG) +#define FAULT1_PORT (GPIO_PORTG_BASE) +#define FAULT1_PIN (GPIO_PIN_5) + +#define FAULT2_PERIPH (SYSCTL_PERIPH_GPIOG) +#define FAULT2_PORT (GPIO_PORTG_BASE) +#define FAULT2_PIN (GPIO_PIN_3) + +#define FAULT3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define FAULT3_PORT (GPIO_PORTH_BASE) +#define FAULT3_PIN (GPIO_PIN_2) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_0) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PHA0_PORT (GPIO_PORTD_BASE) +#define PHA0_PIN (GPIO_PIN_1) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PHB0_PORT (GPIO_PORTF_BASE) +#define PHB0_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM0_PORT (GPIO_PORTF_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM1_PORT (GPIO_PORTF_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM2_PORT (GPIO_PORTF_BASE) +#define PWM2_PIN (GPIO_PIN_2) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM3_PORT (GPIO_PORTF_BASE) +#define PWM3_PIN (GPIO_PIN_3) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM4_PORT (GPIO_PORTG_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM5_PORT (GPIO_PORTG_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define PWM6_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM6_PORT (GPIO_PORTG_BASE) +#define PWM6_PIN (GPIO_PIN_6) + +#define PWM7_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM7_PORT (GPIO_PORTG_BASE) +#define PWM7_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOC) +#define U1RX_PORT (GPIO_PORTC_BASE) +#define U1RX_PIN (GPIO_PIN_6) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOC) +#define U1TX_PORT (GPIO_PORTC_BASE) +#define U1TX_PIN (GPIO_PIN_7) + +#define USB0EPEN_PERIPH (SYSCTL_PERIPH_GPIOH) +#define USB0EPEN_PORT (GPIO_PORTH_BASE) +#define USB0EPEN_PIN (GPIO_PIN_3) + +#define USB0PFLT_PERIPH (SYSCTL_PERIPH_GPIOH) +#define USB0PFLT_PORT (GPIO_PORTH_BASE) +#define USB0PFLT_PIN (GPIO_PIN_4) + +#endif // PART_LM3S3748 + +//***************************************************************************** +// +// LM3S3749 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S3749 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_7) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_6) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_5) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_4) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_7) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_6) + +#define ADC6_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC6_PORT (GPIO_PORTD_BASE) +#define ADC6_PIN (GPIO_PIN_5) + +#define ADC7_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC7_PORT (GPIO_PORTD_BASE) +#define ADC7_PIN (GPIO_PIN_4) + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_7) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_3) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CCP2_PORT (GPIO_PORTF_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP3_PORT (GPIO_PORTA_BASE) +#define CCP3_PIN (GPIO_PIN_7) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CCP4_PORT (GPIO_PORTF_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP6_PORT (GPIO_PORTD_BASE) +#define CCP6_PIN (GPIO_PIN_2) + +#define FAULT0_PERIPH (SYSCTL_PERIPH_GPIOG) +#define FAULT0_PORT (GPIO_PORTG_BASE) +#define FAULT0_PIN (GPIO_PIN_2) + +#define FAULT1_PERIPH (SYSCTL_PERIPH_GPIOG) +#define FAULT1_PORT (GPIO_PORTG_BASE) +#define FAULT1_PIN (GPIO_PIN_4) + +#define FAULT2_PERIPH (SYSCTL_PERIPH_GPIOG) +#define FAULT2_PORT (GPIO_PORTG_BASE) +#define FAULT2_PIN (GPIO_PIN_3) + +#define FAULT3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define FAULT3_PORT (GPIO_PORTH_BASE) +#define FAULT3_PIN (GPIO_PIN_2) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOG) +#define I2C1SCL_PORT (GPIO_PORTG_BASE) +#define I2C1SCL_PIN (GPIO_PIN_0) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOG) +#define I2C1SDA_PORT (GPIO_PORTG_BASE) +#define I2C1SDA_PIN (GPIO_PIN_1) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOG) +#define IDX0_PORT (GPIO_PORTG_BASE) +#define IDX0_PIN (GPIO_PIN_5) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PHA0_PORT (GPIO_PORTF_BASE) +#define PHA0_PIN (GPIO_PIN_6) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB0_PORT (GPIO_PORTC_BASE) +#define PHB0_PIN (GPIO_PIN_6) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM0_PORT (GPIO_PORTF_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM1_PORT (GPIO_PORTF_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM4_PORT (GPIO_PORTF_BASE) +#define PWM4_PIN (GPIO_PIN_2) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM5_PORT (GPIO_PORTF_BASE) +#define PWM5_PIN (GPIO_PIN_3) + +#define PWM6_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM6_PORT (GPIO_PORTG_BASE) +#define PWM6_PIN (GPIO_PIN_6) + +#define PWM7_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM7_PORT (GPIO_PORTG_BASE) +#define PWM7_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1RX_PORT (GPIO_PORTB_BASE) +#define U1RX_PIN (GPIO_PIN_0) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1TX_PORT (GPIO_PORTB_BASE) +#define U1TX_PIN (GPIO_PIN_1) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U2RX_PORT (GPIO_PORTD_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U2TX_PORT (GPIO_PORTD_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#define USB0EPEN_PERIPH (SYSCTL_PERIPH_GPIOH) +#define USB0EPEN_PORT (GPIO_PORTH_BASE) +#define USB0EPEN_PIN (GPIO_PIN_3) + +#define USB0PFLT_PERIPH (SYSCTL_PERIPH_GPIOH) +#define USB0PFLT_PORT (GPIO_PORTH_BASE) +#define USB0PFLT_PIN (GPIO_PIN_4) + +#endif // PART_LM3S3749 + +//***************************************************************************** +// +// LM3S5632 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S5632 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_3) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_2) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_5) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP1_PORT (GPIO_PORTB_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP2_PORT (GPIO_PORTC_BASE) +#define CCP2_PIN (GPIO_PIN_4) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1RX_PORT (GPIO_PORTB_BASE) +#define U1RX_PIN (GPIO_PIN_0) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1TX_PORT (GPIO_PORTB_BASE) +#define U1TX_PIN (GPIO_PIN_1) + +#define USB0EPEN_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0EPEN_PORT (GPIO_PORTC_BASE) +#define USB0EPEN_PIN (GPIO_PIN_5) + +#define USB0PFLT_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0PFLT_PORT (GPIO_PORTC_BASE) +#define USB0PFLT_PIN (GPIO_PIN_6) + +#endif // PART_LM3S5632 + +//***************************************************************************** +// +// LM3S5652 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S5652 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_3) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_2) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_5) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP2_PORT (GPIO_PORTE_BASE) +#define CCP2_PIN (GPIO_PIN_4) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP3_PORT (GPIO_PORTA_BASE) +#define CCP3_PIN (GPIO_PIN_7) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define USB0EPEN_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0EPEN_PORT (GPIO_PORTC_BASE) +#define USB0EPEN_PIN (GPIO_PIN_5) + +#define USB0ID_PERIPH (SYSCTL_PERIPH_GPIOB) +#define USB0ID_PORT (GPIO_PORTB_BASE) +#define USB0ID_PIN (GPIO_PIN_0) + +#define USB0PFLT_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0PFLT_PORT (GPIO_PORTC_BASE) +#define USB0PFLT_PIN (GPIO_PIN_6) + +#define USB0VBUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define USB0VBUS_PORT (GPIO_PORTB_BASE) +#define USB0VBUS_PIN (GPIO_PIN_1) + +#endif // PART_LM3S5652 + +//***************************************************************************** +// +// LM3S5662 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S5662 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CAN0RX_PORT (GPIO_PORTB_BASE) +#define CAN0RX_PIN (GPIO_PIN_4) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CAN0TX_PORT (GPIO_PORTB_BASE) +#define CAN0TX_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_2) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP1_PORT (GPIO_PORTB_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP2_PORT (GPIO_PORTC_BASE) +#define CCP2_PIN (GPIO_PIN_4) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define FAULT0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define FAULT0_PORT (GPIO_PORTB_BASE) +#define FAULT0_PIN (GPIO_PIN_3) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM2_PORT (GPIO_PORTD_BASE) +#define PWM2_PIN (GPIO_PIN_2) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM3_PORT (GPIO_PORTD_BASE) +#define PWM3_PIN (GPIO_PIN_3) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM4_PORT (GPIO_PORTA_BASE) +#define PWM4_PIN (GPIO_PIN_6) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM5_PORT (GPIO_PORTA_BASE) +#define PWM5_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define USB0EPEN_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0EPEN_PORT (GPIO_PORTC_BASE) +#define USB0EPEN_PIN (GPIO_PIN_5) + +#define USB0ID_PERIPH (SYSCTL_PERIPH_GPIOB) +#define USB0ID_PORT (GPIO_PORTB_BASE) +#define USB0ID_PIN (GPIO_PIN_0) + +#define USB0PFLT_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0PFLT_PORT (GPIO_PORTC_BASE) +#define USB0PFLT_PIN (GPIO_PIN_6) + +#define USB0VBUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define USB0VBUS_PORT (GPIO_PORTB_BASE) +#define USB0VBUS_PIN (GPIO_PIN_1) + +#endif // PART_LM3S5662 + +//***************************************************************************** +// +// LM3S5732 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S5732 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_3) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_2) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_5) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP1_PORT (GPIO_PORTB_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP2_PORT (GPIO_PORTC_BASE) +#define CCP2_PIN (GPIO_PIN_4) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1RX_PORT (GPIO_PORTB_BASE) +#define U1RX_PIN (GPIO_PIN_0) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1TX_PORT (GPIO_PORTB_BASE) +#define U1TX_PIN (GPIO_PIN_1) + +#define USB0EPEN_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0EPEN_PORT (GPIO_PORTC_BASE) +#define USB0EPEN_PIN (GPIO_PIN_5) + +#define USB0PFLT_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0PFLT_PORT (GPIO_PORTC_BASE) +#define USB0PFLT_PIN (GPIO_PIN_6) + +#endif // PART_LM3S5732 + +//***************************************************************************** +// +// LM3S5737 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S5737 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_7) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_6) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_5) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_4) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_7) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_6) + +#define ADC6_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC6_PORT (GPIO_PORTD_BASE) +#define ADC6_PIN (GPIO_PIN_5) + +#define ADC7_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC7_PORT (GPIO_PORTD_BASE) +#define ADC7_PIN (GPIO_PIN_4) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP1_PORT (GPIO_PORTB_BASE) +#define CCP1_PIN (GPIO_PIN_1) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define USB0EPEN_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0EPEN_PORT (GPIO_PORTC_BASE) +#define USB0EPEN_PIN (GPIO_PIN_5) + +#define USB0PFLT_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0PFLT_PORT (GPIO_PORTC_BASE) +#define USB0PFLT_PIN (GPIO_PIN_6) + +#endif // PART_LM3S5737 + +//***************************************************************************** +// +// LM3S5739 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S5739 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_7) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_6) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_5) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_4) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_7) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_6) + +#define ADC6_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC6_PORT (GPIO_PORTD_BASE) +#define ADC6_PIN (GPIO_PIN_5) + +#define ADC7_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC7_PORT (GPIO_PORTD_BASE) +#define ADC7_PIN (GPIO_PIN_4) + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CAN0RX_PORT (GPIO_PORTA_BASE) +#define CAN0RX_PIN (GPIO_PIN_6) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CAN0TX_PORT (GPIO_PORTA_BASE) +#define CAN0TX_PIN (GPIO_PIN_7) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP0_PORT (GPIO_PORTC_BASE) +#define CCP0_PIN (GPIO_PIN_6) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CCP1_PORT (GPIO_PORTF_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP2_PORT (GPIO_PORTC_BASE) +#define CCP2_PIN (GPIO_PIN_4) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOG) +#define CCP3_PORT (GPIO_PORTG_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP5_PORT (GPIO_PORTD_BASE) +#define CCP5_PIN (GPIO_PIN_2) + +#define CCP6_PERIPH (SYSCTL_PERIPH_GPIOH) +#define CCP6_PORT (GPIO_PORTH_BASE) +#define CCP6_PIN (GPIO_PIN_0) + +#define CCP7_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP7_PORT (GPIO_PORTD_BASE) +#define CCP7_PIN (GPIO_PIN_3) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOG) +#define I2C1SCL_PORT (GPIO_PORTG_BASE) +#define I2C1SCL_PIN (GPIO_PIN_0) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOG) +#define I2C1SDA_PORT (GPIO_PORTG_BASE) +#define I2C1SDA_PIN (GPIO_PIN_1) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1RX_PORT (GPIO_PORTB_BASE) +#define U1RX_PIN (GPIO_PIN_0) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define U1TX_PORT (GPIO_PORTB_BASE) +#define U1TX_PIN (GPIO_PIN_1) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U2RX_PORT (GPIO_PORTD_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U2TX_PORT (GPIO_PORTD_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#define USB0EPEN_PERIPH (SYSCTL_PERIPH_GPIOH) +#define USB0EPEN_PORT (GPIO_PORTH_BASE) +#define USB0EPEN_PIN (GPIO_PIN_3) + +#define USB0PFLT_PERIPH (SYSCTL_PERIPH_GPIOH) +#define USB0PFLT_PORT (GPIO_PORTH_BASE) +#define USB0PFLT_PIN (GPIO_PIN_4) + +#endif // PART_LM3S5739 + +//***************************************************************************** +// +// LM3S5747 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S5747 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_7) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_6) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_5) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_4) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_7) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_6) + +#define ADC6_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC6_PORT (GPIO_PORTD_BASE) +#define ADC6_PIN (GPIO_PIN_5) + +#define ADC7_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC7_PORT (GPIO_PORTD_BASE) +#define ADC7_PIN (GPIO_PIN_4) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CAN0RX_PORT (GPIO_PORTB_BASE) +#define CAN0RX_PIN (GPIO_PIN_4) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CAN0TX_PORT (GPIO_PORTB_BASE) +#define CAN0TX_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define FAULT0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define FAULT0_PORT (GPIO_PORTE_BASE) +#define FAULT0_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM2_PORT (GPIO_PORTD_BASE) +#define PWM2_PIN (GPIO_PIN_2) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM3_PORT (GPIO_PORTD_BASE) +#define PWM3_PIN (GPIO_PIN_3) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM4_PORT (GPIO_PORTF_BASE) +#define PWM4_PIN (GPIO_PIN_2) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM5_PORT (GPIO_PORTF_BASE) +#define PWM5_PIN (GPIO_PIN_3) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define USB0EPEN_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0EPEN_PORT (GPIO_PORTC_BASE) +#define USB0EPEN_PIN (GPIO_PIN_5) + +#define USB0PFLT_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0PFLT_PORT (GPIO_PORTC_BASE) +#define USB0PFLT_PIN (GPIO_PIN_6) + +#endif // PART_LM3S5747 + +//***************************************************************************** +// +// LM3S5749 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S5749 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_7) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_6) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_5) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_4) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_7) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_6) + +#define ADC6_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC6_PORT (GPIO_PORTD_BASE) +#define ADC6_PIN (GPIO_PIN_5) + +#define ADC7_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC7_PORT (GPIO_PORTD_BASE) +#define ADC7_PIN (GPIO_PIN_4) + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C0O_PORT (GPIO_PORTF_BASE) +#define C0O_PIN (GPIO_PIN_4) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOF) +#define C1O_PORT (GPIO_PORTF_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CAN1RX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1RX_PORT (GPIO_PORTF_BASE) +#define CAN1RX_PIN (GPIO_PIN_0) + +#define CAN1TX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1TX_PORT (GPIO_PORTF_BASE) +#define CAN1TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP1_PORT (GPIO_PORTB_BASE) +#define CCP1_PIN (GPIO_PIN_1) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP2_PORT (GPIO_PORTC_BASE) +#define CCP2_PIN (GPIO_PIN_4) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define FAULT0_PERIPH (SYSCTL_PERIPH_GPIOG) +#define FAULT0_PORT (GPIO_PORTG_BASE) +#define FAULT0_PIN (GPIO_PIN_2) + +#define FAULT1_PERIPH (SYSCTL_PERIPH_GPIOG) +#define FAULT1_PORT (GPIO_PORTG_BASE) +#define FAULT1_PIN (GPIO_PIN_4) + +#define FAULT2_PERIPH (SYSCTL_PERIPH_GPIOG) +#define FAULT2_PORT (GPIO_PORTG_BASE) +#define FAULT2_PIN (GPIO_PIN_3) + +#define FAULT3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define FAULT3_PORT (GPIO_PORTH_BASE) +#define FAULT3_PIN (GPIO_PIN_2) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOG) +#define IDX0_PORT (GPIO_PORTG_BASE) +#define IDX0_PIN (GPIO_PIN_5) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PHA0_PORT (GPIO_PORTF_BASE) +#define PHA0_PIN (GPIO_PIN_6) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PHB0_PORT (GPIO_PORTF_BASE) +#define PHB0_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM0_PORT (GPIO_PORTG_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM1_PORT (GPIO_PORTG_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM2_PORT (GPIO_PORTH_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOH) +#define PWM3_PORT (GPIO_PORTH_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM4_PORT (GPIO_PORTF_BASE) +#define PWM4_PIN (GPIO_PIN_2) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM5_PORT (GPIO_PORTF_BASE) +#define PWM5_PIN (GPIO_PIN_3) + +#define PWM6_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM6_PORT (GPIO_PORTG_BASE) +#define PWM6_PIN (GPIO_PIN_6) + +#define PWM7_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM7_PORT (GPIO_PORTG_BASE) +#define PWM7_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define USB0EPEN_PERIPH (SYSCTL_PERIPH_GPIOH) +#define USB0EPEN_PORT (GPIO_PORTH_BASE) +#define USB0EPEN_PIN (GPIO_PIN_3) + +#define USB0PFLT_PERIPH (SYSCTL_PERIPH_GPIOH) +#define USB0PFLT_PORT (GPIO_PORTH_BASE) +#define USB0PFLT_PIN (GPIO_PIN_4) + +#endif // PART_LM3S5749 + +//***************************************************************************** +// +// LM3S5752 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S5752 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define ADC4_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC4_PORT (GPIO_PORTD_BASE) +#define ADC4_PIN (GPIO_PIN_3) + +#define ADC5_PERIPH (SYSCTL_PERIPH_GPIOD) +#define ADC5_PORT (GPIO_PORTD_BASE) +#define ADC5_PIN (GPIO_PIN_2) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_5) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP2_PORT (GPIO_PORTE_BASE) +#define CCP2_PIN (GPIO_PIN_4) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP3_PORT (GPIO_PORTA_BASE) +#define CCP3_PIN (GPIO_PIN_7) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define USB0EPEN_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0EPEN_PORT (GPIO_PORTC_BASE) +#define USB0EPEN_PIN (GPIO_PIN_5) + +#define USB0ID_PERIPH (SYSCTL_PERIPH_GPIOB) +#define USB0ID_PORT (GPIO_PORTB_BASE) +#define USB0ID_PIN (GPIO_PIN_0) + +#define USB0PFLT_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0PFLT_PORT (GPIO_PORTC_BASE) +#define USB0PFLT_PIN (GPIO_PIN_6) + +#define USB0VBUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define USB0VBUS_PORT (GPIO_PORTB_BASE) +#define USB0VBUS_PIN (GPIO_PIN_1) + +#endif // PART_LM3S5752 + +//***************************************************************************** +// +// LM3S5762 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S5762 + +#define ADC0_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC0_PORT (GPIO_PORTE_BASE) +#define ADC0_PIN (GPIO_PIN_3) + +#define ADC1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC1_PORT (GPIO_PORTE_BASE) +#define ADC1_PIN (GPIO_PIN_2) + +#define ADC2_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC2_PORT (GPIO_PORTE_BASE) +#define ADC2_PIN (GPIO_PIN_1) + +#define ADC3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define ADC3_PORT (GPIO_PORTE_BASE) +#define ADC3_PIN (GPIO_PIN_0) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CAN0RX_PORT (GPIO_PORTB_BASE) +#define CAN0RX_PIN (GPIO_PIN_4) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CAN0TX_PORT (GPIO_PORTB_BASE) +#define CAN0TX_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_2) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP1_PORT (GPIO_PORTB_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP2_PORT (GPIO_PORTC_BASE) +#define CCP2_PIN (GPIO_PIN_4) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define FAULT0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define FAULT0_PORT (GPIO_PORTB_BASE) +#define FAULT0_PIN (GPIO_PIN_3) + +#define NMI_PERIPH (SYSCTL_PERIPH_GPIOB) +#define NMI_PORT (GPIO_PORTB_BASE) +#define NMI_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM2_PORT (GPIO_PORTD_BASE) +#define PWM2_PIN (GPIO_PIN_2) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM3_PORT (GPIO_PORTD_BASE) +#define PWM3_PIN (GPIO_PIN_3) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM4_PORT (GPIO_PORTA_BASE) +#define PWM4_PIN (GPIO_PIN_6) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOA) +#define PWM5_PORT (GPIO_PORTA_BASE) +#define PWM5_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define USB0EPEN_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0EPEN_PORT (GPIO_PORTC_BASE) +#define USB0EPEN_PIN (GPIO_PIN_5) + +#define USB0ID_PERIPH (SYSCTL_PERIPH_GPIOB) +#define USB0ID_PORT (GPIO_PORTB_BASE) +#define USB0ID_PIN (GPIO_PIN_0) + +#define USB0PFLT_PERIPH (SYSCTL_PERIPH_GPIOC) +#define USB0PFLT_PORT (GPIO_PORTC_BASE) +#define USB0PFLT_PIN (GPIO_PIN_6) + +#define USB0VBUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define USB0VBUS_PORT (GPIO_PORTB_BASE) +#define USB0VBUS_PIN (GPIO_PIN_1) + +#endif // PART_LM3S5762 + +//***************************************************************************** +// +// LM3S6100 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6100 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S6100 + +//***************************************************************************** +// +// LM3S6110 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6110 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOB) +#define FAULT_PORT (GPIO_PORTB_BASE) +#define FAULT_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S6110 + +//***************************************************************************** +// +// LM3S6420 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6420 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C1O_PORT (GPIO_PORTE_BASE) +#define C1O_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S6420 + +//***************************************************************************** +// +// LM3S6422 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6422 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S6422 + +//***************************************************************************** +// +// LM3S6432 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6432 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S6432 + +//***************************************************************************** +// +// LM3S6537 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6537 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S6537 + +//***************************************************************************** +// +// LM3S6610 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6610 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C1O_PORT (GPIO_PORTE_BASE) +#define C1O_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C2O_PORT (GPIO_PORTE_BASE) +#define C2O_PIN (GPIO_PIN_7) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_0) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_7) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PHA0_PORT (GPIO_PORTD_BASE) +#define PHA0_PIN (GPIO_PIN_1) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PHB0_PORT (GPIO_PORTF_BASE) +#define PHB0_PIN (GPIO_PIN_0) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM1_PORT (GPIO_PORTF_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S6610 + +//***************************************************************************** +// +// LM3S6611 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6611 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C1O_PORT (GPIO_PORTE_BASE) +#define C1O_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP1_PORT (GPIO_PORTD_BASE) +#define CCP1_PIN (GPIO_PIN_7) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S6611 + +//***************************************************************************** +// +// LM3S6618 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6618 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOG) +#define I2C1SCL_PORT (GPIO_PORTG_BASE) +#define I2C1SCL_PIN (GPIO_PIN_0) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S6618 + +//***************************************************************************** +// +// LM3S6633 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6633 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S6633 + +//***************************************************************************** +// +// LM3S6637 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6637 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2O_PORT (GPIO_PORTC_BASE) +#define C2O_PIN (GPIO_PIN_6) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S6637 + +//***************************************************************************** +// +// LM3S6730 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6730 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C1O_PORT (GPIO_PORTE_BASE) +#define C1O_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S6730 + +//***************************************************************************** +// +// LM3S6753 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6753 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_0) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB0_PORT (GPIO_PORTC_BASE) +#define PHB0_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM0_PORT (GPIO_PORTF_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S6753 + +//***************************************************************************** +// +// LM3S6816 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6816 + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOE) +#define FAULT_PORT (GPIO_PORTE_BASE) +#define FAULT_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S6816 + +//***************************************************************************** +// +// LM3S6911 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6911 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOE) +#define C1O_PORT (GPIO_PORTE_BASE) +#define C1O_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP1_PORT (GPIO_PORTD_BASE) +#define CCP1_PIN (GPIO_PIN_7) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S6911 + +//***************************************************************************** +// +// LM3S6916 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6916 + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOE) +#define FAULT_PORT (GPIO_PORTE_BASE) +#define FAULT_PIN (GPIO_PIN_1) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S6916 + +//***************************************************************************** +// +// LM3S6918 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6918 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP4_PORT (GPIO_PORTC_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOG) +#define I2C1SCL_PORT (GPIO_PORTG_BASE) +#define I2C1SCL_PIN (GPIO_PIN_0) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S6918 + +//***************************************************************************** +// +// LM3S6938 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6938 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_6) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_0) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S6938 + +//***************************************************************************** +// +// LM3S6950 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6950 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_6) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2O_PORT (GPIO_PORTC_BASE) +#define C2O_PIN (GPIO_PIN_6) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_7) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PHA0_PORT (GPIO_PORTD_BASE) +#define PHA0_PIN (GPIO_PIN_1) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PHB0_PORT (GPIO_PORTF_BASE) +#define PHB0_PIN (GPIO_PIN_0) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM1_PORT (GPIO_PORTF_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_6) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_7) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S6950 + +//***************************************************************************** +// +// LM3S6952 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6952 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_6) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_0) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_7) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PHB0_PORT (GPIO_PORTF_BASE) +#define PHB0_PIN (GPIO_PIN_0) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM0_PORT (GPIO_PORTD_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S6952 + +//***************************************************************************** +// +// LM3S6965 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S6965 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP1_PORT (GPIO_PORTD_BASE) +#define CCP1_PIN (GPIO_PIN_7) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP2_PORT (GPIO_PORTD_BASE) +#define CCP2_PIN (GPIO_PIN_5) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_0) + +#define IDX1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define IDX1_PORT (GPIO_PORTF_BASE) +#define IDX1_PIN (GPIO_PIN_1) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHA1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PHA1_PORT (GPIO_PORTE_BASE) +#define PHA1_PIN (GPIO_PIN_3) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB0_PORT (GPIO_PORTC_BASE) +#define PHB0_PIN (GPIO_PIN_7) + +#define PHB1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PHB1_PORT (GPIO_PORTE_BASE) +#define PHB1_PIN (GPIO_PIN_2) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM0_PORT (GPIO_PORTF_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM1_PORT (GPIO_PORTD_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S6965 + +//***************************************************************************** +// +// LM3S8530 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S8530 + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CAN1RX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1RX_PORT (GPIO_PORTF_BASE) +#define CAN1RX_PIN (GPIO_PIN_0) + +#define CAN1TX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1TX_PORT (GPIO_PORTF_BASE) +#define CAN1TX_PIN (GPIO_PIN_1) + +#define CAN2RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CAN2RX_PORT (GPIO_PORTE_BASE) +#define CAN2RX_PIN (GPIO_PIN_4) + +#define CAN2TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CAN2TX_PORT (GPIO_PORTE_BASE) +#define CAN2TX_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S8530 + +//***************************************************************************** +// +// LM3S8538 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S8538 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_6) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_0) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S8538 + +//***************************************************************************** +// +// LM3S8630 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S8630 + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S8630 + +//***************************************************************************** +// +// LM3S8730 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S8730 + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S8730 + +//***************************************************************************** +// +// LM3S8733 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S8733 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S8733 + +//***************************************************************************** +// +// LM3S8738 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S8738 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S8738 + +//***************************************************************************** +// +// LM3S8930 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S8930 + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CAN1RX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1RX_PORT (GPIO_PORTF_BASE) +#define CAN1RX_PIN (GPIO_PIN_0) + +#define CAN1TX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1TX_PORT (GPIO_PORTF_BASE) +#define CAN1TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S8930 + +//***************************************************************************** +// +// LM3S8933 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S8933 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOD) +#define C0O_PORT (GPIO_PORTD_BASE) +#define C0O_PIN (GPIO_PIN_7) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP3_PORT (GPIO_PORTD_BASE) +#define CCP3_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S8933 + +//***************************************************************************** +// +// LM3S8938 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S8938 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_6) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define C1O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1O_PORT (GPIO_PORTC_BASE) +#define C1O_PIN (GPIO_PIN_5) + +#define C1_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C1_MINUS_PORT (GPIO_PORTB_BASE) +#define C1_MINUS_PIN (GPIO_PIN_5) + +#define C1_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C1_PLUS_PORT (GPIO_PORTC_BASE) +#define C1_PLUS_PIN (GPIO_PIN_5) + +#define C2O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2O_PORT (GPIO_PORTC_BASE) +#define C2O_PIN (GPIO_PIN_6) + +#define C2_MINUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_MINUS_PORT (GPIO_PORTC_BASE) +#define C2_MINUS_PIN (GPIO_PIN_7) + +#define C2_PLUS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C2_PLUS_PORT (GPIO_PORTC_BASE) +#define C2_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP1_PORT (GPIO_PORTE_BASE) +#define CCP1_PIN (GPIO_PIN_3) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP3_PORT (GPIO_PORTE_BASE) +#define CCP3_PIN (GPIO_PIN_0) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CCP4_PORT (GPIO_PORTE_BASE) +#define CCP4_PIN (GPIO_PIN_2) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP5_PORT (GPIO_PORTC_BASE) +#define CCP5_PIN (GPIO_PIN_4) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define I2C1SCL_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SCL_PORT (GPIO_PORTA_BASE) +#define I2C1SCL_PIN (GPIO_PIN_6) + +#define I2C1SDA_PERIPH (SYSCTL_PERIPH_GPIOA) +#define I2C1SDA_PORT (GPIO_PORTA_BASE) +#define I2C1SDA_PIN (GPIO_PIN_7) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#define U2RX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2RX_PORT (GPIO_PORTG_BASE) +#define U2RX_PIN (GPIO_PIN_0) + +#define U2TX_PERIPH (SYSCTL_PERIPH_GPIOG) +#define U2TX_PORT (GPIO_PORTG_BASE) +#define U2TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S8938 + +//***************************************************************************** +// +// LM3S8962 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S8962 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0O_PORT (GPIO_PORTB_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CCP0_PORT (GPIO_PORTD_BASE) +#define CCP0_PIN (GPIO_PIN_4) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOD) +#define FAULT_PORT (GPIO_PORTD_BASE) +#define FAULT_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOD) +#define IDX0_PORT (GPIO_PORTD_BASE) +#define IDX0_PIN (GPIO_PIN_7) + +#define IDX1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define IDX1_PORT (GPIO_PORTF_BASE) +#define IDX1_PIN (GPIO_PIN_1) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHA1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PHA1_PORT (GPIO_PORTE_BASE) +#define PHA1_PIN (GPIO_PIN_3) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB0_PORT (GPIO_PORTC_BASE) +#define PHB0_PIN (GPIO_PIN_6) + +#define PHB1_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PHB1_PORT (GPIO_PORTE_BASE) +#define PHB1_PIN (GPIO_PIN_2) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM0_PORT (GPIO_PORTF_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOG) +#define PWM1_PORT (GPIO_PORTG_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM2_PORT (GPIO_PORTB_BASE) +#define PWM2_PIN (GPIO_PIN_0) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOB) +#define PWM3_PORT (GPIO_PORTB_BASE) +#define PWM3_PIN (GPIO_PIN_1) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S8962 + +//***************************************************************************** +// +// LM3S8970 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S8970 + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CAN1RX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1RX_PORT (GPIO_PORTF_BASE) +#define CAN1RX_PIN (GPIO_PIN_0) + +#define CAN1TX_PERIPH (SYSCTL_PERIPH_GPIOF) +#define CAN1TX_PORT (GPIO_PORTF_BASE) +#define CAN1TX_PIN (GPIO_PIN_1) + +#define CAN2RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CAN2RX_PORT (GPIO_PORTE_BASE) +#define CAN2RX_PIN (GPIO_PIN_4) + +#define CAN2TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define CAN2TX_PORT (GPIO_PORTE_BASE) +#define CAN2TX_PIN (GPIO_PIN_5) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define I2C0SCL_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SCL_PORT (GPIO_PORTB_BASE) +#define I2C0SCL_PIN (GPIO_PIN_2) + +#define I2C0SDA_PERIPH (SYSCTL_PERIPH_GPIOB) +#define I2C0SDA_PORT (GPIO_PORTB_BASE) +#define I2C0SDA_PIN (GPIO_PIN_3) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SSI1CLK_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1CLK_PORT (GPIO_PORTE_BASE) +#define SSI1CLK_PIN (GPIO_PIN_0) + +#define SSI1FSS_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1FSS_PORT (GPIO_PORTE_BASE) +#define SSI1FSS_PIN (GPIO_PIN_1) + +#define SSI1RX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1RX_PORT (GPIO_PORTE_BASE) +#define SSI1RX_PIN (GPIO_PIN_2) + +#define SSI1TX_PERIPH (SYSCTL_PERIPH_GPIOE) +#define SSI1TX_PORT (GPIO_PORTE_BASE) +#define SSI1TX_PIN (GPIO_PIN_3) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#define U1RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1RX_PORT (GPIO_PORTD_BASE) +#define U1RX_PIN (GPIO_PIN_2) + +#define U1TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define U1TX_PORT (GPIO_PORTD_BASE) +#define U1TX_PIN (GPIO_PIN_3) + +#endif // PART_LM3S8970 + +//***************************************************************************** +// +// LM3S8971 Port/Pin Mapping Definitions +// +//***************************************************************************** +#ifdef PART_LM3S8971 + +#define C0O_PERIPH (SYSCTL_PERIPH_GPIOC) +#define C0O_PORT (GPIO_PORTC_BASE) +#define C0O_PIN (GPIO_PIN_5) + +#define C0_MINUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_MINUS_PORT (GPIO_PORTB_BASE) +#define C0_MINUS_PIN (GPIO_PIN_4) + +#define C0_PLUS_PERIPH (SYSCTL_PERIPH_GPIOB) +#define C0_PLUS_PORT (GPIO_PORTB_BASE) +#define C0_PLUS_PIN (GPIO_PIN_6) + +#define CAN0RX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0RX_PORT (GPIO_PORTD_BASE) +#define CAN0RX_PIN (GPIO_PIN_0) + +#define CAN0TX_PERIPH (SYSCTL_PERIPH_GPIOD) +#define CAN0TX_PORT (GPIO_PORTD_BASE) +#define CAN0TX_PIN (GPIO_PIN_1) + +#define CCP0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP0_PORT (GPIO_PORTB_BASE) +#define CCP0_PIN (GPIO_PIN_0) + +#define CCP1_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP1_PORT (GPIO_PORTA_BASE) +#define CCP1_PIN (GPIO_PIN_6) + +#define CCP2_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP2_PORT (GPIO_PORTB_BASE) +#define CCP2_PIN (GPIO_PIN_1) + +#define CCP3_PERIPH (SYSCTL_PERIPH_GPIOC) +#define CCP3_PORT (GPIO_PORTC_BASE) +#define CCP3_PIN (GPIO_PIN_6) + +#define CCP4_PERIPH (SYSCTL_PERIPH_GPIOA) +#define CCP4_PORT (GPIO_PORTA_BASE) +#define CCP4_PIN (GPIO_PIN_7) + +#define CCP5_PERIPH (SYSCTL_PERIPH_GPIOB) +#define CCP5_PORT (GPIO_PORTB_BASE) +#define CCP5_PIN (GPIO_PIN_5) + +#define FAULT_PERIPH (SYSCTL_PERIPH_GPIOB) +#define FAULT_PORT (GPIO_PORTB_BASE) +#define FAULT_PIN (GPIO_PIN_3) + +#define IDX0_PERIPH (SYSCTL_PERIPH_GPIOB) +#define IDX0_PORT (GPIO_PORTB_BASE) +#define IDX0_PIN (GPIO_PIN_2) + +#define LED0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED0_PORT (GPIO_PORTF_BASE) +#define LED0_PIN (GPIO_PIN_3) + +#define LED1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define LED1_PORT (GPIO_PORTF_BASE) +#define LED1_PIN (GPIO_PIN_2) + +#define PHA0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHA0_PORT (GPIO_PORTC_BASE) +#define PHA0_PIN (GPIO_PIN_4) + +#define PHB0_PERIPH (SYSCTL_PERIPH_GPIOC) +#define PHB0_PORT (GPIO_PORTC_BASE) +#define PHB0_PIN (GPIO_PIN_7) + +#define PWM0_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM0_PORT (GPIO_PORTF_BASE) +#define PWM0_PIN (GPIO_PIN_0) + +#define PWM1_PERIPH (SYSCTL_PERIPH_GPIOF) +#define PWM1_PORT (GPIO_PORTF_BASE) +#define PWM1_PIN (GPIO_PIN_1) + +#define PWM2_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM2_PORT (GPIO_PORTD_BASE) +#define PWM2_PIN (GPIO_PIN_2) + +#define PWM3_PERIPH (SYSCTL_PERIPH_GPIOD) +#define PWM3_PORT (GPIO_PORTD_BASE) +#define PWM3_PIN (GPIO_PIN_3) + +#define PWM4_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM4_PORT (GPIO_PORTE_BASE) +#define PWM4_PIN (GPIO_PIN_0) + +#define PWM5_PERIPH (SYSCTL_PERIPH_GPIOE) +#define PWM5_PORT (GPIO_PORTE_BASE) +#define PWM5_PIN (GPIO_PIN_1) + +#define SSI0CLK_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0CLK_PORT (GPIO_PORTA_BASE) +#define SSI0CLK_PIN (GPIO_PIN_2) + +#define SSI0FSS_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0FSS_PORT (GPIO_PORTA_BASE) +#define SSI0FSS_PIN (GPIO_PIN_3) + +#define SSI0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0RX_PORT (GPIO_PORTA_BASE) +#define SSI0RX_PIN (GPIO_PIN_4) + +#define SSI0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define SSI0TX_PORT (GPIO_PORTA_BASE) +#define SSI0TX_PIN (GPIO_PIN_5) + +#define SWCLK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWCLK_PORT (GPIO_PORTC_BASE) +#define SWCLK_PIN (GPIO_PIN_0) + +#define SWDIO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWDIO_PORT (GPIO_PORTC_BASE) +#define SWDIO_PIN (GPIO_PIN_1) + +#define SWO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define SWO_PORT (GPIO_PORTC_BASE) +#define SWO_PIN (GPIO_PIN_3) + +#define TCK_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TCK_PORT (GPIO_PORTC_BASE) +#define TCK_PIN (GPIO_PIN_0) + +#define TDI_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDI_PORT (GPIO_PORTC_BASE) +#define TDI_PIN (GPIO_PIN_2) + +#define TDO_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TDO_PORT (GPIO_PORTC_BASE) +#define TDO_PIN (GPIO_PIN_3) + +#define TMS_PERIPH (SYSCTL_PERIPH_GPIOC) +#define TMS_PORT (GPIO_PORTC_BASE) +#define TMS_PIN (GPIO_PIN_1) + +#define TRST_PERIPH (SYSCTL_PERIPH_GPIOB) +#define TRST_PORT (GPIO_PORTB_BASE) +#define TRST_PIN (GPIO_PIN_7) + +#define U0RX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0RX_PORT (GPIO_PORTA_BASE) +#define U0RX_PIN (GPIO_PIN_0) + +#define U0TX_PERIPH (SYSCTL_PERIPH_GPIOA) +#define U0TX_PORT (GPIO_PORTA_BASE) +#define U0TX_PIN (GPIO_PIN_1) + +#endif // PART_LM3S8971 + +//***************************************************************************** +// +// Pin Mapping Functions +// +// This section describes the code that is responsible for handling the +// mapping of peripheral functions to their physical location on the pins of +// a device. +// +//***************************************************************************** + +//***************************************************************************** +// +// Definitions to support mapping GPIO Ports and Pins to their function. +// +//***************************************************************************** + +//***************************************************************************** +// +// Configures the specified ADC pin to function as an ADC pin. +// +// \param ulName is one of the valid names for the ADC pins. +// +// This function takes on of the valid names for an ADC pin and configures +// the pin for its ADC functionality depending on the part that is defined. +// +// The valid names for the pins are as follows: \b ADC0, \b ADC1, \b ADC2, +// \b ADC3, \b ADC4, \b ADC5, \b ADC6, or \b ADC7. +// +// \sa GPIOPinTypeADC() in order to configure multiple ADC pins at once. +// +// \return None. +// +//***************************************************************************** +#define PinTypeADC(ulName) GPIOPinTypeADC(ulName##_PORT, ulName##_PIN) + +//***************************************************************************** +// +// Configures the specified CAN pin to function as a CAN pin. +// +// \param ulName is one of the valid names for the CAN pins. +// +// This function takes one of the valid names for a CAN pin and configures +// the pin for its CAN functionality depending on the part that is defined. +// +// The valid names for the pins are as follows: \b CAN0RX, \b CAN0TX, +// \b CAN1RX, \b CAN1TX, \b CAN2RX, or \b CAN2TX. +// +// \sa GPIOPinTypeCAN() in order to configure multiple CAN pins at once. +// +// \return None. +// +//***************************************************************************** +#define PinTypeCAN(ulName) GPIOPinTypeCAN(ulName##_PORT, ulName##_PIN) + +//***************************************************************************** +// +// Configures the specified comparator pin to function as a comparator pin. +// +// \param ulName is one of the valid names for the Comparator pins. +// +// This function takes one of the valid names for a comparator pin and +// configures the pin for its comparator functionality depending on the part +// that is defined. +// +// The valid names for the pins are as follows: \b C0_MINUS, \b C0_PLUS, +// \b C1_MINUS, \b C1_PLUS, \b C2_MINUS, or \b C2_PLUS. +// +// \sa GPIOPinTypeComparator() in order to configure multiple comparator pins +// at once. +// +// \return None. +// +//***************************************************************************** +#define PinTypeComparator(ulName) \ + GPIOPinTypeComparator(ulName##_PORT, \ + ulName##_PIN) + +//***************************************************************************** +// +// Configures the specified I2C pin to function as an I2C pin. +// +// \param ulName is one of the valid names for the I2C pins. +// +// This function takes one of the valid names for an I2C pin and configures +// the pin for its I2C functionality depending on the part that is defined. +// +// The valid names for the pins are as follows: \b I2C0SCL, \b I2C0SDA, +// \b I2C1SCL, or \b I2C1SDA. +// +// \sa GPIOPinTypeI2C() in order to configure multiple I2C pins at once. +// +// \return None. +// +//***************************************************************************** +#define PinTypeI2C(ulName) GPIOPinTypeI2C(ulName##_PORT, ulName##_PIN) + +//***************************************************************************** +// +// Configures the specified PWM pin to function as a PWM pin. +// +// \param ulName is one of the valid names for the PWM pins. +// +// This function takes one of the valid names for a PWM pin and configures +// the pin for its PWM functionality depending on the part that is defined. +// +// The valid names for the pins are as follows: \b PWM0, \b PWM1, \b PWM2, +// \b PWM3, \b PWM4, \b PWM5, or \b FAULT. +// +// \sa GPIOPinTypePWM() in order to configure multiple PWM pins at once. +// +// \return None. +// +//***************************************************************************** +#define PinTypePWM(ulName) GPIOPinTypePWM(ulName##_PORT, ulName##_PIN) + +//***************************************************************************** +// +// Configures the specified QEI pin to function as a QEI pin. +// +// \param ulName is one of the valid names for the QEI pins. +// +// This function takes one of the valid names for a QEI pin and configures +// the pin for its QEI functionality depending on the part that is defined. +// +// The valid names for the pins are as follows: \b PHA0, \b PHB0, \b IDX0, +// \b PHA1, \b PHB1, or \b IDX1. +// +// \sa GPIOPinTypeQEI() in order to configure multiple QEI pins at once. +// +// \return None. +// +//***************************************************************************** +#define PinTypeQEI(ulName) GPIOPinTypeQEI(ulName##_PORT, ulName##_PIN) + +//***************************************************************************** +// +// Configures the specified SSI pin to function as an SSI pin. +// +// \param ulName is one of the valid names for the SSI pins. +// +// This function takes one of the valid names for an SSI pin and configures +// the pin for its SSI functionality depending on the part that is defined. +// +// The valid names for the pins are as follows: \b SSI0CLK, \b SSI0FSS, +// \b SSI0RX, \b SSI0TX, \b SSI1CLK, \b SSI1FSS, \b SSI1RX, or \b SSI1TX. +// +// \sa GPIOPinTypeSSI() in order to configure multiple SSI pins at once. +// +// \return None. +// +//***************************************************************************** +#define PinTypeSSI(ulName) GPIOPinTypeSSI(ulName##_PORT, ulName##_PIN) + +//***************************************************************************** +// +// Configures the specified Timer pin to function as a Timer pin. +// +// \param ulName is one of the valid names for the Timer pins. +// +// This function takes one of the valid names for a Timer pin and configures +// the pin for its Timer functionality depending on the part that is defined. +// +// The valid names for the pins are as follows: \b CCP0, \b CCP1, \b CCP2, +// \b CCP3, \b CCP4, \b CCP5, \b CCP6, or \b CCP7. +// +// \sa GPIOPinTypeTimer() in order to configure multiple CCP pins at once. +// +// \return None. +// +//***************************************************************************** +#define PinTypeTimer(ulName) GPIOPinTypeTimer(ulName##_PORT, ulName##_PIN) + +//***************************************************************************** +// +// Configures the specified UART pin to function as a UART pin. +// +// \param ulName is one of the valid names for the UART pins. +// +// This function takes one of the valid names for a UART pin and configures +// the pin for its UART functionality depending on the part that is defined. +// +// The valid names for the pins are as follows: \b U0RX, \b U0TX, \b U1RX, +// \b U1TX, \b U2RX, or \b U2TX. +// +// \sa GPIOPinTypeUART() in order to configure multiple UART pins at once. +// +// \return None. +// +//***************************************************************************** +#define PinTypeUART(ulName) GPIOPinTypeUART(ulName##_PORT, ulName##_PIN) + +//***************************************************************************** +// +//! Configures the specified USB digital pin to function as a USB pin. +//! +//! \param ulName is one of the valid names for a USB digital pin. +//! +//! This function takes one of the valid names for a USB digital pin and +//! configures the pin for its USB functionality depending on the part that is +//! defined. +//! +//! The valid names for the pins are as follows: \b EPEN or \b PFAULT. +//! +//! \sa GPIOPinTypeUSBDigital() in order to configure multiple USB pins at +//! once. +//! +//! \return None. +// +//***************************************************************************** +#define PinTypeUSBDigital(ulName) \ + GPIOPinTypeUSBDigital(ulName##_PORT, \ + ulName##_PIN) + +//***************************************************************************** +// +//! Enables the peripheral port used by the given pin. +//! +//! \param ulName is one of the valid names for a pin. +//! +//! This function takes one of the valid names for a pin function and +//! enables the peripheral port for that pin depending on the part that is +//! defined. +//! +//! Any valid pin name can be used. +//! +//! \sa SysCtlPeripheralEnable() in order to enable a single port when +//! multiple pins are on the same port. +//! +//! \return None. +// +//***************************************************************************** +#define PeripheralEnable(ulName) \ + SysCtlPeripheralEnable(ulName##_PERIPH) + +#endif // __PIN_MAP_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/pwm.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/pwm.c new file mode 100644 index 00000000..5f82c487 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/pwm.c @@ -0,0 +1,1748 @@ +//***************************************************************************** +// +// pwm.c - API for the PWM modules +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup pwm_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_pwm.h" +#include "inc/hw_sysctl.h" +#include "inc/hw_types.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" +#include "driverlib/pwm.h" + +//***************************************************************************** +// +// Misc macros for manipulating the encoded generator and output defines used +// by the API. +// +//***************************************************************************** +#define PWM_GEN_BADDR(_mod_, _gen_) \ + ((_mod_) + (_gen_)) +#define PWM_GEN_EXT_BADDR(_mod_, _gen_) \ + ((_mod_) + PWM_GEN_EXT_0 + \ + ((_gen_) - PWM_GEN_0) * 2) +#define PWM_OUT_BADDR(_mod_, _out_) \ + ((_mod_) + ((_out_) & 0xFFFFFFC0)) +#define PWM_IS_OUTPUT_ODD(_out_) \ + ((_out_) & 0x00000001) + +//***************************************************************************** +// +//! \internal +//! Checks a PWM generator number. +//! +//! \param ulGen is the generator number. +//! +//! This function determines if a PWM generator number is valid. +//! +//! \return Returnes \b true if the generator number is valid and \b false +//! otherwise. +// +//***************************************************************************** +#ifdef DEBUG +static tBoolean +PWMGenValid(unsigned long ulGen) +{ + return((ulGen == PWM_GEN_0) || (ulGen == PWM_GEN_1) || + (ulGen == PWM_GEN_2) || (ulGen == PWM_GEN_3)); +} +#endif + +//***************************************************************************** +// +//! \internal +//! Checks a PWM output number. +//! +//! \param ulPWMOut is the output number. +//! +//! This function determines if a PWM output number is valid. +//! +//! \return Returns \b true if the output number is valid and \b false +//! otherwise. +// +//***************************************************************************** +#ifdef DEBUG +static tBoolean +PWMOutValid(unsigned long ulPWMOut) +{ + return((ulPWMOut == PWM_OUT_0) || (ulPWMOut == PWM_OUT_1) || + (ulPWMOut == PWM_OUT_2) || (ulPWMOut == PWM_OUT_3) || + (ulPWMOut == PWM_OUT_4) || (ulPWMOut == PWM_OUT_5) || + (ulPWMOut == PWM_OUT_6) || (ulPWMOut == PWM_OUT_7)); +} +#endif + +//***************************************************************************** +// +//! Configures a PWM generator. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator to configure. Must be one of +//! \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! \param ulConfig is the configuration for the PWM generator. +//! +//! This function is used to set the mode of operation for a PWM generator. +//! The counting mode, synchronization mode, and debug behavior are all +//! configured. After configuration, the generator is left in the disabled +//! state. +//! +//! A PWM generator can count in two different modes: count down mode or count +//! up/down mode. In count down mode, it will count from a value down to zero, +//! and then reset to the preset value. This will produce left-aligned PWM +//! signals (that is the rising edge of the two PWM signals produced by the +//! generator will occur at the same time). In count up/down mode, it will +//! count up from zero to the preset value, count back down to zero, and then +//! repeat the process. This will produce center-aligned PWM signals (that is, +//! the middle of the high/low period of the PWM signals produced by the +//! generator will occur at the same time). +//! +//! When the PWM generator parameters (period and pulse width) are modified, +//! their affect on the output PWM signals can be delayed. In synchronous +//! mode, the parameter updates are not applied until a synchronization event +//! occurs. This allows multiple parameters to be modified and take affect +//! simultaneously, instead of one at a time. Additionally, parameters to +//! multiple PWM generators in synchronous mode can be updated simultaneously, +//! allowing them to be treated as if they were a unified generator. In +//! non-synchronous mode, the parameter updates are not delayed until a +//! synchronization event. In either mode, the parameter updates only occur +//! when the counter is at zero to help prevent oddly formed PWM signals during +//! the update (that is, a PWM pulse that is too short or too long). +//! +//! The PWM generator can either pause or continue running when the processor +//! is stopped via the debugger. If configured to pause, it will continue to +//! count until it reaches zero, at which point it will pause until the +//! processor is restarted. If configured to continue running, it will keep +//! counting as if nothing had happened. +//! +//! The \e ulConfig parameter contains the desired configuration. It is the +//! logical OR of the following: +//! +//! - \b PWM_GEN_MODE_DOWN or \b PWM_GEN_MODE_UP_DOWN to specify the counting +//! mode +//! - \b PWM_GEN_MODE_SYNC or \b PWM_GEN_MODE_NO_SYNC to specify the counter +//! load and comparator update synchronization mode +//! - \b PWM_GEN_MODE_DBG_RUN or \b PWM_GEN_MODE_DBG_STOP to specify the debug +//! behavior +//! - \b PWM_GEN_MODE_GEN_NO_SYNC, \b PWM_GEN_MODE_GEN_SYNC_LOCAL, or +//! \b PWM_GEN_MODE_GEN_SYNC_GLOBAL to specify the update synchronization +//! mode for generator counting mode changes +//! - \b PWM_GEN_MODE_DB_NO_SYNC, \b PWM_GEN_MODE_DB_SYNC_LOCAL, or +//! \b PWM_GEN_MODE_DB_SYNC_GLOBAL to specify the deadband parameter +//! synchronization mode +//! - \b PWM_GEN_MODE_FAULT_LATCHED or \b PWM_GEN_MODE_FAULT_UNLATCHED to +//! specify whether fault conditions are latched or not +//! - \b PWM_GEN_MODE_FAULT_MINPER or \b PWM_GEN_MODE_FAULT_NO_MINPER to +//! specify whether minimum fault period support is required +//! - \b PWM_GEN_MODE_FAULT_EXT or \b PWM_GEN_MODE_FAULT_LEGACY to specify +//! whether extended fault source selection support is enabled or not +//! +//! Setting \b PWM_GEN_MODE_FAULT_MINPER allows an application to set the +//! minimum duration of a PWM fault signal. Fault will be signaled for at +//! least this time even if the external fault pin deasserts earlier. Care +//! should be taken when using this mode since during the fault signal period, +//! the fault interrupt from the PWM generator will remain asserted. The fault +//! interrupt handler may, therefore, reenter immediately if it exits prior to +//! expiration of the fault timer. +//! +//! \note Changes to the counter mode will affect the period of the PWM signals +//! produced. PWMGenPeriodSet() and PWMPulseWidthSet() should be called after +//! any changes to the counter mode of a generator. +//! +//! \return None. +// +//***************************************************************************** +void +PWMGenConfigure(unsigned long ulBase, unsigned long ulGen, + unsigned long ulConfig) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + + // + // Compute the generator's base address. + // + ulGen = PWM_GEN_BADDR(ulBase, ulGen); + + // + // Change the global configuration of the generator. + // + HWREG(ulGen + PWM_O_X_CTL) = ((HWREG(ulGen + PWM_O_X_CTL) & + ~(PWM_X_CTL_MODE | PWM_X_CTL_DEBUG | + PWM_X_CTL_LATCH | PWM_X_CTL_MINFLTPER | + PWM_X_CTL_FLTSRC | PWM_X_CTL_DBFALLUPD_M | + PWM_X_CTL_DBRISEUPD_M | + PWM_X_CTL_DBCTLUPD_M | + PWM_X_CTL_GENBUPD_M | + PWM_X_CTL_GENAUPD_M | + PWM_X_CTL_LOADUPD | PWM_X_CTL_CMPAUPD | + PWM_X_CTL_CMPBUPD)) | ulConfig); + + // + // Set the individual PWM generator controls. + // + if(ulConfig & PWM_X_CTL_MODE) + { + // + // In up/down count mode, set the signal high on up count comparison + // and low on down count comparison (that is, center align the + // signals). + // + HWREG(ulGen + PWM_O_X_GENA) = (PWM_X_GENA_ACTCMPAU_ONE | + PWM_X_GENA_ACTCMPAD_ZERO); + HWREG(ulGen + PWM_O_X_GENB) = (PWM_X_GENB_ACTCMPBU_ONE | + PWM_X_GENB_ACTCMPBD_ZERO); + } + else + { + // + // In down count mode, set the signal high on load and low on count + // comparison (that is, left align the signals). + // + HWREG(ulGen + PWM_O_X_GENA) = (PWM_X_GENA_ACTLOAD_ONE | + PWM_X_GENA_ACTCMPAD_ZERO); + HWREG(ulGen + PWM_O_X_GENB) = (PWM_X_GENB_ACTLOAD_ONE | + PWM_X_GENB_ACTCMPBD_ZERO); + } +} + +//***************************************************************************** +// +//! Set the period of a PWM generator. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator to be modified. Must be one of +//! \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! \param ulPeriod specifies the period of PWM generator output, measured +//! in clock ticks. +//! +//! This function sets the period of the specified PWM generator block, where +//! the period of the generator block is defined as the number of PWM clock +//! ticks between pulses on the generator block zero signal. +//! +//! \note Any subsequent calls made to this function before an update occurs +//! will cause the previous values to be overwritten. +//! +//! \return None. +// +//***************************************************************************** +void +PWMGenPeriodSet(unsigned long ulBase, unsigned long ulGen, + unsigned long ulPeriod) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + + // + // Compute the generator's base address. + // + ulGen = PWM_GEN_BADDR(ulBase, ulGen); + + // + // Set the reload register based on the mode. + // + if(HWREG(ulGen + PWM_O_X_CTL) & PWM_X_CTL_MODE) + { + // + // In up/down count mode, set the reload register to half the requested + // period. + // + ASSERT((ulPeriod / 2) < 65536); + HWREG(ulGen + PWM_O_X_LOAD) = ulPeriod / 2; + } + else + { + // + // In down count mode, set the reload register to the requested period + // minus one. + // + ASSERT((ulPeriod <= 65536) && (ulPeriod != 0)); + HWREG(ulGen + PWM_O_X_LOAD) = ulPeriod - 1; + } +} + +//***************************************************************************** +// +//! Gets the period of a PWM generator block. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator to query. Must be one of +//! \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! +//! This function gets the period of the specified PWM generator block. The +//! period of the generator block is defined as the number of PWM clock ticks +//! between pulses on the generator block zero signal. +//! +//! If the update of the counter for the specified PWM generator has yet +//! to be completed, the value returned may not be the active period. The +//! value returned is the programmed period, measured in PWM clock ticks. +//! +//! \return Returns the programmed period of the specified generator block +//! in PWM clock ticks. +// +//***************************************************************************** +unsigned long +PWMGenPeriodGet(unsigned long ulBase, unsigned long ulGen) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + + // + // Compute the generator's base address. + // + ulGen = PWM_GEN_BADDR(ulBase, ulGen); + + // + // Figure out the counter mode. + // + if(HWREG(ulGen + PWM_O_X_CTL) & PWM_X_CTL_MODE) + { + // + // The period is twice the reload register value. + // + return(HWREG(ulGen + PWM_O_X_LOAD) * 2); + } + else + { + // + // The period is the reload register value plus one. + // + return(HWREG(ulGen + PWM_O_X_LOAD) + 1); + } +} + +//***************************************************************************** +// +//! Enables the timer/counter for a PWM generator block. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator to be enabled. Must be one of +//! \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! +//! This function allows the PWM clock to drive the timer/counter for the +//! specified generator block. +//! +//! \return None. +// +//***************************************************************************** +void +PWMGenEnable(unsigned long ulBase, unsigned long ulGen) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + + // + // Enable the PWM generator. + // + HWREG(PWM_GEN_BADDR(ulBase, ulGen) + PWM_O_X_CTL) |= PWM_X_CTL_ENABLE; +} + +//***************************************************************************** +// +//! Disables the timer/counter for a PWM generator block. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator to be disabled. Must be one of +//! \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! +//! This function blocks the PWM clock from driving the timer/counter for the +//! specified generator block. +//! +//! \return None. +// +//***************************************************************************** +void +PWMGenDisable(unsigned long ulBase, unsigned long ulGen) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + + // + // Disable the PWM generator. + // + HWREG(PWM_GEN_BADDR(ulBase, + ulGen) + PWM_O_X_CTL) &= ~(PWM_X_CTL_ENABLE); +} + +//***************************************************************************** +// +//! Sets the pulse width for the specified PWM output. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulPWMOut is the PWM output to modify. Must be one of \b PWM_OUT_0, +//! \b PWM_OUT_1, \b PWM_OUT_2, \b PWM_OUT_3, \b PWM_OUT_4, \b PWM_OUT_5, +//! \b PWM_OUT_6, or \b PWM_OUT_7. +//! \param ulWidth specifies the width of the positive portion of the pulse. +//! +//! This function sets the pulse width for the specified PWM output, where the +//! pulse width is defined as the number of PWM clock ticks. +//! +//! \note Any subsequent calls made to this function before an update occurs +//! will cause the previous values to be overwritten. +//! +//! \return None. +// +//***************************************************************************** +void +PWMPulseWidthSet(unsigned long ulBase, unsigned long ulPWMOut, + unsigned long ulWidth) +{ + unsigned long ulGenBase, ulReg; + + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMOutValid(ulPWMOut)); + + // + // Compute the generator's base address. + // + ulGenBase = PWM_OUT_BADDR(ulBase, ulPWMOut); + + // + // If the counter is in up/down count mode, divide the width by two. + // + if(HWREG(ulGenBase + PWM_O_X_CTL) & PWM_X_CTL_MODE) + { + ulWidth /= 2; + } + + // + // Get the period. + // + ulReg = HWREG(ulGenBase + PWM_O_X_LOAD); + + // + // Make sure the width is not too large. + // + ASSERT(ulWidth < ulReg); + + // + // Compute the compare value. + // + ulReg = ulReg - ulWidth; + + // + // Write to the appropriate registers. + // + if(PWM_IS_OUTPUT_ODD(ulPWMOut)) + { + HWREG(ulGenBase + PWM_O_X_CMPB) = ulReg; + } + else + { + HWREG(ulGenBase + PWM_O_X_CMPA) = ulReg; + } +} + +//***************************************************************************** +// +//! Gets the pulse width of a PWM output. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulPWMOut is the PWM output to query. Must be one of \b PWM_OUT_0, +//! \b PWM_OUT_1, \b PWM_OUT_2, \b PWM_OUT_3, \b PWM_OUT_4, \b PWM_OUT_5, +//! \b PWM_OUT_6, or \b PWM_OUT_7. +//! +//! This function gets the currently programmed pulse width for the specified +//! PWM output. If the update of the comparator for the specified output has +//! yet to be completed, the value returned may not be the active pulse width. +//! The value returned is the programmed pulse width, measured in PWM clock +//! ticks. +//! +//! \return Returns the width of the pulse in PWM clock ticks. +// +//***************************************************************************** +unsigned long +PWMPulseWidthGet(unsigned long ulBase, unsigned long ulPWMOut) +{ + unsigned long ulGenBase, ulReg, ulLoad; + + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMOutValid(ulPWMOut)); + + // + // Compute the generator's base address. + // + ulGenBase = PWM_OUT_BADDR(ulBase, ulPWMOut); + + // + // Then compute the pulse width. If mode is UpDown, set + // width = (load - compare) * 2. Otherwise, set width = load - compare. + // + ulLoad = HWREG(ulGenBase + PWM_O_X_LOAD); + if(PWM_IS_OUTPUT_ODD(ulPWMOut)) + { + ulReg = HWREG(ulGenBase + PWM_O_X_CMPB); + } + else + { + ulReg = HWREG(ulGenBase + PWM_O_X_CMPA); + } + ulReg = ulLoad - ulReg; + + // + // If in up/down count mode, double the pulse width. + // + if(HWREG(ulGenBase + PWM_O_X_CTL) & PWM_X_CTL_MODE) + { + ulReg = ulReg * 2; + } + + // + // Return the pulse width. + // + return(ulReg); +} + +//***************************************************************************** +// +//! Enables the PWM dead band output, and sets the dead band delays. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator to modify. Must be one of +//! \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! \param usRise specifies the width of delay from the rising edge. +//! \param usFall specifies the width of delay from the falling edge. +//! +//! This function sets the dead bands for the specified PWM generator, +//! where the dead bands are defined as the number of \b PWM clock ticks +//! from the rising or falling edge of the generator's \b OutA signal. +//! Note that this function causes the coupling of \b OutB to \b OutA. +//! +//! \return None. +// +//***************************************************************************** +void +PWMDeadBandEnable(unsigned long ulBase, unsigned long ulGen, + unsigned short usRise, unsigned short usFall) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + ASSERT(usRise < 4096); + ASSERT(usFall < 4096); + + // + // Compute the generator's base address. + // + ulGen = PWM_GEN_BADDR(ulBase, ulGen); + + // + // Write the dead band delay values. + // + HWREG(ulGen + PWM_O_X_DBRISE) = usRise; + HWREG(ulGen + PWM_O_X_DBFALL) = usFall; + + // + // Enable the deadband functionality. + // + HWREG(ulGen + PWM_O_X_DBCTL) |= PWM_X_DBCTL_ENABLE; +} + +//***************************************************************************** +// +//! Disables the PWM dead band output. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator to modify. Must be one of +//! \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! +//! This function disables the dead band mode for the specified PWM generator. +//! Doing so decouples the \b OutA and \b OutB signals. +//! +//! \return None. +// +//***************************************************************************** +void +PWMDeadBandDisable(unsigned long ulBase, unsigned long ulGen) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + + // + // Disable the deadband functionality. + // + HWREG(PWM_GEN_BADDR(ulBase, ulGen) + PWM_O_X_DBCTL) &= + ~(PWM_X_DBCTL_ENABLE); +} + +//***************************************************************************** +// +//! Synchronizes all pending updates. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGenBits are the PWM generator blocks to be updated. Must be the +//! logical OR of any of \b PWM_GEN_0_BIT, \b PWM_GEN_1_BIT, +//! \b PWM_GEN_2_BIT, or \b PWM_GEN_3_BIT. +//! +//! For the selected PWM generators, this function causes all queued updates to +//! the period or pulse width to be applied the next time the corresponding +//! counter becomes zero. +//! +//! \return None. +// +//***************************************************************************** +void +PWMSyncUpdate(unsigned long ulBase, unsigned long ulGenBits) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(!(ulGenBits & ~(PWM_GEN_0_BIT | PWM_GEN_1_BIT | PWM_GEN_2_BIT | + PWM_GEN_3_BIT))); + + // + // Synchronize pending PWM register changes. + // + HWREG(ulBase + PWM_O_CTL) = ulGenBits; +} + +//***************************************************************************** +// +//! Synchronizes the counters in one or multiple PWM generator blocks. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGenBits are the PWM generator blocks to be synchronized. Must be +//! the logical OR of any of \b PWM_GEN_0_BIT, \b PWM_GEN_1_BIT, +//! \b PWM_GEN_2_BIT, or \b PWM_GEN_3_BIT. +//! +//! For the selected PWM module, this function synchronizes the time base +//! of the generator blocks by causing the specified generator counters to be +//! reset to zero. +//! +//! \return None. +// +//***************************************************************************** +void +PWMSyncTimeBase(unsigned long ulBase, unsigned long ulGenBits) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(!(ulGenBits & ~(PWM_GEN_0_BIT | PWM_GEN_1_BIT | PWM_GEN_2_BIT | + PWM_GEN_3_BIT))); + + // + // Synchronize the counters in the specified generators by writing to the + // module's synchronization register. + // + HWREG(ulBase + PWM_O_SYNC) = ulGenBits; +} + +//***************************************************************************** +// +//! Enables or disables PWM outputs. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulPWMOutBits are the PWM outputs to be modified. Must be the +//! logical OR of any of \b PWM_OUT_0_BIT, \b PWM_OUT_1_BIT, \b PWM_OUT_2_BIT, +//! \b PWM_OUT_3_BIT, \b PWM_OUT_4_BIT, \b PWM_OUT_5_BIT, \b PWM_OUT_6_BIT, +//! or \b PWM_OUT_7_BIT. +//! \param bEnable determines if the signal is enabled or disabled. +//! +//! This function is used to enable or disable the selected PWM outputs. The +//! outputs are selected using the parameter \e ulPWMOutBits. The parameter +//! \e bEnable determines the state of the selected outputs. If \e bEnable is +//! \b true, then the selected PWM outputs are enabled, or placed in the active +//! state. If \e bEnable is \b false, then the selected outputs are disabled, +//! or placed in the inactive state. +//! +//! \return None. +// +//***************************************************************************** +void +PWMOutputState(unsigned long ulBase, unsigned long ulPWMOutBits, + tBoolean bEnable) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(!(ulPWMOutBits & ~(PWM_OUT_0_BIT | PWM_OUT_1_BIT | PWM_OUT_2_BIT | + PWM_OUT_3_BIT | PWM_OUT_4_BIT | PWM_OUT_5_BIT | + PWM_OUT_6_BIT | PWM_OUT_7_BIT))); + + // + // Read the module's ENABLE output control register, and set or clear the + // requested bits. + // + if(bEnable == true) + { + HWREG(ulBase + PWM_O_ENABLE) |= ulPWMOutBits; + } + else + { + HWREG(ulBase + PWM_O_ENABLE) &= ~(ulPWMOutBits); + } +} + +//***************************************************************************** +// +//! Selects the inversion mode for PWM outputs. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulPWMOutBits are the PWM outputs to be modified. Must be the +//! logical OR of any of \b PWM_OUT_0_BIT, \b PWM_OUT_1_BIT, \b PWM_OUT_2_BIT, +//! \b PWM_OUT_3_BIT, \b PWM_OUT_4_BIT, \b PWM_OUT_5_BIT, \b PWM_OUT_6_BIT, or +//! \b PWM_OUT_7_BIT. +//! \param bInvert determines if the signal is inverted or passed through. +//! +//! This function is used to select the inversion mode for the selected PWM +//! outputs. The outputs are selected using the parameter \e ulPWMOutBits. +//! The parameter \e bInvert determines the inversion mode for the selected +//! outputs. If \e bInvert is \b true, this function will cause the specified +//! PWM output signals to be inverted, or made active low. If \e bInvert is +//! \b false, the specified output will be passed through as is, or be made +//! active high. +//! +//! \return None. +// +//***************************************************************************** +void +PWMOutputInvert(unsigned long ulBase, unsigned long ulPWMOutBits, + tBoolean bInvert) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(!(ulPWMOutBits & ~(PWM_OUT_0_BIT | PWM_OUT_1_BIT | PWM_OUT_2_BIT | + PWM_OUT_3_BIT | PWM_OUT_4_BIT | PWM_OUT_5_BIT | + PWM_OUT_6_BIT | PWM_OUT_7_BIT))); + + // + // Read the module's INVERT output control register, and set or clear the + // requested bits. + // + if(bInvert == true) + { + HWREG(ulBase + PWM_O_INVERT) |= ulPWMOutBits; + } + else + { + HWREG(ulBase + PWM_O_INVERT) &= ~(ulPWMOutBits); + } +} + +//***************************************************************************** +// +//! Specifies the level of PWM outputs suppressed in response to a fault +//! condition. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulPWMOutBits are the PWM outputs to be modified. Must be the +//! logical OR of any of \b PWM_OUT_0_BIT, \b PWM_OUT_1_BIT, \b PWM_OUT_2_BIT, +//! \b PWM_OUT_3_BIT, \b PWM_OUT_4_BIT, \b PWM_OUT_5_BIT, \b PWM_OUT_6_BIT, or +//! \b PWM_OUT_7_BIT. +//! \param bDriveHigh determines if the signal is driven high or low during an +//! active fault condition. +//! +//! This function determines whether a PWM output pin that is suppressed in +//! response to a fault condition will be driven high or low. The affected +//! outputs are selected using the parameter \e ulPWMOutBits. The parameter +//! \e bDriveHigh determines the output level for the pins identified by +//! \e ulPWMOutBits. If \e bDriveHigh is \b true then the selected outputs +//! will be driven high when a fault is detected. If it is \e false, the pins +//! will be driven low. +//! +//! In a fault condition, pins which have not been configured to be suppressed +//! via a call to PWMOutputFault() are unaffected by this function. +//! +//! \note This function is available only on devices which support extended +//! PWM fault handling. +//! +//! \return None. +// +//***************************************************************************** +void +PWMOutputFaultLevel(unsigned long ulBase, unsigned long ulPWMOutBits, + tBoolean bDriveHigh) +{ + // + // Check the arguments. + // + ASSERT(HWREG(SYSCTL_DC5) & SYSCTL_DC5_PWMEFLT); + ASSERT(ulBase == PWM_BASE); + ASSERT(!(ulPWMOutBits & ~(PWM_OUT_0_BIT | PWM_OUT_1_BIT | PWM_OUT_2_BIT | + PWM_OUT_3_BIT | PWM_OUT_4_BIT | PWM_OUT_5_BIT | + PWM_OUT_6_BIT | PWM_OUT_7_BIT))); + + // + // Read the module's FAULT output control register, and set or clear the + // requested bits. + // + if(bDriveHigh == true) + { + HWREG(ulBase + PWM_O_FAULTVAL) |= ulPWMOutBits; + } + else + { + HWREG(ulBase + PWM_O_FAULTVAL) &= ~(ulPWMOutBits); + } +} + +//***************************************************************************** +// +//! Specifies the state of PWM outputs in response to a fault condition. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulPWMOutBits are the PWM outputs to be modified. Must be the +//! logical OR of any of \b PWM_OUT_0_BIT, \b PWM_OUT_1_BIT, \b PWM_OUT_2_BIT, +//! \b PWM_OUT_3_BIT, \b PWM_OUT_4_BIT, \b PWM_OUT_5_BIT, \b PWM_OUT_6_BIT, or +//! \b PWM_OUT_7_BIT. +//! \param bFaultSuppress determines if the signal is suppressed or passed +//! through during an active fault condition. +//! +//! This function sets the fault handling characteristics of the selected PWM +//! outputs. The outputs are selected using the parameter \e ulPWMOutBits. +//! The parameter \e bFaultSuppress determines the fault handling +//! characteristics for the selected outputs. If \e bFaultSuppress is \b true, +//! then the selected outputs will be made inactive. If \e bFaultSuppress is +//! \b false, then the selected outputs are unaffected by the detected fault. +//! +//! On devices supporting extended PWM fault handling, the state the affected +//! output pins are driven to can be configured with PWMOutputFaultLevel(). If +//! not configured, or if the device does not support extended PWM fault +//! handling, affected outputs will be driven low on a fault condition. +//! +//! \return None. +// +//***************************************************************************** +void +PWMOutputFault(unsigned long ulBase, unsigned long ulPWMOutBits, + tBoolean bFaultSuppress) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(!(ulPWMOutBits & ~(PWM_OUT_0_BIT | PWM_OUT_1_BIT | PWM_OUT_2_BIT | + PWM_OUT_3_BIT | PWM_OUT_4_BIT | PWM_OUT_5_BIT | + PWM_OUT_6_BIT | PWM_OUT_7_BIT))); + + // + // Read the module's FAULT output control register, and set or clear the + // requested bits. + // + if(bFaultSuppress == true) + { + HWREG(ulBase + PWM_O_FAULT) |= ulPWMOutBits; + } + else + { + HWREG(ulBase + PWM_O_FAULT) &= ~(ulPWMOutBits); + } +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the specified PWM generator block. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator in question. Must be one of +//! \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! \param pfnIntHandler is a pointer to the function to be called when the PWM +//! generator interrupt occurs. +//! +//! This function will ensure that the interrupt handler specified by +//! \e pfnIntHandler is called when an interrupt is detected for the specified +//! PWM generator block. This function will also enable the corresponding +//! PWM generator interrupt in the interrupt controller; individual generator +//! interrupts and interrupt sources must be enabled with PWMIntEnable() and +//! PWMGenIntTrigEnable(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +PWMGenIntRegister(unsigned long ulBase, unsigned long ulGen, + void (*pfnIntHandler)(void)) +{ + unsigned long ulInt; + + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + + // + // Get the interrupt number associated with the specified generator. + // + if(ulGen == PWM_GEN_3) + { + ulInt = INT_PWM3; + } + else + { + ulInt = INT_PWM0 + (ulGen >> 6) - 1; + } + + // + // Register the interrupt handler. + // + IntRegister(ulInt, pfnIntHandler); + + // + // Enable the PWMx interrupt. + // + IntEnable(ulInt); +} + +//***************************************************************************** +// +//! Removes an interrupt handler for the specified PWM generator block. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator in question. Must be one of +//! \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! +//! This function will unregister the interrupt handler for the specified +//! PWM generator block. This function will also disable the corresponding +//! PWM generator interrupt in the interrupt controller; individual generator +//! interrupts and interrupt sources must be disabled with PWMIntDisable() and +//! PWMGenIntTrigDisable(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +PWMGenIntUnregister(unsigned long ulBase, unsigned long ulGen) +{ + unsigned long ulInt; + + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + + // + // Get the interrupt number associated with the specified generator. + // + if(ulGen == PWM_GEN_3) + { + ulInt = INT_PWM3; + } + else + { + ulInt = INT_PWM0 + (ulGen >> 6) - 1; + } + + // + // Disable the PWMx interrupt. + // + IntDisable(ulInt); + + // + // Unregister the interrupt handler. + // + IntUnregister(ulInt); +} + +//***************************************************************************** +// +//! Registers an interrupt handler for a fault condition detected in a PWM +//! module. +//! +//! \param ulBase is the base address of the PWM module. +//! \param pfnIntHandler is a pointer to the function to be called when the PWM +//! fault interrupt occurs. +//! +//! This function will ensure that the interrupt handler specified by +//! \e pfnIntHandler is called when a fault interrupt is detected for the +//! selected PWM module. This function will also enable the PWM fault +//! interrupt in the NVIC; the PWM fault interrupt must also be enabled at the +//! module level using PWMIntEnable(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +PWMFaultIntRegister(unsigned long ulBase, void (*pfnIntHandler)(void)) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + + // + // Register the interrupt handler, returning an error if one occurs. + // + IntRegister(INT_PWM_FAULT, pfnIntHandler); + + // + // Enable the PWM fault interrupt. + // + IntEnable(INT_PWM_FAULT); +} + +//***************************************************************************** +// +//! Removes the PWM fault condition interrupt handler. +//! +//! \param ulBase is the base address of the PWM module. +//! +//! This function will remove the interrupt handler for a PWM fault interrupt +//! from the selected PWM module. This function will also disable the PWM +//! fault interrupt in the NVIC; the PWM fault interrupt must also be disabled +//! at the module level using PWMIntDisable(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +PWMFaultIntUnregister(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + + // + // Disable the PWM fault interrupt. + // + IntDisable(INT_PWM_FAULT); + + // + // Unregister the interrupt handler, returning an error if one occurs. + // + IntUnregister(INT_PWM_FAULT); +} + +//***************************************************************************** +// +//! Enables interrupts and triggers for the specified PWM generator block. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator to have interrupts and triggers enabled. +//! Must be one of \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! \param ulIntTrig specifies the interrupts and triggers to be enabled. +//! +//! Unmasks the specified interrupt(s) and trigger(s) by setting the +//! specified bits of the interrupt/trigger enable register for the specified +//! PWM generator. The \e ulIntTrig parameter is the logical OR of +//! \b PWM_INT_CNT_ZERO, \b PWM_INT_CNT_LOAD, \b PWM_INT_CNT_AU, +//! \b PWM_INT_CNT_AD, \b PWM_INT_CNT_BU, \b PWM_INT_CNT_BD, +//! \b PWM_TR_CNT_ZERO, \b PWM_TR_CNT_LOAD, \b PWM_TR_CNT_AU, \b PWM_TR_CNT_AD, +//! \b PWM_TR_CNT_BU, or \b PWM_TR_CNT_BD. +//! +//! \return None. +// +//***************************************************************************** +void +PWMGenIntTrigEnable(unsigned long ulBase, unsigned long ulGen, + unsigned long ulIntTrig) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + ASSERT((ulIntTrig & ~(PWM_INT_CNT_ZERO | PWM_INT_CNT_LOAD | + PWM_INT_CNT_AU | PWM_INT_CNT_AD | PWM_INT_CNT_BU | + PWM_INT_CNT_BD | PWM_TR_CNT_ZERO | PWM_TR_CNT_LOAD | + PWM_TR_CNT_AU | PWM_TR_CNT_AD | PWM_TR_CNT_BU | + PWM_TR_CNT_BD)) == 0); + + // + // Enable the specified interrupts/triggers. + // + HWREG(PWM_GEN_BADDR(ulBase, ulGen) + PWM_O_X_INTEN) |= ulIntTrig; +} + +//***************************************************************************** +// +//! Disables interrupts for the specified PWM generator block. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator to have interrupts and triggers disabled. +//! Must be one of \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! \param ulIntTrig specifies the interrupts and triggers to be disabled. +//! +//! Masks the specified interrupt(s) and trigger(s) by clearing the +//! specified bits of the interrupt/trigger enable register for the specified +//! PWM generator. The \e ulIntTrig parameter is the logical OR of +//! \b PWM_INT_CNT_ZERO, \b PWM_INT_CNT_LOAD, \b PWM_INT_CNT_AU, +//! \b PWM_INT_CNT_AD, \b PWM_INT_CNT_BU, \b PWM_INT_CNT_BD, +//! \b PWM_TR_CNT_ZERO, \b PWM_TR_CNT_LOAD, \b PWM_TR_CNT_AU, \b PWM_TR_CNT_AD, +//! \b PWM_TR_CNT_BU, or \b PWM_TR_CNT_BD. +//! +//! \return None. +// +//***************************************************************************** +void +PWMGenIntTrigDisable(unsigned long ulBase, unsigned long ulGen, + unsigned long ulIntTrig) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + ASSERT((ulIntTrig & ~(PWM_INT_CNT_ZERO | PWM_INT_CNT_LOAD | + PWM_INT_CNT_AU | PWM_INT_CNT_AD | PWM_INT_CNT_BU | + PWM_INT_CNT_BD | PWM_TR_CNT_ZERO | PWM_TR_CNT_LOAD | + PWM_TR_CNT_AU | PWM_TR_CNT_AD | PWM_TR_CNT_BU | + PWM_TR_CNT_BD)) == 0); + + // + // Disable the specified interrupts/triggers. + // + HWREG(PWM_GEN_BADDR(ulBase, ulGen) + PWM_O_X_INTEN) &= ~(ulIntTrig); +} + +//***************************************************************************** +// +//! Gets interrupt status for the specified PWM generator block. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator to query. Must be one of \b PWM_GEN_0, +//! \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! \param bMasked specifies whether masked or raw interrupt status is +//! returned. +//! +//! If \e bMasked is set as \b true, then the masked interrupt status is +//! returned; otherwise, the raw interrupt status will be returned. +//! +//! \return Returns the contents of the interrupt status register, or the +//! contents of the raw interrupt status register, for the specified +//! PWM generator. +// +//***************************************************************************** +unsigned long +PWMGenIntStatus(unsigned long ulBase, unsigned long ulGen, tBoolean bMasked) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + + // + // Compute the generator's base address. + // + ulGen = PWM_GEN_BADDR(ulBase, ulGen); + + // + // Read and return the specified generator's raw or enabled interrupt + // status. + // + if(bMasked == true) + { + return(HWREG(ulGen + PWM_O_X_ISC)); + } + else + { + return(HWREG(ulGen + PWM_O_X_RIS)); + } +} + +//***************************************************************************** +// +//! Clears the specified interrupt(s) for the specified PWM generator block. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator to query. Must be one of \b PWM_GEN_0, +//! \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! \param ulInts specifies the interrupts to be cleared. +//! +//! Clears the specified interrupt(s) by writing a 1 to the specified bits +//! of the interrupt status register for the specified PWM generator. The +//! \e ulInts parameter is the logical OR of \b PWM_INT_CNT_ZERO, +//! \b PWM_INT_CNT_LOAD, \b PWM_INT_CNT_AU, \b PWM_INT_CNT_AD, +//! \b PWM_INT_CNT_BU, or \b PWM_INT_CNT_BD. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +PWMGenIntClear(unsigned long ulBase, unsigned long ulGen, unsigned long ulInts) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + ASSERT((ulInts & ~(PWM_INT_CNT_ZERO | PWM_INT_CNT_LOAD | PWM_INT_CNT_AU | + PWM_INT_CNT_AD | PWM_INT_CNT_BU | PWM_INT_CNT_BD)) == + 0); + + // + // Clear the requested interrupts by writing ones to the specified bit + // of the module's interrupt enable register. + // + HWREG(PWM_GEN_BADDR(ulBase, ulGen) + PWM_O_X_ISC) = ulInts; +} + +//***************************************************************************** +// +//! Enables generator and fault interrupts for a PWM module. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGenFault contains the interrupts to be enabled. Must be a logical +//! OR of any of \b PWM_INT_GEN_0, \b PWM_INT_GEN_1, \b PWM_INT_GEN_2, +//! \b PWM_INT_GEN_3, \b PWM_INT_FAULT0, \b PWM_INT_FAULT1, \b PWM_INT_FAULT2, +//! or \b PWM_INT_FAULT3. +//! +//! Unmasks the specified interrupt(s) by setting the specified bits of +//! the interrupt enable register for the selected PWM module. +//! +//! \return None. +// +//***************************************************************************** +void +PWMIntEnable(unsigned long ulBase, unsigned long ulGenFault) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT((ulGenFault & ~(PWM_INT_GEN_0 | PWM_INT_GEN_1 | PWM_INT_GEN_2 | + PWM_INT_GEN_3 | PWM_INT_FAULT0 | PWM_INT_FAULT1 | + PWM_INT_FAULT2 | PWM_INT_FAULT3)) == 0); + + // + // Read the module's interrupt enable register, and enable interrupts + // for the specified PWM generators. + // + HWREG(ulBase + PWM_O_INTEN) |= ulGenFault; +} + +//***************************************************************************** +// +//! Disables generator and fault interrupts for a PWM module. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGenFault contains the interrupts to be disabled. Must be a +//! logical OR of any of \b PWM_INT_GEN_0, \b PWM_INT_GEN_1, \b PWM_INT_GEN_2, +//! \b PWM_INT_GEN_3, \b PWM_INT_FAULT0, \b PWM_INT_FAULT1, \b PWM_INT_FAULT2, +//! or \b PWM_INT_FAULT3. +//! +//! Masks the specified interrupt(s) by clearing the specified bits of +//! the interrupt enable register for the selected PWM module. +//! +//! \return None. +// +//***************************************************************************** +void +PWMIntDisable(unsigned long ulBase, unsigned long ulGenFault) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT((ulGenFault & ~(PWM_INT_GEN_0 | PWM_INT_GEN_1 | PWM_INT_GEN_2 | + PWM_INT_GEN_3 | PWM_INT_FAULT0 | PWM_INT_FAULT1 | + PWM_INT_FAULT2 | PWM_INT_FAULT3)) == 0); + + // + // Read the module's interrupt enable register, and disable interrupts + // for the specified PWM generators. + // + HWREG(ulBase + PWM_O_INTEN) &= ~(ulGenFault); +} + +//***************************************************************************** +// +//! Clears the fault interrupt for a PWM module. +//! +//! \param ulBase is the base address of the PWM module. +//! +//! Clears the fault interrupt by writing to the appropriate bit of the +//! interrupt status register for the selected PWM module. +//! +//! This function clears only the FAULT0 interrupt and is retained for +//! backwards compatibility. It is recommended that PWMFaultIntClearExt() be +//! used instead since it supports all fault interrupts supported on devices +//! with and without extended PWM fault handling support. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +PWMFaultIntClear(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + + // + // Write the only writeable bit in the module's interrupt register. + // + HWREG(ulBase + PWM_O_ISC) = PWM_ISC_INTFAULT0; +} + +//***************************************************************************** +// +//! Gets the interrupt status for a PWM module. +//! +//! \param ulBase is the base address of the PWM module. +//! \param bMasked specifies whether masked or raw interrupt status is +//! returned. +//! +//! If \e bMasked is set as \b true, then the masked interrupt status is +//! returned; otherwise, the raw interrupt status will be returned. +//! +//! \return The current interrupt status, enumerated as a bit field of +//! \b PWM_INT_GEN_0, \b PWM_INT_GEN_1, \b PWM_INT_GEN_2, \b PWM_INT_GEN_3, +//! \b PWM_INT_FAULT0, \b PWM_INT_FAULT1, \b PWM_INT_FAULT2, and +//! \b PWM_INT_FAULT3. +//! +//***************************************************************************** +unsigned long +PWMIntStatus(unsigned long ulBase, tBoolean bMasked) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + + // + // Read and return either the module's raw or enabled interrupt status. + // + if(bMasked == true) + { + return(HWREG(ulBase + PWM_O_ISC)); + } + else + { + return(HWREG(ulBase + PWM_O_RIS)); + } +} + +//***************************************************************************** +// +//! Clears the fault interrupt for a PWM module. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulFaultInts specifies the fault interrupts to clear. +//! +//! Clears one or more fault interrupts by writing to the appropriate bit of +//! the PWM interrupt status register. The parameter \e ulFaultInts must be +//! the logical OR of any of \b PWM_INT_FAULT0, \b PWM_INT_FAULT1, +//! \b PWM_INT_FAULT2, or \b PWM_INT_FAULT3. +//! +//! When running on a device supporting extended PWM fault handling, the fault +//! interrupts are derived by performing a logical OR of each of the configured +//! fault trigger signals for a given generator. Therefore, these interrupts +//! are not directly related to the four possible FAULTn inputs to the device +//! but indicate that a fault has been signaled to one of the four possible PWM +//! generators. On a device without extended PWM fault handling, the interrupt +//! is directly related to the state of the single FAULT pin. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +PWMFaultIntClearExt(unsigned long ulBase, unsigned long ulFaultInts) +{ + // + // Check the arguments. + // + ASSERT(ulBase == PWM_BASE); + ASSERT((ulFaultInts & ~(PWM_INT_FAULT0 | PWM_INT_FAULT1 | + PWM_INT_FAULT2 | PWM_INT_FAULT3)) == 0); + + // + // Clear the supplied fault bits. + // + HWREG(ulBase + PWM_O_ISC) = ulFaultInts; +} + +//***************************************************************************** +// +//! Configures the minimum fault period and fault pin senses for a given +//! PWM generator. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator whose fault configuration is being set. +//! Must be one of \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! \param ulMinFaultPeriod is the minimum fault active period expressed in +//! PWM clock cycles. +//! \param ulFaultSenses indicates which sense of each FAULT input should be +//! considered the ``asserted'' state. Valid values are logical OR +//! combinations of \b PWM_FAULTn_SENSE_HIGH and \b PWM_FAULTn_SENSE_LOW. +//! +//! This function sets the minimum fault period for a given generator along +//! with the sense of each of the 4 possible fault inputs. The minimum fault +//! period is expressed in PWM clock cycles and takes effect only if +//! PWMGenConfigure() is called with flag \b PWM_GEN_MODE_FAULT_PER set in the +//! \e ulConfig parameter. When a fault input is asserted, the minimum fault +//! period timer ensures that it remains asserted for at least the number of +//! clock cycles specified. +//! +//! \note This function is only available on devices supporting extended PWM +//! fault handling. +//! +//! \return None. +// +//***************************************************************************** +void +PWMGenFaultConfigure(unsigned long ulBase, unsigned long ulGen, + unsigned long ulMinFaultPeriod, + unsigned long ulFaultSenses) +{ + // + // Check the arguments. + // + ASSERT(HWREG(SYSCTL_DC5) & SYSCTL_DC5_PWMEFLT); + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + ASSERT(ulMinFaultPeriod < PWM_X_MINFLTPER_M); + ASSERT((ulFaultSenses & ~(PWM_FAULT0_SENSE_HIGH | PWM_FAULT0_SENSE_LOW | + PWM_FAULT1_SENSE_HIGH | PWM_FAULT1_SENSE_LOW | + PWM_FAULT2_SENSE_HIGH | PWM_FAULT2_SENSE_LOW | + PWM_FAULT3_SENSE_HIGH | PWM_FAULT3_SENSE_LOW)) == + 0); + + // + // Write the minimum fault period. + // + HWREG(PWM_GEN_BADDR(ulBase, ulGen) + PWM_O_X_MINFLTPER) = ulMinFaultPeriod; + + // + // Write the fault senses. + // + HWREG(PWM_GEN_EXT_BADDR(ulBase, ulGen) + PWM_O_X_FLTSEN) = ulFaultSenses; +} + +//***************************************************************************** +// +//! Configures the set of fault triggers for a given PWM generator. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator whose fault triggers are being set. Must +//! be one of \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! \param ulGroup indicates the subset of possible faults that are to be +//! configured. This must be \b PWM_FAULT_GROUP_0 or \b PWM_FAULT_GROUP_1. +//! \param ulFaultTriggers defines the set of inputs that are to contribute +//! towards generation of the fault signal to the given PWM generator. For +//! \b PWM_FAULT_GROUP_0, this will be the logical OR of \b PWM_FAULT_FAULT0, +//! \b PWM_FAULT_FAULT1, \b PWM_FAULT_FAULT2, or \b PWM_FAULT_FAULT3. For +//! \b PWM_FAULT_GROUP_1, this will be the logical OR of \b PWM_FAULT_DCMP0, +//! \b PWM_FAULT_DCMP1, \b PWM_FAULT_DCMP2, \b PWM_FAULT_DCMP3, \b +//! PWM_FAULT_DCMP4, \b PWM_FAULT_DCMP5, \b PWM_FAULT_DCMP6, or \b +//! PWM_FAULT_DCMP7. +//! +//! This function allows selection of the set of fault inputs that will be +//! combined to generate a fault condition to a given PWM generator. By +//! default, all generators use only FAULT0 (for backwards compatibility) but +//! if PWMGenConfigure() is called with flag \b PWM_GEN_MODE_FAULT_SRC in the +//! \e ulConfig parameter, extended fault handling is enabled and this function +//! must be called to configure the fault triggers. +//! +//! The fault signal to the PWM generator is generated by ORing together each +//! of the signals whose inputs are specified in the \e ulFaultTriggers +//! parameter after having adjusted the sense of each FAULTn input based on the +//! configuration previously set using a call to PWMGenFaultConfigure(). +//! +//! \note This function is only available on devices supporting extended PWM +//! fault handling. +//! +//! \return None. +// +//***************************************************************************** +void +PWMGenFaultTriggerSet(unsigned long ulBase, unsigned long ulGen, + unsigned long ulGroup, unsigned long ulFaultTriggers) +{ + // + // Check for valid parameters. + // + ASSERT(HWREG(SYSCTL_DC5) & SYSCTL_DC5_PWMEFLT); + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + ASSERT((ulGroup == PWM_FAULT_GROUP_0) || (ulGroup == PWM_FAULT_GROUP_1)); + ASSERT((ulGroup == PWM_FAULT_GROUP_0) && + ((ulFaultTriggers & ~(PWM_FAULT_FAULT0 | PWM_FAULT_FAULT1 | + PWM_FAULT_FAULT2 | PWM_FAULT_FAULT3)) == 0)); + ASSERT((ulGroup == PWM_FAULT_GROUP_1) && + ((ulFaultTriggers & ~(PWM_FAULT_DCMP0 | PWM_FAULT_DCMP1 | + PWM_FAULT_DCMP2 | PWM_FAULT_DCMP3 | + PWM_FAULT_DCMP4 | PWM_FAULT_DCMP5 | + PWM_FAULT_DCMP6 | PWM_FAULT_DCMP7)) == 0)); + + // + // Write the fault triggers to the appropriate register. + // + if(ulGroup == PWM_FAULT_GROUP_0) + { + HWREG(PWM_GEN_BADDR(ulBase, ulGen) + PWM_O_X_FLTSRC0) = + ulFaultTriggers; + } + else + { + HWREG(PWM_GEN_BADDR(ulBase, ulGen) + PWM_O_X_FLTSRC1) = + ulFaultTriggers; + } +} + +//***************************************************************************** +// +//! Returns the set of fault triggers currently configured for a given PWM +//! generator. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator whose fault triggers are being queried. +//! Must be one of \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or \b PWM_GEN_3. +//! \param ulGroup indicates the subset of faults that are being queried. This +//! must be \b PWM_FAULT_GROUP_0 or \b PWM_FAULT_GROUP_1. +//! +//! This function allows an application to query the current set of inputs that +//! contribute towards the generation of a fault condition to a given PWM +//! generator. +//! +//! \note This function is only available on devices supporting extended PWM +//! fault handling. +//! +//! \return Returns the current fault triggers configured for the fault group +//! provided. For \b PWM_FAULT_GROUP_0, the returned value will be a logical +//! OR of \b PWM_FAULT_FAULT0, \b PWM_FAULT_FAULT1, \b PWM_FAULT_FAULT2, or +//! \b PWM_FAULT_FAULT3. For \b PWM_FAULT_GROUP_1, the return value will be +//! the logical OR of \b PWM_FAULT_DCMP0, \b PWM_FAULT_DCMP1, \b +//! PWM_FAULT_DCMP2, \b PWM_FAULT_DCMP3, \b PWM_FAULT_DCMP4, \b PWM_FAULT_DCMP5, +//! \b PWM_FAULT_DCMP6, or \b PWM_FAULT_DCMP7. +// +//***************************************************************************** +unsigned long +PWMGenFaultTriggerGet(unsigned long ulBase, unsigned long ulGen, + unsigned long ulGroup) +{ + // + // Check for valid parameters. + // + ASSERT(HWREG(SYSCTL_DC5) & SYSCTL_DC5_PWMEFLT); + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + ASSERT((ulGroup == PWM_FAULT_GROUP_0) || (ulGroup == PWM_FAULT_GROUP_1)); + + // + // Return the current fault triggers. + // + if(ulGroup == PWM_FAULT_GROUP_0) + { + return(HWREG(PWM_GEN_BADDR(ulBase, ulGen) + PWM_O_X_FLTSRC0)); + } + else + { + return(HWREG(PWM_GEN_BADDR(ulBase, ulGen) + PWM_O_X_FLTSRC1)); + } +} + +//***************************************************************************** +// +//! Returns the current state of the fault triggers for a given PWM generator. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator whose fault trigger states are being +//! queried. Must be one of \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or +//! \b PWM_GEN_3. +//! \param ulGroup indicates the subset of faults that are being queried. This +//! must be \b PWM_FAULT_GROUP_0 or \b PWM_FAULT_GROUP_1. +//! +//! This function allows an application to query the current state of each of +//! the fault trigger inputs to a given PWM generator. The current state of +//! each fault trigger input is returned unless PWMGenConfigure() has +//! previously been called with flag \b PWM_GEN_MODE_LATCH_FAULT in the +//! \e ulConfig parameter in which case the returned status is the latched +//! fault trigger status. +//! +//! If latched faults are configured, the application must call +//! PWMGenFaultClear() to clear each trigger. +//! +//! \note This function is only available on devices supporting extended PWM +//! fault handling. +//! +//! \return Returns the current state of the fault triggers for the given PWM +//! generator. A set bit indicates that the associated trigger is active. For +//! \b PWM_FAULT_GROUP_0, the returned value will be a logical OR of +//! \b PWM_FAULT_FAULT0, \b PWM_FAULT_FAULT1, \b PWM_FAULT_FAULT2, or +//! \b PWM_FAULT_FAULT3. For \b PWM_FAULT_GROUP_1, the return value will be +//! the logical OR of \b PWM_FAULT_DCMP0, \b PWM_FAULT_DCMP1, \b +//! PWM_FAULT_DCMP2, \b PWM_FAULT_DCMP3, \b PWM_FAULT_DCMP4, \b PWM_FAULT_DCMP5, +//! \b PWM_FAULT_DCMP6, or \b PWM_FAULT_DCMP7. +// +//***************************************************************************** +unsigned long +PWMGenFaultStatus(unsigned long ulBase, unsigned long ulGen, + unsigned long ulGroup) +{ + // + // Check for valid parameters. + // + ASSERT(HWREG(SYSCTL_DC5) & SYSCTL_DC5_PWMEFLT); + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + ASSERT((ulGroup == PWM_FAULT_GROUP_0) || (ulGroup == PWM_FAULT_GROUP_1)); + + // + // Return the current fault status. + // + if(ulGroup == PWM_FAULT_GROUP_0) + { + return(HWREG(PWM_GEN_EXT_BADDR(ulBase, ulGen) + PWM_O_X_FLTSTAT0)); + } + else + { + return(HWREG(PWM_GEN_EXT_BADDR(ulBase, ulGen) + PWM_O_X_FLTSTAT1)); + } +} + +//***************************************************************************** +// +//! Clears one or more latched fault triggers for a given PWM generator. +//! +//! \param ulBase is the base address of the PWM module. +//! \param ulGen is the PWM generator whose fault trigger states are being +//! queried. Must be one of \b PWM_GEN_0, \b PWM_GEN_1, \b PWM_GEN_2, or +//! \b PWM_GEN_3. +//! \param ulGroup indicates the subset of faults that are being queried. This +//! must be \b PWM_FAULT_GROUP_0 or \b PWM_FAULT_GROUP_1. +//! \param ulFaultTriggers is the set of fault triggers which are to be +//! cleared. +//! +//! This function allows an application to clear the fault triggers for a given +//! PWM generator. This is only required if PWMGenConfigure() has previously +//! been called with flag \b PWM_GEN_MODE_LATCH_FAULT in parameter \e ulConfig. +//! +//! \note This function is only available on devices supporting extended PWM +//! fault handling. +//! +//! \return None. +// +//***************************************************************************** +void +PWMGenFaultClear(unsigned long ulBase, unsigned long ulGen, + unsigned long ulGroup, unsigned long ulFaultTriggers) +{ + // + // Check for valid parameters. + // + ASSERT(HWREG(SYSCTL_DC5) & SYSCTL_DC5_PWMEFLT); + ASSERT(ulBase == PWM_BASE); + ASSERT(PWMGenValid(ulGen)); + ASSERT((ulGroup == PWM_FAULT_GROUP_0) || (ulGroup == PWM_FAULT_GROUP_1)); + ASSERT((ulGroup == PWM_FAULT_GROUP_0) && + ((ulFaultTriggers & ~(PWM_FAULT_FAULT0 | PWM_FAULT_FAULT1 | + PWM_FAULT_FAULT2 | PWM_FAULT_FAULT3)) == 0)); + ASSERT((ulGroup == PWM_FAULT_GROUP_1) && + ((ulFaultTriggers & ~(PWM_FAULT_DCMP0 | PWM_FAULT_DCMP1 | + PWM_FAULT_DCMP2 | PWM_FAULT_DCMP3 | + PWM_FAULT_DCMP4 | PWM_FAULT_DCMP5 | + PWM_FAULT_DCMP6 | PWM_FAULT_DCMP7)) == 0)); + + // + // Clear the given faults. + // + if(ulGroup == PWM_FAULT_GROUP_0) + { + HWREG(PWM_GEN_EXT_BADDR(ulBase, ulGen) + PWM_O_X_FLTSTAT0) = + ulFaultTriggers; + } + else + { + HWREG(PWM_GEN_EXT_BADDR(ulBase, ulGen) + PWM_O_X_FLTSTAT1) = + ulFaultTriggers; + } +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/pwm.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/pwm.h new file mode 100644 index 00000000..8eca5912 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/pwm.h @@ -0,0 +1,283 @@ +//***************************************************************************** +// +// pwm.h - API function protoypes for Pulse Width Modulation (PWM) ports +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __PWM_H__ +#define __PWM_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// The following defines are passed to PWMGenConfigure() as the ulConfig +// parameter and specify the configuration of the PWM generator. +// +//***************************************************************************** +#define PWM_GEN_MODE_DOWN 0x00000000 // Down count mode +#define PWM_GEN_MODE_UP_DOWN 0x00000002 // Up/Down count mode +#define PWM_GEN_MODE_SYNC 0x00000038 // Synchronous updates +#define PWM_GEN_MODE_NO_SYNC 0x00000000 // Immediate updates +#define PWM_GEN_MODE_DBG_RUN 0x00000004 // Continue running in debug mode +#define PWM_GEN_MODE_DBG_STOP 0x00000000 // Stop running in debug mode +#define PWM_GEN_MODE_FAULT_LATCHED \ + 0x00040000 // Fault is latched +#define PWM_GEN_MODE_FAULT_UNLATCHED \ + 0x00000000 // Fault is not latched +#define PWM_GEN_MODE_FAULT_MINPER \ + 0x00020000 // Enable min fault period +#define PWM_GEN_MODE_FAULT_NO_MINPER \ + 0x00000000 // Disable min fault period +#define PWM_GEN_MODE_FAULT_EXT 0x00010000 // Enable extended fault support +#define PWM_GEN_MODE_FAULT_LEGACY \ + 0x00000000 // Disable extended fault support +#define PWM_GEN_MODE_DB_NO_SYNC 0x00000000 // Deadband updates occur + // immediately +#define PWM_GEN_MODE_DB_SYNC_LOCAL \ + 0x0000A800 // Deadband updates locally + // synchronized +#define PWM_GEN_MODE_DB_SYNC_GLOBAL \ + 0x0000FC00 // Deadband updates globally + // synchronized +#define PWM_GEN_MODE_GEN_NO_SYNC \ + 0x00000000 // Generator mode updates occur + // immediately +#define PWM_GEN_MODE_GEN_SYNC_LOCAL \ + 0x00000280 // Generator mode updates locally + // synchronized +#define PWM_GEN_MODE_GEN_SYNC_GLOBAL \ + 0x000003C0 // Generator mode updates globally + // synchronized + +//***************************************************************************** +// +// Defines for enabling, disabling, and clearing PWM generator interrupts and +// triggers. +// +//***************************************************************************** +#define PWM_INT_CNT_ZERO 0x00000001 // Int if COUNT = 0 +#define PWM_INT_CNT_LOAD 0x00000002 // Int if COUNT = LOAD +#define PWM_INT_CNT_AU 0x00000004 // Int if COUNT = CMPA U +#define PWM_INT_CNT_AD 0x00000008 // Int if COUNT = CMPA D +#define PWM_INT_CNT_BU 0x00000010 // Int if COUNT = CMPA U +#define PWM_INT_CNT_BD 0x00000020 // Int if COUNT = CMPA D +#define PWM_TR_CNT_ZERO 0x00000100 // Trig if COUNT = 0 +#define PWM_TR_CNT_LOAD 0x00000200 // Trig if COUNT = LOAD +#define PWM_TR_CNT_AU 0x00000400 // Trig if COUNT = CMPA U +#define PWM_TR_CNT_AD 0x00000800 // Trig if COUNT = CMPA D +#define PWM_TR_CNT_BU 0x00001000 // Trig if COUNT = CMPA U +#define PWM_TR_CNT_BD 0x00002000 // Trig if COUNT = CMPA D + +//***************************************************************************** +// +// Defines for enabling, disabling, and clearing PWM interrupts. +// +//***************************************************************************** +#define PWM_INT_GEN_0 0x00000001 // Generator 0 interrupt +#define PWM_INT_GEN_1 0x00000002 // Generator 1 interrupt +#define PWM_INT_GEN_2 0x00000004 // Generator 2 interrupt +#define PWM_INT_GEN_3 0x00000008 // Generator 3 interrupt +#ifndef DEPRECATED +#define PWM_INT_FAULT 0x00010000 // Fault interrupt +#endif +#define PWM_INT_FAULT0 0x00010000 // Fault0 interrupt +#define PWM_INT_FAULT1 0x00020000 // Fault1 interrupt +#define PWM_INT_FAULT2 0x00040000 // Fault2 interrupt +#define PWM_INT_FAULT3 0x00080000 // Fault3 interrupt +#define PWM_INT_FAULT_M 0x000F0000 // Fault interrupt source mask + +//***************************************************************************** +// +// Defines to identify the generators within a module. +// +//***************************************************************************** +#define PWM_GEN_0 0x00000040 // Offset address of Gen0 +#define PWM_GEN_1 0x00000080 // Offset address of Gen1 +#define PWM_GEN_2 0x000000C0 // Offset address of Gen2 +#define PWM_GEN_3 0x00000100 // Offset address of Gen3 + +#define PWM_GEN_0_BIT 0x00000001 // Bit-wise ID for Gen0 +#define PWM_GEN_1_BIT 0x00000002 // Bit-wise ID for Gen1 +#define PWM_GEN_2_BIT 0x00000004 // Bit-wise ID for Gen2 +#define PWM_GEN_3_BIT 0x00000008 // Bit-wise ID for Gen3 + +#define PWM_GEN_EXT_0 0x00000800 // Offset of Gen0 ext address range +#define PWM_GEN_EXT_1 0x00000880 // Offset of Gen1 ext address range +#define PWM_GEN_EXT_2 0x00000900 // Offset of Gen2 ext address range +#define PWM_GEN_EXT_3 0x00000980 // Offset of Gen3 ext address range + +//***************************************************************************** +// +// Defines to identify the outputs within a module. +// +//***************************************************************************** +#define PWM_OUT_0 0x00000040 // Encoded offset address of PWM0 +#define PWM_OUT_1 0x00000041 // Encoded offset address of PWM1 +#define PWM_OUT_2 0x00000082 // Encoded offset address of PWM2 +#define PWM_OUT_3 0x00000083 // Encoded offset address of PWM3 +#define PWM_OUT_4 0x000000C4 // Encoded offset address of PWM4 +#define PWM_OUT_5 0x000000C5 // Encoded offset address of PWM5 +#define PWM_OUT_6 0x00000106 // Encoded offset address of PWM6 +#define PWM_OUT_7 0x00000107 // Encoded offset address of PWM7 + +#define PWM_OUT_0_BIT 0x00000001 // Bit-wise ID for PWM0 +#define PWM_OUT_1_BIT 0x00000002 // Bit-wise ID for PWM1 +#define PWM_OUT_2_BIT 0x00000004 // Bit-wise ID for PWM2 +#define PWM_OUT_3_BIT 0x00000008 // Bit-wise ID for PWM3 +#define PWM_OUT_4_BIT 0x00000010 // Bit-wise ID for PWM4 +#define PWM_OUT_5_BIT 0x00000020 // Bit-wise ID for PWM5 +#define PWM_OUT_6_BIT 0x00000040 // Bit-wise ID for PWM6 +#define PWM_OUT_7_BIT 0x00000080 // Bit-wise ID for PWM7 + +//***************************************************************************** +// +// Defines to identify each of the possible fault trigger conditions in +// PWM_FAULT_GROUP_0. +// +//***************************************************************************** +#define PWM_FAULT_GROUP_0 0 + +#define PWM_FAULT_FAULT0 0x00000001 +#define PWM_FAULT_FAULT1 0x00000002 +#define PWM_FAULT_FAULT2 0x00000004 +#define PWM_FAULT_FAULT3 0x00000008 +#define PWM_FAULT_ACMP0 0x00010000 +#define PWM_FAULT_ACMP1 0x00020000 +#define PWM_FAULT_ACMP2 0x00040000 + +//***************************************************************************** +// +// Defines to identify each of the possible fault trigger conditions in +// PWM_FAULT_GROUP_1. +// +//***************************************************************************** +#define PWM_FAULT_GROUP_1 1 + +#define PWM_FAULT_DCMP0 0x00000001 +#define PWM_FAULT_DCMP1 0x00000002 +#define PWM_FAULT_DCMP2 0x00000004 +#define PWM_FAULT_DCMP3 0x00000008 +#define PWM_FAULT_DCMP4 0x00000010 +#define PWM_FAULT_DCMP5 0x00000020 +#define PWM_FAULT_DCMP6 0x00000040 +#define PWM_FAULT_DCMP7 0x00000080 + +//***************************************************************************** +// +// Defines to identify the sense of each of the external FAULTn signals +// +//***************************************************************************** +#define PWM_FAULT0_SENSE_HIGH 0x00000000 +#define PWM_FAULT0_SENSE_LOW 0x00000001 +#define PWM_FAULT1_SENSE_HIGH 0x00000000 +#define PWM_FAULT1_SENSE_LOW 0x00000002 +#define PWM_FAULT2_SENSE_HIGH 0x00000000 +#define PWM_FAULT2_SENSE_LOW 0x00000004 +#define PWM_FAULT3_SENSE_HIGH 0x00000000 +#define PWM_FAULT3_SENSE_LOW 0x00000008 + +//***************************************************************************** +// +// API Function prototypes +// +//***************************************************************************** +extern void PWMGenConfigure(unsigned long ulBase, unsigned long ulGen, + unsigned long ulConfig); +extern void PWMGenPeriodSet(unsigned long ulBase, unsigned long ulGen, + unsigned long ulPeriod); +extern unsigned long PWMGenPeriodGet(unsigned long ulBase, + unsigned long ulGen); +extern void PWMGenEnable(unsigned long ulBase, unsigned long ulGen); +extern void PWMGenDisable(unsigned long ulBase, unsigned long ulGen); +extern void PWMPulseWidthSet(unsigned long ulBase, unsigned long ulPWMOut, + unsigned long ulWidth); +extern unsigned long PWMPulseWidthGet(unsigned long ulBase, + unsigned long ulPWMOut); +extern void PWMDeadBandEnable(unsigned long ulBase, unsigned long ulGen, + unsigned short usRise, unsigned short usFall); +extern void PWMDeadBandDisable(unsigned long ulBase, unsigned long ulGen); +extern void PWMSyncUpdate(unsigned long ulBase, unsigned long ulGenBits); +extern void PWMSyncTimeBase(unsigned long ulBase, unsigned long ulGenBits); +extern void PWMOutputState(unsigned long ulBase, unsigned long ulPWMOutBits, + tBoolean bEnable); +extern void PWMOutputInvert(unsigned long ulBase, unsigned long ulPWMOutBits, + tBoolean bInvert); +extern void PWMOutputFaultLevel(unsigned long ulBase, + unsigned long ulPWMOutBits, + tBoolean bDriveHigh); +extern void PWMOutputFault(unsigned long ulBase, unsigned long ulPWMOutBits, + tBoolean bFaultSuppress); +extern void PWMGenIntRegister(unsigned long ulBase, unsigned long ulGen, + void (*pfnIntHandler)(void)); +extern void PWMGenIntUnregister(unsigned long ulBase, unsigned long ulGen); +extern void PWMFaultIntRegister(unsigned long ulBase, + void (*pfnIntHandler)(void)); +extern void PWMFaultIntUnregister(unsigned long ulBase); +extern void PWMGenIntTrigEnable(unsigned long ulBase, unsigned long ulGen, + unsigned long ulIntTrig); +extern void PWMGenIntTrigDisable(unsigned long ulBase, unsigned long ulGen, + unsigned long ulIntTrig); +extern unsigned long PWMGenIntStatus(unsigned long ulBase, unsigned long ulGen, + tBoolean bMasked); +extern void PWMGenIntClear(unsigned long ulBase, unsigned long ulGen, + unsigned long ulInts); +extern void PWMIntEnable(unsigned long ulBase, unsigned long ulGenFault); +extern void PWMIntDisable(unsigned long ulBase, unsigned long ulGenFault); +extern void PWMFaultIntClear(unsigned long ulBase); +extern unsigned long PWMIntStatus(unsigned long ulBase, tBoolean bMasked); +extern void PWMFaultIntClearExt(unsigned long ulBase, + unsigned long ulFaultInts); +extern void PWMGenFaultConfigure(unsigned long ulBase, unsigned long ulGen, + unsigned long ulMinFaultPeriod, + unsigned long ulFaultSenses); +extern void PWMGenFaultTriggerSet(unsigned long ulBase, unsigned long ulGen, + unsigned long ulGroup, + unsigned long ulFaultTriggers); +extern unsigned long PWMGenFaultTriggerGet(unsigned long ulBase, + unsigned long ulGen, + unsigned long ulGroup); +extern unsigned long PWMGenFaultStatus(unsigned long ulBase, + unsigned long ulGen, + unsigned long ulGroup); +extern void PWMGenFaultClear(unsigned long ulBase, unsigned long ulGen, + unsigned long ulGroup, + unsigned long ulFaultTriggers); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __PWM_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/qei.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/qei.c new file mode 100644 index 00000000..4615846e --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/qei.c @@ -0,0 +1,616 @@ +//***************************************************************************** +// +// qei.c - Driver for the Quadrature Encoder with Index. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup qei_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_qei.h" +#include "inc/hw_types.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" +#include "driverlib/qei.h" + +//***************************************************************************** +// +//! Enables the quadrature encoder. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! +//! This will enable operation of the quadrature encoder module. It must be +//! configured before it is enabled. +//! +//! \sa QEIConfigure() +//! +//! \return None. +// +//***************************************************************************** +void +QEIEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Enable the QEI module. + // + HWREG(ulBase + QEI_O_CTL) |= QEI_CTL_ENABLE; +} + +//***************************************************************************** +// +//! Disables the quadrature encoder. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! +//! This will disable operation of the quadrature encoder module. +//! +//! \return None. +// +//***************************************************************************** +void +QEIDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Disable the QEI module. + // + HWREG(ulBase + QEI_O_CTL) &= ~(QEI_CTL_ENABLE); +} + +//***************************************************************************** +// +//! Configures the quadrature encoder. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! \param ulConfig is the configuration for the quadrature encoder. See below +//! for a description of this parameter. +//! \param ulMaxPosition specifies the maximum position value. +//! +//! This will configure the operation of the quadrature encoder. The +//! \e ulConfig parameter provides the configuration of the encoder and is the +//! logical OR of several values: +//! +//! - \b QEI_CONFIG_CAPTURE_A or \b QEI_CONFIG_CAPTURE_A_B to specify if edges +//! on channel A or on both channels A and B should be counted by the +//! position integrator and velocity accumulator. +//! - \b QEI_CONFIG_NO_RESET or \b QEI_CONFIG_RESET_IDX to specify if the +//! position integrator should be reset when the index pulse is detected. +//! - \b QEI_CONFIG_QUADRATURE or \b QEI_CONFIG_CLOCK_DIR to specify if +//! quadrature signals are being provided on ChA and ChB, or if a direction +//! signal and a clock are being provided instead. +//! - \b QEI_CONFIG_NO_SWAP or \b QEI_CONFIG_SWAP to specify if the signals +//! provided on ChA and ChB should be swapped before being processed. +//! +//! \e ulMaxPosition is the maximum value of the position integrator, and is +//! the value used to reset the position capture when in index reset mode and +//! moving in the reverse (negative) direction. +//! +//! \return None. +// +//***************************************************************************** +void +QEIConfigure(unsigned long ulBase, unsigned long ulConfig, + unsigned long ulMaxPosition) +{ + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Write the new configuration to the hardware. + // + HWREG(ulBase + QEI_O_CTL) = ((HWREG(ulBase + QEI_O_CTL) & + ~(QEI_CTL_CAPMODE | QEI_CTL_RESMODE | + QEI_CTL_SIGMODE | QEI_CTL_SWAP)) | + ulConfig); + + // + // Set the maximum position. + // + HWREG(ulBase + QEI_O_MAXPOS) = ulMaxPosition; +} + +//***************************************************************************** +// +//! Gets the current encoder position. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! +//! This returns the current position of the encoder. Depending upon the +//! configuration of the encoder, and the incident of an index pulse, this +//! value may or may not contain the expected data (that is, if in reset on +//! index mode, if an index pulse has not been encountered, the position +//! counter will not be aligned with the index pulse yet). +//! +//! \return The current position of the encoder. +// +//***************************************************************************** +unsigned long +QEIPositionGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Return the current position counter. + // + return(HWREG(ulBase + QEI_O_POS)); +} + +//***************************************************************************** +// +//! Sets the current encoder position. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! \param ulPosition is the new position for the encoder. +//! +//! This sets the current position of the encoder; the encoder position will +//! then be measured relative to this value. +//! +//! \return None. +// +//***************************************************************************** +void +QEIPositionSet(unsigned long ulBase, unsigned long ulPosition) +{ + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Set the position counter. + // + HWREG(ulBase + QEI_O_POS) = ulPosition; +} + +//***************************************************************************** +// +//! Gets the current direction of rotation. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! +//! This returns the current direction of rotation. In this case, current +//! means the most recently detected direction of the encoder; it may not be +//! presently moving but this is the direction it last moved before it stopped. +//! +//! \return Returns 1 if moving in the forward direction or -1 if moving in the +//! reverse direction. +// +//***************************************************************************** +long +QEIDirectionGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Return the direction of rotation. + // + return((HWREG(ulBase + QEI_O_STAT) & QEI_STAT_DIRECTION) ? -1 : 1); +} + +//***************************************************************************** +// +//! Gets the encoder error indicator. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! +//! This returns the error indicator for the quadrature encoder. It is an +//! error for both of the signals of the quadrature input to change at the same +//! time. +//! +//! \return Returns \b true if an error has occurred and \b false otherwise. +// +//***************************************************************************** +tBoolean +QEIErrorGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Return the error indicator. + // + return((HWREG(ulBase + QEI_O_STAT) & QEI_STAT_ERROR) ? true : false); +} + +//***************************************************************************** +// +//! Enables the velocity capture. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! +//! This will enable operation of the velocity capture in the quadrature +//! encoder module. It must be configured before it is enabled. Velocity +//! capture will not occur if the quadrature encoder is not enabled. +//! +//! \sa QEIVelocityConfigure() and QEIEnable() +//! +//! \return None. +// +//***************************************************************************** +void +QEIVelocityEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Enable the velocity capture. + // + HWREG(ulBase + QEI_O_CTL) |= QEI_CTL_VELEN; +} + +//***************************************************************************** +// +//! Disables the velocity capture. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! +//! This will disable operation of the velocity capture in the quadrature +//! encoder module. +//! +//! \return None. +// +//***************************************************************************** +void +QEIVelocityDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Disable the velocity capture. + // + HWREG(ulBase + QEI_O_CTL) &= ~(QEI_CTL_VELEN); +} + +//***************************************************************************** +// +//! Configures the velocity capture. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! \param ulPreDiv specifies the predivider applied to the input quadrature +//! signal before it is counted; can be one of \b QEI_VELDIV_1, +//! \b QEI_VELDIV_2, \b QEI_VELDIV_4, \b QEI_VELDIV_8, \b QEI_VELDIV_16, +//! \b QEI_VELDIV_32, \b QEI_VELDIV_64, or \b QEI_VELDIV_128. +//! \param ulPeriod specifies the number of clock ticks over which to measure +//! the velocity; must be non-zero. +//! +//! This will configure the operation of the velocity capture portion of the +//! quadrature encoder. The position increment signal is predivided as +//! specified by \e ulPreDiv before being accumulated by the velocity capture. +//! The divided signal is accumulated over \e ulPeriod system clock before +//! being saved and resetting the accumulator. +//! +//! \return None. +// +//***************************************************************************** +void +QEIVelocityConfigure(unsigned long ulBase, unsigned long ulPreDiv, + unsigned long ulPeriod) +{ + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + ASSERT(!(ulPreDiv & ~(QEI_CTL_VELDIV_M))); + ASSERT(ulPeriod != 0); + + // + // Set the velocity predivider. + // + HWREG(ulBase + QEI_O_CTL) = ((HWREG(ulBase + QEI_O_CTL) & + ~(QEI_CTL_VELDIV_M)) | ulPreDiv); + + // + // Set the timer period. + // + HWREG(ulBase + QEI_O_LOAD) = ulPeriod - 1; +} + +//***************************************************************************** +// +//! Gets the current encoder speed. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! +//! This returns the current speed of the encoder. The value returned is the +//! number of pulses detected in the specified time period; this number can be +//! multiplied by the number of time periods per second and divided by the +//! number of pulses per revolution to obtain the number of revolutions per +//! second. +//! +//! \return Returns the number of pulses captured in the given time period. +// +//***************************************************************************** +unsigned long +QEIVelocityGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Return the speed capture value. + // + return(HWREG(ulBase + QEI_O_SPEED)); +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the quadrature encoder interrupt. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! \param pfnHandler is a pointer to the function to be called when the +//! quadrature encoder interrupt occurs. +//! +//! This sets the handler to be called when a quadrature encoder interrupt +//! occurs. This will enable the global interrupt in the interrupt controller; +//! specific quadrature encoder interrupts must be enabled via QEIIntEnable(). +//! It is the interrupt handler's responsibility to clear the interrupt source +//! via QEIIntClear(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +QEIIntRegister(unsigned long ulBase, void (*pfnHandler)(void)) +{ + unsigned long ulInt; + + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Determine the interrupt number based on the QEI module. + // + ulInt = (ulBase == QEI0_BASE) ? INT_QEI0 : INT_QEI1; + + // + // Register the interrupt handler, returning an error if an error occurs. + // + IntRegister(ulInt, pfnHandler); + + // + // Enable the quadrature encoder interrupt. + // + IntEnable(ulInt); +} + +//***************************************************************************** +// +//! Unregisters an interrupt handler for the quadrature encoder interrupt. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! +//! This function will clear the handler to be called when a quadrature encoder +//! interrupt occurs. This will also mask off the interrupt in the interrupt +//! controller so that the interrupt handler no longer is called. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +QEIIntUnregister(unsigned long ulBase) +{ + unsigned long ulInt; + + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Determine the interrupt number based on the QEI module. + // + ulInt = (ulBase == QEI0_BASE) ? INT_QEI0 : INT_QEI1; + + // + // Disable the interrupt. + // + IntDisable(ulInt); + + // + // Unregister the interrupt handler. + // + IntUnregister(ulInt); +} + +//***************************************************************************** +// +//! Enables individual quadrature encoder interrupt sources. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! \param ulIntFlags is a bit mask of the interrupt sources to be enabled. +//! Can be any of the \b QEI_INTERROR, \b QEI_INTDIR, \b QEI_INTTIMER, or +//! \b QEI_INTINDEX values. +//! +//! Enables the indicated quadrature encoder interrupt sources. Only the +//! sources that are enabled can be reflected to the processor interrupt; +//! disabled sources have no effect on the processor. +//! +//! \return None. +// +//***************************************************************************** +void +QEIIntEnable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Enable the specified interrupts. + // + HWREG(ulBase + QEI_O_INTEN) |= ulIntFlags; +} + +//***************************************************************************** +// +//! Disables individual quadrature encoder interrupt sources. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! \param ulIntFlags is a bit mask of the interrupt sources to be disabled. +//! Can be any of the \b QEI_INTERROR, \b QEI_INTDIR, \b QEI_INTTIMER, or +//! \b QEI_INTINDEX values. +//! +//! Disables the indicated quadrature encoder interrupt sources. Only the +//! sources that are enabled can be reflected to the processor interrupt; +//! disabled sources have no effect on the processor. +//! +//! \return None. +// +//***************************************************************************** +void +QEIIntDisable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Disable the specified interrupts. + // + HWREG(ulBase + QEI_O_INTEN) &= ~(ulIntFlags); +} + +//***************************************************************************** +// +//! Gets the current interrupt status. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! \param bMasked is false if the raw interrupt status is required and true if +//! the masked interrupt status is required. +//! +//! This returns the interrupt status for the quadrature encoder module. +//! Either the raw interrupt status or the status of interrupts that are +//! allowed to reflect to the processor can be returned. +//! +//! \return Returns the current interrupt status, enumerated as a bit field of +//! \b QEI_INTERROR, \b QEI_INTDIR, \b QEI_INTTIMER, and \b QEI_INTINDEX. +// +//***************************************************************************** +unsigned long +QEIIntStatus(unsigned long ulBase, tBoolean bMasked) +{ + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + return(HWREG(ulBase + QEI_O_ISC)); + } + else + { + return(HWREG(ulBase + QEI_O_RIS)); + } +} + +//***************************************************************************** +// +//! Clears quadrature encoder interrupt sources. +//! +//! \param ulBase is the base address of the quadrature encoder module. +//! \param ulIntFlags is a bit mask of the interrupt sources to be cleared. +//! Can be any of the \b QEI_INTERROR, \b QEI_INTDIR, \b QEI_INTTIMER, or +//! \b QEI_INTINDEX values. +//! +//! The specified quadrature encoder interrupt sources are cleared, so that +//! they no longer assert. This must be done in the interrupt handler to keep +//! it from being called again immediately upon exit. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +QEIIntClear(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); + + // + // Clear the requested interrupt sources. + // + HWREG(ulBase + QEI_O_ISC) = ulIntFlags; +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/qei.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/qei.h new file mode 100644 index 00000000..0ad5e1e9 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/qei.h @@ -0,0 +1,112 @@ +//***************************************************************************** +// +// qei.h - Prototypes for the Quadrature Encoder Driver. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __QEI_H__ +#define __QEI_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Values that can be passed to QEIConfigure as the ulConfig paramater. +// +//***************************************************************************** +#define QEI_CONFIG_CAPTURE_A 0x00000000 // Count on ChA edges only +#define QEI_CONFIG_CAPTURE_A_B 0x00000008 // Count on ChA and ChB edges +#define QEI_CONFIG_NO_RESET 0x00000000 // Do not reset on index pulse +#define QEI_CONFIG_RESET_IDX 0x00000010 // Reset position on index pulse +#define QEI_CONFIG_QUADRATURE 0x00000000 // ChA and ChB are quadrature +#define QEI_CONFIG_CLOCK_DIR 0x00000004 // ChA and ChB are clock and dir +#define QEI_CONFIG_NO_SWAP 0x00000000 // Do not swap ChA and ChB +#define QEI_CONFIG_SWAP 0x00000002 // Swap ChA and ChB + +//***************************************************************************** +// +// Values that can be passed to QEIVelocityConfigure as the ulPreDiv parameter. +// +//***************************************************************************** +#define QEI_VELDIV_1 0x00000000 // Predivide by 1 +#define QEI_VELDIV_2 0x00000040 // Predivide by 2 +#define QEI_VELDIV_4 0x00000080 // Predivide by 4 +#define QEI_VELDIV_8 0x000000C0 // Predivide by 8 +#define QEI_VELDIV_16 0x00000100 // Predivide by 16 +#define QEI_VELDIV_32 0x00000140 // Predivide by 32 +#define QEI_VELDIV_64 0x00000180 // Predivide by 64 +#define QEI_VELDIV_128 0x000001C0 // Predivide by 128 + +//***************************************************************************** +// +// Values that can be passed to QEIEnableInts, QEIDisableInts, and QEIClearInts +// as the ulIntFlags parameter, and returned by QEIGetIntStatus. +// +//***************************************************************************** +#define QEI_INTERROR 0x00000008 // Phase error detected +#define QEI_INTDIR 0x00000004 // Direction change +#define QEI_INTTIMER 0x00000002 // Velocity timer expired +#define QEI_INTINDEX 0x00000001 // Index pulse detected + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern void QEIEnable(unsigned long ulBase); +extern void QEIDisable(unsigned long ulBase); +extern void QEIConfigure(unsigned long ulBase, unsigned long ulConfig, + unsigned long ulMaxPosition); +extern unsigned long QEIPositionGet(unsigned long ulBase); +extern void QEIPositionSet(unsigned long ulBase, unsigned long ulPosition); +extern long QEIDirectionGet(unsigned long ulBase); +extern tBoolean QEIErrorGet(unsigned long ulBase); +extern void QEIVelocityEnable(unsigned long ulBase); +extern void QEIVelocityDisable(unsigned long ulBase); +extern void QEIVelocityConfigure(unsigned long ulBase, unsigned long ulPreDiv, + unsigned long ulPeriod); +extern unsigned long QEIVelocityGet(unsigned long ulBase); +extern void QEIIntRegister(unsigned long ulBase, void (*pfnHandler)(void)); +extern void QEIIntUnregister(unsigned long ulBase); +extern void QEIIntEnable(unsigned long ulBase, unsigned long ulIntFlags); +extern void QEIIntDisable(unsigned long ulBase, unsigned long ulIntFlags); +extern unsigned long QEIIntStatus(unsigned long ulBase, tBoolean bMasked); +extern void QEIIntClear(unsigned long ulBase, unsigned long ulIntFlags); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __QEI_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/rom.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/rom.h new file mode 100644 index 00000000..467d6c20 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/rom.h @@ -0,0 +1,3584 @@ +//***************************************************************************** +// +// rom.h - Macros to facilitate calling functions in the ROM. +// +// Copyright (c) 2007-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __ROM_H__ +#define __ROM_H__ + +//***************************************************************************** +// +// Pointers to the main API tables. +// +//***************************************************************************** +#define ROM_APITABLE ((unsigned long *)0x01000010) +#define ROM_VERSION (ROM_APITABLE[0]) +#define ROM_UARTTABLE ((unsigned long *)(ROM_APITABLE[1])) +#define ROM_SSITABLE ((unsigned long *)(ROM_APITABLE[2])) +#define ROM_I2CTABLE ((unsigned long *)(ROM_APITABLE[3])) +#define ROM_GPIOTABLE ((unsigned long *)(ROM_APITABLE[4])) +#define ROM_ADCTABLE ((unsigned long *)(ROM_APITABLE[5])) +#define ROM_COMPARATORTABLE ((unsigned long *)(ROM_APITABLE[6])) +#define ROM_FLASHTABLE ((unsigned long *)(ROM_APITABLE[7])) +#define ROM_PWMTABLE ((unsigned long *)(ROM_APITABLE[8])) +#define ROM_QEITABLE ((unsigned long *)(ROM_APITABLE[9])) +#define ROM_SYSTICKTABLE ((unsigned long *)(ROM_APITABLE[10])) +#define ROM_TIMERTABLE ((unsigned long *)(ROM_APITABLE[11])) +#define ROM_WATCHDOGTABLE ((unsigned long *)(ROM_APITABLE[12])) +#define ROM_SYSCTLTABLE ((unsigned long *)(ROM_APITABLE[13])) +#define ROM_INTERRUPTTABLE ((unsigned long *)(ROM_APITABLE[14])) +#define ROM_ETHERNETTABLE ((unsigned long *)(ROM_APITABLE[15])) +#define ROM_USBTABLE ((unsigned long *)(ROM_APITABLE[16])) +#define ROM_UDMATABLE ((unsigned long *)(ROM_APITABLE[17])) +#define ROM_CANTABLE ((unsigned long *)(ROM_APITABLE[18])) +#define ROM_HIBERNATETABLE ((unsigned long *)(ROM_APITABLE[19])) +#define ROM_MPUTABLE ((unsigned long *)(ROM_APITABLE[20])) +#define ROM_SOFTWARETABLE ((unsigned long *)(ROM_APITABLE[21])) +#define ROM_I2STABLE ((unsigned long *)(ROM_APITABLE[22])) +#define ROM_EPITABLE ((unsigned long *)(ROM_APITABLE[23])) + +//***************************************************************************** +// +// Macros for calling ROM functions in the ADC API. +// +//***************************************************************************** +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCSequenceDataGet \ + ((long (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum, \ + unsigned long *pulBuffer))ROM_ADCTABLE[0]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCIntDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum))ROM_ADCTABLE[1]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCIntEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum))ROM_ADCTABLE[2]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCIntStatus \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum, \ + tBoolean bMasked))ROM_ADCTABLE[3]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCIntClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum))ROM_ADCTABLE[4]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCSequenceEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum))ROM_ADCTABLE[5]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCSequenceDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum))ROM_ADCTABLE[6]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCSequenceConfigure \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum, \ + unsigned long ulTrigger, \ + unsigned long ulPriority))ROM_ADCTABLE[7]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCSequenceStepConfigure \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum, \ + unsigned long ulStep, \ + unsigned long ulConfig))ROM_ADCTABLE[8]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCSequenceOverflow \ + ((long (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum))ROM_ADCTABLE[9]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCSequenceOverflowClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum))ROM_ADCTABLE[10]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCSequenceUnderflow \ + ((long (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum))ROM_ADCTABLE[11]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCSequenceUnderflowClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum))ROM_ADCTABLE[12]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCProcessorTrigger \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum))ROM_ADCTABLE[13]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCHardwareOversampleConfigure \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulFactor))ROM_ADCTABLE[14]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCComparatorConfigure \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulComp, \ + unsigned long ulConfig))ROM_ADCTABLE[15]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCComparatorRegionSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulComp, \ + unsigned long ulLowRef, \ + unsigned long ulHighRef))ROM_ADCTABLE[16]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCComparatorReset \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulComp, \ + tBoolean bTrigger, \ + tBoolean bInterrupt))ROM_ADCTABLE[17]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCComparatorIntDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum))ROM_ADCTABLE[18]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCComparatorIntEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulSequenceNum))ROM_ADCTABLE[19]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCComparatorIntStatus \ + ((unsigned long (*)(unsigned long ulBase))ROM_ADCTABLE[20]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCComparatorIntClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulStatus))ROM_ADCTABLE[21]) +#endif +#if defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCReferenceSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulRef))ROM_ADCTABLE[22]) +#endif +#if defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCReferenceGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_ADCTABLE[23]) +#endif +#if defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCPhaseDelaySet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulPhase))ROM_ADCTABLE[24]) +#endif +#if defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ADCPhaseDelayGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_ADCTABLE[25]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the CAN API. +// +//***************************************************************************** +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANIntClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntClr))ROM_CANTABLE[0]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANInit \ + ((void (*)(unsigned long ulBase))ROM_CANTABLE[1]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANEnable \ + ((void (*)(unsigned long ulBase))ROM_CANTABLE[2]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANDisable \ + ((void (*)(unsigned long ulBase))ROM_CANTABLE[3]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANBitTimingSet \ + ((void (*)(unsigned long ulBase, \ + tCANBitClkParms *pClkParms))ROM_CANTABLE[4]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANBitTimingGet \ + ((void (*)(unsigned long ulBase, \ + tCANBitClkParms *pClkParms))ROM_CANTABLE[5]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANMessageSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulObjID, \ + tCANMsgObject *pMsgObject, \ + tMsgObjType eMsgType))ROM_CANTABLE[6]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANMessageGet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulObjID, \ + tCANMsgObject *pMsgObject, \ + tBoolean bClrPendingInt))ROM_CANTABLE[7]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANStatusGet \ + ((unsigned long (*)(unsigned long ulBase, \ + tCANStsReg eStatusReg))ROM_CANTABLE[8]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANMessageClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulObjID))ROM_CANTABLE[9]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANIntEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_CANTABLE[10]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANIntDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_CANTABLE[11]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANIntStatus \ + ((unsigned long (*)(unsigned long ulBase, \ + tCANIntStsReg eIntStsReg))ROM_CANTABLE[12]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANRetryGet \ + ((tBoolean (*)(unsigned long ulBase))ROM_CANTABLE[13]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANRetrySet \ + ((void (*)(unsigned long ulBase, \ + tBoolean bAutoRetry))ROM_CANTABLE[14]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANErrCntrGet \ + ((tBoolean (*)(unsigned long ulBase, \ + unsigned long *pulRxCount, \ + unsigned long *pulTxCount))ROM_CANTABLE[15]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_CANBitRateSet \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulSourceClock, \ + unsigned long ulBitRate))ROM_CANTABLE[16]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the Comparator API. +// +//***************************************************************************** +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ComparatorIntClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulComp))ROM_COMPARATORTABLE[0]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ComparatorConfigure \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulComp, \ + unsigned long ulConfig))ROM_COMPARATORTABLE[1]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ComparatorRefSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulRef))ROM_COMPARATORTABLE[2]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ComparatorValueGet \ + ((tBoolean (*)(unsigned long ulBase, \ + unsigned long ulComp))ROM_COMPARATORTABLE[3]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ComparatorIntEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulComp))ROM_COMPARATORTABLE[4]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ComparatorIntDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulComp))ROM_COMPARATORTABLE[5]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_ComparatorIntStatus \ + ((tBoolean (*)(unsigned long ulBase, \ + unsigned long ulComp, \ + tBoolean bMasked))ROM_COMPARATORTABLE[6]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the Ethernet API. +// +//***************************************************************************** +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPIIntStatus \ + ((unsigned long (*)(unsigned long ulBase, \ + tBoolean bMasked))ROM_EPITABLE[0]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPIModeSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulMode))ROM_EPITABLE[1]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPIDividerSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulDivider))ROM_EPITABLE[2]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPIConfigSDRAMSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulConfig, \ + unsigned long ulRefresh))ROM_EPITABLE[3]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPIConfigGPModeSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulConfig, \ + unsigned long ulFrameCount, \ + unsigned long ulMaxWait))ROM_EPITABLE[4]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPIConfigHB8Set \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulConfig, \ + unsigned long ulMaxWait))ROM_EPITABLE[5]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPIConfigHB16Set \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulConfig, \ + unsigned long ulMaxWait))ROM_EPITABLE[6]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPIAddressMapSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulMap))ROM_EPITABLE[7]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPINonBlockingReadConfigure \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulChannel, \ + unsigned long ulDataSize, \ + unsigned long ulAddress))ROM_EPITABLE[8]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPINonBlockingReadStart \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulChannel, \ + unsigned long ulCount))ROM_EPITABLE[9]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPINonBlockingReadStop \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulChannel))ROM_EPITABLE[10]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPINonBlockingReadCount \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulChannel))ROM_EPITABLE[11]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPINonBlockingReadAvail \ + ((unsigned long (*)(unsigned long ulBase))ROM_EPITABLE[12]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPINonBlockingReadGet32 \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulCount, \ + unsigned long *pulBuf))ROM_EPITABLE[13]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPINonBlockingReadGet16 \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulCount, \ + unsigned short *pusBuf))ROM_EPITABLE[14]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPINonBlockingReadGet8 \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulCount, \ + unsigned char *pucBuf))ROM_EPITABLE[15]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPIFIFOConfig \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulConfig))ROM_EPITABLE[16]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPIWriteFIFOCountGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_EPITABLE[17]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPIIntEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_EPITABLE[18]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPIIntDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_EPITABLE[19]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPIIntErrorStatus \ + ((unsigned long (*)(unsigned long ulBase))ROM_EPITABLE[20]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EPIIntErrorClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulErrFlags))ROM_EPITABLE[21]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the Ethernet API. +// +//***************************************************************************** +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetIntClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_ETHERNETTABLE[0]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetInitExpClk \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEthClk))ROM_ETHERNETTABLE[1]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetConfigSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulConfig))ROM_ETHERNETTABLE[2]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetConfigGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_ETHERNETTABLE[3]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetMACAddrSet \ + ((void (*)(unsigned long ulBase, \ + unsigned char *pucMACAddr))ROM_ETHERNETTABLE[4]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetMACAddrGet \ + ((void (*)(unsigned long ulBase, \ + unsigned char *pucMACAddr))ROM_ETHERNETTABLE[5]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetEnable \ + ((void (*)(unsigned long ulBase))ROM_ETHERNETTABLE[6]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetDisable \ + ((void (*)(unsigned long ulBase))ROM_ETHERNETTABLE[7]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetPacketAvail \ + ((tBoolean (*)(unsigned long ulBase))ROM_ETHERNETTABLE[8]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetSpaceAvail \ + ((tBoolean (*)(unsigned long ulBase))ROM_ETHERNETTABLE[9]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetPacketGetNonBlocking \ + ((long (*)(unsigned long ulBase, \ + unsigned char *pucBuf, \ + long lBufLen))ROM_ETHERNETTABLE[10]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetPacketGet \ + ((long (*)(unsigned long ulBase, \ + unsigned char *pucBuf, \ + long lBufLen))ROM_ETHERNETTABLE[11]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetPacketPutNonBlocking \ + ((long (*)(unsigned long ulBase, \ + unsigned char *pucBuf, \ + long lBufLen))ROM_ETHERNETTABLE[12]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetPacketPut \ + ((long (*)(unsigned long ulBase, \ + unsigned char *pucBuf, \ + long lBufLen))ROM_ETHERNETTABLE[13]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetIntEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_ETHERNETTABLE[14]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetIntDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_ETHERNETTABLE[15]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetIntStatus \ + ((unsigned long (*)(unsigned long ulBase, \ + tBoolean bMasked))ROM_ETHERNETTABLE[16]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetPHYWrite \ + ((void (*)(unsigned long ulBase, \ + unsigned char ucRegAddr, \ + unsigned long ulData))ROM_ETHERNETTABLE[17]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_EthernetPHYRead \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned char ucRegAddr))ROM_ETHERNETTABLE[18]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UpdateEthernet \ + ((void (*)(unsigned long ulClock))ROM_ETHERNETTABLE[19]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the Flash API. +// +//***************************************************************************** +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_FlashProgram \ + ((long (*)(unsigned long *pulData, \ + unsigned long ulAddress, \ + unsigned long ulCount))ROM_FLASHTABLE[0]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_FlashUsecGet \ + ((unsigned long (*)(void))ROM_FLASHTABLE[1]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_FlashUsecSet \ + ((void (*)(unsigned long ulClocks))ROM_FLASHTABLE[2]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_FlashErase \ + ((long (*)(unsigned long ulAddress))ROM_FLASHTABLE[3]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_FlashProtectGet \ + ((tFlashProtection (*)(unsigned long ulAddress))ROM_FLASHTABLE[4]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_FlashProtectSet \ + ((long (*)(unsigned long ulAddress, \ + tFlashProtection eProtect))ROM_FLASHTABLE[5]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_FlashProtectSave \ + ((long (*)(void))ROM_FLASHTABLE[6]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_FlashUserGet \ + ((long (*)(unsigned long *pulUser0, \ + unsigned long *pulUser1))ROM_FLASHTABLE[7]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_FlashUserSet \ + ((long (*)(unsigned long ulUser0, \ + unsigned long ulUser1))ROM_FLASHTABLE[8]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_FlashUserSave \ + ((long (*)(void))ROM_FLASHTABLE[9]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_FlashIntEnable \ + ((void (*)(unsigned long ulIntFlags))ROM_FLASHTABLE[10]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_FlashIntDisable \ + ((void (*)(unsigned long ulIntFlags))ROM_FLASHTABLE[11]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_FlashIntStatus \ + ((unsigned long (*)(tBoolean bMasked))ROM_FLASHTABLE[12]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_FlashIntClear \ + ((void (*)(unsigned long ulIntFlags))ROM_FLASHTABLE[13]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the GPIO API. +// +//***************************************************************************** +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinWrite \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins, \ + unsigned char ucVal))ROM_GPIOTABLE[0]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIODirModeSet \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins, \ + unsigned long ulPinIO))ROM_GPIOTABLE[1]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIODirModeGet \ + ((unsigned long (*)(unsigned long ulPort, \ + unsigned char ucPin))ROM_GPIOTABLE[2]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOIntTypeSet \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins, \ + unsigned long ulIntType))ROM_GPIOTABLE[3]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOIntTypeGet \ + ((unsigned long (*)(unsigned long ulPort, \ + unsigned char ucPin))ROM_GPIOTABLE[4]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPadConfigSet \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins, \ + unsigned long ulStrength, \ + unsigned long ulPadType))ROM_GPIOTABLE[5]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPadConfigGet \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPin, \ + unsigned long *pulStrength, \ + unsigned long *pulPadType))ROM_GPIOTABLE[6]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinIntEnable \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[7]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinIntDisable \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[8]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinIntStatus \ + ((long (*)(unsigned long ulPort, \ + tBoolean bMasked))ROM_GPIOTABLE[9]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinIntClear \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[10]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinRead \ + ((long (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[11]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeCAN \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[12]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeComparator \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[13]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeGPIOInput \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[14]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeGPIOOutput \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[15]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeI2C \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[16]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypePWM \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[17]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeQEI \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[18]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeSSI \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[19]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeTimer \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[20]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeUART \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[21]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeGPIOOutputOD \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[22]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeADC \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[23]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeUSBDigital \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[24]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeI2S \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[25]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinConfigure \ + ((void (*)(unsigned long ulPinConfig))ROM_GPIOTABLE[26]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeEthernetLED \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[27]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeUSBAnalog \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[28]) +#endif +#if defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeEPI \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[29]) +#endif +#if defined(TARGET_IS_TEMPEST_RC3) +#define ROM_GPIOPinTypeEthernetMII \ + ((void (*)(unsigned long ulPort, \ + unsigned char ucPins))ROM_GPIOTABLE[30]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the Hibernate API. +// +//***************************************************************************** +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateIntClear \ + ((void (*)(unsigned long ulIntFlags))ROM_HIBERNATETABLE[0]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateEnableExpClk \ + ((void (*)(unsigned long ulHibClk))ROM_HIBERNATETABLE[1]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateDisable \ + ((void (*)(void))ROM_HIBERNATETABLE[2]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateClockSelect \ + ((void (*)(unsigned long ulClockInput))ROM_HIBERNATETABLE[3]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateRTCEnable \ + ((void (*)(void))ROM_HIBERNATETABLE[4]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateRTCDisable \ + ((void (*)(void))ROM_HIBERNATETABLE[5]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateWakeSet \ + ((void (*)(unsigned long ulWakeFlags))ROM_HIBERNATETABLE[6]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateWakeGet \ + ((unsigned long (*)(void))ROM_HIBERNATETABLE[7]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateLowBatSet \ + ((void (*)(unsigned long ulLowBatFlags))ROM_HIBERNATETABLE[8]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateLowBatGet \ + ((unsigned long (*)(void))ROM_HIBERNATETABLE[9]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateRTCSet \ + ((void (*)(unsigned long ulRTCValue))ROM_HIBERNATETABLE[10]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateRTCGet \ + ((unsigned long (*)(void))ROM_HIBERNATETABLE[11]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateRTCMatch0Set \ + ((void (*)(unsigned long ulMatch))ROM_HIBERNATETABLE[12]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateRTCMatch0Get \ + ((unsigned long (*)(void))ROM_HIBERNATETABLE[13]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateRTCMatch1Set \ + ((void (*)(unsigned long ulMatch))ROM_HIBERNATETABLE[14]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateRTCMatch1Get \ + ((unsigned long (*)(void))ROM_HIBERNATETABLE[15]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateRTCTrimSet \ + ((void (*)(unsigned long ulTrim))ROM_HIBERNATETABLE[16]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateRTCTrimGet \ + ((unsigned long (*)(void))ROM_HIBERNATETABLE[17]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateDataSet \ + ((void (*)(unsigned long *pulData, \ + unsigned long ulCount))ROM_HIBERNATETABLE[18]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateDataGet \ + ((void (*)(unsigned long *pulData, \ + unsigned long ulCount))ROM_HIBERNATETABLE[19]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateRequest \ + ((void (*)(void))ROM_HIBERNATETABLE[20]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateIntEnable \ + ((void (*)(unsigned long ulIntFlags))ROM_HIBERNATETABLE[21]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateIntDisable \ + ((void (*)(unsigned long ulIntFlags))ROM_HIBERNATETABLE[22]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateIntStatus \ + ((unsigned long (*)(tBoolean bMasked))ROM_HIBERNATETABLE[23]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_HibernateIsActive \ + ((unsigned int (*)(void))ROM_HIBERNATETABLE[24]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the I2C API. +// +//***************************************************************************** +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CMasterDataPut \ + ((void (*)(unsigned long ulBase, \ + unsigned char ucData))ROM_I2CTABLE[0]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CMasterInitExpClk \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulI2CClk, \ + tBoolean bFast))ROM_I2CTABLE[1]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CSlaveInit \ + ((void (*)(unsigned long ulBase, \ + unsigned char ucSlaveAddr))ROM_I2CTABLE[2]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CMasterEnable \ + ((void (*)(unsigned long ulBase))ROM_I2CTABLE[3]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CSlaveEnable \ + ((void (*)(unsigned long ulBase))ROM_I2CTABLE[4]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CMasterDisable \ + ((void (*)(unsigned long ulBase))ROM_I2CTABLE[5]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CSlaveDisable \ + ((void (*)(unsigned long ulBase))ROM_I2CTABLE[6]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CMasterIntEnable \ + ((void (*)(unsigned long ulBase))ROM_I2CTABLE[7]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CSlaveIntEnable \ + ((void (*)(unsigned long ulBase))ROM_I2CTABLE[8]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CMasterIntDisable \ + ((void (*)(unsigned long ulBase))ROM_I2CTABLE[9]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CSlaveIntDisable \ + ((void (*)(unsigned long ulBase))ROM_I2CTABLE[10]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CMasterIntStatus \ + ((tBoolean (*)(unsigned long ulBase, \ + tBoolean bMasked))ROM_I2CTABLE[11]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CSlaveIntStatus \ + ((tBoolean (*)(unsigned long ulBase, \ + tBoolean bMasked))ROM_I2CTABLE[12]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CMasterIntClear \ + ((void (*)(unsigned long ulBase))ROM_I2CTABLE[13]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CSlaveIntClear \ + ((void (*)(unsigned long ulBase))ROM_I2CTABLE[14]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CMasterSlaveAddrSet \ + ((void (*)(unsigned long ulBase, \ + unsigned char ucSlaveAddr, \ + tBoolean bReceive))ROM_I2CTABLE[15]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CMasterBusy \ + ((tBoolean (*)(unsigned long ulBase))ROM_I2CTABLE[16]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CMasterBusBusy \ + ((tBoolean (*)(unsigned long ulBase))ROM_I2CTABLE[17]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CMasterControl \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulCmd))ROM_I2CTABLE[18]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CMasterErr \ + ((unsigned long (*)(unsigned long ulBase))ROM_I2CTABLE[19]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CMasterDataGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_I2CTABLE[20]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CSlaveStatus \ + ((unsigned long (*)(unsigned long ulBase))ROM_I2CTABLE[21]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CSlaveDataPut \ + ((void (*)(unsigned long ulBase, \ + unsigned char ucData))ROM_I2CTABLE[22]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CSlaveDataGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_I2CTABLE[23]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UpdateI2C \ + ((void (*)(void))ROM_I2CTABLE[24]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CSlaveIntEnableEx \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_I2CTABLE[25]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CSlaveIntDisableEx \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_I2CTABLE[26]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CSlaveIntStatusEx \ + ((unsigned long (*)(unsigned long ulBase, \ + tBoolean bMasked))ROM_I2CTABLE[27]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2CSlaveIntClearEx \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_I2CTABLE[28]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the I2S API. +// +//***************************************************************************** +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2SIntStatus \ + ((unsigned long (*)(unsigned long ulBase, \ + tBoolean bMasked))ROM_I2STABLE[0]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2STxEnable \ + ((void (*)(unsigned long ulBase))ROM_I2STABLE[1]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2STxDisable \ + ((void (*)(unsigned long ulBase))ROM_I2STABLE[2]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2STxDataPut \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulData))ROM_I2STABLE[3]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2STxDataPutNonBlocking \ + ((long (*)(unsigned long ulBase, \ + unsigned long ulData))ROM_I2STABLE[4]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2STxConfigSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulConfig))ROM_I2STABLE[5]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2STxFIFOLimitSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulLevel))ROM_I2STABLE[6]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2STxFIFOLimitGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_I2STABLE[7]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2STxFIFOLevelGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_I2STABLE[8]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2SRxEnable \ + ((void (*)(unsigned long ulBase))ROM_I2STABLE[9]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2SRxDisable \ + ((void (*)(unsigned long ulBase))ROM_I2STABLE[10]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2SRxDataGet \ + ((void (*)(unsigned long ulBase, \ + unsigned long *pulData))ROM_I2STABLE[11]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2SRxDataGetNonBlocking \ + ((long (*)(unsigned long ulBase, \ + unsigned long *pulData))ROM_I2STABLE[12]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2SRxConfigSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulConfig))ROM_I2STABLE[13]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2SRxFIFOLimitSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulLevel))ROM_I2STABLE[14]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2SRxFIFOLimitGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_I2STABLE[15]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2SRxFIFOLevelGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_I2STABLE[16]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2STxRxEnable \ + ((void (*)(unsigned long ulBase))ROM_I2STABLE[17]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2STxRxDisable \ + ((void (*)(unsigned long ulBase))ROM_I2STABLE[18]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2STxRxConfigSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulConfig))ROM_I2STABLE[19]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2SMasterClockSelect \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulMClock))ROM_I2STABLE[20]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2SIntEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_I2STABLE[21]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2SIntDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_I2STABLE[22]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_I2SIntClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_I2STABLE[23]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the Interrupt API. +// +//***************************************************************************** +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_IntEnable \ + ((void (*)(unsigned long ulInterrupt))ROM_INTERRUPTTABLE[0]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_IntMasterEnable \ + ((tBoolean (*)(void))ROM_INTERRUPTTABLE[1]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_IntMasterDisable \ + ((tBoolean (*)(void))ROM_INTERRUPTTABLE[2]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_IntDisable \ + ((void (*)(unsigned long ulInterrupt))ROM_INTERRUPTTABLE[3]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_IntPriorityGroupingSet \ + ((void (*)(unsigned long ulBits))ROM_INTERRUPTTABLE[4]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_IntPriorityGroupingGet \ + ((unsigned long (*)(void))ROM_INTERRUPTTABLE[5]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_IntPrioritySet \ + ((void (*)(unsigned long ulInterrupt, \ + unsigned char ucPriority))ROM_INTERRUPTTABLE[6]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_IntPriorityGet \ + ((long (*)(unsigned long ulInterrupt))ROM_INTERRUPTTABLE[7]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_IntPendSet \ + ((void (*)(unsigned long ulInterrupt))ROM_INTERRUPTTABLE[8]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_IntPendClear \ + ((void (*)(unsigned long ulInterrupt))ROM_INTERRUPTTABLE[9]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the MPU API. +// +//***************************************************************************** +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_MPUEnable \ + ((void (*)(unsigned long ulMPUConfig))ROM_MPUTABLE[0]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_MPUDisable \ + ((void (*)(void))ROM_MPUTABLE[1]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_MPURegionCountGet \ + ((unsigned long (*)(void))ROM_MPUTABLE[2]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_MPURegionEnable \ + ((void (*)(unsigned long ulRegion))ROM_MPUTABLE[3]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_MPURegionDisable \ + ((void (*)(unsigned long ulRegion))ROM_MPUTABLE[4]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_MPURegionSet \ + ((void (*)(unsigned long ulRegion, \ + unsigned long ulAddr, \ + unsigned long ulFlags))ROM_MPUTABLE[5]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_MPURegionGet \ + ((void (*)(unsigned long ulRegion, \ + unsigned long *pulAddr, \ + unsigned long *pulFlags))ROM_MPUTABLE[6]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the PWM API. +// +//***************************************************************************** +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMPulseWidthSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulPWMOut, \ + unsigned long ulWidth))ROM_PWMTABLE[0]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMGenConfigure \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGen, \ + unsigned long ulConfig))ROM_PWMTABLE[1]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMGenPeriodSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGen, \ + unsigned long ulPeriod))ROM_PWMTABLE[2]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMGenPeriodGet \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulGen))ROM_PWMTABLE[3]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMGenEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGen))ROM_PWMTABLE[4]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMGenDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGen))ROM_PWMTABLE[5]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMPulseWidthGet \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulPWMOut))ROM_PWMTABLE[6]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMDeadBandEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGen, \ + unsigned short usRise, \ + unsigned short usFall))ROM_PWMTABLE[7]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMDeadBandDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGen))ROM_PWMTABLE[8]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMSyncUpdate \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGenBits))ROM_PWMTABLE[9]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMSyncTimeBase \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGenBits))ROM_PWMTABLE[10]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMOutputState \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulPWMOutBits, \ + tBoolean bEnable))ROM_PWMTABLE[11]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMOutputInvert \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulPWMOutBits, \ + tBoolean bInvert))ROM_PWMTABLE[12]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMOutputFault \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulPWMOutBits, \ + tBoolean bFaultSuppress))ROM_PWMTABLE[13]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMGenIntTrigEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGen, \ + unsigned long ulIntTrig))ROM_PWMTABLE[14]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMGenIntTrigDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGen, \ + unsigned long ulIntTrig))ROM_PWMTABLE[15]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMGenIntStatus \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulGen, \ + tBoolean bMasked))ROM_PWMTABLE[16]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMGenIntClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGen, \ + unsigned long ulInts))ROM_PWMTABLE[17]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMIntEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGenFault))ROM_PWMTABLE[18]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMIntDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGenFault))ROM_PWMTABLE[19]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMFaultIntClear \ + ((void (*)(unsigned long ulBase))ROM_PWMTABLE[20]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMIntStatus \ + ((unsigned long (*)(unsigned long ulBase, \ + tBoolean bMasked))ROM_PWMTABLE[21]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMOutputFaultLevel \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulPWMOutBits, \ + tBoolean bDriveHigh))ROM_PWMTABLE[22]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMFaultIntClearExt \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulFaultInts))ROM_PWMTABLE[23]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMGenFaultConfigure \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGen, \ + unsigned long ulMinFaultPeriod, \ + unsigned long ulFaultSenses))ROM_PWMTABLE[24]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMGenFaultTriggerSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGen, \ + unsigned long ulGroup, \ + unsigned long ulFaultTriggers))ROM_PWMTABLE[25]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMGenFaultTriggerGet \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulGen, \ + unsigned long ulGroup))ROM_PWMTABLE[26]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMGenFaultStatus \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulGen, \ + unsigned long ulGroup))ROM_PWMTABLE[27]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_PWMGenFaultClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulGen, \ + unsigned long ulGroup, \ + unsigned long ulFaultTriggers))ROM_PWMTABLE[28]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the QEI API. +// +//***************************************************************************** +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_QEIPositionGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_QEITABLE[0]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_QEIEnable \ + ((void (*)(unsigned long ulBase))ROM_QEITABLE[1]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_QEIDisable \ + ((void (*)(unsigned long ulBase))ROM_QEITABLE[2]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_QEIConfigure \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulConfig, \ + unsigned long ulMaxPosition))ROM_QEITABLE[3]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_QEIPositionSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulPosition))ROM_QEITABLE[4]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_QEIDirectionGet \ + ((long (*)(unsigned long ulBase))ROM_QEITABLE[5]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_QEIErrorGet \ + ((tBoolean (*)(unsigned long ulBase))ROM_QEITABLE[6]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_QEIVelocityEnable \ + ((void (*)(unsigned long ulBase))ROM_QEITABLE[7]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_QEIVelocityDisable \ + ((void (*)(unsigned long ulBase))ROM_QEITABLE[8]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_QEIVelocityConfigure \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulPreDiv, \ + unsigned long ulPeriod))ROM_QEITABLE[9]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_QEIVelocityGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_QEITABLE[10]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_QEIIntEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_QEITABLE[11]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_QEIIntDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_QEITABLE[12]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_QEIIntStatus \ + ((unsigned long (*)(unsigned long ulBase, \ + tBoolean bMasked))ROM_QEITABLE[13]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_QEIIntClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_QEITABLE[14]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the SSI API. +// +//***************************************************************************** +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SSIDataPut \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulData))ROM_SSITABLE[0]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SSIConfigSetExpClk \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulSSIClk, \ + unsigned long ulProtocol, \ + unsigned long ulMode, \ + unsigned long ulBitRate, \ + unsigned long ulDataWidth))ROM_SSITABLE[1]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SSIEnable \ + ((void (*)(unsigned long ulBase))ROM_SSITABLE[2]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SSIDisable \ + ((void (*)(unsigned long ulBase))ROM_SSITABLE[3]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SSIIntEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_SSITABLE[4]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SSIIntDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_SSITABLE[5]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SSIIntStatus \ + ((unsigned long (*)(unsigned long ulBase, \ + tBoolean bMasked))ROM_SSITABLE[6]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SSIIntClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_SSITABLE[7]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SSIDataPutNonBlocking \ + ((long (*)(unsigned long ulBase, \ + unsigned long ulData))ROM_SSITABLE[8]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SSIDataGet \ + ((void (*)(unsigned long ulBase, \ + unsigned long *pulData))ROM_SSITABLE[9]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SSIDataGetNonBlocking \ + ((long (*)(unsigned long ulBase, \ + unsigned long *pulData))ROM_SSITABLE[10]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UpdateSSI \ + ((void (*)(void))ROM_SSITABLE[11]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SSIDMAEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulDMAFlags))ROM_SSITABLE[12]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SSIDMADisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulDMAFlags))ROM_SSITABLE[13]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SSIBusy \ + ((tBoolean (*)(unsigned long ulBase))ROM_SSITABLE[14]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the SysCtl API. +// +//***************************************************************************** +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlSleep \ + ((void (*)(void))ROM_SYSCTLTABLE[0]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlSRAMSizeGet \ + ((unsigned long (*)(void))ROM_SYSCTLTABLE[1]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlFlashSizeGet \ + ((unsigned long (*)(void))ROM_SYSCTLTABLE[2]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlPinPresent \ + ((tBoolean (*)(unsigned long ulPin))ROM_SYSCTLTABLE[3]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlPeripheralPresent \ + ((tBoolean (*)(unsigned long ulPeripheral))ROM_SYSCTLTABLE[4]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlPeripheralReset \ + ((void (*)(unsigned long ulPeripheral))ROM_SYSCTLTABLE[5]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlPeripheralEnable \ + ((void (*)(unsigned long ulPeripheral))ROM_SYSCTLTABLE[6]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlPeripheralDisable \ + ((void (*)(unsigned long ulPeripheral))ROM_SYSCTLTABLE[7]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlPeripheralSleepEnable \ + ((void (*)(unsigned long ulPeripheral))ROM_SYSCTLTABLE[8]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlPeripheralSleepDisable \ + ((void (*)(unsigned long ulPeripheral))ROM_SYSCTLTABLE[9]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlPeripheralDeepSleepEnable \ + ((void (*)(unsigned long ulPeripheral))ROM_SYSCTLTABLE[10]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlPeripheralDeepSleepDisable \ + ((void (*)(unsigned long ulPeripheral))ROM_SYSCTLTABLE[11]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlPeripheralClockGating \ + ((void (*)(tBoolean bEnable))ROM_SYSCTLTABLE[12]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlIntEnable \ + ((void (*)(unsigned long ulInts))ROM_SYSCTLTABLE[13]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlIntDisable \ + ((void (*)(unsigned long ulInts))ROM_SYSCTLTABLE[14]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlIntClear \ + ((void (*)(unsigned long ulInts))ROM_SYSCTLTABLE[15]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlIntStatus \ + ((unsigned long (*)(tBoolean bMasked))ROM_SYSCTLTABLE[16]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlLDOSet \ + ((void (*)(unsigned long ulVoltage))ROM_SYSCTLTABLE[17]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlLDOGet \ + ((unsigned long (*)(void))ROM_SYSCTLTABLE[18]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlReset \ + ((void (*)(void))ROM_SYSCTLTABLE[19]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlDeepSleep \ + ((void (*)(void))ROM_SYSCTLTABLE[20]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlResetCauseGet \ + ((unsigned long (*)(void))ROM_SYSCTLTABLE[21]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlResetCauseClear \ + ((void (*)(unsigned long ulCauses))ROM_SYSCTLTABLE[22]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlClockSet \ + ((void (*)(unsigned long ulConfig))ROM_SYSCTLTABLE[23]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlClockGet \ + ((unsigned long (*)(void))ROM_SYSCTLTABLE[24]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlPWMClockSet \ + ((void (*)(unsigned long ulConfig))ROM_SYSCTLTABLE[25]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlPWMClockGet \ + ((unsigned long (*)(void))ROM_SYSCTLTABLE[26]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlADCSpeedSet \ + ((void (*)(unsigned long ulSpeed))ROM_SYSCTLTABLE[27]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlADCSpeedGet \ + ((unsigned long (*)(void))ROM_SYSCTLTABLE[28]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlGPIOAHBEnable \ + ((void (*)(unsigned long ulGPIOPeripheral))ROM_SYSCTLTABLE[29]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlGPIOAHBDisable \ + ((void (*)(unsigned long ulGPIOPeripheral))ROM_SYSCTLTABLE[30]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlUSBPLLEnable \ + ((void (*)(void))ROM_SYSCTLTABLE[31]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlUSBPLLDisable \ + ((void (*)(void))ROM_SYSCTLTABLE[32]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlI2SMClkSet \ + ((unsigned long (*)(unsigned long ulInputClock, \ + unsigned long ulMClk))ROM_SYSCTLTABLE[33]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysCtlDelay \ + ((void (*)(unsigned long ulCount))ROM_SYSCTLTABLE[34]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the SysTick API. +// +//***************************************************************************** +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysTickValueGet \ + ((unsigned long (*)(void))ROM_SYSTICKTABLE[0]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysTickEnable \ + ((void (*)(void))ROM_SYSTICKTABLE[1]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysTickDisable \ + ((void (*)(void))ROM_SYSTICKTABLE[2]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysTickIntEnable \ + ((void (*)(void))ROM_SYSTICKTABLE[3]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysTickIntDisable \ + ((void (*)(void))ROM_SYSTICKTABLE[4]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysTickPeriodSet \ + ((void (*)(unsigned long ulPeriod))ROM_SYSTICKTABLE[5]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_SysTickPeriodGet \ + ((unsigned long (*)(void))ROM_SYSTICKTABLE[6]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the Timer API. +// +//***************************************************************************** +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerIntClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_TIMERTABLE[0]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulTimer))ROM_TIMERTABLE[1]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulTimer))ROM_TIMERTABLE[2]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerConfigure \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulConfig))ROM_TIMERTABLE[3]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerControlLevel \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulTimer, \ + tBoolean bInvert))ROM_TIMERTABLE[4]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerControlTrigger \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulTimer, \ + tBoolean bEnable))ROM_TIMERTABLE[5]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerControlEvent \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulTimer, \ + unsigned long ulEvent))ROM_TIMERTABLE[6]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerControlStall \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulTimer, \ + tBoolean bStall))ROM_TIMERTABLE[7]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerRTCEnable \ + ((void (*)(unsigned long ulBase))ROM_TIMERTABLE[8]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerRTCDisable \ + ((void (*)(unsigned long ulBase))ROM_TIMERTABLE[9]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerPrescaleSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulTimer, \ + unsigned long ulValue))ROM_TIMERTABLE[10]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerPrescaleGet \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulTimer))ROM_TIMERTABLE[11]) +#endif +#if defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerPrescaleMatchSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulTimer, \ + unsigned long ulValue))ROM_TIMERTABLE[12]) +#endif +#if defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerPrescaleMatchGet \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulTimer))ROM_TIMERTABLE[13]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerLoadSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulTimer, \ + unsigned long ulValue))ROM_TIMERTABLE[14]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerLoadGet \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulTimer))ROM_TIMERTABLE[15]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerValueGet \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulTimer))ROM_TIMERTABLE[16]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerMatchSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulTimer, \ + unsigned long ulValue))ROM_TIMERTABLE[17]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerMatchGet \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulTimer))ROM_TIMERTABLE[18]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerIntEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_TIMERTABLE[19]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerIntDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_TIMERTABLE[20]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerIntStatus \ + ((unsigned long (*)(unsigned long ulBase, \ + tBoolean bMasked))ROM_TIMERTABLE[21]) +#endif +#if defined(TARGET_IS_TEMPEST_RC3) +#define ROM_TimerControlWaitOnTrigger \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulTimer, \ + tBoolean bWait))ROM_TIMERTABLE[22]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the UART API. +// +//***************************************************************************** +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTCharPut \ + ((void (*)(unsigned long ulBase, \ + unsigned char ucData))ROM_UARTTABLE[0]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTParityModeSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulParity))ROM_UARTTABLE[1]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTParityModeGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_UARTTABLE[2]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTFIFOLevelSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulTxLevel, \ + unsigned long ulRxLevel))ROM_UARTTABLE[3]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTFIFOLevelGet \ + ((void (*)(unsigned long ulBase, \ + unsigned long *pulTxLevel, \ + unsigned long *pulRxLevel))ROM_UARTTABLE[4]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTConfigSetExpClk \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulUARTClk, \ + unsigned long ulBaud, \ + unsigned long ulConfig))ROM_UARTTABLE[5]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTConfigGetExpClk \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulUARTClk, \ + unsigned long *pulBaud, \ + unsigned long *pulConfig))ROM_UARTTABLE[6]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTEnable \ + ((void (*)(unsigned long ulBase))ROM_UARTTABLE[7]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTDisable \ + ((void (*)(unsigned long ulBase))ROM_UARTTABLE[8]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTEnableSIR \ + ((void (*)(unsigned long ulBase, \ + tBoolean bLowPower))ROM_UARTTABLE[9]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTDisableSIR \ + ((void (*)(unsigned long ulBase))ROM_UARTTABLE[10]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTCharsAvail \ + ((tBoolean (*)(unsigned long ulBase))ROM_UARTTABLE[11]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTSpaceAvail \ + ((tBoolean (*)(unsigned long ulBase))ROM_UARTTABLE[12]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTCharGetNonBlocking \ + ((long (*)(unsigned long ulBase))ROM_UARTTABLE[13]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTCharGet \ + ((long (*)(unsigned long ulBase))ROM_UARTTABLE[14]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTCharPutNonBlocking \ + ((tBoolean (*)(unsigned long ulBase, \ + unsigned char ucData))ROM_UARTTABLE[15]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTBreakCtl \ + ((void (*)(unsigned long ulBase, \ + tBoolean bBreakState))ROM_UARTTABLE[16]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTIntEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_UARTTABLE[17]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTIntDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_UARTTABLE[18]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTIntStatus \ + ((unsigned long (*)(unsigned long ulBase, \ + tBoolean bMasked))ROM_UARTTABLE[19]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTIntClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_UARTTABLE[20]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UpdateUART \ + ((void (*)(void))ROM_UARTTABLE[21]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTDMAEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulDMAFlags))ROM_UARTTABLE[22]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTDMADisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulDMAFlags))ROM_UARTTABLE[23]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTFIFOEnable \ + ((void (*)(unsigned long ulBase))ROM_UARTTABLE[24]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTFIFODisable \ + ((void (*)(unsigned long ulBase))ROM_UARTTABLE[25]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTBusy \ + ((tBoolean (*)(unsigned long ulBase))ROM_UARTTABLE[26]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTTxIntModeSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulMode))ROM_UARTTABLE[27]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTTxIntModeGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_UARTTABLE[28]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTRxErrorGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_UARTTABLE[29]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_UARTRxErrorClear \ + ((void (*)(unsigned long ulBase))ROM_UARTTABLE[30]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the uDMA API. +// +//***************************************************************************** +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAChannelTransferSet \ + ((void (*)(unsigned long ulChannelStructIndex, \ + unsigned long ulMode, \ + void *pvSrcAddr, \ + void *pvDstAddr, \ + unsigned long ulTransferSize))ROM_UDMATABLE[0]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAEnable \ + ((void (*)(void))ROM_UDMATABLE[1]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMADisable \ + ((void (*)(void))ROM_UDMATABLE[2]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAErrorStatusGet \ + ((unsigned long (*)(void))ROM_UDMATABLE[3]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAErrorStatusClear \ + ((void (*)(void))ROM_UDMATABLE[4]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAChannelEnable \ + ((void (*)(unsigned long ulChannelNum))ROM_UDMATABLE[5]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAChannelDisable \ + ((void (*)(unsigned long ulChannelNum))ROM_UDMATABLE[6]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAChannelIsEnabled \ + ((tBoolean (*)(unsigned long ulChannelNum))ROM_UDMATABLE[7]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAControlBaseSet \ + ((void (*)(void *pControlTable))ROM_UDMATABLE[8]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAControlBaseGet \ + ((void * (*)(void))ROM_UDMATABLE[9]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAChannelRequest \ + ((void (*)(unsigned long ulChannelNum))ROM_UDMATABLE[10]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAChannelAttributeEnable \ + ((void (*)(unsigned long ulChannelNum, \ + unsigned long ulAttr))ROM_UDMATABLE[11]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAChannelAttributeDisable \ + ((void (*)(unsigned long ulChannelNum, \ + unsigned long ulAttr))ROM_UDMATABLE[12]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAChannelAttributeGet \ + ((unsigned long (*)(unsigned long ulChannelNum))ROM_UDMATABLE[13]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAChannelControlSet \ + ((void (*)(unsigned long ulChannelStructIndex, \ + unsigned long ulControl))ROM_UDMATABLE[14]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAChannelSizeGet \ + ((unsigned long (*)(unsigned long ulChannelStructIndex))ROM_UDMATABLE[15]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAChannelModeGet \ + ((unsigned long (*)(unsigned long ulChannelStructIndex))ROM_UDMATABLE[16]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAChannelSelectSecondary \ + ((void (*)(unsigned long ulSecPeriphs))ROM_UDMATABLE[17]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_uDMAChannelSelectDefault \ + ((void (*)(unsigned long ulDefPeriphs))ROM_UDMATABLE[18]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the USB API. +// +//***************************************************************************** +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBIntStatus \ + ((unsigned long (*)(unsigned long ulBase))ROM_USBTABLE[0]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBDevAddrGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_USBTABLE[1]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBDevAddrSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulAddress))ROM_USBTABLE[2]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBDevConnect \ + ((void (*)(unsigned long ulBase))ROM_USBTABLE[3]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBDevDisconnect \ + ((void (*)(unsigned long ulBase))ROM_USBTABLE[4]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBDevEndpointConfigSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned long ulMaxPacketSize, \ + unsigned long ulFlags))ROM_USBTABLE[5]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBDevEndpointDataAck \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + tBoolean bIsLastPacket))ROM_USBTABLE[6]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBDevEndpointStall \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned long ulFlags))ROM_USBTABLE[7]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBDevEndpointStatusClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned long ulFlags))ROM_USBTABLE[9]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBEndpointDataGet \ + ((long (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned char *pucData, \ + unsigned long *pulSize))ROM_USBTABLE[10]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBEndpointDataPut \ + ((long (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned char *pucData, \ + unsigned long ulSize))ROM_USBTABLE[11]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBEndpointDataSend \ + ((long (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned long ulTransType))ROM_USBTABLE[12]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBEndpointDataToggleClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned long ulFlags))ROM_USBTABLE[13]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBEndpointStatus \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulEndpoint))ROM_USBTABLE[14]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBFIFOAddrGet \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulEndpoint))ROM_USBTABLE[15]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBFIFOConfigGet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned long *pulFIFOAddress, \ + unsigned long *pulFIFOSize, \ + unsigned long ulFlags))ROM_USBTABLE[16]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBFIFOConfigSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned long ulFIFOAddress, \ + unsigned long ulFIFOSize, \ + unsigned long ulFlags))ROM_USBTABLE[17]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBFrameNumberGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_USBTABLE[19]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostAddrGet \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned long ulFlags))ROM_USBTABLE[20]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostAddrSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned long ulAddr, \ + unsigned long ulFlags))ROM_USBTABLE[21]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostEndpointConfig \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned long ulMaxPacketSize, \ + unsigned long ulNAKPollInterval, \ + unsigned long ulTargetEndpoint, \ + unsigned long ulFlags))ROM_USBTABLE[22]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostEndpointDataAck \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint))ROM_USBTABLE[23]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostEndpointDataToggle \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + tBoolean bDataToggle, \ + unsigned long ulFlags))ROM_USBTABLE[24]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostEndpointStatusClear \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned long ulFlags))ROM_USBTABLE[25]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostHubAddrGet \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned long ulFlags))ROM_USBTABLE[26]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostHubAddrSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned long ulAddr, \ + unsigned long ulFlags))ROM_USBTABLE[27]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostPwrDisable \ + ((void (*)(unsigned long ulBase))ROM_USBTABLE[28]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostPwrEnable \ + ((void (*)(unsigned long ulBase))ROM_USBTABLE[29]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostPwrConfig \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulFlags))ROM_USBTABLE[30]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostPwrFaultDisable \ + ((void (*)(unsigned long ulBase))ROM_USBTABLE[31]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostPwrFaultEnable \ + ((void (*)(unsigned long ulBase))ROM_USBTABLE[32]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostRequestIN \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint))ROM_USBTABLE[33]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostRequestStatus \ + ((void (*)(unsigned long ulBase))ROM_USBTABLE[34]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostReset \ + ((void (*)(unsigned long ulBase, \ + tBoolean bStart))ROM_USBTABLE[35]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostResume \ + ((void (*)(unsigned long ulBase, \ + tBoolean bStart))ROM_USBTABLE[36]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostSpeedGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_USBTABLE[37]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBHostSuspend \ + ((void (*)(unsigned long ulBase))ROM_USBTABLE[38]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBIntDisable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_USBTABLE[39]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBIntEnable \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_USBTABLE[40]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBDevEndpointConfigGet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned long *pulMaxPacketSize, \ + unsigned long *pulFlags))ROM_USBTABLE[41]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBEndpointDataAvail \ + ((unsigned long (*)(unsigned long ulBase, \ + unsigned long ulEndpoint))ROM_USBTABLE[44]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBOTGHostRequest \ + ((void (*)(unsigned long ulBase, \ + tBoolean bHNP))ROM_USBTABLE[45]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBModeGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_USBTABLE[46]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBEndpointDMAChannel \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulEndpoint, \ + unsigned long ulChannel))ROM_USBTABLE[47]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBIntDisableControl \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_USBTABLE[48]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBIntEnableControl \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_USBTABLE[49]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBIntStatusControl \ + ((unsigned long (*)(unsigned long ulBase))ROM_USBTABLE[50]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBIntDisableEndpoint \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_USBTABLE[51]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBIntEnableEndpoint \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulIntFlags))ROM_USBTABLE[52]) +#endif +#if defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_USBIntStatusEndpoint \ + ((unsigned long (*)(unsigned long ulBase))ROM_USBTABLE[53]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the Watchdog API. +// +//***************************************************************************** +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_WatchdogIntClear \ + ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[0]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_WatchdogRunning \ + ((tBoolean (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[1]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_WatchdogEnable \ + ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[2]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_WatchdogResetEnable \ + ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[3]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_WatchdogResetDisable \ + ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[4]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_WatchdogLock \ + ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[5]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_WatchdogUnlock \ + ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[6]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_WatchdogLockState \ + ((tBoolean (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[7]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_WatchdogReloadSet \ + ((void (*)(unsigned long ulBase, \ + unsigned long ulLoadVal))ROM_WATCHDOGTABLE[8]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_WatchdogReloadGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[9]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_WatchdogValueGet \ + ((unsigned long (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[10]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_WatchdogIntEnable \ + ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[11]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_WatchdogIntStatus \ + ((unsigned long (*)(unsigned long ulBase, \ + tBoolean bMasked))ROM_WATCHDOGTABLE[12]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_WatchdogStallEnable \ + ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[13]) +#endif +#if defined(TARGET_IS_DUSTDEVIL_RA0) || \ + defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_WatchdogStallDisable \ + ((void (*)(unsigned long ulBase))ROM_WATCHDOGTABLE[14]) +#endif + +//***************************************************************************** +// +// Macros for calling ROM functions in the Software API. +// +//***************************************************************************** +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_Crc16Array \ + ((unsigned short (*)(unsigned long ulWordLen, \ + const unsigned long *pulData))ROM_SOFTWARETABLE[1]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_Crc16Array3 \ + ((void (*)(unsigned long ulWordLen, \ + const unsigned long *pulData, \ + unsigned short *pusCrc3))ROM_SOFTWARETABLE[2]) +#endif +#if defined(TARGET_IS_TEMPEST_RB1) || \ + defined(TARGET_IS_TEMPEST_RC1) || \ + defined(TARGET_IS_TEMPEST_RC3) +#define ROM_pvAESTable \ + ((void *)&(ROM_SOFTWARETABLE[7])) +#endif + +//***************************************************************************** +// +// Deprecated ROM functions. +// +//***************************************************************************** +#ifndef DEPRECATED +#ifdef ROM_FlashIntStatus +#define ROM_FlashIntGetStatus \ + ROM_FlashIntStatus +#endif +#ifdef ROM_USBDevEndpointConfigSet +#define ROM_USBDevEndpointConfig \ + ROM_USBDevEndpointConfigSet +#endif +#ifdef ROM_USBHostPwrConfig +#define ROM_USBHostPwrFaultConfig \ + ROM_USBHostPwrConfig +#endif +#endif + +#endif // __ROM_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/rom_map.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/rom_map.h new file mode 100644 index 00000000..cc6682f3 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/rom_map.h @@ -0,0 +1,3444 @@ +//***************************************************************************** +// +// rom_map.h - Macros to facilitate calling functions in the ROM when they are +// available and in flash otherwise. +// +// Copyright (c) 2008-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __ROM_MAP_H__ +#define __ROM_MAP_H__ + +//***************************************************************************** +// +// Macros for the ADC API. +// +//***************************************************************************** +#ifdef ROM_ADCSequenceDataGet +#define MAP_ADCSequenceDataGet \ + ROM_ADCSequenceDataGet +#else +#define MAP_ADCSequenceDataGet \ + ADCSequenceDataGet +#endif +#ifdef ROM_ADCIntDisable +#define MAP_ADCIntDisable \ + ROM_ADCIntDisable +#else +#define MAP_ADCIntDisable \ + ADCIntDisable +#endif +#ifdef ROM_ADCIntEnable +#define MAP_ADCIntEnable \ + ROM_ADCIntEnable +#else +#define MAP_ADCIntEnable \ + ADCIntEnable +#endif +#ifdef ROM_ADCIntStatus +#define MAP_ADCIntStatus \ + ROM_ADCIntStatus +#else +#define MAP_ADCIntStatus \ + ADCIntStatus +#endif +#ifdef ROM_ADCIntClear +#define MAP_ADCIntClear \ + ROM_ADCIntClear +#else +#define MAP_ADCIntClear \ + ADCIntClear +#endif +#ifdef ROM_ADCSequenceEnable +#define MAP_ADCSequenceEnable \ + ROM_ADCSequenceEnable +#else +#define MAP_ADCSequenceEnable \ + ADCSequenceEnable +#endif +#ifdef ROM_ADCSequenceDisable +#define MAP_ADCSequenceDisable \ + ROM_ADCSequenceDisable +#else +#define MAP_ADCSequenceDisable \ + ADCSequenceDisable +#endif +#ifdef ROM_ADCSequenceConfigure +#define MAP_ADCSequenceConfigure \ + ROM_ADCSequenceConfigure +#else +#define MAP_ADCSequenceConfigure \ + ADCSequenceConfigure +#endif +#ifdef ROM_ADCSequenceStepConfigure +#define MAP_ADCSequenceStepConfigure \ + ROM_ADCSequenceStepConfigure +#else +#define MAP_ADCSequenceStepConfigure \ + ADCSequenceStepConfigure +#endif +#ifdef ROM_ADCSequenceOverflow +#define MAP_ADCSequenceOverflow \ + ROM_ADCSequenceOverflow +#else +#define MAP_ADCSequenceOverflow \ + ADCSequenceOverflow +#endif +#ifdef ROM_ADCSequenceOverflowClear +#define MAP_ADCSequenceOverflowClear \ + ROM_ADCSequenceOverflowClear +#else +#define MAP_ADCSequenceOverflowClear \ + ADCSequenceOverflowClear +#endif +#ifdef ROM_ADCSequenceUnderflow +#define MAP_ADCSequenceUnderflow \ + ROM_ADCSequenceUnderflow +#else +#define MAP_ADCSequenceUnderflow \ + ADCSequenceUnderflow +#endif +#ifdef ROM_ADCSequenceUnderflowClear +#define MAP_ADCSequenceUnderflowClear \ + ROM_ADCSequenceUnderflowClear +#else +#define MAP_ADCSequenceUnderflowClear \ + ADCSequenceUnderflowClear +#endif +#ifdef ROM_ADCProcessorTrigger +#define MAP_ADCProcessorTrigger \ + ROM_ADCProcessorTrigger +#else +#define MAP_ADCProcessorTrigger \ + ADCProcessorTrigger +#endif +#ifdef ROM_ADCHardwareOversampleConfigure +#define MAP_ADCHardwareOversampleConfigure \ + ROM_ADCHardwareOversampleConfigure +#else +#define MAP_ADCHardwareOversampleConfigure \ + ADCHardwareOversampleConfigure +#endif +#ifdef ROM_ADCComparatorConfigure +#define MAP_ADCComparatorConfigure \ + ROM_ADCComparatorConfigure +#else +#define MAP_ADCComparatorConfigure \ + ADCComparatorConfigure +#endif +#ifdef ROM_ADCComparatorRegionSet +#define MAP_ADCComparatorRegionSet \ + ROM_ADCComparatorRegionSet +#else +#define MAP_ADCComparatorRegionSet \ + ADCComparatorRegionSet +#endif +#ifdef ROM_ADCComparatorReset +#define MAP_ADCComparatorReset \ + ROM_ADCComparatorReset +#else +#define MAP_ADCComparatorReset \ + ADCComparatorReset +#endif +#ifdef ROM_ADCComparatorIntDisable +#define MAP_ADCComparatorIntDisable \ + ROM_ADCComparatorIntDisable +#else +#define MAP_ADCComparatorIntDisable \ + ADCComparatorIntDisable +#endif +#ifdef ROM_ADCComparatorIntEnable +#define MAP_ADCComparatorIntEnable \ + ROM_ADCComparatorIntEnable +#else +#define MAP_ADCComparatorIntEnable \ + ADCComparatorIntEnable +#endif +#ifdef ROM_ADCComparatorIntStatus +#define MAP_ADCComparatorIntStatus \ + ROM_ADCComparatorIntStatus +#else +#define MAP_ADCComparatorIntStatus \ + ADCComparatorIntStatus +#endif +#ifdef ROM_ADCComparatorIntClear +#define MAP_ADCComparatorIntClear \ + ROM_ADCComparatorIntClear +#else +#define MAP_ADCComparatorIntClear \ + ADCComparatorIntClear +#endif +#ifdef ROM_ADCReferenceSet +#define MAP_ADCReferenceSet \ + ROM_ADCReferenceSet +#else +#define MAP_ADCReferenceSet \ + ADCReferenceSet +#endif +#ifdef ROM_ADCReferenceGet +#define MAP_ADCReferenceGet \ + ROM_ADCReferenceGet +#else +#define MAP_ADCReferenceGet \ + ADCReferenceGet +#endif +#ifdef ROM_ADCPhaseDelaySet +#define MAP_ADCPhaseDelaySet \ + ROM_ADCPhaseDelaySet +#else +#define MAP_ADCPhaseDelaySet \ + ADCPhaseDelaySet +#endif +#ifdef ROM_ADCPhaseDelayGet +#define MAP_ADCPhaseDelayGet \ + ROM_ADCPhaseDelayGet +#else +#define MAP_ADCPhaseDelayGet \ + ADCPhaseDelayGet +#endif + +//***************************************************************************** +// +// Macros for the CAN API. +// +//***************************************************************************** +#ifdef ROM_CANIntClear +#define MAP_CANIntClear \ + ROM_CANIntClear +#else +#define MAP_CANIntClear \ + CANIntClear +#endif +#ifdef ROM_CANInit +#define MAP_CANInit \ + ROM_CANInit +#else +#define MAP_CANInit \ + CANInit +#endif +#ifdef ROM_CANEnable +#define MAP_CANEnable \ + ROM_CANEnable +#else +#define MAP_CANEnable \ + CANEnable +#endif +#ifdef ROM_CANDisable +#define MAP_CANDisable \ + ROM_CANDisable +#else +#define MAP_CANDisable \ + CANDisable +#endif +#ifdef ROM_CANBitTimingSet +#define MAP_CANBitTimingSet \ + ROM_CANBitTimingSet +#else +#define MAP_CANBitTimingSet \ + CANBitTimingSet +#endif +#ifdef ROM_CANBitTimingGet +#define MAP_CANBitTimingGet \ + ROM_CANBitTimingGet +#else +#define MAP_CANBitTimingGet \ + CANBitTimingGet +#endif +#ifdef ROM_CANMessageSet +#define MAP_CANMessageSet \ + ROM_CANMessageSet +#else +#define MAP_CANMessageSet \ + CANMessageSet +#endif +#ifdef ROM_CANMessageGet +#define MAP_CANMessageGet \ + ROM_CANMessageGet +#else +#define MAP_CANMessageGet \ + CANMessageGet +#endif +#ifdef ROM_CANStatusGet +#define MAP_CANStatusGet \ + ROM_CANStatusGet +#else +#define MAP_CANStatusGet \ + CANStatusGet +#endif +#ifdef ROM_CANMessageClear +#define MAP_CANMessageClear \ + ROM_CANMessageClear +#else +#define MAP_CANMessageClear \ + CANMessageClear +#endif +#ifdef ROM_CANIntEnable +#define MAP_CANIntEnable \ + ROM_CANIntEnable +#else +#define MAP_CANIntEnable \ + CANIntEnable +#endif +#ifdef ROM_CANIntDisable +#define MAP_CANIntDisable \ + ROM_CANIntDisable +#else +#define MAP_CANIntDisable \ + CANIntDisable +#endif +#ifdef ROM_CANIntStatus +#define MAP_CANIntStatus \ + ROM_CANIntStatus +#else +#define MAP_CANIntStatus \ + CANIntStatus +#endif +#ifdef ROM_CANRetryGet +#define MAP_CANRetryGet \ + ROM_CANRetryGet +#else +#define MAP_CANRetryGet \ + CANRetryGet +#endif +#ifdef ROM_CANRetrySet +#define MAP_CANRetrySet \ + ROM_CANRetrySet +#else +#define MAP_CANRetrySet \ + CANRetrySet +#endif +#ifdef ROM_CANErrCntrGet +#define MAP_CANErrCntrGet \ + ROM_CANErrCntrGet +#else +#define MAP_CANErrCntrGet \ + CANErrCntrGet +#endif +#ifdef ROM_CANBitRateSet +#define MAP_CANBitRateSet \ + ROM_CANBitRateSet +#else +#define MAP_CANBitRateSet \ + CANBitRateSet +#endif + +//***************************************************************************** +// +// Macros for the Comparator API. +// +//***************************************************************************** +#ifdef ROM_ComparatorIntClear +#define MAP_ComparatorIntClear \ + ROM_ComparatorIntClear +#else +#define MAP_ComparatorIntClear \ + ComparatorIntClear +#endif +#ifdef ROM_ComparatorConfigure +#define MAP_ComparatorConfigure \ + ROM_ComparatorConfigure +#else +#define MAP_ComparatorConfigure \ + ComparatorConfigure +#endif +#ifdef ROM_ComparatorRefSet +#define MAP_ComparatorRefSet \ + ROM_ComparatorRefSet +#else +#define MAP_ComparatorRefSet \ + ComparatorRefSet +#endif +#ifdef ROM_ComparatorValueGet +#define MAP_ComparatorValueGet \ + ROM_ComparatorValueGet +#else +#define MAP_ComparatorValueGet \ + ComparatorValueGet +#endif +#ifdef ROM_ComparatorIntEnable +#define MAP_ComparatorIntEnable \ + ROM_ComparatorIntEnable +#else +#define MAP_ComparatorIntEnable \ + ComparatorIntEnable +#endif +#ifdef ROM_ComparatorIntDisable +#define MAP_ComparatorIntDisable \ + ROM_ComparatorIntDisable +#else +#define MAP_ComparatorIntDisable \ + ComparatorIntDisable +#endif +#ifdef ROM_ComparatorIntStatus +#define MAP_ComparatorIntStatus \ + ROM_ComparatorIntStatus +#else +#define MAP_ComparatorIntStatus \ + ComparatorIntStatus +#endif + +//***************************************************************************** +// +// Macros for the Ethernet API. +// +//***************************************************************************** +#ifdef ROM_EPIIntStatus +#define MAP_EPIIntStatus \ + ROM_EPIIntStatus +#else +#define MAP_EPIIntStatus \ + EPIIntStatus +#endif +#ifdef ROM_EPIModeSet +#define MAP_EPIModeSet \ + ROM_EPIModeSet +#else +#define MAP_EPIModeSet \ + EPIModeSet +#endif +#ifdef ROM_EPIDividerSet +#define MAP_EPIDividerSet \ + ROM_EPIDividerSet +#else +#define MAP_EPIDividerSet \ + EPIDividerSet +#endif +#ifdef ROM_EPIConfigSDRAMSet +#define MAP_EPIConfigSDRAMSet \ + ROM_EPIConfigSDRAMSet +#else +#define MAP_EPIConfigSDRAMSet \ + EPIConfigSDRAMSet +#endif +#ifdef ROM_EPIConfigGPModeSet +#define MAP_EPIConfigGPModeSet \ + ROM_EPIConfigGPModeSet +#else +#define MAP_EPIConfigGPModeSet \ + EPIConfigGPModeSet +#endif +#ifdef ROM_EPIConfigHB8Set +#define MAP_EPIConfigHB8Set \ + ROM_EPIConfigHB8Set +#else +#define MAP_EPIConfigHB8Set \ + EPIConfigHB8Set +#endif +#ifdef ROM_EPIConfigHB16Set +#define MAP_EPIConfigHB16Set \ + ROM_EPIConfigHB16Set +#else +#define MAP_EPIConfigHB16Set \ + EPIConfigHB16Set +#endif +#ifdef ROM_EPIAddressMapSet +#define MAP_EPIAddressMapSet \ + ROM_EPIAddressMapSet +#else +#define MAP_EPIAddressMapSet \ + EPIAddressMapSet +#endif +#ifdef ROM_EPINonBlockingReadConfigure +#define MAP_EPINonBlockingReadConfigure \ + ROM_EPINonBlockingReadConfigure +#else +#define MAP_EPINonBlockingReadConfigure \ + EPINonBlockingReadConfigure +#endif +#ifdef ROM_EPINonBlockingReadStart +#define MAP_EPINonBlockingReadStart \ + ROM_EPINonBlockingReadStart +#else +#define MAP_EPINonBlockingReadStart \ + EPINonBlockingReadStart +#endif +#ifdef ROM_EPINonBlockingReadStop +#define MAP_EPINonBlockingReadStop \ + ROM_EPINonBlockingReadStop +#else +#define MAP_EPINonBlockingReadStop \ + EPINonBlockingReadStop +#endif +#ifdef ROM_EPINonBlockingReadCount +#define MAP_EPINonBlockingReadCount \ + ROM_EPINonBlockingReadCount +#else +#define MAP_EPINonBlockingReadCount \ + EPINonBlockingReadCount +#endif +#ifdef ROM_EPINonBlockingReadAvail +#define MAP_EPINonBlockingReadAvail \ + ROM_EPINonBlockingReadAvail +#else +#define MAP_EPINonBlockingReadAvail \ + EPINonBlockingReadAvail +#endif +#ifdef ROM_EPINonBlockingReadGet32 +#define MAP_EPINonBlockingReadGet32 \ + ROM_EPINonBlockingReadGet32 +#else +#define MAP_EPINonBlockingReadGet32 \ + EPINonBlockingReadGet32 +#endif +#ifdef ROM_EPINonBlockingReadGet16 +#define MAP_EPINonBlockingReadGet16 \ + ROM_EPINonBlockingReadGet16 +#else +#define MAP_EPINonBlockingReadGet16 \ + EPINonBlockingReadGet16 +#endif +#ifdef ROM_EPINonBlockingReadGet8 +#define MAP_EPINonBlockingReadGet8 \ + ROM_EPINonBlockingReadGet8 +#else +#define MAP_EPINonBlockingReadGet8 \ + EPINonBlockingReadGet8 +#endif +#ifdef ROM_EPIFIFOConfig +#define MAP_EPIFIFOConfig \ + ROM_EPIFIFOConfig +#else +#define MAP_EPIFIFOConfig \ + EPIFIFOConfig +#endif +#ifdef ROM_EPIWriteFIFOCountGet +#define MAP_EPIWriteFIFOCountGet \ + ROM_EPIWriteFIFOCountGet +#else +#define MAP_EPIWriteFIFOCountGet \ + EPIWriteFIFOCountGet +#endif +#ifdef ROM_EPIIntEnable +#define MAP_EPIIntEnable \ + ROM_EPIIntEnable +#else +#define MAP_EPIIntEnable \ + EPIIntEnable +#endif +#ifdef ROM_EPIIntDisable +#define MAP_EPIIntDisable \ + ROM_EPIIntDisable +#else +#define MAP_EPIIntDisable \ + EPIIntDisable +#endif +#ifdef ROM_EPIIntErrorStatus +#define MAP_EPIIntErrorStatus \ + ROM_EPIIntErrorStatus +#else +#define MAP_EPIIntErrorStatus \ + EPIIntErrorStatus +#endif +#ifdef ROM_EPIIntErrorClear +#define MAP_EPIIntErrorClear \ + ROM_EPIIntErrorClear +#else +#define MAP_EPIIntErrorClear \ + EPIIntErrorClear +#endif + +//***************************************************************************** +// +// Macros for the Ethernet API. +// +//***************************************************************************** +#ifdef ROM_EthernetIntClear +#define MAP_EthernetIntClear \ + ROM_EthernetIntClear +#else +#define MAP_EthernetIntClear \ + EthernetIntClear +#endif +#ifdef ROM_EthernetInitExpClk +#define MAP_EthernetInitExpClk \ + ROM_EthernetInitExpClk +#else +#define MAP_EthernetInitExpClk \ + EthernetInitExpClk +#endif +#ifdef ROM_EthernetConfigSet +#define MAP_EthernetConfigSet \ + ROM_EthernetConfigSet +#else +#define MAP_EthernetConfigSet \ + EthernetConfigSet +#endif +#ifdef ROM_EthernetConfigGet +#define MAP_EthernetConfigGet \ + ROM_EthernetConfigGet +#else +#define MAP_EthernetConfigGet \ + EthernetConfigGet +#endif +#ifdef ROM_EthernetMACAddrSet +#define MAP_EthernetMACAddrSet \ + ROM_EthernetMACAddrSet +#else +#define MAP_EthernetMACAddrSet \ + EthernetMACAddrSet +#endif +#ifdef ROM_EthernetMACAddrGet +#define MAP_EthernetMACAddrGet \ + ROM_EthernetMACAddrGet +#else +#define MAP_EthernetMACAddrGet \ + EthernetMACAddrGet +#endif +#ifdef ROM_EthernetEnable +#define MAP_EthernetEnable \ + ROM_EthernetEnable +#else +#define MAP_EthernetEnable \ + EthernetEnable +#endif +#ifdef ROM_EthernetDisable +#define MAP_EthernetDisable \ + ROM_EthernetDisable +#else +#define MAP_EthernetDisable \ + EthernetDisable +#endif +#ifdef ROM_EthernetPacketAvail +#define MAP_EthernetPacketAvail \ + ROM_EthernetPacketAvail +#else +#define MAP_EthernetPacketAvail \ + EthernetPacketAvail +#endif +#ifdef ROM_EthernetSpaceAvail +#define MAP_EthernetSpaceAvail \ + ROM_EthernetSpaceAvail +#else +#define MAP_EthernetSpaceAvail \ + EthernetSpaceAvail +#endif +#ifdef ROM_EthernetPacketGetNonBlocking +#define MAP_EthernetPacketGetNonBlocking \ + ROM_EthernetPacketGetNonBlocking +#else +#define MAP_EthernetPacketGetNonBlocking \ + EthernetPacketGetNonBlocking +#endif +#ifdef ROM_EthernetPacketGet +#define MAP_EthernetPacketGet \ + ROM_EthernetPacketGet +#else +#define MAP_EthernetPacketGet \ + EthernetPacketGet +#endif +#ifdef ROM_EthernetPacketPutNonBlocking +#define MAP_EthernetPacketPutNonBlocking \ + ROM_EthernetPacketPutNonBlocking +#else +#define MAP_EthernetPacketPutNonBlocking \ + EthernetPacketPutNonBlocking +#endif +#ifdef ROM_EthernetPacketPut +#define MAP_EthernetPacketPut \ + ROM_EthernetPacketPut +#else +#define MAP_EthernetPacketPut \ + EthernetPacketPut +#endif +#ifdef ROM_EthernetIntEnable +#define MAP_EthernetIntEnable \ + ROM_EthernetIntEnable +#else +#define MAP_EthernetIntEnable \ + EthernetIntEnable +#endif +#ifdef ROM_EthernetIntDisable +#define MAP_EthernetIntDisable \ + ROM_EthernetIntDisable +#else +#define MAP_EthernetIntDisable \ + EthernetIntDisable +#endif +#ifdef ROM_EthernetIntStatus +#define MAP_EthernetIntStatus \ + ROM_EthernetIntStatus +#else +#define MAP_EthernetIntStatus \ + EthernetIntStatus +#endif +#ifdef ROM_EthernetPHYWrite +#define MAP_EthernetPHYWrite \ + ROM_EthernetPHYWrite +#else +#define MAP_EthernetPHYWrite \ + EthernetPHYWrite +#endif +#ifdef ROM_EthernetPHYRead +#define MAP_EthernetPHYRead \ + ROM_EthernetPHYRead +#else +#define MAP_EthernetPHYRead \ + EthernetPHYRead +#endif + +//***************************************************************************** +// +// Macros for the Flash API. +// +//***************************************************************************** +#ifdef ROM_FlashProgram +#define MAP_FlashProgram \ + ROM_FlashProgram +#else +#define MAP_FlashProgram \ + FlashProgram +#endif +#ifdef ROM_FlashUsecGet +#define MAP_FlashUsecGet \ + ROM_FlashUsecGet +#else +#define MAP_FlashUsecGet \ + FlashUsecGet +#endif +#ifdef ROM_FlashUsecSet +#define MAP_FlashUsecSet \ + ROM_FlashUsecSet +#else +#define MAP_FlashUsecSet \ + FlashUsecSet +#endif +#ifdef ROM_FlashErase +#define MAP_FlashErase \ + ROM_FlashErase +#else +#define MAP_FlashErase \ + FlashErase +#endif +#ifdef ROM_FlashProtectGet +#define MAP_FlashProtectGet \ + ROM_FlashProtectGet +#else +#define MAP_FlashProtectGet \ + FlashProtectGet +#endif +#ifdef ROM_FlashProtectSet +#define MAP_FlashProtectSet \ + ROM_FlashProtectSet +#else +#define MAP_FlashProtectSet \ + FlashProtectSet +#endif +#ifdef ROM_FlashProtectSave +#define MAP_FlashProtectSave \ + ROM_FlashProtectSave +#else +#define MAP_FlashProtectSave \ + FlashProtectSave +#endif +#ifdef ROM_FlashUserGet +#define MAP_FlashUserGet \ + ROM_FlashUserGet +#else +#define MAP_FlashUserGet \ + FlashUserGet +#endif +#ifdef ROM_FlashUserSet +#define MAP_FlashUserSet \ + ROM_FlashUserSet +#else +#define MAP_FlashUserSet \ + FlashUserSet +#endif +#ifdef ROM_FlashUserSave +#define MAP_FlashUserSave \ + ROM_FlashUserSave +#else +#define MAP_FlashUserSave \ + FlashUserSave +#endif +#ifdef ROM_FlashIntEnable +#define MAP_FlashIntEnable \ + ROM_FlashIntEnable +#else +#define MAP_FlashIntEnable \ + FlashIntEnable +#endif +#ifdef ROM_FlashIntDisable +#define MAP_FlashIntDisable \ + ROM_FlashIntDisable +#else +#define MAP_FlashIntDisable \ + FlashIntDisable +#endif +#ifdef ROM_FlashIntStatus +#define MAP_FlashIntStatus \ + ROM_FlashIntStatus +#else +#define MAP_FlashIntStatus \ + FlashIntStatus +#endif +#ifdef ROM_FlashIntClear +#define MAP_FlashIntClear \ + ROM_FlashIntClear +#else +#define MAP_FlashIntClear \ + FlashIntClear +#endif + +//***************************************************************************** +// +// Macros for the GPIO API. +// +//***************************************************************************** +#ifdef ROM_GPIOPinWrite +#define MAP_GPIOPinWrite \ + ROM_GPIOPinWrite +#else +#define MAP_GPIOPinWrite \ + GPIOPinWrite +#endif +#ifdef ROM_GPIODirModeSet +#define MAP_GPIODirModeSet \ + ROM_GPIODirModeSet +#else +#define MAP_GPIODirModeSet \ + GPIODirModeSet +#endif +#ifdef ROM_GPIODirModeGet +#define MAP_GPIODirModeGet \ + ROM_GPIODirModeGet +#else +#define MAP_GPIODirModeGet \ + GPIODirModeGet +#endif +#ifdef ROM_GPIOIntTypeSet +#define MAP_GPIOIntTypeSet \ + ROM_GPIOIntTypeSet +#else +#define MAP_GPIOIntTypeSet \ + GPIOIntTypeSet +#endif +#ifdef ROM_GPIOIntTypeGet +#define MAP_GPIOIntTypeGet \ + ROM_GPIOIntTypeGet +#else +#define MAP_GPIOIntTypeGet \ + GPIOIntTypeGet +#endif +#ifdef ROM_GPIOPadConfigSet +#define MAP_GPIOPadConfigSet \ + ROM_GPIOPadConfigSet +#else +#define MAP_GPIOPadConfigSet \ + GPIOPadConfigSet +#endif +#ifdef ROM_GPIOPadConfigGet +#define MAP_GPIOPadConfigGet \ + ROM_GPIOPadConfigGet +#else +#define MAP_GPIOPadConfigGet \ + GPIOPadConfigGet +#endif +#ifdef ROM_GPIOPinIntEnable +#define MAP_GPIOPinIntEnable \ + ROM_GPIOPinIntEnable +#else +#define MAP_GPIOPinIntEnable \ + GPIOPinIntEnable +#endif +#ifdef ROM_GPIOPinIntDisable +#define MAP_GPIOPinIntDisable \ + ROM_GPIOPinIntDisable +#else +#define MAP_GPIOPinIntDisable \ + GPIOPinIntDisable +#endif +#ifdef ROM_GPIOPinIntStatus +#define MAP_GPIOPinIntStatus \ + ROM_GPIOPinIntStatus +#else +#define MAP_GPIOPinIntStatus \ + GPIOPinIntStatus +#endif +#ifdef ROM_GPIOPinIntClear +#define MAP_GPIOPinIntClear \ + ROM_GPIOPinIntClear +#else +#define MAP_GPIOPinIntClear \ + GPIOPinIntClear +#endif +#ifdef ROM_GPIOPinRead +#define MAP_GPIOPinRead \ + ROM_GPIOPinRead +#else +#define MAP_GPIOPinRead \ + GPIOPinRead +#endif +#ifdef ROM_GPIOPinTypeCAN +#define MAP_GPIOPinTypeCAN \ + ROM_GPIOPinTypeCAN +#else +#define MAP_GPIOPinTypeCAN \ + GPIOPinTypeCAN +#endif +#ifdef ROM_GPIOPinTypeComparator +#define MAP_GPIOPinTypeComparator \ + ROM_GPIOPinTypeComparator +#else +#define MAP_GPIOPinTypeComparator \ + GPIOPinTypeComparator +#endif +#ifdef ROM_GPIOPinTypeGPIOInput +#define MAP_GPIOPinTypeGPIOInput \ + ROM_GPIOPinTypeGPIOInput +#else +#define MAP_GPIOPinTypeGPIOInput \ + GPIOPinTypeGPIOInput +#endif +#ifdef ROM_GPIOPinTypeGPIOOutput +#define MAP_GPIOPinTypeGPIOOutput \ + ROM_GPIOPinTypeGPIOOutput +#else +#define MAP_GPIOPinTypeGPIOOutput \ + GPIOPinTypeGPIOOutput +#endif +#ifdef ROM_GPIOPinTypeI2C +#define MAP_GPIOPinTypeI2C \ + ROM_GPIOPinTypeI2C +#else +#define MAP_GPIOPinTypeI2C \ + GPIOPinTypeI2C +#endif +#ifdef ROM_GPIOPinTypePWM +#define MAP_GPIOPinTypePWM \ + ROM_GPIOPinTypePWM +#else +#define MAP_GPIOPinTypePWM \ + GPIOPinTypePWM +#endif +#ifdef ROM_GPIOPinTypeQEI +#define MAP_GPIOPinTypeQEI \ + ROM_GPIOPinTypeQEI +#else +#define MAP_GPIOPinTypeQEI \ + GPIOPinTypeQEI +#endif +#ifdef ROM_GPIOPinTypeSSI +#define MAP_GPIOPinTypeSSI \ + ROM_GPIOPinTypeSSI +#else +#define MAP_GPIOPinTypeSSI \ + GPIOPinTypeSSI +#endif +#ifdef ROM_GPIOPinTypeTimer +#define MAP_GPIOPinTypeTimer \ + ROM_GPIOPinTypeTimer +#else +#define MAP_GPIOPinTypeTimer \ + GPIOPinTypeTimer +#endif +#ifdef ROM_GPIOPinTypeUART +#define MAP_GPIOPinTypeUART \ + ROM_GPIOPinTypeUART +#else +#define MAP_GPIOPinTypeUART \ + GPIOPinTypeUART +#endif +#ifdef ROM_GPIOPinTypeGPIOOutputOD +#define MAP_GPIOPinTypeGPIOOutputOD \ + ROM_GPIOPinTypeGPIOOutputOD +#else +#define MAP_GPIOPinTypeGPIOOutputOD \ + GPIOPinTypeGPIOOutputOD +#endif +#ifdef ROM_GPIOPinTypeADC +#define MAP_GPIOPinTypeADC \ + ROM_GPIOPinTypeADC +#else +#define MAP_GPIOPinTypeADC \ + GPIOPinTypeADC +#endif +#ifdef ROM_GPIOPinTypeUSBDigital +#define MAP_GPIOPinTypeUSBDigital \ + ROM_GPIOPinTypeUSBDigital +#else +#define MAP_GPIOPinTypeUSBDigital \ + GPIOPinTypeUSBDigital +#endif +#ifdef ROM_GPIOPinTypeI2S +#define MAP_GPIOPinTypeI2S \ + ROM_GPIOPinTypeI2S +#else +#define MAP_GPIOPinTypeI2S \ + GPIOPinTypeI2S +#endif +#ifdef ROM_GPIOPinConfigure +#define MAP_GPIOPinConfigure \ + ROM_GPIOPinConfigure +#else +#define MAP_GPIOPinConfigure \ + GPIOPinConfigure +#endif +#ifdef ROM_GPIOPinTypeEthernetLED +#define MAP_GPIOPinTypeEthernetLED \ + ROM_GPIOPinTypeEthernetLED +#else +#define MAP_GPIOPinTypeEthernetLED \ + GPIOPinTypeEthernetLED +#endif +#ifdef ROM_GPIOPinTypeUSBAnalog +#define MAP_GPIOPinTypeUSBAnalog \ + ROM_GPIOPinTypeUSBAnalog +#else +#define MAP_GPIOPinTypeUSBAnalog \ + GPIOPinTypeUSBAnalog +#endif +#ifdef ROM_GPIOPinTypeEPI +#define MAP_GPIOPinTypeEPI \ + ROM_GPIOPinTypeEPI +#else +#define MAP_GPIOPinTypeEPI \ + GPIOPinTypeEPI +#endif +#ifdef ROM_GPIOPinTypeEthernetMII +#define MAP_GPIOPinTypeEthernetMII \ + ROM_GPIOPinTypeEthernetMII +#else +#define MAP_GPIOPinTypeEthernetMII \ + GPIOPinTypeEthernetMII +#endif + +//***************************************************************************** +// +// Macros for the Hibernate API. +// +//***************************************************************************** +#ifdef ROM_HibernateIntClear +#define MAP_HibernateIntClear \ + ROM_HibernateIntClear +#else +#define MAP_HibernateIntClear \ + HibernateIntClear +#endif +#ifdef ROM_HibernateEnableExpClk +#define MAP_HibernateEnableExpClk \ + ROM_HibernateEnableExpClk +#else +#define MAP_HibernateEnableExpClk \ + HibernateEnableExpClk +#endif +#ifdef ROM_HibernateDisable +#define MAP_HibernateDisable \ + ROM_HibernateDisable +#else +#define MAP_HibernateDisable \ + HibernateDisable +#endif +#ifdef ROM_HibernateClockSelect +#define MAP_HibernateClockSelect \ + ROM_HibernateClockSelect +#else +#define MAP_HibernateClockSelect \ + HibernateClockSelect +#endif +#ifdef ROM_HibernateRTCEnable +#define MAP_HibernateRTCEnable \ + ROM_HibernateRTCEnable +#else +#define MAP_HibernateRTCEnable \ + HibernateRTCEnable +#endif +#ifdef ROM_HibernateRTCDisable +#define MAP_HibernateRTCDisable \ + ROM_HibernateRTCDisable +#else +#define MAP_HibernateRTCDisable \ + HibernateRTCDisable +#endif +#ifdef ROM_HibernateWakeSet +#define MAP_HibernateWakeSet \ + ROM_HibernateWakeSet +#else +#define MAP_HibernateWakeSet \ + HibernateWakeSet +#endif +#ifdef ROM_HibernateWakeGet +#define MAP_HibernateWakeGet \ + ROM_HibernateWakeGet +#else +#define MAP_HibernateWakeGet \ + HibernateWakeGet +#endif +#ifdef ROM_HibernateLowBatSet +#define MAP_HibernateLowBatSet \ + ROM_HibernateLowBatSet +#else +#define MAP_HibernateLowBatSet \ + HibernateLowBatSet +#endif +#ifdef ROM_HibernateLowBatGet +#define MAP_HibernateLowBatGet \ + ROM_HibernateLowBatGet +#else +#define MAP_HibernateLowBatGet \ + HibernateLowBatGet +#endif +#ifdef ROM_HibernateRTCSet +#define MAP_HibernateRTCSet \ + ROM_HibernateRTCSet +#else +#define MAP_HibernateRTCSet \ + HibernateRTCSet +#endif +#ifdef ROM_HibernateRTCGet +#define MAP_HibernateRTCGet \ + ROM_HibernateRTCGet +#else +#define MAP_HibernateRTCGet \ + HibernateRTCGet +#endif +#ifdef ROM_HibernateRTCMatch0Set +#define MAP_HibernateRTCMatch0Set \ + ROM_HibernateRTCMatch0Set +#else +#define MAP_HibernateRTCMatch0Set \ + HibernateRTCMatch0Set +#endif +#ifdef ROM_HibernateRTCMatch0Get +#define MAP_HibernateRTCMatch0Get \ + ROM_HibernateRTCMatch0Get +#else +#define MAP_HibernateRTCMatch0Get \ + HibernateRTCMatch0Get +#endif +#ifdef ROM_HibernateRTCMatch1Set +#define MAP_HibernateRTCMatch1Set \ + ROM_HibernateRTCMatch1Set +#else +#define MAP_HibernateRTCMatch1Set \ + HibernateRTCMatch1Set +#endif +#ifdef ROM_HibernateRTCMatch1Get +#define MAP_HibernateRTCMatch1Get \ + ROM_HibernateRTCMatch1Get +#else +#define MAP_HibernateRTCMatch1Get \ + HibernateRTCMatch1Get +#endif +#ifdef ROM_HibernateRTCTrimSet +#define MAP_HibernateRTCTrimSet \ + ROM_HibernateRTCTrimSet +#else +#define MAP_HibernateRTCTrimSet \ + HibernateRTCTrimSet +#endif +#ifdef ROM_HibernateRTCTrimGet +#define MAP_HibernateRTCTrimGet \ + ROM_HibernateRTCTrimGet +#else +#define MAP_HibernateRTCTrimGet \ + HibernateRTCTrimGet +#endif +#ifdef ROM_HibernateDataSet +#define MAP_HibernateDataSet \ + ROM_HibernateDataSet +#else +#define MAP_HibernateDataSet \ + HibernateDataSet +#endif +#ifdef ROM_HibernateDataGet +#define MAP_HibernateDataGet \ + ROM_HibernateDataGet +#else +#define MAP_HibernateDataGet \ + HibernateDataGet +#endif +#ifdef ROM_HibernateRequest +#define MAP_HibernateRequest \ + ROM_HibernateRequest +#else +#define MAP_HibernateRequest \ + HibernateRequest +#endif +#ifdef ROM_HibernateIntEnable +#define MAP_HibernateIntEnable \ + ROM_HibernateIntEnable +#else +#define MAP_HibernateIntEnable \ + HibernateIntEnable +#endif +#ifdef ROM_HibernateIntDisable +#define MAP_HibernateIntDisable \ + ROM_HibernateIntDisable +#else +#define MAP_HibernateIntDisable \ + HibernateIntDisable +#endif +#ifdef ROM_HibernateIntStatus +#define MAP_HibernateIntStatus \ + ROM_HibernateIntStatus +#else +#define MAP_HibernateIntStatus \ + HibernateIntStatus +#endif +#ifdef ROM_HibernateIsActive +#define MAP_HibernateIsActive \ + ROM_HibernateIsActive +#else +#define MAP_HibernateIsActive \ + HibernateIsActive +#endif + +//***************************************************************************** +// +// Macros for the I2C API. +// +//***************************************************************************** +#ifdef ROM_I2CMasterDataPut +#define MAP_I2CMasterDataPut \ + ROM_I2CMasterDataPut +#else +#define MAP_I2CMasterDataPut \ + I2CMasterDataPut +#endif +#ifdef ROM_I2CMasterInitExpClk +#define MAP_I2CMasterInitExpClk \ + ROM_I2CMasterInitExpClk +#else +#define MAP_I2CMasterInitExpClk \ + I2CMasterInitExpClk +#endif +#ifdef ROM_I2CSlaveInit +#define MAP_I2CSlaveInit \ + ROM_I2CSlaveInit +#else +#define MAP_I2CSlaveInit \ + I2CSlaveInit +#endif +#ifdef ROM_I2CMasterEnable +#define MAP_I2CMasterEnable \ + ROM_I2CMasterEnable +#else +#define MAP_I2CMasterEnable \ + I2CMasterEnable +#endif +#ifdef ROM_I2CSlaveEnable +#define MAP_I2CSlaveEnable \ + ROM_I2CSlaveEnable +#else +#define MAP_I2CSlaveEnable \ + I2CSlaveEnable +#endif +#ifdef ROM_I2CMasterDisable +#define MAP_I2CMasterDisable \ + ROM_I2CMasterDisable +#else +#define MAP_I2CMasterDisable \ + I2CMasterDisable +#endif +#ifdef ROM_I2CSlaveDisable +#define MAP_I2CSlaveDisable \ + ROM_I2CSlaveDisable +#else +#define MAP_I2CSlaveDisable \ + I2CSlaveDisable +#endif +#ifdef ROM_I2CMasterIntEnable +#define MAP_I2CMasterIntEnable \ + ROM_I2CMasterIntEnable +#else +#define MAP_I2CMasterIntEnable \ + I2CMasterIntEnable +#endif +#ifdef ROM_I2CSlaveIntEnable +#define MAP_I2CSlaveIntEnable \ + ROM_I2CSlaveIntEnable +#else +#define MAP_I2CSlaveIntEnable \ + I2CSlaveIntEnable +#endif +#ifdef ROM_I2CMasterIntDisable +#define MAP_I2CMasterIntDisable \ + ROM_I2CMasterIntDisable +#else +#define MAP_I2CMasterIntDisable \ + I2CMasterIntDisable +#endif +#ifdef ROM_I2CSlaveIntDisable +#define MAP_I2CSlaveIntDisable \ + ROM_I2CSlaveIntDisable +#else +#define MAP_I2CSlaveIntDisable \ + I2CSlaveIntDisable +#endif +#ifdef ROM_I2CMasterIntStatus +#define MAP_I2CMasterIntStatus \ + ROM_I2CMasterIntStatus +#else +#define MAP_I2CMasterIntStatus \ + I2CMasterIntStatus +#endif +#ifdef ROM_I2CSlaveIntStatus +#define MAP_I2CSlaveIntStatus \ + ROM_I2CSlaveIntStatus +#else +#define MAP_I2CSlaveIntStatus \ + I2CSlaveIntStatus +#endif +#ifdef ROM_I2CMasterIntClear +#define MAP_I2CMasterIntClear \ + ROM_I2CMasterIntClear +#else +#define MAP_I2CMasterIntClear \ + I2CMasterIntClear +#endif +#ifdef ROM_I2CSlaveIntClear +#define MAP_I2CSlaveIntClear \ + ROM_I2CSlaveIntClear +#else +#define MAP_I2CSlaveIntClear \ + I2CSlaveIntClear +#endif +#ifdef ROM_I2CMasterSlaveAddrSet +#define MAP_I2CMasterSlaveAddrSet \ + ROM_I2CMasterSlaveAddrSet +#else +#define MAP_I2CMasterSlaveAddrSet \ + I2CMasterSlaveAddrSet +#endif +#ifdef ROM_I2CMasterBusy +#define MAP_I2CMasterBusy \ + ROM_I2CMasterBusy +#else +#define MAP_I2CMasterBusy \ + I2CMasterBusy +#endif +#ifdef ROM_I2CMasterBusBusy +#define MAP_I2CMasterBusBusy \ + ROM_I2CMasterBusBusy +#else +#define MAP_I2CMasterBusBusy \ + I2CMasterBusBusy +#endif +#ifdef ROM_I2CMasterControl +#define MAP_I2CMasterControl \ + ROM_I2CMasterControl +#else +#define MAP_I2CMasterControl \ + I2CMasterControl +#endif +#ifdef ROM_I2CMasterErr +#define MAP_I2CMasterErr \ + ROM_I2CMasterErr +#else +#define MAP_I2CMasterErr \ + I2CMasterErr +#endif +#ifdef ROM_I2CMasterDataGet +#define MAP_I2CMasterDataGet \ + ROM_I2CMasterDataGet +#else +#define MAP_I2CMasterDataGet \ + I2CMasterDataGet +#endif +#ifdef ROM_I2CSlaveStatus +#define MAP_I2CSlaveStatus \ + ROM_I2CSlaveStatus +#else +#define MAP_I2CSlaveStatus \ + I2CSlaveStatus +#endif +#ifdef ROM_I2CSlaveDataPut +#define MAP_I2CSlaveDataPut \ + ROM_I2CSlaveDataPut +#else +#define MAP_I2CSlaveDataPut \ + I2CSlaveDataPut +#endif +#ifdef ROM_I2CSlaveDataGet +#define MAP_I2CSlaveDataGet \ + ROM_I2CSlaveDataGet +#else +#define MAP_I2CSlaveDataGet \ + I2CSlaveDataGet +#endif +#ifdef ROM_I2CSlaveIntEnableEx +#define MAP_I2CSlaveIntEnableEx \ + ROM_I2CSlaveIntEnableEx +#else +#define MAP_I2CSlaveIntEnableEx \ + I2CSlaveIntEnableEx +#endif +#ifdef ROM_I2CSlaveIntDisableEx +#define MAP_I2CSlaveIntDisableEx \ + ROM_I2CSlaveIntDisableEx +#else +#define MAP_I2CSlaveIntDisableEx \ + I2CSlaveIntDisableEx +#endif +#ifdef ROM_I2CSlaveIntStatusEx +#define MAP_I2CSlaveIntStatusEx \ + ROM_I2CSlaveIntStatusEx +#else +#define MAP_I2CSlaveIntStatusEx \ + I2CSlaveIntStatusEx +#endif +#ifdef ROM_I2CSlaveIntClearEx +#define MAP_I2CSlaveIntClearEx \ + ROM_I2CSlaveIntClearEx +#else +#define MAP_I2CSlaveIntClearEx \ + I2CSlaveIntClearEx +#endif + +//***************************************************************************** +// +// Macros for the I2S API. +// +//***************************************************************************** +#ifdef ROM_I2SIntStatus +#define MAP_I2SIntStatus \ + ROM_I2SIntStatus +#else +#define MAP_I2SIntStatus \ + I2SIntStatus +#endif +#ifdef ROM_I2STxEnable +#define MAP_I2STxEnable \ + ROM_I2STxEnable +#else +#define MAP_I2STxEnable \ + I2STxEnable +#endif +#ifdef ROM_I2STxDisable +#define MAP_I2STxDisable \ + ROM_I2STxDisable +#else +#define MAP_I2STxDisable \ + I2STxDisable +#endif +#ifdef ROM_I2STxDataPut +#define MAP_I2STxDataPut \ + ROM_I2STxDataPut +#else +#define MAP_I2STxDataPut \ + I2STxDataPut +#endif +#ifdef ROM_I2STxDataPutNonBlocking +#define MAP_I2STxDataPutNonBlocking \ + ROM_I2STxDataPutNonBlocking +#else +#define MAP_I2STxDataPutNonBlocking \ + I2STxDataPutNonBlocking +#endif +#ifdef ROM_I2STxConfigSet +#define MAP_I2STxConfigSet \ + ROM_I2STxConfigSet +#else +#define MAP_I2STxConfigSet \ + I2STxConfigSet +#endif +#ifdef ROM_I2STxFIFOLimitSet +#define MAP_I2STxFIFOLimitSet \ + ROM_I2STxFIFOLimitSet +#else +#define MAP_I2STxFIFOLimitSet \ + I2STxFIFOLimitSet +#endif +#ifdef ROM_I2STxFIFOLimitGet +#define MAP_I2STxFIFOLimitGet \ + ROM_I2STxFIFOLimitGet +#else +#define MAP_I2STxFIFOLimitGet \ + I2STxFIFOLimitGet +#endif +#ifdef ROM_I2STxFIFOLevelGet +#define MAP_I2STxFIFOLevelGet \ + ROM_I2STxFIFOLevelGet +#else +#define MAP_I2STxFIFOLevelGet \ + I2STxFIFOLevelGet +#endif +#ifdef ROM_I2SRxEnable +#define MAP_I2SRxEnable \ + ROM_I2SRxEnable +#else +#define MAP_I2SRxEnable \ + I2SRxEnable +#endif +#ifdef ROM_I2SRxDisable +#define MAP_I2SRxDisable \ + ROM_I2SRxDisable +#else +#define MAP_I2SRxDisable \ + I2SRxDisable +#endif +#ifdef ROM_I2SRxDataGet +#define MAP_I2SRxDataGet \ + ROM_I2SRxDataGet +#else +#define MAP_I2SRxDataGet \ + I2SRxDataGet +#endif +#ifdef ROM_I2SRxDataGetNonBlocking +#define MAP_I2SRxDataGetNonBlocking \ + ROM_I2SRxDataGetNonBlocking +#else +#define MAP_I2SRxDataGetNonBlocking \ + I2SRxDataGetNonBlocking +#endif +#ifdef ROM_I2SRxConfigSet +#define MAP_I2SRxConfigSet \ + ROM_I2SRxConfigSet +#else +#define MAP_I2SRxConfigSet \ + I2SRxConfigSet +#endif +#ifdef ROM_I2SRxFIFOLimitSet +#define MAP_I2SRxFIFOLimitSet \ + ROM_I2SRxFIFOLimitSet +#else +#define MAP_I2SRxFIFOLimitSet \ + I2SRxFIFOLimitSet +#endif +#ifdef ROM_I2SRxFIFOLimitGet +#define MAP_I2SRxFIFOLimitGet \ + ROM_I2SRxFIFOLimitGet +#else +#define MAP_I2SRxFIFOLimitGet \ + I2SRxFIFOLimitGet +#endif +#ifdef ROM_I2SRxFIFOLevelGet +#define MAP_I2SRxFIFOLevelGet \ + ROM_I2SRxFIFOLevelGet +#else +#define MAP_I2SRxFIFOLevelGet \ + I2SRxFIFOLevelGet +#endif +#ifdef ROM_I2STxRxEnable +#define MAP_I2STxRxEnable \ + ROM_I2STxRxEnable +#else +#define MAP_I2STxRxEnable \ + I2STxRxEnable +#endif +#ifdef ROM_I2STxRxDisable +#define MAP_I2STxRxDisable \ + ROM_I2STxRxDisable +#else +#define MAP_I2STxRxDisable \ + I2STxRxDisable +#endif +#ifdef ROM_I2STxRxConfigSet +#define MAP_I2STxRxConfigSet \ + ROM_I2STxRxConfigSet +#else +#define MAP_I2STxRxConfigSet \ + I2STxRxConfigSet +#endif +#ifdef ROM_I2SMasterClockSelect +#define MAP_I2SMasterClockSelect \ + ROM_I2SMasterClockSelect +#else +#define MAP_I2SMasterClockSelect \ + I2SMasterClockSelect +#endif +#ifdef ROM_I2SIntEnable +#define MAP_I2SIntEnable \ + ROM_I2SIntEnable +#else +#define MAP_I2SIntEnable \ + I2SIntEnable +#endif +#ifdef ROM_I2SIntDisable +#define MAP_I2SIntDisable \ + ROM_I2SIntDisable +#else +#define MAP_I2SIntDisable \ + I2SIntDisable +#endif +#ifdef ROM_I2SIntClear +#define MAP_I2SIntClear \ + ROM_I2SIntClear +#else +#define MAP_I2SIntClear \ + I2SIntClear +#endif + +//***************************************************************************** +// +// Macros for the Interrupt API. +// +//***************************************************************************** +#ifdef ROM_IntEnable +#define MAP_IntEnable \ + ROM_IntEnable +#else +#define MAP_IntEnable \ + IntEnable +#endif +#ifdef ROM_IntMasterEnable +#define MAP_IntMasterEnable \ + ROM_IntMasterEnable +#else +#define MAP_IntMasterEnable \ + IntMasterEnable +#endif +#ifdef ROM_IntMasterDisable +#define MAP_IntMasterDisable \ + ROM_IntMasterDisable +#else +#define MAP_IntMasterDisable \ + IntMasterDisable +#endif +#ifdef ROM_IntDisable +#define MAP_IntDisable \ + ROM_IntDisable +#else +#define MAP_IntDisable \ + IntDisable +#endif +#ifdef ROM_IntPriorityGroupingSet +#define MAP_IntPriorityGroupingSet \ + ROM_IntPriorityGroupingSet +#else +#define MAP_IntPriorityGroupingSet \ + IntPriorityGroupingSet +#endif +#ifdef ROM_IntPriorityGroupingGet +#define MAP_IntPriorityGroupingGet \ + ROM_IntPriorityGroupingGet +#else +#define MAP_IntPriorityGroupingGet \ + IntPriorityGroupingGet +#endif +#ifdef ROM_IntPrioritySet +#define MAP_IntPrioritySet \ + ROM_IntPrioritySet +#else +#define MAP_IntPrioritySet \ + IntPrioritySet +#endif +#ifdef ROM_IntPriorityGet +#define MAP_IntPriorityGet \ + ROM_IntPriorityGet +#else +#define MAP_IntPriorityGet \ + IntPriorityGet +#endif +#ifdef ROM_IntPendSet +#define MAP_IntPendSet \ + ROM_IntPendSet +#else +#define MAP_IntPendSet \ + IntPendSet +#endif +#ifdef ROM_IntPendClear +#define MAP_IntPendClear \ + ROM_IntPendClear +#else +#define MAP_IntPendClear \ + IntPendClear +#endif + +//***************************************************************************** +// +// Macros for the MPU API. +// +//***************************************************************************** +#ifdef ROM_MPUEnable +#define MAP_MPUEnable \ + ROM_MPUEnable +#else +#define MAP_MPUEnable \ + MPUEnable +#endif +#ifdef ROM_MPUDisable +#define MAP_MPUDisable \ + ROM_MPUDisable +#else +#define MAP_MPUDisable \ + MPUDisable +#endif +#ifdef ROM_MPURegionCountGet +#define MAP_MPURegionCountGet \ + ROM_MPURegionCountGet +#else +#define MAP_MPURegionCountGet \ + MPURegionCountGet +#endif +#ifdef ROM_MPURegionEnable +#define MAP_MPURegionEnable \ + ROM_MPURegionEnable +#else +#define MAP_MPURegionEnable \ + MPURegionEnable +#endif +#ifdef ROM_MPURegionDisable +#define MAP_MPURegionDisable \ + ROM_MPURegionDisable +#else +#define MAP_MPURegionDisable \ + MPURegionDisable +#endif +#ifdef ROM_MPURegionSet +#define MAP_MPURegionSet \ + ROM_MPURegionSet +#else +#define MAP_MPURegionSet \ + MPURegionSet +#endif +#ifdef ROM_MPURegionGet +#define MAP_MPURegionGet \ + ROM_MPURegionGet +#else +#define MAP_MPURegionGet \ + MPURegionGet +#endif + +//***************************************************************************** +// +// Macros for the PWM API. +// +//***************************************************************************** +#ifdef ROM_PWMPulseWidthSet +#define MAP_PWMPulseWidthSet \ + ROM_PWMPulseWidthSet +#else +#define MAP_PWMPulseWidthSet \ + PWMPulseWidthSet +#endif +#ifdef ROM_PWMGenConfigure +#define MAP_PWMGenConfigure \ + ROM_PWMGenConfigure +#else +#define MAP_PWMGenConfigure \ + PWMGenConfigure +#endif +#ifdef ROM_PWMGenPeriodSet +#define MAP_PWMGenPeriodSet \ + ROM_PWMGenPeriodSet +#else +#define MAP_PWMGenPeriodSet \ + PWMGenPeriodSet +#endif +#ifdef ROM_PWMGenPeriodGet +#define MAP_PWMGenPeriodGet \ + ROM_PWMGenPeriodGet +#else +#define MAP_PWMGenPeriodGet \ + PWMGenPeriodGet +#endif +#ifdef ROM_PWMGenEnable +#define MAP_PWMGenEnable \ + ROM_PWMGenEnable +#else +#define MAP_PWMGenEnable \ + PWMGenEnable +#endif +#ifdef ROM_PWMGenDisable +#define MAP_PWMGenDisable \ + ROM_PWMGenDisable +#else +#define MAP_PWMGenDisable \ + PWMGenDisable +#endif +#ifdef ROM_PWMPulseWidthGet +#define MAP_PWMPulseWidthGet \ + ROM_PWMPulseWidthGet +#else +#define MAP_PWMPulseWidthGet \ + PWMPulseWidthGet +#endif +#ifdef ROM_PWMDeadBandEnable +#define MAP_PWMDeadBandEnable \ + ROM_PWMDeadBandEnable +#else +#define MAP_PWMDeadBandEnable \ + PWMDeadBandEnable +#endif +#ifdef ROM_PWMDeadBandDisable +#define MAP_PWMDeadBandDisable \ + ROM_PWMDeadBandDisable +#else +#define MAP_PWMDeadBandDisable \ + PWMDeadBandDisable +#endif +#ifdef ROM_PWMSyncUpdate +#define MAP_PWMSyncUpdate \ + ROM_PWMSyncUpdate +#else +#define MAP_PWMSyncUpdate \ + PWMSyncUpdate +#endif +#ifdef ROM_PWMSyncTimeBase +#define MAP_PWMSyncTimeBase \ + ROM_PWMSyncTimeBase +#else +#define MAP_PWMSyncTimeBase \ + PWMSyncTimeBase +#endif +#ifdef ROM_PWMOutputState +#define MAP_PWMOutputState \ + ROM_PWMOutputState +#else +#define MAP_PWMOutputState \ + PWMOutputState +#endif +#ifdef ROM_PWMOutputInvert +#define MAP_PWMOutputInvert \ + ROM_PWMOutputInvert +#else +#define MAP_PWMOutputInvert \ + PWMOutputInvert +#endif +#ifdef ROM_PWMOutputFault +#define MAP_PWMOutputFault \ + ROM_PWMOutputFault +#else +#define MAP_PWMOutputFault \ + PWMOutputFault +#endif +#ifdef ROM_PWMGenIntTrigEnable +#define MAP_PWMGenIntTrigEnable \ + ROM_PWMGenIntTrigEnable +#else +#define MAP_PWMGenIntTrigEnable \ + PWMGenIntTrigEnable +#endif +#ifdef ROM_PWMGenIntTrigDisable +#define MAP_PWMGenIntTrigDisable \ + ROM_PWMGenIntTrigDisable +#else +#define MAP_PWMGenIntTrigDisable \ + PWMGenIntTrigDisable +#endif +#ifdef ROM_PWMGenIntStatus +#define MAP_PWMGenIntStatus \ + ROM_PWMGenIntStatus +#else +#define MAP_PWMGenIntStatus \ + PWMGenIntStatus +#endif +#ifdef ROM_PWMGenIntClear +#define MAP_PWMGenIntClear \ + ROM_PWMGenIntClear +#else +#define MAP_PWMGenIntClear \ + PWMGenIntClear +#endif +#ifdef ROM_PWMIntEnable +#define MAP_PWMIntEnable \ + ROM_PWMIntEnable +#else +#define MAP_PWMIntEnable \ + PWMIntEnable +#endif +#ifdef ROM_PWMIntDisable +#define MAP_PWMIntDisable \ + ROM_PWMIntDisable +#else +#define MAP_PWMIntDisable \ + PWMIntDisable +#endif +#ifdef ROM_PWMFaultIntClear +#define MAP_PWMFaultIntClear \ + ROM_PWMFaultIntClear +#else +#define MAP_PWMFaultIntClear \ + PWMFaultIntClear +#endif +#ifdef ROM_PWMIntStatus +#define MAP_PWMIntStatus \ + ROM_PWMIntStatus +#else +#define MAP_PWMIntStatus \ + PWMIntStatus +#endif +#ifdef ROM_PWMOutputFaultLevel +#define MAP_PWMOutputFaultLevel \ + ROM_PWMOutputFaultLevel +#else +#define MAP_PWMOutputFaultLevel \ + PWMOutputFaultLevel +#endif +#ifdef ROM_PWMFaultIntClearExt +#define MAP_PWMFaultIntClearExt \ + ROM_PWMFaultIntClearExt +#else +#define MAP_PWMFaultIntClearExt \ + PWMFaultIntClearExt +#endif +#ifdef ROM_PWMGenFaultConfigure +#define MAP_PWMGenFaultConfigure \ + ROM_PWMGenFaultConfigure +#else +#define MAP_PWMGenFaultConfigure \ + PWMGenFaultConfigure +#endif +#ifdef ROM_PWMGenFaultTriggerSet +#define MAP_PWMGenFaultTriggerSet \ + ROM_PWMGenFaultTriggerSet +#else +#define MAP_PWMGenFaultTriggerSet \ + PWMGenFaultTriggerSet +#endif +#ifdef ROM_PWMGenFaultTriggerGet +#define MAP_PWMGenFaultTriggerGet \ + ROM_PWMGenFaultTriggerGet +#else +#define MAP_PWMGenFaultTriggerGet \ + PWMGenFaultTriggerGet +#endif +#ifdef ROM_PWMGenFaultStatus +#define MAP_PWMGenFaultStatus \ + ROM_PWMGenFaultStatus +#else +#define MAP_PWMGenFaultStatus \ + PWMGenFaultStatus +#endif +#ifdef ROM_PWMGenFaultClear +#define MAP_PWMGenFaultClear \ + ROM_PWMGenFaultClear +#else +#define MAP_PWMGenFaultClear \ + PWMGenFaultClear +#endif + +//***************************************************************************** +// +// Macros for the QEI API. +// +//***************************************************************************** +#ifdef ROM_QEIPositionGet +#define MAP_QEIPositionGet \ + ROM_QEIPositionGet +#else +#define MAP_QEIPositionGet \ + QEIPositionGet +#endif +#ifdef ROM_QEIEnable +#define MAP_QEIEnable \ + ROM_QEIEnable +#else +#define MAP_QEIEnable \ + QEIEnable +#endif +#ifdef ROM_QEIDisable +#define MAP_QEIDisable \ + ROM_QEIDisable +#else +#define MAP_QEIDisable \ + QEIDisable +#endif +#ifdef ROM_QEIConfigure +#define MAP_QEIConfigure \ + ROM_QEIConfigure +#else +#define MAP_QEIConfigure \ + QEIConfigure +#endif +#ifdef ROM_QEIPositionSet +#define MAP_QEIPositionSet \ + ROM_QEIPositionSet +#else +#define MAP_QEIPositionSet \ + QEIPositionSet +#endif +#ifdef ROM_QEIDirectionGet +#define MAP_QEIDirectionGet \ + ROM_QEIDirectionGet +#else +#define MAP_QEIDirectionGet \ + QEIDirectionGet +#endif +#ifdef ROM_QEIErrorGet +#define MAP_QEIErrorGet \ + ROM_QEIErrorGet +#else +#define MAP_QEIErrorGet \ + QEIErrorGet +#endif +#ifdef ROM_QEIVelocityEnable +#define MAP_QEIVelocityEnable \ + ROM_QEIVelocityEnable +#else +#define MAP_QEIVelocityEnable \ + QEIVelocityEnable +#endif +#ifdef ROM_QEIVelocityDisable +#define MAP_QEIVelocityDisable \ + ROM_QEIVelocityDisable +#else +#define MAP_QEIVelocityDisable \ + QEIVelocityDisable +#endif +#ifdef ROM_QEIVelocityConfigure +#define MAP_QEIVelocityConfigure \ + ROM_QEIVelocityConfigure +#else +#define MAP_QEIVelocityConfigure \ + QEIVelocityConfigure +#endif +#ifdef ROM_QEIVelocityGet +#define MAP_QEIVelocityGet \ + ROM_QEIVelocityGet +#else +#define MAP_QEIVelocityGet \ + QEIVelocityGet +#endif +#ifdef ROM_QEIIntEnable +#define MAP_QEIIntEnable \ + ROM_QEIIntEnable +#else +#define MAP_QEIIntEnable \ + QEIIntEnable +#endif +#ifdef ROM_QEIIntDisable +#define MAP_QEIIntDisable \ + ROM_QEIIntDisable +#else +#define MAP_QEIIntDisable \ + QEIIntDisable +#endif +#ifdef ROM_QEIIntStatus +#define MAP_QEIIntStatus \ + ROM_QEIIntStatus +#else +#define MAP_QEIIntStatus \ + QEIIntStatus +#endif +#ifdef ROM_QEIIntClear +#define MAP_QEIIntClear \ + ROM_QEIIntClear +#else +#define MAP_QEIIntClear \ + QEIIntClear +#endif + +//***************************************************************************** +// +// Macros for the SSI API. +// +//***************************************************************************** +#ifdef ROM_SSIDataPut +#define MAP_SSIDataPut \ + ROM_SSIDataPut +#else +#define MAP_SSIDataPut \ + SSIDataPut +#endif +#ifdef ROM_SSIConfigSetExpClk +#define MAP_SSIConfigSetExpClk \ + ROM_SSIConfigSetExpClk +#else +#define MAP_SSIConfigSetExpClk \ + SSIConfigSetExpClk +#endif +#ifdef ROM_SSIEnable +#define MAP_SSIEnable \ + ROM_SSIEnable +#else +#define MAP_SSIEnable \ + SSIEnable +#endif +#ifdef ROM_SSIDisable +#define MAP_SSIDisable \ + ROM_SSIDisable +#else +#define MAP_SSIDisable \ + SSIDisable +#endif +#ifdef ROM_SSIIntEnable +#define MAP_SSIIntEnable \ + ROM_SSIIntEnable +#else +#define MAP_SSIIntEnable \ + SSIIntEnable +#endif +#ifdef ROM_SSIIntDisable +#define MAP_SSIIntDisable \ + ROM_SSIIntDisable +#else +#define MAP_SSIIntDisable \ + SSIIntDisable +#endif +#ifdef ROM_SSIIntStatus +#define MAP_SSIIntStatus \ + ROM_SSIIntStatus +#else +#define MAP_SSIIntStatus \ + SSIIntStatus +#endif +#ifdef ROM_SSIIntClear +#define MAP_SSIIntClear \ + ROM_SSIIntClear +#else +#define MAP_SSIIntClear \ + SSIIntClear +#endif +#ifdef ROM_SSIDataPutNonBlocking +#define MAP_SSIDataPutNonBlocking \ + ROM_SSIDataPutNonBlocking +#else +#define MAP_SSIDataPutNonBlocking \ + SSIDataPutNonBlocking +#endif +#ifdef ROM_SSIDataGet +#define MAP_SSIDataGet \ + ROM_SSIDataGet +#else +#define MAP_SSIDataGet \ + SSIDataGet +#endif +#ifdef ROM_SSIDataGetNonBlocking +#define MAP_SSIDataGetNonBlocking \ + ROM_SSIDataGetNonBlocking +#else +#define MAP_SSIDataGetNonBlocking \ + SSIDataGetNonBlocking +#endif +#ifdef ROM_SSIDMAEnable +#define MAP_SSIDMAEnable \ + ROM_SSIDMAEnable +#else +#define MAP_SSIDMAEnable \ + SSIDMAEnable +#endif +#ifdef ROM_SSIDMADisable +#define MAP_SSIDMADisable \ + ROM_SSIDMADisable +#else +#define MAP_SSIDMADisable \ + SSIDMADisable +#endif +#ifdef ROM_SSIBusy +#define MAP_SSIBusy \ + ROM_SSIBusy +#else +#define MAP_SSIBusy \ + SSIBusy +#endif + +//***************************************************************************** +// +// Macros for the SysCtl API. +// +//***************************************************************************** +#ifdef ROM_SysCtlSleep +#define MAP_SysCtlSleep \ + ROM_SysCtlSleep +#else +#define MAP_SysCtlSleep \ + SysCtlSleep +#endif +#ifdef ROM_SysCtlSRAMSizeGet +#define MAP_SysCtlSRAMSizeGet \ + ROM_SysCtlSRAMSizeGet +#else +#define MAP_SysCtlSRAMSizeGet \ + SysCtlSRAMSizeGet +#endif +#ifdef ROM_SysCtlFlashSizeGet +#define MAP_SysCtlFlashSizeGet \ + ROM_SysCtlFlashSizeGet +#else +#define MAP_SysCtlFlashSizeGet \ + SysCtlFlashSizeGet +#endif +#ifdef ROM_SysCtlPinPresent +#define MAP_SysCtlPinPresent \ + ROM_SysCtlPinPresent +#else +#define MAP_SysCtlPinPresent \ + SysCtlPinPresent +#endif +#ifdef ROM_SysCtlPeripheralPresent +#define MAP_SysCtlPeripheralPresent \ + ROM_SysCtlPeripheralPresent +#else +#define MAP_SysCtlPeripheralPresent \ + SysCtlPeripheralPresent +#endif +#ifdef ROM_SysCtlPeripheralReset +#define MAP_SysCtlPeripheralReset \ + ROM_SysCtlPeripheralReset +#else +#define MAP_SysCtlPeripheralReset \ + SysCtlPeripheralReset +#endif +#ifdef ROM_SysCtlPeripheralEnable +#define MAP_SysCtlPeripheralEnable \ + ROM_SysCtlPeripheralEnable +#else +#define MAP_SysCtlPeripheralEnable \ + SysCtlPeripheralEnable +#endif +#ifdef ROM_SysCtlPeripheralDisable +#define MAP_SysCtlPeripheralDisable \ + ROM_SysCtlPeripheralDisable +#else +#define MAP_SysCtlPeripheralDisable \ + SysCtlPeripheralDisable +#endif +#ifdef ROM_SysCtlPeripheralSleepEnable +#define MAP_SysCtlPeripheralSleepEnable \ + ROM_SysCtlPeripheralSleepEnable +#else +#define MAP_SysCtlPeripheralSleepEnable \ + SysCtlPeripheralSleepEnable +#endif +#ifdef ROM_SysCtlPeripheralSleepDisable +#define MAP_SysCtlPeripheralSleepDisable \ + ROM_SysCtlPeripheralSleepDisable +#else +#define MAP_SysCtlPeripheralSleepDisable \ + SysCtlPeripheralSleepDisable +#endif +#ifdef ROM_SysCtlPeripheralDeepSleepEnable +#define MAP_SysCtlPeripheralDeepSleepEnable \ + ROM_SysCtlPeripheralDeepSleepEnable +#else +#define MAP_SysCtlPeripheralDeepSleepEnable \ + SysCtlPeripheralDeepSleepEnable +#endif +#ifdef ROM_SysCtlPeripheralDeepSleepDisable +#define MAP_SysCtlPeripheralDeepSleepDisable \ + ROM_SysCtlPeripheralDeepSleepDisable +#else +#define MAP_SysCtlPeripheralDeepSleepDisable \ + SysCtlPeripheralDeepSleepDisable +#endif +#ifdef ROM_SysCtlPeripheralClockGating +#define MAP_SysCtlPeripheralClockGating \ + ROM_SysCtlPeripheralClockGating +#else +#define MAP_SysCtlPeripheralClockGating \ + SysCtlPeripheralClockGating +#endif +#ifdef ROM_SysCtlIntEnable +#define MAP_SysCtlIntEnable \ + ROM_SysCtlIntEnable +#else +#define MAP_SysCtlIntEnable \ + SysCtlIntEnable +#endif +#ifdef ROM_SysCtlIntDisable +#define MAP_SysCtlIntDisable \ + ROM_SysCtlIntDisable +#else +#define MAP_SysCtlIntDisable \ + SysCtlIntDisable +#endif +#ifdef ROM_SysCtlIntClear +#define MAP_SysCtlIntClear \ + ROM_SysCtlIntClear +#else +#define MAP_SysCtlIntClear \ + SysCtlIntClear +#endif +#ifdef ROM_SysCtlIntStatus +#define MAP_SysCtlIntStatus \ + ROM_SysCtlIntStatus +#else +#define MAP_SysCtlIntStatus \ + SysCtlIntStatus +#endif +#ifdef ROM_SysCtlLDOSet +#define MAP_SysCtlLDOSet \ + ROM_SysCtlLDOSet +#else +#define MAP_SysCtlLDOSet \ + SysCtlLDOSet +#endif +#ifdef ROM_SysCtlLDOGet +#define MAP_SysCtlLDOGet \ + ROM_SysCtlLDOGet +#else +#define MAP_SysCtlLDOGet \ + SysCtlLDOGet +#endif +#ifdef ROM_SysCtlReset +#define MAP_SysCtlReset \ + ROM_SysCtlReset +#else +#define MAP_SysCtlReset \ + SysCtlReset +#endif +#ifdef ROM_SysCtlDeepSleep +#define MAP_SysCtlDeepSleep \ + ROM_SysCtlDeepSleep +#else +#define MAP_SysCtlDeepSleep \ + SysCtlDeepSleep +#endif +#ifdef ROM_SysCtlResetCauseGet +#define MAP_SysCtlResetCauseGet \ + ROM_SysCtlResetCauseGet +#else +#define MAP_SysCtlResetCauseGet \ + SysCtlResetCauseGet +#endif +#ifdef ROM_SysCtlResetCauseClear +#define MAP_SysCtlResetCauseClear \ + ROM_SysCtlResetCauseClear +#else +#define MAP_SysCtlResetCauseClear \ + SysCtlResetCauseClear +#endif +#ifdef ROM_SysCtlClockSet +#define MAP_SysCtlClockSet \ + ROM_SysCtlClockSet +#else +#define MAP_SysCtlClockSet \ + SysCtlClockSet +#endif +#ifdef ROM_SysCtlClockGet +#define MAP_SysCtlClockGet \ + ROM_SysCtlClockGet +#else +#define MAP_SysCtlClockGet \ + SysCtlClockGet +#endif +#ifdef ROM_SysCtlPWMClockSet +#define MAP_SysCtlPWMClockSet \ + ROM_SysCtlPWMClockSet +#else +#define MAP_SysCtlPWMClockSet \ + SysCtlPWMClockSet +#endif +#ifdef ROM_SysCtlPWMClockGet +#define MAP_SysCtlPWMClockGet \ + ROM_SysCtlPWMClockGet +#else +#define MAP_SysCtlPWMClockGet \ + SysCtlPWMClockGet +#endif +#ifdef ROM_SysCtlADCSpeedSet +#define MAP_SysCtlADCSpeedSet \ + ROM_SysCtlADCSpeedSet +#else +#define MAP_SysCtlADCSpeedSet \ + SysCtlADCSpeedSet +#endif +#ifdef ROM_SysCtlADCSpeedGet +#define MAP_SysCtlADCSpeedGet \ + ROM_SysCtlADCSpeedGet +#else +#define MAP_SysCtlADCSpeedGet \ + SysCtlADCSpeedGet +#endif +#ifdef ROM_SysCtlGPIOAHBEnable +#define MAP_SysCtlGPIOAHBEnable \ + ROM_SysCtlGPIOAHBEnable +#else +#define MAP_SysCtlGPIOAHBEnable \ + SysCtlGPIOAHBEnable +#endif +#ifdef ROM_SysCtlGPIOAHBDisable +#define MAP_SysCtlGPIOAHBDisable \ + ROM_SysCtlGPIOAHBDisable +#else +#define MAP_SysCtlGPIOAHBDisable \ + SysCtlGPIOAHBDisable +#endif +#ifdef ROM_SysCtlUSBPLLEnable +#define MAP_SysCtlUSBPLLEnable \ + ROM_SysCtlUSBPLLEnable +#else +#define MAP_SysCtlUSBPLLEnable \ + SysCtlUSBPLLEnable +#endif +#ifdef ROM_SysCtlUSBPLLDisable +#define MAP_SysCtlUSBPLLDisable \ + ROM_SysCtlUSBPLLDisable +#else +#define MAP_SysCtlUSBPLLDisable \ + SysCtlUSBPLLDisable +#endif +#ifdef ROM_SysCtlI2SMClkSet +#define MAP_SysCtlI2SMClkSet \ + ROM_SysCtlI2SMClkSet +#else +#define MAP_SysCtlI2SMClkSet \ + SysCtlI2SMClkSet +#endif +#ifdef ROM_SysCtlDelay +#define MAP_SysCtlDelay \ + ROM_SysCtlDelay +#else +#define MAP_SysCtlDelay \ + SysCtlDelay +#endif + +//***************************************************************************** +// +// Macros for the SysTick API. +// +//***************************************************************************** +#ifdef ROM_SysTickValueGet +#define MAP_SysTickValueGet \ + ROM_SysTickValueGet +#else +#define MAP_SysTickValueGet \ + SysTickValueGet +#endif +#ifdef ROM_SysTickEnable +#define MAP_SysTickEnable \ + ROM_SysTickEnable +#else +#define MAP_SysTickEnable \ + SysTickEnable +#endif +#ifdef ROM_SysTickDisable +#define MAP_SysTickDisable \ + ROM_SysTickDisable +#else +#define MAP_SysTickDisable \ + SysTickDisable +#endif +#ifdef ROM_SysTickIntEnable +#define MAP_SysTickIntEnable \ + ROM_SysTickIntEnable +#else +#define MAP_SysTickIntEnable \ + SysTickIntEnable +#endif +#ifdef ROM_SysTickIntDisable +#define MAP_SysTickIntDisable \ + ROM_SysTickIntDisable +#else +#define MAP_SysTickIntDisable \ + SysTickIntDisable +#endif +#ifdef ROM_SysTickPeriodSet +#define MAP_SysTickPeriodSet \ + ROM_SysTickPeriodSet +#else +#define MAP_SysTickPeriodSet \ + SysTickPeriodSet +#endif +#ifdef ROM_SysTickPeriodGet +#define MAP_SysTickPeriodGet \ + ROM_SysTickPeriodGet +#else +#define MAP_SysTickPeriodGet \ + SysTickPeriodGet +#endif + +//***************************************************************************** +// +// Macros for the Timer API. +// +//***************************************************************************** +#ifdef ROM_TimerIntClear +#define MAP_TimerIntClear \ + ROM_TimerIntClear +#else +#define MAP_TimerIntClear \ + TimerIntClear +#endif +#ifdef ROM_TimerEnable +#define MAP_TimerEnable \ + ROM_TimerEnable +#else +#define MAP_TimerEnable \ + TimerEnable +#endif +#ifdef ROM_TimerDisable +#define MAP_TimerDisable \ + ROM_TimerDisable +#else +#define MAP_TimerDisable \ + TimerDisable +#endif +#ifdef ROM_TimerConfigure +#define MAP_TimerConfigure \ + ROM_TimerConfigure +#else +#define MAP_TimerConfigure \ + TimerConfigure +#endif +#ifdef ROM_TimerControlLevel +#define MAP_TimerControlLevel \ + ROM_TimerControlLevel +#else +#define MAP_TimerControlLevel \ + TimerControlLevel +#endif +#ifdef ROM_TimerControlTrigger +#define MAP_TimerControlTrigger \ + ROM_TimerControlTrigger +#else +#define MAP_TimerControlTrigger \ + TimerControlTrigger +#endif +#ifdef ROM_TimerControlEvent +#define MAP_TimerControlEvent \ + ROM_TimerControlEvent +#else +#define MAP_TimerControlEvent \ + TimerControlEvent +#endif +#ifdef ROM_TimerControlStall +#define MAP_TimerControlStall \ + ROM_TimerControlStall +#else +#define MAP_TimerControlStall \ + TimerControlStall +#endif +#ifdef ROM_TimerRTCEnable +#define MAP_TimerRTCEnable \ + ROM_TimerRTCEnable +#else +#define MAP_TimerRTCEnable \ + TimerRTCEnable +#endif +#ifdef ROM_TimerRTCDisable +#define MAP_TimerRTCDisable \ + ROM_TimerRTCDisable +#else +#define MAP_TimerRTCDisable \ + TimerRTCDisable +#endif +#ifdef ROM_TimerPrescaleSet +#define MAP_TimerPrescaleSet \ + ROM_TimerPrescaleSet +#else +#define MAP_TimerPrescaleSet \ + TimerPrescaleSet +#endif +#ifdef ROM_TimerPrescaleGet +#define MAP_TimerPrescaleGet \ + ROM_TimerPrescaleGet +#else +#define MAP_TimerPrescaleGet \ + TimerPrescaleGet +#endif +#ifdef ROM_TimerPrescaleMatchSet +#define MAP_TimerPrescaleMatchSet \ + ROM_TimerPrescaleMatchSet +#else +#define MAP_TimerPrescaleMatchSet \ + TimerPrescaleMatchSet +#endif +#ifdef ROM_TimerPrescaleMatchGet +#define MAP_TimerPrescaleMatchGet \ + ROM_TimerPrescaleMatchGet +#else +#define MAP_TimerPrescaleMatchGet \ + TimerPrescaleMatchGet +#endif +#ifdef ROM_TimerLoadSet +#define MAP_TimerLoadSet \ + ROM_TimerLoadSet +#else +#define MAP_TimerLoadSet \ + TimerLoadSet +#endif +#ifdef ROM_TimerLoadGet +#define MAP_TimerLoadGet \ + ROM_TimerLoadGet +#else +#define MAP_TimerLoadGet \ + TimerLoadGet +#endif +#ifdef ROM_TimerValueGet +#define MAP_TimerValueGet \ + ROM_TimerValueGet +#else +#define MAP_TimerValueGet \ + TimerValueGet +#endif +#ifdef ROM_TimerMatchSet +#define MAP_TimerMatchSet \ + ROM_TimerMatchSet +#else +#define MAP_TimerMatchSet \ + TimerMatchSet +#endif +#ifdef ROM_TimerMatchGet +#define MAP_TimerMatchGet \ + ROM_TimerMatchGet +#else +#define MAP_TimerMatchGet \ + TimerMatchGet +#endif +#ifdef ROM_TimerIntEnable +#define MAP_TimerIntEnable \ + ROM_TimerIntEnable +#else +#define MAP_TimerIntEnable \ + TimerIntEnable +#endif +#ifdef ROM_TimerIntDisable +#define MAP_TimerIntDisable \ + ROM_TimerIntDisable +#else +#define MAP_TimerIntDisable \ + TimerIntDisable +#endif +#ifdef ROM_TimerIntStatus +#define MAP_TimerIntStatus \ + ROM_TimerIntStatus +#else +#define MAP_TimerIntStatus \ + TimerIntStatus +#endif +#ifdef ROM_TimerControlWaitOnTrigger +#define MAP_TimerControlWaitOnTrigger \ + ROM_TimerControlWaitOnTrigger +#else +#define MAP_TimerControlWaitOnTrigger \ + TimerControlWaitOnTrigger +#endif + +//***************************************************************************** +// +// Macros for the UART API. +// +//***************************************************************************** +#ifdef ROM_UARTCharPut +#define MAP_UARTCharPut \ + ROM_UARTCharPut +#else +#define MAP_UARTCharPut \ + UARTCharPut +#endif +#ifdef ROM_UARTParityModeSet +#define MAP_UARTParityModeSet \ + ROM_UARTParityModeSet +#else +#define MAP_UARTParityModeSet \ + UARTParityModeSet +#endif +#ifdef ROM_UARTParityModeGet +#define MAP_UARTParityModeGet \ + ROM_UARTParityModeGet +#else +#define MAP_UARTParityModeGet \ + UARTParityModeGet +#endif +#ifdef ROM_UARTFIFOLevelSet +#define MAP_UARTFIFOLevelSet \ + ROM_UARTFIFOLevelSet +#else +#define MAP_UARTFIFOLevelSet \ + UARTFIFOLevelSet +#endif +#ifdef ROM_UARTFIFOLevelGet +#define MAP_UARTFIFOLevelGet \ + ROM_UARTFIFOLevelGet +#else +#define MAP_UARTFIFOLevelGet \ + UARTFIFOLevelGet +#endif +#ifdef ROM_UARTConfigSetExpClk +#define MAP_UARTConfigSetExpClk \ + ROM_UARTConfigSetExpClk +#else +#define MAP_UARTConfigSetExpClk \ + UARTConfigSetExpClk +#endif +#ifdef ROM_UARTConfigGetExpClk +#define MAP_UARTConfigGetExpClk \ + ROM_UARTConfigGetExpClk +#else +#define MAP_UARTConfigGetExpClk \ + UARTConfigGetExpClk +#endif +#ifdef ROM_UARTEnable +#define MAP_UARTEnable \ + ROM_UARTEnable +#else +#define MAP_UARTEnable \ + UARTEnable +#endif +#ifdef ROM_UARTDisable +#define MAP_UARTDisable \ + ROM_UARTDisable +#else +#define MAP_UARTDisable \ + UARTDisable +#endif +#ifdef ROM_UARTEnableSIR +#define MAP_UARTEnableSIR \ + ROM_UARTEnableSIR +#else +#define MAP_UARTEnableSIR \ + UARTEnableSIR +#endif +#ifdef ROM_UARTDisableSIR +#define MAP_UARTDisableSIR \ + ROM_UARTDisableSIR +#else +#define MAP_UARTDisableSIR \ + UARTDisableSIR +#endif +#ifdef ROM_UARTCharsAvail +#define MAP_UARTCharsAvail \ + ROM_UARTCharsAvail +#else +#define MAP_UARTCharsAvail \ + UARTCharsAvail +#endif +#ifdef ROM_UARTSpaceAvail +#define MAP_UARTSpaceAvail \ + ROM_UARTSpaceAvail +#else +#define MAP_UARTSpaceAvail \ + UARTSpaceAvail +#endif +#ifdef ROM_UARTCharGetNonBlocking +#define MAP_UARTCharGetNonBlocking \ + ROM_UARTCharGetNonBlocking +#else +#define MAP_UARTCharGetNonBlocking \ + UARTCharGetNonBlocking +#endif +#ifdef ROM_UARTCharGet +#define MAP_UARTCharGet \ + ROM_UARTCharGet +#else +#define MAP_UARTCharGet \ + UARTCharGet +#endif +#ifdef ROM_UARTCharPutNonBlocking +#define MAP_UARTCharPutNonBlocking \ + ROM_UARTCharPutNonBlocking +#else +#define MAP_UARTCharPutNonBlocking \ + UARTCharPutNonBlocking +#endif +#ifdef ROM_UARTBreakCtl +#define MAP_UARTBreakCtl \ + ROM_UARTBreakCtl +#else +#define MAP_UARTBreakCtl \ + UARTBreakCtl +#endif +#ifdef ROM_UARTIntEnable +#define MAP_UARTIntEnable \ + ROM_UARTIntEnable +#else +#define MAP_UARTIntEnable \ + UARTIntEnable +#endif +#ifdef ROM_UARTIntDisable +#define MAP_UARTIntDisable \ + ROM_UARTIntDisable +#else +#define MAP_UARTIntDisable \ + UARTIntDisable +#endif +#ifdef ROM_UARTIntStatus +#define MAP_UARTIntStatus \ + ROM_UARTIntStatus +#else +#define MAP_UARTIntStatus \ + UARTIntStatus +#endif +#ifdef ROM_UARTIntClear +#define MAP_UARTIntClear \ + ROM_UARTIntClear +#else +#define MAP_UARTIntClear \ + UARTIntClear +#endif +#ifdef ROM_UARTDMAEnable +#define MAP_UARTDMAEnable \ + ROM_UARTDMAEnable +#else +#define MAP_UARTDMAEnable \ + UARTDMAEnable +#endif +#ifdef ROM_UARTDMADisable +#define MAP_UARTDMADisable \ + ROM_UARTDMADisable +#else +#define MAP_UARTDMADisable \ + UARTDMADisable +#endif +#ifdef ROM_UARTFIFOEnable +#define MAP_UARTFIFOEnable \ + ROM_UARTFIFOEnable +#else +#define MAP_UARTFIFOEnable \ + UARTFIFOEnable +#endif +#ifdef ROM_UARTFIFODisable +#define MAP_UARTFIFODisable \ + ROM_UARTFIFODisable +#else +#define MAP_UARTFIFODisable \ + UARTFIFODisable +#endif +#ifdef ROM_UARTBusy +#define MAP_UARTBusy \ + ROM_UARTBusy +#else +#define MAP_UARTBusy \ + UARTBusy +#endif +#ifdef ROM_UARTTxIntModeSet +#define MAP_UARTTxIntModeSet \ + ROM_UARTTxIntModeSet +#else +#define MAP_UARTTxIntModeSet \ + UARTTxIntModeSet +#endif +#ifdef ROM_UARTTxIntModeGet +#define MAP_UARTTxIntModeGet \ + ROM_UARTTxIntModeGet +#else +#define MAP_UARTTxIntModeGet \ + UARTTxIntModeGet +#endif +#ifdef ROM_UARTRxErrorGet +#define MAP_UARTRxErrorGet \ + ROM_UARTRxErrorGet +#else +#define MAP_UARTRxErrorGet \ + UARTRxErrorGet +#endif +#ifdef ROM_UARTRxErrorClear +#define MAP_UARTRxErrorClear \ + ROM_UARTRxErrorClear +#else +#define MAP_UARTRxErrorClear \ + UARTRxErrorClear +#endif + +//***************************************************************************** +// +// Macros for the uDMA API. +// +//***************************************************************************** +#ifdef ROM_uDMAChannelTransferSet +#define MAP_uDMAChannelTransferSet \ + ROM_uDMAChannelTransferSet +#else +#define MAP_uDMAChannelTransferSet \ + uDMAChannelTransferSet +#endif +#ifdef ROM_uDMAEnable +#define MAP_uDMAEnable \ + ROM_uDMAEnable +#else +#define MAP_uDMAEnable \ + uDMAEnable +#endif +#ifdef ROM_uDMADisable +#define MAP_uDMADisable \ + ROM_uDMADisable +#else +#define MAP_uDMADisable \ + uDMADisable +#endif +#ifdef ROM_uDMAErrorStatusGet +#define MAP_uDMAErrorStatusGet \ + ROM_uDMAErrorStatusGet +#else +#define MAP_uDMAErrorStatusGet \ + uDMAErrorStatusGet +#endif +#ifdef ROM_uDMAErrorStatusClear +#define MAP_uDMAErrorStatusClear \ + ROM_uDMAErrorStatusClear +#else +#define MAP_uDMAErrorStatusClear \ + uDMAErrorStatusClear +#endif +#ifdef ROM_uDMAChannelEnable +#define MAP_uDMAChannelEnable \ + ROM_uDMAChannelEnable +#else +#define MAP_uDMAChannelEnable \ + uDMAChannelEnable +#endif +#ifdef ROM_uDMAChannelDisable +#define MAP_uDMAChannelDisable \ + ROM_uDMAChannelDisable +#else +#define MAP_uDMAChannelDisable \ + uDMAChannelDisable +#endif +#ifdef ROM_uDMAChannelIsEnabled +#define MAP_uDMAChannelIsEnabled \ + ROM_uDMAChannelIsEnabled +#else +#define MAP_uDMAChannelIsEnabled \ + uDMAChannelIsEnabled +#endif +#ifdef ROM_uDMAControlBaseSet +#define MAP_uDMAControlBaseSet \ + ROM_uDMAControlBaseSet +#else +#define MAP_uDMAControlBaseSet \ + uDMAControlBaseSet +#endif +#ifdef ROM_uDMAControlBaseGet +#define MAP_uDMAControlBaseGet \ + ROM_uDMAControlBaseGet +#else +#define MAP_uDMAControlBaseGet \ + uDMAControlBaseGet +#endif +#ifdef ROM_uDMAChannelRequest +#define MAP_uDMAChannelRequest \ + ROM_uDMAChannelRequest +#else +#define MAP_uDMAChannelRequest \ + uDMAChannelRequest +#endif +#ifdef ROM_uDMAChannelAttributeEnable +#define MAP_uDMAChannelAttributeEnable \ + ROM_uDMAChannelAttributeEnable +#else +#define MAP_uDMAChannelAttributeEnable \ + uDMAChannelAttributeEnable +#endif +#ifdef ROM_uDMAChannelAttributeDisable +#define MAP_uDMAChannelAttributeDisable \ + ROM_uDMAChannelAttributeDisable +#else +#define MAP_uDMAChannelAttributeDisable \ + uDMAChannelAttributeDisable +#endif +#ifdef ROM_uDMAChannelAttributeGet +#define MAP_uDMAChannelAttributeGet \ + ROM_uDMAChannelAttributeGet +#else +#define MAP_uDMAChannelAttributeGet \ + uDMAChannelAttributeGet +#endif +#ifdef ROM_uDMAChannelControlSet +#define MAP_uDMAChannelControlSet \ + ROM_uDMAChannelControlSet +#else +#define MAP_uDMAChannelControlSet \ + uDMAChannelControlSet +#endif +#ifdef ROM_uDMAChannelSizeGet +#define MAP_uDMAChannelSizeGet \ + ROM_uDMAChannelSizeGet +#else +#define MAP_uDMAChannelSizeGet \ + uDMAChannelSizeGet +#endif +#ifdef ROM_uDMAChannelModeGet +#define MAP_uDMAChannelModeGet \ + ROM_uDMAChannelModeGet +#else +#define MAP_uDMAChannelModeGet \ + uDMAChannelModeGet +#endif +#ifdef ROM_uDMAChannelSelectSecondary +#define MAP_uDMAChannelSelectSecondary \ + ROM_uDMAChannelSelectSecondary +#else +#define MAP_uDMAChannelSelectSecondary \ + uDMAChannelSelectSecondary +#endif +#ifdef ROM_uDMAChannelSelectDefault +#define MAP_uDMAChannelSelectDefault \ + ROM_uDMAChannelSelectDefault +#else +#define MAP_uDMAChannelSelectDefault \ + uDMAChannelSelectDefault +#endif + +//***************************************************************************** +// +// Macros for the USB API. +// +//***************************************************************************** +#ifdef ROM_USBIntStatus +#define MAP_USBIntStatus \ + ROM_USBIntStatus +#else +#define MAP_USBIntStatus \ + USBIntStatus +#endif +#ifdef ROM_USBDevAddrGet +#define MAP_USBDevAddrGet \ + ROM_USBDevAddrGet +#else +#define MAP_USBDevAddrGet \ + USBDevAddrGet +#endif +#ifdef ROM_USBDevAddrSet +#define MAP_USBDevAddrSet \ + ROM_USBDevAddrSet +#else +#define MAP_USBDevAddrSet \ + USBDevAddrSet +#endif +#ifdef ROM_USBDevConnect +#define MAP_USBDevConnect \ + ROM_USBDevConnect +#else +#define MAP_USBDevConnect \ + USBDevConnect +#endif +#ifdef ROM_USBDevDisconnect +#define MAP_USBDevDisconnect \ + ROM_USBDevDisconnect +#else +#define MAP_USBDevDisconnect \ + USBDevDisconnect +#endif +#ifdef ROM_USBDevEndpointConfigSet +#define MAP_USBDevEndpointConfigSet \ + ROM_USBDevEndpointConfigSet +#else +#define MAP_USBDevEndpointConfigSet \ + USBDevEndpointConfigSet +#endif +#ifdef ROM_USBDevEndpointDataAck +#define MAP_USBDevEndpointDataAck \ + ROM_USBDevEndpointDataAck +#else +#define MAP_USBDevEndpointDataAck \ + USBDevEndpointDataAck +#endif +#ifdef ROM_USBDevEndpointStall +#define MAP_USBDevEndpointStall \ + ROM_USBDevEndpointStall +#else +#define MAP_USBDevEndpointStall \ + USBDevEndpointStall +#endif +#ifdef ROM_USBDevEndpointStatusClear +#define MAP_USBDevEndpointStatusClear \ + ROM_USBDevEndpointStatusClear +#else +#define MAP_USBDevEndpointStatusClear \ + USBDevEndpointStatusClear +#endif +#ifdef ROM_USBEndpointDataGet +#define MAP_USBEndpointDataGet \ + ROM_USBEndpointDataGet +#else +#define MAP_USBEndpointDataGet \ + USBEndpointDataGet +#endif +#ifdef ROM_USBEndpointDataPut +#define MAP_USBEndpointDataPut \ + ROM_USBEndpointDataPut +#else +#define MAP_USBEndpointDataPut \ + USBEndpointDataPut +#endif +#ifdef ROM_USBEndpointDataSend +#define MAP_USBEndpointDataSend \ + ROM_USBEndpointDataSend +#else +#define MAP_USBEndpointDataSend \ + USBEndpointDataSend +#endif +#ifdef ROM_USBEndpointDataToggleClear +#define MAP_USBEndpointDataToggleClear \ + ROM_USBEndpointDataToggleClear +#else +#define MAP_USBEndpointDataToggleClear \ + USBEndpointDataToggleClear +#endif +#ifdef ROM_USBEndpointStatus +#define MAP_USBEndpointStatus \ + ROM_USBEndpointStatus +#else +#define MAP_USBEndpointStatus \ + USBEndpointStatus +#endif +#ifdef ROM_USBFIFOAddrGet +#define MAP_USBFIFOAddrGet \ + ROM_USBFIFOAddrGet +#else +#define MAP_USBFIFOAddrGet \ + USBFIFOAddrGet +#endif +#ifdef ROM_USBFIFOConfigGet +#define MAP_USBFIFOConfigGet \ + ROM_USBFIFOConfigGet +#else +#define MAP_USBFIFOConfigGet \ + USBFIFOConfigGet +#endif +#ifdef ROM_USBFIFOConfigSet +#define MAP_USBFIFOConfigSet \ + ROM_USBFIFOConfigSet +#else +#define MAP_USBFIFOConfigSet \ + USBFIFOConfigSet +#endif +#ifdef ROM_USBFrameNumberGet +#define MAP_USBFrameNumberGet \ + ROM_USBFrameNumberGet +#else +#define MAP_USBFrameNumberGet \ + USBFrameNumberGet +#endif +#ifdef ROM_USBHostAddrGet +#define MAP_USBHostAddrGet \ + ROM_USBHostAddrGet +#else +#define MAP_USBHostAddrGet \ + USBHostAddrGet +#endif +#ifdef ROM_USBHostAddrSet +#define MAP_USBHostAddrSet \ + ROM_USBHostAddrSet +#else +#define MAP_USBHostAddrSet \ + USBHostAddrSet +#endif +#ifdef ROM_USBHostEndpointConfig +#define MAP_USBHostEndpointConfig \ + ROM_USBHostEndpointConfig +#else +#define MAP_USBHostEndpointConfig \ + USBHostEndpointConfig +#endif +#ifdef ROM_USBHostEndpointDataAck +#define MAP_USBHostEndpointDataAck \ + ROM_USBHostEndpointDataAck +#else +#define MAP_USBHostEndpointDataAck \ + USBHostEndpointDataAck +#endif +#ifdef ROM_USBHostEndpointDataToggle +#define MAP_USBHostEndpointDataToggle \ + ROM_USBHostEndpointDataToggle +#else +#define MAP_USBHostEndpointDataToggle \ + USBHostEndpointDataToggle +#endif +#ifdef ROM_USBHostEndpointStatusClear +#define MAP_USBHostEndpointStatusClear \ + ROM_USBHostEndpointStatusClear +#else +#define MAP_USBHostEndpointStatusClear \ + USBHostEndpointStatusClear +#endif +#ifdef ROM_USBHostHubAddrGet +#define MAP_USBHostHubAddrGet \ + ROM_USBHostHubAddrGet +#else +#define MAP_USBHostHubAddrGet \ + USBHostHubAddrGet +#endif +#ifdef ROM_USBHostHubAddrSet +#define MAP_USBHostHubAddrSet \ + ROM_USBHostHubAddrSet +#else +#define MAP_USBHostHubAddrSet \ + USBHostHubAddrSet +#endif +#ifdef ROM_USBHostPwrDisable +#define MAP_USBHostPwrDisable \ + ROM_USBHostPwrDisable +#else +#define MAP_USBHostPwrDisable \ + USBHostPwrDisable +#endif +#ifdef ROM_USBHostPwrEnable +#define MAP_USBHostPwrEnable \ + ROM_USBHostPwrEnable +#else +#define MAP_USBHostPwrEnable \ + USBHostPwrEnable +#endif +#ifdef ROM_USBHostPwrConfig +#define MAP_USBHostPwrConfig \ + ROM_USBHostPwrConfig +#else +#define MAP_USBHostPwrConfig \ + USBHostPwrConfig +#endif +#ifdef ROM_USBHostPwrFaultDisable +#define MAP_USBHostPwrFaultDisable \ + ROM_USBHostPwrFaultDisable +#else +#define MAP_USBHostPwrFaultDisable \ + USBHostPwrFaultDisable +#endif +#ifdef ROM_USBHostPwrFaultEnable +#define MAP_USBHostPwrFaultEnable \ + ROM_USBHostPwrFaultEnable +#else +#define MAP_USBHostPwrFaultEnable \ + USBHostPwrFaultEnable +#endif +#ifdef ROM_USBHostRequestIN +#define MAP_USBHostRequestIN \ + ROM_USBHostRequestIN +#else +#define MAP_USBHostRequestIN \ + USBHostRequestIN +#endif +#ifdef ROM_USBHostRequestStatus +#define MAP_USBHostRequestStatus \ + ROM_USBHostRequestStatus +#else +#define MAP_USBHostRequestStatus \ + USBHostRequestStatus +#endif +#ifdef ROM_USBHostReset +#define MAP_USBHostReset \ + ROM_USBHostReset +#else +#define MAP_USBHostReset \ + USBHostReset +#endif +#ifdef ROM_USBHostResume +#define MAP_USBHostResume \ + ROM_USBHostResume +#else +#define MAP_USBHostResume \ + USBHostResume +#endif +#ifdef ROM_USBHostSpeedGet +#define MAP_USBHostSpeedGet \ + ROM_USBHostSpeedGet +#else +#define MAP_USBHostSpeedGet \ + USBHostSpeedGet +#endif +#ifdef ROM_USBHostSuspend +#define MAP_USBHostSuspend \ + ROM_USBHostSuspend +#else +#define MAP_USBHostSuspend \ + USBHostSuspend +#endif +#ifdef ROM_USBIntDisable +#define MAP_USBIntDisable \ + ROM_USBIntDisable +#else +#define MAP_USBIntDisable \ + USBIntDisable +#endif +#ifdef ROM_USBIntEnable +#define MAP_USBIntEnable \ + ROM_USBIntEnable +#else +#define MAP_USBIntEnable \ + USBIntEnable +#endif +#ifdef ROM_USBDevEndpointConfigGet +#define MAP_USBDevEndpointConfigGet \ + ROM_USBDevEndpointConfigGet +#else +#define MAP_USBDevEndpointConfigGet \ + USBDevEndpointConfigGet +#endif +#ifdef ROM_USBEndpointDataAvail +#define MAP_USBEndpointDataAvail \ + ROM_USBEndpointDataAvail +#else +#define MAP_USBEndpointDataAvail \ + USBEndpointDataAvail +#endif +#ifdef ROM_USBOTGHostRequest +#define MAP_USBOTGHostRequest \ + ROM_USBOTGHostRequest +#else +#define MAP_USBOTGHostRequest \ + USBOTGHostRequest +#endif +#ifdef ROM_USBModeGet +#define MAP_USBModeGet \ + ROM_USBModeGet +#else +#define MAP_USBModeGet \ + USBModeGet +#endif +#ifdef ROM_USBEndpointDMAChannel +#define MAP_USBEndpointDMAChannel \ + ROM_USBEndpointDMAChannel +#else +#define MAP_USBEndpointDMAChannel \ + USBEndpointDMAChannel +#endif +#ifdef ROM_USBIntDisableControl +#define MAP_USBIntDisableControl \ + ROM_USBIntDisableControl +#else +#define MAP_USBIntDisableControl \ + USBIntDisableControl +#endif +#ifdef ROM_USBIntEnableControl +#define MAP_USBIntEnableControl \ + ROM_USBIntEnableControl +#else +#define MAP_USBIntEnableControl \ + USBIntEnableControl +#endif +#ifdef ROM_USBIntStatusControl +#define MAP_USBIntStatusControl \ + ROM_USBIntStatusControl +#else +#define MAP_USBIntStatusControl \ + USBIntStatusControl +#endif +#ifdef ROM_USBIntDisableEndpoint +#define MAP_USBIntDisableEndpoint \ + ROM_USBIntDisableEndpoint +#else +#define MAP_USBIntDisableEndpoint \ + USBIntDisableEndpoint +#endif +#ifdef ROM_USBIntEnableEndpoint +#define MAP_USBIntEnableEndpoint \ + ROM_USBIntEnableEndpoint +#else +#define MAP_USBIntEnableEndpoint \ + USBIntEnableEndpoint +#endif +#ifdef ROM_USBIntStatusEndpoint +#define MAP_USBIntStatusEndpoint \ + ROM_USBIntStatusEndpoint +#else +#define MAP_USBIntStatusEndpoint \ + USBIntStatusEndpoint +#endif + +//***************************************************************************** +// +// Macros for the Watchdog API. +// +//***************************************************************************** +#ifdef ROM_WatchdogIntClear +#define MAP_WatchdogIntClear \ + ROM_WatchdogIntClear +#else +#define MAP_WatchdogIntClear \ + WatchdogIntClear +#endif +#ifdef ROM_WatchdogRunning +#define MAP_WatchdogRunning \ + ROM_WatchdogRunning +#else +#define MAP_WatchdogRunning \ + WatchdogRunning +#endif +#ifdef ROM_WatchdogEnable +#define MAP_WatchdogEnable \ + ROM_WatchdogEnable +#else +#define MAP_WatchdogEnable \ + WatchdogEnable +#endif +#ifdef ROM_WatchdogResetEnable +#define MAP_WatchdogResetEnable \ + ROM_WatchdogResetEnable +#else +#define MAP_WatchdogResetEnable \ + WatchdogResetEnable +#endif +#ifdef ROM_WatchdogResetDisable +#define MAP_WatchdogResetDisable \ + ROM_WatchdogResetDisable +#else +#define MAP_WatchdogResetDisable \ + WatchdogResetDisable +#endif +#ifdef ROM_WatchdogLock +#define MAP_WatchdogLock \ + ROM_WatchdogLock +#else +#define MAP_WatchdogLock \ + WatchdogLock +#endif +#ifdef ROM_WatchdogUnlock +#define MAP_WatchdogUnlock \ + ROM_WatchdogUnlock +#else +#define MAP_WatchdogUnlock \ + WatchdogUnlock +#endif +#ifdef ROM_WatchdogLockState +#define MAP_WatchdogLockState \ + ROM_WatchdogLockState +#else +#define MAP_WatchdogLockState \ + WatchdogLockState +#endif +#ifdef ROM_WatchdogReloadSet +#define MAP_WatchdogReloadSet \ + ROM_WatchdogReloadSet +#else +#define MAP_WatchdogReloadSet \ + WatchdogReloadSet +#endif +#ifdef ROM_WatchdogReloadGet +#define MAP_WatchdogReloadGet \ + ROM_WatchdogReloadGet +#else +#define MAP_WatchdogReloadGet \ + WatchdogReloadGet +#endif +#ifdef ROM_WatchdogValueGet +#define MAP_WatchdogValueGet \ + ROM_WatchdogValueGet +#else +#define MAP_WatchdogValueGet \ + WatchdogValueGet +#endif +#ifdef ROM_WatchdogIntEnable +#define MAP_WatchdogIntEnable \ + ROM_WatchdogIntEnable +#else +#define MAP_WatchdogIntEnable \ + WatchdogIntEnable +#endif +#ifdef ROM_WatchdogIntStatus +#define MAP_WatchdogIntStatus \ + ROM_WatchdogIntStatus +#else +#define MAP_WatchdogIntStatus \ + WatchdogIntStatus +#endif +#ifdef ROM_WatchdogStallEnable +#define MAP_WatchdogStallEnable \ + ROM_WatchdogStallEnable +#else +#define MAP_WatchdogStallEnable \ + WatchdogStallEnable +#endif +#ifdef ROM_WatchdogStallDisable +#define MAP_WatchdogStallDisable \ + ROM_WatchdogStallDisable +#else +#define MAP_WatchdogStallDisable \ + WatchdogStallDisable +#endif + +//***************************************************************************** +// +// Deprecated ROM functions. +// +//***************************************************************************** +#ifndef DEPRECATED +#define MAP_FlashIntGetStatus \ + MAP_FlashIntStatus +#define MAP_USBDevEndpointConfig \ + MAP_USBDevEndpointConfigSet +#define MAP_USBHostPwrFaultConfig \ + MAP_USBHostPwrConfig +#endif + +#endif // __ROM_MAP_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ssi.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ssi.c new file mode 100644 index 00000000..48923091 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ssi.c @@ -0,0 +1,706 @@ +//***************************************************************************** +// +// ssi.c - Driver for Synchronous Serial Interface. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup ssi_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_ssi.h" +#include "inc/hw_types.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" +#include "driverlib/ssi.h" + +//***************************************************************************** +// +//! Configures the synchronous serial interface. +//! +//! \param ulBase specifies the SSI module base address. +//! \param ulSSIClk is the rate of the clock supplied to the SSI module. +//! \param ulProtocol specifies the data transfer protocol. +//! \param ulMode specifies the mode of operation. +//! \param ulBitRate specifies the clock rate. +//! \param ulDataWidth specifies number of bits transferred per frame. +//! +//! This function configures the synchronous serial interface. It sets +//! the SSI protocol, mode of operation, bit rate, and data width. +//! +//! The \e ulProtocol parameter defines the data frame format. The +//! \e ulProtocol parameter can be one of the following values: +//! \b SSI_FRF_MOTO_MODE_0, \b SSI_FRF_MOTO_MODE_1, \b SSI_FRF_MOTO_MODE_2, +//! \b SSI_FRF_MOTO_MODE_3, \b SSI_FRF_TI, or \b SSI_FRF_NMW. The Motorola +//! frame formats imply the following polarity and phase configurations: +//! +//! 

    +//! Polarity Phase       Mode
+//!   0       0   SSI_FRF_MOTO_MODE_0
+//!   0       1   SSI_FRF_MOTO_MODE_1
+//!   1       0   SSI_FRF_MOTO_MODE_2
+//!   1       1   SSI_FRF_MOTO_MODE_3
+//!
    +//! +//! The \e ulMode parameter defines the operating mode of the SSI module. The +//! SSI module can operate as a master or slave; if a slave, the SSI can be +//! configured to disable output on its serial output line. The \e ulMode +//! parameter can be one of the following values: \b SSI_MODE_MASTER, +//! \b SSI_MODE_SLAVE, or \b SSI_MODE_SLAVE_OD. +//! +//! The \e ulBitRate parameter defines the bit rate for the SSI. This bit rate +//! must satisfy the following clock ratio criteria: +//! +//! - FSSI >= 2 * bit rate (master mode) +//! - FSSI >= 12 * bit rate (slave modes) +//! +//! where FSSI is the frequency of the clock supplied to the SSI module. +//! +//! The \e ulDataWidth parameter defines the width of the data transfers, and +//! can be a value between 4 and 16, inclusive. +//! +//! The peripheral clock will be the same as the processor clock. This will be +//! the value returned by SysCtlClockGet(), or it can be explicitly hard coded +//! if it is constant and known (to save the code/execution overhead of a call +//! to SysCtlClockGet()). +//! +//! This function replaces the original SSIConfig() API and performs the same +//! actions. A macro is provided in ssi.h to map the original API to +//! this API. +//! +//! \return None. +// +//***************************************************************************** +void +SSIConfigSetExpClk(unsigned long ulBase, unsigned long ulSSIClk, + unsigned long ulProtocol, unsigned long ulMode, + unsigned long ulBitRate, unsigned long ulDataWidth) +{ + unsigned long ulMaxBitRate; + unsigned long ulRegVal; + unsigned long ulPreDiv; + unsigned long ulSCR; + unsigned long ulSPH_SPO; + + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + ASSERT((ulProtocol == SSI_FRF_MOTO_MODE_0) || + (ulProtocol == SSI_FRF_MOTO_MODE_1) || + (ulProtocol == SSI_FRF_MOTO_MODE_2) || + (ulProtocol == SSI_FRF_MOTO_MODE_3) || + (ulProtocol == SSI_FRF_TI) || + (ulProtocol == SSI_FRF_NMW)); + ASSERT((ulMode == SSI_MODE_MASTER) || + (ulMode == SSI_MODE_SLAVE) || + (ulMode == SSI_MODE_SLAVE_OD)); + ASSERT(((ulMode == SSI_MODE_MASTER) && (ulBitRate <= (ulSSIClk / 2))) || + ((ulMode != SSI_MODE_MASTER) && (ulBitRate <= (ulSSIClk / 12)))); + ASSERT((ulSSIClk / ulBitRate) <= (254 * 256)); + ASSERT((ulDataWidth >= 4) && (ulDataWidth <= 16)); + + // + // Set the mode. + // + ulRegVal = (ulMode == SSI_MODE_SLAVE_OD) ? SSI_CR1_SOD : 0; + ulRegVal |= (ulMode == SSI_MODE_MASTER) ? 0 : SSI_CR1_MS; + HWREG(ulBase + SSI_O_CR1) = ulRegVal; + + // + // Set the clock predivider. + // + ulMaxBitRate = ulSSIClk / ulBitRate; + ulPreDiv = 0; + do + { + ulPreDiv += 2; + ulSCR = (ulMaxBitRate / ulPreDiv) - 1; + } + while(ulSCR > 255); + HWREG(ulBase + SSI_O_CPSR) = ulPreDiv; + + // + // Set protocol and clock rate. + // + ulSPH_SPO = (ulProtocol & 3) << 6; + ulProtocol &= SSI_CR0_FRF_M; + ulRegVal = (ulSCR << 8) | ulSPH_SPO | ulProtocol | (ulDataWidth - 1); + HWREG(ulBase + SSI_O_CR0) = ulRegVal; +} + +//***************************************************************************** +// +//! Enables the synchronous serial interface. +//! +//! \param ulBase specifies the SSI module base address. +//! +//! This function enables operation of the synchronous serial interface. The +//! synchronous serial interface must be configured before it is enabled. +//! +//! \return None. +// +//***************************************************************************** +void +SSIEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + + // + // Read-modify-write the enable bit. + // + HWREG(ulBase + SSI_O_CR1) |= SSI_CR1_SSE; +} + +//***************************************************************************** +// +//! Disables the synchronous serial interface. +//! +//! \param ulBase specifies the SSI module base address. +//! +//! This function disables operation of the synchronous serial interface. +//! +//! \return None. +// +//***************************************************************************** +void +SSIDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + + // + // Read-modify-write the enable bit. + // + HWREG(ulBase + SSI_O_CR1) &= ~(SSI_CR1_SSE); +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the synchronous serial interface. +//! +//! \param ulBase specifies the SSI module base address. +//! \param pfnHandler is a pointer to the function to be called when the +//! synchronous serial interface interrupt occurs. +//! +//! This sets the handler to be called when an SSI interrupt +//! occurs. This will enable the global interrupt in the interrupt controller; +//! specific SSI interrupts must be enabled via SSIIntEnable(). If necessary, +//! it is the interrupt handler's responsibility to clear the interrupt source +//! via SSIIntClear(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +SSIIntRegister(unsigned long ulBase, void (*pfnHandler)(void)) +{ + unsigned long ulInt; + + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + + // + // Determine the interrupt number based on the SSI port. + // + ulInt = (ulBase == SSI0_BASE) ? INT_SSI0 : INT_SSI1; + + // + // Register the interrupt handler, returning an error if an error occurs. + // + IntRegister(ulInt, pfnHandler); + + // + // Enable the synchronous serial interface interrupt. + // + IntEnable(ulInt); +} + +//***************************************************************************** +// +//! Unregisters an interrupt handler for the synchronous serial interface. +//! +//! \param ulBase specifies the SSI module base address. +//! +//! This function will clear the handler to be called when a SSI +//! interrupt occurs. This will also mask off the interrupt in the interrupt +//! controller so that the interrupt handler no longer is called. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +SSIIntUnregister(unsigned long ulBase) +{ + unsigned long ulInt; + + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + + // + // Determine the interrupt number based on the SSI port. + // + ulInt = (ulBase == SSI0_BASE) ? INT_SSI0 : INT_SSI1; + + // + // Disable the interrupt. + // + IntDisable(ulInt); + + // + // Unregister the interrupt handler. + // + IntUnregister(ulInt); +} + +//***************************************************************************** +// +//! Enables individual SSI interrupt sources. +//! +//! \param ulBase specifies the SSI module base address. +//! \param ulIntFlags is a bit mask of the interrupt sources to be enabled. +//! +//! Enables the indicated SSI interrupt sources. Only the sources that are +//! enabled can be reflected to the processor interrupt; disabled sources have +//! no effect on the processor. The \e ulIntFlags parameter can be any of the +//! \b SSI_TXFF, \b SSI_RXFF, \b SSI_RXTO, or \b SSI_RXOR values. +//! +//! \return None. +// +//***************************************************************************** +void +SSIIntEnable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + + // + // Enable the specified interrupts. + // + HWREG(ulBase + SSI_O_IM) |= ulIntFlags; +} + +//***************************************************************************** +// +//! Disables individual SSI interrupt sources. +//! +//! \param ulBase specifies the SSI module base address. +//! \param ulIntFlags is a bit mask of the interrupt sources to be disabled. +//! +//! Disables the indicated SSI interrupt sources. The \e ulIntFlags parameter +//! can be any of the \b SSI_TXFF, \b SSI_RXFF, \b SSI_RXTO, or \b SSI_RXOR +//! values. +//! +//! \return None. +// +//***************************************************************************** +void +SSIIntDisable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + + // + // Disable the specified interrupts. + // + HWREG(ulBase + SSI_O_IM) &= ~(ulIntFlags); +} + +//***************************************************************************** +// +//! Gets the current interrupt status. +//! +//! \param ulBase specifies the SSI module base address. +//! \param bMasked is \b false if the raw interrupt status is required or +//! \b true if the masked interrupt status is required. +//! +//! This function returns the interrupt status for the SSI module. Either the +//! raw interrupt status or the status of interrupts that are allowed to +//! reflect to the processor can be returned. +//! +//! \return The current interrupt status, enumerated as a bit field of +//! \b SSI_TXFF, \b SSI_RXFF, \b SSI_RXTO, and \b SSI_RXOR. +// +//***************************************************************************** +unsigned long +SSIIntStatus(unsigned long ulBase, tBoolean bMasked) +{ + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + return(HWREG(ulBase + SSI_O_MIS)); + } + else + { + return(HWREG(ulBase + SSI_O_RIS)); + } +} + +//***************************************************************************** +// +//! Clears SSI interrupt sources. +//! +//! \param ulBase specifies the SSI module base address. +//! \param ulIntFlags is a bit mask of the interrupt sources to be cleared. +//! +//! The specified SSI interrupt sources are cleared so that they no longer +//! assert. This function must be called in the interrupt handler to keep the +//! interrupts from being recognized again immediately upon exit. The +//! \e ulIntFlags parameter can consist of either or both the \b SSI_RXTO and +//! \b SSI_RXOR values. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +SSIIntClear(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + + // + // Clear the requested interrupt sources. + // + HWREG(ulBase + SSI_O_ICR) = ulIntFlags; +} + +//***************************************************************************** +// +//! Puts a data element into the SSI transmit FIFO. +//! +//! \param ulBase specifies the SSI module base address. +//! \param ulData is the data to be transmitted over the SSI interface. +//! +//! This function places the supplied data into the transmit FIFO of the +//! specified SSI module. +//! +//! \note The upper 32 - N bits of the \e ulData are discarded by the hardware, +//! where N is the data width as configured by SSIConfigSetExpClk(). For +//! example, if the interface is configured for 8-bit data width, the upper 24 +//! bits of \e ulData are discarded. +//! +//! \return None. +// +//***************************************************************************** +void +SSIDataPut(unsigned long ulBase, unsigned long ulData) +{ + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + ASSERT((ulData & (0xfffffffe << (HWREG(ulBase + SSI_O_CR0) & + SSI_CR0_DSS_M))) == 0); + + // + // Wait until there is space. + // + while(!(HWREG(ulBase + SSI_O_SR) & SSI_SR_TNF)) + { + } + + // + // Write the data to the SSI. + // + HWREG(ulBase + SSI_O_DR) = ulData; +} + +//***************************************************************************** +// +//! Puts a data element into the SSI transmit FIFO. +//! +//! \param ulBase specifies the SSI module base address. +//! \param ulData is the data to be transmitted over the SSI interface. +//! +//! This function places the supplied data into the transmit FIFO of the +//! specified SSI module. If there is no space in the FIFO, then this function +//! returns a zero. +//! +//! This function replaces the original SSIDataNonBlockingPut() API and +//! performs the same actions. A macro is provided in ssi.h to map +//! the original API to this API. +//! +//! \note The upper 32 - N bits of the \e ulData are discarded by the hardware, +//! where N is the data width as configured by SSIConfigSetExpClk(). For +//! example, if the interface is configured for 8-bit data width, the upper 24 +//! bits of \e ulData are discarded. +//! +//! \return Returns the number of elements written to the SSI transmit FIFO. +// +//***************************************************************************** +long +SSIDataPutNonBlocking(unsigned long ulBase, unsigned long ulData) +{ + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + ASSERT((ulData & (0xfffffffe << (HWREG(ulBase + SSI_O_CR0) & + SSI_CR0_DSS_M))) == 0); + + // + // Check for space to write. + // + if(HWREG(ulBase + SSI_O_SR) & SSI_SR_TNF) + { + HWREG(ulBase + SSI_O_DR) = ulData; + return(1); + } + else + { + return(0); + } +} + +//***************************************************************************** +// +//! Gets a data element from the SSI receive FIFO. +//! +//! \param ulBase specifies the SSI module base address. +//! \param pulData is a pointer to a storage location for data that was +//! received over the SSI interface. +//! +//! This function gets received data from the receive FIFO of the specified +//! SSI module and places that data into the location specified by the +//! \e pulData parameter. +//! +//! \note Only the lower N bits of the value written to \e pulData contain +//! valid data, where N is the data width as configured by +//! SSIConfigSetExpClk(). For example, if the interface is configured for +//! 8-bit data width, only the lower 8 bits of the value written to \e pulData +//! contain valid data. +//! +//! \return None. +// +//***************************************************************************** +void +SSIDataGet(unsigned long ulBase, unsigned long *pulData) +{ + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + + // + // Wait until there is data to be read. + // + while(!(HWREG(ulBase + SSI_O_SR) & SSI_SR_RNE)) + { + } + + // + // Read data from SSI. + // + *pulData = HWREG(ulBase + SSI_O_DR); +} + +//***************************************************************************** +// +//! Gets a data element from the SSI receive FIFO. +//! +//! \param ulBase specifies the SSI module base address. +//! \param pulData is a pointer to a storage location for data that was +//! received over the SSI interface. +//! +//! This function gets received data from the receive FIFO of the specified SSI +//! module and places that data into the location specified by the \e ulData +//! parameter. If there is no data in the FIFO, then this function returns a +//! zero. +//! +//! This function replaces the original SSIDataNonBlockingGet() API and +//! performs the same actions. A macro is provided in ssi.h to map +//! the original API to this API. +//! +//! \note Only the lower N bits of the value written to \e pulData contain +//! valid data, where N is the data width as configured by +//! SSIConfigSetExpClk(). For example, if the interface is configured for +//! 8-bit data width, only the lower 8 bits of the value written to \e pulData +//! contain valid data. +//! +//! \return Returns the number of elements read from the SSI receive FIFO. +// +//***************************************************************************** +long +SSIDataGetNonBlocking(unsigned long ulBase, unsigned long *pulData) +{ + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + + // + // Check for data to read. + // + if(HWREG(ulBase + SSI_O_SR) & SSI_SR_RNE) + { + *pulData = HWREG(ulBase + SSI_O_DR); + return(1); + } + else + { + return(0); + } +} + +//***************************************************************************** +// +//! Enable SSI DMA operation. +//! +//! \param ulBase is the base address of the SSI port. +//! \param ulDMAFlags is a bit mask of the DMA features to enable. +//! +//! The specified SSI DMA features are enabled. The SSI can be +//! configured to use DMA for transmit and/or receive data transfers. +//! The \e ulDMAFlags parameter is the logical OR of any of the following +//! values: +//! +//! - SSI_DMA_RX - enable DMA for receive +//! - SSI_DMA_TX - enable DMA for transmit +//! +//! \note The uDMA controller must also be set up before DMA can be used +//! with the SSI. +//! +//! \return None. +// +//***************************************************************************** +void +SSIDMAEnable(unsigned long ulBase, unsigned long ulDMAFlags) +{ + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + + // + // Set the requested bits in the UART DMA control register. + // + HWREG(ulBase + SSI_O_DMACTL) |= ulDMAFlags; +} + +//***************************************************************************** +// +//! Disable SSI DMA operation. +//! +//! \param ulBase is the base address of the SSI port. +//! \param ulDMAFlags is a bit mask of the DMA features to disable. +//! +//! This function is used to disable SSI DMA features that were enabled +//! by SSIDMAEnable(). The specified SSI DMA features are disabled. The +//! \e ulDMAFlags parameter is the logical OR of any of the following values: +//! +//! - SSI_DMA_RX - disable DMA for receive +//! - SSI_DMA_TX - disable DMA for transmit +//! +//! \return None. +// +//***************************************************************************** +void +SSIDMADisable(unsigned long ulBase, unsigned long ulDMAFlags) +{ + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + + // + // Clear the requested bits in the UART DMA control register. + // + HWREG(ulBase + SSI_O_DMACTL) &= ~ulDMAFlags; +} + +//***************************************************************************** +// +//! Determines whether the SSI transmitter is busy or not. +//! +//! \param ulBase is the base address of the SSI port. +//! +//! Allows the caller to determine whether all transmitted bytes have cleared +//! the transmitter hardware. If \b false is returned, then the transmit FIFO +//! is empty and all bits of the last transmitted word have left the hardware +//! shift register. +//! +//! \return Returns \b true if the SSI is transmitting or \b false if all +//! transmissions are complete. +// +//***************************************************************************** +tBoolean +SSIBusy(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == SSI0_BASE) || (ulBase == SSI1_BASE)); + + // + // Determine if the SSI is busy. + // + return((HWREG(ulBase + SSI_O_SR) & SSI_SR_BSY) ? true : false); +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ssi.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ssi.h new file mode 100644 index 00000000..7970bdda --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/ssi.h @@ -0,0 +1,125 @@ +//***************************************************************************** +// +// ssi.h - Prototypes for the Synchronous Serial Interface Driver. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __SSI_H__ +#define __SSI_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Values that can be passed to SSIIntEnable, SSIIntDisable, and SSIIntClear +// as the ulIntFlags parameter, and returned by SSIIntStatus. +// +//***************************************************************************** +#define SSI_TXFF 0x00000008 // TX FIFO half full or less +#define SSI_RXFF 0x00000004 // RX FIFO half full or more +#define SSI_RXTO 0x00000002 // RX timeout +#define SSI_RXOR 0x00000001 // RX overrun + +//***************************************************************************** +// +// Values that can be passed to SSIConfigSetExpClk. +// +//***************************************************************************** +#define SSI_FRF_MOTO_MODE_0 0x00000000 // Moto fmt, polarity 0, phase 0 +#define SSI_FRF_MOTO_MODE_1 0x00000002 // Moto fmt, polarity 0, phase 1 +#define SSI_FRF_MOTO_MODE_2 0x00000001 // Moto fmt, polarity 1, phase 0 +#define SSI_FRF_MOTO_MODE_3 0x00000003 // Moto fmt, polarity 1, phase 1 +#define SSI_FRF_TI 0x00000010 // TI frame format +#define SSI_FRF_NMW 0x00000020 // National MicroWire frame format + +#define SSI_MODE_MASTER 0x00000000 // SSI master +#define SSI_MODE_SLAVE 0x00000001 // SSI slave +#define SSI_MODE_SLAVE_OD 0x00000002 // SSI slave with output disabled + +//***************************************************************************** +// +// Values that can be passed to SSIDMAEnable() and SSIDMADisable(). +// +//***************************************************************************** +#define SSI_DMA_TX 0x00000002 // Enable DMA for transmit +#define SSI_DMA_RX 0x00000001 // Enable DMA for receive + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern void SSIConfigSetExpClk(unsigned long ulBase, unsigned long ulSSIClk, + unsigned long ulProtocol, unsigned long ulMode, + unsigned long ulBitRate, + unsigned long ulDataWidth); +extern void SSIDataGet(unsigned long ulBase, unsigned long *pulData); +extern long SSIDataGetNonBlocking(unsigned long ulBase, + unsigned long *pulData); +extern void SSIDataPut(unsigned long ulBase, unsigned long ulData); +extern long SSIDataPutNonBlocking(unsigned long ulBase, unsigned long ulData); +extern void SSIDisable(unsigned long ulBase); +extern void SSIEnable(unsigned long ulBase); +extern void SSIIntClear(unsigned long ulBase, unsigned long ulIntFlags); +extern void SSIIntDisable(unsigned long ulBase, unsigned long ulIntFlags); +extern void SSIIntEnable(unsigned long ulBase, unsigned long ulIntFlags); +extern void SSIIntRegister(unsigned long ulBase, void(*pfnHandler)(void)); +extern unsigned long SSIIntStatus(unsigned long ulBase, tBoolean bMasked); +extern void SSIIntUnregister(unsigned long ulBase); +extern void SSIDMAEnable(unsigned long ulBase, unsigned long ulDMAFlags); +extern void SSIDMADisable(unsigned long ulBase, unsigned long ulDMAFlags); +extern tBoolean SSIBusy(unsigned long ulBase); + +//***************************************************************************** +// +// Several SSI APIs have been renamed, with the original function name being +// deprecated. These defines provide backward compatibility. +// +//***************************************************************************** +#ifndef DEPRECATED +#include "driverlib/sysctl.h" +#define SSIConfig(a, b, c, d, e) \ + SSIConfigSetExpClk(a, SysCtlClockGet(), b, c, d, e) +#define SSIDataNonBlockingGet(a, b) \ + SSIDataGetNonBlocking(a, b) +#define SSIDataNonBlockingPut(a, b) \ + SSIDataPutNonBlocking(a, b) +#endif + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __SSI_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/sysctl.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/sysctl.c new file mode 100644 index 00000000..e0023a9d --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/sysctl.c @@ -0,0 +1,2366 @@ +//***************************************************************************** +// +// sysctl.c - Driver for the system controller. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup sysctl_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_ints.h" +#include "inc/hw_nvic.h" +#include "inc/hw_sysctl.h" +#include "inc/hw_types.h" +#include "driverlib/cpu.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" +#include "driverlib/sysctl.h" + +//***************************************************************************** +// +// This macro extracts the array index out of the peripheral number. +// +//***************************************************************************** +#define SYSCTL_PERIPH_INDEX(a) (((a) >> 28) & 0xf) + +//***************************************************************************** +// +// This macro constructs the peripheral bit mask from the peripheral number. +// +//***************************************************************************** +#define SYSCTL_PERIPH_MASK(a) (((a) & 0xffff) << (((a) & 0x001f0000) >> 16)) + +//***************************************************************************** +// +// An array that maps the "peripheral set" number (which is stored in the upper +// nibble of the SYSCTL_PERIPH_* defines) to the SYSCTL DC? register that +// contains the peripheral present bit for that peripheral. +// +//***************************************************************************** +static const unsigned long g_pulDCRegs[] = +{ + SYSCTL_DC1, + SYSCTL_DC2, + SYSCTL_DC4, + SYSCTL_DC1 +}; + +//***************************************************************************** +// +// An array that maps the "peripheral set" number (which is stored in the upper +// nibble of the SYSCTL_PERIPH_* defines) to the SYSCTL_SRCR? register that +// controls the software reset for that peripheral. +// +//***************************************************************************** +static const unsigned long g_pulSRCRRegs[] = +{ + SYSCTL_SRCR0, + SYSCTL_SRCR1, + SYSCTL_SRCR2 +}; + +//***************************************************************************** +// +// An array that maps the "peripheral set" number (which is stored in the upper +// nibble of the SYSCTL_PERIPH_* defines) to the SYSCTL_RCGC? register that +// controls the run-mode enable for that peripheral. +// +//***************************************************************************** +static const unsigned long g_pulRCGCRegs[] = +{ + SYSCTL_RCGC0, + SYSCTL_RCGC1, + SYSCTL_RCGC2 +}; + +//***************************************************************************** +// +// An array that maps the "peripheral set" number (which is stored in the upper +// nibble of the SYSCTL_PERIPH_* defines) to the SYSCTL_SCGC? register that +// controls the sleep-mode enable for that peripheral. +// +//***************************************************************************** +static const unsigned long g_pulSCGCRegs[] = +{ + SYSCTL_SCGC0, + SYSCTL_SCGC1, + SYSCTL_SCGC2 +}; + +//***************************************************************************** +// +// An array that maps the "peripheral set" number (which is stored in the upper +// nibble of the SYSCTL_PERIPH_* defines) to the SYSCTL_DCGC? register that +// controls the deep-sleep-mode enable for that peripheral. +// +//***************************************************************************** +static const unsigned long g_pulDCGCRegs[] = +{ + SYSCTL_DCGC0, + SYSCTL_DCGC1, + SYSCTL_DCGC2 +}; + +//***************************************************************************** +// +// An array that maps the crystal number in RCC to a frequency. +// +//***************************************************************************** +static const unsigned long g_pulXtals[] = +{ + 1000000, + 1843200, + 2000000, + 2457600, + 3579545, + 3686400, + 4000000, + 4096000, + 4915200, + 5000000, + 5120000, + 6000000, + 6144000, + 7372800, + 8000000, + 8192000, + 10000000, + 12000000, + 12288000, + 13560000, + 14318180, + 16000000, + 16384000 +}; + +//***************************************************************************** +// +//! \internal +//! Checks a peripheral identifier. +//! +//! \param ulPeripheral is the peripheral identifier. +//! +//! This function determines if a peripheral identifier is valid. +//! +//! \return Returns \b true if the peripheral identifier is valid and \b false +//! otherwise. +// +//***************************************************************************** +#ifdef DEBUG +static tBoolean +SysCtlPeripheralValid(unsigned long ulPeripheral) +{ + return((ulPeripheral == SYSCTL_PERIPH_ADC0) || + (ulPeripheral == SYSCTL_PERIPH_ADC1) || + (ulPeripheral == SYSCTL_PERIPH_CAN0) || + (ulPeripheral == SYSCTL_PERIPH_CAN1) || + (ulPeripheral == SYSCTL_PERIPH_CAN2) || + (ulPeripheral == SYSCTL_PERIPH_COMP0) || + (ulPeripheral == SYSCTL_PERIPH_COMP1) || + (ulPeripheral == SYSCTL_PERIPH_COMP2) || + (ulPeripheral == SYSCTL_PERIPH_EPI0) || + (ulPeripheral == SYSCTL_PERIPH_ETH) || + (ulPeripheral == SYSCTL_PERIPH_GPIOA) || + (ulPeripheral == SYSCTL_PERIPH_GPIOB) || + (ulPeripheral == SYSCTL_PERIPH_GPIOC) || + (ulPeripheral == SYSCTL_PERIPH_GPIOD) || + (ulPeripheral == SYSCTL_PERIPH_GPIOE) || + (ulPeripheral == SYSCTL_PERIPH_GPIOF) || + (ulPeripheral == SYSCTL_PERIPH_GPIOG) || + (ulPeripheral == SYSCTL_PERIPH_GPIOH) || + (ulPeripheral == SYSCTL_PERIPH_GPIOJ) || + (ulPeripheral == SYSCTL_PERIPH_HIBERNATE) || + (ulPeripheral == SYSCTL_PERIPH_I2C0) || + (ulPeripheral == SYSCTL_PERIPH_I2C1) || + (ulPeripheral == SYSCTL_PERIPH_I2S0) || + (ulPeripheral == SYSCTL_PERIPH_IEEE1588) || + (ulPeripheral == SYSCTL_PERIPH_MPU) || + (ulPeripheral == SYSCTL_PERIPH_PLL) || + (ulPeripheral == SYSCTL_PERIPH_PWM) || + (ulPeripheral == SYSCTL_PERIPH_QEI0) || + (ulPeripheral == SYSCTL_PERIPH_QEI1) || + (ulPeripheral == SYSCTL_PERIPH_SSI0) || + (ulPeripheral == SYSCTL_PERIPH_SSI1) || + (ulPeripheral == SYSCTL_PERIPH_TEMP) || + (ulPeripheral == SYSCTL_PERIPH_TIMER0) || + (ulPeripheral == SYSCTL_PERIPH_TIMER1) || + (ulPeripheral == SYSCTL_PERIPH_TIMER2) || + (ulPeripheral == SYSCTL_PERIPH_TIMER3) || + (ulPeripheral == SYSCTL_PERIPH_UART0) || + (ulPeripheral == SYSCTL_PERIPH_UART1) || + (ulPeripheral == SYSCTL_PERIPH_UART2) || + (ulPeripheral == SYSCTL_PERIPH_UDMA) || + (ulPeripheral == SYSCTL_PERIPH_USB0) || + (ulPeripheral == SYSCTL_PERIPH_WDOG0) || + (ulPeripheral == SYSCTL_PERIPH_WDOG1)); +} +#endif + +//***************************************************************************** +// +//! Gets the size of the SRAM. +//! +//! This function determines the size of the SRAM on the Stellaris device. +//! +//! \return The total number of bytes of SRAM. +// +//***************************************************************************** +unsigned long +SysCtlSRAMSizeGet(void) +{ + // + // Compute the size of the SRAM. + // + return(((HWREG(SYSCTL_DC0) & SYSCTL_DC0_SRAMSZ_M) >> 8) + 0x100); +} + +//***************************************************************************** +// +//! Gets the size of the flash. +//! +//! This function determines the size of the flash on the Stellaris device. +//! +//! \return The total number of bytes of flash. +// +//***************************************************************************** +unsigned long +SysCtlFlashSizeGet(void) +{ + // + // Compute the size of the flash. + // + return(((HWREG(SYSCTL_DC0) & SYSCTL_DC0_FLASHSZ_M) << 11) + 0x800); +} + +//***************************************************************************** +// +//! Determines if a pin is present. +//! +//! \param ulPin is the pin in question. +//! +//! Determines if a particular pin is present in the device. The PWM, analog +//! comparators, ADC, and timers have a varying number of pins across members +//! of the Stellaris family; this will determine which are present on this +//! device. +//! +//! The \e ulPin argument must be only one of the following values: +//! \b SYSCTL_PIN_PWM0, \b SYSCTL_PIN_PWM1, \b SYSCTL_PIN_PWM2, +//! \b SYSCTL_PIN_PWM3, \b SYSCTL_PIN_PWM4, \b SYSCTL_PIN_PWM5, +//! \b SYSCTL_PIN_C0MINUS, \b SYSCTL_PIN_C0PLUS, \b SYSCTL_PIN_C0O, +//! \b SYSCTL_PIN_C1MINUS, \b SYSCTL_PIN_C1PLUS, \b SYSCTL_PIN_C1O, +//! \b SYSCTL_PIN_C2MINUS, \b SYSCTL_PIN_C2PLUS, \b SYSCTL_PIN_C2O, +//! \b SYSCTL_PIN_ADC0, \b SYSCTL_PIN_ADC1, \b SYSCTL_PIN_ADC2, +//! \b SYSCTL_PIN_ADC3, \b SYSCTL_PIN_ADC4, \b SYSCTL_PIN_ADC5, +//! \b SYSCTL_PIN_ADC6, \b SYSCTL_PIN_ADC7, \b SYSCTL_PIN_CCP0, +//! \b SYSCTL_PIN_CCP1, \b SYSCTL_PIN_CCP2, \b SYSCTL_PIN_CCP3, +//! \b SYSCTL_PIN_CCP4, \b SYSCTL_PIN_CCP5, \b SYSCTL_PIN_CCP6, +//! \b SYSCTL_PIN_CCP7, \b SYSCTL_PIN_32KHZ, or \b SYSCTL_PIN_MC_FAULT0. +//! +//! \return Returns \b true if the specified pin is present and \b false if it +//! is not. +// +//***************************************************************************** +tBoolean +SysCtlPinPresent(unsigned long ulPin) +{ + // + // Check the arguments. + // + ASSERT((ulPin == SYSCTL_PIN_PWM0) || + (ulPin == SYSCTL_PIN_PWM1) || + (ulPin == SYSCTL_PIN_PWM2) || + (ulPin == SYSCTL_PIN_PWM3) || + (ulPin == SYSCTL_PIN_PWM4) || + (ulPin == SYSCTL_PIN_PWM5) || + (ulPin == SYSCTL_PIN_C0MINUS) || + (ulPin == SYSCTL_PIN_C0PLUS) || + (ulPin == SYSCTL_PIN_C0O) || + (ulPin == SYSCTL_PIN_C1MINUS) || + (ulPin == SYSCTL_PIN_C1PLUS) || + (ulPin == SYSCTL_PIN_C1O) || + (ulPin == SYSCTL_PIN_C2MINUS) || + (ulPin == SYSCTL_PIN_C2PLUS) || + (ulPin == SYSCTL_PIN_C2O) || + (ulPin == SYSCTL_PIN_MC_FAULT0) || + (ulPin == SYSCTL_PIN_ADC0) || + (ulPin == SYSCTL_PIN_ADC1) || + (ulPin == SYSCTL_PIN_ADC2) || + (ulPin == SYSCTL_PIN_ADC3) || + (ulPin == SYSCTL_PIN_ADC4) || + (ulPin == SYSCTL_PIN_ADC5) || + (ulPin == SYSCTL_PIN_ADC6) || + (ulPin == SYSCTL_PIN_ADC7) || + (ulPin == SYSCTL_PIN_CCP0) || + (ulPin == SYSCTL_PIN_CCP1) || + (ulPin == SYSCTL_PIN_CCP2) || + (ulPin == SYSCTL_PIN_CCP3) || + (ulPin == SYSCTL_PIN_CCP4) || + (ulPin == SYSCTL_PIN_CCP5) || + (ulPin == SYSCTL_PIN_32KHZ)); + + // + // Determine if this pin is present. + // + if(HWREG(SYSCTL_DC3) & ulPin) + { + return(true); + } + else + { + return(false); + } +} + +//***************************************************************************** +// +//! Determines if a peripheral is present. +//! +//! \param ulPeripheral is the peripheral in question. +//! +//! Determines if a particular peripheral is present in the device. Each +//! member of the Stellaris family has a different peripheral set; this will +//! determine which are present on this device. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_IEEE1588, +//! \b SYSCTL_PERIPH_MPU, \b SYSCTL_PERIPH_PLL, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \return Returns \b true if the specified peripheral is present and \b false +//! if it is not. +// +//***************************************************************************** +tBoolean +SysCtlPeripheralPresent(unsigned long ulPeripheral) +{ + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Read the correct DC register and determine if this peripheral exists. + // + if(ulPeripheral == SYSCTL_PERIPH_USB0) + { + // + // USB is a special case since the DC bit is missing for USB0. + // + if(HWREG(SYSCTL_DC6) & SYSCTL_DC6_USB0_M) + { + return(true); + } + else + { + return(false); + } + } + else if(HWREG(g_pulDCRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) & + SYSCTL_PERIPH_MASK(ulPeripheral)) + { + return(true); + } + else + { + return(false); + } +} + +//***************************************************************************** +// +//! Performs a software reset of a peripheral. +//! +//! \param ulPeripheral is the peripheral to reset. +//! +//! This function performs a software reset of the specified peripheral. An +//! individual peripheral reset signal is asserted for a brief period and then +//! deasserted, returning the internal state of the peripheral to its reset +//! condition. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralReset(unsigned long ulPeripheral) +{ + volatile unsigned long ulDelay; + + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Put the peripheral into the reset state. + // + HWREG(g_pulSRCRRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) |= + SYSCTL_PERIPH_MASK(ulPeripheral); + + // + // Delay for a little bit. + // + for(ulDelay = 0; ulDelay < 16; ulDelay++) + { + } + + // + // Take the peripheral out of the reset state. + // + HWREG(g_pulSRCRRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) &= + ~SYSCTL_PERIPH_MASK(ulPeripheral); +} + +//***************************************************************************** +// +//! Enables a peripheral. +//! +//! \param ulPeripheral is the peripheral to enable. +//! +//! Peripherals are enabled with this function. At power-up, all peripherals +//! are disabled; they must be enabled in order to operate or respond to +//! register reads/writes. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \note It takes five clock cycles after the write to enable a peripheral +//! before the the peripheral is actually enabled. During this time, attempts +//! to access the peripheral will result in a bus fault. Care should be taken +//! to ensure that the peripheral is not accessed during this brief time +//! period. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralEnable(unsigned long ulPeripheral) +{ + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Enable this peripheral. + // + HWREG(g_pulRCGCRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) |= + SYSCTL_PERIPH_MASK(ulPeripheral); +} + +//***************************************************************************** +// +//! Disables a peripheral. +//! +//! \param ulPeripheral is the peripheral to disable. +//! +//! Peripherals are disabled with this function. Once disabled, they will not +//! operate or respond to register reads/writes. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralDisable(unsigned long ulPeripheral) +{ + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Disable this peripheral. + // + HWREG(g_pulRCGCRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) &= + ~SYSCTL_PERIPH_MASK(ulPeripheral); +} + +//***************************************************************************** +// +//! Enables a peripheral in sleep mode. +//! +//! \param ulPeripheral is the peripheral to enable in sleep mode. +//! +//! This function allows a peripheral to continue operating when the processor +//! goes into sleep mode. Since the clocking configuration of the device does +//! not change, any peripheral can safely continue operating while the +//! processor is in sleep mode, and can therefore wake the processor from sleep +//! mode. +//! +//! Sleep mode clocking of peripherals must be enabled via +//! SysCtlPeripheralClockGating(); if disabled, the peripheral sleep mode +//! configuration is maintained but has no effect when sleep mode is entered. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralSleepEnable(unsigned long ulPeripheral) +{ + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Enable this peripheral in sleep mode. + // + HWREG(g_pulSCGCRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) |= + SYSCTL_PERIPH_MASK(ulPeripheral); +} + +//***************************************************************************** +// +//! Disables a peripheral in sleep mode. +//! +//! \param ulPeripheral is the peripheral to disable in sleep mode. +//! +//! This function causes a peripheral to stop operating when the processor goes +//! into sleep mode. Disabling peripherals while in sleep mode helps to lower +//! the current draw of the device. If enabled (via SysCtlPeripheralEnable()), +//! the peripheral will automatically resume operation when the processor +//! leaves sleep mode, maintaining its entire state from before sleep mode was +//! entered. +//! +//! Sleep mode clocking of peripherals must be enabled via +//! SysCtlPeripheralClockGating(); if disabled, the peripheral sleep mode +//! configuration is maintained but has no effect when sleep mode is entered. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralSleepDisable(unsigned long ulPeripheral) +{ + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Disable this peripheral in sleep mode. + // + HWREG(g_pulSCGCRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) &= + ~SYSCTL_PERIPH_MASK(ulPeripheral); +} + +//***************************************************************************** +// +//! Enables a peripheral in deep-sleep mode. +//! +//! \param ulPeripheral is the peripheral to enable in deep-sleep mode. +//! +//! This function allows a peripheral to continue operating when the processor +//! goes into deep-sleep mode. Since the clocking configuration of the device +//! may change, not all peripherals can safely continue operating while the +//! processor is in sleep mode. Those that must run at a particular frequency +//! (such as a UART) will not work as expected if the clock changes. It is the +//! responsibility of the caller to make sensible choices. +//! +//! Deep-sleep mode clocking of peripherals must be enabled via +//! SysCtlPeripheralClockGating(); if disabled, the peripheral deep-sleep mode +//! configuration is maintained but has no effect when deep-sleep mode is +//! entered. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralDeepSleepEnable(unsigned long ulPeripheral) +{ + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Enable this peripheral in deep-sleep mode. + // + HWREG(g_pulDCGCRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) |= + SYSCTL_PERIPH_MASK(ulPeripheral); +} + +//***************************************************************************** +// +//! Disables a peripheral in deep-sleep mode. +//! +//! \param ulPeripheral is the peripheral to disable in deep-sleep mode. +//! +//! This function causes a peripheral to stop operating when the processor goes +//! into deep-sleep mode. Disabling peripherals while in deep-sleep mode helps +//! to lower the current draw of the device, and can keep peripherals that +//! require a particular clock frequency from operating when the clock changes +//! as a result of entering deep-sleep mode. If enabled (via +//! SysCtlPeripheralEnable()), the peripheral will automatically resume +//! operation when the processor leaves deep-sleep mode, maintaining its entire +//! state from before deep-sleep mode was entered. +//! +//! Deep-sleep mode clocking of peripherals must be enabled via +//! SysCtlPeripheralClockGating(); if disabled, the peripheral deep-sleep mode +//! configuration is maintained but has no effect when deep-sleep mode is +//! entered. +//! +//! The \e ulPeripheral parameter must be only one of the following values: +//! \b SYSCTL_PERIPH_ADC0, \b SYSCTL_PERIPH_ADC1, \b SYSCTL_PERIPH_CAN0, +//! \b SYSCTL_PERIPH_CAN1, \b SYSCTL_PERIPH_CAN2, \b SYSCTL_PERIPH_COMP0, +//! \b SYSCTL_PERIPH_COMP1, \b SYSCTL_PERIPH_COMP2, \b SYSCTL_PERIPH_EPI0, +//! \b SYSCTL_PERIPH_ETH, \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, +//! \b SYSCTL_PERIPH_GPIOC, \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, +//! \b SYSCTL_PERIPH_GPIOF, \b SYSCTL_PERIPH_GPIOG, \b SYSCTL_PERIPH_GPIOH, +//! \b SYSCTL_PERIPH_GPIOJ, \b SYSCTL_PERIPH_HIBERNATE, \b SYSCTL_PERIPH_I2C0, +//! \b SYSCTL_PERIPH_I2C1, \b SYSCTL_PERIPH_I2S0, \b SYSCTL_PERIPH_PWM, +//! \b SYSCTL_PERIPH_QEI0, \b SYSCTL_PERIPH_QEI1, \b SYSCTL_PERIPH_SSI0, +//! \b SYSCTL_PERIPH_SSI1, \b SYSCTL_PERIPH_TIMER0, \b SYSCTL_PERIPH_TIMER1, +//! \b SYSCTL_PERIPH_TIMER2, \b SYSCTL_PERIPH_TIMER3, \b SYSCTL_PERIPH_TEMP, +//! \b SYSCTL_PERIPH_UART0, \b SYSCTL_PERIPH_UART1, \b SYSCTL_PERIPH_UART2, +//! \b SYSCTL_PERIPH_UDMA, \b SYSCTL_PERIPH_USB0, \b SYSCTL_PERIPH_WDOG0, or +//! \b SYSCTL_PERIPH_WDOG1. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralDeepSleepDisable(unsigned long ulPeripheral) +{ + // + // Check the arguments. + // + ASSERT(SysCtlPeripheralValid(ulPeripheral)); + + // + // Disable this peripheral in deep-sleep mode. + // + HWREG(g_pulDCGCRegs[SYSCTL_PERIPH_INDEX(ulPeripheral)]) &= + ~SYSCTL_PERIPH_MASK(ulPeripheral); +} + +//***************************************************************************** +// +//! Controls peripheral clock gating in sleep and deep-sleep mode. +//! +//! \param bEnable is a boolean that is \b true if the sleep and deep-sleep +//! peripheral configuration should be used and \b false if not. +//! +//! This function controls how peripherals are clocked when the processor goes +//! into sleep or deep-sleep mode. By default, the peripherals are clocked the +//! same as in run mode; if peripheral clock gating is enabled they are clocked +//! according to the configuration set by SysCtlPeripheralSleepEnable(), +//! SysCtlPeripheralSleepDisable(), SysCtlPeripheralDeepSleepEnable(), and +//! SysCtlPeripheralDeepSleepDisable(). +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPeripheralClockGating(tBoolean bEnable) +{ + // + // Enable peripheral clock gating as requested. + // + if(bEnable) + { + HWREG(SYSCTL_RCC) |= SYSCTL_RCC_ACG; + } + else + { + HWREG(SYSCTL_RCC) &= ~(SYSCTL_RCC_ACG); + } +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the system control interrupt. +//! +//! \param pfnHandler is a pointer to the function to be called when the system +//! control interrupt occurs. +//! +//! This sets the handler to be called when a system control interrupt occurs. +//! This will enable the global interrupt in the interrupt controller; specific +//! system control interrupts must be enabled via SysCtlIntEnable(). It is the +//! interrupt handler's responsibility to clear the interrupt source via +//! SysCtlIntClear(). +//! +//! System control can generate interrupts when the PLL achieves lock, if the +//! internal LDO current limit is exceeded, if the internal oscillator fails, +//! if the main oscillator fails, if the internal LDO output voltage droops too +//! much, if the external voltage droops too much, or if the PLL fails. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlIntRegister(void (*pfnHandler)(void)) +{ + // + // Register the interrupt handler, returning an error if an error occurs. + // + IntRegister(INT_SYSCTL, pfnHandler); + + // + // Enable the system control interrupt. + // + IntEnable(INT_SYSCTL); +} + +//***************************************************************************** +// +//! Unregisters the interrupt handler for the system control interrupt. +//! +//! This function will clear the handler to be called when a system control +//! interrupt occurs. This will also mask off the interrupt in the interrupt +//! controller so that the interrupt handler no longer is called. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlIntUnregister(void) +{ + // + // Disable the interrupt. + // + IntDisable(INT_SYSCTL); + + // + // Unregister the interrupt handler. + // + IntUnregister(INT_SYSCTL); +} + +//***************************************************************************** +// +//! Enables individual system control interrupt sources. +//! +//! \param ulInts is a bit mask of the interrupt sources to be enabled. Must +//! be a logical OR of \b SYSCTL_INT_PLL_LOCK, \b SYSCTL_INT_CUR_LIMIT, +//! \b SYSCTL_INT_IOSC_FAIL, \b SYSCTL_INT_MOSC_FAIL, \b SYSCTL_INT_POR, +//! \b SYSCTL_INT_BOR, and/or \b SYSCTL_INT_PLL_FAIL. +//! +//! Enables the indicated system control interrupt sources. Only the sources +//! that are enabled can be reflected to the processor interrupt; disabled +//! sources have no effect on the processor. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlIntEnable(unsigned long ulInts) +{ + // + // Enable the specified interrupts. + // + HWREG(SYSCTL_IMC) |= ulInts; +} + +//***************************************************************************** +// +//! Disables individual system control interrupt sources. +//! +//! \param ulInts is a bit mask of the interrupt sources to be disabled. Must +//! be a logical OR of \b SYSCTL_INT_PLL_LOCK, \b SYSCTL_INT_CUR_LIMIT, +//! \b SYSCTL_INT_IOSC_FAIL, \b SYSCTL_INT_MOSC_FAIL, \b SYSCTL_INT_POR, +//! \b SYSCTL_INT_BOR, and/or \b SYSCTL_INT_PLL_FAIL. +//! +//! Disables the indicated system control interrupt sources. Only the sources +//! that are enabled can be reflected to the processor interrupt; disabled +//! sources have no effect on the processor. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlIntDisable(unsigned long ulInts) +{ + // + // Disable the specified interrupts. + // + HWREG(SYSCTL_IMC) &= ~(ulInts); +} + +//***************************************************************************** +// +//! Clears system control interrupt sources. +//! +//! \param ulInts is a bit mask of the interrupt sources to be cleared. Must +//! be a logical OR of \b SYSCTL_INT_PLL_LOCK, \b SYSCTL_INT_CUR_LIMIT, +//! \b SYSCTL_INT_IOSC_FAIL, \b SYSCTL_INT_MOSC_FAIL, \b SYSCTL_INT_POR, +//! \b SYSCTL_INT_BOR, and/or \b SYSCTL_INT_PLL_FAIL. +//! +//! The specified system control interrupt sources are cleared, so that they no +//! longer assert. This must be done in the interrupt handler to keep it from +//! being called again immediately upon exit. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlIntClear(unsigned long ulInts) +{ + // + // Clear the requested interrupt sources. + // + HWREG(SYSCTL_MISC) = ulInts; +} + +//***************************************************************************** +// +//! Gets the current interrupt status. +//! +//! \param bMasked is false if the raw interrupt status is required and true if +//! the masked interrupt status is required. +//! +//! This returns the interrupt status for the system controller. Either the +//! raw interrupt status or the status of interrupts that are allowed to +//! reflect to the processor can be returned. +//! +//! \return The current interrupt status, enumerated as a bit field of +//! \b SYSCTL_INT_PLL_LOCK, \b SYSCTL_INT_CUR_LIMIT, \b SYSCTL_INT_IOSC_FAIL, +//! \b SYSCTL_INT_MOSC_FAIL, \b SYSCTL_INT_POR, \b SYSCTL_INT_BOR, and +//! \b SYSCTL_INT_PLL_FAIL. +// +//***************************************************************************** +unsigned long +SysCtlIntStatus(tBoolean bMasked) +{ + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + return(HWREG(SYSCTL_MISC)); + } + else + { + return(HWREG(SYSCTL_RIS)); + } +} + +//***************************************************************************** +// +//! Sets the output voltage of the LDO. +//! +//! \param ulVoltage is the required output voltage from the LDO. Must be one +//! of \b SYSCTL_LDO_2_25V, \b SYSCTL_LDO_2_30V, \b SYSCTL_LDO_2_35V, +//! \b SYSCTL_LDO_2_40V, \b SYSCTL_LDO_2_45V, \b SYSCTL_LDO_2_50V, +//! \b SYSCTL_LDO_2_55V, \b SYSCTL_LDO_2_60V, \b SYSCTL_LDO_2_65V, +//! \b SYSCTL_LDO_2_70V, or \b SYSCTL_LDO_2_75V. +//! +//! This function sets the output voltage of the LDO. The default voltage is +//! 2.5 V; it can be adjusted +/- 10%. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlLDOSet(unsigned long ulVoltage) +{ + // + // Check the arguments. + // + ASSERT((ulVoltage == SYSCTL_LDO_2_25V) || + (ulVoltage == SYSCTL_LDO_2_30V) || + (ulVoltage == SYSCTL_LDO_2_35V) || + (ulVoltage == SYSCTL_LDO_2_40V) || + (ulVoltage == SYSCTL_LDO_2_45V) || + (ulVoltage == SYSCTL_LDO_2_50V) || + (ulVoltage == SYSCTL_LDO_2_55V) || + (ulVoltage == SYSCTL_LDO_2_60V) || + (ulVoltage == SYSCTL_LDO_2_65V) || + (ulVoltage == SYSCTL_LDO_2_70V) || + (ulVoltage == SYSCTL_LDO_2_75V)); + + // + // Set the LDO voltage to the requested value. + // + HWREG(SYSCTL_LDOPCTL) = ulVoltage; +} + +//***************************************************************************** +// +//! Gets the output voltage of the LDO. +//! +//! This function determines the output voltage of the LDO, as specified by the +//! control register. +//! +//! \return Returns the current voltage of the LDO; will be one of +//! \b SYSCTL_LDO_2_25V, \b SYSCTL_LDO_2_30V, \b SYSCTL_LDO_2_35V, +//! \b SYSCTL_LDO_2_40V, \b SYSCTL_LDO_2_45V, \b SYSCTL_LDO_2_50V, +//! \b SYSCTL_LDO_2_55V, \b SYSCTL_LDO_2_60V, \b SYSCTL_LDO_2_65V, +//! \b SYSCTL_LDO_2_70V, or \b SYSCTL_LDO_2_75V. +// +//***************************************************************************** +unsigned long +SysCtlLDOGet(void) +{ + // + // Return the LDO voltage setting. + // + return(HWREG(SYSCTL_LDOPCTL)); +} + +//***************************************************************************** +// +//! Configures the LDO failure control. +//! +//! \param ulConfig is the required LDO failure control setting; can be either +//! \b SYSCTL_LDOCFG_ARST or \b SYSCTL_LDOCFG_NORST. +//! +//! This function allows the LDO to be configured to cause a processor reset +//! when the output voltage becomes unregulated. +//! +//! The LDO failure control is only available on Sandstorm-class devices. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlLDOConfigSet(unsigned long ulConfig) +{ + // + // Check the arguments. + // + ASSERT((ulConfig == SYSCTL_LDOCFG_ARST) || + (ulConfig == SYSCTL_LDOCFG_NORST)); + + // + // Set the reset control as requested. + // + HWREG(SYSCTL_LDOARST) = ulConfig; +} + +//***************************************************************************** +// +//! Resets the device. +//! +//! This function will perform a software reset of the entire device. The +//! processor and all peripherals will be reset and all device registers will +//! return to their default values (with the exception of the reset cause +//! register, which will maintain its current value but have the software reset +//! bit set as well). +//! +//! \return This function does not return. +// +//***************************************************************************** +void +SysCtlReset(void) +{ + // + // Perform a software reset request. This will cause the device to reset, + // no further code will be executed. + // + HWREG(NVIC_APINT) = NVIC_APINT_VECTKEY | NVIC_APINT_SYSRESETREQ; + + // + // The device should have reset, so this should never be reached. Just in + // case, loop forever. + // + while(1) + { + } +} + +//***************************************************************************** +// +//! Puts the processor into sleep mode. +//! +//! This function places the processor into sleep mode; it will not return +//! until the processor returns to run mode. The peripherals that are enabled +//! via SysCtlPeripheralSleepEnable() continue to operate and can wake up the +//! processor (if automatic clock gating is enabled with +//! SysCtlPeripheralClockGating(), otherwise all peripherals continue to +//! operate). +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlSleep(void) +{ + // + // Wait for an interrupt. + // + CPUwfi(); +} + +//***************************************************************************** +// +//! Puts the processor into deep-sleep mode. +//! +//! This function places the processor into deep-sleep mode; it will not return +//! until the processor returns to run mode. The peripherals that are enabled +//! via SysCtlPeripheralDeepSleepEnable() continue to operate and can wake up +//! the processor (if automatic clock gating is enabled with +//! SysCtlPeripheralClockGating(), otherwise all peripherals continue to +//! operate). +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlDeepSleep(void) +{ + // + // Enable deep-sleep. + // + HWREG(NVIC_SYS_CTRL) |= NVIC_SYS_CTRL_SLEEPDEEP; + + // + // Wait for an interrupt. + // + CPUwfi(); + + // + // Disable deep-sleep so that a future sleep will work correctly. + // + HWREG(NVIC_SYS_CTRL) &= ~(NVIC_SYS_CTRL_SLEEPDEEP); +} + +//***************************************************************************** +// +//! Gets the reason for a reset. +//! +//! This function will return the reason(s) for a reset. Since the reset +//! reasons are sticky until either cleared by software or an external reset, +//! multiple reset reasons may be returned if multiple resets have occurred. +//! The reset reason will be a logical OR of \b SYSCTL_CAUSE_LDO, +//! \b SYSCTL_CAUSE_SW, \b SYSCTL_CAUSE_WDOG, \b SYSCTL_CAUSE_BOR, +//! \b SYSCTL_CAUSE_POR, and/or \b SYSCTL_CAUSE_EXT. +//! +//! \return Returns the reason(s) for a reset. +// +//***************************************************************************** +unsigned long +SysCtlResetCauseGet(void) +{ + // + // Return the reset reasons. + // + return(HWREG(SYSCTL_RESC)); +} + +//***************************************************************************** +// +//! Clears reset reasons. +//! +//! \param ulCauses are the reset causes to be cleared; must be a logical OR of +//! \b SYSCTL_CAUSE_LDO, \b SYSCTL_CAUSE_SW, \b SYSCTL_CAUSE_WDOG, +//! \b SYSCTL_CAUSE_BOR, \b SYSCTL_CAUSE_POR, and/or \b SYSCTL_CAUSE_EXT. +//! +//! This function clears the specified sticky reset reasons. Once cleared, +//! another reset for the same reason can be detected, and a reset for a +//! different reason can be distinguished (instead of having two reset causes +//! set). If the reset reason is used by an application, all reset causes +//! should be cleared after they are retrieved with SysCtlResetCauseGet(). +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlResetCauseClear(unsigned long ulCauses) +{ + // + // Clear the given reset reasons. + // + HWREG(SYSCTL_RESC) &= ~(ulCauses); +} + +//***************************************************************************** +// +//! Configures the brown-out control. +//! +//! \param ulConfig is the desired configuration of the brown-out control. +//! Must be the logical OR of \b SYSCTL_BOR_RESET and/or +//! \b SYSCTL_BOR_RESAMPLE. +//! \param ulDelay is the number of internal oscillator cycles to wait before +//! resampling an asserted brown-out signal. This value only has meaning when +//! \b SYSCTL_BOR_RESAMPLE is set and must be less than 8192. +//! +//! This function configures how the brown-out control operates. It can detect +//! a brown-out by looking at only the brown-out output, or it can wait for it +//! to be active for two consecutive samples separated by a configurable time. +//! When it detects a brown-out condition, it can either reset the device or +//! generate a processor interrupt. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlBrownOutConfigSet(unsigned long ulConfig, unsigned long ulDelay) +{ + // + // Check the arguments. + // + ASSERT(!(ulConfig & ~(SYSCTL_BOR_RESET | SYSCTL_BOR_RESAMPLE))); + ASSERT(ulDelay < 8192); + + // + // Configure the brown-out reset control. + // + HWREG(SYSCTL_PBORCTL) = (ulDelay << SYSCTL_PBORCTL_BORTIM_S) | ulConfig; +} + +//***************************************************************************** +// +//! Provides a small delay. +//! +//! \param ulCount is the number of delay loop iterations to perform. +//! +//! This function provides a means of generating a constant length delay. It +//! is written in assembly to keep the delay consistent across tool chains, +//! avoiding the need to tune the delay based on the tool chain in use. +//! +//! The loop takes 3 cycles/loop. +//! +//! \return None. +// +//***************************************************************************** +#if defined(ewarm) || defined(DOXYGEN) +void +SysCtlDelay(unsigned long ulCount) +{ + __asm(" subs r0, #1\n" + " bne.n SysCtlDelay\n" + " bx lr"); +} +#endif +#if defined(codered) || defined(gcc) || defined(sourcerygxx) +void __attribute__((naked)) +SysCtlDelay(unsigned long ulCount) +{ + __asm(" subs r0, #1\n" + " bne SysCtlDelay\n" + " bx lr"); +} +#endif +#if defined(rvmdk) || defined(__ARMCC_VERSION) +__asm void +SysCtlDelay(unsigned long ulCount) +{ + subs r0, #1; + bne SysCtlDelay; + bx lr; +} +#endif +// +// For CCS implement this function in pure assembly. This prevents the TI +// compiler from doing funny things with the optimizer. +// +#if defined(ccs) + __asm(" .sect \".text:SysCtlDelay\"\n" + " .clink\n" + " .thumbfunc SysCtlDelay\n" + " .thumb\n" + " .global SysCtlDelay\n" + "SysCtlDelay:\n" + " subs r0, #1\n" + " bne.n SysCtlDelay\n" + " bx lr\n"); +#endif + + +//***************************************************************************** +// +//! Sets the clocking of the device. +//! +//! \param ulConfig is the required configuration of the device clocking. +//! +//! This function configures the clocking of the device. The input crystal +//! frequency, oscillator to be used, use of the PLL, and the system clock +//! divider are all configured with this function. +//! +//! The \e ulConfig parameter is the logical OR of several different values, +//! many of which are grouped into sets where only one can be chosen. +//! +//! The system clock divider is chosen with one of the following values: +//! \b SYSCTL_SYSDIV_1, \b SYSCTL_SYSDIV_2, \b SYSCTL_SYSDIV_3, ... +//! \b SYSCTL_SYSDIV_64. Only \b SYSCTL_SYSDIV_1 through \b SYSCTL_SYSDIV_16 +//! are valid on Sandstorm-class devices. +//! +//! The use of the PLL is chosen with either \b SYSCTL_USE_PLL or +//! \b SYSCTL_USE_OSC. +//! +//! The external crystal frequency is chosen with one of the following values: +//! \b SYSCTL_XTAL_1MHZ, \b SYSCTL_XTAL_1_84MHZ, \b SYSCTL_XTAL_2MHZ, +//! \b SYSCTL_XTAL_2_45MHZ, \b SYSCTL_XTAL_3_57MHZ, \b SYSCTL_XTAL_3_68MHZ, +//! \b SYSCTL_XTAL_4MHZ, \b SYSCTL_XTAL_4_09MHZ, \b SYSCTL_XTAL_4_91MHZ, +//! \b SYSCTL_XTAL_5MHZ, \b SYSCTL_XTAL_5_12MHZ, \b SYSCTL_XTAL_6MHZ, +//! \b SYSCTL_XTAL_6_14MHZ, \b SYSCTL_XTAL_7_37MHZ, \b SYSCTL_XTAL_8MHZ, +//! \b SYSCTL_XTAL_8_19MHZ, \b SYSCTL_XTAL_10MHZ, \b SYSCTL_XTAL_12MHZ, +//! \b SYSCTL_XTAL_12_2MHZ, \b SYSCTL_XTAL_13_5MHZ, \b SYSCTL_XTAL_14_3MHZ, +//! \b SYSCTL_XTAL_16MHZ, or \b SYSCTL_XTAL_16_3MHZ. Values below +//! \b SYSCTL_XTAL_3_57MHZ are not valid when the PLL is in operation. On +//! Sandstorm- and Fury-class devices, values above \b SYSCTL_XTAL_8_19MHZ are +//! not valid. +//! +//! The oscillator source is chosen with one of the following values: +//! \b SYSCTL_OSC_MAIN, \b SYSCTL_OSC_INT, \b SYSCTL_OSC_INT4, +//! \b SYSCTL_OSC_INT30, or \b SYSCTL_OSC_EXT32. On Sandstorm-class devices, +//! \b SYSCTL_OSC_INT30 and \b SYSCTL_OSC_EXT32 are not valid. +//! \b SYSCTL_OSC_EXT32 is only available on devices with the hibernate module, +//! and then only when the hibernate module has been enabled. +//! +//! The internal and main oscillators are disabled with the +//! \b SYSCTL_INT_OSC_DIS and \b SYSCTL_MAIN_OSC_DIS flags, respectively. +//! The external oscillator must be enabled in order to use an external clock +//! source. Note that attempts to disable the oscillator used to clock the +//! device will be prevented by the hardware. +//! +//! To clock the system from an external source (such as an external crystal +//! oscillator), use \b SYSCTL_USE_OSC \b | \b SYSCTL_OSC_MAIN. To clock the +//! system from the main oscillator, use \b SYSCTL_USE_OSC \b | +//! \b SYSCTL_OSC_MAIN. To clock the system from the PLL, use +//! \b SYSCTL_USE_PLL \b | \b SYSCTL_OSC_MAIN, and select the appropriate +//! crystal with one of the \b SYSCTL_XTAL_xxx values. +//! +//! \note If selecting the PLL as the system clock source (that is, via +//! \b SYSCTL_USE_PLL), this function will poll the PLL lock interrupt to +//! determine when the PLL has locked. If an interrupt handler for the +//! system control interrupt is in place, and it responds to and clears the +//! PLL lock interrupt, this function will delay until its timeout has occurred +//! instead of completing as soon as PLL lock is achieved. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlClockSet(unsigned long ulConfig) +{ + unsigned long ulDelay, ulRCC, ulRCC2; + + // + // See if this is a Sandstorm-class device and clocking features from newer + // devices were requested. + // + if(CLASS_IS_SANDSTORM && (ulConfig & SYSCTL_RCC2_USERCC2)) + { + // + // Return without changing the clocking since the requested + // configuration can not be achieved. + // + return; + } + + // + // Get the current value of the RCC and RCC2 registers. If using a + // Sandstorm-class device, the RCC2 register will read back as zero and the + // writes to it from within this function will be ignored. + // + ulRCC = HWREG(SYSCTL_RCC); + ulRCC2 = HWREG(SYSCTL_RCC2); + + // + // Bypass the PLL and system clock dividers for now. + // + ulRCC |= SYSCTL_RCC_BYPASS; + ulRCC &= ~(SYSCTL_RCC_USESYSDIV); + ulRCC2 |= SYSCTL_RCC2_BYPASS2; + + // + // Write the new RCC value. + // + HWREG(SYSCTL_RCC) = ulRCC; + HWREG(SYSCTL_RCC2) = ulRCC2; + + // + // See if either oscillator needs to be enabled. + // + if(((ulRCC & SYSCTL_RCC_IOSCDIS) && !(ulConfig & SYSCTL_RCC_IOSCDIS)) || + ((ulRCC & SYSCTL_RCC_MOSCDIS) && !(ulConfig & SYSCTL_RCC_MOSCDIS))) + { + // + // Make sure that the required oscillators are enabled. For now, the + // previously enabled oscillators must be enabled along with the newly + // requested oscillators. + // + ulRCC &= (~(SYSCTL_RCC_IOSCDIS | SYSCTL_RCC_MOSCDIS) | + (ulConfig & (SYSCTL_RCC_IOSCDIS | SYSCTL_RCC_MOSCDIS))); + + // + // Write the new RCC value. + // + HWREG(SYSCTL_RCC) = ulRCC; + + // + // Wait for a bit, giving the oscillator time to stabilize. The number + // of iterations is adjusted based on the current clock source; a + // smaller number of iterations is required for slower clock rates. + // + if(((ulRCC2 & SYSCTL_RCC2_USERCC2) && + (((ulRCC2 & SYSCTL_RCC2_OSCSRC2_M) == SYSCTL_RCC2_OSCSRC2_30) || + ((ulRCC2 & SYSCTL_RCC2_OSCSRC2_M) == SYSCTL_RCC2_OSCSRC2_32))) || + (!(ulRCC2 & SYSCTL_RCC2_USERCC2) && + ((ulRCC & SYSCTL_RCC_OSCSRC_M) == SYSCTL_RCC_OSCSRC_30))) + { + // + // Delay for 4096 iterations. + // + SysCtlDelay(4096); + } + else + { + // + // Delay for 524,288 iterations. + // + SysCtlDelay(524288); + } + } + + // + // Set the new crystal value, oscillator source, and PLL configuration. + // Since the OSCSRC2 field in RCC2 overlaps the XTAL field in RCC, the + // OSCSRC field has a special encoding within ulConfig to avoid the + // overlap. + // + ulRCC &= ~(SYSCTL_RCC_XTAL_M | SYSCTL_RCC_OSCSRC_M | + SYSCTL_RCC_PWRDN | SYSCTL_RCC_OEN); + ulRCC |= ulConfig & (SYSCTL_RCC_XTAL_M | SYSCTL_RCC_OSCSRC_M | + SYSCTL_RCC_PWRDN | SYSCTL_RCC_OEN); + ulRCC2 &= ~(SYSCTL_RCC2_USERCC2 | SYSCTL_RCC2_OSCSRC2_M | + SYSCTL_RCC2_PWRDN2); + ulRCC2 |= ulConfig & (SYSCTL_RCC2_USERCC2 | SYSCTL_RCC_OSCSRC_M | + SYSCTL_RCC2_PWRDN2); + ulRCC2 |= (ulConfig & 0x00000008) << 3; + + // + // Clear the PLL lock interrupt. + // + HWREG(SYSCTL_MISC) = SYSCTL_INT_PLL_LOCK; + + // + // Write the new RCC value. + // + if(ulRCC2 & SYSCTL_RCC2_USERCC2) + { + HWREG(SYSCTL_RCC2) = ulRCC2; + HWREG(SYSCTL_RCC) = ulRCC; + } + else + { + HWREG(SYSCTL_RCC) = ulRCC; + HWREG(SYSCTL_RCC2) = ulRCC2; + } + + // + // Wait for a bit so that new crystal value and oscillator source can take + // effect. + // + SysCtlDelay(16); + + // + // Set the requested system divider and disable the appropriate + // oscillators. This will not get written immediately. + // + ulRCC &= ~(SYSCTL_RCC_SYSDIV_M | SYSCTL_RCC_USESYSDIV | + SYSCTL_RCC_IOSCDIS | SYSCTL_RCC_MOSCDIS); + ulRCC |= ulConfig & (SYSCTL_RCC_SYSDIV_M | SYSCTL_RCC_USESYSDIV | + SYSCTL_RCC_IOSCDIS | SYSCTL_RCC_MOSCDIS); + ulRCC2 &= ~(SYSCTL_RCC2_SYSDIV2_M); + ulRCC2 |= ulConfig & SYSCTL_RCC2_SYSDIV2_M; + if(ulConfig & SYSCTL_RCC2_DIV400) + { + ulRCC |= SYSCTL_RCC_USESYSDIV; + ulRCC2 &= ~(SYSCTL_RCC_USESYSDIV); + ulRCC2 |= ulConfig & (SYSCTL_RCC2_DIV400 | SYSCTL_RCC2_SYSDIV2LSB); + } + else + { + ulRCC2 &= ~(SYSCTL_RCC2_DIV400); + } + + // + // See if the PLL output is being used to clock the system. + // + if(!(ulConfig & SYSCTL_RCC_BYPASS)) + { + // + // Wait until the PLL has locked. + // + for(ulDelay = 32768; ulDelay > 0; ulDelay--) + { + if(HWREG(SYSCTL_RIS) & SYSCTL_INT_PLL_LOCK) + { + break; + } + } + + // + // Enable use of the PLL. + // + ulRCC &= ~(SYSCTL_RCC_BYPASS); + ulRCC2 &= ~(SYSCTL_RCC2_BYPASS2); + } + + // + // Write the final RCC value. + // + HWREG(SYSCTL_RCC) = ulRCC; + HWREG(SYSCTL_RCC2) = ulRCC2; + + // + // Delay for a little bit so that the system divider takes effect. + // + SysCtlDelay(16); +} + +//***************************************************************************** +// +//! Gets the processor clock rate. +//! +//! This function determines the clock rate of the processor clock. This is +//! also the clock rate of all the peripheral modules (with the exception of +//! PWM, which has its own clock divider). +//! +//! \note This will not return accurate results if SysCtlClockSet() has not +//! been called to configure the clocking of the device, or if the device is +//! directly clocked from a crystal (or a clock source) that is not one of the +//! supported crystal frequencies. In the later case, this function should be +//! modified to directly return the correct system clock rate. +//! +//! \return The processor clock rate. +// +//***************************************************************************** +unsigned long +SysCtlClockGet(void) +{ + unsigned long ulRCC, ulRCC2, ulPLL, ulClk; + + // + // Read RCC and RCC2. For Sandstorm-class devices (which do not have + // RCC2), the RCC2 read will return 0, which indicates that RCC2 is + // disabled (since the SYSCTL_RCC2_USERCC2 bit is clear). + // + ulRCC = HWREG(SYSCTL_RCC); + ulRCC2 = HWREG(SYSCTL_RCC2); + + // + // Get the base clock rate. + // + switch((ulRCC2 & SYSCTL_RCC2_USERCC2) ? + (ulRCC2 & SYSCTL_RCC2_OSCSRC2_M) : + (ulRCC & SYSCTL_RCC_OSCSRC_M)) + { + // + // The main oscillator is the clock source. Determine its rate from + // the crystal setting field. + // + case SYSCTL_RCC_OSCSRC_MAIN: + { + ulClk = g_pulXtals[(ulRCC & SYSCTL_RCC_XTAL_M) >> + SYSCTL_RCC_XTAL_S]; + break; + } + + // + // The internal oscillator is the source clock. + // + case SYSCTL_RCC_OSCSRC_INT: + { + // + // See if this is a Sandstorm-class or Fury-class device. + // + if(CLASS_IS_SANDSTORM) + { + // + // The internal oscillator on a Sandstorm-class device is + // 15 MHz +/- 50%. + // + ulClk = 15000000; + } + else if((CLASS_IS_FURY && REVISION_IS_A2) || + (CLASS_IS_DUSTDEVIL && REVISION_IS_A0)) + { + // + // The internal oscillator on a rev A2 Fury-class device and a + // rev A0 Dustdevil-class device is 12 MHz +/- 30%. + // + ulClk = 12000000; + } + else + { + // + // The internal oscillator on all other devices is 16 MHz. + // + ulClk = 16000000; + } + break; + } + + // + // The internal oscillator divided by four is the source clock. + // + case SYSCTL_RCC_OSCSRC_INT4: + { + // + // See if this is a Sandstorm-class or Fury-class device. + // + if(CLASS_IS_SANDSTORM) + { + // + // The internal oscillator on a Sandstorm-class device is + // 15 MHz +/- 50%. + // + ulClk = 15000000 / 4; + } + else if((CLASS_IS_FURY && REVISION_IS_A2) || + (CLASS_IS_DUSTDEVIL && REVISION_IS_A0)) + { + // + // The internal oscillator on a rev A2 Fury-class device and a + // rev A0 Dustdevil-class device is 12 MHz +/- 30%. + // + ulClk = 12000000 / 4; + } + else + { + // + // The internal oscillator on a Tempest-class device is 16 MHz. + // + ulClk = 16000000 / 4; + } + break; + } + + // + // The internal 30 KHz oscillator is the source clock. + // + case SYSCTL_RCC_OSCSRC_30: + { + // + // The internal 30 KHz oscillator has an accuracy of +/- 30%. + // + ulClk = 30000; + break; + } + + // + // The 4.19 MHz clock from the hibernate module is the clock source. + // + case SYSCTL_RCC2_OSCSRC2_419: + { + ulClk = 4194304; + break; + } + + // + // The 32 KHz clock from the hibernate module is the source clock. + // + case SYSCTL_RCC2_OSCSRC2_32: + { + ulClk = 32768; + break; + } + + // + // An unknown setting, so return a zero clock (that is, an unknown + // clock rate). + // + default: + { + return(0); + } + } + + // + // See if the PLL is being used. + // + if(((ulRCC2 & SYSCTL_RCC2_USERCC2) && !(ulRCC2 & SYSCTL_RCC2_BYPASS2)) || + (!(ulRCC2 & SYSCTL_RCC2_USERCC2) && !(ulRCC & SYSCTL_RCC_BYPASS))) + { + // + // Get the PLL configuration. + // + ulPLL = HWREG(SYSCTL_PLLCFG); + + // + // See if this is a Sandstorm-class or Fury-class device. + // + if(CLASS_IS_SANDSTORM) + { + // + // Compute the PLL output frequency based on its input frequency. + // The formula for a Sandstorm-class devices is + // "(xtal * (f + 2)) / (r + 2)". + // + ulClk = ((ulClk * (((ulPLL & SYSCTL_PLLCFG_F_M) >> + SYSCTL_PLLCFG_F_S) + 2)) / + (((ulPLL & SYSCTL_PLLCFG_R_M) >> + SYSCTL_PLLCFG_R_S) + 2)); + } + else + { + // + // Compute the PLL output frequency based on its input frequency. + // The formula for a Fury-class device is + // "(xtal * f) / ((r + 1) * 2)". + // + ulClk = ((ulClk * ((ulPLL & SYSCTL_PLLCFG_F_M) >> + SYSCTL_PLLCFG_F_S)) / + ((((ulPLL & SYSCTL_PLLCFG_R_M) >> + SYSCTL_PLLCFG_R_S) + 1) * 2)); + } + + // + // See if the optional output divide by 2 is being used. + // + if(ulPLL & SYSCTL_PLLCFG_OD_2) + { + ulClk /= 2; + } + + // + // See if the optional output divide by 4 is being used. + // + if(ulPLL & SYSCTL_PLLCFG_OD_4) + { + ulClk /= 4; + } + + // + // Force the system divider to be enabled. It is always used when + // using the PLL, but in some cases it will not read as being enabled. + // + ulRCC |= SYSCTL_RCC_USESYSDIV; + } + + // + // See if the system divider is being used. + // + if(ulRCC & SYSCTL_RCC_USESYSDIV) + { + // + // Adjust the clock rate by the system clock divider. + // + if(ulRCC2 & SYSCTL_RCC2_USERCC2) + { + if((ulRCC2 & SYSCTL_RCC2_DIV400) && + (((ulRCC2 & SYSCTL_RCC2_USERCC2) && + !(ulRCC2 & SYSCTL_RCC2_BYPASS2)) || + (!(ulRCC2 & SYSCTL_RCC2_USERCC2) && + !(ulRCC & SYSCTL_RCC_BYPASS)))) + + { + ulClk = ((ulClk * 2) / (((ulRCC2 & (SYSCTL_RCC2_SYSDIV2_M | + SYSCTL_RCC2_SYSDIV2LSB)) >> + (SYSCTL_RCC2_SYSDIV2_S - 1)) + 1)); + } + else + { + ulClk /= (((ulRCC2 & SYSCTL_RCC2_SYSDIV2_M) >> + SYSCTL_RCC2_SYSDIV2_S) + 1); + } + } + else + { + ulClk /= (((ulRCC & SYSCTL_RCC_SYSDIV_M) >> SYSCTL_RCC_SYSDIV_S) + + 1); + } + } + + // + // Return the computed clock rate. + // + return(ulClk); +} + +//***************************************************************************** +// +//! Sets the PWM clock configuration. +//! +//! \param ulConfig is the configuration for the PWM clock; it must be one of +//! \b SYSCTL_PWMDIV_1, \b SYSCTL_PWMDIV_2, \b SYSCTL_PWMDIV_4, +//! \b SYSCTL_PWMDIV_8, \b SYSCTL_PWMDIV_16, \b SYSCTL_PWMDIV_32, or +//! \b SYSCTL_PWMDIV_64. +//! +//! This function sets the rate of the clock provided to the PWM module as a +//! ratio of the processor clock. This clock is used by the PWM module to +//! generate PWM signals; its rate forms the basis for all PWM signals. +//! +//! \note The clocking of the PWM is dependent upon the system clock rate as +//! configured by SysCtlClockSet(). +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPWMClockSet(unsigned long ulConfig) +{ + // + // Check the arguments. + // + ASSERT((ulConfig == SYSCTL_PWMDIV_1) || + (ulConfig == SYSCTL_PWMDIV_2) || + (ulConfig == SYSCTL_PWMDIV_4) || + (ulConfig == SYSCTL_PWMDIV_8) || + (ulConfig == SYSCTL_PWMDIV_16) || + (ulConfig == SYSCTL_PWMDIV_32) || + (ulConfig == SYSCTL_PWMDIV_64)); + + // + // Check that there is a PWM block on this part. + // + ASSERT(HWREG(SYSCTL_DC1) & SYSCTL_DC1_PWM); + + // + // Set the PWM clock configuration into the run-mode clock configuration + // register. + // + HWREG(SYSCTL_RCC) = ((HWREG(SYSCTL_RCC) & + ~(SYSCTL_RCC_USEPWMDIV | SYSCTL_RCC_PWMDIV_M)) | + ulConfig); +} + +//***************************************************************************** +// +//! Gets the current PWM clock configuration. +//! +//! This function returns the current PWM clock configuration. +//! +//! \return Returns the current PWM clock configuration; will be one of +//! \b SYSCTL_PWMDIV_1, \b SYSCTL_PWMDIV_2, \b SYSCTL_PWMDIV_4, +//! \b SYSCTL_PWMDIV_8, \b SYSCTL_PWMDIV_16, \b SYSCTL_PWMDIV_32, or +//! \b SYSCTL_PWMDIV_64. +// +//***************************************************************************** +unsigned long +SysCtlPWMClockGet(void) +{ + // + // Check that there is a PWM block on this part. + // + ASSERT(HWREG(SYSCTL_DC1) & SYSCTL_DC1_PWM); + + // + // Return the current PWM clock configuration. Make sure that + // SYSCTL_PWMDIV_1 is returned in all cases where the divider is disabled. + // + if(!(HWREG(SYSCTL_RCC) & SYSCTL_RCC_USEPWMDIV)) + { + // + // The divider is not active so reflect this in the value we return. + // + return(SYSCTL_PWMDIV_1); + } + else + { + // + // The divider is active so directly return the masked register value. + // + return(HWREG(SYSCTL_RCC) & + (SYSCTL_RCC_USEPWMDIV | SYSCTL_RCC_PWMDIV_M)); + } +} + +//***************************************************************************** +// +//! Sets the sample rate of the ADC. +//! +//! \param ulSpeed is the desired sample rate of the ADC; must be one of +//! \b SYSCTL_ADCSPEED_1MSPS, \b SYSCTL_ADCSPEED_500KSPS, +//! \b SYSCTL_ADCSPEED_250KSPS, or \b SYSCTL_ADCSPEED_125KSPS. +//! +//! This function sets the rate at which the ADC samples are captured by the +//! ADC block. The sampling speed may be limited by the hardware, so the +//! sample rate may end up being slower than requested. SysCtlADCSpeedGet() +//! will return the actual speed in use. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlADCSpeedSet(unsigned long ulSpeed) +{ + // + // Check the arguments. + // + ASSERT((ulSpeed == SYSCTL_ADCSPEED_1MSPS) || + (ulSpeed == SYSCTL_ADCSPEED_500KSPS) || + (ulSpeed == SYSCTL_ADCSPEED_250KSPS) || + (ulSpeed == SYSCTL_ADCSPEED_125KSPS)); + + // + // Check that there is an ADC block on this part. + // + ASSERT(HWREG(SYSCTL_DC1) & SYSCTL_DC1_ADC0); + + // + // Set the ADC speed in run, sleep, and deep-sleep mode. + // + HWREG(SYSCTL_RCGC0) = ((HWREG(SYSCTL_RCGC0) & ~(SYSCTL_RCGC0_ADCSPD_M)) | + ulSpeed); + HWREG(SYSCTL_SCGC0) = ((HWREG(SYSCTL_SCGC0) & ~(SYSCTL_SCGC0_ADCSPD_M)) | + ulSpeed); +} + +//***************************************************************************** +// +//! Gets the sample rate of the ADC. +//! +//! This function gets the current sample rate of the ADC. +//! +//! \return Returns the current ADC sample rate; will be one of +//! \b SYSCTL_ADCSPEED_1MSPS, \b SYSCTL_ADCSPEED_500KSPS, +//! \b SYSCTL_ADCSPEED_250KSPS, or \b SYSCTL_ADCSPEED_125KSPS. +// +//***************************************************************************** +unsigned long +SysCtlADCSpeedGet(void) +{ + // + // Check that there is an ADC block on this part. + // + ASSERT(HWREG(SYSCTL_DC1) & SYSCTL_DC1_ADC0); + + // + // Return the current ADC speed. + // + return(HWREG(SYSCTL_RCGC0) & SYSCTL_RCGC0_ADCSPD_M); +} + +//***************************************************************************** +// +//! Configures the internal oscillator verification timer. +//! +//! \param bEnable is a boolean that is \b true if the internal oscillator +//! verification timer should be enabled. +//! +//! This function allows the internal oscillator verification timer to be +//! enabled or disabled. When enabled, an interrupt will be generated if the +//! internal oscillator ceases to operate. +//! +//! The internal oscillator verification timer is only available on +//! Sandstorm-class devices. +//! +//! \note Both oscillators (main and internal) must be enabled for this +//! verification timer to operate as the main oscillator will verify the +//! internal oscillator. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlIOSCVerificationSet(tBoolean bEnable) +{ + // + // Enable or disable the internal oscillator verification timer as + // requested. + // + if(bEnable) + { + HWREG(SYSCTL_RCC) |= SYSCTL_RCC_IOSCVER; + } + else + { + HWREG(SYSCTL_RCC) &= ~(SYSCTL_RCC_IOSCVER); + } +} + +//***************************************************************************** +// +//! Configures the main oscillator verification timer. +//! +//! \param bEnable is a boolean that is \b true if the main oscillator +//! verification timer should be enabled. +//! +//! This function allows the main oscillator verification timer to be enabled +//! or disabled. When enabled, an interrupt will be generated if the main +//! oscillator ceases to operate. +//! +//! The main oscillator verification timer is only available on +//! Sandstorm-class devices. +//! +//! \note Both oscillators (main and internal) must be enabled for this +//! verification timer to operate as the internal oscillator will verify the +//! main oscillator. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlMOSCVerificationSet(tBoolean bEnable) +{ + // + // Enable or disable the main oscillator verification timer as requested. + // + if(bEnable) + { + HWREG(SYSCTL_RCC) |= SYSCTL_RCC_MOSCVER; + } + else + { + HWREG(SYSCTL_RCC) &= ~(SYSCTL_RCC_MOSCVER); + } +} + +//***************************************************************************** +// +//! Configures the PLL verification timer. +//! +//! \param bEnable is a boolean that is \b true if the PLL verification timer +//! should be enabled. +//! +//! This function allows the PLL verification timer to be enabled or disabled. +//! When enabled, an interrupt will be generated if the PLL ceases to operate. +//! +//! The PLL verification timer is only available on Sandstorm-class devices. +//! +//! \note The main oscillator must be enabled for this verification timer to +//! operate as it is used to check the PLL. Also, the verification timer +//! should be disabled while the PLL is being reconfigured via +//! SysCtlClockSet(). +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlPLLVerificationSet(tBoolean bEnable) +{ + // + // Enable or disable the PLL verification timer as requested. + // + if(bEnable) + { + HWREG(SYSCTL_RCC) |= SYSCTL_RCC_PLLVER; + } + else + { + HWREG(SYSCTL_RCC) &= ~(SYSCTL_RCC_PLLVER); + } +} + +//***************************************************************************** +// +//! Clears the clock verification status. +//! +//! This function clears the status of the clock verification timers, allowing +//! them to assert another failure if detected. +//! +//! The clock verification timers are only available on Sandstorm-class +//! devices. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlClkVerificationClear(void) +{ + // + // Clear the clock verification. + // + HWREG(SYSCTL_CLKVCLR) = SYSCTL_CLKVCLR_VERCLR; + + // + // The bit does not self-reset, so clear it. + // + HWREG(SYSCTL_CLKVCLR) = 0; +} + +//***************************************************************************** +// +//! Enables a GPIO peripheral for access from the AHB. +//! +//! \param ulGPIOPeripheral is the GPIO peripheral to enable. +//! +//! This function is used to enable the specified GPIO peripheral to be +//! accessed from the Advanced Host Bus (AHB) instead of the legacy Advanced +//! Peripheral Bus (APB). When a GPIO peripheral is enabled for AHB access, +//! the \b _AHB_BASE form of the base address should be used for GPIO +//! functions. For example, instead of using \b GPIO_PORTA_BASE as the base +//! address for GPIO functions, use \b GPIO_PORTA_AHB_BASE instead. +//! +//! The \e ulGPIOPeripheral argument must be only one of the following values: +//! \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, \b SYSCTL_PERIPH_GPIOC, +//! \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, \b SYSCTL_PERIPH_GPIOF, +//! \b SYSCTL_PERIPH_GPIOG, or \b SYSCTL_PERIPH_GPIOH. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlGPIOAHBEnable(unsigned long ulGPIOPeripheral) +{ + // + // Check the arguments. + // + ASSERT((ulGPIOPeripheral == SYSCTL_PERIPH_GPIOA) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOB) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOC) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOD) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOE) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOF) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOG) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOH) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOJ)); + + // + // Enable this GPIO for AHB access. + // + HWREG(SYSCTL_GPIOHBCTL) |= ulGPIOPeripheral & 0xFFFF; +} + +//***************************************************************************** +// +//! Disables a GPIO peripheral for access from the AHB. +//! +//! \param ulGPIOPeripheral is the GPIO peripheral to disable. +//! +//! This function disables the specified GPIO peripheral for access from the +//! Advanced Host Bus (AHB). Once disabled, the GPIO peripheral is accessed +//! from the legacy Advanced Peripheral Bus (AHB). +//! +//! The \b ulGPIOPeripheral argument must be only one of the following values: +//! \b SYSCTL_PERIPH_GPIOA, \b SYSCTL_PERIPH_GPIOB, \b SYSCTL_PERIPH_GPIOC, +//! \b SYSCTL_PERIPH_GPIOD, \b SYSCTL_PERIPH_GPIOE, \b SYSCTL_PERIPH_GPIOF, +//! \b SYSCTL_PERIPH_GPIOG, or \b SYSCTL_PERIPH_GPIOH. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlGPIOAHBDisable(unsigned long ulGPIOPeripheral) +{ + // + // Check the arguments. + // + ASSERT((ulGPIOPeripheral == SYSCTL_PERIPH_GPIOA) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOB) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOC) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOD) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOE) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOF) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOG) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOH) || + (ulGPIOPeripheral == SYSCTL_PERIPH_GPIOJ)); + + // + // Disable this GPIO for AHB access. + // + HWREG(SYSCTL_GPIOHBCTL) &= ~(ulGPIOPeripheral & 0xFFFF); +} + +//***************************************************************************** +// +//! Powers up the USB PLL. +//! +//! This function will enable the USB controller's PLL which is used by it's +//! physical layer. This call is necessary before connecting to any external +//! devices. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlUSBPLLEnable(void) +{ + // + // Turn on the USB PLL. + // + HWREG(SYSCTL_RCC2) &= ~SYSCTL_RCC2_USBPWRDN; +} + +//***************************************************************************** +// +//! Powers down the USB PLL. +//! +//! This function will disable the USB controller's PLL which is used by it's +//! physical layer. The USB registers are still accessible, but the physical +//! layer will no longer function. +//! +//! \return None. +// +//***************************************************************************** +void +SysCtlUSBPLLDisable(void) +{ + // + // Turn of USB PLL. + // + HWREG(SYSCTL_RCC2) |= SYSCTL_RCC2_USBPWRDN; +} + +//***************************************************************************** +// +//! Sets the MCLK frequency provided to the I2S module. +//! +//! \param ulInputClock is the input clock to the MCLK divider. If this is +//! zero, the value is computed from the current PLL configuration. +//! \param ulMClk is the desired MCLK frequency. If this is zero, MCLK output +//! is disabled. +//! +//! This function sets the dividers to provide MCLK to the I2S module. A MCLK +//! divider will be chosen that produces the MCLK frequency that is the closest +//! possible to the requested frequency, which may be above or below the +//! requested frequency. +//! +//! The actual MCLK frequency will be returned. It is the responsibility of +//! the application to determine if the selected MCLK is acceptable; in general +//! the human ear can not discern the frequency difference if it is within 0.3% +//! of the desired frequency (though there is a very small percentage of the +//! population that can discern lower frequency deviations). +//! +//! \return Returns the actual MCLK frequency. +// +//***************************************************************************** +unsigned long +SysCtlI2SMClkSet(unsigned long ulInputClock, unsigned long ulMClk) +{ + unsigned long ulDivInt, ulDivFrac, ulPLL; + + // + // See if the I2S MCLK should be disabled. + // + if(ulMClk == 0) + { + // + // Disable the I2S MCLK and return. + // + HWREG(SYSCTL_I2SMCLKCFG) = 0; + return(0); + } + + // + // See if the input clock was specified. + // + if(ulInputClock == 0) + { + // + // The input clock was not specified, so compute the output frequency + // of the PLL. Get the current PLL configuration. + // + ulPLL = HWREG(SYSCTL_PLLCFG); + + // + // Get the frequency of the crystal in use. + // + ulInputClock = g_pulXtals[(HWREG(SYSCTL_RCC) & SYSCTL_RCC_XTAL_M) >> + SYSCTL_RCC_XTAL_S]; + + // + // Calculate the PLL output frequency. + // + ulInputClock = ((ulInputClock * ((ulPLL & SYSCTL_PLLCFG_F_M) >> + SYSCTL_PLLCFG_F_S)) / + ((((ulPLL & SYSCTL_PLLCFG_R_M) >> + SYSCTL_PLLCFG_R_S) + 1))); + + // + // See if the optional output divide by 2 is being used. + // + if(ulPLL & SYSCTL_PLLCFG_OD_2) + { + ulInputClock /= 2; + } + + // + // See if the optional output divide by 4 is being used. + // + if(ulPLL & SYSCTL_PLLCFG_OD_4) + { + ulInputClock /= 4; + } + } + + // + // Verify that the requested MCLK frequency is attainable. + // + ASSERT(ulMClk < ulInputClock); + + // + // Add a rounding factor to the input clock, so that the MCLK frequency + // that is closest to the desire value is selected. + // + ulInputClock += (ulMClk / 32) - 1; + + // + // Compute the integer portion of the MCLK divider. + // + ulDivInt = ulInputClock / ulMClk; + + // + // If the divisor is too large, then simply use the maximum divisor. + // + if(CLASS_IS_TEMPEST && REVISION_IS_B1 && (ulDivInt > 255)) + { + ulDivInt = 255; + ulDivFrac = 15; + } + else if(ulDivInt > 1023) + { + ulDivInt = 1023; + ulDivFrac = 15; + } + else + { + // + // Compute the fractional portion of the MCLK divider. + // + ulDivFrac = ((ulInputClock - (ulDivInt * ulMClk)) * 16) / ulMClk; + } + + // + // Set the divisor for the Tx and Rx MCLK generators and enable the clocks. + // + HWREG(SYSCTL_I2SMCLKCFG) = (SYSCTL_I2SMCLKCFG_RXEN | + (ulDivInt << SYSCTL_I2SMCLKCFG_RXI_S) | + (ulDivFrac << SYSCTL_I2SMCLKCFG_RXF_S) | + SYSCTL_I2SMCLKCFG_TXEN | + (ulDivInt << SYSCTL_I2SMCLKCFG_TXI_S) | + (ulDivFrac << SYSCTL_I2SMCLKCFG_TXF_S)); + + // + // Return the actual MCLK frequency. + // + ulInputClock -= (ulMClk / 32) - 1; + ulDivInt = (ulDivInt * 16) + ulDivFrac; + ulMClk = (ulInputClock / ulDivInt) * 16; + ulMClk += ((ulInputClock - ((ulMClk / 16) * ulDivInt)) * 16) / ulDivInt; + return(ulMClk); +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/sysctl.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/sysctl.h new file mode 100644 index 00000000..d5b00681 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/sysctl.h @@ -0,0 +1,466 @@ +//***************************************************************************** +// +// sysctl.h - Prototypes for the system control driver. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __SYSCTL_H__ +#define __SYSCTL_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// The following are values that can be passed to the +// SysCtlPeripheralPresent(), SysCtlPeripheralEnable(), +// SysCtlPeripheralDisable(), and SysCtlPeripheralReset() APIs as the +// ulPeripheral parameter. The peripherals in the fourth group (upper nibble +// is 3) can only be used with the SysCtlPeripheralPresent() API. +// +//***************************************************************************** +#ifndef DEPRECATED +#define SYSCTL_PERIPH_WDOG 0x00000008 // Watchdog +#endif +#define SYSCTL_PERIPH_WDOG0 0x00000008 // Watchdog 0 +#define SYSCTL_PERIPH_HIBERNATE 0x00000040 // Hibernation module +#ifndef DEPRECATED +#define SYSCTL_PERIPH_ADC 0x00100001 // ADC +#endif +#define SYSCTL_PERIPH_ADC0 0x00100001 // ADC0 +#define SYSCTL_PERIPH_ADC1 0x00100002 // ADC1 +#define SYSCTL_PERIPH_PWM 0x00100010 // PWM +#define SYSCTL_PERIPH_CAN0 0x00100100 // CAN 0 +#define SYSCTL_PERIPH_CAN1 0x00100200 // CAN 1 +#define SYSCTL_PERIPH_CAN2 0x00100400 // CAN 2 +#define SYSCTL_PERIPH_WDOG1 0x00101000 // Watchdog 1 +#define SYSCTL_PERIPH_UART0 0x10000001 // UART 0 +#define SYSCTL_PERIPH_UART1 0x10000002 // UART 1 +#define SYSCTL_PERIPH_UART2 0x10000004 // UART 2 +#ifndef DEPRECATED +#define SYSCTL_PERIPH_SSI 0x10000010 // SSI +#endif +#define SYSCTL_PERIPH_SSI0 0x10000010 // SSI 0 +#define SYSCTL_PERIPH_SSI1 0x10000020 // SSI 1 +#ifndef DEPRECATED +#define SYSCTL_PERIPH_QEI 0x10000100 // QEI +#endif +#define SYSCTL_PERIPH_QEI0 0x10000100 // QEI 0 +#define SYSCTL_PERIPH_QEI1 0x10000200 // QEI 1 +#ifndef DEPRECATED +#define SYSCTL_PERIPH_I2C 0x10001000 // I2C +#endif +#define SYSCTL_PERIPH_I2C0 0x10001000 // I2C 0 +#define SYSCTL_PERIPH_I2C1 0x10004000 // I2C 1 +#define SYSCTL_PERIPH_TIMER0 0x10100001 // Timer 0 +#define SYSCTL_PERIPH_TIMER1 0x10100002 // Timer 1 +#define SYSCTL_PERIPH_TIMER2 0x10100004 // Timer 2 +#define SYSCTL_PERIPH_TIMER3 0x10100008 // Timer 3 +#define SYSCTL_PERIPH_COMP0 0x10100100 // Analog comparator 0 +#define SYSCTL_PERIPH_COMP1 0x10100200 // Analog comparator 1 +#define SYSCTL_PERIPH_COMP2 0x10100400 // Analog comparator 2 +#define SYSCTL_PERIPH_I2S0 0x10101000 // I2S0 +#define SYSCTL_PERIPH_EPI0 0x10104000 // EPI0 +#define SYSCTL_PERIPH_GPIOA 0x20000001 // GPIO A +#define SYSCTL_PERIPH_GPIOB 0x20000002 // GPIO B +#define SYSCTL_PERIPH_GPIOC 0x20000004 // GPIO C +#define SYSCTL_PERIPH_GPIOD 0x20000008 // GPIO D +#define SYSCTL_PERIPH_GPIOE 0x20000010 // GPIO E +#define SYSCTL_PERIPH_GPIOF 0x20000020 // GPIO F +#define SYSCTL_PERIPH_GPIOG 0x20000040 // GPIO G +#define SYSCTL_PERIPH_GPIOH 0x20000080 // GPIO H +#define SYSCTL_PERIPH_GPIOJ 0x20000100 // GPIO J +#define SYSCTL_PERIPH_UDMA 0x20002000 // uDMA +#define SYSCTL_PERIPH_USB0 0x20100001 // USB0 +#define SYSCTL_PERIPH_ETH 0x20105000 // ETH +#define SYSCTL_PERIPH_IEEE1588 0x20100100 // IEEE1588 +#define SYSCTL_PERIPH_PLL 0x30000010 // PLL +#define SYSCTL_PERIPH_TEMP 0x30000020 // Temperature sensor +#define SYSCTL_PERIPH_MPU 0x30000080 // Cortex M3 MPU + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlPinPresent() API +// as the ulPin parameter. +// +//***************************************************************************** +#define SYSCTL_PIN_PWM0 0x00000001 // PWM0 pin +#define SYSCTL_PIN_PWM1 0x00000002 // PWM1 pin +#define SYSCTL_PIN_PWM2 0x00000004 // PWM2 pin +#define SYSCTL_PIN_PWM3 0x00000008 // PWM3 pin +#define SYSCTL_PIN_PWM4 0x00000010 // PWM4 pin +#define SYSCTL_PIN_PWM5 0x00000020 // PWM5 pin +#define SYSCTL_PIN_PWM6 0x00000040 // PWM6 pin +#define SYSCTL_PIN_PWM7 0x00000080 // PWM7 pin +#define SYSCTL_PIN_C0MINUS 0x00000040 // C0- pin +#define SYSCTL_PIN_C0PLUS 0x00000080 // C0+ pin +#define SYSCTL_PIN_C0O 0x00000100 // C0o pin +#define SYSCTL_PIN_C1MINUS 0x00000200 // C1- pin +#define SYSCTL_PIN_C1PLUS 0x00000400 // C1+ pin +#define SYSCTL_PIN_C1O 0x00000800 // C1o pin +#define SYSCTL_PIN_C2MINUS 0x00001000 // C2- pin +#define SYSCTL_PIN_C2PLUS 0x00002000 // C2+ pin +#define SYSCTL_PIN_C2O 0x00004000 // C2o pin +#define SYSCTL_PIN_MC_FAULT0 0x00008000 // MC0 Fault pin +#define SYSCTL_PIN_ADC0 0x00010000 // ADC0 pin +#define SYSCTL_PIN_ADC1 0x00020000 // ADC1 pin +#define SYSCTL_PIN_ADC2 0x00040000 // ADC2 pin +#define SYSCTL_PIN_ADC3 0x00080000 // ADC3 pin +#define SYSCTL_PIN_ADC4 0x00100000 // ADC4 pin +#define SYSCTL_PIN_ADC5 0x00200000 // ADC5 pin +#define SYSCTL_PIN_ADC6 0x00400000 // ADC6 pin +#define SYSCTL_PIN_ADC7 0x00800000 // ADC7 pin +#define SYSCTL_PIN_CCP0 0x01000000 // CCP0 pin +#define SYSCTL_PIN_CCP1 0x02000000 // CCP1 pin +#define SYSCTL_PIN_CCP2 0x04000000 // CCP2 pin +#define SYSCTL_PIN_CCP3 0x08000000 // CCP3 pin +#define SYSCTL_PIN_CCP4 0x10000000 // CCP4 pin +#define SYSCTL_PIN_CCP5 0x20000000 // CCP5 pin +#define SYSCTL_PIN_32KHZ 0x80000000 // 32kHz pin + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlLDOSet() API as +// the ulVoltage value, or returned by the SysCtlLDOGet() API. +// +//***************************************************************************** +#define SYSCTL_LDO_2_25V 0x00000005 // LDO output of 2.25V +#define SYSCTL_LDO_2_30V 0x00000004 // LDO output of 2.30V +#define SYSCTL_LDO_2_35V 0x00000003 // LDO output of 2.35V +#define SYSCTL_LDO_2_40V 0x00000002 // LDO output of 2.40V +#define SYSCTL_LDO_2_45V 0x00000001 // LDO output of 2.45V +#define SYSCTL_LDO_2_50V 0x00000000 // LDO output of 2.50V +#define SYSCTL_LDO_2_55V 0x0000001f // LDO output of 2.55V +#define SYSCTL_LDO_2_60V 0x0000001e // LDO output of 2.60V +#define SYSCTL_LDO_2_65V 0x0000001d // LDO output of 2.65V +#define SYSCTL_LDO_2_70V 0x0000001c // LDO output of 2.70V +#define SYSCTL_LDO_2_75V 0x0000001b // LDO output of 2.75V + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlLDOConfigSet() API. +// +//***************************************************************************** +#define SYSCTL_LDOCFG_ARST 0x00000001 // Allow LDO failure to reset +#define SYSCTL_LDOCFG_NORST 0x00000000 // Do not reset on LDO failure + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlIntEnable(), +// SysCtlIntDisable(), and SysCtlIntClear() APIs, or returned in the bit mask +// by the SysCtlIntStatus() API. +// +//***************************************************************************** +#define SYSCTL_INT_MOSC_PUP 0x00000100 // MOSC power-up interrupt +#define SYSCTL_INT_USBPLL_LOCK 0x00000080 // USB PLL lock interrupt +#define SYSCTL_INT_PLL_LOCK 0x00000040 // PLL lock interrupt +#define SYSCTL_INT_CUR_LIMIT 0x00000020 // Current limit interrupt +#define SYSCTL_INT_IOSC_FAIL 0x00000010 // Internal oscillator failure int +#define SYSCTL_INT_MOSC_FAIL 0x00000008 // Main oscillator failure int +#define SYSCTL_INT_POR 0x00000004 // Power on reset interrupt +#define SYSCTL_INT_BOR 0x00000002 // Brown out interrupt +#define SYSCTL_INT_PLL_FAIL 0x00000001 // PLL failure interrupt + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlResetCauseClear() +// API or returned by the SysCtlResetCauseGet() API. +// +//***************************************************************************** +#define SYSCTL_CAUSE_LDO 0x00000020 // LDO power not OK reset +#define SYSCTL_CAUSE_SW 0x00000010 // Software reset +#define SYSCTL_CAUSE_WDOG 0x00000008 // Watchdog reset +#define SYSCTL_CAUSE_BOR 0x00000004 // Brown-out reset +#define SYSCTL_CAUSE_POR 0x00000002 // Power on reset +#define SYSCTL_CAUSE_EXT 0x00000001 // External reset + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlBrownOutConfigSet() +// API as the ulConfig parameter. +// +//***************************************************************************** +#define SYSCTL_BOR_RESET 0x00000002 // Reset instead of interrupting +#define SYSCTL_BOR_RESAMPLE 0x00000001 // Resample BOR before asserting + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlPWMClockSet() API +// as the ulConfig parameter, and can be returned by the SysCtlPWMClockGet() +// API. +// +//***************************************************************************** +#define SYSCTL_PWMDIV_1 0x00000000 // PWM clock is processor clock /1 +#define SYSCTL_PWMDIV_2 0x00100000 // PWM clock is processor clock /2 +#define SYSCTL_PWMDIV_4 0x00120000 // PWM clock is processor clock /4 +#define SYSCTL_PWMDIV_8 0x00140000 // PWM clock is processor clock /8 +#define SYSCTL_PWMDIV_16 0x00160000 // PWM clock is processor clock /16 +#define SYSCTL_PWMDIV_32 0x00180000 // PWM clock is processor clock /32 +#define SYSCTL_PWMDIV_64 0x001A0000 // PWM clock is processor clock /64 + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlADCSpeedSet() API +// as the ulSpeed parameter, and can be returned by the SyCtlADCSpeedGet() +// API. +// +//***************************************************************************** +#define SYSCTL_ADCSPEED_1MSPS 0x00000F00 // 1,000,000 samples per second +#define SYSCTL_ADCSPEED_500KSPS 0x00000A00 // 500,000 samples per second +#define SYSCTL_ADCSPEED_250KSPS 0x00000500 // 250,000 samples per second +#define SYSCTL_ADCSPEED_125KSPS 0x00000000 // 125,000 samples per second + +//***************************************************************************** +// +// The following are values that can be passed to the SysCtlClockSet() API as +// the ulConfig parameter. +// +//***************************************************************************** +#define SYSCTL_SYSDIV_1 0x07800000 // Processor clock is osc/pll /1 +#define SYSCTL_SYSDIV_2 0x00C00000 // Processor clock is osc/pll /2 +#define SYSCTL_SYSDIV_3 0x01400000 // Processor clock is osc/pll /3 +#define SYSCTL_SYSDIV_4 0x01C00000 // Processor clock is osc/pll /4 +#define SYSCTL_SYSDIV_5 0x02400000 // Processor clock is osc/pll /5 +#define SYSCTL_SYSDIV_6 0x02C00000 // Processor clock is osc/pll /6 +#define SYSCTL_SYSDIV_7 0x03400000 // Processor clock is osc/pll /7 +#define SYSCTL_SYSDIV_8 0x03C00000 // Processor clock is osc/pll /8 +#define SYSCTL_SYSDIV_9 0x04400000 // Processor clock is osc/pll /9 +#define SYSCTL_SYSDIV_10 0x04C00000 // Processor clock is osc/pll /10 +#define SYSCTL_SYSDIV_11 0x05400000 // Processor clock is osc/pll /11 +#define SYSCTL_SYSDIV_12 0x05C00000 // Processor clock is osc/pll /12 +#define SYSCTL_SYSDIV_13 0x06400000 // Processor clock is osc/pll /13 +#define SYSCTL_SYSDIV_14 0x06C00000 // Processor clock is osc/pll /14 +#define SYSCTL_SYSDIV_15 0x07400000 // Processor clock is osc/pll /15 +#define SYSCTL_SYSDIV_16 0x07C00000 // Processor clock is osc/pll /16 +#define SYSCTL_SYSDIV_17 0x88400000 // Processor clock is osc/pll /17 +#define SYSCTL_SYSDIV_18 0x88C00000 // Processor clock is osc/pll /18 +#define SYSCTL_SYSDIV_19 0x89400000 // Processor clock is osc/pll /19 +#define SYSCTL_SYSDIV_20 0x89C00000 // Processor clock is osc/pll /20 +#define SYSCTL_SYSDIV_21 0x8A400000 // Processor clock is osc/pll /21 +#define SYSCTL_SYSDIV_22 0x8AC00000 // Processor clock is osc/pll /22 +#define SYSCTL_SYSDIV_23 0x8B400000 // Processor clock is osc/pll /23 +#define SYSCTL_SYSDIV_24 0x8BC00000 // Processor clock is osc/pll /24 +#define SYSCTL_SYSDIV_25 0x8C400000 // Processor clock is osc/pll /25 +#define SYSCTL_SYSDIV_26 0x8CC00000 // Processor clock is osc/pll /26 +#define SYSCTL_SYSDIV_27 0x8D400000 // Processor clock is osc/pll /27 +#define SYSCTL_SYSDIV_28 0x8DC00000 // Processor clock is osc/pll /28 +#define SYSCTL_SYSDIV_29 0x8E400000 // Processor clock is osc/pll /29 +#define SYSCTL_SYSDIV_30 0x8EC00000 // Processor clock is osc/pll /30 +#define SYSCTL_SYSDIV_31 0x8F400000 // Processor clock is osc/pll /31 +#define SYSCTL_SYSDIV_32 0x8FC00000 // Processor clock is osc/pll /32 +#define SYSCTL_SYSDIV_33 0x90400000 // Processor clock is osc/pll /33 +#define SYSCTL_SYSDIV_34 0x90C00000 // Processor clock is osc/pll /34 +#define SYSCTL_SYSDIV_35 0x91400000 // Processor clock is osc/pll /35 +#define SYSCTL_SYSDIV_36 0x91C00000 // Processor clock is osc/pll /36 +#define SYSCTL_SYSDIV_37 0x92400000 // Processor clock is osc/pll /37 +#define SYSCTL_SYSDIV_38 0x92C00000 // Processor clock is osc/pll /38 +#define SYSCTL_SYSDIV_39 0x93400000 // Processor clock is osc/pll /39 +#define SYSCTL_SYSDIV_40 0x93C00000 // Processor clock is osc/pll /40 +#define SYSCTL_SYSDIV_41 0x94400000 // Processor clock is osc/pll /41 +#define SYSCTL_SYSDIV_42 0x94C00000 // Processor clock is osc/pll /42 +#define SYSCTL_SYSDIV_43 0x95400000 // Processor clock is osc/pll /43 +#define SYSCTL_SYSDIV_44 0x95C00000 // Processor clock is osc/pll /44 +#define SYSCTL_SYSDIV_45 0x96400000 // Processor clock is osc/pll /45 +#define SYSCTL_SYSDIV_46 0x96C00000 // Processor clock is osc/pll /46 +#define SYSCTL_SYSDIV_47 0x97400000 // Processor clock is osc/pll /47 +#define SYSCTL_SYSDIV_48 0x97C00000 // Processor clock is osc/pll /48 +#define SYSCTL_SYSDIV_49 0x98400000 // Processor clock is osc/pll /49 +#define SYSCTL_SYSDIV_50 0x98C00000 // Processor clock is osc/pll /50 +#define SYSCTL_SYSDIV_51 0x99400000 // Processor clock is osc/pll /51 +#define SYSCTL_SYSDIV_52 0x99C00000 // Processor clock is osc/pll /52 +#define SYSCTL_SYSDIV_53 0x9A400000 // Processor clock is osc/pll /53 +#define SYSCTL_SYSDIV_54 0x9AC00000 // Processor clock is osc/pll /54 +#define SYSCTL_SYSDIV_55 0x9B400000 // Processor clock is osc/pll /55 +#define SYSCTL_SYSDIV_56 0x9BC00000 // Processor clock is osc/pll /56 +#define SYSCTL_SYSDIV_57 0x9C400000 // Processor clock is osc/pll /57 +#define SYSCTL_SYSDIV_58 0x9CC00000 // Processor clock is osc/pll /58 +#define SYSCTL_SYSDIV_59 0x9D400000 // Processor clock is osc/pll /59 +#define SYSCTL_SYSDIV_60 0x9DC00000 // Processor clock is osc/pll /60 +#define SYSCTL_SYSDIV_61 0x9E400000 // Processor clock is osc/pll /61 +#define SYSCTL_SYSDIV_62 0x9EC00000 // Processor clock is osc/pll /62 +#define SYSCTL_SYSDIV_63 0x9F400000 // Processor clock is osc/pll /63 +#define SYSCTL_SYSDIV_64 0x9FC00000 // Processor clock is osc/pll /64 +#define SYSCTL_SYSDIV_2_5 0xC1000000 // Processor clock is pll / 2.5 +#define SYSCTL_SYSDIV_3_5 0xC1800000 // Processor clock is pll / 3.5 +#define SYSCTL_SYSDIV_4_5 0xC2000000 // Processor clock is pll / 4.5 +#define SYSCTL_SYSDIV_5_5 0xC2800000 // Processor clock is pll / 5.5 +#define SYSCTL_SYSDIV_6_5 0xC3000000 // Processor clock is pll / 6.5 +#define SYSCTL_SYSDIV_7_5 0xC3800000 // Processor clock is pll / 7.5 +#define SYSCTL_SYSDIV_8_5 0xC4000000 // Processor clock is pll / 8.5 +#define SYSCTL_SYSDIV_9_5 0xC4800000 // Processor clock is pll / 9.5 +#define SYSCTL_SYSDIV_10_5 0xC5000000 // Processor clock is pll / 10.5 +#define SYSCTL_SYSDIV_11_5 0xC5800000 // Processor clock is pll / 11.5 +#define SYSCTL_SYSDIV_12_5 0xC6000000 // Processor clock is pll / 12.5 +#define SYSCTL_SYSDIV_13_5 0xC6800000 // Processor clock is pll / 13.5 +#define SYSCTL_SYSDIV_14_5 0xC7000000 // Processor clock is pll / 14.5 +#define SYSCTL_SYSDIV_15_5 0xC7800000 // Processor clock is pll / 15.5 +#define SYSCTL_SYSDIV_16_5 0xC8000000 // Processor clock is pll / 16.5 +#define SYSCTL_SYSDIV_17_5 0xC8800000 // Processor clock is pll / 17.5 +#define SYSCTL_SYSDIV_18_5 0xC9000000 // Processor clock is pll / 18.5 +#define SYSCTL_SYSDIV_19_5 0xC9800000 // Processor clock is pll / 19.5 +#define SYSCTL_SYSDIV_20_5 0xCA000000 // Processor clock is pll / 20.5 +#define SYSCTL_SYSDIV_21_5 0xCA800000 // Processor clock is pll / 21.5 +#define SYSCTL_SYSDIV_22_5 0xCB000000 // Processor clock is pll / 22.5 +#define SYSCTL_SYSDIV_23_5 0xCB800000 // Processor clock is pll / 23.5 +#define SYSCTL_SYSDIV_24_5 0xCC000000 // Processor clock is pll / 24.5 +#define SYSCTL_SYSDIV_25_5 0xCC800000 // Processor clock is pll / 25.5 +#define SYSCTL_SYSDIV_26_5 0xCD000000 // Processor clock is pll / 26.5 +#define SYSCTL_SYSDIV_27_5 0xCD800000 // Processor clock is pll / 27.5 +#define SYSCTL_SYSDIV_28_5 0xCE000000 // Processor clock is pll / 28.5 +#define SYSCTL_SYSDIV_29_5 0xCE800000 // Processor clock is pll / 29.5 +#define SYSCTL_SYSDIV_30_5 0xCF000000 // Processor clock is pll / 30.5 +#define SYSCTL_SYSDIV_31_5 0xCF800000 // Processor clock is pll / 31.5 +#define SYSCTL_SYSDIV_32_5 0xD0000000 // Processor clock is pll / 32.5 +#define SYSCTL_SYSDIV_33_5 0xD0800000 // Processor clock is pll / 33.5 +#define SYSCTL_SYSDIV_34_5 0xD1000000 // Processor clock is pll / 34.5 +#define SYSCTL_SYSDIV_35_5 0xD1800000 // Processor clock is pll / 35.5 +#define SYSCTL_SYSDIV_36_5 0xD2000000 // Processor clock is pll / 36.5 +#define SYSCTL_SYSDIV_37_5 0xD2800000 // Processor clock is pll / 37.5 +#define SYSCTL_SYSDIV_38_5 0xD3000000 // Processor clock is pll / 38.5 +#define SYSCTL_SYSDIV_39_5 0xD3800000 // Processor clock is pll / 39.5 +#define SYSCTL_SYSDIV_40_5 0xD4000000 // Processor clock is pll / 40.5 +#define SYSCTL_SYSDIV_41_5 0xD4800000 // Processor clock is pll / 41.5 +#define SYSCTL_SYSDIV_42_5 0xD5000000 // Processor clock is pll / 42.5 +#define SYSCTL_SYSDIV_43_5 0xD5800000 // Processor clock is pll / 43.5 +#define SYSCTL_SYSDIV_44_5 0xD6000000 // Processor clock is pll / 44.5 +#define SYSCTL_SYSDIV_45_5 0xD6800000 // Processor clock is pll / 45.5 +#define SYSCTL_SYSDIV_46_5 0xD7000000 // Processor clock is pll / 46.5 +#define SYSCTL_SYSDIV_47_5 0xD7800000 // Processor clock is pll / 47.5 +#define SYSCTL_SYSDIV_48_5 0xD8000000 // Processor clock is pll / 48.5 +#define SYSCTL_SYSDIV_49_5 0xD8800000 // Processor clock is pll / 49.5 +#define SYSCTL_SYSDIV_50_5 0xD9000000 // Processor clock is pll / 50.5 +#define SYSCTL_SYSDIV_51_5 0xD9800000 // Processor clock is pll / 51.5 +#define SYSCTL_SYSDIV_52_5 0xDA000000 // Processor clock is pll / 52.5 +#define SYSCTL_SYSDIV_53_5 0xDA800000 // Processor clock is pll / 53.5 +#define SYSCTL_SYSDIV_54_5 0xDB000000 // Processor clock is pll / 54.5 +#define SYSCTL_SYSDIV_55_5 0xDB800000 // Processor clock is pll / 55.5 +#define SYSCTL_SYSDIV_56_5 0xDC000000 // Processor clock is pll / 56.5 +#define SYSCTL_SYSDIV_57_5 0xDC800000 // Processor clock is pll / 57.5 +#define SYSCTL_SYSDIV_58_5 0xDD000000 // Processor clock is pll / 58.5 +#define SYSCTL_SYSDIV_59_5 0xDD800000 // Processor clock is pll / 59.5 +#define SYSCTL_SYSDIV_60_5 0xDE000000 // Processor clock is pll / 60.5 +#define SYSCTL_SYSDIV_61_5 0xDE800000 // Processor clock is pll / 61.5 +#define SYSCTL_SYSDIV_62_5 0xDF000000 // Processor clock is pll / 62.5 +#define SYSCTL_SYSDIV_63_5 0xDF800000 // Processor clock is pll / 63.5 +#define SYSCTL_USE_PLL 0x00000000 // System clock is the PLL clock +#define SYSCTL_USE_OSC 0x00003800 // System clock is the osc clock +#define SYSCTL_XTAL_1MHZ 0x00000000 // External crystal is 1MHz +#define SYSCTL_XTAL_1_84MHZ 0x00000040 // External crystal is 1.8432MHz +#define SYSCTL_XTAL_2MHZ 0x00000080 // External crystal is 2MHz +#define SYSCTL_XTAL_2_45MHZ 0x000000C0 // External crystal is 2.4576MHz +#define SYSCTL_XTAL_3_57MHZ 0x00000100 // External crystal is 3.579545MHz +#define SYSCTL_XTAL_3_68MHZ 0x00000140 // External crystal is 3.6864MHz +#define SYSCTL_XTAL_4MHZ 0x00000180 // External crystal is 4MHz +#define SYSCTL_XTAL_4_09MHZ 0x000001C0 // External crystal is 4.096MHz +#define SYSCTL_XTAL_4_91MHZ 0x00000200 // External crystal is 4.9152MHz +#define SYSCTL_XTAL_5MHZ 0x00000240 // External crystal is 5MHz +#define SYSCTL_XTAL_5_12MHZ 0x00000280 // External crystal is 5.12MHz +#define SYSCTL_XTAL_6MHZ 0x000002C0 // External crystal is 6MHz +#define SYSCTL_XTAL_6_14MHZ 0x00000300 // External crystal is 6.144MHz +#define SYSCTL_XTAL_7_37MHZ 0x00000340 // External crystal is 7.3728MHz +#define SYSCTL_XTAL_8MHZ 0x00000380 // External crystal is 8MHz +#define SYSCTL_XTAL_8_19MHZ 0x000003C0 // External crystal is 8.192MHz +#define SYSCTL_XTAL_10MHZ 0x00000400 // External crystal is 10 MHz +#define SYSCTL_XTAL_12MHZ 0x00000440 // External crystal is 12 MHz +#define SYSCTL_XTAL_12_2MHZ 0x00000480 // External crystal is 12.288 MHz +#define SYSCTL_XTAL_13_5MHZ 0x000004C0 // External crystal is 13.56 MHz +#define SYSCTL_XTAL_14_3MHZ 0x00000500 // External crystal is 14.31818 MHz +#define SYSCTL_XTAL_16MHZ 0x00000540 // External crystal is 16 MHz +#define SYSCTL_XTAL_16_3MHZ 0x00000580 // External crystal is 16.384 MHz +#define SYSCTL_OSC_MAIN 0x00000000 // Osc source is main osc +#define SYSCTL_OSC_INT 0x00000010 // Osc source is int. osc +#define SYSCTL_OSC_INT4 0x00000020 // Osc source is int. osc /4 +#define SYSCTL_OSC_INT30 0x00000030 // Osc source is int. 30 KHz +#define SYSCTL_OSC_EXT4_19 0x80000028 // Osc source is ext. 4.19 MHz +#define SYSCTL_OSC_EXT32 0x80000038 // Osc source is ext. 32 KHz +#define SYSCTL_INT_PIOSC_DIS 0x00000004 // Disable interal precision osc. +#define SYSCTL_INT_OSC_DIS 0x00000002 // Disable internal oscillator +#define SYSCTL_MAIN_OSC_DIS 0x00000001 // Disable main oscillator + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern unsigned long SysCtlSRAMSizeGet(void); +extern unsigned long SysCtlFlashSizeGet(void); +extern tBoolean SysCtlPinPresent(unsigned long ulPin); +extern tBoolean SysCtlPeripheralPresent(unsigned long ulPeripheral); +extern void SysCtlPeripheralReset(unsigned long ulPeripheral); +extern void SysCtlPeripheralEnable(unsigned long ulPeripheral); +extern void SysCtlPeripheralDisable(unsigned long ulPeripheral); +extern void SysCtlPeripheralSleepEnable(unsigned long ulPeripheral); +extern void SysCtlPeripheralSleepDisable(unsigned long ulPeripheral); +extern void SysCtlPeripheralDeepSleepEnable(unsigned long ulPeripheral); +extern void SysCtlPeripheralDeepSleepDisable(unsigned long ulPeripheral); +extern void SysCtlPeripheralClockGating(tBoolean bEnable); +extern void SysCtlIntRegister(void (*pfnHandler)(void)); +extern void SysCtlIntUnregister(void); +extern void SysCtlIntEnable(unsigned long ulInts); +extern void SysCtlIntDisable(unsigned long ulInts); +extern void SysCtlIntClear(unsigned long ulInts); +extern unsigned long SysCtlIntStatus(tBoolean bMasked); +extern void SysCtlLDOSet(unsigned long ulVoltage); +extern unsigned long SysCtlLDOGet(void); +extern void SysCtlLDOConfigSet(unsigned long ulConfig); +extern void SysCtlReset(void); +extern void SysCtlSleep(void); +extern void SysCtlDeepSleep(void); +extern unsigned long SysCtlResetCauseGet(void); +extern void SysCtlResetCauseClear(unsigned long ulCauses); +extern void SysCtlBrownOutConfigSet(unsigned long ulConfig, + unsigned long ulDelay); +extern void SysCtlDelay(unsigned long ulCount); +extern void SysCtlClockSet(unsigned long ulConfig); +extern unsigned long SysCtlClockGet(void); +extern void SysCtlPWMClockSet(unsigned long ulConfig); +extern unsigned long SysCtlPWMClockGet(void); +extern void SysCtlADCSpeedSet(unsigned long ulSpeed); +extern unsigned long SysCtlADCSpeedGet(void); +extern void SysCtlIOSCVerificationSet(tBoolean bEnable); +extern void SysCtlMOSCVerificationSet(tBoolean bEnable); +extern void SysCtlPLLVerificationSet(tBoolean bEnable); +extern void SysCtlClkVerificationClear(void); +extern void SysCtlGPIOAHBEnable(unsigned long ulGPIOPeripheral); +extern void SysCtlGPIOAHBDisable(unsigned long ulGPIOPeripheral); +extern void SysCtlUSBPLLEnable(void); +extern void SysCtlUSBPLLDisable(void); +extern unsigned long SysCtlI2SMClkSet(unsigned long ulInputClock, + unsigned long ulMClk); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __SYSCTL_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/systick.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/systick.c new file mode 100644 index 00000000..f19f19e7 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/systick.c @@ -0,0 +1,259 @@ +//***************************************************************************** +// +// systick.c - Driver for the SysTick timer in NVIC. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup systick_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_ints.h" +#include "inc/hw_nvic.h" +#include "inc/hw_types.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" +#include "driverlib/systick.h" + +//***************************************************************************** +// +//! Enables the SysTick counter. +//! +//! This will start the SysTick counter. If an interrupt handler has been +//! registered, it will be called when the SysTick counter rolls over. +//! +//! \note Calling this function will cause the SysTick counter to (re)commence +//! counting from its current value. The counter is not automatically reloaded +//! with the period as specified in a previous call to SysTickPeriodSet(). If +//! an immediate reload is required, the \b NVIC_ST_CURRENT register must be +//! written to force this. Any write to this register clears the SysTick +//! counter to 0 and will cause a reload with the supplied period on the next +//! clock. +//! +//! \return None. +// +//***************************************************************************** +void +SysTickEnable(void) +{ + // + // Enable SysTick. + // + HWREG(NVIC_ST_CTRL) |= NVIC_ST_CTRL_CLK_SRC | NVIC_ST_CTRL_ENABLE; +} + +//***************************************************************************** +// +//! Disables the SysTick counter. +//! +//! This will stop the SysTick counter. If an interrupt handler has been +//! registered, it will no longer be called until SysTick is restarted. +//! +//! \return None. +// +//***************************************************************************** +void +SysTickDisable(void) +{ + // + // Disable SysTick. + // + HWREG(NVIC_ST_CTRL) &= ~(NVIC_ST_CTRL_ENABLE); +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the SysTick interrupt. +//! +//! \param pfnHandler is a pointer to the function to be called when the +//! SysTick interrupt occurs. +//! +//! This sets the handler to be called when a SysTick interrupt occurs. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +SysTickIntRegister(void (*pfnHandler)(void)) +{ + // + // Register the interrupt handler, returning an error if an error occurs. + // + IntRegister(FAULT_SYSTICK, pfnHandler); + + // + // Enable the SysTick interrupt. + // + HWREG(NVIC_ST_CTRL) |= NVIC_ST_CTRL_INTEN; +} + +//***************************************************************************** +// +//! Unregisters the interrupt handler for the SysTick interrupt. +//! +//! This function will clear the handler to be called when a SysTick interrupt +//! occurs. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +SysTickIntUnregister(void) +{ + // + // Disable the SysTick interrupt. + // + HWREG(NVIC_ST_CTRL) &= ~(NVIC_ST_CTRL_INTEN); + + // + // Unregister the interrupt handler. + // + IntUnregister(FAULT_SYSTICK); +} + +//***************************************************************************** +// +//! Enables the SysTick interrupt. +//! +//! This function will enable the SysTick interrupt, allowing it to be +//! reflected to the processor. +//! +//! \note The SysTick interrupt handler does not need to clear the SysTick +//! interrupt source as this is done automatically by NVIC when the interrupt +//! handler is called. +//! +//! \return None. +// +//***************************************************************************** +void +SysTickIntEnable(void) +{ + // + // Enable the SysTick interrupt. + // + HWREG(NVIC_ST_CTRL) |= NVIC_ST_CTRL_INTEN; +} + +//***************************************************************************** +// +//! Disables the SysTick interrupt. +//! +//! This function will disable the SysTick interrupt, preventing it from being +//! reflected to the processor. +//! +//! \return None. +// +//***************************************************************************** +void +SysTickIntDisable(void) +{ + // + // Disable the SysTick interrupt. + // + HWREG(NVIC_ST_CTRL) &= ~(NVIC_ST_CTRL_INTEN); +} + +//***************************************************************************** +// +//! Sets the period of the SysTick counter. +//! +//! \param ulPeriod is the number of clock ticks in each period of the SysTick +//! counter; must be between 1 and 16,777,216, inclusive. +//! +//! This function sets the rate at which the SysTick counter wraps; this +//! equates to the number of processor clocks between interrupts. +//! +//! \note Calling this function does not cause the SysTick counter to reload +//! immediately. If an immediate reload is required, the \b NVIC_ST_CURRENT +//! register must be written. Any write to this register clears the SysTick +//! counter to 0 and will cause a reload with the \e ulPeriod supplied here on +//! the next clock after the SysTick is enabled. +//! +//! \return None. +// +//***************************************************************************** +void +SysTickPeriodSet(unsigned long ulPeriod) +{ + // + // Check the arguments. + // + ASSERT((ulPeriod > 0) && (ulPeriod <= 16777216)); + + // + // Set the period of the SysTick counter. + // + HWREG(NVIC_ST_RELOAD) = ulPeriod - 1; +} + +//***************************************************************************** +// +//! Gets the period of the SysTick counter. +//! +//! This function returns the rate at which the SysTick counter wraps; this +//! equates to the number of processor clocks between interrupts. +//! +//! \return Returns the period of the SysTick counter. +// +//***************************************************************************** +unsigned long +SysTickPeriodGet(void) +{ + // + // Return the period of the SysTick counter. + // + return(HWREG(NVIC_ST_RELOAD) + 1); +} + +//***************************************************************************** +// +//! Gets the current value of the SysTick counter. +//! +//! This function returns the current value of the SysTick counter; this will +//! be a value between the period - 1 and zero, inclusive. +//! +//! \return Returns the current value of the SysTick counter. +// +//***************************************************************************** +unsigned long +SysTickValueGet(void) +{ + // + // Return the current value of the SysTick counter. + // + return(HWREG(NVIC_ST_CURRENT)); +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/systick.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/systick.h new file mode 100644 index 00000000..31a7e5d1 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/systick.h @@ -0,0 +1,63 @@ +//***************************************************************************** +// +// systick.h - Prototypes for the SysTick driver. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __SYSTICK_H__ +#define __SYSTICK_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern void SysTickEnable(void); +extern void SysTickDisable(void); +extern void SysTickIntRegister(void (*pfnHandler)(void)); +extern void SysTickIntUnregister(void); +extern void SysTickIntEnable(void); +extern void SysTickIntDisable(void); +extern void SysTickPeriodSet(unsigned long ulPeriod); +extern unsigned long SysTickPeriodGet(void); +extern unsigned long SysTickValueGet(void); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __SYSTICK_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/timer.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/timer.c new file mode 100644 index 00000000..9fd98c8a --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/timer.c @@ -0,0 +1,1161 @@ +//***************************************************************************** +// +// timer.c - Driver for the timer module. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup timer_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_timer.h" +#include "inc/hw_types.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" +#include "driverlib/timer.h" + +//***************************************************************************** +// +//! \internal +//! Checks a timer base address. +//! +//! \param ulBase is the base address of the timer module. +//! +//! This function determines if a timer module base address is valid. +//! +//! \return Returns \b true if the base address is valid and \b false +//! otherwise. +// +//***************************************************************************** +#ifdef DEBUG +static tBoolean +TimerBaseValid(unsigned long ulBase) +{ + return((ulBase == TIMER0_BASE) || (ulBase == TIMER1_BASE) || + (ulBase == TIMER2_BASE) || (ulBase == TIMER3_BASE)); +} +#endif + +//***************************************************************************** +// +//! Enables the timer(s). +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer(s) to enable; must be one of \b TIMER_A, +//! \b TIMER_B, or \b TIMER_BOTH. +//! +//! This will enable operation of the timer module. The timer must be +//! configured before it is enabled. +//! +//! \return None. +// +//***************************************************************************** +void +TimerEnable(unsigned long ulBase, unsigned long ulTimer) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) || + (ulTimer == TIMER_BOTH)); + + // + // Enable the timer(s) module. + // + HWREG(ulBase + TIMER_O_CTL) |= ulTimer & (TIMER_CTL_TAEN | TIMER_CTL_TBEN); +} + +//***************************************************************************** +// +//! Disables the timer(s). +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer(s) to disable; must be one of +//! \b TIMER_A, \b TIMER_B, or \b TIMER_BOTH. +//! +//! This will disable operation of the timer module. +//! +//! \return None. +// +//***************************************************************************** +void +TimerDisable(unsigned long ulBase, unsigned long ulTimer) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) || + (ulTimer == TIMER_BOTH)); + + // + // Disable the timer module. + // + HWREG(ulBase + TIMER_O_CTL) &= ~(ulTimer & + (TIMER_CTL_TAEN | TIMER_CTL_TBEN)); +} + +//***************************************************************************** +// +//! Configures the timer(s). +//! +//! \param ulBase is the base address of the timer module. +//! \param ulConfig is the configuration for the timer. +//! +//! This function configures the operating mode of the timer(s). The timer +//! module is disabled before being configured, and is left in the disabled +//! state. The configuration is specified in \e ulConfig as one of the +//! following values: +//! +//! - \b TIMER_CFG_32_BIT_OS - 32-bit one-shot timer +//! - \b TIMER_CFG_32_BIT_OS_UP - 32-bit one-shot timer that counts up instead +//! of down (not available on all parts) +//! - \b TIMER_CFG_32_BIT_PER - 32-bit periodic timer +//! - \b TIMER_CFG_32_BIT_PER_UP - 32-bit periodic timer that counts up instead +//! of down (not available on all parts) +//! - \b TIMER_CFG_32_RTC - 32-bit real time clock timer +//! - \b TIMER_CFG_16_BIT_PAIR - Two 16-bit timers +//! +//! When configured for a pair of 16-bit timers, each timer is separately +//! configured. The first timer is configured by setting \e ulConfig to +//! the result of a logical OR operation between one of the following values +//! and \e ulConfig: +//! +//! - \b TIMER_CFG_A_ONE_SHOT - 16-bit one-shot timer +//! - \b TIMER_CFG_A_ONE_SHOT_UP - 16-bit one-shot timer that counts up instead +//! of down (not available on all parts) +//! - \b TIMER_CFG_A_PERIODIC - 16-bit periodic timer +//! - \b TIMER_CFG_A_PERIODIC_UP - 16-bit periodic timer that counts up instead +//! of down (not available on all parts) +//! - \b TIMER_CFG_A_CAP_COUNT - 16-bit edge count capture +//! - \b TIMER_CFG_A_CAP_TIME - 16-bit edge time capture +//! - \b TIMER_CFG_A_PWM - 16-bit PWM output +//! +//! Similarly, the second timer is configured by setting \e ulConfig to +//! the result of a logical OR operation between one of the corresponding +//! \b TIMER_CFG_B_* values and \e ulConfig. +//! +//! \return None. +// +//***************************************************************************** +void +TimerConfigure(unsigned long ulBase, unsigned long ulConfig) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulConfig == TIMER_CFG_32_BIT_OS) || + (ulConfig == TIMER_CFG_32_BIT_OS_UP) || + (ulConfig == TIMER_CFG_32_BIT_PER) || + (ulConfig == TIMER_CFG_32_BIT_PER_UP) || + (ulConfig == TIMER_CFG_32_RTC) || + ((ulConfig & 0xff000000) == TIMER_CFG_16_BIT_PAIR)); + ASSERT(((ulConfig & 0xff000000) != TIMER_CFG_16_BIT_PAIR) || + ((((ulConfig & 0x000000ff) == TIMER_CFG_A_ONE_SHOT) || + ((ulConfig & 0x000000ff) == TIMER_CFG_A_ONE_SHOT_UP) || + ((ulConfig & 0x000000ff) == TIMER_CFG_A_PERIODIC) || + ((ulConfig & 0x000000ff) == TIMER_CFG_A_PERIODIC_UP) || + ((ulConfig & 0x000000ff) == TIMER_CFG_A_CAP_COUNT) || + ((ulConfig & 0x000000ff) == TIMER_CFG_A_CAP_TIME) || + ((ulConfig & 0x000000ff) == TIMER_CFG_A_PWM)) && + (((ulConfig & 0x0000ff00) == TIMER_CFG_B_ONE_SHOT) || + ((ulConfig & 0x0000ff00) == TIMER_CFG_B_ONE_SHOT_UP) || + ((ulConfig & 0x0000ff00) == TIMER_CFG_B_PERIODIC) || + ((ulConfig & 0x0000ff00) == TIMER_CFG_B_PERIODIC_UP) || + ((ulConfig & 0x0000ff00) == TIMER_CFG_B_CAP_COUNT) || + ((ulConfig & 0x0000ff00) == TIMER_CFG_B_CAP_TIME) || + ((ulConfig & 0x0000ff00) == TIMER_CFG_B_PWM)))); + + // + // Disable the timers. + // + HWREG(ulBase + TIMER_O_CTL) &= ~(TIMER_CTL_TAEN | TIMER_CTL_TBEN); + + // + // Set the global timer configuration. + // + HWREG(ulBase + TIMER_O_CFG) = ulConfig >> 24; + + // + // Set the configuration of the A and B timers. Note that the B timer + // configuration is ignored by the hardware in 32-bit modes. + // + HWREG(ulBase + TIMER_O_TAMR) = ulConfig & 255; + HWREG(ulBase + TIMER_O_TBMR) = (ulConfig >> 8) & 255; +} + +//***************************************************************************** +// +//! Controls the output level. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer(s) to adjust; must be one of \b TIMER_A, +//! \b TIMER_B, or \b TIMER_BOTH. +//! \param bInvert specifies the output level. +//! +//! This function sets the PWM output level for the specified timer. If the +//! \e bInvert parameter is \b true, then the timer's output will be made +//! active low; otherwise, it will be made active high. +//! +//! \return None. +// +//***************************************************************************** +void +TimerControlLevel(unsigned long ulBase, unsigned long ulTimer, + tBoolean bInvert) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) || + (ulTimer == TIMER_BOTH)); + + // + // Set the output levels as requested. + // + ulTimer &= TIMER_CTL_TAPWML | TIMER_CTL_TBPWML; + HWREG(ulBase + TIMER_O_CTL) = (bInvert ? + (HWREG(ulBase + TIMER_O_CTL) | ulTimer) : + (HWREG(ulBase + TIMER_O_CTL) & ~(ulTimer))); +} + +//***************************************************************************** +// +//! Enables or disables the trigger output. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer to adjust; must be one of \b TIMER_A, +//! \b TIMER_B, or \b TIMER_BOTH. +//! \param bEnable specifies the desired trigger state. +//! +//! This function controls the trigger output for the specified timer. If the +//! \e bEnable parameter is \b true, then the timer's output trigger is +//! enabled; otherwise it is disabled. +//! +//! \return None. +// +//***************************************************************************** +void +TimerControlTrigger(unsigned long ulBase, unsigned long ulTimer, + tBoolean bEnable) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) || + (ulTimer == TIMER_BOTH)); + + // + // Set the trigger output as requested. + // + ulTimer &= TIMER_CTL_TAOTE | TIMER_CTL_TBOTE; + HWREG(ulBase + TIMER_O_CTL) = (bEnable ? + (HWREG(ulBase + TIMER_O_CTL) | ulTimer) : + (HWREG(ulBase + TIMER_O_CTL) & ~(ulTimer))); +} + +//***************************************************************************** +// +//! Controls the event type. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer(s) to be adjusted; must be one of +//! \b TIMER_A, \b TIMER_B, or \b TIMER_BOTH. +//! \param ulEvent specifies the type of event; must be one of +//! \b TIMER_EVENT_POS_EDGE, \b TIMER_EVENT_NEG_EDGE, or +//! \b TIMER_EVENT_BOTH_EDGES. +//! +//! This function sets the signal edge(s) that will trigger the timer when in +//! capture mode. +//! +//! \return None. +// +//***************************************************************************** +void +TimerControlEvent(unsigned long ulBase, unsigned long ulTimer, + unsigned long ulEvent) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) || + (ulTimer == TIMER_BOTH)); + + // + // Set the event type. + // + ulEvent &= ulTimer & (TIMER_CTL_TAEVENT_M | TIMER_CTL_TBEVENT_M); + HWREG(ulBase + TIMER_O_CTL) = ((HWREG(ulBase + TIMER_O_CTL) & + ~(TIMER_CTL_TAEVENT_M | + TIMER_CTL_TBEVENT_M)) | ulEvent); +} + +//***************************************************************************** +// +//! Controls the stall handling. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer(s) to be adjusted; must be one of +//! \b TIMER_A, \b TIMER_B, or \b TIMER_BOTH. +//! \param bStall specifies the response to a stall signal. +//! +//! This function controls the stall response for the specified timer. If the +//! \e bStall parameter is \b true, then the timer will stop counting if the +//! processor enters debug mode; otherwise the timer will keep running while in +//! debug mode. +//! +//! \return None. +// +//***************************************************************************** +void +TimerControlStall(unsigned long ulBase, unsigned long ulTimer, + tBoolean bStall) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) || + (ulTimer == TIMER_BOTH)); + + // + // Set the stall mode. + // + ulTimer &= TIMER_CTL_TASTALL | TIMER_CTL_TBSTALL; + HWREG(ulBase + TIMER_O_CTL) = (bStall ? + (HWREG(ulBase + TIMER_O_CTL) | ulTimer) : + (HWREG(ulBase + TIMER_O_CTL) & ~(ulTimer))); +} + +//***************************************************************************** +// +//! Controls the wait on trigger handling. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer(s) to be adjusted; must be one of +//! \b TIMER_A, \b TIMER_B, or \b TIMER_BOTH. +//! \param bWait specifies if the timer should wait for a trigger input. +//! +//! This function controls whether or not a timer waits for a trigger input to +//! start counting. When enabled, the previous timer in the trigger chain must +//! count to its timeout in order for this timer to start counting. Refer to +//! the part's data sheet for a description of the trigger chain. +//! +//! \note This functionality is not available on all parts. +//! +//! \return None. +// +//***************************************************************************** +void +TimerControlWaitOnTrigger(unsigned long ulBase, unsigned long ulTimer, + tBoolean bWait) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) || + (ulTimer == TIMER_BOTH)); + + // + // Set the wait on trigger mode for timer A. + // + if((ulTimer & TIMER_A) != 0) + { + if(bWait) + { + HWREG(ulBase + TIMER_O_TAMR) |= TIMER_TAMR_TAWOT; + } + else + { + HWREG(ulBase + TIMER_O_TAMR) &= ~(TIMER_TAMR_TAWOT); + } + } + + // + // Set the wait on trigger mode for timer A. + // + if((ulTimer & TIMER_B) != 0) + { + if(bWait) + { + HWREG(ulBase + TIMER_O_TBMR) |= TIMER_TBMR_TBWOT; + } + else + { + HWREG(ulBase + TIMER_O_TBMR) &= ~(TIMER_TBMR_TBWOT); + } + } +} + +//***************************************************************************** +// +//! Enable RTC counting. +//! +//! \param ulBase is the base address of the timer module. +//! +//! This function causes the timer to start counting when in RTC mode. If not +//! configured for RTC mode, this will do nothing. +//! +//! \return None. +// +//***************************************************************************** +void +TimerRTCEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + + // + // Enable RTC counting. + // + HWREG(ulBase + TIMER_O_CTL) |= TIMER_CTL_RTCEN; +} + +//***************************************************************************** +// +//! Disable RTC counting. +//! +//! \param ulBase is the base address of the timer module. +//! +//! This function causes the timer to stop counting when in RTC mode. +//! +//! \return None. +// +//***************************************************************************** +void +TimerRTCDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + + // + // Disable RTC counting. + // + HWREG(ulBase + TIMER_O_CTL) &= ~(TIMER_CTL_RTCEN); +} + +//***************************************************************************** +// +//! Set the timer prescale value. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer(s) to adjust; must be one of \b TIMER_A, +//! \b TIMER_B, or \b TIMER_BOTH. +//! \param ulValue is the timer prescale value; must be between 0 and 255, +//! inclusive. +//! +//! This function sets the value of the input clock prescaler. The prescaler +//! is only operational when in 16-bit mode and is used to extend the range of +//! the 16-bit timer modes. +//! +//! \return None. +// +//***************************************************************************** +void +TimerPrescaleSet(unsigned long ulBase, unsigned long ulTimer, + unsigned long ulValue) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) || + (ulTimer == TIMER_BOTH)); + ASSERT(ulValue < 256); + + // + // Set the timer A prescaler if requested. + // + if(ulTimer & TIMER_A) + { + HWREG(ulBase + TIMER_O_TAPR) = ulValue; + } + + // + // Set the timer B prescaler if requested. + // + if(ulTimer & TIMER_B) + { + HWREG(ulBase + TIMER_O_TBPR) = ulValue; + } +} + +//***************************************************************************** +// +//! Get the timer prescale value. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer; must be one of \b TIMER_A or +//! \b TIMER_B. +//! +//! This function gets the value of the input clock prescaler. The prescaler +//! is only operational when in 16-bit mode and is used to extend the range of +//! the 16-bit timer modes. +//! +//! \return The value of the timer prescaler. +// +//***************************************************************************** +unsigned long +TimerPrescaleGet(unsigned long ulBase, unsigned long ulTimer) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) || + (ulTimer == TIMER_BOTH)); + + // + // Return the appropriate prescale value. + // + return((ulTimer == TIMER_A) ? HWREG(ulBase + TIMER_O_TAPR) : + HWREG(ulBase + TIMER_O_TBPR)); +} + +//***************************************************************************** +// +//! Set the timer prescale match value. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer(s) to adjust; must be one of \b TIMER_A, +//! \b TIMER_B, or \b TIMER_BOTH. +//! \param ulValue is the timer prescale match value; must be between 0 and +//! 255, inclusive. +//! +//! This function sets the value of the input clock prescaler match value. +//! When in a 16-bit mode that uses the counter match and the prescaler, the +//! prescale match effectively extends the range of the counter to 24-bits. +//! +//! \note This functionality is not available on all parts. +//! +//! \return None. +// +//***************************************************************************** +void +TimerPrescaleMatchSet(unsigned long ulBase, unsigned long ulTimer, + unsigned long ulValue) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) || + (ulTimer == TIMER_BOTH)); + ASSERT(ulValue < 256); + + // + // Set the timer A prescale match if requested. + // + if(ulTimer & TIMER_A) + { + HWREG(ulBase + TIMER_O_TAPMR) = ulValue; + } + + // + // Set the timer B prescale match if requested. + // + if(ulTimer & TIMER_B) + { + HWREG(ulBase + TIMER_O_TBPMR) = ulValue; + } +} + +//***************************************************************************** +// +//! Get the timer prescale match value. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer; must be one of \b TIMER_A or +//! \b TIMER_B. +//! +//! This function gets the value of the input clock prescaler match value. +//! When in a 16-bit mode that uses the counter match and prescaler, the +//! prescale match effectively extends the range of the counter to 24-bits. +//! +//! \note This functionality is not available on all parts. +//! +//! \return The value of the timer prescale match. +// +//***************************************************************************** +unsigned long +TimerPrescaleMatchGet(unsigned long ulBase, unsigned long ulTimer) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) || + (ulTimer == TIMER_BOTH)); + + // + // Return the appropriate prescale match value. + // + return((ulTimer == TIMER_A) ? HWREG(ulBase + TIMER_O_TAPMR) : + HWREG(ulBase + TIMER_O_TBPMR)); +} + +//***************************************************************************** +// +//! Sets the timer load value. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer(s) to adjust; must be one of \b TIMER_A, +//! \b TIMER_B, or \b TIMER_BOTH. Only \b TIMER_A should be used when the +//! timer is configured for 32-bit operation. +//! \param ulValue is the load value. +//! +//! This function sets the timer load value; if the timer is running then the +//! value will be immediately loaded into the timer. +//! +//! \return None. +// +//***************************************************************************** +void +TimerLoadSet(unsigned long ulBase, unsigned long ulTimer, + unsigned long ulValue) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) || + (ulTimer == TIMER_BOTH)); + + // + // Set the timer A load value if requested. + // + if(ulTimer & TIMER_A) + { + HWREG(ulBase + TIMER_O_TAILR) = ulValue; + } + + // + // Set the timer B load value if requested. + // + if(ulTimer & TIMER_B) + { + HWREG(ulBase + TIMER_O_TBILR) = ulValue; + } +} + +//***************************************************************************** +// +//! Gets the timer load value. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer; must be one of \b TIMER_A or +//! \b TIMER_B. Only \b TIMER_A should be used when the timer is configured +//! for 32-bit operation. +//! +//! This function gets the currently programmed interval load value for the +//! specified timer. +//! +//! \return Returns the load value for the timer. +// +//***************************************************************************** +unsigned long +TimerLoadGet(unsigned long ulBase, unsigned long ulTimer) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B)); + + // + // Return the appropriate load value. + // + return((ulTimer == TIMER_A) ? HWREG(ulBase + TIMER_O_TAILR) : + HWREG(ulBase + TIMER_O_TBILR)); +} + +//***************************************************************************** +// +//! Gets the current timer value. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer; must be one of \b TIMER_A or +//! \b TIMER_B. Only \b TIMER_A should be used when the timer is configured +//! for 32-bit operation. +//! +//! This function reads the current value of the specified timer. +//! +//! \return Returns the current value of the timer. +// +//***************************************************************************** +unsigned long +TimerValueGet(unsigned long ulBase, unsigned long ulTimer) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B)); + + // + // Return the appropriate timer value. + // + return((ulTimer == TIMER_A) ? HWREG(ulBase + TIMER_O_TAR) : + HWREG(ulBase + TIMER_O_TBR)); +} + +//***************************************************************************** +// +//! Sets the timer match value. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer(s) to adjust; must be one of \b TIMER_A, +//! \b TIMER_B, or \b TIMER_BOTH. Only \b TIMER_A should be used when the +//! timer is configured for 32-bit operation. +//! \param ulValue is the match value. +//! +//! This function sets the match value for a timer. This is used in capture +//! count mode to determine when to interrupt the processor and in PWM mode to +//! determine the duty cycle of the output signal. +//! +//! \return None. +// +//***************************************************************************** +void +TimerMatchSet(unsigned long ulBase, unsigned long ulTimer, + unsigned long ulValue) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) || + (ulTimer == TIMER_BOTH)); + + // + // Set the timer A match value if requested. + // + if(ulTimer & TIMER_A) + { + HWREG(ulBase + TIMER_O_TAMATCHR) = ulValue; + } + + // + // Set the timer B match value if requested. + // + if(ulTimer & TIMER_B) + { + HWREG(ulBase + TIMER_O_TBMATCHR) = ulValue; + } +} + +//***************************************************************************** +// +//! Gets the timer match value. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer; must be one of \b TIMER_A or +//! \b TIMER_B. Only \b TIMER_A should be used when the timer is configured +//! for 32-bit operation. +//! +//! This function gets the match value for the specified timer. +//! +//! \return Returns the match value for the timer. +// +//***************************************************************************** +unsigned long +TimerMatchGet(unsigned long ulBase, unsigned long ulTimer) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B)); + + // + // Return the appropriate match value. + // + return((ulTimer == TIMER_A) ? HWREG(ulBase + TIMER_O_TAMATCHR) : + HWREG(ulBase + TIMER_O_TBMATCHR)); +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the timer interrupt. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer(s); must be one of \b TIMER_A, +//! \b TIMER_B, or \b TIMER_BOTH. +//! \param pfnHandler is a pointer to the function to be called when the timer +//! interrupt occurs. +//! +//! This sets the handler to be called when a timer interrupt occurs. This +//! will enable the global interrupt in the interrupt controller; specific +//! timer interrupts must be enabled via TimerIntEnable(). It is the interrupt +//! handler's responsibility to clear the interrupt source via TimerIntClear(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +TimerIntRegister(unsigned long ulBase, unsigned long ulTimer, + void (*pfnHandler)(void)) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) || + (ulTimer == TIMER_BOTH)); + + // + // Get the interrupt number for this timer module. + // + ulBase = ((ulBase == TIMER0_BASE) ? INT_TIMER0A : + ((ulBase == TIMER1_BASE) ? INT_TIMER1A : + ((ulBase == TIMER2_BASE) ? INT_TIMER2A : INT_TIMER3A))); + + // + // Register an interrupt handler for timer A if requested. + // + if(ulTimer & TIMER_A) + { + // + // Register the interrupt handler. + // + IntRegister(ulBase, pfnHandler); + + // + // Enable the interrupt. + // + IntEnable(ulBase); + } + + // + // Register an interrupt handler for timer B if requested. + // + if(ulTimer & TIMER_B) + { + // + // Register the interrupt handler. + // + IntRegister(ulBase + 1, pfnHandler); + + // + // Enable the interrupt. + // + IntEnable(ulBase + 1); + } +} + +//***************************************************************************** +// +//! Unregisters an interrupt handler for the timer interrupt. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulTimer specifies the timer(s); must be one of \b TIMER_A, +//! \b TIMER_B, or \b TIMER_BOTH. +//! +//! This function will clear the handler to be called when a timer interrupt +//! occurs. This will also mask off the interrupt in the interrupt controller +//! so that the interrupt handler no longer is called. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +TimerIntUnregister(unsigned long ulBase, unsigned long ulTimer) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) || + (ulTimer == TIMER_BOTH)); + + // + // Get the interrupt number for this timer module. + // + ulBase = ((ulBase == TIMER0_BASE) ? INT_TIMER0A : + ((ulBase == TIMER1_BASE) ? INT_TIMER1A : + ((ulBase == TIMER2_BASE) ? INT_TIMER2A : INT_TIMER3A))); + + // + // Unregister the interrupt handler for timer A if requested. + // + if(ulTimer & TIMER_A) + { + // + // Disable the interrupt. + // + IntDisable(ulBase); + + // + // Unregister the interrupt handler. + // + IntUnregister(ulBase); + } + + // + // Unregister the interrupt handler for timer B if requested. + // + if(ulTimer & TIMER_B) + { + // + // Disable the interrupt. + // + IntDisable(ulBase + 1); + + // + // Unregister the interrupt handler. + // + IntUnregister(ulBase + 1); + } +} + +//***************************************************************************** +// +//! Enables individual timer interrupt sources. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulIntFlags is the bit mask of the interrupt sources to be enabled. +//! +//! Enables the indicated timer interrupt sources. Only the sources that are +//! enabled can be reflected to the processor interrupt; disabled sources have +//! no effect on the processor. +//! +//! The \e ulIntFlags parameter must be the logical OR of any combination of +//! the following: +//! +//! - \b TIMER_CAPB_EVENT - Capture B event interrupt +//! - \b TIMER_CAPB_MATCH - Capture B match interrupt +//! - \b TIMER_TIMB_TIMEOUT - Timer B timeout interrupt +//! - \b TIMER_RTC_MATCH - RTC interrupt mask +//! - \b TIMER_CAPA_EVENT - Capture A event interrupt +//! - \b TIMER_CAPA_MATCH - Capture A match interrupt +//! - \b TIMER_TIMA_TIMEOUT - Timer A timeout interrupt +//! +//! \return None. +// +//***************************************************************************** +void +TimerIntEnable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + + // + // Enable the specified interrupts. + // + HWREG(ulBase + TIMER_O_IMR) |= ulIntFlags; +} + +//***************************************************************************** +// +//! Disables individual timer interrupt sources. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulIntFlags is the bit mask of the interrupt sources to be disabled. +//! +//! Disables the indicated timer interrupt sources. Only the sources that are +//! enabled can be reflected to the processor interrupt; disabled sources have +//! no effect on the processor. +//! +//! The \e ulIntFlags parameter has the same definition as the \e ulIntFlags +//! parameter to TimerIntEnable(). +//! +//! \return None. +// +//***************************************************************************** +void +TimerIntDisable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + + // + // Disable the specified interrupts. + // + HWREG(ulBase + TIMER_O_IMR) &= ~(ulIntFlags); +} + +//***************************************************************************** +// +//! Gets the current interrupt status. +//! +//! \param ulBase is the base address of the timer module. +//! \param bMasked is false if the raw interrupt status is required and true if +//! the masked interrupt status is required. +//! +//! This returns the interrupt status for the timer module. Either the raw +//! interrupt status or the status of interrupts that are allowed to reflect to +//! the processor can be returned. +//! +//! \return The current interrupt status, enumerated as a bit field of +//! values described in TimerIntEnable(). +// +//***************************************************************************** +unsigned long +TimerIntStatus(unsigned long ulBase, tBoolean bMasked) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + return(bMasked ? HWREG(ulBase + TIMER_O_MIS) : + HWREG(ulBase + TIMER_O_RIS)); +} + +//***************************************************************************** +// +//! Clears timer interrupt sources. +//! +//! \param ulBase is the base address of the timer module. +//! \param ulIntFlags is a bit mask of the interrupt sources to be cleared. +//! +//! The specified timer interrupt sources are cleared, so that they no longer +//! assert. This must be done in the interrupt handler to keep it from being +//! called again immediately upon exit. +//! +//! The \e ulIntFlags parameter has the same definition as the \e ulIntFlags +//! parameter to TimerIntEnable(). +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +TimerIntClear(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + + // + // Clear the requested interrupt sources. + // + HWREG(ulBase + TIMER_O_ICR) = ulIntFlags; +} + +//***************************************************************************** +// +// Puts the timer into its reset state. +// +// \param ulBase is the base address of the timer module. +// +// The specified timer is disabled, and all its interrupts are disabled, +// cleared, and unregistered. Then the timer registers are set to their reset +// value. +// +// \return None. +// +//***************************************************************************** +#ifndef DEPRECATED +void +TimerQuiesce(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(TimerBaseValid(ulBase)); + + // + // Disable the timer. + // + HWREG(ulBase + TIMER_O_CTL) = TIMER_RV_CTL; + + // + // Disable all the timer interrupts. + // + HWREG(ulBase + TIMER_O_IMR) = TIMER_RV_IMR; + + // + // Clear all the timer interrupts. + // + HWREG(ulBase + TIMER_O_ICR) = 0xFFFFFFFF; + + // + // Unregister the interrupt handler. This also disables interrupts to the + // core. + // + TimerIntUnregister(ulBase, TIMER_BOTH); + + // + // Set all the registers to their reset value. + // + HWREG(ulBase + TIMER_O_CFG) = TIMER_RV_CFG; + HWREG(ulBase + TIMER_O_TAMR) = TIMER_RV_TAMR; + HWREG(ulBase + TIMER_O_TBMR) = TIMER_RV_TBMR; + HWREG(ulBase + TIMER_O_RIS) = TIMER_RV_RIS; + HWREG(ulBase + TIMER_O_MIS) = TIMER_RV_MIS; + HWREG(ulBase + TIMER_O_TAILR) = TIMER_RV_TAILR; + HWREG(ulBase + TIMER_O_TBILR) = TIMER_RV_TBILR; + HWREG(ulBase + TIMER_O_TAMATCHR) = TIMER_RV_TAMATCHR; + HWREG(ulBase + TIMER_O_TBMATCHR) = TIMER_RV_TBMATCHR; + HWREG(ulBase + TIMER_O_TAPR) = TIMER_RV_TAPR; + HWREG(ulBase + TIMER_O_TBPR) = TIMER_RV_TBPR; + HWREG(ulBase + TIMER_O_TAPMR) = TIMER_RV_TAPMR; + HWREG(ulBase + TIMER_O_TBPMR) = TIMER_RV_TBPMR; + HWREG(ulBase + TIMER_O_TAR) = TIMER_RV_TAR; + HWREG(ulBase + TIMER_O_TBR) = TIMER_RV_TBR; +} +#endif // DEPRECATED + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/timer.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/timer.h new file mode 100644 index 00000000..e59b1e9e --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/timer.h @@ -0,0 +1,165 @@ +//***************************************************************************** +// +// timer.h - Prototypes for the timer module +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __TIMER_H__ +#define __TIMER_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Values that can be passed to TimerConfigure as the ulConfig parameter. +// +//***************************************************************************** +#define TIMER_CFG_32_BIT_OS 0x00000001 // 32-bit one-shot timer +#define TIMER_CFG_32_BIT_OS_UP 0x00000011 // 32-bit one-shot up-count timer +#define TIMER_CFG_32_BIT_PER 0x00000002 // 32-bit periodic timer +#define TIMER_CFG_32_BIT_PER_UP 0x00000012 // 32-bit periodic up-count timer +#define TIMER_CFG_32_RTC 0x01000000 // 32-bit RTC timer +#define TIMER_CFG_16_BIT_PAIR 0x04000000 // Two 16-bit timers +#define TIMER_CFG_A_ONE_SHOT 0x00000001 // Timer A one-shot timer +#define TIMER_CFG_A_ONE_SHOT_UP 0x00000011 // Timer A one-shot up-count timer +#define TIMER_CFG_A_PERIODIC 0x00000002 // Timer A periodic timer +#define TIMER_CFG_A_PERIODIC_UP 0x00000012 // Timer A periodic up-count timer +#define TIMER_CFG_A_CAP_COUNT 0x00000003 // Timer A event counter +#define TIMER_CFG_A_CAP_TIME 0x00000007 // Timer A event timer +#define TIMER_CFG_A_PWM 0x0000000A // Timer A PWM output +#define TIMER_CFG_B_ONE_SHOT 0x00000100 // Timer B one-shot timer +#define TIMER_CFG_B_ONE_SHOT_UP 0x00001100 // Timer B one-shot up-count timer +#define TIMER_CFG_B_PERIODIC 0x00000200 // Timer B periodic timer +#define TIMER_CFG_B_PERIODIC_UP 0x00001200 // Timer B periodic up-count timer +#define TIMER_CFG_B_CAP_COUNT 0x00000300 // Timer B event counter +#define TIMER_CFG_B_CAP_TIME 0x00000700 // Timer B event timer +#define TIMER_CFG_B_PWM 0x00000A00 // Timer B PWM output + +//***************************************************************************** +// +// Values that can be passed to TimerIntEnable, TimerIntDisable, and +// TimerIntClear as the ulIntFlags parameter, and returned from TimerIntStatus. +// +//***************************************************************************** +#define TIMER_TIMB_MATCH 0x00000800 // TimerB match interrupt +#define TIMER_CAPB_EVENT 0x00000400 // CaptureB event interrupt +#define TIMER_CAPB_MATCH 0x00000200 // CaptureB match interrupt +#define TIMER_TIMB_TIMEOUT 0x00000100 // TimerB time out interrupt +#define TIMER_TIMA_MATCH 0x00000010 // TimerA match interrupt +#define TIMER_RTC_MATCH 0x00000008 // RTC interrupt mask +#define TIMER_CAPA_EVENT 0x00000004 // CaptureA event interrupt +#define TIMER_CAPA_MATCH 0x00000002 // CaptureA match interrupt +#define TIMER_TIMA_TIMEOUT 0x00000001 // TimerA time out interrupt + +//***************************************************************************** +// +// Values that can be passed to TimerControlEvent as the ulEvent parameter. +// +//***************************************************************************** +#define TIMER_EVENT_POS_EDGE 0x00000000 // Count positive edges +#define TIMER_EVENT_NEG_EDGE 0x00000404 // Count negative edges +#define TIMER_EVENT_BOTH_EDGES 0x00000C0C // Count both edges + +//***************************************************************************** +// +// Values that can be passed to most of the timer APIs as the ulTimer +// parameter. +// +//***************************************************************************** +#define TIMER_A 0x000000ff // Timer A +#define TIMER_B 0x0000ff00 // Timer B +#define TIMER_BOTH 0x0000ffff // Timer Both + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern void TimerEnable(unsigned long ulBase, unsigned long ulTimer); +extern void TimerDisable(unsigned long ulBase, unsigned long ulTimer); +extern void TimerConfigure(unsigned long ulBase, unsigned long ulConfig); +extern void TimerControlLevel(unsigned long ulBase, unsigned long ulTimer, + tBoolean bInvert); +extern void TimerControlTrigger(unsigned long ulBase, unsigned long ulTimer, + tBoolean bEnable); +extern void TimerControlEvent(unsigned long ulBase, unsigned long ulTimer, + unsigned long ulEvent); +extern void TimerControlStall(unsigned long ulBase, unsigned long ulTimer, + tBoolean bStall); +extern void TimerControlWaitOnTrigger(unsigned long ulBase, + unsigned long ulTimer, + tBoolean bWait); +extern void TimerRTCEnable(unsigned long ulBase); +extern void TimerRTCDisable(unsigned long ulBase); +extern void TimerPrescaleSet(unsigned long ulBase, unsigned long ulTimer, + unsigned long ulValue); +extern unsigned long TimerPrescaleGet(unsigned long ulBase, + unsigned long ulTimer); +extern void TimerPrescaleMatchSet(unsigned long ulBase, unsigned long ulTimer, + unsigned long ulValue); +extern unsigned long TimerPrescaleMatchGet(unsigned long ulBase, + unsigned long ulTimer); +extern void TimerLoadSet(unsigned long ulBase, unsigned long ulTimer, + unsigned long ulValue); +extern unsigned long TimerLoadGet(unsigned long ulBase, unsigned long ulTimer); +extern unsigned long TimerValueGet(unsigned long ulBase, + unsigned long ulTimer); +extern void TimerMatchSet(unsigned long ulBase, unsigned long ulTimer, + unsigned long ulValue); +extern unsigned long TimerMatchGet(unsigned long ulBase, + unsigned long ulTimer); +extern void TimerIntRegister(unsigned long ulBase, unsigned long ulTimer, + void (*pfnHandler)(void)); +extern void TimerIntUnregister(unsigned long ulBase, unsigned long ulTimer); +extern void TimerIntEnable(unsigned long ulBase, unsigned long ulIntFlags); +extern void TimerIntDisable(unsigned long ulBase, unsigned long ulIntFlags); +extern unsigned long TimerIntStatus(unsigned long ulBase, tBoolean bMasked); +extern void TimerIntClear(unsigned long ulBase, unsigned long ulIntFlags); + +//***************************************************************************** +// +// TimerQuiesce() has been deprecated. SysCtlPeripheralReset() should be used +// instead to return the timer to its reset state. +// +//***************************************************************************** +#ifndef DEPRECATED +extern void TimerQuiesce(unsigned long ulBase); +#endif + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __TIMER_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/uart.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/uart.c new file mode 100644 index 00000000..51f8ab81 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/uart.c @@ -0,0 +1,1611 @@ +//***************************************************************************** +// +// uart.c - Driver for the UART. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup uart_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_sysctl.h" +#include "inc/hw_types.h" +#include "inc/hw_uart.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" +#include "driverlib/uart.h" + +//***************************************************************************** +// +// The system clock divider defining the maximum baud rate supported by the +// UART. +// +//***************************************************************************** +#define UART_CLK_DIVIDER ((CLASS_IS_SANDSTORM || \ + (CLASS_IS_FURY && REVISION_IS_A2) || \ + (CLASS_IS_DUSTDEVIL && REVISION_IS_A0)) ? \ + 16 : 8) + +//***************************************************************************** +// +//! \internal +//! Checks a UART base address. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function determines if a UART port base address is valid. +//! +//! \return Returns \b true if the base address is valid and \b false +//! otherwise. +// +//***************************************************************************** +#ifdef DEBUG +static tBoolean +UARTBaseValid(unsigned long ulBase) +{ + return((ulBase == UART0_BASE) || (ulBase == UART1_BASE) || + (ulBase == UART2_BASE)); +} +#endif + +//***************************************************************************** +// +//! Sets the type of parity. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulParity specifies the type of parity to use. +//! +//! Sets the type of parity to use for transmitting and expect when receiving. +//! The \e ulParity parameter must be one of \b UART_CONFIG_PAR_NONE, +//! \b UART_CONFIG_PAR_EVEN, \b UART_CONFIG_PAR_ODD, \b UART_CONFIG_PAR_ONE, +//! or \b UART_CONFIG_PAR_ZERO. The last two allow direct control of the +//! parity bit; it is always either one or zero based on the mode. +//! +//! \return None. +// +//***************************************************************************** +void +UARTParityModeSet(unsigned long ulBase, unsigned long ulParity) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + ASSERT((ulParity == UART_CONFIG_PAR_NONE) || + (ulParity == UART_CONFIG_PAR_EVEN) || + (ulParity == UART_CONFIG_PAR_ODD) || + (ulParity == UART_CONFIG_PAR_ONE) || + (ulParity == UART_CONFIG_PAR_ZERO)); + + // + // Set the parity mode. + // + HWREG(ulBase + UART_O_LCRH) = ((HWREG(ulBase + UART_O_LCRH) & + ~(UART_LCRH_SPS | UART_LCRH_EPS | + UART_LCRH_PEN)) | ulParity); +} + +//***************************************************************************** +// +//! Gets the type of parity currently being used. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function gets the type of parity used for transmitting data and +//! expected when receiving data. +//! +//! \return Returns the current parity settings, specified as one of +//! \b UART_CONFIG_PAR_NONE, \b UART_CONFIG_PAR_EVEN, \b UART_CONFIG_PAR_ODD, +//! \b UART_CONFIG_PAR_ONE, or \b UART_CONFIG_PAR_ZERO. +// +//***************************************************************************** +unsigned long +UARTParityModeGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Return the current parity setting. + // + return(HWREG(ulBase + UART_O_LCRH) & + (UART_LCRH_SPS | UART_LCRH_EPS | UART_LCRH_PEN)); +} + +//***************************************************************************** +// +//! Sets the FIFO level at which interrupts are generated. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulTxLevel is the transmit FIFO interrupt level, specified as one of +//! \b UART_FIFO_TX1_8, \b UART_FIFO_TX2_8, \b UART_FIFO_TX4_8, +//! \b UART_FIFO_TX6_8, or \b UART_FIFO_TX7_8. +//! \param ulRxLevel is the receive FIFO interrupt level, specified as one of +//! \b UART_FIFO_RX1_8, \b UART_FIFO_RX2_8, \b UART_FIFO_RX4_8, +//! \b UART_FIFO_RX6_8, or \b UART_FIFO_RX7_8. +//! +//! This function sets the FIFO level at which transmit and receive interrupts +//! are generated. +//! +//! \return None. +// +//***************************************************************************** +void +UARTFIFOLevelSet(unsigned long ulBase, unsigned long ulTxLevel, + unsigned long ulRxLevel) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + ASSERT((ulTxLevel == UART_FIFO_TX1_8) || + (ulTxLevel == UART_FIFO_TX2_8) || + (ulTxLevel == UART_FIFO_TX4_8) || + (ulTxLevel == UART_FIFO_TX6_8) || + (ulTxLevel == UART_FIFO_TX7_8)); + ASSERT((ulRxLevel == UART_FIFO_RX1_8) || + (ulRxLevel == UART_FIFO_RX2_8) || + (ulRxLevel == UART_FIFO_RX4_8) || + (ulRxLevel == UART_FIFO_RX6_8) || + (ulRxLevel == UART_FIFO_RX7_8)); + + // + // Set the FIFO interrupt levels. + // + HWREG(ulBase + UART_O_IFLS) = ulTxLevel | ulRxLevel; +} + +//***************************************************************************** +// +//! Gets the FIFO level at which interrupts are generated. +//! +//! \param ulBase is the base address of the UART port. +//! \param pulTxLevel is a pointer to storage for the transmit FIFO level, +//! returned as one of \b UART_FIFO_TX1_8, \b UART_FIFO_TX2_8, +//! \b UART_FIFO_TX4_8, \b UART_FIFO_TX6_8, or \b UART_FIFO_TX7_8. +//! \param pulRxLevel is a pointer to storage for the receive FIFO level, +//! returned as one of \b UART_FIFO_RX1_8, \b UART_FIFO_RX2_8, +//! \b UART_FIFO_RX4_8, \b UART_FIFO_RX6_8, or \b UART_FIFO_RX7_8. +//! +//! This function gets the FIFO level at which transmit and receive interrupts +//! are generated. +//! +//! \return None. +// +//***************************************************************************** +void +UARTFIFOLevelGet(unsigned long ulBase, unsigned long *pulTxLevel, + unsigned long *pulRxLevel) +{ + unsigned long ulTemp; + + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Read the FIFO level register. + // + ulTemp = HWREG(ulBase + UART_O_IFLS); + + // + // Extract the transmit and receive FIFO levels. + // + *pulTxLevel = ulTemp & UART_IFLS_TX_M; + *pulRxLevel = ulTemp & UART_IFLS_RX_M; +} + +//***************************************************************************** +// +//! Sets the configuration of a UART. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulUARTClk is the rate of the clock supplied to the UART module. +//! \param ulBaud is the desired baud rate. +//! \param ulConfig is the data format for the port (number of data bits, +//! number of stop bits, and parity). +//! +//! This function configures the UART for operation in the specified data +//! format. The baud rate is provided in the \e ulBaud parameter and the data +//! format in the \e ulConfig parameter. +//! +//! The \e ulConfig parameter is the logical OR of three values: the number of +//! data bits, the number of stop bits, and the parity. \b UART_CONFIG_WLEN_8, +//! \b UART_CONFIG_WLEN_7, \b UART_CONFIG_WLEN_6, and \b UART_CONFIG_WLEN_5 +//! select from eight to five data bits per byte (respectively). +//! \b UART_CONFIG_STOP_ONE and \b UART_CONFIG_STOP_TWO select one or two stop +//! bits (respectively). \b UART_CONFIG_PAR_NONE, \b UART_CONFIG_PAR_EVEN, +//! \b UART_CONFIG_PAR_ODD, \b UART_CONFIG_PAR_ONE, and \b UART_CONFIG_PAR_ZERO +//! select the parity mode (no parity bit, even parity bit, odd parity bit, +//! parity bit always one, and parity bit always zero, respectively). +//! +//! The peripheral clock will be the same as the processor clock. This will be +//! the value returned by SysCtlClockGet(), or it can be explicitly hard coded +//! if it is constant and known (to save the code/execution overhead of a call +//! to SysCtlClockGet()). +//! +//! This function replaces the original UARTConfigSet() API and performs the +//! same actions. A macro is provided in uart.h to map the original +//! API to this API. +//! +//! \return None. +// +//***************************************************************************** +void +UARTConfigSetExpClk(unsigned long ulBase, unsigned long ulUARTClk, + unsigned long ulBaud, unsigned long ulConfig) +{ + unsigned long ulDiv; + + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + ASSERT(ulBaud != 0); + ASSERT(ulUARTClk >= (ulBaud * UART_CLK_DIVIDER)); + + // + // Stop the UART. + // + UARTDisable(ulBase); + + // + // Is the required baud rate greater than the maximum rate supported + // without the use of high speed mode? + // + if((ulBaud * 16) > ulUARTClk) + { + // + // Enable high speed mode. + // + HWREG(ulBase + UART_O_CTL) |= UART_CTL_HSE; + + // + // Half the supplied baud rate to compensate for enabling high speed + // mode. This allows the following code to be common to both cases. + // + ulBaud /= 2; + } + else + { + // + // Disable high speed mode. + // + HWREG(ulBase + UART_O_CTL) &= ~(UART_CTL_HSE); + } + + // + // Compute the fractional baud rate divider. + // + ulDiv = (((ulUARTClk * 8) / ulBaud) + 1) / 2; + + // + // Set the baud rate. + // + HWREG(ulBase + UART_O_IBRD) = ulDiv / 64; + HWREG(ulBase + UART_O_FBRD) = ulDiv % 64; + + // + // Set parity, data length, and number of stop bits. + // + HWREG(ulBase + UART_O_LCRH) = ulConfig; + + // + // Clear the flags register. + // + HWREG(ulBase + UART_O_FR) = 0; + + // + // Start the UART. + // + UARTEnable(ulBase); +} + +//***************************************************************************** +// +//! Gets the current configuration of a UART. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulUARTClk is the rate of the clock supplied to the UART module. +//! \param pulBaud is a pointer to storage for the baud rate. +//! \param pulConfig is a pointer to storage for the data format. +//! +//! The baud rate and data format for the UART is determined, given an +//! explicitly provided peripheral clock (hence the ExpClk suffix). The +//! returned baud rate is the actual baud rate; it may not be the exact baud +//! rate requested or an ``official'' baud rate. The data format returned in +//! \e pulConfig is enumerated the same as the \e ulConfig parameter of +//! UARTConfigSetExpClk(). +//! +//! The peripheral clock will be the same as the processor clock. This will be +//! the value returned by SysCtlClockGet(), or it can be explicitly hard coded +//! if it is constant and known (to save the code/execution overhead of a call +//! to SysCtlClockGet()). +//! +//! This function replaces the original UARTConfigGet() API and performs the +//! same actions. A macro is provided in uart.h to map the original +//! API to this API. +//! +//! \return None. +// +//***************************************************************************** +void +UARTConfigGetExpClk(unsigned long ulBase, unsigned long ulUARTClk, + unsigned long *pulBaud, unsigned long *pulConfig) +{ + unsigned long ulInt, ulFrac; + + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Compute the baud rate. + // + ulInt = HWREG(ulBase + UART_O_IBRD); + ulFrac = HWREG(ulBase + UART_O_FBRD); + *pulBaud = (ulUARTClk * 4) / ((64 * ulInt) + ulFrac); + + // + // See if high speed mode enabled. + // + if(HWREG(ulBase + UART_O_CTL) & UART_CTL_HSE) + { + // + // High speed mode is enabled so the actual baud rate is actually + // double what was just calculated. + // + *pulBaud *= 2; + } + + // + // Get the parity, data length, and number of stop bits. + // + *pulConfig = (HWREG(ulBase + UART_O_LCRH) & + (UART_LCRH_SPS | UART_LCRH_WLEN_M | UART_LCRH_STP2 | + UART_LCRH_EPS | UART_LCRH_PEN)); +} + +//***************************************************************************** +// +//! Enables transmitting and receiving. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Sets the UARTEN, TXE, and RXE bits, and enables the transmit and receive +//! FIFOs. +//! +//! \return None. +// +//***************************************************************************** +void +UARTEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Enable the FIFO. + // + HWREG(ulBase + UART_O_LCRH) |= UART_LCRH_FEN; + + // + // Enable RX, TX, and the UART. + // + HWREG(ulBase + UART_O_CTL) |= (UART_CTL_UARTEN | UART_CTL_TXE | + UART_CTL_RXE); +} + +//***************************************************************************** +// +//! Disables transmitting and receiving. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Clears the UARTEN, TXE, and RXE bits, then waits for the end of +//! transmission of the current character, and flushes the transmit FIFO. +//! +//! \return None. +// +//***************************************************************************** +void +UARTDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Wait for end of TX. + // + while(HWREG(ulBase + UART_O_FR) & UART_FR_BUSY) + { + } + + // + // Disable the FIFO. + // + HWREG(ulBase + UART_O_LCRH) &= ~(UART_LCRH_FEN); + + // + // Disable the UART. + // + HWREG(ulBase + UART_O_CTL) &= ~(UART_CTL_UARTEN | UART_CTL_TXE | + UART_CTL_RXE); +} + +//***************************************************************************** +// +//! Enables the transmit and receive FIFOs. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This functions enables the transmit and receive FIFOs in the UART. +//! +//! \return None. +// +//***************************************************************************** +void +UARTFIFOEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Enable the FIFO. + // + HWREG(ulBase + UART_O_LCRH) |= UART_LCRH_FEN; +} + +//***************************************************************************** +// +//! Disables the transmit and receive FIFOs. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This functions disables the transmit and receive FIFOs in the UART. +//! +//! \return None. +// +//***************************************************************************** +void +UARTFIFODisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Disable the FIFO. + // + HWREG(ulBase + UART_O_LCRH) &= ~(UART_LCRH_FEN); +} + +//***************************************************************************** +// +//! Enables SIR (IrDA) mode on the specified UART. +//! +//! \param ulBase is the base address of the UART port. +//! \param bLowPower indicates if SIR Low Power Mode is to be used. +//! +//! Enables the SIREN control bit for IrDA mode on the UART. If the +//! \e bLowPower flag is set, then SIRLP bit will also be set. +//! +//! \note SIR (IrDA) operation is not supported on Sandstorm-class devices. +//! +//! \return None. +// +//***************************************************************************** +void +UARTEnableSIR(unsigned long ulBase, tBoolean bLowPower) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Enable SIR and SIRLP (if appropriate). + // + if(bLowPower) + { + HWREG(ulBase + UART_O_CTL) |= (UART_CTL_SIREN | UART_CTL_SIRLP); + } + else + { + HWREG(ulBase + UART_O_CTL) |= (UART_CTL_SIREN); + } +} + +//***************************************************************************** +// +//! Disables SIR (IrDA) mode on the specified UART. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Clears the SIREN (IrDA) and SIRLP (Low Power) bits. +//! +//! \note SIR (IrDA) operation is not supported on Sandstorm-class devices. +//! +//! \return None. +// +//***************************************************************************** +void +UARTDisableSIR(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Disable SIR and SIRLP (if appropriate). + // + HWREG(ulBase + UART_O_CTL) &= ~(UART_CTL_SIREN | UART_CTL_SIRLP); +} + +//***************************************************************************** +// +//! Enables ISO 7816 smart card mode on the specified UART. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Enables the SMART control bit for ISO 7816 smart card mode on the UART. +//! This call also sets 8 bit word length and even parity as required by ISO +//! 7816. +//! +//! \note The availability of ISO 7816 smart card mode varies with the +//! Stellaris part and UART in use. Please consult the datasheet for the part +//! you are using to determine whether this support is available. +//! +//! \return None. +// +//***************************************************************************** +void +UARTSmartCardEnable(unsigned long ulBase) +{ + unsigned long ulVal; + + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(UARTBaseValid(ulBase)); + + // + // Set 8 bit word length, even parity, 2 stop bits (even though the STP2 + // bit is ignored when in smartcard mode, this lets the caller read back + // the actual setting in use). + // + ulVal = HWREG(ulBase + UART_O_LCRH); + ulVal &= ~(UART_LCRH_SPS | UART_LCRH_EPS | UART_LCRH_PEN | + UART_LCRH_WLEN_M); + ulVal |= UART_LCRH_WLEN_8 | UART_LCRH_PEN | UART_LCRH_EPS | UART_LCRH_STP2; + HWREG(ulBase + UART_O_LCRH) = ulVal; + + // + // Enable SMART mode. + // + HWREG(ulBase + UART_O_CTL) |= UART_CTL_SMART; +} + +//***************************************************************************** +// +//! Disables ISO 7816 smart card mode on the specified UART. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Clears the SMART (ISO 7816 smart card) bits in the UART control register. +//! +//! \note The availability of ISO 7816 smart card mode varies with the +//! Stellaris part and UART in use. Please consult the datasheet for the part +//! you are using to determine whether this support is available. +//! +//! \return None. +// +//***************************************************************************** +void +UARTSmartCardDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(UARTBaseValid(ulBase)); + + // + // Disable the SMART bit. + // + HWREG(ulBase + UART_O_CTL) &= ~UART_CTL_SMART; +} + +//***************************************************************************** +// +//! Sets the states of the DTR and/or RTS modem control signals. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulControl is a bit-mapped flag indicating which modem control bits +//! should be set. +//! +//! Sets the states of the DTR or RTS modem handshake outputs from the UART. +//! +//! The \e ulControl parameter is the logical OR of any of the following: +//! +//! - \b UART_OUTPUT_DTR - The Modem Control DTR signal +//! - \b UART_OUTPUT_RTS - The Modem Control RTS signal +//! +//! \note The availability of hardware modem handshake signals varies with the +//! Stellaris part and UART in use. Please consult the datasheet for the part +//! you are using to determine whether this support is available. +//! +//! \return None. +// +//***************************************************************************** +void +UARTModemControlSet(unsigned long ulBase, unsigned long ulControl) +{ + unsigned long ulTemp; + + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(ulBase == UART1_BASE); + ASSERT((ulControl & ~(UART_OUTPUT_RTS | UART_OUTPUT_DTR)) == 0); + + // + // Set the appropriate modem control output bits. + // + ulTemp = HWREG(ulBase + UART_O_CTL); + ulTemp |= (ulControl & (UART_OUTPUT_RTS | UART_OUTPUT_DTR)); + HWREG(ulBase + UART_O_CTL) = ulTemp; +} + +//***************************************************************************** +// +//! Clears the states of the DTR and/or RTS modem control signals. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulControl is a bit-mapped flag indicating which modem control bits +//! should be set. +//! +//! Clears the states of the DTR or RTS modem handshake outputs from the UART. +//! +//! The \e ulControl parameter is the logical OR of any of the following: +//! +//! - \b UART_OUTPUT_DTR - The Modem Control DTR signal +//! - \b UART_OUTPUT_RTS - The Modem Control RTS signal +//! +//! \note The availability of hardware modem handshake signals varies with the +//! Stellaris part and UART in use. Please consult the datasheet for the part +//! you are using to determine whether this support is available. +//! +//! \return None. +// +//***************************************************************************** +void +UARTModemControlClear(unsigned long ulBase, unsigned long ulControl) +{ + unsigned long ulTemp; + + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(ulBase == UART1_BASE); + ASSERT((ulControl & ~(UART_OUTPUT_RTS | UART_OUTPUT_DTR)) == 0); + + // + // Set the appropriate modem control output bits. + // + ulTemp = HWREG(ulBase + UART_O_CTL); + ulTemp &= ~(ulControl & (UART_OUTPUT_RTS | UART_OUTPUT_DTR)); + HWREG(ulBase + UART_O_CTL) = ulTemp; +} + +//***************************************************************************** +// +//! Gets the states of the DTR and RTS modem control signals. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Returns the current states of each of the two UART modem control signals, +//! DTR and RTS. +//! +//! \note The availability of hardware modem handshake signals varies with the +//! Stellaris part and UART in use. Please consult the datasheet for the part +//! you are using to determine whether this support is available. +//! +//! \return Returns the states of the handshake output signals. This will be a +//! logical logical OR combination of values \b UART_OUTPUT_RTS and +//! \b UART_OUTPUT_DTR where the presence of each flag indicates that the +//! associated signal is asserted. +// +//***************************************************************************** +unsigned long +UARTModemControlGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(ulBase == UART1_BASE); + + return(HWREG(ulBase + UART_O_CTL) & (UART_OUTPUT_RTS | UART_OUTPUT_DTR)); +} + +//***************************************************************************** +// +//! Gets the states of the RI, DCD, DSR and CTS modem status signals. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Returns the current states of each of the four UART modem status signals, +//! RI, DCD, DSR and CTS. +//! +//! \note The availability of hardware modem handshake signals varies with the +//! Stellaris part and UART in use. Please consult the datasheet for the part +//! you are using to determine whether this support is available. +//! +//! \return Returns the states of the handshake output signals. This will be a +//! logical logical OR combination of values \b UART_INPUT_RI, \b +//! UART_INPUT_DCD, \b UART_INPUT_CTS and \b UART_INPUT_DSR where the +//! presence of each flag indicates that the associated signal is asserted. +// +//***************************************************************************** +unsigned long +UARTModemStatusGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(ulBase == UART1_BASE); + + return(HWREG(ulBase + UART_O_FR) & (UART_INPUT_RI | UART_INPUT_DCD | + UART_INPUT_CTS | UART_INPUT_DSR)); +} + +//***************************************************************************** +// +//! Sets the UART hardware flow control mode to be used. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulMode indicates the flow control modes to be used. This is a +//! logical OR combination of values \b UART_FLOWCONTROL_TX and \b +//! UART_FLOWCONTROL_RX to enable hardware transmit (CTS) and receive (RTS) +//! flow control or \b UART_FLOWCONTROL_NONE to disable hardware flow control. +//! +//! Sets the required hardware flow control modes. If \e ulMode contains +//! flag \b UART_FLOWCONTROL_TX, data is only transmitted if the incoming CTS +//! signal is asserted. If \e ulMode contains flag \b UART_FLOWCONTROL_RX, +//! the RTS output is controlled by the hardware and is asserted only when +//! there is space available in the receive FIFO. If no hardware flow control +//! is required, UART_FLOWCONTROL_NONE should be passed. +//! +//! \note The availability of hardware flow control varies with the Stellaris +//! part and UART in use. Please consult the datasheet for the part you are +//! using to determine whether this support is available. +//! +//! \return None. +// +//***************************************************************************** +void +UARTFlowControlSet(unsigned long ulBase, unsigned long ulMode) +{ + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(UARTBaseValid(ulBase)); + ASSERT((ulMode & ~(UART_FLOWCONTROL_TX | UART_FLOWCONTROL_RX)) == 0); + + // + // Set the flow control mode as requested. + // + HWREG(ulBase + UART_O_CTL) = ((HWREG(ulBase + UART_O_CTL) & + ~(UART_FLOWCONTROL_TX | + UART_FLOWCONTROL_RX)) | ulMode); +} + +//***************************************************************************** +// +//! Returns the UART hardware flow control mode currently in use. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Returns the current hardware flow control mode. +//! +//! \note The availability of hardware flow control varies with the Stellaris +//! part and UART in use. Please consult the datasheet for the part you are +//! using to determine whether this support is available. +//! +//! \return Returns the current flow control mode in use. This is a +//! logical OR combination of values \b UART_FLOWCONTROL_TX if transmit +//! (CTS) flow control is enabled and \b UART_FLOWCONTROL_RX if receive (RTS) +//! flow control is in use. If hardware flow control is disabled, \b +//! UART_FLOWCONTROL_NONE will be returned. +// +//***************************************************************************** +unsigned long +UARTFlowControlGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(!CLASS_IS_SANDSTORM && !CLASS_IS_FURY && !CLASS_IS_DUSTDEVIL); + ASSERT(UARTBaseValid(ulBase)); + + return(HWREG(ulBase + UART_O_CTL) & (UART_FLOWCONTROL_TX | + UART_FLOWCONTROL_RX)); +} + +//***************************************************************************** +// +//! Sets the operating mode for the UART transmit interrupt. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulMode is the operating mode for the transmit interrupt. It may be +//! \b UART_TXINT_MODE_EOT to trigger interrupts when the transmitter is idle +//! or \b UART_TXINT_MODE_FIFO to trigger based on the current transmit FIFO +//! level. +//! +//! This function allows the mode of the UART transmit interrupt to be set. By +//! default, the transmit interrupt is asserted when the FIFO level falls past +//! a threshold set via a call to UARTFIFOLevelSet(). Alternatively, if this +//! function is called with \e ulMode set to \b UART_TXINT_MODE_EOT, the +//! transmit interrupt will only be asserted once the transmitter is completely +//! idle - the transmit FIFO is empty and all bits, including any stop bits, +//! have cleared the transmitter. +//! +//! \note The availability of end-of-transmission mode varies with the +//! Stellaris part in use. Please consult the datasheet for the part you are +//! using to determine whether this support is available. +//! +//! \return None. +// +//***************************************************************************** +void +UARTTxIntModeSet(unsigned long ulBase, unsigned long ulMode) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + ASSERT((ulMode == UART_TXINT_MODE_EOT) || + (ulMode == UART_TXINT_MODE_FIFO)); + + // + // Set or clear the EOT bit of the UART control register as appropriate. + // + HWREG(ulBase + UART_O_CTL) = ((HWREG(ulBase + UART_O_CTL) & + ~(UART_TXINT_MODE_EOT | + UART_TXINT_MODE_FIFO)) | ulMode); +} + +//***************************************************************************** +// +//! Returns the current operating mode for the UART transmit interrupt. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function returns the current operating mode for the UART transmit +//! interrupt. The return value will be \b UART_TXINT_MODE_EOT if the +//! transmit interrupt is currently set to be asserted once the transmitter is +//! completely idle - the transmit FIFO is empty and all bits, including any +//! stop bits, have cleared the transmitter. The return value will be \b +//! UART_TXINT_MODE_FIFO if the interrupt is set to be asserted based upon the +//! level of the transmit FIFO. +//! +//! \note The availability of end-of-transmission mode varies with the +//! Stellaris part in use. Please consult the datasheet for the part you are +//! using to determine whether this support is available. +//! +//! \return Returns \b UART_TXINT_MODE_FIFO or \b UART_TXINT_MODE_EOT. +// +//***************************************************************************** +unsigned long +UARTTxIntModeGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Return the current transmit interrupt mode. + // + return(HWREG(ulBase + UART_O_CTL) & (UART_TXINT_MODE_EOT | + UART_TXINT_MODE_FIFO)); +} + +//***************************************************************************** +// +//! Determines if there are any characters in the receive FIFO. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function returns a flag indicating whether or not there is data +//! available in the receive FIFO. +//! +//! \return Returns \b true if there is data in the receive FIFO or \b false +//! if there is no data in the receive FIFO. +// +//***************************************************************************** +tBoolean +UARTCharsAvail(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Return the availability of characters. + // + return((HWREG(ulBase + UART_O_FR) & UART_FR_RXFE) ? false : true); +} + +//***************************************************************************** +// +//! Determines if there is any space in the transmit FIFO. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function returns a flag indicating whether or not there is space +//! available in the transmit FIFO. +//! +//! \return Returns \b true if there is space available in the transmit FIFO +//! or \b false if there is no space available in the transmit FIFO. +// +//***************************************************************************** +tBoolean +UARTSpaceAvail(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Return the availability of space. + // + return((HWREG(ulBase + UART_O_FR) & UART_FR_TXFF) ? false : true); +} + +//***************************************************************************** +// +//! Receives a character from the specified port. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Gets a character from the receive FIFO for the specified port. +//! +//! This function replaces the original UARTCharNonBlockingGet() API and +//! performs the same actions. A macro is provided in uart.h to map +//! the original API to this API. +//! +//! \return Returns the character read from the specified port, cast as a +//! \e long. A \b -1 is returned if there are no characters present in the +//! receive FIFO. The UARTCharsAvail() function should be called before +//! attempting to call this function. +// +//***************************************************************************** +long +UARTCharGetNonBlocking(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // See if there are any characters in the receive FIFO. + // + if(!(HWREG(ulBase + UART_O_FR) & UART_FR_RXFE)) + { + // + // Read and return the next character. + // + return(HWREG(ulBase + UART_O_DR)); + } + else + { + // + // There are no characters, so return a failure. + // + return(-1); + } +} + +//***************************************************************************** +// +//! Waits for a character from the specified port. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Gets a character from the receive FIFO for the specified port. If there +//! are no characters available, this function waits until a character is +//! received before returning. +//! +//! \return Returns the character read from the specified port, cast as a +//! \e long. +// +//***************************************************************************** +long +UARTCharGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Wait until a char is available. + // + while(HWREG(ulBase + UART_O_FR) & UART_FR_RXFE) + { + } + + // + // Now get the char. + // + return(HWREG(ulBase + UART_O_DR)); +} + +//***************************************************************************** +// +//! Sends a character to the specified port. +//! +//! \param ulBase is the base address of the UART port. +//! \param ucData is the character to be transmitted. +//! +//! Writes the character \e ucData to the transmit FIFO for the specified port. +//! This function does not block, so if there is no space available, then a +//! \b false is returned, and the application must retry the function later. +//! +//! This function replaces the original UARTCharNonBlockingPut() API and +//! performs the same actions. A macro is provided in uart.h to map +//! the original API to this API. +//! +//! \return Returns \b true if the character was successfully placed in the +//! transmit FIFO or \b false if there was no space available in the transmit +//! FIFO. +// +//***************************************************************************** +tBoolean +UARTCharPutNonBlocking(unsigned long ulBase, unsigned char ucData) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // See if there is space in the transmit FIFO. + // + if(!(HWREG(ulBase + UART_O_FR) & UART_FR_TXFF)) + { + // + // Write this character to the transmit FIFO. + // + HWREG(ulBase + UART_O_DR) = ucData; + + // + // Success. + // + return(true); + } + else + { + // + // There is no space in the transmit FIFO, so return a failure. + // + return(false); + } +} + +//***************************************************************************** +// +//! Waits to send a character from the specified port. +//! +//! \param ulBase is the base address of the UART port. +//! \param ucData is the character to be transmitted. +//! +//! Sends the character \e ucData to the transmit FIFO for the specified port. +//! If there is no space available in the transmit FIFO, this function waits +//! until there is space available before returning. +//! +//! \return None. +// +//***************************************************************************** +void +UARTCharPut(unsigned long ulBase, unsigned char ucData) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Wait until space is available. + // + while(HWREG(ulBase + UART_O_FR) & UART_FR_TXFF) + { + } + + // + // Send the char. + // + HWREG(ulBase + UART_O_DR) = ucData; +} + +//***************************************************************************** +// +//! Causes a BREAK to be sent. +//! +//! \param ulBase is the base address of the UART port. +//! \param bBreakState controls the output level. +//! +//! Calling this function with \e bBreakState set to \b true asserts a break +//! condition on the UART. Calling this function with \e bBreakState set to +//! \b false removes the break condition. For proper transmission of a break +//! command, the break must be asserted for at least two complete frames. +//! +//! \return None. +// +//***************************************************************************** +void +UARTBreakCtl(unsigned long ulBase, tBoolean bBreakState) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Set the break condition as requested. + // + HWREG(ulBase + UART_O_LCRH) = + (bBreakState ? + (HWREG(ulBase + UART_O_LCRH) | UART_LCRH_BRK) : + (HWREG(ulBase + UART_O_LCRH) & ~(UART_LCRH_BRK))); +} + +//***************************************************************************** +// +//! Determines whether the UART transmitter is busy or not. +//! +//! \param ulBase is the base address of the UART port. +//! +//! Allows the caller to determine whether all transmitted bytes have cleared +//! the transmitter hardware. If \b false is returned, the transmit FIFO is +//! empty and all bits of the last transmitted character, including all stop +//! bits, have left the hardware shift register. +//! +//! \return Returns \b true if the UART is transmitting or \b false if all +//! transmissions are complete. +// +//***************************************************************************** +tBoolean +UARTBusy(unsigned long ulBase) +{ + // + // Check the argument. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Determine if the UART is busy. + // + return((HWREG(ulBase + UART_O_FR) & UART_FR_BUSY) ? true : false); +} + +//***************************************************************************** +// +//! Registers an interrupt handler for a UART interrupt. +//! +//! \param ulBase is the base address of the UART port. +//! \param pfnHandler is a pointer to the function to be called when the +//! UART interrupt occurs. +//! +//! This function does the actual registering of the interrupt handler. This +//! will enable the global interrupt in the interrupt controller; specific UART +//! interrupts must be enabled via UARTIntEnable(). It is the interrupt +//! handler's responsibility to clear the interrupt source. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +UARTIntRegister(unsigned long ulBase, void (*pfnHandler)(void)) +{ + unsigned long ulInt; + + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Determine the interrupt number based on the UART port. + // + ulInt = ((ulBase == UART0_BASE) ? INT_UART0 : + ((ulBase == UART1_BASE) ? INT_UART1 : INT_UART2)); + + // + // Register the interrupt handler. + // + IntRegister(ulInt, pfnHandler); + + // + // Enable the UART interrupt. + // + IntEnable(ulInt); +} + +//***************************************************************************** +// +//! Unregisters an interrupt handler for a UART interrupt. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function does the actual unregistering of the interrupt handler. It +//! will clear the handler to be called when a UART interrupt occurs. This +//! will also mask off the interrupt in the interrupt controller so that the +//! interrupt handler no longer is called. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +UARTIntUnregister(unsigned long ulBase) +{ + unsigned long ulInt; + + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Determine the interrupt number based on the UART port. + // + ulInt = ((ulBase == UART0_BASE) ? INT_UART0 : + ((ulBase == UART1_BASE) ? INT_UART1 : INT_UART2)); + + // + // Disable the interrupt. + // + IntDisable(ulInt); + + // + // Unregister the interrupt handler. + // + IntUnregister(ulInt); +} + +//***************************************************************************** +// +//! Enables individual UART interrupt sources. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulIntFlags is the bit mask of the interrupt sources to be enabled. +//! +//! Enables the indicated UART interrupt sources. Only the sources that are +//! enabled can be reflected to the processor interrupt; disabled sources have +//! no effect on the processor. +//! +//! The \e ulIntFlags parameter is the logical OR of any of the following: +//! +//! - \b UART_INT_OE - Overrun Error interrupt +//! - \b UART_INT_BE - Break Error interrupt +//! - \b UART_INT_PE - Parity Error interrupt +//! - \b UART_INT_FE - Framing Error interrupt +//! - \b UART_INT_RT - Receive Timeout interrupt +//! - \b UART_INT_TX - Transmit interrupt +//! - \b UART_INT_RX - Receive interrupt +//! - \b UART_INT_DSR - DSR interrupt +//! - \b UART_INT_DCD - DCD interrupt +//! - \b UART_INT_CTS - CTS interrupt +//! - \b UART_INT_RI - RI interrupt +//! +//! \return None. +// +//***************************************************************************** +void +UARTIntEnable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Enable the specified interrupts. + // + HWREG(ulBase + UART_O_IM) |= ulIntFlags; +} + +//***************************************************************************** +// +//! Disables individual UART interrupt sources. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulIntFlags is the bit mask of the interrupt sources to be disabled. +//! +//! Disables the indicated UART interrupt sources. Only the sources that are +//! enabled can be reflected to the processor interrupt; disabled sources have +//! no effect on the processor. +//! +//! The \e ulIntFlags parameter has the same definition as the \e ulIntFlags +//! parameter to UARTIntEnable(). +//! +//! \return None. +// +//***************************************************************************** +void +UARTIntDisable(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Disable the specified interrupts. + // + HWREG(ulBase + UART_O_IM) &= ~(ulIntFlags); +} + +//***************************************************************************** +// +//! Gets the current interrupt status. +//! +//! \param ulBase is the base address of the UART port. +//! \param bMasked is \b false if the raw interrupt status is required and +//! \b true if the masked interrupt status is required. +//! +//! This returns the interrupt status for the specified UART. Either the raw +//! interrupt status or the status of interrupts that are allowed to reflect to +//! the processor can be returned. +//! +//! \return Returns the current interrupt status, enumerated as a bit field of +//! values described in UARTIntEnable(). +// +//***************************************************************************** +unsigned long +UARTIntStatus(unsigned long ulBase, tBoolean bMasked) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + return(HWREG(ulBase + UART_O_MIS)); + } + else + { + return(HWREG(ulBase + UART_O_RIS)); + } +} + +//***************************************************************************** +// +//! Clears UART interrupt sources. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulIntFlags is a bit mask of the interrupt sources to be cleared. +//! +//! The specified UART interrupt sources are cleared, so that they no longer +//! assert. This function must be called in the interrupt handler to keep the +//! interrupt from being recognized again immediately upon exit. +//! +//! The \e ulIntFlags parameter has the same definition as the \e ulIntFlags +//! parameter to UARTIntEnable(). +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +UARTIntClear(unsigned long ulBase, unsigned long ulIntFlags) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Clear the requested interrupt sources. + // + HWREG(ulBase + UART_O_ICR) = ulIntFlags; +} + +//***************************************************************************** +// +//! Enable UART DMA operation. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulDMAFlags is a bit mask of the DMA features to enable. +//! +//! The specified UART DMA features are enabled. The UART can be +//! configured to use DMA for transmit or receive, and to disable +//! receive if an error occurs. The \e ulDMAFlags parameter is the +//! logical OR of any of the following values: +//! +//! - UART_DMA_RX - enable DMA for receive +//! - UART_DMA_TX - enable DMA for transmit +//! - UART_DMA_ERR_RXSTOP - disable DMA receive on UART error +//! +//! \note The uDMA controller must also be set up before DMA can be used +//! with the UART. +//! +//! \return None. +// +//***************************************************************************** +void +UARTDMAEnable(unsigned long ulBase, unsigned long ulDMAFlags) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Set the requested bits in the UART DMA control register. + // + HWREG(ulBase + UART_O_DMACTL) |= ulDMAFlags; +} + +//***************************************************************************** +// +//! Disable UART DMA operation. +//! +//! \param ulBase is the base address of the UART port. +//! \param ulDMAFlags is a bit mask of the DMA features to disable. +//! +//! This function is used to disable UART DMA features that were enabled +//! by UARTDMAEnable(). The specified UART DMA features are disabled. The +//! \e ulDMAFlags parameter is the logical OR of any of the following values: +//! +//! - UART_DMA_RX - disable DMA for receive +//! - UART_DMA_TX - disable DMA for transmit +//! - UART_DMA_ERR_RXSTOP - do not disable DMA receive on UART error +//! +//! \return None. +// +//***************************************************************************** +void +UARTDMADisable(unsigned long ulBase, unsigned long ulDMAFlags) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Clear the requested bits in the UART DMA control register. + // + HWREG(ulBase + UART_O_DMACTL) &= ~ulDMAFlags; +} + +//***************************************************************************** +// +//! Gets current receiver errors. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function returns the current state of each of the 4 receiver error +//! sources. The returned errors are equivalent to the four error bits +//! returned via the previous call to UARTCharGet() or UARTCharGetNonBlocking() +//! with the exception that the overrun error is set immediately the overrun +//! occurs rather than when a character is next read. +//! +//! \return Returns a logical OR combination of the receiver error flags, +//! \b UART_RXERROR_FRAMING, \b UART_RXERROR_PARITY, \b UART_RXERROR_BREAK +//! and \b UART_RXERROR_OVERRUN. +// +//***************************************************************************** +unsigned long +UARTRxErrorGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Return the current value of the receive status register. + // + return(HWREG(ulBase + UART_O_RSR) & 0x0000000F); +} + +//***************************************************************************** +// +//! Clears all reported receiver errors. +//! +//! \param ulBase is the base address of the UART port. +//! +//! This function is used to clear all receiver error conditions reported via +//! UARTRxErrorGet(). If using the overrun, framing error, parity error or +//! break interrupts, this function must be called after clearing the interrupt +//! to ensure that later errors of the same type trigger another interrupt. +//! +//! \return None. +// +//***************************************************************************** +void +UARTRxErrorClear(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(UARTBaseValid(ulBase)); + + // + // Any write to the Error Clear Register will clear all bits which are + // currently set. + // + HWREG(ulBase + UART_O_ECR) = 0; +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/uart.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/uart.h new file mode 100644 index 00000000..2a23fa63 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/uart.h @@ -0,0 +1,243 @@ +//***************************************************************************** +// +// uart.h - Defines and Macros for the UART. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __UART_H__ +#define __UART_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Values that can be passed to UARTIntEnable, UARTIntDisable, and UARTIntClear +// as the ulIntFlags parameter, and returned from UARTIntStatus. +// +//***************************************************************************** +#define UART_INT_OE 0x400 // Overrun Error Interrupt Mask +#define UART_INT_BE 0x200 // Break Error Interrupt Mask +#define UART_INT_PE 0x100 // Parity Error Interrupt Mask +#define UART_INT_FE 0x080 // Framing Error Interrupt Mask +#define UART_INT_RT 0x040 // Receive Timeout Interrupt Mask +#define UART_INT_TX 0x020 // Transmit Interrupt Mask +#define UART_INT_RX 0x010 // Receive Interrupt Mask +#define UART_INT_DSR 0x008 // DSR Modem Interrupt Mask +#define UART_INT_DCD 0x004 // DCD Modem Interrupt Mask +#define UART_INT_CTS 0x002 // CTS Modem Interrupt Mask +#define UART_INT_RI 0x001 // RI Modem Interrupt Mask + +//***************************************************************************** +// +// Values that can be passed to UARTConfigSetExpClk as the ulConfig parameter +// and returned by UARTConfigGetExpClk in the pulConfig parameter. +// Additionally, the UART_CONFIG_PAR_* subset can be passed to +// UARTParityModeSet as the ulParity parameter, and are returned by +// UARTParityModeGet. +// +//***************************************************************************** +#define UART_CONFIG_WLEN_MASK 0x00000060 // Mask for extracting word length +#define UART_CONFIG_WLEN_8 0x00000060 // 8 bit data +#define UART_CONFIG_WLEN_7 0x00000040 // 7 bit data +#define UART_CONFIG_WLEN_6 0x00000020 // 6 bit data +#define UART_CONFIG_WLEN_5 0x00000000 // 5 bit data +#define UART_CONFIG_STOP_MASK 0x00000008 // Mask for extracting stop bits +#define UART_CONFIG_STOP_ONE 0x00000000 // One stop bit +#define UART_CONFIG_STOP_TWO 0x00000008 // Two stop bits +#define UART_CONFIG_PAR_MASK 0x00000086 // Mask for extracting parity +#define UART_CONFIG_PAR_NONE 0x00000000 // No parity +#define UART_CONFIG_PAR_EVEN 0x00000006 // Even parity +#define UART_CONFIG_PAR_ODD 0x00000002 // Odd parity +#define UART_CONFIG_PAR_ONE 0x00000082 // Parity bit is one +#define UART_CONFIG_PAR_ZERO 0x00000086 // Parity bit is zero + +//***************************************************************************** +// +// Values that can be passed to UARTFIFOLevelSet as the ulTxLevel parameter and +// returned by UARTFIFOLevelGet in the pulTxLevel. +// +//***************************************************************************** +#define UART_FIFO_TX1_8 0x00000000 // Transmit interrupt at 1/8 Full +#define UART_FIFO_TX2_8 0x00000001 // Transmit interrupt at 1/4 Full +#define UART_FIFO_TX4_8 0x00000002 // Transmit interrupt at 1/2 Full +#define UART_FIFO_TX6_8 0x00000003 // Transmit interrupt at 3/4 Full +#define UART_FIFO_TX7_8 0x00000004 // Transmit interrupt at 7/8 Full + +//***************************************************************************** +// +// Values that can be passed to UARTFIFOLevelSet as the ulRxLevel parameter and +// returned by UARTFIFOLevelGet in the pulRxLevel. +// +//***************************************************************************** +#define UART_FIFO_RX1_8 0x00000000 // Receive interrupt at 1/8 Full +#define UART_FIFO_RX2_8 0x00000008 // Receive interrupt at 1/4 Full +#define UART_FIFO_RX4_8 0x00000010 // Receive interrupt at 1/2 Full +#define UART_FIFO_RX6_8 0x00000018 // Receive interrupt at 3/4 Full +#define UART_FIFO_RX7_8 0x00000020 // Receive interrupt at 7/8 Full + +//***************************************************************************** +// +// Values that can be passed to UARTDMAEnable() and UARTDMADisable(). +// +//***************************************************************************** +#define UART_DMA_ERR_RXSTOP 0x00000004 // Stop DMA receive if UART error +#define UART_DMA_TX 0x00000002 // Enable DMA for transmit +#define UART_DMA_RX 0x00000001 // Enable DMA for receive + +//***************************************************************************** +// +// Values returned from UARTRxErrorGet(). +// +//***************************************************************************** +#define UART_RXERROR_OVERRUN 0x00000008 +#define UART_RXERROR_BREAK 0x00000004 +#define UART_RXERROR_PARITY 0x00000002 +#define UART_RXERROR_FRAMING 0x00000001 + +//***************************************************************************** +// +// Values that can be passed to UARTHandshakeOutputsSet() or returned from +// UARTHandshakeOutputGet(). +// +//***************************************************************************** +#define UART_OUTPUT_RTS 0x00000800 +#define UART_OUTPUT_DTR 0x00000400 + +//***************************************************************************** +// +// Values that can be returned from UARTHandshakeInputsGet(). +// +//***************************************************************************** +#define UART_INPUT_RI 0x00000100 +#define UART_INPUT_DCD 0x00000004 +#define UART_INPUT_DSR 0x00000002 +#define UART_INPUT_CTS 0x00000001 + +//***************************************************************************** +// +// Values that can be passed to UARTFlowControl() or returned from +// UARTFlowControlGet(). +// +//***************************************************************************** +#define UART_FLOWCONTROL_TX 0x00008000 +#define UART_FLOWCONTROL_RX 0x00004000 +#define UART_FLOWCONTROL_NONE 0x00000000 + +//***************************************************************************** +// +// Values that can be passed to UARTTxIntModeSet() or returned from +// UARTTxIntModeGet(). +// +//***************************************************************************** +#define UART_TXINT_MODE_FIFO 0x00000000 +#define UART_TXINT_MODE_EOT 0x00000010 + +//***************************************************************************** +// +// API Function prototypes +// +//***************************************************************************** +extern void UARTParityModeSet(unsigned long ulBase, unsigned long ulParity); +extern unsigned long UARTParityModeGet(unsigned long ulBase); +extern void UARTFIFOLevelSet(unsigned long ulBase, unsigned long ulTxLevel, + unsigned long ulRxLevel); +extern void UARTFIFOLevelGet(unsigned long ulBase, unsigned long *pulTxLevel, + unsigned long *pulRxLevel); +extern void UARTConfigSetExpClk(unsigned long ulBase, unsigned long ulUARTClk, + unsigned long ulBaud, unsigned long ulConfig); +extern void UARTConfigGetExpClk(unsigned long ulBase, unsigned long ulUARTClk, + unsigned long *pulBaud, + unsigned long *pulConfig); +extern void UARTEnable(unsigned long ulBase); +extern void UARTDisable(unsigned long ulBase); +extern void UARTFIFOEnable(unsigned long ulBase); +extern void UARTFIFODisable(unsigned long ulBase); +extern void UARTEnableSIR(unsigned long ulBase, tBoolean bLowPower); +extern void UARTDisableSIR(unsigned long ulBase); +extern tBoolean UARTCharsAvail(unsigned long ulBase); +extern tBoolean UARTSpaceAvail(unsigned long ulBase); +extern long UARTCharGetNonBlocking(unsigned long ulBase); +extern long UARTCharGet(unsigned long ulBase); +extern tBoolean UARTCharPutNonBlocking(unsigned long ulBase, + unsigned char ucData); +extern void UARTCharPut(unsigned long ulBase, unsigned char ucData); +extern void UARTBreakCtl(unsigned long ulBase, tBoolean bBreakState); +extern tBoolean UARTBusy(unsigned long ulBase); +extern void UARTIntRegister(unsigned long ulBase, void(*pfnHandler)(void)); +extern void UARTIntUnregister(unsigned long ulBase); +extern void UARTIntEnable(unsigned long ulBase, unsigned long ulIntFlags); +extern void UARTIntDisable(unsigned long ulBase, unsigned long ulIntFlags); +extern unsigned long UARTIntStatus(unsigned long ulBase, tBoolean bMasked); +extern void UARTIntClear(unsigned long ulBase, unsigned long ulIntFlags); +extern void UARTDMAEnable(unsigned long ulBase, unsigned long ulDMAFlags); +extern void UARTDMADisable(unsigned long ulBase, unsigned long ulDMAFlags); +extern unsigned long UARTRxErrorGet(unsigned long ulBase); +extern void UARTRxErrorClear(unsigned long ulBase); +extern void UARTSmartCardEnable(unsigned long ulBase); +extern void UARTSmartCardDisable(unsigned long ulBase); +extern void UARTModemControlSet(unsigned long ulBase, + unsigned long ulControl); +extern void UARTModemControlClear(unsigned long ulBase, + unsigned long ulControl); +extern unsigned long UARTModemControlGet(unsigned long ulBase); +extern unsigned long UARTModemStatusGet(unsigned long ulBase); +extern void UARTFlowControlSet(unsigned long ulBase, unsigned long ulMode); +extern unsigned long UARTFlowControlGet(unsigned long ulBase); +extern void UARTTxIntModeSet(unsigned long ulBase, unsigned long ulMode); +extern unsigned long UARTTxIntModeGet(unsigned long ulBase); + +//***************************************************************************** +// +// Several UART APIs have been renamed, with the original function name being +// deprecated. These defines provide backward compatibility. +// +//***************************************************************************** +#ifndef DEPRECATED +#include "driverlib/sysctl.h" +#define UARTConfigSet(a, b, c) \ + UARTConfigSetExpClk(a, SysCtlClockGet(), b, c) +#define UARTConfigGet(a, b, c) \ + UARTConfigGetExpClk(a, SysCtlClockGet(), b, c) +#define UARTCharNonBlockingGet(a) \ + UARTCharGetNonBlocking(a) +#define UARTCharNonBlockingPut(a, b) \ + UARTCharPutNonBlocking(a, b) +#endif + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __UART_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/udma.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/udma.c new file mode 100644 index 00000000..a9596641 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/udma.c @@ -0,0 +1,1178 @@ +//***************************************************************************** +// +// udma.c - Driver for the micro-DMA controller. +// +// Copyright (c) 2007-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup udma_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_types.h" +#include "inc/hw_udma.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" +#include "driverlib/udma.h" + +//***************************************************************************** +// +//! Enables the uDMA controller for use. +//! +//! This function enables the uDMA controller. The uDMA controller must be +//! enabled before it can be configured and used. +//! +//! \return None. +// +//***************************************************************************** +void +uDMAEnable(void) +{ + // + // Set the master enable bit in the config register. + // + HWREG(UDMA_CFG) = UDMA_CFG_MASTEN; +} + +//***************************************************************************** +// +//! Disables the uDMA controller for use. +//! +//! This function disables the uDMA controller. Once disabled, the uDMA +//! controller will not operate until re-enabled with uDMAEnable(). +//! +//! \return None. +// +//***************************************************************************** +void +uDMADisable(void) +{ + // + // Clear the master enable bit in the config register. + // + HWREG(UDMA_CFG) = 0; +} + +//***************************************************************************** +// +//! Gets the uDMA error status. +//! +//! This function returns the uDMA error status. It should be called from +//! within the uDMA error interrupt handler to determine if a uDMA error +//! occurred. +//! +//! \return Returns non-zero if a uDMA error is pending. +// +//***************************************************************************** +unsigned long +uDMAErrorStatusGet(void) +{ + // + // Return the uDMA error status. + // + return(HWREG(UDMA_ERRCLR)); +} + +//***************************************************************************** +// +//! Clears the uDMA error interrupt. +//! +//! This function clears a pending uDMA error interrupt. It should be called +//! from within the uDMA error interrupt handler to clear the interrupt. +//! +//! \return None. +// +//***************************************************************************** +void +uDMAErrorStatusClear(void) +{ + // + // Clear the uDMA error interrupt. + // + HWREG(UDMA_ERRCLR) = 1; +} + +//***************************************************************************** +// +//! Enables a uDMA channel for operation. +//! +//! \param ulChannelNum is the channel number to enable. +//! +//! This function enables a specific uDMA channel for use. This function must +//! be used to enable a channel before it can be used to perform a uDMA +//! transfer. +//! +//! When a uDMA transfer is completed, the channel will be automatically +//! disabled by the uDMA controller. Therefore, this function should be called +//! prior to starting up any new transfer. +//! +//! \return None. +// +//***************************************************************************** +void +uDMAChannelEnable(unsigned long ulChannelNum) +{ + // + // Check the arguments. + // + ASSERT(ulChannelNum < 32); + + // + // Set the bit for this channel in the enable set register. + // + HWREG(UDMA_ENASET) = 1 << ulChannelNum; +} + +//***************************************************************************** +// +//! Disables a uDMA channel for operation. +//! +//! \param ulChannelNum is the channel number to disable. +//! +//! This function disables a specific uDMA channel. Once disabled, a channel +//! will not respond to uDMA transfer requests until re-enabled via +//! uDMAChannelEnable(). +//! +//! \return None. +// +//***************************************************************************** +void +uDMAChannelDisable(unsigned long ulChannelNum) +{ + // + // Check the arguments. + // + ASSERT(ulChannelNum < 32); + + // + // Set the bit for this channel in the enable clear register. + // + HWREG(UDMA_ENACLR) = 1 << ulChannelNum; +} + +//***************************************************************************** +// +//! Checks if a uDMA channel is enabled for operation. +//! +//! \param ulChannelNum is the channel number to check. +//! +//! This function checks to see if a specific uDMA channel is enabled. This +//! can be used to check the status of a transfer, since the channel will +//! be automatically disabled at the end of a transfer. +//! +//! \return Returns \b true if the channel is enabled, \b false if disabled. +// +//***************************************************************************** +tBoolean +uDMAChannelIsEnabled(unsigned long ulChannelNum) +{ + // + // Check the arguments. + // + ASSERT(ulChannelNum < 32); + + // + // AND the specified channel bit with the enable register, and return the + // result. + // + return((HWREG(UDMA_ENASET) & (1 << ulChannelNum)) ? true : false); +} + +//***************************************************************************** +// +//! Sets the base address for the channel control table. +//! +//! \param pControlTable is a pointer to the 1024 byte aligned base address +//! of the uDMA channel control table. +//! +//! This function sets the base address of the channel control table. This +//! table resides in system memory and holds control information for each uDMA +//! channel. The table must be aligned on a 1024 byte boundary. The base +//! address must be set before any of the channel functions can be used. +//! +//! The size of the channel control table depends on the number of uDMA +//! channels, and which transfer modes are used. Refer to the introductory +//! text and the microcontroller datasheet for more information about the +//! channel control table. +//! +//! \return None. +// +//***************************************************************************** +void +uDMAControlBaseSet(void *pControlTable) +{ + // + // Check the arguments. + // + ASSERT(((unsigned long)pControlTable & ~0x3FF) == + (unsigned long)pControlTable); + ASSERT((unsigned long)pControlTable >= 0x20000000); + + // + // Program the base address into the register. + // + HWREG(UDMA_CTLBASE) = (unsigned long)pControlTable; +} + +//***************************************************************************** +// +//! Gets the base address for the channel control table. +//! +//! This function gets the base address of the channel control table. This +//! table resides in system memory and holds control information for each uDMA +//! channel. +//! +//! \return Returns a pointer to the base address of the channel control table. +// +//***************************************************************************** +void * +uDMAControlBaseGet(void) +{ + // + // Read the current value of the control base register, and return it to + // the caller. + // + return((void *)HWREG(UDMA_CTLBASE)); +} + +//***************************************************************************** +// +//! Gets the base address for the channel control table alternate structures. +//! +//! This function gets the base address of the second half of the channel +//! control table that holds the alternate control structures for each channel. +//! +//! \return Returns a pointer to the base address of the second half of the +//! channel control table. +// +//***************************************************************************** +void * +uDMAControlAlternateBaseGet(void) +{ + // + // Read the current value of the control base register, and return it to + // the caller. + // + return((void *)HWREG(UDMA_ALTBASE)); +} + +//***************************************************************************** +// +//! Requests a uDMA channel to start a transfer. +//! +//! \param ulChannelNum is the channel number on which to request a uDMA +//! transfer. +//! +//! This function allows software to request a uDMA channel to begin a +//! transfer. This could be used for performing a memory to memory transfer, +//! or if for some reason a transfer needs to be initiated by software instead +//! of the peripheral associated with that channel. +//! +//! \note If the channel is \b UDMA_CHANNEL_SW and interrupts are used, then +//! the completion will be signaled on the uDMA dedicated interrupt. If a +//! peripheral channel is used, then the completion will be signaled on the +//! peripheral's interrupt. +//! +//! \return None. +// +//***************************************************************************** +void +uDMAChannelRequest(unsigned long ulChannelNum) +{ + // + // Check the arguments. + // + ASSERT(ulChannelNum < 32); + + // + // Set the bit for this channel in the software uDMA request register. + // + HWREG(UDMA_SWREQ) = 1 << ulChannelNum; +} + +//***************************************************************************** +// +//! Enables attributes of a uDMA channel. +//! +//! \param ulChannelNum is the channel to configure. +//! \param ulAttr is a combination of attributes for the channel. +//! +//! The \e ulAttr parameter is the logical OR of any of the following: +//! +//! - \b UDMA_ATTR_USEBURST is used to restrict transfers to use only a burst +//! mode. +//! - \b UDMA_ATTR_ALTSELECT is used to select the alternate control structure +//! for this channel (it is very unlikely that this flag should be used) +//! - \b UDMA_ATTR_HIGH_PRIORITY is used to set this channel to high priority +//! - \b UDMA_ATTR_REQMASK is used to mask the hardware request signal from the +//! peripheral for this channel. +//! +//! \return None. +// +//***************************************************************************** +void +uDMAChannelAttributeEnable(unsigned long ulChannelNum, unsigned long ulAttr) +{ + // + // Check the arguments. + // + ASSERT(ulChannelNum < 32); + ASSERT((ulAttr & ~(UDMA_ATTR_USEBURST | UDMA_ATTR_ALTSELECT | + UDMA_ATTR_HIGH_PRIORITY | UDMA_ATTR_REQMASK)) == 0); + + // + // Set the useburst bit for this channel if set in ulConfig. + // + if(ulAttr & UDMA_ATTR_USEBURST) + { + HWREG(UDMA_USEBURSTSET) = 1 << ulChannelNum; + } + + // + // Set the alternate control select bit for this channel, + // if set in ulConfig. + // + if(ulAttr & UDMA_ATTR_ALTSELECT) + { + HWREG(UDMA_ALTSET) = 1 << ulChannelNum; + } + + // + // Set the high priority bit for this channel, if set in ulConfig. + // + if(ulAttr & UDMA_ATTR_HIGH_PRIORITY) + { + HWREG(UDMA_PRIOSET) = 1 << ulChannelNum; + } + + // + // Set the request mask bit for this channel, if set in ulConfig. + // + if(ulAttr & UDMA_ATTR_REQMASK) + { + HWREG(UDMA_REQMASKSET) = 1 << ulChannelNum; + } +} + +//***************************************************************************** +// +//! Disables attributes of a uDMA channel. +//! +//! \param ulChannelNum is the channel to configure. +//! \param ulAttr is a combination of attributes for the channel. +//! +//! This function is used to disable attributes of a uDMA channel. +//! +//! The \e ulAttr parameter is the logical OR of any of the following: +//! +//! - \b UDMA_ATTR_USEBURST is used to restrict transfers to use only a burst +//! mode. +//! - \b UDMA_ATTR_ALTSELECT is used to select the alternate control structure +//! for this channel. +//! - \b UDMA_ATTR_HIGH_PRIORITY is used to set this channel to high priority. +//! - \b UDMA_ATTR_REQMASK is used to mask the hardware request signal from the +//! peripheral for this channel. +//! +//! \return None. +// +//***************************************************************************** +void +uDMAChannelAttributeDisable(unsigned long ulChannelNum, unsigned long ulAttr) +{ + // + // Check the arguments. + // + ASSERT(ulChannelNum < 32); + ASSERT((ulAttr & ~(UDMA_ATTR_USEBURST | UDMA_ATTR_ALTSELECT | + UDMA_ATTR_HIGH_PRIORITY | UDMA_ATTR_REQMASK)) == 0); + + // + // Clear the useburst bit for this channel if set in ulConfig. + // + if(ulAttr & UDMA_ATTR_USEBURST) + { + HWREG(UDMA_USEBURSTCLR) = 1 << ulChannelNum; + } + + // + // Clear the alternate control select bit for this channel, if set in + // ulConfig. + // + if(ulAttr & UDMA_ATTR_ALTSELECT) + { + HWREG(UDMA_ALTCLR) = 1 << ulChannelNum; + } + + // + // Clear the high priority bit for this channel, if set in ulConfig. + // + if(ulAttr & UDMA_ATTR_HIGH_PRIORITY) + { + HWREG(UDMA_PRIOCLR) = 1 << ulChannelNum; + } + + // + // Clear the request mask bit for this channel, if set in ulConfig. + // + if(ulAttr & UDMA_ATTR_REQMASK) + { + HWREG(UDMA_REQMASKCLR) = 1 << ulChannelNum; + } +} + +//***************************************************************************** +// +//! Gets the enabled attributes of a uDMA channel. +//! +//! \param ulChannelNum is the channel to configure. +//! +//! This function returns a combination of flags representing the attributes of +//! the uDMA channel. +//! +//! \return Returns the logical OR of the attributes of the uDMA channel, which +//! can be any of the following: +//! - \b UDMA_ATTR_USEBURST is used to restrict transfers to use only a burst +//! mode. +//! - \b UDMA_ATTR_ALTSELECT is used to select the alternate control structure +//! for this channel. +//! - \b UDMA_ATTR_HIGH_PRIORITY is used to set this channel to high priority. +//! - \b UDMA_ATTR_REQMASK is used to mask the hardware request signal from the +//! peripheral for this channel. +// +//***************************************************************************** +unsigned long +uDMAChannelAttributeGet(unsigned long ulChannelNum) +{ + unsigned long ulAttr = 0; + + // + // Check the arguments. + // + ASSERT(ulChannelNum < 32); + + // + // Check to see if useburst bit is set for this channel. + // + if(HWREG(UDMA_USEBURSTSET) & (1 << ulChannelNum)) + { + ulAttr |= UDMA_ATTR_USEBURST; + } + + // + // Check to see if the alternate control bit is set for this channel. + // + if(HWREG(UDMA_ALTSET) & (1 << ulChannelNum)) + { + ulAttr |= UDMA_ATTR_ALTSELECT; + } + + // + // Check to see if the high priority bit is set for this channel. + // + if(HWREG(UDMA_PRIOSET) & (1 << ulChannelNum)) + { + ulAttr |= UDMA_ATTR_HIGH_PRIORITY; + } + + // + // Check to see if the request mask bit is set for this channel. + // + if(HWREG(UDMA_REQMASKSET) & (1 << ulChannelNum)) + { + ulAttr |= UDMA_ATTR_REQMASK; + } + + // + // Return the configuration flags. + // + return(ulAttr); +} + +//***************************************************************************** +// +//! Sets the control parameters for a uDMA channel control structure. +//! +//! \param ulChannelStructIndex is the logical OR of the uDMA channel number +//! with \b UDMA_PRI_SELECT or \b UDMA_ALT_SELECT. +//! \param ulControl is logical OR of several control values to set the control +//! parameters for the channel. +//! +//! This function is used to set control parameters for a uDMA transfer. These +//! are typically parameters that are not changed often. +//! +//! The \e ulChannelStructIndex parameter should be the logical OR of the +//! channel number with one of \b UDMA_PRI_SELECT or \b UDMA_ALT_SELECT to +//! choose whether the primary or alternate data structure is used. +//! +//! The \e ulControl parameter is the logical OR of five values: the data size, +//! the source address increment, the destination address increment, the +//! arbitration size, and the use burst flag. The choices available for each +//! of these values is described below. +//! +//! Choose the data size from one of \b UDMA_SIZE_8, \b UDMA_SIZE_16, or +//! \b UDMA_SIZE_32 to select a data size of 8, 16, or 32 bits. +//! +//! Choose the source address increment from one of \b UDMA_SRC_INC_8, +//! \b UDMA_SRC_INC_16, \b UDMA_SRC_INC_32, or \b UDMA_SRC_INC_NONE to select +//! an address increment of 8-bit bytes, 16-bit halfwords, 32-bit words, or +//! to select non-incrementing. +//! +//! Choose the destination address increment from one of \b UDMA_DST_INC_8, +//! \b UDMA_DST_INC_16, \b UDMA_DST_INC_32, or \b UDMA_DST_INC_NONE to select +//! an address increment of 8-bit bytes, 16-bit halfwords, 32-bit words, or +//! to select non-incrementing. +//! +//! The arbitration size determines how many items are transferred before +//! the uDMA controller re-arbitrates for the bus. Choose the arbitration size +//! from one of \b UDMA_ARB_1, \b UDMA_ARB_2, \b UDMA_ARB_4, \b UDMA_ARB_8, +//! through \b UDMA_ARB_1024 to select the arbitration size from 1 to 1024 +//! items, in powers of 2. +//! +//! The value \b UDMA_NEXT_USEBURST is used to force the channel to only +//! respond to burst requests at the tail end of a scatter-gather transfer. +//! +//! \note The address increment cannot be smaller than the data size. +//! +//! \return None. +// +//***************************************************************************** +void +uDMAChannelControlSet(unsigned long ulChannelStructIndex, + unsigned long ulControl) +{ + tDMAControlTable *pCtl; + + // + // Check the arguments. + // + ASSERT(ulChannelStructIndex < 64); + ASSERT(HWREG(UDMA_CTLBASE) != 0); + + // + // Get the base address of the control table. + // + pCtl = (tDMAControlTable *)HWREG(UDMA_CTLBASE); + + // + // Get the current control word value and mask off the fields to be + // changed, then OR in the new settings. + // + pCtl[ulChannelStructIndex].ulControl = + ((pCtl[ulChannelStructIndex].ulControl & + ~(UDMA_CHCTL_DSTINC_M | + UDMA_CHCTL_DSTSIZE_M | + UDMA_CHCTL_SRCINC_M | + UDMA_CHCTL_SRCSIZE_M | + UDMA_CHCTL_ARBSIZE_M | + UDMA_CHCTL_NXTUSEBURST)) | + ulControl); +} + +//***************************************************************************** +// +//! Sets the transfer parameters for a uDMA channel control structure. +//! +//! \param ulChannelStructIndex is the logical OR of the uDMA channel number +//! with either \b UDMA_PRI_SELECT or \b UDMA_ALT_SELECT. +//! \param ulMode is the type of uDMA transfer. +//! \param pvSrcAddr is the source address for the transfer. +//! \param pvDstAddr is the destination address for the transfer. +//! \param ulTransferSize is the number of data items to transfer. +//! +//! This function is used to set the parameters for a uDMA transfer. These are +//! typically parameters that are changed often. The function +//! uDMAChannelControlSet() MUST be called at least once for this channel prior +//! to calling this function. +//! +//! The \e ulChannelStructIndex parameter should be the logical OR of the +//! channel number with one of \b UDMA_PRI_SELECT or \b UDMA_ALT_SELECT to +//! choose whether the primary or alternate data structure is used. +//! +//! The \e ulMode parameter should be one of the following values: +//! +//! - \b UDMA_MODE_STOP stops the uDMA transfer. The controller sets the mode +//! to this value at the end of a transfer. +//! - \b UDMA_MODE_BASIC to perform a basic transfer based on request. +//! - \b UDMA_MODE_AUTO to perform a transfer that will always complete once +//! started even if request is removed. +//! - \b UDMA_MODE_PINGPONG to set up a transfer that switches between the +//! primary and alternate control structures for the channel. This allows +//! use of ping-pong buffering for uDMA transfers. +//! - \b UDMA_MODE_MEM_SCATTER_GATHER to set up a memory scatter-gather +//! transfer. +//! - \b UDMA_MODE_PER_SCATTER_GATHER to set up a peripheral scatter-gather +//! transfer. +//! +//! The \e pvSrcAddr and \e pvDstAddr parameters are pointers to the first +//! location of the data to be transferred. These addresses should be aligned +//! according to the item size. The compiler will take care of this if the +//! pointers are pointing to storage of the appropriate data type. +//! +//! The \e ulTransferSize parameter is the number of data items, not the number +//! of bytes. +//! +//! The two scatter/gather modes, memory and peripheral, are actually different +//! depending on whether the primary or alternate control structure is +//! selected. This function will look for the \b UDMA_PRI_SELECT and +//! \b UDMA_ALT_SELECT flag along with the channel number and will set the +//! scatter/gather mode as appropriate for the primary or alternate control +//! structure. +//! +//! The channel must also be enabled using uDMAChannelEnable() after calling +//! this function. The transfer will not begin until the channel has been set +//! up and enabled. Note that the channel is automatically disabled after the +//! transfer is completed, meaning that uDMAChannelEnable() must be called +//! again after setting up the next transfer. +//! +//! \note Great care must be taken to not modify a channel control structure +//! that is in use or else the results will be unpredictable, including the +//! possibility of undesired data transfers to or from memory or peripherals. +//! For BASIC and AUTO modes, it is safe to make changes when the channel is +//! disabled, or the uDMAChannelModeGet() returns \b UDMA_MODE_STOP. For +//! PINGPONG or one of the SCATTER_GATHER modes, it is safe to modify the +//! primary or alternate control structure only when the other is being used. +//! The uDMAChannelModeGet() function will return \b UDMA_MODE_STOP when a +//! channel control structure is inactive and safe to modify. +//! +//! \return None. +// +//***************************************************************************** +void +uDMAChannelTransferSet(unsigned long ulChannelStructIndex, + unsigned long ulMode, void *pvSrcAddr, void *pvDstAddr, + unsigned long ulTransferSize) +{ + tDMAControlTable *pControlTable; + unsigned long ulControl; + unsigned long ulInc; + unsigned long ulBufferBytes; + + // + // Check the arguments. + // + ASSERT(ulChannelStructIndex < 64); + ASSERT(HWREG(UDMA_CTLBASE) != 0); + ASSERT(ulMode <= UDMA_MODE_PER_SCATTER_GATHER); + ASSERT((unsigned long)pvSrcAddr >= 0x20000000); + ASSERT((unsigned long)pvDstAddr >= 0x20000000); + ASSERT((ulTransferSize != 0) && (ulTransferSize <= 1024)); + + // + // Get the base address of the control table. + // + pControlTable = (tDMAControlTable *)HWREG(UDMA_CTLBASE); + + // + // Get the current control word value and mask off the mode and size + // fields. + // + ulControl = (pControlTable[ulChannelStructIndex].ulControl & + ~(UDMA_CHCTL_XFERSIZE_M | UDMA_CHCTL_XFERMODE_M)); + + // + // Adjust the mode if the alt control structure is selected. + // + if(ulChannelStructIndex & UDMA_ALT_SELECT) + { + if((ulMode == UDMA_MODE_MEM_SCATTER_GATHER) || + (ulMode == UDMA_MODE_PER_SCATTER_GATHER)) + { + ulMode |= UDMA_MODE_ALT_SELECT; + } + } + + // + // Set the transfer size and mode in the control word (but don't write the + // control word yet as it could kick off a transfer). + // + ulControl |= ulMode | ((ulTransferSize - 1) << 4); + + // + // Get the address increment value for the source, from the control word. + // + ulInc = (ulControl & UDMA_CHCTL_SRCINC_M); + + // + // Compute the ending source address of the transfer. If the source + // increment is set to none, then the ending address is the same as the + // beginning. + // + if(ulInc != UDMA_SRC_INC_NONE) + { + ulInc = ulInc >> 26; + ulBufferBytes = ulTransferSize << ulInc; + pvSrcAddr = (void *)((unsigned long)pvSrcAddr + ulBufferBytes - 1); + } + + // + // Load the source ending address into the control block. + // + pControlTable[ulChannelStructIndex].pvSrcEndAddr = pvSrcAddr; + + // + // Get the address increment value for the destination, from the control + // word. + // + ulInc = ulControl & UDMA_CHCTL_DSTINC_M; + + // + // Compute the ending destination address of the transfer. If the + // destination increment is set to none, then the ending address is the + // same as the beginning. + // + if(ulInc != UDMA_DST_INC_NONE) + { + // + // There is a special case if this is setting up a scatter-gather + // transfer. The destination pointer needs to point to the end of + // the alternate structure for this channel instead of calculating + // the end of the buffer in the normal way. + // + if((ulMode == UDMA_MODE_MEM_SCATTER_GATHER) || + (ulMode == UDMA_MODE_PER_SCATTER_GATHER)) + { + pvDstAddr = + (void *)&pControlTable[ulChannelStructIndex | + UDMA_ALT_SELECT].ulSpare; + } + // + // Not a scatter-gather transfer, calculate end pointer normally. + // + else + { + ulInc = ulInc >> 30; + ulBufferBytes = ulTransferSize << ulInc; + pvDstAddr = (void *)((unsigned long)pvDstAddr + ulBufferBytes - 1); + } + } + + // + // Load the destination ending address into the control block. + // + pControlTable[ulChannelStructIndex].pvDstEndAddr = pvDstAddr; + + // + // Write the new control word value. + // + pControlTable[ulChannelStructIndex].ulControl = ulControl; +} + +//***************************************************************************** +// +//! Configures a uDMA channel for scatter-gather mode. +//! +//! \param ulChannelNum is the uDMA channel number. +//! \param ulTaskCount is the number of scatter-gather tasks to execute. +//! \param pvTaskList is a pointer to the beginning of the scatter-gather +//! task list. +//! \param ulIsPeriphSG is a flag to indicate it is a peripheral scatter-gather +//! transfer (else it will be memory scatter-gather transfer) +//! +//! This function is used to configure a channel for scatter-gather mode. +//! The caller must have already set up a task list, and pass a pointer to +//! the start of the task list as the \e pvTaskList parameter. The +//! \e ulTaskCount parameter is the count of tasks in the task list, not the +//! size of the task list. The flag \e bIsPeriphSG should be used to indicate +//! if the scatter-gather should be configured for a peripheral or memory +//! scatter-gather operation. +//! +//! \sa uDMATaskStructEntry +//! +//! \return None. +// +//***************************************************************************** +void +uDMAChannelScatterGatherSet(unsigned long ulChannelNum, unsigned ulTaskCount, + void *pvTaskList, unsigned long ulIsPeriphSG) +{ + tDMAControlTable *pControlTable; + tDMAControlTable *pTaskTable; + + // + // Check the parameters + // + ASSERT(ulChannelNum < 32); + ASSERT(HWREG(UDMA_CTLBASE) != 0); + ASSERT(pvTaskList != 0); + ASSERT(ulTaskCount <= 1024); + ASSERT(ulTaskCount != 0); + + // + // Get the base address of the control table. + // + pControlTable = (tDMAControlTable *)HWREG(UDMA_CTLBASE); + + // + // Get a handy pointer to the task list + // + pTaskTable = (tDMAControlTable *)pvTaskList; + + // + // Compute the ending address for the source pointer. This will be the + // last element of the last task in the task table + // + pControlTable[ulChannelNum].pvSrcEndAddr = + &pTaskTable[ulTaskCount - 1].ulSpare; + + // + // Compute the ending address for the destination pointer. This will be + // the end of the alternate structure for this channel. + // + pControlTable[ulChannelNum].pvDstEndAddr = + &pControlTable[ulChannelNum | UDMA_ALT_SELECT].ulSpare; + + // + // Compute the control word. Most configurable items are fixed for + // scatter-gather. Item and increment sizes are all 32-bit and arb + // size must be 4. The count is the number of items in the task list + // times 4 (4 words per task). + // + pControlTable[ulChannelNum].ulControl = + (UDMA_CHCTL_DSTINC_32 | UDMA_CHCTL_DSTSIZE_32 | + UDMA_CHCTL_SRCINC_32 | UDMA_CHCTL_SRCSIZE_32 | + UDMA_CHCTL_ARBSIZE_4 | + (((ulTaskCount * 4) - 1) << UDMA_CHCTL_XFERSIZE_S) | + (ulIsPeriphSG ? UDMA_CHCTL_XFERMODE_PER_SG : + UDMA_CHCTL_XFERMODE_MEM_SG)); +} + +//***************************************************************************** +// +//! Gets the current transfer size for a uDMA channel control structure. +//! +//! \param ulChannelStructIndex is the logical OR of the uDMA channel number +//! with either \b UDMA_PRI_SELECT or \b UDMA_ALT_SELECT. +//! +//! This function is used to get the uDMA transfer size for a channel. The +//! transfer size is the number of items to transfer, where the size of an item +//! might be 8, 16, or 32 bits. If a partial transfer has already occurred, +//! then the number of remaining items will be returned. If the transfer is +//! complete, then 0 will be returned. +//! +//! \return Returns the number of items remaining to transfer. +// +//***************************************************************************** +unsigned long +uDMAChannelSizeGet(unsigned long ulChannelStructIndex) +{ + tDMAControlTable *pControlTable; + unsigned long ulControl; + + // + // Check the arguments. + // + ASSERT(ulChannelStructIndex < 64); + ASSERT(HWREG(UDMA_CTLBASE) != 0); + + // + // Get the base address of the control table. + // + pControlTable = (tDMAControlTable *)HWREG(UDMA_CTLBASE); + + // + // Get the current control word value and mask off all but the size field + // and the mode field. + // + ulControl = (pControlTable[ulChannelStructIndex].ulControl & + (UDMA_CHCTL_XFERSIZE_M | UDMA_CHCTL_XFERMODE_M)); + + // + // If the size field and mode field are 0 then the transfer is finished + // and there are no more items to transfer + // + if(ulControl == 0) + { + return(0); + } + + // + // Otherwise, if either the size field or more field is non-zero, then + // not all the items have been transferred. + // + else + { + // + // Shift the size field and add one, then return to user. + // + return((ulControl >> 4) + 1); + } +} + +//***************************************************************************** +// +//! Gets the transfer mode for a uDMA channel control structure. +//! +//! \param ulChannelStructIndex is the logical OR of the uDMA channel number +//! with either \b UDMA_PRI_SELECT or \b UDMA_ALT_SELECT. +//! +//! This function is used to get the transfer mode for the uDMA channel. It +//! can be used to query the status of a transfer on a channel. When the +//! transfer is complete the mode will be \b UDMA_MODE_STOP. +//! +//! \return Returns the transfer mode of the specified channel and control +//! structure, which will be one of the following values: \b UDMA_MODE_STOP, +//! \b UDMA_MODE_BASIC, \b UDMA_MODE_AUTO, \b UDMA_MODE_PINGPONG, +//! \b UDMA_MODE_MEM_SCATTER_GATHER, or \b UDMA_MODE_PER_SCATTER_GATHER. +// +//***************************************************************************** +unsigned long +uDMAChannelModeGet(unsigned long ulChannelStructIndex) +{ + tDMAControlTable *pControlTable; + unsigned long ulControl; + + // + // Check the arguments. + // + ASSERT(ulChannelStructIndex < 64); + ASSERT(HWREG(UDMA_CTLBASE) != 0); + + // + // Get the base address of the control table. + // + pControlTable = (tDMAControlTable *)HWREG(UDMA_CTLBASE); + + // + // Get the current control word value and mask off all but the mode field. + // + ulControl = (pControlTable[ulChannelStructIndex].ulControl & + UDMA_CHCTL_XFERMODE_M); + + // + // Check if scatter/gather mode, and if so, mask off the alt bit. + // + if(((ulControl & ~UDMA_MODE_ALT_SELECT) == UDMA_MODE_MEM_SCATTER_GATHER) || + ((ulControl & ~UDMA_MODE_ALT_SELECT) == UDMA_MODE_PER_SCATTER_GATHER)) + { + ulControl &= ~UDMA_MODE_ALT_SELECT; + } + + // + // Return the mode to the caller. + // + return(ulControl); +} + +//***************************************************************************** +// +//! Selects the secondary peripheral for a set of uDMA channels. +//! +//! \param ulSecPeriphs is the logical or of the uDMA channels for which to +//! use the secondary peripheral, instead of the default peripheral. +//! +//! This function is used to select the secondary peripheral assignment for +//! a set of uDMA channels. By selecting the secondary peripheral assignment +//! for a channel, the default peripheral assignment is no longer available +//! for that channel. +//! +//! The parameter \e ulSecPeriphs can be the logical OR of any of the +//! following macros. If one of the macros below is in the list passed +//! to this function, then the secondary peripheral (marked as \b _SEC_) +//! will be selected. +//! +//! - \b UDMA_DEF_USBEP1RX_SEC_UART2RX +//! - \b UDMA_DEF_USBEP1TX_SEC_UART2TX +//! - \b UDMA_DEF_USBEP2RX_SEC_TMR3A +//! - \b UDMA_DEF_USBEP2TX_SEC_TMR3B +//! - \b UDMA_DEF_USBEP3RX_SEC_TMR2A +//! - \b UDMA_DEF_USBEP3TX_SEC_TMR2B +//! - \b UDMA_DEF_ETH0RX_SEC_TMR2A +//! - \b UDMA_DEF_ETH0TX_SEC_TMR2B +//! - \b UDMA_DEF_UART0RX_SEC_UART1RX +//! - \b UDMA_DEF_UART0TX_SEC_UART1TX +//! - \b UDMA_DEF_SSI0RX_SEC_SSI1RX +//! - \b UDMA_DEF_SSI0TX_SEC_SSI1TX +//! - \b UDMA_DEF_RESERVED_SEC_UART2RX +//! - \b UDMA_DEF_RESERVED_SEC_UART2TX +//! - \b UDMA_DEF_ADC00_SEC_TMR2A +//! - \b UDMA_DEF_ADC01_SEC_TMR2B +//! - \b UDMA_DEF_ADC02_SEC_RESERVED +//! - \b UDMA_DEF_ADC03_SEC_RESERVED +//! - \b UDMA_DEF_TMR0A_SEC_TMR1A +//! - \b UDMA_DEF_TMR0B_SEC_TMR1B +//! - \b UDMA_DEF_TMR1A_SEC_EPI0RX +//! - \b UDMA_DEF_TMR1B_SEC_EPI0TX +//! - \b UDMA_DEF_UART1RX_SEC_RESERVED +//! - \b UDMA_DEF_UART1TX_SEC_RESERVED +//! - \b UDMA_DEF_SSI1RX_SEC_ADC10 +//! - \b UDMA_DEF_SSI1TX_SEC_ADC11 +//! - \b UDMA_DEF_RESERVED_SEC_ADC12 +//! - \b UDMA_DEF_RESERVED_SEC_ADC13 +//! - \b UDMA_DEF_I2S0RX_SEC_RESERVED +//! - \b UDMA_DEF_I2S0TX_SEC_RESERVED +//! +//! \return None. +// +//***************************************************************************** +void +uDMAChannelSelectSecondary(unsigned long ulSecPeriphs) +{ + // + // Select the secondary peripheral for the specified channels. + // + HWREG(UDMA_CHASGN) |= ulSecPeriphs; +} + +//***************************************************************************** +// +//! Selects the default peripheral for a set of uDMA channels. +//! +//! \param ulDefPeriphs is the logical or of the uDMA channels for which to +//! use the default peripheral, instead of the secondary peripheral. +//! +//! This function is used to select the default peripheral assignment for +//! a set of uDMA channels. +//! +//! The parameter \e ulDefPeriphs can be the logical OR of any of the +//! following macros. If one of the macros below is in the list passed +//! to this function, then the default peripheral (marked as \b _DEF_) +//! will be selected. +//! +//! - \b UDMA_DEF_USBEP1RX_SEC_UART2RX +//! - \b UDMA_DEF_USBEP1TX_SEC_UART2TX +//! - \b UDMA_DEF_USBEP2RX_SEC_TMR3A +//! - \b UDMA_DEF_USBEP2TX_SEC_TMR3B +//! - \b UDMA_DEF_USBEP3RX_SEC_TMR2A +//! - \b UDMA_DEF_USBEP3TX_SEC_TMR2B +//! - \b UDMA_DEF_ETH0RX_SEC_TMR2A +//! - \b UDMA_DEF_ETH0TX_SEC_TMR2B +//! - \b UDMA_DEF_UART0RX_SEC_UART1RX +//! - \b UDMA_DEF_UART0TX_SEC_UART1TX +//! - \b UDMA_DEF_SSI0RX_SEC_SSI1RX +//! - \b UDMA_DEF_SSI0TX_SEC_SSI1TX +//! - \b UDMA_DEF_RESERVED_SEC_UART2RX +//! - \b UDMA_DEF_RESERVED_SEC_UART2TX +//! - \b UDMA_DEF_ADC00_SEC_TMR2A +//! - \b UDMA_DEF_ADC01_SEC_TMR2B +//! - \b UDMA_DEF_ADC02_SEC_RESERVED +//! - \b UDMA_DEF_ADC03_SEC_RESERVED +//! - \b UDMA_DEF_TMR0A_SEC_TMR1A +//! - \b UDMA_DEF_TMR0B_SEC_TMR1B +//! - \b UDMA_DEF_TMR1A_SEC_EPI0RX +//! - \b UDMA_DEF_TMR1B_SEC_EPI0TX +//! - \b UDMA_DEF_UART1RX_SEC_RESERVED +//! - \b UDMA_DEF_UART1TX_SEC_RESERVED +//! - \b UDMA_DEF_SSI1RX_SEC_ADC10 +//! - \b UDMA_DEF_SSI1TX_SEC_ADC11 +//! - \b UDMA_DEF_RESERVED_SEC_ADC12 +//! - \b UDMA_DEF_RESERVED_SEC_ADC13 +//! - \b UDMA_DEF_I2S0RX_SEC_RESERVED +//! - \b UDMA_DEF_I2S0TX_SEC_RESERVED +//! +//! \return None. +// +//***************************************************************************** +void +uDMAChannelSelectDefault(unsigned long ulDefPeriphs) +{ + // + // Select the default peripheral for the specified channels. + // + HWREG(UDMA_CHASGN) &= ~ulDefPeriphs; +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the uDMA controller. +//! +//! \param ulIntChannel identifies which uDMA interrupt is to be registered. +//! \param pfnHandler is a pointer to the function to be called when the +//! interrupt is activated. +//! +//! This sets and enables the handler to be called when the uDMA controller +//! generates an interrupt. The \e ulIntChannel parameter should be one of the +//! following: +//! +//! - \b UDMA_INT_SW to register an interrupt handler to process interrupts +//! from the uDMA software channel (UDMA_CHANNEL_SW) +//! - \b UDMA_INT_ERR to register an interrupt handler to process uDMA error +//! interrupts +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \note The interrupt handler for uDMA is for transfer completion when the +//! channel UDMA_CHANNEL_SW is used, and for error interrupts. The +//! interrupts for each peripheral channel are handled through the individual +//! peripheral interrupt handlers. +//! +//! \return None. +// +//***************************************************************************** +void +uDMAIntRegister(unsigned long ulIntChannel, void (*pfnHandler)(void)) +{ + // + // Check the arguments. + // + ASSERT(pfnHandler); + ASSERT((ulIntChannel == UDMA_INT_SW) || (ulIntChannel == UDMA_INT_ERR)); + + // + // Register the interrupt handler. + // + IntRegister(ulIntChannel, pfnHandler); + + // + // Enable the memory management fault. + // + IntEnable(ulIntChannel); +} + +//***************************************************************************** +// +//! Unregisters an interrupt handler for the uDMA controller. +//! +//! \param ulIntChannel identifies which uDMA interrupt to unregister. +//! +//! This function will disable and clear the handler to be called for the +//! specified uDMA interrupt. The \e ulIntChannel parameter should be one of +//! \b UDMA_INT_SW or \b UDMA_INT_ERR as documented for the function +//! uDMAIntRegister(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +uDMAIntUnregister(unsigned long ulIntChannel) +{ + // + // Disable the interrupt. + // + IntDisable(ulIntChannel); + + // + // Unregister the interrupt handler. + // + IntUnregister(ulIntChannel); +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/udma.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/udma.h new file mode 100644 index 00000000..5a876fdb --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/udma.h @@ -0,0 +1,442 @@ +//***************************************************************************** +// +// udma.h - Prototypes and macros for the uDMA controller. +// +// Copyright (c) 2007-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __UDMA_H__ +#define __UDMA_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +//! \addtogroup udma_api +//! @{ +// +//***************************************************************************** + +//***************************************************************************** +// +// A structure that defines an entry in the channel control table. These +// fields are used by the uDMA controller and normally it is not necessary for +// software to directly read or write fields in the table. +// +//***************************************************************************** +typedef struct +{ + // + // The ending source address of the data transfer. + // + volatile void *pvSrcEndAddr; + + // + // The ending destination address of the data transfer. + // + volatile void *pvDstEndAddr; + + // + // The channel control mode. + // + volatile unsigned long ulControl; + + // + // An unused location. + // + volatile unsigned long ulSpare; +} +tDMAControlTable; + +//***************************************************************************** +// +//! A helper macro for building scatter-gather task table entries. +//! +//! \param ulTransferCount is the count of items to transfer for this task. +//! \param ulItemSize is the bit size of the items to transfer for this task. +//! \param ulSrcIncrement is the bit size increment for source data. +//! \param pvSrcAddr is the starting address of the data to transfer. +//! \param ulDstIncrement is the bit size increment for destination data. +//! \param pvDstAddr is the starting address of the destination data. +//! \param ulArbSize is the arbitration size to use for the transfer task. +//! \param ulMode is the transfer mode for this task. +//! +//! This macro is intended to be used to help populate a table of uDMA tasks +//! for a scatter-gather transfer. This macro will calculate the values for +//! the fields of a task structure entry based on the input parameters. +//! +//! There are specific requirements for the values of each parameter. No +//! checking is done so it is up to the caller to ensure that correct values +//! are used for the parameters. +//! +//! The \e ulTransferCount parameter is the number of items that will be +//! transferred by this task. It must be in the range 1-1024. +//! +//! The \e ulItemSize parameter is the bit size of the transfer data. It must +//! be one of \b UDMA_SIZE_8, \b UDMA_SIZE_16, or \b UDMA_SIZE_32. +//! +//! The \e ulSrcIncrement parameter is the increment size for the source data. +//! It must be one of \b UDMA_SRC_INC_8, \b UDMA_SRC_INC_16, +//! \b UDMA_SRC_INC_32, or \b UDMA_SRC_INC_NONE. +//! +//! The \e pvSrcAddr parameter is a void pointer to the beginning of the source +//! data. +//! +//! The \e ulDstIncrement parameter is the increment size for the destination +//! data. It must be one of \b UDMA_SRC_INC_8, \b UDMA_SRC_INC_16, +//! \b UDMA_SRC_INC_32, or \b UDMA_SRC_INC_NONE. +//! +//! The \e pvDstAddr parameter is a void pointer to the beginning of the +//! location where the data will be transferred. +//! +//! The \e ulArbSize parameter is the arbitration size for the transfer, and +//! must be one of \b UDMA_ARB_1, \b UDMA_ARB_2, \b UDMA_ARB_4, and so on +//! up to \b UDMA_ARB_1024. This is used to select the arbitration size in +//! powers of 2, from 1 to 1024. +//! +//! The \e ulMode parameter is the mode to use for this transfer task. It +//! must be one of \b UDMA_MODE_BASIC, \b UDMA_MODE_AUTO, +//! \b UDMA_MODE_MEM_SCATTER_GATHER, or \b UDMA_MODE_PER_SCATTER_GATHER. Note +//! that normally all tasks will be one of the scatter-gather modes while the +//! last task is a task list will be AUTO or BASIC. +//! +//! This macro is intended to be used to initialize individual entries of +//! a structure of tDMAControlTable type, like this: +//! +//! \verbatim +//! tDMAControlTable MyTaskList[] = +//! { +//! uDMATaskStructEntry(Task1Count, UDMA_SIZE_8, +//! UDMA_SRC_INC_8, MySourceBuf, +//! UDMA_DST_INC_8, MyDestBuf, +//! UDMA_ARB_8, UDMA_MODE_MEM_SCATTER_GATHER), +//! uDMATaskStructEntry(Task2Count, ... ), +//! } +//! \endverbatim +//! +//! \return Nothing; this is not a function. +// +//***************************************************************************** +#define uDMATaskStructEntry(ulTransferCount, \ + ulItemSize, \ + ulSrcIncrement, \ + pvSrcAddr, \ + ulDstIncrement, \ + pvDstAddr, \ + ulArbSize, \ + ulMode) \ + { \ + (((ulSrcIncrement) == UDMA_SRC_INC_NONE) ? (pvSrcAddr) : \ + ((void *)(&((unsigned char *)(pvSrcAddr))[((ulTransferCount) << \ + ((ulSrcIncrement) >> 26)) - 1]))), \ + (((ulDstIncrement) == UDMA_DST_INC_NONE) ? (pvDstAddr) : \ + ((void *)(&((unsigned char *)(pvDstAddr))[((ulTransferCount) << \ + ((ulDstIncrement) >> 30)) - 1]))), \ + (ulSrcIncrement) | (ulDstIncrement) | (ulItemSize) | (ulArbSize) | \ + (((ulTransferCount) - 1) << 4) | \ + ((((ulMode) == UDMA_MODE_MEM_SCATTER_GATHER) || \ + ((ulMode) == UDMA_MODE_PER_SCATTER_GATHER)) ? \ + (ulMode) | UDMA_MODE_ALT_SELECT : (ulMode)), 0 \ + } + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** + +//***************************************************************************** +// +// Flags that can be passed to uDMAChannelAttributeEnable(), +// uDMAChannelAttributeDisable(), and returned from uDMAChannelAttributeGet(). +// +//***************************************************************************** +#define UDMA_ATTR_USEBURST 0x00000001 +#define UDMA_ATTR_ALTSELECT 0x00000002 +#define UDMA_ATTR_HIGH_PRIORITY 0x00000004 +#define UDMA_ATTR_REQMASK 0x00000008 +#define UDMA_ATTR_ALL 0x0000000F + +//***************************************************************************** +// +// DMA control modes that can be passed to uDMAModeSet() and returned +// uDMAModeGet(). +// +//***************************************************************************** +#define UDMA_MODE_STOP 0x00000000 +#define UDMA_MODE_BASIC 0x00000001 +#define UDMA_MODE_AUTO 0x00000002 +#define UDMA_MODE_PINGPONG 0x00000003 +#define UDMA_MODE_MEM_SCATTER_GATHER \ + 0x00000004 +#define UDMA_MODE_PER_SCATTER_GATHER \ + 0x00000006 +#define UDMA_MODE_ALT_SELECT 0x00000001 + +//***************************************************************************** +// +// Channel configuration values that can be passed to uDMAControlSet(). +// +//***************************************************************************** +#define UDMA_DST_INC_8 0x00000000 +#define UDMA_DST_INC_16 0x40000000 +#define UDMA_DST_INC_32 0x80000000 +#define UDMA_DST_INC_NONE 0xc0000000 +#define UDMA_SRC_INC_8 0x00000000 +#define UDMA_SRC_INC_16 0x04000000 +#define UDMA_SRC_INC_32 0x08000000 +#define UDMA_SRC_INC_NONE 0x0c000000 +#define UDMA_SIZE_8 0x00000000 +#define UDMA_SIZE_16 0x11000000 +#define UDMA_SIZE_32 0x22000000 +#define UDMA_ARB_1 0x00000000 +#define UDMA_ARB_2 0x00004000 +#define UDMA_ARB_4 0x00008000 +#define UDMA_ARB_8 0x0000c000 +#define UDMA_ARB_16 0x00010000 +#define UDMA_ARB_32 0x00014000 +#define UDMA_ARB_64 0x00018000 +#define UDMA_ARB_128 0x0001c000 +#define UDMA_ARB_256 0x00020000 +#define UDMA_ARB_512 0x00024000 +#define UDMA_ARB_1024 0x00028000 +#define UDMA_NEXT_USEBURST 0x00000008 + +//***************************************************************************** +// +// Channel numbers to be passed to API functions that require a channel number +// ID. +// +//***************************************************************************** +#define UDMA_CHANNEL_USBEP1RX 0 +#define UDMA_CHANNEL_USBEP1TX 1 +#define UDMA_CHANNEL_USBEP2RX 2 +#define UDMA_CHANNEL_USBEP2TX 3 +#define UDMA_CHANNEL_USBEP3RX 4 +#define UDMA_CHANNEL_USBEP3TX 5 +#define UDMA_CHANNEL_ETH0RX 6 +#define UDMA_CHANNEL_ETH0TX 7 +#define UDMA_CHANNEL_UART0RX 8 +#define UDMA_CHANNEL_UART0TX 9 +#define UDMA_CHANNEL_SSI0RX 10 +#define UDMA_CHANNEL_SSI0TX 11 +#define UDMA_CHANNEL_ADC0 14 +#define UDMA_CHANNEL_ADC1 15 +#define UDMA_CHANNEL_ADC2 16 +#define UDMA_CHANNEL_ADC3 17 +#define UDMA_CHANNEL_TMR0A 18 +#define UDMA_CHANNEL_TMR0B 19 +#define UDMA_CHANNEL_TMR1A 20 +#define UDMA_CHANNEL_TMR1B 21 +#define UDMA_CHANNEL_UART1RX 22 +#define UDMA_CHANNEL_UART1TX 23 +#define UDMA_CHANNEL_SSI1RX 24 +#define UDMA_CHANNEL_SSI1TX 25 +#define UDMA_CHANNEL_I2S0RX 28 +#define UDMA_CHANNEL_I2S0TX 29 +#define UDMA_CHANNEL_SW 30 + +//***************************************************************************** +// +// Flags to be OR'd with the channel ID to indicate if the primary or alternate +// control structure should be used. +// +//***************************************************************************** +#define UDMA_PRI_SELECT 0x00000000 +#define UDMA_ALT_SELECT 0x00000020 + +//***************************************************************************** +// +// uDMA interrupt sources, to be passed to uDMAIntRegister() and +// uDMAIntUnregister(). +// +//***************************************************************************** +#define UDMA_INT_SW 62 +#define UDMA_INT_ERR 63 + +//***************************************************************************** +// +// Channel numbers to be passed to API functions that require a channel number +// ID. These are for secondary peripheral assignments. +// +//***************************************************************************** +#define UDMA_SEC_CHANNEL_UART2RX_0 \ + 0 +#define UDMA_SEC_CHANNEL_UART2TX_1 \ + 1 +#define UDMA_SEC_CHANNEL_TMR3A 2 +#define UDMA_SEC_CHANNEL_TMR3B 3 +#define UDMA_SEC_CHANNEL_TMR2A_4 \ + 4 +#define UDMA_SEC_CHANNEL_TMR2B_5 \ + 5 +#define UDMA_SEC_CHANNEL_TMR2A_6 \ + 6 +#define UDMA_SEC_CHANNEL_TMR2B_7 \ + 7 +#define UDMA_SEC_CHANNEL_UART1RX \ + 8 +#define UDMA_SEC_CHANNEL_UART1TX \ + 9 +#define UDMA_SEC_CHANNEL_SSI1RX 10 +#define UDMA_SEC_CHANNEL_SSI1TX 11 +#define UDMA_SEC_CHANNEL_UART2RX_12 \ + 12 +#define UDMA_SEC_CHANNEL_UART2TX_13 \ + 13 +#define UDMA_SEC_CHANNEL_TMR2A_14 \ + 14 +#define UDMA_SEC_CHANNEL_TMR2B_15 \ + 15 +#define UDMA_SEC_CHANNEL_TMR1A 18 +#define UDMA_SEC_CHANNEL_TMR1B 19 +#define UDMA_SEC_CHANNEL_EPI0RX 20 +#define UDMA_SEC_CHANNEL_EPI0TX 21 +#define UDMA_SEC_CHANNEL_ADC10 24 +#define UDMA_SEC_CHANNEL_ADC11 25 +#define UDMA_SEC_CHANNEL_ADC12 26 +#define UDMA_SEC_CHANNEL_ADC13 27 +#define UDMA_SEC_CHANNEL_SW 30 + +//***************************************************************************** +// +// uDMA default/secondary peripheral selections, to be passed to +// uDMAChannelSelectSecondary() and uDMAChannelSelectDefault(). +// +//***************************************************************************** +#define UDMA_DEF_USBEP1RX_SEC_UART2RX \ + 0x00000001 +#define UDMA_DEF_USBEP1TX_SEC_UART2TX \ + 0x00000002 +#define UDMA_DEF_USBEP2RX_SEC_TMR3A \ + 0x00000004 +#define UDMA_DEF_USBEP2TX_SEC_TMR3B \ + 0x00000008 +#define UDMA_DEF_USBEP3RX_SEC_TMR2A \ + 0x00000010 +#define UDMA_DEF_USBEP3TX_SEC_TMR2B \ + 0x00000020 +#define UDMA_DEF_ETH0RX_SEC_TMR2A \ + 0x00000040 +#define UDMA_DEF_ETH0TX_SEC_TMR2B \ + 0x00000080 +#define UDMA_DEF_UART0RX_SEC_UART1RX \ + 0x00000100 +#define UDMA_DEF_UART0TX_SEC_UART1TX \ + 0x00000200 +#define UDMA_DEF_SSI0RX_SEC_SSI1RX \ + 0x00000400 +#define UDMA_DEF_SSI0TX_SEC_SSI1TX \ + 0x00000800 +#define UDMA_DEF_RESERVED_SEC_UART2RX \ + 0x00001000 +#define UDMA_DEF_RESERVED_SEC_UART2TX \ + 0x00002000 +#define UDMA_DEF_ADC00_SEC_TMR2A \ + 0x00004000 +#define UDMA_DEF_ADC01_SEC_TMR2B \ + 0x00008000 +#define UDMA_DEF_ADC02_SEC_RESERVED \ + 0x00010000 +#define UDMA_DEF_ADC03_SEC_RESERVED \ + 0x00020000 +#define UDMA_DEF_TMR0A_SEC_TMR1A \ + 0x00040000 +#define UDMA_DEF_TMR0B_SEC_TMR1B \ + 0x00080000 +#define UDMA_DEF_TMR1A_SEC_EPI0RX \ + 0x00100000 +#define UDMA_DEF_TMR1B_SEC_EPI0TX \ + 0x00200000 +#define UDMA_DEF_UART1RX_SEC_RESERVED \ + 0x00400000 +#define UDMA_DEF_UART1TX_SEC_RESERVED \ + 0x00800000 +#define UDMA_DEF_SSI1RX_SEC_ADC10 \ + 0x01000000 +#define UDMA_DEF_SSI1TX_SEC_ADC11 \ + 0x02000000 +#define UDMA_DEF_RESERVED_SEC_ADC12 \ + 0x04000000 +#define UDMA_DEF_RESERVED_SEC_ADC13 \ + 0x08000000 +#define UDMA_DEF_I2S0RX_SEC_RESERVED \ + 0x10000000 +#define UDMA_DEF_I2S0TX_SEC_RESERVED \ + 0x20000000 + +//***************************************************************************** +// +// API Function prototypes +// +//***************************************************************************** +extern void uDMAEnable(void); +extern void uDMADisable(void); +extern unsigned long uDMAErrorStatusGet(void); +extern void uDMAErrorStatusClear(void); +extern void uDMAChannelEnable(unsigned long ulChannelNum); +extern void uDMAChannelDisable(unsigned long ulChannelNum); +extern tBoolean uDMAChannelIsEnabled(unsigned long ulChannelNum); +extern void uDMAControlBaseSet(void *pControlTable); +extern void *uDMAControlBaseGet(void); +extern void *uDMAControlAlternateBaseGet(void); +extern void uDMAChannelRequest(unsigned long ulChannelNum); +extern void uDMAChannelAttributeEnable(unsigned long ulChannelNum, + unsigned long ulAttr); +extern void uDMAChannelAttributeDisable(unsigned long ulChannelNum, + unsigned long ulAttr); +extern unsigned long uDMAChannelAttributeGet(unsigned long ulChannelNum); +extern void uDMAChannelControlSet(unsigned long ulChannelStructIndex, + unsigned long ulControl); +extern void uDMAChannelTransferSet(unsigned long ulChannelStructIndex, + unsigned long ulMode, void *pvSrcAddr, + void *pvDstAddr, + unsigned long ulTransferSize); +extern void uDMAChannelScatterGatherSet(unsigned long ulChannelNum, + unsigned ulTaskCount, void *pvTaskList, + unsigned long ulIsPeriphSG); +extern unsigned long uDMAChannelSizeGet(unsigned long ulChannelStructIndex); +extern unsigned long uDMAChannelModeGet(unsigned long ulChannelStructIndex); +extern void uDMAIntRegister(unsigned long ulIntChannel, + void (*pfnHandler)(void)); +extern void uDMAIntUnregister(unsigned long ulIntChannel); +extern void uDMAChannelSelectDefault(unsigned long ulDefPeriphs); +extern void uDMAChannelSelectSecondary(unsigned long ulSecPeriphs); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __UDMA_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/usb.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/usb.c new file mode 100644 index 00000000..e8511711 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/usb.c @@ -0,0 +1,3871 @@ +//***************************************************************************** +// +// usb.c - Driver for the USB Interface. +// +// Copyright (c) 2007-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup usb_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_types.h" +#include "inc/hw_usb.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" +#include "driverlib/udma.h" +#include "driverlib/usb.h" + +//***************************************************************************** +// +// Amount to shift the RX interrupt sources by in the flags used in the +// interrupt calls. +// +//***************************************************************************** +#ifndef DEPRECATED +#define USB_INT_RX_SHIFT 8 +#endif +#define USB_INTEP_RX_SHIFT 16 + +//***************************************************************************** +// +// Amount to shift the status interrupt sources by in the flags used in the +// interrupt calls. +// +//***************************************************************************** +#ifndef DEPRECATED +#define USB_INT_STATUS_SHIFT 24 +#endif + +//***************************************************************************** +// +// Amount to shift the RX endpoint status sources by in the flags used in the +// calls. +// +//***************************************************************************** +#define USB_RX_EPSTATUS_SHIFT 16 + +//***************************************************************************** +// +// Converts from an endpoint specifier to the offset of the endpoint's +// control/status registers. +// +//***************************************************************************** +#define EP_OFFSET(Endpoint) (Endpoint - 0x10) + +//***************************************************************************** +// +// Sets one of the indexed registers. +// +// \param ulBase specifies the USB module base address. +// \param ulEndpoint is the endpoint index to target for this write. +// \param ulIndexedReg is the indexed register to write to. +// \param ucValue is the value to write to the register. +// +// This function is used to access the indexed registers for each endpoint. +// The only registers that are indexed are the FIFO configuration registers +// which are not used after configuration. +// +// \return None. +// +//***************************************************************************** +static void +USBIndexWrite(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulIndexedReg, unsigned long ulValue, + unsigned long ulSize) +{ + unsigned long ulIndex; + + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == 0) || (ulEndpoint == 1) || (ulEndpoint == 2) || + (ulEndpoint == 3)); + ASSERT((ulSize == 1) || (ulSize == 2)); + + // + // Save the old index in case it was in use. + // + ulIndex = HWREGB(ulBase + USB_O_EPIDX); + + // + // Set the index. + // + HWREGB(ulBase + USB_O_EPIDX) = ulEndpoint; + + // + // Determine the size of the register value. + // + if(ulSize == 1) + { + // + // Set the value. + // + HWREGB(ulBase + ulIndexedReg) = ulValue; + } + else + { + // + // Set the value. + // + HWREGH(ulBase + ulIndexedReg) = ulValue; + } + + // + // Restore the old index in case it was in use. + // + HWREGB(ulBase + USB_O_EPIDX) = ulIndex; +} + +//***************************************************************************** +// +// Reads one of the indexed registers. +// +// \param ulBase specifies the USB module base address. +// \param ulEndpoint is the endpoint index to target for this write. +// \param ulIndexedReg is the indexed register to write to. +// +// This function is used internally to access the indexed registers for each +// endpoint. The only registers that are indexed are the FIFO configuration +// registers which are not used after configuration. +// +// \return The value in the register requested. +// +//***************************************************************************** +static unsigned long +USBIndexRead(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulIndexedReg, unsigned long ulSize) +{ + unsigned char ulIndex; + unsigned char ulValue; + + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == 0) || (ulEndpoint == 1) || (ulEndpoint == 2) || + (ulEndpoint == 3)); + ASSERT((ulSize == 1) || (ulSize == 2)); + + // + // Save the old index in case it was in use. + // + ulIndex = HWREGB(ulBase + USB_O_EPIDX); + + // + // Set the index. + // + HWREGB(ulBase + USB_O_EPIDX) = ulEndpoint; + + // + // Determine the size of the register value. + // + if(ulSize == 1) + { + // + // Get the value. + // + ulValue = HWREGB(ulBase + ulIndexedReg); + } + else + { + // + // Get the value. + // + ulValue = HWREGH(ulBase + ulIndexedReg); + } + + // + // Restore the old index in case it was in use. + // + HWREGB(ulBase + USB_O_EPIDX) = ulIndex; + + // + // Return the register's value. + // + return(ulValue); +} + +//***************************************************************************** +// +//! Puts the USB bus in a suspended state. +//! +//! \param ulBase specifies the USB module base address. +//! +//! When used in host mode, this function will put the USB bus in the suspended +//! state. +//! +//! \note This function should only be called in host mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostSuspend(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Send the suspend signaling to the USB bus. + // + HWREGB(ulBase + USB_O_POWER) |= USB_POWER_SUSPEND; +} + +//***************************************************************************** +// +//! Handles the USB bus reset condition. +//! +//! \param ulBase specifies the USB module base address. +//! \param bStart specifies whether to start or stop signaling reset on the USB +//! bus. +//! +//! When this function is called with the \e bStart parameter set to \b true, +//! this function will cause the start of a reset condition on the USB bus. +//! The caller should then delay at least 20ms before calling this function +//! again with the \e bStart parameter set to \b false. +//! +//! \note This function should only be called in host mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostReset(unsigned long ulBase, tBoolean bStart) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Send a reset signal to the bus. + // + if(bStart) + { + HWREGB(ulBase + USB_O_POWER) |= USB_POWER_RESET; + } + else + { + HWREGB(ulBase + USB_O_POWER) &= ~USB_POWER_RESET; + } +} + +//***************************************************************************** +// +//! Handles the USB bus resume condition. +//! +//! \param ulBase specifies the USB module base address. +//! \param bStart specifies if the USB controller is entering or leaving the +//! resume signaling state. +//! +//! When in device mode this function will bring the USB controller out of the +//! suspend state. This call should first be made with the \e bStart parameter +//! set to \b true to start resume signaling. The device application should +//! then delay at least 10ms but not more than 15ms before calling this +//! function with the \e bStart parameter set to \b false. +//! +//! When in host mode this function will signal devices to leave the suspend +//! state. This call should first be made with the \e bStart parameter set to +//! \b true to start resume signaling. The host application should then delay +//! at least 20ms before calling this function with the \e bStart parameter set +//! to \b false. This will cause the controller to complete the resume +//! signaling on the USB bus. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostResume(unsigned long ulBase, tBoolean bStart) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Send a resume signal to the bus. + // + if(bStart) + { + HWREGB(ulBase + USB_O_POWER) |= USB_POWER_RESUME; + } + else + { + HWREGB(ulBase + USB_O_POWER) &= ~USB_POWER_RESUME; + } +} + +//***************************************************************************** +// +//! Returns the current speed of the USB device connected. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function will return the current speed of the USB bus. +//! +//! \note This function should only be called in host mode. +//! +//! \return Returns either \b USB_LOW_SPEED, \b USB_FULL_SPEED, or +//! \b USB_UNDEF_SPEED. +// +//***************************************************************************** +unsigned long +USBHostSpeedGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // If the Full Speed device bit is set, then this is a full speed device. + // + if(HWREGB(ulBase + USB_O_DEVCTL) & USB_DEVCTL_FSDEV) + { + return(USB_FULL_SPEED); + } + + // + // If the Low Speed device bit is set, then this is a low speed device. + // + if(HWREGB(ulBase + USB_O_DEVCTL) & USB_DEVCTL_LSDEV) + { + return(USB_LOW_SPEED); + } + + // + // The device speed is not known. + // + return(USB_UNDEF_SPEED); +} + +//***************************************************************************** +// +//! Returns the status of the USB interrupts. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function will read the source of the interrupt for the USB controller. +//! There are three groups of interrupt sources, IN Endpoints, OUT Endpoints, +//! and general status changes. This call will return the current status for +//! all of these interrupts. The bit values returned should be compared +//! against the \b USB_HOST_IN, \b USB_HOST_OUT, \b USB_HOST_EP0, +//! \b USB_DEV_IN, \b USB_DEV_OUT, and \b USB_DEV_EP0 values. +//! +//! \note This call will clear the source of all of the general status +//! interrupts. +//! +//! \note WARNING: This API cannot be used on endpoint numbers greater than +//! endpoint 3 so USBIntStatusControl() or USBIntStatusEndpoint() should be +//! used instead. +//! +//! \return Returns the status of the sources for the USB controller's +//! interrupt. +// +//***************************************************************************** +#ifndef DEPRECATED +unsigned long +USBIntStatus(unsigned long ulBase) +{ + unsigned long ulStatus; + + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Get the transmit interrupt status. + // + ulStatus = (HWREGB(ulBase + USB_O_TXIS)); + + // + // Get the receive interrupt status, these bits go into the second byte of + // the returned value. + // + ulStatus |= (HWREGB(ulBase + USB_O_RXIS) << USB_INT_RX_SHIFT); + + // + // Get the general interrupt status, these bits go into the upper 8 bits + // of the returned value. + // + ulStatus |= (HWREGB(ulBase + USB_O_IS) << USB_INT_STATUS_SHIFT); + + // + // Add the power fault status. + // + if(HWREG(ulBase + USB_O_EPCISC) & USB_EPCISC_PF) + { + // + // Indicate a power fault was detected. + // + ulStatus |= USB_INT_POWER_FAULT; + + // + // Clear the power fault interrupt. + // + HWREGB(ulBase + USB_O_EPCISC) |= USB_EPCISC_PF; + } + + if(HWREG(USB0_BASE + USB_O_IDVISC) & USB_IDVRIS_ID) + { + // + // Indicate a id detection was detected. + // + ulStatus |= USB_INT_MODE_DETECT; + + // + // Clear the id detection interrupt. + // + HWREG(USB0_BASE + USB_O_IDVISC) |= USB_IDVRIS_ID; + } + + // + // Return the combined interrupt status. + // + return(ulStatus); +} +#endif + +//***************************************************************************** +// +//! Disables the sources for USB interrupts. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulFlags specifies which interrupts to disable. +//! +//! This function will disable the USB controller from generating the +//! interrupts indicated by the \e ulFlags parameter. There are three groups +//! of interrupt sources, IN Endpoints, OUT Endpoints, and general status +//! changes, specified by \b USB_INT_HOST_IN, \b USB_INT_HOST_OUT, +//! \b USB_INT_DEV_IN, \b USB_INT_DEV_OUT, and \b USB_INT_STATUS. If +//! \b USB_INT_ALL is specified then all interrupts will be disabled. +//! +//! \note WARNING: This API cannot be used on endpoint numbers greater than +//! endpoint 3 so USBIntDisableControl() or USBIntDisableEndpoint() should be +//! used instead. +//! +//! \return None. +// +//***************************************************************************** +#ifndef DEPRECATED +void +USBIntDisable(unsigned long ulBase, unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulFlags & ~(USB_INT_ALL)) == 0); + + // + // If any transmit interrupts were disabled then write the transmit + // interrupt settings out to the hardware. + // + if(ulFlags & (USB_INT_HOST_OUT | USB_INT_DEV_IN | USB_INT_EP0)) + { + HWREGH(ulBase + USB_O_TXIE) &= + ~(ulFlags & (USB_INT_HOST_OUT | USB_INT_DEV_IN | USB_INT_EP0)); + } + + // + // If any receive interrupts were disabled then write the receive interrupt + // settings out to the hardware. + // + if(ulFlags & (USB_INT_HOST_IN | USB_INT_DEV_OUT)) + { + HWREGH(ulBase + USB_O_RXIE) &= + ~((ulFlags & (USB_INT_HOST_IN | USB_INT_DEV_OUT)) >> + USB_INT_RX_SHIFT); + } + + // + // If any general interrupts were disabled then write the general interrupt + // settings out to the hardware. + // + if(ulFlags & USB_INT_STATUS) + { + HWREGB(ulBase + USB_O_IE) &= + ~((ulFlags & USB_INT_STATUS) >> USB_INT_STATUS_SHIFT); + } + + // + // Disable the power fault interrupt. + // + if(ulFlags & USB_INT_POWER_FAULT) + { + HWREG(ulBase + USB_O_EPCIM) = 0; + } + + // + // Disable the ID pin detect interrupt. + // + if(ulFlags & USB_INT_MODE_DETECT) + { + HWREG(USB0_BASE + USB_O_IDVIM) = 0; + } +} +#endif + +//***************************************************************************** +// +//! Enables the sources for USB interrupts. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulFlags specifies which interrupts to enable. +//! +//! This function will enable the USB controller's ability to generate the +//! interrupts indicated by the \e ulFlags parameter. There are three +//! groups of interrupt sources, IN Endpoints, OUT Endpoints, and +//! general status changes, specified by \b USB_INT_HOST_IN, +//! \b USB_INT_HOST_OUT, \b USB_INT_DEV_IN, \b USB_INT_DEV_OUT, and +//! \b USB_STATUS. If \b USB_INT_ALL is specified then all interrupts will be +//! enabled. +//! +//! \note A call must be made to enable the interrupt in the main interrupt +//! controller to receive interrupts. The USBIntRegister() API performs this +//! controller level interrupt enable. However if static interrupt handlers +//! are used then then a call to IntEnable() must be made in order to allow any +//! USB interrupts to occur. +//! +//! \note WARNING: This API cannot be used on endpoint numbers greater than +//! endpoint 3 so USBIntEnableControl() or USBIntEnableEndpoint() should be +//! used instead. +//! +//! \return None. +// +//***************************************************************************** +#ifndef DEPRECATED +void +USBIntEnable(unsigned long ulBase, unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulFlags & (~USB_INT_ALL)) == 0); + + // + // If any transmit interrupts were enabled then write the transmit + // interrupt settings out to the hardware. + // + if(ulFlags & (USB_INT_HOST_OUT | USB_INT_DEV_IN | USB_INT_EP0)) + { + HWREGH(ulBase + USB_O_TXIE) |= + ulFlags & (USB_INT_HOST_OUT | USB_INT_DEV_IN | USB_INT_EP0); + } + + // + // If any receive interrupts were enabled then write the receive interrupt + // settings out to the hardware. + // + if(ulFlags & (USB_INT_HOST_IN | USB_INT_DEV_OUT)) + { + HWREGH(ulBase + USB_O_RXIE) |= + ((ulFlags & (USB_INT_HOST_IN | USB_INT_DEV_OUT)) >> + USB_INT_RX_SHIFT); + } + + // + // If any general interrupts were enabled then write the general interrupt + // settings out to the hardware. + // + if(ulFlags & USB_INT_STATUS) + { + HWREGB(ulBase + USB_O_IE) |= + (ulFlags & USB_INT_STATUS) >> USB_INT_STATUS_SHIFT; + } + + // + // Enable the power fault interrupt. + // + if(ulFlags & USB_INT_POWER_FAULT) + { + HWREG(ulBase + USB_O_EPCIM) = USB_EPCIM_PF; + } + + // + // Enable the ID pin detect interrupt. + // + if(ulFlags & USB_INT_MODE_DETECT) + { + HWREG(USB0_BASE + USB_O_IDVIM) = USB_IDVIM_ID; + } +} +#endif + +//***************************************************************************** +// +//! Disable control interrupts on a given USB controller. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulFlags specifies which control interrupts to disable. +//! +//! This function will disable the control interrupts for the USB controller +//! specified by the \e ulBase parameter. The \e ulFlags parameter specifies +//! which control interrupts to disable. The flags passed in the \e ulFlags +//! parameters should be the definitions that start with \b USB_INTCTRL_* and +//! not any other \b USB_INT flags. +//! +//! \return None. +// +//***************************************************************************** +void +USBIntDisableControl(unsigned long ulBase, unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulFlags & ~(USB_INTCTRL_ALL)) == 0); + + // + // If any general interrupts were disabled then write the general interrupt + // settings out to the hardware. + // + if(ulFlags & USB_INTCTRL_STATUS) + { + HWREGB(ulBase + USB_O_IE) &= ~(ulFlags & USB_INTCTRL_STATUS); + } + + // + // Disable the power fault interrupt. + // + if(ulFlags & USB_INTCTRL_POWER_FAULT) + { + HWREG(ulBase + USB_O_EPCIM) = 0; + } + + // + // Disable the ID pin detect interrupt. + // + if(ulFlags & USB_INTCTRL_MODE_DETECT) + { + HWREG(USB0_BASE + USB_O_IDVIM) = 0; + } +} + +//***************************************************************************** +// +//! Enable control interrupts on a given USB controller. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulFlags specifies which control interrupts to enable. +//! +//! This function will enable the control interrupts for the USB controller +//! specified by the \e ulBase parameter. The \e ulFlags parameter specifies +//! which control interrupts to enable. The flags passed in the \e ulFlags +//! parameters should be the definitions that start with \b USB_INTCTRL_* and +//! not any other \b USB_INT flags. +//! +//! \return None. +// +//***************************************************************************** +void +USBIntEnableControl(unsigned long ulBase, unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulFlags & (~USB_INTCTRL_ALL)) == 0); + + // + // If any general interrupts were enabled then write the general interrupt + // settings out to the hardware. + // + if(ulFlags & USB_INTCTRL_STATUS) + { + HWREGB(ulBase + USB_O_IE) |= ulFlags; + } + + // + // Enable the power fault interrupt. + // + if(ulFlags & USB_INTCTRL_POWER_FAULT) + { + HWREG(ulBase + USB_O_EPCIM) = USB_EPCIM_PF; + } + + // + // Enable the ID pin detect interrupt. + // + if(ulFlags & USB_INTCTRL_MODE_DETECT) + { + HWREG(USB0_BASE + USB_O_IDVIM) = USB_IDVIM_ID; + } +} + +//***************************************************************************** +// +//! Returns the control interrupt status on a given USB controller. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function will read control interrupt status for a USB controller. +//! This call will return the current status for control interrupts only, the +//! endpoint interrupt status is retrieved by calling USBIntStatusEndpoint(). +//! The bit values returned should be compared against the \b USB_INTCTRL_* +//! values. +//! +//! The following are the meanings of all \b USB_INCTRL_ flags and the modes +//! for which they are valid. These values apply to any calls to +//! USBIntStatusControl(), USBIntEnableControl(), and USBIntDisableConrol(). +//! Some of these flags are only valid in the following modes as indicated in +//! the parenthesis: Host, Device, and OTG. +//! +//! - \b USB_INTCTRL_ALL - A full mask of all control interrupt sources. +//! - \b USB_INTCTRL_VBUS_ERR - A VBUS error has occurred (Host Only). +//! - \b USB_INTCTRL_SESSION - Session Start Detected on A-side of cable +//! (OTG Only). +//! - \b USB_INTCTRL_SESSION_END - Session End Detected (Device Only) +//! - \b USB_INTCTRL_DISCONNECT - Device Disconnect Detected (Host Only) +//! - \b USB_INTCTRL_CONNECT - Device Connect Detected (Host Only) +//! - \b USB_INTCTRL_SOF - Start of Frame Detected. +//! - \b USB_INTCTRL_BABBLE - USB controller detected a device signaling past +//! the end of a frame. (Host Only) +//! - \b USB_INTCTRL_RESET - Reset signaling detected by device. (Device Only) +//! - \b USB_INTCTRL_RESUME - Resume signaling detected. +//! - \b USB_INTCTRL_SUSPEND - Suspend signaling detected by device (Device +//! Only) +//! - \b USB_INTCTRL_MODE_DETECT - OTG cable mode detection has completed +//! (OTG Only) +//! - \b USB_INTCTRL_POWER_FAULT - Power Fault detected. (Host Only) +//! +//! \note This call will clear the source of all of the control status +//! interrupts. +//! +//! \return Returns the status of the control interrupts for a USB controller. +// +//***************************************************************************** +unsigned long +USBIntStatusControl(unsigned long ulBase) +{ + unsigned long ulStatus; + + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Get the general interrupt status, these bits go into the upper 8 bits + // of the returned value. + // + ulStatus = HWREGB(ulBase + USB_O_IS); + + // + // Add the power fault status. + // + if(HWREG(ulBase + USB_O_EPCISC) & USB_EPCISC_PF) + { + // + // Indicate a power fault was detected. + // + ulStatus |= USB_INTCTRL_POWER_FAULT; + + // + // Clear the power fault interrupt. + // + HWREGB(ulBase + USB_O_EPCISC) |= USB_EPCISC_PF; + } + + if(HWREG(USB0_BASE + USB_O_IDVISC) & USB_IDVRIS_ID) + { + // + // Indicate a id detection was detected. + // + ulStatus |= USB_INTCTRL_MODE_DETECT; + + // + // Clear the id detection interrupt. + // + HWREG(USB0_BASE + USB_O_IDVISC) |= USB_IDVRIS_ID; + } + + // + // Return the combined interrupt status. + // + return(ulStatus); +} + +//***************************************************************************** +// +//! Disable endpoint interrupts on a given USB controller. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulFlags specifies which endpoint interrupts to disable. +//! +//! This function will disable endpoint interrupts for the USB controller +//! specified by the \e ulBase parameter. The \e ulFlags parameter specifies +//! which endpoint interrupts to disable. The flags passed in the \e ulFlags +//! parameters should be the definitions that start with \b USB_INTEP_* and not +//! any other \b USB_INT flags. +//! +//! \return None. +// +//***************************************************************************** +void +USBIntDisableEndpoint(unsigned long ulBase, unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // If any transmit interrupts were disabled then write the transmit + // interrupt settings out to the hardware. + // + HWREGH(ulBase + USB_O_TXIE) &= + ~(ulFlags & (USB_INTEP_HOST_OUT | USB_INTEP_DEV_IN | USB_INTEP_0)); + + // + // If any receive interrupts were disabled then write the receive interrupt + // settings out to the hardware. + // + HWREGH(ulBase + USB_O_RXIE) &= + ~((ulFlags & (USB_INTEP_HOST_IN | USB_INTEP_DEV_OUT)) >> + USB_INTEP_RX_SHIFT); +} + +//***************************************************************************** +// +//! Enable endpoint interrupts on a given USB controller. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulFlags specifies which endpoint interrupts to enable. +//! +//! This function will enable endpoint interrupts for the USB controller +//! specified by the \e ulBase parameter. The \e ulFlags parameter specifies +//! which endpoint interrupts to enable. The flags passed in the \e ulFlags +//! parameters should be the definitions that start with \b USB_INTEP_* and not +//! any other \b USB_INT flags. +//! +//! \return None. +// +//***************************************************************************** +void +USBIntEnableEndpoint(unsigned long ulBase, unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Enable any transmit endpoint interrupts. + // + HWREGH(ulBase + USB_O_TXIE) |= + ulFlags & (USB_INTEP_HOST_OUT | USB_INTEP_DEV_IN | USB_INTEP_0); + + // + // Enable any receive endpoint interrupts. + // + HWREGH(ulBase + USB_O_RXIE) |= + ((ulFlags & (USB_INTEP_HOST_IN | USB_INTEP_DEV_OUT)) >> + USB_INTEP_RX_SHIFT); +} + +//***************************************************************************** +// +//! Returns the endpoint interrupt status on a given USB controller. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function will read endpoint interrupt status for a USB controller. +//! This call will return the current status for endpoint interrupts only, the +//! control interrupt status is retrieved by calling USBIntStatusControl(). +//! The bit values returned should be compared against the \b USB_INTEP_* +//! values. These are grouped into classes for \b USB_INTEP_HOST_* and +//! \b USB_INTEP_DEV_* values to handle both host and device modes with all +//! endpoints. +//! +//! \note This call will clear the source of all of the endpoint interrupts. +//! +//! \return Returns the status of the endpoint interrupts for a USB controller. +// +//***************************************************************************** +unsigned long +USBIntStatusEndpoint(unsigned long ulBase) +{ + unsigned long ulStatus; + + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Get the transmit interrupt status. + // + ulStatus = HWREGH(ulBase + USB_O_TXIS); + + ulStatus |= (HWREGH(ulBase + USB_O_RXIS) << USB_INTEP_RX_SHIFT); + + // + // Return the combined interrupt status. + // + return(ulStatus); +} + +//***************************************************************************** +// +//! Registers an interrupt handler for the USB controller. +//! +//! \param ulBase specifies the USB module base address. +//! \param pfnHandler is a pointer to the function to be called when a USB +//! interrupt occurs. +//! +//! This sets the handler to be called when a USB interrupt occurs. This will +//! also enable the global USB interrupt in the interrupt controller. The +//! specific desired USB interrupts must be enabled via a separate call to +//! USBIntEnable(). It is the interrupt handler's responsibility to clear the +//! interrupt sources via a calls to USBIntStatusControl() and +//! USBIntStatusEndpoint(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +USBIntRegister(unsigned long ulBase, void(*pfnHandler)(void)) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Register the interrupt handler. + // + IntRegister(INT_USB0, pfnHandler); + + // + // Enable the USB interrupt. + // + IntEnable(INT_USB0); +} + +//***************************************************************************** +// +//! Unregisters an interrupt handler for the USB controller. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function unregister the interrupt handler. This function will also +//! disable the USB interrupt in the interrupt controller. +//! +//! \sa IntRegister() for important information about registering or +//! unregistering interrupt handlers. +//! +//! \return None. +// +//***************************************************************************** +void +USBIntUnregister(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Unregister the interrupt handler. + // + IntUnregister(INT_USB0); + + // + // Disable the CAN interrupt. + // + IntDisable(INT_USB0); +} + +//***************************************************************************** +// +//! Returns the current status of an endpoint. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! +//! This function will return the status of a given endpoint. If any of these +//! status bits need to be cleared, then these these values must be cleared by +//! calling the USBDevEndpointStatusClear() or USBHostEndpointStatusClear() +//! functions. +//! +//! The following are the status flags for host mode: +//! +//! - \b USB_HOST_IN_PID_ERROR - PID error on the given endpoint. +//! - \b USB_HOST_IN_NOT_COMP - The device failed to respond to an IN request. +//! - \b USB_HOST_IN_STALL - A stall was received on an IN endpoint. +//! - \b USB_HOST_IN_DATA_ERROR - There was a CRC or bit-stuff error on an IN +//! endpoint in Isochronous mode. +//! - \b USB_HOST_IN_NAK_TO - NAKs received on this IN endpoint for more than +//! the specified timeout period. +//! - \b USB_HOST_IN_ERROR - Failed to communicate with a device using this IN +//! endpoint. +//! - \b USB_HOST_IN_FIFO_FULL - This IN endpoint's FIFO is full. +//! - \b USB_HOST_IN_PKTRDY - Data packet ready on this IN endpoint. +//! - \b USB_HOST_OUT_NAK_TO - NAKs received on this OUT endpoint for more than +//! the specified timeout period. +//! - \b USB_HOST_OUT_NOT_COMP - The device failed to respond to an OUT +//! request. +//! - \b USB_HOST_OUT_STALL - A stall was received on this OUT endpoint. +//! - \b USB_HOST_OUT_ERROR - Failed to communicate with a device using this +//! OUT endpoint. +//! - \b USB_HOST_OUT_FIFO_NE - This endpoint's OUT FIFO is not empty. +//! - \b USB_HOST_OUT_PKTPEND - The data transfer on this OUT endpoint has not +//! completed. +//! - \b USB_HOST_EP0_NAK_TO - NAKs received on endpoint zero for more than the +//! specified timeout period. +//! - \b USB_HOST_EP0_ERROR - The device failed to respond to a request on +//! endpoint zero. +//! - \b USB_HOST_EP0_IN_STALL - A stall was received on endpoint zero for an +//! IN transaction. +//! - \b USB_HOST_EP0_IN_PKTRDY - Data packet ready on endpoint zero for an IN +//! transaction. +//! +//! The following are the status flags for device mode: +//! +//! - \b USB_DEV_OUT_SENT_STALL - A stall was sent on this OUT endpoint. +//! - \b USB_DEV_OUT_DATA_ERROR - There was a CRC or bit-stuff error on an OUT +//! endpoint. +//! - \b USB_DEV_OUT_OVERRUN - An OUT packet was not loaded due to a full FIFO. +//! - \b USB_DEV_OUT_FIFO_FULL - The OUT endpoint's FIFO is full. +//! - \b USB_DEV_OUT_PKTRDY - There is a data packet ready in the OUT +//! endpoint's FIFO. +//! - \b USB_DEV_IN_NOT_COMP - A larger packet was split up, more data to come. +//! - \b USB_DEV_IN_SENT_STALL - A stall was sent on this IN endpoint. +//! - \b USB_DEV_IN_UNDERRUN - Data was requested on the IN endpoint and no +//! data was ready. +//! - \b USB_DEV_IN_FIFO_NE - The IN endpoint's FIFO is not empty. +//! - \b USB_DEV_IN_PKTPEND - The data transfer on this IN endpoint has not +//! completed. +//! - \b USB_DEV_EP0_SETUP_END - A control transaction ended before Data End +//! condition was sent. +//! - \b USB_DEV_EP0_SENT_STALL - A stall was sent on endpoint zero. +//! - \b USB_DEV_EP0_IN_PKTPEND - The data transfer on endpoint zero has not +//! completed. +//! - \b USB_DEV_EP0_OUT_PKTRDY - There is a data packet ready in endpoint +//! zero's OUT FIFO. +//! +//! \return The current status flags for the endpoint depending on mode. +// +//***************************************************************************** +unsigned long +USBEndpointStatus(unsigned long ulBase, unsigned long ulEndpoint) +{ + unsigned long ulStatus; + + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // Get the TX portion of the endpoint status. + // + ulStatus = HWREGH(ulBase + EP_OFFSET(ulEndpoint) + USB_O_TXCSRL1); + + // + // Get the RX portion of the endpoint status. + // + ulStatus |= ((HWREGH(ulBase + EP_OFFSET(ulEndpoint) + USB_O_RXCSRL1)) << + USB_RX_EPSTATUS_SHIFT); + + // + // Return the endpoint status. + // + return(ulStatus); +} + +//***************************************************************************** +// +//! Clears the status bits in this endpoint in host mode. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param ulFlags are the status bits that will be cleared. +//! +//! This function will clear the status of any bits that are passed in the +//! \e ulFlags parameter. The \e ulFlags parameter can take the value returned +//! from the USBEndpointStatus() call. +//! +//! \note This function should only be called in host mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostEndpointStatusClear(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // Clear the specified flags for the endpoint. + // + if(ulEndpoint == USB_EP_0) + { + HWREGB(ulBase + USB_O_CSRL0) &= ~ulFlags; + } + else + { + HWREGB(ulBase + USB_O_TXCSRL1 + EP_OFFSET(ulEndpoint)) &= ~ulFlags; + HWREGB(ulBase + USB_O_RXCSRL1 + EP_OFFSET(ulEndpoint)) &= + ~(ulFlags >> USB_RX_EPSTATUS_SHIFT); + } +} + +//***************************************************************************** +// +//! Clears the status bits in this endpoint in device mode. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param ulFlags are the status bits that will be cleared. +//! +//! This function will clear the status of any bits that are passed in the +//! \e ulFlags parameter. The \e ulFlags parameter can take the value returned +//! from the USBEndpointStatus() call. +//! +//! \note This function should only be called in device mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBDevEndpointStatusClear(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // If this is endpoint 0 then the bits have different meaning and map into + // the TX memory location. + // + if(ulEndpoint == USB_EP_0) + { + // + // Set the Serviced RxPktRdy bit to clear the RxPktRdy. + // + if(ulFlags & USB_DEV_EP0_OUT_PKTRDY) + { + HWREGB(ulBase + USB_O_CSRL0) |= USB_CSRL0_RXRDYC; + } + + // + // Set the serviced Setup End bit to clear the SetupEnd status. + // + if(ulFlags & USB_DEV_EP0_SETUP_END) + { + HWREGB(ulBase + USB_O_CSRL0) |= USB_CSRL0_SETENDC; + } + + // + // Clear the Sent Stall status flag. + // + if(ulFlags & USB_DEV_EP0_SENT_STALL) + { + HWREGB(ulBase + USB_O_CSRL0) &= ~(USB_DEV_EP0_SENT_STALL); + } + } + else + { + // + // Clear out any TX flags that were passed in. Only + // USB_DEV_TX_SENT_STALL and USB_DEV_TX_UNDERRUN should be cleared. + // + HWREGB(ulBase + USB_O_TXCSRL1 + EP_OFFSET(ulEndpoint)) &= + ~(ulFlags & (USB_DEV_TX_SENT_STALL | USB_DEV_TX_UNDERRUN)); + + // + // Clear out valid RX flags that were passed in. Only + // USB_DEV_RX_SENT_STALL, USB_DEV_RX_DATA_ERROR, and USB_DEV_RX_OVERRUN + // should be cleared. + // + HWREGB(ulBase + USB_O_RXCSRL1 + EP_OFFSET(ulEndpoint)) &= + ~((ulFlags & (USB_DEV_RX_SENT_STALL | USB_DEV_RX_DATA_ERROR | + USB_DEV_RX_OVERRUN)) >> USB_RX_EPSTATUS_SHIFT); + } +} + +//***************************************************************************** +// +//! Sets the value data toggle on an endpoint in host mode. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint specifies the endpoint to reset the data toggle. +//! \param bDataToggle specifies whether to set the state to DATA0 or DATA1. +//! \param ulFlags specifies whether to set the IN or OUT endpoint. +//! +//! This function is used to force the state of the data toggle in host mode. +//! If the value passed in the \e bDataToggle parameter is \b false, then the +//! data toggle will be set to the DATA0 state, and if it is \b true it will be +//! set to the DATA1 state. The \e ulFlags parameter can be \b USB_EP_HOST_IN +//! or \b USB_EP_HOST_OUT to access the desired portion of this endpoint. The +//! \e ulFlags parameter is ignored for endpoint zero. +//! +//! \note This function should only be called in host mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostEndpointDataToggle(unsigned long ulBase, unsigned long ulEndpoint, + tBoolean bDataToggle, unsigned long ulFlags) +{ + unsigned long ulDataToggle; + + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // The data toggle defaults to DATA0. + // + ulDataToggle = 0; + + // + // See if the data toggle should be set to DATA1. + // + if(bDataToggle) + { + // + // Select the data toggle bit based on the endpoint. + // + if(ulEndpoint == USB_EP_0) + { + ulDataToggle = USB_CSRH0_DT; + } + else if(ulFlags == USB_EP_HOST_IN) + { + ulDataToggle = USB_RXCSRH1_DT; + } + else + { + ulDataToggle = USB_TXCSRH1_DT; + } + } + + // + // Set the data toggle based on the endpoint. + // + if(ulEndpoint == USB_EP_0) + { + // + // Set the write enable and the bit value for endpoint zero. + // + HWREGB(ulBase + USB_O_CSRH0) = + ((HWREGB(ulBase + USB_O_CSRH0) & + ~(USB_CSRH0_DTWE | USB_CSRH0_DT)) | + (ulDataToggle | USB_CSRH0_DTWE)); + } + else if(ulFlags == USB_EP_HOST_IN) + { + // + // Set the Write enable and the bit value for an IN endpoint. + // + HWREGB(ulBase + USB_O_RXCSRH1 + EP_OFFSET(ulEndpoint)) = + ((HWREGB(ulBase + USB_O_RXCSRH1 + EP_OFFSET(ulEndpoint)) & + ~(USB_RXCSRH1_DTWE | USB_RXCSRH1_DT)) | + (ulDataToggle | USB_RXCSRH1_DTWE)); + } + else + { + // + // Set the Write enable and the bit value for an OUT endpoint. + // + HWREGB(ulBase + USB_O_TXCSRH1 + EP_OFFSET(ulEndpoint)) = + ((HWREGB(ulBase + USB_O_TXCSRH1 + EP_OFFSET(ulEndpoint)) & + ~(USB_TXCSRH1_DTWE | USB_TXCSRH1_DT)) | + (ulDataToggle | USB_TXCSRH1_DTWE)); + } +} + +//***************************************************************************** +// +//! Sets the Data toggle on an endpoint to zero. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint specifies the endpoint to reset the data toggle. +//! \param ulFlags specifies whether to access the IN or OUT endpoint. +//! +//! This function will cause the controller to clear the data toggle for an +//! endpoint. This call is not valid for endpoint zero and can be made with +//! host or device controllers. +//! +//! The \e ulFlags parameter should be one of \b USB_EP_HOST_OUT, +//! \b USB_EP_HOST_IN, \b USB_EP_DEV_OUT, or \b USB_EP_DEV_IN. +//! +//! \return None. +// +//***************************************************************************** +void +USBEndpointDataToggleClear(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_1) || (ulEndpoint == USB_EP_2) || + (ulEndpoint == USB_EP_3) || (ulEndpoint == USB_EP_4) || + (ulEndpoint == USB_EP_5) || (ulEndpoint == USB_EP_6) || + (ulEndpoint == USB_EP_7) || (ulEndpoint == USB_EP_8) || + (ulEndpoint == USB_EP_9) || (ulEndpoint == USB_EP_10) || + (ulEndpoint == USB_EP_11) || (ulEndpoint == USB_EP_12) || + (ulEndpoint == USB_EP_13) || (ulEndpoint == USB_EP_14) || + (ulEndpoint == USB_EP_15)); + + // + // See if the transmit or receive data toggle should be cleared. + // + if(ulFlags & (USB_EP_HOST_OUT | USB_EP_DEV_IN)) + { + HWREGB(ulBase + USB_O_TXCSRL1 + EP_OFFSET(ulEndpoint)) |= + USB_TXCSRL1_CLRDT; + } + else + { + HWREGB(ulBase + USB_O_RXCSRL1 + EP_OFFSET(ulEndpoint)) |= + USB_RXCSRL1_CLRDT; + } +} + +//***************************************************************************** +// +//! Stalls the specified endpoint in device mode. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint specifies the endpoint to stall. +//! \param ulFlags specifies whether to stall the IN or OUT endpoint. +//! +//! This function will cause to endpoint number passed in to go into a stall +//! condition. If the \e ulFlags parameter is \b USB_EP_DEV_IN then the stall +//! will be issued on the IN portion of this endpoint. If the \e ulFlags +//! parameter is \b USB_EP_DEV_OUT then the stall will be issued on the OUT +//! portion of this endpoint. +//! +//! \note This function should only be called in device mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBDevEndpointStall(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulFlags & ~(USB_EP_DEV_IN | USB_EP_DEV_OUT)) == 0) + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // Determine how to stall this endpoint. + // + if(ulEndpoint == USB_EP_0) + { + // + // Perform a stall on endpoint zero. + // + HWREGB(ulBase + USB_O_CSRL0) |= + (USB_CSRL0_STALL | USB_CSRL0_RXRDYC); + } + else if(ulFlags == USB_EP_DEV_IN) + { + // + // Perform a stall on an IN endpoint. + // + HWREGB(ulBase + USB_O_TXCSRL1 + EP_OFFSET(ulEndpoint)) |= + USB_TXCSRL1_STALL; + } + else + { + // + // Perform a stall on an OUT endpoint. + // + HWREGB(ulBase + USB_O_RXCSRL1 + EP_OFFSET(ulEndpoint)) |= + USB_RXCSRL1_STALL; + } +} + +//***************************************************************************** +// +//! Clears the stall condition on the specified endpoint in device mode. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint specifies which endpoint to remove the stall condition. +//! \param ulFlags specifies whether to remove the stall condition from the IN +//! or the OUT portion of this endpoint. +//! +//! This function will cause the endpoint number passed in to exit the stall +//! condition. If the \e ulFlags parameter is \b USB_EP_DEV_IN then the stall +//! will be cleared on the IN portion of this endpoint. If the \e ulFlags +//! parameter is \b USB_EP_DEV_OUT then the stall will be cleared on the OUT +//! portion of this endpoint. +//! +//! \note This function should only be called in device mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBDevEndpointStallClear(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + ASSERT((ulFlags & ~(USB_EP_DEV_IN | USB_EP_DEV_OUT)) == 0) + + // + // Determine how to clear the stall on this endpoint. + // + if(ulEndpoint == USB_EP_0) + { + // + // Clear the stall on endpoint zero. + // + HWREGB(ulBase + USB_O_CSRL0) &= ~USB_CSRL0_STALLED; + } + else if(ulFlags == USB_EP_DEV_IN) + { + // + // Clear the stall on an IN endpoint. + // + HWREGB(ulBase + USB_O_TXCSRL1 + EP_OFFSET(ulEndpoint)) &= + ~(USB_TXCSRL1_STALL | USB_TXCSRL1_STALLED); + + // + // Reset the data toggle. + // + HWREGB(ulBase + USB_O_TXCSRL1 + EP_OFFSET(ulEndpoint)) |= + USB_TXCSRL1_CLRDT; + } + else + { + // + // Clear the stall on an OUT endpoint. + // + HWREGB(ulBase + USB_O_RXCSRL1 + EP_OFFSET(ulEndpoint)) &= + ~(USB_RXCSRL1_STALL | USB_RXCSRL1_STALLED); + + // + // Reset the data toggle. + // + HWREGB(ulBase + USB_O_RXCSRL1 + EP_OFFSET(ulEndpoint)) |= + USB_RXCSRL1_CLRDT; + } +} + +//***************************************************************************** +// +//! Connects the USB controller to the bus in device mode. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function will cause the soft connect feature of the USB controller to +//! be enabled. Call USBDisconnect() to remove the USB device from the bus. +//! +//! \note This function should only be called in device mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBDevConnect(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Enable connection to the USB bus. + // + HWREGB(ulBase + USB_O_POWER) |= USB_POWER_SOFTCONN; +} + +//***************************************************************************** +// +//! Removes the USB controller from the bus in device mode. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function will cause the soft connect feature of the USB controller to +//! remove the device from the USB bus. A call to USBDevConnect() is needed to +//! reconnect to the bus. +//! +//! \note This function should only be called in device mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBDevDisconnect(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Disable connection to the USB bus. + // + HWREGB(ulBase + USB_O_POWER) &= (~USB_POWER_SOFTCONN); +} + +//***************************************************************************** +// +//! Sets the address in device mode. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulAddress is the address to use for a device. +//! +//! This function will set the device address on the USB bus. This address was +//! likely received via a SET ADDRESS command from the host controller. +//! +//! \note This function should only be called in device mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBDevAddrSet(unsigned long ulBase, unsigned long ulAddress) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Set the function address in the correct location. + // + HWREGB(ulBase + USB_O_FADDR) = (unsigned char)ulAddress; +} + +//***************************************************************************** +// +//! Returns the current device address in device mode. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function will return the current device address. This address was set +//! by a call to USBDevAddrSet(). +//! +//! \note This function should only be called in device mode. +//! +//! \return The current device address. +// +//***************************************************************************** +unsigned long +USBDevAddrGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Return the function address. + // + return(HWREGB(ulBase + USB_O_FADDR)); +} + +//***************************************************************************** +// +//! Sets the base configuration for a host endpoint. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param ulMaxPayload is the maximum payload for this endpoint. +//! \param ulNAKPollInterval is the either the NAK timeout limit or the polling +//! interval depending on the type of endpoint. +//! \param ulTargetEndpoint is the endpoint that the host endpoint is +//! targeting. +//! \param ulFlags are used to configure other endpoint settings. +//! +//! This function will set the basic configuration for the transmit or receive +//! portion of an endpoint in host mode. The \e ulFlags parameter determines +//! some of the configuration while the other parameters provide the rest. The +//! \e ulFlags parameter determines whether this is an IN endpoint +//! (USB_EP_HOST_IN or USB_EP_DEV_IN) or an OUT endpoint (USB_EP_HOST_OUT or +//! USB_EP_DEV_OUT), whether this is a Full speed endpoint (USB_EP_SPEED_FULL) +//! or a Low speed endpoint (USB_EP_SPEED_LOW). +//! +//! The \b USB_EP_MODE_ flags control the type of the endpoint. +//! - \b USB_EP_MODE_CTRL is a control endpoint. +//! - \b USB_EP_MODE_ISOC is an isochronous endpoint. +//! - \b USB_EP_MODE_BULK is a bulk endpoint. +//! - \b USB_EP_MODE_INT is an interrupt endpoint. +//! +//! The \e ulNAKPollInterval parameter has different meanings based on the +//! \b USB_EP_MODE value and whether or not this call is being made for +//! endpoint zero or another endpoint. For endpoint zero or any Bulk +//! endpoints, this value always indicates the number of frames to allow a +//! device to NAK before considering it a timeout. If this endpoint is an +//! isochronous or interrupt endpoint, this value is the polling interval for +//! this endpoint. +//! +//! For interrupt endpoints the polling interval is simply the number of +//! frames between polling an interrupt endpoint. For isochronous endpoints +//! this value represents a polling interval of 2 ^ (\e ulNAKPollInterval - 1) +//! frames. When used as a NAK timeout, the \e ulNAKPollInterval value +//! specifies 2 ^ (\e ulNAKPollInterval - 1) frames before issuing a time out. +//! There are two special time out values that can be specified when setting +//! the \e ulNAKPollInterval value. The first is \b MAX_NAK_LIMIT which is the +//! maximum value that can be passed in this variable. The other is +//! \b DISABLE_NAK_LIMIT which indicates that there should be no limit on the +//! number of NAKs. +//! +//! The \b USB_EP_DMA_MODE_ flags enables the type of DMA used to access the +//! endpoint's data FIFOs. The choice of the DMA mode depends on how the DMA +//! controller is configured and how it is being used. See the ``Using USB +//! with the uDMA Controller'' section for more information on DMA +//! configuration. +//! +//! When configuring the OUT portion of an endpoint, the \b USB_EP_AUTO_SET bit +//! is specified to cause the transmission of data on the USB bus to start +//! as soon as the number of bytes specified by \e ulMaxPayload have been +//! written into the OUT FIFO for this endpoint. +//! +//! When configuring the IN portion of an endpoint, the \b USB_EP_AUTO_REQUEST +//! bit can be specified to trigger the request for more data once the FIFO has +//! been drained enough to fit \e ulMaxPayload bytes. The \b USB_EP_AUTO_CLEAR +//! bit can be used to clear the data packet ready flag automatically once the +//! data has been read from the FIFO. If this is not used, this flag must be +//! manually cleared via a call to USBDevEndpointStatusClear() or +//! USBHostEndpointStatusClear(). +//! +//! \note This function should only be called in host mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostEndpointConfig(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulMaxPayload, + unsigned long ulNAKPollInterval, + unsigned long ulTargetEndpoint, unsigned long ulFlags) +{ + unsigned long ulRegister; + + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + ASSERT(ulNAKPollInterval <= MAX_NAK_LIMIT); + + // + // Endpoint zero is configured differently than the other endpoints, so see + // if this is endpoint zero. + // + if(ulEndpoint == USB_EP_0) + { + // + // Set the NAK timeout. + // + HWREGB(ulBase + USB_O_NAKLMT) = ulNAKPollInterval; + + // + // Set the transfer type information. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_TYPE0) = + ((ulFlags & USB_EP_SPEED_FULL) ? USB_TYPE0_SPEED_FULL : + USB_TYPE0_SPEED_LOW); + } + else + { + // + // Start with the target endpoint. + // + ulRegister = ulTargetEndpoint; + + // + // Set the speed for the device using this endpoint. + // + if(ulFlags & USB_EP_SPEED_FULL) + { + ulRegister |= USB_TXTYPE1_SPEED_FULL; + } + else + { + ulRegister |= USB_TXTYPE1_SPEED_LOW; + } + + // + // Set the protocol for the device using this endpoint. + // + switch(ulFlags & USB_EP_MODE_MASK) + { + // + // The bulk protocol is being used. + // + case USB_EP_MODE_BULK: + { + ulRegister |= USB_TXTYPE1_PROTO_BULK; + break; + } + + // + // The isochronous protocol is being used. + // + case USB_EP_MODE_ISOC: + { + ulRegister |= USB_TXTYPE1_PROTO_ISOC; + break; + } + + // + // The interrupt protocol is being used. + // + case USB_EP_MODE_INT: + { + ulRegister |= USB_TXTYPE1_PROTO_INT; + break; + } + + // + // The control protocol is being used. + // + case USB_EP_MODE_CTRL: + { + ulRegister |= USB_TXTYPE1_PROTO_CTRL; + break; + } + } + + // + // See if the transmit or receive endpoint is being configured. + // + if(ulFlags & USB_EP_HOST_OUT) + { + // + // Set the transfer type information. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_TXTYPE1) = + ulRegister; + + // + // Set the NAK timeout or polling interval. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_TXINTERVAL1) = + ulNAKPollInterval; + + // + // Set the Maximum Payload per transaction. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_TXMAXP1) = + ulMaxPayload; + + // + // Set the transmit control value to zero. + // + ulRegister = 0; + + // + // Allow auto setting of TxPktRdy when max packet size has been + // loaded into the FIFO. + // + if(ulFlags & USB_EP_AUTO_SET) + { + ulRegister |= USB_TXCSRH1_AUTOSET; + } + + // + // Configure the DMA Mode. + // + if(ulFlags & USB_EP_DMA_MODE_1) + { + ulRegister |= USB_TXCSRH1_DMAEN | USB_TXCSRH1_DMAMOD; + } + else if(ulFlags & USB_EP_DMA_MODE_0) + { + ulRegister |= USB_TXCSRH1_DMAEN; + } + + // + // Write out the transmit control value. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_TXCSRH1) = + (unsigned char)ulRegister; + } + else + { + // + // Set the transfer type information. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_RXTYPE1) = + ulRegister; + + // + // Set the NAK timeout or polling interval. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_RXINTERVAL1) = + ulNAKPollInterval; + + // + // Set the receive control value to zero. + // + ulRegister = 0; + + // + // Allow auto clearing of RxPktRdy when packet of size max packet + // has been unloaded from the FIFO. + // + if(ulFlags & USB_EP_AUTO_CLEAR) + { + ulRegister |= USB_RXCSRH1_AUTOCL; + } + + // + // Configure the DMA Mode. + // + if(ulFlags & USB_EP_DMA_MODE_1) + { + ulRegister |= USB_RXCSRH1_DMAEN | USB_RXCSRH1_DMAMOD; + } + else if(ulFlags & USB_EP_DMA_MODE_0) + { + ulRegister |= USB_RXCSRH1_DMAEN; + } + + // + // Write out the receive control value. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_RXCSRH1) = + (unsigned char)ulRegister; + } + } +} + +//***************************************************************************** +// +//! Sets the configuration for an endpoint. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param ulMaxPacketSize is the maximum packet size for this endpoint. +//! \param ulFlags are used to configure other endpoint settings. +//! +//! This function will set the basic configuration for an endpoint in device +//! mode. Endpoint zero does not have a dynamic configuration, so this +//! function should not be called for endpoint zero. The \e ulFlags parameter +//! determines some of the configuration while the other parameters provide the +//! rest. +//! +//! The \b USB_EP_MODE_ flags define what the type is for the given endpoint. +//! +//! - \b USB_EP_MODE_CTRL is a control endpoint. +//! - \b USB_EP_MODE_ISOC is an isochronous endpoint. +//! - \b USB_EP_MODE_BULK is a bulk endpoint. +//! - \b USB_EP_MODE_INT is an interrupt endpoint. +//! +//! The \b USB_EP_DMA_MODE_ flags determines the type of DMA access to the +//! endpoint data FIFOs. The choice of the DMA mode depends on how the DMA +//! controller is configured and how it is being used. See the ``Using USB +//! with the uDMA Controller'' section for more information on DMA +//! configuration. +//! +//! When configuring an IN endpoint, the \b USB_EP_AUTO_SET bit can be +//! specified to cause the automatic transmission of data on the USB bus as +//! soon as \e ulMaxPacketSize bytes of data are written into the FIFO for +//! this endpoint. This is commonly used with DMA as no interaction is +//! required to start the transmission of data. +//! +//! When configuring an OUT endpoint, the \b USB_EP_AUTO_REQUEST bit is +//! specified to trigger the request for more data once the FIFO has been +//! drained enough to receive \e ulMaxPacketSize more bytes of data. Also for +//! OUT endpoints, the \b USB_EP_AUTO_CLEAR bit can be used to clear the data +//! packet ready flag automatically once the data has been read from the FIFO. +//! If this is not used, this flag must be manually cleared via a call to +//! USBDevEndpointStatusClear(). Both of these settings can be used to remove +//! the need for extra calls when using the controller in DMA mode. +//! +//! \note This function should only be called in device mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBDevEndpointConfigSet(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulMaxPacketSize, unsigned long ulFlags) +{ + unsigned long ulRegister; + + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_1) || (ulEndpoint == USB_EP_2) || + (ulEndpoint == USB_EP_3) || (ulEndpoint == USB_EP_4) || + (ulEndpoint == USB_EP_5) || (ulEndpoint == USB_EP_6) || + (ulEndpoint == USB_EP_7) || (ulEndpoint == USB_EP_8) || + (ulEndpoint == USB_EP_9) || (ulEndpoint == USB_EP_10) || + (ulEndpoint == USB_EP_11) || (ulEndpoint == USB_EP_12) || + (ulEndpoint == USB_EP_13) || (ulEndpoint == USB_EP_14) || + (ulEndpoint == USB_EP_15)); + + // + // Determine if a transmit or receive endpoint is being configured. + // + if(ulFlags & USB_EP_DEV_IN) + { + // + // Set the maximum packet size. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_TXMAXP1) = + ulMaxPacketSize; + + // + // The transmit control value is zero unless options are enabled. + // + ulRegister = 0; + + // + // Allow auto setting of TxPktRdy when max packet size has been loaded + // into the FIFO. + // + if(ulFlags & USB_EP_AUTO_SET) + { + ulRegister |= USB_TXCSRH1_AUTOSET; + } + + // + // Configure the DMA mode. + // + if(ulFlags & USB_EP_DMA_MODE_1) + { + ulRegister |= USB_TXCSRH1_DMAEN | USB_TXCSRH1_DMAMOD; + } + else if(ulFlags & USB_EP_DMA_MODE_0) + { + ulRegister |= USB_TXCSRH1_DMAEN; + } + + // + // Enable isochronous mode if requested. + // + if((ulFlags & USB_EP_MODE_MASK) == USB_EP_MODE_ISOC) + { + ulRegister |= USB_TXCSRH1_ISO; + } + + // + // Write the transmit control value. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_TXCSRH1) = + (unsigned char)ulRegister; + + // + // Reset the Data toggle to zero. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_TXCSRL1) = + USB_TXCSRL1_CLRDT; + } + else + { + // + // Set the MaxPacketSize. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_RXMAXP1) = + ulMaxPacketSize; + + // + // The receive control value is zero unless options are enabled. + // + ulRegister = 0; + + // + // Allow auto clearing of RxPktRdy when packet of size max packet + // has been unloaded from the FIFO. + // + if(ulFlags & USB_EP_AUTO_CLEAR) + { + ulRegister = USB_RXCSRH1_AUTOCL; + } + + // + // Configure the DMA mode. + // + if(ulFlags & USB_EP_DMA_MODE_1) + { + ulRegister |= USB_RXCSRH1_DMAEN | USB_RXCSRH1_DMAMOD; + } + else if(ulFlags & USB_EP_DMA_MODE_0) + { + ulRegister |= USB_RXCSRH1_DMAEN; + } + + // + // Enable isochronous mode if requested. + // + if((ulFlags & USB_EP_MODE_MASK) == USB_EP_MODE_ISOC) + { + ulRegister |= USB_RXCSRH1_ISO; + } + + // + // Write the receive control value. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_RXCSRH1) = + (unsigned char)ulRegister; + + // + // Reset the Data toggle to zero. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_RXCSRL1) = + USB_RXCSRL1_CLRDT; + } +} + +//***************************************************************************** +// +//! Gets the current configuration for an endpoint. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param pulMaxPacketSize is a pointer which will be written with the +//! maximum packet size for this endpoint. +//! \param pulFlags is a pointer which will be written with the current +//! endpoint settings. On entry to the function, this pointer must contain +//! either \b USB_EP_DEV_IN or \b USB_EP_DEV_OUT to indicate whether the IN or +//! OUT endpoint is to be queried. +//! +//! This function will return the basic configuration for an endpoint in device +//! mode. The values returned in \e *pulMaxPacketSize and \e *pulFlags are +//! equivalent to the \e ulMaxPacketSize and \e ulFlags previously passed to +//! USBDevEndpointConfigSet() for this endpoint. +//! +//! \note This function should only be called in device mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBDevEndpointConfigGet(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long *pulMaxPacketSize, + unsigned long *pulFlags) +{ + unsigned long ulRegister; + + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT(pulMaxPacketSize && pulFlags); + ASSERT((ulEndpoint == USB_EP_1) || (ulEndpoint == USB_EP_2) || + (ulEndpoint == USB_EP_3) || (ulEndpoint == USB_EP_4) || + (ulEndpoint == USB_EP_5) || (ulEndpoint == USB_EP_6) || + (ulEndpoint == USB_EP_7) || (ulEndpoint == USB_EP_8) || + (ulEndpoint == USB_EP_9) || (ulEndpoint == USB_EP_10) || + (ulEndpoint == USB_EP_11) || (ulEndpoint == USB_EP_12) || + (ulEndpoint == USB_EP_13) || (ulEndpoint == USB_EP_14) || + (ulEndpoint == USB_EP_15)); + + // + // Determine if a transmit or receive endpoint is being queried. + // + if(*pulFlags & USB_EP_DEV_IN) + { + // + // Clear the flags other than the direction bit. + // + *pulFlags = USB_EP_DEV_IN; + + // + // Get the maximum packet size. + // + *pulMaxPacketSize = (unsigned long)HWREGB(ulBase + + EP_OFFSET(ulEndpoint) + + USB_O_TXMAXP1); + + // + // Get the current transmit control register value. + // + ulRegister = (unsigned long)HWREGB(ulBase + EP_OFFSET(ulEndpoint) + + USB_O_TXCSRH1); + + // + // Are we allowing auto setting of TxPktRdy when max packet size has + // been loaded into the FIFO? + // + if(ulRegister & USB_TXCSRH1_AUTOSET) + { + *pulFlags |= USB_EP_AUTO_SET; + } + + // + // Get the DMA mode. + // + if(ulRegister & USB_TXCSRH1_DMAEN) + { + if(ulRegister & USB_TXCSRH1_DMAMOD) + { + *pulFlags |= USB_EP_DMA_MODE_1; + } + else + { + *pulFlags |= USB_EP_DMA_MODE_0; + } + } + + // + // Are we in isochronous mode? + // + if(ulRegister & USB_TXCSRH1_ISO) + { + *pulFlags |= USB_EP_MODE_ISOC; + } + else + { + // + // The hardware doesn't differentiate between bulk, interrupt + // and control mode for the endpoint so we just set something + // that isn't isochronous. This ensures that anyone modifying + // the returned flags in preparation for a call to + // USBDevEndpointConfigSet will not see an unexpected mode change. + // If they decode the returned mode, however, they may be in for + // a surprise. + // + *pulFlags |= USB_EP_MODE_BULK; + } + } + else + { + // + // Clear the flags other than the direction bit. + // + *pulFlags = USB_EP_DEV_OUT; + + // + // Get the MaxPacketSize. + // + *pulMaxPacketSize = (unsigned long)HWREGB(ulBase + + EP_OFFSET(ulEndpoint) + + USB_O_RXMAXP1); + + // + // Get the current receive control register value. + // + ulRegister = (unsigned long)HWREGB(ulBase + EP_OFFSET(ulEndpoint) + + USB_O_RXCSRH1); + + // + // Are we allowing auto clearing of RxPktRdy when packet of size max + // packet has been unloaded from the FIFO? + // + if(ulRegister & USB_RXCSRH1_AUTOCL) + { + *pulFlags |= USB_EP_AUTO_CLEAR; + } + + // + // Get the DMA mode. + // + if(ulRegister & USB_RXCSRH1_DMAEN) + { + if(ulRegister & USB_RXCSRH1_DMAMOD) + { + *pulFlags |= USB_EP_DMA_MODE_1; + } + else + { + *pulFlags |= USB_EP_DMA_MODE_0; + } + } + + // + // Are we in isochronous mode? + // + if(ulRegister & USB_RXCSRH1_ISO) + { + *pulFlags |= USB_EP_MODE_ISOC; + } + else + { + // + // The hardware doesn't differentiate between bulk, interrupt + // and control mode for the endpoint so we just set something + // that isn't isochronous. This ensures that anyone modifying + // the returned flags in preparation for a call to + // USBDevEndpointConfigSet will not see an unexpected mode change. + // If they decode the returned mode, however, they may be in for + // a surprise. + // + *pulFlags |= USB_EP_MODE_BULK; + } + } +} + +//***************************************************************************** +// +//! Sets the FIFO configuration for an endpoint. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param ulFIFOAddress is the starting address for the FIFO. +//! \param ulFIFOSize is the size of the FIFO in bytes. +//! \param ulFlags specifies what information to set in the FIFO configuration. +//! +//! This function will set the starting FIFO RAM address and size of the FIFO +//! for a given endpoint. Endpoint zero does not have a dynamically +//! configurable FIFO so this function should not be called for endpoint zero. +//! The \e ulFIFOSize parameter should be one of the values in the +//! \b USB_FIFO_SZ_ values. If the endpoint is going to use double buffering +//! it should use the values with the \b _DB at the end of the value. For +//! example, use \b USB_FIFO_SZ_16_DB to configure an endpoint to have a 16 +//! byte double buffered FIFO. If a double buffered FIFO is used, then the +//! actual size of the FIFO will be twice the size indicated by the +//! \e ulFIFOSize parameter. This means that the \b USB_FIFO_SZ_16_DB value +//! will use 32 bytes of the USB controller's FIFO memory. +//! +//! The \e ulFIFOAddress value should be a multiple of 8 bytes and directly +//! indicates the starting address in the USB controller's FIFO RAM. For +//! example, a value of 64 indicates that the FIFO should start 64 bytes into +//! the USB controller's FIFO memory. The \e ulFlags value specifies whether +//! the endpoint's OUT or IN FIFO should be configured. If in host mode, use +//! \b USB_EP_HOST_OUT or \b USB_EP_HOST_IN, and if in device mode use +//! \b USB_EP_DEV_OUT or \b USB_EP_DEV_IN. +//! +//! \return None. +// +//***************************************************************************** +void +USBFIFOConfigSet(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulFIFOAddress, unsigned long ulFIFOSize, + unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_1) || (ulEndpoint == USB_EP_2) || + (ulEndpoint == USB_EP_3) || (ulEndpoint == USB_EP_4) || + (ulEndpoint == USB_EP_5) || (ulEndpoint == USB_EP_6) || + (ulEndpoint == USB_EP_7) || (ulEndpoint == USB_EP_8) || + (ulEndpoint == USB_EP_9) || (ulEndpoint == USB_EP_10) || + (ulEndpoint == USB_EP_11) || (ulEndpoint == USB_EP_12) || + (ulEndpoint == USB_EP_13) || (ulEndpoint == USB_EP_14) || + (ulEndpoint == USB_EP_15)); + + // + // See if the transmit or receive FIFO is being configured. + // + if(ulFlags & (USB_EP_HOST_OUT | USB_EP_DEV_IN)) + { + // + // Set the transmit FIFO location and size for this endpoint. + // + USBIndexWrite(ulBase, ulEndpoint >> 4, USB_O_TXFIFOSZ, ulFIFOSize, 1); + USBIndexWrite(ulBase, ulEndpoint >> 4, USB_O_TXFIFOADD, + ulFIFOAddress >> 3, 2); + } + else + { + // + // Set the receive FIFO location and size for this endpoint. + // + USBIndexWrite(ulBase, ulEndpoint >> 4, USB_O_RXFIFOSZ, ulFIFOSize, 1); + USBIndexWrite(ulBase, ulEndpoint >> 4, USB_O_RXFIFOADD, + ulFIFOAddress >> 3, 2); + } +} + +//***************************************************************************** +// +//! Returns the FIFO configuration for an endpoint. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param pulFIFOAddress is the starting address for the FIFO. +//! \param pulFIFOSize is the size of the FIFO in bytes. +//! \param ulFlags specifies what information to retrieve from the FIFO +//! configuration. +//! +//! This function will return the starting address and size of the FIFO for a +//! given endpoint. Endpoint zero does not have a dynamically configurable +//! FIFO so this function should not be called for endpoint zero. The +//! \e ulFlags parameter specifies whether the endpoint's OUT or IN FIFO should +//! be read. If in host mode, the \e ulFlags parameter should be +//! \b USB_EP_HOST_OUT or \b USB_EP_HOST_IN, and if in device mode the +//! \e ulFlags parameter should be either \b USB_EP_DEV_OUT or +//! \b USB_EP_DEV_IN. +//! +//! \return None. +// +//***************************************************************************** +void +USBFIFOConfigGet(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long *pulFIFOAddress, unsigned long *pulFIFOSize, + unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_1) || (ulEndpoint == USB_EP_2) || + (ulEndpoint == USB_EP_3) || (ulEndpoint == USB_EP_4) || + (ulEndpoint == USB_EP_5) || (ulEndpoint == USB_EP_6) || + (ulEndpoint == USB_EP_7) || (ulEndpoint == USB_EP_8) || + (ulEndpoint == USB_EP_9) || (ulEndpoint == USB_EP_10) || + (ulEndpoint == USB_EP_11) || (ulEndpoint == USB_EP_12) || + (ulEndpoint == USB_EP_13) || (ulEndpoint == USB_EP_14) || + (ulEndpoint == USB_EP_15)); + + // + // See if the transmit or receive FIFO is being configured. + // + if(ulFlags & (USB_EP_HOST_OUT | USB_EP_DEV_IN)) + { + // + // Get the transmit FIFO location and size for this endpoint. + // + *pulFIFOAddress = (USBIndexRead(ulBase, ulEndpoint >> 4, + (unsigned long)USB_O_TXFIFOADD, + 2)) << 3; + *pulFIFOSize = USBIndexRead(ulBase, ulEndpoint >> 4, + (unsigned long)USB_O_TXFIFOSZ, 1); + + } + else + { + // + // Get the receive FIFO location and size for this endpoint. + // + *pulFIFOAddress = (USBIndexRead(ulBase, ulEndpoint >> 4, + (unsigned long)USB_O_RXFIFOADD, + 2)) << 3; + *pulFIFOSize = USBIndexRead(ulBase, ulEndpoint >> 4, + (unsigned long)USB_O_RXFIFOSZ, 1); + } +} + +//***************************************************************************** +// +//! Enable DMA on a given endpoint. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param ulFlags specifies which direction and what mode to use when enabling +//! DMA. +//! +//! This function will enable DMA on a given endpoint and set the mode according +//! to the values in the \e ulFlags parameter. The \e ulFlags parameter should +//! have \b USB_EP_DEV_IN or \b USB_EP_DEV_OUT set. +//! +//! \return None. +// +//***************************************************************************** +void +USBEndpointDMAEnable(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulFlags) +{ + // + // See if the transmit DMA is being enabled. + // + if(ulFlags & USB_EP_DEV_IN) + { + // + // Enable DMA on the transmit end point. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_TXCSRH1) |= + USB_TXCSRH1_DMAEN; + } + else + { + // + // Enable DMA on the receive end point. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_RXCSRH1) |= + USB_RXCSRH1_DMAEN; + } +} + +//***************************************************************************** +// +//! Disable DMA on a given endpoint. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param ulFlags specifies which direction to disable. +//! +//! This function will disable DMA on a given end point to allow non-DMA +//! USB transactions to generate interrupts normally. The ulFlags should be +//! \b USB_EP_DEV_IN or \b USB_EP_DEV_OUT all other bits are ignored. +//! +//! \return None. +// +//***************************************************************************** +void +USBEndpointDMADisable(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulFlags) +{ + // + // If this was a request to disable DMA on the IN portion of the end point + // then handle it. + // + if(ulFlags & USB_EP_DEV_IN) + { + // + // Just disable DMA leave the mode setting. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_TXCSRH1) &= + ~USB_TXCSRH1_DMAEN; + } + else + { + // + // Just disable DMA leave the mode setting. + // + HWREGB(ulBase + EP_OFFSET(ulEndpoint) + USB_O_RXCSRH1) &= + ~USB_RXCSRH1_DMAEN; + } +} + +//***************************************************************************** +// +//! Determine the number of bytes of data available in a given endpoint's FIFO. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! +//! This function will return the number of bytes of data currently available +//! in the FIFO for the given receive (OUT) endpoint. It may be used prior to +//! calling USBEndpointDataGet() to determine the size of buffer required to +//! hold the newly-received packet. +//! +//! \return This call will return the number of bytes available in a given +//! endpoint FIFO. +// +//***************************************************************************** +unsigned long +USBEndpointDataAvail(unsigned long ulBase, unsigned long ulEndpoint) +{ + unsigned long ulRegister; + + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // Get the address of the receive status register to use, based on the + // endpoint. + // + if(ulEndpoint == USB_EP_0) + { + ulRegister = USB_O_CSRL0; + } + else + { + ulRegister = USB_O_RXCSRL1 + EP_OFFSET(ulEndpoint); + } + + // + // Is there a packet ready in the FIFO? + // + if((HWREGH(ulBase + ulRegister) & USB_CSRL0_RXRDY) == 0) + { + return(0); + } + + // + // Return the byte count in the FIFO. + // + return(HWREGH(ulBase + USB_O_COUNT0 + ulEndpoint)); +} + +//***************************************************************************** +// +//! Retrieves data from the given endpoint's FIFO. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param pucData is a pointer to the data area used to return the data from +//! the FIFO. +//! \param pulSize is initially the size of the buffer passed into this call +//! via the \e pucData parameter. It will be set to the amount of data +//! returned in the buffer. +//! +//! This function will return the data from the FIFO for the given endpoint. +//! The \e pulSize parameter should indicate the size of the buffer passed in +//! the \e pulData parameter. The data in the \e pulSize parameter will be +//! changed to match the amount of data returned in the \e pucData parameter. +//! If a zero byte packet was received this call will not return a error but +//! will instead just return a zero in the \e pulSize parameter. The only +//! error case occurs when there is no data packet available. +//! +//! \return This call will return 0, or -1 if no packet was received. +// +//***************************************************************************** +long +USBEndpointDataGet(unsigned long ulBase, unsigned long ulEndpoint, + unsigned char *pucData, unsigned long *pulSize) +{ + unsigned long ulRegister, ulByteCount, ulFIFO; + + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // Get the address of the receive status register to use, based on the + // endpoint. + // + if(ulEndpoint == USB_EP_0) + { + ulRegister = USB_O_CSRL0; + } + else + { + ulRegister = USB_O_RXCSRL1 + EP_OFFSET(ulEndpoint); + } + + // + // Don't allow reading of data if the RxPktRdy bit is not set. + // + if((HWREGH(ulBase + ulRegister) & USB_CSRL0_RXRDY) == 0) + { + // + // Can't read the data because none is available. + // + *pulSize = 0; + + // + // Return a failure since there is no data to read. + // + return(-1); + } + + // + // Get the byte count in the FIFO. + // + ulByteCount = HWREGH(ulBase + USB_O_COUNT0 + ulEndpoint); + + // + // Determine how many bytes we will actually copy. + // + ulByteCount = (ulByteCount < *pulSize) ? ulByteCount : *pulSize; + + // + // Return the number of bytes we are going to read. + // + *pulSize = ulByteCount; + + // + // Calculate the FIFO address. + // + ulFIFO = ulBase + USB_O_FIFO0 + (ulEndpoint >> 2); + + // + // Read the data out of the FIFO. + // + for(; ulByteCount > 0; ulByteCount--) + { + // + // Read a byte at a time from the FIFO. + // + *pucData++ = HWREGB(ulFIFO); + } + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Acknowledge that data was read from the given endpoint's FIFO in device +//! mode. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param bIsLastPacket indicates if this is the last packet. +//! +//! This function acknowledges that the data was read from the endpoint's FIFO. +//! The \e bIsLastPacket parameter is set to a \b true value if this is the +//! last in a series of data packets on endpoint zero. The \e bIsLastPacket +//! parameter is not used for endpoints other than endpoint zero. This call +//! can be used if processing is required between reading the data and +//! acknowledging that the data has been read. +//! +//! \note This function should only be called in device mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBDevEndpointDataAck(unsigned long ulBase, unsigned long ulEndpoint, + tBoolean bIsLastPacket) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // Determine which endpoint is being acked. + // + if(ulEndpoint == USB_EP_0) + { + // + // Clear RxPktRdy, and optionally DataEnd, on endpoint zero. + // + HWREGB(ulBase + USB_O_CSRL0) = + USB_CSRL0_RXRDYC | (bIsLastPacket ? USB_CSRL0_DATAEND : 0); + } + else + { + // + // Clear RxPktRdy on all other endpoints. + // + HWREGB(ulBase + USB_O_RXCSRL1 + EP_OFFSET(ulEndpoint)) &= + ~(USB_RXCSRL1_RXRDY); + } +} + +//***************************************************************************** +// +//! Acknowledge that data was read from the given endpoint's FIFO in host +//! mode. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! +//! This function acknowledges that the data was read from the endpoint's FIFO. +//! This call is used if processing is required between reading the data and +//! acknowledging that the data has been read. +//! +//! \note This function should only be called in host mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostEndpointDataAck(unsigned long ulBase, unsigned long ulEndpoint) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // Clear RxPktRdy. + // + if(ulEndpoint == USB_EP_0) + { + HWREGB(ulBase + USB_O_CSRL0) &= ~USB_CSRL0_RXRDY; + } + else + { + HWREGB(ulBase + USB_O_RXCSRL1 + EP_OFFSET(ulEndpoint)) &= + ~(USB_RXCSRL1_RXRDY); + } +} + +//***************************************************************************** +// +//! Puts data into the given endpoint's FIFO. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param pucData is a pointer to the data area used as the source for the +//! data to put into the FIFO. +//! \param ulSize is the amount of data to put into the FIFO. +//! +//! This function will put the data from the \e pucData parameter into the FIFO +//! for this endpoint. If a packet is already pending for transmission then +//! this call will not put any of the data into the FIFO and will return -1. +//! Care should be taken to not write more data than can fit into the FIFO +//! allocated by the call to USBFIFOConfig(). +//! +//! \return This call will return 0 on success, or -1 to indicate that the FIFO +//! is in use and cannot be written. +// +//***************************************************************************** +long +USBEndpointDataPut(unsigned long ulBase, unsigned long ulEndpoint, + unsigned char *pucData, unsigned long ulSize) +{ + unsigned long ulFIFO; + unsigned char ucTxPktRdy; + + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // Get the bit position of TxPktRdy based on the endpoint. + // + if(ulEndpoint == USB_EP_0) + { + ucTxPktRdy = USB_CSRL0_TXRDY; + } + else + { + ucTxPktRdy = USB_TXCSRL1_TXRDY; + } + + // + // Don't allow transmit of data if the TxPktRdy bit is already set. + // + if(HWREGB(ulBase + USB_O_CSRL0 + ulEndpoint) & ucTxPktRdy) + { + return(-1); + } + + // + // Calculate the FIFO address. + // + ulFIFO = ulBase + USB_O_FIFO0 + (ulEndpoint >> 2); + + // + // Write the data to the FIFO. + // + for(; ulSize > 0; ulSize--) + { + HWREGB(ulFIFO) = *pucData++; + } + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Starts the transfer of data from an endpoint's FIFO. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param ulTransType is set to indicate what type of data is being sent. +//! +//! This function will start the transfer of data from the FIFO for a given +//! endpoint. This is necessary if the \b USB_EP_AUTO_SET bit was not enabled +//! for the endpoint. Setting the \e ulTransType parameter will allow the +//! appropriate signaling on the USB bus for the type of transaction being +//! requested. The \e ulTransType parameter should be one of the following: +//! +//! - USB_TRANS_OUT for OUT transaction on any endpoint in host mode. +//! - USB_TRANS_IN for IN transaction on any endpoint in device mode. +//! - USB_TRANS_IN_LAST for the last IN transactions on endpoint zero in a +//! sequence of IN transactions. +//! - USB_TRANS_SETUP for setup transactions on endpoint zero. +//! - USB_TRANS_STATUS for status results on endpoint zero. +//! +//! \return This call will return 0 on success, or -1 if a transmission is +//! already in progress. +// +//***************************************************************************** +long +USBEndpointDataSend(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulTransType) +{ + unsigned long ulTxPktRdy; + + // + // CHeck the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // Get the bit position of TxPktRdy based on the endpoint. + // + if(ulEndpoint == USB_EP_0) + { + ulTxPktRdy = ulTransType & 0xff; + } + else + { + ulTxPktRdy = (ulTransType >> 8) & 0xff; + } + + // + // Don't allow transmit of data if the TxPktRdy bit is already set. + // + if(HWREGB(ulBase + USB_O_CSRL0 + ulEndpoint) & USB_CSRL0_TXRDY) + { + return(-1); + } + + // + // Set TxPktRdy in order to send the data. + // + HWREGB(ulBase + USB_O_CSRL0 + ulEndpoint) = ulTxPktRdy; + + // + // Success. + // + return(0); +} + +//***************************************************************************** +// +//! Forces a flush of an endpoint's FIFO. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param ulFlags specifies if the IN or OUT endpoint should be accessed. +//! +//! This function will force the controller to flush out the data in the FIFO. +//! The function can be called with either host or device controllers and +//! requires the \e ulFlags parameter be one of \b USB_EP_HOST_OUT, +//! \b USB_EP_HOST_IN, \b USB_EP_DEV_OUT, or \b USB_EP_DEV_IN. +//! +//! \return None. +// +//***************************************************************************** +void +USBFIFOFlush(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // Endpoint zero has a different register set for FIFO flushing. + // + if(ulEndpoint == USB_EP_0) + { + // + // Nothing in the FIFO if neither of these bits are set. + // + if((HWREGB(ulBase + USB_O_CSRL0) & + (USB_CSRL0_RXRDY | USB_CSRL0_TXRDY)) != 0) + { + // + // Hit the Flush FIFO bit. + // + HWREGB(ulBase + USB_O_CSRH0) = USB_CSRH0_FLUSH; + } + } + else + { + // + // Only reset the IN or OUT FIFO. + // + if(ulFlags & (USB_EP_HOST_OUT | USB_EP_DEV_IN)) + { + // + // Make sure the FIFO is not empty. + // + if(HWREGB(ulBase + USB_O_TXCSRL1 + EP_OFFSET(ulEndpoint)) & + USB_TXCSRL1_TXRDY) + { + // + // Hit the Flush FIFO bit. + // + HWREGB(ulBase + USB_O_TXCSRL1 + EP_OFFSET(ulEndpoint)) |= + USB_TXCSRL1_FLUSH; + } + } + else + { + // + // Make sure that the FIFO is not empty. + // + if(HWREGB(ulBase + USB_O_RXCSRL1 + EP_OFFSET(ulEndpoint)) & + USB_RXCSRL1_RXRDY) + { + // + // Hit the Flush FIFO bit. + // + HWREGB(ulBase + USB_O_RXCSRL1 + EP_OFFSET(ulEndpoint)) |= + USB_RXCSRL1_FLUSH; + } + } + } +} + +//***************************************************************************** +// +//! Schedules a request for an IN transaction on an endpoint in host mode. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! +//! This function will schedule a request for an IN transaction. When the USB +//! device being communicated with responds the data, the data can be retrieved +//! by calling USBEndpointDataGet() or via a DMA transfer. +//! +//! \note This function should only be called in host mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostRequestIN(unsigned long ulBase, unsigned long ulEndpoint) +{ + unsigned long ulRegister; + + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // Endpoint zero uses a different offset than the other endpoints. + // + if(ulEndpoint == USB_EP_0) + { + ulRegister = USB_O_CSRL0; + } + else + { + ulRegister = USB_O_RXCSRL1 + EP_OFFSET(ulEndpoint); + } + + // + // Set the request for an IN transaction. + // + HWREGB(ulBase + ulRegister) = USB_RXCSRL1_REQPKT; +} + +//***************************************************************************** +// +//! Issues a request for a status IN transaction on endpoint zero. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function is used to cause a request for an status IN transaction from +//! a device on endpoint zero. This function can only be used with endpoint +//! zero as that is the only control endpoint that supports this ability. This +//! is used to complete the last phase of a control transaction to a device and +//! an interrupt will be signaled when the status packet has been received. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostRequestStatus(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Set the request for a status IN transaction. + // + HWREGB(ulBase + USB_O_CSRL0) = USB_CSRL0_REQPKT | USB_CSRL0_STATUS; +} + +//***************************************************************************** +// +//! Sets the functional address for the device that is connected to an +//! endpoint in host mode. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param ulAddr is the functional address for the controller to use for this +//! endpoint. +//! \param ulFlags determines if this is an IN or an OUT endpoint. +//! +//! This function will set the functional address for a device that is using +//! this endpoint for communication. This \e ulAddr parameter is the address +//! of the target device that this endpoint will be used to communicate with. +//! The \e ulFlags parameter indicates if the IN or OUT endpoint should be set. +//! +//! \note This function should only be called in host mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostAddrSet(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulAddr, unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // See if the transmit or receive address should be set. + // + if(ulFlags & USB_EP_HOST_OUT) + { + // + // Set the transmit address. + // + HWREGB(ulBase + USB_O_TXFUNCADDR0 + (ulEndpoint >> 1)) = ulAddr; + } + else + { + // + // Set the receive address. + // + HWREGB(ulBase + USB_O_TXFUNCADDR0 + 4 + (ulEndpoint >> 1)) = ulAddr; + } +} + +//***************************************************************************** +// +//! Gets the current functional device address for an endpoint. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param ulFlags determines if this is an IN or an OUT endpoint. +//! +//! This function returns the current functional address that an endpoint is +//! using to communicate with a device. The \e ulFlags parameter determines if +//! the IN or OUT endpoint's device address is returned. +//! +//! \note This function should only be called in host mode. +//! +//! \return Returns the current function address being used by an endpoint. +// +//***************************************************************************** +unsigned long +USBHostAddrGet(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // See if the transmit or receive address should be returned. + // + if(ulFlags & USB_EP_HOST_OUT) + { + // + // Return this endpoint's transmit address. + // + return(HWREGB(ulBase + USB_O_TXFUNCADDR0 + (ulEndpoint >> 1))); + } + else + { + // + // Return this endpoint's receive address. + // + return(HWREGB(ulBase + USB_O_TXFUNCADDR0 + 4 + (ulEndpoint >> 1))); + } +} + +//***************************************************************************** +// +//! Set the hub address for the device that is connected to an endpoint. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param ulAddr is the hub address for the device using this endpoint. +//! \param ulFlags determines if this is an IN or an OUT endpoint. +//! +//! This function will set the hub address for a device that is using this +//! endpoint for communication. The \e ulFlags parameter determines if the +//! device address for the IN or the OUT endpoint is set by this call. +//! +//! \note This function should only be called in host mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostHubAddrSet(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulAddr, unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // See if the hub transmit or receive address is being set. + // + if(ulFlags & USB_EP_HOST_OUT) + { + // + // Set the hub transmit address for this endpoint. + // + HWREGB(ulBase + USB_O_TXHUBADDR0 + (ulEndpoint >> 1)) = ulAddr; + } + else + { + // + // Set the hub receive address for this endpoint. + // + HWREGB(ulBase + USB_O_TXHUBADDR0 + 4 + (ulEndpoint >> 1)) = ulAddr; + } +} + +//***************************************************************************** +// +//! Get the current device hub address for this endpoint. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint is the endpoint to access. +//! \param ulFlags determines if this is an IN or an OUT endpoint. +//! +//! This function will return the current hub address that an endpoint is using +//! to communicate with a device. The \e ulFlags parameter determines if the +//! device address for the IN or OUT endpoint is returned. +//! +//! \note This function should only be called in host mode. +//! +//! \return This function returns the current hub address being used by an +//! endpoint. +// +//***************************************************************************** +unsigned long +USBHostHubAddrGet(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_0) || (ulEndpoint == USB_EP_1) || + (ulEndpoint == USB_EP_2) || (ulEndpoint == USB_EP_3) || + (ulEndpoint == USB_EP_4) || (ulEndpoint == USB_EP_5) || + (ulEndpoint == USB_EP_6) || (ulEndpoint == USB_EP_7) || + (ulEndpoint == USB_EP_8) || (ulEndpoint == USB_EP_9) || + (ulEndpoint == USB_EP_10) || (ulEndpoint == USB_EP_11) || + (ulEndpoint == USB_EP_12) || (ulEndpoint == USB_EP_13) || + (ulEndpoint == USB_EP_14) || (ulEndpoint == USB_EP_15)); + + // + // See if the hub transmit or receive address should be returned. + // + if(ulFlags & USB_EP_HOST_OUT) + { + // + // Return the hub transmit address for this endpoint. + // + return(HWREGB(ulBase + USB_O_TXHUBADDR0 + (ulEndpoint >> 1))); + } + else + { + // + // Return the hub receive address for this endpoint. + // + return(HWREGB(ulBase + USB_O_TXHUBADDR0 + 4 + (ulEndpoint >> 1))); + } +} + +//***************************************************************************** +// +//! Sets the configuration for USB power fault. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulFlags specifies the configuration of the power fault. +//! +//! This function controls how the USB controller uses its external power +//! control pins(USBnPFTL and USBnEPEN). The flags specify the power +//! fault level sensitivity, the power fault action, and the power enable level +//! and source. +//! +//! One of the following can be selected as the power fault level +//! sensitivity: +//! +//! - \b USB_HOST_PWRFLT_LOW - An external power fault is indicated by the pin +//! being driven low. +//! - \b USB_HOST_PWRFLT_HIGH - An external power fault is indicated by the pin +//! being driven high. +//! +//! One of the following can be selected as the power fault action: +//! +//! - \b USB_HOST_PWRFLT_EP_NONE - No automatic action when power fault +//! detected. +//! - \b USB_HOST_PWRFLT_EP_TRI - Automatically Tri-state the USBnEPEN pin on a +//! power fault. +//! - \b USB_HOST_PWRFLT_EP_LOW - Automatically drive USBnEPEN pin low on a +//! power fault. +//! - \b USB_HOST_PWRFLT_EP_HIGH - Automatically drive USBnEPEN pin high on a +//! power fault. +//! +//! One of the following can be selected as the power enable level and source: +//! +//! - \b USB_HOST_PWREN_MAN_LOW - USBEPEN is driven low by the USB controller +//! when USBHostPwrEnable() is called. +//! - \b USB_HOST_PWREN_MAN_HIGH - USBEPEN is driven high by the USB controller +//! when USBHostPwrEnable() is called. +//! - \b USB_HOST_PWREN_AUTOLOW - USBEPEN is driven low by the USB controller +//! automatically if USBOTGSessionRequest() has +//! enabled a session. +//! - \b USB_HOST_PWREN_AUTOHIGH - USBEPEN is driven high by the USB controller +//! automatically if USBOTGSessionRequest() has +//! enabled a session. +//! +//! On devices that support the VBUS glitch filter, the +//! \b USB_HOST_PWREN_FILTER can be added to ignore small short drops in VBUS +//! level caused by high power consumption. This is mainly used to avoid +//! causing VBUS errors caused by devices with high in-rush current. +//! +//! \note The following values have been deprecated and should no longer be +//! used. +//! - \b USB_HOST_PWREN_LOW - Automatically drive USBnEPEN low when power is +//! enabled. +//! - \b USB_HOST_PWREN_HIGH - Automatically drive USBnEPEN high when power is +//! enabled. +//! - \b USB_HOST_PWREN_VBLOW - Automatically drive USBnEPEN low when power is +//! enabled. +//! - \b USB_HOST_PWREN_VBHIGH - Automatically drive USBnEPEN high when power is +//! enabled. +//! +//! \note This function should only be called on microcontrollers that support +//! host mode or OTG operation. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostPwrConfig(unsigned long ulBase, unsigned long ulFlags) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulFlags & ~(USB_HOST_PWREN_FILTER | USB_EPC_PFLTACT_M | + USB_EPC_PFLTAEN | USB_EPC_PFLTSEN_HIGH | + USB_EPC_EPEN_M)) == 0); + + // + // If requested, enable VBUS droop detection on parts that support this + // feature. + // + HWREG(ulBase + USB_O_VDC) = ulFlags >> 16; + + // + // Set the power fault configuration as specified. This will not change + // whether fault detection is enabled or not. + // + HWREGH(ulBase + USB_O_EPC) = + (ulFlags | (HWREGH(ulBase + USB_O_EPC) & + ~(USB_EPC_PFLTACT_M | USB_EPC_PFLTAEN | + USB_EPC_PFLTSEN_HIGH | USB_EPC_EPEN_M))); +} + +//***************************************************************************** +// +//! Enables power fault detection. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function enables power fault detection in the USB controller. If the +//! USBPFLT pin is not in use this function should not be used. +//! +//! \note This function should only be called in host mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostPwrFaultEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Enable power fault input. + // + HWREGH(ulBase + USB_O_EPC) |= USB_EPC_PFLTEN; +} + +//***************************************************************************** +// +//! Disables power fault detection. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function disables power fault detection in the USB controller. +//! +//! \note This function should only be called in host mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostPwrFaultDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Enable power fault input. + // + HWREGH(ulBase + USB_O_EPC) &= ~USB_EPC_PFLTEN; +} + +//***************************************************************************** +// +//! Enables the external power pin. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function enables the USBEPEN signal to enable an external power supply +//! in host mode operation. +//! +//! \note This function should only be called in host mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostPwrEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Enable the external power supply enable signal. + // + HWREGH(ulBase + USB_O_EPC) |= USB_EPC_EPENDE; +} + +//***************************************************************************** +// +//! Disables the external power pin. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function disables the USBEPEN signal to disable an external power +//! supply in host mode operation. +//! +//! \note This function should only be called in host mode. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostPwrDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Disable the external power supply enable signal. + // + HWREGH(ulBase + USB_O_EPC) &= ~USB_EPC_EPENDE; +} + +//***************************************************************************** +// +//! Get the current frame number. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function returns the last frame number received. +//! +//! \return The last frame number received. +// +//***************************************************************************** +unsigned long +USBFrameNumberGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Return the most recent frame number. + // + return(HWREGH(ulBase + USB_O_FRAME)); +} + +//***************************************************************************** +// +//! Starts or ends a session. +//! +//! \param ulBase specifies the USB module base address. +//! \param bStart specifies if this call starts or ends a session. +//! +//! This function is used in OTG mode to start a session request or end a +//! session. If the \e bStart parameter is set to \b true, then this function +//! start a session and if it is \b false it will end a session. +//! +//! \return None. +// +//***************************************************************************** +void +USBOTGSessionRequest(unsigned long ulBase, tBoolean bStart) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Start or end the session as directed. + // + if(bStart) + { + HWREGB(ulBase + USB_O_DEVCTL) |= USB_DEVCTL_SESSION; + } + else + { + HWREGB(ulBase + USB_O_DEVCTL) &= ~USB_DEVCTL_SESSION; + } +} + +//***************************************************************************** +// +//! Returns the absolute FIFO address for a given endpoint. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint specifies which endpoint's FIFO address to return. +//! +//! This function returns the actual physical address of the FIFO. This is +//! needed when the USB is going to be used with the uDMA controller and the +//! source or destination address needs to be set to the physical FIFO address +//! for a given endpoint. +//! +//! \return None. +// +//***************************************************************************** +unsigned long +USBFIFOAddrGet(unsigned long ulBase, unsigned long ulEndpoint) +{ + // + // Return the FIFO address for this endpoint. + // + return(ulBase + USB_O_FIFO0 + (ulEndpoint >> 2)); +} + +//***************************************************************************** +// +//! Returns the current operating mode of the controller. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function returns the current operating mode on USB controllers with +//! OTG or Dual mode functionality. +//! +//! For OTG controllers: +//! +//! The function will return on of the following values on OTG controllers: +//! \b USB_OTG_MODE_ASIDE_HOST, \b USB_OTG_MODE_ASIDE_DEV, +//! \b USB_OTG_MODE_BSIDE_HOST, \b USB_OTG_MODE_BSIDE_DEV, +//! \b USB_OTG_MODE_NONE. +//! +//! \b USB_OTG_MODE_ASIDE_HOST indicates that the controller is in host mode +//! on the A-side of the cable. +//! +//! \b USB_OTG_MODE_ASIDE_DEV indicates that the controller is in device mode +//! on the A-side of the cable. +//! +//! \b USB_OTG_MODE_BSIDE_HOST indicates that the controller is in host mode +//! on the B-side of the cable. +//! +//! \b USB_OTG_MODE_BSIDE_DEV indicates that the controller is in device mode +//! on the B-side of the cable. If and OTG session request is started with no +//! cable in place this is the default mode for the controller. +//! +//! \b USB_OTG_MODE_NONE indicates that the controller is not attempting to +//! determine its role in the system. +//! +//! For Dual Mode controllers: +//! +//! The function will return on of the following values: +//! \b USB_DUAL_MODE_HOST, \b USB_DUAL_MODE_DEVICE, or +//! \b USB_DUAL_MODE_NONE. +//! +//! \b USB_DUAL_MODE_HOST indicates that the controller is acting as a host. +//! +//! \b USB_DUAL_MODE_DEVICE indicates that the controller acting as a device. +//! +//! \b USB_DUAL_MODE_NONE indicates that the controller is not active as +//! either a host or device. +//! +//! \return Returns \b USB_OTG_MODE_ASIDE_HOST, \b USB_OTG_MODE_ASIDE_DEV, +//! \b USB_OTG_MODE_BSIDE_HOST, \b USB_OTG_MODE_BSIDE_DEV, +//! \b USB_OTG_MODE_NONE, \b USB_DUAL_MODE_HOST, \b USB_DUAL_MODE_DEVICE, or +//! \b USB_DUAL_MODE_NONE. +// +//***************************************************************************** +unsigned long +USBModeGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Checks the current mode in the USB_O_DEVCTL and returns the current + // mode. + // + // USB_OTG_MODE_ASIDE_HOST: USB_DEVCTL_HOST | USB_DEVCTL_SESSION + // USB_OTG_MODE_ASIDE_DEV: USB_DEVCTL_SESSION + // USB_OTG_MODE_BSIDE_HOST: USB_DEVCTL_DEV | USB_DEVCTL_SESSION | + // USB_DEVCTL_HOST + // USB_OTG_MODE_BSIDE_DEV: USB_DEVCTL_DEV | USB_DEVCTL_SESSION + // USB_OTG_MODE_NONE: USB_DEVCTL_DEV + // + return(HWREGB(ulBase + USB_O_DEVCTL) & + (USB_DEVCTL_DEV | USB_DEVCTL_HOST | USB_DEVCTL_SESSION | + USB_DEVCTL_VBUS_M)); +} + +//***************************************************************************** +// +//! Sets the DMA channel to use for a given endpoint. +//! +//! \param ulBase specifies the USB module base address. +//! \param ulEndpoint specifies which endpoint's FIFO address to return. +//! \param ulChannel specifies which DMA channel to use for which endpoint. +//! +//! This function is used to configure which DMA channel to use with a given +//! endpoint. Receive DMA channels can only be used with receive endpoints +//! and transmit DMA channels can only be used with transmit endpoints. This +//! allows the 3 receive and 3 transmit DMA channels to be mapped to any +//! endpoint other than 0. The values that should be passed into the \e +//! ulChannel value are the UDMA_CHANNEL_USBEP* values defined in udma.h. +//! +//! \note This function only has an effect on microcontrollers that have the +//! ability to change the DMA channel for an endpoint. Calling this function +//! on other devices will have no effect. +//! +//! \return None. +//! +//***************************************************************************** +void +USBEndpointDMAChannel(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulChannel) +{ + unsigned long ulMask; + + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + ASSERT((ulEndpoint == USB_EP_1) || (ulEndpoint == USB_EP_2) || + (ulEndpoint == USB_EP_3) || (ulEndpoint == USB_EP_4) || + (ulEndpoint == USB_EP_5) || (ulEndpoint == USB_EP_6) || + (ulEndpoint == USB_EP_7) || (ulEndpoint == USB_EP_8) || + (ulEndpoint == USB_EP_9) || (ulEndpoint == USB_EP_10) || + (ulEndpoint == USB_EP_11) || (ulEndpoint == USB_EP_12) || + (ulEndpoint == USB_EP_13) || (ulEndpoint == USB_EP_14) || + (ulEndpoint == USB_EP_15)); + ASSERT(ulChannel <= UDMA_CHANNEL_USBEP3TX); + + // + // The input select mask needs to be shifted into the correct position + // based on the channel. + // + ulMask = 0xf << (ulChannel * 4); + + // + // Clear out the current selection for the channel. + // + ulMask = HWREG(ulBase + USB_O_DMASEL) & (~ulMask); + + // + // The input select is now shifted into the correct position based on the + // channel. + // + ulMask |= (USB_EP_TO_INDEX(ulEndpoint)) << (ulChannel * 4); + + // + // Write the value out to the register. + // + HWREG(ulBase + USB_O_DMASEL) = ulMask; +} + +//***************************************************************************** +// +//! Change the mode of the USB controller to host. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function changes the mode of the USB controller to host mode. This +//! is only valid on microcontrollers that have the host and device +//! capabilities and not the OTG capabilities. +//! +//! \return None. +// +//***************************************************************************** +void +USBHostMode(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Force mode in OTG parts that support forcing USB controller mode. + // This bit is not writable in USB controllers that do not support + // forcing the mode. Not setting the USB_GPCS_DEVMOD bit makes this a + // force of host mode. + // + HWREGB(ulBase + USB_O_GPCS) = USB_GPCS_DEVMODOTG; +} + +//***************************************************************************** +// +//! Change the mode of the USB controller to device. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function changes the mode of the USB controller to device mode. This +//! is only valid on microcontrollers that have the host and device +//! capabilities and not the OTG capabilities. +//! +//! \return None. +// +//***************************************************************************** +void +USBDevMode(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT(ulBase == USB0_BASE); + + // + // Set the USB controller mode to device. + // + HWREGB(ulBase + USB_O_GPCS) = USB_GPCS_DEVMODOTG | USB_GPCS_DEVMOD; +} + +//***************************************************************************** +// +//! Powers off the USB PHY. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function will power off the USB PHY, reducing the current consuption +//! of the device. While in the powered off state, the USB controller will be +//! unable to operate. +//! +//! \return None. +// +//***************************************************************************** +void +USBPHYPowerOff(unsigned long ulBase) +{ + // + // Set the PWRDNPHY bit in the PHY, putting it into its low power mode. + // + HWREGB(ulBase + USB_O_POWER) |= USB_POWER_PWRDNPHY; +} + +//***************************************************************************** +// +//! Powers on the USB PHY. +//! +//! \param ulBase specifies the USB module base address. +//! +//! This function will power on the USB PHY, enabling it return to normal +//! operation. By default, the PHY is powered on, so this function only needs +//! to be called if USBPHYPowerOff() has previously been called. +//! +//! \return None. +// +//***************************************************************************** +void +USBPHYPowerOn(unsigned long ulBase) +{ + // + // Clear the PWRDNPHY bit in the PHY, putting it into normal operating + // mode. + // + HWREGB(ulBase + USB_O_POWER) &= ~USB_POWER_PWRDNPHY; +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/usb.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/usb.h new file mode 100644 index 00000000..c5b3b7f2 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/usb.h @@ -0,0 +1,567 @@ +//***************************************************************************** +// +// usb.h - Prototypes for the USB Interface Driver. +// +// Copyright (c) 2007-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __USB_H__ +#define __USB_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// The following are values that can be passed to USBIntEnableControl() and +// USBIntDisableControl() as the ulFlags parameter, and are returned from +// USBIntStatusControl(). +// +//***************************************************************************** +#define USB_INTCTRL_ALL 0x000003FF // All control interrupt sources +#define USB_INTCTRL_STATUS 0x000000FF // Status Interrupts +#define USB_INTCTRL_VBUS_ERR 0x00000080 // VBUS Error +#define USB_INTCTRL_SESSION 0x00000040 // Session Start Detected +#define USB_INTCTRL_SESSION_END 0x00000040 // Session End Detected +#define USB_INTCTRL_DISCONNECT 0x00000020 // Disconnect Detected +#define USB_INTCTRL_CONNECT 0x00000010 // Device Connect Detected +#define USB_INTCTRL_SOF 0x00000008 // Start of Frame Detected +#define USB_INTCTRL_BABBLE 0x00000004 // Babble signaled +#define USB_INTCTRL_RESET 0x00000004 // Reset signaled +#define USB_INTCTRL_RESUME 0x00000002 // Resume detected +#define USB_INTCTRL_SUSPEND 0x00000001 // Suspend detected +#define USB_INTCTRL_MODE_DETECT 0x00000200 // Mode value valid +#define USB_INTCTRL_POWER_FAULT 0x00000100 // Power Fault detected + +//***************************************************************************** +// +// The following are values that can be passed to USBIntEnableEndpoint() and +// USBIntDisableEndpoint() as the ulFlags parameter, and are returned from +// USBIntStatusEndpoint(). +// +//***************************************************************************** +#define USB_INTEP_ALL 0xFFFFFFFF // Host IN Interrupts +#define USB_INTEP_HOST_IN 0xFFFE0000 // Host IN Interrupts +#define USB_INTEP_HOST_IN_15 0x80000000 // Endpoint 15 Host IN Interrupt +#define USB_INTEP_HOST_IN_14 0x40000000 // Endpoint 14 Host IN Interrupt +#define USB_INTEP_HOST_IN_13 0x20000000 // Endpoint 13 Host IN Interrupt +#define USB_INTEP_HOST_IN_12 0x10000000 // Endpoint 12 Host IN Interrupt +#define USB_INTEP_HOST_IN_11 0x08000000 // Endpoint 11 Host IN Interrupt +#define USB_INTEP_HOST_IN_10 0x04000000 // Endpoint 10 Host IN Interrupt +#define USB_INTEP_HOST_IN_9 0x02000000 // Endpoint 9 Host IN Interrupt +#define USB_INTEP_HOST_IN_8 0x01000000 // Endpoint 8 Host IN Interrupt +#define USB_INTEP_HOST_IN_7 0x00800000 // Endpoint 7 Host IN Interrupt +#define USB_INTEP_HOST_IN_6 0x00400000 // Endpoint 6 Host IN Interrupt +#define USB_INTEP_HOST_IN_5 0x00200000 // Endpoint 5 Host IN Interrupt +#define USB_INTEP_HOST_IN_4 0x00100000 // Endpoint 4 Host IN Interrupt +#define USB_INTEP_HOST_IN_3 0x00080000 // Endpoint 3 Host IN Interrupt +#define USB_INTEP_HOST_IN_2 0x00040000 // Endpoint 2 Host IN Interrupt +#define USB_INTEP_HOST_IN_1 0x00020000 // Endpoint 1 Host IN Interrupt + +#define USB_INTEP_DEV_OUT 0xFFFE0000 // Device OUT Interrupts +#define USB_INTEP_DEV_OUT_15 0x80000000 // Endpoint 15 Device OUT Interrupt +#define USB_INTEP_DEV_OUT_14 0x40000000 // Endpoint 14 Device OUT Interrupt +#define USB_INTEP_DEV_OUT_13 0x20000000 // Endpoint 13 Device OUT Interrupt +#define USB_INTEP_DEV_OUT_12 0x10000000 // Endpoint 12 Device OUT Interrupt +#define USB_INTEP_DEV_OUT_11 0x08000000 // Endpoint 11 Device OUT Interrupt +#define USB_INTEP_DEV_OUT_10 0x04000000 // Endpoint 10 Device OUT Interrupt +#define USB_INTEP_DEV_OUT_9 0x02000000 // Endpoint 9 Device OUT Interrupt +#define USB_INTEP_DEV_OUT_8 0x01000000 // Endpoint 8 Device OUT Interrupt +#define USB_INTEP_DEV_OUT_7 0x00800000 // Endpoint 7 Device OUT Interrupt +#define USB_INTEP_DEV_OUT_6 0x00400000 // Endpoint 6 Device OUT Interrupt +#define USB_INTEP_DEV_OUT_5 0x00200000 // Endpoint 5 Device OUT Interrupt +#define USB_INTEP_DEV_OUT_4 0x00100000 // Endpoint 4 Device OUT Interrupt +#define USB_INTEP_DEV_OUT_3 0x00080000 // Endpoint 3 Device OUT Interrupt +#define USB_INTEP_DEV_OUT_2 0x00040000 // Endpoint 2 Device OUT Interrupt +#define USB_INTEP_DEV_OUT_1 0x00020000 // Endpoint 1 Device OUT Interrupt + +#define USB_INTEP_HOST_OUT 0x0000FFFE // Host OUT Interrupts +#define USB_INTEP_HOST_OUT_15 0x00008000 // Endpoint 15 Host OUT Interrupt +#define USB_INTEP_HOST_OUT_14 0x00004000 // Endpoint 14 Host OUT Interrupt +#define USB_INTEP_HOST_OUT_13 0x00002000 // Endpoint 13 Host OUT Interrupt +#define USB_INTEP_HOST_OUT_12 0x00001000 // Endpoint 12 Host OUT Interrupt +#define USB_INTEP_HOST_OUT_11 0x00000800 // Endpoint 11 Host OUT Interrupt +#define USB_INTEP_HOST_OUT_10 0x00000400 // Endpoint 10 Host OUT Interrupt +#define USB_INTEP_HOST_OUT_9 0x00000200 // Endpoint 9 Host OUT Interrupt +#define USB_INTEP_HOST_OUT_8 0x00000100 // Endpoint 8 Host OUT Interrupt +#define USB_INTEP_HOST_OUT_7 0x00000080 // Endpoint 7 Host OUT Interrupt +#define USB_INTEP_HOST_OUT_6 0x00000040 // Endpoint 6 Host OUT Interrupt +#define USB_INTEP_HOST_OUT_5 0x00000020 // Endpoint 5 Host OUT Interrupt +#define USB_INTEP_HOST_OUT_4 0x00000010 // Endpoint 4 Host OUT Interrupt +#define USB_INTEP_HOST_OUT_3 0x00000008 // Endpoint 3 Host OUT Interrupt +#define USB_INTEP_HOST_OUT_2 0x00000004 // Endpoint 2 Host OUT Interrupt +#define USB_INTEP_HOST_OUT_1 0x00000002 // Endpoint 1 Host OUT Interrupt + +#define USB_INTEP_DEV_IN 0x0000FFFE // Device IN Interrupts +#define USB_INTEP_DEV_IN_15 0x00008000 // Endpoint 15 Device IN Interrupt +#define USB_INTEP_DEV_IN_14 0x00004000 // Endpoint 14 Device IN Interrupt +#define USB_INTEP_DEV_IN_13 0x00002000 // Endpoint 13 Device IN Interrupt +#define USB_INTEP_DEV_IN_12 0x00001000 // Endpoint 12 Device IN Interrupt +#define USB_INTEP_DEV_IN_11 0x00000800 // Endpoint 11 Device IN Interrupt +#define USB_INTEP_DEV_IN_10 0x00000400 // Endpoint 10 Device IN Interrupt +#define USB_INTEP_DEV_IN_9 0x00000200 // Endpoint 9 Device IN Interrupt +#define USB_INTEP_DEV_IN_8 0x00000100 // Endpoint 8 Device IN Interrupt +#define USB_INTEP_DEV_IN_7 0x00000080 // Endpoint 7 Device IN Interrupt +#define USB_INTEP_DEV_IN_6 0x00000040 // Endpoint 6 Device IN Interrupt +#define USB_INTEP_DEV_IN_5 0x00000020 // Endpoint 5 Device IN Interrupt +#define USB_INTEP_DEV_IN_4 0x00000010 // Endpoint 4 Device IN Interrupt +#define USB_INTEP_DEV_IN_3 0x00000008 // Endpoint 3 Device IN Interrupt +#define USB_INTEP_DEV_IN_2 0x00000004 // Endpoint 2 Device IN Interrupt +#define USB_INTEP_DEV_IN_1 0x00000002 // Endpoint 1 Device IN Interrupt + +#define USB_INTEP_0 0x00000001 // Endpoint 0 Interrupt + +//***************************************************************************** +// +// The following are values that are returned from USBSpeedGet(). +// +//***************************************************************************** +#define USB_UNDEF_SPEED 0x80000000 // Current speed is undefined +#define USB_FULL_SPEED 0x00000001 // Current speed is Full Speed +#define USB_LOW_SPEED 0x00000000 // Current speed is Low Speed + +//***************************************************************************** +// +// The following are values that are returned from USBEndpointStatus(). The +// USB_HOST_* values are used when the USB controller is in host mode and the +// USB_DEV_* values are used when the USB controller is in device mode. +// +//***************************************************************************** +#define USB_HOST_IN_PID_ERROR 0x01000000 // Stall on this endpoint received +#define USB_HOST_IN_NOT_COMP 0x00100000 // Device failed to respond +#define USB_HOST_IN_STALL 0x00400000 // Stall on this endpoint received +#define USB_HOST_IN_DATA_ERROR 0x00080000 // CRC or bit-stuff error + // (ISOC Mode) +#define USB_HOST_IN_NAK_TO 0x00080000 // NAK received for more than the + // specified timeout period +#define USB_HOST_IN_ERROR 0x00040000 // Failed to communicate with a + // device +#define USB_HOST_IN_FIFO_FULL 0x00020000 // RX FIFO full +#define USB_HOST_IN_PKTRDY 0x00010000 // Data packet ready +#define USB_HOST_OUT_NAK_TO 0x00000080 // NAK received for more than the + // specified timeout period +#define USB_HOST_OUT_NOT_COMP 0x00000080 // No response from device + // (ISOC mode) +#define USB_HOST_OUT_STALL 0x00000020 // Stall on this endpoint received +#define USB_HOST_OUT_ERROR 0x00000004 // Failed to communicate with a + // device +#define USB_HOST_OUT_FIFO_NE 0x00000002 // TX FIFO is not empty +#define USB_HOST_OUT_PKTPEND 0x00000001 // Transmit still being transmitted +#define USB_HOST_EP0_NAK_TO 0x00000080 // NAK received for more than the + // specified timeout period +#define USB_HOST_EP0_STATUS 0x00000040 // This was a status packet +#define USB_HOST_EP0_ERROR 0x00000010 // Failed to communicate with a + // device +#define USB_HOST_EP0_RX_STALL 0x00000004 // Stall on this endpoint received +#define USB_HOST_EP0_RXPKTRDY 0x00000001 // Receive data packet ready +#define USB_DEV_RX_SENT_STALL 0x00400000 // Stall was sent on this endpoint +#define USB_DEV_RX_DATA_ERROR 0x00080000 // CRC error on the data +#define USB_DEV_RX_OVERRUN 0x00040000 // OUT packet was not loaded due to + // a full FIFO +#define USB_DEV_RX_FIFO_FULL 0x00020000 // RX FIFO full +#define USB_DEV_RX_PKT_RDY 0x00010000 // Data packet ready +#define USB_DEV_TX_NOT_COMP 0x00000080 // Large packet split up, more data + // to come +#define USB_DEV_TX_SENT_STALL 0x00000020 // Stall was sent on this endpoint +#define USB_DEV_TX_UNDERRUN 0x00000004 // IN received with no data ready +#define USB_DEV_TX_FIFO_NE 0x00000002 // The TX FIFO is not empty +#define USB_DEV_TX_TXPKTRDY 0x00000001 // Transmit still being transmitted +#define USB_DEV_EP0_SETUP_END 0x00000010 // Control transaction ended before + // Data End seen +#define USB_DEV_EP0_SENT_STALL 0x00000004 // Stall was sent on this endpoint +#define USB_DEV_EP0_IN_PKTPEND 0x00000002 // Transmit data packet pending +#define USB_DEV_EP0_OUT_PKTRDY 0x00000001 // Receive data packet ready + +//***************************************************************************** +// +// The following are values that can be passed to USBHostEndpointConfig() and +// USBDevEndpointConfigSet() as the ulFlags parameter. +// +//***************************************************************************** +#define USB_EP_AUTO_SET 0x00000001 // Auto set feature enabled +#define USB_EP_AUTO_REQUEST 0x00000002 // Auto request feature enabled +#define USB_EP_AUTO_CLEAR 0x00000004 // Auto clear feature enabled +#define USB_EP_DMA_MODE_0 0x00000008 // Enable DMA access using mode 0 +#define USB_EP_DMA_MODE_1 0x00000010 // Enable DMA access using mode 1 +#define USB_EP_MODE_ISOC 0x00000000 // Isochronous endpoint +#define USB_EP_MODE_BULK 0x00000100 // Bulk endpoint +#define USB_EP_MODE_INT 0x00000200 // Interrupt endpoint +#define USB_EP_MODE_CTRL 0x00000300 // Control endpoint +#define USB_EP_MODE_MASK 0x00000300 // Mode Mask +#define USB_EP_SPEED_LOW 0x00000000 // Low Speed +#define USB_EP_SPEED_FULL 0x00001000 // Full Speed +#define USB_EP_HOST_IN 0x00000000 // Host IN endpoint +#define USB_EP_HOST_OUT 0x00002000 // Host OUT endpoint +#define USB_EP_DEV_IN 0x00002000 // Device IN endpoint +#define USB_EP_DEV_OUT 0x00000000 // Device OUT endpoint + +//***************************************************************************** +// +// The following are values that can be passed to USBHostPwrConfig() as +// the ulFlags parameter. +// +//***************************************************************************** +#define USB_HOST_PWRFLT_LOW 0x00000010 +#define USB_HOST_PWRFLT_HIGH 0x00000030 +#define USB_HOST_PWRFLT_EP_NONE 0x00000000 +#define USB_HOST_PWRFLT_EP_TRI 0x00000140 +#define USB_HOST_PWRFLT_EP_LOW 0x00000240 +#define USB_HOST_PWRFLT_EP_HIGH 0x00000340 +#ifndef DEPRECATED +#define USB_HOST_PWREN_LOW 0x00000002 +#define USB_HOST_PWREN_HIGH 0x00000003 +#define USB_HOST_PWREN_VBLOW 0x00000002 +#define USB_HOST_PWREN_VBHIGH 0x00000003 +#endif +#define USB_HOST_PWREN_MAN_LOW 0x00000000 +#define USB_HOST_PWREN_MAN_HIGH 0x00000001 +#define USB_HOST_PWREN_AUTOLOW 0x00000002 +#define USB_HOST_PWREN_AUTOHIGH 0x00000003 +#define USB_HOST_PWREN_FILTER 0x00010000 + +//***************************************************************************** +// +// The following are special values that can be passed to +// USBHostEndpointConfig() as the ulNAKPollInterval parameter. +// +//***************************************************************************** +#define MAX_NAK_LIMIT 31 // Maximum NAK interval +#define DISABLE_NAK_LIMIT 0 // No NAK timeouts + +//***************************************************************************** +// +// This value specifies the maximum size of transfers on endpoint 0 as 64 +// bytes. This value is fixed in hardware as the FIFO size for endpoint 0. +// +//***************************************************************************** +#define MAX_PACKET_SIZE_EP0 64 + +//***************************************************************************** +// +// These values are used to indicate which endpoint to access. +// +//***************************************************************************** +#define USB_EP_0 0x00000000 // Endpoint 0 +#define USB_EP_1 0x00000010 // Endpoint 1 +#define USB_EP_2 0x00000020 // Endpoint 2 +#define USB_EP_3 0x00000030 // Endpoint 3 +#define USB_EP_4 0x00000040 // Endpoint 4 +#define USB_EP_5 0x00000050 // Endpoint 5 +#define USB_EP_6 0x00000060 // Endpoint 6 +#define USB_EP_7 0x00000070 // Endpoint 7 +#define USB_EP_8 0x00000080 // Endpoint 8 +#define USB_EP_9 0x00000090 // Endpoint 9 +#define USB_EP_10 0x000000A0 // Endpoint 10 +#define USB_EP_11 0x000000B0 // Endpoint 11 +#define USB_EP_12 0x000000C0 // Endpoint 12 +#define USB_EP_13 0x000000D0 // Endpoint 13 +#define USB_EP_14 0x000000E0 // Endpoint 14 +#define USB_EP_15 0x000000F0 // Endpoint 15 +#define NUM_USB_EP 16 // Number of supported endpoints + +//***************************************************************************** +// +// These macros allow conversion between 0-based endpoint indices and the +// USB_EP_x values required when calling various USB APIs. +// +//***************************************************************************** +#define INDEX_TO_USB_EP(x) ((x) << 4) +#define USB_EP_TO_INDEX(x) ((x) >> 4) + +//***************************************************************************** +// +// The following are values that can be passed to USBFIFOConfigSet() as the +// ulFIFOSize parameter. +// +//***************************************************************************** +#define USB_FIFO_SZ_8 0x00000000 // 8 byte FIFO +#define USB_FIFO_SZ_16 0x00000001 // 16 byte FIFO +#define USB_FIFO_SZ_32 0x00000002 // 32 byte FIFO +#define USB_FIFO_SZ_64 0x00000003 // 64 byte FIFO +#define USB_FIFO_SZ_128 0x00000004 // 128 byte FIFO +#define USB_FIFO_SZ_256 0x00000005 // 256 byte FIFO +#define USB_FIFO_SZ_512 0x00000006 // 512 byte FIFO +#define USB_FIFO_SZ_1024 0x00000007 // 1024 byte FIFO +#define USB_FIFO_SZ_2048 0x00000008 // 2048 byte FIFO +#define USB_FIFO_SZ_4096 0x00000009 // 4096 byte FIFO +#define USB_FIFO_SZ_8_DB 0x00000010 // 8 byte double buffered FIFO + // (occupying 16 bytes) +#define USB_FIFO_SZ_16_DB 0x00000011 // 16 byte double buffered FIFO + // (occupying 32 bytes) +#define USB_FIFO_SZ_32_DB 0x00000012 // 32 byte double buffered FIFO + // (occupying 64 bytes) +#define USB_FIFO_SZ_64_DB 0x00000013 // 64 byte double buffered FIFO + // (occupying 128 bytes) +#define USB_FIFO_SZ_128_DB 0x00000014 // 128 byte double buffered FIFO + // (occupying 256 bytes) +#define USB_FIFO_SZ_256_DB 0x00000015 // 256 byte double buffered FIFO + // (occupying 512 bytes) +#define USB_FIFO_SZ_512_DB 0x00000016 // 512 byte double buffered FIFO + // (occupying 1024 bytes) +#define USB_FIFO_SZ_1024_DB 0x00000017 // 1024 byte double buffered FIFO + // (occupying 2048 bytes) +#define USB_FIFO_SZ_2048_DB 0x00000018 // 2048 byte double buffered FIFO + // (occupying 4096 bytes) + +//***************************************************************************** +// +// This macro allow conversion from a FIFO size label as defined above to +// a number of bytes +// +//***************************************************************************** +#define USB_FIFO_SIZE_DB_FLAG 0x00000010 +#define USB_FIFO_SZ_TO_BYTES(x) ((8 << ((x) & ~ USB_FIFO_SIZE_DB_FLAG)) * \ + (((x) & USB_FIFO_SIZE_DB_FLAG) ? 2 : 1)) + +//***************************************************************************** +// +// The following are values that can be passed to USBEndpointDataSend() as the +// ulTransType parameter. +// +//***************************************************************************** +#define USB_TRANS_OUT 0x00000102 // Normal OUT transaction +#define USB_TRANS_IN 0x00000102 // Normal IN transaction +#define USB_TRANS_IN_LAST 0x0000010a // Final IN transaction (for + // endpoint 0 in device mode) +#define USB_TRANS_SETUP 0x0000110a // Setup transaction (for endpoint + // 0) +#define USB_TRANS_STATUS 0x00000142 // Status transaction (for endpoint + // 0) + +//***************************************************************************** +// +// The following are values are returned by the USBModeGet function. +// +//***************************************************************************** +#define USB_DUAL_MODE_HOST 0x00000001 // Dual mode controller is in Host + // mode. +#define USB_DUAL_MODE_DEVICE 0x00000081 // Dual mode controller is in + // Device mode. +#define USB_DUAL_MODE_NONE 0x00000080 // Dual mode controller mode is not + // set. +#define USB_OTG_MODE_ASIDE_HOST 0x0000001d // OTG controller on the A side of + // the cable. +#define USB_OTG_MODE_ASIDE_NPWR 0x00000001 // OTG controller on the A side of + // the cable. +#define USB_OTG_MODE_ASIDE_SESS 0x00000009 // OTG controller on the A side of + // the cable Session Valid. +#define USB_OTG_MODE_ASIDE_AVAL 0x00000011 // OTG controller on the A side of + // the cable A valid. +#define USB_OTG_MODE_ASIDE_DEV 0x00000019 // OTG controller on the A side of + // the cable. +#define USB_OTG_MODE_BSIDE_HOST 0x0000009d // OTG controller on the B side of + // the cable. +#define USB_OTG_MODE_BSIDE_DEV 0x00000099 // OTG controller on the B side of + // the cable. +#define USB_OTG_MODE_BSIDE_NPWR 0x00000081 // OTG controller on the B side of + // the cable. +#define USB_OTG_MODE_NONE 0x00000080 // OTG controller mode is not set. + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern unsigned long USBDevAddrGet(unsigned long ulBase); +extern void USBDevAddrSet(unsigned long ulBase, unsigned long ulAddress); +extern void USBDevConnect(unsigned long ulBase); +extern void USBDevDisconnect(unsigned long ulBase); +extern void USBDevEndpointConfigSet(unsigned long ulBase, + unsigned long ulEndpoint, + unsigned long ulMaxPacketSize, + unsigned long ulFlags); +extern void USBDevEndpointConfigGet(unsigned long ulBase, + unsigned long ulEndpoint, + unsigned long *pulMaxPacketSize, + unsigned long *pulFlags); +extern void USBDevEndpointDataAck(unsigned long ulBase, + unsigned long ulEndpoint, + tBoolean bIsLastPacket); +extern void USBDevEndpointStall(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulFlags); +extern void USBDevEndpointStallClear(unsigned long ulBase, + unsigned long ulEndpoint, + unsigned long ulFlags); +extern void USBDevEndpointStatusClear(unsigned long ulBase, + unsigned long ulEndpoint, + unsigned long ulFlags); +extern unsigned long USBEndpointDataAvail(unsigned long ulBase, + unsigned long ulEndpoint); +extern void USBEndpointDMAEnable(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulFlags); +extern void USBEndpointDMADisable(unsigned long ulBase, + unsigned long ulEndpoint, + unsigned long ulFlags); +extern long USBEndpointDataGet(unsigned long ulBase, unsigned long ulEndpoint, + unsigned char *pucData, unsigned long *pulSize); +extern long USBEndpointDataPut(unsigned long ulBase, unsigned long ulEndpoint, + unsigned char *pucData, unsigned long ulSize); +extern long USBEndpointDataSend(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulTransType); +extern void USBEndpointDataToggleClear(unsigned long ulBase, + unsigned long ulEndpoint, + unsigned long ulFlags); +extern unsigned long USBEndpointStatus(unsigned long ulBase, + unsigned long ulEndpoint); +extern unsigned long USBFIFOAddrGet(unsigned long ulBase, + unsigned long ulEndpoint); +extern void USBFIFOConfigGet(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long *pulFIFOAddress, + unsigned long *pulFIFOSize, + unsigned long ulFlags); +extern void USBFIFOConfigSet(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulFIFOAddress, + unsigned long ulFIFOSize, unsigned long ulFlags); +extern void USBFIFOFlush(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulFlags); +extern unsigned long USBFrameNumberGet(unsigned long ulBase); +extern unsigned long USBHostAddrGet(unsigned long ulBase, + unsigned long ulEndpoint, + unsigned long ulFlags); +extern void USBHostAddrSet(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulAddr, unsigned long ulFlags); +extern void USBHostEndpointConfig(unsigned long ulBase, + unsigned long ulEndpoint, + unsigned long ulMaxPacketSize, + unsigned long ulNAKPollInterval, + unsigned long ulTargetEndpoint, + unsigned long ulFlags); +extern void USBHostEndpointDataAck(unsigned long ulBase, + unsigned long ulEndpoint); +extern void USBHostEndpointDataToggle(unsigned long ulBase, + unsigned long ulEndpoint, + tBoolean bDataToggle, + unsigned long ulFlags); +extern void USBHostEndpointStatusClear(unsigned long ulBase, + unsigned long ulEndpoint, + unsigned long ulFlags); +extern unsigned long USBHostHubAddrGet(unsigned long ulBase, + unsigned long ulEndpoint, + unsigned long ulFlags); +extern void USBHostHubAddrSet(unsigned long ulBase, unsigned long ulEndpoint, + unsigned long ulAddr, unsigned long ulFlags); +extern void USBHostPwrDisable(unsigned long ulBase); +extern void USBHostPwrEnable(unsigned long ulBase); +extern void USBHostPwrConfig(unsigned long ulBase, unsigned long ulFlags); +#ifndef DEPRECATED +#define USBHostPwrFaultConfig USBHostPwrConfig +#endif +extern void USBHostPwrFaultDisable(unsigned long ulBase); +extern void USBHostPwrFaultEnable(unsigned long ulBase); +extern void USBHostRequestIN(unsigned long ulBase, unsigned long ulEndpoint); +extern void USBHostRequestStatus(unsigned long ulBase); +extern void USBHostReset(unsigned long ulBase, tBoolean bStart); +extern void USBHostResume(unsigned long ulBase, tBoolean bStart); +extern unsigned long USBHostSpeedGet(unsigned long ulBase); +extern void USBHostSuspend(unsigned long ulBase); +extern void USBIntDisableControl(unsigned long ulBase, + unsigned long ulIntFlags); +extern void USBIntEnableControl(unsigned long ulBase, + unsigned long ulIntFlags); +extern unsigned long USBIntStatusControl(unsigned long ulBase); +extern void USBIntDisableEndpoint(unsigned long ulBase, + unsigned long ulIntFlags); +extern void USBIntEnableEndpoint(unsigned long ulBase, + unsigned long ulIntFlags); +extern unsigned long USBIntStatusEndpoint(unsigned long ulBase); +extern void USBIntRegister(unsigned long ulBase, void(*pfnHandler)(void)); +extern void USBIntUnregister(unsigned long ulBase); +extern void USBOTGSessionRequest(unsigned long ulBase, tBoolean bStart); +extern unsigned long USBModeGet(unsigned long ulBase); +extern void USBEndpointDMAChannel(unsigned long ulBase, + unsigned long ulEndpoint, + unsigned long ulChannel); +extern void USBHostMode(unsigned long ulBase); +extern void USBHostMode(unsigned long ulBase); +extern void USBDevMode(unsigned long ulBase); +extern void USBPHYPowerOff(unsigned long ulBase); +extern void USBPHYPowerOn(unsigned long ulBase); + +//***************************************************************************** +// +// Several USB APIs have been renamed, with the original function name being +// deprecated. These defines and function protypes provide backward +// compatibility. +// +//***************************************************************************** +#ifndef DEPRECATED +//***************************************************************************** +// +// The following are values that can be passed to USBIntEnable() and +// USBIntDisable() as the ulIntFlags parameter, and are returned from +// USBIntStatus(). +// +//***************************************************************************** +#define USB_INT_ALL 0xFF030E0F // All Interrupt sources +#define USB_INT_STATUS 0xFF000000 // Status Interrupts +#define USB_INT_VBUS_ERR 0x80000000 // VBUS Error +#define USB_INT_SESSION_START 0x40000000 // Session Start Detected +#define USB_INT_SESSION_END 0x20000000 // Session End Detected +#define USB_INT_DISCONNECT 0x20000000 // Disconnect Detected +#define USB_INT_CONNECT 0x10000000 // Device Connect Detected +#define USB_INT_SOF 0x08000000 // Start of Frame Detected +#define USB_INT_BABBLE 0x04000000 // Babble signaled +#define USB_INT_RESET 0x04000000 // Reset signaled +#define USB_INT_RESUME 0x02000000 // Resume detected +#define USB_INT_SUSPEND 0x01000000 // Suspend detected +#define USB_INT_MODE_DETECT 0x00020000 // Mode value valid +#define USB_INT_POWER_FAULT 0x00010000 // Power Fault detected +#define USB_INT_HOST_IN 0x00000E00 // Host IN Interrupts +#define USB_INT_DEV_OUT 0x00000E00 // Device OUT Interrupts +#define USB_INT_HOST_IN_EP3 0x00000800 // Endpoint 3 Host IN Interrupt +#define USB_INT_HOST_IN_EP2 0x00000400 // Endpoint 2 Host IN Interrupt +#define USB_INT_HOST_IN_EP1 0x00000200 // Endpoint 1 Host IN Interrupt +#define USB_INT_DEV_OUT_EP3 0x00000800 // Endpoint 3 Device OUT Interrupt +#define USB_INT_DEV_OUT_EP2 0x00000400 // Endpoint 2 Device OUT Interrupt +#define USB_INT_DEV_OUT_EP1 0x00000200 // Endpoint 1 Device OUT Interrupt +#define USB_INT_HOST_OUT 0x0000000E // Host OUT Interrupts +#define USB_INT_DEV_IN 0x0000000E // Device IN Interrupts +#define USB_INT_HOST_OUT_EP3 0x00000008 // Endpoint 3 HOST_OUT Interrupt +#define USB_INT_HOST_OUT_EP2 0x00000004 // Endpoint 2 HOST_OUT Interrupt +#define USB_INT_HOST_OUT_EP1 0x00000002 // Endpoint 1 HOST_OUT Interrupt +#define USB_INT_DEV_IN_EP3 0x00000008 // Endpoint 3 DEV_IN Interrupt +#define USB_INT_DEV_IN_EP2 0x00000004 // Endpoint 2 DEV_IN Interrupt +#define USB_INT_DEV_IN_EP1 0x00000002 // Endpoint 1 DEV_IN Interrupt +#define USB_INT_EP0 0x00000001 // Endpoint 0 Interrupt + +#define USBDevEndpointConfig USBDevEndpointConfigSet +extern void USBIntDisable(unsigned long ulBase, unsigned long ulIntFlags); +extern void USBIntEnable(unsigned long ulBase, unsigned long ulIntFlags); +extern unsigned long USBIntStatus(unsigned long ulBase); +#endif + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __USB_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/watchdog.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/watchdog.c new file mode 100644 index 00000000..e9d66c9d --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/watchdog.c @@ -0,0 +1,564 @@ +//***************************************************************************** +// +// watchdog.c - Driver for the Watchdog Timer Module. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +//***************************************************************************** +// +//! \addtogroup watchdog_api +//! @{ +// +//***************************************************************************** + +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_types.h" +#include "inc/hw_watchdog.h" +#include "driverlib/debug.h" +#include "driverlib/interrupt.h" +#include "driverlib/watchdog.h" + +//***************************************************************************** +// +//! Determines if the watchdog timer is enabled. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! +//! This will check to see if the watchdog timer is enabled. +//! +//! \return Returns \b true if the watchdog timer is enabled, and \b false +//! if it is not. +// +//***************************************************************************** +tBoolean +WatchdogRunning(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // See if the watchdog timer module is enabled, and return. + // + return(HWREG(ulBase + WDT_O_CTL) & WDT_CTL_INTEN); +} + +//***************************************************************************** +// +//! Enables the watchdog timer. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! +//! This will enable the watchdog timer counter and interrupt. +//! +//! \note This function will have no effect if the watchdog timer has +//! been locked. +//! +//! \sa WatchdogLock(), WatchdogUnlock() +//! +//! \return None. +// +//***************************************************************************** +void +WatchdogEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Enable the watchdog timer module. + // + HWREG(ulBase + WDT_O_CTL) |= WDT_CTL_INTEN; +} + +//***************************************************************************** +// +//! Enables the watchdog timer reset. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! +//! Enables the capability of the watchdog timer to issue a reset to the +//! processor upon a second timeout condition. +//! +//! \note This function will have no effect if the watchdog timer has +//! been locked. +//! +//! \sa WatchdogLock(), WatchdogUnlock() +//! +//! \return None. +// +//***************************************************************************** +void +WatchdogResetEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Enable the watchdog reset. + // + HWREG(ulBase + WDT_O_CTL) |= WDT_CTL_RESEN; +} + +//***************************************************************************** +// +//! Disables the watchdog timer reset. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! +//! Disables the capability of the watchdog timer to issue a reset to the +//! processor upon a second timeout condition. +//! +//! \note This function will have no effect if the watchdog timer has +//! been locked. +//! +//! \sa WatchdogLock(), WatchdogUnlock() +//! +//! \return None. +// +//***************************************************************************** +void +WatchdogResetDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Disable the watchdog reset. + // + HWREG(ulBase + WDT_O_CTL) &= ~(WDT_CTL_RESEN); +} + +//***************************************************************************** +// +//! Enables the watchdog timer lock mechanism. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! +//! Locks out write access to the watchdog timer configuration registers. +//! +//! \return None. +// +//***************************************************************************** +void +WatchdogLock(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Lock out watchdog register writes. Writing anything to the WDT_O_LOCK + // register causes the lock to go into effect. + // + HWREG(ulBase + WDT_O_LOCK) = WDT_LOCK_LOCKED; +} + +//***************************************************************************** +// +//! Disables the watchdog timer lock mechanism. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! +//! Enables write access to the watchdog timer configuration registers. +//! +//! \return None. +// +//***************************************************************************** +void +WatchdogUnlock(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Unlock watchdog register writes. + // + HWREG(ulBase + WDT_O_LOCK) = WDT_LOCK_UNLOCK; +} + +//***************************************************************************** +// +//! Gets the state of the watchdog timer lock mechanism. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! +//! Returns the lock state of the watchdog timer registers. +//! +//! \return Returns \b true if the watchdog timer registers are locked, and +//! \b false if they are not locked. +// +//***************************************************************************** +tBoolean +WatchdogLockState(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Get the lock state. + // + return((HWREG(ulBase + WDT_O_LOCK) == WDT_LOCK_LOCKED) ? true : false); +} + +//***************************************************************************** +// +//! Sets the watchdog timer reload value. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! \param ulLoadVal is the load value for the watchdog timer. +//! +//! This function sets the value to load into the watchdog timer when the count +//! reaches zero for the first time; if the watchdog timer is running when this +//! function is called, then the value will be immediately loaded into the +//! watchdog timer counter. If the \e ulLoadVal parameter is 0, then an +//! interrupt is immediately generated. +//! +//! \note This function will have no effect if the watchdog timer has +//! been locked. +//! +//! \sa WatchdogLock(), WatchdogUnlock(), WatchdogReloadGet() +//! +//! \return None. +// +//***************************************************************************** +void +WatchdogReloadSet(unsigned long ulBase, unsigned long ulLoadVal) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Set the load register. + // + HWREG(ulBase + WDT_O_LOAD) = ulLoadVal; +} + +//***************************************************************************** +// +//! Gets the watchdog timer reload value. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! +//! This function gets the value that is loaded into the watchdog timer when +//! the count reaches zero for the first time. +//! +//! \sa WatchdogReloadSet() +//! +//! \return None. +// +//***************************************************************************** +unsigned long +WatchdogReloadGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Get the load register. + // + return(HWREG(ulBase + WDT_O_LOAD)); +} + +//***************************************************************************** +// +//! Gets the current watchdog timer value. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! +//! This function reads the current value of the watchdog timer. +//! +//! \return Returns the current value of the watchdog timer. +// +//***************************************************************************** +unsigned long +WatchdogValueGet(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Get the current watchdog timer register value. + // + return(HWREG(ulBase + WDT_O_VALUE)); +} + +//***************************************************************************** +// +//! Registers an interrupt handler for watchdog timer interrupt. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! \param pfnHandler is a pointer to the function to be called when the +//! watchdog timer interrupt occurs. +//! +//! This function does the actual registering of the interrupt handler. This +//! will enable the global interrupt in the interrupt controller; the watchdog +//! timer interrupt must be enabled via WatchdogEnable(). It is the interrupt +//! handler's responsibility to clear the interrupt source via +//! WatchdogIntClear(). +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +WatchdogIntRegister(unsigned long ulBase, void (*pfnHandler)(void)) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Register the interrupt handler. + // + IntRegister(INT_WATCHDOG, pfnHandler); + + // + // Enable the watchdog timer interrupt. + // + IntEnable(INT_WATCHDOG); +} + +//***************************************************************************** +// +//! Unregisters an interrupt handler for the watchdog timer interrupt. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! +//! This function does the actual unregistering of the interrupt handler. This +//! function will clear the handler to be called when a watchdog timer +//! interrupt occurs. This will also mask off the interrupt in the interrupt +//! controller so that the interrupt handler no longer is called. +//! +//! \sa IntRegister() for important information about registering interrupt +//! handlers. +//! +//! \return None. +// +//***************************************************************************** +void +WatchdogIntUnregister(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Disable the interrupt. + // + IntDisable(INT_WATCHDOG); + + // + // Unregister the interrupt handler. + // + IntUnregister(INT_WATCHDOG); +} + +//***************************************************************************** +// +//! Enables the watchdog timer interrupt. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! +//! Enables the watchdog timer interrupt. +//! +//! \note This function will have no effect if the watchdog timer has +//! been locked. +//! +//! \sa WatchdogLock(), WatchdogUnlock(), WatchdogEnable() +//! +//! \return None. +// +//***************************************************************************** +void +WatchdogIntEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Enable the watchdog interrupt. + // + HWREG(ulBase + WDT_O_CTL) |= WDT_CTL_INTEN; +} + +//***************************************************************************** +// +//! Gets the current watchdog timer interrupt status. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! \param bMasked is \b false if the raw interrupt status is required and +//! \b true if the masked interrupt status is required. +//! +//! This returns the interrupt status for the watchdog timer module. Either +//! the raw interrupt status or the status of interrupt that is allowed to +//! reflect to the processor can be returned. +//! +//! \return Returns the current interrupt status, where a 1 indicates that the +//! watchdog interrupt is active, and a 0 indicates that it is not active. +// +//***************************************************************************** +unsigned long +WatchdogIntStatus(unsigned long ulBase, tBoolean bMasked) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Return either the interrupt status or the raw interrupt status as + // requested. + // + if(bMasked) + { + return(HWREG(ulBase + WDT_O_MIS)); + } + else + { + return(HWREG(ulBase + WDT_O_RIS)); + } +} + +//***************************************************************************** +// +//! Clears the watchdog timer interrupt. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! +//! The watchdog timer interrupt source is cleared, so that it no longer +//! asserts. +//! +//! \note Because there is a write buffer in the Cortex-M3 processor, it may +//! take several clock cycles before the interrupt source is actually cleared. +//! Therefore, it is recommended that the interrupt source be cleared early in +//! the interrupt handler (as opposed to the very last action) to avoid +//! returning from the interrupt handler before the interrupt source is +//! actually cleared. Failure to do so may result in the interrupt handler +//! being immediately reentered (because the interrupt controller still sees +//! the interrupt source asserted). +//! +//! \return None. +// +//***************************************************************************** +void +WatchdogIntClear(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Clear the interrupt source. + // + HWREG(ulBase + WDT_O_ICR) = WDT_INT_TIMEOUT; +} + +//***************************************************************************** +// +//! Enables stalling of the watchdog timer during debug events. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! +//! This function allows the watchdog timer to stop counting when the processor +//! is stopped by the debugger. By doing so, the watchdog is prevented from +//! expiring (typically almost immediately from a human time perspective) and +//! resetting the system (if reset is enabled). The watchdog will instead +//! expired after the appropriate number of processor cycles have been executed +//! while debugging (or at the appropriate time after the processor has been +//! restarted). +//! +//! \return None. +// +//***************************************************************************** +void +WatchdogStallEnable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Enable timer stalling. + // + HWREG(ulBase + WDT_O_TEST) |= WDT_TEST_STALL; +} + +//***************************************************************************** +// +//! Disables stalling of the watchdog timer during debug events. +//! +//! \param ulBase is the base address of the watchdog timer module. +//! +//! This function disables the debug mode stall of the watchdog timer. By +//! doing so, the watchdog timer continues to count regardless of the processor +//! debug state. +//! +//! \return None. +// +//***************************************************************************** +void +WatchdogStallDisable(unsigned long ulBase) +{ + // + // Check the arguments. + // + ASSERT((ulBase == WATCHDOG0_BASE) || (ulBase == WATCHDOG1_BASE)); + + // + // Disable timer stalling. + // + HWREG(ulBase + WDT_O_TEST) &= ~(WDT_TEST_STALL); +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/watchdog.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/watchdog.h new file mode 100644 index 00000000..93b38879 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/driverlib/watchdog.h @@ -0,0 +1,71 @@ +//***************************************************************************** +// +// watchdog.h - Prototypes for the Watchdog Timer API +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Peripheral Driver Library. +// +//***************************************************************************** + +#ifndef __WATCHDOG_H__ +#define __WATCHDOG_H__ + +//***************************************************************************** +// +// If building with a C++ compiler, make all of the definitions in this header +// have a C binding. +// +//***************************************************************************** +#ifdef __cplusplus +extern "C" +{ +#endif + +//***************************************************************************** +// +// Prototypes for the APIs. +// +//***************************************************************************** +extern tBoolean WatchdogRunning(unsigned long ulBase); +extern void WatchdogEnable(unsigned long ulBase); +extern void WatchdogResetEnable(unsigned long ulBase); +extern void WatchdogResetDisable(unsigned long ulBase); +extern void WatchdogLock(unsigned long ulBase); +extern void WatchdogUnlock(unsigned long ulBase); +extern tBoolean WatchdogLockState(unsigned long ulBase); +extern void WatchdogReloadSet(unsigned long ulBase, unsigned long ulLoadVal); +extern unsigned long WatchdogReloadGet(unsigned long ulBase); +extern unsigned long WatchdogValueGet(unsigned long ulBase); +extern void WatchdogIntRegister(unsigned long ulBase, void(*pfnHandler)(void)); +extern void WatchdogIntUnregister(unsigned long ulBase); +extern void WatchdogIntEnable(unsigned long ulBase); +extern unsigned long WatchdogIntStatus(unsigned long ulBase, tBoolean bMasked); +extern void WatchdogIntClear(unsigned long ulBase); +extern void WatchdogStallEnable(unsigned long ulBase); +extern void WatchdogStallDisable(unsigned long ulBase); + +//***************************************************************************** +// +// Mark the end of the C bindings section for C++ compilers. +// +//***************************************************************************** +#ifdef __cplusplus +} +#endif + +#endif // __WATCHDOG_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/asmdefs.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/asmdefs.h new file mode 100644 index 00000000..6a134fd1 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/asmdefs.h @@ -0,0 +1,212 @@ +//***************************************************************************** +// +// asmdefs.h - Macros to allow assembly code be portable among toolchains. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __ASMDEFS_H__ +#define __ASMDEFS_H__ + +//***************************************************************************** +// +// The defines required for code_red. +// +//***************************************************************************** +#ifdef codered + +// +// The assembly code preamble required to put the assembler into the correct +// configuration. +// + .syntax unified + .thumb + +// +// Section headers. +// +#define __LIBRARY__ @ +#define __TEXT__ .text +#define __DATA__ .data +#define __BSS__ .bss +#define __TEXT_NOROOT__ .text + +// +// Assembler nmenonics. +// +#define __ALIGN__ .balign 4 +#define __END__ .end +#define __EXPORT__ .globl +#define __IMPORT__ .extern +#define __LABEL__ : +#define __STR__ .ascii +#define __THUMB_LABEL__ .thumb_func +#define __WORD__ .word +#define __INLINE_DATA__ + +#endif // codered + +//***************************************************************************** +// +// The defines required for EW-ARM. +// +//***************************************************************************** +#ifdef ewarm + +// +// Section headers. +// +#define __LIBRARY__ module +#define __TEXT__ rseg CODE:CODE(2) +#define __DATA__ rseg DATA:DATA(2) +#define __BSS__ rseg DATA:DATA(2) +#define __TEXT_NOROOT__ rseg CODE:CODE:NOROOT(2) + +// +// Assembler nmenonics. +// +#define __ALIGN__ alignrom 2 +#define __END__ end +#define __EXPORT__ export +#define __IMPORT__ import +#define __LABEL__ +#define __STR__ dcb +#define __THUMB_LABEL__ thumb +#define __WORD__ dcd +#define __INLINE_DATA__ data + +#endif // ewarm + +//***************************************************************************** +// +// The defines required for GCC. +// +//***************************************************************************** +#if defined(gcc) + +// +// The assembly code preamble required to put the assembler into the correct +// configuration. +// + .syntax unified + .thumb + +// +// Section headers. +// +#define __LIBRARY__ @ +#define __TEXT__ .text +#define __DATA__ .data +#define __BSS__ .bss +#define __TEXT_NOROOT__ .text + +// +// Assembler nmenonics. +// +#define __ALIGN__ .balign 4 +#define __END__ .end +#define __EXPORT__ .globl +#define __IMPORT__ .extern +#define __LABEL__ : +#define __STR__ .ascii +#define __THUMB_LABEL__ .thumb_func +#define __WORD__ .word +#define __INLINE_DATA__ + +#endif // gcc + +//***************************************************************************** +// +// The defines required for RV-MDK. +// +//***************************************************************************** +#ifdef rvmdk + +// +// The assembly code preamble required to put the assembler into the correct +// configuration. +// + thumb + require8 + preserve8 + +// +// Section headers. +// +#define __LIBRARY__ ; +#define __TEXT__ area ||.text||, code, readonly, align=2 +#define __DATA__ area ||.data||, data, align=2 +#define __BSS__ area ||.bss||, noinit, align=2 +#define __TEXT_NOROOT__ area ||.text||, code, readonly, align=2 + +// +// Assembler nmenonics. +// +#define __ALIGN__ align 4 +#define __END__ end +#define __EXPORT__ export +#define __IMPORT__ import +#define __LABEL__ +#define __STR__ dcb +#define __THUMB_LABEL__ +#define __WORD__ dcd +#define __INLINE_DATA__ + +#endif // rvmdk + +//***************************************************************************** +// +// The defines required for Sourcery G++. +// +//***************************************************************************** +#if defined(sourcerygxx) + +// +// The assembly code preamble required to put the assembler into the correct +// configuration. +// + .syntax unified + .thumb + +// +// Section headers. +// +#define __LIBRARY__ @ +#define __TEXT__ .text +#define __DATA__ .data +#define __BSS__ .bss +#define __TEXT_NOROOT__ .text + +// +// Assembler nmenonics. +// +#define __ALIGN__ .balign 4 +#define __END__ .end +#define __EXPORT__ .globl +#define __IMPORT__ .extern +#define __LABEL__ : +#define __STR__ .ascii +#define __THUMB_LABEL__ .thumb_func +#define __WORD__ .word +#define __INLINE_DATA__ + +#endif // sourcerygxx + +#endif // __ASMDEF_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_adc.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_adc.h new file mode 100644 index 00000000..872ad6f5 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_adc.h @@ -0,0 +1,1193 @@ +//***************************************************************************** +// +// hw_adc.h - Macros used when accessing the ADC hardware. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_ADC_H__ +#define __HW_ADC_H__ + +//***************************************************************************** +// +// The following are defines for the ADC register offsets. +// +//***************************************************************************** +#define ADC_O_ACTSS 0x00000000 // ADC Active Sample Sequencer +#define ADC_O_RIS 0x00000004 // ADC Raw Interrupt Status +#define ADC_O_IM 0x00000008 // ADC Interrupt Mask +#define ADC_O_ISC 0x0000000C // ADC Interrupt Status and Clear +#define ADC_O_OSTAT 0x00000010 // ADC Overflow Status +#define ADC_O_EMUX 0x00000014 // ADC Event Multiplexer Select +#define ADC_O_USTAT 0x00000018 // ADC Underflow Status +#define ADC_O_SSPRI 0x00000020 // ADC Sample Sequencer Priority +#define ADC_O_SPC 0x00000024 // ADC Sample Phase Control +#define ADC_O_PSSI 0x00000028 // ADC Processor Sample Sequence + // Initiate +#define ADC_O_SAC 0x00000030 // ADC Sample Averaging Control +#define ADC_O_DCISC 0x00000034 // ADC Digital Comparator Interrupt + // Status and Clear +#define ADC_O_CTL 0x00000038 // ADC Control +#define ADC_O_SSMUX0 0x00000040 // ADC Sample Sequence Input + // Multiplexer Select 0 +#define ADC_O_SSCTL0 0x00000044 // ADC Sample Sequence Control 0 +#define ADC_O_SSFIFO0 0x00000048 // ADC Sample Sequence Result FIFO + // 0 +#define ADC_O_SSFSTAT0 0x0000004C // ADC Sample Sequence FIFO 0 + // Status +#define ADC_O_SSOP0 0x00000050 // ADC Sample Sequence 0 Operation +#define ADC_O_SSDC0 0x00000054 // ADC Sample Sequence 0 Digital + // Comparator Select +#define ADC_O_SSMUX1 0x00000060 // ADC Sample Sequence Input + // Multiplexer Select 1 +#define ADC_O_SSCTL1 0x00000064 // ADC Sample Sequence Control 1 +#define ADC_O_SSFIFO1 0x00000068 // ADC Sample Sequence Result FIFO + // 1 +#define ADC_O_SSFSTAT1 0x0000006C // ADC Sample Sequence FIFO 1 + // Status +#define ADC_O_SSOP1 0x00000070 // ADC Sample Sequence 1 Operation +#define ADC_O_SSDC1 0x00000074 // ADC Sample Sequence 1 Digital + // Comparator Select +#define ADC_O_SSMUX2 0x00000080 // ADC Sample Sequence Input + // Multiplexer Select 2 +#define ADC_O_SSCTL2 0x00000084 // ADC Sample Sequence Control 2 +#define ADC_O_SSFIFO2 0x00000088 // ADC Sample Sequence Result FIFO + // 2 +#define ADC_O_SSFSTAT2 0x0000008C // ADC Sample Sequence FIFO 2 + // Status +#define ADC_O_SSOP2 0x00000090 // ADC Sample Sequence 2 Operation +#define ADC_O_SSDC2 0x00000094 // ADC Sample Sequence 2 Digital + // Comparator Select +#define ADC_O_SSMUX3 0x000000A0 // ADC Sample Sequence Input + // Multiplexer Select 3 +#define ADC_O_SSCTL3 0x000000A4 // ADC Sample Sequence Control 3 +#define ADC_O_SSFIFO3 0x000000A8 // ADC Sample Sequence Result FIFO + // 3 +#define ADC_O_SSFSTAT3 0x000000AC // ADC Sample Sequence FIFO 3 + // Status +#define ADC_O_SSOP3 0x000000B0 // ADC Sample Sequence 3 Operation +#define ADC_O_SSDC3 0x000000B4 // ADC Sample Sequence 3 Digital + // Comparator Select +#define ADC_O_TMLB 0x00000100 // ADC Test Mode Loopback +#define ADC_O_DCRIC 0x00000D00 // ADC Digital Comparator Reset + // Initial Conditions +#define ADC_O_DCCTL0 0x00000E00 // ADC Digital Comparator Control 0 +#define ADC_O_DCCTL1 0x00000E04 // ADC Digital Comparator Control 1 +#define ADC_O_DCCTL2 0x00000E08 // ADC Digital Comparator Control 2 +#define ADC_O_DCCTL3 0x00000E0C // ADC Digital Comparator Control 3 +#define ADC_O_DCCTL4 0x00000E10 // ADC Digital Comparator Control 4 +#define ADC_O_DCCTL5 0x00000E14 // ADC Digital Comparator Control 5 +#define ADC_O_DCCTL6 0x00000E18 // ADC Digital Comparator Control 6 +#define ADC_O_DCCTL7 0x00000E1C // ADC Digital Comparator Control 7 +#define ADC_O_DCCMP0 0x00000E40 // ADC Digital Comparator Range 0 +#define ADC_O_DCCMP1 0x00000E44 // ADC Digital Comparator Range 1 +#define ADC_O_DCCMP2 0x00000E48 // ADC Digital Comparator Range 2 +#define ADC_O_DCCMP3 0x00000E4C // ADC Digital Comparator Range 3 +#define ADC_O_DCCMP4 0x00000E50 // ADC Digital Comparator Range 4 +#define ADC_O_DCCMP5 0x00000E54 // ADC Digital Comparator Range 5 +#define ADC_O_DCCMP6 0x00000E58 // ADC Digital Comparator Range 6 +#define ADC_O_DCCMP7 0x00000E5C // ADC Digital Comparator Range 7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_ACTSS register. +// +//***************************************************************************** +#define ADC_ACTSS_ASEN3 0x00000008 // ADC SS3 Enable +#define ADC_ACTSS_ASEN2 0x00000004 // ADC SS2 Enable +#define ADC_ACTSS_ASEN1 0x00000002 // ADC SS1 Enable +#define ADC_ACTSS_ASEN0 0x00000001 // ADC SS0 Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_RIS register. +// +//***************************************************************************** +#define ADC_RIS_INRDC 0x00010000 // Digital Comparator Raw Interrupt + // Status +#define ADC_RIS_INR3 0x00000008 // SS3 Raw Interrupt Status +#define ADC_RIS_INR2 0x00000004 // SS2 Raw Interrupt Status +#define ADC_RIS_INR1 0x00000002 // SS1 Raw Interrupt Status +#define ADC_RIS_INR0 0x00000001 // SS0 Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_IM register. +// +//***************************************************************************** +#define ADC_IM_DCONSS3 0x00080000 // Digital Comparator Interrupt on + // SS3 +#define ADC_IM_DCONSS2 0x00040000 // Digital Comparator Interrupt on + // SS2 +#define ADC_IM_DCONSS1 0x00020000 // Digital Comparator Interrupt on + // SS1 +#define ADC_IM_DCONSS0 0x00010000 // Digital Comparator Interrupt on + // SS0 +#define ADC_IM_MASK3 0x00000008 // SS3 Interrupt Mask +#define ADC_IM_MASK2 0x00000004 // SS2 Interrupt Mask +#define ADC_IM_MASK1 0x00000002 // SS1 Interrupt Mask +#define ADC_IM_MASK0 0x00000001 // SS0 Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_ISC register. +// +//***************************************************************************** +#define ADC_ISC_DCINSS3 0x00080000 // Digital Comparator Interrupt + // Status on SS3 +#define ADC_ISC_DCINSS2 0x00040000 // Digital Comparator Interrupt + // Status on SS2 +#define ADC_ISC_DCINSS1 0x00020000 // Digital Comparator Interrupt + // Status on SS1 +#define ADC_ISC_DCINSS0 0x00010000 // Digital Comparator Interrupt + // Status on SS0 +#define ADC_ISC_IN3 0x00000008 // SS3 Interrupt Status and Clear +#define ADC_ISC_IN2 0x00000004 // SS2 Interrupt Status and Clear +#define ADC_ISC_IN1 0x00000002 // SS1 Interrupt Status and Clear +#define ADC_ISC_IN0 0x00000001 // SS0 Interrupt Status and Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_OSTAT register. +// +//***************************************************************************** +#define ADC_OSTAT_OV3 0x00000008 // SS3 FIFO Overflow +#define ADC_OSTAT_OV2 0x00000004 // SS2 FIFO Overflow +#define ADC_OSTAT_OV1 0x00000002 // SS1 FIFO Overflow +#define ADC_OSTAT_OV0 0x00000001 // SS0 FIFO Overflow + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_EMUX register. +// +//***************************************************************************** +#define ADC_EMUX_EM3_M 0x0000F000 // SS3 Trigger Select +#define ADC_EMUX_EM3_PROCESSOR 0x00000000 // Processor (default) +#define ADC_EMUX_EM3_COMP0 0x00001000 // Analog Comparator 0 +#define ADC_EMUX_EM3_COMP1 0x00002000 // Analog Comparator 1 +#define ADC_EMUX_EM3_COMP2 0x00003000 // Analog Comparator 2 +#define ADC_EMUX_EM3_EXTERNAL 0x00004000 // External (GPIO PB4) +#define ADC_EMUX_EM3_TIMER 0x00005000 // Timer +#define ADC_EMUX_EM3_PWM0 0x00006000 // PWM0 +#define ADC_EMUX_EM3_PWM1 0x00007000 // PWM1 +#define ADC_EMUX_EM3_PWM2 0x00008000 // PWM2 +#define ADC_EMUX_EM3_PWM3 0x00009000 // PWM3 +#define ADC_EMUX_EM3_ALWAYS 0x0000F000 // Always (continuously sample) +#define ADC_EMUX_EM2_M 0x00000F00 // SS2 Trigger Select +#define ADC_EMUX_EM2_PROCESSOR 0x00000000 // Processor (default) +#define ADC_EMUX_EM2_COMP0 0x00000100 // Analog Comparator 0 +#define ADC_EMUX_EM2_COMP1 0x00000200 // Analog Comparator 1 +#define ADC_EMUX_EM2_COMP2 0x00000300 // Analog Comparator 2 +#define ADC_EMUX_EM2_EXTERNAL 0x00000400 // External (GPIO PB4) +#define ADC_EMUX_EM2_TIMER 0x00000500 // Timer +#define ADC_EMUX_EM2_PWM0 0x00000600 // PWM0 +#define ADC_EMUX_EM2_PWM1 0x00000700 // PWM1 +#define ADC_EMUX_EM2_PWM2 0x00000800 // PWM2 +#define ADC_EMUX_EM2_PWM3 0x00000900 // PWM3 +#define ADC_EMUX_EM2_ALWAYS 0x00000F00 // Always (continuously sample) +#define ADC_EMUX_EM1_M 0x000000F0 // SS1 Trigger Select +#define ADC_EMUX_EM1_PROCESSOR 0x00000000 // Processor (default) +#define ADC_EMUX_EM1_COMP0 0x00000010 // Analog Comparator 0 +#define ADC_EMUX_EM1_COMP1 0x00000020 // Analog Comparator 1 +#define ADC_EMUX_EM1_COMP2 0x00000030 // Analog Comparator 2 +#define ADC_EMUX_EM1_EXTERNAL 0x00000040 // External (GPIO PB4) +#define ADC_EMUX_EM1_TIMER 0x00000050 // Timer +#define ADC_EMUX_EM1_PWM0 0x00000060 // PWM0 +#define ADC_EMUX_EM1_PWM1 0x00000070 // PWM1 +#define ADC_EMUX_EM1_PWM2 0x00000080 // PWM2 +#define ADC_EMUX_EM1_PWM3 0x00000090 // PWM3 +#define ADC_EMUX_EM1_ALWAYS 0x000000F0 // Always (continuously sample) +#define ADC_EMUX_EM0_M 0x0000000F // SS0 Trigger Select +#define ADC_EMUX_EM0_PROCESSOR 0x00000000 // Processor (default) +#define ADC_EMUX_EM0_COMP0 0x00000001 // Analog Comparator 0 +#define ADC_EMUX_EM0_COMP1 0x00000002 // Analog Comparator 1 +#define ADC_EMUX_EM0_COMP2 0x00000003 // Analog Comparator 2 +#define ADC_EMUX_EM0_EXTERNAL 0x00000004 // External (GPIO PB4) +#define ADC_EMUX_EM0_TIMER 0x00000005 // Timer +#define ADC_EMUX_EM0_PWM0 0x00000006 // PWM0 +#define ADC_EMUX_EM0_PWM1 0x00000007 // PWM1 +#define ADC_EMUX_EM0_PWM2 0x00000008 // PWM2 +#define ADC_EMUX_EM0_PWM3 0x00000009 // PWM3 +#define ADC_EMUX_EM0_ALWAYS 0x0000000F // Always (continuously sample) + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_USTAT register. +// +//***************************************************************************** +#define ADC_USTAT_UV3 0x00000008 // SS3 FIFO Underflow +#define ADC_USTAT_UV2 0x00000004 // SS2 FIFO Underflow +#define ADC_USTAT_UV1 0x00000002 // SS1 FIFO Underflow +#define ADC_USTAT_UV0 0x00000001 // SS0 FIFO Underflow + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSPRI register. +// +//***************************************************************************** +#define ADC_SSPRI_SS3_M 0x00003000 // SS3 Priority +#define ADC_SSPRI_SS3_1ST 0x00000000 // First priority +#define ADC_SSPRI_SS3_2ND 0x00001000 // Second priority +#define ADC_SSPRI_SS3_3RD 0x00002000 // Third priority +#define ADC_SSPRI_SS3_4TH 0x00003000 // Fourth priority +#define ADC_SSPRI_SS2_M 0x00000300 // SS2 Priority +#define ADC_SSPRI_SS2_1ST 0x00000000 // First priority +#define ADC_SSPRI_SS2_2ND 0x00000100 // Second priority +#define ADC_SSPRI_SS2_3RD 0x00000200 // Third priority +#define ADC_SSPRI_SS2_4TH 0x00000300 // Fourth priority +#define ADC_SSPRI_SS1_M 0x00000030 // SS1 Priority +#define ADC_SSPRI_SS1_1ST 0x00000000 // First priority +#define ADC_SSPRI_SS1_2ND 0x00000010 // Second priority +#define ADC_SSPRI_SS1_3RD 0x00000020 // Third priority +#define ADC_SSPRI_SS1_4TH 0x00000030 // Fourth priority +#define ADC_SSPRI_SS0_M 0x00000003 // SS0 Priority +#define ADC_SSPRI_SS0_1ST 0x00000000 // First priority +#define ADC_SSPRI_SS0_2ND 0x00000001 // Second priority +#define ADC_SSPRI_SS0_3RD 0x00000002 // Third priority +#define ADC_SSPRI_SS0_4TH 0x00000003 // Fourth priority + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SPC register. +// +//***************************************************************************** +#define ADC_SPC_PHASE_M 0x0000000F // Phase Difference +#define ADC_SPC_PHASE_0 0x00000000 // ADC sample lags by 0.0 +#define ADC_SPC_PHASE_22_5 0x00000001 // ADC sample lags by 22.5 +#define ADC_SPC_PHASE_45 0x00000002 // ADC sample lags by 45.0 +#define ADC_SPC_PHASE_67_5 0x00000003 // ADC sample lags by 67.5 +#define ADC_SPC_PHASE_90 0x00000004 // ADC sample lags by 90.0 +#define ADC_SPC_PHASE_112_5 0x00000005 // ADC sample lags by 112.5 +#define ADC_SPC_PHASE_135 0x00000006 // ADC sample lags by 135.0 +#define ADC_SPC_PHASE_157_5 0x00000007 // ADC sample lags by 157.5 +#define ADC_SPC_PHASE_180 0x00000008 // ADC sample lags by 180.0 +#define ADC_SPC_PHASE_202_5 0x00000009 // ADC sample lags by 202.5 +#define ADC_SPC_PHASE_225 0x0000000A // ADC sample lags by 225.0 +#define ADC_SPC_PHASE_247_5 0x0000000B // ADC sample lags by 247.5 +#define ADC_SPC_PHASE_270 0x0000000C // ADC sample lags by 270.0 +#define ADC_SPC_PHASE_292_5 0x0000000D // ADC sample lags by 292.5 +#define ADC_SPC_PHASE_315 0x0000000E // ADC sample lags by 315.0 +#define ADC_SPC_PHASE_337_5 0x0000000F // ADC sample lags by 337.5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_PSSI register. +// +//***************************************************************************** +#define ADC_PSSI_GSYNC 0x80000000 // Global Synchronize +#define ADC_PSSI_SYNCWAIT 0x08000000 // Synchronize Wait +#define ADC_PSSI_SS3 0x00000008 // SS3 Initiate +#define ADC_PSSI_SS2 0x00000004 // SS2 Initiate +#define ADC_PSSI_SS1 0x00000002 // SS1 Initiate +#define ADC_PSSI_SS0 0x00000001 // SS0 Initiate + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SAC register. +// +//***************************************************************************** +#define ADC_SAC_AVG_M 0x00000007 // Hardware Averaging Control +#define ADC_SAC_AVG_OFF 0x00000000 // No hardware oversampling +#define ADC_SAC_AVG_2X 0x00000001 // 2x hardware oversampling +#define ADC_SAC_AVG_4X 0x00000002 // 4x hardware oversampling +#define ADC_SAC_AVG_8X 0x00000003 // 8x hardware oversampling +#define ADC_SAC_AVG_16X 0x00000004 // 16x hardware oversampling +#define ADC_SAC_AVG_32X 0x00000005 // 32x hardware oversampling +#define ADC_SAC_AVG_64X 0x00000006 // 64x hardware oversampling + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCISC register. +// +//***************************************************************************** +#define ADC_DCISC_DCINT7 0x00000080 // Digital Comparator 7 Interrupt + // Status and Clear +#define ADC_DCISC_DCINT6 0x00000040 // Digital Comparator 6 Interrupt + // Status and Clear +#define ADC_DCISC_DCINT5 0x00000020 // Digital Comparator 5 Interrupt + // Status and Clear +#define ADC_DCISC_DCINT4 0x00000010 // Digital Comparator 4 Interrupt + // Status and Clear +#define ADC_DCISC_DCINT3 0x00000008 // Digital Comparator 3 Interrupt + // Status and Clear +#define ADC_DCISC_DCINT2 0x00000004 // Digital Comparator 2 Interrupt + // Status and Clear +#define ADC_DCISC_DCINT1 0x00000002 // Digital Comparator 1 Interrupt + // Status and Clear +#define ADC_DCISC_DCINT0 0x00000001 // Digital Comparator 0 Interrupt + // Status and Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_CTL register. +// +//***************************************************************************** +#define ADC_CTL_VREF 0x00000001 // Voltage Reference Select + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSMUX0 register. +// +//***************************************************************************** +#define ADC_SSMUX0_MUX7_M 0xF0000000 // 8th Sample Input Select +#define ADC_SSMUX0_MUX6_M 0x0F000000 // 7th Sample Input Select +#define ADC_SSMUX0_MUX5_M 0x00F00000 // 6th Sample Input Select +#define ADC_SSMUX0_MUX4_M 0x000F0000 // 5th Sample Input Select +#define ADC_SSMUX0_MUX3_M 0x0000F000 // 4th Sample Input Select +#define ADC_SSMUX0_MUX2_M 0x00000F00 // 3rd Sample Input Select +#define ADC_SSMUX0_MUX1_M 0x000000F0 // 2nd Sample Input Select +#define ADC_SSMUX0_MUX0_M 0x0000000F // 1st Sample Input Select +#define ADC_SSMUX0_MUX7_S 28 +#define ADC_SSMUX0_MUX6_S 24 +#define ADC_SSMUX0_MUX5_S 20 +#define ADC_SSMUX0_MUX4_S 16 +#define ADC_SSMUX0_MUX3_S 12 +#define ADC_SSMUX0_MUX2_S 8 +#define ADC_SSMUX0_MUX1_S 4 +#define ADC_SSMUX0_MUX0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSCTL0 register. +// +//***************************************************************************** +#define ADC_SSCTL0_TS7 0x80000000 // 8th Sample Temp Sensor Select +#define ADC_SSCTL0_IE7 0x40000000 // 8th Sample Interrupt Enable +#define ADC_SSCTL0_END7 0x20000000 // 8th Sample is End of Sequence +#define ADC_SSCTL0_D7 0x10000000 // 8th Sample Diff Input Select +#define ADC_SSCTL0_TS6 0x08000000 // 7th Sample Temp Sensor Select +#define ADC_SSCTL0_IE6 0x04000000 // 7th Sample Interrupt Enable +#define ADC_SSCTL0_END6 0x02000000 // 7th Sample is End of Sequence +#define ADC_SSCTL0_D6 0x01000000 // 7th Sample Diff Input Select +#define ADC_SSCTL0_TS5 0x00800000 // 6th Sample Temp Sensor Select +#define ADC_SSCTL0_IE5 0x00400000 // 6th Sample Interrupt Enable +#define ADC_SSCTL0_END5 0x00200000 // 6th Sample is End of Sequence +#define ADC_SSCTL0_D5 0x00100000 // 6th Sample Diff Input Select +#define ADC_SSCTL0_TS4 0x00080000 // 5th Sample Temp Sensor Select +#define ADC_SSCTL0_IE4 0x00040000 // 5th Sample Interrupt Enable +#define ADC_SSCTL0_END4 0x00020000 // 5th Sample is End of Sequence +#define ADC_SSCTL0_D4 0x00010000 // 5th Sample Diff Input Select +#define ADC_SSCTL0_TS3 0x00008000 // 4th Sample Temp Sensor Select +#define ADC_SSCTL0_IE3 0x00004000 // 4th Sample Interrupt Enable +#define ADC_SSCTL0_END3 0x00002000 // 4th Sample is End of Sequence +#define ADC_SSCTL0_D3 0x00001000 // 4th Sample Diff Input Select +#define ADC_SSCTL0_TS2 0x00000800 // 3rd Sample Temp Sensor Select +#define ADC_SSCTL0_IE2 0x00000400 // 3rd Sample Interrupt Enable +#define ADC_SSCTL0_END2 0x00000200 // 3rd Sample is End of Sequence +#define ADC_SSCTL0_D2 0x00000100 // 3rd Sample Diff Input Select +#define ADC_SSCTL0_TS1 0x00000080 // 2nd Sample Temp Sensor Select +#define ADC_SSCTL0_IE1 0x00000040 // 2nd Sample Interrupt Enable +#define ADC_SSCTL0_END1 0x00000020 // 2nd Sample is End of Sequence +#define ADC_SSCTL0_D1 0x00000010 // 2nd Sample Diff Input Select +#define ADC_SSCTL0_TS0 0x00000008 // 1st Sample Temp Sensor Select +#define ADC_SSCTL0_IE0 0x00000004 // 1st Sample Interrupt Enable +#define ADC_SSCTL0_END0 0x00000002 // 1st Sample is End of Sequence +#define ADC_SSCTL0_D0 0x00000001 // 1st Sample Diff Input Select + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFIFO0 register. +// +//***************************************************************************** +#define ADC_SSFIFO0_DATA_M 0x000003FF // Conversion Result Data +#define ADC_SSFIFO0_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFSTAT0 register. +// +//***************************************************************************** +#define ADC_SSFSTAT0_FULL 0x00001000 // FIFO Full +#define ADC_SSFSTAT0_EMPTY 0x00000100 // FIFO Empty +#define ADC_SSFSTAT0_HPTR_M 0x000000F0 // FIFO Head Pointer +#define ADC_SSFSTAT0_TPTR_M 0x0000000F // FIFO Tail Pointer +#define ADC_SSFSTAT0_HPTR_S 4 +#define ADC_SSFSTAT0_TPTR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSOP0 register. +// +//***************************************************************************** +#define ADC_SSOP0_S7DCOP 0x10000000 // Sample 7 Digital Comparator + // Operation +#define ADC_SSOP0_S6DCOP 0x01000000 // Sample 6 Digital Comparator + // Operation +#define ADC_SSOP0_S5DCOP 0x00100000 // Sample 5 Digital Comparator + // Operation +#define ADC_SSOP0_S4DCOP 0x00010000 // Sample 4 Digital Comparator + // Operation +#define ADC_SSOP0_S3DCOP 0x00001000 // Sample 3 Digital Comparator + // Operation +#define ADC_SSOP0_S2DCOP 0x00000100 // Sample 2 Digital Comparator + // Operation +#define ADC_SSOP0_S1DCOP 0x00000010 // Sample 1 Digital Comparator + // Operation +#define ADC_SSOP0_S0DCOP 0x00000001 // Sample 0 Digital Comparator + // Operation + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSDC0 register. +// +//***************************************************************************** +#define ADC_SSDC0_S7DCSEL_M 0xF0000000 // Sample 7 Digital Comparator + // Select +#define ADC_SSDC0_S6DCSEL_M 0x0F000000 // Sample 6 Digital Comparator + // Select +#define ADC_SSDC0_S5DCSEL_M 0x00F00000 // Sample 5 Digital Comparator + // Select +#define ADC_SSDC0_S4DCSEL_M 0x000F0000 // Sample 4 Digital Comparator + // Select +#define ADC_SSDC0_S3DCSEL_M 0x0000F000 // Sample 3 Digital Comparator + // Select +#define ADC_SSDC0_S2DCSEL_M 0x00000F00 // Sample 2 Digital Comparator + // Select +#define ADC_SSDC0_S1DCSEL_M 0x000000F0 // Sample 1 Digital Comparator + // Select +#define ADC_SSDC0_S0DCSEL_M 0x0000000F // Sample 0 Digital Comparator + // Select +#define ADC_SSDC0_S6DCSEL_S 24 +#define ADC_SSDC0_S5DCSEL_S 20 +#define ADC_SSDC0_S4DCSEL_S 16 +#define ADC_SSDC0_S3DCSEL_S 12 +#define ADC_SSDC0_S2DCSEL_S 8 +#define ADC_SSDC0_S1DCSEL_S 4 +#define ADC_SSDC0_S0DCSEL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSMUX1 register. +// +//***************************************************************************** +#define ADC_SSMUX1_MUX3_M 0x0000F000 // 4th Sample Input Select +#define ADC_SSMUX1_MUX2_M 0x00000F00 // 3rd Sample Input Select +#define ADC_SSMUX1_MUX1_M 0x000000F0 // 2nd Sample Input Select +#define ADC_SSMUX1_MUX0_M 0x0000000F // 1st Sample Input Select +#define ADC_SSMUX1_MUX3_S 12 +#define ADC_SSMUX1_MUX2_S 8 +#define ADC_SSMUX1_MUX1_S 4 +#define ADC_SSMUX1_MUX0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSCTL1 register. +// +//***************************************************************************** +#define ADC_SSCTL1_TS3 0x00008000 // 4th Sample Temp Sensor Select +#define ADC_SSCTL1_IE3 0x00004000 // 4th Sample Interrupt Enable +#define ADC_SSCTL1_END3 0x00002000 // 4th Sample is End of Sequence +#define ADC_SSCTL1_D3 0x00001000 // 4th Sample Diff Input Select +#define ADC_SSCTL1_TS2 0x00000800 // 3rd Sample Temp Sensor Select +#define ADC_SSCTL1_IE2 0x00000400 // 3rd Sample Interrupt Enable +#define ADC_SSCTL1_END2 0x00000200 // 3rd Sample is End of Sequence +#define ADC_SSCTL1_D2 0x00000100 // 3rd Sample Diff Input Select +#define ADC_SSCTL1_TS1 0x00000080 // 2nd Sample Temp Sensor Select +#define ADC_SSCTL1_IE1 0x00000040 // 2nd Sample Interrupt Enable +#define ADC_SSCTL1_END1 0x00000020 // 2nd Sample is End of Sequence +#define ADC_SSCTL1_D1 0x00000010 // 2nd Sample Diff Input Select +#define ADC_SSCTL1_TS0 0x00000008 // 1st Sample Temp Sensor Select +#define ADC_SSCTL1_IE0 0x00000004 // 1st Sample Interrupt Enable +#define ADC_SSCTL1_END0 0x00000002 // 1st Sample is End of Sequence +#define ADC_SSCTL1_D0 0x00000001 // 1st Sample Diff Input Select + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFIFO1 register. +// +//***************************************************************************** +#define ADC_SSFIFO1_DATA_M 0x000003FF // Conversion Result Data +#define ADC_SSFIFO1_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFSTAT1 register. +// +//***************************************************************************** +#define ADC_SSFSTAT1_FULL 0x00001000 // FIFO Full +#define ADC_SSFSTAT1_EMPTY 0x00000100 // FIFO Empty +#define ADC_SSFSTAT1_HPTR_M 0x000000F0 // FIFO Head Pointer +#define ADC_SSFSTAT1_TPTR_M 0x0000000F // FIFO Tail Pointer +#define ADC_SSFSTAT1_HPTR_S 4 +#define ADC_SSFSTAT1_TPTR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSOP1 register. +// +//***************************************************************************** +#define ADC_SSOP1_S3DCOP 0x00001000 // Sample 3 Digital Comparator + // Operation +#define ADC_SSOP1_S2DCOP 0x00000100 // Sample 2 Digital Comparator + // Operation +#define ADC_SSOP1_S1DCOP 0x00000010 // Sample 1 Digital Comparator + // Operation +#define ADC_SSOP1_S0DCOP 0x00000001 // Sample 0 Digital Comparator + // Operation + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSDC1 register. +// +//***************************************************************************** +#define ADC_SSDC1_S3DCSEL_M 0x0000F000 // Sample 3 Digital Comparator + // Select +#define ADC_SSDC1_S2DCSEL_M 0x00000F00 // Sample 2 Digital Comparator + // Select +#define ADC_SSDC1_S1DCSEL_M 0x000000F0 // Sample 1 Digital Comparator + // Select +#define ADC_SSDC1_S0DCSEL_M 0x0000000F // Sample 0 Digital Comparator + // Select +#define ADC_SSDC1_S2DCSEL_S 8 +#define ADC_SSDC1_S1DCSEL_S 4 +#define ADC_SSDC1_S0DCSEL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSMUX2 register. +// +//***************************************************************************** +#define ADC_SSMUX2_MUX3_M 0x0000F000 // 4th Sample Input Select +#define ADC_SSMUX2_MUX2_M 0x00000F00 // 3rd Sample Input Select +#define ADC_SSMUX2_MUX1_M 0x000000F0 // 2nd Sample Input Select +#define ADC_SSMUX2_MUX0_M 0x0000000F // 1st Sample Input Select +#define ADC_SSMUX2_MUX3_S 12 +#define ADC_SSMUX2_MUX2_S 8 +#define ADC_SSMUX2_MUX1_S 4 +#define ADC_SSMUX2_MUX0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSCTL2 register. +// +//***************************************************************************** +#define ADC_SSCTL2_TS3 0x00008000 // 4th Sample Temp Sensor Select +#define ADC_SSCTL2_IE3 0x00004000 // 4th Sample Interrupt Enable +#define ADC_SSCTL2_END3 0x00002000 // 4th Sample is End of Sequence +#define ADC_SSCTL2_D3 0x00001000 // 4th Sample Diff Input Select +#define ADC_SSCTL2_TS2 0x00000800 // 3rd Sample Temp Sensor Select +#define ADC_SSCTL2_IE2 0x00000400 // 3rd Sample Interrupt Enable +#define ADC_SSCTL2_END2 0x00000200 // 3rd Sample is End of Sequence +#define ADC_SSCTL2_D2 0x00000100 // 3rd Sample Diff Input Select +#define ADC_SSCTL2_TS1 0x00000080 // 2nd Sample Temp Sensor Select +#define ADC_SSCTL2_IE1 0x00000040 // 2nd Sample Interrupt Enable +#define ADC_SSCTL2_END1 0x00000020 // 2nd Sample is End of Sequence +#define ADC_SSCTL2_D1 0x00000010 // 2nd Sample Diff Input Select +#define ADC_SSCTL2_TS0 0x00000008 // 1st Sample Temp Sensor Select +#define ADC_SSCTL2_IE0 0x00000004 // 1st Sample Interrupt Enable +#define ADC_SSCTL2_END0 0x00000002 // 1st Sample is End of Sequence +#define ADC_SSCTL2_D0 0x00000001 // 1st Sample Diff Input Select + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFIFO2 register. +// +//***************************************************************************** +#define ADC_SSFIFO2_DATA_M 0x000003FF // Conversion Result Data +#define ADC_SSFIFO2_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFSTAT2 register. +// +//***************************************************************************** +#define ADC_SSFSTAT2_FULL 0x00001000 // FIFO Full +#define ADC_SSFSTAT2_EMPTY 0x00000100 // FIFO Empty +#define ADC_SSFSTAT2_HPTR_M 0x000000F0 // FIFO Head Pointer +#define ADC_SSFSTAT2_TPTR_M 0x0000000F // FIFO Tail Pointer +#define ADC_SSFSTAT2_HPTR_S 4 +#define ADC_SSFSTAT2_TPTR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSOP2 register. +// +//***************************************************************************** +#define ADC_SSOP2_S3DCOP 0x00001000 // Sample 3 Digital Comparator + // Operation +#define ADC_SSOP2_S2DCOP 0x00000100 // Sample 2 Digital Comparator + // Operation +#define ADC_SSOP2_S1DCOP 0x00000010 // Sample 1 Digital Comparator + // Operation +#define ADC_SSOP2_S0DCOP 0x00000001 // Sample 0 Digital Comparator + // Operation + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSDC2 register. +// +//***************************************************************************** +#define ADC_SSDC2_S3DCSEL_M 0x0000F000 // Sample 3 Digital Comparator + // Select +#define ADC_SSDC2_S2DCSEL_M 0x00000F00 // Sample 2 Digital Comparator + // Select +#define ADC_SSDC2_S1DCSEL_M 0x000000F0 // Sample 1 Digital Comparator + // Select +#define ADC_SSDC2_S0DCSEL_M 0x0000000F // Sample 0 Digital Comparator + // Select +#define ADC_SSDC2_S2DCSEL_S 8 +#define ADC_SSDC2_S1DCSEL_S 4 +#define ADC_SSDC2_S0DCSEL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSMUX3 register. +// +//***************************************************************************** +#define ADC_SSMUX3_MUX0_M 0x0000000F // 1st Sample Input Select +#define ADC_SSMUX3_MUX0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSCTL3 register. +// +//***************************************************************************** +#define ADC_SSCTL3_TS0 0x00000008 // 1st Sample Temp Sensor Select +#define ADC_SSCTL3_IE0 0x00000004 // 1st Sample Interrupt Enable +#define ADC_SSCTL3_END0 0x00000002 // 1st Sample is End of Sequence +#define ADC_SSCTL3_D0 0x00000001 // 1st Sample Diff Input Select + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFIFO3 register. +// +//***************************************************************************** +#define ADC_SSFIFO3_DATA_M 0x000003FF // Conversion Result Data +#define ADC_SSFIFO3_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFSTAT3 register. +// +//***************************************************************************** +#define ADC_SSFSTAT3_FULL 0x00001000 // FIFO Full +#define ADC_SSFSTAT3_EMPTY 0x00000100 // FIFO Empty +#define ADC_SSFSTAT3_HPTR_M 0x000000F0 // FIFO Head Pointer +#define ADC_SSFSTAT3_TPTR_M 0x0000000F // FIFO Tail Pointer +#define ADC_SSFSTAT3_HPTR_S 4 +#define ADC_SSFSTAT3_TPTR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSOP3 register. +// +//***************************************************************************** +#define ADC_SSOP3_S0DCOP 0x00000001 // Sample 0 Digital Comparator + // Operation + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSDC3 register. +// +//***************************************************************************** +#define ADC_SSDC3_S0DCSEL_M 0x0000000F // Sample 0 Digital Comparator + // Select + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_TMLB register. +// +//***************************************************************************** +#define ADC_TMLB_LB 0x00000001 // Loopback Mode Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCRIC register. +// +//***************************************************************************** +#define ADC_DCRIC_DCTRIG7 0x00800000 // Digital Comparator Trigger 7 +#define ADC_DCRIC_DCTRIG6 0x00400000 // Digital Comparator Trigger 6 +#define ADC_DCRIC_DCTRIG5 0x00200000 // Digital Comparator Trigger 5 +#define ADC_DCRIC_DCTRIG4 0x00100000 // Digital Comparator Trigger 4 +#define ADC_DCRIC_DCTRIG3 0x00080000 // Digital Comparator Trigger 3 +#define ADC_DCRIC_DCTRIG2 0x00040000 // Digital Comparator Trigger 2 +#define ADC_DCRIC_DCTRIG1 0x00020000 // Digital Comparator Trigger 1 +#define ADC_DCRIC_DCTRIG0 0x00010000 // Digital Comparator Trigger 0 +#define ADC_DCRIC_DCINT7 0x00000080 // Digital Comparator Interrupt 7 +#define ADC_DCRIC_DCINT6 0x00000040 // Digital Comparator Interrupt 6 +#define ADC_DCRIC_DCINT5 0x00000020 // Digital Comparator Interrupt 5 +#define ADC_DCRIC_DCINT4 0x00000010 // Digital Comparator Interrupt 4 +#define ADC_DCRIC_DCINT3 0x00000008 // Digital Comparator Interrupt 3 +#define ADC_DCRIC_DCINT2 0x00000004 // Digital Comparator Interrupt 2 +#define ADC_DCRIC_DCINT1 0x00000002 // Digital Comparator Interrupt 1 +#define ADC_DCRIC_DCINT0 0x00000001 // Digital Comparator Interrupt 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCTL0 register. +// +//***************************************************************************** +#define ADC_DCCTL0_CTE 0x00001000 // Comparison Trigger Enable +#define ADC_DCCTL0_CTC_M 0x00000C00 // Comparison Trigger Condition +#define ADC_DCCTL0_CTC_LOW 0x00000000 // Low Band +#define ADC_DCCTL0_CTC_MID 0x00000400 // Mid Band +#define ADC_DCCTL0_CTC_HIGH 0x00000C00 // High Band +#define ADC_DCCTL0_CTM_M 0x00000300 // Comparison Trigger Mode +#define ADC_DCCTL0_CTM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL0_CTM_ONCE 0x00000100 // Once +#define ADC_DCCTL0_CTM_HALWAYS 0x00000200 // Hysteresis Always +#define ADC_DCCTL0_CTM_HONCE 0x00000300 // Hysteresis Once +#define ADC_DCCTL0_CIE 0x00000010 // Comparison Interrupt Enable +#define ADC_DCCTL0_CIC_M 0x0000000C // Comparison Interrupt Condition +#define ADC_DCCTL0_CIC_LOW 0x00000000 // Low Band +#define ADC_DCCTL0_CIC_MID 0x00000004 // Mid Band +#define ADC_DCCTL0_CIC_HIGH 0x0000000C // High Band +#define ADC_DCCTL0_CIM_M 0x00000003 // Comparison Interrupt Mode +#define ADC_DCCTL0_CIM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL0_CIM_ONCE 0x00000001 // Once +#define ADC_DCCTL0_CIM_HALWAYS 0x00000002 // Hysteresis Always +#define ADC_DCCTL0_CIM_HONCE 0x00000003 // Hysteresis Once + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCTL1 register. +// +//***************************************************************************** +#define ADC_DCCTL1_CTE 0x00001000 // Comparison Trigger Enable +#define ADC_DCCTL1_CTC_M 0x00000C00 // Comparison Trigger Condition +#define ADC_DCCTL1_CTC_LOW 0x00000000 // Low Band +#define ADC_DCCTL1_CTC_MID 0x00000400 // Mid Band +#define ADC_DCCTL1_CTC_HIGH 0x00000C00 // High Band +#define ADC_DCCTL1_CTM_M 0x00000300 // Comparison Trigger Mode +#define ADC_DCCTL1_CTM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL1_CTM_ONCE 0x00000100 // Once +#define ADC_DCCTL1_CTM_HALWAYS 0x00000200 // Hysteresis Always +#define ADC_DCCTL1_CTM_HONCE 0x00000300 // Hysteresis Once +#define ADC_DCCTL1_CIE 0x00000010 // Comparison Interrupt Enable +#define ADC_DCCTL1_CIC_M 0x0000000C // Comparison Interrupt Condition +#define ADC_DCCTL1_CIC_LOW 0x00000000 // Low Band +#define ADC_DCCTL1_CIC_MID 0x00000004 // Mid Band +#define ADC_DCCTL1_CIC_HIGH 0x0000000C // High Band +#define ADC_DCCTL1_CIM_M 0x00000003 // Comparison Interrupt Mode +#define ADC_DCCTL1_CIM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL1_CIM_ONCE 0x00000001 // Once +#define ADC_DCCTL1_CIM_HALWAYS 0x00000002 // Hysteresis Always +#define ADC_DCCTL1_CIM_HONCE 0x00000003 // Hysteresis Once + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCTL2 register. +// +//***************************************************************************** +#define ADC_DCCTL2_CTE 0x00001000 // Comparison Trigger Enable +#define ADC_DCCTL2_CTC_M 0x00000C00 // Comparison Trigger Condition +#define ADC_DCCTL2_CTC_LOW 0x00000000 // Low Band +#define ADC_DCCTL2_CTC_MID 0x00000400 // Mid Band +#define ADC_DCCTL2_CTC_HIGH 0x00000C00 // High Band +#define ADC_DCCTL2_CTM_M 0x00000300 // Comparison Trigger Mode +#define ADC_DCCTL2_CTM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL2_CTM_ONCE 0x00000100 // Once +#define ADC_DCCTL2_CTM_HALWAYS 0x00000200 // Hysteresis Always +#define ADC_DCCTL2_CTM_HONCE 0x00000300 // Hysteresis Once +#define ADC_DCCTL2_CIE 0x00000010 // Comparison Interrupt Enable +#define ADC_DCCTL2_CIC_M 0x0000000C // Comparison Interrupt Condition +#define ADC_DCCTL2_CIC_LOW 0x00000000 // Low Band +#define ADC_DCCTL2_CIC_MID 0x00000004 // Mid Band +#define ADC_DCCTL2_CIC_HIGH 0x0000000C // High Band +#define ADC_DCCTL2_CIM_M 0x00000003 // Comparison Interrupt Mode +#define ADC_DCCTL2_CIM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL2_CIM_ONCE 0x00000001 // Once +#define ADC_DCCTL2_CIM_HALWAYS 0x00000002 // Hysteresis Always +#define ADC_DCCTL2_CIM_HONCE 0x00000003 // Hysteresis Once + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCTL3 register. +// +//***************************************************************************** +#define ADC_DCCTL3_CTE 0x00001000 // Comparison Trigger Enable +#define ADC_DCCTL3_CTC_M 0x00000C00 // Comparison Trigger Condition +#define ADC_DCCTL3_CTC_LOW 0x00000000 // Low Band +#define ADC_DCCTL3_CTC_MID 0x00000400 // Mid Band +#define ADC_DCCTL3_CTC_HIGH 0x00000C00 // High Band +#define ADC_DCCTL3_CTM_M 0x00000300 // Comparison Trigger Mode +#define ADC_DCCTL3_CTM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL3_CTM_ONCE 0x00000100 // Once +#define ADC_DCCTL3_CTM_HALWAYS 0x00000200 // Hysteresis Always +#define ADC_DCCTL3_CTM_HONCE 0x00000300 // Hysteresis Once +#define ADC_DCCTL3_CIE 0x00000010 // Comparison Interrupt Enable +#define ADC_DCCTL3_CIC_M 0x0000000C // Comparison Interrupt Condition +#define ADC_DCCTL3_CIC_LOW 0x00000000 // Low Band +#define ADC_DCCTL3_CIC_MID 0x00000004 // Mid Band +#define ADC_DCCTL3_CIC_HIGH 0x0000000C // High Band +#define ADC_DCCTL3_CIM_M 0x00000003 // Comparison Interrupt Mode +#define ADC_DCCTL3_CIM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL3_CIM_ONCE 0x00000001 // Once +#define ADC_DCCTL3_CIM_HALWAYS 0x00000002 // Hysteresis Always +#define ADC_DCCTL3_CIM_HONCE 0x00000003 // Hysteresis Once + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCTL4 register. +// +//***************************************************************************** +#define ADC_DCCTL4_CTE 0x00001000 // Comparison Trigger Enable +#define ADC_DCCTL4_CTC_M 0x00000C00 // Comparison Trigger Condition +#define ADC_DCCTL4_CTC_LOW 0x00000000 // Low Band +#define ADC_DCCTL4_CTC_MID 0x00000400 // Mid Band +#define ADC_DCCTL4_CTC_HIGH 0x00000C00 // High Band +#define ADC_DCCTL4_CTM_M 0x00000300 // Comparison Trigger Mode +#define ADC_DCCTL4_CTM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL4_CTM_ONCE 0x00000100 // Once +#define ADC_DCCTL4_CTM_HALWAYS 0x00000200 // Hysteresis Always +#define ADC_DCCTL4_CTM_HONCE 0x00000300 // Hysteresis Once +#define ADC_DCCTL4_CIE 0x00000010 // Comparison Interrupt Enable +#define ADC_DCCTL4_CIC_M 0x0000000C // Comparison Interrupt Condition +#define ADC_DCCTL4_CIC_LOW 0x00000000 // Low Band +#define ADC_DCCTL4_CIC_MID 0x00000004 // Mid Band +#define ADC_DCCTL4_CIC_HIGH 0x0000000C // High Band +#define ADC_DCCTL4_CIM_M 0x00000003 // Comparison Interrupt Mode +#define ADC_DCCTL4_CIM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL4_CIM_ONCE 0x00000001 // Once +#define ADC_DCCTL4_CIM_HALWAYS 0x00000002 // Hysteresis Always +#define ADC_DCCTL4_CIM_HONCE 0x00000003 // Hysteresis Once + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCTL5 register. +// +//***************************************************************************** +#define ADC_DCCTL5_CTE 0x00001000 // Comparison Trigger Enable +#define ADC_DCCTL5_CTC_M 0x00000C00 // Comparison Trigger Condition +#define ADC_DCCTL5_CTC_LOW 0x00000000 // Low Band +#define ADC_DCCTL5_CTC_MID 0x00000400 // Mid Band +#define ADC_DCCTL5_CTC_HIGH 0x00000C00 // High Band +#define ADC_DCCTL5_CTM_M 0x00000300 // Comparison Trigger Mode +#define ADC_DCCTL5_CTM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL5_CTM_ONCE 0x00000100 // Once +#define ADC_DCCTL5_CTM_HALWAYS 0x00000200 // Hysteresis Always +#define ADC_DCCTL5_CTM_HONCE 0x00000300 // Hysteresis Once +#define ADC_DCCTL5_CIE 0x00000010 // Comparison Interrupt Enable +#define ADC_DCCTL5_CIC_M 0x0000000C // Comparison Interrupt Condition +#define ADC_DCCTL5_CIC_LOW 0x00000000 // Low Band +#define ADC_DCCTL5_CIC_MID 0x00000004 // Mid Band +#define ADC_DCCTL5_CIC_HIGH 0x0000000C // High Band +#define ADC_DCCTL5_CIM_M 0x00000003 // Comparison Interrupt Mode +#define ADC_DCCTL5_CIM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL5_CIM_ONCE 0x00000001 // Once +#define ADC_DCCTL5_CIM_HALWAYS 0x00000002 // Hysteresis Always +#define ADC_DCCTL5_CIM_HONCE 0x00000003 // Hysteresis Once + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCTL6 register. +// +//***************************************************************************** +#define ADC_DCCTL6_CTE 0x00001000 // Comparison Trigger Enable +#define ADC_DCCTL6_CTC_M 0x00000C00 // Comparison Trigger Condition +#define ADC_DCCTL6_CTC_LOW 0x00000000 // Low Band +#define ADC_DCCTL6_CTC_MID 0x00000400 // Mid Band +#define ADC_DCCTL6_CTC_HIGH 0x00000C00 // High Band +#define ADC_DCCTL6_CTM_M 0x00000300 // Comparison Trigger Mode +#define ADC_DCCTL6_CTM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL6_CTM_ONCE 0x00000100 // Once +#define ADC_DCCTL6_CTM_HALWAYS 0x00000200 // Hysteresis Always +#define ADC_DCCTL6_CTM_HONCE 0x00000300 // Hysteresis Once +#define ADC_DCCTL6_CIE 0x00000010 // Comparison Interrupt Enable +#define ADC_DCCTL6_CIC_M 0x0000000C // Comparison Interrupt Condition +#define ADC_DCCTL6_CIC_LOW 0x00000000 // Low Band +#define ADC_DCCTL6_CIC_MID 0x00000004 // Mid Band +#define ADC_DCCTL6_CIC_HIGH 0x0000000C // High Band +#define ADC_DCCTL6_CIM_M 0x00000003 // Comparison Interrupt Mode +#define ADC_DCCTL6_CIM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL6_CIM_ONCE 0x00000001 // Once +#define ADC_DCCTL6_CIM_HALWAYS 0x00000002 // Hysteresis Always +#define ADC_DCCTL6_CIM_HONCE 0x00000003 // Hysteresis Once + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCTL7 register. +// +//***************************************************************************** +#define ADC_DCCTL7_CTE 0x00001000 // Comparison Trigger Enable +#define ADC_DCCTL7_CTC_M 0x00000C00 // Comparison Trigger Condition +#define ADC_DCCTL7_CTC_LOW 0x00000000 // Low Band +#define ADC_DCCTL7_CTC_MID 0x00000400 // Mid Band +#define ADC_DCCTL7_CTC_HIGH 0x00000C00 // High Band +#define ADC_DCCTL7_CTM_M 0x00000300 // Comparison Trigger Mode +#define ADC_DCCTL7_CTM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL7_CTM_ONCE 0x00000100 // Once +#define ADC_DCCTL7_CTM_HALWAYS 0x00000200 // Hysteresis Always +#define ADC_DCCTL7_CTM_HONCE 0x00000300 // Hysteresis Once +#define ADC_DCCTL7_CIE 0x00000010 // Comparison Interrupt Enable +#define ADC_DCCTL7_CIC_M 0x0000000C // Comparison Interrupt Condition +#define ADC_DCCTL7_CIC_LOW 0x00000000 // Low Band +#define ADC_DCCTL7_CIC_MID 0x00000004 // Mid Band +#define ADC_DCCTL7_CIC_HIGH 0x0000000C // High Band +#define ADC_DCCTL7_CIM_M 0x00000003 // Comparison Interrupt Mode +#define ADC_DCCTL7_CIM_ALWAYS 0x00000000 // Always +#define ADC_DCCTL7_CIM_ONCE 0x00000001 // Once +#define ADC_DCCTL7_CIM_HALWAYS 0x00000002 // Hysteresis Always +#define ADC_DCCTL7_CIM_HONCE 0x00000003 // Hysteresis Once + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCMP0 register. +// +//***************************************************************************** +#define ADC_DCCMP0_COMP1_M 0x03FF0000 // Compare 1 +#define ADC_DCCMP0_COMP0_M 0x000003FF // Compare 0 +#define ADC_DCCMP0_COMP1_S 16 +#define ADC_DCCMP0_COMP0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCMP1 register. +// +//***************************************************************************** +#define ADC_DCCMP1_COMP1_M 0x03FF0000 // Compare 1 +#define ADC_DCCMP1_COMP0_M 0x000003FF // Compare 0 +#define ADC_DCCMP1_COMP1_S 16 +#define ADC_DCCMP1_COMP0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCMP2 register. +// +//***************************************************************************** +#define ADC_DCCMP2_COMP1_M 0x03FF0000 // Compare 1 +#define ADC_DCCMP2_COMP0_M 0x000003FF // Compare 0 +#define ADC_DCCMP2_COMP1_S 16 +#define ADC_DCCMP2_COMP0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCMP3 register. +// +//***************************************************************************** +#define ADC_DCCMP3_COMP1_M 0x03FF0000 // Compare 1 +#define ADC_DCCMP3_COMP0_M 0x000003FF // Compare 0 +#define ADC_DCCMP3_COMP1_S 16 +#define ADC_DCCMP3_COMP0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCMP4 register. +// +//***************************************************************************** +#define ADC_DCCMP4_COMP1_M 0x03FF0000 // Compare 1 +#define ADC_DCCMP4_COMP0_M 0x000003FF // Compare 0 +#define ADC_DCCMP4_COMP1_S 16 +#define ADC_DCCMP4_COMP0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCMP5 register. +// +//***************************************************************************** +#define ADC_DCCMP5_COMP1_M 0x03FF0000 // Compare 1 +#define ADC_DCCMP5_COMP0_M 0x000003FF // Compare 0 +#define ADC_DCCMP5_COMP1_S 16 +#define ADC_DCCMP5_COMP0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCMP6 register. +// +//***************************************************************************** +#define ADC_DCCMP6_COMP1_M 0x03FF0000 // Compare 1 +#define ADC_DCCMP6_COMP0_M 0x000003FF // Compare 0 +#define ADC_DCCMP6_COMP1_S 16 +#define ADC_DCCMP6_COMP0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_DCCMP7 register. +// +//***************************************************************************** +#define ADC_DCCMP7_COMP1_M 0x03FF0000 // Compare 1 +#define ADC_DCCMP7_COMP0_M 0x000003FF // Compare 0 +#define ADC_DCCMP7_COMP1_S 16 +#define ADC_DCCMP7_COMP0_S 0 + +//***************************************************************************** +// +// The following are defines for the the interpretation of the data in the +// SSFIFOx when the ADC TMLB is enabled. +// +//***************************************************************************** +#define ADC_SSFIFO_TMLB_CNT_M 0x000003C0 // Continuous Sample Counter +#define ADC_SSFIFO_TMLB_CONT 0x00000020 // Continuation Sample Indicator +#define ADC_SSFIFO_TMLB_DIFF 0x00000010 // Differential Sample Indicator +#define ADC_SSFIFO_TMLB_TS 0x00000008 // Temp Sensor Sample Indicator +#define ADC_SSFIFO_TMLB_MUX_M 0x00000007 // Analog Input Indicator +#define ADC_SSFIFO_TMLB_CNT_S 6 // Sample counter shift +#define ADC_SSFIFO_TMLB_MUX_S 0 // Input channel number shift + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the ADC_O_EMUX +// register. +// +//***************************************************************************** +#define ADC_EMUX_EM3_MASK 0x0000F000 // Event mux 3 mask +#define ADC_EMUX_EM2_MASK 0x00000F00 // Event mux 2 mask +#define ADC_EMUX_EM1_MASK 0x000000F0 // Event mux 1 mask +#define ADC_EMUX_EM0_MASK 0x0000000F // Event mux 0 mask +#define ADC_EMUX_EM3_SHIFT 12 // The shift for the fourth event +#define ADC_EMUX_EM2_SHIFT 8 // The shift for the third event +#define ADC_EMUX_EM1_SHIFT 4 // The shift for the second event +#define ADC_EMUX_EM0_SHIFT 0 // The shift for the first event + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the ADC_O_SSPRI +// register. +// +//***************************************************************************** +#define ADC_SSPRI_SS3_MASK 0x00003000 // Sequencer 3 priority mask +#define ADC_SSPRI_SS2_MASK 0x00000300 // Sequencer 2 priority mask +#define ADC_SSPRI_SS1_MASK 0x00000030 // Sequencer 1 priority mask +#define ADC_SSPRI_SS0_MASK 0x00000003 // Sequencer 0 priority mask + +//***************************************************************************** +// +// The following are deprecated defines for the ADC sequence register offsets.. +// +//***************************************************************************** +#define ADC_O_SEQ 0x00000040 // Offset to the first sequence +#define ADC_O_SEQ_STEP 0x00000020 // Increment to the next sequence +#define ADC_O_X_SSFSTAT 0x0000000C // FIFO status register +#define ADC_O_X_SSFIFO 0x00000008 // Result FIFO register +#define ADC_O_X_SSCTL 0x00000004 // Sample sequence control register +#define ADC_O_X_SSMUX 0x00000000 // Multiplexer select register + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the ADC_SSMUX0, +// ADC_SSMUX1, ADC_SSMUX2, and ADC_SSMUX3 registers. Not all fields are present +// in all registers.. +// +//***************************************************************************** +#define ADC_SSMUX_MUX7_MASK 0x70000000 // 8th mux select mask +#define ADC_SSMUX_MUX6_MASK 0x07000000 // 7th mux select mask +#define ADC_SSMUX_MUX5_MASK 0x00700000 // 6th mux select mask +#define ADC_SSMUX_MUX4_MASK 0x00070000 // 5th mux select mask +#define ADC_SSMUX_MUX3_MASK 0x00007000 // 4th mux select mask +#define ADC_SSMUX_MUX2_MASK 0x00000700 // 3rd mux select mask +#define ADC_SSMUX_MUX1_MASK 0x00000070 // 2nd mux select mask +#define ADC_SSMUX_MUX0_MASK 0x00000007 // 1st mux select mask +#define ADC_SSMUX_MUX7_SHIFT 28 +#define ADC_SSMUX_MUX6_SHIFT 24 +#define ADC_SSMUX_MUX5_SHIFT 20 +#define ADC_SSMUX_MUX4_SHIFT 16 +#define ADC_SSMUX_MUX3_SHIFT 12 +#define ADC_SSMUX_MUX2_SHIFT 8 +#define ADC_SSMUX_MUX1_SHIFT 4 +#define ADC_SSMUX_MUX0_SHIFT 0 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the ADC_SSCTL0, +// ADC_SSCTL1, ADC_SSCTL2, and ADC_SSCTL3 registers. Not all fields are present +// in all registers. +// +//***************************************************************************** +#define ADC_SSCTL_TS7 0x80000000 // 8th temperature sensor select +#define ADC_SSCTL_IE7 0x40000000 // 8th interrupt enable +#define ADC_SSCTL_END7 0x20000000 // 8th sequence end select +#define ADC_SSCTL_D7 0x10000000 // 8th differential select +#define ADC_SSCTL_TS6 0x08000000 // 7th temperature sensor select +#define ADC_SSCTL_IE6 0x04000000 // 7th interrupt enable +#define ADC_SSCTL_END6 0x02000000 // 7th sequence end select +#define ADC_SSCTL_D6 0x01000000 // 7th differential select +#define ADC_SSCTL_TS5 0x00800000 // 6th temperature sensor select +#define ADC_SSCTL_IE5 0x00400000 // 6th interrupt enable +#define ADC_SSCTL_END5 0x00200000 // 6th sequence end select +#define ADC_SSCTL_D5 0x00100000 // 6th differential select +#define ADC_SSCTL_TS4 0x00080000 // 5th temperature sensor select +#define ADC_SSCTL_IE4 0x00040000 // 5th interrupt enable +#define ADC_SSCTL_END4 0x00020000 // 5th sequence end select +#define ADC_SSCTL_D4 0x00010000 // 5th differential select +#define ADC_SSCTL_TS3 0x00008000 // 4th temperature sensor select +#define ADC_SSCTL_IE3 0x00004000 // 4th interrupt enable +#define ADC_SSCTL_END3 0x00002000 // 4th sequence end select +#define ADC_SSCTL_D3 0x00001000 // 4th differential select +#define ADC_SSCTL_TS2 0x00000800 // 3rd temperature sensor select +#define ADC_SSCTL_IE2 0x00000400 // 3rd interrupt enable +#define ADC_SSCTL_END2 0x00000200 // 3rd sequence end select +#define ADC_SSCTL_D2 0x00000100 // 3rd differential select +#define ADC_SSCTL_TS1 0x00000080 // 2nd temperature sensor select +#define ADC_SSCTL_IE1 0x00000040 // 2nd interrupt enable +#define ADC_SSCTL_END1 0x00000020 // 2nd sequence end select +#define ADC_SSCTL_D1 0x00000010 // 2nd differential select +#define ADC_SSCTL_TS0 0x00000008 // 1st temperature sensor select +#define ADC_SSCTL_IE0 0x00000004 // 1st interrupt enable +#define ADC_SSCTL_END0 0x00000002 // 1st sequence end select +#define ADC_SSCTL_D0 0x00000001 // 1st differential select + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the ADC_SSFIFO0, +// ADC_SSFIFO1, ADC_SSFIFO2, and ADC_SSFIFO3 registers. +// +//***************************************************************************** +#define ADC_SSFIFO_DATA_MASK 0x000003FF // Sample data +#define ADC_SSFIFO_DATA_SHIFT 0 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the ADC_SSFSTAT0, +// ADC_SSFSTAT1, ADC_SSFSTAT2, and ADC_SSFSTAT3 registers. +// +//***************************************************************************** +#define ADC_SSFSTAT_FULL 0x00001000 // FIFO is full +#define ADC_SSFSTAT_EMPTY 0x00000100 // FIFO is empty +#define ADC_SSFSTAT_HPTR 0x000000F0 // FIFO head pointer +#define ADC_SSFSTAT_TPTR 0x0000000F // FIFO tail pointer + +//***************************************************************************** +// +// The following are deprecated defines for the the interpretation of the data +// in the SSFIFOx when the ADC TMLB is enabled. +// +//***************************************************************************** +#define ADC_TMLB_CNT_M 0x000003C0 // Continuous Sample Counter +#define ADC_TMLB_CONT 0x00000020 // Continuation Sample Indicator +#define ADC_TMLB_DIFF 0x00000010 // Differential Sample Indicator +#define ADC_TMLB_TS 0x00000008 // Temp Sensor Sample Indicator +#define ADC_TMLB_MUX_M 0x00000007 // Analog Input Indicator +#define ADC_TMLB_CNT_S 6 // Sample counter shift +#define ADC_TMLB_MUX_S 0 // Input channel number shift + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the loopback ADC +// data. +// +//***************************************************************************** +#define ADC_LB_CNT_MASK 0x000003C0 // Sample counter mask +#define ADC_LB_CONT 0x00000020 // Continuation sample +#define ADC_LB_DIFF 0x00000010 // Differential sample +#define ADC_LB_TS 0x00000008 // Temperature sensor sample +#define ADC_LB_MUX_MASK 0x00000007 // Input channel number mask +#define ADC_LB_CNT_SHIFT 6 // Sample counter shift +#define ADC_LB_MUX_SHIFT 0 // Input channel number shift + +#endif + +#endif // __HW_ADC_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_comp.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_comp.h new file mode 100644 index 00000000..4b58bbf5 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_comp.h @@ -0,0 +1,277 @@ +//***************************************************************************** +// +// hw_comp.h - Macros used when accessing the comparator hardware. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_COMP_H__ +#define __HW_COMP_H__ + +//***************************************************************************** +// +// The following are defines for the Comparator register offsets. +// +//***************************************************************************** +#define COMP_O_ACMIS 0x00000000 // Analog Comparator Masked + // Interrupt Status +#define COMP_O_ACRIS 0x00000004 // Analog Comparator Raw Interrupt + // Status +#define COMP_O_ACINTEN 0x00000008 // Analog Comparator Interrupt + // Enable +#define COMP_O_ACREFCTL 0x00000010 // Analog Comparator Reference + // Voltage Control +#define COMP_O_ACSTAT0 0x00000020 // Analog Comparator Status 0 +#define COMP_O_ACCTL0 0x00000024 // Analog Comparator Control 0 +#define COMP_O_ACSTAT1 0x00000040 // Analog Comparator Status 1 +#define COMP_O_ACCTL1 0x00000044 // Analog Comparator Control 1 +#define COMP_O_ACSTAT2 0x00000060 // Analog Comparator Status 2 +#define COMP_O_ACCTL2 0x00000064 // Analog Comparator Control 2 + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACMIS register. +// +//***************************************************************************** +#define COMP_ACMIS_IN2 0x00000004 // Comparator 2 Masked Interrupt + // Status +#define COMP_ACMIS_IN1 0x00000002 // Comparator 1 Masked Interrupt + // Status +#define COMP_ACMIS_IN0 0x00000001 // Comparator 0 Masked Interrupt + // Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACRIS register. +// +//***************************************************************************** +#define COMP_ACRIS_IN2 0x00000004 // Comparator 2 Interrupt Status +#define COMP_ACRIS_IN1 0x00000002 // Comparator 1 Interrupt Status +#define COMP_ACRIS_IN0 0x00000001 // Comparator 0 Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACINTEN register. +// +//***************************************************************************** +#define COMP_ACINTEN_IN2 0x00000004 // Comparator 2 Interrupt Enable +#define COMP_ACINTEN_IN1 0x00000002 // Comparator 1 Interrupt Enable +#define COMP_ACINTEN_IN0 0x00000001 // Comparator 0 Interrupt Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACREFCTL +// register. +// +//***************************************************************************** +#define COMP_ACREFCTL_EN 0x00000200 // Resistor Ladder Enable +#define COMP_ACREFCTL_RNG 0x00000100 // Resistor Ladder Range +#define COMP_ACREFCTL_VREF_M 0x0000000F // Resistor Ladder Voltage Ref +#define COMP_ACREFCTL_VREF_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACSTAT0 register. +// +//***************************************************************************** +#define COMP_ACSTAT0_OVAL 0x00000002 // Comparator Output Value + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACCTL0 register. +// +//***************************************************************************** +#define COMP_ACCTL0_TOEN 0x00000800 // Trigger Output Enable +#define COMP_ACCTL0_ASRCP_M 0x00000600 // Analog Source Positive +#define COMP_ACCTL0_ASRCP_PIN 0x00000000 // Pin value of Cn+ +#define COMP_ACCTL0_ASRCP_PIN0 0x00000200 // Pin value of C0+ +#define COMP_ACCTL0_ASRCP_REF 0x00000400 // Internal voltage reference + // (VIREF) +#define COMP_ACCTL0_TSLVAL 0x00000080 // Trigger Sense Level Value +#define COMP_ACCTL0_TSEN_M 0x00000060 // Trigger Sense +#define COMP_ACCTL0_TSEN_LEVEL 0x00000000 // Level sense, see TSLVAL +#define COMP_ACCTL0_TSEN_FALL 0x00000020 // Falling edge +#define COMP_ACCTL0_TSEN_RISE 0x00000040 // Rising edge +#define COMP_ACCTL0_TSEN_BOTH 0x00000060 // Either edge +#define COMP_ACCTL0_ISLVAL 0x00000010 // Interrupt Sense Level Value +#define COMP_ACCTL0_ISEN_M 0x0000000C // Interrupt Sense +#define COMP_ACCTL0_ISEN_LEVEL 0x00000000 // Level sense, see ISLVAL +#define COMP_ACCTL0_ISEN_FALL 0x00000004 // Falling edge +#define COMP_ACCTL0_ISEN_RISE 0x00000008 // Rising edge +#define COMP_ACCTL0_ISEN_BOTH 0x0000000C // Either edge +#define COMP_ACCTL0_CINV 0x00000002 // Comparator Output Invert + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACSTAT1 register. +// +//***************************************************************************** +#define COMP_ACSTAT1_OVAL 0x00000002 // Comparator Output Value + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACCTL1 register. +// +//***************************************************************************** +#define COMP_ACCTL1_TOEN 0x00000800 // Trigger Output Enable +#define COMP_ACCTL1_ASRCP_M 0x00000600 // Analog Source Positive +#define COMP_ACCTL1_ASRCP_PIN 0x00000000 // Pin value of Cn+ +#define COMP_ACCTL1_ASRCP_PIN0 0x00000200 // Pin value of C0+ +#define COMP_ACCTL1_ASRCP_REF 0x00000400 // Internal voltage reference + // (VIREF) +#define COMP_ACCTL1_TSLVAL 0x00000080 // Trigger Sense Level Value +#define COMP_ACCTL1_TSEN_M 0x00000060 // Trigger Sense +#define COMP_ACCTL1_TSEN_LEVEL 0x00000000 // Level sense, see TSLVAL +#define COMP_ACCTL1_TSEN_FALL 0x00000020 // Falling edge +#define COMP_ACCTL1_TSEN_RISE 0x00000040 // Rising edge +#define COMP_ACCTL1_TSEN_BOTH 0x00000060 // Either edge +#define COMP_ACCTL1_ISLVAL 0x00000010 // Interrupt Sense Level Value +#define COMP_ACCTL1_ISEN_M 0x0000000C // Interrupt Sense +#define COMP_ACCTL1_ISEN_LEVEL 0x00000000 // Level sense, see ISLVAL +#define COMP_ACCTL1_ISEN_FALL 0x00000004 // Falling edge +#define COMP_ACCTL1_ISEN_RISE 0x00000008 // Rising edge +#define COMP_ACCTL1_ISEN_BOTH 0x0000000C // Either edge +#define COMP_ACCTL1_CINV 0x00000002 // Comparator Output Invert + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACSTAT2 register. +// +//***************************************************************************** +#define COMP_ACSTAT2_OVAL 0x00000002 // Comparator Output Value + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACCTL2 register. +// +//***************************************************************************** +#define COMP_ACCTL2_TOEN 0x00000800 // Trigger Output Enable +#define COMP_ACCTL2_ASRCP_M 0x00000600 // Analog Source Positive +#define COMP_ACCTL2_ASRCP_PIN 0x00000000 // Pin value of Cn+ +#define COMP_ACCTL2_ASRCP_PIN0 0x00000200 // Pin value of C0+ +#define COMP_ACCTL2_ASRCP_REF 0x00000400 // Internal voltage reference + // (VIREF) +#define COMP_ACCTL2_TSLVAL 0x00000080 // Trigger Sense Level Value +#define COMP_ACCTL2_TSEN_M 0x00000060 // Trigger Sense +#define COMP_ACCTL2_TSEN_LEVEL 0x00000000 // Level sense, see TSLVAL +#define COMP_ACCTL2_TSEN_FALL 0x00000020 // Falling edge +#define COMP_ACCTL2_TSEN_RISE 0x00000040 // Rising edge +#define COMP_ACCTL2_TSEN_BOTH 0x00000060 // Either edge +#define COMP_ACCTL2_ISLVAL 0x00000010 // Interrupt Sense Level Value +#define COMP_ACCTL2_ISEN_M 0x0000000C // Interrupt Sense +#define COMP_ACCTL2_ISEN_LEVEL 0x00000000 // Level sense, see ISLVAL +#define COMP_ACCTL2_ISEN_FALL 0x00000004 // Falling edge +#define COMP_ACCTL2_ISEN_RISE 0x00000008 // Rising edge +#define COMP_ACCTL2_ISEN_BOTH 0x0000000C // Either edge +#define COMP_ACCTL2_CINV 0x00000002 // Comparator Output Invert + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the Comparator register offsets. +// +//***************************************************************************** +#define COMP_O_MIS 0x00000000 // Interrupt status register +#define COMP_O_RIS 0x00000004 // Raw interrupt status register +#define COMP_O_INTEN 0x00000008 // Interrupt enable register +#define COMP_O_REFCTL 0x00000010 // Reference voltage control reg + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the COMP_O_REFCTL +// register. +// +//***************************************************************************** +#define COMP_REFCTL_EN 0x00000200 // Reference voltage enable +#define COMP_REFCTL_RNG 0x00000100 // Reference voltage range +#define COMP_REFCTL_VREF_MASK 0x0000000F // Reference voltage select mask +#define COMP_REFCTL_VREF_SHIFT 0 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the COMP_MIS, +// COMP_RIS, and COMP_INTEN registers. +// +//***************************************************************************** +#define COMP_INT_2 0x00000004 // Comp2 interrupt +#define COMP_INT_1 0x00000002 // Comp1 interrupt +#define COMP_INT_0 0x00000001 // Comp0 interrupt + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the COMP_ACSTAT0, +// COMP_ACSTAT1, and COMP_ACSTAT2 registers. +// +//***************************************************************************** +#define COMP_ACSTAT_OVAL 0x00000002 // Comparator output value + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the COMP_ACCTL0, +// COMP_ACCTL1, and COMP_ACCTL2 registers. +// +//***************************************************************************** +#define COMP_ACCTL_TMASK 0x00000800 // Trigger enable +#define COMP_ACCTL_ASRCP_MASK 0x00000600 // Vin+ source select mask +#define COMP_ACCTL_ASRCP_PIN 0x00000000 // Dedicated Comp+ pin +#define COMP_ACCTL_ASRCP_PIN0 0x00000200 // Comp0+ pin +#define COMP_ACCTL_ASRCP_REF 0x00000400 // Internal voltage reference +#define COMP_ACCTL_ASRCP_RES 0x00000600 // Reserved +#define COMP_ACCTL_OEN 0x00000100 // Comparator output enable +#define COMP_ACCTL_TSVAL 0x00000080 // Trigger polarity select +#define COMP_ACCTL_TSEN_MASK 0x00000060 // Trigger sense mask +#define COMP_ACCTL_TSEN_LEVEL 0x00000000 // Trigger is level sense +#define COMP_ACCTL_TSEN_FALL 0x00000020 // Trigger is falling edge +#define COMP_ACCTL_TSEN_RISE 0x00000040 // Trigger is rising edge +#define COMP_ACCTL_TSEN_BOTH 0x00000060 // Trigger is both edges +#define COMP_ACCTL_ISLVAL 0x00000010 // Interrupt polarity select +#define COMP_ACCTL_ISEN_MASK 0x0000000C // Interrupt sense mask +#define COMP_ACCTL_ISEN_LEVEL 0x00000000 // Interrupt is level sense +#define COMP_ACCTL_ISEN_FALL 0x00000004 // Interrupt is falling edge +#define COMP_ACCTL_ISEN_RISE 0x00000008 // Interrupt is rising edge +#define COMP_ACCTL_ISEN_BOTH 0x0000000C // Interrupt is both edges +#define COMP_ACCTL_CINV 0x00000002 // Comparator output invert + +//***************************************************************************** +// +// The following are deprecated defines for the reset values for the comparator +// registers. +// +//***************************************************************************** +#define COMP_RV_ACCTL1 0x00000000 // Comp1 control register +#define COMP_RV_ACSTAT2 0x00000000 // Comp2 status register +#define COMP_RV_ACSTAT0 0x00000000 // Comp0 status register +#define COMP_RV_RIS 0x00000000 // Raw interrupt status register +#define COMP_RV_INTEN 0x00000000 // Interrupt enable register +#define COMP_RV_ACCTL2 0x00000000 // Comp2 control register +#define COMP_RV_MIS 0x00000000 // Interrupt status register +#define COMP_RV_ACCTL0 0x00000000 // Comp0 control register +#define COMP_RV_ACSTAT1 0x00000000 // Comp1 status register +#define COMP_RV_REFCTL 0x00000000 // Reference voltage control reg + +#endif + +#endif // __HW_COMP_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_epi.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_epi.h new file mode 100644 index 00000000..8ed9d165 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_epi.h @@ -0,0 +1,499 @@ +//***************************************************************************** +// +// hw_epi.h - Macros for use in accessing the EPI registers. +// +// Copyright (c) 2008-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_EPI_H__ +#define __HW_EPI_H__ + +//***************************************************************************** +// +// The following are defines for the External Peripheral Interface register +// offsets. +// +//***************************************************************************** +#define EPI_O_CFG 0x00000000 // EPI Configuration +#define EPI_O_BAUD 0x00000004 // EPI Main Baud Rate +#define EPI_O_HB16CFG 0x00000010 // EPI Host-Bus 16 Configuration +#define EPI_O_GPCFG 0x00000010 // EPI General-Purpose + // Configuration +#define EPI_O_SDRAMCFG 0x00000010 // EPI SDRAM Configuration +#define EPI_O_HB8CFG 0x00000010 // EPI Host-Bus 8 Configuration +#define EPI_O_HB8CFG2 0x00000014 // EPI Host-Bus 8 Configuration 2 +#define EPI_O_HB16CFG2 0x00000014 // EPI Host-Bus 16 Configuration 2 +#define EPI_O_GPCFG2 0x00000014 // EPI General-Purpose + // Configuration 2 +#define EPI_O_ADDRMAP 0x0000001C // EPI Address Map +#define EPI_O_RSIZE0 0x00000020 // EPI Read Size 0 +#define EPI_O_RADDR0 0x00000024 // EPI Read Address 0 +#define EPI_O_RPSTD0 0x00000028 // EPI Non-Blocking Read Data 0 +#define EPI_O_RSIZE1 0x00000030 // EPI Read Size 1 +#define EPI_O_RADDR1 0x00000034 // EPI Read Address 1 +#define EPI_O_RPSTD1 0x00000038 // EPI Non-Blocking Read Data 1 +#define EPI_O_STAT 0x00000060 // EPI Status +#define EPI_O_RFIFOCNT 0x0000006C // EPI Read FIFO Count +#define EPI_O_READFIFO 0x00000070 // EPI Read FIFO +#define EPI_O_READFIFO1 0x00000074 // EPI Read FIFO Alias 1 +#define EPI_O_READFIFO2 0x00000078 // EPI Read FIFO Alias 2 +#define EPI_O_READFIFO3 0x0000007C // EPI Read FIFO Alias 3 +#define EPI_O_READFIFO4 0x00000080 // EPI Read FIFO Alias 4 +#define EPI_O_READFIFO5 0x00000084 // EPI Read FIFO Alias 5 +#define EPI_O_READFIFO6 0x00000088 // EPI Read FIFO Alias 6 +#define EPI_O_READFIFO7 0x0000008C // EPI Read FIFO Alias 7 +#define EPI_O_FIFOLVL 0x00000200 // EPI FIFO Level Selects +#define EPI_O_WFIFOCNT 0x00000204 // EPI Write FIFO Count +#define EPI_O_IM 0x00000210 // EPI Interrupt Mask +#define EPI_O_RIS 0x00000214 // EPI Raw Interrupt Status +#define EPI_O_MIS 0x00000218 // EPI Masked Interrupt Status +#define EPI_O_EISC 0x0000021C // EPI Error Interrupt Status and + // Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_CFG register. +// +//***************************************************************************** +#define EPI_CFG_BLKEN 0x00000010 // Block Enable +#define EPI_CFG_MODE_M 0x0000000F // Mode Select +#define EPI_CFG_MODE_NONE 0x00000000 // General Purpose +#define EPI_CFG_MODE_SDRAM 0x00000001 // SDRAM +#define EPI_CFG_MODE_HB8 0x00000002 // 8-Bit Host-Bus (HB8) +#define EPI_CFG_MODE_HB16 0x00000003 // 16-Bit Host-Bus (HB16) + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_BAUD register. +// +//***************************************************************************** +#define EPI_BAUD_COUNT1_M 0xFFFF0000 // Baud Rate Counter 1 +#define EPI_BAUD_COUNT0_M 0x0000FFFF // Baud Rate Counter 0 +#define EPI_BAUD_COUNT1_S 16 +#define EPI_BAUD_COUNT0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_HB16CFG register. +// +//***************************************************************************** +#define EPI_HB16CFG_XFFEN 0x00800000 // External FIFO FULL Enable +#define EPI_HB16CFG_XFEEN 0x00400000 // External FIFO EMPTY Enable +#define EPI_HB16CFG_WRHIGH 0x00200000 // WRITE Strobe Polarity +#define EPI_HB16CFG_RDHIGH 0x00100000 // READ Strobe Polarity +#define EPI_HB16CFG_MAXWAIT_M 0x0000FF00 // Maximum Wait +#define EPI_HB16CFG_WRWS_M 0x000000C0 // CS0n Write Wait States +#define EPI_HB16CFG_WRWS_0 0x00000000 // No wait states +#define EPI_HB16CFG_WRWS_1 0x00000040 // 1 wait state +#define EPI_HB16CFG_WRWS_2 0x00000080 // 2 wait states +#define EPI_HB16CFG_WRWS_3 0x000000C0 // 3 wait states +#define EPI_HB16CFG_RDWS_M 0x00000030 // CS0n Read Wait States +#define EPI_HB16CFG_RDWS_0 0x00000000 // No wait states +#define EPI_HB16CFG_RDWS_1 0x00000010 // 1 wait state +#define EPI_HB16CFG_RDWS_2 0x00000020 // 2 wait states +#define EPI_HB16CFG_RDWS_3 0x00000030 // 3 wait states +#define EPI_HB16CFG_BSEL 0x00000004 // Byte Select Configuration +#define EPI_HB16CFG_MODE_M 0x00000003 // Host Bus Sub-Mode +#define EPI_HB16CFG_MODE_ADMUX 0x00000000 // ADMUX - AD[15:0] +#define EPI_HB16CFG_MODE_ADNMUX 0x00000001 // ADNONMUX - D[15:0] +#define EPI_HB16CFG_MODE_SRAM 0x00000002 // Continuous Read - D[15:0] +#define EPI_HB16CFG_MODE_XFIFO 0x00000003 // XFIFO - D[15:0] +#define EPI_HB16CFG_MAXWAIT_S 8 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_GPCFG register. +// +//***************************************************************************** +#define EPI_GPCFG_CLKPIN 0x80000000 // Clock Pin +#define EPI_GPCFG_CLKGATE 0x40000000 // Clock Gated +#define EPI_GPCFG_RDYEN 0x10000000 // Ready Enable +#define EPI_GPCFG_FRMPIN 0x08000000 // Framing Pin +#define EPI_GPCFG_FRM50 0x04000000 // 50/50 Frame +#define EPI_GPCFG_FRMCNT_M 0x03C00000 // Frame Count +#define EPI_GPCFG_RW 0x00200000 // Read and Write +#define EPI_GPCFG_WR2CYC 0x00080000 // 2-Cycle Writes +#define EPI_GPCFG_RD2CYC 0x00040000 // 2-Cycle Reads +#define EPI_GPCFG_MAXWAIT_M 0x0000FF00 // Maximum Wait +#define EPI_GPCFG_ASIZE_M 0x00000030 // Address Bus Size +#define EPI_GPCFG_ASIZE_NONE 0x00000000 // No address +#define EPI_GPCFG_ASIZE_4BIT 0x00000010 // Up to 4 bits wide +#define EPI_GPCFG_ASIZE_12BIT 0x00000020 // Up to 12 bits wide. This size + // cannot be used with 24-bit data +#define EPI_GPCFG_ASIZE_20BIT 0x00000030 // Up to 20 bits wide. This size + // cannot be used with data sizes + // other than 8 +#define EPI_GPCFG_DSIZE_M 0x00000003 // Size of Data Bus +#define EPI_GPCFG_DSIZE_4BIT 0x00000000 // 8 Bits Wide (EPI0S0 to EPI0S7) +#define EPI_GPCFG_DSIZE_16BIT 0x00000001 // 16 Bits Wide (EPI0S0 to EPI0S15) +#define EPI_GPCFG_DSIZE_24BIT 0x00000002 // 24 Bits Wide (EPI0S0 to EPI0S23) +#define EPI_GPCFG_DSIZE_32BIT 0x00000003 // 32 Bits Wide (EPI0S0 to EPI0S31) +#define EPI_GPCFG_FRMCNT_S 22 +#define EPI_GPCFG_MAXWAIT_S 8 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_SDRAMCFG register. +// +//***************************************************************************** +#define EPI_SDRAMCFG_FREQ_M 0xC0000000 // Frequency Range +#define EPI_SDRAMCFG_FREQ_NONE 0x00000000 // 0 - 15 MHz +#define EPI_SDRAMCFG_FREQ_15MHZ 0x40000000 // 15 - 30 MHz +#define EPI_SDRAMCFG_FREQ_30MHZ 0x80000000 // 30 - 50 MHz +#define EPI_SDRAMCFG_FREQ_50MHZ 0xC0000000 // 50 - 100 MHz +#define EPI_SDRAMCFG_RFSH_M 0x07FF0000 // Refresh Counter +#define EPI_SDRAMCFG_SLEEP 0x00000200 // Sleep Mode +#define EPI_SDRAMCFG_SIZE_M 0x00000003 // Size of SDRAM +#define EPI_SDRAMCFG_SIZE_8MB 0x00000000 // 64 megabits (8MB) +#define EPI_SDRAMCFG_SIZE_16MB 0x00000001 // 128 megabits (16MB) +#define EPI_SDRAMCFG_SIZE_32MB 0x00000002 // 256 megabits (32MB) +#define EPI_SDRAMCFG_SIZE_64MB 0x00000003 // 512 megabits (64MB) +#define EPI_SDRAMCFG_RFSH_S 16 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_HB8CFG register. +// +//***************************************************************************** +#define EPI_HB8CFG_XFFEN 0x00800000 // External FIFO FULL Enable +#define EPI_HB8CFG_XFEEN 0x00400000 // External FIFO EMPTY Enable +#define EPI_HB8CFG_WRHIGH 0x00200000 // CS0n WRITE Strobe Polarity +#define EPI_HB8CFG_RDHIGH 0x00100000 // CS0n READ Strobe Polarity +#define EPI_HB8CFG_MAXWAIT_M 0x0000FF00 // Maximum Wait +#define EPI_HB8CFG_WRWS_M 0x000000C0 // Write Wait States +#define EPI_HB8CFG_WRWS_0 0x00000000 // No wait states +#define EPI_HB8CFG_WRWS_1 0x00000040 // 1 wait state +#define EPI_HB8CFG_WRWS_2 0x00000080 // 2 wait states +#define EPI_HB8CFG_WRWS_3 0x000000C0 // 3 wait states +#define EPI_HB8CFG_RDWS_M 0x00000030 // Read Wait States +#define EPI_HB8CFG_RDWS_0 0x00000000 // No wait states +#define EPI_HB8CFG_RDWS_1 0x00000010 // 1 wait state +#define EPI_HB8CFG_RDWS_2 0x00000020 // 2 wait states +#define EPI_HB8CFG_RDWS_3 0x00000030 // 3 wait states +#define EPI_HB8CFG_MODE_M 0x00000003 // Host Bus Sub-Mode +#define EPI_HB8CFG_MODE_MUX 0x00000000 // ADMUX - AD[7:0] +#define EPI_HB8CFG_MODE_NMUX 0x00000001 // ADNONMUX - D[7:0] +#define EPI_HB8CFG_MODE_SRAM 0x00000002 // Continuous Read - D[7:0] +#define EPI_HB8CFG_MODE_FIFO 0x00000003 // XFIFO - D[7:0] +#define EPI_HB8CFG_MAXWAIT_S 8 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_HB8CFG2 register. +// +//***************************************************************************** +#define EPI_HB8CFG2_WORD 0x80000000 // Word Access Mode +#define EPI_HB8CFG2_CSBAUD 0x04000000 // Chip Select Baud Rate +#define EPI_HB8CFG2_CSCFG_M 0x03000000 // Chip Select Configuration +#define EPI_HB8CFG2_CSCFG_ALE 0x00000000 // ALE Configuration +#define EPI_HB8CFG2_CSCFG_CS 0x01000000 // CSn Configuration +#define EPI_HB8CFG2_CSCFG_DCS 0x02000000 // Dual CSn Configuration +#define EPI_HB8CFG2_CSCFG_ADCS 0x03000000 // ALE with Dual CSn Configuration + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_HB16CFG2 register. +// +//***************************************************************************** +#define EPI_HB16CFG2_WORD 0x80000000 // Word Access Mode +#define EPI_HB16CFG2_CSBAUD 0x04000000 // Chip Select Baud Rate +#define EPI_HB16CFG2_CSCFG_M 0x03000000 // Chip Select Configuration +#define EPI_HB16CFG2_CSCFG_ALE 0x00000000 // ALE Configuration +#define EPI_HB16CFG2_CSCFG_CS 0x01000000 // CSn Configuration +#define EPI_HB16CFG2_CSCFG_DCS 0x02000000 // Dual CSn Configuration +#define EPI_HB16CFG2_CSCFG_ADCS 0x03000000 // ALE with Dual CSn Configuration + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_GPCFG2 register. +// +//***************************************************************************** +#define EPI_GPCFG2_WORD 0x80000000 // Word Access Mode + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_ADDRMAP register. +// +//***************************************************************************** +#define EPI_ADDRMAP_EPSZ_M 0x000000C0 // External Peripheral Size +#define EPI_ADDRMAP_EPSZ_256B 0x00000000 // 256 bytes; lower address range: + // 0x00 to 0xFF +#define EPI_ADDRMAP_EPSZ_64KB 0x00000040 // 64 KB; lower address range: + // 0x0000 to 0xFFFF +#define EPI_ADDRMAP_EPSZ_16MB 0x00000080 // 16 MB; lower address range: + // 0x00.0000 to 0xFF.FFFF +#define EPI_ADDRMAP_EPSZ_256MB 0x000000C0 // 256 MB; lower address range: + // 0x000.0000 to 0xFFF.FFFF +#define EPI_ADDRMAP_EPADR_M 0x00000030 // External Peripheral Address +#define EPI_ADDRMAP_EPADR_NONE 0x00000000 // Not mapped +#define EPI_ADDRMAP_EPADR_A000 0x00000010 // At 0xA000.0000 +#define EPI_ADDRMAP_EPADR_C000 0x00000020 // At 0xC000.0000 +#define EPI_ADDRMAP_ERSZ_M 0x0000000C // External RAM Size +#define EPI_ADDRMAP_ERSZ_256B 0x00000000 // 256 bytes; lower address range: + // 0x00 to 0xFF +#define EPI_ADDRMAP_ERSZ_64KB 0x00000004 // 64 KB; lower address range: + // 0x0000 to 0xFFFF +#define EPI_ADDRMAP_ERSZ_16MB 0x00000008 // 16 MB; lower address range: + // 0x00.0000 to 0xFF.FFFF +#define EPI_ADDRMAP_ERSZ_256MB 0x0000000C // 256 MB; lower address range: + // 0x000.0000 to 0xFFF.FFFF +#define EPI_ADDRMAP_ERADR_M 0x00000003 // External RAM Address +#define EPI_ADDRMAP_ERADR_NONE 0x00000000 // Not mapped +#define EPI_ADDRMAP_ERADR_6000 0x00000001 // At 0x6000.0000 +#define EPI_ADDRMAP_ERADR_8000 0x00000002 // At 0x8000.0000 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_RSIZE0 register. +// +//***************************************************************************** +#define EPI_RSIZE0_SIZE_M 0x00000003 // Current Size +#define EPI_RSIZE0_SIZE_8BIT 0x00000001 // Byte (8 bits) +#define EPI_RSIZE0_SIZE_16BIT 0x00000002 // Half-word (16 bits) +#define EPI_RSIZE0_SIZE_32BIT 0x00000003 // Word (32 bits) + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_RADDR0 register. +// +//***************************************************************************** +#define EPI_RADDR0_ADDR_M 0x1FFFFFFF // Current Address +#define EPI_RADDR0_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_RPSTD0 register. +// +//***************************************************************************** +#define EPI_RPSTD0_POSTCNT_M 0x00001FFF // Post Count +#define EPI_RPSTD0_POSTCNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_RSIZE1 register. +// +//***************************************************************************** +#define EPI_RSIZE1_SIZE_M 0x00000003 // Current Size +#define EPI_RSIZE1_SIZE_8BIT 0x00000001 // Byte (8 bits) +#define EPI_RSIZE1_SIZE_16BIT 0x00000002 // Half-word (16 bits) +#define EPI_RSIZE1_SIZE_32BIT 0x00000003 // Word (32 bits) + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_RADDR1 register. +// +//***************************************************************************** +#define EPI_RADDR1_ADDR_M 0x1FFFFFFF // Current Address +#define EPI_RADDR1_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_RPSTD1 register. +// +//***************************************************************************** +#define EPI_RPSTD1_POSTCNT_M 0x00001FFF // Post Count +#define EPI_RPSTD1_POSTCNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_STAT register. +// +//***************************************************************************** +#define EPI_STAT_CELOW 0x00000200 // Clock Enable Low +#define EPI_STAT_XFFULL 0x00000100 // External FIFO Full +#define EPI_STAT_XFEMPTY 0x00000080 // External FIFO Empty +#define EPI_STAT_INITSEQ 0x00000040 // Initialization Sequence +#define EPI_STAT_WBUSY 0x00000020 // Write Busy +#define EPI_STAT_NBRBUSY 0x00000010 // Non-Blocking Read Busy +#define EPI_STAT_ACTIVE 0x00000001 // Register Active + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_RFIFOCNT register. +// +//***************************************************************************** +#define EPI_RFIFOCNT_COUNT_M 0x00000007 // FIFO Count +#define EPI_RFIFOCNT_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_READFIFO register. +// +//***************************************************************************** +#define EPI_READFIFO_DATA_M 0xFFFFFFFF // Reads Data +#define EPI_READFIFO_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_READFIFO1 +// register. +// +//***************************************************************************** +#define EPI_READFIFO1_DATA_M 0xFFFFFFFF // Reads Data +#define EPI_READFIFO1_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_READFIFO2 +// register. +// +//***************************************************************************** +#define EPI_READFIFO2_DATA_M 0xFFFFFFFF // Reads Data +#define EPI_READFIFO2_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_READFIFO3 +// register. +// +//***************************************************************************** +#define EPI_READFIFO3_DATA_M 0xFFFFFFFF // Reads Data +#define EPI_READFIFO3_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_READFIFO4 +// register. +// +//***************************************************************************** +#define EPI_READFIFO4_DATA_M 0xFFFFFFFF // Reads Data +#define EPI_READFIFO4_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_READFIFO5 +// register. +// +//***************************************************************************** +#define EPI_READFIFO5_DATA_M 0xFFFFFFFF // Reads Data +#define EPI_READFIFO5_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_READFIFO6 +// register. +// +//***************************************************************************** +#define EPI_READFIFO6_DATA_M 0xFFFFFFFF // Reads Data +#define EPI_READFIFO6_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_READFIFO7 +// register. +// +//***************************************************************************** +#define EPI_READFIFO7_DATA_M 0xFFFFFFFF // Reads Data +#define EPI_READFIFO7_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_FIFOLVL register. +// +//***************************************************************************** +#define EPI_FIFOLVL_WFERR 0x00020000 // Write Full Error +#define EPI_FIFOLVL_RSERR 0x00010000 // Read Stall Error +#define EPI_FIFOLVL_WRFIFO_M 0x00000070 // Write FIFO +#define EPI_FIFOLVL_WRFIFO_EMPT 0x00000000 // Trigger when there are 1 to 4 + // spaces available in the WFIFO +#define EPI_FIFOLVL_WRFIFO_1_4 0x00000020 // Trigger when there are 1 to 3 + // spaces available in the WFIFO +#define EPI_FIFOLVL_WRFIFO_1_2 0x00000030 // Trigger when there are 1 to 2 + // spaces available in the WFIFO +#define EPI_FIFOLVL_WRFIFO_3_4 0x00000040 // Trigger when there is 1 space + // available in the WFIFO +#define EPI_FIFOLVL_RDFIFO_M 0x00000007 // Read FIFO +#define EPI_FIFOLVL_RDFIFO_EMPT 0x00000000 // Empty +#define EPI_FIFOLVL_RDFIFO_1_8 0x00000001 // Trigger when there are 1 or more + // entries in the NBRFIFO +#define EPI_FIFOLVL_RDFIFO_1_4 0x00000002 // Trigger when there are 2 or more + // entries in the NBRFIFO +#define EPI_FIFOLVL_RDFIFO_1_2 0x00000003 // Trigger when there are 4 or more + // entries in the NBRFIFO +#define EPI_FIFOLVL_RDFIFO_3_4 0x00000004 // Trigger when there are 6 or more + // entries in the NBRFIFO +#define EPI_FIFOLVL_RDFIFO_7_8 0x00000005 // Trigger when there are 7 or more + // entries in the NBRFIFO +#define EPI_FIFOLVL_RDFIFO_FULL 0x00000006 // Trigger when there are 8 entries + // in the NBRFIFO + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_WFIFOCNT register. +// +//***************************************************************************** +#define EPI_WFIFOCNT_WTAV_M 0x00000007 // Available Write Transactions +#define EPI_WFIFOCNT_WTAV_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_IM register. +// +//***************************************************************************** +#define EPI_IM_WRIM 0x00000004 // Write Interrupt Mask +#define EPI_IM_RDIM 0x00000002 // Read Interrupt Mask +#define EPI_IM_ERRIM 0x00000001 // Error Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_RIS register. +// +//***************************************************************************** +#define EPI_RIS_WRRIS 0x00000004 // Write Raw Interrupt Status +#define EPI_RIS_RDRIS 0x00000002 // Read Raw Interrupt Status +#define EPI_RIS_ERRRIS 0x00000001 // Error Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_MIS register. +// +//***************************************************************************** +#define EPI_MIS_WRMIS 0x00000004 // Write Masked Interrupt Status +#define EPI_MIS_RDMIS 0x00000002 // Read Masked Interrupt Status +#define EPI_MIS_ERRMIS 0x00000001 // Error Masked Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the EPI_O_EISC register. +// +//***************************************************************************** +#define EPI_EISC_WTFULL 0x00000004 // Write FIFO Full Error +#define EPI_EISC_RSTALL 0x00000002 // Read Stalled Error +#define EPI_EISC_TOUT 0x00000001 // Timeout Error + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the EPI_O_BAUD +// register. +// +//***************************************************************************** +#define EPI_BAUD_COUNT_M 0x0000FFFF // Baud Rate Counter +#define EPI_BAUD_COUNT_S 0 + +#endif + +#endif // __HW_EPI_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_ethernet.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_ethernet.h new file mode 100644 index 00000000..742db3ff --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_ethernet.h @@ -0,0 +1,679 @@ +//***************************************************************************** +// +// hw_ethernet.h - Macros used when accessing the Ethernet hardware. +// +// Copyright (c) 2006-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_ETHERNET_H__ +#define __HW_ETHERNET_H__ + +//***************************************************************************** +// +// The following are defines for the Ethernet MAC register offsets. +// +//***************************************************************************** +#define MAC_O_RIS 0x00000000 // Ethernet MAC Raw Interrupt + // Status/Acknowledge +#define MAC_O_IACK 0x00000000 // Ethernet MAC Raw Interrupt + // Status/Acknowledge +#define MAC_O_IM 0x00000004 // Ethernet MAC Interrupt Mask +#define MAC_O_RCTL 0x00000008 // Ethernet MAC Receive Control +#define MAC_O_TCTL 0x0000000C // Ethernet MAC Transmit Control +#define MAC_O_DATA 0x00000010 // Ethernet MAC Data +#define MAC_O_IA0 0x00000014 // Ethernet MAC Individual Address + // 0 +#define MAC_O_IA1 0x00000018 // Ethernet MAC Individual Address + // 1 +#define MAC_O_THR 0x0000001C // Ethernet MAC Threshold +#define MAC_O_MCTL 0x00000020 // Ethernet MAC Management Control +#define MAC_O_MDV 0x00000024 // Ethernet MAC Management Divider +#define MAC_O_MTXD 0x0000002C // Ethernet MAC Management Transmit + // Data +#define MAC_O_MRXD 0x00000030 // Ethernet MAC Management Receive + // Data +#define MAC_O_NP 0x00000034 // Ethernet MAC Number of Packets +#define MAC_O_TR 0x00000038 // Ethernet MAC Transmission + // Request +#define MAC_O_TS 0x0000003C // Ethernet MAC Timer Support +#define MAC_O_LED 0x00000040 // Ethernet MAC LED Encoding +#define MAC_O_MDIX 0x00000044 // Ethernet PHY MDIX + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_RIS register. +// +//***************************************************************************** +#define MAC_RIS_PHYINT 0x00000040 // PHY Interrupt +#define MAC_RIS_MDINT 0x00000020 // MII Transaction Complete +#define MAC_RIS_RXER 0x00000010 // Receive Error +#define MAC_RIS_FOV 0x00000008 // FIFO Overrun +#define MAC_RIS_TXEMP 0x00000004 // Transmit FIFO Empty +#define MAC_RIS_TXER 0x00000002 // Transmit Error +#define MAC_RIS_RXINT 0x00000001 // Packet Received + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_IACK register. +// +//***************************************************************************** +#define MAC_IACK_PHYINT 0x00000040 // Clear PHY Interrupt +#define MAC_IACK_MDINT 0x00000020 // Clear MII Transaction Complete +#define MAC_IACK_RXER 0x00000010 // Clear Receive Error +#define MAC_IACK_FOV 0x00000008 // Clear FIFO Overrun +#define MAC_IACK_TXEMP 0x00000004 // Clear Transmit FIFO Empty +#define MAC_IACK_TXER 0x00000002 // Clear Transmit Error +#define MAC_IACK_RXINT 0x00000001 // Clear Packet Received + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_IM register. +// +//***************************************************************************** +#define MAC_IM_PHYINTM 0x00000040 // Mask PHY Interrupt +#define MAC_IM_MDINTM 0x00000020 // Mask MII Transaction Complete +#define MAC_IM_RXERM 0x00000010 // Mask Receive Error +#define MAC_IM_FOVM 0x00000008 // Mask FIFO Overrun +#define MAC_IM_TXEMPM 0x00000004 // Mask Transmit FIFO Empty +#define MAC_IM_TXERM 0x00000002 // Mask Transmit Error +#define MAC_IM_RXINTM 0x00000001 // Mask Packet Received + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_RCTL register. +// +//***************************************************************************** +#define MAC_RCTL_RSTFIFO 0x00000010 // Clear Receive FIFO +#define MAC_RCTL_BADCRC 0x00000008 // Enable Reject Bad CRC +#define MAC_RCTL_PRMS 0x00000004 // Enable Promiscuous Mode +#define MAC_RCTL_AMUL 0x00000002 // Enable Multicast Frames +#define MAC_RCTL_RXEN 0x00000001 // Enable Receiver + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_TCTL register. +// +//***************************************************************************** +#define MAC_TCTL_DUPLEX 0x00000010 // Enable Duplex Mode +#define MAC_TCTL_CRC 0x00000004 // Enable CRC Generation +#define MAC_TCTL_PADEN 0x00000002 // Enable Packet Padding +#define MAC_TCTL_TXEN 0x00000001 // Enable Transmitter + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_DATA register. +// +//***************************************************************************** +#define MAC_DATA_TXDATA_M 0xFFFFFFFF // Transmit FIFO Data +#define MAC_DATA_RXDATA_M 0xFFFFFFFF // Receive FIFO Data +#define MAC_DATA_RXDATA_S 0 +#define MAC_DATA_TXDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_IA0 register. +// +//***************************************************************************** +#define MAC_IA0_MACOCT4_M 0xFF000000 // MAC Address Octet 4 +#define MAC_IA0_MACOCT3_M 0x00FF0000 // MAC Address Octet 3 +#define MAC_IA0_MACOCT2_M 0x0000FF00 // MAC Address Octet 2 +#define MAC_IA0_MACOCT1_M 0x000000FF // MAC Address Octet 1 +#define MAC_IA0_MACOCT4_S 24 +#define MAC_IA0_MACOCT3_S 16 +#define MAC_IA0_MACOCT2_S 8 +#define MAC_IA0_MACOCT1_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_IA1 register. +// +//***************************************************************************** +#define MAC_IA1_MACOCT6_M 0x0000FF00 // MAC Address Octet 6 +#define MAC_IA1_MACOCT5_M 0x000000FF // MAC Address Octet 5 +#define MAC_IA1_MACOCT6_S 8 +#define MAC_IA1_MACOCT5_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_THR register. +// +//***************************************************************************** +#define MAC_THR_THRESH_M 0x0000003F // Threshold Value +#define MAC_THR_THRESH_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_MCTL register. +// +//***************************************************************************** +#define MAC_MCTL_REGADR_M 0x000000F8 // MII Register Address +#define MAC_MCTL_WRITE 0x00000002 // MII Register Transaction Type +#define MAC_MCTL_START 0x00000001 // MII Register Transaction Enable +#define MAC_MCTL_REGADR_S 3 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_MDV register. +// +//***************************************************************************** +#define MAC_MDV_DIV_M 0x000000FF // Clock Divider +#define MAC_MDV_DIV_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_MTXD register. +// +//***************************************************************************** +#define MAC_MTXD_MDTX_M 0x0000FFFF // MII Register Transmit Data +#define MAC_MTXD_MDTX_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_MRXD register. +// +//***************************************************************************** +#define MAC_MRXD_MDRX_M 0x0000FFFF // MII Register Receive Data +#define MAC_MRXD_MDRX_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_NP register. +// +//***************************************************************************** +#define MAC_NP_NPR_M 0x0000003F // Number of Packets in Receive + // FIFO +#define MAC_NP_NPR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_TR register. +// +//***************************************************************************** +#define MAC_TR_NEWTX 0x00000001 // New Transmission + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_TS register. +// +//***************************************************************************** +#define MAC_TS_TSEN 0x00000001 // Time Stamp Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_LED register. +// +//***************************************************************************** +#define MAC_LED_LED1_M 0x00000F00 // LED1 Source +#define MAC_LED_LED1_LINK 0x00000000 // Link OK +#define MAC_LED_LED1_RXTX 0x00000100 // RX or TX Activity (Default LED1) +#define MAC_LED_LED1_100 0x00000500 // 100BASE-TX mode +#define MAC_LED_LED1_10 0x00000600 // 10BASE-T mode +#define MAC_LED_LED1_DUPLEX 0x00000700 // Full-Duplex +#define MAC_LED_LED1_LINKACT 0x00000800 // Link OK & Blink=RX or TX + // Activity +#define MAC_LED_LED0_M 0x0000000F // LED0 Source +#define MAC_LED_LED0_LINK 0x00000000 // Link OK (Default LED0) +#define MAC_LED_LED0_RXTX 0x00000001 // RX or TX Activity +#define MAC_LED_LED0_100 0x00000005 // 100BASE-TX mode +#define MAC_LED_LED0_10 0x00000006 // 10BASE-T mode +#define MAC_LED_LED0_DUPLEX 0x00000007 // Full-Duplex +#define MAC_LED_LED0_LINKACT 0x00000008 // Link OK & Blink=RX or TX + // Activity + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_MDIX register. +// +//***************************************************************************** +#define MAC_MDIX_EN 0x00000001 // MDI/MDI-X Enable + +//***************************************************************************** +// +// The following are defines for the Ethernet Controller PHY registers. +// +//***************************************************************************** +#define PHY_MR0 0x00000000 // Ethernet PHY Management Register + // 0 - Control +#define PHY_MR1 0x00000001 // Ethernet PHY Management Register + // 1 - Status +#define PHY_MR2 0x00000002 // Ethernet PHY Management Register + // 2 - PHY Identifier 1 +#define PHY_MR3 0x00000003 // Ethernet PHY Management Register + // 3 - PHY Identifier 2 +#define PHY_MR4 0x00000004 // Ethernet PHY Management Register + // 4 - Auto-Negotiation + // Advertisement +#define PHY_MR5 0x00000005 // Ethernet PHY Management Register + // 5 - Auto-Negotiation Link + // Partner Base Page Ability +#define PHY_MR6 0x00000006 // Ethernet PHY Management Register + // 6 - Auto-Negotiation Expansion +#define PHY_MR16 0x00000010 // Ethernet PHY Management Register + // 16 - Vendor-Specific +#define PHY_MR17 0x00000011 // Ethernet PHY Management Register + // 17 - Mode Control/Status +#define PHY_MR18 0x00000012 // Ethernet PHY Management Register + // 18 - Diagnostic +#define PHY_MR19 0x00000013 // Ethernet PHY Management Register + // 19 - Transceiver Control +#define PHY_MR23 0x00000017 // Ethernet PHY Management Register + // 23 - LED Configuration +#define PHY_MR24 0x00000018 // Ethernet PHY Management Register + // 24 -MDI/MDIX Control +#define PHY_MR27 0x0000001B // Ethernet PHY Management Register + // 27 - Special Control/Status +#define PHY_MR29 0x0000001D // Ethernet PHY Management Register + // 29 - Interrupt Status +#define PHY_MR30 0x0000001E // Ethernet PHY Management Register + // 30 - Interrupt Mask +#define PHY_MR31 0x0000001F // Ethernet PHY Management Register + // 31 - PHY Special Control/Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR0 register. +// +//***************************************************************************** +#define PHY_MR0_RESET 0x00008000 // Reset Registers +#define PHY_MR0_LOOPBK 0x00004000 // Loopback Mode +#define PHY_MR0_SPEEDSL 0x00002000 // Speed Select +#define PHY_MR0_ANEGEN 0x00001000 // Auto-Negotiation Enable +#define PHY_MR0_PWRDN 0x00000800 // Power Down +#define PHY_MR0_ISO 0x00000400 // Isolate +#define PHY_MR0_RANEG 0x00000200 // Restart Auto-Negotiation +#define PHY_MR0_DUPLEX 0x00000100 // Set Duplex Mode +#define PHY_MR0_COLT 0x00000080 // Collision Test + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR1 register. +// +//***************************************************************************** +#define PHY_MR1_100X_F 0x00004000 // 100BASE-TX Full-Duplex Mode +#define PHY_MR1_100X_H 0x00002000 // 100BASE-TX Half-Duplex Mode +#define PHY_MR1_10T_F 0x00001000 // 10BASE-T Full-Duplex Mode +#define PHY_MR1_10T_H 0x00000800 // 10BASE-T Half-Duplex Mode +#define PHY_MR1_MFPS 0x00000040 // Management Frames with Preamble + // Suppressed +#define PHY_MR1_ANEGC 0x00000020 // Auto-Negotiation Complete +#define PHY_MR1_RFAULT 0x00000010 // Remote Fault +#define PHY_MR1_ANEGA 0x00000008 // Auto-Negotiation +#define PHY_MR1_LINK 0x00000004 // Link Made +#define PHY_MR1_JAB 0x00000002 // Jabber Condition +#define PHY_MR1_EXTD 0x00000001 // Extended Capabilities + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR2 register. +// +//***************************************************************************** +#define PHY_MR2_OUI_M 0x0000FFFF // Organizationally Unique + // Identifier[21:6] +#define PHY_MR2_OUI_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR3 register. +// +//***************************************************************************** +#define PHY_MR3_OUI_M 0x0000FC00 // Organizationally Unique + // Identifier[5:0] +#define PHY_MR3_MN_M 0x000003F0 // Model Number +#define PHY_MR3_RN_M 0x0000000F // Revision Number +#define PHY_MR3_OUI_S 10 +#define PHY_MR3_MN_S 4 +#define PHY_MR3_RN_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR4 register. +// +//***************************************************************************** +#define PHY_MR4_NP 0x00008000 // Next Page +#define PHY_MR4_RF 0x00002000 // Remote Fault +#define PHY_MR4_A3 0x00000100 // Technology Ability Field [3] +#define PHY_MR4_A2 0x00000080 // Technology Ability Field [2] +#define PHY_MR4_A1 0x00000040 // Technology Ability Field [1] +#define PHY_MR4_A0 0x00000020 // Technology Ability Field [0] +#define PHY_MR4_S_M 0x0000001F // Selector Field +#define PHY_MR4_S_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR5 register. +// +//***************************************************************************** +#define PHY_MR5_NP 0x00008000 // Next Page +#define PHY_MR5_ACK 0x00004000 // Acknowledge +#define PHY_MR5_RF 0x00002000 // Remote Fault +#define PHY_MR5_A_M 0x00001FE0 // Technology Ability Field +#define PHY_MR5_S_M 0x0000001F // Selector Field +#define PHY_MR5_S_8023 0x00000001 // IEEE Std 802.3 +#define PHY_MR5_S_8029 0x00000002 // IEEE Std 802.9 ISLAN-16T +#define PHY_MR5_S_8025 0x00000003 // IEEE Std 802.5 +#define PHY_MR5_S_1394 0x00000004 // IEEE Std 1394 +#define PHY_MR5_A_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR6 register. +// +//***************************************************************************** +#define PHY_MR6_PDF 0x00000010 // Parallel Detection Fault +#define PHY_MR6_LPNPA 0x00000008 // Link Partner is Next Page Able +#define PHY_MR6_PRX 0x00000002 // New Page Received +#define PHY_MR6_LPANEGA 0x00000001 // Link Partner is Auto-Negotiation + // Able + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR16 register. +// +//***************************************************************************** +#define PHY_MR16_RPTR 0x00008000 // Repeater Mode +#define PHY_MR16_INPOL 0x00004000 // Interrupt Polarity +#define PHY_MR16_TXHIM 0x00001000 // Transmit High Impedance Mode +#define PHY_MR16_SQEI 0x00000800 // SQE Inhibit Testing +#define PHY_MR16_NL10 0x00000400 // Natural Loopback Mode +#define PHY_MR16_SR_M 0x000003C0 // Silicon Revision Identifier +#define PHY_MR16_APOL 0x00000020 // Auto-Polarity Disable +#define PHY_MR16_RVSPOL 0x00000010 // Receive Data Polarity +#define PHY_MR16_PCSBP 0x00000002 // PCS Bypass +#define PHY_MR16_RXCC 0x00000001 // Receive Clock Control +#define PHY_MR16_SR_S 6 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR17 register. +// +//***************************************************************************** +#define PHY_MR17_JABBER_IE 0x00008000 // Jabber Interrupt Enable +#define PHY_MR17_FASTRIP 0x00004000 // 10-BASE-T Fast Mode Enable +#define PHY_MR17_RXER_IE 0x00004000 // Receive Error Interrupt Enable +#define PHY_MR17_EDPD 0x00002000 // Enable Energy Detect Power Down +#define PHY_MR17_PRX_IE 0x00002000 // Page Received Interrupt Enable +#define PHY_MR17_PDF_IE 0x00001000 // Parallel Detection Fault + // Interrupt Enable +#define PHY_MR17_LSQE 0x00000800 // Low Squelch Enable +#define PHY_MR17_LPACK_IE 0x00000800 // LP Acknowledge Interrupt Enable +#define PHY_MR17_LSCHG_IE 0x00000400 // Link Status Change Interrupt + // Enable +#define PHY_MR17_RFAULT_IE 0x00000200 // Remote Fault Interrupt Enable +#define PHY_MR17_ANEGCOMP_IE 0x00000100 // Auto-Negotiation Complete + // Interrupt Enable +#define PHY_MR17_FASTEST 0x00000100 // Auto-Negotiation Test Mode +#define PHY_MR17_JABBER_INT 0x00000080 // Jabber Event Interrupt +#define PHY_MR17_RXER_INT 0x00000040 // Receive Error Interrupt +#define PHY_MR17_PRX_INT 0x00000020 // Page Receive Interrupt +#define PHY_MR17_PDF_INT 0x00000010 // Parallel Detection Fault + // Interrupt +#define PHY_MR17_LPACK_INT 0x00000008 // LP Acknowledge Interrupt +#define PHY_MR17_LSCHG_INT 0x00000004 // Link Status Change Interrupt +#define PHY_MR17_FGLS 0x00000004 // Force Good Link Status +#define PHY_MR17_RFAULT_INT 0x00000002 // Remote Fault Interrupt +#define PHY_MR17_ENON 0x00000002 // Energy On +#define PHY_MR17_ANEGCOMP_INT 0x00000001 // Auto-Negotiation Complete + // Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR18 register. +// +//***************************************************************************** +#define PHY_MR18_ANEGF 0x00001000 // Auto-Negotiation Failure +#define PHY_MR18_DPLX 0x00000800 // Duplex Mode +#define PHY_MR18_RATE 0x00000400 // Rate +#define PHY_MR18_RXSD 0x00000200 // Receive Detection +#define PHY_MR18_RX_LOCK 0x00000100 // Receive PLL Lock + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR19 register. +// +//***************************************************************************** +#define PHY_MR19_TXO_M 0x0000C000 // Transmit Amplitude Selection +#define PHY_MR19_TXO_00DB 0x00000000 // Gain set for 0.0dB of insertion + // loss +#define PHY_MR19_TXO_04DB 0x00004000 // Gain set for 0.4dB of insertion + // loss +#define PHY_MR19_TXO_08DB 0x00008000 // Gain set for 0.8dB of insertion + // loss +#define PHY_MR19_TXO_12DB 0x0000C000 // Gain set for 1.2dB of insertion + // loss + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR23 register. +// +//***************************************************************************** +#define PHY_MR23_LED1_M 0x000000F0 // LED1 Source +#define PHY_MR23_LED1_LINK 0x00000000 // Link OK +#define PHY_MR23_LED1_RXTX 0x00000010 // RX or TX Activity (Default LED1) +#define PHY_MR23_LED1_100 0x00000050 // 100BASE-TX mode +#define PHY_MR23_LED1_10 0x00000060 // 10BASE-T mode +#define PHY_MR23_LED1_DUPLEX 0x00000070 // Full-Duplex +#define PHY_MR23_LED1_LINKACT 0x00000080 // Link OK & Blink=RX or TX + // Activity +#define PHY_MR23_LED0_M 0x0000000F // LED0 Source +#define PHY_MR23_LED0_LINK 0x00000000 // Link OK (Default LED0) +#define PHY_MR23_LED0_RXTX 0x00000001 // RX or TX Activity +#define PHY_MR23_LED0_100 0x00000005 // 100BASE-TX mode +#define PHY_MR23_LED0_10 0x00000006 // 10BASE-T mode +#define PHY_MR23_LED0_DUPLEX 0x00000007 // Full-Duplex +#define PHY_MR23_LED0_LINKACT 0x00000008 // Link OK & Blink=RX or TX + // Activity + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR24 register. +// +//***************************************************************************** +#define PHY_MR24_PD_MODE 0x00000080 // Parallel Detection Mode +#define PHY_MR24_AUTO_SW 0x00000040 // Auto-Switching Enable +#define PHY_MR24_MDIX 0x00000020 // Auto-Switching Configuration +#define PHY_MR24_MDIX_CM 0x00000010 // Auto-Switching Complete +#define PHY_MR24_MDIX_SD_M 0x0000000F // Auto-Switching Seed +#define PHY_MR24_MDIX_SD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR27 register. +// +//***************************************************************************** +#define PHY_MR27_XPOL 0x00000010 // Polarity State of 10 BASE-T + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR29 register. +// +//***************************************************************************** +#define PHY_MR29_EONIS 0x00000080 // ENERGYON Interrupt +#define PHY_MR29_ANCOMPIS 0x00000040 // Auto-Negotiation Complete + // Interrupt +#define PHY_MR29_RFLTIS 0x00000020 // Remote Fault Interrupt +#define PHY_MR29_LDIS 0x00000010 // Link Down Interrupt +#define PHY_MR29_LPACKIS 0x00000008 // Auto-Negotiation LP Acknowledge +#define PHY_MR29_PDFIS 0x00000004 // Parallel Detection Fault +#define PHY_MR29_PRXIS 0x00000002 // Auto Negotiation Page Received + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR30 register. +// +//***************************************************************************** +#define PHY_MR30_EONIM 0x00000080 // ENERGYON Interrupt Enabled +#define PHY_MR30_ANCOMPIM 0x00000040 // Auto-Negotiation Complete + // Interrupt Enabled +#define PHY_MR30_RFLTIM 0x00000020 // Remote Fault Interrupt Enabled +#define PHY_MR30_LDIM 0x00000010 // Link Down Interrupt Enabled +#define PHY_MR30_LPACKIM 0x00000008 // Auto-Negotiation LP Acknowledge + // Enabled +#define PHY_MR30_PDFIM 0x00000004 // Parallel Detection Fault Enabled +#define PHY_MR30_PRXIM 0x00000002 // Auto Negotiation Page Received + // Enabled + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR31 register. +// +//***************************************************************************** +#define PHY_MR31_AUTODONE 0x00001000 // Auto Negotiation Done +#define PHY_MR31_SPEED_M 0x0000001C // HCD Speed Value +#define PHY_MR31_SPEED_10HD 0x00000004 // 10BASE-T half duplex +#define PHY_MR31_SPEED_100HD 0x00000008 // 100BASE-T half duplex +#define PHY_MR31_SPEED_10FD 0x00000014 // 10BASE-T full duplex +#define PHY_MR31_SPEED_100FD 0x00000018 // 100BASE-T full duplex +#define PHY_MR31_SCRDIS 0x00000001 // Scramble Disable + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the Ethernet MAC register offsets. +// +//***************************************************************************** +#define MAC_O_IS 0x00000000 // Interrupt Status Register + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the MAC_O_IS +// register. +// +//***************************************************************************** +#define MAC_IS_PHYINT 0x00000040 // PHY Interrupt +#define MAC_IS_MDINT 0x00000020 // MDI Transaction Complete +#define MAC_IS_RXER 0x00000010 // RX Error +#define MAC_IS_FOV 0x00000008 // RX FIFO Overrun +#define MAC_IS_TXEMP 0x00000004 // TX FIFO Empy +#define MAC_IS_TXER 0x00000002 // TX Error +#define MAC_IS_RXINT 0x00000001 // RX Packet Available + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the MAC_O_IA0 +// register. +// +//***************************************************************************** +#define MAC_IA0_MACOCT4 0xFF000000 // 4th Octet of MAC address +#define MAC_IA0_MACOCT3 0x00FF0000 // 3rd Octet of MAC address +#define MAC_IA0_MACOCT2 0x0000FF00 // 2nd Octet of MAC address +#define MAC_IA0_MACOCT1 0x000000FF // 1st Octet of MAC address + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the MAC_O_IA1 +// register. +// +//***************************************************************************** +#define MAC_IA1_MACOCT6 0x0000FF00 // 6th Octet of MAC address +#define MAC_IA1_MACOCT5 0x000000FF // 5th Octet of MAC address + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the MAC_O_THR +// register. +// +//***************************************************************************** +#define MAC_THR_THRESH 0x0000003F // Transmit Threshold Value + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the MAC_O_MCTL +// register. +// +//***************************************************************************** +#define MAC_MCTL_REGADR 0x000000F8 // Address for Next MII Transaction + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the MAC_O_MDV +// register. +// +//***************************************************************************** +#define MAC_MDV_DIV 0x000000FF // Clock Divider for MDC for TX + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the MAC_O_MTXD +// register. +// +//***************************************************************************** +#define MAC_MTXD_MDTX 0x0000FFFF // Data for Next MII Transaction + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the MAC_O_MRXD +// register. +// +//***************************************************************************** +#define MAC_MRXD_MDRX 0x0000FFFF // Data Read from Last MII Trans + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the MAC_O_NP +// register. +// +//***************************************************************************** +#define MAC_NP_NPR 0x0000003F // Number of RX Frames in FIFO + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the PHY_MR23 +// register. +// +//***************************************************************************** +#define PHY_MR23_LED1_TX 0x00000020 // TX Activity +#define PHY_MR23_LED1_RX 0x00000030 // RX Activity +#define PHY_MR23_LED1_COL 0x00000040 // Collision +#define PHY_MR23_LED0_TX 0x00000002 // TX Activity +#define PHY_MR23_LED0_RX 0x00000003 // RX Activity +#define PHY_MR23_LED0_COL 0x00000004 // Collision + +//***************************************************************************** +// +// The following are deprecated defines for the reset values of the MAC +// registers. +// +//***************************************************************************** +#define MAC_RV_MDV 0x00000080 +#define MAC_RV_IM 0x0000007F +#define MAC_RV_THR 0x0000003F +#define MAC_RV_RCTL 0x00000008 +#define MAC_RV_IA0 0x00000000 +#define MAC_RV_TCTL 0x00000000 +#define MAC_RV_DATA 0x00000000 +#define MAC_RV_MRXD 0x00000000 +#define MAC_RV_TR 0x00000000 +#define MAC_RV_IS 0x00000000 +#define MAC_RV_NP 0x00000000 +#define MAC_RV_MCTL 0x00000000 +#define MAC_RV_MTXD 0x00000000 +#define MAC_RV_IA1 0x00000000 +#define MAC_RV_IACK 0x00000000 +#define MAC_RV_MADD 0x00000000 + +#endif + +#endif // __HW_ETHERNET_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_flash.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_flash.h new file mode 100644 index 00000000..13a013e5 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_flash.h @@ -0,0 +1,381 @@ +//***************************************************************************** +// +// hw_flash.h - Macros used when accessing the flash controller. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_FLASH_H__ +#define __HW_FLASH_H__ + +//***************************************************************************** +// +// The following are defines for the FLASH register offsets. +// +//***************************************************************************** +#define FLASH_FMA 0x400FD000 // Flash Memory Address +#define FLASH_FMD 0x400FD004 // Flash Memory Data +#define FLASH_FMC 0x400FD008 // Flash Memory Control +#define FLASH_FCRIS 0x400FD00C // Flash Controller Raw Interrupt + // Status +#define FLASH_FCIM 0x400FD010 // Flash Controller Interrupt Mask +#define FLASH_FCMISC 0x400FD014 // Flash Controller Masked + // Interrupt Status and Clear +#define FLASH_FMC2 0x400FD020 // Flash Memory Control 2 +#define FLASH_FWBVAL 0x400FD030 // Flash Write Buffer Valid +#define FLASH_FCTL 0x400FD0F8 // Flash Control +#define FLASH_FWBN 0x400FD100 // Flash Write Buffer n +#define FLASH_RMCTL 0x400FE0F0 // ROM Control +#define FLASH_FMPRE 0x400FE130 // Flash Memory Protection Read + // Enable +#define FLASH_FMPPE 0x400FE134 // Flash Memory Protection Program + // Enable +#define FLASH_USECRL 0x400FE140 // USec Reload +#define FLASH_USERDBG 0x400FE1D0 // User Debug +#define FLASH_BOOTCFG 0x400FE1D0 // Boot Configuration +#define FLASH_USERREG0 0x400FE1E0 // User Register 0 +#define FLASH_USERREG1 0x400FE1E4 // User Register 1 +#define FLASH_USERREG2 0x400FE1E8 // User Register 2 +#define FLASH_USERREG3 0x400FE1EC // User Register 3 +#define FLASH_FMPRE0 0x400FE200 // Flash Memory Protection Read + // Enable 0 +#define FLASH_FMPRE1 0x400FE204 // Flash Memory Protection Read + // Enable 1 +#define FLASH_FMPRE2 0x400FE208 // Flash Memory Protection Read + // Enable 2 +#define FLASH_FMPRE3 0x400FE20C // Flash Memory Protection Read + // Enable 3 +#define FLASH_FMPPE0 0x400FE400 // Flash Memory Protection Program + // Enable 0 +#define FLASH_FMPPE1 0x400FE404 // Flash Memory Protection Program + // Enable 1 +#define FLASH_FMPPE2 0x400FE408 // Flash Memory Protection Program + // Enable 2 +#define FLASH_FMPPE3 0x400FE40C // Flash Memory Protection Program + // Enable 3 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FMA register. +// +//***************************************************************************** +#define FLASH_FMA_OFFSET_M 0x0003FFFF // Address Offset +#define FLASH_FMA_OFFSET_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FMD register. +// +//***************************************************************************** +#define FLASH_FMD_DATA_M 0xFFFFFFFF // Data Value +#define FLASH_FMD_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FMC register. +// +//***************************************************************************** +#define FLASH_FMC_WRKEY 0xA4420000 // FLASH write key +#define FLASH_FMC_COMT 0x00000008 // Commit Register Value +#define FLASH_FMC_MERASE 0x00000004 // Mass Erase Flash Memory +#define FLASH_FMC_ERASE 0x00000002 // Erase a Page of Flash Memory +#define FLASH_FMC_WRITE 0x00000001 // Write a Word into Flash Memory + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FCRIS register. +// +//***************************************************************************** +#define FLASH_FCRIS_PRIS 0x00000002 // Programming Raw Interrupt Status +#define FLASH_FCRIS_ARIS 0x00000001 // Access Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FCIM register. +// +//***************************************************************************** +#define FLASH_FCIM_PMASK 0x00000002 // Programming Interrupt Mask +#define FLASH_FCIM_AMASK 0x00000001 // Access Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FCMISC register. +// +//***************************************************************************** +#define FLASH_FCMISC_PMISC 0x00000002 // Programming Masked Interrupt + // Status and Clear +#define FLASH_FCMISC_AMISC 0x00000001 // Access Masked Interrupt Status + // and Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FMC2 register. +// +//***************************************************************************** +#define FLASH_FMC2_WRKEY 0xA4420000 // FLASH write key +#define FLASH_FMC2_WRBUF 0x00000001 // Buffered Flash Memory Write + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FWBVAL register. +// +//***************************************************************************** +#define FLASH_FWBVAL_FWB_M 0xFFFFFFFF // Flash Memory Write Buffer + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FCTL register. +// +//***************************************************************************** +#define FLASH_FCTL_USDACK 0x00000002 // User Shut Down Acknowledge +#define FLASH_FCTL_USDREQ 0x00000001 // User Shut Down Request + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FWBN register. +// +//***************************************************************************** +#define FLASH_FWBN_DATA_M 0xFFFFFFFF // Data + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_RMCTL register. +// +//***************************************************************************** +#define FLASH_RMCTL_BA 0x00000001 // Boot Alias + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USECRL register. +// +//***************************************************************************** +#define FLASH_USECRL_M 0x000000FF // Microsecond Reload Value +#define FLASH_USECRL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USERDBG register. +// +//***************************************************************************** +#define FLASH_USERDBG_NW 0x80000000 // User Debug Not Written +#define FLASH_USERDBG_DATA_M 0x7FFFFFFC // User Data +#define FLASH_USERDBG_DBG1 0x00000002 // Debug Control 1 +#define FLASH_USERDBG_DBG0 0x00000001 // Debug Control 0 +#define FLASH_USERDBG_DATA_S 2 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_BOOTCFG register. +// +//***************************************************************************** +#define FLASH_BOOTCFG_NW 0x80000000 // Not Written +#define FLASH_BOOTCFG_PORT_M 0x0000E000 // Boot GPIO Port +#define FLASH_BOOTCFG_PORT_A 0x00000000 // Port A +#define FLASH_BOOTCFG_PORT_B 0x00002000 // Port B +#define FLASH_BOOTCFG_PORT_C 0x00004000 // Port C +#define FLASH_BOOTCFG_PORT_D 0x00006000 // Port D +#define FLASH_BOOTCFG_PORT_E 0x00008000 // Port E +#define FLASH_BOOTCFG_PORT_F 0x0000A000 // Port F +#define FLASH_BOOTCFG_PORT_G 0x0000C000 // Port G +#define FLASH_BOOTCFG_PORT_H 0x0000E000 // Port H +#define FLASH_BOOTCFG_PIN_M 0x00001C00 // Boot GPIO Pin +#define FLASH_BOOTCFG_PIN_0 0x00000000 // Pin 0 +#define FLASH_BOOTCFG_PIN_1 0x00000400 // Pin 1 +#define FLASH_BOOTCFG_PIN_2 0x00000800 // Pin 2 +#define FLASH_BOOTCFG_PIN_3 0x00000C00 // Pin 3 +#define FLASH_BOOTCFG_PIN_4 0x00001000 // Pin 4 +#define FLASH_BOOTCFG_PIN_5 0x00001400 // Pin 5 +#define FLASH_BOOTCFG_PIN_6 0x00001800 // Pin 6 +#define FLASH_BOOTCFG_PIN_7 0x00001C00 // Pin 7 +#define FLASH_BOOTCFG_POL 0x00000200 // Boot GPIO Polarity +#define FLASH_BOOTCFG_EN 0x00000100 // Boot GPIO Enable +#define FLASH_BOOTCFG_DBG1 0x00000002 // Debug Control 1 +#define FLASH_BOOTCFG_DBG0 0x00000001 // Debug Control 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USERREG0 register. +// +//***************************************************************************** +#define FLASH_USERREG0_NW 0x80000000 // Not Written +#define FLASH_USERREG0_DATA_M 0x7FFFFFFF // User Data +#define FLASH_USERREG0_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USERREG1 register. +// +//***************************************************************************** +#define FLASH_USERREG1_NW 0x80000000 // Not Written +#define FLASH_USERREG1_DATA_M 0x7FFFFFFF // User Data +#define FLASH_USERREG1_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USERREG2 register. +// +//***************************************************************************** +#define FLASH_USERREG2_NW 0x80000000 // Not Written +#define FLASH_USERREG2_DATA_M 0x7FFFFFFF // User Data +#define FLASH_USERREG2_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USERREG3 register. +// +//***************************************************************************** +#define FLASH_USERREG3_NW 0x80000000 // Not Written +#define FLASH_USERREG3_DATA_M 0x7FFFFFFF // User Data +#define FLASH_USERREG3_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FMPRE and +// FLASH_FMPPE registers. +// +//***************************************************************************** +#define FLASH_FMP_BLOCK_31 0x80000000 // Enable for block 31 +#define FLASH_FMP_BLOCK_30 0x40000000 // Enable for block 30 +#define FLASH_FMP_BLOCK_29 0x20000000 // Enable for block 29 +#define FLASH_FMP_BLOCK_28 0x10000000 // Enable for block 28 +#define FLASH_FMP_BLOCK_27 0x08000000 // Enable for block 27 +#define FLASH_FMP_BLOCK_26 0x04000000 // Enable for block 26 +#define FLASH_FMP_BLOCK_25 0x02000000 // Enable for block 25 +#define FLASH_FMP_BLOCK_24 0x01000000 // Enable for block 24 +#define FLASH_FMP_BLOCK_23 0x00800000 // Enable for block 23 +#define FLASH_FMP_BLOCK_22 0x00400000 // Enable for block 22 +#define FLASH_FMP_BLOCK_21 0x00200000 // Enable for block 21 +#define FLASH_FMP_BLOCK_20 0x00100000 // Enable for block 20 +#define FLASH_FMP_BLOCK_19 0x00080000 // Enable for block 19 +#define FLASH_FMP_BLOCK_18 0x00040000 // Enable for block 18 +#define FLASH_FMP_BLOCK_17 0x00020000 // Enable for block 17 +#define FLASH_FMP_BLOCK_16 0x00010000 // Enable for block 16 +#define FLASH_FMP_BLOCK_15 0x00008000 // Enable for block 15 +#define FLASH_FMP_BLOCK_14 0x00004000 // Enable for block 14 +#define FLASH_FMP_BLOCK_13 0x00002000 // Enable for block 13 +#define FLASH_FMP_BLOCK_12 0x00001000 // Enable for block 12 +#define FLASH_FMP_BLOCK_11 0x00000800 // Enable for block 11 +#define FLASH_FMP_BLOCK_10 0x00000400 // Enable for block 10 +#define FLASH_FMP_BLOCK_9 0x00000200 // Enable for block 9 +#define FLASH_FMP_BLOCK_8 0x00000100 // Enable for block 8 +#define FLASH_FMP_BLOCK_7 0x00000080 // Enable for block 7 +#define FLASH_FMP_BLOCK_6 0x00000040 // Enable for block 6 +#define FLASH_FMP_BLOCK_5 0x00000020 // Enable for block 5 +#define FLASH_FMP_BLOCK_4 0x00000010 // Enable for block 4 +#define FLASH_FMP_BLOCK_3 0x00000008 // Enable for block 3 +#define FLASH_FMP_BLOCK_2 0x00000004 // Enable for block 2 +#define FLASH_FMP_BLOCK_1 0x00000002 // Enable for block 1 +#define FLASH_FMP_BLOCK_0 0x00000001 // Enable for block 0 + +//***************************************************************************** +// +// The following are defines for the erase size of the FLASH block that is +// erased by an erase operation, and the protect size is the size of the FLASH +// block that is protected by each protection register. +// +//***************************************************************************** +#define FLASH_PROTECT_SIZE 0x00000800 +#define FLASH_ERASE_SIZE 0x00000400 + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the FLASH register offsets. +// +//***************************************************************************** +#define FLASH_RMVER 0x400FE0F4 // ROM Version Register + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the FLASH_FMC +// register. +// +//***************************************************************************** +#define FLASH_FMC_WRKEY_MASK 0xFFFF0000 // FLASH write key mask +#define FLASH_FMC_WRKEY_M 0xFFFF0000 // Flash Memory Write Key +#define FLASH_FMC_WRKEY_S 16 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the FLASH_FCRIS +// register. +// +//***************************************************************************** +#define FLASH_FCRIS_PROGRAM 0x00000002 // Programming status +#define FLASH_FCRIS_ACCESS 0x00000001 // Invalid access status + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the FLASH_FCIM +// register. +// +//***************************************************************************** +#define FLASH_FCIM_PROGRAM 0x00000002 // Programming mask +#define FLASH_FCIM_ACCESS 0x00000001 // Invalid access mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the FLASH_FCMISC +// register. +// +//***************************************************************************** +#define FLASH_FCMISC_PROGRAM 0x00000002 // Programming status +#define FLASH_FCMISC_ACCESS 0x00000001 // Invalid access status + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the FLASH_RMVER +// register. +// +//***************************************************************************** +#define FLASH_RMVER_CONT_M 0xFF000000 // ROM Contents +#define FLASH_RMVER_CONT_LM 0x00000000 // Stellaris Boot Loader & + // DriverLib +#define FLASH_RMVER_CONT_LM_AES 0x02000000 // Stellaris Boot Loader & + // DriverLib with AES +#define FLASH_RMVER_CONT_LM_AES_SAFERTOS \ + 0x03000000 // Stellaris Boot Loader & + // DriverLib with AES and SAFERTOS +#define FLASH_RMVER_CONT_LM_AES2 \ + 0x05000000 // Stellaris Boot Loader & + // DriverLib with AES +#define FLASH_RMVER_VER_M 0x0000FF00 // ROM Version +#define FLASH_RMVER_REV_M 0x000000FF // ROM Revision +#define FLASH_RMVER_VER_S 8 +#define FLASH_RMVER_REV_S 0 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the FLASH_USECRL +// register. +// +//***************************************************************************** +#define FLASH_USECRL_MASK 0x000000FF // Clock per uSec +#define FLASH_USECRL_SHIFT 0 + +#endif + +#endif // __HW_FLASH_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_gpio.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_gpio.h new file mode 100644 index 00000000..acdb2984 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_gpio.h @@ -0,0 +1,592 @@ +//***************************************************************************** +// +// hw_gpio.h - Defines and Macros for GPIO hardware. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_GPIO_H__ +#define __HW_GPIO_H__ + +//***************************************************************************** +// +// The following are defines for the GPIO register offsets. +// +//***************************************************************************** +#define GPIO_O_DATA 0x00000000 // GPIO Data +#define GPIO_O_DIR 0x00000400 // GPIO Direction +#define GPIO_O_IS 0x00000404 // GPIO Interrupt Sense +#define GPIO_O_IBE 0x00000408 // GPIO Interrupt Both Edges +#define GPIO_O_IEV 0x0000040C // GPIO Interrupt Event +#define GPIO_O_IM 0x00000410 // GPIO Interrupt Mask +#define GPIO_O_RIS 0x00000414 // GPIO Raw Interrupt Status +#define GPIO_O_MIS 0x00000418 // GPIO Masked Interrupt Status +#define GPIO_O_ICR 0x0000041C // GPIO Interrupt Clear +#define GPIO_O_AFSEL 0x00000420 // GPIO Alternate Function Select +#define GPIO_O_DR2R 0x00000500 // GPIO 2-mA Drive Select +#define GPIO_O_DR4R 0x00000504 // GPIO 4-mA Drive Select +#define GPIO_O_DR8R 0x00000508 // GPIO 8-mA Drive Select +#define GPIO_O_ODR 0x0000050C // GPIO Open Drain Select +#define GPIO_O_PUR 0x00000510 // GPIO Pull-Up Select +#define GPIO_O_PDR 0x00000514 // GPIO Pull-Down Select +#define GPIO_O_SLR 0x00000518 // GPIO Slew Rate Control Select +#define GPIO_O_DEN 0x0000051C // GPIO Digital Enable +#define GPIO_O_LOCK 0x00000520 // GPIO Lock +#define GPIO_O_CR 0x00000524 // GPIO Commit +#define GPIO_O_AMSEL 0x00000528 // GPIO Analog Mode Select +#define GPIO_O_PCTL 0x0000052C // GPIO Port Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_O_LOCK register. +// +//***************************************************************************** +#define GPIO_LOCK_M 0xFFFFFFFF // GPIO Lock +#define GPIO_LOCK_UNLOCKED 0x00000000 // The GPIOCR register is unlocked + // and may be modified +#define GPIO_LOCK_LOCKED 0x00000001 // The GPIOCR register is locked + // and may not be modified +#define GPIO_LOCK_KEY 0x1ACCE551 // Unlocks the GPIO_CR register +#define GPIO_LOCK_KEY_DD 0x4C4F434B // Unlocks the GPIO_CR register on + // DustDevil-class devices and + // later + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port A. +// +//***************************************************************************** +#define GPIO_PCTL_PA0_M 0x0000000F // PA0 mask +#define GPIO_PCTL_PA0_U0RX 0x00000001 // U0RX on PA0 +#define GPIO_PCTL_PA0_I2C1SCL 0x00000008 // I2C1SCL on PA0 +#define GPIO_PCTL_PA0_U1RX 0x00000009 // U1RX on PA0 +#define GPIO_PCTL_PA1_M 0x000000F0 // PA1 mask +#define GPIO_PCTL_PA1_U0TX 0x00000010 // U0TX on PA1 +#define GPIO_PCTL_PA1_I2C1SDA 0x00000080 // I2C1SDA on PA1 +#define GPIO_PCTL_PA1_U1TX 0x00000090 // U1TX on PA1 +#define GPIO_PCTL_PA2_M 0x00000F00 // PA2 mask +#define GPIO_PCTL_PA2_SSI0CLK 0x00000100 // SSI0CLK on PA2 +#define GPIO_PCTL_PA2_PWM4 0x00000400 // PWM4 on PA2 +#define GPIO_PCTL_PA2_I2S0RXSD 0x00000900 // I2S0RXSD on PA2 +#define GPIO_PCTL_PA3_M 0x0000F000 // PA3 mask +#define GPIO_PCTL_PA3_SSI0FSS 0x00001000 // SSI0FSS on PA3 +#define GPIO_PCTL_PA3_PWM5 0x00004000 // PWM5 on PA3 +#define GPIO_PCTL_PA3_I2S0RXMCLK \ + 0x00009000 // I2S0RXMCLK on PA3 +#define GPIO_PCTL_PA4_M 0x000F0000 // PA4 mask +#define GPIO_PCTL_PA4_SSI0RX 0x00010000 // SSI0RX on PA4 +#define GPIO_PCTL_PA4_PWM6 0x00040000 // PWM6 on PA4 +#define GPIO_PCTL_PA4_CAN0RX 0x00050000 // CAN0RX on PA4 +#define GPIO_PCTL_PA4_I2S0TXSCK 0x00090000 // I2S0TXSCK on PA4 +#define GPIO_PCTL_PA5_M 0x00F00000 // PA5 mask +#define GPIO_PCTL_PA5_SSI0TX 0x00100000 // SSI0TX on PA5 +#define GPIO_PCTL_PA5_PWM7 0x00400000 // PWM7 on PA5 +#define GPIO_PCTL_PA5_CAN0TX 0x00500000 // CAN0TX on PA5 +#define GPIO_PCTL_PA5_I2S0TXWS 0x00900000 // I2S0TXWS on PA5 +#define GPIO_PCTL_PA6_M 0x0F000000 // PA6 mask +#define GPIO_PCTL_PA6_I2C1SCL 0x01000000 // I2C1SCL on PA6 +#define GPIO_PCTL_PA6_CCP1 0x02000000 // CCP1 on PA6 +#define GPIO_PCTL_PA6_PWM0 0x04000000 // PWM0 on PA6 +#define GPIO_PCTL_PA6_PWM4 0x05000000 // PWM4 on PA6 +#define GPIO_PCTL_PA6_CAN0RX 0x06000000 // CAN0RX on PA6 +#define GPIO_PCTL_PA6_USB0EPEN 0x08000000 // USB0EPEN on PA6 +#define GPIO_PCTL_PA6_U1CTS 0x09000000 // U1CTS on PA6 +#define GPIO_PCTL_PA7_M 0xF0000000 // PA7 mask +#define GPIO_PCTL_PA7_I2C1SDA 0x10000000 // I2C1SDA on PA7 +#define GPIO_PCTL_PA7_CCP4 0x20000000 // CCP4 on PA7 +#define GPIO_PCTL_PA7_PWM1 0x40000000 // PWM1 on PA7 +#define GPIO_PCTL_PA7_PWM5 0x50000000 // PWM5 on PA7 +#define GPIO_PCTL_PA7_CAN0TX 0x60000000 // CAN0TX on PA7 +#define GPIO_PCTL_PA7_CCP3 0x70000000 // CCP3 on PA7 +#define GPIO_PCTL_PA7_USB0PFLT 0x80000000 // USB0PFLT on PA7 +#define GPIO_PCTL_PA7_U1DCD 0x90000000 // U1DCD on PA7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port B. +// +//***************************************************************************** +#define GPIO_PCTL_PB0_M 0x0000000F // PB0 mask +#define GPIO_PCTL_PB0_CCP0 0x00000001 // CCP0 on PB0 +#define GPIO_PCTL_PB0_PWM2 0x00000002 // PWM2 on PB0 +#define GPIO_PCTL_PB0_U1RX 0x00000005 // U1RX on PB0 +#define GPIO_PCTL_PB1_M 0x000000F0 // PB1 mask +#define GPIO_PCTL_PB1_CCP2 0x00000010 // CCP2 on PB1 +#define GPIO_PCTL_PB1_PWM3 0x00000020 // PWM3 on PB1 +#define GPIO_PCTL_PB1_CCP1 0x00000040 // CCP1 on PB1 +#define GPIO_PCTL_PB1_U1TX 0x00000050 // U1TX on PB1 +#define GPIO_PCTL_PB2_M 0x00000F00 // PB2 mask +#define GPIO_PCTL_PB2_I2C0SCL 0x00000100 // I2C0SCL on PB2 +#define GPIO_PCTL_PB2_IDX0 0x00000200 // IDX0 on PB2 +#define GPIO_PCTL_PB2_CCP3 0x00000400 // CCP3 on PB2 +#define GPIO_PCTL_PB2_CCP0 0x00000500 // CCP0 on PB2 +#define GPIO_PCTL_PB2_USB0EPEN 0x00000800 // USB0EPEN on PB2 +#define GPIO_PCTL_PB3_M 0x0000F000 // PB3 mask +#define GPIO_PCTL_PB3_I2C0SDA 0x00001000 // I2C0SDA on PB3 +#define GPIO_PCTL_PB3_FAULT0 0x00002000 // FAULT0 on PB3 +#define GPIO_PCTL_PB3_FAULT3 0x00004000 // FAULT3 on PB3 +#define GPIO_PCTL_PB3_USB0PFLT 0x00008000 // USB0PFLT on PB3 +#define GPIO_PCTL_PB4_M 0x000F0000 // PB4 mask +#define GPIO_PCTL_PB4_U2RX 0x00040000 // U2RX on PB4 +#define GPIO_PCTL_PB4_CAN0RX 0x00050000 // CAN0RX on PB4 +#define GPIO_PCTL_PB4_IDX0 0x00060000 // IDX0 on PB4 +#define GPIO_PCTL_PB4_U1RX 0x00070000 // U1RX on PB4 +#define GPIO_PCTL_PB4_EPI0S23 0x00080000 // EPI0S23 on PB4 +#define GPIO_PCTL_PB5_M 0x00F00000 // PB5 mask +#define GPIO_PCTL_PB5_C0O 0x00100000 // C0O on PB5 +#define GPIO_PCTL_PB5_CCP5 0x00200000 // CCP5 on PB5 +#define GPIO_PCTL_PB5_CCP6 0x00300000 // CCP6 on PB5 +#define GPIO_PCTL_PB5_CCP0 0x00400000 // CCP0 on PB5 +#define GPIO_PCTL_PB5_CAN0TX 0x00500000 // CAN0TX on PB5 +#define GPIO_PCTL_PB5_CCP2 0x00600000 // CCP2 on PB5 +#define GPIO_PCTL_PB5_U1TX 0x00700000 // U1TX on PB5 +#define GPIO_PCTL_PB5_EPI0S22 0x00800000 // EPI0S22 on PB5 +#define GPIO_PCTL_PB6_M 0x0F000000 // PB6 mask +#define GPIO_PCTL_PB6_CCP1 0x01000000 // CCP1 on PB6 +#define GPIO_PCTL_PB6_CCP7 0x02000000 // CCP7 on PB6 +#define GPIO_PCTL_PB6_C0O 0x03000000 // C0O on PB6 +#define GPIO_PCTL_PB6_FAULT1 0x04000000 // FAULT1 on PB6 +#define GPIO_PCTL_PB6_IDX0 0x05000000 // IDX0 on PB6 +#define GPIO_PCTL_PB6_CCP5 0x06000000 // CCP5 on PB6 +#define GPIO_PCTL_PB6_I2S0TXSCK 0x09000000 // I2S0TXSCK on PB6 +#define GPIO_PCTL_PB7_M 0xF0000000 // PB7 mask +#define GPIO_PCTL_PB7_NMI 0x40000000 // NMI on PB7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port C. +// +//***************************************************************************** +#define GPIO_PCTL_PC0_M 0x0000000F // PC0 mask +#define GPIO_PCTL_PC0_TCK 0x00000003 // TCK on PC0 +#define GPIO_PCTL_PC1_M 0x000000F0 // PC1 mask +#define GPIO_PCTL_PC1_TMS 0x00000030 // TMS on PC1 +#define GPIO_PCTL_PC2_M 0x00000F00 // PC2 mask +#define GPIO_PCTL_PC2_TDI 0x00000300 // TDI on PC2 +#define GPIO_PCTL_PC3_M 0x0000F000 // PC3 mask +#define GPIO_PCTL_PC3_TDO 0x00003000 // TDO on PC3 +#define GPIO_PCTL_PC4_M 0x000F0000 // PC4 mask +#define GPIO_PCTL_PC4_CCP5 0x00010000 // CCP5 on PC4 +#define GPIO_PCTL_PC4_PHA0 0x00020000 // PHA0 on PC4 +#define GPIO_PCTL_PC4_PWM6 0x00040000 // PWM6 on PC4 +#define GPIO_PCTL_PC4_CCP2 0x00050000 // CCP2 on PC4 +#define GPIO_PCTL_PC4_CCP4 0x00060000 // CCP4 on PC4 +#define GPIO_PCTL_PC4_EPI0S2 0x00080000 // EPI0S2 on PC4 +#define GPIO_PCTL_PC4_CCP1 0x00090000 // CCP1 on PC4 +#define GPIO_PCTL_PC5_M 0x00F00000 // PC5 mask +#define GPIO_PCTL_PC5_CCP1 0x00100000 // CCP1 on PC5 +#define GPIO_PCTL_PC5_C1O 0x00200000 // C1O on PC5 +#define GPIO_PCTL_PC5_C0O 0x00300000 // C0O on PC5 +#define GPIO_PCTL_PC5_FAULT2 0x00400000 // FAULT2 on PC5 +#define GPIO_PCTL_PC5_CCP3 0x00500000 // CCP3 on PC5 +#define GPIO_PCTL_PC5_USB0EPEN 0x00600000 // USB0EPEN on PC5 +#define GPIO_PCTL_PC5_EPI0S3 0x00800000 // EPI0S3 on PC5 +#define GPIO_PCTL_PC6_M 0x0F000000 // PC6 mask +#define GPIO_PCTL_PC6_CCP3 0x01000000 // CCP3 on PC6 +#define GPIO_PCTL_PC6_PHB0 0x02000000 // PHB0 on PC6 +#define GPIO_PCTL_PC6_C2O 0x03000000 // C2O on PC6 +#define GPIO_PCTL_PC6_PWM7 0x04000000 // PWM7 on PC6 +#define GPIO_PCTL_PC6_U1RX 0x05000000 // U1RX on PC6 +#define GPIO_PCTL_PC6_CCP0 0x06000000 // CCP0 on PC6 +#define GPIO_PCTL_PC6_USB0PFLT 0x07000000 // USB0PFLT on PC6 +#define GPIO_PCTL_PC6_EPI0S4 0x08000000 // EPI0S4 on PC6 +#define GPIO_PCTL_PC7_M 0xF0000000 // PC7 mask +#define GPIO_PCTL_PC7_CCP4 0x10000000 // CCP4 on PC7 +#define GPIO_PCTL_PC7_PHB0 0x20000000 // PHB0 on PC7 +#define GPIO_PCTL_PC7_CCP0 0x40000000 // CCP0 on PC7 +#define GPIO_PCTL_PC7_U1TX 0x50000000 // U1TX on PC7 +#define GPIO_PCTL_PC7_USB0PFLT 0x60000000 // USB0PFLT on PC7 +#define GPIO_PCTL_PC7_C1O 0x70000000 // C1O on PC7 +#define GPIO_PCTL_PC7_EPI0S5 0x80000000 // EPI0S5 on PC7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port D. +// +//***************************************************************************** +#define GPIO_PCTL_PD0_M 0x0000000F // PD0 mask +#define GPIO_PCTL_PD0_PWM0 0x00000001 // PWM0 on PD0 +#define GPIO_PCTL_PD0_CAN0RX 0x00000002 // CAN0RX on PD0 +#define GPIO_PCTL_PD0_IDX0 0x00000003 // IDX0 on PD0 +#define GPIO_PCTL_PD0_U2RX 0x00000004 // U2RX on PD0 +#define GPIO_PCTL_PD0_U1RX 0x00000005 // U1RX on PD0 +#define GPIO_PCTL_PD0_CCP6 0x00000006 // CCP6 on PD0 +#define GPIO_PCTL_PD0_I2S0RXSCK 0x00000008 // I2S0RXSCK on PD0 +#define GPIO_PCTL_PD0_U1CTS 0x00000009 // U1CTS on PD0 +#define GPIO_PCTL_PD1_M 0x000000F0 // PD1 mask +#define GPIO_PCTL_PD1_PWM1 0x00000010 // PWM1 on PD1 +#define GPIO_PCTL_PD1_CAN0TX 0x00000020 // CAN0TX on PD1 +#define GPIO_PCTL_PD1_PHA0 0x00000030 // PHA0 on PD1 +#define GPIO_PCTL_PD1_U2TX 0x00000040 // U2TX on PD1 +#define GPIO_PCTL_PD1_U1TX 0x00000050 // U1TX on PD1 +#define GPIO_PCTL_PD1_CCP7 0x00000060 // CCP7 on PD1 +#define GPIO_PCTL_PD1_I2S0RXWS 0x00000080 // I2S0RXWS on PD1 +#define GPIO_PCTL_PD1_U1DCD 0x00000090 // U1DCD on PD1 +#define GPIO_PCTL_PD1_CCP2 0x000000A0 // CCP2 on PD1 +#define GPIO_PCTL_PD1_PHB1 0x000000B0 // PHB1 on PD1 +#define GPIO_PCTL_PD2_M 0x00000F00 // PD2 mask +#define GPIO_PCTL_PD2_U1RX 0x00000100 // U1RX on PD2 +#define GPIO_PCTL_PD2_CCP6 0x00000200 // CCP6 on PD2 +#define GPIO_PCTL_PD2_PWM2 0x00000300 // PWM2 on PD2 +#define GPIO_PCTL_PD2_CCP5 0x00000400 // CCP5 on PD2 +#define GPIO_PCTL_PD2_EPI0S20 0x00000800 // EPI0S20 on PD2 +#define GPIO_PCTL_PD3_M 0x0000F000 // PD3 mask +#define GPIO_PCTL_PD3_U1TX 0x00001000 // U1TX on PD3 +#define GPIO_PCTL_PD3_CCP7 0x00002000 // CCP7 on PD3 +#define GPIO_PCTL_PD3_PWM3 0x00003000 // PWM3 on PD3 +#define GPIO_PCTL_PD3_CCP0 0x00004000 // CCP0 on PD3 +#define GPIO_PCTL_PD3_EPI0S21 0x00008000 // EPI0S21 on PD3 +#define GPIO_PCTL_PD4_M 0x000F0000 // PD4 mask +#define GPIO_PCTL_PD4_CCP0 0x00010000 // CCP0 on PD4 +#define GPIO_PCTL_PD4_CCP3 0x00020000 // CCP3 on PD4 +#define GPIO_PCTL_PD4_I2S0RXSD 0x00080000 // I2S0RXSD on PD4 +#define GPIO_PCTL_PD4_U1RI 0x00090000 // U1RI on PD4 +#define GPIO_PCTL_PD4_EPI0S19 0x000A0000 // EPI0S19 on PD4 +#define GPIO_PCTL_PD5_M 0x00F00000 // PD5 mask +#define GPIO_PCTL_PD5_CCP2 0x00100000 // CCP2 on PD5 +#define GPIO_PCTL_PD5_CCP4 0x00200000 // CCP4 on PD5 +#define GPIO_PCTL_PD5_I2S0RXMCLK \ + 0x00800000 // I2S0RXMCLK on PD5 +#define GPIO_PCTL_PD5_U2RX 0x00900000 // U2RX on PD5 +#define GPIO_PCTL_PD5_EPI0S28 0x00A00000 // EPI0S28 on PD5 +#define GPIO_PCTL_PD6_M 0x0F000000 // PD6 mask +#define GPIO_PCTL_PD6_FAULT0 0x01000000 // FAULT0 on PD6 +#define GPIO_PCTL_PD6_I2S0TXSCK 0x08000000 // I2S0TXSCK on PD6 +#define GPIO_PCTL_PD6_U2TX 0x09000000 // U2TX on PD6 +#define GPIO_PCTL_PD6_EPI0S29 0x0A000000 // EPI0S29 on PD6 +#define GPIO_PCTL_PD7_M 0xF0000000 // PD7 mask +#define GPIO_PCTL_PD7_IDX0 0x10000000 // IDX0 on PD7 +#define GPIO_PCTL_PD7_C0O 0x20000000 // C0O on PD7 +#define GPIO_PCTL_PD7_CCP1 0x30000000 // CCP1 on PD7 +#define GPIO_PCTL_PD7_I2S0TXWS 0x80000000 // I2S0TXWS on PD7 +#define GPIO_PCTL_PD7_U1DTR 0x90000000 // U1DTR on PD7 +#define GPIO_PCTL_PD7_EPI0S30 0xA0000000 // EPI0S30 on PD7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port E. +// +//***************************************************************************** +#define GPIO_PCTL_PE0_M 0x0000000F // PE0 mask +#define GPIO_PCTL_PE0_PWM4 0x00000001 // PWM4 on PE0 +#define GPIO_PCTL_PE0_SSI1CLK 0x00000002 // SSI1CLK on PE0 +#define GPIO_PCTL_PE0_CCP3 0x00000003 // CCP3 on PE0 +#define GPIO_PCTL_PE0_EPI0S8 0x00000008 // EPI0S8 on PE0 +#define GPIO_PCTL_PE0_USB0PFLT 0x00000009 // USB0PFLT on PE0 +#define GPIO_PCTL_PE1_M 0x000000F0 // PE1 mask +#define GPIO_PCTL_PE1_PWM5 0x00000010 // PWM5 on PE1 +#define GPIO_PCTL_PE1_SSI1FSS 0x00000020 // SSI1FSS on PE1 +#define GPIO_PCTL_PE1_FAULT0 0x00000030 // FAULT0 on PE1 +#define GPIO_PCTL_PE1_CCP2 0x00000040 // CCP2 on PE1 +#define GPIO_PCTL_PE1_CCP6 0x00000050 // CCP6 on PE1 +#define GPIO_PCTL_PE1_EPI0S9 0x00000080 // EPI0S9 on PE1 +#define GPIO_PCTL_PE2_M 0x00000F00 // PE2 mask +#define GPIO_PCTL_PE2_CCP4 0x00000100 // CCP4 on PE2 +#define GPIO_PCTL_PE2_SSI1RX 0x00000200 // SSI1RX on PE2 +#define GPIO_PCTL_PE2_PHB1 0x00000300 // PHB1 on PE2 +#define GPIO_PCTL_PE2_PHA0 0x00000400 // PHA0 on PE2 +#define GPIO_PCTL_PE2_CCP2 0x00000500 // CCP2 on PE2 +#define GPIO_PCTL_PE2_EPI0S24 0x00000800 // EPI0S24 on PE2 +#define GPIO_PCTL_PE3_M 0x0000F000 // PE3 mask +#define GPIO_PCTL_PE3_CCP1 0x00001000 // CCP1 on PE3 +#define GPIO_PCTL_PE3_SSI1TX 0x00002000 // SSI1TX on PE3 +#define GPIO_PCTL_PE3_PHA1 0x00003000 // PHA1 on PE3 +#define GPIO_PCTL_PE3_PHB0 0x00004000 // PHB0 on PE3 +#define GPIO_PCTL_PE3_CCP7 0x00005000 // CCP7 on PE3 +#define GPIO_PCTL_PE3_EPI0S25 0x00008000 // EPI0S25 on PE3 +#define GPIO_PCTL_PE4_M 0x000F0000 // PE4 mask +#define GPIO_PCTL_PE4_CCP3 0x00010000 // CCP3 on PE4 +#define GPIO_PCTL_PE4_FAULT0 0x00040000 // FAULT0 on PE4 +#define GPIO_PCTL_PE4_U2TX 0x00050000 // U2TX on PE4 +#define GPIO_PCTL_PE4_CCP2 0x00060000 // CCP2 on PE4 +#define GPIO_PCTL_PE4_I2S0TXWS 0x00090000 // I2S0TXWS on PE4 +#define GPIO_PCTL_PE5_M 0x00F00000 // PE5 mask +#define GPIO_PCTL_PE5_CCP5 0x00100000 // CCP5 on PE5 +#define GPIO_PCTL_PE5_I2S0TXSD 0x00900000 // I2S0TXSD on PE5 +#define GPIO_PCTL_PE6_M 0x0F000000 // PE6 mask +#define GPIO_PCTL_PE6_PWM4 0x01000000 // PWM4 on PE6 +#define GPIO_PCTL_PE6_C1O 0x02000000 // C1O on PE6 +#define GPIO_PCTL_PE6_U1CTS 0x09000000 // U1CTS on PE6 +#define GPIO_PCTL_PE7_M 0xF0000000 // PE7 mask +#define GPIO_PCTL_PE7_PWM5 0x10000000 // PWM5 on PE7 +#define GPIO_PCTL_PE7_C2O 0x20000000 // C2O on PE7 +#define GPIO_PCTL_PE7_U1DCD 0x90000000 // U1DCD on PE7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port F. +// +//***************************************************************************** +#define GPIO_PCTL_PF0_M 0x0000000F // PF0 mask +#define GPIO_PCTL_PF0_CAN1RX 0x00000001 // CAN1RX on PF0 +#define GPIO_PCTL_PF0_PHB0 0x00000002 // PHB0 on PF0 +#define GPIO_PCTL_PF0_PWM0 0x00000003 // PWM0 on PF0 +#define GPIO_PCTL_PF0_I2S0TXSD 0x00000008 // I2S0TXSD on PF0 +#define GPIO_PCTL_PF0_U1DSR 0x00000009 // U1DSR on PF0 +#define GPIO_PCTL_PF1_M 0x000000F0 // PF1 mask +#define GPIO_PCTL_PF1_CAN1TX 0x00000010 // CAN1TX on PF1 +#define GPIO_PCTL_PF1_IDX1 0x00000020 // IDX1 on PF1 +#define GPIO_PCTL_PF1_PWM1 0x00000030 // PWM1 on PF1 +#define GPIO_PCTL_PF1_I2S0TXMCLK \ + 0x00000080 // I2S0TXMCLK on PF1 +#define GPIO_PCTL_PF1_U1RTS 0x00000090 // U1RTS on PF1 +#define GPIO_PCTL_PF1_CCP3 0x000000A0 // CCP3 on PF1 +#define GPIO_PCTL_PF2_M 0x00000F00 // PF2 mask +#define GPIO_PCTL_PF2_LED1 0x00000100 // LED1 on PF2 +#define GPIO_PCTL_PF2_PWM4 0x00000200 // PWM4 on PF2 +#define GPIO_PCTL_PF2_PWM2 0x00000400 // PWM2 on PF2 +#define GPIO_PCTL_PF2_SSI1CLK 0x00000900 // SSI1CLK on PF2 +#define GPIO_PCTL_PF3_M 0x0000F000 // PF3 mask +#define GPIO_PCTL_PF3_LED0 0x00001000 // LED0 on PF3 +#define GPIO_PCTL_PF3_PWM5 0x00002000 // PWM5 on PF3 +#define GPIO_PCTL_PF3_PWM3 0x00004000 // PWM3 on PF3 +#define GPIO_PCTL_PF3_SSI1FSS 0x00009000 // SSI1FSS on PF3 +#define GPIO_PCTL_PF4_M 0x000F0000 // PF4 mask +#define GPIO_PCTL_PF4_CCP0 0x00010000 // CCP0 on PF4 +#define GPIO_PCTL_PF4_C0O 0x00020000 // C0O on PF4 +#define GPIO_PCTL_PF4_FAULT0 0x00040000 // FAULT0 on PF4 +#define GPIO_PCTL_PF4_EPI0S12 0x00080000 // EPI0S12 on PF4 +#define GPIO_PCTL_PF4_SSI1RX 0x00090000 // SSI1RX on PF4 +#define GPIO_PCTL_PF5_M 0x00F00000 // PF5 mask +#define GPIO_PCTL_PF5_CCP2 0x00100000 // CCP2 on PF5 +#define GPIO_PCTL_PF5_C1O 0x00200000 // C1O on PF5 +#define GPIO_PCTL_PF5_EPI0S15 0x00800000 // EPI0S15 on PF5 +#define GPIO_PCTL_PF5_SSI1TX 0x00900000 // SSI1TX on PF5 +#define GPIO_PCTL_PF6_M 0x0F000000 // PF6 mask +#define GPIO_PCTL_PF6_CCP1 0x01000000 // CCP1 on PF6 +#define GPIO_PCTL_PF6_C2O 0x02000000 // C2O on PF6 +#define GPIO_PCTL_PF6_PHA0 0x04000000 // PHA0 on PF6 +#define GPIO_PCTL_PF6_I2S0TXMCLK \ + 0x09000000 // I2S0TXMCLK on PF6 +#define GPIO_PCTL_PF6_U1RTS 0x0A000000 // U1RTS on PF6 +#define GPIO_PCTL_PF7_M 0xF0000000 // PF7 mask +#define GPIO_PCTL_PF7_CCP4 0x10000000 // CCP4 on PF7 +#define GPIO_PCTL_PF7_PHB0 0x40000000 // PHB0 on PF7 +#define GPIO_PCTL_PF7_EPI0S12 0x80000000 // EPI0S12 on PF7 +#define GPIO_PCTL_PF7_FAULT1 0x90000000 // FAULT1 on PF7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port G. +// +//***************************************************************************** +#define GPIO_PCTL_PG0_M 0x0000000F // PG0 mask +#define GPIO_PCTL_PG0_U2RX 0x00000001 // U2RX on PG0 +#define GPIO_PCTL_PG0_PWM0 0x00000002 // PWM0 on PG0 +#define GPIO_PCTL_PG0_I2C1SCL 0x00000003 // I2C1SCL on PG0 +#define GPIO_PCTL_PG0_PWM4 0x00000004 // PWM4 on PG0 +#define GPIO_PCTL_PG0_USB0EPEN 0x00000007 // USB0EPEN on PG0 +#define GPIO_PCTL_PG0_EPI0S13 0x00000008 // EPI0S13 on PG0 +#define GPIO_PCTL_PG1_M 0x000000F0 // PG1 mask +#define GPIO_PCTL_PG1_U2TX 0x00000010 // U2TX on PG1 +#define GPIO_PCTL_PG1_PWM1 0x00000020 // PWM1 on PG1 +#define GPIO_PCTL_PG1_I2C1SDA 0x00000030 // I2C1SDA on PG1 +#define GPIO_PCTL_PG1_PWM5 0x00000040 // PWM5 on PG1 +#define GPIO_PCTL_PG1_EPI0S14 0x00000080 // EPI0S14 on PG1 +#define GPIO_PCTL_PG2_M 0x00000F00 // PG2 mask +#define GPIO_PCTL_PG2_PWM0 0x00000100 // PWM0 on PG2 +#define GPIO_PCTL_PG2_FAULT0 0x00000400 // FAULT0 on PG2 +#define GPIO_PCTL_PG2_IDX1 0x00000800 // IDX1 on PG2 +#define GPIO_PCTL_PG2_I2S0RXSD 0x00000900 // I2S0RXSD on PG2 +#define GPIO_PCTL_PG3_M 0x0000F000 // PG3 mask +#define GPIO_PCTL_PG3_PWM1 0x00001000 // PWM1 on PG3 +#define GPIO_PCTL_PG3_FAULT2 0x00004000 // FAULT2 on PG3 +#define GPIO_PCTL_PG3_FAULT0 0x00008000 // FAULT0 on PG3 +#define GPIO_PCTL_PG3_I2S0RXMCLK \ + 0x00009000 // I2S0RXMCLK on PG3 +#define GPIO_PCTL_PG4_M 0x000F0000 // PG4 mask +#define GPIO_PCTL_PG4_CCP3 0x00010000 // CCP3 on PG4 +#define GPIO_PCTL_PG4_FAULT1 0x00040000 // FAULT1 on PG4 +#define GPIO_PCTL_PG4_EPI0S15 0x00080000 // EPI0S15 on PG4 +#define GPIO_PCTL_PG4_PWM6 0x00090000 // PWM6 on PG4 +#define GPIO_PCTL_PG4_U1RI 0x000A0000 // U1RI on PG4 +#define GPIO_PCTL_PG5_M 0x00F00000 // PG5 mask +#define GPIO_PCTL_PG5_CCP5 0x00100000 // CCP5 on PG5 +#define GPIO_PCTL_PG5_IDX0 0x00400000 // IDX0 on PG5 +#define GPIO_PCTL_PG5_FAULT1 0x00500000 // FAULT1 on PG5 +#define GPIO_PCTL_PG5_PWM7 0x00800000 // PWM7 on PG5 +#define GPIO_PCTL_PG5_I2S0RXSCK 0x00900000 // I2S0RXSCK on PG5 +#define GPIO_PCTL_PG5_U1DTR 0x00A00000 // U1DTR on PG5 +#define GPIO_PCTL_PG6_M 0x0F000000 // PG6 mask +#define GPIO_PCTL_PG6_PHA1 0x01000000 // PHA1 on PG6 +#define GPIO_PCTL_PG6_PWM6 0x04000000 // PWM6 on PG6 +#define GPIO_PCTL_PG6_FAULT1 0x08000000 // FAULT1 on PG6 +#define GPIO_PCTL_PG6_I2S0RXWS 0x09000000 // I2S0RXWS on PG6 +#define GPIO_PCTL_PG6_U1RI 0x0A000000 // U1RI on PG6 +#define GPIO_PCTL_PG7_M 0xF0000000 // PG7 mask +#define GPIO_PCTL_PG7_PHB1 0x10000000 // PHB1 on PG7 +#define GPIO_PCTL_PG7_PWM7 0x40000000 // PWM7 on PG7 +#define GPIO_PCTL_PG7_CCP5 0x80000000 // CCP5 on PG7 +#define GPIO_PCTL_PG7_EPI0S31 0x90000000 // EPI0S31 on PG7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port H. +// +//***************************************************************************** +#define GPIO_PCTL_PH0_M 0x0000000F // PH0 mask +#define GPIO_PCTL_PH0_CCP6 0x00000001 // CCP6 on PH0 +#define GPIO_PCTL_PH0_PWM2 0x00000002 // PWM2 on PH0 +#define GPIO_PCTL_PH0_EPI0S6 0x00000008 // EPI0S6 on PH0 +#define GPIO_PCTL_PH0_PWM4 0x00000009 // PWM4 on PH0 +#define GPIO_PCTL_PH1_M 0x000000F0 // PH1 mask +#define GPIO_PCTL_PH1_CCP7 0x00000010 // CCP7 on PH1 +#define GPIO_PCTL_PH1_PWM3 0x00000020 // PWM3 on PH1 +#define GPIO_PCTL_PH1_EPI0S7 0x00000080 // EPI0S7 on PH1 +#define GPIO_PCTL_PH1_PWM5 0x00000090 // PWM5 on PH1 +#define GPIO_PCTL_PH2_M 0x00000F00 // PH2 mask +#define GPIO_PCTL_PH2_IDX1 0x00000100 // IDX1 on PH2 +#define GPIO_PCTL_PH2_C1O 0x00000200 // C1O on PH2 +#define GPIO_PCTL_PH2_FAULT3 0x00000400 // FAULT3 on PH2 +#define GPIO_PCTL_PH2_EPI0S1 0x00000800 // EPI0S1 on PH2 +#define GPIO_PCTL_PH3_M 0x0000F000 // PH3 mask +#define GPIO_PCTL_PH3_PHB0 0x00001000 // PHB0 on PH3 +#define GPIO_PCTL_PH3_FAULT0 0x00002000 // FAULT0 on PH3 +#define GPIO_PCTL_PH3_USB0EPEN 0x00004000 // USB0EPEN on PH3 +#define GPIO_PCTL_PH3_EPI0S0 0x00008000 // EPI0S0 on PH3 +#define GPIO_PCTL_PH4_M 0x000F0000 // PH4 mask +#define GPIO_PCTL_PH4_USB0PFLT 0x00040000 // USB0PFLT on PH4 +#define GPIO_PCTL_PH4_EPI0S10 0x00080000 // EPI0S10 on PH4 +#define GPIO_PCTL_PH4_SSI1CLK 0x000B0000 // SSI1CLK on PH4 +#define GPIO_PCTL_PH5_M 0x00F00000 // PH5 mask +#define GPIO_PCTL_PH5_EPI0S11 0x00800000 // EPI0S11 on PH5 +#define GPIO_PCTL_PH5_FAULT2 0x00A00000 // FAULT2 on PH5 +#define GPIO_PCTL_PH5_SSI1FSS 0x00B00000 // SSI1FSS on PH5 +#define GPIO_PCTL_PH6_M 0x0F000000 // PH6 mask +#define GPIO_PCTL_PH6_EPI0S26 0x08000000 // EPI0S26 on PH6 +#define GPIO_PCTL_PH6_PWM4 0x0A000000 // PWM4 on PH6 +#define GPIO_PCTL_PH6_SSI1RX 0x0B000000 // SSI1RX on PH6 +#define GPIO_PCTL_PH7_M 0xF0000000 // PH7 mask +#define GPIO_PCTL_PH7_EPI0S27 0x80000000 // EPI0S27 on PH7 +#define GPIO_PCTL_PH7_PWM5 0xA0000000 // PWM5 on PH7 +#define GPIO_PCTL_PH7_SSI1TX 0xB0000000 // SSI1TX on PH7 + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_PCTL register for +// port J. +// +//***************************************************************************** +#define GPIO_PCTL_PJ0_M 0x0000000F // PJ0 mask +#define GPIO_PCTL_PJ0_EPI0S16 0x00000008 // EPI0S16 on PJ0 +#define GPIO_PCTL_PJ0_PWM0 0x0000000A // PWM0 on PJ0 +#define GPIO_PCTL_PJ0_I2C1SCL 0x0000000B // I2C1SCL on PJ0 +#define GPIO_PCTL_PJ1_M 0x000000F0 // PJ1 mask +#define GPIO_PCTL_PJ1_EPI0S17 0x00000080 // EPI0S17 on PJ1 +#define GPIO_PCTL_PJ1_USB0PFLT 0x00000090 // USB0PFLT on PJ1 +#define GPIO_PCTL_PJ1_PWM1 0x000000A0 // PWM1 on PJ1 +#define GPIO_PCTL_PJ1_I2C1SDA 0x000000B0 // I2C1SDA on PJ1 +#define GPIO_PCTL_PJ2_M 0x00000F00 // PJ2 mask +#define GPIO_PCTL_PJ2_EPI0S18 0x00000800 // EPI0S18 on PJ2 +#define GPIO_PCTL_PJ2_CCP0 0x00000900 // CCP0 on PJ2 +#define GPIO_PCTL_PJ2_FAULT0 0x00000A00 // FAULT0 on PJ2 +#define GPIO_PCTL_PJ3_M 0x0000F000 // PJ3 mask +#define GPIO_PCTL_PJ3_EPI0S19 0x00008000 // EPI0S19 on PJ3 +#define GPIO_PCTL_PJ3_U1CTS 0x00009000 // U1CTS on PJ3 +#define GPIO_PCTL_PJ3_CCP6 0x0000A000 // CCP6 on PJ3 +#define GPIO_PCTL_PJ4_M 0x000F0000 // PJ4 mask +#define GPIO_PCTL_PJ4_EPI0S28 0x00080000 // EPI0S28 on PJ4 +#define GPIO_PCTL_PJ4_U1DCD 0x00090000 // U1DCD on PJ4 +#define GPIO_PCTL_PJ4_CCP4 0x000A0000 // CCP4 on PJ4 +#define GPIO_PCTL_PJ5_M 0x00F00000 // PJ5 mask +#define GPIO_PCTL_PJ5_EPI0S29 0x00800000 // EPI0S29 on PJ5 +#define GPIO_PCTL_PJ5_U1DSR 0x00900000 // U1DSR on PJ5 +#define GPIO_PCTL_PJ5_CCP2 0x00A00000 // CCP2 on PJ5 +#define GPIO_PCTL_PJ6_M 0x0F000000 // PJ6 mask +#define GPIO_PCTL_PJ6_EPI0S30 0x08000000 // EPI0S30 on PJ6 +#define GPIO_PCTL_PJ6_U1RTS 0x09000000 // U1RTS on PJ6 +#define GPIO_PCTL_PJ6_CCP1 0x0A000000 // CCP1 on PJ6 +#define GPIO_PCTL_PJ7_M 0xF0000000 // PJ7 mask +#define GPIO_PCTL_PJ7_U1DTR 0x90000000 // U1DTR on PJ7 +#define GPIO_PCTL_PJ7_CCP0 0xA0000000 // CCP0 on PJ7 + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the GPIO register offsets. +// +//***************************************************************************** +#define GPIO_O_PeriphID4 0x00000FD0 +#define GPIO_O_PeriphID5 0x00000FD4 +#define GPIO_O_PeriphID6 0x00000FD8 +#define GPIO_O_PeriphID7 0x00000FDC +#define GPIO_O_PeriphID0 0x00000FE0 +#define GPIO_O_PeriphID1 0x00000FE4 +#define GPIO_O_PeriphID2 0x00000FE8 +#define GPIO_O_PeriphID3 0x00000FEC +#define GPIO_O_PCellID0 0x00000FF0 +#define GPIO_O_PCellID1 0x00000FF4 +#define GPIO_O_PCellID2 0x00000FF8 +#define GPIO_O_PCellID3 0x00000FFC + +//***************************************************************************** +// +// The following are deprecated defines for the GPIO Register reset values. +// +//***************************************************************************** +#define GPIO_RV_DEN 0x000000FF // Digital input enable reg RV +#define GPIO_RV_PUR 0x000000FF // Pull up select reg RV +#define GPIO_RV_DR2R 0x000000FF // 2ma drive select reg RV +#define GPIO_RV_PCellID1 0x000000F0 +#define GPIO_RV_PCellID3 0x000000B1 +#define GPIO_RV_PeriphID0 0x00000061 +#define GPIO_RV_PeriphID1 0x00000010 +#define GPIO_RV_PCellID0 0x0000000D +#define GPIO_RV_PCellID2 0x00000005 +#define GPIO_RV_PeriphID2 0x00000004 +#define GPIO_RV_LOCK 0x00000001 // Lock register RV +#define GPIO_RV_PeriphID7 0x00000000 +#define GPIO_RV_PDR 0x00000000 // Pull down select reg RV +#define GPIO_RV_IC 0x00000000 // Interrupt clear reg RV +#define GPIO_RV_SLR 0x00000000 // Slew rate control enable reg RV +#define GPIO_RV_ODR 0x00000000 // Open drain select reg RV +#define GPIO_RV_IBE 0x00000000 // Interrupt both edges reg RV +#define GPIO_RV_AFSEL 0x00000000 // Mode control select reg RV +#define GPIO_RV_IS 0x00000000 // Interrupt sense reg RV +#define GPIO_RV_IM 0x00000000 // Interrupt mask reg RV +#define GPIO_RV_PeriphID4 0x00000000 +#define GPIO_RV_PeriphID5 0x00000000 +#define GPIO_RV_DR8R 0x00000000 // 8ma drive select reg RV +#define GPIO_RV_RIS 0x00000000 // Raw interrupt status reg RV +#define GPIO_RV_DR4R 0x00000000 // 4ma drive select reg RV +#define GPIO_RV_IEV 0x00000000 // Intterupt event reg RV +#define GPIO_RV_DIR 0x00000000 // Data direction reg RV +#define GPIO_RV_PeriphID6 0x00000000 +#define GPIO_RV_PeriphID3 0x00000000 +#define GPIO_RV_DATA 0x00000000 // Data register reset value +#define GPIO_RV_MIS 0x00000000 // Masked interrupt status reg RV + +#endif + +#endif // __HW_GPIO_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_hibernate.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_hibernate.h new file mode 100644 index 00000000..5c286da2 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_hibernate.h @@ -0,0 +1,242 @@ +//***************************************************************************** +// +// hw_hibernate.h - Defines and Macros for the Hibernation module. +// +// Copyright (c) 2007-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_HIBERNATE_H__ +#define __HW_HIBERNATE_H__ + +//***************************************************************************** +// +// The following are defines for the Hibernation module register addresses. +// +//***************************************************************************** +#define HIB_RTCC 0x400FC000 // Hibernation RTC Counter +#define HIB_RTCM0 0x400FC004 // Hibernation RTC Match 0 +#define HIB_RTCM1 0x400FC008 // Hibernation RTC Match 1 +#define HIB_RTCLD 0x400FC00C // Hibernation RTC Load +#define HIB_CTL 0x400FC010 // Hibernation Control +#define HIB_IM 0x400FC014 // Hibernation Interrupt Mask +#define HIB_RIS 0x400FC018 // Hibernation Raw Interrupt Status +#define HIB_MIS 0x400FC01C // Hibernation Masked Interrupt + // Status +#define HIB_IC 0x400FC020 // Hibernation Interrupt Clear +#define HIB_RTCT 0x400FC024 // Hibernation RTC Trim +#define HIB_DATA 0x400FC030 // Hibernation Data + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_RTCC register. +// +//***************************************************************************** +#define HIB_RTCC_M 0xFFFFFFFF // RTC Counter +#define HIB_RTCC_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_RTCM0 register. +// +//***************************************************************************** +#define HIB_RTCM0_M 0xFFFFFFFF // RTC Match 0 +#define HIB_RTCM0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_RTCM1 register. +// +//***************************************************************************** +#define HIB_RTCM1_M 0xFFFFFFFF // RTC Match 1 +#define HIB_RTCM1_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_RTCLD register. +// +//***************************************************************************** +#define HIB_RTCLD_M 0xFFFFFFFF // RTC Load +#define HIB_RTCLD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_CTL register. +// +//***************************************************************************** +#define HIB_CTL_WRC 0x80000000 // Write Complete/Capable +#define HIB_CTL_VDD3ON 0x00000100 // VDD Powered +#define HIB_CTL_VABORT 0x00000080 // Power Cut Abort Enable +#define HIB_CTL_CLK32EN 0x00000040 // Clocking Enable +#define HIB_CTL_LOWBATEN 0x00000020 // Low Battery Monitoring Enable +#define HIB_CTL_PINWEN 0x00000010 // External WAKE Pin Enable +#define HIB_CTL_RTCWEN 0x00000008 // RTC Wake-up Enable +#define HIB_CTL_CLKSEL 0x00000004 // Hibernation Module Clock Select +#define HIB_CTL_HIBREQ 0x00000002 // Hibernation Request +#define HIB_CTL_RTCEN 0x00000001 // RTC Timer Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_IM register. +// +//***************************************************************************** +#define HIB_IM_EXTW 0x00000008 // External Wake-Up Interrupt Mask +#define HIB_IM_LOWBAT 0x00000004 // Low Battery Voltage Interrupt + // Mask +#define HIB_IM_RTCALT1 0x00000002 // RTC Alert 1 Interrupt Mask +#define HIB_IM_RTCALT0 0x00000001 // RTC Alert 0 Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_RIS register. +// +//***************************************************************************** +#define HIB_RIS_EXTW 0x00000008 // External Wake-Up Raw Interrupt + // Status +#define HIB_RIS_LOWBAT 0x00000004 // Low Battery Voltage Raw + // Interrupt Status +#define HIB_RIS_RTCALT1 0x00000002 // RTC Alert 1 Raw Interrupt Status +#define HIB_RIS_RTCALT0 0x00000001 // RTC Alert 0 Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_MIS register. +// +//***************************************************************************** +#define HIB_MIS_EXTW 0x00000008 // External Wake-Up Masked + // Interrupt Status +#define HIB_MIS_LOWBAT 0x00000004 // Low Battery Voltage Masked + // Interrupt Status +#define HIB_MIS_RTCALT1 0x00000002 // RTC Alert 1 Masked Interrupt + // Status +#define HIB_MIS_RTCALT0 0x00000001 // RTC Alert 0 Masked Interrupt + // Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_IC register. +// +//***************************************************************************** +#define HIB_IC_EXTW 0x00000008 // External Wake-Up Masked + // Interrupt Clear +#define HIB_IC_LOWBAT 0x00000004 // Low Battery Voltage Masked + // Interrupt Clear +#define HIB_IC_RTCALT1 0x00000002 // RTC Alert1 Masked Interrupt + // Clear +#define HIB_IC_RTCALT0 0x00000001 // RTC Alert0 Masked Interrupt + // Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_RTCT register. +// +//***************************************************************************** +#define HIB_RTCT_TRIM_M 0x0000FFFF // RTC Trim Value +#define HIB_RTCT_TRIM_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_DATA register. +// +//***************************************************************************** +#define HIB_DATA_RTD_M 0xFFFFFFFF // Hibernation Module NV Data +#define HIB_DATA_RTD_S 0 + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the Hibernation module register +// addresses. +// +//***************************************************************************** +#define HIB_DATA_END 0x400FC130 // end of data area, exclusive + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the HIB_RTCC +// register. +// +//***************************************************************************** +#define HIB_RTCC_MASK 0xFFFFFFFF // RTC counter mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the HIB_RTCM0 +// register. +// +//***************************************************************************** +#define HIB_RTCM0_MASK 0xFFFFFFFF // RTC match 0 mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the HIB_RTCM1 +// register. +// +//***************************************************************************** +#define HIB_RTCM1_MASK 0xFFFFFFFF // RTC match 1 mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the HIB_RTCLD +// register. +// +//***************************************************************************** +#define HIB_RTCLD_MASK 0xFFFFFFFF // RTC load mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the HIB_RIS +// register. +// +//***************************************************************************** +#define HIB_RID_RTCALT0 0x00000001 // RTC match 0 interrupt + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the HIB_MIS +// register. +// +//***************************************************************************** +#define HIB_MID_RTCALT0 0x00000001 // RTC match 0 interrupt + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the HIB_RTCT +// register. +// +//***************************************************************************** +#define HIB_RTCT_MASK 0x0000FFFF // RTC trim mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the HIB_DATA +// register. +// +//***************************************************************************** +#define HIB_DATA_MASK 0xFFFFFFFF // NV memory data mask + +#endif + +#endif // __HW_HIBERNATE_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_i2c.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_i2c.h new file mode 100644 index 00000000..e956d376 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_i2c.h @@ -0,0 +1,407 @@ +//***************************************************************************** +// +// hw_i2c.h - Macros used when accessing the I2C master and slave hardware. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_I2C_H__ +#define __HW_I2C_H__ + +//***************************************************************************** +// +// The following are defines for the I2C register offsets. +// +//***************************************************************************** +#define I2C_O_MSA 0x00000000 // I2C Master Slave Address +#define I2C_O_SOAR 0x00000000 // I2C Slave Own Address +#define I2C_O_SCSR 0x00000004 // I2C Slave Control/Status +#define I2C_O_MCS 0x00000004 // I2C Master Control/Status +#define I2C_O_SDR 0x00000008 // I2C Slave Data +#define I2C_O_MDR 0x00000008 // I2C Master Data +#define I2C_O_MTPR 0x0000000C // I2C Master Timer Period +#define I2C_O_SIMR 0x0000000C // I2C Slave Interrupt Mask +#define I2C_O_SRIS 0x00000010 // I2C Slave Raw Interrupt Status +#define I2C_O_MIMR 0x00000010 // I2C Master Interrupt Mask +#define I2C_O_MRIS 0x00000014 // I2C Master Raw Interrupt Status +#define I2C_O_SMIS 0x00000014 // I2C Slave Masked Interrupt + // Status +#define I2C_O_SICR 0x00000018 // I2C Slave Interrupt Clear +#define I2C_O_MMIS 0x00000018 // I2C Master Masked Interrupt + // Status +#define I2C_O_MICR 0x0000001C // I2C Master Interrupt Clear +#define I2C_O_MCR 0x00000020 // I2C Master Configuration + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MSA register. +// +//***************************************************************************** +#define I2C_MSA_SA_M 0x000000FE // I2C Slave Address +#define I2C_MSA_RS 0x00000001 // Receive not send +#define I2C_MSA_SA_S 1 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_SOAR register. +// +//***************************************************************************** +#define I2C_SOAR_OAR_M 0x0000007F // I2C Slave Own Address +#define I2C_SOAR_OAR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_SCSR register. +// +//***************************************************************************** +#define I2C_SCSR_FBR 0x00000004 // First Byte Received +#define I2C_SCSR_TREQ 0x00000002 // Transmit Request +#define I2C_SCSR_DA 0x00000001 // Device Active +#define I2C_SCSR_RREQ 0x00000001 // Receive Request + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MCS register. +// +//***************************************************************************** +#define I2C_MCS_BUSBSY 0x00000040 // Bus Busy +#define I2C_MCS_IDLE 0x00000020 // I2C Idle +#define I2C_MCS_ARBLST 0x00000010 // Arbitration Lost +#define I2C_MCS_ACK 0x00000008 // Data Acknowledge Enable +#define I2C_MCS_DATACK 0x00000008 // Acknowledge Data +#define I2C_MCS_ADRACK 0x00000004 // Acknowledge Address +#define I2C_MCS_STOP 0x00000004 // Generate STOP +#define I2C_MCS_START 0x00000002 // Generate START +#define I2C_MCS_ERROR 0x00000002 // Error +#define I2C_MCS_RUN 0x00000001 // I2C Master Enable +#define I2C_MCS_BUSY 0x00000001 // I2C Busy + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_SDR register. +// +//***************************************************************************** +#define I2C_SDR_DATA_M 0x000000FF // Data for Transfer +#define I2C_SDR_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MDR register. +// +//***************************************************************************** +#define I2C_MDR_DATA_M 0x000000FF // Data Transferred +#define I2C_MDR_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MTPR register. +// +//***************************************************************************** +#define I2C_MTPR_TPR_M 0x0000007F // SCL Clock Period +#define I2C_MTPR_TPR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_SIMR register. +// +//***************************************************************************** +#define I2C_SIMR_STOPIM 0x00000004 // Stop Condition Interrupt Mask +#define I2C_SIMR_STARTIM 0x00000002 // Start Condition Interrupt Mask +#define I2C_SIMR_DATAIM 0x00000001 // Data Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_SRIS register. +// +//***************************************************************************** +#define I2C_SRIS_STOPRIS 0x00000004 // Stop Condition Raw Interrupt + // Status +#define I2C_SRIS_STARTRIS 0x00000002 // Start Condition Raw Interrupt + // Status +#define I2C_SRIS_DATARIS 0x00000001 // Data Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MIMR register. +// +//***************************************************************************** +#define I2C_MIMR_IM 0x00000001 // Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MRIS register. +// +//***************************************************************************** +#define I2C_MRIS_RIS 0x00000001 // Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_SMIS register. +// +//***************************************************************************** +#define I2C_SMIS_STOPMIS 0x00000004 // Stop Condition Masked Interrupt + // Status +#define I2C_SMIS_STARTMIS 0x00000002 // Start Condition Masked Interrupt + // Status +#define I2C_SMIS_DATAMIS 0x00000001 // Data Masked Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_SICR register. +// +//***************************************************************************** +#define I2C_SICR_STOPIC 0x00000004 // Stop Condition Interrupt Clear +#define I2C_SICR_STARTIC 0x00000002 // Start Condition Interrupt Clear +#define I2C_SICR_DATAIC 0x00000001 // Data Interrupt Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MMIS register. +// +//***************************************************************************** +#define I2C_MMIS_MIS 0x00000001 // Masked Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MICR register. +// +//***************************************************************************** +#define I2C_MICR_IC 0x00000001 // Interrupt Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MCR register. +// +//***************************************************************************** +#define I2C_MCR_SFE 0x00000020 // I2C Slave Function Enable +#define I2C_MCR_MFE 0x00000010 // I2C Master Function Enable +#define I2C_MCR_LPBK 0x00000001 // I2C Loopback + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the I2C register offsets. +// +//***************************************************************************** +#define I2C_O_SLAVE 0x00000800 // Offset from master to slave + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C_O_SIMR +// register. +// +//***************************************************************************** +#define I2C_SIMR_IM 0x00000001 // Interrupt Mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C_O_SRIS +// register. +// +//***************************************************************************** +#define I2C_SRIS_RIS 0x00000001 // Raw Interrupt Status + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C_O_SMIS +// register. +// +//***************************************************************************** +#define I2C_SMIS_MIS 0x00000001 // Masked Interrupt Status + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C_O_SICR +// register. +// +//***************************************************************************** +#define I2C_SICR_IC 0x00000001 // Clear Interrupt + +//***************************************************************************** +// +// The following are deprecated defines for the I2C master register offsets. +// +//***************************************************************************** +#define I2C_MASTER_O_SA 0x00000000 // Slave address register +#define I2C_MASTER_O_CS 0x00000004 // Control and Status register +#define I2C_MASTER_O_DR 0x00000008 // Data register +#define I2C_MASTER_O_TPR 0x0000000C // Timer period register +#define I2C_MASTER_O_IMR 0x00000010 // Interrupt mask register +#define I2C_MASTER_O_RIS 0x00000014 // Raw interrupt status register +#define I2C_MASTER_O_MIS 0x00000018 // Masked interrupt status reg +#define I2C_MASTER_O_MICR 0x0000001C // Interrupt clear register +#define I2C_MASTER_O_CR 0x00000020 // Configuration register + +//***************************************************************************** +// +// The following are deprecated defines for the I2C slave register offsets. +// +//***************************************************************************** +#define I2C_SLAVE_O_SICR 0x00000018 // Interrupt clear register +#define I2C_SLAVE_O_MIS 0x00000014 // Masked interrupt status reg +#define I2C_SLAVE_O_RIS 0x00000010 // Raw interrupt status register +#define I2C_SLAVE_O_IM 0x0000000C // Interrupt mask register +#define I2C_SLAVE_O_DR 0x00000008 // Data register +#define I2C_SLAVE_O_CSR 0x00000004 // Control/Status register +#define I2C_SLAVE_O_OAR 0x00000000 // Own address register + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C master +// slave address register. +// +//***************************************************************************** +#define I2C_MASTER_SA_SA_MASK 0x000000FE // Slave address +#define I2C_MASTER_SA_RS 0x00000001 // Receive/send +#define I2C_MASTER_SA_SA_SHIFT 1 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C Master +// Control and Status register. +// +//***************************************************************************** +#define I2C_MASTER_CS_BUS_BUSY 0x00000040 // Bus busy +#define I2C_MASTER_CS_IDLE 0x00000020 // Idle +#define I2C_MASTER_CS_ERR_MASK 0x0000001C +#define I2C_MASTER_CS_BUSY 0x00000001 // Controller is TX/RX data +#define I2C_MASTER_CS_ERROR 0x00000002 // Error occurred +#define I2C_MASTER_CS_ADDR_ACK 0x00000004 // Address byte not acknowledged +#define I2C_MASTER_CS_DATA_ACK 0x00000008 // Data byte not acknowledged +#define I2C_MASTER_CS_ARB_LOST 0x00000010 // Lost arbitration +#define I2C_MASTER_CS_ACK 0x00000008 // Acknowlegde +#define I2C_MASTER_CS_STOP 0x00000004 // Stop +#define I2C_MASTER_CS_START 0x00000002 // Start +#define I2C_MASTER_CS_RUN 0x00000001 // Run + +//***************************************************************************** +// +// The following are deprecated defines for the values used in determining the +// contents of the I2C Master Timer Period register. +// +//***************************************************************************** +#define I2C_SCL_FAST 400000 // SCL fast frequency +#define I2C_SCL_STANDARD 100000 // SCL standard frequency +#define I2C_MASTER_TPR_SCL_LP 0x00000006 // SCL low period +#define I2C_MASTER_TPR_SCL_HP 0x00000004 // SCL high period +#define I2C_MASTER_TPR_SCL (I2C_MASTER_TPR_SCL_HP + I2C_MASTER_TPR_SCL_LP) + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C Master +// Interrupt Mask register. +// +//***************************************************************************** +#define I2C_MASTER_IMR_IM 0x00000001 // Master interrupt mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C Master +// Raw Interrupt Status register. +// +//***************************************************************************** +#define I2C_MASTER_RIS_RIS 0x00000001 // Master raw interrupt status + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C Master +// Masked Interrupt Status register. +// +//***************************************************************************** +#define I2C_MASTER_MIS_MIS 0x00000001 // Master masked interrupt status + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C Master +// Interrupt Clear register. +// +//***************************************************************************** +#define I2C_MASTER_MICR_IC 0x00000001 // Master interrupt clear + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C Master +// Configuration register. +// +//***************************************************************************** +#define I2C_MASTER_CR_SFE 0x00000020 // Slave function enable +#define I2C_MASTER_CR_MFE 0x00000010 // Master function enable +#define I2C_MASTER_CR_LPBK 0x00000001 // Loopback enable + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C Slave Own +// Address register. +// +//***************************************************************************** +#define I2C_SLAVE_SOAR_OAR_MASK 0x0000007F // Slave address + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C Slave +// Control/Status register. +// +//***************************************************************************** +#define I2C_SLAVE_CSR_FBR 0x00000004 // First byte received from master +#define I2C_SLAVE_CSR_TREQ 0x00000002 // Transmit request received +#define I2C_SLAVE_CSR_DA 0x00000001 // Enable the device +#define I2C_SLAVE_CSR_RREQ 0x00000001 // Receive data from I2C master + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C Slave +// Interrupt Mask register. +// +//***************************************************************************** +#define I2C_SLAVE_IMR_IM 0x00000001 // Slave interrupt mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C Slave Raw +// Interrupt Status register. +// +//***************************************************************************** +#define I2C_SLAVE_RIS_RIS 0x00000001 // Slave raw interrupt status + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C Slave +// Masked Interrupt Status register. +// +//***************************************************************************** +#define I2C_SLAVE_MIS_MIS 0x00000001 // Slave masked interrupt status + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the I2C Slave +// Interrupt Clear register. +// +//***************************************************************************** +#define I2C_SLAVE_SICR_IC 0x00000001 // Slave interrupt clear + +#endif + +#endif // __HW_I2C_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_i2s.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_i2s.h new file mode 100644 index 00000000..f02ce94c --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_i2s.h @@ -0,0 +1,224 @@ +//***************************************************************************** +// +// hw_i2s.h - Macros for use in accessing the I2S registers. +// +// Copyright (c) 2008-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_I2S_H__ +#define __HW_I2S_H__ + +//***************************************************************************** +// +// The following are defines for the Inter-Integrated Circuit Sound register +// offsets. +// +//***************************************************************************** +#define I2S_O_TXFIFO 0x00000000 // I2S Transmit FIFO Data +#define I2S_O_TXFIFOCFG 0x00000004 // I2S Transmit FIFO Configuration +#define I2S_O_TXCFG 0x00000008 // I2S Transmit Module + // Configuration +#define I2S_O_TXLIMIT 0x0000000C // I2S Transmit FIFO Limit +#define I2S_O_TXISM 0x00000010 // I2S Transmit Interrupt Status + // and Mask +#define I2S_O_TXLEV 0x00000018 // I2S Transmit FIFO Level +#define I2S_O_RXFIFO 0x00000800 // I2S Receive FIFO Data +#define I2S_O_RXFIFOCFG 0x00000804 // I2S Receive FIFO Configuration +#define I2S_O_RXCFG 0x00000808 // I2S Receive Module Configuration +#define I2S_O_RXLIMIT 0x0000080C // I2S Receive FIFO Limit +#define I2S_O_RXISM 0x00000810 // I2S Receive Interrupt Status and + // Mask +#define I2S_O_RXLEV 0x00000818 // I2S Receive FIFO Level +#define I2S_O_CFG 0x00000C00 // I2S Module Configuration +#define I2S_O_IM 0x00000C10 // I2S Interrupt Mask +#define I2S_O_RIS 0x00000C14 // I2S Raw Interrupt Status +#define I2S_O_MIS 0x00000C18 // I2S Masked Interrupt Status +#define I2S_O_IC 0x00000C1C // I2S Interrupt Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_TXFIFO register. +// +//***************************************************************************** +#define I2S_TXFIFO_M 0xFFFFFFFF // TX Data +#define I2S_TXFIFO_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_TXFIFOCFG +// register. +// +//***************************************************************************** +#define I2S_TXFIFOCFG_CSS 0x00000002 // Compact Stereo Sample Size +#define I2S_TXFIFOCFG_LRS 0x00000001 // Left-Right Sample Indicator + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_TXCFG register. +// +//***************************************************************************** +#define I2S_TXCFG_JST 0x20000000 // Justification of Output Data +#define I2S_TXCFG_DLY 0x10000000 // Data Delay +#define I2S_TXCFG_SCP 0x08000000 // SCLK Polarity +#define I2S_TXCFG_LRP 0x04000000 // Left/Right Clock Polarity +#define I2S_TXCFG_WM_M 0x03000000 // Write Mode +#define I2S_TXCFG_WM_DUAL 0x00000000 // Stereo mode +#define I2S_TXCFG_WM_COMPACT 0x01000000 // Compact Stereo mode +#define I2S_TXCFG_WM_MONO 0x02000000 // Mono mode +#define I2S_TXCFG_FMT 0x00800000 // FIFO Empty +#define I2S_TXCFG_MSL 0x00400000 // SCLK Master/Slave +#define I2S_TXCFG_SSZ_M 0x0000FC00 // Sample Size +#define I2S_TXCFG_SDSZ_M 0x000003F0 // System Data Size +#define I2S_TXCFG_SSZ_S 10 +#define I2S_TXCFG_SDSZ_S 4 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_TXLIMIT register. +// +//***************************************************************************** +#define I2S_TXLIMIT_LIMIT_M 0x0000001F // FIFO Limit +#define I2S_TXLIMIT_LIMIT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_TXISM register. +// +//***************************************************************************** +#define I2S_TXISM_FFI 0x00010000 // Transmit FIFO Service Request + // Interrupt +#define I2S_TXISM_FFM 0x00000001 // FIFO Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_TXLEV register. +// +//***************************************************************************** +#define I2S_TXLEV_LEVEL_M 0x0000001F // Number of Audio Samples +#define I2S_TXLEV_LEVEL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_RXFIFO register. +// +//***************************************************************************** +#define I2S_RXFIFO_M 0xFFFFFFFF // RX Data +#define I2S_RXFIFO_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_RXFIFOCFG +// register. +// +//***************************************************************************** +#define I2S_RXFIFOCFG_FMM 0x00000004 // FIFO Mono Mode +#define I2S_RXFIFOCFG_CSS 0x00000002 // Compact Stereo Sample Size +#define I2S_RXFIFOCFG_LRS 0x00000001 // Left-Right Sample Indicator + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_RXCFG register. +// +//***************************************************************************** +#define I2S_RXCFG_JST 0x20000000 // Justification of Input Data +#define I2S_RXCFG_DLY 0x10000000 // Data Delay +#define I2S_RXCFG_SCP 0x08000000 // SCLK Polarity +#define I2S_RXCFG_LRP 0x04000000 // Left/Right Clock Polarity +#define I2S_RXCFG_RM 0x01000000 // Read Mode +#define I2S_RXCFG_MSL 0x00400000 // SCLK Master/Slave +#define I2S_RXCFG_SSZ_M 0x0000FC00 // Sample Size +#define I2S_RXCFG_SDSZ_M 0x000003F0 // System Data Size +#define I2S_RXCFG_SSZ_S 10 +#define I2S_RXCFG_SDSZ_S 4 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_RXLIMIT register. +// +//***************************************************************************** +#define I2S_RXLIMIT_LIMIT_M 0x0000001F // FIFO Limit +#define I2S_RXLIMIT_LIMIT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_RXISM register. +// +//***************************************************************************** +#define I2S_RXISM_FFI 0x00010000 // Receive FIFO Service Request + // Interrupt +#define I2S_RXISM_FFM 0x00000001 // FIFO Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_RXLEV register. +// +//***************************************************************************** +#define I2S_RXLEV_LEVEL_M 0x0000001F // Number of Audio Samples +#define I2S_RXLEV_LEVEL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_CFG register. +// +//***************************************************************************** +#define I2S_CFG_RXSLV 0x00000020 // Use External I2S0RXMCLK +#define I2S_CFG_TXSLV 0x00000010 // Use External I2S0TXMCLK +#define I2S_CFG_RXEN 0x00000002 // Serial Receive Engine Enable +#define I2S_CFG_TXEN 0x00000001 // Serial Transmit Engine Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_IM register. +// +//***************************************************************************** +#define I2S_IM_RXRE 0x00000020 // Receive FIFO Read Error +#define I2S_IM_RXFSR 0x00000010 // Receive FIFO Service Request +#define I2S_IM_TXWE 0x00000002 // Transmit FIFO Write Error +#define I2S_IM_TXFSR 0x00000001 // Transmit FIFO Service Request + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_RIS register. +// +//***************************************************************************** +#define I2S_RIS_RXRE 0x00000020 // Receive FIFO Read Error +#define I2S_RIS_RXFSR 0x00000010 // Receive FIFO Service Request +#define I2S_RIS_TXWE 0x00000002 // Transmit FIFO Write Error +#define I2S_RIS_TXFSR 0x00000001 // Transmit FIFO Service Request + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_MIS register. +// +//***************************************************************************** +#define I2S_MIS_RXRE 0x00000020 // Receive FIFO Read Error +#define I2S_MIS_RXFSR 0x00000010 // Receive FIFO Service Request +#define I2S_MIS_TXWE 0x00000002 // Transmit FIFO Write Error +#define I2S_MIS_TXFSR 0x00000001 // Transmit FIFO Service Request + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2S_O_IC register. +// +//***************************************************************************** +#define I2S_IC_RXRE 0x00000020 // Receive FIFO Read Error +#define I2S_IC_TXWE 0x00000002 // Transmit FIFO Write Error + +#endif // __HW_I2S_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_ints.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_ints.h new file mode 100644 index 00000000..1eb1e34e --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_ints.h @@ -0,0 +1,141 @@ +//***************************************************************************** +// +// hw_ints.h - Macros that define the interrupt assignment on Stellaris. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_INTS_H__ +#define __HW_INTS_H__ + +//***************************************************************************** +// +// The following are defines for the fault assignments. +// +//***************************************************************************** +#define FAULT_NMI 2 // NMI fault +#define FAULT_HARD 3 // Hard fault +#define FAULT_MPU 4 // MPU fault +#define FAULT_BUS 5 // Bus fault +#define FAULT_USAGE 6 // Usage fault +#define FAULT_SVCALL 11 // SVCall +#define FAULT_DEBUG 12 // Debug monitor +#define FAULT_PENDSV 14 // PendSV +#define FAULT_SYSTICK 15 // System Tick + +//***************************************************************************** +// +// The following are defines for the interrupt assignments. +// +//***************************************************************************** +#define INT_GPIOA 16 // GPIO Port A +#define INT_GPIOB 17 // GPIO Port B +#define INT_GPIOC 18 // GPIO Port C +#define INT_GPIOD 19 // GPIO Port D +#define INT_GPIOE 20 // GPIO Port E +#define INT_UART0 21 // UART0 Rx and Tx +#define INT_UART1 22 // UART1 Rx and Tx +#define INT_SSI0 23 // SSI0 Rx and Tx +#define INT_I2C0 24 // I2C0 Master and Slave +#define INT_PWM_FAULT 25 // PWM Fault +#define INT_PWM0 26 // PWM Generator 0 +#define INT_PWM1 27 // PWM Generator 1 +#define INT_PWM2 28 // PWM Generator 2 +#define INT_QEI0 29 // Quadrature Encoder 0 +#define INT_ADC0SS0 30 // ADC0 Sequence 0 +#define INT_ADC0SS1 31 // ADC0 Sequence 1 +#define INT_ADC0SS2 32 // ADC0 Sequence 2 +#define INT_ADC0SS3 33 // ADC0 Sequence 3 +#define INT_WATCHDOG 34 // Watchdog timer +#define INT_TIMER0A 35 // Timer 0 subtimer A +#define INT_TIMER0B 36 // Timer 0 subtimer B +#define INT_TIMER1A 37 // Timer 1 subtimer A +#define INT_TIMER1B 38 // Timer 1 subtimer B +#define INT_TIMER2A 39 // Timer 2 subtimer A +#define INT_TIMER2B 40 // Timer 2 subtimer B +#define INT_COMP0 41 // Analog Comparator 0 +#define INT_COMP1 42 // Analog Comparator 1 +#define INT_COMP2 43 // Analog Comparator 2 +#define INT_SYSCTL 44 // System Control (PLL, OSC, BO) +#define INT_FLASH 45 // FLASH Control +#define INT_GPIOF 46 // GPIO Port F +#define INT_GPIOG 47 // GPIO Port G +#define INT_GPIOH 48 // GPIO Port H +#define INT_UART2 49 // UART2 Rx and Tx +#define INT_SSI1 50 // SSI1 Rx and Tx +#define INT_TIMER3A 51 // Timer 3 subtimer A +#define INT_TIMER3B 52 // Timer 3 subtimer B +#define INT_I2C1 53 // I2C1 Master and Slave +#define INT_QEI1 54 // Quadrature Encoder 1 +#define INT_CAN0 55 // CAN0 +#define INT_CAN1 56 // CAN1 +#define INT_CAN2 57 // CAN2 +#define INT_ETH 58 // Ethernet +#define INT_HIBERNATE 59 // Hibernation module +#define INT_USB0 60 // USB 0 Controller +#define INT_PWM3 61 // PWM Generator 3 +#define INT_UDMA 62 // uDMA controller +#define INT_UDMAERR 63 // uDMA Error +#define INT_ADC1SS0 64 // ADC1 Sequence 0 +#define INT_ADC1SS1 65 // ADC1 Sequence 1 +#define INT_ADC1SS2 66 // ADC1 Sequence 2 +#define INT_ADC1SS3 67 // ADC1 Sequence 3 +#define INT_I2S0 68 // I2S0 +#define INT_EPI0 69 // EPI0 +#define INT_GPIOJ 70 // GPIO Port J + +//***************************************************************************** +// +// The following are defines for the total number of interrupts. +// +//***************************************************************************** +#define NUM_INTERRUPTS 71 + +//***************************************************************************** +// +// The following are defines for the total number of priority levels. +// +//***************************************************************************** +#define NUM_PRIORITY 8 +#define NUM_PRIORITY_BITS 3 + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the interrupt assignments. +// +//***************************************************************************** +#define INT_SSI 23 // SSI Rx and Tx +#define INT_I2C 24 // I2C Master and Slave +#define INT_QEI 29 // Quadrature Encoder +#define INT_ADC0 30 // ADC Sequence 0 +#define INT_ADC1 31 // ADC Sequence 1 +#define INT_ADC2 32 // ADC Sequence 2 +#define INT_ADC3 33 // ADC Sequence 3 + +#endif + +#endif // __HW_INTS_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_memmap.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_memmap.h new file mode 100644 index 00000000..144f9d25 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_memmap.h @@ -0,0 +1,115 @@ +//***************************************************************************** +// +// hw_memmap.h - Macros defining the memory map of Stellaris. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_MEMMAP_H__ +#define __HW_MEMMAP_H__ + +//***************************************************************************** +// +// The following are defines for the base address of the memories and +// peripherals. +// +//***************************************************************************** +#define FLASH_BASE 0x00000000 // FLASH memory +#define SRAM_BASE 0x20000000 // SRAM memory +#define WATCHDOG0_BASE 0x40000000 // Watchdog0 +#define WATCHDOG1_BASE 0x40001000 // Watchdog1 +#define GPIO_PORTA_BASE 0x40004000 // GPIO Port A +#define GPIO_PORTB_BASE 0x40005000 // GPIO Port B +#define GPIO_PORTC_BASE 0x40006000 // GPIO Port C +#define GPIO_PORTD_BASE 0x40007000 // GPIO Port D +#define SSI0_BASE 0x40008000 // SSI0 +#define SSI1_BASE 0x40009000 // SSI1 +#define UART0_BASE 0x4000C000 // UART0 +#define UART1_BASE 0x4000D000 // UART1 +#define UART2_BASE 0x4000E000 // UART2 +#define I2C0_MASTER_BASE 0x40020000 // I2C0 Master +#define I2C0_SLAVE_BASE 0x40020800 // I2C0 Slave +#define I2C1_MASTER_BASE 0x40021000 // I2C1 Master +#define I2C1_SLAVE_BASE 0x40021800 // I2C1 Slave +#define GPIO_PORTE_BASE 0x40024000 // GPIO Port E +#define GPIO_PORTF_BASE 0x40025000 // GPIO Port F +#define GPIO_PORTG_BASE 0x40026000 // GPIO Port G +#define GPIO_PORTH_BASE 0x40027000 // GPIO Port H +#define PWM_BASE 0x40028000 // PWM +#define QEI0_BASE 0x4002C000 // QEI0 +#define QEI1_BASE 0x4002D000 // QEI1 +#define TIMER0_BASE 0x40030000 // Timer0 +#define TIMER1_BASE 0x40031000 // Timer1 +#define TIMER2_BASE 0x40032000 // Timer2 +#define TIMER3_BASE 0x40033000 // Timer3 +#define ADC0_BASE 0x40038000 // ADC0 +#define ADC1_BASE 0x40039000 // ADC1 +#define COMP_BASE 0x4003C000 // Analog comparators +#define GPIO_PORTJ_BASE 0x4003D000 // GPIO Port J +#define CAN0_BASE 0x40040000 // CAN0 +#define CAN1_BASE 0x40041000 // CAN1 +#define CAN2_BASE 0x40042000 // CAN2 +#define ETH_BASE 0x40048000 // Ethernet +#define MAC_BASE 0x40048000 // Ethernet +#define USB0_BASE 0x40050000 // USB 0 Controller +#define I2S0_BASE 0x40054000 // I2S0 +#define GPIO_PORTA_AHB_BASE 0x40058000 // GPIO Port A (high speed) +#define GPIO_PORTB_AHB_BASE 0x40059000 // GPIO Port B (high speed) +#define GPIO_PORTC_AHB_BASE 0x4005A000 // GPIO Port C (high speed) +#define GPIO_PORTD_AHB_BASE 0x4005B000 // GPIO Port D (high speed) +#define GPIO_PORTE_AHB_BASE 0x4005C000 // GPIO Port E (high speed) +#define GPIO_PORTF_AHB_BASE 0x4005D000 // GPIO Port F (high speed) +#define GPIO_PORTG_AHB_BASE 0x4005E000 // GPIO Port G (high speed) +#define GPIO_PORTH_AHB_BASE 0x4005F000 // GPIO Port H (high speed) +#define GPIO_PORTJ_AHB_BASE 0x40060000 // GPIO Port J (high speed) +#define EPI0_BASE 0x400D0000 // EPI0 +#define HIB_BASE 0x400FC000 // Hibernation Module +#define FLASH_CTRL_BASE 0x400FD000 // FLASH Controller +#define SYSCTL_BASE 0x400FE000 // System Control +#define UDMA_BASE 0x400FF000 // uDMA Controller +#define ITM_BASE 0xE0000000 // Instrumentation Trace Macrocell +#define DWT_BASE 0xE0001000 // Data Watchpoint and Trace +#define FPB_BASE 0xE0002000 // FLASH Patch and Breakpoint +#define NVIC_BASE 0xE000E000 // Nested Vectored Interrupt Ctrl +#define TPIU_BASE 0xE0040000 // Trace Port Interface Unit + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the base address of the memories +// and peripherals. +// +//***************************************************************************** +#define WATCHDOG_BASE 0x40000000 // Watchdog +#define SSI_BASE 0x40008000 // SSI +#define I2C_MASTER_BASE 0x40020000 // I2C Master +#define I2C_SLAVE_BASE 0x40020800 // I2C Slave +#define QEI_BASE 0x4002C000 // QEI +#define ADC_BASE 0x40038000 // ADC + +#endif + +#endif // __HW_MEMMAP_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_nvic.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_nvic.h new file mode 100644 index 00000000..5ac7bafb --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_nvic.h @@ -0,0 +1,1189 @@ +//***************************************************************************** +// +// hw_nvic.h - Macros used when accessing the NVIC hardware. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_NVIC_H__ +#define __HW_NVIC_H__ + +//***************************************************************************** +// +// The following are defines for the NVIC register addresses. +// +//***************************************************************************** +#define NVIC_INT_TYPE 0xE000E004 // Interrupt Controller Type Reg +#define NVIC_ACTLR 0xE000E008 // Auxiliary Control +#define NVIC_ST_CTRL 0xE000E010 // SysTick Control and Status + // Register +#define NVIC_ST_RELOAD 0xE000E014 // SysTick Reload Value Register +#define NVIC_ST_CURRENT 0xE000E018 // SysTick Current Value Register +#define NVIC_ST_CAL 0xE000E01C // SysTick Calibration Value Reg +#define NVIC_EN0 0xE000E100 // Interrupt 0-31 Set Enable +#define NVIC_EN1 0xE000E104 // Interrupt 32-54 Set Enable +#define NVIC_DIS0 0xE000E180 // Interrupt 0-31 Clear Enable +#define NVIC_DIS1 0xE000E184 // Interrupt 32-54 Clear Enable +#define NVIC_PEND0 0xE000E200 // Interrupt 0-31 Set Pending +#define NVIC_PEND1 0xE000E204 // Interrupt 32-54 Set Pending +#define NVIC_UNPEND0 0xE000E280 // Interrupt 0-31 Clear Pending +#define NVIC_UNPEND1 0xE000E284 // Interrupt 32-54 Clear Pending +#define NVIC_ACTIVE0 0xE000E300 // Interrupt 0-31 Active Bit +#define NVIC_ACTIVE1 0xE000E304 // Interrupt 32-54 Active Bit +#define NVIC_PRI0 0xE000E400 // Interrupt 0-3 Priority +#define NVIC_PRI1 0xE000E404 // Interrupt 4-7 Priority +#define NVIC_PRI2 0xE000E408 // Interrupt 8-11 Priority +#define NVIC_PRI3 0xE000E40C // Interrupt 12-15 Priority +#define NVIC_PRI4 0xE000E410 // Interrupt 16-19 Priority +#define NVIC_PRI5 0xE000E414 // Interrupt 20-23 Priority +#define NVIC_PRI6 0xE000E418 // Interrupt 24-27 Priority +#define NVIC_PRI7 0xE000E41C // Interrupt 28-31 Priority +#define NVIC_PRI8 0xE000E420 // Interrupt 32-35 Priority +#define NVIC_PRI9 0xE000E424 // Interrupt 36-39 Priority +#define NVIC_PRI10 0xE000E428 // Interrupt 40-43 Priority +#define NVIC_PRI11 0xE000E42C // Interrupt 44-47 Priority +#define NVIC_PRI12 0xE000E430 // Interrupt 48-51 Priority +#define NVIC_PRI13 0xE000E434 // Interrupt 52-53 Priority +#define NVIC_CPUID 0xE000ED00 // CPU ID Base +#define NVIC_INT_CTRL 0xE000ED04 // Interrupt Control and State +#define NVIC_VTABLE 0xE000ED08 // Vector Table Offset +#define NVIC_APINT 0xE000ED0C // Application Interrupt and Reset + // Control +#define NVIC_SYS_CTRL 0xE000ED10 // System Control +#define NVIC_CFG_CTRL 0xE000ED14 // Configuration and Control +#define NVIC_SYS_PRI1 0xE000ED18 // System Handler Priority 1 +#define NVIC_SYS_PRI2 0xE000ED1C // System Handler Priority 2 +#define NVIC_SYS_PRI3 0xE000ED20 // System Handler Priority 3 +#define NVIC_SYS_HND_CTRL 0xE000ED24 // System Handler Control and State +#define NVIC_FAULT_STAT 0xE000ED28 // Configurable Fault Status +#define NVIC_HFAULT_STAT 0xE000ED2C // Hard Fault Status +#define NVIC_DEBUG_STAT 0xE000ED30 // Debug Status Register +#define NVIC_MM_ADDR 0xE000ED34 // Memory Management Fault Address +#define NVIC_FAULT_ADDR 0xE000ED38 // Bus Fault Address +#define NVIC_MPU_TYPE 0xE000ED90 // MPU Type +#define NVIC_MPU_CTRL 0xE000ED94 // MPU Control +#define NVIC_MPU_NUMBER 0xE000ED98 // MPU Region Number +#define NVIC_MPU_BASE 0xE000ED9C // MPU Region Base Address +#define NVIC_MPU_ATTR 0xE000EDA0 // MPU Region Attribute and Size +#define NVIC_MPU_BASE1 0xE000EDA4 // MPU Region Base Address Alias 1 +#define NVIC_MPU_ATTR1 0xE000EDA8 // MPU Region Attribute and Size + // Alias 1 +#define NVIC_MPU_BASE2 0xE000EDAC // MPU Region Base Address Alias 2 +#define NVIC_MPU_ATTR2 0xE000EDB0 // MPU Region Attribute and Size + // Alias 2 +#define NVIC_MPU_BASE3 0xE000EDB4 // MPU Region Base Address Alias 3 +#define NVIC_MPU_ATTR3 0xE000EDB8 // MPU Region Attribute and Size + // Alias 3 +#define NVIC_DBG_CTRL 0xE000EDF0 // Debug Control and Status Reg +#define NVIC_DBG_XFER 0xE000EDF4 // Debug Core Reg. Transfer Select +#define NVIC_DBG_DATA 0xE000EDF8 // Debug Core Register Data +#define NVIC_DBG_INT 0xE000EDFC // Debug Reset Interrupt Control +#define NVIC_SW_TRIG 0xE000EF00 // Software Trigger Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_INT_TYPE register. +// +//***************************************************************************** +#define NVIC_INT_TYPE_LINES_M 0x0000001F // Number of interrupt lines (x32) +#define NVIC_INT_TYPE_LINES_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ACTLR register. +// +//***************************************************************************** +#define NVIC_ACTLR_DISFOLD 0x00000004 // Disable IT Folding +#define NVIC_ACTLR_DISWBUF 0x00000002 // Disable Write Buffer +#define NVIC_ACTLR_DISMCYC 0x00000001 // Disable Interrupts of Multiple + // Cycle Instructions + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ST_CTRL register. +// +//***************************************************************************** +#define NVIC_ST_CTRL_COUNT 0x00010000 // Count Flag +#define NVIC_ST_CTRL_CLK_SRC 0x00000004 // Clock Source +#define NVIC_ST_CTRL_INTEN 0x00000002 // Interrupt Enable +#define NVIC_ST_CTRL_ENABLE 0x00000001 // Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ST_RELOAD register. +// +//***************************************************************************** +#define NVIC_ST_RELOAD_M 0x00FFFFFF // Reload Value +#define NVIC_ST_RELOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ST_CURRENT +// register. +// +//***************************************************************************** +#define NVIC_ST_CURRENT_M 0x00FFFFFF // Current Value +#define NVIC_ST_CURRENT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ST_CAL register. +// +//***************************************************************************** +#define NVIC_ST_CAL_NOREF 0x80000000 // No reference clock +#define NVIC_ST_CAL_SKEW 0x40000000 // Clock skew +#define NVIC_ST_CAL_ONEMS_M 0x00FFFFFF // 1ms reference value +#define NVIC_ST_CAL_ONEMS_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_EN0 register. +// +//***************************************************************************** +#define NVIC_EN0_INT_M 0xFFFFFFFF // Interrupt Enable +#define NVIC_EN0_INT0 0x00000001 // Interrupt 0 enable +#define NVIC_EN0_INT1 0x00000002 // Interrupt 1 enable +#define NVIC_EN0_INT2 0x00000004 // Interrupt 2 enable +#define NVIC_EN0_INT3 0x00000008 // Interrupt 3 enable +#define NVIC_EN0_INT4 0x00000010 // Interrupt 4 enable +#define NVIC_EN0_INT5 0x00000020 // Interrupt 5 enable +#define NVIC_EN0_INT6 0x00000040 // Interrupt 6 enable +#define NVIC_EN0_INT7 0x00000080 // Interrupt 7 enable +#define NVIC_EN0_INT8 0x00000100 // Interrupt 8 enable +#define NVIC_EN0_INT9 0x00000200 // Interrupt 9 enable +#define NVIC_EN0_INT10 0x00000400 // Interrupt 10 enable +#define NVIC_EN0_INT11 0x00000800 // Interrupt 11 enable +#define NVIC_EN0_INT12 0x00001000 // Interrupt 12 enable +#define NVIC_EN0_INT13 0x00002000 // Interrupt 13 enable +#define NVIC_EN0_INT14 0x00004000 // Interrupt 14 enable +#define NVIC_EN0_INT15 0x00008000 // Interrupt 15 enable +#define NVIC_EN0_INT16 0x00010000 // Interrupt 16 enable +#define NVIC_EN0_INT17 0x00020000 // Interrupt 17 enable +#define NVIC_EN0_INT18 0x00040000 // Interrupt 18 enable +#define NVIC_EN0_INT19 0x00080000 // Interrupt 19 enable +#define NVIC_EN0_INT20 0x00100000 // Interrupt 20 enable +#define NVIC_EN0_INT21 0x00200000 // Interrupt 21 enable +#define NVIC_EN0_INT22 0x00400000 // Interrupt 22 enable +#define NVIC_EN0_INT23 0x00800000 // Interrupt 23 enable +#define NVIC_EN0_INT24 0x01000000 // Interrupt 24 enable +#define NVIC_EN0_INT25 0x02000000 // Interrupt 25 enable +#define NVIC_EN0_INT26 0x04000000 // Interrupt 26 enable +#define NVIC_EN0_INT27 0x08000000 // Interrupt 27 enable +#define NVIC_EN0_INT28 0x10000000 // Interrupt 28 enable +#define NVIC_EN0_INT29 0x20000000 // Interrupt 29 enable +#define NVIC_EN0_INT30 0x40000000 // Interrupt 30 enable +#define NVIC_EN0_INT31 0x80000000 // Interrupt 31 enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_EN1 register. +// +//***************************************************************************** +#define NVIC_EN1_INT_M 0x007FFFFF // Interrupt Enable +#define NVIC_EN1_INT32 0x00000001 // Interrupt 32 enable +#define NVIC_EN1_INT33 0x00000002 // Interrupt 33 enable +#define NVIC_EN1_INT34 0x00000004 // Interrupt 34 enable +#define NVIC_EN1_INT35 0x00000008 // Interrupt 35 enable +#define NVIC_EN1_INT36 0x00000010 // Interrupt 36 enable +#define NVIC_EN1_INT37 0x00000020 // Interrupt 37 enable +#define NVIC_EN1_INT38 0x00000040 // Interrupt 38 enable +#define NVIC_EN1_INT39 0x00000080 // Interrupt 39 enable +#define NVIC_EN1_INT40 0x00000100 // Interrupt 40 enable +#define NVIC_EN1_INT41 0x00000200 // Interrupt 41 enable +#define NVIC_EN1_INT42 0x00000400 // Interrupt 42 enable +#define NVIC_EN1_INT43 0x00000800 // Interrupt 43 enable +#define NVIC_EN1_INT44 0x00001000 // Interrupt 44 enable +#define NVIC_EN1_INT45 0x00002000 // Interrupt 45 enable +#define NVIC_EN1_INT46 0x00004000 // Interrupt 46 enable +#define NVIC_EN1_INT47 0x00008000 // Interrupt 47 enable +#define NVIC_EN1_INT48 0x00010000 // Interrupt 48 enable +#define NVIC_EN1_INT49 0x00020000 // Interrupt 49 enable +#define NVIC_EN1_INT50 0x00040000 // Interrupt 50 enable +#define NVIC_EN1_INT51 0x00080000 // Interrupt 51 enable +#define NVIC_EN1_INT52 0x00100000 // Interrupt 52 enable +#define NVIC_EN1_INT53 0x00200000 // Interrupt 53 enable +#define NVIC_EN1_INT54 0x00400000 // Interrupt 54 enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DIS0 register. +// +//***************************************************************************** +#define NVIC_DIS0_INT_M 0xFFFFFFFF // Interrupt Disable +#define NVIC_DIS0_INT0 0x00000001 // Interrupt 0 disable +#define NVIC_DIS0_INT1 0x00000002 // Interrupt 1 disable +#define NVIC_DIS0_INT2 0x00000004 // Interrupt 2 disable +#define NVIC_DIS0_INT3 0x00000008 // Interrupt 3 disable +#define NVIC_DIS0_INT4 0x00000010 // Interrupt 4 disable +#define NVIC_DIS0_INT5 0x00000020 // Interrupt 5 disable +#define NVIC_DIS0_INT6 0x00000040 // Interrupt 6 disable +#define NVIC_DIS0_INT7 0x00000080 // Interrupt 7 disable +#define NVIC_DIS0_INT8 0x00000100 // Interrupt 8 disable +#define NVIC_DIS0_INT9 0x00000200 // Interrupt 9 disable +#define NVIC_DIS0_INT10 0x00000400 // Interrupt 10 disable +#define NVIC_DIS0_INT11 0x00000800 // Interrupt 11 disable +#define NVIC_DIS0_INT12 0x00001000 // Interrupt 12 disable +#define NVIC_DIS0_INT13 0x00002000 // Interrupt 13 disable +#define NVIC_DIS0_INT14 0x00004000 // Interrupt 14 disable +#define NVIC_DIS0_INT15 0x00008000 // Interrupt 15 disable +#define NVIC_DIS0_INT16 0x00010000 // Interrupt 16 disable +#define NVIC_DIS0_INT17 0x00020000 // Interrupt 17 disable +#define NVIC_DIS0_INT18 0x00040000 // Interrupt 18 disable +#define NVIC_DIS0_INT19 0x00080000 // Interrupt 19 disable +#define NVIC_DIS0_INT20 0x00100000 // Interrupt 20 disable +#define NVIC_DIS0_INT21 0x00200000 // Interrupt 21 disable +#define NVIC_DIS0_INT22 0x00400000 // Interrupt 22 disable +#define NVIC_DIS0_INT23 0x00800000 // Interrupt 23 disable +#define NVIC_DIS0_INT24 0x01000000 // Interrupt 24 disable +#define NVIC_DIS0_INT25 0x02000000 // Interrupt 25 disable +#define NVIC_DIS0_INT26 0x04000000 // Interrupt 26 disable +#define NVIC_DIS0_INT27 0x08000000 // Interrupt 27 disable +#define NVIC_DIS0_INT28 0x10000000 // Interrupt 28 disable +#define NVIC_DIS0_INT29 0x20000000 // Interrupt 29 disable +#define NVIC_DIS0_INT30 0x40000000 // Interrupt 30 disable +#define NVIC_DIS0_INT31 0x80000000 // Interrupt 31 disable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DIS1 register. +// +//***************************************************************************** +#define NVIC_DIS1_INT_M 0x00FFFFFF // Interrupt Disable +#define NVIC_DIS1_INT32 0x00000001 // Interrupt 32 disable +#define NVIC_DIS1_INT33 0x00000002 // Interrupt 33 disable +#define NVIC_DIS1_INT34 0x00000004 // Interrupt 34 disable +#define NVIC_DIS1_INT35 0x00000008 // Interrupt 35 disable +#define NVIC_DIS1_INT36 0x00000010 // Interrupt 36 disable +#define NVIC_DIS1_INT37 0x00000020 // Interrupt 37 disable +#define NVIC_DIS1_INT38 0x00000040 // Interrupt 38 disable +#define NVIC_DIS1_INT39 0x00000080 // Interrupt 39 disable +#define NVIC_DIS1_INT40 0x00000100 // Interrupt 40 disable +#define NVIC_DIS1_INT41 0x00000200 // Interrupt 41 disable +#define NVIC_DIS1_INT42 0x00000400 // Interrupt 42 disable +#define NVIC_DIS1_INT43 0x00000800 // Interrupt 43 disable +#define NVIC_DIS1_INT44 0x00001000 // Interrupt 44 disable +#define NVIC_DIS1_INT45 0x00002000 // Interrupt 45 disable +#define NVIC_DIS1_INT46 0x00004000 // Interrupt 46 disable +#define NVIC_DIS1_INT47 0x00008000 // Interrupt 47 disable +#define NVIC_DIS1_INT48 0x00010000 // Interrupt 48 disable +#define NVIC_DIS1_INT49 0x00020000 // Interrupt 49 disable +#define NVIC_DIS1_INT50 0x00040000 // Interrupt 50 disable +#define NVIC_DIS1_INT51 0x00080000 // Interrupt 51 disable +#define NVIC_DIS1_INT52 0x00100000 // Interrupt 52 disable +#define NVIC_DIS1_INT53 0x00200000 // Interrupt 53 disable +#define NVIC_DIS1_INT54 0x00400000 // Interrupt 54 disable +#define NVIC_DIS1_INT55 0x00800000 // Interrupt 55 disable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PEND0 register. +// +//***************************************************************************** +#define NVIC_PEND0_INT_M 0xFFFFFFFF // Interrupt Set Pending +#define NVIC_PEND0_INT0 0x00000001 // Interrupt 0 pend +#define NVIC_PEND0_INT1 0x00000002 // Interrupt 1 pend +#define NVIC_PEND0_INT2 0x00000004 // Interrupt 2 pend +#define NVIC_PEND0_INT3 0x00000008 // Interrupt 3 pend +#define NVIC_PEND0_INT4 0x00000010 // Interrupt 4 pend +#define NVIC_PEND0_INT5 0x00000020 // Interrupt 5 pend +#define NVIC_PEND0_INT6 0x00000040 // Interrupt 6 pend +#define NVIC_PEND0_INT7 0x00000080 // Interrupt 7 pend +#define NVIC_PEND0_INT8 0x00000100 // Interrupt 8 pend +#define NVIC_PEND0_INT9 0x00000200 // Interrupt 9 pend +#define NVIC_PEND0_INT10 0x00000400 // Interrupt 10 pend +#define NVIC_PEND0_INT11 0x00000800 // Interrupt 11 pend +#define NVIC_PEND0_INT12 0x00001000 // Interrupt 12 pend +#define NVIC_PEND0_INT13 0x00002000 // Interrupt 13 pend +#define NVIC_PEND0_INT14 0x00004000 // Interrupt 14 pend +#define NVIC_PEND0_INT15 0x00008000 // Interrupt 15 pend +#define NVIC_PEND0_INT16 0x00010000 // Interrupt 16 pend +#define NVIC_PEND0_INT17 0x00020000 // Interrupt 17 pend +#define NVIC_PEND0_INT18 0x00040000 // Interrupt 18 pend +#define NVIC_PEND0_INT19 0x00080000 // Interrupt 19 pend +#define NVIC_PEND0_INT20 0x00100000 // Interrupt 20 pend +#define NVIC_PEND0_INT21 0x00200000 // Interrupt 21 pend +#define NVIC_PEND0_INT22 0x00400000 // Interrupt 22 pend +#define NVIC_PEND0_INT23 0x00800000 // Interrupt 23 pend +#define NVIC_PEND0_INT24 0x01000000 // Interrupt 24 pend +#define NVIC_PEND0_INT25 0x02000000 // Interrupt 25 pend +#define NVIC_PEND0_INT26 0x04000000 // Interrupt 26 pend +#define NVIC_PEND0_INT27 0x08000000 // Interrupt 27 pend +#define NVIC_PEND0_INT28 0x10000000 // Interrupt 28 pend +#define NVIC_PEND0_INT29 0x20000000 // Interrupt 29 pend +#define NVIC_PEND0_INT30 0x40000000 // Interrupt 30 pend +#define NVIC_PEND0_INT31 0x80000000 // Interrupt 31 pend + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PEND1 register. +// +//***************************************************************************** +#define NVIC_PEND1_INT_M 0x00FFFFFF // Interrupt Set Pending +#define NVIC_PEND1_INT32 0x00000001 // Interrupt 32 pend +#define NVIC_PEND1_INT33 0x00000002 // Interrupt 33 pend +#define NVIC_PEND1_INT34 0x00000004 // Interrupt 34 pend +#define NVIC_PEND1_INT35 0x00000008 // Interrupt 35 pend +#define NVIC_PEND1_INT36 0x00000010 // Interrupt 36 pend +#define NVIC_PEND1_INT37 0x00000020 // Interrupt 37 pend +#define NVIC_PEND1_INT38 0x00000040 // Interrupt 38 pend +#define NVIC_PEND1_INT39 0x00000080 // Interrupt 39 pend +#define NVIC_PEND1_INT40 0x00000100 // Interrupt 40 pend +#define NVIC_PEND1_INT41 0x00000200 // Interrupt 41 pend +#define NVIC_PEND1_INT42 0x00000400 // Interrupt 42 pend +#define NVIC_PEND1_INT43 0x00000800 // Interrupt 43 pend +#define NVIC_PEND1_INT44 0x00001000 // Interrupt 44 pend +#define NVIC_PEND1_INT45 0x00002000 // Interrupt 45 pend +#define NVIC_PEND1_INT46 0x00004000 // Interrupt 46 pend +#define NVIC_PEND1_INT47 0x00008000 // Interrupt 47 pend +#define NVIC_PEND1_INT48 0x00010000 // Interrupt 48 pend +#define NVIC_PEND1_INT49 0x00020000 // Interrupt 49 pend +#define NVIC_PEND1_INT50 0x00040000 // Interrupt 50 pend +#define NVIC_PEND1_INT51 0x00080000 // Interrupt 51 pend +#define NVIC_PEND1_INT52 0x00100000 // Interrupt 52 pend +#define NVIC_PEND1_INT53 0x00200000 // Interrupt 53 pend +#define NVIC_PEND1_INT54 0x00400000 // Interrupt 54 pend +#define NVIC_PEND1_INT55 0x00800000 // Interrupt 55 pend + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_UNPEND0 register. +// +//***************************************************************************** +#define NVIC_UNPEND0_INT_M 0xFFFFFFFF // Interrupt Clear Pending +#define NVIC_UNPEND0_INT0 0x00000001 // Interrupt 0 unpend +#define NVIC_UNPEND0_INT1 0x00000002 // Interrupt 1 unpend +#define NVIC_UNPEND0_INT2 0x00000004 // Interrupt 2 unpend +#define NVIC_UNPEND0_INT3 0x00000008 // Interrupt 3 unpend +#define NVIC_UNPEND0_INT4 0x00000010 // Interrupt 4 unpend +#define NVIC_UNPEND0_INT5 0x00000020 // Interrupt 5 unpend +#define NVIC_UNPEND0_INT6 0x00000040 // Interrupt 6 unpend +#define NVIC_UNPEND0_INT7 0x00000080 // Interrupt 7 unpend +#define NVIC_UNPEND0_INT8 0x00000100 // Interrupt 8 unpend +#define NVIC_UNPEND0_INT9 0x00000200 // Interrupt 9 unpend +#define NVIC_UNPEND0_INT10 0x00000400 // Interrupt 10 unpend +#define NVIC_UNPEND0_INT11 0x00000800 // Interrupt 11 unpend +#define NVIC_UNPEND0_INT12 0x00001000 // Interrupt 12 unpend +#define NVIC_UNPEND0_INT13 0x00002000 // Interrupt 13 unpend +#define NVIC_UNPEND0_INT14 0x00004000 // Interrupt 14 unpend +#define NVIC_UNPEND0_INT15 0x00008000 // Interrupt 15 unpend +#define NVIC_UNPEND0_INT16 0x00010000 // Interrupt 16 unpend +#define NVIC_UNPEND0_INT17 0x00020000 // Interrupt 17 unpend +#define NVIC_UNPEND0_INT18 0x00040000 // Interrupt 18 unpend +#define NVIC_UNPEND0_INT19 0x00080000 // Interrupt 19 unpend +#define NVIC_UNPEND0_INT20 0x00100000 // Interrupt 20 unpend +#define NVIC_UNPEND0_INT21 0x00200000 // Interrupt 21 unpend +#define NVIC_UNPEND0_INT22 0x00400000 // Interrupt 22 unpend +#define NVIC_UNPEND0_INT23 0x00800000 // Interrupt 23 unpend +#define NVIC_UNPEND0_INT24 0x01000000 // Interrupt 24 unpend +#define NVIC_UNPEND0_INT25 0x02000000 // Interrupt 25 unpend +#define NVIC_UNPEND0_INT26 0x04000000 // Interrupt 26 unpend +#define NVIC_UNPEND0_INT27 0x08000000 // Interrupt 27 unpend +#define NVIC_UNPEND0_INT28 0x10000000 // Interrupt 28 unpend +#define NVIC_UNPEND0_INT29 0x20000000 // Interrupt 29 unpend +#define NVIC_UNPEND0_INT30 0x40000000 // Interrupt 30 unpend +#define NVIC_UNPEND0_INT31 0x80000000 // Interrupt 31 unpend + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_UNPEND1 register. +// +//***************************************************************************** +#define NVIC_UNPEND1_INT_M 0x00FFFFFF // Interrupt Clear Pending +#define NVIC_UNPEND1_INT32 0x00000001 // Interrupt 32 unpend +#define NVIC_UNPEND1_INT33 0x00000002 // Interrupt 33 unpend +#define NVIC_UNPEND1_INT34 0x00000004 // Interrupt 34 unpend +#define NVIC_UNPEND1_INT35 0x00000008 // Interrupt 35 unpend +#define NVIC_UNPEND1_INT36 0x00000010 // Interrupt 36 unpend +#define NVIC_UNPEND1_INT37 0x00000020 // Interrupt 37 unpend +#define NVIC_UNPEND1_INT38 0x00000040 // Interrupt 38 unpend +#define NVIC_UNPEND1_INT39 0x00000080 // Interrupt 39 unpend +#define NVIC_UNPEND1_INT40 0x00000100 // Interrupt 40 unpend +#define NVIC_UNPEND1_INT41 0x00000200 // Interrupt 41 unpend +#define NVIC_UNPEND1_INT42 0x00000400 // Interrupt 42 unpend +#define NVIC_UNPEND1_INT43 0x00000800 // Interrupt 43 unpend +#define NVIC_UNPEND1_INT44 0x00001000 // Interrupt 44 unpend +#define NVIC_UNPEND1_INT45 0x00002000 // Interrupt 45 unpend +#define NVIC_UNPEND1_INT46 0x00004000 // Interrupt 46 unpend +#define NVIC_UNPEND1_INT47 0x00008000 // Interrupt 47 unpend +#define NVIC_UNPEND1_INT48 0x00010000 // Interrupt 48 unpend +#define NVIC_UNPEND1_INT49 0x00020000 // Interrupt 49 unpend +#define NVIC_UNPEND1_INT50 0x00040000 // Interrupt 50 unpend +#define NVIC_UNPEND1_INT51 0x00080000 // Interrupt 51 unpend +#define NVIC_UNPEND1_INT52 0x00100000 // Interrupt 52 unpend +#define NVIC_UNPEND1_INT53 0x00200000 // Interrupt 53 unpend +#define NVIC_UNPEND1_INT54 0x00400000 // Interrupt 54 unpend +#define NVIC_UNPEND1_INT55 0x00800000 // Interrupt 55 unpend + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ACTIVE0 register. +// +//***************************************************************************** +#define NVIC_ACTIVE0_INT_M 0xFFFFFFFF // Interrupt Active +#define NVIC_ACTIVE0_INT0 0x00000001 // Interrupt 0 active +#define NVIC_ACTIVE0_INT1 0x00000002 // Interrupt 1 active +#define NVIC_ACTIVE0_INT2 0x00000004 // Interrupt 2 active +#define NVIC_ACTIVE0_INT3 0x00000008 // Interrupt 3 active +#define NVIC_ACTIVE0_INT4 0x00000010 // Interrupt 4 active +#define NVIC_ACTIVE0_INT5 0x00000020 // Interrupt 5 active +#define NVIC_ACTIVE0_INT6 0x00000040 // Interrupt 6 active +#define NVIC_ACTIVE0_INT7 0x00000080 // Interrupt 7 active +#define NVIC_ACTIVE0_INT8 0x00000100 // Interrupt 8 active +#define NVIC_ACTIVE0_INT9 0x00000200 // Interrupt 9 active +#define NVIC_ACTIVE0_INT10 0x00000400 // Interrupt 10 active +#define NVIC_ACTIVE0_INT11 0x00000800 // Interrupt 11 active +#define NVIC_ACTIVE0_INT12 0x00001000 // Interrupt 12 active +#define NVIC_ACTIVE0_INT13 0x00002000 // Interrupt 13 active +#define NVIC_ACTIVE0_INT14 0x00004000 // Interrupt 14 active +#define NVIC_ACTIVE0_INT15 0x00008000 // Interrupt 15 active +#define NVIC_ACTIVE0_INT16 0x00010000 // Interrupt 16 active +#define NVIC_ACTIVE0_INT17 0x00020000 // Interrupt 17 active +#define NVIC_ACTIVE0_INT18 0x00040000 // Interrupt 18 active +#define NVIC_ACTIVE0_INT19 0x00080000 // Interrupt 19 active +#define NVIC_ACTIVE0_INT20 0x00100000 // Interrupt 20 active +#define NVIC_ACTIVE0_INT21 0x00200000 // Interrupt 21 active +#define NVIC_ACTIVE0_INT22 0x00400000 // Interrupt 22 active +#define NVIC_ACTIVE0_INT23 0x00800000 // Interrupt 23 active +#define NVIC_ACTIVE0_INT24 0x01000000 // Interrupt 24 active +#define NVIC_ACTIVE0_INT25 0x02000000 // Interrupt 25 active +#define NVIC_ACTIVE0_INT26 0x04000000 // Interrupt 26 active +#define NVIC_ACTIVE0_INT27 0x08000000 // Interrupt 27 active +#define NVIC_ACTIVE0_INT28 0x10000000 // Interrupt 28 active +#define NVIC_ACTIVE0_INT29 0x20000000 // Interrupt 29 active +#define NVIC_ACTIVE0_INT30 0x40000000 // Interrupt 30 active +#define NVIC_ACTIVE0_INT31 0x80000000 // Interrupt 31 active + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ACTIVE1 register. +// +//***************************************************************************** +#define NVIC_ACTIVE1_INT_M 0x00FFFFFF // Interrupt Active +#define NVIC_ACTIVE1_INT32 0x00000001 // Interrupt 32 active +#define NVIC_ACTIVE1_INT33 0x00000002 // Interrupt 33 active +#define NVIC_ACTIVE1_INT34 0x00000004 // Interrupt 34 active +#define NVIC_ACTIVE1_INT35 0x00000008 // Interrupt 35 active +#define NVIC_ACTIVE1_INT36 0x00000010 // Interrupt 36 active +#define NVIC_ACTIVE1_INT37 0x00000020 // Interrupt 37 active +#define NVIC_ACTIVE1_INT38 0x00000040 // Interrupt 38 active +#define NVIC_ACTIVE1_INT39 0x00000080 // Interrupt 39 active +#define NVIC_ACTIVE1_INT40 0x00000100 // Interrupt 40 active +#define NVIC_ACTIVE1_INT41 0x00000200 // Interrupt 41 active +#define NVIC_ACTIVE1_INT42 0x00000400 // Interrupt 42 active +#define NVIC_ACTIVE1_INT43 0x00000800 // Interrupt 43 active +#define NVIC_ACTIVE1_INT44 0x00001000 // Interrupt 44 active +#define NVIC_ACTIVE1_INT45 0x00002000 // Interrupt 45 active +#define NVIC_ACTIVE1_INT46 0x00004000 // Interrupt 46 active +#define NVIC_ACTIVE1_INT47 0x00008000 // Interrupt 47 active +#define NVIC_ACTIVE1_INT48 0x00010000 // Interrupt 48 active +#define NVIC_ACTIVE1_INT49 0x00020000 // Interrupt 49 active +#define NVIC_ACTIVE1_INT50 0x00040000 // Interrupt 50 active +#define NVIC_ACTIVE1_INT51 0x00080000 // Interrupt 51 active +#define NVIC_ACTIVE1_INT52 0x00100000 // Interrupt 52 active +#define NVIC_ACTIVE1_INT53 0x00200000 // Interrupt 53 active +#define NVIC_ACTIVE1_INT54 0x00400000 // Interrupt 54 active +#define NVIC_ACTIVE1_INT55 0x00800000 // Interrupt 55 active + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI0 register. +// +//***************************************************************************** +#define NVIC_PRI0_INT3_M 0xE0000000 // Interrupt 3 Priority Mask +#define NVIC_PRI0_INT2_M 0x00E00000 // Interrupt 2 Priority Mask +#define NVIC_PRI0_INT1_M 0x0000E000 // Interrupt 1 Priority Mask +#define NVIC_PRI0_INT0_M 0x000000E0 // Interrupt 0 Priority Mask +#define NVIC_PRI0_INT3_S 29 +#define NVIC_PRI0_INT2_S 21 +#define NVIC_PRI0_INT1_S 13 +#define NVIC_PRI0_INT0_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI1 register. +// +//***************************************************************************** +#define NVIC_PRI1_INT7_M 0xE0000000 // Interrupt 7 Priority Mask +#define NVIC_PRI1_INT6_M 0x00E00000 // Interrupt 6 Priority Mask +#define NVIC_PRI1_INT5_M 0x0000E000 // Interrupt 5 Priority Mask +#define NVIC_PRI1_INT4_M 0x000000E0 // Interrupt 4 Priority Mask +#define NVIC_PRI1_INT7_S 29 +#define NVIC_PRI1_INT6_S 21 +#define NVIC_PRI1_INT5_S 13 +#define NVIC_PRI1_INT4_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI2 register. +// +//***************************************************************************** +#define NVIC_PRI2_INT11_M 0xE0000000 // Interrupt 11 Priority Mask +#define NVIC_PRI2_INT10_M 0x00E00000 // Interrupt 10 Priority Mask +#define NVIC_PRI2_INT9_M 0x0000E000 // Interrupt 9 Priority Mask +#define NVIC_PRI2_INT8_M 0x000000E0 // Interrupt 8 Priority Mask +#define NVIC_PRI2_INT11_S 29 +#define NVIC_PRI2_INT10_S 21 +#define NVIC_PRI2_INT9_S 13 +#define NVIC_PRI2_INT8_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI3 register. +// +//***************************************************************************** +#define NVIC_PRI3_INT15_M 0xE0000000 // Interrupt 15 Priority Mask +#define NVIC_PRI3_INT14_M 0x00E00000 // Interrupt 14 Priority Mask +#define NVIC_PRI3_INT13_M 0x0000E000 // Interrupt 13 Priority Mask +#define NVIC_PRI3_INT12_M 0x000000E0 // Interrupt 12 Priority Mask +#define NVIC_PRI3_INT15_S 29 +#define NVIC_PRI3_INT14_S 21 +#define NVIC_PRI3_INT13_S 13 +#define NVIC_PRI3_INT12_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI4 register. +// +//***************************************************************************** +#define NVIC_PRI4_INT19_M 0xE0000000 // Interrupt 19 Priority Mask +#define NVIC_PRI4_INT18_M 0x00E00000 // Interrupt 18 Priority Mask +#define NVIC_PRI4_INT17_M 0x0000E000 // Interrupt 17 Priority Mask +#define NVIC_PRI4_INT16_M 0x000000E0 // Interrupt 16 Priority Mask +#define NVIC_PRI4_INT19_S 29 +#define NVIC_PRI4_INT18_S 21 +#define NVIC_PRI4_INT17_S 13 +#define NVIC_PRI4_INT16_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI5 register. +// +//***************************************************************************** +#define NVIC_PRI5_INT23_M 0xE0000000 // Interrupt 23 Priority Mask +#define NVIC_PRI5_INT22_M 0x00E00000 // Interrupt 22 Priority Mask +#define NVIC_PRI5_INT21_M 0x0000E000 // Interrupt 21 Priority Mask +#define NVIC_PRI5_INT20_M 0x000000E0 // Interrupt 20 Priority Mask +#define NVIC_PRI5_INT23_S 29 +#define NVIC_PRI5_INT22_S 21 +#define NVIC_PRI5_INT21_S 13 +#define NVIC_PRI5_INT20_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI6 register. +// +//***************************************************************************** +#define NVIC_PRI6_INT27_M 0xE0000000 // Interrupt 27 Priority Mask +#define NVIC_PRI6_INT26_M 0x00E00000 // Interrupt 26 Priority Mask +#define NVIC_PRI6_INT25_M 0x0000E000 // Interrupt 25 Priority Mask +#define NVIC_PRI6_INT24_M 0x000000E0 // Interrupt 24 Priority Mask +#define NVIC_PRI6_INT27_S 29 +#define NVIC_PRI6_INT26_S 21 +#define NVIC_PRI6_INT25_S 13 +#define NVIC_PRI6_INT24_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI7 register. +// +//***************************************************************************** +#define NVIC_PRI7_INT31_M 0xE0000000 // Interrupt 31 Priority Mask +#define NVIC_PRI7_INT30_M 0x00E00000 // Interrupt 30 Priority Mask +#define NVIC_PRI7_INT29_M 0x0000E000 // Interrupt 29 Priority Mask +#define NVIC_PRI7_INT28_M 0x000000E0 // Interrupt 28 Priority Mask +#define NVIC_PRI7_INT31_S 29 +#define NVIC_PRI7_INT30_S 21 +#define NVIC_PRI7_INT29_S 13 +#define NVIC_PRI7_INT28_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI8 register. +// +//***************************************************************************** +#define NVIC_PRI8_INT35_M 0xE0000000 // Interrupt 35 Priority Mask +#define NVIC_PRI8_INT34_M 0x00E00000 // Interrupt 34 Priority Mask +#define NVIC_PRI8_INT33_M 0x0000E000 // Interrupt 33 Priority Mask +#define NVIC_PRI8_INT32_M 0x000000E0 // Interrupt 32 Priority Mask +#define NVIC_PRI8_INT35_S 29 +#define NVIC_PRI8_INT34_S 21 +#define NVIC_PRI8_INT33_S 13 +#define NVIC_PRI8_INT32_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI9 register. +// +//***************************************************************************** +#define NVIC_PRI9_INT39_M 0xE0000000 // Interrupt 39 Priority Mask +#define NVIC_PRI9_INT38_M 0x00E00000 // Interrupt 38 Priority Mask +#define NVIC_PRI9_INT37_M 0x0000E000 // Interrupt 37 Priority Mask +#define NVIC_PRI9_INT36_M 0x000000E0 // Interrupt 36 Priority Mask +#define NVIC_PRI9_INT39_S 29 +#define NVIC_PRI9_INT38_S 21 +#define NVIC_PRI9_INT37_S 13 +#define NVIC_PRI9_INT36_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI10 register. +// +//***************************************************************************** +#define NVIC_PRI10_INT43_M 0xE0000000 // Interrupt 43 Priority Mask +#define NVIC_PRI10_INT42_M 0x00E00000 // Interrupt 42 Priority Mask +#define NVIC_PRI10_INT41_M 0x0000E000 // Interrupt 41 Priority Mask +#define NVIC_PRI10_INT40_M 0x000000E0 // Interrupt 40 Priority Mask +#define NVIC_PRI10_INT43_S 29 +#define NVIC_PRI10_INT42_S 21 +#define NVIC_PRI10_INT41_S 13 +#define NVIC_PRI10_INT40_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI11 register. +// +//***************************************************************************** +#define NVIC_PRI11_INT47_M 0xE0000000 // Interrupt 47 Priority Mask +#define NVIC_PRI11_INT46_M 0x00E00000 // Interrupt 46 Priority Mask +#define NVIC_PRI11_INT45_M 0x0000E000 // Interrupt 45 Priority Mask +#define NVIC_PRI11_INT44_M 0x000000E0 // Interrupt 44 Priority Mask +#define NVIC_PRI11_INT47_S 29 +#define NVIC_PRI11_INT46_S 21 +#define NVIC_PRI11_INT45_S 13 +#define NVIC_PRI11_INT44_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI12 register. +// +//***************************************************************************** +#define NVIC_PRI12_INT51_M 0xE0000000 // Interrupt 51 Priority Mask +#define NVIC_PRI12_INT50_M 0x00E00000 // Interrupt 50 Priority Mask +#define NVIC_PRI12_INT49_M 0x0000E000 // Interrupt 49 Priority Mask +#define NVIC_PRI12_INT48_M 0x000000E0 // Interrupt 48 Priority Mask +#define NVIC_PRI12_INT51_S 29 +#define NVIC_PRI12_INT50_S 21 +#define NVIC_PRI12_INT49_S 13 +#define NVIC_PRI12_INT48_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI13 register. +// +//***************************************************************************** +#define NVIC_PRI13_INT55_M 0xE0000000 // Interrupt 55 Priority Mask +#define NVIC_PRI13_INT54_M 0x00E00000 // Interrupt 54 Priority Mask +#define NVIC_PRI13_INT53_M 0x0000E000 // Interrupt 53 Priority Mask +#define NVIC_PRI13_INT52_M 0x000000E0 // Interrupt 52 Priority Mask +#define NVIC_PRI13_INT55_S 29 +#define NVIC_PRI13_INT54_S 21 +#define NVIC_PRI13_INT53_S 13 +#define NVIC_PRI13_INT52_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_CPUID register. +// +//***************************************************************************** +#define NVIC_CPUID_IMP_M 0xFF000000 // Implementer Code +#define NVIC_CPUID_IMP_ARM 0x41000000 // ARM +#define NVIC_CPUID_VAR_M 0x00F00000 // Variant Number +#define NVIC_CPUID_CON_M 0x000F0000 // Constant +#define NVIC_CPUID_PARTNO_M 0x0000FFF0 // Part Number +#define NVIC_CPUID_PARTNO_CM3 0x0000C230 // Cortex-M3 processor +#define NVIC_CPUID_REV_M 0x0000000F // Revision Number + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_INT_CTRL register. +// +//***************************************************************************** +#define NVIC_INT_CTRL_NMI_SET 0x80000000 // NMI Set Pending +#define NVIC_INT_CTRL_PEND_SV 0x10000000 // PendSV Set Pending +#define NVIC_INT_CTRL_UNPEND_SV 0x08000000 // PendSV Clear Pending +#define NVIC_INT_CTRL_PENDSTSET 0x04000000 // SysTick Set Pending +#define NVIC_INT_CTRL_PENDSTCLR 0x02000000 // SysTick Clear Pending +#define NVIC_INT_CTRL_ISR_PRE 0x00800000 // Debug Interrupt Handling +#define NVIC_INT_CTRL_ISR_PEND 0x00400000 // Interrupt Pending +#define NVIC_INT_CTRL_VEC_PEN_M 0x0007F000 // Interrupt Pending Vector Number +#define NVIC_INT_CTRL_VEC_PEN_NMI \ + 0x00002000 // NMI +#define NVIC_INT_CTRL_VEC_PEN_HARD \ + 0x00003000 // Hard fault +#define NVIC_INT_CTRL_VEC_PEN_MEM \ + 0x00004000 // Memory management fault +#define NVIC_INT_CTRL_VEC_PEN_BUS \ + 0x00005000 // Bus fault +#define NVIC_INT_CTRL_VEC_PEN_USG \ + 0x00006000 // Usage fault +#define NVIC_INT_CTRL_VEC_PEN_SVC \ + 0x0000B000 // SVCall +#define NVIC_INT_CTRL_VEC_PEN_PNDSV \ + 0x0000E000 // PendSV +#define NVIC_INT_CTRL_VEC_PEN_TICK \ + 0x0000F000 // SysTick +#define NVIC_INT_CTRL_RET_BASE 0x00000800 // Return to Base +#define NVIC_INT_CTRL_VEC_ACT_M 0x0000007F // Interrupt Pending Vector Number +#define NVIC_INT_CTRL_VEC_PEN_S 12 +#define NVIC_INT_CTRL_VEC_ACT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_VTABLE register. +// +//***************************************************************************** +#define NVIC_VTABLE_BASE 0x20000000 // Vector Table Base +#define NVIC_VTABLE_OFFSET_M 0x1FFFFE00 // Vector Table Offset +#define NVIC_VTABLE_OFFSET_S 9 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_APINT register. +// +//***************************************************************************** +#define NVIC_APINT_VECTKEY_M 0xFFFF0000 // Register Key +#define NVIC_APINT_VECTKEY 0x05FA0000 // Vector key +#define NVIC_APINT_ENDIANESS 0x00008000 // Data Endianess +#define NVIC_APINT_PRIGROUP_M 0x00000700 // Interrupt Priority Grouping +#define NVIC_APINT_PRIGROUP_7_1 0x00000000 // Priority group 7.1 split +#define NVIC_APINT_PRIGROUP_6_2 0x00000100 // Priority group 6.2 split +#define NVIC_APINT_PRIGROUP_5_3 0x00000200 // Priority group 5.3 split +#define NVIC_APINT_PRIGROUP_4_4 0x00000300 // Priority group 4.4 split +#define NVIC_APINT_PRIGROUP_3_5 0x00000400 // Priority group 3.5 split +#define NVIC_APINT_PRIGROUP_2_6 0x00000500 // Priority group 2.6 split +#define NVIC_APINT_PRIGROUP_1_7 0x00000600 // Priority group 1.7 split +#define NVIC_APINT_PRIGROUP_0_8 0x00000700 // Priority group 0.8 split +#define NVIC_APINT_SYSRESETREQ 0x00000004 // System Reset Request +#define NVIC_APINT_VECT_CLR_ACT 0x00000002 // Clear Active NMI / Fault +#define NVIC_APINT_VECT_RESET 0x00000001 // System Reset + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SYS_CTRL register. +// +//***************************************************************************** +#define NVIC_SYS_CTRL_SEVONPEND 0x00000010 // Wake Up on Pending +#define NVIC_SYS_CTRL_SLEEPDEEP 0x00000004 // Deep Sleep Enable +#define NVIC_SYS_CTRL_SLEEPEXIT 0x00000002 // Sleep on ISR Exit + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_CFG_CTRL register. +// +//***************************************************************************** +#define NVIC_CFG_CTRL_STKALIGN 0x00000200 // Stack Alignment on Exception + // Entry +#define NVIC_CFG_CTRL_BFHFNMIGN 0x00000100 // Ignore Bus Fault in NMI and + // Fault +#define NVIC_CFG_CTRL_DIV0 0x00000010 // Trap on Divide by 0 +#define NVIC_CFG_CTRL_UNALIGNED 0x00000008 // Trap on Unaligned Access +#define NVIC_CFG_CTRL_MAIN_PEND 0x00000002 // Allow Main Interrupt Trigger +#define NVIC_CFG_CTRL_BASE_THR 0x00000001 // Thread State Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SYS_PRI1 register. +// +//***************************************************************************** +#define NVIC_SYS_PRI1_USAGE_M 0x00E00000 // Usage Fault Priority +#define NVIC_SYS_PRI1_BUS_M 0x0000E000 // Bus Fault Priority +#define NVIC_SYS_PRI1_MEM_M 0x000000E0 // Memory Management Fault Priority +#define NVIC_SYS_PRI1_USAGE_S 21 +#define NVIC_SYS_PRI1_BUS_S 13 +#define NVIC_SYS_PRI1_MEM_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SYS_PRI2 register. +// +//***************************************************************************** +#define NVIC_SYS_PRI2_SVC_M 0xE0000000 // SVCall Priority +#define NVIC_SYS_PRI2_SVC_S 29 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SYS_PRI3 register. +// +//***************************************************************************** +#define NVIC_SYS_PRI3_TICK_M 0xE0000000 // SysTick Exception Priority +#define NVIC_SYS_PRI3_PENDSV_M 0x00E00000 // PendSV Priority +#define NVIC_SYS_PRI3_DEBUG_M 0x000000E0 // Debug Priority +#define NVIC_SYS_PRI3_TICK_S 29 +#define NVIC_SYS_PRI3_PENDSV_S 21 +#define NVIC_SYS_PRI3_DEBUG_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SYS_HND_CTRL +// register. +// +//***************************************************************************** +#define NVIC_SYS_HND_CTRL_USAGE 0x00040000 // Usage Fault Enable +#define NVIC_SYS_HND_CTRL_BUS 0x00020000 // Bus Fault Enable +#define NVIC_SYS_HND_CTRL_MEM 0x00010000 // Memory Management Fault Enable +#define NVIC_SYS_HND_CTRL_SVC 0x00008000 // SVC Call Pending +#define NVIC_SYS_HND_CTRL_BUSP 0x00004000 // Bus Fault Pending +#define NVIC_SYS_HND_CTRL_MEMP 0x00002000 // Memory Management Fault Pending +#define NVIC_SYS_HND_CTRL_USAGEP \ + 0x00001000 // Usage Fault Pending +#define NVIC_SYS_HND_CTRL_TICK 0x00000800 // SysTick Exception Active +#define NVIC_SYS_HND_CTRL_PNDSV 0x00000400 // PendSV Exception Active +#define NVIC_SYS_HND_CTRL_MON 0x00000100 // Debug Monitor Active +#define NVIC_SYS_HND_CTRL_SVCA 0x00000080 // SVC Call Active +#define NVIC_SYS_HND_CTRL_USGA 0x00000008 // Usage Fault Active +#define NVIC_SYS_HND_CTRL_BUSA 0x00000002 // Bus Fault Active +#define NVIC_SYS_HND_CTRL_MEMA 0x00000001 // Memory Management Fault Active + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_FAULT_STAT +// register. +// +//***************************************************************************** +#define NVIC_FAULT_STAT_DIV0 0x02000000 // Divide-by-Zero Usage Fault +#define NVIC_FAULT_STAT_UNALIGN 0x01000000 // Unaligned Access Usage Fault +#define NVIC_FAULT_STAT_NOCP 0x00080000 // No Coprocessor Usage Fault +#define NVIC_FAULT_STAT_INVPC 0x00040000 // Invalid PC Load Usage Fault +#define NVIC_FAULT_STAT_INVSTAT 0x00020000 // Invalid State Usage Fault +#define NVIC_FAULT_STAT_UNDEF 0x00010000 // Undefined Instruction Usage + // Fault +#define NVIC_FAULT_STAT_BFARV 0x00008000 // Bus Fault Address Register Valid +#define NVIC_FAULT_STAT_BSTKE 0x00001000 // Stack Bus Fault +#define NVIC_FAULT_STAT_BUSTKE 0x00000800 // Unstack Bus Fault +#define NVIC_FAULT_STAT_IMPRE 0x00000400 // Imprecise Data Bus Error +#define NVIC_FAULT_STAT_PRECISE 0x00000200 // Precise Data Bus Error +#define NVIC_FAULT_STAT_IBUS 0x00000100 // Instruction Bus Error +#define NVIC_FAULT_STAT_MMARV 0x00000080 // Memory Management Fault Address + // Register Valid +#define NVIC_FAULT_STAT_MSTKE 0x00000010 // Stack Access Violation +#define NVIC_FAULT_STAT_MUSTKE 0x00000008 // Unstack Access Violation +#define NVIC_FAULT_STAT_DERR 0x00000002 // Data Access Violation +#define NVIC_FAULT_STAT_IERR 0x00000001 // Instruction Access Violation + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_HFAULT_STAT +// register. +// +//***************************************************************************** +#define NVIC_HFAULT_STAT_DBG 0x80000000 // Debug Event +#define NVIC_HFAULT_STAT_FORCED 0x40000000 // Forced Hard Fault +#define NVIC_HFAULT_STAT_VECT 0x00000002 // Vector Table Read Fault + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DEBUG_STAT +// register. +// +//***************************************************************************** +#define NVIC_DEBUG_STAT_EXTRNL 0x00000010 // EDBGRQ asserted +#define NVIC_DEBUG_STAT_VCATCH 0x00000008 // Vector catch +#define NVIC_DEBUG_STAT_DWTTRAP 0x00000004 // DWT match +#define NVIC_DEBUG_STAT_BKPT 0x00000002 // Breakpoint instruction +#define NVIC_DEBUG_STAT_HALTED 0x00000001 // Halt request + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MM_ADDR register. +// +//***************************************************************************** +#define NVIC_MM_ADDR_M 0xFFFFFFFF // Fault Address +#define NVIC_MM_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_FAULT_ADDR +// register. +// +//***************************************************************************** +#define NVIC_FAULT_ADDR_M 0xFFFFFFFF // Fault Address +#define NVIC_FAULT_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_TYPE register. +// +//***************************************************************************** +#define NVIC_MPU_TYPE_IREGION_M 0x00FF0000 // Number of I Regions +#define NVIC_MPU_TYPE_DREGION_M 0x0000FF00 // Number of D Regions +#define NVIC_MPU_TYPE_SEPARATE 0x00000001 // Separate or Unified MPU +#define NVIC_MPU_TYPE_IREGION_S 16 +#define NVIC_MPU_TYPE_DREGION_S 8 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_CTRL register. +// +//***************************************************************************** +#define NVIC_MPU_CTRL_PRIVDEFEN 0x00000004 // MPU Default Region +#define NVIC_MPU_CTRL_HFNMIENA 0x00000002 // MPU Enabled During Faults +#define NVIC_MPU_CTRL_ENABLE 0x00000001 // MPU Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_NUMBER +// register. +// +//***************************************************************************** +#define NVIC_MPU_NUMBER_M 0x00000007 // MPU Region to Access +#define NVIC_MPU_NUMBER_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_BASE register. +// +//***************************************************************************** +#define NVIC_MPU_BASE_ADDR_M 0xFFFFFFE0 // Base Address Mask +#define NVIC_MPU_BASE_VALID 0x00000010 // Region Number Valid +#define NVIC_MPU_BASE_REGION_M 0x00000007 // Region Number +#define NVIC_MPU_BASE_ADDR_S 5 +#define NVIC_MPU_BASE_REGION_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_ATTR register. +// +//***************************************************************************** +#define NVIC_MPU_ATTR_M 0xFFFF0000 // Attributes +#define NVIC_MPU_ATTR_XN 0x10000000 // Instruction Access Disable +#define NVIC_MPU_ATTR_AP_M 0x07000000 // Access Privilege +#define NVIC_MPU_ATTR_AP_NO_NO 0x00000000 // prv: no access, usr: no access +#define NVIC_MPU_ATTR_AP_RW_NO 0x01000000 // prv: rw, usr: none +#define NVIC_MPU_ATTR_AP_RW_RO 0x02000000 // prv: rw, usr: read-only +#define NVIC_MPU_ATTR_AP_RW_RW 0x03000000 // prv: rw, usr: rw +#define NVIC_MPU_ATTR_AP_RO_NO 0x05000000 // prv: ro, usr: none +#define NVIC_MPU_ATTR_AP_RO_RO 0x06000000 // prv: ro, usr: ro +#define NVIC_MPU_ATTR_TEX_M 0x00380000 // Type Extension Mask +#define NVIC_MPU_ATTR_SHAREABLE 0x00040000 // Shareable +#define NVIC_MPU_ATTR_CACHEABLE 0x00020000 // Cacheable +#define NVIC_MPU_ATTR_BUFFRABLE 0x00010000 // Bufferable +#define NVIC_MPU_ATTR_SRD_M 0x0000FF00 // Subregion Disable Bits +#define NVIC_MPU_ATTR_SRD_0 0x00000100 // Sub-region 0 disable +#define NVIC_MPU_ATTR_SRD_1 0x00000200 // Sub-region 1 disable +#define NVIC_MPU_ATTR_SRD_2 0x00000400 // Sub-region 2 disable +#define NVIC_MPU_ATTR_SRD_3 0x00000800 // Sub-region 3 disable +#define NVIC_MPU_ATTR_SRD_4 0x00001000 // Sub-region 4 disable +#define NVIC_MPU_ATTR_SRD_5 0x00002000 // Sub-region 5 disable +#define NVIC_MPU_ATTR_SRD_6 0x00004000 // Sub-region 6 disable +#define NVIC_MPU_ATTR_SRD_7 0x00008000 // Sub-region 7 disable +#define NVIC_MPU_ATTR_SIZE_M 0x0000003E // Region Size Mask +#define NVIC_MPU_ATTR_SIZE_32B 0x00000008 // Region size 32 bytes +#define NVIC_MPU_ATTR_SIZE_64B 0x0000000A // Region size 64 bytes +#define NVIC_MPU_ATTR_SIZE_128B 0x0000000C // Region size 128 bytes +#define NVIC_MPU_ATTR_SIZE_256B 0x0000000E // Region size 256 bytes +#define NVIC_MPU_ATTR_SIZE_512B 0x00000010 // Region size 512 bytes +#define NVIC_MPU_ATTR_SIZE_1K 0x00000012 // Region size 1 Kbytes +#define NVIC_MPU_ATTR_SIZE_2K 0x00000014 // Region size 2 Kbytes +#define NVIC_MPU_ATTR_SIZE_4K 0x00000016 // Region size 4 Kbytes +#define NVIC_MPU_ATTR_SIZE_8K 0x00000018 // Region size 8 Kbytes +#define NVIC_MPU_ATTR_SIZE_16K 0x0000001A // Region size 16 Kbytes +#define NVIC_MPU_ATTR_SIZE_32K 0x0000001C // Region size 32 Kbytes +#define NVIC_MPU_ATTR_SIZE_64K 0x0000001E // Region size 64 Kbytes +#define NVIC_MPU_ATTR_SIZE_128K 0x00000020 // Region size 128 Kbytes +#define NVIC_MPU_ATTR_SIZE_256K 0x00000022 // Region size 256 Kbytes +#define NVIC_MPU_ATTR_SIZE_512K 0x00000024 // Region size 512 Kbytes +#define NVIC_MPU_ATTR_SIZE_1M 0x00000026 // Region size 1 Mbytes +#define NVIC_MPU_ATTR_SIZE_2M 0x00000028 // Region size 2 Mbytes +#define NVIC_MPU_ATTR_SIZE_4M 0x0000002A // Region size 4 Mbytes +#define NVIC_MPU_ATTR_SIZE_8M 0x0000002C // Region size 8 Mbytes +#define NVIC_MPU_ATTR_SIZE_16M 0x0000002E // Region size 16 Mbytes +#define NVIC_MPU_ATTR_SIZE_32M 0x00000030 // Region size 32 Mbytes +#define NVIC_MPU_ATTR_SIZE_64M 0x00000032 // Region size 64 Mbytes +#define NVIC_MPU_ATTR_SIZE_128M 0x00000034 // Region size 128 Mbytes +#define NVIC_MPU_ATTR_SIZE_256M 0x00000036 // Region size 256 Mbytes +#define NVIC_MPU_ATTR_SIZE_512M 0x00000038 // Region size 512 Mbytes +#define NVIC_MPU_ATTR_SIZE_1G 0x0000003A // Region size 1 Gbytes +#define NVIC_MPU_ATTR_SIZE_2G 0x0000003C // Region size 2 Gbytes +#define NVIC_MPU_ATTR_SIZE_4G 0x0000003E // Region size 4 Gbytes +#define NVIC_MPU_ATTR_ENABLE 0x00000001 // Region Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_BASE1 register. +// +//***************************************************************************** +#define NVIC_MPU_BASE1_ADDR_M 0xFFFFFFE0 // Base Address Mask +#define NVIC_MPU_BASE1_VALID 0x00000010 // Region Number Valid +#define NVIC_MPU_BASE1_REGION_M 0x00000007 // Region Number +#define NVIC_MPU_BASE1_ADDR_S 5 +#define NVIC_MPU_BASE1_REGION_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_ATTR1 register. +// +//***************************************************************************** +#define NVIC_MPU_ATTR1_XN 0x10000000 // Instruction Access Disable +#define NVIC_MPU_ATTR1_AP_M 0x07000000 // Access Privilege +#define NVIC_MPU_ATTR1_TEX_M 0x00380000 // Type Extension Mask +#define NVIC_MPU_ATTR1_SHAREABLE \ + 0x00040000 // Shareable +#define NVIC_MPU_ATTR1_CACHEABLE \ + 0x00020000 // Cacheable +#define NVIC_MPU_ATTR1_BUFFRABLE \ + 0x00010000 // Bufferable +#define NVIC_MPU_ATTR1_SRD_M 0x0000FF00 // Subregion Disable Bits +#define NVIC_MPU_ATTR1_SIZE_M 0x0000003E // Region Size Mask +#define NVIC_MPU_ATTR1_ENABLE 0x00000001 // Region Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_BASE2 register. +// +//***************************************************************************** +#define NVIC_MPU_BASE2_ADDR_M 0xFFFFFFE0 // Base Address Mask +#define NVIC_MPU_BASE2_VALID 0x00000010 // Region Number Valid +#define NVIC_MPU_BASE2_REGION_M 0x00000007 // Region Number +#define NVIC_MPU_BASE2_ADDR_S 5 +#define NVIC_MPU_BASE2_REGION_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_ATTR2 register. +// +//***************************************************************************** +#define NVIC_MPU_ATTR2_XN 0x10000000 // Instruction Access Disable +#define NVIC_MPU_ATTR2_AP_M 0x07000000 // Access Privilege +#define NVIC_MPU_ATTR2_TEX_M 0x00380000 // Type Extension Mask +#define NVIC_MPU_ATTR2_SHAREABLE \ + 0x00040000 // Shareable +#define NVIC_MPU_ATTR2_CACHEABLE \ + 0x00020000 // Cacheable +#define NVIC_MPU_ATTR2_BUFFRABLE \ + 0x00010000 // Bufferable +#define NVIC_MPU_ATTR2_SRD_M 0x0000FF00 // Subregion Disable Bits +#define NVIC_MPU_ATTR2_SIZE_M 0x0000003E // Region Size Mask +#define NVIC_MPU_ATTR2_ENABLE 0x00000001 // Region Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_BASE3 register. +// +//***************************************************************************** +#define NVIC_MPU_BASE3_ADDR_M 0xFFFFFFE0 // Base Address Mask +#define NVIC_MPU_BASE3_VALID 0x00000010 // Region Number Valid +#define NVIC_MPU_BASE3_REGION_M 0x00000007 // Region Number +#define NVIC_MPU_BASE3_ADDR_S 5 +#define NVIC_MPU_BASE3_REGION_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_ATTR3 register. +// +//***************************************************************************** +#define NVIC_MPU_ATTR3_XN 0x10000000 // Instruction Access Disable +#define NVIC_MPU_ATTR3_AP_M 0x07000000 // Access Privilege +#define NVIC_MPU_ATTR3_TEX_M 0x00380000 // Type Extension Mask +#define NVIC_MPU_ATTR3_SHAREABLE \ + 0x00040000 // Shareable +#define NVIC_MPU_ATTR3_CACHEABLE \ + 0x00020000 // Cacheable +#define NVIC_MPU_ATTR3_BUFFRABLE \ + 0x00010000 // Bufferable +#define NVIC_MPU_ATTR3_SRD_M 0x0000FF00 // Subregion Disable Bits +#define NVIC_MPU_ATTR3_SIZE_M 0x0000003E // Region Size Mask +#define NVIC_MPU_ATTR3_ENABLE 0x00000001 // Region Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DBG_CTRL register. +// +//***************************************************************************** +#define NVIC_DBG_CTRL_DBGKEY_M 0xFFFF0000 // Debug key mask +#define NVIC_DBG_CTRL_DBGKEY 0xA05F0000 // Debug key +#define NVIC_DBG_CTRL_S_RESET_ST \ + 0x02000000 // Core has reset since last read +#define NVIC_DBG_CTRL_S_RETIRE_ST \ + 0x01000000 // Core has executed insruction + // since last read +#define NVIC_DBG_CTRL_S_LOCKUP 0x00080000 // Core is locked up +#define NVIC_DBG_CTRL_S_SLEEP 0x00040000 // Core is sleeping +#define NVIC_DBG_CTRL_S_HALT 0x00020000 // Core status on halt +#define NVIC_DBG_CTRL_S_REGRDY 0x00010000 // Register read/write available +#define NVIC_DBG_CTRL_C_SNAPSTALL \ + 0x00000020 // Breaks a stalled load/store +#define NVIC_DBG_CTRL_C_MASKINT 0x00000008 // Mask interrupts when stepping +#define NVIC_DBG_CTRL_C_STEP 0x00000004 // Step the core +#define NVIC_DBG_CTRL_C_HALT 0x00000002 // Halt the core +#define NVIC_DBG_CTRL_C_DEBUGEN 0x00000001 // Enable debug + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DBG_XFER register. +// +//***************************************************************************** +#define NVIC_DBG_XFER_REG_WNR 0x00010000 // Write or not read +#define NVIC_DBG_XFER_REG_SEL_M 0x0000001F // Register +#define NVIC_DBG_XFER_REG_R0 0x00000000 // Register R0 +#define NVIC_DBG_XFER_REG_R1 0x00000001 // Register R1 +#define NVIC_DBG_XFER_REG_R2 0x00000002 // Register R2 +#define NVIC_DBG_XFER_REG_R3 0x00000003 // Register R3 +#define NVIC_DBG_XFER_REG_R4 0x00000004 // Register R4 +#define NVIC_DBG_XFER_REG_R5 0x00000005 // Register R5 +#define NVIC_DBG_XFER_REG_R6 0x00000006 // Register R6 +#define NVIC_DBG_XFER_REG_R7 0x00000007 // Register R7 +#define NVIC_DBG_XFER_REG_R8 0x00000008 // Register R8 +#define NVIC_DBG_XFER_REG_R9 0x00000009 // Register R9 +#define NVIC_DBG_XFER_REG_R10 0x0000000A // Register R10 +#define NVIC_DBG_XFER_REG_R11 0x0000000B // Register R11 +#define NVIC_DBG_XFER_REG_R12 0x0000000C // Register R12 +#define NVIC_DBG_XFER_REG_R13 0x0000000D // Register R13 +#define NVIC_DBG_XFER_REG_R14 0x0000000E // Register R14 +#define NVIC_DBG_XFER_REG_R15 0x0000000F // Register R15 +#define NVIC_DBG_XFER_REG_FLAGS 0x00000010 // xPSR/Flags register +#define NVIC_DBG_XFER_REG_MSP 0x00000011 // Main SP +#define NVIC_DBG_XFER_REG_PSP 0x00000012 // Process SP +#define NVIC_DBG_XFER_REG_DSP 0x00000013 // Deep SP +#define NVIC_DBG_XFER_REG_CFBP 0x00000014 // Control/Fault/BasePri/PriMask + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DBG_DATA register. +// +//***************************************************************************** +#define NVIC_DBG_DATA_M 0xFFFFFFFF // Data temporary cache +#define NVIC_DBG_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DBG_INT register. +// +//***************************************************************************** +#define NVIC_DBG_INT_HARDERR 0x00000400 // Debug trap on hard fault +#define NVIC_DBG_INT_INTERR 0x00000200 // Debug trap on interrupt errors +#define NVIC_DBG_INT_BUSERR 0x00000100 // Debug trap on bus error +#define NVIC_DBG_INT_STATERR 0x00000080 // Debug trap on usage fault state +#define NVIC_DBG_INT_CHKERR 0x00000040 // Debug trap on usage fault check +#define NVIC_DBG_INT_NOCPERR 0x00000020 // Debug trap on coprocessor error +#define NVIC_DBG_INT_MMERR 0x00000010 // Debug trap on mem manage fault +#define NVIC_DBG_INT_RESET 0x00000008 // Core reset status +#define NVIC_DBG_INT_RSTPENDCLR 0x00000004 // Clear pending core reset +#define NVIC_DBG_INT_RSTPENDING 0x00000002 // Core reset is pending +#define NVIC_DBG_INT_RSTVCATCH 0x00000001 // Reset vector catch + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SW_TRIG register. +// +//***************************************************************************** +#define NVIC_SW_TRIG_INTID_M 0x0000003F // Interrupt ID +#define NVIC_SW_TRIG_INTID_S 0 + +#endif // __HW_NVIC_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_pwm.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_pwm.h new file mode 100644 index 00000000..a59f3edb --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_pwm.h @@ -0,0 +1,756 @@ +//***************************************************************************** +// +// hw_pwm.h - Defines and Macros for Pulse Width Modulation (PWM) ports. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_PWM_H__ +#define __HW_PWM_H__ + +//***************************************************************************** +// +// The following are defines for the PWM register offsets. +// +//***************************************************************************** +#define PWM_O_CTL 0x00000000 // PWM Master Control +#define PWM_O_SYNC 0x00000004 // PWM Time Base Sync +#define PWM_O_ENABLE 0x00000008 // PWM Output Enable +#define PWM_O_INVERT 0x0000000C // PWM Output Inversion +#define PWM_O_FAULT 0x00000010 // PWM Output Fault +#define PWM_O_INTEN 0x00000014 // PWM Interrupt Enable +#define PWM_O_RIS 0x00000018 // PWM Raw Interrupt Status +#define PWM_O_ISC 0x0000001C // PWM Interrupt Status and Clear +#define PWM_O_STATUS 0x00000020 // PWM Status +#define PWM_O_FAULTVAL 0x00000024 // PWM Fault Condition Value +#define PWM_O_ENUPD 0x00000028 // PWM Enable Update +#define PWM_O_0_CTL 0x00000040 // PWM0 Control +#define PWM_O_0_INTEN 0x00000044 // PWM0 Interrupt and Trigger + // Enable +#define PWM_O_0_RIS 0x00000048 // PWM0 Raw Interrupt Status +#define PWM_O_0_ISC 0x0000004C // PWM0 Interrupt Status and Clear +#define PWM_O_0_LOAD 0x00000050 // PWM0 Load +#define PWM_O_0_COUNT 0x00000054 // PWM0 Counter +#define PWM_O_0_CMPA 0x00000058 // PWM0 Compare A +#define PWM_O_0_CMPB 0x0000005C // PWM0 Compare B +#define PWM_O_0_GENA 0x00000060 // PWM0 Generator A Control +#define PWM_O_0_GENB 0x00000064 // PWM0 Generator B Control +#define PWM_O_0_DBCTL 0x00000068 // PWM0 Dead-Band Control +#define PWM_O_0_DBRISE 0x0000006C // PWM0 Dead-Band Rising-Edge Delay +#define PWM_O_0_DBFALL 0x00000070 // PWM0 Dead-Band + // Falling-Edge-Delay +#define PWM_O_0_FLTSRC0 0x00000074 // PWM0 Fault Source 0 +#define PWM_O_0_FLTSRC1 0x00000078 // PWM0 Fault Source 1 +#define PWM_O_0_MINFLTPER 0x0000007C // PWM0 Minimum Fault Period +#define PWM_O_1_CTL 0x00000080 // PWM1 Control +#define PWM_O_1_INTEN 0x00000084 // PWM1 Interrupt and Trigger + // Enable +#define PWM_O_1_RIS 0x00000088 // PWM1 Raw Interrupt Status +#define PWM_O_1_ISC 0x0000008C // PWM1 Interrupt Status and Clear +#define PWM_O_1_LOAD 0x00000090 // PWM1 Load +#define PWM_O_1_COUNT 0x00000094 // PWM1 Counter +#define PWM_O_1_CMPA 0x00000098 // PWM1 Compare A +#define PWM_O_1_CMPB 0x0000009C // PWM1 Compare B +#define PWM_O_1_GENA 0x000000A0 // PWM1 Generator A Control +#define PWM_O_1_GENB 0x000000A4 // PWM1 Generator B Control +#define PWM_O_1_DBCTL 0x000000A8 // PWM1 Dead-Band Control +#define PWM_O_1_DBRISE 0x000000AC // PWM1 Dead-Band Rising-Edge Delay +#define PWM_O_1_DBFALL 0x000000B0 // PWM1 Dead-Band + // Falling-Edge-Delay +#define PWM_O_1_FLTSRC0 0x000000B4 // PWM1 Fault Source 0 +#define PWM_O_1_FLTSRC1 0x000000B8 // PWM1 Fault Source 1 +#define PWM_O_1_MINFLTPER 0x000000BC // PWM1 Minimum Fault Period +#define PWM_O_2_CTL 0x000000C0 // PWM2 Control +#define PWM_O_2_INTEN 0x000000C4 // PWM2 Interrupt and Trigger + // Enable +#define PWM_O_2_RIS 0x000000C8 // PWM2 Raw Interrupt Status +#define PWM_O_2_ISC 0x000000CC // PWM2 Interrupt Status and Clear +#define PWM_O_2_LOAD 0x000000D0 // PWM2 Load +#define PWM_O_2_COUNT 0x000000D4 // PWM2 Counter +#define PWM_O_2_CMPA 0x000000D8 // PWM2 Compare A +#define PWM_O_2_CMPB 0x000000DC // PWM2 Compare B +#define PWM_O_2_GENA 0x000000E0 // PWM2 Generator A Control +#define PWM_O_2_GENB 0x000000E4 // PWM2 Generator B Control +#define PWM_O_2_DBCTL 0x000000E8 // PWM2 Dead-Band Control +#define PWM_O_2_DBRISE 0x000000EC // PWM2 Dead-Band Rising-Edge Delay +#define PWM_O_2_DBFALL 0x000000F0 // PWM2 Dead-Band + // Falling-Edge-Delay +#define PWM_O_2_FLTSRC0 0x000000F4 // PWM2 Fault Source 0 +#define PWM_O_2_FLTSRC1 0x000000F8 // PWM2 Fault Source 1 +#define PWM_O_2_MINFLTPER 0x000000FC // PWM2 Minimum Fault Period +#define PWM_O_3_CTL 0x00000100 // PWM3 Control +#define PWM_O_3_INTEN 0x00000104 // PWM3 Interrupt and Trigger + // Enable +#define PWM_O_3_RIS 0x00000108 // PWM3 Raw Interrupt Status +#define PWM_O_3_ISC 0x0000010C // PWM3 Interrupt Status and Clear +#define PWM_O_3_LOAD 0x00000110 // PWM3 Load +#define PWM_O_3_COUNT 0x00000114 // PWM3 Counter +#define PWM_O_3_CMPA 0x00000118 // PWM3 Compare A +#define PWM_O_3_CMPB 0x0000011C // PWM3 Compare B +#define PWM_O_3_GENA 0x00000120 // PWM3 Generator A Control +#define PWM_O_3_GENB 0x00000124 // PWM3 Generator B Control +#define PWM_O_3_DBCTL 0x00000128 // PWM3 Dead-Band Control +#define PWM_O_3_DBRISE 0x0000012C // PWM3 Dead-Band Rising-Edge Delay +#define PWM_O_3_DBFALL 0x00000130 // PWM3 Dead-Band + // Falling-Edge-Delay +#define PWM_O_3_FLTSRC0 0x00000134 // PWM3 Fault Source 0 +#define PWM_O_3_FLTSRC1 0x00000138 // PWM3 Fault Source 1 +#define PWM_O_3_MINFLTPER 0x0000013C // PWM3 Minimum Fault Period +#define PWM_O_0_FLTSEN 0x00000800 // PWM0 Fault Pin Logic Sense +#define PWM_O_0_FLTSTAT0 0x00000804 // PWM0 Fault Status 0 +#define PWM_O_0_FLTSTAT1 0x00000808 // PWM0 Fault Status 1 +#define PWM_O_1_FLTSEN 0x00000880 // PWM1 Fault Pin Logic Sense +#define PWM_O_1_FLTSTAT0 0x00000884 // PWM1 Fault Status 0 +#define PWM_O_1_FLTSTAT1 0x00000888 // PWM1 Fault Status 1 +#define PWM_O_2_FLTSEN 0x00000900 // PWM2 Fault Pin Logic Sense +#define PWM_O_2_FLTSTAT0 0x00000904 // PWM2 Fault Status 0 +#define PWM_O_2_FLTSTAT1 0x00000908 // PWM2 Fault Status 1 +#define PWM_O_3_FLTSEN 0x00000980 // PWM3 Fault Pin Logic Sense +#define PWM_O_3_FLTSTAT0 0x00000984 // PWM3 Fault Status 0 +#define PWM_O_3_FLTSTAT1 0x00000988 // PWM3 Fault Status 1 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_CTL register. +// +//***************************************************************************** +#define PWM_CTL_GLOBALSYNC3 0x00000008 // Update PWM Generator 3 +#define PWM_CTL_GLOBALSYNC2 0x00000004 // Update PWM Generator 2 +#define PWM_CTL_GLOBALSYNC1 0x00000002 // Update PWM Generator 1 +#define PWM_CTL_GLOBALSYNC0 0x00000001 // Update PWM Generator 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_SYNC register. +// +//***************************************************************************** +#define PWM_SYNC_SYNC3 0x00000008 // Reset Generator 3 Counter +#define PWM_SYNC_SYNC2 0x00000004 // Reset Generator 2 Counter +#define PWM_SYNC_SYNC1 0x00000002 // Reset Generator 1 Counter +#define PWM_SYNC_SYNC0 0x00000001 // Reset Generator 0 Counter + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_ENABLE register. +// +//***************************************************************************** +#define PWM_ENABLE_PWM7EN 0x00000080 // PWM7 Output Enable +#define PWM_ENABLE_PWM6EN 0x00000040 // PWM6 Output Enable +#define PWM_ENABLE_PWM5EN 0x00000020 // PWM5 Output Enable +#define PWM_ENABLE_PWM4EN 0x00000010 // PWM4 Output Enable +#define PWM_ENABLE_PWM3EN 0x00000008 // PWM3 Output Enable +#define PWM_ENABLE_PWM2EN 0x00000004 // PWM2 Output Enable +#define PWM_ENABLE_PWM1EN 0x00000002 // PWM1 Output Enable +#define PWM_ENABLE_PWM0EN 0x00000001 // PWM0 Output Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_INVERT register. +// +//***************************************************************************** +#define PWM_INVERT_PWM7INV 0x00000080 // Invert PWM7 Signal +#define PWM_INVERT_PWM6INV 0x00000040 // Invert PWM6 Signal +#define PWM_INVERT_PWM5INV 0x00000020 // Invert PWM5 Signal +#define PWM_INVERT_PWM4INV 0x00000010 // Invert PWM4 Signal +#define PWM_INVERT_PWM3INV 0x00000008 // Invert PWM3 Signal +#define PWM_INVERT_PWM2INV 0x00000004 // Invert PWM2 Signal +#define PWM_INVERT_PWM1INV 0x00000002 // Invert PWM1 Signal +#define PWM_INVERT_PWM0INV 0x00000001 // Invert PWM0 Signal + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_FAULT register. +// +//***************************************************************************** +#define PWM_FAULT_FAULT7 0x00000080 // PWM7 Fault +#define PWM_FAULT_FAULT6 0x00000040 // PWM6 Fault +#define PWM_FAULT_FAULT5 0x00000020 // PWM5 Fault +#define PWM_FAULT_FAULT4 0x00000010 // PWM4 Fault +#define PWM_FAULT_FAULT3 0x00000008 // PWM3 Fault +#define PWM_FAULT_FAULT2 0x00000004 // PWM2 Fault +#define PWM_FAULT_FAULT1 0x00000002 // PWM1 Fault +#define PWM_FAULT_FAULT0 0x00000001 // PWM0 Fault + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_INTEN register. +// +//***************************************************************************** +#define PWM_INTEN_INTFAULT3 0x00080000 // Interrupt Fault 3 +#define PWM_INTEN_INTFAULT2 0x00040000 // Interrupt Fault 2 +#define PWM_INTEN_INTFAULT1 0x00020000 // Interrupt Fault 1 +#define PWM_INTEN_INTFAULT 0x00010000 // Fault Interrupt Enable +#define PWM_INTEN_INTFAULT0 0x00010000 // Interrupt Fault 0 +#define PWM_INTEN_INTPWM3 0x00000008 // PWM3 Interrupt Enable +#define PWM_INTEN_INTPWM2 0x00000004 // PWM2 Interrupt Enable +#define PWM_INTEN_INTPWM1 0x00000002 // PWM1 Interrupt Enable +#define PWM_INTEN_INTPWM0 0x00000001 // PWM0 Interrupt Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_RIS register. +// +//***************************************************************************** +#define PWM_RIS_INTFAULT3 0x00080000 // Interrupt Fault PWM 3 +#define PWM_RIS_INTFAULT2 0x00040000 // Interrupt Fault PWM 2 +#define PWM_RIS_INTFAULT1 0x00020000 // Interrupt Fault PWM 1 +#define PWM_RIS_INTFAULT0 0x00010000 // Interrupt Fault PWM 0 +#define PWM_RIS_INTFAULT 0x00010000 // Fault Interrupt Asserted +#define PWM_RIS_INTPWM3 0x00000008 // PWM3 Interrupt Asserted +#define PWM_RIS_INTPWM2 0x00000004 // PWM2 Interrupt Asserted +#define PWM_RIS_INTPWM1 0x00000002 // PWM1 Interrupt Asserted +#define PWM_RIS_INTPWM0 0x00000001 // PWM0 Interrupt Asserted + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_ISC register. +// +//***************************************************************************** +#define PWM_ISC_INTFAULT3 0x00080000 // FAULT3 Interrupt Asserted +#define PWM_ISC_INTFAULT2 0x00040000 // FAULT2 Interrupt Asserted +#define PWM_ISC_INTFAULT1 0x00020000 // FAULT1 Interrupt Asserted +#define PWM_ISC_INTFAULT 0x00010000 // Fault Interrupt Asserted +#define PWM_ISC_INTFAULT0 0x00010000 // FAULT0 Interrupt Asserted +#define PWM_ISC_INTPWM3 0x00000008 // PWM3 Interrupt Status +#define PWM_ISC_INTPWM2 0x00000004 // PWM2 Interrupt Status +#define PWM_ISC_INTPWM1 0x00000002 // PWM1 Interrupt Status +#define PWM_ISC_INTPWM0 0x00000001 // PWM0 Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_STATUS register. +// +//***************************************************************************** +#define PWM_STATUS_FAULT3 0x00000008 // Generator 3 Fault Status +#define PWM_STATUS_FAULT2 0x00000004 // Generator 2 Fault Status +#define PWM_STATUS_FAULT1 0x00000002 // Generator 1 Fault Status +#define PWM_STATUS_FAULT0 0x00000001 // Generator 0 Fault Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_FAULTVAL register. +// +//***************************************************************************** +#define PWM_FAULTVAL_PWM7 0x00000080 // PWM7 Fault Value +#define PWM_FAULTVAL_PWM6 0x00000040 // PWM6 Fault Value +#define PWM_FAULTVAL_PWM5 0x00000020 // PWM5 Fault Value +#define PWM_FAULTVAL_PWM4 0x00000010 // PWM4 Fault Value +#define PWM_FAULTVAL_PWM3 0x00000008 // PWM3 Fault Value +#define PWM_FAULTVAL_PWM2 0x00000004 // PWM2 Fault Value +#define PWM_FAULTVAL_PWM1 0x00000002 // PWM1 Fault Value +#define PWM_FAULTVAL_PWM0 0x00000001 // PWM0 Fault Value + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_ENUPD register. +// +//***************************************************************************** +#define PWM_ENUPD_ENUPD7_M 0x0000C000 // PWM7 Enable Update Mode +#define PWM_ENUPD_ENUPD7_IMM 0x00000000 // Immediate +#define PWM_ENUPD_ENUPD7_LSYNC 0x00008000 // Locally Synchronized +#define PWM_ENUPD_ENUPD7_GSYNC 0x0000C000 // Globally Synchronized +#define PWM_ENUPD_ENUPD6_M 0x00003000 // PWM6 Enable Update Mode +#define PWM_ENUPD_ENUPD6_IMM 0x00000000 // Immediate +#define PWM_ENUPD_ENUPD6_LSYNC 0x00002000 // Locally Synchronized +#define PWM_ENUPD_ENUPD6_GSYNC 0x00003000 // Globally Synchronized +#define PWM_ENUPD_ENUPD5_M 0x00000C00 // PWM5 Enable Update Mode +#define PWM_ENUPD_ENUPD5_IMM 0x00000000 // Immediate +#define PWM_ENUPD_ENUPD5_LSYNC 0x00000800 // Locally Synchronized +#define PWM_ENUPD_ENUPD5_GSYNC 0x00000C00 // Globally Synchronized +#define PWM_ENUPD_ENUPD4_M 0x00000300 // PWM4 Enable Update Mode +#define PWM_ENUPD_ENUPD4_IMM 0x00000000 // Immediate +#define PWM_ENUPD_ENUPD4_LSYNC 0x00000200 // Locally Synchronized +#define PWM_ENUPD_ENUPD4_GSYNC 0x00000300 // Globally Synchronized +#define PWM_ENUPD_ENUPD3_M 0x000000C0 // PWM3 Enable Update Mode +#define PWM_ENUPD_ENUPD3_IMM 0x00000000 // Immediate +#define PWM_ENUPD_ENUPD3_LSYNC 0x00000080 // Locally Synchronized +#define PWM_ENUPD_ENUPD3_GSYNC 0x000000C0 // Globally Synchronized +#define PWM_ENUPD_ENUPD2_M 0x00000030 // PWM2 Enable Update Mode +#define PWM_ENUPD_ENUPD2_IMM 0x00000000 // Immediate +#define PWM_ENUPD_ENUPD2_LSYNC 0x00000020 // Locally Synchronized +#define PWM_ENUPD_ENUPD2_GSYNC 0x00000030 // Globally Synchronized +#define PWM_ENUPD_ENUPD1_M 0x0000000C // PWM1 Enable Update Mode +#define PWM_ENUPD_ENUPD1_IMM 0x00000000 // Immediate +#define PWM_ENUPD_ENUPD1_LSYNC 0x00000008 // Locally Synchronized +#define PWM_ENUPD_ENUPD1_GSYNC 0x0000000C // Globally Synchronized +#define PWM_ENUPD_ENUPD0_M 0x00000003 // PWM0 Enable Update Mode +#define PWM_ENUPD_ENUPD0_IMM 0x00000000 // Immediate +#define PWM_ENUPD_ENUPD0_LSYNC 0x00000002 // Locally Synchronized +#define PWM_ENUPD_ENUPD0_GSYNC 0x00000003 // Globally Synchronized + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_CTL register. +// +//***************************************************************************** +#define PWM_X_CTL_LATCH 0x00040000 // Latch Fault Input +#define PWM_X_CTL_MINFLTPER 0x00020000 // Minimum Fault Period +#define PWM_X_CTL_FLTSRC 0x00010000 // Fault Condition Source +#define PWM_X_CTL_DBFALLUPD_M 0x0000C000 // PWMnDBFALL Update Mode +#define PWM_X_CTL_DBFALLUPD_I 0x00000000 // Immediate +#define PWM_X_CTL_DBFALLUPD_LS 0x00008000 // Locally Synchronized +#define PWM_X_CTL_DBFALLUPD_GS 0x0000C000 // Globally Synchronized +#define PWM_X_CTL_DBRISEUPD_M 0x00003000 // PWMnDBRISE Update Mode +#define PWM_X_CTL_DBRISEUPD_I 0x00000000 // Immediate +#define PWM_X_CTL_DBRISEUPD_LS 0x00002000 // Locally Synchronized +#define PWM_X_CTL_DBRISEUPD_GS 0x00003000 // Globally Synchronized +#define PWM_X_CTL_DBCTLUPD_M 0x00000C00 // PWMnDBCTL Update Mode +#define PWM_X_CTL_DBCTLUPD_I 0x00000000 // Immediate +#define PWM_X_CTL_DBCTLUPD_LS 0x00000800 // Locally Synchronized +#define PWM_X_CTL_DBCTLUPD_GS 0x00000C00 // Globally Synchronized +#define PWM_X_CTL_GENBUPD_M 0x00000300 // PWMnGENB Update Mode +#define PWM_X_CTL_GENBUPD_I 0x00000000 // Immediate +#define PWM_X_CTL_GENBUPD_LS 0x00000200 // Locally Synchronized +#define PWM_X_CTL_GENBUPD_GS 0x00000300 // Globally Synchronized +#define PWM_X_CTL_GENAUPD_M 0x000000C0 // PWMnGENA Update Mode +#define PWM_X_CTL_GENAUPD_I 0x00000000 // Immediate +#define PWM_X_CTL_GENAUPD_LS 0x00000080 // Locally Synchronized +#define PWM_X_CTL_GENAUPD_GS 0x000000C0 // Globally Synchronized +#define PWM_X_CTL_CMPBUPD 0x00000020 // Comparator B Update Mode +#define PWM_X_CTL_CMPAUPD 0x00000010 // Comparator A Update Mode +#define PWM_X_CTL_LOADUPD 0x00000008 // Load Register Update Mode +#define PWM_X_CTL_DEBUG 0x00000004 // Debug Mode +#define PWM_X_CTL_MODE 0x00000002 // Counter Mode +#define PWM_X_CTL_ENABLE 0x00000001 // PWM Block Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_INTEN register. +// +//***************************************************************************** +#define PWM_X_INTEN_TRCMPBD 0x00002000 // Trigger for Counter=PWMnCMPB + // Down +#define PWM_X_INTEN_TRCMPBU 0x00001000 // Trigger for Counter=PWMnCMPB Up +#define PWM_X_INTEN_TRCMPAD 0x00000800 // Trigger for Counter=PWMnCMPA + // Down +#define PWM_X_INTEN_TRCMPAU 0x00000400 // Trigger for Counter=PWMnCMPA Up +#define PWM_X_INTEN_TRCNTLOAD 0x00000200 // Trigger for Counter=PWMnLOAD +#define PWM_X_INTEN_TRCNTZERO 0x00000100 // Trigger for Counter=0 +#define PWM_X_INTEN_INTCMPBD 0x00000020 // Interrupt for Counter=PWMnCMPB + // Down +#define PWM_X_INTEN_INTCMPBU 0x00000010 // Interrupt for Counter=PWMnCMPB + // Up +#define PWM_X_INTEN_INTCMPAD 0x00000008 // Interrupt for Counter=PWMnCMPA + // Down +#define PWM_X_INTEN_INTCMPAU 0x00000004 // Interrupt for Counter=PWMnCMPA + // Up +#define PWM_X_INTEN_INTCNTLOAD 0x00000002 // Interrupt for Counter=PWMnLOAD +#define PWM_X_INTEN_INTCNTZERO 0x00000001 // Interrupt for Counter=0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_RIS register. +// +//***************************************************************************** +#define PWM_X_RIS_INTCMPBD 0x00000020 // Comparator B Down Interrupt + // Status +#define PWM_X_RIS_INTCMPBU 0x00000010 // Comparator B Up Interrupt Status +#define PWM_X_RIS_INTCMPAD 0x00000008 // Comparator A Down Interrupt + // Status +#define PWM_X_RIS_INTCMPAU 0x00000004 // Comparator A Up Interrupt Status +#define PWM_X_RIS_INTCNTLOAD 0x00000002 // Counter=Load Interrupt Status +#define PWM_X_RIS_INTCNTZERO 0x00000001 // Counter=0 Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_ISC register. +// +//***************************************************************************** +#define PWM_X_ISC_INTCMPBD 0x00000020 // Comparator B Down Interrupt +#define PWM_X_ISC_INTCMPBU 0x00000010 // Comparator B Up Interrupt +#define PWM_X_ISC_INTCMPAD 0x00000008 // Comparator A Down Interrupt +#define PWM_X_ISC_INTCMPAU 0x00000004 // Comparator A Up Interrupt +#define PWM_X_ISC_INTCNTLOAD 0x00000002 // Counter=Load Interrupt +#define PWM_X_ISC_INTCNTZERO 0x00000001 // Counter=0 Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_LOAD register. +// +//***************************************************************************** +#define PWM_X_LOAD_M 0x0000FFFF // Counter Load Value +#define PWM_X_LOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_COUNT register. +// +//***************************************************************************** +#define PWM_X_COUNT_M 0x0000FFFF // Counter Value +#define PWM_X_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_CMPA register. +// +//***************************************************************************** +#define PWM_X_CMPA_M 0x0000FFFF // Comparator A Value +#define PWM_X_CMPA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_CMPB register. +// +//***************************************************************************** +#define PWM_X_CMPB_M 0x0000FFFF // Comparator B Value +#define PWM_X_CMPB_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_GENA register. +// +//***************************************************************************** +#define PWM_X_GENA_ACTCMPBD_M 0x00000C00 // Action for Comparator B Down +#define PWM_X_GENA_ACTCMPBD_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENA_ACTCMPBD_INV 0x00000400 // Invert pwmA +#define PWM_X_GENA_ACTCMPBD_ZERO \ + 0x00000800 // Drive pwmA Low +#define PWM_X_GENA_ACTCMPBD_ONE 0x00000C00 // Drive pwmA High +#define PWM_X_GENA_ACTCMPBU_M 0x00000300 // Action for Comparator B Up +#define PWM_X_GENA_ACTCMPBU_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENA_ACTCMPBU_INV 0x00000100 // Invert pwmA +#define PWM_X_GENA_ACTCMPBU_ZERO \ + 0x00000200 // Drive pwmA Low +#define PWM_X_GENA_ACTCMPBU_ONE 0x00000300 // Drive pwmA High +#define PWM_X_GENA_ACTCMPAD_M 0x000000C0 // Action for Comparator A Down +#define PWM_X_GENA_ACTCMPAD_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENA_ACTCMPAD_INV 0x00000040 // Invert pwmA +#define PWM_X_GENA_ACTCMPAD_ZERO \ + 0x00000080 // Drive pwmA Low +#define PWM_X_GENA_ACTCMPAD_ONE 0x000000C0 // Drive pwmA High +#define PWM_X_GENA_ACTCMPAU_M 0x00000030 // Action for Comparator A Up +#define PWM_X_GENA_ACTCMPAU_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENA_ACTCMPAU_INV 0x00000010 // Invert pwmA +#define PWM_X_GENA_ACTCMPAU_ZERO \ + 0x00000020 // Drive pwmA Low +#define PWM_X_GENA_ACTCMPAU_ONE 0x00000030 // Drive pwmA High +#define PWM_X_GENA_ACTLOAD_M 0x0000000C // Action for Counter=LOAD +#define PWM_X_GENA_ACTLOAD_NONE 0x00000000 // Do nothing +#define PWM_X_GENA_ACTLOAD_INV 0x00000004 // Invert pwmA +#define PWM_X_GENA_ACTLOAD_ZERO 0x00000008 // Drive pwmA Low +#define PWM_X_GENA_ACTLOAD_ONE 0x0000000C // Drive pwmA High +#define PWM_X_GENA_ACTZERO_M 0x00000003 // Action for Counter=0 +#define PWM_X_GENA_ACTZERO_NONE 0x00000000 // Do nothing +#define PWM_X_GENA_ACTZERO_INV 0x00000001 // Invert pwmA +#define PWM_X_GENA_ACTZERO_ZERO 0x00000002 // Drive pwmA Low +#define PWM_X_GENA_ACTZERO_ONE 0x00000003 // Drive pwmA High + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_GENB register. +// +//***************************************************************************** +#define PWM_X_GENB_ACTCMPBD_M 0x00000C00 // Action for Comparator B Down +#define PWM_X_GENB_ACTCMPBD_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENB_ACTCMPBD_INV 0x00000400 // Invert pwmB +#define PWM_X_GENB_ACTCMPBD_ZERO \ + 0x00000800 // Drive pwmB Low +#define PWM_X_GENB_ACTCMPBD_ONE 0x00000C00 // Drive pwmB High +#define PWM_X_GENB_ACTCMPBU_M 0x00000300 // Action for Comparator B Up +#define PWM_X_GENB_ACTCMPBU_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENB_ACTCMPBU_INV 0x00000100 // Invert pwmB +#define PWM_X_GENB_ACTCMPBU_ZERO \ + 0x00000200 // Drive pwmB Low +#define PWM_X_GENB_ACTCMPBU_ONE 0x00000300 // Drive pwmB High +#define PWM_X_GENB_ACTCMPAD_M 0x000000C0 // Action for Comparator A Down +#define PWM_X_GENB_ACTCMPAD_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENB_ACTCMPAD_INV 0x00000040 // Invert pwmB +#define PWM_X_GENB_ACTCMPAD_ZERO \ + 0x00000080 // Drive pwmB Low +#define PWM_X_GENB_ACTCMPAD_ONE 0x000000C0 // Drive pwmB High +#define PWM_X_GENB_ACTCMPAU_M 0x00000030 // Action for Comparator A Up +#define PWM_X_GENB_ACTCMPAU_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENB_ACTCMPAU_INV 0x00000010 // Invert pwmB +#define PWM_X_GENB_ACTCMPAU_ZERO \ + 0x00000020 // Drive pwmB Low +#define PWM_X_GENB_ACTCMPAU_ONE 0x00000030 // Drive pwmB High +#define PWM_X_GENB_ACTLOAD_M 0x0000000C // Action for Counter=LOAD +#define PWM_X_GENB_ACTLOAD_NONE 0x00000000 // Do nothing +#define PWM_X_GENB_ACTLOAD_INV 0x00000004 // Invert pwmB +#define PWM_X_GENB_ACTLOAD_ZERO 0x00000008 // Drive pwmB Low +#define PWM_X_GENB_ACTLOAD_ONE 0x0000000C // Drive pwmB High +#define PWM_X_GENB_ACTZERO_M 0x00000003 // Action for Counter=0 +#define PWM_X_GENB_ACTZERO_NONE 0x00000000 // Do nothing +#define PWM_X_GENB_ACTZERO_INV 0x00000001 // Invert pwmB +#define PWM_X_GENB_ACTZERO_ZERO 0x00000002 // Drive pwmB Low +#define PWM_X_GENB_ACTZERO_ONE 0x00000003 // Drive pwmB High + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_DBCTL register. +// +//***************************************************************************** +#define PWM_X_DBCTL_ENABLE 0x00000001 // Dead-Band Generator Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_DBRISE register. +// +//***************************************************************************** +#define PWM_X_DBRISE_DELAY_M 0x00000FFF // Dead-Band Rise Delay +#define PWM_X_DBRISE_DELAY_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_DBFALL register. +// +//***************************************************************************** +#define PWM_X_DBFALL_DELAY_M 0x00000FFF // Dead-Band Fall Delay +#define PWM_X_DBFALL_DELAY_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_FLTSRC0 +// register. +// +//***************************************************************************** +#define PWM_X_FLTSRC0_FAULT3 0x00000008 // Fault3 Input +#define PWM_X_FLTSRC0_FAULT2 0x00000004 // Fault2 Input +#define PWM_X_FLTSRC0_FAULT1 0x00000002 // Fault1 Input +#define PWM_X_FLTSRC0_FAULT0 0x00000001 // Fault0 Input + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_FLTSRC1 +// register. +// +//***************************************************************************** +#define PWM_X_FLTSRC1_DCMP7 0x00000080 // Digital Comparator 7 +#define PWM_X_FLTSRC1_DCMP6 0x00000040 // Digital Comparator 6 +#define PWM_X_FLTSRC1_DCMP5 0x00000020 // Digital Comparator 5 +#define PWM_X_FLTSRC1_DCMP4 0x00000010 // Digital Comparator 4 +#define PWM_X_FLTSRC1_DCMP3 0x00000008 // Digital Comparator 3 +#define PWM_X_FLTSRC1_DCMP2 0x00000004 // Digital Comparator 2 +#define PWM_X_FLTSRC1_DCMP1 0x00000002 // Digital Comparator 1 +#define PWM_X_FLTSRC1_DCMP0 0x00000001 // Digital Comparator 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_MINFLTPER +// register. +// +//***************************************************************************** +#define PWM_X_MINFLTPER_M 0x0000FFFF // Minimum Fault Period +#define PWM_X_MINFLTPER_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_FLTSEN register. +// +//***************************************************************************** +#define PWM_X_FLTSEN_FAULT3 0x00000008 // Fault3 Sense +#define PWM_X_FLTSEN_FAULT2 0x00000004 // Fault2 Sense +#define PWM_X_FLTSEN_FAULT1 0x00000002 // Fault1 Sense +#define PWM_X_FLTSEN_FAULT0 0x00000001 // Fault0 Sense + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_FLTSTAT0 +// register. +// +//***************************************************************************** +#define PWM_X_FLTSTAT0_FAULT3 0x00000008 // Fault Input 3 +#define PWM_X_FLTSTAT0_FAULT2 0x00000004 // Fault Input 2 +#define PWM_X_FLTSTAT0_FAULT1 0x00000002 // Fault Input 1 +#define PWM_X_FLTSTAT0_FAULT0 0x00000001 // Fault Input 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_FLTSTAT1 +// register. +// +//***************************************************************************** +#define PWM_X_FLTSTAT1_DCMP7 0x00000080 // Digital Comparator 7 Trigger +#define PWM_X_FLTSTAT1_DCMP6 0x00000040 // Digital Comparator 6 Trigger +#define PWM_X_FLTSTAT1_DCMP5 0x00000020 // Digital Comparator 5 Trigger +#define PWM_X_FLTSTAT1_DCMP4 0x00000010 // Digital Comparator 4 Trigger +#define PWM_X_FLTSTAT1_DCMP3 0x00000008 // Digital Comparator 3 Trigger +#define PWM_X_FLTSTAT1_DCMP2 0x00000004 // Digital Comparator 2 Trigger +#define PWM_X_FLTSTAT1_DCMP1 0x00000002 // Digital Comparator 1 Trigger +#define PWM_X_FLTSTAT1_DCMP0 0x00000001 // Digital Comparator 0 Trigger + +//***************************************************************************** +// +// The following are defines for the PWM Generator standard offsets. +// +//***************************************************************************** +#define PWM_O_X_CTL 0x00000000 // Gen Control Reg +#define PWM_O_X_INTEN 0x00000004 // Gen Int/Trig Enable Reg +#define PWM_O_X_RIS 0x00000008 // Gen Raw Int Status Reg +#define PWM_O_X_ISC 0x0000000C // Gen Int Status Reg +#define PWM_O_X_LOAD 0x00000010 // Gen Load Reg +#define PWM_O_X_COUNT 0x00000014 // Gen Counter Reg +#define PWM_O_X_CMPA 0x00000018 // Gen Compare A Reg +#define PWM_O_X_CMPB 0x0000001C // Gen Compare B Reg +#define PWM_O_X_GENA 0x00000020 // Gen Generator A Ctrl Reg +#define PWM_O_X_GENB 0x00000024 // Gen Generator B Ctrl Reg +#define PWM_O_X_DBCTL 0x00000028 // Gen Dead Band Ctrl Reg +#define PWM_O_X_DBRISE 0x0000002C // Gen DB Rising Edge Delay Reg +#define PWM_O_X_DBFALL 0x00000030 // Gen DB Falling Edge Delay Reg +#define PWM_O_X_FLTSRC0 0x00000034 // Fault pin, comparator condition +#define PWM_O_X_FLTSRC1 0x00000038 // Digital comparator condition +#define PWM_O_X_MINFLTPER 0x0000003C // Fault minimum period extension +#define PWM_GEN_0_OFFSET 0x00000040 // PWM0 base +#define PWM_GEN_1_OFFSET 0x00000080 // PWM1 base +#define PWM_GEN_2_OFFSET 0x000000C0 // PWM2 base +#define PWM_GEN_3_OFFSET 0x00000100 // PWM3 base + +//***************************************************************************** +// +// The following are defines for the PWM Generator extended offsets. +// +//***************************************************************************** +#define PWM_O_X_FLTSEN 0x00000000 // Fault logic sense +#define PWM_O_X_FLTSTAT0 0x00000004 // Pin and comparator status +#define PWM_O_X_FLTSTAT1 0x00000008 // Digital comparator status +#define PWM_EXT_0_OFFSET 0x00000800 // PWM0 extended base +#define PWM_EXT_1_OFFSET 0x00000880 // PWM1 extended base +#define PWM_EXT_2_OFFSET 0x00000900 // PWM2 extended base +#define PWM_EXT_3_OFFSET 0x00000980 // PWM3 extended base + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the PWM_O_CTL +// register. +// +//***************************************************************************** +#define PWM_CTL_GLOBAL_SYNC2 0x00000004 // Global sync generator 2 +#define PWM_CTL_GLOBAL_SYNC1 0x00000002 // Global sync generator 1 +#define PWM_CTL_GLOBAL_SYNC0 0x00000001 // Global sync generator 0 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the PWM_O_STATUS +// register. +// +//***************************************************************************** +#define PWM_STATUS_FAULT 0x00000001 // Fault Interrupt Status + +//***************************************************************************** +// +// The following are deprecated defines for the PWM Interrupt Register bit +// definitions. +// +//***************************************************************************** +#define PWM_INT_INTFAULT 0x00010000 // Fault interrupt pending + +//***************************************************************************** +// +// The following are deprecated defines for the PWM_X Interrupt Status Register +// bit definitions. +// +//***************************************************************************** +#define PWM_X_INT_INTCMPBD 0x00000020 // PWM_X_COUNT = PWM_X_CMPB D rcvd +#define PWM_X_INT_INTCMPBU 0x00000010 // PWM_X_COUNT = PWM_X_CMPB U rcvd +#define PWM_X_INT_INTCMPAD 0x00000008 // PWM_X_COUNT = PWM_X_CMPA D rcvd +#define PWM_X_INT_INTCMPAU 0x00000004 // PWM_X_COUNT = PWM_X_CMPA U rcvd +#define PWM_X_INT_INTCNTLOAD 0x00000002 // PWM_X_COUNT = PWM_X_LOAD rcvd +#define PWM_X_INT_INTCNTZERO 0x00000001 // PWM_X_COUNT = 0 received + +//***************************************************************************** +// +// The following are deprecated defines for the PWM_X Generator A/B Control +// Register bit definitions. +// +//***************************************************************************** +#define PWM_X_GEN_Y_ACTCMPBD 0x00000C00 // Act PWM_X_COUNT = PWM_X_CMPB D +#define PWM_X_GEN_Y_ACTCMPBU 0x00000300 // Act PWM_X_COUNT = PWM_X_CMPB U +#define PWM_X_GEN_Y_ACTCMPAD 0x000000C0 // Act PWM_X_COUNT = PWM_X_CMPA D +#define PWM_X_GEN_Y_ACTCMPAU 0x00000030 // Act PWM_X_COUNT = PWM_X_CMPA U +#define PWM_X_GEN_Y_ACTLOAD 0x0000000C // Act PWM_X_COUNT = PWM_X_LOAD +#define PWM_X_GEN_Y_ACTZERO 0x00000003 // Act PWM_X_COUNT = 0 + +//***************************************************************************** +// +// The following are deprecated defines for the PWM_X Generator A/B Control +// Register action definitions. +// +//***************************************************************************** +#define PWM_GEN_ACT_ONE 0x00000003 // Set the output signal to one +#define PWM_GEN_ACT_ZERO 0x00000002 // Set the output signal to zero +#define PWM_GEN_ACT_INV 0x00000001 // Invert the output signal +#define PWM_GEN_ACT_NONE 0x00000000 // Do nothing +#define PWM_GEN_ACT_B_DN_SHIFT 10 // Shift amount for the B dn action +#define PWM_GEN_ACT_B_UP_SHIFT 8 // Shift amount for the B up action +#define PWM_GEN_ACT_A_DN_SHIFT 6 // Shift amount for the A dn action +#define PWM_GEN_ACT_A_UP_SHIFT 4 // Shift amount for the A up action +#define PWM_GEN_ACT_LOAD_SHIFT 2 // Shift amount for the load action +#define PWM_GEN_ACT_ZERO_SHIFT 0 // Shift amount for the zero action + +//***************************************************************************** +// +// The following are deprecated defines for the PWM_X Dead Band Control +// Register bit definitions. +// +//***************************************************************************** +#define PWM_DBCTL_ENABLE 0x00000001 // Enable dead band insertion + +//***************************************************************************** +// +// The following are deprecated defines for the PWM Register reset values. +// +//***************************************************************************** +#define PWM_RV_X_DBCTL 0x00000000 // Control the dead band generator +#define PWM_RV_STATUS 0x00000000 // Status +#define PWM_RV_X_ISC 0x00000000 // Interrupt status and clearing +#define PWM_RV_X_RIS 0x00000000 // Raw interrupt status +#define PWM_RV_X_CTL 0x00000000 // Master control of the PWM + // generator block +#define PWM_RV_SYNC 0x00000000 // Counter synch for PWM generators +#define PWM_RV_X_DBFALL 0x00000000 // The dead band falling edge delay + // count +#define PWM_RV_X_INTEN 0x00000000 // Interrupt and trigger enable +#define PWM_RV_X_LOAD 0x00000000 // The load value for the counter +#define PWM_RV_X_GENA 0x00000000 // Controls PWM generator A +#define PWM_RV_CTL 0x00000000 // Master control of the PWM module +#define PWM_RV_FAULT 0x00000000 // Fault handling for the PWM + // output pins +#define PWM_RV_RIS 0x00000000 // Raw interrupt status +#define PWM_RV_X_CMPA 0x00000000 // The comparator A value +#define PWM_RV_INVERT 0x00000000 // Inversion control for PWM output + // pins +#define PWM_RV_X_DBRISE 0x00000000 // The dead band rising edge delay + // count +#define PWM_RV_ENABLE 0x00000000 // Master enable for the PWM output + // pins +#define PWM_RV_X_GENB 0x00000000 // Controls PWM generator B +#define PWM_RV_X_CMPB 0x00000000 // The comparator B value +#define PWM_RV_ISC 0x00000000 // Interrupt status and clearing +#define PWM_RV_INTEN 0x00000000 // Interrupt enable +#define PWM_RV_X_COUNT 0x00000000 // The current counter value + +#endif + +#endif // __HW_PWM_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_qei.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_qei.h new file mode 100644 index 00000000..2b6dbd54 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_qei.h @@ -0,0 +1,201 @@ +//***************************************************************************** +// +// hw_qei.h - Macros used when accessing the QEI hardware. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_QEI_H__ +#define __HW_QEI_H__ + +//***************************************************************************** +// +// The following are defines for the QEI register offsets. +// +//***************************************************************************** +#define QEI_O_CTL 0x00000000 // QEI Control +#define QEI_O_STAT 0x00000004 // QEI Status +#define QEI_O_POS 0x00000008 // QEI Position +#define QEI_O_MAXPOS 0x0000000C // QEI Maximum Position +#define QEI_O_LOAD 0x00000010 // QEI Timer Load +#define QEI_O_TIME 0x00000014 // QEI Timer +#define QEI_O_COUNT 0x00000018 // QEI Velocity Counter +#define QEI_O_SPEED 0x0000001C // QEI Velocity +#define QEI_O_INTEN 0x00000020 // QEI Interrupt Enable +#define QEI_O_RIS 0x00000024 // QEI Raw Interrupt Status +#define QEI_O_ISC 0x00000028 // QEI Interrupt Status and Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_CTL register. +// +//***************************************************************************** +#define QEI_CTL_FILTCNT_M 0x000F0000 // Input Filter Prescale Count +#define QEI_CTL_FILTEN 0x00002000 // Enable Input Filter +#define QEI_CTL_STALLEN 0x00001000 // Stall QEI +#define QEI_CTL_INVI 0x00000800 // Invert Index Pulse +#define QEI_CTL_INVB 0x00000400 // Invert PhB +#define QEI_CTL_INVA 0x00000200 // Invert PhA +#define QEI_CTL_VELDIV_M 0x000001C0 // Predivide Velocity +#define QEI_CTL_VELDIV_1 0x00000000 // QEI clock /1 +#define QEI_CTL_VELDIV_2 0x00000040 // QEI clock /2 +#define QEI_CTL_VELDIV_4 0x00000080 // QEI clock /4 +#define QEI_CTL_VELDIV_8 0x000000C0 // QEI clock /8 +#define QEI_CTL_VELDIV_16 0x00000100 // QEI clock /16 +#define QEI_CTL_VELDIV_32 0x00000140 // QEI clock /32 +#define QEI_CTL_VELDIV_64 0x00000180 // QEI clock /64 +#define QEI_CTL_VELDIV_128 0x000001C0 // QEI clock /128 +#define QEI_CTL_VELEN 0x00000020 // Capture Velocity +#define QEI_CTL_RESMODE 0x00000010 // Reset Mode +#define QEI_CTL_CAPMODE 0x00000008 // Capture Mode +#define QEI_CTL_SIGMODE 0x00000004 // Signal Mode +#define QEI_CTL_SWAP 0x00000002 // Swap Signals +#define QEI_CTL_ENABLE 0x00000001 // Enable QEI +#define QEI_CTL_FILTCNT_S 16 + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_STAT register. +// +//***************************************************************************** +#define QEI_STAT_DIRECTION 0x00000002 // Direction of Rotation +#define QEI_STAT_ERROR 0x00000001 // Error Detected + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_POS register. +// +//***************************************************************************** +#define QEI_POS_M 0xFFFFFFFF // Current Position Integrator + // Value +#define QEI_POS_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_MAXPOS register. +// +//***************************************************************************** +#define QEI_MAXPOS_M 0xFFFFFFFF // Maximum Position Integrator + // Value +#define QEI_MAXPOS_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_LOAD register. +// +//***************************************************************************** +#define QEI_LOAD_M 0xFFFFFFFF // Velocity Timer Load Value +#define QEI_LOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_TIME register. +// +//***************************************************************************** +#define QEI_TIME_M 0xFFFFFFFF // Velocity Timer Current Value +#define QEI_TIME_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_COUNT register. +// +//***************************************************************************** +#define QEI_COUNT_M 0xFFFFFFFF // Velocity Pulse Count +#define QEI_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_SPEED register. +// +//***************************************************************************** +#define QEI_SPEED_M 0xFFFFFFFF // Velocity +#define QEI_SPEED_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_INTEN register. +// +//***************************************************************************** +#define QEI_INTEN_ERROR 0x00000008 // Phase Error Interrupt Enable +#define QEI_INTEN_DIR 0x00000004 // Direction Change Interrupt + // Enable +#define QEI_INTEN_TIMER 0x00000002 // Timer Expires Interrupt Enable +#define QEI_INTEN_INDEX 0x00000001 // Index Pulse Detected Interrupt + // Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_RIS register. +// +//***************************************************************************** +#define QEI_RIS_ERROR 0x00000008 // Phase Error Detected +#define QEI_RIS_DIR 0x00000004 // Direction Change Detected +#define QEI_RIS_TIMER 0x00000002 // Velocity Timer Expired +#define QEI_RIS_INDEX 0x00000001 // Index Pulse Asserted + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_ISC register. +// +//***************************************************************************** +#define QEI_ISC_ERROR 0x00000008 // Phase Error Interrupt +#define QEI_ISC_DIR 0x00000004 // Direction Change Interrupt +#define QEI_ISC_TIMER 0x00000002 // Velocity Timer Expired Interrupt +#define QEI_ISC_INDEX 0x00000001 // Index Pulse Interrupt + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the QEI_ISC +// register. +// +//***************************************************************************** +#define QEI_INT_ERROR 0x00000008 // Phase error detected +#define QEI_INT_DIR 0x00000004 // Direction change +#define QEI_INT_TIMER 0x00000002 // Velocity timer expired +#define QEI_INT_INDEX 0x00000001 // Index pulse detected + +//***************************************************************************** +// +// The following are deprecated defines for the reset values for the QEI +// registers. +// +//***************************************************************************** +#define QEI_RV_POS 0x00000000 // Current position register +#define QEI_RV_LOAD 0x00000000 // Velocity timer load register +#define QEI_RV_CTL 0x00000000 // Configuration and control reg +#define QEI_RV_RIS 0x00000000 // Raw interrupt status register +#define QEI_RV_ISC 0x00000000 // Interrupt status register +#define QEI_RV_SPEED 0x00000000 // Velocity speed register +#define QEI_RV_INTEN 0x00000000 // Interrupt enable register +#define QEI_RV_STAT 0x00000000 // Status register +#define QEI_RV_COUNT 0x00000000 // Velocity pulse count register +#define QEI_RV_MAXPOS 0x00000000 // Maximum position register +#define QEI_RV_TIME 0x00000000 // Velocity timer register + +#endif + +#endif // __HW_QEI_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_ssi.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_ssi.h new file mode 100644 index 00000000..22706961 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_ssi.h @@ -0,0 +1,217 @@ +//***************************************************************************** +// +// hw_ssi.h - Macros used when accessing the SSI hardware. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_SSI_H__ +#define __HW_SSI_H__ + +//***************************************************************************** +// +// The following are defines for the SSI register offsets. +// +//***************************************************************************** +#define SSI_O_CR0 0x00000000 // SSI Control 0 +#define SSI_O_CR1 0x00000004 // SSI Control 1 +#define SSI_O_DR 0x00000008 // SSI Data +#define SSI_O_SR 0x0000000C // SSI Status +#define SSI_O_CPSR 0x00000010 // SSI Clock Prescale +#define SSI_O_IM 0x00000014 // SSI Interrupt Mask +#define SSI_O_RIS 0x00000018 // SSI Raw Interrupt Status +#define SSI_O_MIS 0x0000001C // SSI Masked Interrupt Status +#define SSI_O_ICR 0x00000020 // SSI Interrupt Clear +#define SSI_O_DMACTL 0x00000024 // SSI DMA Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_CR0 register. +// +//***************************************************************************** +#define SSI_CR0_SCR_M 0x0000FF00 // SSI Serial Clock Rate +#define SSI_CR0_SPH 0x00000080 // SSI Serial Clock Phase +#define SSI_CR0_SPO 0x00000040 // SSI Serial Clock Polarity +#define SSI_CR0_FRF_M 0x00000030 // SSI Frame Format Select +#define SSI_CR0_FRF_MOTO 0x00000000 // Freescale SPI Frame Format +#define SSI_CR0_FRF_TI 0x00000010 // Texas Instruments Synchronous + // Serial Frame Format +#define SSI_CR0_FRF_NMW 0x00000020 // MICROWIRE Frame Format +#define SSI_CR0_DSS_M 0x0000000F // SSI Data Size Select +#define SSI_CR0_DSS_4 0x00000003 // 4-bit data +#define SSI_CR0_DSS_5 0x00000004 // 5-bit data +#define SSI_CR0_DSS_6 0x00000005 // 6-bit data +#define SSI_CR0_DSS_7 0x00000006 // 7-bit data +#define SSI_CR0_DSS_8 0x00000007 // 8-bit data +#define SSI_CR0_DSS_9 0x00000008 // 9-bit data +#define SSI_CR0_DSS_10 0x00000009 // 10-bit data +#define SSI_CR0_DSS_11 0x0000000A // 11-bit data +#define SSI_CR0_DSS_12 0x0000000B // 12-bit data +#define SSI_CR0_DSS_13 0x0000000C // 13-bit data +#define SSI_CR0_DSS_14 0x0000000D // 14-bit data +#define SSI_CR0_DSS_15 0x0000000E // 15-bit data +#define SSI_CR0_DSS_16 0x0000000F // 16-bit data +#define SSI_CR0_SCR_S 8 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_CR1 register. +// +//***************************************************************************** +#define SSI_CR1_EOT 0x00000010 // End of Transmission +#define SSI_CR1_SOD 0x00000008 // SSI Slave Mode Output Disable +#define SSI_CR1_MS 0x00000004 // SSI Master/Slave Select +#define SSI_CR1_SSE 0x00000002 // SSI Synchronous Serial Port + // Enable +#define SSI_CR1_LBM 0x00000001 // SSI Loopback Mode + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_DR register. +// +//***************************************************************************** +#define SSI_DR_DATA_M 0x0000FFFF // SSI Receive/Transmit Data +#define SSI_DR_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_SR register. +// +//***************************************************************************** +#define SSI_SR_BSY 0x00000010 // SSI Busy Bit +#define SSI_SR_RFF 0x00000008 // SSI Receive FIFO Full +#define SSI_SR_RNE 0x00000004 // SSI Receive FIFO Not Empty +#define SSI_SR_TNF 0x00000002 // SSI Transmit FIFO Not Full +#define SSI_SR_TFE 0x00000001 // SSI Transmit FIFO Empty + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_CPSR register. +// +//***************************************************************************** +#define SSI_CPSR_CPSDVSR_M 0x000000FF // SSI Clock Prescale Divisor +#define SSI_CPSR_CPSDVSR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_IM register. +// +//***************************************************************************** +#define SSI_IM_TXIM 0x00000008 // SSI Transmit FIFO Interrupt Mask +#define SSI_IM_RXIM 0x00000004 // SSI Receive FIFO Interrupt Mask +#define SSI_IM_RTIM 0x00000002 // SSI Receive Time-Out Interrupt + // Mask +#define SSI_IM_RORIM 0x00000001 // SSI Receive Overrun Interrupt + // Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_RIS register. +// +//***************************************************************************** +#define SSI_RIS_TXRIS 0x00000008 // SSI Transmit FIFO Raw Interrupt + // Status +#define SSI_RIS_RXRIS 0x00000004 // SSI Receive FIFO Raw Interrupt + // Status +#define SSI_RIS_RTRIS 0x00000002 // SSI Receive Time-Out Raw + // Interrupt Status +#define SSI_RIS_RORRIS 0x00000001 // SSI Receive Overrun Raw + // Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_MIS register. +// +//***************************************************************************** +#define SSI_MIS_TXMIS 0x00000008 // SSI Transmit FIFO Masked + // Interrupt Status +#define SSI_MIS_RXMIS 0x00000004 // SSI Receive FIFO Masked + // Interrupt Status +#define SSI_MIS_RTMIS 0x00000002 // SSI Receive Time-Out Masked + // Interrupt Status +#define SSI_MIS_RORMIS 0x00000001 // SSI Receive Overrun Masked + // Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_ICR register. +// +//***************************************************************************** +#define SSI_ICR_RTIC 0x00000002 // SSI Receive Time-Out Interrupt + // Clear +#define SSI_ICR_RORIC 0x00000001 // SSI Receive Overrun Interrupt + // Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_DMACTL register. +// +//***************************************************************************** +#define SSI_DMACTL_TXDMAE 0x00000002 // Transmit DMA Enable +#define SSI_DMACTL_RXDMAE 0x00000001 // Receive DMA Enable + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SSI_O_CR0 +// register. +// +//***************************************************************************** +#define SSI_CR0_SCR 0x0000FF00 // Serial clock rate +#define SSI_CR0_FRF_MASK 0x00000030 // Frame format mask +#define SSI_CR0_DSS 0x0000000F // Data size select + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SSI_O_CPSR +// register. +// +//***************************************************************************** +#define SSI_CPSR_CPSDVSR_MASK 0x000000FF // Clock prescale + +//***************************************************************************** +// +// The following are deprecated defines for the SSI controller's FIFO size. +// +//***************************************************************************** +#define TX_FIFO_SIZE (8) // Number of entries in the TX FIFO +#define RX_FIFO_SIZE (8) // Number of entries in the RX FIFO + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the interrupt +// mask set and clear, raw interrupt, masked interrupt, and interrupt clear +// registers. +// +//***************************************************************************** +#define SSI_INT_TXFF 0x00000008 // TX FIFO interrupt +#define SSI_INT_RXFF 0x00000004 // RX FIFO interrupt +#define SSI_INT_RXTO 0x00000002 // RX timeout interrupt +#define SSI_INT_RXOR 0x00000001 // RX overrun interrupt + +#endif + +#endif // __HW_SSI_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_sysctl.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_sysctl.h new file mode 100644 index 00000000..2bcd8c71 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_sysctl.h @@ -0,0 +1,1687 @@ +//***************************************************************************** +// +// hw_sysctl.h - Macros used when accessing the system control hardware. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_SYSCTL_H__ +#define __HW_SYSCTL_H__ + +//***************************************************************************** +// +// The following are defines for the System Control register addresses. +// +//***************************************************************************** +#define SYSCTL_DID0 0x400FE000 // Device Identification 0 +#define SYSCTL_DID1 0x400FE004 // Device Identification 1 +#define SYSCTL_DC0 0x400FE008 // Device Capabilities 0 +#define SYSCTL_DC1 0x400FE010 // Device Capabilities 1 +#define SYSCTL_DC2 0x400FE014 // Device Capabilities 2 +#define SYSCTL_DC3 0x400FE018 // Device Capabilities 3 +#define SYSCTL_DC4 0x400FE01C // Device Capabilities 4 +#define SYSCTL_DC5 0x400FE020 // Device Capabilities 5 +#define SYSCTL_DC6 0x400FE024 // Device Capabilities 6 +#define SYSCTL_DC7 0x400FE028 // Device Capabilities 7 +#define SYSCTL_DC8 0x400FE02C // Device Capabilities 8 ADC + // Channels +#define SYSCTL_PBORCTL 0x400FE030 // Brown-Out Reset Control +#define SYSCTL_LDOPCTL 0x400FE034 // LDO Power Control +#define SYSCTL_SRCR0 0x400FE040 // Software Reset Control 0 +#define SYSCTL_SRCR1 0x400FE044 // Software Reset Control 1 +#define SYSCTL_SRCR2 0x400FE048 // Software Reset Control 2 +#define SYSCTL_RIS 0x400FE050 // Raw Interrupt Status +#define SYSCTL_IMC 0x400FE054 // Interrupt Mask Control +#define SYSCTL_MISC 0x400FE058 // Masked Interrupt Status and + // Clear +#define SYSCTL_RESC 0x400FE05C // Reset Cause +#define SYSCTL_RCC 0x400FE060 // Run-Mode Clock Configuration +#define SYSCTL_PLLCFG 0x400FE064 // XTAL to PLL Translation +#define SYSCTL_GPIOHBCTL 0x400FE06C // GPIO High-Performance Bus + // Control +#define SYSCTL_RCC2 0x400FE070 // Run-Mode Clock Configuration 2 +#define SYSCTL_MOSCCTL 0x400FE07C // Main Oscillator Control +#define SYSCTL_RCGC0 0x400FE100 // Run Mode Clock Gating Control + // Register 0 +#define SYSCTL_RCGC1 0x400FE104 // Run Mode Clock Gating Control + // Register 1 +#define SYSCTL_RCGC2 0x400FE108 // Run Mode Clock Gating Control + // Register 2 +#define SYSCTL_SCGC0 0x400FE110 // Sleep Mode Clock Gating Control + // Register 0 +#define SYSCTL_SCGC1 0x400FE114 // Sleep Mode Clock Gating Control + // Register 1 +#define SYSCTL_SCGC2 0x400FE118 // Sleep Mode Clock Gating Control + // Register 2 +#define SYSCTL_DCGC0 0x400FE120 // Deep Sleep Mode Clock Gating + // Control Register 0 +#define SYSCTL_DCGC1 0x400FE124 // Deep-Sleep Mode Clock Gating + // Control Register 1 +#define SYSCTL_DCGC2 0x400FE128 // Deep Sleep Mode Clock Gating + // Control Register 2 +#define SYSCTL_DSLPCLKCFG 0x400FE144 // Deep Sleep Clock Configuration +#define SYSCTL_PIOSCCAL 0x400FE150 // Precision Internal Oscillator + // Calibration +#define SYSCTL_CLKVCLR 0x400FE150 // Clock Verification Clear +#define SYSCTL_PIOSCSTAT 0x400FE154 // Precision Internal Oscillator + // Statistics +#define SYSCTL_LDOARST 0x400FE160 // Allow Unregulated LDO to Reset + // the Part +#define SYSCTL_I2SMCLKCFG 0x400FE170 // I2S MCLK Configuration +#define SYSCTL_DC9 0x400FE190 // Device Capabilities 9 ADC + // Digital Comparators +#define SYSCTL_NVMSTAT 0x400FE1A0 // Non-Volatile Memory Information + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DID0 register. +// +//***************************************************************************** +#define SYSCTL_DID0_VER_M 0x70000000 // DID0 Version +#define SYSCTL_DID0_VER_0 0x00000000 // Initial DID0 register format + // definition for Stellaris(R) + // Sandstorm-class devices +#define SYSCTL_DID0_VER_1 0x10000000 // Second version of the DID0 + // register format +#define SYSCTL_DID0_CLASS_M 0x00FF0000 // Device Class +#define SYSCTL_DID0_CLASS_SANDSTORM \ + 0x00000000 // Sandstorm-class Device +#define SYSCTL_DID0_CLASS_FURY 0x00010000 // Stellaris(R) Fury-class devices +#define SYSCTL_DID0_CLASS_DUSTDEVIL \ + 0x00030000 // Stellaris(R) DustDevil-class + // devices +#define SYSCTL_DID0_CLASS_TEMPEST \ + 0x00040000 // Stellaris(R) Tempest-class + // microcontrollers +#define SYSCTL_DID0_MAJ_M 0x0000FF00 // Major Revision +#define SYSCTL_DID0_MAJ_REVA 0x00000000 // Revision A (initial device) +#define SYSCTL_DID0_MAJ_REVB 0x00000100 // Revision B (first base layer + // revision) +#define SYSCTL_DID0_MAJ_REVC 0x00000200 // Revision C (second base layer + // revision) +#define SYSCTL_DID0_MIN_M 0x000000FF // Minor Revision +#define SYSCTL_DID0_MIN_0 0x00000000 // Initial device, or a major + // revision update +#define SYSCTL_DID0_MIN_1 0x00000001 // First metal layer change +#define SYSCTL_DID0_MIN_2 0x00000002 // Second metal layer change +#define SYSCTL_DID0_MIN_3 0x00000003 // Minor revision 3 +#define SYSCTL_DID0_MIN_4 0x00000004 // Minor revision 4 +#define SYSCTL_DID0_MIN_5 0x00000005 // Minor revision 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DID1 register. +// +//***************************************************************************** +#define SYSCTL_DID1_VER_M 0xF0000000 // DID1 Version +#define SYSCTL_DID1_VER_0 0x00000000 // Initial DID1 register format + // definition, indicating a + // Stellaris LM3Snnn device +#define SYSCTL_DID1_VER_1 0x10000000 // Second version of the DID1 + // register format +#define SYSCTL_DID1_FAM_M 0x0F000000 // Family +#define SYSCTL_DID1_FAM_STELLARIS \ + 0x00000000 // Stellaris family of + // microcontollers, that is, all + // devices with external part + // numbers starting with LM3S +#define SYSCTL_DID1_PRTNO_M 0x00FF0000 // Part Number +#define SYSCTL_DID1_PRTNO_101 0x00010000 // LM3S101 +#define SYSCTL_DID1_PRTNO_102 0x00020000 // LM3S102 +#define SYSCTL_DID1_PRTNO_300 0x00190000 // LM3S300 +#define SYSCTL_DID1_PRTNO_301 0x00110000 // LM3S301 +#define SYSCTL_DID1_PRTNO_308 0x001A0000 // LM3S308 +#define SYSCTL_DID1_PRTNO_310 0x00120000 // LM3S310 +#define SYSCTL_DID1_PRTNO_315 0x00130000 // LM3S315 +#define SYSCTL_DID1_PRTNO_316 0x00140000 // LM3S316 +#define SYSCTL_DID1_PRTNO_317 0x00170000 // LM3S317 +#define SYSCTL_DID1_PRTNO_328 0x00150000 // LM3S328 +#define SYSCTL_DID1_PRTNO_600 0x002A0000 // LM3S600 +#define SYSCTL_DID1_PRTNO_601 0x00210000 // LM3S601 +#define SYSCTL_DID1_PRTNO_608 0x002B0000 // LM3S608 +#define SYSCTL_DID1_PRTNO_610 0x00220000 // LM3S610 +#define SYSCTL_DID1_PRTNO_611 0x00230000 // LM3S611 +#define SYSCTL_DID1_PRTNO_612 0x00240000 // LM3S612 +#define SYSCTL_DID1_PRTNO_613 0x00250000 // LM3S613 +#define SYSCTL_DID1_PRTNO_615 0x00260000 // LM3S615 +#define SYSCTL_DID1_PRTNO_617 0x00280000 // LM3S617 +#define SYSCTL_DID1_PRTNO_618 0x00290000 // LM3S618 +#define SYSCTL_DID1_PRTNO_628 0x00270000 // LM3S628 +#define SYSCTL_DID1_PRTNO_800 0x00380000 // LM3S800 +#define SYSCTL_DID1_PRTNO_801 0x00310000 // LM3S801 +#define SYSCTL_DID1_PRTNO_808 0x00390000 // LM3S808 +#define SYSCTL_DID1_PRTNO_811 0x00320000 // LM3S811 +#define SYSCTL_DID1_PRTNO_812 0x00330000 // LM3S812 +#define SYSCTL_DID1_PRTNO_815 0x00340000 // LM3S815 +#define SYSCTL_DID1_PRTNO_817 0x00360000 // LM3S817 +#define SYSCTL_DID1_PRTNO_818 0x00370000 // LM3S818 +#define SYSCTL_DID1_PRTNO_828 0x00350000 // LM3S828 +#define SYSCTL_DID1_PRTNO_1110 0x00BF0000 // LM3S1110 +#define SYSCTL_DID1_PRTNO_1133 0x00C30000 // LM3S1133 +#define SYSCTL_DID1_PRTNO_1138 0x00C50000 // LM3S1138 +#define SYSCTL_DID1_PRTNO_1150 0x00C10000 // LM3S1150 +#define SYSCTL_DID1_PRTNO_1162 0x00C40000 // LM3S1162 +#define SYSCTL_DID1_PRTNO_1165 0x00C20000 // LM3S1165 +#define SYSCTL_DID1_PRTNO_1332 0x00C60000 // LM3S1332 +#define SYSCTL_DID1_PRTNO_1435 0x00BC0000 // LM3S1435 +#define SYSCTL_DID1_PRTNO_1439 0x00BA0000 // LM3S1439 +#define SYSCTL_DID1_PRTNO_1512 0x00BB0000 // LM3S1512 +#define SYSCTL_DID1_PRTNO_1538 0x00C70000 // LM3S1538 +#define SYSCTL_DID1_PRTNO_1601 0x00DB0000 // LM3S1601 +#define SYSCTL_DID1_PRTNO_1607 0x00060000 // LM3S1607 +#define SYSCTL_DID1_PRTNO_1608 0x00DA0000 // LM3S1608 +#define SYSCTL_DID1_PRTNO_1620 0x00C00000 // LM3S1620 +#define SYSCTL_DID1_PRTNO_1625 0x00030000 // LM3S1625 +#define SYSCTL_DID1_PRTNO_1626 0x00040000 // LM3S1626 +#define SYSCTL_DID1_PRTNO_1627 0x00050000 // LM3S1627 +#define SYSCTL_DID1_PRTNO_1635 0x00B30000 // LM3S1635 +#define SYSCTL_DID1_PRTNO_1637 0x00BD0000 // LM3S1637 +#define SYSCTL_DID1_PRTNO_1651 0x00B10000 // LM3S1651 +#define SYSCTL_DID1_PRTNO_1751 0x00B90000 // LM3S1751 +#define SYSCTL_DID1_PRTNO_1776 0x00100000 // LM3S1776 +#define SYSCTL_DID1_PRTNO_1811 0x00160000 // LM3S1811 +#define SYSCTL_DID1_PRTNO_1816 0x003D0000 // LM3S1816 +#define SYSCTL_DID1_PRTNO_1850 0x00B40000 // LM3S1850 +#define SYSCTL_DID1_PRTNO_1911 0x00DD0000 // LM3S1911 +#define SYSCTL_DID1_PRTNO_1918 0x00DC0000 // LM3S1918 +#define SYSCTL_DID1_PRTNO_1937 0x00B70000 // LM3S1937 +#define SYSCTL_DID1_PRTNO_1958 0x00BE0000 // LM3S1958 +#define SYSCTL_DID1_PRTNO_1960 0x00B50000 // LM3S1960 +#define SYSCTL_DID1_PRTNO_1968 0x00B80000 // LM3S1968 +#define SYSCTL_DID1_PRTNO_1J11 0x000F0000 // LM3S1J11 +#define SYSCTL_DID1_PRTNO_1J16 0x003C0000 // LM3S1J16 +#define SYSCTL_DID1_PRTNO_1N11 0x000E0000 // LM3S1N11 +#define SYSCTL_DID1_PRTNO_1N16 0x003B0000 // LM3S1N16 +#define SYSCTL_DID1_PRTNO_1P51 0x00B20000 // LM3S1P51 +#define SYSCTL_DID1_PRTNO_1R21 0x009E0000 // LM3S1R21 +#define SYSCTL_DID1_PRTNO_1W16 0x00300000 // LM3S1W16 +#define SYSCTL_DID1_PRTNO_1Z16 0x002F0000 // LM3S1Z16 +#define SYSCTL_DID1_PRTNO_2110 0x00510000 // LM3S2110 +#define SYSCTL_DID1_PRTNO_2139 0x00840000 // LM3S2139 +#define SYSCTL_DID1_PRTNO_2276 0x00390000 // LM3S2276 +#define SYSCTL_DID1_PRTNO_2410 0x00A20000 // LM3S2410 +#define SYSCTL_DID1_PRTNO_2412 0x00590000 // LM3S2412 +#define SYSCTL_DID1_PRTNO_2432 0x00560000 // LM3S2432 +#define SYSCTL_DID1_PRTNO_2533 0x005A0000 // LM3S2533 +#define SYSCTL_DID1_PRTNO_2601 0x00E10000 // LM3S2601 +#define SYSCTL_DID1_PRTNO_2608 0x00E00000 // LM3S2608 +#define SYSCTL_DID1_PRTNO_2616 0x00330000 // LM3S2616 +#define SYSCTL_DID1_PRTNO_2620 0x00570000 // LM3S2620 +#define SYSCTL_DID1_PRTNO_2637 0x00850000 // LM3S2637 +#define SYSCTL_DID1_PRTNO_2651 0x00530000 // LM3S2651 +#define SYSCTL_DID1_PRTNO_2671 0x00800000 // LM3S2671 +#define SYSCTL_DID1_PRTNO_2678 0x00500000 // LM3S2678 +#define SYSCTL_DID1_PRTNO_2730 0x00A40000 // LM3S2730 +#define SYSCTL_DID1_PRTNO_2739 0x00520000 // LM3S2739 +#define SYSCTL_DID1_PRTNO_2776 0x003A0000 // LM3S2776 +#define SYSCTL_DID1_PRTNO_2793 0x006D0000 // LM3S2793 +#define SYSCTL_DID1_PRTNO_2911 0x00E30000 // LM3S2911 +#define SYSCTL_DID1_PRTNO_2918 0x00E20000 // LM3S2918 +#define SYSCTL_DID1_PRTNO_2939 0x00540000 // LM3S2939 +#define SYSCTL_DID1_PRTNO_2948 0x008F0000 // LM3S2948 +#define SYSCTL_DID1_PRTNO_2950 0x00580000 // LM3S2950 +#define SYSCTL_DID1_PRTNO_2965 0x00550000 // LM3S2965 +#define SYSCTL_DID1_PRTNO_2B93 0x006C0000 // LM3S2B93 +#define SYSCTL_DID1_PRTNO_3634 0x00080000 // LM3S3634 +#define SYSCTL_DID1_PRTNO_3651 0x00430000 // LM3S3651 +#define SYSCTL_DID1_PRTNO_3739 0x00440000 // LM3S3739 +#define SYSCTL_DID1_PRTNO_3748 0x00490000 // LM3S3748 +#define SYSCTL_DID1_PRTNO_3749 0x00450000 // LM3S3749 +#define SYSCTL_DID1_PRTNO_3826 0x00420000 // LM3S3826 +#define SYSCTL_DID1_PRTNO_3J26 0x00410000 // LM3S3J26 +#define SYSCTL_DID1_PRTNO_3N26 0x00400000 // LM3S3N26 +#define SYSCTL_DID1_PRTNO_3W26 0x003F0000 // LM3S3W26 +#define SYSCTL_DID1_PRTNO_3Z26 0x003E0000 // LM3S3Z26 +#define SYSCTL_DID1_PRTNO_5632 0x00810000 // LM3S5632 +#define SYSCTL_DID1_PRTNO_5651 0x000C0000 // LM3S5651 +#define SYSCTL_DID1_PRTNO_5652 0x008A0000 // LM3S5652 +#define SYSCTL_DID1_PRTNO_5656 0x004D0000 // LM3S5656 +#define SYSCTL_DID1_PRTNO_5662 0x00910000 // LM3S5662 +#define SYSCTL_DID1_PRTNO_5732 0x00960000 // LM3S5732 +#define SYSCTL_DID1_PRTNO_5737 0x00970000 // LM3S5737 +#define SYSCTL_DID1_PRTNO_5739 0x00A00000 // LM3S5739 +#define SYSCTL_DID1_PRTNO_5747 0x00990000 // LM3S5747 +#define SYSCTL_DID1_PRTNO_5749 0x00A70000 // LM3S5749 +#define SYSCTL_DID1_PRTNO_5752 0x009A0000 // LM3S5752 +#define SYSCTL_DID1_PRTNO_5762 0x009C0000 // LM3S5762 +#define SYSCTL_DID1_PRTNO_5791 0x00690000 // LM3S5791 +#define SYSCTL_DID1_PRTNO_5951 0x000B0000 // LM3S5951 +#define SYSCTL_DID1_PRTNO_5956 0x004E0000 // LM3S5956 +#define SYSCTL_DID1_PRTNO_5B91 0x00680000 // LM3S5B91 +#define SYSCTL_DID1_PRTNO_5K31 0x00090000 // LM3S5K31 +#define SYSCTL_DID1_PRTNO_5K36 0x004A0000 // LM3S5K36 +#define SYSCTL_DID1_PRTNO_5P31 0x000A0000 // LM3S5P31 +#define SYSCTL_DID1_PRTNO_5P36 0x00480000 // LM3S5P36 +#define SYSCTL_DID1_PRTNO_5P51 0x000D0000 // LM3S5P51 +#define SYSCTL_DID1_PRTNO_5P56 0x004C0000 // LM3S5P56 +#define SYSCTL_DID1_PRTNO_5R31 0x00070000 // LM3S5R31 +#define SYSCTL_DID1_PRTNO_5R36 0x004B0000 // LM3S5R36 +#define SYSCTL_DID1_PRTNO_5T36 0x00470000 // LM3S5T36 +#define SYSCTL_DID1_PRTNO_5Y36 0x00460000 // LM3S5Y36 +#define SYSCTL_DID1_PRTNO_6100 0x00A10000 // LM3S6100 +#define SYSCTL_DID1_PRTNO_6110 0x00740000 // LM3S6110 +#define SYSCTL_DID1_PRTNO_6420 0x00A50000 // LM3S6420 +#define SYSCTL_DID1_PRTNO_6422 0x00820000 // LM3S6422 +#define SYSCTL_DID1_PRTNO_6432 0x00750000 // LM3S6432 +#define SYSCTL_DID1_PRTNO_6537 0x00760000 // LM3S6537 +#define SYSCTL_DID1_PRTNO_6610 0x00710000 // LM3S6610 +#define SYSCTL_DID1_PRTNO_6611 0x00E70000 // LM3S6611 +#define SYSCTL_DID1_PRTNO_6618 0x00E60000 // LM3S6618 +#define SYSCTL_DID1_PRTNO_6633 0x00830000 // LM3S6633 +#define SYSCTL_DID1_PRTNO_6637 0x008B0000 // LM3S6637 +#define SYSCTL_DID1_PRTNO_6730 0x00A30000 // LM3S6730 +#define SYSCTL_DID1_PRTNO_6753 0x00770000 // LM3S6753 +#define SYSCTL_DID1_PRTNO_6911 0x00E90000 // LM3S6911 +#define SYSCTL_DID1_PRTNO_6918 0x00E80000 // LM3S6918 +#define SYSCTL_DID1_PRTNO_6938 0x00890000 // LM3S6938 +#define SYSCTL_DID1_PRTNO_6950 0x00720000 // LM3S6950 +#define SYSCTL_DID1_PRTNO_6952 0x00780000 // LM3S6952 +#define SYSCTL_DID1_PRTNO_6965 0x00730000 // LM3S6965 +#define SYSCTL_DID1_PRTNO_8530 0x00640000 // LM3S8530 +#define SYSCTL_DID1_PRTNO_8538 0x008E0000 // LM3S8538 +#define SYSCTL_DID1_PRTNO_8630 0x00610000 // LM3S8630 +#define SYSCTL_DID1_PRTNO_8730 0x00630000 // LM3S8730 +#define SYSCTL_DID1_PRTNO_8733 0x008D0000 // LM3S8733 +#define SYSCTL_DID1_PRTNO_8738 0x00860000 // LM3S8738 +#define SYSCTL_DID1_PRTNO_8930 0x00650000 // LM3S8930 +#define SYSCTL_DID1_PRTNO_8933 0x008C0000 // LM3S8933 +#define SYSCTL_DID1_PRTNO_8938 0x00880000 // LM3S8938 +#define SYSCTL_DID1_PRTNO_8962 0x00A60000 // LM3S8962 +#define SYSCTL_DID1_PRTNO_8970 0x00620000 // LM3S8970 +#define SYSCTL_DID1_PRTNO_8971 0x00D70000 // LM3S8971 +#define SYSCTL_DID1_PRTNO_9790 0x00670000 // LM3S9790 +#define SYSCTL_DID1_PRTNO_9792 0x006B0000 // LM3S9792 +#define SYSCTL_DID1_PRTNO_9997 0x00200000 // LM3S9997 +#define SYSCTL_DID1_PRTNO_9B90 0x00660000 // LM3S9B90 +#define SYSCTL_DID1_PRTNO_9B92 0x006A0000 // LM3S9B92 +#define SYSCTL_DID1_PRTNO_9B95 0x006E0000 // LM3S9B95 +#define SYSCTL_DID1_PRTNO_9B96 0x006F0000 // LM3S9B96 +#define SYSCTL_DID1_PRTNO_9L97 0x00180000 // LM3S9L97 +#define SYSCTL_DID1_PINCNT_M 0x0000E000 // Package Pin Count +#define SYSCTL_DID1_PINCNT_28 0x00000000 // 28 pin package +#define SYSCTL_DID1_PINCNT_48 0x00002000 // 48-pin package +#define SYSCTL_DID1_PINCNT_100 0x00004000 // 100-pin package +#define SYSCTL_DID1_PINCNT_64 0x00006000 // 64-pin package +#define SYSCTL_DID1_TEMP_M 0x000000E0 // Temperature Range +#define SYSCTL_DID1_TEMP_C 0x00000000 // Commercial temperature range (0C + // to 70C) +#define SYSCTL_DID1_TEMP_I 0x00000020 // Industrial temperature range + // (-40C to 85C) +#define SYSCTL_DID1_TEMP_E 0x00000040 // Extended temperature range (-40C + // to 105C) +#define SYSCTL_DID1_PKG_M 0x00000018 // Package Type +#define SYSCTL_DID1_PKG_SOIC 0x00000000 // SOIC package +#define SYSCTL_DID1_PKG_QFP 0x00000008 // LQFP package +#define SYSCTL_DID1_PKG_BGA 0x00000010 // BGA package +#define SYSCTL_DID1_PKG_QFN 0x00000018 // QFN package +#define SYSCTL_DID1_ROHS 0x00000004 // RoHS-Compliance +#define SYSCTL_DID1_QUAL_M 0x00000003 // Qualification Status +#define SYSCTL_DID1_QUAL_ES 0x00000000 // Engineering Sample (unqualified) +#define SYSCTL_DID1_QUAL_PP 0x00000001 // Pilot Production (unqualified) +#define SYSCTL_DID1_QUAL_FQ 0x00000002 // Fully Qualified +#define SYSCTL_DID1_PRTNO_S 16 // Part number shift + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC0 register. +// +//***************************************************************************** +#define SYSCTL_DC0_SRAMSZ_M 0xFFFF0000 // SRAM Size +#define SYSCTL_DC0_SRAMSZ_2KB 0x00070000 // 2 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_4KB 0x000F0000 // 4 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_6KB 0x00170000 // 6 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_8KB 0x001F0000 // 8 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_12KB 0x002F0000 // 12 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_16KB 0x003F0000 // 16 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_20KB 0x004F0000 // 20 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_24KB 0x005F0000 // 24 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_32KB 0x007F0000 // 32 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_64KB 0x00FF0000 // 64 KB of SRAM +#define SYSCTL_DC0_SRAMSZ_96KB 0x017F0000 // 96 KB of SRAM +#define SYSCTL_DC0_FLASHSZ_M 0x0000FFFF // Flash Size +#define SYSCTL_DC0_FLASHSZ_8KB 0x00000003 // 8 KB of Flash +#define SYSCTL_DC0_FLASHSZ_16KB 0x00000007 // 16 KB of Flash +#define SYSCTL_DC0_FLASHSZ_32KB 0x0000000F // 32 KB of Flash +#define SYSCTL_DC0_FLASHSZ_64KB 0x0000001F // 64 KB of Flash +#define SYSCTL_DC0_FLASHSZ_96KB 0x0000002F // 96 KB of Flash +#define SYSCTL_DC0_FLASHSZ_128K 0x0000003F // 128 KB of Flash +#define SYSCTL_DC0_FLASHSZ_256K 0x0000007F // 256 KB of Flash +#define SYSCTL_DC0_SRAMSZ_S 16 // SRAM size shift +#define SYSCTL_DC0_FLASHSZ_S 0 // Flash size shift + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC1 register. +// +//***************************************************************************** +#define SYSCTL_DC1_WDT1 0x10000000 // Watchdog Timer1 Present +#define SYSCTL_DC1_CAN2 0x04000000 // CAN Module 2 Present +#define SYSCTL_DC1_CAN1 0x02000000 // CAN Module 1 Present +#define SYSCTL_DC1_CAN0 0x01000000 // CAN Module 0 Present +#define SYSCTL_DC1_PWM 0x00100000 // PWM Module Present +#define SYSCTL_DC1_ADC1 0x00020000 // ADC Module 1 Present +#define SYSCTL_DC1_ADC0 0x00010000 // ADC Module 0 Present +#define SYSCTL_DC1_MINSYSDIV_M 0x0000F000 // System Clock Divider +#define SYSCTL_DC1_MINSYSDIV_100 \ + 0x00001000 // Divide VCO (400MHZ) by 5 minimum +#define SYSCTL_DC1_MINSYSDIV_66 0x00002000 // Divide VCO (400MHZ) by 2*2 + 2 = + // 6 minimum +#define SYSCTL_DC1_MINSYSDIV_50 0x00003000 // Specifies a 50-MHz CPU clock + // with a PLL divider of 4 +#define SYSCTL_DC1_MINSYSDIV_25 0x00007000 // Specifies a 25-MHz clock with a + // PLL divider of 8 +#define SYSCTL_DC1_MINSYSDIV_20 0x00009000 // Specifies a 20-MHz clock with a + // PLL divider of 10 +#define SYSCTL_DC1_ADCSPD_M 0x00000F00 // Max ADC Speed +#define SYSCTL_DC1_ADCSPD_125K 0x00000000 // 125Ksps ADC +#define SYSCTL_DC1_ADCSPD_250K 0x00000100 // 250K samples/second +#define SYSCTL_DC1_ADCSPD_500K 0x00000200 // 500K samples/second +#define SYSCTL_DC1_ADCSPD_1M 0x00000300 // 1M samples/second +#define SYSCTL_DC1_ADC1SPD_M 0x00000C00 // Max ADC1 Speed +#define SYSCTL_DC1_ADC1SPD_1M 0x00000C00 // 1M samples/second +#define SYSCTL_DC1_ADC0SPD_M 0x00000300 // Max ADC0 Speed +#define SYSCTL_DC1_ADC0SPD_1M 0x00000300 // 1M samples/second +#define SYSCTL_DC1_MPU 0x00000080 // MPU Present +#define SYSCTL_DC1_HIB 0x00000040 // Hibernation Module Present +#define SYSCTL_DC1_TEMP 0x00000020 // Temp Sensor Present +#define SYSCTL_DC1_PLL 0x00000010 // PLL Present +#define SYSCTL_DC1_WDT0 0x00000008 // Watchdog Timer 0 Present +#define SYSCTL_DC1_SWO 0x00000004 // SWO Trace Port Present +#define SYSCTL_DC1_SWD 0x00000002 // SWD Present +#define SYSCTL_DC1_JTAG 0x00000001 // JTAG Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC2 register. +// +//***************************************************************************** +#define SYSCTL_DC2_EPI0 0x40000000 // EPI Module 0 Present +#define SYSCTL_DC2_I2S0 0x10000000 // I2S Module 0 Present +#define SYSCTL_DC2_COMP2 0x04000000 // Analog Comparator 2 Present +#define SYSCTL_DC2_COMP1 0x02000000 // Analog Comparator 1 Present +#define SYSCTL_DC2_COMP0 0x01000000 // Analog Comparator 0 Present +#define SYSCTL_DC2_TIMER3 0x00080000 // Timer Module 3 Present +#define SYSCTL_DC2_TIMER2 0x00040000 // Timer Module 2 Present +#define SYSCTL_DC2_TIMER1 0x00020000 // Timer Module 1 Present +#define SYSCTL_DC2_TIMER0 0x00010000 // Timer Module 0 Present +#define SYSCTL_DC2_I2C1 0x00004000 // I2C Module 1 Present +#define SYSCTL_DC2_I2C0 0x00001000 // I2C Module 0 Present +#define SYSCTL_DC2_QEI1 0x00000200 // QEI Module 1 Present +#define SYSCTL_DC2_QEI0 0x00000100 // QEI Module 0 Present +#define SYSCTL_DC2_SSI1 0x00000020 // SSI Module 1 Present +#define SYSCTL_DC2_SSI0 0x00000010 // SSI Module 0 Present +#define SYSCTL_DC2_UART2 0x00000004 // UART Module 2 Present +#define SYSCTL_DC2_UART1 0x00000002 // UART Module 1 Present +#define SYSCTL_DC2_UART0 0x00000001 // UART Module 0 Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC3 register. +// +//***************************************************************************** +#define SYSCTL_DC3_32KHZ 0x80000000 // 32KHz Input Clock Available +#define SYSCTL_DC3_CCP5 0x20000000 // CCP5 Pin Present +#define SYSCTL_DC3_CCP4 0x10000000 // CCP4 Pin Present +#define SYSCTL_DC3_CCP3 0x08000000 // CCP3 Pin Present +#define SYSCTL_DC3_CCP2 0x04000000 // CCP2 Pin Present +#define SYSCTL_DC3_CCP1 0x02000000 // CCP1 Pin Present +#define SYSCTL_DC3_CCP0 0x01000000 // CCP0 Pin Present +#define SYSCTL_DC3_ADC0AIN7 0x00800000 // ADC Module 0 AIN7 Pin Present +#define SYSCTL_DC3_ADC0AIN6 0x00400000 // ADC Module 0 AIN6 Pin Present +#define SYSCTL_DC3_ADC0AIN5 0x00200000 // ADC Module 0 AIN5 Pin Present +#define SYSCTL_DC3_ADC0AIN4 0x00100000 // ADC Module 0 AIN4 Pin Present +#define SYSCTL_DC3_ADC0AIN3 0x00080000 // ADC Module 0 AIN3 Pin Present +#define SYSCTL_DC3_ADC0AIN2 0x00040000 // ADC Module 0 AIN2 Pin Present +#define SYSCTL_DC3_ADC0AIN1 0x00020000 // ADC Module 0 AIN1 Pin Present +#define SYSCTL_DC3_ADC0AIN0 0x00010000 // ADC Module 0 AIN0 Pin Present +#define SYSCTL_DC3_PWMFAULT 0x00008000 // PWM Fault Pin Present +#define SYSCTL_DC3_C2O 0x00004000 // C2o Pin Present +#define SYSCTL_DC3_C2PLUS 0x00002000 // C2+ Pin Present +#define SYSCTL_DC3_C2MINUS 0x00001000 // C2- Pin Present +#define SYSCTL_DC3_C1O 0x00000800 // C1o Pin Present +#define SYSCTL_DC3_C1PLUS 0x00000400 // C1+ Pin Present +#define SYSCTL_DC3_C1MINUS 0x00000200 // C1- Pin Present +#define SYSCTL_DC3_C0O 0x00000100 // C0o Pin Present +#define SYSCTL_DC3_C0PLUS 0x00000080 // C0+ Pin Present +#define SYSCTL_DC3_C0MINUS 0x00000040 // C0- Pin Present +#define SYSCTL_DC3_PWM5 0x00000020 // PWM5 Pin Present +#define SYSCTL_DC3_PWM4 0x00000010 // PWM4 Pin Present +#define SYSCTL_DC3_PWM3 0x00000008 // PWM3 Pin Present +#define SYSCTL_DC3_PWM2 0x00000004 // PWM2 Pin Present +#define SYSCTL_DC3_PWM1 0x00000002 // PWM1 Pin Present +#define SYSCTL_DC3_PWM0 0x00000001 // PWM0 Pin Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC4 register. +// +//***************************************************************************** +#define SYSCTL_DC4_ETH 0x50000000 // Ethernet present +#define SYSCTL_DC4_EPHY0 0x40000000 // Ethernet PHY Layer 0 Present +#define SYSCTL_DC4_EMAC0 0x10000000 // Ethernet MAC Layer 0 Present +#define SYSCTL_DC4_E1588 0x01000000 // 1588 Capable +#define SYSCTL_DC4_PICAL 0x00040000 // PIOSC Calibrate +#define SYSCTL_DC4_CCP7 0x00008000 // CCP7 Pin Present +#define SYSCTL_DC4_CCP6 0x00004000 // CCP6 Pin Present +#define SYSCTL_DC4_UDMA 0x00002000 // Micro-DMA Module Present +#define SYSCTL_DC4_ROM 0x00001000 // Internal Code ROM Present +#define SYSCTL_DC4_GPIOJ 0x00000100 // GPIO Port J Present +#define SYSCTL_DC4_GPIOH 0x00000080 // GPIO Port H Present +#define SYSCTL_DC4_GPIOG 0x00000040 // GPIO Port G Present +#define SYSCTL_DC4_GPIOF 0x00000020 // GPIO Port F Present +#define SYSCTL_DC4_GPIOE 0x00000010 // GPIO Port E Present +#define SYSCTL_DC4_GPIOD 0x00000008 // GPIO Port D Present +#define SYSCTL_DC4_GPIOC 0x00000004 // GPIO Port C Present +#define SYSCTL_DC4_GPIOB 0x00000002 // GPIO Port B Present +#define SYSCTL_DC4_GPIOA 0x00000001 // GPIO Port A Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC5 register. +// +//***************************************************************************** +#define SYSCTL_DC5_PWMFAULT3 0x08000000 // PWM Fault 3 Pin Present +#define SYSCTL_DC5_PWMFAULT2 0x04000000 // PWM Fault 2 Pin Present +#define SYSCTL_DC5_PWMFAULT1 0x02000000 // PWM Fault 1 Pin Present +#define SYSCTL_DC5_PWMFAULT0 0x01000000 // PWM Fault 0 Pin Present +#define SYSCTL_DC5_PWMEFLT 0x00200000 // PWM Extended Fault Active +#define SYSCTL_DC5_PWMESYNC 0x00100000 // PWM Extended SYNC Active +#define SYSCTL_DC5_PWM7 0x00000080 // PWM7 Pin Present +#define SYSCTL_DC5_PWM6 0x00000040 // PWM6 Pin Present +#define SYSCTL_DC5_PWM5 0x00000020 // PWM5 Pin Present +#define SYSCTL_DC5_PWM4 0x00000010 // PWM4 Pin Present +#define SYSCTL_DC5_PWM3 0x00000008 // PWM3 Pin Present +#define SYSCTL_DC5_PWM2 0x00000004 // PWM2 Pin Present +#define SYSCTL_DC5_PWM1 0x00000002 // PWM1 Pin Present +#define SYSCTL_DC5_PWM0 0x00000001 // PWM0 Pin Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC6 register. +// +//***************************************************************************** +#define SYSCTL_DC6_USB0PHY 0x00000010 // USB Module 0 PHY Present +#define SYSCTL_DC6_USB0_M 0x00000003 // USB Module 0 Present +#define SYSCTL_DC6_USB0_DEV 0x00000001 // USB0 is Device Only +#define SYSCTL_DC6_USB0_HOSTDEV 0x00000002 // USB is Device or Host +#define SYSCTL_DC6_USB0_OTG 0x00000003 // USB0 is OTG + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC7 register. +// +//***************************************************************************** +#define SYSCTL_DC7_SW 0x40000000 // Software transfer on uDMA Ch30 +#define SYSCTL_DC7_DMACH30 0x40000000 // SW +#define SYSCTL_DC7_DMACH29 0x20000000 // I2S0_TX / CAN1_TX +#define SYSCTL_DC7_DMACH28 0x10000000 // I2S0_RX / CAN1_RX +#define SYSCTL_DC7_DMACH27 0x08000000 // CAN1_TX / ADC1_SS3 +#define SYSCTL_DC7_DMACH26 0x04000000 // CAN1_RX / ADC1_SS2 +#define SYSCTL_DC7_DMACH25 0x02000000 // SSI1_TX / ADC1_SS1 +#define SYSCTL_DC7_SSI1_TX 0x02000000 // SSI1 TX on uDMA Ch25 +#define SYSCTL_DC7_SSI1_RX 0x01000000 // SSI1 RX on uDMA Ch24 +#define SYSCTL_DC7_DMACH24 0x01000000 // SSI1_RX / ADC1_SS0 +#define SYSCTL_DC7_UART1_TX 0x00800000 // UART1 TX on uDMA Ch23 +#define SYSCTL_DC7_DMACH23 0x00800000 // UART1_TX / CAN2_TX +#define SYSCTL_DC7_DMACH22 0x00400000 // UART1_RX / CAN2_RX +#define SYSCTL_DC7_UART1_RX 0x00400000 // UART1 RX on uDMA Ch22 +#define SYSCTL_DC7_DMACH21 0x00200000 // Timer1B / EPI0_WFIFO +#define SYSCTL_DC7_DMACH20 0x00100000 // Timer1A / EPI0_NBRFIFO +#define SYSCTL_DC7_DMACH19 0x00080000 // Timer0B / Timer1B +#define SYSCTL_DC7_DMACH18 0x00040000 // Timer0A / Timer1A +#define SYSCTL_DC7_DMACH17 0x00020000 // ADC0_SS3 +#define SYSCTL_DC7_DMACH16 0x00010000 // ADC0_SS2 +#define SYSCTL_DC7_DMACH15 0x00008000 // ADC0_SS1 / Timer2B +#define SYSCTL_DC7_DMACH14 0x00004000 // ADC0_SS0 / Timer2A +#define SYSCTL_DC7_DMACH13 0x00002000 // CAN0_TX / UART2_TX +#define SYSCTL_DC7_DMACH12 0x00001000 // CAN0_RX / UART2_RX +#define SYSCTL_DC7_SSI0_TX 0x00000800 // SSI0 TX on uDMA Ch11 +#define SYSCTL_DC7_DMACH11 0x00000800 // SSI0_TX / SSI1_TX +#define SYSCTL_DC7_SSI0_RX 0x00000400 // SSI0 RX on uDMA Ch10 +#define SYSCTL_DC7_DMACH10 0x00000400 // SSI0_RX / SSI1_RX +#define SYSCTL_DC7_UART0_TX 0x00000200 // UART0 TX on uDMA Ch9 +#define SYSCTL_DC7_DMACH9 0x00000200 // UART0_TX / UART1_TX +#define SYSCTL_DC7_DMACH8 0x00000100 // UART0_RX / UART1_RX +#define SYSCTL_DC7_UART0_RX 0x00000100 // UART0 RX on uDMA Ch8 +#define SYSCTL_DC7_DMACH7 0x00000080 // ETH_TX / Timer2B +#define SYSCTL_DC7_DMACH6 0x00000040 // ETH_RX / Timer2A +#define SYSCTL_DC7_DMACH5 0x00000020 // USB_EP3_TX / Timer2B +#define SYSCTL_DC7_USB_EP3_TX 0x00000020 // USB EP3 TX on uDMA Ch5 +#define SYSCTL_DC7_USB_EP3_RX 0x00000010 // USB EP3 RX on uDMA Ch4 +#define SYSCTL_DC7_DMACH4 0x00000010 // USB_EP3_RX / Timer2A +#define SYSCTL_DC7_USB_EP2_TX 0x00000008 // USB EP2 TX on uDMA Ch3 +#define SYSCTL_DC7_DMACH3 0x00000008 // USB_EP2_TX / Timer3B +#define SYSCTL_DC7_USB_EP2_RX 0x00000004 // USB EP2 RX on uDMA Ch2 +#define SYSCTL_DC7_DMACH2 0x00000004 // USB_EP2_RX / Timer3A +#define SYSCTL_DC7_USB_EP1_TX 0x00000002 // USB EP1 TX on uDMA Ch1 +#define SYSCTL_DC7_DMACH1 0x00000002 // USB_EP1_TX / UART2_TX +#define SYSCTL_DC7_DMACH0 0x00000001 // USB_EP1_RX / UART2_RX +#define SYSCTL_DC7_USB_EP1_RX 0x00000001 // USB EP1 RX on uDMA Ch0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC8 register. +// +//***************************************************************************** +#define SYSCTL_DC8_ADC1AIN15 0x80000000 // ADC Module 1 AIN15 Pin Present +#define SYSCTL_DC8_ADC1AIN14 0x40000000 // ADC Module 1 AIN14 Pin Present +#define SYSCTL_DC8_ADC1AIN13 0x20000000 // ADC Module 1 AIN13 Pin Present +#define SYSCTL_DC8_ADC1AIN12 0x10000000 // ADC Module 1 AIN12 Pin Present +#define SYSCTL_DC8_ADC1AIN11 0x08000000 // ADC Module 1 AIN11 Pin Present +#define SYSCTL_DC8_ADC1AIN10 0x04000000 // ADC Module 1 AIN10 Pin Present +#define SYSCTL_DC8_ADC1AIN9 0x02000000 // ADC Module 1 AIN9 Pin Present +#define SYSCTL_DC8_ADC1AIN8 0x01000000 // ADC Module 1 AIN8 Pin Present +#define SYSCTL_DC8_ADC1AIN7 0x00800000 // ADC Module 1 AIN7 Pin Present +#define SYSCTL_DC8_ADC1AIN6 0x00400000 // ADC Module 1 AIN6 Pin Present +#define SYSCTL_DC8_ADC1AIN5 0x00200000 // ADC Module 1 AIN5 Pin Present +#define SYSCTL_DC8_ADC1AIN4 0x00100000 // ADC Module 1 AIN4 Pin Present +#define SYSCTL_DC8_ADC1AIN3 0x00080000 // ADC Module 1 AIN3 Pin Present +#define SYSCTL_DC8_ADC1AIN2 0x00040000 // ADC Module 1 AIN2 Pin Present +#define SYSCTL_DC8_ADC1AIN1 0x00020000 // ADC Module 1 AIN1 Pin Present +#define SYSCTL_DC8_ADC1AIN0 0x00010000 // ADC Module 1 AIN0 Pin Present +#define SYSCTL_DC8_ADC0AIN15 0x00008000 // ADC Module 0 AIN15 Pin Present +#define SYSCTL_DC8_ADC0AIN14 0x00004000 // ADC Module 0 AIN14 Pin Present +#define SYSCTL_DC8_ADC0AIN13 0x00002000 // ADC Module 0 AIN13 Pin Present +#define SYSCTL_DC8_ADC0AIN12 0x00001000 // ADC Module 0 AIN12 Pin Present +#define SYSCTL_DC8_ADC0AIN11 0x00000800 // ADC Module 0 AIN11 Pin Present +#define SYSCTL_DC8_ADC0AIN10 0x00000400 // ADC Module 0 AIN10 Pin Present +#define SYSCTL_DC8_ADC0AIN9 0x00000200 // ADC Module 0 AIN9 Pin Present +#define SYSCTL_DC8_ADC0AIN8 0x00000100 // ADC Module 0 AIN8 Pin Present +#define SYSCTL_DC8_ADC0AIN7 0x00000080 // ADC Module 0 AIN7 Pin Present +#define SYSCTL_DC8_ADC0AIN6 0x00000040 // ADC Module 0 AIN6 Pin Present +#define SYSCTL_DC8_ADC0AIN5 0x00000020 // ADC Module 0 AIN5 Pin Present +#define SYSCTL_DC8_ADC0AIN4 0x00000010 // ADC Module 0 AIN4 Pin Present +#define SYSCTL_DC8_ADC0AIN3 0x00000008 // ADC Module 0 AIN3 Pin Present +#define SYSCTL_DC8_ADC0AIN2 0x00000004 // ADC Module 0 AIN2 Pin Present +#define SYSCTL_DC8_ADC0AIN1 0x00000002 // ADC Module 0 AIN1 Pin Present +#define SYSCTL_DC8_ADC0AIN0 0x00000001 // ADC Module 0 AIN0 Pin Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_PBORCTL register. +// +//***************************************************************************** +#define SYSCTL_PBORCTL_BORTIM_M 0x0000FFFC // BOR Time Delay +#define SYSCTL_PBORCTL_BORIOR 0x00000002 // BOR Interrupt or Reset +#define SYSCTL_PBORCTL_BORWT 0x00000001 // BOR Wait and Check for Noise +#define SYSCTL_PBORCTL_BORTIM_S 2 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_LDOPCTL register. +// +//***************************************************************************** +#define SYSCTL_LDOPCTL_M 0x0000003F // LDO Output Voltage +#define SYSCTL_LDOPCTL_2_50V 0x00000000 // 2.50 +#define SYSCTL_LDOPCTL_2_45V 0x00000001 // 2.45 +#define SYSCTL_LDOPCTL_2_40V 0x00000002 // 2.40 +#define SYSCTL_LDOPCTL_2_35V 0x00000003 // 2.35 +#define SYSCTL_LDOPCTL_2_30V 0x00000004 // 2.30 +#define SYSCTL_LDOPCTL_2_25V 0x00000005 // 2.25 +#define SYSCTL_LDOPCTL_2_75V 0x0000001B // 2.75 +#define SYSCTL_LDOPCTL_2_70V 0x0000001C // 2.70 +#define SYSCTL_LDOPCTL_2_65V 0x0000001D // 2.65 +#define SYSCTL_LDOPCTL_2_60V 0x0000001E // 2.60 +#define SYSCTL_LDOPCTL_2_55V 0x0000001F // 2.55 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SRCR0 register. +// +//***************************************************************************** +#define SYSCTL_SRCR0_WDT1 0x10000000 // WDT1 Reset Control +#define SYSCTL_SRCR0_CAN2 0x04000000 // CAN2 Reset Control +#define SYSCTL_SRCR0_CAN1 0x02000000 // CAN1 Reset Control +#define SYSCTL_SRCR0_CAN0 0x01000000 // CAN0 Reset Control +#define SYSCTL_SRCR0_PWM 0x00100000 // PWM Reset Control +#define SYSCTL_SRCR0_ADC1 0x00020000 // ADC1 Reset Control +#define SYSCTL_SRCR0_ADC0 0x00010000 // ADC0 Reset Control +#define SYSCTL_SRCR0_HIB 0x00000040 // HIB Reset Control +#define SYSCTL_SRCR0_WDT0 0x00000008 // WDT0 Reset Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SRCR1 register. +// +//***************************************************************************** +#define SYSCTL_SRCR1_EPI0 0x40000000 // EPI0 Reset Control +#define SYSCTL_SRCR1_I2S0 0x10000000 // I2S0 Reset Control +#define SYSCTL_SRCR1_COMP2 0x04000000 // Analog Comp 2 Reset Control +#define SYSCTL_SRCR1_COMP1 0x02000000 // Analog Comp 1 Reset Control +#define SYSCTL_SRCR1_COMP0 0x01000000 // Analog Comp 0 Reset Control +#define SYSCTL_SRCR1_TIMER3 0x00080000 // Timer 3 Reset Control +#define SYSCTL_SRCR1_TIMER2 0x00040000 // Timer 2 Reset Control +#define SYSCTL_SRCR1_TIMER1 0x00020000 // Timer 1 Reset Control +#define SYSCTL_SRCR1_TIMER0 0x00010000 // Timer 0 Reset Control +#define SYSCTL_SRCR1_I2C1 0x00004000 // I2C1 Reset Control +#define SYSCTL_SRCR1_I2C0 0x00001000 // I2C0 Reset Control +#define SYSCTL_SRCR1_QEI1 0x00000200 // QEI1 Reset Control +#define SYSCTL_SRCR1_QEI0 0x00000100 // QEI0 Reset Control +#define SYSCTL_SRCR1_SSI1 0x00000020 // SSI1 Reset Control +#define SYSCTL_SRCR1_SSI0 0x00000010 // SSI0 Reset Control +#define SYSCTL_SRCR1_UART2 0x00000004 // UART2 Reset Control +#define SYSCTL_SRCR1_UART1 0x00000002 // UART1 Reset Control +#define SYSCTL_SRCR1_UART0 0x00000001 // UART0 Reset Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SRCR2 register. +// +//***************************************************************************** +#define SYSCTL_SRCR2_EPHY0 0x40000000 // PHY0 Reset Control +#define SYSCTL_SRCR2_EMAC0 0x10000000 // MAC0 Reset Control +#define SYSCTL_SRCR2_USB0 0x00010000 // USB0 Reset Control +#define SYSCTL_SRCR2_UDMA 0x00002000 // Micro-DMA Reset Control +#define SYSCTL_SRCR2_GPIOJ 0x00000100 // Port J Reset Control +#define SYSCTL_SRCR2_GPIOH 0x00000080 // Port H Reset Control +#define SYSCTL_SRCR2_GPIOG 0x00000040 // Port G Reset Control +#define SYSCTL_SRCR2_GPIOF 0x00000020 // Port F Reset Control +#define SYSCTL_SRCR2_GPIOE 0x00000010 // Port E Reset Control +#define SYSCTL_SRCR2_GPIOD 0x00000008 // Port D Reset Control +#define SYSCTL_SRCR2_GPIOC 0x00000004 // Port C Reset Control +#define SYSCTL_SRCR2_GPIOB 0x00000002 // Port B Reset Control +#define SYSCTL_SRCR2_GPIOA 0x00000001 // Port A Reset Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RIS register. +// +//***************************************************************************** +#define SYSCTL_RIS_MOSCPUPRIS 0x00000100 // MOSC Power Up Raw Interrupt + // Status +#define SYSCTL_RIS_USBPLLLRIS 0x00000080 // USB PLL Lock Raw Interrupt + // Status +#define SYSCTL_RIS_PLLLRIS 0x00000040 // PLL Lock Raw Interrupt Status +#define SYSCTL_RIS_CLRIS 0x00000020 // Current Limit Raw Interrupt + // Status +#define SYSCTL_RIS_IOFRIS 0x00000010 // Internal Oscillator Fault Raw + // Interrupt Status +#define SYSCTL_RIS_MOFRIS 0x00000008 // Main Oscillator Fault Raw + // Interrupt Status +#define SYSCTL_RIS_LDORIS 0x00000004 // LDO Power Unregulated Raw + // Interrupt Status +#define SYSCTL_RIS_BORRIS 0x00000002 // Brown-Out Reset Raw Interrupt + // Status +#define SYSCTL_RIS_PLLFRIS 0x00000001 // PLL Fault Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_IMC register. +// +//***************************************************************************** +#define SYSCTL_IMC_MOSCPUPIM 0x00000100 // MOSC Power Up Interrupt Mask +#define SYSCTL_IMC_USBPLLLIM 0x00000080 // USB PLL Lock Interrupt Mask +#define SYSCTL_IMC_PLLLIM 0x00000040 // PLL Lock Interrupt Mask +#define SYSCTL_IMC_CLIM 0x00000020 // Current Limit Interrupt Mask +#define SYSCTL_IMC_IOFIM 0x00000010 // Internal Oscillator Fault + // Interrupt Mask +#define SYSCTL_IMC_MOFIM 0x00000008 // Main Oscillator Fault Interrupt + // Mask +#define SYSCTL_IMC_LDOIM 0x00000004 // LDO Power Unregulated Interrupt + // Mask +#define SYSCTL_IMC_BORIM 0x00000002 // Brown-Out Reset Interrupt Mask +#define SYSCTL_IMC_PLLFIM 0x00000001 // PLL Fault Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_MISC register. +// +//***************************************************************************** +#define SYSCTL_MISC_MOSCPUPMIS 0x00000100 // MOSC Power Up Masked Interrupt + // Status +#define SYSCTL_MISC_USBPLLLMIS 0x00000080 // USB PLL Lock Masked Interrupt + // Status +#define SYSCTL_MISC_PLLLMIS 0x00000040 // PLL Lock Masked Interrupt Status +#define SYSCTL_MISC_CLMIS 0x00000020 // Current Limit Masked Interrupt + // Status +#define SYSCTL_MISC_IOFMIS 0x00000010 // Internal Oscillator Fault Masked + // Interrupt Status +#define SYSCTL_MISC_MOFMIS 0x00000008 // Main Oscillator Fault Masked + // Interrupt Status +#define SYSCTL_MISC_LDOMIS 0x00000004 // LDO Power Unregulated Masked + // Interrupt Status +#define SYSCTL_MISC_BORMIS 0x00000002 // BOR Masked Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RESC register. +// +//***************************************************************************** +#define SYSCTL_RESC_MOSCFAIL 0x00010000 // MOSC Failure Reset +#define SYSCTL_RESC_LDO 0x00000020 // LDO Reset +#define SYSCTL_RESC_WDT1 0x00000020 // Watchdog Timer 1 Reset +#define SYSCTL_RESC_SW 0x00000010 // Software Reset +#define SYSCTL_RESC_WDT0 0x00000008 // Watchdog Timer 0 Reset +#define SYSCTL_RESC_BOR 0x00000004 // Brown-Out Reset +#define SYSCTL_RESC_POR 0x00000002 // Power-On Reset +#define SYSCTL_RESC_EXT 0x00000001 // External Reset + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RCC register. +// +//***************************************************************************** +#define SYSCTL_RCC_ACG 0x08000000 // Auto Clock Gating +#define SYSCTL_RCC_SYSDIV_M 0x07800000 // System Clock Divisor +#define SYSCTL_RCC_SYSDIV_2 0x00800000 // System clock /2 +#define SYSCTL_RCC_SYSDIV_3 0x01000000 // System clock /3 +#define SYSCTL_RCC_SYSDIV_4 0x01800000 // System clock /4 +#define SYSCTL_RCC_SYSDIV_5 0x02000000 // System clock /5 +#define SYSCTL_RCC_SYSDIV_6 0x02800000 // System clock /6 +#define SYSCTL_RCC_SYSDIV_7 0x03000000 // System clock /7 +#define SYSCTL_RCC_SYSDIV_8 0x03800000 // System clock /8 +#define SYSCTL_RCC_SYSDIV_9 0x04000000 // System clock /9 +#define SYSCTL_RCC_SYSDIV_10 0x04800000 // System clock /10 +#define SYSCTL_RCC_SYSDIV_11 0x05000000 // System clock /11 +#define SYSCTL_RCC_SYSDIV_12 0x05800000 // System clock /12 +#define SYSCTL_RCC_SYSDIV_13 0x06000000 // System clock /13 +#define SYSCTL_RCC_SYSDIV_14 0x06800000 // System clock /14 +#define SYSCTL_RCC_SYSDIV_15 0x07000000 // System clock /15 +#define SYSCTL_RCC_SYSDIV_16 0x07800000 // System clock /16 +#define SYSCTL_RCC_USESYSDIV 0x00400000 // Enable System Clock Divider +#define SYSCTL_RCC_USEPWMDIV 0x00100000 // Enable PWM Clock Divisor +#define SYSCTL_RCC_PWMDIV_M 0x000E0000 // PWM Unit Clock Divisor +#define SYSCTL_RCC_PWMDIV_2 0x00000000 // PWM clock /2 +#define SYSCTL_RCC_PWMDIV_4 0x00020000 // PWM clock /4 +#define SYSCTL_RCC_PWMDIV_8 0x00040000 // PWM clock /8 +#define SYSCTL_RCC_PWMDIV_16 0x00060000 // PWM clock /16 +#define SYSCTL_RCC_PWMDIV_32 0x00080000 // PWM clock /32 +#define SYSCTL_RCC_PWMDIV_64 0x000A0000 // PWM clock /64 +#define SYSCTL_RCC_PWRDN 0x00002000 // PLL Power Down +#define SYSCTL_RCC_OEN 0x00001000 // PLL Output Enable +#define SYSCTL_RCC_BYPASS 0x00000800 // PLL Bypass +#define SYSCTL_RCC_XTAL_M 0x000007C0 // Crystal Value +#define SYSCTL_RCC_XTAL_1MHZ 0x00000000 // 1 MHz +#define SYSCTL_RCC_XTAL_1_84MHZ 0x00000040 // 1.8432 MHz +#define SYSCTL_RCC_XTAL_2MHZ 0x00000080 // 2 MHz +#define SYSCTL_RCC_XTAL_2_45MHZ 0x000000C0 // 2.4576 MHz +#define SYSCTL_RCC_XTAL_3_57MHZ 0x00000100 // 3.579545 MHz +#define SYSCTL_RCC_XTAL_3_68MHZ 0x00000140 // 3.6864 MHz +#define SYSCTL_RCC_XTAL_4MHZ 0x00000180 // 4 MHz +#define SYSCTL_RCC_XTAL_4_09MHZ 0x000001C0 // 4.096 MHz +#define SYSCTL_RCC_XTAL_4_91MHZ 0x00000200 // 4.9152 MHz +#define SYSCTL_RCC_XTAL_5MHZ 0x00000240 // 5 MHz +#define SYSCTL_RCC_XTAL_5_12MHZ 0x00000280 // 5.12 MHz +#define SYSCTL_RCC_XTAL_6MHZ 0x000002C0 // 6 MHz +#define SYSCTL_RCC_XTAL_6_14MHZ 0x00000300 // 6.144 MHz +#define SYSCTL_RCC_XTAL_7_37MHZ 0x00000340 // 7.3728 MHz +#define SYSCTL_RCC_XTAL_8MHZ 0x00000380 // 8 MHz +#define SYSCTL_RCC_XTAL_8_19MHZ 0x000003C0 // 8.192 MHz +#define SYSCTL_RCC_XTAL_10MHZ 0x00000400 // 10 MHz +#define SYSCTL_RCC_XTAL_12MHZ 0x00000440 // 12 MHz +#define SYSCTL_RCC_XTAL_12_2MHZ 0x00000480 // 12.288 MHz +#define SYSCTL_RCC_XTAL_13_5MHZ 0x000004C0 // 13.56 MHz +#define SYSCTL_RCC_XTAL_14_3MHZ 0x00000500 // 14.31818 MHz +#define SYSCTL_RCC_XTAL_16MHZ 0x00000540 // 16 MHz +#define SYSCTL_RCC_XTAL_16_3MHZ 0x00000580 // 16.384 MHz +#define SYSCTL_RCC_PLLVER 0x00000400 // PLL Verification +#define SYSCTL_RCC_OSCSRC_M 0x00000030 // Oscillator Source +#define SYSCTL_RCC_OSCSRC_MAIN 0x00000000 // MOSC +#define SYSCTL_RCC_OSCSRC_INT 0x00000010 // IOSC +#define SYSCTL_RCC_OSCSRC_INT4 0x00000020 // IOSC/4 +#define SYSCTL_RCC_OSCSRC_30 0x00000030 // 30 kHz +#define SYSCTL_RCC_IOSCVER 0x00000008 // Internal Oscillator Verification + // Timer +#define SYSCTL_RCC_MOSCVER 0x00000004 // Main Oscillator Verification + // Timer +#define SYSCTL_RCC_IOSCDIS 0x00000002 // Internal Oscillator Disable +#define SYSCTL_RCC_MOSCDIS 0x00000001 // Main Oscillator Disable +#define SYSCTL_RCC_SYSDIV_S 23 +#define SYSCTL_RCC_PWMDIV_S 17 // Shift to the PWMDIV field +#define SYSCTL_RCC_XTAL_S 6 // Shift to the XTAL field +#define SYSCTL_RCC_OSCSRC_S 4 // Shift to the OSCSRC field + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_PLLCFG register. +// +//***************************************************************************** +#define SYSCTL_PLLCFG_OD_M 0x0000C000 // PLL OD Value +#define SYSCTL_PLLCFG_OD_1 0x00000000 // Divide by 1 +#define SYSCTL_PLLCFG_OD_2 0x00004000 // Divide by 2 +#define SYSCTL_PLLCFG_OD_4 0x00008000 // Divide by 4 +#define SYSCTL_PLLCFG_F_M 0x00003FE0 // PLL F Value +#define SYSCTL_PLLCFG_R_M 0x0000001F // PLL R Value +#define SYSCTL_PLLCFG_F_S 5 +#define SYSCTL_PLLCFG_R_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_GPIOHBCTL +// register. +// +//***************************************************************************** +#define SYSCTL_GPIOHBCTL_PORTJ 0x00000100 // Port J Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTH 0x00000080 // Port H Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTG 0x00000040 // Port G Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTF 0x00000020 // Port F Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTE 0x00000010 // Port E Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTD 0x00000008 // Port D Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTC 0x00000004 // Port C Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTB 0x00000002 // Port B Advanced High-Performance + // Bus +#define SYSCTL_GPIOHBCTL_PORTA 0x00000001 // Port A Advanced High-Performance + // Bus + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RCC2 register. +// +//***************************************************************************** +#define SYSCTL_RCC2_USERCC2 0x80000000 // Use RCC2 +#define SYSCTL_RCC2_DIV400 0x40000000 // Divide PLL as 400 MHz vs. 200 + // MHz +#define SYSCTL_RCC2_SYSDIV2_M 0x1F800000 // System Clock Divisor 2 +#define SYSCTL_RCC2_SYSDIV2_2 0x00800000 // System clock /2 +#define SYSCTL_RCC2_SYSDIV2_3 0x01000000 // System clock /3 +#define SYSCTL_RCC2_SYSDIV2_4 0x01800000 // System clock /4 +#define SYSCTL_RCC2_SYSDIV2_5 0x02000000 // System clock /5 +#define SYSCTL_RCC2_SYSDIV2_6 0x02800000 // System clock /6 +#define SYSCTL_RCC2_SYSDIV2_7 0x03000000 // System clock /7 +#define SYSCTL_RCC2_SYSDIV2_8 0x03800000 // System clock /8 +#define SYSCTL_RCC2_SYSDIV2_9 0x04000000 // System clock /9 +#define SYSCTL_RCC2_SYSDIV2_10 0x04800000 // System clock /10 +#define SYSCTL_RCC2_SYSDIV2_11 0x05000000 // System clock /11 +#define SYSCTL_RCC2_SYSDIV2_12 0x05800000 // System clock /12 +#define SYSCTL_RCC2_SYSDIV2_13 0x06000000 // System clock /13 +#define SYSCTL_RCC2_SYSDIV2_14 0x06800000 // System clock /14 +#define SYSCTL_RCC2_SYSDIV2_15 0x07000000 // System clock /15 +#define SYSCTL_RCC2_SYSDIV2_16 0x07800000 // System clock /16 +#define SYSCTL_RCC2_SYSDIV2_17 0x08000000 // System clock /17 +#define SYSCTL_RCC2_SYSDIV2_18 0x08800000 // System clock /18 +#define SYSCTL_RCC2_SYSDIV2_19 0x09000000 // System clock /19 +#define SYSCTL_RCC2_SYSDIV2_20 0x09800000 // System clock /20 +#define SYSCTL_RCC2_SYSDIV2_21 0x0A000000 // System clock /21 +#define SYSCTL_RCC2_SYSDIV2_22 0x0A800000 // System clock /22 +#define SYSCTL_RCC2_SYSDIV2_23 0x0B000000 // System clock /23 +#define SYSCTL_RCC2_SYSDIV2_24 0x0B800000 // System clock /24 +#define SYSCTL_RCC2_SYSDIV2_25 0x0C000000 // System clock /25 +#define SYSCTL_RCC2_SYSDIV2_26 0x0C800000 // System clock /26 +#define SYSCTL_RCC2_SYSDIV2_27 0x0D000000 // System clock /27 +#define SYSCTL_RCC2_SYSDIV2_28 0x0D800000 // System clock /28 +#define SYSCTL_RCC2_SYSDIV2_29 0x0E000000 // System clock /29 +#define SYSCTL_RCC2_SYSDIV2_30 0x0E800000 // System clock /30 +#define SYSCTL_RCC2_SYSDIV2_31 0x0F000000 // System clock /31 +#define SYSCTL_RCC2_SYSDIV2_32 0x0F800000 // System clock /32 +#define SYSCTL_RCC2_SYSDIV2_33 0x10000000 // System clock /33 +#define SYSCTL_RCC2_SYSDIV2_34 0x10800000 // System clock /34 +#define SYSCTL_RCC2_SYSDIV2_35 0x11000000 // System clock /35 +#define SYSCTL_RCC2_SYSDIV2_36 0x11800000 // System clock /36 +#define SYSCTL_RCC2_SYSDIV2_37 0x12000000 // System clock /37 +#define SYSCTL_RCC2_SYSDIV2_38 0x12800000 // System clock /38 +#define SYSCTL_RCC2_SYSDIV2_39 0x13000000 // System clock /39 +#define SYSCTL_RCC2_SYSDIV2_40 0x13800000 // System clock /40 +#define SYSCTL_RCC2_SYSDIV2_41 0x14000000 // System clock /41 +#define SYSCTL_RCC2_SYSDIV2_42 0x14800000 // System clock /42 +#define SYSCTL_RCC2_SYSDIV2_43 0x15000000 // System clock /43 +#define SYSCTL_RCC2_SYSDIV2_44 0x15800000 // System clock /44 +#define SYSCTL_RCC2_SYSDIV2_45 0x16000000 // System clock /45 +#define SYSCTL_RCC2_SYSDIV2_46 0x16800000 // System clock /46 +#define SYSCTL_RCC2_SYSDIV2_47 0x17000000 // System clock /47 +#define SYSCTL_RCC2_SYSDIV2_48 0x17800000 // System clock /48 +#define SYSCTL_RCC2_SYSDIV2_49 0x18000000 // System clock /49 +#define SYSCTL_RCC2_SYSDIV2_50 0x18800000 // System clock /50 +#define SYSCTL_RCC2_SYSDIV2_51 0x19000000 // System clock /51 +#define SYSCTL_RCC2_SYSDIV2_52 0x19800000 // System clock /52 +#define SYSCTL_RCC2_SYSDIV2_53 0x1A000000 // System clock /53 +#define SYSCTL_RCC2_SYSDIV2_54 0x1A800000 // System clock /54 +#define SYSCTL_RCC2_SYSDIV2_55 0x1B000000 // System clock /55 +#define SYSCTL_RCC2_SYSDIV2_56 0x1B800000 // System clock /56 +#define SYSCTL_RCC2_SYSDIV2_57 0x1C000000 // System clock /57 +#define SYSCTL_RCC2_SYSDIV2_58 0x1C800000 // System clock /58 +#define SYSCTL_RCC2_SYSDIV2_59 0x1D000000 // System clock /59 +#define SYSCTL_RCC2_SYSDIV2_60 0x1D800000 // System clock /60 +#define SYSCTL_RCC2_SYSDIV2_61 0x1E000000 // System clock /61 +#define SYSCTL_RCC2_SYSDIV2_62 0x1E800000 // System clock /62 +#define SYSCTL_RCC2_SYSDIV2_63 0x1F000000 // System clock /63 +#define SYSCTL_RCC2_SYSDIV2_64 0x1F800000 // System clock /64 +#define SYSCTL_RCC2_SYSDIV2LSB 0x00400000 // Additional LSB for SYSDIV2 +#define SYSCTL_RCC2_USBPWRDN 0x00004000 // Power-Down USB PLL +#define SYSCTL_RCC2_PWRDN2 0x00002000 // Power-Down PLL 2 +#define SYSCTL_RCC2_BYPASS2 0x00000800 // PLL Bypass 2 +#define SYSCTL_RCC2_OSCSRC2_M 0x00000070 // Oscillator Source 2 +#define SYSCTL_RCC2_OSCSRC2_MO 0x00000000 // MOSC +#define SYSCTL_RCC2_OSCSRC2_IO 0x00000010 // PIOSC +#define SYSCTL_RCC2_OSCSRC2_IO4 0x00000020 // PIOSC/4 +#define SYSCTL_RCC2_OSCSRC2_30 0x00000030 // 30 kHz +#define SYSCTL_RCC2_OSCSRC2_419 0x00000060 // 4.194304 MHz +#define SYSCTL_RCC2_OSCSRC2_32 0x00000070 // 32.768 kHz +#define SYSCTL_RCC2_SYSDIV2_S 23 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_MOSCCTL register. +// +//***************************************************************************** +#define SYSCTL_MOSCCTL_CVAL 0x00000001 // Clock Validation for MOSC + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RCGC0 register. +// +//***************************************************************************** +#define SYSCTL_RCGC0_WDT1 0x10000000 // WDT1 Clock Gating Control +#define SYSCTL_RCGC0_CAN2 0x04000000 // CAN2 Clock Gating Control +#define SYSCTL_RCGC0_CAN1 0x02000000 // CAN1 Clock Gating Control +#define SYSCTL_RCGC0_CAN0 0x01000000 // CAN0 Clock Gating Control +#define SYSCTL_RCGC0_PWM 0x00100000 // PWM Clock Gating Control +#define SYSCTL_RCGC0_ADC1 0x00020000 // ADC1 Clock Gating Control +#define SYSCTL_RCGC0_ADC0 0x00010000 // ADC0 Clock Gating Control +#define SYSCTL_RCGC0_ADCSPD_M 0x00000F00 // ADC Sample Speed +#define SYSCTL_RCGC0_ADCSPD125K 0x00000000 // 125K samples/second +#define SYSCTL_RCGC0_ADCSPD250K 0x00000100 // 250K samples/second +#define SYSCTL_RCGC0_ADCSPD500K 0x00000200 // 500K samples/second +#define SYSCTL_RCGC0_ADCSPD1M 0x00000300 // 1M samples/second +#define SYSCTL_RCGC0_ADC1SPD_M 0x00000C00 // ADC1 Sample Speed +#define SYSCTL_RCGC0_ADC1SPD_125K \ + 0x00000000 // 125K samples/second +#define SYSCTL_RCGC0_ADC1SPD_250K \ + 0x00000400 // 250K samples/second +#define SYSCTL_RCGC0_ADC1SPD_500K \ + 0x00000800 // 500K samples/second +#define SYSCTL_RCGC0_ADC1SPD_1M 0x00000C00 // 1M samples/second +#define SYSCTL_RCGC0_ADC0SPD_M 0x00000300 // ADC0 Sample Speed +#define SYSCTL_RCGC0_ADC0SPD_125K \ + 0x00000000 // 125K samples/second +#define SYSCTL_RCGC0_ADC0SPD_250K \ + 0x00000100 // 250K samples/second +#define SYSCTL_RCGC0_ADC0SPD_500K \ + 0x00000200 // 500K samples/second +#define SYSCTL_RCGC0_ADC0SPD_1M 0x00000300 // 1M samples/second +#define SYSCTL_RCGC0_HIB 0x00000040 // HIB Clock Gating Control +#define SYSCTL_RCGC0_WDT0 0x00000008 // WDT0 Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RCGC1 register. +// +//***************************************************************************** +#define SYSCTL_RCGC1_EPI0 0x40000000 // EPI0 Clock Gating +#define SYSCTL_RCGC1_I2S0 0x10000000 // I2S0 Clock Gating +#define SYSCTL_RCGC1_COMP2 0x04000000 // Analog Comparator 2 Clock Gating +#define SYSCTL_RCGC1_COMP1 0x02000000 // Analog Comparator 1 Clock Gating +#define SYSCTL_RCGC1_COMP0 0x01000000 // Analog Comparator 0 Clock Gating +#define SYSCTL_RCGC1_TIMER3 0x00080000 // Timer 3 Clock Gating Control +#define SYSCTL_RCGC1_TIMER2 0x00040000 // Timer 2 Clock Gating Control +#define SYSCTL_RCGC1_TIMER1 0x00020000 // Timer 1 Clock Gating Control +#define SYSCTL_RCGC1_TIMER0 0x00010000 // Timer 0 Clock Gating Control +#define SYSCTL_RCGC1_I2C1 0x00004000 // I2C1 Clock Gating Control +#define SYSCTL_RCGC1_I2C0 0x00001000 // I2C0 Clock Gating Control +#define SYSCTL_RCGC1_QEI1 0x00000200 // QEI1 Clock Gating Control +#define SYSCTL_RCGC1_QEI0 0x00000100 // QEI0 Clock Gating Control +#define SYSCTL_RCGC1_SSI1 0x00000020 // SSI1 Clock Gating Control +#define SYSCTL_RCGC1_SSI0 0x00000010 // SSI0 Clock Gating Control +#define SYSCTL_RCGC1_UART2 0x00000004 // UART2 Clock Gating Control +#define SYSCTL_RCGC1_UART1 0x00000002 // UART1 Clock Gating Control +#define SYSCTL_RCGC1_UART0 0x00000001 // UART0 Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RCGC2 register. +// +//***************************************************************************** +#define SYSCTL_RCGC2_EPHY0 0x40000000 // PHY0 Clock Gating Control +#define SYSCTL_RCGC2_EMAC0 0x10000000 // MAC0 Clock Gating Control +#define SYSCTL_RCGC2_USB0 0x00010000 // USB0 Clock Gating Control +#define SYSCTL_RCGC2_UDMA 0x00002000 // Micro-DMA Clock Gating Control +#define SYSCTL_RCGC2_GPIOJ 0x00000100 // Port J Clock Gating Control +#define SYSCTL_RCGC2_GPIOH 0x00000080 // Port H Clock Gating Control +#define SYSCTL_RCGC2_GPIOG 0x00000040 // Port G Clock Gating Control +#define SYSCTL_RCGC2_GPIOF 0x00000020 // Port F Clock Gating Control +#define SYSCTL_RCGC2_GPIOE 0x00000010 // Port E Clock Gating Control +#define SYSCTL_RCGC2_GPIOD 0x00000008 // Port D Clock Gating Control +#define SYSCTL_RCGC2_GPIOC 0x00000004 // Port C Clock Gating Control +#define SYSCTL_RCGC2_GPIOB 0x00000002 // Port B Clock Gating Control +#define SYSCTL_RCGC2_GPIOA 0x00000001 // Port A Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SCGC0 register. +// +//***************************************************************************** +#define SYSCTL_SCGC0_WDT1 0x10000000 // WDT1 Clock Gating Control +#define SYSCTL_SCGC0_CAN2 0x04000000 // CAN2 Clock Gating Control +#define SYSCTL_SCGC0_CAN1 0x02000000 // CAN1 Clock Gating Control +#define SYSCTL_SCGC0_CAN0 0x01000000 // CAN0 Clock Gating Control +#define SYSCTL_SCGC0_PWM 0x00100000 // PWM Clock Gating Control +#define SYSCTL_SCGC0_ADC1 0x00020000 // ADC1 Clock Gating Control +#define SYSCTL_SCGC0_ADC0 0x00010000 // ADC0 Clock Gating Control +#define SYSCTL_SCGC0_ADCSPD_M 0x00000F00 // ADC Sample Speed +#define SYSCTL_SCGC0_ADCSPD125K 0x00000000 // 125K samples/second +#define SYSCTL_SCGC0_ADCSPD250K 0x00000100 // 250K samples/second +#define SYSCTL_SCGC0_ADCSPD500K 0x00000200 // 500K samples/second +#define SYSCTL_SCGC0_ADCSPD1M 0x00000300 // 1M samples/second +#define SYSCTL_SCGC0_ADC1SPD_M 0x00000C00 // ADC1 Sample Speed +#define SYSCTL_SCGC0_ADC1SPD_125K \ + 0x00000000 // 125K samples/second +#define SYSCTL_SCGC0_ADC1SPD_250K \ + 0x00000400 // 250K samples/second +#define SYSCTL_SCGC0_ADC1SPD_500K \ + 0x00000800 // 500K samples/second +#define SYSCTL_SCGC0_ADC1SPD_1M 0x00000C00 // 1M samples/second +#define SYSCTL_SCGC0_ADC0SPD_M 0x00000300 // ADC0 Sample Speed +#define SYSCTL_SCGC0_ADC0SPD_125K \ + 0x00000000 // 125K samples/second +#define SYSCTL_SCGC0_ADC0SPD_250K \ + 0x00000100 // 250K samples/second +#define SYSCTL_SCGC0_ADC0SPD_500K \ + 0x00000200 // 500K samples/second +#define SYSCTL_SCGC0_ADC0SPD_1M 0x00000300 // 1M samples/second +#define SYSCTL_SCGC0_HIB 0x00000040 // HIB Clock Gating Control +#define SYSCTL_SCGC0_WDT0 0x00000008 // WDT0 Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SCGC1 register. +// +//***************************************************************************** +#define SYSCTL_SCGC1_EPI0 0x40000000 // EPI0 Clock Gating +#define SYSCTL_SCGC1_I2S0 0x10000000 // I2S0 Clock Gating +#define SYSCTL_SCGC1_COMP2 0x04000000 // Analog Comparator 2 Clock Gating +#define SYSCTL_SCGC1_COMP1 0x02000000 // Analog Comparator 1 Clock Gating +#define SYSCTL_SCGC1_COMP0 0x01000000 // Analog Comparator 0 Clock Gating +#define SYSCTL_SCGC1_TIMER3 0x00080000 // Timer 3 Clock Gating Control +#define SYSCTL_SCGC1_TIMER2 0x00040000 // Timer 2 Clock Gating Control +#define SYSCTL_SCGC1_TIMER1 0x00020000 // Timer 1 Clock Gating Control +#define SYSCTL_SCGC1_TIMER0 0x00010000 // Timer 0 Clock Gating Control +#define SYSCTL_SCGC1_I2C1 0x00004000 // I2C1 Clock Gating Control +#define SYSCTL_SCGC1_I2C0 0x00001000 // I2C0 Clock Gating Control +#define SYSCTL_SCGC1_QEI1 0x00000200 // QEI1 Clock Gating Control +#define SYSCTL_SCGC1_QEI0 0x00000100 // QEI0 Clock Gating Control +#define SYSCTL_SCGC1_SSI1 0x00000020 // SSI1 Clock Gating Control +#define SYSCTL_SCGC1_SSI0 0x00000010 // SSI0 Clock Gating Control +#define SYSCTL_SCGC1_UART2 0x00000004 // UART2 Clock Gating Control +#define SYSCTL_SCGC1_UART1 0x00000002 // UART1 Clock Gating Control +#define SYSCTL_SCGC1_UART0 0x00000001 // UART0 Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SCGC2 register. +// +//***************************************************************************** +#define SYSCTL_SCGC2_EPHY0 0x40000000 // PHY0 Clock Gating Control +#define SYSCTL_SCGC2_EMAC0 0x10000000 // MAC0 Clock Gating Control +#define SYSCTL_SCGC2_USB0 0x00010000 // USB0 Clock Gating Control +#define SYSCTL_SCGC2_UDMA 0x00002000 // Micro-DMA Clock Gating Control +#define SYSCTL_SCGC2_GPIOJ 0x00000100 // Port J Clock Gating Control +#define SYSCTL_SCGC2_GPIOH 0x00000080 // Port H Clock Gating Control +#define SYSCTL_SCGC2_GPIOG 0x00000040 // Port G Clock Gating Control +#define SYSCTL_SCGC2_GPIOF 0x00000020 // Port F Clock Gating Control +#define SYSCTL_SCGC2_GPIOE 0x00000010 // Port E Clock Gating Control +#define SYSCTL_SCGC2_GPIOD 0x00000008 // Port D Clock Gating Control +#define SYSCTL_SCGC2_GPIOC 0x00000004 // Port C Clock Gating Control +#define SYSCTL_SCGC2_GPIOB 0x00000002 // Port B Clock Gating Control +#define SYSCTL_SCGC2_GPIOA 0x00000001 // Port A Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DCGC0 register. +// +//***************************************************************************** +#define SYSCTL_DCGC0_WDT1 0x10000000 // WDT1 Clock Gating Control +#define SYSCTL_DCGC0_CAN2 0x04000000 // CAN2 Clock Gating Control +#define SYSCTL_DCGC0_CAN1 0x02000000 // CAN1 Clock Gating Control +#define SYSCTL_DCGC0_CAN0 0x01000000 // CAN0 Clock Gating Control +#define SYSCTL_DCGC0_PWM 0x00100000 // PWM Clock Gating Control +#define SYSCTL_DCGC0_ADC1 0x00020000 // ADC1 Clock Gating Control +#define SYSCTL_DCGC0_ADC0 0x00010000 // ADC0 Clock Gating Control +#define SYSCTL_DCGC0_HIB 0x00000040 // HIB Clock Gating Control +#define SYSCTL_DCGC0_WDT0 0x00000008 // WDT0 Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DCGC1 register. +// +//***************************************************************************** +#define SYSCTL_DCGC1_EPI0 0x40000000 // EPI0 Clock Gating +#define SYSCTL_DCGC1_I2S0 0x10000000 // I2S0 Clock Gating +#define SYSCTL_DCGC1_COMP2 0x04000000 // Analog Comparator 2 Clock Gating +#define SYSCTL_DCGC1_COMP1 0x02000000 // Analog Comparator 1 Clock Gating +#define SYSCTL_DCGC1_COMP0 0x01000000 // Analog Comparator 0 Clock Gating +#define SYSCTL_DCGC1_TIMER3 0x00080000 // Timer 3 Clock Gating Control +#define SYSCTL_DCGC1_TIMER2 0x00040000 // Timer 2 Clock Gating Control +#define SYSCTL_DCGC1_TIMER1 0x00020000 // Timer 1 Clock Gating Control +#define SYSCTL_DCGC1_TIMER0 0x00010000 // Timer 0 Clock Gating Control +#define SYSCTL_DCGC1_I2C1 0x00004000 // I2C1 Clock Gating Control +#define SYSCTL_DCGC1_I2C0 0x00001000 // I2C0 Clock Gating Control +#define SYSCTL_DCGC1_QEI1 0x00000200 // QEI1 Clock Gating Control +#define SYSCTL_DCGC1_QEI0 0x00000100 // QEI0 Clock Gating Control +#define SYSCTL_DCGC1_SSI1 0x00000020 // SSI1 Clock Gating Control +#define SYSCTL_DCGC1_SSI0 0x00000010 // SSI0 Clock Gating Control +#define SYSCTL_DCGC1_UART2 0x00000004 // UART2 Clock Gating Control +#define SYSCTL_DCGC1_UART1 0x00000002 // UART1 Clock Gating Control +#define SYSCTL_DCGC1_UART0 0x00000001 // UART0 Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DCGC2 register. +// +//***************************************************************************** +#define SYSCTL_DCGC2_EPHY0 0x40000000 // PHY0 Clock Gating Control +#define SYSCTL_DCGC2_EMAC0 0x10000000 // MAC0 Clock Gating Control +#define SYSCTL_DCGC2_USB0 0x00010000 // USB0 Clock Gating Control +#define SYSCTL_DCGC2_UDMA 0x00002000 // Micro-DMA Clock Gating Control +#define SYSCTL_DCGC2_GPIOJ 0x00000100 // Port J Clock Gating Control +#define SYSCTL_DCGC2_GPIOH 0x00000080 // Port H Clock Gating Control +#define SYSCTL_DCGC2_GPIOG 0x00000040 // Port G Clock Gating Control +#define SYSCTL_DCGC2_GPIOF 0x00000020 // Port F Clock Gating Control +#define SYSCTL_DCGC2_GPIOE 0x00000010 // Port E Clock Gating Control +#define SYSCTL_DCGC2_GPIOD 0x00000008 // Port D Clock Gating Control +#define SYSCTL_DCGC2_GPIOC 0x00000004 // Port C Clock Gating Control +#define SYSCTL_DCGC2_GPIOB 0x00000002 // Port B Clock Gating Control +#define SYSCTL_DCGC2_GPIOA 0x00000001 // Port A Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DSLPCLKCFG +// register. +// +//***************************************************************************** +#define SYSCTL_DSLPCLKCFG_D_M 0x1F800000 // Divider Field Override +#define SYSCTL_DSLPCLKCFG_D_1 0x00000000 // System clock /1 +#define SYSCTL_DSLPCLKCFG_D_2 0x00800000 // System clock /2 +#define SYSCTL_DSLPCLKCFG_D_3 0x01000000 // System clock /3 +#define SYSCTL_DSLPCLKCFG_D_4 0x01800000 // System clock /4 +#define SYSCTL_DSLPCLKCFG_D_5 0x02000000 // System clock /5 +#define SYSCTL_DSLPCLKCFG_D_6 0x02800000 // System clock /6 +#define SYSCTL_DSLPCLKCFG_D_7 0x03000000 // System clock /7 +#define SYSCTL_DSLPCLKCFG_D_8 0x03800000 // System clock /8 +#define SYSCTL_DSLPCLKCFG_D_9 0x04000000 // System clock /9 +#define SYSCTL_DSLPCLKCFG_D_10 0x04800000 // System clock /10 +#define SYSCTL_DSLPCLKCFG_D_11 0x05000000 // System clock /11 +#define SYSCTL_DSLPCLKCFG_D_12 0x05800000 // System clock /12 +#define SYSCTL_DSLPCLKCFG_D_13 0x06000000 // System clock /13 +#define SYSCTL_DSLPCLKCFG_D_14 0x06800000 // System clock /14 +#define SYSCTL_DSLPCLKCFG_D_15 0x07000000 // System clock /15 +#define SYSCTL_DSLPCLKCFG_D_16 0x07800000 // System clock /16 +#define SYSCTL_DSLPCLKCFG_D_17 0x08000000 // System clock /17 +#define SYSCTL_DSLPCLKCFG_D_18 0x08800000 // System clock /18 +#define SYSCTL_DSLPCLKCFG_D_19 0x09000000 // System clock /19 +#define SYSCTL_DSLPCLKCFG_D_20 0x09800000 // System clock /20 +#define SYSCTL_DSLPCLKCFG_D_21 0x0A000000 // System clock /21 +#define SYSCTL_DSLPCLKCFG_D_22 0x0A800000 // System clock /22 +#define SYSCTL_DSLPCLKCFG_D_23 0x0B000000 // System clock /23 +#define SYSCTL_DSLPCLKCFG_D_24 0x0B800000 // System clock /24 +#define SYSCTL_DSLPCLKCFG_D_25 0x0C000000 // System clock /25 +#define SYSCTL_DSLPCLKCFG_D_26 0x0C800000 // System clock /26 +#define SYSCTL_DSLPCLKCFG_D_27 0x0D000000 // System clock /27 +#define SYSCTL_DSLPCLKCFG_D_28 0x0D800000 // System clock /28 +#define SYSCTL_DSLPCLKCFG_D_29 0x0E000000 // System clock /29 +#define SYSCTL_DSLPCLKCFG_D_30 0x0E800000 // System clock /30 +#define SYSCTL_DSLPCLKCFG_D_31 0x0F000000 // System clock /31 +#define SYSCTL_DSLPCLKCFG_D_32 0x0F800000 // System clock /32 +#define SYSCTL_DSLPCLKCFG_D_33 0x10000000 // System clock /33 +#define SYSCTL_DSLPCLKCFG_D_34 0x10800000 // System clock /34 +#define SYSCTL_DSLPCLKCFG_D_35 0x11000000 // System clock /35 +#define SYSCTL_DSLPCLKCFG_D_36 0x11800000 // System clock /36 +#define SYSCTL_DSLPCLKCFG_D_37 0x12000000 // System clock /37 +#define SYSCTL_DSLPCLKCFG_D_38 0x12800000 // System clock /38 +#define SYSCTL_DSLPCLKCFG_D_39 0x13000000 // System clock /39 +#define SYSCTL_DSLPCLKCFG_D_40 0x13800000 // System clock /40 +#define SYSCTL_DSLPCLKCFG_D_41 0x14000000 // System clock /41 +#define SYSCTL_DSLPCLKCFG_D_42 0x14800000 // System clock /42 +#define SYSCTL_DSLPCLKCFG_D_43 0x15000000 // System clock /43 +#define SYSCTL_DSLPCLKCFG_D_44 0x15800000 // System clock /44 +#define SYSCTL_DSLPCLKCFG_D_45 0x16000000 // System clock /45 +#define SYSCTL_DSLPCLKCFG_D_46 0x16800000 // System clock /46 +#define SYSCTL_DSLPCLKCFG_D_47 0x17000000 // System clock /47 +#define SYSCTL_DSLPCLKCFG_D_48 0x17800000 // System clock /48 +#define SYSCTL_DSLPCLKCFG_D_49 0x18000000 // System clock /49 +#define SYSCTL_DSLPCLKCFG_D_50 0x18800000 // System clock /50 +#define SYSCTL_DSLPCLKCFG_D_51 0x19000000 // System clock /51 +#define SYSCTL_DSLPCLKCFG_D_52 0x19800000 // System clock /52 +#define SYSCTL_DSLPCLKCFG_D_53 0x1A000000 // System clock /53 +#define SYSCTL_DSLPCLKCFG_D_54 0x1A800000 // System clock /54 +#define SYSCTL_DSLPCLKCFG_D_55 0x1B000000 // System clock /55 +#define SYSCTL_DSLPCLKCFG_D_56 0x1B800000 // System clock /56 +#define SYSCTL_DSLPCLKCFG_D_57 0x1C000000 // System clock /57 +#define SYSCTL_DSLPCLKCFG_D_58 0x1C800000 // System clock /58 +#define SYSCTL_DSLPCLKCFG_D_59 0x1D000000 // System clock /59 +#define SYSCTL_DSLPCLKCFG_D_60 0x1D800000 // System clock /60 +#define SYSCTL_DSLPCLKCFG_D_61 0x1E000000 // System clock /61 +#define SYSCTL_DSLPCLKCFG_D_62 0x1E800000 // System clock /62 +#define SYSCTL_DSLPCLKCFG_D_63 0x1F000000 // System clock /63 +#define SYSCTL_DSLPCLKCFG_D_64 0x1F800000 // System clock /64 +#define SYSCTL_DSLPCLKCFG_O_M 0x00000070 // Clock Source +#define SYSCTL_DSLPCLKCFG_O_IGN 0x00000000 // MOSC +#define SYSCTL_DSLPCLKCFG_O_IO 0x00000010 // PIOSC +#define SYSCTL_DSLPCLKCFG_O_30 0x00000030 // 30 kHz +#define SYSCTL_DSLPCLKCFG_O_32 0x00000070 // 32.768 kHz +#define SYSCTL_DSLPCLKCFG_IOSC 0x00000001 // IOSC Clock Source +#define SYSCTL_DSLPCLKCFG_D_S 23 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_PIOSCCAL +// register. +// +//***************************************************************************** +#define SYSCTL_PIOSCCAL_UTEN 0x80000000 // Use User Trim Value +#define SYSCTL_PIOSCCAL_CAL 0x00000200 // Start Calibration +#define SYSCTL_PIOSCCAL_UPDATE 0x00000100 // Update Trim +#define SYSCTL_PIOSCCAL_UT_M 0x0000007F // User Trim Value +#define SYSCTL_PIOSCCAL_UT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_CLKVCLR register. +// +//***************************************************************************** +#define SYSCTL_CLKVCLR_VERCLR 0x00000001 // Clock Verification Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_PIOSCSTAT +// register. +// +//***************************************************************************** +#define SYSCTL_PIOSCSTAT_DT_M 0x007F0000 // Default Trim Value +#define SYSCTL_PIOSCSTAT_CR_M 0x00000300 // Calibration Result +#define SYSCTL_PIOSCSTAT_CRNONE 0x00000000 // Calibration has not been + // attempted +#define SYSCTL_PIOSCSTAT_CRPASS 0x00000100 // The last calibration operation + // completed to meet 1% accuracy +#define SYSCTL_PIOSCSTAT_CRFAIL 0x00000200 // The last calibration operation + // failed to meet 1% accuracy +#define SYSCTL_PIOSCSTAT_CT_M 0x0000007F // Calibration Trim Value +#define SYSCTL_PIOSCSTAT_DT_S 16 +#define SYSCTL_PIOSCSTAT_CT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_LDOARST register. +// +//***************************************************************************** +#define SYSCTL_LDOARST_LDOARST 0x00000001 // LDO Reset + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_I2SMCLKCFG +// register. +// +//***************************************************************************** +#define SYSCTL_I2SMCLKCFG_RXEN 0x80000000 // RX Clock Enable +#define SYSCTL_I2SMCLKCFG_RXI_M 0x3FF00000 // RX Clock Integer Input +#define SYSCTL_I2SMCLKCFG_RXF_M 0x000F0000 // RX Clock Fractional Input +#define SYSCTL_I2SMCLKCFG_TXEN 0x00008000 // TX Clock Enable +#define SYSCTL_I2SMCLKCFG_TXI_M 0x00003FF0 // TX Clock Integer Input +#define SYSCTL_I2SMCLKCFG_TXF_M 0x0000000F // TX Clock Fractional Input +#define SYSCTL_I2SMCLKCFG_RXI_S 20 +#define SYSCTL_I2SMCLKCFG_RXF_S 16 +#define SYSCTL_I2SMCLKCFG_TXI_S 4 +#define SYSCTL_I2SMCLKCFG_TXF_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC9 register. +// +//***************************************************************************** +#define SYSCTL_DC9_ADC1DC7 0x00800000 // ADC1 DC7 Present +#define SYSCTL_DC9_ADC1DC6 0x00400000 // ADC1 DC6 Present +#define SYSCTL_DC9_ADC1DC5 0x00200000 // ADC1 DC5 Present +#define SYSCTL_DC9_ADC1DC4 0x00100000 // ADC1 DC4 Present +#define SYSCTL_DC9_ADC1DC3 0x00080000 // ADC1 DC3 Present +#define SYSCTL_DC9_ADC1DC2 0x00040000 // ADC1 DC2 Present +#define SYSCTL_DC9_ADC1DC1 0x00020000 // ADC1 DC1 Present +#define SYSCTL_DC9_ADC1DC0 0x00010000 // ADC1 DC0 Present +#define SYSCTL_DC9_ADC0DC7 0x00000080 // ADC0 DC7 Present +#define SYSCTL_DC9_ADC0DC6 0x00000040 // ADC0 DC6 Present +#define SYSCTL_DC9_ADC0DC5 0x00000020 // ADC0 DC5 Present +#define SYSCTL_DC9_ADC0DC4 0x00000010 // ADC0 DC4 Present +#define SYSCTL_DC9_ADC0DC3 0x00000008 // ADC0 DC3 Present +#define SYSCTL_DC9_ADC0DC2 0x00000004 // ADC0 DC2 Present +#define SYSCTL_DC9_ADC0DC1 0x00000002 // ADC0 DC1 Present +#define SYSCTL_DC9_ADC0DC0 0x00000001 // ADC0 DC0 Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_NVMSTAT register. +// +//***************************************************************************** +#define SYSCTL_NVMSTAT_TPSW 0x00000010 // Third Party Software Present +#define SYSCTL_NVMSTAT_FWB 0x00000001 // 32 Word Flash Write Buffer + // Active + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the System Control register +// addresses. +// +//***************************************************************************** +#define SYSCTL_GPIOHSCTL 0x400FE06C // GPIO High-Speed Control +#define SYSCTL_USER0 0x400FE1E0 // NV User Register 0 +#define SYSCTL_USER1 0x400FE1E4 // NV User Register 1 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_DID0 +// register. +// +//***************************************************************************** +#define SYSCTL_DID0_VER_MASK 0x70000000 // DID0 version mask +#define SYSCTL_DID0_CLASS_MASK 0x00FF0000 // Device Class +#define SYSCTL_DID0_MAJ_MASK 0x0000FF00 // Major revision mask +#define SYSCTL_DID0_MAJ_A 0x00000000 // Major revision A +#define SYSCTL_DID0_MAJ_B 0x00000100 // Major revision B +#define SYSCTL_DID0_MAJ_C 0x00000200 // Major revision C +#define SYSCTL_DID0_MIN_MASK 0x000000FF // Minor revision mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_DID1 +// register. +// +//***************************************************************************** +#define SYSCTL_DID1_VER_MASK 0xF0000000 // Register version mask +#define SYSCTL_DID1_FAM_MASK 0x0F000000 // Family mask +#define SYSCTL_DID1_FAM_S 0x00000000 // Stellaris family +#define SYSCTL_DID1_PRTNO_MASK 0x00FF0000 // Part number mask +#define SYSCTL_DID1_PINCNT_MASK 0x0000E000 // Pin count +#define SYSCTL_DID1_TEMP_MASK 0x000000E0 // Temperature range mask +#define SYSCTL_DID1_PKG_MASK 0x00000018 // Package mask +#define SYSCTL_DID1_PKG_48QFP 0x00000008 // QFP package +#define SYSCTL_DID1_QUAL_MASK 0x00000003 // Qualification status mask +#define SYSCTL_DID1_PKG_28SOIC 0x00000000 // SOIC package +#define SYSCTL_DID1_PRTNO_SHIFT 16 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_DC0 +// register. +// +//***************************************************************************** +#define SYSCTL_DC0_SRAMSZ_MASK 0xFFFF0000 // SRAM size mask +#define SYSCTL_DC0_FLASHSZ_MASK 0x0000FFFF // Flash size mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_DC1 +// register. +// +//***************************************************************************** +#define SYSCTL_DC1_ADC 0x00010000 // ADC Module Present +#define SYSCTL_DC1_SYSDIV_MASK 0x0000F000 // Minimum system divider mask +#define SYSCTL_DC1_ADCSPD_MASK 0x00000F00 // ADC speed mask +#define SYSCTL_DC1_WDOG 0x00000008 // Watchdog present +#define SYSCTL_DC1_WDT 0x00000008 // Watchdog Timer Present + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_DC2 +// register. +// +//***************************************************************************** +#define SYSCTL_DC2_I2C 0x00001000 // I2C present +#define SYSCTL_DC2_QEI 0x00000100 // QEI present +#define SYSCTL_DC2_SSI 0x00000010 // SSI present + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_DC3 +// register. +// +//***************************************************************************** +#define SYSCTL_DC3_ADC7 0x00800000 // ADC7 Pin Present +#define SYSCTL_DC3_ADC6 0x00400000 // ADC6 Pin Present +#define SYSCTL_DC3_ADC5 0x00200000 // ADC5 Pin Present +#define SYSCTL_DC3_ADC4 0x00100000 // ADC4 Pin Present +#define SYSCTL_DC3_ADC3 0x00080000 // ADC3 Pin Present +#define SYSCTL_DC3_ADC2 0x00040000 // ADC2 Pin Present +#define SYSCTL_DC3_ADC1 0x00020000 // ADC1 Pin Present +#define SYSCTL_DC3_ADC0 0x00010000 // ADC0 Pin Present +#define SYSCTL_DC3_MC_FAULT0 0x00008000 // MC0 fault pin present + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// SYSCTL_PBORCTL register. +// +//***************************************************************************** +#define SYSCTL_PBORCTL_BOR_MASK 0x0000FFFC // BOR wait timer +#define SYSCTL_PBORCTL_BOR_SH 2 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// SYSCTL_LDOPCTL register. +// +//***************************************************************************** +#define SYSCTL_LDOPCTL_MASK 0x0000003F // Voltage adjust mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_SRCR0 +// register. +// +//***************************************************************************** +#define SYSCTL_SRCR0_ADC 0x00010000 // ADC0 Reset Control +#define SYSCTL_SRCR0_WDT 0x00000008 // WDT Reset Control + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_RESC +// register. +// +//***************************************************************************** +#define SYSCTL_RESC_WDOG 0x00000008 // Watchdog reset +#define SYSCTL_RESC_WDT 0x00000008 // Watchdog Timer Reset + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_RCC +// register. +// +//***************************************************************************** +#define SYSCTL_RCC_SYSDIV_MASK 0x07800000 // System clock divider +#define SYSCTL_RCC_USE_SYSDIV 0x00400000 // Use sytem clock divider +#define SYSCTL_RCC_USE_PWMDIV 0x00100000 // Use PWM clock divider +#define SYSCTL_RCC_PWMDIV_MASK 0x000E0000 // PWM clock divider +#define SYSCTL_RCC_OE 0x00001000 // PLL output enable +#define SYSCTL_RCC_XTAL_3_68MHz 0x00000140 // Using a 3.6864 MHz crystal +#define SYSCTL_RCC_XTAL_4MHz 0x00000180 // Using a 4 MHz crystal +#define SYSCTL_RCC_XTAL_MASK 0x000003C0 // Crystal attached to main osc +#define SYSCTL_RCC_OSCSRC_MASK 0x00000030 // Oscillator input select +#define SYSCTL_RCC_SYSDIV_SHIFT 23 // Shift to the SYSDIV field +#define SYSCTL_RCC_PWMDIV_SHIFT 17 // Shift to the PWMDIV field +#define SYSCTL_RCC_XTAL_SHIFT 6 // Shift to the XTAL field +#define SYSCTL_RCC_OSCSRC_SHIFT 4 // Shift to the OSCSRC field + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_PLLCFG +// register. +// +//***************************************************************************** +#define SYSCTL_PLLCFG_OD_MASK 0x0000C000 // Output divider +#define SYSCTL_PLLCFG_F_MASK 0x00003FE0 // PLL multiplier +#define SYSCTL_PLLCFG_R_MASK 0x0000001F // Input predivider +#define SYSCTL_PLLCFG_F_SHIFT 5 +#define SYSCTL_PLLCFG_R_SHIFT 0 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// SYSCTL_GPIOHSCTL register. +// +//***************************************************************************** +#define SYSCTL_GPIOHSCTL_PORTA 0x00000001 // Port A High-Speed +#define SYSCTL_GPIOHSCTL_PORTB 0x00000002 // Port B High-Speed +#define SYSCTL_GPIOHSCTL_PORTC 0x00000004 // Port C High-Speed +#define SYSCTL_GPIOHSCTL_PORTD 0x00000008 // Port D High-Speed +#define SYSCTL_GPIOHSCTL_PORTE 0x00000010 // Port E High-Speed +#define SYSCTL_GPIOHSCTL_PORTF 0x00000020 // Port F High-Speed +#define SYSCTL_GPIOHSCTL_PORTG 0x00000040 // Port G High-Speed +#define SYSCTL_GPIOHSCTL_PORTH 0x00000080 // Port H High-Speed + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_RCC2 +// register. +// +//***************************************************************************** +#define SYSCTL_RCC2_USEFRACT 0x40000000 // Use fractional divider +#define SYSCTL_RCC2_SYSDIV2_MSK 0x1F800000 // System clock divider +#define SYSCTL_RCC2_FRACT 0x00400000 // Fractional divide +#define SYSCTL_RCC2_OSCSRC2_MSK 0x00000070 // Oscillator input select + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_RCGC0 +// register. +// +//***************************************************************************** +#define SYSCTL_RCGC0_ADC 0x00010000 // ADC0 Clock Gating Control +#define SYSCTL_RCGC0_WDT 0x00000008 // WDT Clock Gating Control + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_SCGC0 +// register. +// +//***************************************************************************** +#define SYSCTL_SCGC0_ADC 0x00010000 // ADC0 Clock Gating Control +#define SYSCTL_SCGC0_WDT 0x00000008 // WDT Clock Gating Control + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_DCGC0 +// register. +// +//***************************************************************************** +#define SYSCTL_DCGC0_ADC 0x00010000 // ADC0 Clock Gating Control +#define SYSCTL_DCGC0_WDT 0x00000008 // WDT Clock Gating Control + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// SYSCTL_DSLPCLKCFG register. +// +//***************************************************************************** +#define SYSCTL_DSLPCLKCFG_D_MSK 0x1F800000 // Deep sleep system clock override +#define SYSCTL_DSLPCLKCFG_O_MSK 0x00000070 // Deep sleep oscillator override + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// SYSCTL_CLKVCLR register. +// +//***************************************************************************** +#define SYSCTL_CLKVCLR_CLR 0x00000001 // Clear clock verification fault + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// SYSCTL_LDOARST register. +// +//***************************************************************************** +#define SYSCTL_LDOARST_ARST 0x00000001 // Allow LDO to reset device + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_SRCR0, +// SYSCTL_RCGC0, SYSCTL_SCGC0, and SYSCTL_DCGC0 registers. +// +//***************************************************************************** +#define SYSCTL_SET0_CAN2 0x04000000 // CAN 2 module +#define SYSCTL_SET0_CAN1 0x02000000 // CAN 1 module +#define SYSCTL_SET0_CAN0 0x01000000 // CAN 0 module +#define SYSCTL_SET0_PWM 0x00100000 // PWM module +#define SYSCTL_SET0_ADC 0x00010000 // ADC module +#define SYSCTL_SET0_ADCSPD_MASK 0x00000F00 // ADC speed mask +#define SYSCTL_SET0_ADCSPD_125K 0x00000000 // 125Ksps ADC +#define SYSCTL_SET0_ADCSPD_250K 0x00000100 // 250Ksps ADC +#define SYSCTL_SET0_ADCSPD_500K 0x00000200 // 500Ksps ADC +#define SYSCTL_SET0_ADCSPD_1M 0x00000300 // 1Msps ADC +#define SYSCTL_SET0_HIB 0x00000040 // Hibernation module +#define SYSCTL_SET0_WDOG 0x00000008 // Watchdog module + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_SRCR1, +// SYSCTL_RCGC1, SYSCTL_SCGC1, and SYSCTL_DCGC1 registers. +// +//***************************************************************************** +#define SYSCTL_SET1_COMP2 0x04000000 // Analog comparator module 2 +#define SYSCTL_SET1_COMP1 0x02000000 // Analog comparator module 1 +#define SYSCTL_SET1_COMP0 0x01000000 // Analog comparator module 0 +#define SYSCTL_SET1_TIMER3 0x00080000 // Timer module 3 +#define SYSCTL_SET1_TIMER2 0x00040000 // Timer module 2 +#define SYSCTL_SET1_TIMER1 0x00020000 // Timer module 1 +#define SYSCTL_SET1_TIMER0 0x00010000 // Timer module 0 +#define SYSCTL_SET1_I2C1 0x00002000 // I2C module 1 +#define SYSCTL_SET1_I2C0 0x00001000 // I2C module 0 +#define SYSCTL_SET1_I2C 0x00001000 // I2C module +#define SYSCTL_SET1_QEI1 0x00000200 // QEI module 1 +#define SYSCTL_SET1_QEI 0x00000100 // QEI module +#define SYSCTL_SET1_QEI0 0x00000100 // QEI module 0 +#define SYSCTL_SET1_SSI1 0x00000020 // SSI module 1 +#define SYSCTL_SET1_SSI0 0x00000010 // SSI module 0 +#define SYSCTL_SET1_SSI 0x00000010 // SSI module +#define SYSCTL_SET1_UART2 0x00000004 // UART module 2 +#define SYSCTL_SET1_UART1 0x00000002 // UART module 1 +#define SYSCTL_SET1_UART0 0x00000001 // UART module 0 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_SRCR2, +// SYSCTL_RCGC2, SYSCTL_SCGC2, and SYSCTL_DCGC2 registers. +// +//***************************************************************************** +#define SYSCTL_SET2_ETH 0x50000000 // ETH module +#define SYSCTL_SET2_GPIOH 0x00000080 // GPIO H module +#define SYSCTL_SET2_GPIOG 0x00000040 // GPIO G module +#define SYSCTL_SET2_GPIOF 0x00000020 // GPIO F module +#define SYSCTL_SET2_GPIOE 0x00000010 // GPIO E module +#define SYSCTL_SET2_GPIOD 0x00000008 // GPIO D module +#define SYSCTL_SET2_GPIOC 0x00000004 // GPIO C module +#define SYSCTL_SET2_GPIOB 0x00000002 // GPIO B module +#define SYSCTL_SET2_GPIOA 0x00000001 // GIPO A module + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the SYSCTL_RIS, +// SYSCTL_IMC, and SYSCTL_IMS registers. +// +//***************************************************************************** +#define SYSCTL_INT_PLL_LOCK 0x00000040 // PLL lock interrupt +#define SYSCTL_INT_CUR_LIMIT 0x00000020 // Current limit interrupt +#define SYSCTL_INT_IOSC_FAIL 0x00000010 // Internal oscillator failure int +#define SYSCTL_INT_MOSC_FAIL 0x00000008 // Main oscillator failure int +#define SYSCTL_INT_POR 0x00000004 // Power on reset interrupt +#define SYSCTL_INT_BOR 0x00000002 // Brown out interrupt +#define SYSCTL_INT_PLL_FAIL 0x00000001 // PLL failure interrupt + +#endif + +#endif // __HW_SYSCTL_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_timer.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_timer.h new file mode 100644 index 00000000..2a2cac71 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_timer.h @@ -0,0 +1,474 @@ +//***************************************************************************** +// +// hw_timer.h - Defines and macros used when accessing the timer. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_TIMER_H__ +#define __HW_TIMER_H__ + +//***************************************************************************** +// +// The following are defines for the Timer register offsets. +// +//***************************************************************************** +#define TIMER_O_CFG 0x00000000 // GPTM Configuration +#define TIMER_O_TAMR 0x00000004 // GPTM Timer A Mode +#define TIMER_O_TBMR 0x00000008 // GPTM Timer B Mode +#define TIMER_O_CTL 0x0000000C // GPTM Control +#define TIMER_O_IMR 0x00000018 // GPTM Interrupt Mask +#define TIMER_O_RIS 0x0000001C // GPTM Raw Interrupt Status +#define TIMER_O_MIS 0x00000020 // GPTM Masked Interrupt Status +#define TIMER_O_ICR 0x00000024 // GPTM Interrupt Clear +#define TIMER_O_TAILR 0x00000028 // GPTM Timer A Interval Load +#define TIMER_O_TBILR 0x0000002C // GPTM Timer B Interval Load +#define TIMER_O_TAMATCHR 0x00000030 // GPTM Timer A Match +#define TIMER_O_TBMATCHR 0x00000034 // GPTM Timer B Match +#define TIMER_O_TAPR 0x00000038 // GPTM Timer A Prescale +#define TIMER_O_TBPR 0x0000003C // GPTM Timer B Prescale +#define TIMER_O_TAPMR 0x00000040 // GPTM TimerA Prescale Match +#define TIMER_O_TBPMR 0x00000044 // GPTM TimerB Prescale Match +#define TIMER_O_TAR 0x00000048 // GPTM Timer A +#define TIMER_O_TBR 0x0000004C // GPTM Timer B +#define TIMER_O_TAV 0x00000050 // GPTM Timer A Value +#define TIMER_O_TBV 0x00000054 // GPTM Timer B Value + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_CFG register. +// +//***************************************************************************** +#define TIMER_CFG_M 0x00000007 // GPTM Configuration +#define TIMER_CFG_32_BIT_TIMER 0x00000000 // 32-bit timer configuration +#define TIMER_CFG_32_BIT_RTC 0x00000001 // 32-bit real-time clock (RTC) + // counter configuration +#define TIMER_CFG_16_BIT 0x00000004 // 16-bit timer configuration. The + // function is controlled by bits + // 1:0 of GPTMTAMR and GPTMTBMR + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TAMR register. +// +//***************************************************************************** +#define TIMER_TAMR_TASNAPS 0x00000080 // GPTM Timer A Snap-Shot Mode +#define TIMER_TAMR_TAWOT 0x00000040 // GPTM Timer A Wait-on-Trigger +#define TIMER_TAMR_TAMIE 0x00000020 // GPTM Timer A Match Interrupt + // Enable +#define TIMER_TAMR_TACDIR 0x00000010 // GPTM Timer A Count Direction +#define TIMER_TAMR_TAAMS 0x00000008 // GPTM Timer A Alternate Mode + // Select +#define TIMER_TAMR_TACMR 0x00000004 // GPTM Timer A Capture Mode +#define TIMER_TAMR_TAMR_M 0x00000003 // GPTM Timer A Mode +#define TIMER_TAMR_TAMR_1_SHOT 0x00000001 // One-Shot Timer mode +#define TIMER_TAMR_TAMR_PERIOD 0x00000002 // Periodic Timer mode +#define TIMER_TAMR_TAMR_CAP 0x00000003 // Capture mode + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TBMR register. +// +//***************************************************************************** +#define TIMER_TBMR_TBSNAPS 0x00000080 // GPTM Timer B Snap-Shot Mode +#define TIMER_TBMR_TBWOT 0x00000040 // GPTM Timer B Wait-on-Trigger +#define TIMER_TBMR_TBMIE 0x00000020 // GPTM Timer B Match Interrupt + // Enable +#define TIMER_TBMR_TBCDIR 0x00000010 // GPTM Timer B Count Direction +#define TIMER_TBMR_TBAMS 0x00000008 // GPTM Timer B Alternate Mode + // Select +#define TIMER_TBMR_TBCMR 0x00000004 // GPTM Timer B Capture Mode +#define TIMER_TBMR_TBMR_M 0x00000003 // GPTM Timer B Mode +#define TIMER_TBMR_TBMR_1_SHOT 0x00000001 // One-Shot Timer mode +#define TIMER_TBMR_TBMR_PERIOD 0x00000002 // Periodic Timer mode +#define TIMER_TBMR_TBMR_CAP 0x00000003 // Capture mode + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_CTL register. +// +//***************************************************************************** +#define TIMER_CTL_TBPWML 0x00004000 // GPTM Timer B PWM Output Level +#define TIMER_CTL_TBOTE 0x00002000 // GPTM Timer B Output Trigger + // Enable +#define TIMER_CTL_TBEVENT_M 0x00000C00 // GPTM Timer B Event Mode +#define TIMER_CTL_TBEVENT_POS 0x00000000 // Positive edge +#define TIMER_CTL_TBEVENT_NEG 0x00000400 // Negative edge +#define TIMER_CTL_TBEVENT_BOTH 0x00000C00 // Both edges +#define TIMER_CTL_TBSTALL 0x00000200 // GPTM Timer B Stall Enable +#define TIMER_CTL_TBEN 0x00000100 // GPTM Timer B Enable +#define TIMER_CTL_TAPWML 0x00000040 // GPTM Timer A PWM Output Level +#define TIMER_CTL_TAOTE 0x00000020 // GPTM Timer A Output Trigger + // Enable +#define TIMER_CTL_RTCEN 0x00000010 // GPTM RTC Enable +#define TIMER_CTL_TAEVENT_M 0x0000000C // GPTM Timer A Event Mode +#define TIMER_CTL_TAEVENT_POS 0x00000000 // Positive edge +#define TIMER_CTL_TAEVENT_NEG 0x00000004 // Negative edge +#define TIMER_CTL_TAEVENT_BOTH 0x0000000C // Both edges +#define TIMER_CTL_TASTALL 0x00000002 // GPTM Timer A Stall Enable +#define TIMER_CTL_TAEN 0x00000001 // GPTM Timer A Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_IMR register. +// +//***************************************************************************** +#define TIMER_IMR_TBMIM 0x00000800 // GPTM Timer B Mode Match + // Interrupt Mask +#define TIMER_IMR_CBEIM 0x00000400 // GPTM Capture B Event Interrupt + // Mask +#define TIMER_IMR_CBMIM 0x00000200 // GPTM Capture B Match Interrupt + // Mask +#define TIMER_IMR_TBTOIM 0x00000100 // GPTM Timer B Time-Out Interrupt + // Mask +#define TIMER_IMR_TAMIM 0x00000010 // GPTM Timer A Mode Match + // Interrupt Mask +#define TIMER_IMR_RTCIM 0x00000008 // GPTM RTC Interrupt Mask +#define TIMER_IMR_CAEIM 0x00000004 // GPTM Capture A Event Interrupt + // Mask +#define TIMER_IMR_CAMIM 0x00000002 // GPTM Capture A Match Interrupt + // Mask +#define TIMER_IMR_TATOIM 0x00000001 // GPTM Timer A Time-Out Interrupt + // Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_RIS register. +// +//***************************************************************************** +#define TIMER_RIS_TBMRIS 0x00000800 // GPTM Timer B Mode Match Raw + // Interrupt +#define TIMER_RIS_CBERIS 0x00000400 // GPTM Capture B Event Raw + // Interrupt +#define TIMER_RIS_CBMRIS 0x00000200 // GPTM Capture B Match Raw + // Interrupt +#define TIMER_RIS_TBTORIS 0x00000100 // GPTM Timer B Time-Out Raw + // Interrupt +#define TIMER_RIS_TAMRIS 0x00000010 // GPTM Timer A Mode Match Raw + // Interrupt +#define TIMER_RIS_RTCRIS 0x00000008 // GPTM RTC Raw Interrupt +#define TIMER_RIS_CAERIS 0x00000004 // GPTM Capture A Event Raw + // Interrupt +#define TIMER_RIS_CAMRIS 0x00000002 // GPTM Capture A Match Raw + // Interrupt +#define TIMER_RIS_TATORIS 0x00000001 // GPTM Timer A Time-Out Raw + // Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_MIS register. +// +//***************************************************************************** +#define TIMER_MIS_TBMMIS 0x00000800 // GPTM Timer B Mode Match Masked + // Interrupt +#define TIMER_MIS_CBEMIS 0x00000400 // GPTM Capture B Event Masked + // Interrupt +#define TIMER_MIS_CBMMIS 0x00000200 // GPTM Capture B Match Masked + // Interrupt +#define TIMER_MIS_TBTOMIS 0x00000100 // GPTM Timer B Time-Out Masked + // Interrupt +#define TIMER_MIS_TAMMIS 0x00000010 // GPTM Timer A Mode Match Masked + // Interrupt +#define TIMER_MIS_RTCMIS 0x00000008 // GPTM RTC Masked Interrupt +#define TIMER_MIS_CAEMIS 0x00000004 // GPTM Capture A Event Masked + // Interrupt +#define TIMER_MIS_CAMMIS 0x00000002 // GPTM Capture A Match Masked + // Interrupt +#define TIMER_MIS_TATOMIS 0x00000001 // GPTM Timer A Time-Out Masked + // Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_ICR register. +// +//***************************************************************************** +#define TIMER_ICR_TBMCINT 0x00000800 // GPTM Timer B Mode Match + // Interrupt Clear +#define TIMER_ICR_CBECINT 0x00000400 // GPTM Capture B Event Interrupt + // Clear +#define TIMER_ICR_CBMCINT 0x00000200 // GPTM Capture B Match Interrupt + // Clear +#define TIMER_ICR_TBTOCINT 0x00000100 // GPTM Timer B Time-Out Interrupt + // Clear +#define TIMER_ICR_TAMCINT 0x00000010 // GPTM Timer A Mode Match + // Interrupt Clear +#define TIMER_ICR_RTCCINT 0x00000008 // GPTM RTC Interrupt Clear +#define TIMER_ICR_CAECINT 0x00000004 // GPTM Capture A Event Interrupt + // Clear +#define TIMER_ICR_CAMCINT 0x00000002 // GPTM Capture A Match Interrupt + // Clear +#define TIMER_ICR_TATOCINT 0x00000001 // GPTM Timer A Time-Out Raw + // Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TAILR register. +// +//***************************************************************************** +#define TIMER_TAILR_TAILRH_M 0xFFFF0000 // GPTM Timer A Interval Load + // Register High +#define TIMER_TAILR_TAILRL_M 0x0000FFFF // GPTM Timer A Interval Load + // Register Low +#define TIMER_TAILR_TAILRH_S 16 +#define TIMER_TAILR_TAILRL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TBILR register. +// +//***************************************************************************** +#define TIMER_TBILR_TBILRL_M 0x0000FFFF // GPTM Timer B Interval Load + // Register +#define TIMER_TBILR_TBILRL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TAMATCHR +// register. +// +//***************************************************************************** +#define TIMER_TAMATCHR_TAMRH_M 0xFFFF0000 // GPTM Timer A Match Register High +#define TIMER_TAMATCHR_TAMRL_M 0x0000FFFF // GPTM Timer A Match Register Low +#define TIMER_TAMATCHR_TAMRH_S 16 +#define TIMER_TAMATCHR_TAMRL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TBMATCHR +// register. +// +//***************************************************************************** +#define TIMER_TBMATCHR_TBMRL_M 0x0000FFFF // GPTM Timer B Match Register Low +#define TIMER_TBMATCHR_TBMRL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TAPR register. +// +//***************************************************************************** +#define TIMER_TAPR_TAPSR_M 0x000000FF // GPTM Timer A Prescale +#define TIMER_TAPR_TAPSR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TBPR register. +// +//***************************************************************************** +#define TIMER_TBPR_TBPSR_M 0x000000FF // GPTM Timer B Prescale +#define TIMER_TBPR_TBPSR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TAPMR register. +// +//***************************************************************************** +#define TIMER_TAPMR_TAPSMR_M 0x000000FF // GPTM TimerA Prescale Match +#define TIMER_TAPMR_TAPSMR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TBPMR register. +// +//***************************************************************************** +#define TIMER_TBPMR_TBPSMR_M 0x000000FF // GPTM TimerB Prescale Match +#define TIMER_TBPMR_TBPSMR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TAR register. +// +//***************************************************************************** +#define TIMER_TAR_TARH_M 0xFFFF0000 // GPTM Timer A Register High +#define TIMER_TAR_TARL_M 0x0000FFFF // GPTM Timer A Register Low +#define TIMER_TAR_TARH_S 16 +#define TIMER_TAR_TARL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TBR register. +// +//***************************************************************************** +#define TIMER_TBR_TBRL_M 0x00FFFFFF // GPTM Timer B +#define TIMER_TBR_TBRL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TAV register. +// +//***************************************************************************** +#define TIMER_TAV_TAVH_M 0xFFFF0000 // GPTM Timer A Value High +#define TIMER_TAV_TAVL_M 0x0000FFFF // GPTM Timer A Register Low +#define TIMER_TAV_TAVH_S 16 +#define TIMER_TAV_TAVL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TBV register. +// +//***************************************************************************** +#define TIMER_TBV_TBVL_M 0x0000FFFF // GPTM Timer B Register +#define TIMER_TBV_TBVL_S 0 + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the TIMER_O_CFG +// register. +// +//***************************************************************************** +#define TIMER_CFG_CFG_MSK 0x00000007 // Configuration options mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the TIMER_O_CTL +// register. +// +//***************************************************************************** +#define TIMER_CTL_TBEVENT_MSK 0x00000C00 // TimerB event mode mask +#define TIMER_CTL_TAEVENT_MSK 0x0000000C // TimerA event mode mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the TIMER_O_RIS +// register. +// +//***************************************************************************** +#define TIMER_RIS_CBEMIS 0x00000400 // CaptureB event masked int status +#define TIMER_RIS_CBMMIS 0x00000200 // CaptureB match masked int status +#define TIMER_RIS_TBTOMIS 0x00000100 // TimerB time out masked int stat +#define TIMER_RIS_RTCMIS 0x00000008 // RTC masked int status +#define TIMER_RIS_CAEMIS 0x00000004 // CaptureA event masked int status +#define TIMER_RIS_CAMMIS 0x00000002 // CaptureA match masked int status +#define TIMER_RIS_TATOMIS 0x00000001 // TimerA time out masked int stat + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the TIMER_O_TAILR +// register. +// +//***************************************************************************** +#define TIMER_TAILR_TAILRH 0xFFFF0000 // TimerB load val in 32 bit mode +#define TIMER_TAILR_TAILRL 0x0000FFFF // TimerA interval load value + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the TIMER_O_TBILR +// register. +// +//***************************************************************************** +#define TIMER_TBILR_TBILRL 0x0000FFFF // TimerB interval load value + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// TIMER_O_TAMATCHR register. +// +//***************************************************************************** +#define TIMER_TAMATCHR_TAMRH 0xFFFF0000 // TimerB match val in 32 bit mode +#define TIMER_TAMATCHR_TAMRL 0x0000FFFF // TimerA match value + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// TIMER_O_TBMATCHR register. +// +//***************************************************************************** +#define TIMER_TBMATCHR_TBMRL 0x0000FFFF // TimerB match load value + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the TIMER_O_TAR +// register. +// +//***************************************************************************** +#define TIMER_TAR_TARH 0xFFFF0000 // TimerB val in 32 bit mode +#define TIMER_TAR_TARL 0x0000FFFF // TimerA value + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the TIMER_O_TBR +// register. +// +//***************************************************************************** +#define TIMER_TBR_TBRL 0x0000FFFF // TimerB value + +//***************************************************************************** +// +// The following are deprecated defines for the reset values of the timer +// registers. +// +//***************************************************************************** +#define TIMER_RV_TAILR 0xFFFFFFFF // TimerA interval load reg RV +#define TIMER_RV_TAR 0xFFFFFFFF // TimerA register RV +#define TIMER_RV_TAMATCHR 0xFFFFFFFF // TimerA match register RV +#define TIMER_RV_TBILR 0x0000FFFF // TimerB interval load reg RV +#define TIMER_RV_TBMATCHR 0x0000FFFF // TimerB match register RV +#define TIMER_RV_TBR 0x0000FFFF // TimerB register RV +#define TIMER_RV_TAPR 0x00000000 // TimerA prescale register RV +#define TIMER_RV_CFG 0x00000000 // Configuration register RV +#define TIMER_RV_TBPMR 0x00000000 // TimerB prescale match regi RV +#define TIMER_RV_TAPMR 0x00000000 // TimerA prescale match reg RV +#define TIMER_RV_CTL 0x00000000 // Control register RV +#define TIMER_RV_ICR 0x00000000 // Interrupt clear register RV +#define TIMER_RV_TBMR 0x00000000 // TimerB mode register RV +#define TIMER_RV_MIS 0x00000000 // Masked interrupt status reg RV +#define TIMER_RV_RIS 0x00000000 // Interrupt status register RV +#define TIMER_RV_TBPR 0x00000000 // TimerB prescale register RV +#define TIMER_RV_IMR 0x00000000 // Interrupt mask register RV +#define TIMER_RV_TAMR 0x00000000 // TimerA mode register RV + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the TIMER_TnMR +// register. +// +//***************************************************************************** +#define TIMER_TNMR_TNAMS 0x00000008 // Alternate mode select +#define TIMER_TNMR_TNCMR 0x00000004 // Capture mode - count or time +#define TIMER_TNMR_TNTMR_MSK 0x00000003 // Timer mode mask +#define TIMER_TNMR_TNTMR_1_SHOT 0x00000001 // Mode - one shot +#define TIMER_TNMR_TNTMR_PERIOD 0x00000002 // Mode - periodic +#define TIMER_TNMR_TNTMR_CAP 0x00000003 // Mode - capture + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the TIMER_TnPR +// register. +// +//***************************************************************************** +#define TIMER_TNPR_TNPSR 0x000000FF // TimerN prescale value + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the TIMER_TnPMR +// register. +// +//***************************************************************************** +#define TIMER_TNPMR_TNPSMR 0x000000FF // TimerN prescale match value + +#endif + +#endif // __HW_TIMER_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_types.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_types.h new file mode 100644 index 00000000..c62428aa --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_types.h @@ -0,0 +1,185 @@ +//***************************************************************************** +// +// hw_types.h - Common types and macros. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_TYPES_H__ +#define __HW_TYPES_H__ + +//***************************************************************************** +// +// Define a boolean type, and values for true and false. +// +//***************************************************************************** +typedef unsigned char tBoolean; + +#ifndef true +#define true 1 +#endif + +#ifndef false +#define false 0 +#endif + +//***************************************************************************** +// +// Macros for hardware access, both direct and via the bit-band region. +// +//***************************************************************************** +#define HWREG(x) \ + (*((volatile unsigned long *)(x))) +#define HWREGH(x) \ + (*((volatile unsigned short *)(x))) +#define HWREGB(x) \ + (*((volatile unsigned char *)(x))) +#define HWREGBITW(x, b) \ + HWREG(((unsigned long)(x) & 0xF0000000) | 0x02000000 | \ + (((unsigned long)(x) & 0x000FFFFF) << 5) | ((b) << 2)) +#define HWREGBITH(x, b) \ + HWREGH(((unsigned long)(x) & 0xF0000000) | 0x02000000 | \ + (((unsigned long)(x) & 0x000FFFFF) << 5) | ((b) << 2)) +#define HWREGBITB(x, b) \ + HWREGB(((unsigned long)(x) & 0xF0000000) | 0x02000000 | \ + (((unsigned long)(x) & 0x000FFFFF) << 5) | ((b) << 2)) + +//***************************************************************************** +// +// Helper Macros for determining silicon revisions, etc. +// +// These macros will be used by Driverlib at "run-time" to create necessary +// conditional code blocks that will allow a single version of the Driverlib +// "binary" code to support multiple(all) Stellaris silicon revisions. +// +// It is expected that these macros will be used inside of a standard 'C' +// conditional block of code, e.g. +// +// if(CLASS_IS_SANDSTORM) +// { +// do some Sandstorm-class specific code here. +// } +// +// By default, these macros will be defined as run-time checks of the +// appropriate register(s) to allow creation of run-time conditional code +// blocks for a common DriverLib across the entire Stellaris family. +// +// However, if code-space optimization is required, these macros can be "hard- +// coded" for a specific version of Stellaris silicon. Many compilers will +// then detect the "hard-coded" conditionals, and appropriately optimize the +// code blocks, eliminating any "unreachable" code. This would result in +// a smaller Driverlib, thus producing a smaller final application size, but +// at the cost of limiting the Driverlib binary to a specific Stellaris +// silicon revision. +// +//***************************************************************************** +#ifndef CLASS_IS_SANDSTORM +#define CLASS_IS_SANDSTORM \ + (((HWREG(SYSCTL_DID0) & SYSCTL_DID0_VER_M) == SYSCTL_DID0_VER_0) || \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_VER_M | SYSCTL_DID0_CLASS_M)) == \ + (SYSCTL_DID0_VER_1 | SYSCTL_DID0_CLASS_SANDSTORM))) +#endif + +#ifndef CLASS_IS_FURY +#define CLASS_IS_FURY \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_VER_M | SYSCTL_DID0_CLASS_M)) == \ + (SYSCTL_DID0_VER_1 | SYSCTL_DID0_CLASS_FURY)) +#endif + +#ifndef CLASS_IS_DUSTDEVIL +#define CLASS_IS_DUSTDEVIL \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_VER_M | SYSCTL_DID0_CLASS_M)) == \ + (SYSCTL_DID0_VER_1 | SYSCTL_DID0_CLASS_DUSTDEVIL)) +#endif + +#ifndef CLASS_IS_TEMPEST +#define CLASS_IS_TEMPEST \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_VER_M | SYSCTL_DID0_CLASS_M)) == \ + (SYSCTL_DID0_VER_1 | SYSCTL_DID0_CLASS_TEMPEST)) +#endif + +#ifndef REVISION_IS_A0 +#define REVISION_IS_A0 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVA | SYSCTL_DID0_MIN_0)) +#endif + +#ifndef REVISION_IS_A1 +#define REVISION_IS_A1 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVA | SYSCTL_DID0_MIN_0)) +#endif + +#ifndef REVISION_IS_A2 +#define REVISION_IS_A2 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVA | SYSCTL_DID0_MIN_2)) +#endif + +#ifndef REVISION_IS_B0 +#define REVISION_IS_B0 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVB | SYSCTL_DID0_MIN_0)) +#endif + +#ifndef REVISION_IS_B1 +#define REVISION_IS_B1 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVB | SYSCTL_DID0_MIN_1)) +#endif + +#ifndef REVISION_IS_C0 +#define REVISION_IS_C0 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVC | SYSCTL_DID0_MIN_0)) +#endif + +#ifndef REVISION_IS_C1 +#define REVISION_IS_C1 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVC | SYSCTL_DID0_MIN_1)) +#endif + +#ifndef REVISION_IS_C2 +#define REVISION_IS_C2 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVC | SYSCTL_DID0_MIN_2)) +#endif + +#ifndef REVISION_IS_C3 +#define REVISION_IS_C3 \ + ((HWREG(SYSCTL_DID0) & (SYSCTL_DID0_MAJ_M | SYSCTL_DID0_MIN_M)) == \ + (SYSCTL_DID0_MAJ_REVC | SYSCTL_DID0_MIN_3)) +#endif + +//***************************************************************************** +// +// Deprecated silicon class and revision detection macros. +// +//***************************************************************************** +#ifndef DEPRECATED +#define DEVICE_IS_SANDSTORM CLASS_IS_SANDSTORM +#define DEVICE_IS_FURY CLASS_IS_FURY +#define DEVICE_IS_REVA2 REVISION_IS_A2 +#define DEVICE_IS_REVC1 REVISION_IS_C1 +#define DEVICE_IS_REVC2 REVISION_IS_C2 +#endif + +#endif // __HW_TYPES_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_uart.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_uart.h new file mode 100644 index 00000000..b6613861 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_uart.h @@ -0,0 +1,458 @@ +//***************************************************************************** +// +// hw_uart.h - Macros and defines used when accessing the UART hardware. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_UART_H__ +#define __HW_UART_H__ + +//***************************************************************************** +// +// The following are defines for the UART register offsets. +// +//***************************************************************************** +#define UART_O_DR 0x00000000 // UART Data +#define UART_O_RSR 0x00000004 // UART Receive Status/Error Clear +#define UART_O_ECR 0x00000004 // UART Receive Status/Error Clear +#define UART_O_FR 0x00000018 // UART Flag +#define UART_O_ILPR 0x00000020 // UART IrDA Low-Power Register +#define UART_O_IBRD 0x00000024 // UART Integer Baud-Rate Divisor +#define UART_O_FBRD 0x00000028 // UART Fractional Baud-Rate + // Divisor +#define UART_O_LCRH 0x0000002C // UART Line Control +#define UART_O_CTL 0x00000030 // UART Control +#define UART_O_IFLS 0x00000034 // UART Interrupt FIFO Level Select +#define UART_O_IM 0x00000038 // UART Interrupt Mask +#define UART_O_RIS 0x0000003C // UART Raw Interrupt Status +#define UART_O_MIS 0x00000040 // UART Masked Interrupt Status +#define UART_O_ICR 0x00000044 // UART Interrupt Clear +#define UART_O_DMACTL 0x00000048 // UART DMA Control +#define UART_O_LCTL 0x00000090 // UART LIN Control +#define UART_O_LSS 0x00000094 // UART LIN Snap Shot +#define UART_O_LTIM 0x00000098 // UART LIN Timer + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_DR register. +// +//***************************************************************************** +#define UART_DR_OE 0x00000800 // UART Overrun Error +#define UART_DR_BE 0x00000400 // UART Break Error +#define UART_DR_PE 0x00000200 // UART Parity Error +#define UART_DR_FE 0x00000100 // UART Framing Error +#define UART_DR_DATA_M 0x000000FF // Data Transmitted or Received +#define UART_DR_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_RSR register. +// +//***************************************************************************** +#define UART_RSR_OE 0x00000008 // UART Overrun Error +#define UART_RSR_BE 0x00000004 // UART Break Error +#define UART_RSR_PE 0x00000002 // UART Parity Error +#define UART_RSR_FE 0x00000001 // UART Framing Error + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_ECR register. +// +//***************************************************************************** +#define UART_ECR_DATA_M 0x000000FF // Error Clear +#define UART_ECR_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_FR register. +// +//***************************************************************************** +#define UART_FR_RI 0x00000100 // Ring Indicator +#define UART_FR_TXFE 0x00000080 // UART Transmit FIFO Empty +#define UART_FR_RXFF 0x00000040 // UART Receive FIFO Full +#define UART_FR_TXFF 0x00000020 // UART Transmit FIFO Full +#define UART_FR_RXFE 0x00000010 // UART Receive FIFO Empty +#define UART_FR_BUSY 0x00000008 // UART Busy +#define UART_FR_DCD 0x00000004 // Data Carrier Detect +#define UART_FR_DSR 0x00000002 // Data Set Ready +#define UART_FR_CTS 0x00000001 // Clear To Send + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_ILPR register. +// +//***************************************************************************** +#define UART_ILPR_ILPDVSR_M 0x000000FF // IrDA Low-Power Divisor +#define UART_ILPR_ILPDVSR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_IBRD register. +// +//***************************************************************************** +#define UART_IBRD_DIVINT_M 0x0000FFFF // Integer Baud-Rate Divisor +#define UART_IBRD_DIVINT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_FBRD register. +// +//***************************************************************************** +#define UART_FBRD_DIVFRAC_M 0x0000003F // Fractional Baud-Rate Divisor +#define UART_FBRD_DIVFRAC_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_LCRH register. +// +//***************************************************************************** +#define UART_LCRH_SPS 0x00000080 // UART Stick Parity Select +#define UART_LCRH_WLEN_M 0x00000060 // UART Word Length +#define UART_LCRH_WLEN_5 0x00000000 // 5 bits (default) +#define UART_LCRH_WLEN_6 0x00000020 // 6 bits +#define UART_LCRH_WLEN_7 0x00000040 // 7 bits +#define UART_LCRH_WLEN_8 0x00000060 // 8 bits +#define UART_LCRH_FEN 0x00000010 // UART Enable FIFOs +#define UART_LCRH_STP2 0x00000008 // UART Two Stop Bits Select +#define UART_LCRH_EPS 0x00000004 // UART Even Parity Select +#define UART_LCRH_PEN 0x00000002 // UART Parity Enable +#define UART_LCRH_BRK 0x00000001 // UART Send Break + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_CTL register. +// +//***************************************************************************** +#define UART_CTL_CTSEN 0x00008000 // Enable Clear To Send +#define UART_CTL_RTSEN 0x00004000 // Enable Request to Send +#define UART_CTL_RTS 0x00000800 // Request to Send +#define UART_CTL_DTR 0x00000400 // Data Terminal Ready +#define UART_CTL_RXE 0x00000200 // UART Receive Enable +#define UART_CTL_TXE 0x00000100 // UART Transmit Enable +#define UART_CTL_LBE 0x00000080 // UART Loop Back Enable +#define UART_CTL_LIN 0x00000040 // LIN Mode Enable +#define UART_CTL_HSE 0x00000020 // High-Speed Enable +#define UART_CTL_EOT 0x00000010 // End of Transmission +#define UART_CTL_SMART 0x00000008 // ISO 7816 Smart Card Support +#define UART_CTL_SIRLP 0x00000004 // UART SIR Low-Power Mode +#define UART_CTL_SIREN 0x00000002 // UART SIR Enable +#define UART_CTL_UARTEN 0x00000001 // UART Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_IFLS register. +// +//***************************************************************************** +#define UART_IFLS_RX_M 0x00000038 // UART Receive Interrupt FIFO + // Level Select +#define UART_IFLS_RX1_8 0x00000000 // RX FIFO >= 1/8 full +#define UART_IFLS_RX2_8 0x00000008 // RX FIFO >= 1/4 full +#define UART_IFLS_RX4_8 0x00000010 // RX FIFO >= 1/2 full (default) +#define UART_IFLS_RX6_8 0x00000018 // RX FIFO >= 3/4 full +#define UART_IFLS_RX7_8 0x00000020 // RX FIFO >= 7/8 full +#define UART_IFLS_TX_M 0x00000007 // UART Transmit Interrupt FIFO + // Level Select +#define UART_IFLS_TX1_8 0x00000000 // TX FIFO <= 1/8 full +#define UART_IFLS_TX2_8 0x00000001 // TX FIFO <= 1/4 full +#define UART_IFLS_TX4_8 0x00000002 // TX FIFO <= 1/2 full (default) +#define UART_IFLS_TX6_8 0x00000003 // TX FIFO <= 3/4 full +#define UART_IFLS_TX7_8 0x00000004 // TX FIFO <= 7/8 full + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_IM register. +// +//***************************************************************************** +#define UART_IM_LME5IM 0x00008000 // LIN Mode Edge 5 Interrupt Mask +#define UART_IM_LME1IM 0x00004000 // LIN Mode Edge 1 Interrupt Mask +#define UART_IM_LMSBIM 0x00002000 // LIN Mode Sync Break Interrupt + // Mask +#define UART_IM_OEIM 0x00000400 // UART Overrun Error Interrupt + // Mask +#define UART_IM_BEIM 0x00000200 // UART Break Error Interrupt Mask +#define UART_IM_PEIM 0x00000100 // UART Parity Error Interrupt Mask +#define UART_IM_FEIM 0x00000080 // UART Framing Error Interrupt + // Mask +#define UART_IM_RTIM 0x00000040 // UART Receive Time-Out Interrupt + // Mask +#define UART_IM_TXIM 0x00000020 // UART Transmit Interrupt Mask +#define UART_IM_RXIM 0x00000010 // UART Receive Interrupt Mask +#define UART_IM_DSRMIM 0x00000008 // UART Data Set Ready Modem + // Interrupt Mask +#define UART_IM_DCDMIM 0x00000004 // UART Data Carrier Detect Modem + // Interrupt Mask +#define UART_IM_CTSMIM 0x00000002 // UART Clear to Send Modem + // Interrupt Mask +#define UART_IM_RIMIM 0x00000001 // UART Ring Indicator Modem + // Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_RIS register. +// +//***************************************************************************** +#define UART_RIS_LME5RIS 0x00008000 // LIN Mode Edge 5 Raw Interrupt + // Status +#define UART_RIS_LME1RIS 0x00004000 // LIN Mode Edge 1 Raw Interrupt + // Status +#define UART_RIS_LMSBRIS 0x00002000 // LIN Mode Sync Break Raw + // Interrupt Status +#define UART_RIS_OERIS 0x00000400 // UART Overrun Error Raw Interrupt + // Status +#define UART_RIS_BERIS 0x00000200 // UART Break Error Raw Interrupt + // Status +#define UART_RIS_PERIS 0x00000100 // UART Parity Error Raw Interrupt + // Status +#define UART_RIS_FERIS 0x00000080 // UART Framing Error Raw Interrupt + // Status +#define UART_RIS_RTRIS 0x00000040 // UART Receive Time-Out Raw + // Interrupt Status +#define UART_RIS_TXRIS 0x00000020 // UART Transmit Raw Interrupt + // Status +#define UART_RIS_RXRIS 0x00000010 // UART Receive Raw Interrupt + // Status +#define UART_RIS_DSRRIS 0x00000008 // UART Data Set Ready Modem Raw + // Interrupt Status +#define UART_RIS_DCDRIS 0x00000004 // UART Data Carrier Detect Modem + // Raw Interrupt Status +#define UART_RIS_CTSRIS 0x00000002 // UART Clear to Send Modem Raw + // Interrupt Status +#define UART_RIS_RIRIS 0x00000001 // UART Ring Indicator Modem Raw + // Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_MIS register. +// +//***************************************************************************** +#define UART_MIS_LME5MIS 0x00008000 // LIN Mode Edge 5 Masked Interrupt + // Status +#define UART_MIS_LME1MIS 0x00004000 // LIN Mode Edge 1 Masked Interrupt + // Status +#define UART_MIS_LMSBMIS 0x00002000 // LIN Mode Sync Break Masked + // Interrupt Status +#define UART_MIS_OEMIS 0x00000400 // UART Overrun Error Masked + // Interrupt Status +#define UART_MIS_BEMIS 0x00000200 // UART Break Error Masked + // Interrupt Status +#define UART_MIS_PEMIS 0x00000100 // UART Parity Error Masked + // Interrupt Status +#define UART_MIS_FEMIS 0x00000080 // UART Framing Error Masked + // Interrupt Status +#define UART_MIS_RTMIS 0x00000040 // UART Receive Time-Out Masked + // Interrupt Status +#define UART_MIS_TXMIS 0x00000020 // UART Transmit Masked Interrupt + // Status +#define UART_MIS_RXMIS 0x00000010 // UART Receive Masked Interrupt + // Status +#define UART_MIS_DSRMIS 0x00000008 // UART Data Set Ready Modem Masked + // Interrupt Status +#define UART_MIS_DCDMIS 0x00000004 // UART Data Carrier Detect Modem + // Masked Interrupt Status +#define UART_MIS_CTSMIS 0x00000002 // UART Clear to Send Modem Masked + // Interrupt Status +#define UART_MIS_RIMIS 0x00000001 // UART Ring Indicator Modem Masked + // Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_ICR register. +// +//***************************************************************************** +#define UART_ICR_LME5MIC 0x00008000 // LIN Mode Edge 5 Interrupt Clear +#define UART_ICR_LME1MIC 0x00004000 // LIN Mode Edge 1 Interrupt Clear +#define UART_ICR_LMSBMIC 0x00002000 // LIN Mode Sync Break Interrupt + // Clear +#define UART_ICR_OEIC 0x00000400 // Overrun Error Interrupt Clear +#define UART_ICR_BEIC 0x00000200 // Break Error Interrupt Clear +#define UART_ICR_PEIC 0x00000100 // Parity Error Interrupt Clear +#define UART_ICR_FEIC 0x00000080 // Framing Error Interrupt Clear +#define UART_ICR_RTIC 0x00000040 // Receive Time-Out Interrupt Clear +#define UART_ICR_TXIC 0x00000020 // Transmit Interrupt Clear +#define UART_ICR_RXIC 0x00000010 // Receive Interrupt Clear +#define UART_ICR_DSRMIC 0x00000008 // UART Data Set Ready Modem + // Interrupt Clear +#define UART_ICR_DCDMIC 0x00000004 // UART Data Carrier Detect Modem + // Interrupt Clear +#define UART_ICR_CTSMIC 0x00000002 // UART Clear to Send Modem + // Interrupt Clear +#define UART_ICR_RIMIC 0x00000001 // UART Ring Indicator Modem + // Interrupt Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_DMACTL register. +// +//***************************************************************************** +#define UART_DMACTL_DMAERR 0x00000004 // DMA on Error +#define UART_DMACTL_TXDMAE 0x00000002 // Transmit DMA Enable +#define UART_DMACTL_RXDMAE 0x00000001 // Receive DMA Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_LCTL register. +// +//***************************************************************************** +#define UART_LCTL_BLEN_M 0x00000030 // Sync Break Length +#define UART_LCTL_BLEN_13T 0x00000000 // Sync break length is 13T bits + // (default) +#define UART_LCTL_BLEN_14T 0x00000010 // Sync break length is 14T bits +#define UART_LCTL_BLEN_15T 0x00000020 // Sync break length is 15T bits +#define UART_LCTL_BLEN_16T 0x00000030 // Sync break length is 16T bits +#define UART_LCTL_MASTER 0x00000001 // LIN Master Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_LSS register. +// +//***************************************************************************** +#define UART_LSS_TSS_M 0x0000FFFF // Timer Snap Shot +#define UART_LSS_TSS_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_LTIM register. +// +//***************************************************************************** +#define UART_LTIM_TIMER_M 0x0000FFFF // Timer Value +#define UART_LTIM_TIMER_S 0 + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the UART register offsets. +// +//***************************************************************************** +#define UART_O_LCR_H 0x0000002C // Line Control Register, HIGH byte +#define UART_O_PeriphID4 0x00000FD0 +#define UART_O_PeriphID5 0x00000FD4 +#define UART_O_PeriphID6 0x00000FD8 +#define UART_O_PeriphID7 0x00000FDC +#define UART_O_PeriphID0 0x00000FE0 +#define UART_O_PeriphID1 0x00000FE4 +#define UART_O_PeriphID2 0x00000FE8 +#define UART_O_PeriphID3 0x00000FEC +#define UART_O_PCellID0 0x00000FF0 +#define UART_O_PCellID1 0x00000FF4 +#define UART_O_PCellID2 0x00000FF8 +#define UART_O_PCellID3 0x00000FFC + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the UART_O_DR +// register. +// +//***************************************************************************** +#define UART_DR_DATA_MASK 0x000000FF // UART data + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the UART_O_IBRD +// register. +// +//***************************************************************************** +#define UART_IBRD_DIVINT_MASK 0x0000FFFF // Integer baud-rate divisor + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the UART_O_FBRD +// register. +// +//***************************************************************************** +#define UART_FBRD_DIVFRAC_MASK 0x0000003F // Fractional baud-rate divisor + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the UART_O_LCR_H +// register. +// +//***************************************************************************** +#define UART_LCR_H_SPS 0x00000080 // Stick Parity Select +#define UART_LCR_H_WLEN 0x00000060 // Word length +#define UART_LCR_H_WLEN_5 0x00000000 // 5 bit data +#define UART_LCR_H_WLEN_6 0x00000020 // 6 bit data +#define UART_LCR_H_WLEN_7 0x00000040 // 7 bit data +#define UART_LCR_H_WLEN_8 0x00000060 // 8 bit data +#define UART_LCR_H_FEN 0x00000010 // Enable FIFO +#define UART_LCR_H_STP2 0x00000008 // Two Stop Bits Select +#define UART_LCR_H_EPS 0x00000004 // Even Parity Select +#define UART_LCR_H_PEN 0x00000002 // Parity Enable +#define UART_LCR_H_BRK 0x00000001 // Send Break + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the UART_O_IFLS +// register. +// +//***************************************************************************** +#define UART_IFLS_RX_MASK 0x00000038 // RX FIFO level mask +#define UART_IFLS_TX_MASK 0x00000007 // TX FIFO level mask + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the UART_O_ICR +// register. +// +//***************************************************************************** +#define UART_RSR_ANY (UART_RSR_OE | UART_RSR_BE | UART_RSR_PE | \ + UART_RSR_FE) + +//***************************************************************************** +// +// The following are deprecated defines for the Reset Values for UART +// Registers. +// +//***************************************************************************** +#define UART_RV_CTL 0x00000300 +#define UART_RV_PCellID1 0x000000F0 +#define UART_RV_PCellID3 0x000000B1 +#define UART_RV_FR 0x00000090 +#define UART_RV_PeriphID2 0x00000018 +#define UART_RV_IFLS 0x00000012 +#define UART_RV_PeriphID0 0x00000011 +#define UART_RV_PCellID0 0x0000000D +#define UART_RV_PCellID2 0x00000005 +#define UART_RV_PeriphID3 0x00000001 +#define UART_RV_PeriphID4 0x00000000 +#define UART_RV_LCR_H 0x00000000 +#define UART_RV_PeriphID6 0x00000000 +#define UART_RV_DR 0x00000000 +#define UART_RV_RSR 0x00000000 +#define UART_RV_ECR 0x00000000 +#define UART_RV_PeriphID5 0x00000000 +#define UART_RV_RIS 0x00000000 +#define UART_RV_FBRD 0x00000000 +#define UART_RV_IM 0x00000000 +#define UART_RV_MIS 0x00000000 +#define UART_RV_ICR 0x00000000 +#define UART_RV_PeriphID1 0x00000000 +#define UART_RV_PeriphID7 0x00000000 +#define UART_RV_IBRD 0x00000000 + +#endif + +#endif // __HW_UART_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_udma.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_udma.h new file mode 100644 index 00000000..6f6270b1 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_udma.h @@ -0,0 +1,331 @@ +//***************************************************************************** +// +// hw_udma.h - Macros for use in accessing the UDMA registers. +// +// Copyright (c) 2007-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_UDMA_H__ +#define __HW_UDMA_H__ + +//***************************************************************************** +// +// The following are defines for the Micro Direct Memory Access register +// addresses. +// +//***************************************************************************** +#define UDMA_STAT 0x400FF000 // DMA Status +#define UDMA_CFG 0x400FF004 // DMA Configuration +#define UDMA_CTLBASE 0x400FF008 // DMA Channel Control Base Pointer +#define UDMA_ALTBASE 0x400FF00C // DMA Alternate Channel Control + // Base Pointer +#define UDMA_WAITSTAT 0x400FF010 // DMA Channel Wait-on-Request + // Status +#define UDMA_SWREQ 0x400FF014 // DMA Channel Software Request +#define UDMA_USEBURSTSET 0x400FF018 // DMA Channel Useburst Set +#define UDMA_USEBURSTCLR 0x400FF01C // DMA Channel Useburst Clear +#define UDMA_REQMASKSET 0x400FF020 // DMA Channel Request Mask Set +#define UDMA_REQMASKCLR 0x400FF024 // DMA Channel Request Mask Clear +#define UDMA_ENASET 0x400FF028 // DMA Channel Enable Set +#define UDMA_ENACLR 0x400FF02C // DMA Channel Enable Clear +#define UDMA_ALTSET 0x400FF030 // DMA Channel Primary Alternate + // Set +#define UDMA_ALTCLR 0x400FF034 // DMA Channel Primary Alternate + // Clear +#define UDMA_PRIOSET 0x400FF038 // DMA Channel Priority Set +#define UDMA_PRIOCLR 0x400FF03C // DMA Channel Priority Clear +#define UDMA_ERRCLR 0x400FF04C // DMA Bus Error Clear +#define UDMA_CHASGN 0x400FF500 // DMA Channel Assignment + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_STAT register. +// +//***************************************************************************** +#define UDMA_STAT_DMACHANS_M 0x001F0000 // Available uDMA Channels Minus 1 +#define UDMA_STAT_STATE_M 0x000000F0 // Control State Machine Status +#define UDMA_STAT_STATE_IDLE 0x00000000 // Idle +#define UDMA_STAT_STATE_RD_CTRL 0x00000010 // Reading channel controller data +#define UDMA_STAT_STATE_RD_SRCENDP \ + 0x00000020 // Reading source end pointer +#define UDMA_STAT_STATE_RD_DSTENDP \ + 0x00000030 // Reading destination end pointer +#define UDMA_STAT_STATE_RD_SRCDAT \ + 0x00000040 // Reading source data +#define UDMA_STAT_STATE_WR_DSTDAT \ + 0x00000050 // Writing destination data +#define UDMA_STAT_STATE_WAIT 0x00000060 // Waiting for uDMA request to + // clear +#define UDMA_STAT_STATE_WR_CTRL 0x00000070 // Writing channel controller data +#define UDMA_STAT_STATE_STALL 0x00000080 // Stalled +#define UDMA_STAT_STATE_DONE 0x00000090 // Done +#define UDMA_STAT_STATE_UNDEF 0x000000A0 // Undefined +#define UDMA_STAT_MASTEN 0x00000001 // Master Enable Status +#define UDMA_STAT_DMACHANS_S 16 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_CFG register. +// +//***************************************************************************** +#define UDMA_CFG_MASTEN 0x00000001 // Controller Master Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_CTLBASE register. +// +//***************************************************************************** +#define UDMA_CTLBASE_ADDR_M 0xFFFFFC00 // Channel Control Base Address +#define UDMA_CTLBASE_ADDR_S 10 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_ALTBASE register. +// +//***************************************************************************** +#define UDMA_ALTBASE_ADDR_M 0xFFFFFFFF // Alternate Channel Address + // Pointer +#define UDMA_ALTBASE_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_WAITSTAT register. +// +//***************************************************************************** +#define UDMA_WAITSTAT_WAITREQ_M 0xFFFFFFFF // Channel [n] Wait Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_SWREQ register. +// +//***************************************************************************** +#define UDMA_SWREQ_M 0xFFFFFFFF // Channel [n] Software Request + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_USEBURSTSET +// register. +// +//***************************************************************************** +#define UDMA_USEBURSTSET_SET_M 0xFFFFFFFF // Channel [n] Useburst Set + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_USEBURSTCLR +// register. +// +//***************************************************************************** +#define UDMA_USEBURSTCLR_CLR_M 0xFFFFFFFF // Channel [n] Useburst Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_REQMASKSET +// register. +// +//***************************************************************************** +#define UDMA_REQMASKSET_SET_M 0xFFFFFFFF // Channel [n] Request Mask Set + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_REQMASKCLR +// register. +// +//***************************************************************************** +#define UDMA_REQMASKCLR_CLR_M 0xFFFFFFFF // Channel [n] Request Mask Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_ENASET register. +// +//***************************************************************************** +#define UDMA_ENASET_SET_M 0xFFFFFFFF // Channel [n] Enable Set + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_ENACLR register. +// +//***************************************************************************** +#define UDMA_ENACLR_CLR_M 0xFFFFFFFF // Clear Channel [n] Enable Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_ALTSET register. +// +//***************************************************************************** +#define UDMA_ALTSET_SET_M 0xFFFFFFFF // Channel [n] Alternate Set + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_ALTCLR register. +// +//***************************************************************************** +#define UDMA_ALTCLR_CLR_M 0xFFFFFFFF // Channel [n] Alternate Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_PRIOSET register. +// +//***************************************************************************** +#define UDMA_PRIOSET_SET_M 0xFFFFFFFF // Channel [n] Priority Set + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_PRIOCLR register. +// +//***************************************************************************** +#define UDMA_PRIOCLR_CLR_M 0xFFFFFFFF // Channel [n] Priority Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_ERRCLR register. +// +//***************************************************************************** +#define UDMA_ERRCLR_ERRCLR 0x00000001 // uDMA Bus Error Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_CHASGN register. +// +//***************************************************************************** +#define UDMA_CHASGN_M 0xFFFFFFFF // Channel [n] Assignment Select +#define UDMA_CHASGN_PRIMARY 0x00000000 // Use the primary channel + // assignment +#define UDMA_CHASGN_SECONDARY 0x00000001 // Use the secondary channel + // assignment + +//***************************************************************************** +// +// The following are defines for the Micro Direct Memory Access (uDMA) offsets. +// +//***************************************************************************** +#define UDMA_O_SRCENDP 0x00000000 // DMA Channel Source Address End + // Pointer +#define UDMA_O_DSTENDP 0x00000004 // DMA Channel Destination Address + // End Pointer +#define UDMA_O_CHCTL 0x00000008 // DMA Channel Control Word + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_O_SRCENDP register. +// +//***************************************************************************** +#define UDMA_SRCENDP_ADDR_M 0xFFFFFFFF // Source Address End Pointer +#define UDMA_SRCENDP_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_O_DSTENDP register. +// +//***************************************************************************** +#define UDMA_DSTENDP_ADDR_M 0xFFFFFFFF // Destination Address End Pointer +#define UDMA_DSTENDP_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UDMA_O_CHCTL register. +// +//***************************************************************************** +#define UDMA_CHCTL_DSTINC_M 0xC0000000 // Destination Address Increment +#define UDMA_CHCTL_DSTINC_8 0x00000000 // Byte +#define UDMA_CHCTL_DSTINC_16 0x40000000 // Half-word +#define UDMA_CHCTL_DSTINC_32 0x80000000 // Word +#define UDMA_CHCTL_DSTINC_NONE 0xC0000000 // No increment +#define UDMA_CHCTL_DSTSIZE_M 0x30000000 // Destination Data Size +#define UDMA_CHCTL_DSTSIZE_8 0x00000000 // Byte +#define UDMA_CHCTL_DSTSIZE_16 0x10000000 // Half-word +#define UDMA_CHCTL_DSTSIZE_32 0x20000000 // Word +#define UDMA_CHCTL_SRCINC_M 0x0C000000 // Source Address Increment +#define UDMA_CHCTL_SRCINC_8 0x00000000 // Byte +#define UDMA_CHCTL_SRCINC_16 0x04000000 // Half-word +#define UDMA_CHCTL_SRCINC_32 0x08000000 // Word +#define UDMA_CHCTL_SRCINC_NONE 0x0C000000 // No increment +#define UDMA_CHCTL_SRCSIZE_M 0x03000000 // Source Data Size +#define UDMA_CHCTL_SRCSIZE_8 0x00000000 // Byte +#define UDMA_CHCTL_SRCSIZE_16 0x01000000 // Half-word +#define UDMA_CHCTL_SRCSIZE_32 0x02000000 // Word +#define UDMA_CHCTL_ARBSIZE_M 0x0003C000 // Arbitration Size +#define UDMA_CHCTL_ARBSIZE_1 0x00000000 // 1 Transfer +#define UDMA_CHCTL_ARBSIZE_2 0x00004000 // 2 Transfers +#define UDMA_CHCTL_ARBSIZE_4 0x00008000 // 4 Transfers +#define UDMA_CHCTL_ARBSIZE_8 0x0000C000 // 8 Transfers +#define UDMA_CHCTL_ARBSIZE_16 0x00010000 // 16 Transfers +#define UDMA_CHCTL_ARBSIZE_32 0x00014000 // 32 Transfers +#define UDMA_CHCTL_ARBSIZE_64 0x00018000 // 64 Transfers +#define UDMA_CHCTL_ARBSIZE_128 0x0001C000 // 128 Transfers +#define UDMA_CHCTL_ARBSIZE_256 0x00020000 // 256 Transfers +#define UDMA_CHCTL_ARBSIZE_512 0x00024000 // 512 Transfers +#define UDMA_CHCTL_ARBSIZE_1024 0x00028000 // 1024 Transfers +#define UDMA_CHCTL_XFERSIZE_M 0x00003FF0 // Transfer Size (minus 1) +#define UDMA_CHCTL_NXTUSEBURST 0x00000008 // Next Useburst +#define UDMA_CHCTL_XFERMODE_M 0x00000007 // uDMA Transfer Mode +#define UDMA_CHCTL_XFERMODE_STOP \ + 0x00000000 // Stop +#define UDMA_CHCTL_XFERMODE_BASIC \ + 0x00000001 // Basic +#define UDMA_CHCTL_XFERMODE_AUTO \ + 0x00000002 // Auto-Request +#define UDMA_CHCTL_XFERMODE_PINGPONG \ + 0x00000003 // Ping-Pong +#define UDMA_CHCTL_XFERMODE_MEM_SG \ + 0x00000004 // Memory Scatter-Gather +#define UDMA_CHCTL_XFERMODE_MEM_SGA \ + 0x00000005 // Alternate Memory Scatter-Gather +#define UDMA_CHCTL_XFERMODE_PER_SG \ + 0x00000006 // Peripheral Scatter-Gather +#define UDMA_CHCTL_XFERMODE_PER_SGA \ + 0x00000007 // Alternate Peripheral + // Scatter-Gather +#define UDMA_CHCTL_XFERSIZE_S 4 + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the Micro Direct Memory Access +// register addresses. +// +//***************************************************************************** +#define UDMA_CHALT 0x400FF500 // DMA Channel Alternate Select + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the UDMA_ENASET +// register. +// +//***************************************************************************** +#define UDMA_ENASET_CHENSET_M 0xFFFFFFFF // Channel [n] Enable Set + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the UDMA_CHALT +// register. +// +//***************************************************************************** +#define UDMA_CHALT_M 0xFFFFFFFF // Channel [n] Alternate Assignment + // Select + +#endif + +#endif // __HW_UDMA_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_usb.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_usb.h new file mode 100644 index 00000000..0dda4a4c --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_usb.h @@ -0,0 +1,4620 @@ +//***************************************************************************** +// +// hw_usb.h - Macros for use in accessing the USB registers. +// +// Copyright (c) 2007-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_USB_H__ +#define __HW_USB_H__ + +//***************************************************************************** +// +// The following are defines for the Univeral Serial Bus register offsets. +// +//***************************************************************************** +#define USB_O_FADDR 0x00000000 // USB Device Functional Address +#define USB_O_POWER 0x00000001 // USB Power +#define USB_O_TXIS 0x00000002 // USB Transmit Interrupt Status +#define USB_O_RXIS 0x00000004 // USB Receive Interrupt Status +#define USB_O_TXIE 0x00000006 // USB Transmit Interrupt Enable +#define USB_O_RXIE 0x00000008 // USB Receive Interrupt Enable +#define USB_O_IS 0x0000000A // USB General Interrupt Status +#define USB_O_IE 0x0000000B // USB Interrupt Enable +#define USB_O_FRAME 0x0000000C // USB Frame Value +#define USB_O_EPIDX 0x0000000E // USB Endpoint Index +#define USB_O_TEST 0x0000000F // USB Test Mode +#define USB_O_FIFO0 0x00000020 // USB FIFO Endpoint 0 +#define USB_O_FIFO1 0x00000024 // USB FIFO Endpoint 1 +#define USB_O_FIFO2 0x00000028 // USB FIFO Endpoint 2 +#define USB_O_FIFO3 0x0000002C // USB FIFO Endpoint 3 +#define USB_O_FIFO4 0x00000030 // USB FIFO Endpoint 4 +#define USB_O_FIFO5 0x00000034 // USB FIFO Endpoint 5 +#define USB_O_FIFO6 0x00000038 // USB FIFO Endpoint 6 +#define USB_O_FIFO7 0x0000003C // USB FIFO Endpoint 7 +#define USB_O_FIFO8 0x00000040 // USB FIFO Endpoint 8 +#define USB_O_FIFO9 0x00000044 // USB FIFO Endpoint 9 +#define USB_O_FIFO10 0x00000048 // USB FIFO Endpoint 10 +#define USB_O_FIFO11 0x0000004C // USB FIFO Endpoint 11 +#define USB_O_FIFO12 0x00000050 // USB FIFO Endpoint 12 +#define USB_O_FIFO13 0x00000054 // USB FIFO Endpoint 13 +#define USB_O_FIFO14 0x00000058 // USB FIFO Endpoint 14 +#define USB_O_FIFO15 0x0000005C // USB FIFO Endpoint 15 +#define USB_O_DEVCTL 0x00000060 // USB Device Control +#define USB_O_TXFIFOSZ 0x00000062 // USB Transmit Dynamic FIFO Sizing +#define USB_O_RXFIFOSZ 0x00000063 // USB Receive Dynamic FIFO Sizing +#define USB_O_TXFIFOADD 0x00000064 // USB Transmit FIFO Start Address +#define USB_O_RXFIFOADD 0x00000066 // USB Receive FIFO Start Address +#define USB_O_CONTIM 0x0000007A // USB Connect Timing +#define USB_O_VPLEN 0x0000007B // USB OTG VBUS Pulse Timing +#define USB_O_FSEOF 0x0000007D // USB Full-Speed Last Transaction + // to End of Frame Timing +#define USB_O_LSEOF 0x0000007E // USB Low-Speed Last Transaction + // to End of Frame Timing +#define USB_O_TXFUNCADDR0 0x00000080 // USB Transmit Functional Address + // Endpoint 0 +#define USB_O_TXHUBADDR0 0x00000082 // USB Transmit Hub Address + // Endpoint 0 +#define USB_O_TXHUBPORT0 0x00000083 // USB Transmit Hub Port Endpoint 0 +#define USB_O_TXFUNCADDR1 0x00000088 // USB Transmit Functional Address + // Endpoint 1 +#define USB_O_TXHUBADDR1 0x0000008A // USB Transmit Hub Address + // Endpoint 1 +#define USB_O_TXHUBPORT1 0x0000008B // USB Transmit Hub Port Endpoint 1 +#define USB_O_RXFUNCADDR1 0x0000008C // USB Receive Functional Address + // Endpoint 1 +#define USB_O_RXHUBADDR1 0x0000008E // USB Receive Hub Address Endpoint + // 1 +#define USB_O_RXHUBPORT1 0x0000008F // USB Receive Hub Port Endpoint 1 +#define USB_O_TXFUNCADDR2 0x00000090 // USB Transmit Functional Address + // Endpoint 2 +#define USB_O_TXHUBADDR2 0x00000092 // USB Transmit Hub Address + // Endpoint 2 +#define USB_O_TXHUBPORT2 0x00000093 // USB Transmit Hub Port Endpoint 2 +#define USB_O_RXFUNCADDR2 0x00000094 // USB Receive Functional Address + // Endpoint 2 +#define USB_O_RXHUBADDR2 0x00000096 // USB Receive Hub Address Endpoint + // 2 +#define USB_O_RXHUBPORT2 0x00000097 // USB Receive Hub Port Endpoint 2 +#define USB_O_TXFUNCADDR3 0x00000098 // USB Transmit Functional Address + // Endpoint 3 +#define USB_O_TXHUBADDR3 0x0000009A // USB Transmit Hub Address + // Endpoint 3 +#define USB_O_TXHUBPORT3 0x0000009B // USB Transmit Hub Port Endpoint 3 +#define USB_O_RXFUNCADDR3 0x0000009C // USB Receive Functional Address + // Endpoint 3 +#define USB_O_RXHUBADDR3 0x0000009E // USB Receive Hub Address Endpoint + // 3 +#define USB_O_RXHUBPORT3 0x0000009F // USB Receive Hub Port Endpoint 3 +#define USB_O_TXFUNCADDR4 0x000000A0 // USB Transmit Functional Address + // Endpoint 4 +#define USB_O_TXHUBADDR4 0x000000A2 // USB Transmit Hub Address + // Endpoint 4 +#define USB_O_TXHUBPORT4 0x000000A3 // USB Transmit Hub Port Endpoint 4 +#define USB_O_RXFUNCADDR4 0x000000A4 // USB Receive Functional Address + // Endpoint 4 +#define USB_O_RXHUBADDR4 0x000000A6 // USB Receive Hub Address Endpoint + // 4 +#define USB_O_RXHUBPORT4 0x000000A7 // USB Receive Hub Port Endpoint 4 +#define USB_O_TXFUNCADDR5 0x000000A8 // USB Transmit Functional Address + // Endpoint 5 +#define USB_O_TXHUBADDR5 0x000000AA // USB Transmit Hub Address + // Endpoint 5 +#define USB_O_TXHUBPORT5 0x000000AB // USB Transmit Hub Port Endpoint 5 +#define USB_O_RXFUNCADDR5 0x000000AC // USB Receive Functional Address + // Endpoint 5 +#define USB_O_RXHUBADDR5 0x000000AE // USB Receive Hub Address Endpoint + // 5 +#define USB_O_RXHUBPORT5 0x000000AF // USB Receive Hub Port Endpoint 5 +#define USB_O_TXFUNCADDR6 0x000000B0 // USB Transmit Functional Address + // Endpoint 6 +#define USB_O_TXHUBADDR6 0x000000B2 // USB Transmit Hub Address + // Endpoint 6 +#define USB_O_TXHUBPORT6 0x000000B3 // USB Transmit Hub Port Endpoint 6 +#define USB_O_RXFUNCADDR6 0x000000B4 // USB Receive Functional Address + // Endpoint 6 +#define USB_O_RXHUBADDR6 0x000000B6 // USB Receive Hub Address Endpoint + // 6 +#define USB_O_RXHUBPORT6 0x000000B7 // USB Receive Hub Port Endpoint 6 +#define USB_O_TXFUNCADDR7 0x000000B8 // USB Transmit Functional Address + // Endpoint 7 +#define USB_O_TXHUBADDR7 0x000000BA // USB Transmit Hub Address + // Endpoint 7 +#define USB_O_TXHUBPORT7 0x000000BB // USB Transmit Hub Port Endpoint 7 +#define USB_O_RXFUNCADDR7 0x000000BC // USB Receive Functional Address + // Endpoint 7 +#define USB_O_RXHUBADDR7 0x000000BE // USB Receive Hub Address Endpoint + // 7 +#define USB_O_RXHUBPORT7 0x000000BF // USB Receive Hub Port Endpoint 7 +#define USB_O_TXFUNCADDR8 0x000000C0 // USB Transmit Functional Address + // Endpoint 8 +#define USB_O_TXHUBADDR8 0x000000C2 // USB Transmit Hub Address + // Endpoint 8 +#define USB_O_TXHUBPORT8 0x000000C3 // USB Transmit Hub Port Endpoint 8 +#define USB_O_RXFUNCADDR8 0x000000C4 // USB Receive Functional Address + // Endpoint 8 +#define USB_O_RXHUBADDR8 0x000000C6 // USB Receive Hub Address Endpoint + // 8 +#define USB_O_RXHUBPORT8 0x000000C7 // USB Receive Hub Port Endpoint 8 +#define USB_O_TXFUNCADDR9 0x000000C8 // USB Transmit Functional Address + // Endpoint 9 +#define USB_O_TXHUBADDR9 0x000000CA // USB Transmit Hub Address + // Endpoint 9 +#define USB_O_TXHUBPORT9 0x000000CB // USB Transmit Hub Port Endpoint 9 +#define USB_O_RXFUNCADDR9 0x000000CC // USB Receive Functional Address + // Endpoint 9 +#define USB_O_RXHUBADDR9 0x000000CE // USB Receive Hub Address Endpoint + // 9 +#define USB_O_RXHUBPORT9 0x000000CF // USB Receive Hub Port Endpoint 9 +#define USB_O_TXFUNCADDR10 0x000000D0 // USB Transmit Functional Address + // Endpoint 10 +#define USB_O_TXHUBADDR10 0x000000D2 // USB Transmit Hub Address + // Endpoint 10 +#define USB_O_TXHUBPORT10 0x000000D3 // USB Transmit Hub Port Endpoint + // 10 +#define USB_O_RXFUNCADDR10 0x000000D4 // USB Receive Functional Address + // Endpoint 10 +#define USB_O_RXHUBADDR10 0x000000D6 // USB Receive Hub Address Endpoint + // 10 +#define USB_O_RXHUBPORT10 0x000000D7 // USB Receive Hub Port Endpoint 10 +#define USB_O_TXFUNCADDR11 0x000000D8 // USB Transmit Functional Address + // Endpoint 11 +#define USB_O_TXHUBADDR11 0x000000DA // USB Transmit Hub Address + // Endpoint 11 +#define USB_O_TXHUBPORT11 0x000000DB // USB Transmit Hub Port Endpoint + // 11 +#define USB_O_RXFUNCADDR11 0x000000DC // USB Receive Functional Address + // Endpoint 11 +#define USB_O_RXHUBADDR11 0x000000DE // USB Receive Hub Address Endpoint + // 11 +#define USB_O_RXHUBPORT11 0x000000DF // USB Receive Hub Port Endpoint 11 +#define USB_O_TXFUNCADDR12 0x000000E0 // USB Transmit Functional Address + // Endpoint 12 +#define USB_O_TXHUBADDR12 0x000000E2 // USB Transmit Hub Address + // Endpoint 12 +#define USB_O_TXHUBPORT12 0x000000E3 // USB Transmit Hub Port Endpoint + // 12 +#define USB_O_RXFUNCADDR12 0x000000E4 // USB Receive Functional Address + // Endpoint 12 +#define USB_O_RXHUBADDR12 0x000000E6 // USB Receive Hub Address Endpoint + // 12 +#define USB_O_RXHUBPORT12 0x000000E7 // USB Receive Hub Port Endpoint 12 +#define USB_O_TXFUNCADDR13 0x000000E8 // USB Transmit Functional Address + // Endpoint 13 +#define USB_O_TXHUBADDR13 0x000000EA // USB Transmit Hub Address + // Endpoint 13 +#define USB_O_TXHUBPORT13 0x000000EB // USB Transmit Hub Port Endpoint + // 13 +#define USB_O_RXFUNCADDR13 0x000000EC // USB Receive Functional Address + // Endpoint 13 +#define USB_O_RXHUBADDR13 0x000000EE // USB Receive Hub Address Endpoint + // 13 +#define USB_O_RXHUBPORT13 0x000000EF // USB Receive Hub Port Endpoint 13 +#define USB_O_TXFUNCADDR14 0x000000F0 // USB Transmit Functional Address + // Endpoint 14 +#define USB_O_TXHUBADDR14 0x000000F2 // USB Transmit Hub Address + // Endpoint 14 +#define USB_O_TXHUBPORT14 0x000000F3 // USB Transmit Hub Port Endpoint + // 14 +#define USB_O_RXFUNCADDR14 0x000000F4 // USB Receive Functional Address + // Endpoint 14 +#define USB_O_RXHUBADDR14 0x000000F6 // USB Receive Hub Address Endpoint + // 14 +#define USB_O_RXHUBPORT14 0x000000F7 // USB Receive Hub Port Endpoint 14 +#define USB_O_TXFUNCADDR15 0x000000F8 // USB Transmit Functional Address + // Endpoint 15 +#define USB_O_TXHUBADDR15 0x000000FA // USB Transmit Hub Address + // Endpoint 15 +#define USB_O_TXHUBPORT15 0x000000FB // USB Transmit Hub Port Endpoint + // 15 +#define USB_O_RXFUNCADDR15 0x000000FC // USB Receive Functional Address + // Endpoint 15 +#define USB_O_RXHUBADDR15 0x000000FE // USB Receive Hub Address Endpoint + // 15 +#define USB_O_RXHUBPORT15 0x000000FF // USB Receive Hub Port Endpoint 15 +#define USB_O_CSRL0 0x00000102 // USB Control and Status Endpoint + // 0 Low +#define USB_O_CSRH0 0x00000103 // USB Control and Status Endpoint + // 0 High +#define USB_O_COUNT0 0x00000108 // USB Receive Byte Count Endpoint + // 0 +#define USB_O_TYPE0 0x0000010A // USB Type Endpoint 0 +#define USB_O_NAKLMT 0x0000010B // USB NAK Limit +#define USB_O_TXMAXP1 0x00000110 // USB Maximum Transmit Data + // Endpoint 1 +#define USB_O_TXCSRL1 0x00000112 // USB Transmit Control and Status + // Endpoint 1 Low +#define USB_O_TXCSRH1 0x00000113 // USB Transmit Control and Status + // Endpoint 1 High +#define USB_O_RXMAXP1 0x00000114 // USB Maximum Receive Data + // Endpoint 1 +#define USB_O_RXCSRL1 0x00000116 // USB Receive Control and Status + // Endpoint 1 Low +#define USB_O_RXCSRH1 0x00000117 // USB Receive Control and Status + // Endpoint 1 High +#define USB_O_RXCOUNT1 0x00000118 // USB Receive Byte Count Endpoint + // 1 +#define USB_O_TXTYPE1 0x0000011A // USB Host Transmit Configure Type + // Endpoint 1 +#define USB_O_TXINTERVAL1 0x0000011B // USB Host Transmit Interval + // Endpoint 1 +#define USB_O_RXTYPE1 0x0000011C // USB Host Configure Receive Type + // Endpoint 1 +#define USB_O_RXINTERVAL1 0x0000011D // USB Host Receive Polling + // Interval Endpoint 1 +#define USB_O_TXMAXP2 0x00000120 // USB Maximum Transmit Data + // Endpoint 2 +#define USB_O_TXCSRL2 0x00000122 // USB Transmit Control and Status + // Endpoint 2 Low +#define USB_O_TXCSRH2 0x00000123 // USB Transmit Control and Status + // Endpoint 2 High +#define USB_O_RXMAXP2 0x00000124 // USB Maximum Receive Data + // Endpoint 2 +#define USB_O_RXCSRL2 0x00000126 // USB Receive Control and Status + // Endpoint 2 Low +#define USB_O_RXCSRH2 0x00000127 // USB Receive Control and Status + // Endpoint 2 High +#define USB_O_RXCOUNT2 0x00000128 // USB Receive Byte Count Endpoint + // 2 +#define USB_O_TXTYPE2 0x0000012A // USB Host Transmit Configure Type + // Endpoint 2 +#define USB_O_TXINTERVAL2 0x0000012B // USB Host Transmit Interval + // Endpoint 2 +#define USB_O_RXTYPE2 0x0000012C // USB Host Configure Receive Type + // Endpoint 2 +#define USB_O_RXINTERVAL2 0x0000012D // USB Host Receive Polling + // Interval Endpoint 2 +#define USB_O_TXMAXP3 0x00000130 // USB Maximum Transmit Data + // Endpoint 3 +#define USB_O_TXCSRL3 0x00000132 // USB Transmit Control and Status + // Endpoint 3 Low +#define USB_O_TXCSRH3 0x00000133 // USB Transmit Control and Status + // Endpoint 3 High +#define USB_O_RXMAXP3 0x00000134 // USB Maximum Receive Data + // Endpoint 3 +#define USB_O_RXCSRL3 0x00000136 // USB Receive Control and Status + // Endpoint 3 Low +#define USB_O_RXCSRH3 0x00000137 // USB Receive Control and Status + // Endpoint 3 High +#define USB_O_RXCOUNT3 0x00000138 // USB Receive Byte Count Endpoint + // 3 +#define USB_O_TXTYPE3 0x0000013A // USB Host Transmit Configure Type + // Endpoint 3 +#define USB_O_TXINTERVAL3 0x0000013B // USB Host Transmit Interval + // Endpoint 3 +#define USB_O_RXTYPE3 0x0000013C // USB Host Configure Receive Type + // Endpoint 3 +#define USB_O_RXINTERVAL3 0x0000013D // USB Host Receive Polling + // Interval Endpoint 3 +#define USB_O_TXMAXP4 0x00000140 // USB Maximum Transmit Data + // Endpoint 4 +#define USB_O_TXCSRL4 0x00000142 // USB Transmit Control and Status + // Endpoint 4 Low +#define USB_O_TXCSRH4 0x00000143 // USB Transmit Control and Status + // Endpoint 4 High +#define USB_O_RXMAXP4 0x00000144 // USB Maximum Receive Data + // Endpoint 4 +#define USB_O_RXCSRL4 0x00000146 // USB Receive Control and Status + // Endpoint 4 Low +#define USB_O_RXCSRH4 0x00000147 // USB Receive Control and Status + // Endpoint 4 High +#define USB_O_RXCOUNT4 0x00000148 // USB Receive Byte Count Endpoint + // 4 +#define USB_O_TXTYPE4 0x0000014A // USB Host Transmit Configure Type + // Endpoint 4 +#define USB_O_TXINTERVAL4 0x0000014B // USB Host Transmit Interval + // Endpoint 4 +#define USB_O_RXTYPE4 0x0000014C // USB Host Configure Receive Type + // Endpoint 4 +#define USB_O_RXINTERVAL4 0x0000014D // USB Host Receive Polling + // Interval Endpoint 4 +#define USB_O_TXMAXP5 0x00000150 // USB Maximum Transmit Data + // Endpoint 5 +#define USB_O_TXCSRL5 0x00000152 // USB Transmit Control and Status + // Endpoint 5 Low +#define USB_O_TXCSRH5 0x00000153 // USB Transmit Control and Status + // Endpoint 5 High +#define USB_O_RXMAXP5 0x00000154 // USB Maximum Receive Data + // Endpoint 5 +#define USB_O_RXCSRL5 0x00000156 // USB Receive Control and Status + // Endpoint 5 Low +#define USB_O_RXCSRH5 0x00000157 // USB Receive Control and Status + // Endpoint 5 High +#define USB_O_RXCOUNT5 0x00000158 // USB Receive Byte Count Endpoint + // 5 +#define USB_O_TXTYPE5 0x0000015A // USB Host Transmit Configure Type + // Endpoint 5 +#define USB_O_TXINTERVAL5 0x0000015B // USB Host Transmit Interval + // Endpoint 5 +#define USB_O_RXTYPE5 0x0000015C // USB Host Configure Receive Type + // Endpoint 5 +#define USB_O_RXINTERVAL5 0x0000015D // USB Host Receive Polling + // Interval Endpoint 5 +#define USB_O_TXMAXP6 0x00000160 // USB Maximum Transmit Data + // Endpoint 6 +#define USB_O_TXCSRL6 0x00000162 // USB Transmit Control and Status + // Endpoint 6 Low +#define USB_O_TXCSRH6 0x00000163 // USB Transmit Control and Status + // Endpoint 6 High +#define USB_O_RXMAXP6 0x00000164 // USB Maximum Receive Data + // Endpoint 6 +#define USB_O_RXCSRL6 0x00000166 // USB Receive Control and Status + // Endpoint 6 Low +#define USB_O_RXCSRH6 0x00000167 // USB Receive Control and Status + // Endpoint 6 High +#define USB_O_RXCOUNT6 0x00000168 // USB Receive Byte Count Endpoint + // 6 +#define USB_O_TXTYPE6 0x0000016A // USB Host Transmit Configure Type + // Endpoint 6 +#define USB_O_TXINTERVAL6 0x0000016B // USB Host Transmit Interval + // Endpoint 6 +#define USB_O_RXTYPE6 0x0000016C // USB Host Configure Receive Type + // Endpoint 6 +#define USB_O_RXINTERVAL6 0x0000016D // USB Host Receive Polling + // Interval Endpoint 6 +#define USB_O_TXMAXP7 0x00000170 // USB Maximum Transmit Data + // Endpoint 7 +#define USB_O_TXCSRL7 0x00000172 // USB Transmit Control and Status + // Endpoint 7 Low +#define USB_O_TXCSRH7 0x00000173 // USB Transmit Control and Status + // Endpoint 7 High +#define USB_O_RXMAXP7 0x00000174 // USB Maximum Receive Data + // Endpoint 7 +#define USB_O_RXCSRL7 0x00000176 // USB Receive Control and Status + // Endpoint 7 Low +#define USB_O_RXCSRH7 0x00000177 // USB Receive Control and Status + // Endpoint 7 High +#define USB_O_RXCOUNT7 0x00000178 // USB Receive Byte Count Endpoint + // 7 +#define USB_O_TXTYPE7 0x0000017A // USB Host Transmit Configure Type + // Endpoint 7 +#define USB_O_TXINTERVAL7 0x0000017B // USB Host Transmit Interval + // Endpoint 7 +#define USB_O_RXTYPE7 0x0000017C // USB Host Configure Receive Type + // Endpoint 7 +#define USB_O_RXINTERVAL7 0x0000017D // USB Host Receive Polling + // Interval Endpoint 7 +#define USB_O_TXMAXP8 0x00000180 // USB Maximum Transmit Data + // Endpoint 8 +#define USB_O_TXCSRL8 0x00000182 // USB Transmit Control and Status + // Endpoint 8 Low +#define USB_O_TXCSRH8 0x00000183 // USB Transmit Control and Status + // Endpoint 8 High +#define USB_O_RXMAXP8 0x00000184 // USB Maximum Receive Data + // Endpoint 8 +#define USB_O_RXCSRL8 0x00000186 // USB Receive Control and Status + // Endpoint 8 Low +#define USB_O_RXCSRH8 0x00000187 // USB Receive Control and Status + // Endpoint 8 High +#define USB_O_RXCOUNT8 0x00000188 // USB Receive Byte Count Endpoint + // 8 +#define USB_O_TXTYPE8 0x0000018A // USB Host Transmit Configure Type + // Endpoint 8 +#define USB_O_TXINTERVAL8 0x0000018B // USB Host Transmit Interval + // Endpoint 8 +#define USB_O_RXTYPE8 0x0000018C // USB Host Configure Receive Type + // Endpoint 8 +#define USB_O_RXINTERVAL8 0x0000018D // USB Host Receive Polling + // Interval Endpoint 8 +#define USB_O_TXMAXP9 0x00000190 // USB Maximum Transmit Data + // Endpoint 9 +#define USB_O_TXCSRL9 0x00000192 // USB Transmit Control and Status + // Endpoint 9 Low +#define USB_O_TXCSRH9 0x00000193 // USB Transmit Control and Status + // Endpoint 9 High +#define USB_O_RXMAXP9 0x00000194 // USB Maximum Receive Data + // Endpoint 9 +#define USB_O_RXCSRL9 0x00000196 // USB Receive Control and Status + // Endpoint 9 Low +#define USB_O_RXCSRH9 0x00000197 // USB Receive Control and Status + // Endpoint 9 High +#define USB_O_RXCOUNT9 0x00000198 // USB Receive Byte Count Endpoint + // 9 +#define USB_O_TXTYPE9 0x0000019A // USB Host Transmit Configure Type + // Endpoint 9 +#define USB_O_TXINTERVAL9 0x0000019B // USB Host Transmit Interval + // Endpoint 9 +#define USB_O_RXTYPE9 0x0000019C // USB Host Configure Receive Type + // Endpoint 9 +#define USB_O_RXINTERVAL9 0x0000019D // USB Host Receive Polling + // Interval Endpoint 9 +#define USB_O_TXMAXP10 0x000001A0 // USB Maximum Transmit Data + // Endpoint 10 +#define USB_O_TXCSRL10 0x000001A2 // USB Transmit Control and Status + // Endpoint 10 Low +#define USB_O_TXCSRH10 0x000001A3 // USB Transmit Control and Status + // Endpoint 10 High +#define USB_O_RXMAXP10 0x000001A4 // USB Maximum Receive Data + // Endpoint 10 +#define USB_O_RXCSRL10 0x000001A6 // USB Receive Control and Status + // Endpoint 10 Low +#define USB_O_RXCSRH10 0x000001A7 // USB Receive Control and Status + // Endpoint 10 High +#define USB_O_RXCOUNT10 0x000001A8 // USB Receive Byte Count Endpoint + // 10 +#define USB_O_TXTYPE10 0x000001AA // USB Host Transmit Configure Type + // Endpoint 10 +#define USB_O_TXINTERVAL10 0x000001AB // USB Host Transmit Interval + // Endpoint 10 +#define USB_O_RXTYPE10 0x000001AC // USB Host Configure Receive Type + // Endpoint 10 +#define USB_O_RXINTERVAL10 0x000001AD // USB Host Receive Polling + // Interval Endpoint 10 +#define USB_O_TXMAXP11 0x000001B0 // USB Maximum Transmit Data + // Endpoint 11 +#define USB_O_TXCSRL11 0x000001B2 // USB Transmit Control and Status + // Endpoint 11 Low +#define USB_O_TXCSRH11 0x000001B3 // USB Transmit Control and Status + // Endpoint 11 High +#define USB_O_RXMAXP11 0x000001B4 // USB Maximum Receive Data + // Endpoint 11 +#define USB_O_RXCSRL11 0x000001B6 // USB Receive Control and Status + // Endpoint 11 Low +#define USB_O_RXCSRH11 0x000001B7 // USB Receive Control and Status + // Endpoint 11 High +#define USB_O_RXCOUNT11 0x000001B8 // USB Receive Byte Count Endpoint + // 11 +#define USB_O_TXTYPE11 0x000001BA // USB Host Transmit Configure Type + // Endpoint 11 +#define USB_O_TXINTERVAL11 0x000001BB // USB Host Transmit Interval + // Endpoint 11 +#define USB_O_RXTYPE11 0x000001BC // USB Host Configure Receive Type + // Endpoint 11 +#define USB_O_RXINTERVAL11 0x000001BD // USB Host Receive Polling + // Interval Endpoint 11 +#define USB_O_TXMAXP12 0x000001C0 // USB Maximum Transmit Data + // Endpoint 12 +#define USB_O_TXCSRL12 0x000001C2 // USB Transmit Control and Status + // Endpoint 12 Low +#define USB_O_TXCSRH12 0x000001C3 // USB Transmit Control and Status + // Endpoint 12 High +#define USB_O_RXMAXP12 0x000001C4 // USB Maximum Receive Data + // Endpoint 12 +#define USB_O_RXCSRL12 0x000001C6 // USB Receive Control and Status + // Endpoint 12 Low +#define USB_O_RXCSRH12 0x000001C7 // USB Receive Control and Status + // Endpoint 12 High +#define USB_O_RXCOUNT12 0x000001C8 // USB Receive Byte Count Endpoint + // 12 +#define USB_O_TXTYPE12 0x000001CA // USB Host Transmit Configure Type + // Endpoint 12 +#define USB_O_TXINTERVAL12 0x000001CB // USB Host Transmit Interval + // Endpoint 12 +#define USB_O_RXTYPE12 0x000001CC // USB Host Configure Receive Type + // Endpoint 12 +#define USB_O_RXINTERVAL12 0x000001CD // USB Host Receive Polling + // Interval Endpoint 12 +#define USB_O_TXMAXP13 0x000001D0 // USB Maximum Transmit Data + // Endpoint 13 +#define USB_O_TXCSRL13 0x000001D2 // USB Transmit Control and Status + // Endpoint 13 Low +#define USB_O_TXCSRH13 0x000001D3 // USB Transmit Control and Status + // Endpoint 13 High +#define USB_O_RXMAXP13 0x000001D4 // USB Maximum Receive Data + // Endpoint 13 +#define USB_O_RXCSRL13 0x000001D6 // USB Receive Control and Status + // Endpoint 13 Low +#define USB_O_RXCSRH13 0x000001D7 // USB Receive Control and Status + // Endpoint 13 High +#define USB_O_RXCOUNT13 0x000001D8 // USB Receive Byte Count Endpoint + // 13 +#define USB_O_TXTYPE13 0x000001DA // USB Host Transmit Configure Type + // Endpoint 13 +#define USB_O_TXINTERVAL13 0x000001DB // USB Host Transmit Interval + // Endpoint 13 +#define USB_O_RXTYPE13 0x000001DC // USB Host Configure Receive Type + // Endpoint 13 +#define USB_O_RXINTERVAL13 0x000001DD // USB Host Receive Polling + // Interval Endpoint 13 +#define USB_O_TXMAXP14 0x000001E0 // USB Maximum Transmit Data + // Endpoint 14 +#define USB_O_TXCSRL14 0x000001E2 // USB Transmit Control and Status + // Endpoint 14 Low +#define USB_O_TXCSRH14 0x000001E3 // USB Transmit Control and Status + // Endpoint 14 High +#define USB_O_RXMAXP14 0x000001E4 // USB Maximum Receive Data + // Endpoint 14 +#define USB_O_RXCSRL14 0x000001E6 // USB Receive Control and Status + // Endpoint 14 Low +#define USB_O_RXCSRH14 0x000001E7 // USB Receive Control and Status + // Endpoint 14 High +#define USB_O_RXCOUNT14 0x000001E8 // USB Receive Byte Count Endpoint + // 14 +#define USB_O_TXTYPE14 0x000001EA // USB Host Transmit Configure Type + // Endpoint 14 +#define USB_O_TXINTERVAL14 0x000001EB // USB Host Transmit Interval + // Endpoint 14 +#define USB_O_RXTYPE14 0x000001EC // USB Host Configure Receive Type + // Endpoint 14 +#define USB_O_RXINTERVAL14 0x000001ED // USB Host Receive Polling + // Interval Endpoint 14 +#define USB_O_TXMAXP15 0x000001F0 // USB Maximum Transmit Data + // Endpoint 15 +#define USB_O_TXCSRL15 0x000001F2 // USB Transmit Control and Status + // Endpoint 15 Low +#define USB_O_TXCSRH15 0x000001F3 // USB Transmit Control and Status + // Endpoint 15 High +#define USB_O_RXMAXP15 0x000001F4 // USB Maximum Receive Data + // Endpoint 15 +#define USB_O_RXCSRL15 0x000001F6 // USB Receive Control and Status + // Endpoint 15 Low +#define USB_O_RXCSRH15 0x000001F7 // USB Receive Control and Status + // Endpoint 15 High +#define USB_O_RXCOUNT15 0x000001F8 // USB Receive Byte Count Endpoint + // 15 +#define USB_O_TXTYPE15 0x000001FA // USB Host Transmit Configure Type + // Endpoint 15 +#define USB_O_TXINTERVAL15 0x000001FB // USB Host Transmit Interval + // Endpoint 15 +#define USB_O_RXTYPE15 0x000001FC // USB Host Configure Receive Type + // Endpoint 15 +#define USB_O_RXINTERVAL15 0x000001FD // USB Host Receive Polling + // Interval Endpoint 15 +#define USB_O_RQPKTCOUNT1 0x00000304 // USB Request Packet Count in + // Block Transfer Endpoint 1 +#define USB_O_RQPKTCOUNT2 0x00000308 // USB Request Packet Count in + // Block Transfer Endpoint 2 +#define USB_O_RQPKTCOUNT3 0x0000030C // USB Request Packet Count in + // Block Transfer Endpoint 3 +#define USB_O_RQPKTCOUNT4 0x00000310 // USB Request Packet Count in + // Block Transfer Endpoint 4 +#define USB_O_RQPKTCOUNT5 0x00000314 // USB Request Packet Count in + // Block Transfer Endpoint 5 +#define USB_O_RQPKTCOUNT6 0x00000318 // USB Request Packet Count in + // Block Transfer Endpoint 6 +#define USB_O_RQPKTCOUNT7 0x0000031C // USB Request Packet Count in + // Block Transfer Endpoint 7 +#define USB_O_RQPKTCOUNT8 0x00000320 // USB Request Packet Count in + // Block Transfer Endpoint 8 +#define USB_O_RQPKTCOUNT9 0x00000324 // USB Request Packet Count in + // Block Transfer Endpoint 9 +#define USB_O_RQPKTCOUNT10 0x00000328 // USB Request Packet Count in + // Block Transfer Endpoint 10 +#define USB_O_RQPKTCOUNT11 0x0000032C // USB Request Packet Count in + // Block Transfer Endpoint 11 +#define USB_O_RQPKTCOUNT12 0x00000330 // USB Request Packet Count in + // Block Transfer Endpoint 12 +#define USB_O_RQPKTCOUNT13 0x00000334 // USB Request Packet Count in + // Block Transfer Endpoint 13 +#define USB_O_RQPKTCOUNT14 0x00000338 // USB Request Packet Count in + // Block Transfer Endpoint 14 +#define USB_O_RQPKTCOUNT15 0x0000033C // USB Request Packet Count in + // Block Transfer Endpoint 15 +#define USB_O_RXDPKTBUFDIS 0x00000340 // USB Receive Double Packet Buffer + // Disable +#define USB_O_TXDPKTBUFDIS 0x00000342 // USB Transmit Double Packet + // Buffer Disable +#define USB_O_EPC 0x00000400 // USB External Power Control +#define USB_O_EPCRIS 0x00000404 // USB External Power Control Raw + // Interrupt Status +#define USB_O_EPCIM 0x00000408 // USB External Power Control + // Interrupt Mask +#define USB_O_EPCISC 0x0000040C // USB External Power Control + // Interrupt Status and Clear +#define USB_O_DRRIS 0x00000410 // USB Device RESUME Raw Interrupt + // Status +#define USB_O_DRIM 0x00000414 // USB Device RESUME Interrupt Mask +#define USB_O_DRISC 0x00000418 // USB Device RESUME Interrupt + // Status and Clear +#define USB_O_GPCS 0x0000041C // USB General-Purpose Control and + // Status +#define USB_O_VDC 0x00000430 // USB VBUS Droop Control +#define USB_O_VDCRIS 0x00000434 // USB VBUS Droop Control Raw + // Interrupt Status +#define USB_O_VDCIM 0x00000438 // USB VBUS Droop Control Interrupt + // Mask +#define USB_O_VDCISC 0x0000043C // USB VBUS Droop Control Interrupt + // Status and Clear +#define USB_O_IDVRIS 0x00000444 // USB ID Valid Detect Raw + // Interrupt Status +#define USB_O_IDVIM 0x00000448 // USB ID Valid Detect Interrupt + // Mask +#define USB_O_IDVISC 0x0000044C // USB ID Valid Detect Interrupt + // Status and Clear +#define USB_O_DMASEL 0x00000450 // USB DMA Select + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FADDR register. +// +//***************************************************************************** +#define USB_FADDR_M 0x0000007F // Function Address +#define USB_FADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_POWER register. +// +//***************************************************************************** +#define USB_POWER_ISOUP 0x00000080 // Isochronous Update +#define USB_POWER_SOFTCONN 0x00000040 // Soft Connect/Disconnect +#define USB_POWER_RESET 0x00000008 // RESET Signaling +#define USB_POWER_RESUME 0x00000004 // RESUME Signaling +#define USB_POWER_SUSPEND 0x00000002 // SUSPEND Mode +#define USB_POWER_PWRDNPHY 0x00000001 // Power Down PHY + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXIS register. +// +//***************************************************************************** +#define USB_TXIS_EP15 0x00008000 // TX Endpoint 15 Interrupt +#define USB_TXIS_EP14 0x00004000 // TX Endpoint 14 Interrupt +#define USB_TXIS_EP13 0x00002000 // TX Endpoint 13 Interrupt +#define USB_TXIS_EP12 0x00001000 // TX Endpoint 12 Interrupt +#define USB_TXIS_EP11 0x00000800 // TX Endpoint 11 Interrupt +#define USB_TXIS_EP10 0x00000400 // TX Endpoint 10 Interrupt +#define USB_TXIS_EP9 0x00000200 // TX Endpoint 9 Interrupt +#define USB_TXIS_EP8 0x00000100 // TX Endpoint 8 Interrupt +#define USB_TXIS_EP7 0x00000080 // TX Endpoint 7 Interrupt +#define USB_TXIS_EP6 0x00000040 // TX Endpoint 6 Interrupt +#define USB_TXIS_EP5 0x00000020 // TX Endpoint 5 Interrupt +#define USB_TXIS_EP4 0x00000010 // TX Endpoint 4 Interrupt +#define USB_TXIS_EP3 0x00000008 // TX Endpoint 3 Interrupt +#define USB_TXIS_EP2 0x00000004 // TX Endpoint 2 Interrupt +#define USB_TXIS_EP1 0x00000002 // TX Endpoint 1 Interrupt +#define USB_TXIS_EP0 0x00000001 // TX and RX Endpoint 0 Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXIS register. +// +//***************************************************************************** +#define USB_RXIS_EP15 0x00008000 // RX Endpoint 15 Interrupt +#define USB_RXIS_EP14 0x00004000 // RX Endpoint 14 Interrupt +#define USB_RXIS_EP13 0x00002000 // RX Endpoint 13 Interrupt +#define USB_RXIS_EP12 0x00001000 // RX Endpoint 12 Interrupt +#define USB_RXIS_EP11 0x00000800 // RX Endpoint 11 Interrupt +#define USB_RXIS_EP10 0x00000400 // RX Endpoint 10 Interrupt +#define USB_RXIS_EP9 0x00000200 // RX Endpoint 9 Interrupt +#define USB_RXIS_EP8 0x00000100 // RX Endpoint 8 Interrupt +#define USB_RXIS_EP7 0x00000080 // RX Endpoint 7 Interrupt +#define USB_RXIS_EP6 0x00000040 // RX Endpoint 6 Interrupt +#define USB_RXIS_EP5 0x00000020 // RX Endpoint 5 Interrupt +#define USB_RXIS_EP4 0x00000010 // RX Endpoint 4 Interrupt +#define USB_RXIS_EP3 0x00000008 // RX Endpoint 3 Interrupt +#define USB_RXIS_EP2 0x00000004 // RX Endpoint 2 Interrupt +#define USB_RXIS_EP1 0x00000002 // RX Endpoint 1 Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXIE register. +// +//***************************************************************************** +#define USB_TXIE_EP15 0x00008000 // TX Endpoint 15 Interrupt Enable +#define USB_TXIE_EP14 0x00004000 // TX Endpoint 14 Interrupt Enable +#define USB_TXIE_EP13 0x00002000 // TX Endpoint 13 Interrupt Enable +#define USB_TXIE_EP12 0x00001000 // TX Endpoint 12 Interrupt Enable +#define USB_TXIE_EP11 0x00000800 // TX Endpoint 11 Interrupt Enable +#define USB_TXIE_EP10 0x00000400 // TX Endpoint 10 Interrupt Enable +#define USB_TXIE_EP9 0x00000200 // TX Endpoint 9 Interrupt Enable +#define USB_TXIE_EP8 0x00000100 // TX Endpoint 8 Interrupt Enable +#define USB_TXIE_EP7 0x00000080 // TX Endpoint 7 Interrupt Enable +#define USB_TXIE_EP6 0x00000040 // TX Endpoint 6 Interrupt Enable +#define USB_TXIE_EP5 0x00000020 // TX Endpoint 5 Interrupt Enable +#define USB_TXIE_EP4 0x00000010 // TX Endpoint 4 Interrupt Enable +#define USB_TXIE_EP3 0x00000008 // TX Endpoint 3 Interrupt Enable +#define USB_TXIE_EP2 0x00000004 // TX Endpoint 2 Interrupt Enable +#define USB_TXIE_EP1 0x00000002 // TX Endpoint 1 Interrupt Enable +#define USB_TXIE_EP0 0x00000001 // TX and RX Endpoint 0 Interrupt + // Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXIE register. +// +//***************************************************************************** +#define USB_RXIE_EP15 0x00008000 // RX Endpoint 15 Interrupt Enable +#define USB_RXIE_EP14 0x00004000 // RX Endpoint 14 Interrupt Enable +#define USB_RXIE_EP13 0x00002000 // RX Endpoint 13 Interrupt Enable +#define USB_RXIE_EP12 0x00001000 // RX Endpoint 12 Interrupt Enable +#define USB_RXIE_EP11 0x00000800 // RX Endpoint 11 Interrupt Enable +#define USB_RXIE_EP10 0x00000400 // RX Endpoint 10 Interrupt Enable +#define USB_RXIE_EP9 0x00000200 // RX Endpoint 9 Interrupt Enable +#define USB_RXIE_EP8 0x00000100 // RX Endpoint 8 Interrupt Enable +#define USB_RXIE_EP7 0x00000080 // RX Endpoint 7 Interrupt Enable +#define USB_RXIE_EP6 0x00000040 // RX Endpoint 6 Interrupt Enable +#define USB_RXIE_EP5 0x00000020 // RX Endpoint 5 Interrupt Enable +#define USB_RXIE_EP4 0x00000010 // RX Endpoint 4 Interrupt Enable +#define USB_RXIE_EP3 0x00000008 // RX Endpoint 3 Interrupt Enable +#define USB_RXIE_EP2 0x00000004 // RX Endpoint 2 Interrupt Enable +#define USB_RXIE_EP1 0x00000002 // RX Endpoint 1 Interrupt Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_IS register. +// +//***************************************************************************** +#define USB_IS_VBUSERR 0x00000080 // VBUS Error +#define USB_IS_SESREQ 0x00000040 // SESSION REQUEST +#define USB_IS_DISCON 0x00000020 // Session Disconnect +#define USB_IS_CONN 0x00000010 // Session Connect +#define USB_IS_SOF 0x00000008 // Start of Frame +#define USB_IS_BABBLE 0x00000004 // Babble Detected +#define USB_IS_RESET 0x00000004 // RESET Signaling Detected +#define USB_IS_RESUME 0x00000002 // RESUME Signaling Detected +#define USB_IS_SUSPEND 0x00000001 // SUSPEND Signaling Detected + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_IE register. +// +//***************************************************************************** +#define USB_IE_VBUSERR 0x00000080 // Enable VBUS Error Interrupt +#define USB_IE_SESREQ 0x00000040 // Enable Session Request +#define USB_IE_DISCON 0x00000020 // Enable Disconnect Interrupt +#define USB_IE_CONN 0x00000010 // Enable Connect Interrupt +#define USB_IE_SOF 0x00000008 // Enable Start-of-Frame Interrupt +#define USB_IE_BABBLE 0x00000004 // Enable Babble Interrupt +#define USB_IE_RESET 0x00000004 // Enable RESET Interrupt +#define USB_IE_RESUME 0x00000002 // Enable RESUME Interrupt +#define USB_IE_SUSPND 0x00000001 // Enable SUSPEND Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FRAME register. +// +//***************************************************************************** +#define USB_FRAME_M 0x000007FF // Frame Number +#define USB_FRAME_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_EPIDX register. +// +//***************************************************************************** +#define USB_EPIDX_EPIDX_M 0x0000000F // Endpoint Index +#define USB_EPIDX_EPIDX_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TEST register. +// +//***************************************************************************** +#define USB_TEST_FORCEH 0x00000080 // Force Host Mode +#define USB_TEST_FIFOACC 0x00000040 // FIFO Access +#define USB_TEST_FORCEFS 0x00000020 // Force Full-Speed Mode + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO0 register. +// +//***************************************************************************** +#define USB_FIFO0_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO0_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO1 register. +// +//***************************************************************************** +#define USB_FIFO1_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO1_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO2 register. +// +//***************************************************************************** +#define USB_FIFO2_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO2_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO3 register. +// +//***************************************************************************** +#define USB_FIFO3_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO3_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO4 register. +// +//***************************************************************************** +#define USB_FIFO4_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO4_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO5 register. +// +//***************************************************************************** +#define USB_FIFO5_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO5_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO6 register. +// +//***************************************************************************** +#define USB_FIFO6_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO6_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO7 register. +// +//***************************************************************************** +#define USB_FIFO7_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO7_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO8 register. +// +//***************************************************************************** +#define USB_FIFO8_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO8_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO9 register. +// +//***************************************************************************** +#define USB_FIFO9_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO9_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO10 register. +// +//***************************************************************************** +#define USB_FIFO10_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO10_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO11 register. +// +//***************************************************************************** +#define USB_FIFO11_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO11_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO12 register. +// +//***************************************************************************** +#define USB_FIFO12_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO12_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO13 register. +// +//***************************************************************************** +#define USB_FIFO13_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO13_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO14 register. +// +//***************************************************************************** +#define USB_FIFO14_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO14_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FIFO15 register. +// +//***************************************************************************** +#define USB_FIFO15_EPDATA_M 0xFFFFFFFF // Endpoint Data +#define USB_FIFO15_EPDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_DEVCTL register. +// +//***************************************************************************** +#define USB_DEVCTL_DEV 0x00000080 // Device Mode +#define USB_DEVCTL_FSDEV 0x00000040 // Full-Speed Device Detected +#define USB_DEVCTL_LSDEV 0x00000020 // Low-Speed Device Detected +#define USB_DEVCTL_VBUS_M 0x00000018 // VBUS Level +#define USB_DEVCTL_VBUS_NONE 0x00000000 // Below SessionEnd +#define USB_DEVCTL_VBUS_SEND 0x00000008 // Above SessionEnd, below AValid +#define USB_DEVCTL_VBUS_AVALID 0x00000010 // Above AValid, below VBUSValid +#define USB_DEVCTL_VBUS_VALID 0x00000018 // Above VBUSValid +#define USB_DEVCTL_HOST 0x00000004 // Host Mode +#define USB_DEVCTL_HOSTREQ 0x00000002 // Host Request +#define USB_DEVCTL_SESSION 0x00000001 // Session Start/End + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFIFOSZ register. +// +//***************************************************************************** +#define USB_TXFIFOSZ_DPB 0x00000010 // Double Packet Buffer Support +#define USB_TXFIFOSZ_SIZE_M 0x0000000F // Max Packet Size +#define USB_TXFIFOSZ_SIZE_8 0x00000000 // 8 +#define USB_TXFIFOSZ_SIZE_16 0x00000001 // 16 +#define USB_TXFIFOSZ_SIZE_32 0x00000002 // 32 +#define USB_TXFIFOSZ_SIZE_64 0x00000003 // 64 +#define USB_TXFIFOSZ_SIZE_128 0x00000004 // 128 +#define USB_TXFIFOSZ_SIZE_256 0x00000005 // 256 +#define USB_TXFIFOSZ_SIZE_512 0x00000006 // 512 +#define USB_TXFIFOSZ_SIZE_1024 0x00000007 // 1024 +#define USB_TXFIFOSZ_SIZE_2048 0x00000008 // 2048 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFIFOSZ register. +// +//***************************************************************************** +#define USB_RXFIFOSZ_DPB 0x00000010 // Double Packet Buffer Support +#define USB_RXFIFOSZ_SIZE_M 0x0000000F // Max Packet Size +#define USB_RXFIFOSZ_SIZE_8 0x00000000 // 8 +#define USB_RXFIFOSZ_SIZE_16 0x00000001 // 16 +#define USB_RXFIFOSZ_SIZE_32 0x00000002 // 32 +#define USB_RXFIFOSZ_SIZE_64 0x00000003 // 64 +#define USB_RXFIFOSZ_SIZE_128 0x00000004 // 128 +#define USB_RXFIFOSZ_SIZE_256 0x00000005 // 256 +#define USB_RXFIFOSZ_SIZE_512 0x00000006 // 512 +#define USB_RXFIFOSZ_SIZE_1024 0x00000007 // 1024 +#define USB_RXFIFOSZ_SIZE_2048 0x00000008 // 2048 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFIFOADD +// register. +// +//***************************************************************************** +#define USB_TXFIFOADD_ADDR_M 0x000001FF // Transmit/Receive Start Address +#define USB_TXFIFOADD_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFIFOADD +// register. +// +//***************************************************************************** +#define USB_RXFIFOADD_ADDR_M 0x000001FF // Transmit/Receive Start Address +#define USB_RXFIFOADD_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_CONTIM register. +// +//***************************************************************************** +#define USB_CONTIM_WTCON_M 0x000000F0 // Connect Wait +#define USB_CONTIM_WTID_M 0x0000000F // Wait ID +#define USB_CONTIM_WTCON_S 4 +#define USB_CONTIM_WTID_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_VPLEN register. +// +//***************************************************************************** +#define USB_VPLEN_VPLEN_M 0x000000FF // VBUS Pulse Length +#define USB_VPLEN_VPLEN_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_FSEOF register. +// +//***************************************************************************** +#define USB_FSEOF_FSEOFG_M 0x000000FF // Full-Speed End-of-Frame Gap +#define USB_FSEOF_FSEOFG_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_LSEOF register. +// +//***************************************************************************** +#define USB_LSEOF_LSEOFG_M 0x000000FF // Low-Speed End-of-Frame Gap +#define USB_LSEOF_LSEOFG_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR0 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR0_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR0_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR0 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR0_MULTTRAN 0x00000080 // Multiple Translators +#define USB_TXHUBADDR0_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR0_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT0 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT0_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT0_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR1 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR1_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR1_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR1 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR1_MULTTRAN 0x00000080 // Multiple Translators +#define USB_TXHUBADDR1_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR1_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT1 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT1_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT1_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFUNCADDR1 +// register. +// +//***************************************************************************** +#define USB_RXFUNCADDR1_ADDR_M 0x0000007F // Device Address +#define USB_RXFUNCADDR1_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBADDR1 +// register. +// +//***************************************************************************** +#define USB_RXHUBADDR1_MULTTRAN 0x00000080 // Multiple Translators +#define USB_RXHUBADDR1_ADDR_M 0x0000007F // Hub Address +#define USB_RXHUBADDR1_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBPORT1 +// register. +// +//***************************************************************************** +#define USB_RXHUBPORT1_PORT_M 0x0000007F // Hub Port +#define USB_RXHUBPORT1_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR2 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR2_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR2_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR2 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR2_MULTTRAN 0x00000080 // Multiple Translators +#define USB_TXHUBADDR2_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR2_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT2 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT2_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT2_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFUNCADDR2 +// register. +// +//***************************************************************************** +#define USB_RXFUNCADDR2_ADDR_M 0x0000007F // Device Address +#define USB_RXFUNCADDR2_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBADDR2 +// register. +// +//***************************************************************************** +#define USB_RXHUBADDR2_MULTTRAN 0x00000080 // Multiple Translators +#define USB_RXHUBADDR2_ADDR_M 0x0000007F // Hub Address +#define USB_RXHUBADDR2_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBPORT2 +// register. +// +//***************************************************************************** +#define USB_RXHUBPORT2_PORT_M 0x0000007F // Hub Port +#define USB_RXHUBPORT2_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR3 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR3_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR3_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR3 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR3_MULTTRAN 0x00000080 // Multiple Translators +#define USB_TXHUBADDR3_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR3_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT3 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT3_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT3_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFUNCADDR3 +// register. +// +//***************************************************************************** +#define USB_RXFUNCADDR3_ADDR_M 0x0000007F // Device Address +#define USB_RXFUNCADDR3_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBADDR3 +// register. +// +//***************************************************************************** +#define USB_RXHUBADDR3_MULTTRAN 0x00000080 // Multiple Translators +#define USB_RXHUBADDR3_ADDR_M 0x0000007F // Hub Address +#define USB_RXHUBADDR3_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBPORT3 +// register. +// +//***************************************************************************** +#define USB_RXHUBPORT3_PORT_M 0x0000007F // Hub Port +#define USB_RXHUBPORT3_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR4 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR4_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR4_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR4 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR4_MULTTRAN 0x00000080 // Multiple Translators +#define USB_TXHUBADDR4_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR4_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT4 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT4_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT4_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFUNCADDR4 +// register. +// +//***************************************************************************** +#define USB_RXFUNCADDR4_ADDR_M 0x0000007F // Device Address +#define USB_RXFUNCADDR4_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBADDR4 +// register. +// +//***************************************************************************** +#define USB_RXHUBADDR4_MULTTRAN 0x00000080 // Multiple Translators +#define USB_RXHUBADDR4_ADDR_M 0x0000007F // Hub Address +#define USB_RXHUBADDR4_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBPORT4 +// register. +// +//***************************************************************************** +#define USB_RXHUBPORT4_PORT_M 0x0000007F // Hub Port +#define USB_RXHUBPORT4_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR5 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR5_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR5_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR5 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR5_MULTTRAN 0x00000080 // Multiple Translators +#define USB_TXHUBADDR5_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR5_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT5 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT5_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT5_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFUNCADDR5 +// register. +// +//***************************************************************************** +#define USB_RXFUNCADDR5_ADDR_M 0x0000007F // Device Address +#define USB_RXFUNCADDR5_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBADDR5 +// register. +// +//***************************************************************************** +#define USB_RXHUBADDR5_MULTTRAN 0x00000080 // Multiple Translators +#define USB_RXHUBADDR5_ADDR_M 0x0000007F // Hub Address +#define USB_RXHUBADDR5_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBPORT5 +// register. +// +//***************************************************************************** +#define USB_RXHUBPORT5_PORT_M 0x0000007F // Hub Port +#define USB_RXHUBPORT5_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR6 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR6_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR6_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR6 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR6_MULTTRAN 0x00000080 // Multiple Translators +#define USB_TXHUBADDR6_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR6_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT6 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT6_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT6_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFUNCADDR6 +// register. +// +//***************************************************************************** +#define USB_RXFUNCADDR6_ADDR_M 0x0000007F // Device Address +#define USB_RXFUNCADDR6_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBADDR6 +// register. +// +//***************************************************************************** +#define USB_RXHUBADDR6_MULTTRAN 0x00000080 // Multiple Translators +#define USB_RXHUBADDR6_ADDR_M 0x0000007F // Hub Address +#define USB_RXHUBADDR6_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBPORT6 +// register. +// +//***************************************************************************** +#define USB_RXHUBPORT6_PORT_M 0x0000007F // Hub Port +#define USB_RXHUBPORT6_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR7 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR7_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR7_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR7 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR7_MULTTRAN 0x00000080 // Multiple Translators +#define USB_TXHUBADDR7_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR7_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT7 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT7_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT7_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFUNCADDR7 +// register. +// +//***************************************************************************** +#define USB_RXFUNCADDR7_ADDR_M 0x0000007F // Device Address +#define USB_RXFUNCADDR7_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBADDR7 +// register. +// +//***************************************************************************** +#define USB_RXHUBADDR7_MULTTRAN 0x00000080 // Multiple Translators +#define USB_RXHUBADDR7_ADDR_M 0x0000007F // Hub Address +#define USB_RXHUBADDR7_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBPORT7 +// register. +// +//***************************************************************************** +#define USB_RXHUBPORT7_PORT_M 0x0000007F // Hub Port +#define USB_RXHUBPORT7_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR8 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR8_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR8_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR8 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR8_MULTTRAN 0x00000080 // Multiple Translators +#define USB_TXHUBADDR8_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR8_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT8 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT8_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT8_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFUNCADDR8 +// register. +// +//***************************************************************************** +#define USB_RXFUNCADDR8_ADDR_M 0x0000007F // Device Address +#define USB_RXFUNCADDR8_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBADDR8 +// register. +// +//***************************************************************************** +#define USB_RXHUBADDR8_MULTTRAN 0x00000080 // Multiple Translators +#define USB_RXHUBADDR8_ADDR_M 0x0000007F // Hub Address +#define USB_RXHUBADDR8_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBPORT8 +// register. +// +//***************************************************************************** +#define USB_RXHUBPORT8_PORT_M 0x0000007F // Hub Port +#define USB_RXHUBPORT8_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR9 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR9_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR9_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR9 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR9_MULTTRAN 0x00000080 // Multiple Translators +#define USB_TXHUBADDR9_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR9_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT9 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT9_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT9_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFUNCADDR9 +// register. +// +//***************************************************************************** +#define USB_RXFUNCADDR9_ADDR_M 0x0000007F // Device Address +#define USB_RXFUNCADDR9_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBADDR9 +// register. +// +//***************************************************************************** +#define USB_RXHUBADDR9_MULTTRAN 0x00000080 // Multiple Translators +#define USB_RXHUBADDR9_ADDR_M 0x0000007F // Hub Address +#define USB_RXHUBADDR9_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBPORT9 +// register. +// +//***************************************************************************** +#define USB_RXHUBPORT9_PORT_M 0x0000007F // Hub Port +#define USB_RXHUBPORT9_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR10 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR10_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR10_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR10 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR10_MULTTRAN \ + 0x00000080 // Multiple Translators +#define USB_TXHUBADDR10_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR10_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT10 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT10_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT10_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFUNCADDR10 +// register. +// +//***************************************************************************** +#define USB_RXFUNCADDR10_ADDR_M 0x0000007F // Device Address +#define USB_RXFUNCADDR10_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBADDR10 +// register. +// +//***************************************************************************** +#define USB_RXHUBADDR10_MULTTRAN \ + 0x00000080 // Multiple Translators +#define USB_RXHUBADDR10_ADDR_M 0x0000007F // Hub Address +#define USB_RXHUBADDR10_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBPORT10 +// register. +// +//***************************************************************************** +#define USB_RXHUBPORT10_PORT_M 0x0000007F // Hub Port +#define USB_RXHUBPORT10_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR11 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR11_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR11_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR11 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR11_MULTTRAN \ + 0x00000080 // Multiple Translators +#define USB_TXHUBADDR11_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR11_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT11 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT11_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT11_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFUNCADDR11 +// register. +// +//***************************************************************************** +#define USB_RXFUNCADDR11_ADDR_M 0x0000007F // Device Address +#define USB_RXFUNCADDR11_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBADDR11 +// register. +// +//***************************************************************************** +#define USB_RXHUBADDR11_MULTTRAN \ + 0x00000080 // Multiple Translators +#define USB_RXHUBADDR11_ADDR_M 0x0000007F // Hub Address +#define USB_RXHUBADDR11_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBPORT11 +// register. +// +//***************************************************************************** +#define USB_RXHUBPORT11_PORT_M 0x0000007F // Hub Port +#define USB_RXHUBPORT11_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR12 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR12_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR12_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR12 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR12_MULTTRAN \ + 0x00000080 // Multiple Translators +#define USB_TXHUBADDR12_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR12_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT12 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT12_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT12_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFUNCADDR12 +// register. +// +//***************************************************************************** +#define USB_RXFUNCADDR12_ADDR_M 0x0000007F // Device Address +#define USB_RXFUNCADDR12_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBADDR12 +// register. +// +//***************************************************************************** +#define USB_RXHUBADDR12_MULTTRAN \ + 0x00000080 // Multiple Translators +#define USB_RXHUBADDR12_ADDR_M 0x0000007F // Hub Address +#define USB_RXHUBADDR12_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBPORT12 +// register. +// +//***************************************************************************** +#define USB_RXHUBPORT12_PORT_M 0x0000007F // Hub Port +#define USB_RXHUBPORT12_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR13 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR13_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR13_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR13 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR13_MULTTRAN \ + 0x00000080 // Multiple Translators +#define USB_TXHUBADDR13_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR13_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT13 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT13_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT13_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFUNCADDR13 +// register. +// +//***************************************************************************** +#define USB_RXFUNCADDR13_ADDR_M 0x0000007F // Device Address +#define USB_RXFUNCADDR13_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBADDR13 +// register. +// +//***************************************************************************** +#define USB_RXHUBADDR13_MULTTRAN \ + 0x00000080 // Multiple Translators +#define USB_RXHUBADDR13_ADDR_M 0x0000007F // Hub Address +#define USB_RXHUBADDR13_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBPORT13 +// register. +// +//***************************************************************************** +#define USB_RXHUBPORT13_PORT_M 0x0000007F // Hub Port +#define USB_RXHUBPORT13_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR14 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR14_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR14_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR14 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR14_MULTTRAN \ + 0x00000080 // Multiple Translators +#define USB_TXHUBADDR14_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR14_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT14 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT14_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT14_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFUNCADDR14 +// register. +// +//***************************************************************************** +#define USB_RXFUNCADDR14_ADDR_M 0x0000007F // Device Address +#define USB_RXFUNCADDR14_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBADDR14 +// register. +// +//***************************************************************************** +#define USB_RXHUBADDR14_MULTTRAN \ + 0x00000080 // Multiple Translators +#define USB_RXHUBADDR14_ADDR_M 0x0000007F // Hub Address +#define USB_RXHUBADDR14_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBPORT14 +// register. +// +//***************************************************************************** +#define USB_RXHUBPORT14_PORT_M 0x0000007F // Hub Port +#define USB_RXHUBPORT14_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXFUNCADDR15 +// register. +// +//***************************************************************************** +#define USB_TXFUNCADDR15_ADDR_M 0x0000007F // Device Address +#define USB_TXFUNCADDR15_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBADDR15 +// register. +// +//***************************************************************************** +#define USB_TXHUBADDR15_MULTTRAN \ + 0x00000080 // Multiple Translators +#define USB_TXHUBADDR15_ADDR_M 0x0000007F // Hub Address +#define USB_TXHUBADDR15_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXHUBPORT15 +// register. +// +//***************************************************************************** +#define USB_TXHUBPORT15_PORT_M 0x0000007F // Hub Port +#define USB_TXHUBPORT15_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXFUNCADDR15 +// register. +// +//***************************************************************************** +#define USB_RXFUNCADDR15_ADDR_M 0x0000007F // Device Address +#define USB_RXFUNCADDR15_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBADDR15 +// register. +// +//***************************************************************************** +#define USB_RXHUBADDR15_MULTTRAN \ + 0x00000080 // Multiple Translators +#define USB_RXHUBADDR15_ADDR_M 0x0000007F // Hub Address +#define USB_RXHUBADDR15_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXHUBPORT15 +// register. +// +//***************************************************************************** +#define USB_RXHUBPORT15_PORT_M 0x0000007F // Hub Port +#define USB_RXHUBPORT15_PORT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_CSRL0 register. +// +//***************************************************************************** +#define USB_CSRL0_NAKTO 0x00000080 // NAK Timeout +#define USB_CSRL0_SETENDC 0x00000080 // Setup End Clear +#define USB_CSRL0_STATUS 0x00000040 // STATUS Packet +#define USB_CSRL0_RXRDYC 0x00000040 // RXRDY Clear +#define USB_CSRL0_REQPKT 0x00000020 // Request Packet +#define USB_CSRL0_STALL 0x00000020 // Send Stall +#define USB_CSRL0_SETEND 0x00000010 // Setup End +#define USB_CSRL0_ERROR 0x00000010 // Error +#define USB_CSRL0_DATAEND 0x00000008 // Data End +#define USB_CSRL0_SETUP 0x00000008 // Setup Packet +#define USB_CSRL0_STALLED 0x00000004 // Endpoint Stalled +#define USB_CSRL0_TXRDY 0x00000002 // Transmit Packet Ready +#define USB_CSRL0_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_CSRH0 register. +// +//***************************************************************************** +#define USB_CSRH0_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_CSRH0_DT 0x00000002 // Data Toggle +#define USB_CSRH0_FLUSH 0x00000001 // Flush FIFO + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_COUNT0 register. +// +//***************************************************************************** +#define USB_COUNT0_COUNT_M 0x0000007F // FIFO Count +#define USB_COUNT0_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TYPE0 register. +// +//***************************************************************************** +#define USB_TYPE0_SPEED_M 0x000000C0 // Operating Speed +#define USB_TYPE0_SPEED_FULL 0x00000080 // Full +#define USB_TYPE0_SPEED_LOW 0x000000C0 // Low + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_NAKLMT register. +// +//***************************************************************************** +#define USB_NAKLMT_NAKLMT_M 0x0000001F // EP0 NAK Limit +#define USB_NAKLMT_NAKLMT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXMAXP1 register. +// +//***************************************************************************** +#define USB_TXMAXP1_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_TXMAXP1_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRL1 register. +// +//***************************************************************************** +#define USB_TXCSRL1_NAKTO 0x00000080 // NAK Timeout +#define USB_TXCSRL1_CLRDT 0x00000040 // Clear Data Toggle +#define USB_TXCSRL1_STALLED 0x00000020 // Endpoint Stalled +#define USB_TXCSRL1_STALL 0x00000010 // Send STALL +#define USB_TXCSRL1_SETUP 0x00000010 // Setup Packet +#define USB_TXCSRL1_FLUSH 0x00000008 // Flush FIFO +#define USB_TXCSRL1_ERROR 0x00000004 // Error +#define USB_TXCSRL1_UNDRN 0x00000004 // Underrun +#define USB_TXCSRL1_FIFONE 0x00000002 // FIFO Not Empty +#define USB_TXCSRL1_TXRDY 0x00000001 // Transmit Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRH1 register. +// +//***************************************************************************** +#define USB_TXCSRH1_AUTOSET 0x00000080 // Auto Set +#define USB_TXCSRH1_ISO 0x00000040 // Isochronous Transfers +#define USB_TXCSRH1_MODE 0x00000020 // Mode +#define USB_TXCSRH1_DMAEN 0x00000010 // DMA Request Enable +#define USB_TXCSRH1_FDT 0x00000008 // Force Data Toggle +#define USB_TXCSRH1_DMAMOD 0x00000004 // DMA Request Mode +#define USB_TXCSRH1_DTWE 0x00000002 // Data Toggle Write Enable +#define USB_TXCSRH1_DT 0x00000001 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXMAXP1 register. +// +//***************************************************************************** +#define USB_RXMAXP1_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_RXMAXP1_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRL1 register. +// +//***************************************************************************** +#define USB_RXCSRL1_CLRDT 0x00000080 // Clear Data Toggle +#define USB_RXCSRL1_STALLED 0x00000040 // Endpoint Stalled +#define USB_RXCSRL1_STALL 0x00000020 // Send STALL +#define USB_RXCSRL1_REQPKT 0x00000020 // Request Packet +#define USB_RXCSRL1_FLUSH 0x00000010 // Flush FIFO +#define USB_RXCSRL1_DATAERR 0x00000008 // Data Error +#define USB_RXCSRL1_NAKTO 0x00000008 // NAK Timeout +#define USB_RXCSRL1_OVER 0x00000004 // Overrun +#define USB_RXCSRL1_ERROR 0x00000004 // Error +#define USB_RXCSRL1_FULL 0x00000002 // FIFO Full +#define USB_RXCSRL1_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRH1 register. +// +//***************************************************************************** +#define USB_RXCSRH1_AUTOCL 0x00000080 // Auto Clear +#define USB_RXCSRH1_AUTORQ 0x00000040 // Auto Request +#define USB_RXCSRH1_ISO 0x00000040 // Isochronous Transfers +#define USB_RXCSRH1_DMAEN 0x00000020 // DMA Request Enable +#define USB_RXCSRH1_DISNYET 0x00000010 // Disable NYET +#define USB_RXCSRH1_PIDERR 0x00000010 // PID Error +#define USB_RXCSRH1_DMAMOD 0x00000008 // DMA Request Mode +#define USB_RXCSRH1_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_RXCSRH1_DT 0x00000002 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCOUNT1 register. +// +//***************************************************************************** +#define USB_RXCOUNT1_COUNT_M 0x00001FFF // Receive Packet Count +#define USB_RXCOUNT1_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXTYPE1 register. +// +//***************************************************************************** +#define USB_TXTYPE1_SPEED_M 0x000000C0 // Operating Speed +#define USB_TXTYPE1_SPEED_DFLT 0x00000000 // Default +#define USB_TXTYPE1_SPEED_FULL 0x00000080 // Full +#define USB_TXTYPE1_SPEED_LOW 0x000000C0 // Low +#define USB_TXTYPE1_PROTO_M 0x00000030 // Protocol +#define USB_TXTYPE1_PROTO_CTRL 0x00000000 // Control +#define USB_TXTYPE1_PROTO_ISOC 0x00000010 // Isochronous +#define USB_TXTYPE1_PROTO_BULK 0x00000020 // Bulk +#define USB_TXTYPE1_PROTO_INT 0x00000030 // Interrupt +#define USB_TXTYPE1_TEP_M 0x0000000F // Target Endpoint Number +#define USB_TXTYPE1_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXINTERVAL1 +// register. +// +//***************************************************************************** +#define USB_TXINTERVAL1_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_TXINTERVAL1_TXPOLL_M \ + 0x000000FF // TX Polling +#define USB_TXINTERVAL1_TXPOLL_S \ + 0 +#define USB_TXINTERVAL1_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXTYPE1 register. +// +//***************************************************************************** +#define USB_RXTYPE1_SPEED_M 0x000000C0 // Operating Speed +#define USB_RXTYPE1_SPEED_DFLT 0x00000000 // Default +#define USB_RXTYPE1_SPEED_FULL 0x00000080 // Full +#define USB_RXTYPE1_SPEED_LOW 0x000000C0 // Low +#define USB_RXTYPE1_PROTO_M 0x00000030 // Protocol +#define USB_RXTYPE1_PROTO_CTRL 0x00000000 // Control +#define USB_RXTYPE1_PROTO_ISOC 0x00000010 // Isochronous +#define USB_RXTYPE1_PROTO_BULK 0x00000020 // Bulk +#define USB_RXTYPE1_PROTO_INT 0x00000030 // Interrupt +#define USB_RXTYPE1_TEP_M 0x0000000F // Target Endpoint Number +#define USB_RXTYPE1_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXINTERVAL1 +// register. +// +//***************************************************************************** +#define USB_RXINTERVAL1_TXPOLL_M \ + 0x000000FF // RX Polling +#define USB_RXINTERVAL1_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_RXINTERVAL1_TXPOLL_S \ + 0 +#define USB_RXINTERVAL1_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXMAXP2 register. +// +//***************************************************************************** +#define USB_TXMAXP2_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_TXMAXP2_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRL2 register. +// +//***************************************************************************** +#define USB_TXCSRL2_NAKTO 0x00000080 // NAK Timeout +#define USB_TXCSRL2_CLRDT 0x00000040 // Clear Data Toggle +#define USB_TXCSRL2_STALLED 0x00000020 // Endpoint Stalled +#define USB_TXCSRL2_SETUP 0x00000010 // Setup Packet +#define USB_TXCSRL2_STALL 0x00000010 // Send STALL +#define USB_TXCSRL2_FLUSH 0x00000008 // Flush FIFO +#define USB_TXCSRL2_ERROR 0x00000004 // Error +#define USB_TXCSRL2_UNDRN 0x00000004 // Underrun +#define USB_TXCSRL2_FIFONE 0x00000002 // FIFO Not Empty +#define USB_TXCSRL2_TXRDY 0x00000001 // Transmit Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRH2 register. +// +//***************************************************************************** +#define USB_TXCSRH2_AUTOSET 0x00000080 // Auto Set +#define USB_TXCSRH2_ISO 0x00000040 // Isochronous Transfers +#define USB_TXCSRH2_MODE 0x00000020 // Mode +#define USB_TXCSRH2_DMAEN 0x00000010 // DMA Request Enable +#define USB_TXCSRH2_FDT 0x00000008 // Force Data Toggle +#define USB_TXCSRH2_DMAMOD 0x00000004 // DMA Request Mode +#define USB_TXCSRH2_DTWE 0x00000002 // Data Toggle Write Enable +#define USB_TXCSRH2_DT 0x00000001 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXMAXP2 register. +// +//***************************************************************************** +#define USB_RXMAXP2_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_RXMAXP2_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRL2 register. +// +//***************************************************************************** +#define USB_RXCSRL2_CLRDT 0x00000080 // Clear Data Toggle +#define USB_RXCSRL2_STALLED 0x00000040 // Endpoint Stalled +#define USB_RXCSRL2_REQPKT 0x00000020 // Request Packet +#define USB_RXCSRL2_STALL 0x00000020 // Send STALL +#define USB_RXCSRL2_FLUSH 0x00000010 // Flush FIFO +#define USB_RXCSRL2_DATAERR 0x00000008 // Data Error +#define USB_RXCSRL2_NAKTO 0x00000008 // NAK Timeout +#define USB_RXCSRL2_ERROR 0x00000004 // Error +#define USB_RXCSRL2_OVER 0x00000004 // Overrun +#define USB_RXCSRL2_FULL 0x00000002 // FIFO Full +#define USB_RXCSRL2_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRH2 register. +// +//***************************************************************************** +#define USB_RXCSRH2_AUTOCL 0x00000080 // Auto Clear +#define USB_RXCSRH2_AUTORQ 0x00000040 // Auto Request +#define USB_RXCSRH2_ISO 0x00000040 // Isochronous Transfers +#define USB_RXCSRH2_DMAEN 0x00000020 // DMA Request Enable +#define USB_RXCSRH2_DISNYET 0x00000010 // Disable NYET +#define USB_RXCSRH2_PIDERR 0x00000010 // PID Error +#define USB_RXCSRH2_DMAMOD 0x00000008 // DMA Request Mode +#define USB_RXCSRH2_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_RXCSRH2_DT 0x00000002 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCOUNT2 register. +// +//***************************************************************************** +#define USB_RXCOUNT2_COUNT_M 0x00001FFF // Receive Packet Count +#define USB_RXCOUNT2_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXTYPE2 register. +// +//***************************************************************************** +#define USB_TXTYPE2_SPEED_M 0x000000C0 // Operating Speed +#define USB_TXTYPE2_SPEED_DFLT 0x00000000 // Default +#define USB_TXTYPE2_SPEED_FULL 0x00000080 // Full +#define USB_TXTYPE2_SPEED_LOW 0x000000C0 // Low +#define USB_TXTYPE2_PROTO_M 0x00000030 // Protocol +#define USB_TXTYPE2_PROTO_CTRL 0x00000000 // Control +#define USB_TXTYPE2_PROTO_ISOC 0x00000010 // Isochronous +#define USB_TXTYPE2_PROTO_BULK 0x00000020 // Bulk +#define USB_TXTYPE2_PROTO_INT 0x00000030 // Interrupt +#define USB_TXTYPE2_TEP_M 0x0000000F // Target Endpoint Number +#define USB_TXTYPE2_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXINTERVAL2 +// register. +// +//***************************************************************************** +#define USB_TXINTERVAL2_TXPOLL_M \ + 0x000000FF // TX Polling +#define USB_TXINTERVAL2_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_TXINTERVAL2_NAKLMT_S \ + 0 +#define USB_TXINTERVAL2_TXPOLL_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXTYPE2 register. +// +//***************************************************************************** +#define USB_RXTYPE2_SPEED_M 0x000000C0 // Operating Speed +#define USB_RXTYPE2_SPEED_DFLT 0x00000000 // Default +#define USB_RXTYPE2_SPEED_FULL 0x00000080 // Full +#define USB_RXTYPE2_SPEED_LOW 0x000000C0 // Low +#define USB_RXTYPE2_PROTO_M 0x00000030 // Protocol +#define USB_RXTYPE2_PROTO_CTRL 0x00000000 // Control +#define USB_RXTYPE2_PROTO_ISOC 0x00000010 // Isochronous +#define USB_RXTYPE2_PROTO_BULK 0x00000020 // Bulk +#define USB_RXTYPE2_PROTO_INT 0x00000030 // Interrupt +#define USB_RXTYPE2_TEP_M 0x0000000F // Target Endpoint Number +#define USB_RXTYPE2_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXINTERVAL2 +// register. +// +//***************************************************************************** +#define USB_RXINTERVAL2_TXPOLL_M \ + 0x000000FF // RX Polling +#define USB_RXINTERVAL2_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_RXINTERVAL2_TXPOLL_S \ + 0 +#define USB_RXINTERVAL2_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXMAXP3 register. +// +//***************************************************************************** +#define USB_TXMAXP3_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_TXMAXP3_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRL3 register. +// +//***************************************************************************** +#define USB_TXCSRL3_NAKTO 0x00000080 // NAK Timeout +#define USB_TXCSRL3_CLRDT 0x00000040 // Clear Data Toggle +#define USB_TXCSRL3_STALLED 0x00000020 // Endpoint Stalled +#define USB_TXCSRL3_SETUP 0x00000010 // Setup Packet +#define USB_TXCSRL3_STALL 0x00000010 // Send STALL +#define USB_TXCSRL3_FLUSH 0x00000008 // Flush FIFO +#define USB_TXCSRL3_ERROR 0x00000004 // Error +#define USB_TXCSRL3_UNDRN 0x00000004 // Underrun +#define USB_TXCSRL3_FIFONE 0x00000002 // FIFO Not Empty +#define USB_TXCSRL3_TXRDY 0x00000001 // Transmit Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRH3 register. +// +//***************************************************************************** +#define USB_TXCSRH3_AUTOSET 0x00000080 // Auto Set +#define USB_TXCSRH3_ISO 0x00000040 // Isochronous Transfers +#define USB_TXCSRH3_MODE 0x00000020 // Mode +#define USB_TXCSRH3_DMAEN 0x00000010 // DMA Request Enable +#define USB_TXCSRH3_FDT 0x00000008 // Force Data Toggle +#define USB_TXCSRH3_DMAMOD 0x00000004 // DMA Request Mode +#define USB_TXCSRH3_DTWE 0x00000002 // Data Toggle Write Enable +#define USB_TXCSRH3_DT 0x00000001 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXMAXP3 register. +// +//***************************************************************************** +#define USB_RXMAXP3_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_RXMAXP3_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRL3 register. +// +//***************************************************************************** +#define USB_RXCSRL3_CLRDT 0x00000080 // Clear Data Toggle +#define USB_RXCSRL3_STALLED 0x00000040 // Endpoint Stalled +#define USB_RXCSRL3_STALL 0x00000020 // Send STALL +#define USB_RXCSRL3_REQPKT 0x00000020 // Request Packet +#define USB_RXCSRL3_FLUSH 0x00000010 // Flush FIFO +#define USB_RXCSRL3_DATAERR 0x00000008 // Data Error +#define USB_RXCSRL3_NAKTO 0x00000008 // NAK Timeout +#define USB_RXCSRL3_ERROR 0x00000004 // Error +#define USB_RXCSRL3_OVER 0x00000004 // Overrun +#define USB_RXCSRL3_FULL 0x00000002 // FIFO Full +#define USB_RXCSRL3_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRH3 register. +// +//***************************************************************************** +#define USB_RXCSRH3_AUTOCL 0x00000080 // Auto Clear +#define USB_RXCSRH3_AUTORQ 0x00000040 // Auto Request +#define USB_RXCSRH3_ISO 0x00000040 // Isochronous Transfers +#define USB_RXCSRH3_DMAEN 0x00000020 // DMA Request Enable +#define USB_RXCSRH3_DISNYET 0x00000010 // Disable NYET +#define USB_RXCSRH3_PIDERR 0x00000010 // PID Error +#define USB_RXCSRH3_DMAMOD 0x00000008 // DMA Request Mode +#define USB_RXCSRH3_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_RXCSRH3_DT 0x00000002 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCOUNT3 register. +// +//***************************************************************************** +#define USB_RXCOUNT3_COUNT_M 0x00001FFF // Receive Packet Count +#define USB_RXCOUNT3_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXTYPE3 register. +// +//***************************************************************************** +#define USB_TXTYPE3_SPEED_M 0x000000C0 // Operating Speed +#define USB_TXTYPE3_SPEED_DFLT 0x00000000 // Default +#define USB_TXTYPE3_SPEED_FULL 0x00000080 // Full +#define USB_TXTYPE3_SPEED_LOW 0x000000C0 // Low +#define USB_TXTYPE3_PROTO_M 0x00000030 // Protocol +#define USB_TXTYPE3_PROTO_CTRL 0x00000000 // Control +#define USB_TXTYPE3_PROTO_ISOC 0x00000010 // Isochronous +#define USB_TXTYPE3_PROTO_BULK 0x00000020 // Bulk +#define USB_TXTYPE3_PROTO_INT 0x00000030 // Interrupt +#define USB_TXTYPE3_TEP_M 0x0000000F // Target Endpoint Number +#define USB_TXTYPE3_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXINTERVAL3 +// register. +// +//***************************************************************************** +#define USB_TXINTERVAL3_TXPOLL_M \ + 0x000000FF // TX Polling +#define USB_TXINTERVAL3_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_TXINTERVAL3_TXPOLL_S \ + 0 +#define USB_TXINTERVAL3_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXTYPE3 register. +// +//***************************************************************************** +#define USB_RXTYPE3_SPEED_M 0x000000C0 // Operating Speed +#define USB_RXTYPE3_SPEED_DFLT 0x00000000 // Default +#define USB_RXTYPE3_SPEED_FULL 0x00000080 // Full +#define USB_RXTYPE3_SPEED_LOW 0x000000C0 // Low +#define USB_RXTYPE3_PROTO_M 0x00000030 // Protocol +#define USB_RXTYPE3_PROTO_CTRL 0x00000000 // Control +#define USB_RXTYPE3_PROTO_ISOC 0x00000010 // Isochronous +#define USB_RXTYPE3_PROTO_BULK 0x00000020 // Bulk +#define USB_RXTYPE3_PROTO_INT 0x00000030 // Interrupt +#define USB_RXTYPE3_TEP_M 0x0000000F // Target Endpoint Number +#define USB_RXTYPE3_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXINTERVAL3 +// register. +// +//***************************************************************************** +#define USB_RXINTERVAL3_TXPOLL_M \ + 0x000000FF // RX Polling +#define USB_RXINTERVAL3_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_RXINTERVAL3_TXPOLL_S \ + 0 +#define USB_RXINTERVAL3_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXMAXP4 register. +// +//***************************************************************************** +#define USB_TXMAXP4_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_TXMAXP4_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRL4 register. +// +//***************************************************************************** +#define USB_TXCSRL4_NAKTO 0x00000080 // NAK Timeout +#define USB_TXCSRL4_CLRDT 0x00000040 // Clear Data Toggle +#define USB_TXCSRL4_STALLED 0x00000020 // Endpoint Stalled +#define USB_TXCSRL4_SETUP 0x00000010 // Setup Packet +#define USB_TXCSRL4_STALL 0x00000010 // Send STALL +#define USB_TXCSRL4_FLUSH 0x00000008 // Flush FIFO +#define USB_TXCSRL4_ERROR 0x00000004 // Error +#define USB_TXCSRL4_UNDRN 0x00000004 // Underrun +#define USB_TXCSRL4_FIFONE 0x00000002 // FIFO Not Empty +#define USB_TXCSRL4_TXRDY 0x00000001 // Transmit Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRH4 register. +// +//***************************************************************************** +#define USB_TXCSRH4_AUTOSET 0x00000080 // Auto Set +#define USB_TXCSRH4_ISO 0x00000040 // Isochronous Transfers +#define USB_TXCSRH4_MODE 0x00000020 // Mode +#define USB_TXCSRH4_DMAEN 0x00000010 // DMA Request Enable +#define USB_TXCSRH4_FDT 0x00000008 // Force Data Toggle +#define USB_TXCSRH4_DMAMOD 0x00000004 // DMA Request Mode +#define USB_TXCSRH4_DTWE 0x00000002 // Data Toggle Write Enable +#define USB_TXCSRH4_DT 0x00000001 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXMAXP4 register. +// +//***************************************************************************** +#define USB_RXMAXP4_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_RXMAXP4_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRL4 register. +// +//***************************************************************************** +#define USB_RXCSRL4_CLRDT 0x00000080 // Clear Data Toggle +#define USB_RXCSRL4_STALLED 0x00000040 // Endpoint Stalled +#define USB_RXCSRL4_STALL 0x00000020 // Send STALL +#define USB_RXCSRL4_REQPKT 0x00000020 // Request Packet +#define USB_RXCSRL4_FLUSH 0x00000010 // Flush FIFO +#define USB_RXCSRL4_NAKTO 0x00000008 // NAK Timeout +#define USB_RXCSRL4_DATAERR 0x00000008 // Data Error +#define USB_RXCSRL4_OVER 0x00000004 // Overrun +#define USB_RXCSRL4_ERROR 0x00000004 // Error +#define USB_RXCSRL4_FULL 0x00000002 // FIFO Full +#define USB_RXCSRL4_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRH4 register. +// +//***************************************************************************** +#define USB_RXCSRH4_AUTOCL 0x00000080 // Auto Clear +#define USB_RXCSRH4_AUTORQ 0x00000040 // Auto Request +#define USB_RXCSRH4_ISO 0x00000040 // Isochronous Transfers +#define USB_RXCSRH4_DMAEN 0x00000020 // DMA Request Enable +#define USB_RXCSRH4_DISNYET 0x00000010 // Disable NYET +#define USB_RXCSRH4_PIDERR 0x00000010 // PID Error +#define USB_RXCSRH4_DMAMOD 0x00000008 // DMA Request Mode +#define USB_RXCSRH4_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_RXCSRH4_DT 0x00000002 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCOUNT4 register. +// +//***************************************************************************** +#define USB_RXCOUNT4_COUNT_M 0x00001FFF // Receive Packet Count +#define USB_RXCOUNT4_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXTYPE4 register. +// +//***************************************************************************** +#define USB_TXTYPE4_SPEED_M 0x000000C0 // Operating Speed +#define USB_TXTYPE4_SPEED_DFLT 0x00000000 // Default +#define USB_TXTYPE4_SPEED_FULL 0x00000080 // Full +#define USB_TXTYPE4_SPEED_LOW 0x000000C0 // Low +#define USB_TXTYPE4_PROTO_M 0x00000030 // Protocol +#define USB_TXTYPE4_PROTO_CTRL 0x00000000 // Control +#define USB_TXTYPE4_PROTO_ISOC 0x00000010 // Isochronous +#define USB_TXTYPE4_PROTO_BULK 0x00000020 // Bulk +#define USB_TXTYPE4_PROTO_INT 0x00000030 // Interrupt +#define USB_TXTYPE4_TEP_M 0x0000000F // Target Endpoint Number +#define USB_TXTYPE4_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXINTERVAL4 +// register. +// +//***************************************************************************** +#define USB_TXINTERVAL4_TXPOLL_M \ + 0x000000FF // TX Polling +#define USB_TXINTERVAL4_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_TXINTERVAL4_NAKLMT_S \ + 0 +#define USB_TXINTERVAL4_TXPOLL_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXTYPE4 register. +// +//***************************************************************************** +#define USB_RXTYPE4_SPEED_M 0x000000C0 // Operating Speed +#define USB_RXTYPE4_SPEED_DFLT 0x00000000 // Default +#define USB_RXTYPE4_SPEED_FULL 0x00000080 // Full +#define USB_RXTYPE4_SPEED_LOW 0x000000C0 // Low +#define USB_RXTYPE4_PROTO_M 0x00000030 // Protocol +#define USB_RXTYPE4_PROTO_CTRL 0x00000000 // Control +#define USB_RXTYPE4_PROTO_ISOC 0x00000010 // Isochronous +#define USB_RXTYPE4_PROTO_BULK 0x00000020 // Bulk +#define USB_RXTYPE4_PROTO_INT 0x00000030 // Interrupt +#define USB_RXTYPE4_TEP_M 0x0000000F // Target Endpoint Number +#define USB_RXTYPE4_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXINTERVAL4 +// register. +// +//***************************************************************************** +#define USB_RXINTERVAL4_TXPOLL_M \ + 0x000000FF // RX Polling +#define USB_RXINTERVAL4_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_RXINTERVAL4_NAKLMT_S \ + 0 +#define USB_RXINTERVAL4_TXPOLL_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXMAXP5 register. +// +//***************************************************************************** +#define USB_TXMAXP5_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_TXMAXP5_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRL5 register. +// +//***************************************************************************** +#define USB_TXCSRL5_NAKTO 0x00000080 // NAK Timeout +#define USB_TXCSRL5_CLRDT 0x00000040 // Clear Data Toggle +#define USB_TXCSRL5_STALLED 0x00000020 // Endpoint Stalled +#define USB_TXCSRL5_SETUP 0x00000010 // Setup Packet +#define USB_TXCSRL5_STALL 0x00000010 // Send STALL +#define USB_TXCSRL5_FLUSH 0x00000008 // Flush FIFO +#define USB_TXCSRL5_ERROR 0x00000004 // Error +#define USB_TXCSRL5_UNDRN 0x00000004 // Underrun +#define USB_TXCSRL5_FIFONE 0x00000002 // FIFO Not Empty +#define USB_TXCSRL5_TXRDY 0x00000001 // Transmit Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRH5 register. +// +//***************************************************************************** +#define USB_TXCSRH5_AUTOSET 0x00000080 // Auto Set +#define USB_TXCSRH5_ISO 0x00000040 // Isochronous Transfers +#define USB_TXCSRH5_MODE 0x00000020 // Mode +#define USB_TXCSRH5_DMAEN 0x00000010 // DMA Request Enable +#define USB_TXCSRH5_FDT 0x00000008 // Force Data Toggle +#define USB_TXCSRH5_DMAMOD 0x00000004 // DMA Request Mode +#define USB_TXCSRH5_DTWE 0x00000002 // Data Toggle Write Enable +#define USB_TXCSRH5_DT 0x00000001 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXMAXP5 register. +// +//***************************************************************************** +#define USB_RXMAXP5_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_RXMAXP5_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRL5 register. +// +//***************************************************************************** +#define USB_RXCSRL5_CLRDT 0x00000080 // Clear Data Toggle +#define USB_RXCSRL5_STALLED 0x00000040 // Endpoint Stalled +#define USB_RXCSRL5_STALL 0x00000020 // Send STALL +#define USB_RXCSRL5_REQPKT 0x00000020 // Request Packet +#define USB_RXCSRL5_FLUSH 0x00000010 // Flush FIFO +#define USB_RXCSRL5_NAKTO 0x00000008 // NAK Timeout +#define USB_RXCSRL5_DATAERR 0x00000008 // Data Error +#define USB_RXCSRL5_ERROR 0x00000004 // Error +#define USB_RXCSRL5_OVER 0x00000004 // Overrun +#define USB_RXCSRL5_FULL 0x00000002 // FIFO Full +#define USB_RXCSRL5_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRH5 register. +// +//***************************************************************************** +#define USB_RXCSRH5_AUTOCL 0x00000080 // Auto Clear +#define USB_RXCSRH5_AUTORQ 0x00000040 // Auto Request +#define USB_RXCSRH5_ISO 0x00000040 // Isochronous Transfers +#define USB_RXCSRH5_DMAEN 0x00000020 // DMA Request Enable +#define USB_RXCSRH5_DISNYET 0x00000010 // Disable NYET +#define USB_RXCSRH5_PIDERR 0x00000010 // PID Error +#define USB_RXCSRH5_DMAMOD 0x00000008 // DMA Request Mode +#define USB_RXCSRH5_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_RXCSRH5_DT 0x00000002 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCOUNT5 register. +// +//***************************************************************************** +#define USB_RXCOUNT5_COUNT_M 0x00001FFF // Receive Packet Count +#define USB_RXCOUNT5_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXTYPE5 register. +// +//***************************************************************************** +#define USB_TXTYPE5_SPEED_M 0x000000C0 // Operating Speed +#define USB_TXTYPE5_SPEED_DFLT 0x00000000 // Default +#define USB_TXTYPE5_SPEED_FULL 0x00000080 // Full +#define USB_TXTYPE5_SPEED_LOW 0x000000C0 // Low +#define USB_TXTYPE5_PROTO_M 0x00000030 // Protocol +#define USB_TXTYPE5_PROTO_CTRL 0x00000000 // Control +#define USB_TXTYPE5_PROTO_ISOC 0x00000010 // Isochronous +#define USB_TXTYPE5_PROTO_BULK 0x00000020 // Bulk +#define USB_TXTYPE5_PROTO_INT 0x00000030 // Interrupt +#define USB_TXTYPE5_TEP_M 0x0000000F // Target Endpoint Number +#define USB_TXTYPE5_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXINTERVAL5 +// register. +// +//***************************************************************************** +#define USB_TXINTERVAL5_TXPOLL_M \ + 0x000000FF // TX Polling +#define USB_TXINTERVAL5_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_TXINTERVAL5_NAKLMT_S \ + 0 +#define USB_TXINTERVAL5_TXPOLL_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXTYPE5 register. +// +//***************************************************************************** +#define USB_RXTYPE5_SPEED_M 0x000000C0 // Operating Speed +#define USB_RXTYPE5_SPEED_DFLT 0x00000000 // Default +#define USB_RXTYPE5_SPEED_FULL 0x00000080 // Full +#define USB_RXTYPE5_SPEED_LOW 0x000000C0 // Low +#define USB_RXTYPE5_PROTO_M 0x00000030 // Protocol +#define USB_RXTYPE5_PROTO_CTRL 0x00000000 // Control +#define USB_RXTYPE5_PROTO_ISOC 0x00000010 // Isochronous +#define USB_RXTYPE5_PROTO_BULK 0x00000020 // Bulk +#define USB_RXTYPE5_PROTO_INT 0x00000030 // Interrupt +#define USB_RXTYPE5_TEP_M 0x0000000F // Target Endpoint Number +#define USB_RXTYPE5_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXINTERVAL5 +// register. +// +//***************************************************************************** +#define USB_RXINTERVAL5_TXPOLL_M \ + 0x000000FF // RX Polling +#define USB_RXINTERVAL5_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_RXINTERVAL5_TXPOLL_S \ + 0 +#define USB_RXINTERVAL5_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXMAXP6 register. +// +//***************************************************************************** +#define USB_TXMAXP6_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_TXMAXP6_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRL6 register. +// +//***************************************************************************** +#define USB_TXCSRL6_NAKTO 0x00000080 // NAK Timeout +#define USB_TXCSRL6_CLRDT 0x00000040 // Clear Data Toggle +#define USB_TXCSRL6_STALLED 0x00000020 // Endpoint Stalled +#define USB_TXCSRL6_STALL 0x00000010 // Send STALL +#define USB_TXCSRL6_SETUP 0x00000010 // Setup Packet +#define USB_TXCSRL6_FLUSH 0x00000008 // Flush FIFO +#define USB_TXCSRL6_ERROR 0x00000004 // Error +#define USB_TXCSRL6_UNDRN 0x00000004 // Underrun +#define USB_TXCSRL6_FIFONE 0x00000002 // FIFO Not Empty +#define USB_TXCSRL6_TXRDY 0x00000001 // Transmit Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRH6 register. +// +//***************************************************************************** +#define USB_TXCSRH6_AUTOSET 0x00000080 // Auto Set +#define USB_TXCSRH6_ISO 0x00000040 // Isochronous Transfers +#define USB_TXCSRH6_MODE 0x00000020 // Mode +#define USB_TXCSRH6_DMAEN 0x00000010 // DMA Request Enable +#define USB_TXCSRH6_FDT 0x00000008 // Force Data Toggle +#define USB_TXCSRH6_DMAMOD 0x00000004 // DMA Request Mode +#define USB_TXCSRH6_DTWE 0x00000002 // Data Toggle Write Enable +#define USB_TXCSRH6_DT 0x00000001 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXMAXP6 register. +// +//***************************************************************************** +#define USB_RXMAXP6_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_RXMAXP6_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRL6 register. +// +//***************************************************************************** +#define USB_RXCSRL6_CLRDT 0x00000080 // Clear Data Toggle +#define USB_RXCSRL6_STALLED 0x00000040 // Endpoint Stalled +#define USB_RXCSRL6_REQPKT 0x00000020 // Request Packet +#define USB_RXCSRL6_STALL 0x00000020 // Send STALL +#define USB_RXCSRL6_FLUSH 0x00000010 // Flush FIFO +#define USB_RXCSRL6_NAKTO 0x00000008 // NAK Timeout +#define USB_RXCSRL6_DATAERR 0x00000008 // Data Error +#define USB_RXCSRL6_ERROR 0x00000004 // Error +#define USB_RXCSRL6_OVER 0x00000004 // Overrun +#define USB_RXCSRL6_FULL 0x00000002 // FIFO Full +#define USB_RXCSRL6_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRH6 register. +// +//***************************************************************************** +#define USB_RXCSRH6_AUTOCL 0x00000080 // Auto Clear +#define USB_RXCSRH6_AUTORQ 0x00000040 // Auto Request +#define USB_RXCSRH6_ISO 0x00000040 // Isochronous Transfers +#define USB_RXCSRH6_DMAEN 0x00000020 // DMA Request Enable +#define USB_RXCSRH6_DISNYET 0x00000010 // Disable NYET +#define USB_RXCSRH6_PIDERR 0x00000010 // PID Error +#define USB_RXCSRH6_DMAMOD 0x00000008 // DMA Request Mode +#define USB_RXCSRH6_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_RXCSRH6_DT 0x00000002 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCOUNT6 register. +// +//***************************************************************************** +#define USB_RXCOUNT6_COUNT_M 0x00001FFF // Receive Packet Count +#define USB_RXCOUNT6_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXTYPE6 register. +// +//***************************************************************************** +#define USB_TXTYPE6_SPEED_M 0x000000C0 // Operating Speed +#define USB_TXTYPE6_SPEED_DFLT 0x00000000 // Default +#define USB_TXTYPE6_SPEED_FULL 0x00000080 // Full +#define USB_TXTYPE6_SPEED_LOW 0x000000C0 // Low +#define USB_TXTYPE6_PROTO_M 0x00000030 // Protocol +#define USB_TXTYPE6_PROTO_CTRL 0x00000000 // Control +#define USB_TXTYPE6_PROTO_ISOC 0x00000010 // Isochronous +#define USB_TXTYPE6_PROTO_BULK 0x00000020 // Bulk +#define USB_TXTYPE6_PROTO_INT 0x00000030 // Interrupt +#define USB_TXTYPE6_TEP_M 0x0000000F // Target Endpoint Number +#define USB_TXTYPE6_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXINTERVAL6 +// register. +// +//***************************************************************************** +#define USB_TXINTERVAL6_TXPOLL_M \ + 0x000000FF // TX Polling +#define USB_TXINTERVAL6_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_TXINTERVAL6_TXPOLL_S \ + 0 +#define USB_TXINTERVAL6_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXTYPE6 register. +// +//***************************************************************************** +#define USB_RXTYPE6_SPEED_M 0x000000C0 // Operating Speed +#define USB_RXTYPE6_SPEED_DFLT 0x00000000 // Default +#define USB_RXTYPE6_SPEED_FULL 0x00000080 // Full +#define USB_RXTYPE6_SPEED_LOW 0x000000C0 // Low +#define USB_RXTYPE6_PROTO_M 0x00000030 // Protocol +#define USB_RXTYPE6_PROTO_CTRL 0x00000000 // Control +#define USB_RXTYPE6_PROTO_ISOC 0x00000010 // Isochronous +#define USB_RXTYPE6_PROTO_BULK 0x00000020 // Bulk +#define USB_RXTYPE6_PROTO_INT 0x00000030 // Interrupt +#define USB_RXTYPE6_TEP_M 0x0000000F // Target Endpoint Number +#define USB_RXTYPE6_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXINTERVAL6 +// register. +// +//***************************************************************************** +#define USB_RXINTERVAL6_TXPOLL_M \ + 0x000000FF // RX Polling +#define USB_RXINTERVAL6_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_RXINTERVAL6_NAKLMT_S \ + 0 +#define USB_RXINTERVAL6_TXPOLL_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXMAXP7 register. +// +//***************************************************************************** +#define USB_TXMAXP7_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_TXMAXP7_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRL7 register. +// +//***************************************************************************** +#define USB_TXCSRL7_NAKTO 0x00000080 // NAK Timeout +#define USB_TXCSRL7_CLRDT 0x00000040 // Clear Data Toggle +#define USB_TXCSRL7_STALLED 0x00000020 // Endpoint Stalled +#define USB_TXCSRL7_STALL 0x00000010 // Send STALL +#define USB_TXCSRL7_SETUP 0x00000010 // Setup Packet +#define USB_TXCSRL7_FLUSH 0x00000008 // Flush FIFO +#define USB_TXCSRL7_ERROR 0x00000004 // Error +#define USB_TXCSRL7_UNDRN 0x00000004 // Underrun +#define USB_TXCSRL7_FIFONE 0x00000002 // FIFO Not Empty +#define USB_TXCSRL7_TXRDY 0x00000001 // Transmit Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRH7 register. +// +//***************************************************************************** +#define USB_TXCSRH7_AUTOSET 0x00000080 // Auto Set +#define USB_TXCSRH7_ISO 0x00000040 // Isochronous Transfers +#define USB_TXCSRH7_MODE 0x00000020 // Mode +#define USB_TXCSRH7_DMAEN 0x00000010 // DMA Request Enable +#define USB_TXCSRH7_FDT 0x00000008 // Force Data Toggle +#define USB_TXCSRH7_DMAMOD 0x00000004 // DMA Request Mode +#define USB_TXCSRH7_DTWE 0x00000002 // Data Toggle Write Enable +#define USB_TXCSRH7_DT 0x00000001 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXMAXP7 register. +// +//***************************************************************************** +#define USB_RXMAXP7_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_RXMAXP7_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRL7 register. +// +//***************************************************************************** +#define USB_RXCSRL7_CLRDT 0x00000080 // Clear Data Toggle +#define USB_RXCSRL7_STALLED 0x00000040 // Endpoint Stalled +#define USB_RXCSRL7_REQPKT 0x00000020 // Request Packet +#define USB_RXCSRL7_STALL 0x00000020 // Send STALL +#define USB_RXCSRL7_FLUSH 0x00000010 // Flush FIFO +#define USB_RXCSRL7_DATAERR 0x00000008 // Data Error +#define USB_RXCSRL7_NAKTO 0x00000008 // NAK Timeout +#define USB_RXCSRL7_ERROR 0x00000004 // Error +#define USB_RXCSRL7_OVER 0x00000004 // Overrun +#define USB_RXCSRL7_FULL 0x00000002 // FIFO Full +#define USB_RXCSRL7_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRH7 register. +// +//***************************************************************************** +#define USB_RXCSRH7_AUTOCL 0x00000080 // Auto Clear +#define USB_RXCSRH7_ISO 0x00000040 // Isochronous Transfers +#define USB_RXCSRH7_AUTORQ 0x00000040 // Auto Request +#define USB_RXCSRH7_DMAEN 0x00000020 // DMA Request Enable +#define USB_RXCSRH7_PIDERR 0x00000010 // PID Error +#define USB_RXCSRH7_DISNYET 0x00000010 // Disable NYET +#define USB_RXCSRH7_DMAMOD 0x00000008 // DMA Request Mode +#define USB_RXCSRH7_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_RXCSRH7_DT 0x00000002 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCOUNT7 register. +// +//***************************************************************************** +#define USB_RXCOUNT7_COUNT_M 0x00001FFF // Receive Packet Count +#define USB_RXCOUNT7_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXTYPE7 register. +// +//***************************************************************************** +#define USB_TXTYPE7_SPEED_M 0x000000C0 // Operating Speed +#define USB_TXTYPE7_SPEED_DFLT 0x00000000 // Default +#define USB_TXTYPE7_SPEED_FULL 0x00000080 // Full +#define USB_TXTYPE7_SPEED_LOW 0x000000C0 // Low +#define USB_TXTYPE7_PROTO_M 0x00000030 // Protocol +#define USB_TXTYPE7_PROTO_CTRL 0x00000000 // Control +#define USB_TXTYPE7_PROTO_ISOC 0x00000010 // Isochronous +#define USB_TXTYPE7_PROTO_BULK 0x00000020 // Bulk +#define USB_TXTYPE7_PROTO_INT 0x00000030 // Interrupt +#define USB_TXTYPE7_TEP_M 0x0000000F // Target Endpoint Number +#define USB_TXTYPE7_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXINTERVAL7 +// register. +// +//***************************************************************************** +#define USB_TXINTERVAL7_TXPOLL_M \ + 0x000000FF // TX Polling +#define USB_TXINTERVAL7_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_TXINTERVAL7_NAKLMT_S \ + 0 +#define USB_TXINTERVAL7_TXPOLL_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXTYPE7 register. +// +//***************************************************************************** +#define USB_RXTYPE7_SPEED_M 0x000000C0 // Operating Speed +#define USB_RXTYPE7_SPEED_DFLT 0x00000000 // Default +#define USB_RXTYPE7_SPEED_FULL 0x00000080 // Full +#define USB_RXTYPE7_SPEED_LOW 0x000000C0 // Low +#define USB_RXTYPE7_PROTO_M 0x00000030 // Protocol +#define USB_RXTYPE7_PROTO_CTRL 0x00000000 // Control +#define USB_RXTYPE7_PROTO_ISOC 0x00000010 // Isochronous +#define USB_RXTYPE7_PROTO_BULK 0x00000020 // Bulk +#define USB_RXTYPE7_PROTO_INT 0x00000030 // Interrupt +#define USB_RXTYPE7_TEP_M 0x0000000F // Target Endpoint Number +#define USB_RXTYPE7_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXINTERVAL7 +// register. +// +//***************************************************************************** +#define USB_RXINTERVAL7_TXPOLL_M \ + 0x000000FF // RX Polling +#define USB_RXINTERVAL7_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_RXINTERVAL7_NAKLMT_S \ + 0 +#define USB_RXINTERVAL7_TXPOLL_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXMAXP8 register. +// +//***************************************************************************** +#define USB_TXMAXP8_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_TXMAXP8_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRL8 register. +// +//***************************************************************************** +#define USB_TXCSRL8_NAKTO 0x00000080 // NAK Timeout +#define USB_TXCSRL8_CLRDT 0x00000040 // Clear Data Toggle +#define USB_TXCSRL8_STALLED 0x00000020 // Endpoint Stalled +#define USB_TXCSRL8_STALL 0x00000010 // Send STALL +#define USB_TXCSRL8_SETUP 0x00000010 // Setup Packet +#define USB_TXCSRL8_FLUSH 0x00000008 // Flush FIFO +#define USB_TXCSRL8_ERROR 0x00000004 // Error +#define USB_TXCSRL8_UNDRN 0x00000004 // Underrun +#define USB_TXCSRL8_FIFONE 0x00000002 // FIFO Not Empty +#define USB_TXCSRL8_TXRDY 0x00000001 // Transmit Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRH8 register. +// +//***************************************************************************** +#define USB_TXCSRH8_AUTOSET 0x00000080 // Auto Set +#define USB_TXCSRH8_ISO 0x00000040 // Isochronous Transfers +#define USB_TXCSRH8_MODE 0x00000020 // Mode +#define USB_TXCSRH8_DMAEN 0x00000010 // DMA Request Enable +#define USB_TXCSRH8_FDT 0x00000008 // Force Data Toggle +#define USB_TXCSRH8_DMAMOD 0x00000004 // DMA Request Mode +#define USB_TXCSRH8_DTWE 0x00000002 // Data Toggle Write Enable +#define USB_TXCSRH8_DT 0x00000001 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXMAXP8 register. +// +//***************************************************************************** +#define USB_RXMAXP8_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_RXMAXP8_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRL8 register. +// +//***************************************************************************** +#define USB_RXCSRL8_CLRDT 0x00000080 // Clear Data Toggle +#define USB_RXCSRL8_STALLED 0x00000040 // Endpoint Stalled +#define USB_RXCSRL8_STALL 0x00000020 // Send STALL +#define USB_RXCSRL8_REQPKT 0x00000020 // Request Packet +#define USB_RXCSRL8_FLUSH 0x00000010 // Flush FIFO +#define USB_RXCSRL8_NAKTO 0x00000008 // NAK Timeout +#define USB_RXCSRL8_DATAERR 0x00000008 // Data Error +#define USB_RXCSRL8_OVER 0x00000004 // Overrun +#define USB_RXCSRL8_ERROR 0x00000004 // Error +#define USB_RXCSRL8_FULL 0x00000002 // FIFO Full +#define USB_RXCSRL8_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRH8 register. +// +//***************************************************************************** +#define USB_RXCSRH8_AUTOCL 0x00000080 // Auto Clear +#define USB_RXCSRH8_AUTORQ 0x00000040 // Auto Request +#define USB_RXCSRH8_ISO 0x00000040 // Isochronous Transfers +#define USB_RXCSRH8_DMAEN 0x00000020 // DMA Request Enable +#define USB_RXCSRH8_DISNYET 0x00000010 // Disable NYET +#define USB_RXCSRH8_PIDERR 0x00000010 // PID Error +#define USB_RXCSRH8_DMAMOD 0x00000008 // DMA Request Mode +#define USB_RXCSRH8_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_RXCSRH8_DT 0x00000002 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCOUNT8 register. +// +//***************************************************************************** +#define USB_RXCOUNT8_COUNT_M 0x00001FFF // Receive Packet Count +#define USB_RXCOUNT8_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXTYPE8 register. +// +//***************************************************************************** +#define USB_TXTYPE8_SPEED_M 0x000000C0 // Operating Speed +#define USB_TXTYPE8_SPEED_DFLT 0x00000000 // Default +#define USB_TXTYPE8_SPEED_FULL 0x00000080 // Full +#define USB_TXTYPE8_SPEED_LOW 0x000000C0 // Low +#define USB_TXTYPE8_PROTO_M 0x00000030 // Protocol +#define USB_TXTYPE8_PROTO_CTRL 0x00000000 // Control +#define USB_TXTYPE8_PROTO_ISOC 0x00000010 // Isochronous +#define USB_TXTYPE8_PROTO_BULK 0x00000020 // Bulk +#define USB_TXTYPE8_PROTO_INT 0x00000030 // Interrupt +#define USB_TXTYPE8_TEP_M 0x0000000F // Target Endpoint Number +#define USB_TXTYPE8_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXINTERVAL8 +// register. +// +//***************************************************************************** +#define USB_TXINTERVAL8_TXPOLL_M \ + 0x000000FF // TX Polling +#define USB_TXINTERVAL8_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_TXINTERVAL8_NAKLMT_S \ + 0 +#define USB_TXINTERVAL8_TXPOLL_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXTYPE8 register. +// +//***************************************************************************** +#define USB_RXTYPE8_SPEED_M 0x000000C0 // Operating Speed +#define USB_RXTYPE8_SPEED_DFLT 0x00000000 // Default +#define USB_RXTYPE8_SPEED_FULL 0x00000080 // Full +#define USB_RXTYPE8_SPEED_LOW 0x000000C0 // Low +#define USB_RXTYPE8_PROTO_M 0x00000030 // Protocol +#define USB_RXTYPE8_PROTO_CTRL 0x00000000 // Control +#define USB_RXTYPE8_PROTO_ISOC 0x00000010 // Isochronous +#define USB_RXTYPE8_PROTO_BULK 0x00000020 // Bulk +#define USB_RXTYPE8_PROTO_INT 0x00000030 // Interrupt +#define USB_RXTYPE8_TEP_M 0x0000000F // Target Endpoint Number +#define USB_RXTYPE8_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXINTERVAL8 +// register. +// +//***************************************************************************** +#define USB_RXINTERVAL8_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_RXINTERVAL8_TXPOLL_M \ + 0x000000FF // RX Polling +#define USB_RXINTERVAL8_NAKLMT_S \ + 0 +#define USB_RXINTERVAL8_TXPOLL_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXMAXP9 register. +// +//***************************************************************************** +#define USB_TXMAXP9_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_TXMAXP9_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRL9 register. +// +//***************************************************************************** +#define USB_TXCSRL9_NAKTO 0x00000080 // NAK Timeout +#define USB_TXCSRL9_CLRDT 0x00000040 // Clear Data Toggle +#define USB_TXCSRL9_STALLED 0x00000020 // Endpoint Stalled +#define USB_TXCSRL9_SETUP 0x00000010 // Setup Packet +#define USB_TXCSRL9_STALL 0x00000010 // Send STALL +#define USB_TXCSRL9_FLUSH 0x00000008 // Flush FIFO +#define USB_TXCSRL9_ERROR 0x00000004 // Error +#define USB_TXCSRL9_UNDRN 0x00000004 // Underrun +#define USB_TXCSRL9_FIFONE 0x00000002 // FIFO Not Empty +#define USB_TXCSRL9_TXRDY 0x00000001 // Transmit Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRH9 register. +// +//***************************************************************************** +#define USB_TXCSRH9_AUTOSET 0x00000080 // Auto Set +#define USB_TXCSRH9_ISO 0x00000040 // Isochronous Transfers +#define USB_TXCSRH9_MODE 0x00000020 // Mode +#define USB_TXCSRH9_DMAEN 0x00000010 // DMA Request Enable +#define USB_TXCSRH9_FDT 0x00000008 // Force Data Toggle +#define USB_TXCSRH9_DMAMOD 0x00000004 // DMA Request Mode +#define USB_TXCSRH9_DTWE 0x00000002 // Data Toggle Write Enable +#define USB_TXCSRH9_DT 0x00000001 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXMAXP9 register. +// +//***************************************************************************** +#define USB_RXMAXP9_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_RXMAXP9_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRL9 register. +// +//***************************************************************************** +#define USB_RXCSRL9_CLRDT 0x00000080 // Clear Data Toggle +#define USB_RXCSRL9_STALLED 0x00000040 // Endpoint Stalled +#define USB_RXCSRL9_STALL 0x00000020 // Send STALL +#define USB_RXCSRL9_REQPKT 0x00000020 // Request Packet +#define USB_RXCSRL9_FLUSH 0x00000010 // Flush FIFO +#define USB_RXCSRL9_DATAERR 0x00000008 // Data Error +#define USB_RXCSRL9_NAKTO 0x00000008 // NAK Timeout +#define USB_RXCSRL9_ERROR 0x00000004 // Error +#define USB_RXCSRL9_OVER 0x00000004 // Overrun +#define USB_RXCSRL9_FULL 0x00000002 // FIFO Full +#define USB_RXCSRL9_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRH9 register. +// +//***************************************************************************** +#define USB_RXCSRH9_AUTOCL 0x00000080 // Auto Clear +#define USB_RXCSRH9_ISO 0x00000040 // Isochronous Transfers +#define USB_RXCSRH9_AUTORQ 0x00000040 // Auto Request +#define USB_RXCSRH9_DMAEN 0x00000020 // DMA Request Enable +#define USB_RXCSRH9_PIDERR 0x00000010 // PID Error +#define USB_RXCSRH9_DISNYET 0x00000010 // Disable NYET +#define USB_RXCSRH9_DMAMOD 0x00000008 // DMA Request Mode +#define USB_RXCSRH9_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_RXCSRH9_DT 0x00000002 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCOUNT9 register. +// +//***************************************************************************** +#define USB_RXCOUNT9_COUNT_M 0x00001FFF // Receive Packet Count +#define USB_RXCOUNT9_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXTYPE9 register. +// +//***************************************************************************** +#define USB_TXTYPE9_SPEED_M 0x000000C0 // Operating Speed +#define USB_TXTYPE9_SPEED_DFLT 0x00000000 // Default +#define USB_TXTYPE9_SPEED_FULL 0x00000080 // Full +#define USB_TXTYPE9_SPEED_LOW 0x000000C0 // Low +#define USB_TXTYPE9_PROTO_M 0x00000030 // Protocol +#define USB_TXTYPE9_PROTO_CTRL 0x00000000 // Control +#define USB_TXTYPE9_PROTO_ISOC 0x00000010 // Isochronous +#define USB_TXTYPE9_PROTO_BULK 0x00000020 // Bulk +#define USB_TXTYPE9_PROTO_INT 0x00000030 // Interrupt +#define USB_TXTYPE9_TEP_M 0x0000000F // Target Endpoint Number +#define USB_TXTYPE9_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXINTERVAL9 +// register. +// +//***************************************************************************** +#define USB_TXINTERVAL9_TXPOLL_M \ + 0x000000FF // TX Polling +#define USB_TXINTERVAL9_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_TXINTERVAL9_TXPOLL_S \ + 0 +#define USB_TXINTERVAL9_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXTYPE9 register. +// +//***************************************************************************** +#define USB_RXTYPE9_SPEED_M 0x000000C0 // Operating Speed +#define USB_RXTYPE9_SPEED_DFLT 0x00000000 // Default +#define USB_RXTYPE9_SPEED_FULL 0x00000080 // Full +#define USB_RXTYPE9_SPEED_LOW 0x000000C0 // Low +#define USB_RXTYPE9_PROTO_M 0x00000030 // Protocol +#define USB_RXTYPE9_PROTO_CTRL 0x00000000 // Control +#define USB_RXTYPE9_PROTO_ISOC 0x00000010 // Isochronous +#define USB_RXTYPE9_PROTO_BULK 0x00000020 // Bulk +#define USB_RXTYPE9_PROTO_INT 0x00000030 // Interrupt +#define USB_RXTYPE9_TEP_M 0x0000000F // Target Endpoint Number +#define USB_RXTYPE9_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXINTERVAL9 +// register. +// +//***************************************************************************** +#define USB_RXINTERVAL9_TXPOLL_M \ + 0x000000FF // RX Polling +#define USB_RXINTERVAL9_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_RXINTERVAL9_NAKLMT_S \ + 0 +#define USB_RXINTERVAL9_TXPOLL_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXMAXP10 register. +// +//***************************************************************************** +#define USB_TXMAXP10_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_TXMAXP10_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRL10 register. +// +//***************************************************************************** +#define USB_TXCSRL10_NAKTO 0x00000080 // NAK Timeout +#define USB_TXCSRL10_CLRDT 0x00000040 // Clear Data Toggle +#define USB_TXCSRL10_STALLED 0x00000020 // Endpoint Stalled +#define USB_TXCSRL10_SETUP 0x00000010 // Setup Packet +#define USB_TXCSRL10_STALL 0x00000010 // Send STALL +#define USB_TXCSRL10_FLUSH 0x00000008 // Flush FIFO +#define USB_TXCSRL10_UNDRN 0x00000004 // Underrun +#define USB_TXCSRL10_ERROR 0x00000004 // Error +#define USB_TXCSRL10_FIFONE 0x00000002 // FIFO Not Empty +#define USB_TXCSRL10_TXRDY 0x00000001 // Transmit Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRH10 register. +// +//***************************************************************************** +#define USB_TXCSRH10_AUTOSET 0x00000080 // Auto Set +#define USB_TXCSRH10_ISO 0x00000040 // Isochronous Transfers +#define USB_TXCSRH10_MODE 0x00000020 // Mode +#define USB_TXCSRH10_DMAEN 0x00000010 // DMA Request Enable +#define USB_TXCSRH10_FDT 0x00000008 // Force Data Toggle +#define USB_TXCSRH10_DMAMOD 0x00000004 // DMA Request Mode +#define USB_TXCSRH10_DTWE 0x00000002 // Data Toggle Write Enable +#define USB_TXCSRH10_DT 0x00000001 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXMAXP10 register. +// +//***************************************************************************** +#define USB_RXMAXP10_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_RXMAXP10_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRL10 register. +// +//***************************************************************************** +#define USB_RXCSRL10_CLRDT 0x00000080 // Clear Data Toggle +#define USB_RXCSRL10_STALLED 0x00000040 // Endpoint Stalled +#define USB_RXCSRL10_STALL 0x00000020 // Send STALL +#define USB_RXCSRL10_REQPKT 0x00000020 // Request Packet +#define USB_RXCSRL10_FLUSH 0x00000010 // Flush FIFO +#define USB_RXCSRL10_NAKTO 0x00000008 // NAK Timeout +#define USB_RXCSRL10_DATAERR 0x00000008 // Data Error +#define USB_RXCSRL10_OVER 0x00000004 // Overrun +#define USB_RXCSRL10_ERROR 0x00000004 // Error +#define USB_RXCSRL10_FULL 0x00000002 // FIFO Full +#define USB_RXCSRL10_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRH10 register. +// +//***************************************************************************** +#define USB_RXCSRH10_AUTOCL 0x00000080 // Auto Clear +#define USB_RXCSRH10_AUTORQ 0x00000040 // Auto Request +#define USB_RXCSRH10_ISO 0x00000040 // Isochronous Transfers +#define USB_RXCSRH10_DMAEN 0x00000020 // DMA Request Enable +#define USB_RXCSRH10_PIDERR 0x00000010 // PID Error +#define USB_RXCSRH10_DISNYET 0x00000010 // Disable NYET +#define USB_RXCSRH10_DMAMOD 0x00000008 // DMA Request Mode +#define USB_RXCSRH10_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_RXCSRH10_DT 0x00000002 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCOUNT10 +// register. +// +//***************************************************************************** +#define USB_RXCOUNT10_COUNT_M 0x00001FFF // Receive Packet Count +#define USB_RXCOUNT10_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXTYPE10 register. +// +//***************************************************************************** +#define USB_TXTYPE10_SPEED_M 0x000000C0 // Operating Speed +#define USB_TXTYPE10_SPEED_DFLT 0x00000000 // Default +#define USB_TXTYPE10_SPEED_FULL 0x00000080 // Full +#define USB_TXTYPE10_SPEED_LOW 0x000000C0 // Low +#define USB_TXTYPE10_PROTO_M 0x00000030 // Protocol +#define USB_TXTYPE10_PROTO_CTRL 0x00000000 // Control +#define USB_TXTYPE10_PROTO_ISOC 0x00000010 // Isochronous +#define USB_TXTYPE10_PROTO_BULK 0x00000020 // Bulk +#define USB_TXTYPE10_PROTO_INT 0x00000030 // Interrupt +#define USB_TXTYPE10_TEP_M 0x0000000F // Target Endpoint Number +#define USB_TXTYPE10_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXINTERVAL10 +// register. +// +//***************************************************************************** +#define USB_TXINTERVAL10_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_TXINTERVAL10_TXPOLL_M \ + 0x000000FF // TX Polling +#define USB_TXINTERVAL10_TXPOLL_S \ + 0 +#define USB_TXINTERVAL10_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXTYPE10 register. +// +//***************************************************************************** +#define USB_RXTYPE10_SPEED_M 0x000000C0 // Operating Speed +#define USB_RXTYPE10_SPEED_DFLT 0x00000000 // Default +#define USB_RXTYPE10_SPEED_FULL 0x00000080 // Full +#define USB_RXTYPE10_SPEED_LOW 0x000000C0 // Low +#define USB_RXTYPE10_PROTO_M 0x00000030 // Protocol +#define USB_RXTYPE10_PROTO_CTRL 0x00000000 // Control +#define USB_RXTYPE10_PROTO_ISOC 0x00000010 // Isochronous +#define USB_RXTYPE10_PROTO_BULK 0x00000020 // Bulk +#define USB_RXTYPE10_PROTO_INT 0x00000030 // Interrupt +#define USB_RXTYPE10_TEP_M 0x0000000F // Target Endpoint Number +#define USB_RXTYPE10_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXINTERVAL10 +// register. +// +//***************************************************************************** +#define USB_RXINTERVAL10_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_RXINTERVAL10_TXPOLL_M \ + 0x000000FF // RX Polling +#define USB_RXINTERVAL10_TXPOLL_S \ + 0 +#define USB_RXINTERVAL10_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXMAXP11 register. +// +//***************************************************************************** +#define USB_TXMAXP11_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_TXMAXP11_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRL11 register. +// +//***************************************************************************** +#define USB_TXCSRL11_NAKTO 0x00000080 // NAK Timeout +#define USB_TXCSRL11_CLRDT 0x00000040 // Clear Data Toggle +#define USB_TXCSRL11_STALLED 0x00000020 // Endpoint Stalled +#define USB_TXCSRL11_STALL 0x00000010 // Send STALL +#define USB_TXCSRL11_SETUP 0x00000010 // Setup Packet +#define USB_TXCSRL11_FLUSH 0x00000008 // Flush FIFO +#define USB_TXCSRL11_ERROR 0x00000004 // Error +#define USB_TXCSRL11_UNDRN 0x00000004 // Underrun +#define USB_TXCSRL11_FIFONE 0x00000002 // FIFO Not Empty +#define USB_TXCSRL11_TXRDY 0x00000001 // Transmit Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRH11 register. +// +//***************************************************************************** +#define USB_TXCSRH11_AUTOSET 0x00000080 // Auto Set +#define USB_TXCSRH11_ISO 0x00000040 // Isochronous Transfers +#define USB_TXCSRH11_MODE 0x00000020 // Mode +#define USB_TXCSRH11_DMAEN 0x00000010 // DMA Request Enable +#define USB_TXCSRH11_FDT 0x00000008 // Force Data Toggle +#define USB_TXCSRH11_DMAMOD 0x00000004 // DMA Request Mode +#define USB_TXCSRH11_DTWE 0x00000002 // Data Toggle Write Enable +#define USB_TXCSRH11_DT 0x00000001 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXMAXP11 register. +// +//***************************************************************************** +#define USB_RXMAXP11_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_RXMAXP11_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRL11 register. +// +//***************************************************************************** +#define USB_RXCSRL11_CLRDT 0x00000080 // Clear Data Toggle +#define USB_RXCSRL11_STALLED 0x00000040 // Endpoint Stalled +#define USB_RXCSRL11_STALL 0x00000020 // Send STALL +#define USB_RXCSRL11_REQPKT 0x00000020 // Request Packet +#define USB_RXCSRL11_FLUSH 0x00000010 // Flush FIFO +#define USB_RXCSRL11_DATAERR 0x00000008 // Data Error +#define USB_RXCSRL11_NAKTO 0x00000008 // NAK Timeout +#define USB_RXCSRL11_OVER 0x00000004 // Overrun +#define USB_RXCSRL11_ERROR 0x00000004 // Error +#define USB_RXCSRL11_FULL 0x00000002 // FIFO Full +#define USB_RXCSRL11_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRH11 register. +// +//***************************************************************************** +#define USB_RXCSRH11_AUTOCL 0x00000080 // Auto Clear +#define USB_RXCSRH11_ISO 0x00000040 // Isochronous Transfers +#define USB_RXCSRH11_AUTORQ 0x00000040 // Auto Request +#define USB_RXCSRH11_DMAEN 0x00000020 // DMA Request Enable +#define USB_RXCSRH11_DISNYET 0x00000010 // Disable NYET +#define USB_RXCSRH11_PIDERR 0x00000010 // PID Error +#define USB_RXCSRH11_DMAMOD 0x00000008 // DMA Request Mode +#define USB_RXCSRH11_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_RXCSRH11_DT 0x00000002 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCOUNT11 +// register. +// +//***************************************************************************** +#define USB_RXCOUNT11_COUNT_M 0x00001FFF // Receive Packet Count +#define USB_RXCOUNT11_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXTYPE11 register. +// +//***************************************************************************** +#define USB_TXTYPE11_SPEED_M 0x000000C0 // Operating Speed +#define USB_TXTYPE11_SPEED_DFLT 0x00000000 // Default +#define USB_TXTYPE11_SPEED_FULL 0x00000080 // Full +#define USB_TXTYPE11_SPEED_LOW 0x000000C0 // Low +#define USB_TXTYPE11_PROTO_M 0x00000030 // Protocol +#define USB_TXTYPE11_PROTO_CTRL 0x00000000 // Control +#define USB_TXTYPE11_PROTO_ISOC 0x00000010 // Isochronous +#define USB_TXTYPE11_PROTO_BULK 0x00000020 // Bulk +#define USB_TXTYPE11_PROTO_INT 0x00000030 // Interrupt +#define USB_TXTYPE11_TEP_M 0x0000000F // Target Endpoint Number +#define USB_TXTYPE11_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXINTERVAL11 +// register. +// +//***************************************************************************** +#define USB_TXINTERVAL11_TXPOLL_M \ + 0x000000FF // TX Polling +#define USB_TXINTERVAL11_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_TXINTERVAL11_NAKLMT_S \ + 0 +#define USB_TXINTERVAL11_TXPOLL_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXTYPE11 register. +// +//***************************************************************************** +#define USB_RXTYPE11_SPEED_M 0x000000C0 // Operating Speed +#define USB_RXTYPE11_SPEED_DFLT 0x00000000 // Default +#define USB_RXTYPE11_SPEED_FULL 0x00000080 // Full +#define USB_RXTYPE11_SPEED_LOW 0x000000C0 // Low +#define USB_RXTYPE11_PROTO_M 0x00000030 // Protocol +#define USB_RXTYPE11_PROTO_CTRL 0x00000000 // Control +#define USB_RXTYPE11_PROTO_ISOC 0x00000010 // Isochronous +#define USB_RXTYPE11_PROTO_BULK 0x00000020 // Bulk +#define USB_RXTYPE11_PROTO_INT 0x00000030 // Interrupt +#define USB_RXTYPE11_TEP_M 0x0000000F // Target Endpoint Number +#define USB_RXTYPE11_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXINTERVAL11 +// register. +// +//***************************************************************************** +#define USB_RXINTERVAL11_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_RXINTERVAL11_TXPOLL_M \ + 0x000000FF // RX Polling +#define USB_RXINTERVAL11_TXPOLL_S \ + 0 +#define USB_RXINTERVAL11_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXMAXP12 register. +// +//***************************************************************************** +#define USB_TXMAXP12_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_TXMAXP12_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRL12 register. +// +//***************************************************************************** +#define USB_TXCSRL12_NAKTO 0x00000080 // NAK Timeout +#define USB_TXCSRL12_CLRDT 0x00000040 // Clear Data Toggle +#define USB_TXCSRL12_STALLED 0x00000020 // Endpoint Stalled +#define USB_TXCSRL12_SETUP 0x00000010 // Setup Packet +#define USB_TXCSRL12_STALL 0x00000010 // Send STALL +#define USB_TXCSRL12_FLUSH 0x00000008 // Flush FIFO +#define USB_TXCSRL12_UNDRN 0x00000004 // Underrun +#define USB_TXCSRL12_ERROR 0x00000004 // Error +#define USB_TXCSRL12_FIFONE 0x00000002 // FIFO Not Empty +#define USB_TXCSRL12_TXRDY 0x00000001 // Transmit Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRH12 register. +// +//***************************************************************************** +#define USB_TXCSRH12_AUTOSET 0x00000080 // Auto Set +#define USB_TXCSRH12_ISO 0x00000040 // Isochronous Transfers +#define USB_TXCSRH12_MODE 0x00000020 // Mode +#define USB_TXCSRH12_DMAEN 0x00000010 // DMA Request Enable +#define USB_TXCSRH12_FDT 0x00000008 // Force Data Toggle +#define USB_TXCSRH12_DMAMOD 0x00000004 // DMA Request Mode +#define USB_TXCSRH12_DTWE 0x00000002 // Data Toggle Write Enable +#define USB_TXCSRH12_DT 0x00000001 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXMAXP12 register. +// +//***************************************************************************** +#define USB_RXMAXP12_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_RXMAXP12_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRL12 register. +// +//***************************************************************************** +#define USB_RXCSRL12_CLRDT 0x00000080 // Clear Data Toggle +#define USB_RXCSRL12_STALLED 0x00000040 // Endpoint Stalled +#define USB_RXCSRL12_STALL 0x00000020 // Send STALL +#define USB_RXCSRL12_REQPKT 0x00000020 // Request Packet +#define USB_RXCSRL12_FLUSH 0x00000010 // Flush FIFO +#define USB_RXCSRL12_NAKTO 0x00000008 // NAK Timeout +#define USB_RXCSRL12_DATAERR 0x00000008 // Data Error +#define USB_RXCSRL12_ERROR 0x00000004 // Error +#define USB_RXCSRL12_OVER 0x00000004 // Overrun +#define USB_RXCSRL12_FULL 0x00000002 // FIFO Full +#define USB_RXCSRL12_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRH12 register. +// +//***************************************************************************** +#define USB_RXCSRH12_AUTOCL 0x00000080 // Auto Clear +#define USB_RXCSRH12_ISO 0x00000040 // Isochronous Transfers +#define USB_RXCSRH12_AUTORQ 0x00000040 // Auto Request +#define USB_RXCSRH12_DMAEN 0x00000020 // DMA Request Enable +#define USB_RXCSRH12_PIDERR 0x00000010 // PID Error +#define USB_RXCSRH12_DISNYET 0x00000010 // Disable NYET +#define USB_RXCSRH12_DMAMOD 0x00000008 // DMA Request Mode +#define USB_RXCSRH12_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_RXCSRH12_DT 0x00000002 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCOUNT12 +// register. +// +//***************************************************************************** +#define USB_RXCOUNT12_COUNT_M 0x00001FFF // Receive Packet Count +#define USB_RXCOUNT12_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXTYPE12 register. +// +//***************************************************************************** +#define USB_TXTYPE12_SPEED_M 0x000000C0 // Operating Speed +#define USB_TXTYPE12_SPEED_DFLT 0x00000000 // Default +#define USB_TXTYPE12_SPEED_FULL 0x00000080 // Full +#define USB_TXTYPE12_SPEED_LOW 0x000000C0 // Low +#define USB_TXTYPE12_PROTO_M 0x00000030 // Protocol +#define USB_TXTYPE12_PROTO_CTRL 0x00000000 // Control +#define USB_TXTYPE12_PROTO_ISOC 0x00000010 // Isochronous +#define USB_TXTYPE12_PROTO_BULK 0x00000020 // Bulk +#define USB_TXTYPE12_PROTO_INT 0x00000030 // Interrupt +#define USB_TXTYPE12_TEP_M 0x0000000F // Target Endpoint Number +#define USB_TXTYPE12_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXINTERVAL12 +// register. +// +//***************************************************************************** +#define USB_TXINTERVAL12_TXPOLL_M \ + 0x000000FF // TX Polling +#define USB_TXINTERVAL12_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_TXINTERVAL12_TXPOLL_S \ + 0 +#define USB_TXINTERVAL12_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXTYPE12 register. +// +//***************************************************************************** +#define USB_RXTYPE12_SPEED_M 0x000000C0 // Operating Speed +#define USB_RXTYPE12_SPEED_DFLT 0x00000000 // Default +#define USB_RXTYPE12_SPEED_FULL 0x00000080 // Full +#define USB_RXTYPE12_SPEED_LOW 0x000000C0 // Low +#define USB_RXTYPE12_PROTO_M 0x00000030 // Protocol +#define USB_RXTYPE12_PROTO_CTRL 0x00000000 // Control +#define USB_RXTYPE12_PROTO_ISOC 0x00000010 // Isochronous +#define USB_RXTYPE12_PROTO_BULK 0x00000020 // Bulk +#define USB_RXTYPE12_PROTO_INT 0x00000030 // Interrupt +#define USB_RXTYPE12_TEP_M 0x0000000F // Target Endpoint Number +#define USB_RXTYPE12_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXINTERVAL12 +// register. +// +//***************************************************************************** +#define USB_RXINTERVAL12_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_RXINTERVAL12_TXPOLL_M \ + 0x000000FF // RX Polling +#define USB_RXINTERVAL12_NAKLMT_S \ + 0 +#define USB_RXINTERVAL12_TXPOLL_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXMAXP13 register. +// +//***************************************************************************** +#define USB_TXMAXP13_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_TXMAXP13_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRL13 register. +// +//***************************************************************************** +#define USB_TXCSRL13_NAKTO 0x00000080 // NAK Timeout +#define USB_TXCSRL13_CLRDT 0x00000040 // Clear Data Toggle +#define USB_TXCSRL13_STALLED 0x00000020 // Endpoint Stalled +#define USB_TXCSRL13_SETUP 0x00000010 // Setup Packet +#define USB_TXCSRL13_STALL 0x00000010 // Send STALL +#define USB_TXCSRL13_FLUSH 0x00000008 // Flush FIFO +#define USB_TXCSRL13_UNDRN 0x00000004 // Underrun +#define USB_TXCSRL13_ERROR 0x00000004 // Error +#define USB_TXCSRL13_FIFONE 0x00000002 // FIFO Not Empty +#define USB_TXCSRL13_TXRDY 0x00000001 // Transmit Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRH13 register. +// +//***************************************************************************** +#define USB_TXCSRH13_AUTOSET 0x00000080 // Auto Set +#define USB_TXCSRH13_ISO 0x00000040 // Isochronous Transfers +#define USB_TXCSRH13_MODE 0x00000020 // Mode +#define USB_TXCSRH13_DMAEN 0x00000010 // DMA Request Enable +#define USB_TXCSRH13_FDT 0x00000008 // Force Data Toggle +#define USB_TXCSRH13_DMAMOD 0x00000004 // DMA Request Mode +#define USB_TXCSRH13_DTWE 0x00000002 // Data Toggle Write Enable +#define USB_TXCSRH13_DT 0x00000001 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXMAXP13 register. +// +//***************************************************************************** +#define USB_RXMAXP13_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_RXMAXP13_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRL13 register. +// +//***************************************************************************** +#define USB_RXCSRL13_CLRDT 0x00000080 // Clear Data Toggle +#define USB_RXCSRL13_STALLED 0x00000040 // Endpoint Stalled +#define USB_RXCSRL13_REQPKT 0x00000020 // Request Packet +#define USB_RXCSRL13_STALL 0x00000020 // Send STALL +#define USB_RXCSRL13_FLUSH 0x00000010 // Flush FIFO +#define USB_RXCSRL13_NAKTO 0x00000008 // NAK Timeout +#define USB_RXCSRL13_DATAERR 0x00000008 // Data Error +#define USB_RXCSRL13_OVER 0x00000004 // Overrun +#define USB_RXCSRL13_ERROR 0x00000004 // Error +#define USB_RXCSRL13_FULL 0x00000002 // FIFO Full +#define USB_RXCSRL13_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRH13 register. +// +//***************************************************************************** +#define USB_RXCSRH13_AUTOCL 0x00000080 // Auto Clear +#define USB_RXCSRH13_ISO 0x00000040 // Isochronous Transfers +#define USB_RXCSRH13_AUTORQ 0x00000040 // Auto Request +#define USB_RXCSRH13_DMAEN 0x00000020 // DMA Request Enable +#define USB_RXCSRH13_DISNYET 0x00000010 // Disable NYET +#define USB_RXCSRH13_PIDERR 0x00000010 // PID Error +#define USB_RXCSRH13_DMAMOD 0x00000008 // DMA Request Mode +#define USB_RXCSRH13_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_RXCSRH13_DT 0x00000002 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCOUNT13 +// register. +// +//***************************************************************************** +#define USB_RXCOUNT13_COUNT_M 0x00001FFF // Receive Packet Count +#define USB_RXCOUNT13_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXTYPE13 register. +// +//***************************************************************************** +#define USB_TXTYPE13_SPEED_M 0x000000C0 // Operating Speed +#define USB_TXTYPE13_SPEED_DFLT 0x00000000 // Default +#define USB_TXTYPE13_SPEED_FULL 0x00000080 // Full +#define USB_TXTYPE13_SPEED_LOW 0x000000C0 // Low +#define USB_TXTYPE13_PROTO_M 0x00000030 // Protocol +#define USB_TXTYPE13_PROTO_CTRL 0x00000000 // Control +#define USB_TXTYPE13_PROTO_ISOC 0x00000010 // Isochronous +#define USB_TXTYPE13_PROTO_BULK 0x00000020 // Bulk +#define USB_TXTYPE13_PROTO_INT 0x00000030 // Interrupt +#define USB_TXTYPE13_TEP_M 0x0000000F // Target Endpoint Number +#define USB_TXTYPE13_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXINTERVAL13 +// register. +// +//***************************************************************************** +#define USB_TXINTERVAL13_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_TXINTERVAL13_TXPOLL_M \ + 0x000000FF // TX Polling +#define USB_TXINTERVAL13_TXPOLL_S \ + 0 +#define USB_TXINTERVAL13_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXTYPE13 register. +// +//***************************************************************************** +#define USB_RXTYPE13_SPEED_M 0x000000C0 // Operating Speed +#define USB_RXTYPE13_SPEED_DFLT 0x00000000 // Default +#define USB_RXTYPE13_SPEED_FULL 0x00000080 // Full +#define USB_RXTYPE13_SPEED_LOW 0x000000C0 // Low +#define USB_RXTYPE13_PROTO_M 0x00000030 // Protocol +#define USB_RXTYPE13_PROTO_CTRL 0x00000000 // Control +#define USB_RXTYPE13_PROTO_ISOC 0x00000010 // Isochronous +#define USB_RXTYPE13_PROTO_BULK 0x00000020 // Bulk +#define USB_RXTYPE13_PROTO_INT 0x00000030 // Interrupt +#define USB_RXTYPE13_TEP_M 0x0000000F // Target Endpoint Number +#define USB_RXTYPE13_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXINTERVAL13 +// register. +// +//***************************************************************************** +#define USB_RXINTERVAL13_TXPOLL_M \ + 0x000000FF // RX Polling +#define USB_RXINTERVAL13_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_RXINTERVAL13_TXPOLL_S \ + 0 +#define USB_RXINTERVAL13_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXMAXP14 register. +// +//***************************************************************************** +#define USB_TXMAXP14_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_TXMAXP14_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRL14 register. +// +//***************************************************************************** +#define USB_TXCSRL14_NAKTO 0x00000080 // NAK Timeout +#define USB_TXCSRL14_CLRDT 0x00000040 // Clear Data Toggle +#define USB_TXCSRL14_STALLED 0x00000020 // Endpoint Stalled +#define USB_TXCSRL14_STALL 0x00000010 // Send STALL +#define USB_TXCSRL14_SETUP 0x00000010 // Setup Packet +#define USB_TXCSRL14_FLUSH 0x00000008 // Flush FIFO +#define USB_TXCSRL14_ERROR 0x00000004 // Error +#define USB_TXCSRL14_UNDRN 0x00000004 // Underrun +#define USB_TXCSRL14_FIFONE 0x00000002 // FIFO Not Empty +#define USB_TXCSRL14_TXRDY 0x00000001 // Transmit Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRH14 register. +// +//***************************************************************************** +#define USB_TXCSRH14_AUTOSET 0x00000080 // Auto Set +#define USB_TXCSRH14_ISO 0x00000040 // Isochronous Transfers +#define USB_TXCSRH14_MODE 0x00000020 // Mode +#define USB_TXCSRH14_DMAEN 0x00000010 // DMA Request Enable +#define USB_TXCSRH14_FDT 0x00000008 // Force Data Toggle +#define USB_TXCSRH14_DMAMOD 0x00000004 // DMA Request Mode +#define USB_TXCSRH14_DTWE 0x00000002 // Data Toggle Write Enable +#define USB_TXCSRH14_DT 0x00000001 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXMAXP14 register. +// +//***************************************************************************** +#define USB_RXMAXP14_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_RXMAXP14_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRL14 register. +// +//***************************************************************************** +#define USB_RXCSRL14_CLRDT 0x00000080 // Clear Data Toggle +#define USB_RXCSRL14_STALLED 0x00000040 // Endpoint Stalled +#define USB_RXCSRL14_REQPKT 0x00000020 // Request Packet +#define USB_RXCSRL14_STALL 0x00000020 // Send STALL +#define USB_RXCSRL14_FLUSH 0x00000010 // Flush FIFO +#define USB_RXCSRL14_DATAERR 0x00000008 // Data Error +#define USB_RXCSRL14_NAKTO 0x00000008 // NAK Timeout +#define USB_RXCSRL14_OVER 0x00000004 // Overrun +#define USB_RXCSRL14_ERROR 0x00000004 // Error +#define USB_RXCSRL14_FULL 0x00000002 // FIFO Full +#define USB_RXCSRL14_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRH14 register. +// +//***************************************************************************** +#define USB_RXCSRH14_AUTOCL 0x00000080 // Auto Clear +#define USB_RXCSRH14_AUTORQ 0x00000040 // Auto Request +#define USB_RXCSRH14_ISO 0x00000040 // Isochronous Transfers +#define USB_RXCSRH14_DMAEN 0x00000020 // DMA Request Enable +#define USB_RXCSRH14_PIDERR 0x00000010 // PID Error +#define USB_RXCSRH14_DISNYET 0x00000010 // Disable NYET +#define USB_RXCSRH14_DMAMOD 0x00000008 // DMA Request Mode +#define USB_RXCSRH14_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_RXCSRH14_DT 0x00000002 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCOUNT14 +// register. +// +//***************************************************************************** +#define USB_RXCOUNT14_COUNT_M 0x00001FFF // Receive Packet Count +#define USB_RXCOUNT14_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXTYPE14 register. +// +//***************************************************************************** +#define USB_TXTYPE14_SPEED_M 0x000000C0 // Operating Speed +#define USB_TXTYPE14_SPEED_DFLT 0x00000000 // Default +#define USB_TXTYPE14_SPEED_FULL 0x00000080 // Full +#define USB_TXTYPE14_SPEED_LOW 0x000000C0 // Low +#define USB_TXTYPE14_PROTO_M 0x00000030 // Protocol +#define USB_TXTYPE14_PROTO_CTRL 0x00000000 // Control +#define USB_TXTYPE14_PROTO_ISOC 0x00000010 // Isochronous +#define USB_TXTYPE14_PROTO_BULK 0x00000020 // Bulk +#define USB_TXTYPE14_PROTO_INT 0x00000030 // Interrupt +#define USB_TXTYPE14_TEP_M 0x0000000F // Target Endpoint Number +#define USB_TXTYPE14_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXINTERVAL14 +// register. +// +//***************************************************************************** +#define USB_TXINTERVAL14_TXPOLL_M \ + 0x000000FF // TX Polling +#define USB_TXINTERVAL14_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_TXINTERVAL14_TXPOLL_S \ + 0 +#define USB_TXINTERVAL14_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXTYPE14 register. +// +//***************************************************************************** +#define USB_RXTYPE14_SPEED_M 0x000000C0 // Operating Speed +#define USB_RXTYPE14_SPEED_DFLT 0x00000000 // Default +#define USB_RXTYPE14_SPEED_FULL 0x00000080 // Full +#define USB_RXTYPE14_SPEED_LOW 0x000000C0 // Low +#define USB_RXTYPE14_PROTO_M 0x00000030 // Protocol +#define USB_RXTYPE14_PROTO_CTRL 0x00000000 // Control +#define USB_RXTYPE14_PROTO_ISOC 0x00000010 // Isochronous +#define USB_RXTYPE14_PROTO_BULK 0x00000020 // Bulk +#define USB_RXTYPE14_PROTO_INT 0x00000030 // Interrupt +#define USB_RXTYPE14_TEP_M 0x0000000F // Target Endpoint Number +#define USB_RXTYPE14_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXINTERVAL14 +// register. +// +//***************************************************************************** +#define USB_RXINTERVAL14_TXPOLL_M \ + 0x000000FF // RX Polling +#define USB_RXINTERVAL14_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_RXINTERVAL14_TXPOLL_S \ + 0 +#define USB_RXINTERVAL14_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXMAXP15 register. +// +//***************************************************************************** +#define USB_TXMAXP15_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_TXMAXP15_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRL15 register. +// +//***************************************************************************** +#define USB_TXCSRL15_NAKTO 0x00000080 // NAK Timeout +#define USB_TXCSRL15_CLRDT 0x00000040 // Clear Data Toggle +#define USB_TXCSRL15_STALLED 0x00000020 // Endpoint Stalled +#define USB_TXCSRL15_SETUP 0x00000010 // Setup Packet +#define USB_TXCSRL15_STALL 0x00000010 // Send STALL +#define USB_TXCSRL15_FLUSH 0x00000008 // Flush FIFO +#define USB_TXCSRL15_UNDRN 0x00000004 // Underrun +#define USB_TXCSRL15_ERROR 0x00000004 // Error +#define USB_TXCSRL15_FIFONE 0x00000002 // FIFO Not Empty +#define USB_TXCSRL15_TXRDY 0x00000001 // Transmit Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXCSRH15 register. +// +//***************************************************************************** +#define USB_TXCSRH15_AUTOSET 0x00000080 // Auto Set +#define USB_TXCSRH15_ISO 0x00000040 // Isochronous Transfers +#define USB_TXCSRH15_MODE 0x00000020 // Mode +#define USB_TXCSRH15_DMAEN 0x00000010 // DMA Request Enable +#define USB_TXCSRH15_FDT 0x00000008 // Force Data Toggle +#define USB_TXCSRH15_DMAMOD 0x00000004 // DMA Request Mode +#define USB_TXCSRH15_DTWE 0x00000002 // Data Toggle Write Enable +#define USB_TXCSRH15_DT 0x00000001 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXMAXP15 register. +// +//***************************************************************************** +#define USB_RXMAXP15_MAXLOAD_M 0x000007FF // Maximum Payload +#define USB_RXMAXP15_MAXLOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRL15 register. +// +//***************************************************************************** +#define USB_RXCSRL15_CLRDT 0x00000080 // Clear Data Toggle +#define USB_RXCSRL15_STALLED 0x00000040 // Endpoint Stalled +#define USB_RXCSRL15_STALL 0x00000020 // Send STALL +#define USB_RXCSRL15_REQPKT 0x00000020 // Request Packet +#define USB_RXCSRL15_FLUSH 0x00000010 // Flush FIFO +#define USB_RXCSRL15_DATAERR 0x00000008 // Data Error +#define USB_RXCSRL15_NAKTO 0x00000008 // NAK Timeout +#define USB_RXCSRL15_ERROR 0x00000004 // Error +#define USB_RXCSRL15_OVER 0x00000004 // Overrun +#define USB_RXCSRL15_FULL 0x00000002 // FIFO Full +#define USB_RXCSRL15_RXRDY 0x00000001 // Receive Packet Ready + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCSRH15 register. +// +//***************************************************************************** +#define USB_RXCSRH15_AUTOCL 0x00000080 // Auto Clear +#define USB_RXCSRH15_AUTORQ 0x00000040 // Auto Request +#define USB_RXCSRH15_ISO 0x00000040 // Isochronous Transfers +#define USB_RXCSRH15_DMAEN 0x00000020 // DMA Request Enable +#define USB_RXCSRH15_PIDERR 0x00000010 // PID Error +#define USB_RXCSRH15_DISNYET 0x00000010 // Disable NYET +#define USB_RXCSRH15_DMAMOD 0x00000008 // DMA Request Mode +#define USB_RXCSRH15_DTWE 0x00000004 // Data Toggle Write Enable +#define USB_RXCSRH15_DT 0x00000002 // Data Toggle + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXCOUNT15 +// register. +// +//***************************************************************************** +#define USB_RXCOUNT15_COUNT_M 0x00001FFF // Receive Packet Count +#define USB_RXCOUNT15_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXTYPE15 register. +// +//***************************************************************************** +#define USB_TXTYPE15_SPEED_M 0x000000C0 // Operating Speed +#define USB_TXTYPE15_SPEED_DFLT 0x00000000 // Default +#define USB_TXTYPE15_SPEED_FULL 0x00000080 // Full +#define USB_TXTYPE15_SPEED_LOW 0x000000C0 // Low +#define USB_TXTYPE15_PROTO_M 0x00000030 // Protocol +#define USB_TXTYPE15_PROTO_CTRL 0x00000000 // Control +#define USB_TXTYPE15_PROTO_ISOC 0x00000010 // Isochronous +#define USB_TXTYPE15_PROTO_BULK 0x00000020 // Bulk +#define USB_TXTYPE15_PROTO_INT 0x00000030 // Interrupt +#define USB_TXTYPE15_TEP_M 0x0000000F // Target Endpoint Number +#define USB_TXTYPE15_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXINTERVAL15 +// register. +// +//***************************************************************************** +#define USB_TXINTERVAL15_TXPOLL_M \ + 0x000000FF // TX Polling +#define USB_TXINTERVAL15_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_TXINTERVAL15_NAKLMT_S \ + 0 +#define USB_TXINTERVAL15_TXPOLL_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXTYPE15 register. +// +//***************************************************************************** +#define USB_RXTYPE15_SPEED_M 0x000000C0 // Operating Speed +#define USB_RXTYPE15_SPEED_DFLT 0x00000000 // Default +#define USB_RXTYPE15_SPEED_FULL 0x00000080 // Full +#define USB_RXTYPE15_SPEED_LOW 0x000000C0 // Low +#define USB_RXTYPE15_PROTO_M 0x00000030 // Protocol +#define USB_RXTYPE15_PROTO_CTRL 0x00000000 // Control +#define USB_RXTYPE15_PROTO_ISOC 0x00000010 // Isochronous +#define USB_RXTYPE15_PROTO_BULK 0x00000020 // Bulk +#define USB_RXTYPE15_PROTO_INT 0x00000030 // Interrupt +#define USB_RXTYPE15_TEP_M 0x0000000F // Target Endpoint Number +#define USB_RXTYPE15_TEP_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXINTERVAL15 +// register. +// +//***************************************************************************** +#define USB_RXINTERVAL15_TXPOLL_M \ + 0x000000FF // RX Polling +#define USB_RXINTERVAL15_NAKLMT_M \ + 0x000000FF // NAK Limit +#define USB_RXINTERVAL15_TXPOLL_S \ + 0 +#define USB_RXINTERVAL15_NAKLMT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RQPKTCOUNT1 +// register. +// +//***************************************************************************** +#define USB_RQPKTCOUNT1_M 0x0000FFFF // Block Transfer Packet Count +#define USB_RQPKTCOUNT1_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RQPKTCOUNT2 +// register. +// +//***************************************************************************** +#define USB_RQPKTCOUNT2_M 0x0000FFFF // Block Transfer Packet Count +#define USB_RQPKTCOUNT2_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RQPKTCOUNT3 +// register. +// +//***************************************************************************** +#define USB_RQPKTCOUNT3_M 0x0000FFFF // Block Transfer Packet Count +#define USB_RQPKTCOUNT3_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RQPKTCOUNT4 +// register. +// +//***************************************************************************** +#define USB_RQPKTCOUNT4_COUNT_M 0x0000FFFF // Block Transfer Packet Count +#define USB_RQPKTCOUNT4_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RQPKTCOUNT5 +// register. +// +//***************************************************************************** +#define USB_RQPKTCOUNT5_COUNT_M 0x0000FFFF // Block Transfer Packet Count +#define USB_RQPKTCOUNT5_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RQPKTCOUNT6 +// register. +// +//***************************************************************************** +#define USB_RQPKTCOUNT6_COUNT_M 0x0000FFFF // Block Transfer Packet Count +#define USB_RQPKTCOUNT6_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RQPKTCOUNT7 +// register. +// +//***************************************************************************** +#define USB_RQPKTCOUNT7_COUNT_M 0x0000FFFF // Block Transfer Packet Count +#define USB_RQPKTCOUNT7_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RQPKTCOUNT8 +// register. +// +//***************************************************************************** +#define USB_RQPKTCOUNT8_COUNT_M 0x0000FFFF // Block Transfer Packet Count +#define USB_RQPKTCOUNT8_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RQPKTCOUNT9 +// register. +// +//***************************************************************************** +#define USB_RQPKTCOUNT9_COUNT_M 0x0000FFFF // Block Transfer Packet Count +#define USB_RQPKTCOUNT9_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RQPKTCOUNT10 +// register. +// +//***************************************************************************** +#define USB_RQPKTCOUNT10_COUNT_M \ + 0x0000FFFF // Block Transfer Packet Count +#define USB_RQPKTCOUNT10_COUNT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RQPKTCOUNT11 +// register. +// +//***************************************************************************** +#define USB_RQPKTCOUNT11_COUNT_M \ + 0x0000FFFF // Block Transfer Packet Count +#define USB_RQPKTCOUNT11_COUNT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RQPKTCOUNT12 +// register. +// +//***************************************************************************** +#define USB_RQPKTCOUNT12_COUNT_M \ + 0x0000FFFF // Block Transfer Packet Count +#define USB_RQPKTCOUNT12_COUNT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RQPKTCOUNT13 +// register. +// +//***************************************************************************** +#define USB_RQPKTCOUNT13_COUNT_M \ + 0x0000FFFF // Block Transfer Packet Count +#define USB_RQPKTCOUNT13_COUNT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RQPKTCOUNT14 +// register. +// +//***************************************************************************** +#define USB_RQPKTCOUNT14_COUNT_M \ + 0x0000FFFF // Block Transfer Packet Count +#define USB_RQPKTCOUNT14_COUNT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RQPKTCOUNT15 +// register. +// +//***************************************************************************** +#define USB_RQPKTCOUNT15_COUNT_M \ + 0x0000FFFF // Block Transfer Packet Count +#define USB_RQPKTCOUNT15_COUNT_S \ + 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_RXDPKTBUFDIS +// register. +// +//***************************************************************************** +#define USB_RXDPKTBUFDIS_EP15 0x00008000 // EP15 RX Double-Packet Buffer + // Disable +#define USB_RXDPKTBUFDIS_EP14 0x00004000 // EP14 RX Double-Packet Buffer + // Disable +#define USB_RXDPKTBUFDIS_EP13 0x00002000 // EP13 RX Double-Packet Buffer + // Disable +#define USB_RXDPKTBUFDIS_EP12 0x00001000 // EP12 RX Double-Packet Buffer + // Disable +#define USB_RXDPKTBUFDIS_EP11 0x00000800 // EP11 RX Double-Packet Buffer + // Disable +#define USB_RXDPKTBUFDIS_EP10 0x00000400 // EP10 RX Double-Packet Buffer + // Disable +#define USB_RXDPKTBUFDIS_EP9 0x00000200 // EP9 RX Double-Packet Buffer + // Disable +#define USB_RXDPKTBUFDIS_EP8 0x00000100 // EP8 RX Double-Packet Buffer + // Disable +#define USB_RXDPKTBUFDIS_EP7 0x00000080 // EP7 RX Double-Packet Buffer + // Disable +#define USB_RXDPKTBUFDIS_EP6 0x00000040 // EP6 RX Double-Packet Buffer + // Disable +#define USB_RXDPKTBUFDIS_EP5 0x00000020 // EP5 RX Double-Packet Buffer + // Disable +#define USB_RXDPKTBUFDIS_EP4 0x00000010 // EP4 RX Double-Packet Buffer + // Disable +#define USB_RXDPKTBUFDIS_EP3 0x00000008 // EP3 RX Double-Packet Buffer + // Disable +#define USB_RXDPKTBUFDIS_EP2 0x00000004 // EP2 RX Double-Packet Buffer + // Disable +#define USB_RXDPKTBUFDIS_EP1 0x00000002 // EP1 RX Double-Packet Buffer + // Disable + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_TXDPKTBUFDIS +// register. +// +//***************************************************************************** +#define USB_TXDPKTBUFDIS_EP15 0x00008000 // EP15 TX Double-Packet Buffer + // Disable +#define USB_TXDPKTBUFDIS_EP14 0x00004000 // EP14 TX Double-Packet Buffer + // Disable +#define USB_TXDPKTBUFDIS_EP13 0x00002000 // EP13 TX Double-Packet Buffer + // Disable +#define USB_TXDPKTBUFDIS_EP12 0x00001000 // EP12 TX Double-Packet Buffer + // Disable +#define USB_TXDPKTBUFDIS_EP11 0x00000800 // EP11 TX Double-Packet Buffer + // Disable +#define USB_TXDPKTBUFDIS_EP10 0x00000400 // EP10 TX Double-Packet Buffer + // Disable +#define USB_TXDPKTBUFDIS_EP9 0x00000200 // EP9 TX Double-Packet Buffer + // Disable +#define USB_TXDPKTBUFDIS_EP8 0x00000100 // EP8 TX Double-Packet Buffer + // Disable +#define USB_TXDPKTBUFDIS_EP7 0x00000080 // EP7 TX Double-Packet Buffer + // Disable +#define USB_TXDPKTBUFDIS_EP6 0x00000040 // EP6 TX Double-Packet Buffer + // Disable +#define USB_TXDPKTBUFDIS_EP5 0x00000020 // EP5 TX Double-Packet Buffer + // Disable +#define USB_TXDPKTBUFDIS_EP4 0x00000010 // EP4 TX Double-Packet Buffer + // Disable +#define USB_TXDPKTBUFDIS_EP3 0x00000008 // EP3 TX Double-Packet Buffer + // Disable +#define USB_TXDPKTBUFDIS_EP2 0x00000004 // EP2 TX Double-Packet Buffer + // Disable +#define USB_TXDPKTBUFDIS_EP1 0x00000002 // EP1 TX Double-Packet Buffer + // Disable + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_EPC register. +// +//***************************************************************************** +#define USB_EPC_PFLTACT_M 0x00000300 // Power Fault Action +#define USB_EPC_PFLTACT_UNCHG 0x00000000 // Unchanged +#define USB_EPC_PFLTACT_TRIS 0x00000100 // Tristate +#define USB_EPC_PFLTACT_LOW 0x00000200 // Low +#define USB_EPC_PFLTACT_HIGH 0x00000300 // High +#define USB_EPC_PFLTAEN 0x00000040 // Power Fault Action Enable +#define USB_EPC_PFLTSEN_HIGH 0x00000020 // Power Fault Sense +#define USB_EPC_PFLTEN 0x00000010 // Power Fault Input Enable +#define USB_EPC_EPENDE 0x00000004 // EPEN Drive Enable +#define USB_EPC_EPEN_M 0x00000003 // External Power Supply Enable + // Configuration +#define USB_EPC_EPEN_LOW 0x00000000 // Power Enable Active Low +#define USB_EPC_EPEN_HIGH 0x00000001 // Power Enable Active High +#define USB_EPC_EPEN_VBLOW 0x00000002 // Power Enable High if VBUS Low +#define USB_EPC_EPEN_VBHIGH 0x00000003 // Power Enable High if VBUS High + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_EPCRIS register. +// +//***************************************************************************** +#define USB_EPCRIS_PF 0x00000001 // USB Power Fault Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_EPCIM register. +// +//***************************************************************************** +#define USB_EPCIM_PF 0x00000001 // USB Power Fault Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_EPCISC register. +// +//***************************************************************************** +#define USB_EPCISC_PF 0x00000001 // USB Power Fault Interrupt Status + // and Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_DRRIS register. +// +//***************************************************************************** +#define USB_DRRIS_RESUME 0x00000001 // RESUME Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_DRIM register. +// +//***************************************************************************** +#define USB_DRIM_RESUME 0x00000001 // RESUME Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_DRISC register. +// +//***************************************************************************** +#define USB_DRISC_RESUME 0x00000001 // RESUME Interrupt Status and + // Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_GPCS register. +// +//***************************************************************************** +#define USB_GPCS_DEVMODOTG 0x00000002 // Enable Device Mode +#define USB_GPCS_DEVMOD 0x00000001 // Device Mode + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_VDC register. +// +//***************************************************************************** +#define USB_VDC_VBDEN 0x00000001 // VBUS Droop Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_VDCRIS register. +// +//***************************************************************************** +#define USB_VDCRIS_VD 0x00000001 // VBUS Droop Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_VDCIM register. +// +//***************************************************************************** +#define USB_VDCIM_VD 0x00000001 // VBUS Droop Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_VDCISC register. +// +//***************************************************************************** +#define USB_VDCISC_VD 0x00000001 // VBUS Droop Interrupt Status and + // Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_IDVRIS register. +// +//***************************************************************************** +#define USB_IDVRIS_ID 0x00000001 // ID Valid Detect Raw Interrupt + // Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_IDVIM register. +// +//***************************************************************************** +#define USB_IDVIM_ID 0x00000001 // ID Valid Detect Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_IDVISC register. +// +//***************************************************************************** +#define USB_IDVISC_ID 0x00000001 // ID Valid Detect Interrupt Status + // and Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the USB_O_DMASEL register. +// +//***************************************************************************** +#define USB_DMASEL_DMACTX_M 0x00F00000 // DMA C TX Select +#define USB_DMASEL_DMACRX_M 0x000F0000 // DMA C RX Select +#define USB_DMASEL_DMABTX_M 0x0000F000 // DMA B TX Select +#define USB_DMASEL_DMABRX_M 0x00000F00 // DMA B RX Select +#define USB_DMASEL_DMAATX_M 0x000000F0 // DMA A TX Select +#define USB_DMASEL_DMAARX_M 0x0000000F // DMA A RX Select +#define USB_DMASEL_DMABTX_S 12 +#define USB_DMASEL_DMABRX_S 8 +#define USB_DMASEL_DMAATX_S 4 +#define USB_DMASEL_DMAARX_S 0 + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// USB_O_TXFIFOADD register. +// +//***************************************************************************** +#define USB_TXFIFOADD_ADDR_2048 0x00000009 // 2048 +#define USB_TXFIFOADD_ADDR_1024 0x00000008 // 1024 +#define USB_TXFIFOADD_ADDR_512 0x00000007 // 512 +#define USB_TXFIFOADD_ADDR_256 0x00000006 // 256 +#define USB_TXFIFOADD_ADDR_128 0x00000005 // 128 +#define USB_TXFIFOADD_ADDR_64 0x00000004 // 64 +#define USB_TXFIFOADD_ADDR_32 0x00000003 // 32 +#define USB_TXFIFOADD_ADDR_16 0x00000002 // 16 +#define USB_TXFIFOADD_ADDR_8 0x00000001 // 8 +#define USB_TXFIFOADD_ADDR_0 0x00000000 // 0 + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the +// USB_O_RXFIFOADD register. +// +//***************************************************************************** +#define USB_RXFIFOADD_ADDR_2048 0x00000009 // 2048 +#define USB_RXFIFOADD_ADDR_1024 0x00000008 // 1024 +#define USB_RXFIFOADD_ADDR_512 0x00000007 // 512 +#define USB_RXFIFOADD_ADDR_256 0x00000006 // 256 +#define USB_RXFIFOADD_ADDR_128 0x00000005 // 128 +#define USB_RXFIFOADD_ADDR_64 0x00000004 // 64 +#define USB_RXFIFOADD_ADDR_32 0x00000003 // 32 +#define USB_RXFIFOADD_ADDR_16 0x00000002 // 16 +#define USB_RXFIFOADD_ADDR_8 0x00000001 // 8 +#define USB_RXFIFOADD_ADDR_0 0x00000000 // 0 + +#endif + +#endif // __HW_USB_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_watchdog.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_watchdog.h new file mode 100644 index 00000000..b8aeb7a8 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/hw_watchdog.h @@ -0,0 +1,175 @@ +//***************************************************************************** +// +// hw_watchdog.h - Macros used when accessing the Watchdog Timer hardware. +// +// Copyright (c) 2005-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __HW_WATCHDOG_H__ +#define __HW_WATCHDOG_H__ + +//***************************************************************************** +// +// The following are defines for the Watchdog Timer register offsets. +// +//***************************************************************************** +#define WDT_O_LOAD 0x00000000 // Watchdog Load +#define WDT_O_VALUE 0x00000004 // Watchdog Value +#define WDT_O_CTL 0x00000008 // Watchdog Control +#define WDT_O_ICR 0x0000000C // Watchdog Interrupt Clear +#define WDT_O_RIS 0x00000010 // Watchdog Raw Interrupt Status +#define WDT_O_MIS 0x00000014 // Watchdog Masked Interrupt Status +#define WDT_O_TEST 0x00000418 // Watchdog Test +#define WDT_O_LOCK 0x00000C00 // Watchdog Lock + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_LOAD register. +// +//***************************************************************************** +#define WDT_LOAD_M 0xFFFFFFFF // Watchdog Load Value +#define WDT_LOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_VALUE register. +// +//***************************************************************************** +#define WDT_VALUE_M 0xFFFFFFFF // Watchdog Value +#define WDT_VALUE_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_CTL register. +// +//***************************************************************************** +#define WDT_CTL_WRC 0x80000000 // Write Complete +#define WDT_CTL_RESEN 0x00000002 // Watchdog Reset Enable +#define WDT_CTL_INTEN 0x00000001 // Watchdog Interrupt Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_ICR register. +// +//***************************************************************************** +#define WDT_ICR_M 0xFFFFFFFF // Watchdog Interrupt Clear +#define WDT_ICR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_RIS register. +// +//***************************************************************************** +#define WDT_RIS_WDTRIS 0x00000001 // Watchdog Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_MIS register. +// +//***************************************************************************** +#define WDT_MIS_WDTMIS 0x00000001 // Watchdog Masked Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_TEST register. +// +//***************************************************************************** +#define WDT_TEST_STALL 0x00000100 // Watchdog Stall Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_LOCK register. +// +//***************************************************************************** +#define WDT_LOCK_M 0xFFFFFFFF // Watchdog Lock +#define WDT_LOCK_UNLOCKED 0x00000000 // Unlocked +#define WDT_LOCK_LOCKED 0x00000001 // Locked +#define WDT_LOCK_UNLOCK 0x1ACCE551 // Unlocks the watchdog timer + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_ISR, WDT_RIS, and +// WDT_MIS registers. +// +//***************************************************************************** +#define WDT_INT_TIMEOUT 0x00000001 // Watchdog timer expired + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// The following are deprecated defines for the Watchdog Timer register +// offsets. +// +//***************************************************************************** +#define WDT_O_PeriphID4 0x00000FD0 +#define WDT_O_PeriphID5 0x00000FD4 +#define WDT_O_PeriphID6 0x00000FD8 +#define WDT_O_PeriphID7 0x00000FDC +#define WDT_O_PeriphID0 0x00000FE0 +#define WDT_O_PeriphID1 0x00000FE4 +#define WDT_O_PeriphID2 0x00000FE8 +#define WDT_O_PeriphID3 0x00000FEC +#define WDT_O_PCellID0 0x00000FF0 +#define WDT_O_PCellID1 0x00000FF4 +#define WDT_O_PCellID2 0x00000FF8 +#define WDT_O_PCellID3 0x00000FFC + +//***************************************************************************** +// +// The following are deprecated defines for the bit fields in the WDT_O_TEST +// register. +// +//***************************************************************************** +#define WDT_TEST_STALL_EN 0x00000100 // Watchdog stall enable + +//***************************************************************************** +// +// The following are deprecated defines for the reset values for the WDT +// registers. +// +//***************************************************************************** +#define WDT_RV_VALUE 0xFFFFFFFF // Current value register +#define WDT_RV_LOAD 0xFFFFFFFF // Load register +#define WDT_RV_PCellID1 0x000000F0 +#define WDT_RV_PCellID3 0x000000B1 +#define WDT_RV_PeriphID1 0x00000018 +#define WDT_RV_PeriphID2 0x00000018 +#define WDT_RV_PCellID0 0x0000000D +#define WDT_RV_PCellID2 0x00000005 +#define WDT_RV_PeriphID0 0x00000005 +#define WDT_RV_PeriphID3 0x00000001 +#define WDT_RV_PeriphID5 0x00000000 +#define WDT_RV_RIS 0x00000000 // Raw interrupt status register +#define WDT_RV_CTL 0x00000000 // Control register +#define WDT_RV_PeriphID4 0x00000000 +#define WDT_RV_PeriphID6 0x00000000 +#define WDT_RV_PeriphID7 0x00000000 +#define WDT_RV_LOCK 0x00000000 // Lock register +#define WDT_RV_MIS 0x00000000 // Masked interrupt status register + +#endif + +#endif // __HW_WATCHDOG_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/lm3s6965.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/lm3s6965.h new file mode 100644 index 00000000..b52248cd --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/lib/inc/lm3s6965.h @@ -0,0 +1,4795 @@ +//***************************************************************************** +// +// lm3s6965.h - LM3S6965 Register Definitions +// +// Copyright (c) 2007-2011 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 6852 of the Stellaris Firmware Development Package. +// +//***************************************************************************** + +#ifndef __LM3S6965_H__ +#define __LM3S6965_H__ + +//***************************************************************************** +// +// Watchdog Timer registers (WATCHDOG0) +// +//***************************************************************************** +#define WATCHDOG0_LOAD_R (*((volatile unsigned long *)0x40000000)) +#define WATCHDOG0_VALUE_R (*((volatile unsigned long *)0x40000004)) +#define WATCHDOG0_CTL_R (*((volatile unsigned long *)0x40000008)) +#define WATCHDOG0_ICR_R (*((volatile unsigned long *)0x4000000C)) +#define WATCHDOG0_RIS_R (*((volatile unsigned long *)0x40000010)) +#define WATCHDOG0_MIS_R (*((volatile unsigned long *)0x40000014)) +#define WATCHDOG0_TEST_R (*((volatile unsigned long *)0x40000418)) +#define WATCHDOG0_LOCK_R (*((volatile unsigned long *)0x40000C00)) + +//***************************************************************************** +// +// GPIO registers (PORTA) +// +//***************************************************************************** +#define GPIO_PORTA_DATA_BITS_R ((volatile unsigned long *)0x40004000) +#define GPIO_PORTA_DATA_R (*((volatile unsigned long *)0x400043FC)) +#define GPIO_PORTA_DIR_R (*((volatile unsigned long *)0x40004400)) +#define GPIO_PORTA_IS_R (*((volatile unsigned long *)0x40004404)) +#define GPIO_PORTA_IBE_R (*((volatile unsigned long *)0x40004408)) +#define GPIO_PORTA_IEV_R (*((volatile unsigned long *)0x4000440C)) +#define GPIO_PORTA_IM_R (*((volatile unsigned long *)0x40004410)) +#define GPIO_PORTA_RIS_R (*((volatile unsigned long *)0x40004414)) +#define GPIO_PORTA_MIS_R (*((volatile unsigned long *)0x40004418)) +#define GPIO_PORTA_ICR_R (*((volatile unsigned long *)0x4000441C)) +#define GPIO_PORTA_AFSEL_R (*((volatile unsigned long *)0x40004420)) +#define GPIO_PORTA_DR2R_R (*((volatile unsigned long *)0x40004500)) +#define GPIO_PORTA_DR4R_R (*((volatile unsigned long *)0x40004504)) +#define GPIO_PORTA_DR8R_R (*((volatile unsigned long *)0x40004508)) +#define GPIO_PORTA_ODR_R (*((volatile unsigned long *)0x4000450C)) +#define GPIO_PORTA_PUR_R (*((volatile unsigned long *)0x40004510)) +#define GPIO_PORTA_PDR_R (*((volatile unsigned long *)0x40004514)) +#define GPIO_PORTA_SLR_R (*((volatile unsigned long *)0x40004518)) +#define GPIO_PORTA_DEN_R (*((volatile unsigned long *)0x4000451C)) +#define GPIO_PORTA_LOCK_R (*((volatile unsigned long *)0x40004520)) +#define GPIO_PORTA_CR_R (*((volatile unsigned long *)0x40004524)) + +//***************************************************************************** +// +// GPIO registers (PORTB) +// +//***************************************************************************** +#define GPIO_PORTB_DATA_BITS_R ((volatile unsigned long *)0x40005000) +#define GPIO_PORTB_DATA_R (*((volatile unsigned long *)0x400053FC)) +#define GPIO_PORTB_DIR_R (*((volatile unsigned long *)0x40005400)) +#define GPIO_PORTB_IS_R (*((volatile unsigned long *)0x40005404)) +#define GPIO_PORTB_IBE_R (*((volatile unsigned long *)0x40005408)) +#define GPIO_PORTB_IEV_R (*((volatile unsigned long *)0x4000540C)) +#define GPIO_PORTB_IM_R (*((volatile unsigned long *)0x40005410)) +#define GPIO_PORTB_RIS_R (*((volatile unsigned long *)0x40005414)) +#define GPIO_PORTB_MIS_R (*((volatile unsigned long *)0x40005418)) +#define GPIO_PORTB_ICR_R (*((volatile unsigned long *)0x4000541C)) +#define GPIO_PORTB_AFSEL_R (*((volatile unsigned long *)0x40005420)) +#define GPIO_PORTB_DR2R_R (*((volatile unsigned long *)0x40005500)) +#define GPIO_PORTB_DR4R_R (*((volatile unsigned long *)0x40005504)) +#define GPIO_PORTB_DR8R_R (*((volatile unsigned long *)0x40005508)) +#define GPIO_PORTB_ODR_R (*((volatile unsigned long *)0x4000550C)) +#define GPIO_PORTB_PUR_R (*((volatile unsigned long *)0x40005510)) +#define GPIO_PORTB_PDR_R (*((volatile unsigned long *)0x40005514)) +#define GPIO_PORTB_SLR_R (*((volatile unsigned long *)0x40005518)) +#define GPIO_PORTB_DEN_R (*((volatile unsigned long *)0x4000551C)) +#define GPIO_PORTB_LOCK_R (*((volatile unsigned long *)0x40005520)) +#define GPIO_PORTB_CR_R (*((volatile unsigned long *)0x40005524)) + +//***************************************************************************** +// +// GPIO registers (PORTC) +// +//***************************************************************************** +#define GPIO_PORTC_DATA_BITS_R ((volatile unsigned long *)0x40006000) +#define GPIO_PORTC_DATA_R (*((volatile unsigned long *)0x400063FC)) +#define GPIO_PORTC_DIR_R (*((volatile unsigned long *)0x40006400)) +#define GPIO_PORTC_IS_R (*((volatile unsigned long *)0x40006404)) +#define GPIO_PORTC_IBE_R (*((volatile unsigned long *)0x40006408)) +#define GPIO_PORTC_IEV_R (*((volatile unsigned long *)0x4000640C)) +#define GPIO_PORTC_IM_R (*((volatile unsigned long *)0x40006410)) +#define GPIO_PORTC_RIS_R (*((volatile unsigned long *)0x40006414)) +#define GPIO_PORTC_MIS_R (*((volatile unsigned long *)0x40006418)) +#define GPIO_PORTC_ICR_R (*((volatile unsigned long *)0x4000641C)) +#define GPIO_PORTC_AFSEL_R (*((volatile unsigned long *)0x40006420)) +#define GPIO_PORTC_DR2R_R (*((volatile unsigned long *)0x40006500)) +#define GPIO_PORTC_DR4R_R (*((volatile unsigned long *)0x40006504)) +#define GPIO_PORTC_DR8R_R (*((volatile unsigned long *)0x40006508)) +#define GPIO_PORTC_ODR_R (*((volatile unsigned long *)0x4000650C)) +#define GPIO_PORTC_PUR_R (*((volatile unsigned long *)0x40006510)) +#define GPIO_PORTC_PDR_R (*((volatile unsigned long *)0x40006514)) +#define GPIO_PORTC_SLR_R (*((volatile unsigned long *)0x40006518)) +#define GPIO_PORTC_DEN_R (*((volatile unsigned long *)0x4000651C)) +#define GPIO_PORTC_LOCK_R (*((volatile unsigned long *)0x40006520)) +#define GPIO_PORTC_CR_R (*((volatile unsigned long *)0x40006524)) + +//***************************************************************************** +// +// GPIO registers (PORTD) +// +//***************************************************************************** +#define GPIO_PORTD_DATA_BITS_R ((volatile unsigned long *)0x40007000) +#define GPIO_PORTD_DATA_R (*((volatile unsigned long *)0x400073FC)) +#define GPIO_PORTD_DIR_R (*((volatile unsigned long *)0x40007400)) +#define GPIO_PORTD_IS_R (*((volatile unsigned long *)0x40007404)) +#define GPIO_PORTD_IBE_R (*((volatile unsigned long *)0x40007408)) +#define GPIO_PORTD_IEV_R (*((volatile unsigned long *)0x4000740C)) +#define GPIO_PORTD_IM_R (*((volatile unsigned long *)0x40007410)) +#define GPIO_PORTD_RIS_R (*((volatile unsigned long *)0x40007414)) +#define GPIO_PORTD_MIS_R (*((volatile unsigned long *)0x40007418)) +#define GPIO_PORTD_ICR_R (*((volatile unsigned long *)0x4000741C)) +#define GPIO_PORTD_AFSEL_R (*((volatile unsigned long *)0x40007420)) +#define GPIO_PORTD_DR2R_R (*((volatile unsigned long *)0x40007500)) +#define GPIO_PORTD_DR4R_R (*((volatile unsigned long *)0x40007504)) +#define GPIO_PORTD_DR8R_R (*((volatile unsigned long *)0x40007508)) +#define GPIO_PORTD_ODR_R (*((volatile unsigned long *)0x4000750C)) +#define GPIO_PORTD_PUR_R (*((volatile unsigned long *)0x40007510)) +#define GPIO_PORTD_PDR_R (*((volatile unsigned long *)0x40007514)) +#define GPIO_PORTD_SLR_R (*((volatile unsigned long *)0x40007518)) +#define GPIO_PORTD_DEN_R (*((volatile unsigned long *)0x4000751C)) +#define GPIO_PORTD_LOCK_R (*((volatile unsigned long *)0x40007520)) +#define GPIO_PORTD_CR_R (*((volatile unsigned long *)0x40007524)) + +//***************************************************************************** +// +// SSI registers (SSI0) +// +//***************************************************************************** +#define SSI0_CR0_R (*((volatile unsigned long *)0x40008000)) +#define SSI0_CR1_R (*((volatile unsigned long *)0x40008004)) +#define SSI0_DR_R (*((volatile unsigned long *)0x40008008)) +#define SSI0_SR_R (*((volatile unsigned long *)0x4000800C)) +#define SSI0_CPSR_R (*((volatile unsigned long *)0x40008010)) +#define SSI0_IM_R (*((volatile unsigned long *)0x40008014)) +#define SSI0_RIS_R (*((volatile unsigned long *)0x40008018)) +#define SSI0_MIS_R (*((volatile unsigned long *)0x4000801C)) +#define SSI0_ICR_R (*((volatile unsigned long *)0x40008020)) + +//***************************************************************************** +// +// UART registers (UART0) +// +//***************************************************************************** +#define UART0_DR_R (*((volatile unsigned long *)0x4000C000)) +#define UART0_RSR_R (*((volatile unsigned long *)0x4000C004)) +#define UART0_ECR_R (*((volatile unsigned long *)0x4000C004)) +#define UART0_FR_R (*((volatile unsigned long *)0x4000C018)) +#define UART0_ILPR_R (*((volatile unsigned long *)0x4000C020)) +#define UART0_IBRD_R (*((volatile unsigned long *)0x4000C024)) +#define UART0_FBRD_R (*((volatile unsigned long *)0x4000C028)) +#define UART0_LCRH_R (*((volatile unsigned long *)0x4000C02C)) +#define UART0_CTL_R (*((volatile unsigned long *)0x4000C030)) +#define UART0_IFLS_R (*((volatile unsigned long *)0x4000C034)) +#define UART0_IM_R (*((volatile unsigned long *)0x4000C038)) +#define UART0_RIS_R (*((volatile unsigned long *)0x4000C03C)) +#define UART0_MIS_R (*((volatile unsigned long *)0x4000C040)) +#define UART0_ICR_R (*((volatile unsigned long *)0x4000C044)) + +//***************************************************************************** +// +// UART registers (UART1) +// +//***************************************************************************** +#define UART1_DR_R (*((volatile unsigned long *)0x4000D000)) +#define UART1_RSR_R (*((volatile unsigned long *)0x4000D004)) +#define UART1_ECR_R (*((volatile unsigned long *)0x4000D004)) +#define UART1_FR_R (*((volatile unsigned long *)0x4000D018)) +#define UART1_ILPR_R (*((volatile unsigned long *)0x4000D020)) +#define UART1_IBRD_R (*((volatile unsigned long *)0x4000D024)) +#define UART1_FBRD_R (*((volatile unsigned long *)0x4000D028)) +#define UART1_LCRH_R (*((volatile unsigned long *)0x4000D02C)) +#define UART1_CTL_R (*((volatile unsigned long *)0x4000D030)) +#define UART1_IFLS_R (*((volatile unsigned long *)0x4000D034)) +#define UART1_IM_R (*((volatile unsigned long *)0x4000D038)) +#define UART1_RIS_R (*((volatile unsigned long *)0x4000D03C)) +#define UART1_MIS_R (*((volatile unsigned long *)0x4000D040)) +#define UART1_ICR_R (*((volatile unsigned long *)0x4000D044)) + +//***************************************************************************** +// +// UART registers (UART2) +// +//***************************************************************************** +#define UART2_DR_R (*((volatile unsigned long *)0x4000E000)) +#define UART2_RSR_R (*((volatile unsigned long *)0x4000E004)) +#define UART2_ECR_R (*((volatile unsigned long *)0x4000E004)) +#define UART2_FR_R (*((volatile unsigned long *)0x4000E018)) +#define UART2_ILPR_R (*((volatile unsigned long *)0x4000E020)) +#define UART2_IBRD_R (*((volatile unsigned long *)0x4000E024)) +#define UART2_FBRD_R (*((volatile unsigned long *)0x4000E028)) +#define UART2_LCRH_R (*((volatile unsigned long *)0x4000E02C)) +#define UART2_CTL_R (*((volatile unsigned long *)0x4000E030)) +#define UART2_IFLS_R (*((volatile unsigned long *)0x4000E034)) +#define UART2_IM_R (*((volatile unsigned long *)0x4000E038)) +#define UART2_RIS_R (*((volatile unsigned long *)0x4000E03C)) +#define UART2_MIS_R (*((volatile unsigned long *)0x4000E040)) +#define UART2_ICR_R (*((volatile unsigned long *)0x4000E044)) + +//***************************************************************************** +// +// I2C registers (I2C0 MASTER) +// +//***************************************************************************** +#define I2C0_MASTER_MSA_R (*((volatile unsigned long *)0x40020000)) +#define I2C0_MASTER_MCS_R (*((volatile unsigned long *)0x40020004)) +#define I2C0_MASTER_MDR_R (*((volatile unsigned long *)0x40020008)) +#define I2C0_MASTER_MTPR_R (*((volatile unsigned long *)0x4002000C)) +#define I2C0_MASTER_MIMR_R (*((volatile unsigned long *)0x40020010)) +#define I2C0_MASTER_MRIS_R (*((volatile unsigned long *)0x40020014)) +#define I2C0_MASTER_MMIS_R (*((volatile unsigned long *)0x40020018)) +#define I2C0_MASTER_MICR_R (*((volatile unsigned long *)0x4002001C)) +#define I2C0_MASTER_MCR_R (*((volatile unsigned long *)0x40020020)) + +//***************************************************************************** +// +// I2C registers (I2C0 SLAVE) +// +//***************************************************************************** +#define I2C0_SLAVE_SOAR_R (*((volatile unsigned long *)0x40020800)) +#define I2C0_SLAVE_SCSR_R (*((volatile unsigned long *)0x40020804)) +#define I2C0_SLAVE_SDR_R (*((volatile unsigned long *)0x40020808)) +#define I2C0_SLAVE_SIMR_R (*((volatile unsigned long *)0x4002080C)) +#define I2C0_SLAVE_SRIS_R (*((volatile unsigned long *)0x40020810)) +#define I2C0_SLAVE_SMIS_R (*((volatile unsigned long *)0x40020814)) +#define I2C0_SLAVE_SICR_R (*((volatile unsigned long *)0x40020818)) + +//***************************************************************************** +// +// I2C registers (I2C1 MASTER) +// +//***************************************************************************** +#define I2C1_MASTER_MSA_R (*((volatile unsigned long *)0x40021000)) +#define I2C1_MASTER_MCS_R (*((volatile unsigned long *)0x40021004)) +#define I2C1_MASTER_MDR_R (*((volatile unsigned long *)0x40021008)) +#define I2C1_MASTER_MTPR_R (*((volatile unsigned long *)0x4002100C)) +#define I2C1_MASTER_MIMR_R (*((volatile unsigned long *)0x40021010)) +#define I2C1_MASTER_MRIS_R (*((volatile unsigned long *)0x40021014)) +#define I2C1_MASTER_MMIS_R (*((volatile unsigned long *)0x40021018)) +#define I2C1_MASTER_MICR_R (*((volatile unsigned long *)0x4002101C)) +#define I2C1_MASTER_MCR_R (*((volatile unsigned long *)0x40021020)) + +//***************************************************************************** +// +// I2C registers (I2C1 SLAVE) +// +//***************************************************************************** +#define I2C1_SLAVE_SOAR_R (*((volatile unsigned long *)0x40021800)) +#define I2C1_SLAVE_SCSR_R (*((volatile unsigned long *)0x40021804)) +#define I2C1_SLAVE_SDR_R (*((volatile unsigned long *)0x40021808)) +#define I2C1_SLAVE_SIMR_R (*((volatile unsigned long *)0x4002180C)) +#define I2C1_SLAVE_SRIS_R (*((volatile unsigned long *)0x40021810)) +#define I2C1_SLAVE_SMIS_R (*((volatile unsigned long *)0x40021814)) +#define I2C1_SLAVE_SICR_R (*((volatile unsigned long *)0x40021818)) + +//***************************************************************************** +// +// GPIO registers (PORTE) +// +//***************************************************************************** +#define GPIO_PORTE_DATA_BITS_R ((volatile unsigned long *)0x40024000) +#define GPIO_PORTE_DATA_R (*((volatile unsigned long *)0x400243FC)) +#define GPIO_PORTE_DIR_R (*((volatile unsigned long *)0x40024400)) +#define GPIO_PORTE_IS_R (*((volatile unsigned long *)0x40024404)) +#define GPIO_PORTE_IBE_R (*((volatile unsigned long *)0x40024408)) +#define GPIO_PORTE_IEV_R (*((volatile unsigned long *)0x4002440C)) +#define GPIO_PORTE_IM_R (*((volatile unsigned long *)0x40024410)) +#define GPIO_PORTE_RIS_R (*((volatile unsigned long *)0x40024414)) +#define GPIO_PORTE_MIS_R (*((volatile unsigned long *)0x40024418)) +#define GPIO_PORTE_ICR_R (*((volatile unsigned long *)0x4002441C)) +#define GPIO_PORTE_AFSEL_R (*((volatile unsigned long *)0x40024420)) +#define GPIO_PORTE_DR2R_R (*((volatile unsigned long *)0x40024500)) +#define GPIO_PORTE_DR4R_R (*((volatile unsigned long *)0x40024504)) +#define GPIO_PORTE_DR8R_R (*((volatile unsigned long *)0x40024508)) +#define GPIO_PORTE_ODR_R (*((volatile unsigned long *)0x4002450C)) +#define GPIO_PORTE_PUR_R (*((volatile unsigned long *)0x40024510)) +#define GPIO_PORTE_PDR_R (*((volatile unsigned long *)0x40024514)) +#define GPIO_PORTE_SLR_R (*((volatile unsigned long *)0x40024518)) +#define GPIO_PORTE_DEN_R (*((volatile unsigned long *)0x4002451C)) +#define GPIO_PORTE_LOCK_R (*((volatile unsigned long *)0x40024520)) +#define GPIO_PORTE_CR_R (*((volatile unsigned long *)0x40024524)) + +//***************************************************************************** +// +// GPIO registers (PORTF) +// +//***************************************************************************** +#define GPIO_PORTF_DATA_BITS_R ((volatile unsigned long *)0x40025000) +#define GPIO_PORTF_DATA_R (*((volatile unsigned long *)0x400253FC)) +#define GPIO_PORTF_DIR_R (*((volatile unsigned long *)0x40025400)) +#define GPIO_PORTF_IS_R (*((volatile unsigned long *)0x40025404)) +#define GPIO_PORTF_IBE_R (*((volatile unsigned long *)0x40025408)) +#define GPIO_PORTF_IEV_R (*((volatile unsigned long *)0x4002540C)) +#define GPIO_PORTF_IM_R (*((volatile unsigned long *)0x40025410)) +#define GPIO_PORTF_RIS_R (*((volatile unsigned long *)0x40025414)) +#define GPIO_PORTF_MIS_R (*((volatile unsigned long *)0x40025418)) +#define GPIO_PORTF_ICR_R (*((volatile unsigned long *)0x4002541C)) +#define GPIO_PORTF_AFSEL_R (*((volatile unsigned long *)0x40025420)) +#define GPIO_PORTF_DR2R_R (*((volatile unsigned long *)0x40025500)) +#define GPIO_PORTF_DR4R_R (*((volatile unsigned long *)0x40025504)) +#define GPIO_PORTF_DR8R_R (*((volatile unsigned long *)0x40025508)) +#define GPIO_PORTF_ODR_R (*((volatile unsigned long *)0x4002550C)) +#define GPIO_PORTF_PUR_R (*((volatile unsigned long *)0x40025510)) +#define GPIO_PORTF_PDR_R (*((volatile unsigned long *)0x40025514)) +#define GPIO_PORTF_SLR_R (*((volatile unsigned long *)0x40025518)) +#define GPIO_PORTF_DEN_R (*((volatile unsigned long *)0x4002551C)) +#define GPIO_PORTF_LOCK_R (*((volatile unsigned long *)0x40025520)) +#define GPIO_PORTF_CR_R (*((volatile unsigned long *)0x40025524)) + +//***************************************************************************** +// +// GPIO registers (PORTG) +// +//***************************************************************************** +#define GPIO_PORTG_DATA_BITS_R ((volatile unsigned long *)0x40026000) +#define GPIO_PORTG_DATA_R (*((volatile unsigned long *)0x400263FC)) +#define GPIO_PORTG_DIR_R (*((volatile unsigned long *)0x40026400)) +#define GPIO_PORTG_IS_R (*((volatile unsigned long *)0x40026404)) +#define GPIO_PORTG_IBE_R (*((volatile unsigned long *)0x40026408)) +#define GPIO_PORTG_IEV_R (*((volatile unsigned long *)0x4002640C)) +#define GPIO_PORTG_IM_R (*((volatile unsigned long *)0x40026410)) +#define GPIO_PORTG_RIS_R (*((volatile unsigned long *)0x40026414)) +#define GPIO_PORTG_MIS_R (*((volatile unsigned long *)0x40026418)) +#define GPIO_PORTG_ICR_R (*((volatile unsigned long *)0x4002641C)) +#define GPIO_PORTG_AFSEL_R (*((volatile unsigned long *)0x40026420)) +#define GPIO_PORTG_DR2R_R (*((volatile unsigned long *)0x40026500)) +#define GPIO_PORTG_DR4R_R (*((volatile unsigned long *)0x40026504)) +#define GPIO_PORTG_DR8R_R (*((volatile unsigned long *)0x40026508)) +#define GPIO_PORTG_ODR_R (*((volatile unsigned long *)0x4002650C)) +#define GPIO_PORTG_PUR_R (*((volatile unsigned long *)0x40026510)) +#define GPIO_PORTG_PDR_R (*((volatile unsigned long *)0x40026514)) +#define GPIO_PORTG_SLR_R (*((volatile unsigned long *)0x40026518)) +#define GPIO_PORTG_DEN_R (*((volatile unsigned long *)0x4002651C)) +#define GPIO_PORTG_LOCK_R (*((volatile unsigned long *)0x40026520)) +#define GPIO_PORTG_CR_R (*((volatile unsigned long *)0x40026524)) + +//***************************************************************************** +// +// PWM registers (PWM) +// +//***************************************************************************** +#define PWM_CTL_R (*((volatile unsigned long *)0x40028000)) +#define PWM_SYNC_R (*((volatile unsigned long *)0x40028004)) +#define PWM_ENABLE_R (*((volatile unsigned long *)0x40028008)) +#define PWM_INVERT_R (*((volatile unsigned long *)0x4002800C)) +#define PWM_FAULT_R (*((volatile unsigned long *)0x40028010)) +#define PWM_INTEN_R (*((volatile unsigned long *)0x40028014)) +#define PWM_RIS_R (*((volatile unsigned long *)0x40028018)) +#define PWM_ISC_R (*((volatile unsigned long *)0x4002801C)) +#define PWM_STATUS_R (*((volatile unsigned long *)0x40028020)) +#define PWM_0_CTL_R (*((volatile unsigned long *)0x40028040)) +#define PWM_0_INTEN_R (*((volatile unsigned long *)0x40028044)) +#define PWM_0_RIS_R (*((volatile unsigned long *)0x40028048)) +#define PWM_0_ISC_R (*((volatile unsigned long *)0x4002804C)) +#define PWM_0_LOAD_R (*((volatile unsigned long *)0x40028050)) +#define PWM_0_COUNT_R (*((volatile unsigned long *)0x40028054)) +#define PWM_0_CMPA_R (*((volatile unsigned long *)0x40028058)) +#define PWM_0_CMPB_R (*((volatile unsigned long *)0x4002805C)) +#define PWM_0_GENA_R (*((volatile unsigned long *)0x40028060)) +#define PWM_0_GENB_R (*((volatile unsigned long *)0x40028064)) +#define PWM_0_DBCTL_R (*((volatile unsigned long *)0x40028068)) +#define PWM_0_DBRISE_R (*((volatile unsigned long *)0x4002806C)) +#define PWM_0_DBFALL_R (*((volatile unsigned long *)0x40028070)) +#define PWM_1_CTL_R (*((volatile unsigned long *)0x40028080)) +#define PWM_1_INTEN_R (*((volatile unsigned long *)0x40028084)) +#define PWM_1_RIS_R (*((volatile unsigned long *)0x40028088)) +#define PWM_1_ISC_R (*((volatile unsigned long *)0x4002808C)) +#define PWM_1_LOAD_R (*((volatile unsigned long *)0x40028090)) +#define PWM_1_COUNT_R (*((volatile unsigned long *)0x40028094)) +#define PWM_1_CMPA_R (*((volatile unsigned long *)0x40028098)) +#define PWM_1_CMPB_R (*((volatile unsigned long *)0x4002809C)) +#define PWM_1_GENA_R (*((volatile unsigned long *)0x400280A0)) +#define PWM_1_GENB_R (*((volatile unsigned long *)0x400280A4)) +#define PWM_1_DBCTL_R (*((volatile unsigned long *)0x400280A8)) +#define PWM_1_DBRISE_R (*((volatile unsigned long *)0x400280AC)) +#define PWM_1_DBFALL_R (*((volatile unsigned long *)0x400280B0)) +#define PWM_2_CTL_R (*((volatile unsigned long *)0x400280C0)) +#define PWM_2_INTEN_R (*((volatile unsigned long *)0x400280C4)) +#define PWM_2_RIS_R (*((volatile unsigned long *)0x400280C8)) +#define PWM_2_ISC_R (*((volatile unsigned long *)0x400280CC)) +#define PWM_2_LOAD_R (*((volatile unsigned long *)0x400280D0)) +#define PWM_2_COUNT_R (*((volatile unsigned long *)0x400280D4)) +#define PWM_2_CMPA_R (*((volatile unsigned long *)0x400280D8)) +#define PWM_2_CMPB_R (*((volatile unsigned long *)0x400280DC)) +#define PWM_2_GENA_R (*((volatile unsigned long *)0x400280E0)) +#define PWM_2_GENB_R (*((volatile unsigned long *)0x400280E4)) +#define PWM_2_DBCTL_R (*((volatile unsigned long *)0x400280E8)) +#define PWM_2_DBRISE_R (*((volatile unsigned long *)0x400280EC)) +#define PWM_2_DBFALL_R (*((volatile unsigned long *)0x400280F0)) + +//***************************************************************************** +// +// QEI registers (QEI0) +// +//***************************************************************************** +#define QEI0_CTL_R (*((volatile unsigned long *)0x4002C000)) +#define QEI0_STAT_R (*((volatile unsigned long *)0x4002C004)) +#define QEI0_POS_R (*((volatile unsigned long *)0x4002C008)) +#define QEI0_MAXPOS_R (*((volatile unsigned long *)0x4002C00C)) +#define QEI0_LOAD_R (*((volatile unsigned long *)0x4002C010)) +#define QEI0_TIME_R (*((volatile unsigned long *)0x4002C014)) +#define QEI0_COUNT_R (*((volatile unsigned long *)0x4002C018)) +#define QEI0_SPEED_R (*((volatile unsigned long *)0x4002C01C)) +#define QEI0_INTEN_R (*((volatile unsigned long *)0x4002C020)) +#define QEI0_RIS_R (*((volatile unsigned long *)0x4002C024)) +#define QEI0_ISC_R (*((volatile unsigned long *)0x4002C028)) + +//***************************************************************************** +// +// QEI registers (QEI1) +// +//***************************************************************************** +#define QEI1_CTL_R (*((volatile unsigned long *)0x4002D000)) +#define QEI1_STAT_R (*((volatile unsigned long *)0x4002D004)) +#define QEI1_POS_R (*((volatile unsigned long *)0x4002D008)) +#define QEI1_MAXPOS_R (*((volatile unsigned long *)0x4002D00C)) +#define QEI1_LOAD_R (*((volatile unsigned long *)0x4002D010)) +#define QEI1_TIME_R (*((volatile unsigned long *)0x4002D014)) +#define QEI1_COUNT_R (*((volatile unsigned long *)0x4002D018)) +#define QEI1_SPEED_R (*((volatile unsigned long *)0x4002D01C)) +#define QEI1_INTEN_R (*((volatile unsigned long *)0x4002D020)) +#define QEI1_RIS_R (*((volatile unsigned long *)0x4002D024)) +#define QEI1_ISC_R (*((volatile unsigned long *)0x4002D028)) + +//***************************************************************************** +// +// Timer registers (TIMER0) +// +//***************************************************************************** +#define TIMER0_CFG_R (*((volatile unsigned long *)0x40030000)) +#define TIMER0_TAMR_R (*((volatile unsigned long *)0x40030004)) +#define TIMER0_TBMR_R (*((volatile unsigned long *)0x40030008)) +#define TIMER0_CTL_R (*((volatile unsigned long *)0x4003000C)) +#define TIMER0_IMR_R (*((volatile unsigned long *)0x40030018)) +#define TIMER0_RIS_R (*((volatile unsigned long *)0x4003001C)) +#define TIMER0_MIS_R (*((volatile unsigned long *)0x40030020)) +#define TIMER0_ICR_R (*((volatile unsigned long *)0x40030024)) +#define TIMER0_TAILR_R (*((volatile unsigned long *)0x40030028)) +#define TIMER0_TBILR_R (*((volatile unsigned long *)0x4003002C)) +#define TIMER0_TAMATCHR_R (*((volatile unsigned long *)0x40030030)) +#define TIMER0_TBMATCHR_R (*((volatile unsigned long *)0x40030034)) +#define TIMER0_TAPR_R (*((volatile unsigned long *)0x40030038)) +#define TIMER0_TBPR_R (*((volatile unsigned long *)0x4003003C)) +#define TIMER0_TAPMR_R (*((volatile unsigned long *)0x40030040)) +#define TIMER0_TBPMR_R (*((volatile unsigned long *)0x40030044)) +#define TIMER0_TAR_R (*((volatile unsigned long *)0x40030048)) +#define TIMER0_TBR_R (*((volatile unsigned long *)0x4003004C)) + +//***************************************************************************** +// +// Timer registers (TIMER1) +// +//***************************************************************************** +#define TIMER1_CFG_R (*((volatile unsigned long *)0x40031000)) +#define TIMER1_TAMR_R (*((volatile unsigned long *)0x40031004)) +#define TIMER1_TBMR_R (*((volatile unsigned long *)0x40031008)) +#define TIMER1_CTL_R (*((volatile unsigned long *)0x4003100C)) +#define TIMER1_IMR_R (*((volatile unsigned long *)0x40031018)) +#define TIMER1_RIS_R (*((volatile unsigned long *)0x4003101C)) +#define TIMER1_MIS_R (*((volatile unsigned long *)0x40031020)) +#define TIMER1_ICR_R (*((volatile unsigned long *)0x40031024)) +#define TIMER1_TAILR_R (*((volatile unsigned long *)0x40031028)) +#define TIMER1_TBILR_R (*((volatile unsigned long *)0x4003102C)) +#define TIMER1_TAMATCHR_R (*((volatile unsigned long *)0x40031030)) +#define TIMER1_TBMATCHR_R (*((volatile unsigned long *)0x40031034)) +#define TIMER1_TAPR_R (*((volatile unsigned long *)0x40031038)) +#define TIMER1_TBPR_R (*((volatile unsigned long *)0x4003103C)) +#define TIMER1_TAPMR_R (*((volatile unsigned long *)0x40031040)) +#define TIMER1_TBPMR_R (*((volatile unsigned long *)0x40031044)) +#define TIMER1_TAR_R (*((volatile unsigned long *)0x40031048)) +#define TIMER1_TBR_R (*((volatile unsigned long *)0x4003104C)) + +//***************************************************************************** +// +// Timer registers (TIMER2) +// +//***************************************************************************** +#define TIMER2_CFG_R (*((volatile unsigned long *)0x40032000)) +#define TIMER2_TAMR_R (*((volatile unsigned long *)0x40032004)) +#define TIMER2_TBMR_R (*((volatile unsigned long *)0x40032008)) +#define TIMER2_CTL_R (*((volatile unsigned long *)0x4003200C)) +#define TIMER2_IMR_R (*((volatile unsigned long *)0x40032018)) +#define TIMER2_RIS_R (*((volatile unsigned long *)0x4003201C)) +#define TIMER2_MIS_R (*((volatile unsigned long *)0x40032020)) +#define TIMER2_ICR_R (*((volatile unsigned long *)0x40032024)) +#define TIMER2_TAILR_R (*((volatile unsigned long *)0x40032028)) +#define TIMER2_TBILR_R (*((volatile unsigned long *)0x4003202C)) +#define TIMER2_TAMATCHR_R (*((volatile unsigned long *)0x40032030)) +#define TIMER2_TBMATCHR_R (*((volatile unsigned long *)0x40032034)) +#define TIMER2_TAPR_R (*((volatile unsigned long *)0x40032038)) +#define TIMER2_TBPR_R (*((volatile unsigned long *)0x4003203C)) +#define TIMER2_TAPMR_R (*((volatile unsigned long *)0x40032040)) +#define TIMER2_TBPMR_R (*((volatile unsigned long *)0x40032044)) +#define TIMER2_TAR_R (*((volatile unsigned long *)0x40032048)) +#define TIMER2_TBR_R (*((volatile unsigned long *)0x4003204C)) + +//***************************************************************************** +// +// Timer registers (TIMER3) +// +//***************************************************************************** +#define TIMER3_CFG_R (*((volatile unsigned long *)0x40033000)) +#define TIMER3_TAMR_R (*((volatile unsigned long *)0x40033004)) +#define TIMER3_TBMR_R (*((volatile unsigned long *)0x40033008)) +#define TIMER3_CTL_R (*((volatile unsigned long *)0x4003300C)) +#define TIMER3_IMR_R (*((volatile unsigned long *)0x40033018)) +#define TIMER3_RIS_R (*((volatile unsigned long *)0x4003301C)) +#define TIMER3_MIS_R (*((volatile unsigned long *)0x40033020)) +#define TIMER3_ICR_R (*((volatile unsigned long *)0x40033024)) +#define TIMER3_TAILR_R (*((volatile unsigned long *)0x40033028)) +#define TIMER3_TBILR_R (*((volatile unsigned long *)0x4003302C)) +#define TIMER3_TAMATCHR_R (*((volatile unsigned long *)0x40033030)) +#define TIMER3_TBMATCHR_R (*((volatile unsigned long *)0x40033034)) +#define TIMER3_TAPR_R (*((volatile unsigned long *)0x40033038)) +#define TIMER3_TBPR_R (*((volatile unsigned long *)0x4003303C)) +#define TIMER3_TAPMR_R (*((volatile unsigned long *)0x40033040)) +#define TIMER3_TBPMR_R (*((volatile unsigned long *)0x40033044)) +#define TIMER3_TAR_R (*((volatile unsigned long *)0x40033048)) +#define TIMER3_TBR_R (*((volatile unsigned long *)0x4003304C)) + +//***************************************************************************** +// +// ADC registers (ADC0) +// +//***************************************************************************** +#define ADC0_ACTSS_R (*((volatile unsigned long *)0x40038000)) +#define ADC0_RIS_R (*((volatile unsigned long *)0x40038004)) +#define ADC0_IM_R (*((volatile unsigned long *)0x40038008)) +#define ADC0_ISC_R (*((volatile unsigned long *)0x4003800C)) +#define ADC0_OSTAT_R (*((volatile unsigned long *)0x40038010)) +#define ADC0_EMUX_R (*((volatile unsigned long *)0x40038014)) +#define ADC0_USTAT_R (*((volatile unsigned long *)0x40038018)) +#define ADC0_SSPRI_R (*((volatile unsigned long *)0x40038020)) +#define ADC0_PSSI_R (*((volatile unsigned long *)0x40038028)) +#define ADC0_SAC_R (*((volatile unsigned long *)0x40038030)) +#define ADC0_SSMUX0_R (*((volatile unsigned long *)0x40038040)) +#define ADC0_SSCTL0_R (*((volatile unsigned long *)0x40038044)) +#define ADC0_SSFIFO0_R (*((volatile unsigned long *)0x40038048)) +#define ADC0_SSFSTAT0_R (*((volatile unsigned long *)0x4003804C)) +#define ADC0_SSMUX1_R (*((volatile unsigned long *)0x40038060)) +#define ADC0_SSCTL1_R (*((volatile unsigned long *)0x40038064)) +#define ADC0_SSFIFO1_R (*((volatile unsigned long *)0x40038068)) +#define ADC0_SSFSTAT1_R (*((volatile unsigned long *)0x4003806C)) +#define ADC0_SSMUX2_R (*((volatile unsigned long *)0x40038080)) +#define ADC0_SSCTL2_R (*((volatile unsigned long *)0x40038084)) +#define ADC0_SSFIFO2_R (*((volatile unsigned long *)0x40038088)) +#define ADC0_SSFSTAT2_R (*((volatile unsigned long *)0x4003808C)) +#define ADC0_SSMUX3_R (*((volatile unsigned long *)0x400380A0)) +#define ADC0_SSCTL3_R (*((volatile unsigned long *)0x400380A4)) +#define ADC0_SSFIFO3_R (*((volatile unsigned long *)0x400380A8)) +#define ADC0_SSFSTAT3_R (*((volatile unsigned long *)0x400380AC)) +#define ADC0_TMLB_R (*((volatile unsigned long *)0x40038100)) + +//***************************************************************************** +// +// Comparator registers (COMP) +// +//***************************************************************************** +#define COMP_ACMIS_R (*((volatile unsigned long *)0x4003C000)) +#define COMP_ACRIS_R (*((volatile unsigned long *)0x4003C004)) +#define COMP_ACINTEN_R (*((volatile unsigned long *)0x4003C008)) +#define COMP_ACREFCTL_R (*((volatile unsigned long *)0x4003C010)) +#define COMP_ACSTAT0_R (*((volatile unsigned long *)0x4003C020)) +#define COMP_ACCTL0_R (*((volatile unsigned long *)0x4003C024)) +#define COMP_ACSTAT1_R (*((volatile unsigned long *)0x4003C040)) +#define COMP_ACCTL1_R (*((volatile unsigned long *)0x4003C044)) + +//***************************************************************************** +// +// Ethernet MAC registers (MAC) +// +//***************************************************************************** +#define MAC_RIS_R (*((volatile unsigned long *)0x40048000)) +#define MAC_IACK_R (*((volatile unsigned long *)0x40048000)) +#define MAC_IM_R (*((volatile unsigned long *)0x40048004)) +#define MAC_RCTL_R (*((volatile unsigned long *)0x40048008)) +#define MAC_TCTL_R (*((volatile unsigned long *)0x4004800C)) +#define MAC_DATA_R (*((volatile unsigned long *)0x40048010)) +#define MAC_IA0_R (*((volatile unsigned long *)0x40048014)) +#define MAC_IA1_R (*((volatile unsigned long *)0x40048018)) +#define MAC_THR_R (*((volatile unsigned long *)0x4004801C)) +#define MAC_MCTL_R (*((volatile unsigned long *)0x40048020)) +#define MAC_MDV_R (*((volatile unsigned long *)0x40048024)) +#define MAC_MTXD_R (*((volatile unsigned long *)0x4004802C)) +#define MAC_MRXD_R (*((volatile unsigned long *)0x40048030)) +#define MAC_NP_R (*((volatile unsigned long *)0x40048034)) +#define MAC_TR_R (*((volatile unsigned long *)0x40048038)) + +//***************************************************************************** +// +// Ethernet Controller PHY registers (MAC) +// +//***************************************************************************** +#define PHY_MR0 0x00000000 // Ethernet PHY Management Register + // 0 - Control +#define PHY_MR1 0x00000001 // Ethernet PHY Management Register + // 1 - Status +#define PHY_MR2 0x00000002 // Ethernet PHY Management Register + // 2 - PHY Identifier 1 +#define PHY_MR3 0x00000003 // Ethernet PHY Management Register + // 3 - PHY Identifier 2 +#define PHY_MR4 0x00000004 // Ethernet PHY Management Register + // 4 - Auto-Negotiation + // Advertisement +#define PHY_MR5 0x00000005 // Ethernet PHY Management Register + // 5 - Auto-Negotiation Link + // Partner Base Page Ability +#define PHY_MR6 0x00000006 // Ethernet PHY Management Register + // 6 - Auto-Negotiation Expansion +#define PHY_MR16 0x00000010 // Ethernet PHY Management Register + // 16 - Vendor-Specific +#define PHY_MR17 0x00000011 // Ethernet PHY Management Register + // 17 - Mode Control/Status +#define PHY_MR18 0x00000012 // Ethernet PHY Management Register + // 18 - Diagnostic +#define PHY_MR19 0x00000013 // Ethernet PHY Management Register + // 19 - Transceiver Control +#define PHY_MR23 0x00000017 // Ethernet PHY Management Register + // 23 - LED Configuration +#define PHY_MR24 0x00000018 // Ethernet PHY Management Register + // 24 -MDI/MDIX Control + +//***************************************************************************** +// +// Hibernation module registers (HIB) +// +//***************************************************************************** +#define HIB_RTCC_R (*((volatile unsigned long *)0x400FC000)) +#define HIB_RTCM0_R (*((volatile unsigned long *)0x400FC004)) +#define HIB_RTCM1_R (*((volatile unsigned long *)0x400FC008)) +#define HIB_RTCLD_R (*((volatile unsigned long *)0x400FC00C)) +#define HIB_CTL_R (*((volatile unsigned long *)0x400FC010)) +#define HIB_IM_R (*((volatile unsigned long *)0x400FC014)) +#define HIB_RIS_R (*((volatile unsigned long *)0x400FC018)) +#define HIB_MIS_R (*((volatile unsigned long *)0x400FC01C)) +#define HIB_IC_R (*((volatile unsigned long *)0x400FC020)) +#define HIB_RTCT_R (*((volatile unsigned long *)0x400FC024)) +#define HIB_DATA_R (*((volatile unsigned long *)0x400FC030)) + +//***************************************************************************** +// +// FLASH registers (FLASH CTRL) +// +//***************************************************************************** +#define FLASH_FMA_R (*((volatile unsigned long *)0x400FD000)) +#define FLASH_FMD_R (*((volatile unsigned long *)0x400FD004)) +#define FLASH_FMC_R (*((volatile unsigned long *)0x400FD008)) +#define FLASH_FCRIS_R (*((volatile unsigned long *)0x400FD00C)) +#define FLASH_FCIM_R (*((volatile unsigned long *)0x400FD010)) +#define FLASH_FCMISC_R (*((volatile unsigned long *)0x400FD014)) +#define FLASH_USECRL_R (*((volatile unsigned long *)0x400FE140)) +#define FLASH_USERDBG_R (*((volatile unsigned long *)0x400FE1D0)) +#define FLASH_USERREG0_R (*((volatile unsigned long *)0x400FE1E0)) +#define FLASH_USERREG1_R (*((volatile unsigned long *)0x400FE1E4)) +#define FLASH_FMPRE0_R (*((volatile unsigned long *)0x400FE200)) +#define FLASH_FMPRE1_R (*((volatile unsigned long *)0x400FE204)) +#define FLASH_FMPRE2_R (*((volatile unsigned long *)0x400FE208)) +#define FLASH_FMPRE3_R (*((volatile unsigned long *)0x400FE20C)) +#define FLASH_FMPPE0_R (*((volatile unsigned long *)0x400FE400)) +#define FLASH_FMPPE1_R (*((volatile unsigned long *)0x400FE404)) +#define FLASH_FMPPE2_R (*((volatile unsigned long *)0x400FE408)) +#define FLASH_FMPPE3_R (*((volatile unsigned long *)0x400FE40C)) + +//***************************************************************************** +// +// System Control registers (SYSCTL) +// +//***************************************************************************** +#define SYSCTL_DID0_R (*((volatile unsigned long *)0x400FE000)) +#define SYSCTL_DID1_R (*((volatile unsigned long *)0x400FE004)) +#define SYSCTL_DC0_R (*((volatile unsigned long *)0x400FE008)) +#define SYSCTL_DC1_R (*((volatile unsigned long *)0x400FE010)) +#define SYSCTL_DC2_R (*((volatile unsigned long *)0x400FE014)) +#define SYSCTL_DC3_R (*((volatile unsigned long *)0x400FE018)) +#define SYSCTL_DC4_R (*((volatile unsigned long *)0x400FE01C)) +#define SYSCTL_PBORCTL_R (*((volatile unsigned long *)0x400FE030)) +#define SYSCTL_LDOPCTL_R (*((volatile unsigned long *)0x400FE034)) +#define SYSCTL_SRCR0_R (*((volatile unsigned long *)0x400FE040)) +#define SYSCTL_SRCR1_R (*((volatile unsigned long *)0x400FE044)) +#define SYSCTL_SRCR2_R (*((volatile unsigned long *)0x400FE048)) +#define SYSCTL_RIS_R (*((volatile unsigned long *)0x400FE050)) +#define SYSCTL_IMC_R (*((volatile unsigned long *)0x400FE054)) +#define SYSCTL_MISC_R (*((volatile unsigned long *)0x400FE058)) +#define SYSCTL_RESC_R (*((volatile unsigned long *)0x400FE05C)) +#define SYSCTL_RCC_R (*((volatile unsigned long *)0x400FE060)) +#define SYSCTL_PLLCFG_R (*((volatile unsigned long *)0x400FE064)) +#define SYSCTL_RCC2_R (*((volatile unsigned long *)0x400FE070)) +#define SYSCTL_RCGC0_R (*((volatile unsigned long *)0x400FE100)) +#define SYSCTL_RCGC1_R (*((volatile unsigned long *)0x400FE104)) +#define SYSCTL_RCGC2_R (*((volatile unsigned long *)0x400FE108)) +#define SYSCTL_SCGC0_R (*((volatile unsigned long *)0x400FE110)) +#define SYSCTL_SCGC1_R (*((volatile unsigned long *)0x400FE114)) +#define SYSCTL_SCGC2_R (*((volatile unsigned long *)0x400FE118)) +#define SYSCTL_DCGC0_R (*((volatile unsigned long *)0x400FE120)) +#define SYSCTL_DCGC1_R (*((volatile unsigned long *)0x400FE124)) +#define SYSCTL_DCGC2_R (*((volatile unsigned long *)0x400FE128)) +#define SYSCTL_DSLPCLKCFG_R (*((volatile unsigned long *)0x400FE144)) + +//***************************************************************************** +// +// NVIC registers (NVIC) +// +//***************************************************************************** +#define NVIC_INT_TYPE_R (*((volatile unsigned long *)0xE000E004)) +#define NVIC_ST_CTRL_R (*((volatile unsigned long *)0xE000E010)) +#define NVIC_ST_RELOAD_R (*((volatile unsigned long *)0xE000E014)) +#define NVIC_ST_CURRENT_R (*((volatile unsigned long *)0xE000E018)) +#define NVIC_ST_CAL_R (*((volatile unsigned long *)0xE000E01C)) +#define NVIC_EN0_R (*((volatile unsigned long *)0xE000E100)) +#define NVIC_EN1_R (*((volatile unsigned long *)0xE000E104)) +#define NVIC_DIS0_R (*((volatile unsigned long *)0xE000E180)) +#define NVIC_DIS1_R (*((volatile unsigned long *)0xE000E184)) +#define NVIC_PEND0_R (*((volatile unsigned long *)0xE000E200)) +#define NVIC_PEND1_R (*((volatile unsigned long *)0xE000E204)) +#define NVIC_UNPEND0_R (*((volatile unsigned long *)0xE000E280)) +#define NVIC_UNPEND1_R (*((volatile unsigned long *)0xE000E284)) +#define NVIC_ACTIVE0_R (*((volatile unsigned long *)0xE000E300)) +#define NVIC_ACTIVE1_R (*((volatile unsigned long *)0xE000E304)) +#define NVIC_PRI0_R (*((volatile unsigned long *)0xE000E400)) +#define NVIC_PRI1_R (*((volatile unsigned long *)0xE000E404)) +#define NVIC_PRI2_R (*((volatile unsigned long *)0xE000E408)) +#define NVIC_PRI3_R (*((volatile unsigned long *)0xE000E40C)) +#define NVIC_PRI4_R (*((volatile unsigned long *)0xE000E410)) +#define NVIC_PRI5_R (*((volatile unsigned long *)0xE000E414)) +#define NVIC_PRI6_R (*((volatile unsigned long *)0xE000E418)) +#define NVIC_PRI7_R (*((volatile unsigned long *)0xE000E41C)) +#define NVIC_PRI8_R (*((volatile unsigned long *)0xE000E420)) +#define NVIC_PRI9_R (*((volatile unsigned long *)0xE000E424)) +#define NVIC_PRI10_R (*((volatile unsigned long *)0xE000E428)) +#define NVIC_CPUID_R (*((volatile unsigned long *)0xE000ED00)) +#define NVIC_INT_CTRL_R (*((volatile unsigned long *)0xE000ED04)) +#define NVIC_VTABLE_R (*((volatile unsigned long *)0xE000ED08)) +#define NVIC_APINT_R (*((volatile unsigned long *)0xE000ED0C)) +#define NVIC_SYS_CTRL_R (*((volatile unsigned long *)0xE000ED10)) +#define NVIC_CFG_CTRL_R (*((volatile unsigned long *)0xE000ED14)) +#define NVIC_SYS_PRI1_R (*((volatile unsigned long *)0xE000ED18)) +#define NVIC_SYS_PRI2_R (*((volatile unsigned long *)0xE000ED1C)) +#define NVIC_SYS_PRI3_R (*((volatile unsigned long *)0xE000ED20)) +#define NVIC_SYS_HND_CTRL_R (*((volatile unsigned long *)0xE000ED24)) +#define NVIC_FAULT_STAT_R (*((volatile unsigned long *)0xE000ED28)) +#define NVIC_HFAULT_STAT_R (*((volatile unsigned long *)0xE000ED2C)) +#define NVIC_DEBUG_STAT_R (*((volatile unsigned long *)0xE000ED30)) +#define NVIC_MM_ADDR_R (*((volatile unsigned long *)0xE000ED34)) +#define NVIC_FAULT_ADDR_R (*((volatile unsigned long *)0xE000ED38)) +#define NVIC_MPU_TYPE_R (*((volatile unsigned long *)0xE000ED90)) +#define NVIC_MPU_CTRL_R (*((volatile unsigned long *)0xE000ED94)) +#define NVIC_MPU_NUMBER_R (*((volatile unsigned long *)0xE000ED98)) +#define NVIC_MPU_BASE_R (*((volatile unsigned long *)0xE000ED9C)) +#define NVIC_MPU_ATTR_R (*((volatile unsigned long *)0xE000EDA0)) +#define NVIC_MPU_BASE1_R (*((volatile unsigned long *)0xE000EDA4)) +#define NVIC_MPU_ATTR1_R (*((volatile unsigned long *)0xE000EDA8)) +#define NVIC_MPU_BASE2_R (*((volatile unsigned long *)0xE000EDAC)) +#define NVIC_MPU_ATTR2_R (*((volatile unsigned long *)0xE000EDB0)) +#define NVIC_MPU_BASE3_R (*((volatile unsigned long *)0xE000EDB4)) +#define NVIC_MPU_ATTR3_R (*((volatile unsigned long *)0xE000EDB8)) +#define NVIC_DBG_CTRL_R (*((volatile unsigned long *)0xE000EDF0)) +#define NVIC_DBG_XFER_R (*((volatile unsigned long *)0xE000EDF4)) +#define NVIC_DBG_DATA_R (*((volatile unsigned long *)0xE000EDF8)) +#define NVIC_DBG_INT_R (*((volatile unsigned long *)0xE000EDFC)) +#define NVIC_SW_TRIG_R (*((volatile unsigned long *)0xE000EF00)) + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_LOAD register. +// +//***************************************************************************** +#define WDT_LOAD_M 0xFFFFFFFF // Watchdog Load Value +#define WDT_LOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_VALUE register. +// +//***************************************************************************** +#define WDT_VALUE_M 0xFFFFFFFF // Watchdog Value +#define WDT_VALUE_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_CTL register. +// +//***************************************************************************** +#define WDT_CTL_RESEN 0x00000002 // Watchdog Reset Enable +#define WDT_CTL_INTEN 0x00000001 // Watchdog Interrupt Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_ICR register. +// +//***************************************************************************** +#define WDT_ICR_M 0xFFFFFFFF // Watchdog Interrupt Clear +#define WDT_ICR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_RIS register. +// +//***************************************************************************** +#define WDT_RIS_WDTRIS 0x00000001 // Watchdog Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_MIS register. +// +//***************************************************************************** +#define WDT_MIS_WDTMIS 0x00000001 // Watchdog Masked Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_TEST register. +// +//***************************************************************************** +#define WDT_TEST_STALL 0x00000100 // Watchdog Stall Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the WDT_O_LOCK register. +// +//***************************************************************************** +#define WDT_LOCK_M 0xFFFFFFFF // Watchdog Lock +#define WDT_LOCK_UNLOCKED 0x00000000 // Unlocked +#define WDT_LOCK_LOCKED 0x00000001 // Locked +#define WDT_LOCK_UNLOCK 0x1ACCE551 // Unlocks the watchdog timer + +//***************************************************************************** +// +// The following are defines for the bit fields in the GPIO_O_LOCK register. +// +//***************************************************************************** +#define GPIO_LOCK_M 0xFFFFFFFF // GPIO Lock +#define GPIO_LOCK_UNLOCKED 0x00000000 // The GPIOCR register is unlocked + // and may be modified +#define GPIO_LOCK_LOCKED 0x00000001 // The GPIOCR register is locked + // and may not be modified +#define GPIO_LOCK_KEY 0x1ACCE551 // Unlocks the GPIO_CR register + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_CR0 register. +// +//***************************************************************************** +#define SSI_CR0_SCR_M 0x0000FF00 // SSI Serial Clock Rate +#define SSI_CR0_SPH 0x00000080 // SSI Serial Clock Phase +#define SSI_CR0_SPO 0x00000040 // SSI Serial Clock Polarity +#define SSI_CR0_FRF_M 0x00000030 // SSI Frame Format Select +#define SSI_CR0_FRF_MOTO 0x00000000 // Freescale SPI Frame Format +#define SSI_CR0_FRF_TI 0x00000010 // Texas Instruments Synchronous + // Serial Frame Format +#define SSI_CR0_FRF_NMW 0x00000020 // MICROWIRE Frame Format +#define SSI_CR0_DSS_M 0x0000000F // SSI Data Size Select +#define SSI_CR0_DSS_4 0x00000003 // 4-bit data +#define SSI_CR0_DSS_5 0x00000004 // 5-bit data +#define SSI_CR0_DSS_6 0x00000005 // 6-bit data +#define SSI_CR0_DSS_7 0x00000006 // 7-bit data +#define SSI_CR0_DSS_8 0x00000007 // 8-bit data +#define SSI_CR0_DSS_9 0x00000008 // 9-bit data +#define SSI_CR0_DSS_10 0x00000009 // 10-bit data +#define SSI_CR0_DSS_11 0x0000000A // 11-bit data +#define SSI_CR0_DSS_12 0x0000000B // 12-bit data +#define SSI_CR0_DSS_13 0x0000000C // 13-bit data +#define SSI_CR0_DSS_14 0x0000000D // 14-bit data +#define SSI_CR0_DSS_15 0x0000000E // 15-bit data +#define SSI_CR0_DSS_16 0x0000000F // 16-bit data +#define SSI_CR0_SCR_S 8 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_CR1 register. +// +//***************************************************************************** +#define SSI_CR1_SOD 0x00000008 // SSI Slave Mode Output Disable +#define SSI_CR1_MS 0x00000004 // SSI Master/Slave Select +#define SSI_CR1_SSE 0x00000002 // SSI Synchronous Serial Port + // Enable +#define SSI_CR1_LBM 0x00000001 // SSI Loopback Mode + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_DR register. +// +//***************************************************************************** +#define SSI_DR_DATA_M 0x0000FFFF // SSI Receive/Transmit Data +#define SSI_DR_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_SR register. +// +//***************************************************************************** +#define SSI_SR_BSY 0x00000010 // SSI Busy Bit +#define SSI_SR_RFF 0x00000008 // SSI Receive FIFO Full +#define SSI_SR_RNE 0x00000004 // SSI Receive FIFO Not Empty +#define SSI_SR_TNF 0x00000002 // SSI Transmit FIFO Not Full +#define SSI_SR_TFE 0x00000001 // SSI Transmit FIFO Empty + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_CPSR register. +// +//***************************************************************************** +#define SSI_CPSR_CPSDVSR_M 0x000000FF // SSI Clock Prescale Divisor +#define SSI_CPSR_CPSDVSR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_IM register. +// +//***************************************************************************** +#define SSI_IM_TXIM 0x00000008 // SSI Transmit FIFO Interrupt Mask +#define SSI_IM_RXIM 0x00000004 // SSI Receive FIFO Interrupt Mask +#define SSI_IM_RTIM 0x00000002 // SSI Receive Time-Out Interrupt + // Mask +#define SSI_IM_RORIM 0x00000001 // SSI Receive Overrun Interrupt + // Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_RIS register. +// +//***************************************************************************** +#define SSI_RIS_TXRIS 0x00000008 // SSI Transmit FIFO Raw Interrupt + // Status +#define SSI_RIS_RXRIS 0x00000004 // SSI Receive FIFO Raw Interrupt + // Status +#define SSI_RIS_RTRIS 0x00000002 // SSI Receive Time-Out Raw + // Interrupt Status +#define SSI_RIS_RORRIS 0x00000001 // SSI Receive Overrun Raw + // Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_MIS register. +// +//***************************************************************************** +#define SSI_MIS_TXMIS 0x00000008 // SSI Transmit FIFO Masked + // Interrupt Status +#define SSI_MIS_RXMIS 0x00000004 // SSI Receive FIFO Masked + // Interrupt Status +#define SSI_MIS_RTMIS 0x00000002 // SSI Receive Time-Out Masked + // Interrupt Status +#define SSI_MIS_RORMIS 0x00000001 // SSI Receive Overrun Masked + // Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the SSI_O_ICR register. +// +//***************************************************************************** +#define SSI_ICR_RTIC 0x00000002 // SSI Receive Time-Out Interrupt + // Clear +#define SSI_ICR_RORIC 0x00000001 // SSI Receive Overrun Interrupt + // Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_DR register. +// +//***************************************************************************** +#define UART_DR_OE 0x00000800 // UART Overrun Error +#define UART_DR_BE 0x00000400 // UART Break Error +#define UART_DR_PE 0x00000200 // UART Parity Error +#define UART_DR_FE 0x00000100 // UART Framing Error +#define UART_DR_DATA_M 0x000000FF // Data Transmitted or Received +#define UART_DR_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_RSR register. +// +//***************************************************************************** +#define UART_RSR_OE 0x00000008 // UART Overrun Error +#define UART_RSR_BE 0x00000004 // UART Break Error +#define UART_RSR_PE 0x00000002 // UART Parity Error +#define UART_RSR_FE 0x00000001 // UART Framing Error + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_ECR register. +// +//***************************************************************************** +#define UART_ECR_DATA_M 0x000000FF // Error Clear +#define UART_ECR_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_FR register. +// +//***************************************************************************** +#define UART_FR_TXFE 0x00000080 // UART Transmit FIFO Empty +#define UART_FR_RXFF 0x00000040 // UART Receive FIFO Full +#define UART_FR_TXFF 0x00000020 // UART Transmit FIFO Full +#define UART_FR_RXFE 0x00000010 // UART Receive FIFO Empty +#define UART_FR_BUSY 0x00000008 // UART Busy + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_ILPR register. +// +//***************************************************************************** +#define UART_ILPR_ILPDVSR_M 0x000000FF // IrDA Low-Power Divisor +#define UART_ILPR_ILPDVSR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_IBRD register. +// +//***************************************************************************** +#define UART_IBRD_DIVINT_M 0x0000FFFF // Integer Baud-Rate Divisor +#define UART_IBRD_DIVINT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_FBRD register. +// +//***************************************************************************** +#define UART_FBRD_DIVFRAC_M 0x0000003F // Fractional Baud-Rate Divisor +#define UART_FBRD_DIVFRAC_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_LCRH register. +// +//***************************************************************************** +#define UART_LCRH_SPS 0x00000080 // UART Stick Parity Select +#define UART_LCRH_WLEN_M 0x00000060 // UART Word Length +#define UART_LCRH_WLEN_5 0x00000000 // 5 bits (default) +#define UART_LCRH_WLEN_6 0x00000020 // 6 bits +#define UART_LCRH_WLEN_7 0x00000040 // 7 bits +#define UART_LCRH_WLEN_8 0x00000060 // 8 bits +#define UART_LCRH_FEN 0x00000010 // UART Enable FIFOs +#define UART_LCRH_STP2 0x00000008 // UART Two Stop Bits Select +#define UART_LCRH_EPS 0x00000004 // UART Even Parity Select +#define UART_LCRH_PEN 0x00000002 // UART Parity Enable +#define UART_LCRH_BRK 0x00000001 // UART Send Break + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_CTL register. +// +//***************************************************************************** +#define UART_CTL_RXE 0x00000200 // UART Receive Enable +#define UART_CTL_TXE 0x00000100 // UART Transmit Enable +#define UART_CTL_LBE 0x00000080 // UART Loop Back Enable +#define UART_CTL_SIRLP 0x00000004 // UART SIR Low-Power Mode +#define UART_CTL_SIREN 0x00000002 // UART SIR Enable +#define UART_CTL_UARTEN 0x00000001 // UART Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_IFLS register. +// +//***************************************************************************** +#define UART_IFLS_RX_M 0x00000038 // UART Receive Interrupt FIFO + // Level Select +#define UART_IFLS_RX1_8 0x00000000 // RX FIFO >= 1/8 full +#define UART_IFLS_RX2_8 0x00000008 // RX FIFO >= 1/4 full +#define UART_IFLS_RX4_8 0x00000010 // RX FIFO >= 1/2 full (default) +#define UART_IFLS_RX6_8 0x00000018 // RX FIFO >= 3/4 full +#define UART_IFLS_RX7_8 0x00000020 // RX FIFO >= 7/8 full +#define UART_IFLS_TX_M 0x00000007 // UART Transmit Interrupt FIFO + // Level Select +#define UART_IFLS_TX1_8 0x00000000 // TX FIFO <= 1/8 full +#define UART_IFLS_TX2_8 0x00000001 // TX FIFO <= 1/4 full +#define UART_IFLS_TX4_8 0x00000002 // TX FIFO <= 1/2 full (default) +#define UART_IFLS_TX6_8 0x00000003 // TX FIFO <= 3/4 full +#define UART_IFLS_TX7_8 0x00000004 // TX FIFO <= 7/8 full + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_IM register. +// +//***************************************************************************** +#define UART_IM_OEIM 0x00000400 // UART Overrun Error Interrupt + // Mask +#define UART_IM_BEIM 0x00000200 // UART Break Error Interrupt Mask +#define UART_IM_PEIM 0x00000100 // UART Parity Error Interrupt Mask +#define UART_IM_FEIM 0x00000080 // UART Framing Error Interrupt + // Mask +#define UART_IM_RTIM 0x00000040 // UART Receive Time-Out Interrupt + // Mask +#define UART_IM_TXIM 0x00000020 // UART Transmit Interrupt Mask +#define UART_IM_RXIM 0x00000010 // UART Receive Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_RIS register. +// +//***************************************************************************** +#define UART_RIS_OERIS 0x00000400 // UART Overrun Error Raw Interrupt + // Status +#define UART_RIS_BERIS 0x00000200 // UART Break Error Raw Interrupt + // Status +#define UART_RIS_PERIS 0x00000100 // UART Parity Error Raw Interrupt + // Status +#define UART_RIS_FERIS 0x00000080 // UART Framing Error Raw Interrupt + // Status +#define UART_RIS_RTRIS 0x00000040 // UART Receive Time-Out Raw + // Interrupt Status +#define UART_RIS_TXRIS 0x00000020 // UART Transmit Raw Interrupt + // Status +#define UART_RIS_RXRIS 0x00000010 // UART Receive Raw Interrupt + // Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_MIS register. +// +//***************************************************************************** +#define UART_MIS_OEMIS 0x00000400 // UART Overrun Error Masked + // Interrupt Status +#define UART_MIS_BEMIS 0x00000200 // UART Break Error Masked + // Interrupt Status +#define UART_MIS_PEMIS 0x00000100 // UART Parity Error Masked + // Interrupt Status +#define UART_MIS_FEMIS 0x00000080 // UART Framing Error Masked + // Interrupt Status +#define UART_MIS_RTMIS 0x00000040 // UART Receive Time-Out Masked + // Interrupt Status +#define UART_MIS_TXMIS 0x00000020 // UART Transmit Masked Interrupt + // Status +#define UART_MIS_RXMIS 0x00000010 // UART Receive Masked Interrupt + // Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the UART_O_ICR register. +// +//***************************************************************************** +#define UART_ICR_OEIC 0x00000400 // Overrun Error Interrupt Clear +#define UART_ICR_BEIC 0x00000200 // Break Error Interrupt Clear +#define UART_ICR_PEIC 0x00000100 // Parity Error Interrupt Clear +#define UART_ICR_FEIC 0x00000080 // Framing Error Interrupt Clear +#define UART_ICR_RTIC 0x00000040 // Receive Time-Out Interrupt Clear +#define UART_ICR_TXIC 0x00000020 // Transmit Interrupt Clear +#define UART_ICR_RXIC 0x00000010 // Receive Interrupt Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MSA register. +// +//***************************************************************************** +#define I2C_MSA_SA_M 0x000000FE // I2C Slave Address +#define I2C_MSA_RS 0x00000001 // Receive not send +#define I2C_MSA_SA_S 1 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_SOAR register. +// +//***************************************************************************** +#define I2C_SOAR_OAR_M 0x0000007F // I2C Slave Own Address +#define I2C_SOAR_OAR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_SCSR register. +// +//***************************************************************************** +#define I2C_SCSR_FBR 0x00000004 // First Byte Received +#define I2C_SCSR_TREQ 0x00000002 // Transmit Request +#define I2C_SCSR_DA 0x00000001 // Device Active +#define I2C_SCSR_RREQ 0x00000001 // Receive Request + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MCS register. +// +//***************************************************************************** +#define I2C_MCS_BUSBSY 0x00000040 // Bus Busy +#define I2C_MCS_IDLE 0x00000020 // I2C Idle +#define I2C_MCS_ARBLST 0x00000010 // Arbitration Lost +#define I2C_MCS_ACK 0x00000008 // Data Acknowledge Enable +#define I2C_MCS_DATACK 0x00000008 // Acknowledge Data +#define I2C_MCS_ADRACK 0x00000004 // Acknowledge Address +#define I2C_MCS_STOP 0x00000004 // Generate STOP +#define I2C_MCS_START 0x00000002 // Generate START +#define I2C_MCS_ERROR 0x00000002 // Error +#define I2C_MCS_RUN 0x00000001 // I2C Master Enable +#define I2C_MCS_BUSY 0x00000001 // I2C Busy + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_SDR register. +// +//***************************************************************************** +#define I2C_SDR_DATA_M 0x000000FF // Data for Transfer +#define I2C_SDR_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MDR register. +// +//***************************************************************************** +#define I2C_MDR_DATA_M 0x000000FF // Data Transferred +#define I2C_MDR_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MTPR register. +// +//***************************************************************************** +#define I2C_MTPR_TPR_M 0x0000007F // SCL Clock Period +#define I2C_MTPR_TPR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_SIMR register. +// +//***************************************************************************** +#define I2C_SIMR_DATAIM 0x00000001 // Data Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_SRIS register. +// +//***************************************************************************** +#define I2C_SRIS_DATARIS 0x00000001 // Data Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MIMR register. +// +//***************************************************************************** +#define I2C_MIMR_IM 0x00000001 // Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MRIS register. +// +//***************************************************************************** +#define I2C_MRIS_RIS 0x00000001 // Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_SMIS register. +// +//***************************************************************************** +#define I2C_SMIS_DATAMIS 0x00000001 // Data Masked Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_SICR register. +// +//***************************************************************************** +#define I2C_SICR_DATAIC 0x00000001 // Data Interrupt Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MMIS register. +// +//***************************************************************************** +#define I2C_MMIS_MIS 0x00000001 // Masked Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MICR register. +// +//***************************************************************************** +#define I2C_MICR_IC 0x00000001 // Interrupt Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the I2C_O_MCR register. +// +//***************************************************************************** +#define I2C_MCR_SFE 0x00000020 // I2C Slave Function Enable +#define I2C_MCR_MFE 0x00000010 // I2C Master Function Enable +#define I2C_MCR_LPBK 0x00000001 // I2C Loopback + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_CTL register. +// +//***************************************************************************** +#define PWM_CTL_GLOBALSYNC2 0x00000004 // Update PWM Generator 2 +#define PWM_CTL_GLOBALSYNC1 0x00000002 // Update PWM Generator 1 +#define PWM_CTL_GLOBALSYNC0 0x00000001 // Update PWM Generator 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_SYNC register. +// +//***************************************************************************** +#define PWM_SYNC_SYNC2 0x00000004 // Reset Generator 2 Counter +#define PWM_SYNC_SYNC1 0x00000002 // Reset Generator 1 Counter +#define PWM_SYNC_SYNC0 0x00000001 // Reset Generator 0 Counter + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_ENABLE register. +// +//***************************************************************************** +#define PWM_ENABLE_PWM5EN 0x00000020 // PWM5 Output Enable +#define PWM_ENABLE_PWM4EN 0x00000010 // PWM4 Output Enable +#define PWM_ENABLE_PWM3EN 0x00000008 // PWM3 Output Enable +#define PWM_ENABLE_PWM2EN 0x00000004 // PWM2 Output Enable +#define PWM_ENABLE_PWM1EN 0x00000002 // PWM1 Output Enable +#define PWM_ENABLE_PWM0EN 0x00000001 // PWM0 Output Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_INVERT register. +// +//***************************************************************************** +#define PWM_INVERT_PWM5INV 0x00000020 // Invert PWM5 Signal +#define PWM_INVERT_PWM4INV 0x00000010 // Invert PWM4 Signal +#define PWM_INVERT_PWM3INV 0x00000008 // Invert PWM3 Signal +#define PWM_INVERT_PWM2INV 0x00000004 // Invert PWM2 Signal +#define PWM_INVERT_PWM1INV 0x00000002 // Invert PWM1 Signal +#define PWM_INVERT_PWM0INV 0x00000001 // Invert PWM0 Signal + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_FAULT register. +// +//***************************************************************************** +#define PWM_FAULT_FAULT5 0x00000020 // PWM5 Fault +#define PWM_FAULT_FAULT4 0x00000010 // PWM4 Fault +#define PWM_FAULT_FAULT3 0x00000008 // PWM3 Fault +#define PWM_FAULT_FAULT2 0x00000004 // PWM2 Fault +#define PWM_FAULT_FAULT1 0x00000002 // PWM1 Fault +#define PWM_FAULT_FAULT0 0x00000001 // PWM0 Fault + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_INTEN register. +// +//***************************************************************************** +#define PWM_INTEN_INTFAULT 0x00010000 // Fault Interrupt Enable +#define PWM_INTEN_INTPWM2 0x00000004 // PWM2 Interrupt Enable +#define PWM_INTEN_INTPWM1 0x00000002 // PWM1 Interrupt Enable +#define PWM_INTEN_INTPWM0 0x00000001 // PWM0 Interrupt Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_RIS register. +// +//***************************************************************************** +#define PWM_RIS_INTFAULT 0x00010000 // Fault Interrupt Asserted +#define PWM_RIS_INTPWM2 0x00000004 // PWM2 Interrupt Asserted +#define PWM_RIS_INTPWM1 0x00000002 // PWM1 Interrupt Asserted +#define PWM_RIS_INTPWM0 0x00000001 // PWM0 Interrupt Asserted + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_ISC register. +// +//***************************************************************************** +#define PWM_ISC_INTFAULT 0x00010000 // Fault Interrupt Asserted +#define PWM_ISC_INTPWM2 0x00000004 // PWM2 Interrupt Status +#define PWM_ISC_INTPWM1 0x00000002 // PWM1 Interrupt Status +#define PWM_ISC_INTPWM0 0x00000001 // PWM0 Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_STATUS register. +// +//***************************************************************************** +#define PWM_STATUS_FAULT 0x00000001 // Fault Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_CTL register. +// +//***************************************************************************** +#define PWM_X_CTL_CMPBUPD 0x00000020 // Comparator B Update Mode +#define PWM_X_CTL_CMPAUPD 0x00000010 // Comparator A Update Mode +#define PWM_X_CTL_LOADUPD 0x00000008 // Load Register Update Mode +#define PWM_X_CTL_DEBUG 0x00000004 // Debug Mode +#define PWM_X_CTL_MODE 0x00000002 // Counter Mode +#define PWM_X_CTL_ENABLE 0x00000001 // PWM Block Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_INTEN register. +// +//***************************************************************************** +#define PWM_X_INTEN_TRCMPBD 0x00002000 // Trigger for Counter=PWMnCMPB + // Down +#define PWM_X_INTEN_TRCMPBU 0x00001000 // Trigger for Counter=PWMnCMPB Up +#define PWM_X_INTEN_TRCMPAD 0x00000800 // Trigger for Counter=PWMnCMPA + // Down +#define PWM_X_INTEN_TRCMPAU 0x00000400 // Trigger for Counter=PWMnCMPA Up +#define PWM_X_INTEN_TRCNTLOAD 0x00000200 // Trigger for Counter=PWMnLOAD +#define PWM_X_INTEN_TRCNTZERO 0x00000100 // Trigger for Counter=0 +#define PWM_X_INTEN_INTCMPBD 0x00000020 // Interrupt for Counter=PWMnCMPB + // Down +#define PWM_X_INTEN_INTCMPBU 0x00000010 // Interrupt for Counter=PWMnCMPB + // Up +#define PWM_X_INTEN_INTCMPAD 0x00000008 // Interrupt for Counter=PWMnCMPA + // Down +#define PWM_X_INTEN_INTCMPAU 0x00000004 // Interrupt for Counter=PWMnCMPA + // Up +#define PWM_X_INTEN_INTCNTLOAD 0x00000002 // Interrupt for Counter=PWMnLOAD +#define PWM_X_INTEN_INTCNTZERO 0x00000001 // Interrupt for Counter=0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_RIS register. +// +//***************************************************************************** +#define PWM_X_RIS_INTCMPBD 0x00000020 // Comparator B Down Interrupt + // Status +#define PWM_X_RIS_INTCMPBU 0x00000010 // Comparator B Up Interrupt Status +#define PWM_X_RIS_INTCMPAD 0x00000008 // Comparator A Down Interrupt + // Status +#define PWM_X_RIS_INTCMPAU 0x00000004 // Comparator A Up Interrupt Status +#define PWM_X_RIS_INTCNTLOAD 0x00000002 // Counter=Load Interrupt Status +#define PWM_X_RIS_INTCNTZERO 0x00000001 // Counter=0 Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_ISC register. +// +//***************************************************************************** +#define PWM_X_ISC_INTCMPBD 0x00000020 // Comparator B Down Interrupt +#define PWM_X_ISC_INTCMPBU 0x00000010 // Comparator B Up Interrupt +#define PWM_X_ISC_INTCMPAD 0x00000008 // Comparator A Down Interrupt +#define PWM_X_ISC_INTCMPAU 0x00000004 // Comparator A Up Interrupt +#define PWM_X_ISC_INTCNTLOAD 0x00000002 // Counter=Load Interrupt +#define PWM_X_ISC_INTCNTZERO 0x00000001 // Counter=0 Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_LOAD register. +// +//***************************************************************************** +#define PWM_X_LOAD_M 0x0000FFFF // Counter Load Value +#define PWM_X_LOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_COUNT register. +// +//***************************************************************************** +#define PWM_X_COUNT_M 0x0000FFFF // Counter Value +#define PWM_X_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_CMPA register. +// +//***************************************************************************** +#define PWM_X_CMPA_M 0x0000FFFF // Comparator A Value +#define PWM_X_CMPA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_CMPB register. +// +//***************************************************************************** +#define PWM_X_CMPB_M 0x0000FFFF // Comparator B Value +#define PWM_X_CMPB_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_GENA register. +// +//***************************************************************************** +#define PWM_X_GENA_ACTCMPBD_M 0x00000C00 // Action for Comparator B Down +#define PWM_X_GENA_ACTCMPBD_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENA_ACTCMPBD_INV 0x00000400 // Invert pwmA +#define PWM_X_GENA_ACTCMPBD_ZERO \ + 0x00000800 // Drive pwmA Low +#define PWM_X_GENA_ACTCMPBD_ONE 0x00000C00 // Drive pwmA High +#define PWM_X_GENA_ACTCMPBU_M 0x00000300 // Action for Comparator B Up +#define PWM_X_GENA_ACTCMPBU_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENA_ACTCMPBU_INV 0x00000100 // Invert pwmA +#define PWM_X_GENA_ACTCMPBU_ZERO \ + 0x00000200 // Drive pwmA Low +#define PWM_X_GENA_ACTCMPBU_ONE 0x00000300 // Drive pwmA High +#define PWM_X_GENA_ACTCMPAD_M 0x000000C0 // Action for Comparator A Down +#define PWM_X_GENA_ACTCMPAD_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENA_ACTCMPAD_INV 0x00000040 // Invert pwmA +#define PWM_X_GENA_ACTCMPAD_ZERO \ + 0x00000080 // Drive pwmA Low +#define PWM_X_GENA_ACTCMPAD_ONE 0x000000C0 // Drive pwmA High +#define PWM_X_GENA_ACTCMPAU_M 0x00000030 // Action for Comparator A Up +#define PWM_X_GENA_ACTCMPAU_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENA_ACTCMPAU_INV 0x00000010 // Invert pwmA +#define PWM_X_GENA_ACTCMPAU_ZERO \ + 0x00000020 // Drive pwmA Low +#define PWM_X_GENA_ACTCMPAU_ONE 0x00000030 // Drive pwmA High +#define PWM_X_GENA_ACTLOAD_M 0x0000000C // Action for Counter=LOAD +#define PWM_X_GENA_ACTLOAD_NONE 0x00000000 // Do nothing +#define PWM_X_GENA_ACTLOAD_INV 0x00000004 // Invert pwmA +#define PWM_X_GENA_ACTLOAD_ZERO 0x00000008 // Drive pwmA Low +#define PWM_X_GENA_ACTLOAD_ONE 0x0000000C // Drive pwmA High +#define PWM_X_GENA_ACTZERO_M 0x00000003 // Action for Counter=0 +#define PWM_X_GENA_ACTZERO_NONE 0x00000000 // Do nothing +#define PWM_X_GENA_ACTZERO_INV 0x00000001 // Invert pwmA +#define PWM_X_GENA_ACTZERO_ZERO 0x00000002 // Drive pwmA Low +#define PWM_X_GENA_ACTZERO_ONE 0x00000003 // Drive pwmA High + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_GENB register. +// +//***************************************************************************** +#define PWM_X_GENB_ACTCMPBD_M 0x00000C00 // Action for Comparator B Down +#define PWM_X_GENB_ACTCMPBD_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENB_ACTCMPBD_INV 0x00000400 // Invert pwmB +#define PWM_X_GENB_ACTCMPBD_ZERO \ + 0x00000800 // Drive pwmB Low +#define PWM_X_GENB_ACTCMPBD_ONE 0x00000C00 // Drive pwmB High +#define PWM_X_GENB_ACTCMPBU_M 0x00000300 // Action for Comparator B Up +#define PWM_X_GENB_ACTCMPBU_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENB_ACTCMPBU_INV 0x00000100 // Invert pwmB +#define PWM_X_GENB_ACTCMPBU_ZERO \ + 0x00000200 // Drive pwmB Low +#define PWM_X_GENB_ACTCMPBU_ONE 0x00000300 // Drive pwmB High +#define PWM_X_GENB_ACTCMPAD_M 0x000000C0 // Action for Comparator A Down +#define PWM_X_GENB_ACTCMPAD_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENB_ACTCMPAD_INV 0x00000040 // Invert pwmB +#define PWM_X_GENB_ACTCMPAD_ZERO \ + 0x00000080 // Drive pwmB Low +#define PWM_X_GENB_ACTCMPAD_ONE 0x000000C0 // Drive pwmB High +#define PWM_X_GENB_ACTCMPAU_M 0x00000030 // Action for Comparator A Up +#define PWM_X_GENB_ACTCMPAU_NONE \ + 0x00000000 // Do nothing +#define PWM_X_GENB_ACTCMPAU_INV 0x00000010 // Invert pwmB +#define PWM_X_GENB_ACTCMPAU_ZERO \ + 0x00000020 // Drive pwmB Low +#define PWM_X_GENB_ACTCMPAU_ONE 0x00000030 // Drive pwmB High +#define PWM_X_GENB_ACTLOAD_M 0x0000000C // Action for Counter=LOAD +#define PWM_X_GENB_ACTLOAD_NONE 0x00000000 // Do nothing +#define PWM_X_GENB_ACTLOAD_INV 0x00000004 // Invert pwmB +#define PWM_X_GENB_ACTLOAD_ZERO 0x00000008 // Drive pwmB Low +#define PWM_X_GENB_ACTLOAD_ONE 0x0000000C // Drive pwmB High +#define PWM_X_GENB_ACTZERO_M 0x00000003 // Action for Counter=0 +#define PWM_X_GENB_ACTZERO_NONE 0x00000000 // Do nothing +#define PWM_X_GENB_ACTZERO_INV 0x00000001 // Invert pwmB +#define PWM_X_GENB_ACTZERO_ZERO 0x00000002 // Drive pwmB Low +#define PWM_X_GENB_ACTZERO_ONE 0x00000003 // Drive pwmB High + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_DBCTL register. +// +//***************************************************************************** +#define PWM_X_DBCTL_ENABLE 0x00000001 // Dead-Band Generator Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_DBRISE register. +// +//***************************************************************************** +#define PWM_X_DBRISE_DELAY_M 0x00000FFF // Dead-Band Rise Delay +#define PWM_X_DBRISE_DELAY_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PWM_O_X_DBFALL register. +// +//***************************************************************************** +#define PWM_X_DBFALL_DELAY_M 0x00000FFF // Dead-Band Fall Delay +#define PWM_X_DBFALL_DELAY_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_CTL register. +// +//***************************************************************************** +#define QEI_CTL_STALLEN 0x00001000 // Stall QEI +#define QEI_CTL_INVI 0x00000800 // Invert Index Pulse +#define QEI_CTL_INVB 0x00000400 // Invert PhB +#define QEI_CTL_INVA 0x00000200 // Invert PhA +#define QEI_CTL_VELDIV_M 0x000001C0 // Predivide Velocity +#define QEI_CTL_VELDIV_1 0x00000000 // QEI clock /1 +#define QEI_CTL_VELDIV_2 0x00000040 // QEI clock /2 +#define QEI_CTL_VELDIV_4 0x00000080 // QEI clock /4 +#define QEI_CTL_VELDIV_8 0x000000C0 // QEI clock /8 +#define QEI_CTL_VELDIV_16 0x00000100 // QEI clock /16 +#define QEI_CTL_VELDIV_32 0x00000140 // QEI clock /32 +#define QEI_CTL_VELDIV_64 0x00000180 // QEI clock /64 +#define QEI_CTL_VELDIV_128 0x000001C0 // QEI clock /128 +#define QEI_CTL_VELEN 0x00000020 // Capture Velocity +#define QEI_CTL_RESMODE 0x00000010 // Reset Mode +#define QEI_CTL_CAPMODE 0x00000008 // Capture Mode +#define QEI_CTL_SIGMODE 0x00000004 // Signal Mode +#define QEI_CTL_SWAP 0x00000002 // Swap Signals +#define QEI_CTL_ENABLE 0x00000001 // Enable QEI + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_STAT register. +// +//***************************************************************************** +#define QEI_STAT_DIRECTION 0x00000002 // Direction of Rotation +#define QEI_STAT_ERROR 0x00000001 // Error Detected + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_POS register. +// +//***************************************************************************** +#define QEI_POS_M 0xFFFFFFFF // Current Position Integrator + // Value +#define QEI_POS_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_MAXPOS register. +// +//***************************************************************************** +#define QEI_MAXPOS_M 0xFFFFFFFF // Maximum Position Integrator + // Value +#define QEI_MAXPOS_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_LOAD register. +// +//***************************************************************************** +#define QEI_LOAD_M 0xFFFFFFFF // Velocity Timer Load Value +#define QEI_LOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_TIME register. +// +//***************************************************************************** +#define QEI_TIME_M 0xFFFFFFFF // Velocity Timer Current Value +#define QEI_TIME_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_COUNT register. +// +//***************************************************************************** +#define QEI_COUNT_M 0xFFFFFFFF // Velocity Pulse Count +#define QEI_COUNT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_SPEED register. +// +//***************************************************************************** +#define QEI_SPEED_M 0xFFFFFFFF // Velocity +#define QEI_SPEED_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_INTEN register. +// +//***************************************************************************** +#define QEI_INTEN_ERROR 0x00000008 // Phase Error Interrupt Enable +#define QEI_INTEN_DIR 0x00000004 // Direction Change Interrupt + // Enable +#define QEI_INTEN_TIMER 0x00000002 // Timer Expires Interrupt Enable +#define QEI_INTEN_INDEX 0x00000001 // Index Pulse Detected Interrupt + // Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_RIS register. +// +//***************************************************************************** +#define QEI_RIS_ERROR 0x00000008 // Phase Error Detected +#define QEI_RIS_DIR 0x00000004 // Direction Change Detected +#define QEI_RIS_TIMER 0x00000002 // Velocity Timer Expired +#define QEI_RIS_INDEX 0x00000001 // Index Pulse Asserted + +//***************************************************************************** +// +// The following are defines for the bit fields in the QEI_O_ISC register. +// +//***************************************************************************** +#define QEI_ISC_ERROR 0x00000008 // Phase Error Interrupt +#define QEI_ISC_DIR 0x00000004 // Direction Change Interrupt +#define QEI_ISC_TIMER 0x00000002 // Velocity Timer Expired Interrupt +#define QEI_ISC_INDEX 0x00000001 // Index Pulse Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_CFG register. +// +//***************************************************************************** +#define TIMER_CFG_M 0x00000007 // GPTM Configuration +#define TIMER_CFG_32_BIT_TIMER 0x00000000 // 32-bit timer configuration +#define TIMER_CFG_32_BIT_RTC 0x00000001 // 32-bit real-time clock (RTC) + // counter configuration +#define TIMER_CFG_16_BIT 0x00000004 // 16-bit timer configuration. The + // function is controlled by bits + // 1:0 of GPTMTAMR and GPTMTBMR + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TAMR register. +// +//***************************************************************************** +#define TIMER_TAMR_TAAMS 0x00000008 // GPTM Timer A Alternate Mode + // Select +#define TIMER_TAMR_TACMR 0x00000004 // GPTM Timer A Capture Mode +#define TIMER_TAMR_TAMR_M 0x00000003 // GPTM Timer A Mode +#define TIMER_TAMR_TAMR_1_SHOT 0x00000001 // One-Shot Timer mode +#define TIMER_TAMR_TAMR_PERIOD 0x00000002 // Periodic Timer mode +#define TIMER_TAMR_TAMR_CAP 0x00000003 // Capture mode + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TBMR register. +// +//***************************************************************************** +#define TIMER_TBMR_TBAMS 0x00000008 // GPTM Timer B Alternate Mode + // Select +#define TIMER_TBMR_TBCMR 0x00000004 // GPTM Timer B Capture Mode +#define TIMER_TBMR_TBMR_M 0x00000003 // GPTM Timer B Mode +#define TIMER_TBMR_TBMR_1_SHOT 0x00000001 // One-Shot Timer mode +#define TIMER_TBMR_TBMR_PERIOD 0x00000002 // Periodic Timer mode +#define TIMER_TBMR_TBMR_CAP 0x00000003 // Capture mode + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_CTL register. +// +//***************************************************************************** +#define TIMER_CTL_TBPWML 0x00004000 // GPTM Timer B PWM Output Level +#define TIMER_CTL_TBOTE 0x00002000 // GPTM Timer B Output Trigger + // Enable +#define TIMER_CTL_TBEVENT_M 0x00000C00 // GPTM Timer B Event Mode +#define TIMER_CTL_TBEVENT_POS 0x00000000 // Positive edge +#define TIMER_CTL_TBEVENT_NEG 0x00000400 // Negative edge +#define TIMER_CTL_TBEVENT_BOTH 0x00000C00 // Both edges +#define TIMER_CTL_TBSTALL 0x00000200 // GPTM Timer B Stall Enable +#define TIMER_CTL_TBEN 0x00000100 // GPTM Timer B Enable +#define TIMER_CTL_TAPWML 0x00000040 // GPTM Timer A PWM Output Level +#define TIMER_CTL_TAOTE 0x00000020 // GPTM Timer A Output Trigger + // Enable +#define TIMER_CTL_RTCEN 0x00000010 // GPTM RTC Enable +#define TIMER_CTL_TAEVENT_M 0x0000000C // GPTM Timer A Event Mode +#define TIMER_CTL_TAEVENT_POS 0x00000000 // Positive edge +#define TIMER_CTL_TAEVENT_NEG 0x00000004 // Negative edge +#define TIMER_CTL_TAEVENT_BOTH 0x0000000C // Both edges +#define TIMER_CTL_TASTALL 0x00000002 // GPTM Timer A Stall Enable +#define TIMER_CTL_TAEN 0x00000001 // GPTM Timer A Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_IMR register. +// +//***************************************************************************** +#define TIMER_IMR_CBEIM 0x00000400 // GPTM Capture B Event Interrupt + // Mask +#define TIMER_IMR_CBMIM 0x00000200 // GPTM Capture B Match Interrupt + // Mask +#define TIMER_IMR_TBTOIM 0x00000100 // GPTM Timer B Time-Out Interrupt + // Mask +#define TIMER_IMR_RTCIM 0x00000008 // GPTM RTC Interrupt Mask +#define TIMER_IMR_CAEIM 0x00000004 // GPTM Capture A Event Interrupt + // Mask +#define TIMER_IMR_CAMIM 0x00000002 // GPTM Capture A Match Interrupt + // Mask +#define TIMER_IMR_TATOIM 0x00000001 // GPTM Timer A Time-Out Interrupt + // Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_RIS register. +// +//***************************************************************************** +#define TIMER_RIS_CBERIS 0x00000400 // GPTM Capture B Event Raw + // Interrupt +#define TIMER_RIS_CBMRIS 0x00000200 // GPTM Capture B Match Raw + // Interrupt +#define TIMER_RIS_TBTORIS 0x00000100 // GPTM Timer B Time-Out Raw + // Interrupt +#define TIMER_RIS_RTCRIS 0x00000008 // GPTM RTC Raw Interrupt +#define TIMER_RIS_CAERIS 0x00000004 // GPTM Capture A Event Raw + // Interrupt +#define TIMER_RIS_CAMRIS 0x00000002 // GPTM Capture A Match Raw + // Interrupt +#define TIMER_RIS_TATORIS 0x00000001 // GPTM Timer A Time-Out Raw + // Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_MIS register. +// +//***************************************************************************** +#define TIMER_MIS_CBEMIS 0x00000400 // GPTM Capture B Event Masked + // Interrupt +#define TIMER_MIS_CBMMIS 0x00000200 // GPTM Capture B Match Masked + // Interrupt +#define TIMER_MIS_TBTOMIS 0x00000100 // GPTM Timer B Time-Out Masked + // Interrupt +#define TIMER_MIS_RTCMIS 0x00000008 // GPTM RTC Masked Interrupt +#define TIMER_MIS_CAEMIS 0x00000004 // GPTM Capture A Event Masked + // Interrupt +#define TIMER_MIS_CAMMIS 0x00000002 // GPTM Capture A Match Masked + // Interrupt +#define TIMER_MIS_TATOMIS 0x00000001 // GPTM Timer A Time-Out Masked + // Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_ICR register. +// +//***************************************************************************** +#define TIMER_ICR_CBECINT 0x00000400 // GPTM Capture B Event Interrupt + // Clear +#define TIMER_ICR_CBMCINT 0x00000200 // GPTM Capture B Match Interrupt + // Clear +#define TIMER_ICR_TBTOCINT 0x00000100 // GPTM Timer B Time-Out Interrupt + // Clear +#define TIMER_ICR_RTCCINT 0x00000008 // GPTM RTC Interrupt Clear +#define TIMER_ICR_CAECINT 0x00000004 // GPTM Capture A Event Interrupt + // Clear +#define TIMER_ICR_CAMCINT 0x00000002 // GPTM Capture A Match Interrupt + // Clear +#define TIMER_ICR_TATOCINT 0x00000001 // GPTM Timer A Time-Out Raw + // Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TAILR register. +// +//***************************************************************************** +#define TIMER_TAILR_TAILRH_M 0xFFFF0000 // GPTM Timer A Interval Load + // Register High +#define TIMER_TAILR_TAILRL_M 0x0000FFFF // GPTM Timer A Interval Load + // Register Low +#define TIMER_TAILR_TAILRH_S 16 +#define TIMER_TAILR_TAILRL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TBILR register. +// +//***************************************************************************** +#define TIMER_TBILR_TBILRL_M 0x0000FFFF // GPTM Timer B Interval Load + // Register +#define TIMER_TBILR_TBILRL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TAMATCHR +// register. +// +//***************************************************************************** +#define TIMER_TAMATCHR_TAMRH_M 0xFFFF0000 // GPTM Timer A Match Register High +#define TIMER_TAMATCHR_TAMRL_M 0x0000FFFF // GPTM Timer A Match Register Low +#define TIMER_TAMATCHR_TAMRH_S 16 +#define TIMER_TAMATCHR_TAMRL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TBMATCHR +// register. +// +//***************************************************************************** +#define TIMER_TBMATCHR_TBMRL_M 0x0000FFFF // GPTM Timer B Match Register Low +#define TIMER_TBMATCHR_TBMRL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TAPR register. +// +//***************************************************************************** +#define TIMER_TAPR_TAPSR_M 0x000000FF // GPTM Timer A Prescale +#define TIMER_TAPR_TAPSR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TBPR register. +// +//***************************************************************************** +#define TIMER_TBPR_TBPSR_M 0x000000FF // GPTM Timer B Prescale +#define TIMER_TBPR_TBPSR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TAPMR register. +// +//***************************************************************************** +#define TIMER_TAPMR_TAPSMR_M 0x000000FF // GPTM TimerA Prescale Match +#define TIMER_TAPMR_TAPSMR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TBPMR register. +// +//***************************************************************************** +#define TIMER_TBPMR_TBPSMR_M 0x000000FF // GPTM TimerB Prescale Match +#define TIMER_TBPMR_TBPSMR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TAR register. +// +//***************************************************************************** +#define TIMER_TAR_TARH_M 0xFFFF0000 // GPTM Timer A Register High +#define TIMER_TAR_TARL_M 0x0000FFFF // GPTM Timer A Register Low +#define TIMER_TAR_TARH_S 16 +#define TIMER_TAR_TARL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the TIMER_O_TBR register. +// +//***************************************************************************** +#define TIMER_TBR_TBRL_M 0x0000FFFF // GPTM Timer B +#define TIMER_TBR_TBRL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_ACTSS register. +// +//***************************************************************************** +#define ADC_ACTSS_ASEN3 0x00000008 // ADC SS3 Enable +#define ADC_ACTSS_ASEN2 0x00000004 // ADC SS2 Enable +#define ADC_ACTSS_ASEN1 0x00000002 // ADC SS1 Enable +#define ADC_ACTSS_ASEN0 0x00000001 // ADC SS0 Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_RIS register. +// +//***************************************************************************** +#define ADC_RIS_INR3 0x00000008 // SS3 Raw Interrupt Status +#define ADC_RIS_INR2 0x00000004 // SS2 Raw Interrupt Status +#define ADC_RIS_INR1 0x00000002 // SS1 Raw Interrupt Status +#define ADC_RIS_INR0 0x00000001 // SS0 Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_IM register. +// +//***************************************************************************** +#define ADC_IM_MASK3 0x00000008 // SS3 Interrupt Mask +#define ADC_IM_MASK2 0x00000004 // SS2 Interrupt Mask +#define ADC_IM_MASK1 0x00000002 // SS1 Interrupt Mask +#define ADC_IM_MASK0 0x00000001 // SS0 Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_ISC register. +// +//***************************************************************************** +#define ADC_ISC_IN3 0x00000008 // SS3 Interrupt Status and Clear +#define ADC_ISC_IN2 0x00000004 // SS2 Interrupt Status and Clear +#define ADC_ISC_IN1 0x00000002 // SS1 Interrupt Status and Clear +#define ADC_ISC_IN0 0x00000001 // SS0 Interrupt Status and Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_OSTAT register. +// +//***************************************************************************** +#define ADC_OSTAT_OV3 0x00000008 // SS3 FIFO Overflow +#define ADC_OSTAT_OV2 0x00000004 // SS2 FIFO Overflow +#define ADC_OSTAT_OV1 0x00000002 // SS1 FIFO Overflow +#define ADC_OSTAT_OV0 0x00000001 // SS0 FIFO Overflow + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_EMUX register. +// +//***************************************************************************** +#define ADC_EMUX_EM3_M 0x0000F000 // SS3 Trigger Select +#define ADC_EMUX_EM3_PROCESSOR 0x00000000 // Processor (default) +#define ADC_EMUX_EM3_COMP0 0x00001000 // Analog Comparator 0 +#define ADC_EMUX_EM3_COMP1 0x00002000 // Analog Comparator 1 +#define ADC_EMUX_EM3_EXTERNAL 0x00004000 // External (GPIO PB4) +#define ADC_EMUX_EM3_TIMER 0x00005000 // Timer +#define ADC_EMUX_EM3_PWM0 0x00006000 // PWM0 +#define ADC_EMUX_EM3_PWM1 0x00007000 // PWM1 +#define ADC_EMUX_EM3_PWM2 0x00008000 // PWM2 +#define ADC_EMUX_EM3_ALWAYS 0x0000F000 // Always (continuously sample) +#define ADC_EMUX_EM2_M 0x00000F00 // SS2 Trigger Select +#define ADC_EMUX_EM2_PROCESSOR 0x00000000 // Processor (default) +#define ADC_EMUX_EM2_COMP0 0x00000100 // Analog Comparator 0 +#define ADC_EMUX_EM2_COMP1 0x00000200 // Analog Comparator 1 +#define ADC_EMUX_EM2_EXTERNAL 0x00000400 // External (GPIO PB4) +#define ADC_EMUX_EM2_TIMER 0x00000500 // Timer +#define ADC_EMUX_EM2_PWM0 0x00000600 // PWM0 +#define ADC_EMUX_EM2_PWM1 0x00000700 // PWM1 +#define ADC_EMUX_EM2_PWM2 0x00000800 // PWM2 +#define ADC_EMUX_EM2_ALWAYS 0x00000F00 // Always (continuously sample) +#define ADC_EMUX_EM1_M 0x000000F0 // SS1 Trigger Select +#define ADC_EMUX_EM1_PROCESSOR 0x00000000 // Processor (default) +#define ADC_EMUX_EM1_COMP0 0x00000010 // Analog Comparator 0 +#define ADC_EMUX_EM1_COMP1 0x00000020 // Analog Comparator 1 +#define ADC_EMUX_EM1_EXTERNAL 0x00000040 // External (GPIO PB4) +#define ADC_EMUX_EM1_TIMER 0x00000050 // Timer +#define ADC_EMUX_EM1_PWM0 0x00000060 // PWM0 +#define ADC_EMUX_EM1_PWM1 0x00000070 // PWM1 +#define ADC_EMUX_EM1_PWM2 0x00000080 // PWM2 +#define ADC_EMUX_EM1_ALWAYS 0x000000F0 // Always (continuously sample) +#define ADC_EMUX_EM0_M 0x0000000F // SS0 Trigger Select +#define ADC_EMUX_EM0_PROCESSOR 0x00000000 // Processor (default) +#define ADC_EMUX_EM0_COMP0 0x00000001 // Analog Comparator 0 +#define ADC_EMUX_EM0_COMP1 0x00000002 // Analog Comparator 1 +#define ADC_EMUX_EM0_EXTERNAL 0x00000004 // External (GPIO PB4) +#define ADC_EMUX_EM0_TIMER 0x00000005 // Timer +#define ADC_EMUX_EM0_PWM0 0x00000006 // PWM0 +#define ADC_EMUX_EM0_PWM1 0x00000007 // PWM1 +#define ADC_EMUX_EM0_PWM2 0x00000008 // PWM2 +#define ADC_EMUX_EM0_ALWAYS 0x0000000F // Always (continuously sample) + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_USTAT register. +// +//***************************************************************************** +#define ADC_USTAT_UV3 0x00000008 // SS3 FIFO Underflow +#define ADC_USTAT_UV2 0x00000004 // SS2 FIFO Underflow +#define ADC_USTAT_UV1 0x00000002 // SS1 FIFO Underflow +#define ADC_USTAT_UV0 0x00000001 // SS0 FIFO Underflow + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSPRI register. +// +//***************************************************************************** +#define ADC_SSPRI_SS3_M 0x00003000 // SS3 Priority +#define ADC_SSPRI_SS3_1ST 0x00000000 // First priority +#define ADC_SSPRI_SS3_2ND 0x00001000 // Second priority +#define ADC_SSPRI_SS3_3RD 0x00002000 // Third priority +#define ADC_SSPRI_SS3_4TH 0x00003000 // Fourth priority +#define ADC_SSPRI_SS2_M 0x00000300 // SS2 Priority +#define ADC_SSPRI_SS2_1ST 0x00000000 // First priority +#define ADC_SSPRI_SS2_2ND 0x00000100 // Second priority +#define ADC_SSPRI_SS2_3RD 0x00000200 // Third priority +#define ADC_SSPRI_SS2_4TH 0x00000300 // Fourth priority +#define ADC_SSPRI_SS1_M 0x00000030 // SS1 Priority +#define ADC_SSPRI_SS1_1ST 0x00000000 // First priority +#define ADC_SSPRI_SS1_2ND 0x00000010 // Second priority +#define ADC_SSPRI_SS1_3RD 0x00000020 // Third priority +#define ADC_SSPRI_SS1_4TH 0x00000030 // Fourth priority +#define ADC_SSPRI_SS0_M 0x00000003 // SS0 Priority +#define ADC_SSPRI_SS0_1ST 0x00000000 // First priority +#define ADC_SSPRI_SS0_2ND 0x00000001 // Second priority +#define ADC_SSPRI_SS0_3RD 0x00000002 // Third priority +#define ADC_SSPRI_SS0_4TH 0x00000003 // Fourth priority + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_PSSI register. +// +//***************************************************************************** +#define ADC_PSSI_SS3 0x00000008 // SS3 Initiate +#define ADC_PSSI_SS2 0x00000004 // SS2 Initiate +#define ADC_PSSI_SS1 0x00000002 // SS1 Initiate +#define ADC_PSSI_SS0 0x00000001 // SS0 Initiate + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SAC register. +// +//***************************************************************************** +#define ADC_SAC_AVG_M 0x00000007 // Hardware Averaging Control +#define ADC_SAC_AVG_OFF 0x00000000 // No hardware oversampling +#define ADC_SAC_AVG_2X 0x00000001 // 2x hardware oversampling +#define ADC_SAC_AVG_4X 0x00000002 // 4x hardware oversampling +#define ADC_SAC_AVG_8X 0x00000003 // 8x hardware oversampling +#define ADC_SAC_AVG_16X 0x00000004 // 16x hardware oversampling +#define ADC_SAC_AVG_32X 0x00000005 // 32x hardware oversampling +#define ADC_SAC_AVG_64X 0x00000006 // 64x hardware oversampling + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSMUX0 register. +// +//***************************************************************************** +#define ADC_SSMUX0_MUX7_M 0x30000000 // 8th Sample Input Select +#define ADC_SSMUX0_MUX6_M 0x03000000 // 7th Sample Input Select +#define ADC_SSMUX0_MUX5_M 0x00300000 // 6th Sample Input Select +#define ADC_SSMUX0_MUX4_M 0x00030000 // 5th Sample Input Select +#define ADC_SSMUX0_MUX3_M 0x00003000 // 4th Sample Input Select +#define ADC_SSMUX0_MUX2_M 0x00000300 // 3rd Sample Input Select +#define ADC_SSMUX0_MUX1_M 0x00000030 // 2nd Sample Input Select +#define ADC_SSMUX0_MUX0_M 0x00000003 // 1st Sample Input Select +#define ADC_SSMUX0_MUX7_S 28 +#define ADC_SSMUX0_MUX6_S 24 +#define ADC_SSMUX0_MUX5_S 20 +#define ADC_SSMUX0_MUX4_S 16 +#define ADC_SSMUX0_MUX3_S 12 +#define ADC_SSMUX0_MUX2_S 8 +#define ADC_SSMUX0_MUX1_S 4 +#define ADC_SSMUX0_MUX0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSCTL0 register. +// +//***************************************************************************** +#define ADC_SSCTL0_TS7 0x80000000 // 8th Sample Temp Sensor Select +#define ADC_SSCTL0_IE7 0x40000000 // 8th Sample Interrupt Enable +#define ADC_SSCTL0_END7 0x20000000 // 8th Sample is End of Sequence +#define ADC_SSCTL0_D7 0x10000000 // 8th Sample Diff Input Select +#define ADC_SSCTL0_TS6 0x08000000 // 7th Sample Temp Sensor Select +#define ADC_SSCTL0_IE6 0x04000000 // 7th Sample Interrupt Enable +#define ADC_SSCTL0_END6 0x02000000 // 7th Sample is End of Sequence +#define ADC_SSCTL0_D6 0x01000000 // 7th Sample Diff Input Select +#define ADC_SSCTL0_TS5 0x00800000 // 6th Sample Temp Sensor Select +#define ADC_SSCTL0_IE5 0x00400000 // 6th Sample Interrupt Enable +#define ADC_SSCTL0_END5 0x00200000 // 6th Sample is End of Sequence +#define ADC_SSCTL0_D5 0x00100000 // 6th Sample Diff Input Select +#define ADC_SSCTL0_TS4 0x00080000 // 5th Sample Temp Sensor Select +#define ADC_SSCTL0_IE4 0x00040000 // 5th Sample Interrupt Enable +#define ADC_SSCTL0_END4 0x00020000 // 5th Sample is End of Sequence +#define ADC_SSCTL0_D4 0x00010000 // 5th Sample Diff Input Select +#define ADC_SSCTL0_TS3 0x00008000 // 4th Sample Temp Sensor Select +#define ADC_SSCTL0_IE3 0x00004000 // 4th Sample Interrupt Enable +#define ADC_SSCTL0_END3 0x00002000 // 4th Sample is End of Sequence +#define ADC_SSCTL0_D3 0x00001000 // 4th Sample Diff Input Select +#define ADC_SSCTL0_TS2 0x00000800 // 3rd Sample Temp Sensor Select +#define ADC_SSCTL0_IE2 0x00000400 // 3rd Sample Interrupt Enable +#define ADC_SSCTL0_END2 0x00000200 // 3rd Sample is End of Sequence +#define ADC_SSCTL0_D2 0x00000100 // 3rd Sample Diff Input Select +#define ADC_SSCTL0_TS1 0x00000080 // 2nd Sample Temp Sensor Select +#define ADC_SSCTL0_IE1 0x00000040 // 2nd Sample Interrupt Enable +#define ADC_SSCTL0_END1 0x00000020 // 2nd Sample is End of Sequence +#define ADC_SSCTL0_D1 0x00000010 // 2nd Sample Diff Input Select +#define ADC_SSCTL0_TS0 0x00000008 // 1st Sample Temp Sensor Select +#define ADC_SSCTL0_IE0 0x00000004 // 1st Sample Interrupt Enable +#define ADC_SSCTL0_END0 0x00000002 // 1st Sample is End of Sequence +#define ADC_SSCTL0_D0 0x00000001 // 1st Sample Diff Input Select + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFIFO0 register. +// +//***************************************************************************** +#define ADC_SSFIFO0_DATA_M 0x000003FF // Conversion Result Data +#define ADC_SSFIFO0_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFSTAT0 register. +// +//***************************************************************************** +#define ADC_SSFSTAT0_FULL 0x00001000 // FIFO Full +#define ADC_SSFSTAT0_EMPTY 0x00000100 // FIFO Empty +#define ADC_SSFSTAT0_HPTR_M 0x000000F0 // FIFO Head Pointer +#define ADC_SSFSTAT0_TPTR_M 0x0000000F // FIFO Tail Pointer +#define ADC_SSFSTAT0_HPTR_S 4 +#define ADC_SSFSTAT0_TPTR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSMUX1 register. +// +//***************************************************************************** +#define ADC_SSMUX1_MUX3_M 0x00003000 // 4th Sample Input Select +#define ADC_SSMUX1_MUX2_M 0x00000300 // 3rd Sample Input Select +#define ADC_SSMUX1_MUX1_M 0x00000030 // 2nd Sample Input Select +#define ADC_SSMUX1_MUX0_M 0x00000003 // 1st Sample Input Select +#define ADC_SSMUX1_MUX3_S 12 +#define ADC_SSMUX1_MUX2_S 8 +#define ADC_SSMUX1_MUX1_S 4 +#define ADC_SSMUX1_MUX0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSCTL1 register. +// +//***************************************************************************** +#define ADC_SSCTL1_TS3 0x00008000 // 4th Sample Temp Sensor Select +#define ADC_SSCTL1_IE3 0x00004000 // 4th Sample Interrupt Enable +#define ADC_SSCTL1_END3 0x00002000 // 4th Sample is End of Sequence +#define ADC_SSCTL1_D3 0x00001000 // 4th Sample Diff Input Select +#define ADC_SSCTL1_TS2 0x00000800 // 3rd Sample Temp Sensor Select +#define ADC_SSCTL1_IE2 0x00000400 // 3rd Sample Interrupt Enable +#define ADC_SSCTL1_END2 0x00000200 // 3rd Sample is End of Sequence +#define ADC_SSCTL1_D2 0x00000100 // 3rd Sample Diff Input Select +#define ADC_SSCTL1_TS1 0x00000080 // 2nd Sample Temp Sensor Select +#define ADC_SSCTL1_IE1 0x00000040 // 2nd Sample Interrupt Enable +#define ADC_SSCTL1_END1 0x00000020 // 2nd Sample is End of Sequence +#define ADC_SSCTL1_D1 0x00000010 // 2nd Sample Diff Input Select +#define ADC_SSCTL1_TS0 0x00000008 // 1st Sample Temp Sensor Select +#define ADC_SSCTL1_IE0 0x00000004 // 1st Sample Interrupt Enable +#define ADC_SSCTL1_END0 0x00000002 // 1st Sample is End of Sequence +#define ADC_SSCTL1_D0 0x00000001 // 1st Sample Diff Input Select + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFIFO1 register. +// +//***************************************************************************** +#define ADC_SSFIFO1_DATA_M 0x000003FF // Conversion Result Data +#define ADC_SSFIFO1_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFSTAT1 register. +// +//***************************************************************************** +#define ADC_SSFSTAT1_FULL 0x00001000 // FIFO Full +#define ADC_SSFSTAT1_EMPTY 0x00000100 // FIFO Empty +#define ADC_SSFSTAT1_HPTR_M 0x000000F0 // FIFO Head Pointer +#define ADC_SSFSTAT1_TPTR_M 0x0000000F // FIFO Tail Pointer +#define ADC_SSFSTAT1_HPTR_S 4 +#define ADC_SSFSTAT1_TPTR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSMUX2 register. +// +//***************************************************************************** +#define ADC_SSMUX2_MUX3_M 0x00003000 // 4th Sample Input Select +#define ADC_SSMUX2_MUX2_M 0x00000300 // 3rd Sample Input Select +#define ADC_SSMUX2_MUX1_M 0x00000030 // 2nd Sample Input Select +#define ADC_SSMUX2_MUX0_M 0x00000003 // 1st Sample Input Select +#define ADC_SSMUX2_MUX3_S 12 +#define ADC_SSMUX2_MUX2_S 8 +#define ADC_SSMUX2_MUX1_S 4 +#define ADC_SSMUX2_MUX0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSCTL2 register. +// +//***************************************************************************** +#define ADC_SSCTL2_TS3 0x00008000 // 4th Sample Temp Sensor Select +#define ADC_SSCTL2_IE3 0x00004000 // 4th Sample Interrupt Enable +#define ADC_SSCTL2_END3 0x00002000 // 4th Sample is End of Sequence +#define ADC_SSCTL2_D3 0x00001000 // 4th Sample Diff Input Select +#define ADC_SSCTL2_TS2 0x00000800 // 3rd Sample Temp Sensor Select +#define ADC_SSCTL2_IE2 0x00000400 // 3rd Sample Interrupt Enable +#define ADC_SSCTL2_END2 0x00000200 // 3rd Sample is End of Sequence +#define ADC_SSCTL2_D2 0x00000100 // 3rd Sample Diff Input Select +#define ADC_SSCTL2_TS1 0x00000080 // 2nd Sample Temp Sensor Select +#define ADC_SSCTL2_IE1 0x00000040 // 2nd Sample Interrupt Enable +#define ADC_SSCTL2_END1 0x00000020 // 2nd Sample is End of Sequence +#define ADC_SSCTL2_D1 0x00000010 // 2nd Sample Diff Input Select +#define ADC_SSCTL2_TS0 0x00000008 // 1st Sample Temp Sensor Select +#define ADC_SSCTL2_IE0 0x00000004 // 1st Sample Interrupt Enable +#define ADC_SSCTL2_END0 0x00000002 // 1st Sample is End of Sequence +#define ADC_SSCTL2_D0 0x00000001 // 1st Sample Diff Input Select + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFIFO2 register. +// +//***************************************************************************** +#define ADC_SSFIFO2_DATA_M 0x000003FF // Conversion Result Data +#define ADC_SSFIFO2_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFSTAT2 register. +// +//***************************************************************************** +#define ADC_SSFSTAT2_FULL 0x00001000 // FIFO Full +#define ADC_SSFSTAT2_EMPTY 0x00000100 // FIFO Empty +#define ADC_SSFSTAT2_HPTR_M 0x000000F0 // FIFO Head Pointer +#define ADC_SSFSTAT2_TPTR_M 0x0000000F // FIFO Tail Pointer +#define ADC_SSFSTAT2_HPTR_S 4 +#define ADC_SSFSTAT2_TPTR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSMUX3 register. +// +//***************************************************************************** +#define ADC_SSMUX3_MUX0_M 0x00000003 // 1st Sample Input Select +#define ADC_SSMUX3_MUX0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSCTL3 register. +// +//***************************************************************************** +#define ADC_SSCTL3_TS0 0x00000008 // 1st Sample Temp Sensor Select +#define ADC_SSCTL3_IE0 0x00000004 // 1st Sample Interrupt Enable +#define ADC_SSCTL3_END0 0x00000002 // 1st Sample is End of Sequence +#define ADC_SSCTL3_D0 0x00000001 // 1st Sample Diff Input Select + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFIFO3 register. +// +//***************************************************************************** +#define ADC_SSFIFO3_DATA_M 0x000003FF // Conversion Result Data +#define ADC_SSFIFO3_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_SSFSTAT3 register. +// +//***************************************************************************** +#define ADC_SSFSTAT3_FULL 0x00001000 // FIFO Full +#define ADC_SSFSTAT3_EMPTY 0x00000100 // FIFO Empty +#define ADC_SSFSTAT3_HPTR_M 0x000000F0 // FIFO Head Pointer +#define ADC_SSFSTAT3_TPTR_M 0x0000000F // FIFO Tail Pointer +#define ADC_SSFSTAT3_HPTR_S 4 +#define ADC_SSFSTAT3_TPTR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the ADC_O_TMLB register. +// +//***************************************************************************** +#define ADC_TMLB_LB 0x00000001 // Loopback Mode Enable + +//***************************************************************************** +// +// The following are defines for the the interpretation of the data in the +// SSFIFOx when the ADC TMLB is enabled. +// +//***************************************************************************** +#define ADC_SSFIFO_TMLB_CNT_M 0x000003C0 // Continuous Sample Counter +#define ADC_SSFIFO_TMLB_CONT 0x00000020 // Continuation Sample Indicator +#define ADC_SSFIFO_TMLB_DIFF 0x00000010 // Differential Sample Indicator +#define ADC_SSFIFO_TMLB_TS 0x00000008 // Temp Sensor Sample Indicator +#define ADC_SSFIFO_TMLB_MUX_M 0x00000007 // Analog Input Indicator +#define ADC_SSFIFO_TMLB_CNT_S 6 // Sample counter shift +#define ADC_SSFIFO_TMLB_MUX_S 0 // Input channel number shift + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACMIS register. +// +//***************************************************************************** +#define COMP_ACMIS_IN1 0x00000002 // Comparator 1 Masked Interrupt + // Status +#define COMP_ACMIS_IN0 0x00000001 // Comparator 0 Masked Interrupt + // Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACRIS register. +// +//***************************************************************************** +#define COMP_ACRIS_IN1 0x00000002 // Comparator 1 Interrupt Status +#define COMP_ACRIS_IN0 0x00000001 // Comparator 0 Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACINTEN register. +// +//***************************************************************************** +#define COMP_ACINTEN_IN1 0x00000002 // Comparator 1 Interrupt Enable +#define COMP_ACINTEN_IN0 0x00000001 // Comparator 0 Interrupt Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACREFCTL +// register. +// +//***************************************************************************** +#define COMP_ACREFCTL_EN 0x00000200 // Resistor Ladder Enable +#define COMP_ACREFCTL_RNG 0x00000100 // Resistor Ladder Range +#define COMP_ACREFCTL_VREF_M 0x0000000F // Resistor Ladder Voltage Ref +#define COMP_ACREFCTL_VREF_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACSTAT0 register. +// +//***************************************************************************** +#define COMP_ACSTAT0_OVAL 0x00000002 // Comparator Output Value + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACCTL0 register. +// +//***************************************************************************** +#define COMP_ACCTL0_TOEN 0x00000800 // Trigger Output Enable +#define COMP_ACCTL0_ASRCP_M 0x00000600 // Analog Source Positive +#define COMP_ACCTL0_ASRCP_PIN 0x00000000 // Pin value of Cn+ +#define COMP_ACCTL0_ASRCP_PIN0 0x00000200 // Pin value of C0+ +#define COMP_ACCTL0_ASRCP_REF 0x00000400 // Internal voltage reference + // (VIREF) +#define COMP_ACCTL0_TSLVAL 0x00000080 // Trigger Sense Level Value +#define COMP_ACCTL0_TSEN_M 0x00000060 // Trigger Sense +#define COMP_ACCTL0_TSEN_LEVEL 0x00000000 // Level sense, see TSLVAL +#define COMP_ACCTL0_TSEN_FALL 0x00000020 // Falling edge +#define COMP_ACCTL0_TSEN_RISE 0x00000040 // Rising edge +#define COMP_ACCTL0_TSEN_BOTH 0x00000060 // Either edge +#define COMP_ACCTL0_ISLVAL 0x00000010 // Interrupt Sense Level Value +#define COMP_ACCTL0_ISEN_M 0x0000000C // Interrupt Sense +#define COMP_ACCTL0_ISEN_LEVEL 0x00000000 // Level sense, see ISLVAL +#define COMP_ACCTL0_ISEN_FALL 0x00000004 // Falling edge +#define COMP_ACCTL0_ISEN_RISE 0x00000008 // Rising edge +#define COMP_ACCTL0_ISEN_BOTH 0x0000000C // Either edge +#define COMP_ACCTL0_CINV 0x00000002 // Comparator Output Invert + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACSTAT1 register. +// +//***************************************************************************** +#define COMP_ACSTAT1_OVAL 0x00000002 // Comparator Output Value + +//***************************************************************************** +// +// The following are defines for the bit fields in the COMP_O_ACCTL1 register. +// +//***************************************************************************** +#define COMP_ACCTL1_TOEN 0x00000800 // Trigger Output Enable +#define COMP_ACCTL1_ASRCP_M 0x00000600 // Analog Source Positive +#define COMP_ACCTL1_ASRCP_PIN 0x00000000 // Pin value of Cn+ +#define COMP_ACCTL1_ASRCP_PIN0 0x00000200 // Pin value of C0+ +#define COMP_ACCTL1_ASRCP_REF 0x00000400 // Internal voltage reference + // (VIREF) +#define COMP_ACCTL1_TSLVAL 0x00000080 // Trigger Sense Level Value +#define COMP_ACCTL1_TSEN_M 0x00000060 // Trigger Sense +#define COMP_ACCTL1_TSEN_LEVEL 0x00000000 // Level sense, see TSLVAL +#define COMP_ACCTL1_TSEN_FALL 0x00000020 // Falling edge +#define COMP_ACCTL1_TSEN_RISE 0x00000040 // Rising edge +#define COMP_ACCTL1_TSEN_BOTH 0x00000060 // Either edge +#define COMP_ACCTL1_ISLVAL 0x00000010 // Interrupt Sense Level Value +#define COMP_ACCTL1_ISEN_M 0x0000000C // Interrupt Sense +#define COMP_ACCTL1_ISEN_LEVEL 0x00000000 // Level sense, see ISLVAL +#define COMP_ACCTL1_ISEN_FALL 0x00000004 // Falling edge +#define COMP_ACCTL1_ISEN_RISE 0x00000008 // Rising edge +#define COMP_ACCTL1_ISEN_BOTH 0x0000000C // Either edge +#define COMP_ACCTL1_CINV 0x00000002 // Comparator Output Invert + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_RIS register. +// +//***************************************************************************** +#define MAC_RIS_PHYINT 0x00000040 // PHY Interrupt +#define MAC_RIS_MDINT 0x00000020 // MII Transaction Complete +#define MAC_RIS_RXER 0x00000010 // Receive Error +#define MAC_RIS_FOV 0x00000008 // FIFO Overrun +#define MAC_RIS_TXEMP 0x00000004 // Transmit FIFO Empty +#define MAC_RIS_TXER 0x00000002 // Transmit Error +#define MAC_RIS_RXINT 0x00000001 // Packet Received + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_IACK register. +// +//***************************************************************************** +#define MAC_IACK_PHYINT 0x00000040 // Clear PHY Interrupt +#define MAC_IACK_MDINT 0x00000020 // Clear MII Transaction Complete +#define MAC_IACK_RXER 0x00000010 // Clear Receive Error +#define MAC_IACK_FOV 0x00000008 // Clear FIFO Overrun +#define MAC_IACK_TXEMP 0x00000004 // Clear Transmit FIFO Empty +#define MAC_IACK_TXER 0x00000002 // Clear Transmit Error +#define MAC_IACK_RXINT 0x00000001 // Clear Packet Received + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_IM register. +// +//***************************************************************************** +#define MAC_IM_PHYINTM 0x00000040 // Mask PHY Interrupt +#define MAC_IM_MDINTM 0x00000020 // Mask MII Transaction Complete +#define MAC_IM_RXERM 0x00000010 // Mask Receive Error +#define MAC_IM_FOVM 0x00000008 // Mask FIFO Overrun +#define MAC_IM_TXEMPM 0x00000004 // Mask Transmit FIFO Empty +#define MAC_IM_TXERM 0x00000002 // Mask Transmit Error +#define MAC_IM_RXINTM 0x00000001 // Mask Packet Received + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_RCTL register. +// +//***************************************************************************** +#define MAC_RCTL_RSTFIFO 0x00000010 // Clear Receive FIFO +#define MAC_RCTL_BADCRC 0x00000008 // Enable Reject Bad CRC +#define MAC_RCTL_PRMS 0x00000004 // Enable Promiscuous Mode +#define MAC_RCTL_AMUL 0x00000002 // Enable Multicast Frames +#define MAC_RCTL_RXEN 0x00000001 // Enable Receiver + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_TCTL register. +// +//***************************************************************************** +#define MAC_TCTL_DUPLEX 0x00000010 // Enable Duplex Mode +#define MAC_TCTL_CRC 0x00000004 // Enable CRC Generation +#define MAC_TCTL_PADEN 0x00000002 // Enable Packet Padding +#define MAC_TCTL_TXEN 0x00000001 // Enable Transmitter + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_DATA register. +// +//***************************************************************************** +#define MAC_DATA_TXDATA_M 0xFFFFFFFF // Transmit FIFO Data +#define MAC_DATA_RXDATA_M 0xFFFFFFFF // Receive FIFO Data +#define MAC_DATA_RXDATA_S 0 +#define MAC_DATA_TXDATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_IA0 register. +// +//***************************************************************************** +#define MAC_IA0_MACOCT4_M 0xFF000000 // MAC Address Octet 4 +#define MAC_IA0_MACOCT3_M 0x00FF0000 // MAC Address Octet 3 +#define MAC_IA0_MACOCT2_M 0x0000FF00 // MAC Address Octet 2 +#define MAC_IA0_MACOCT1_M 0x000000FF // MAC Address Octet 1 +#define MAC_IA0_MACOCT4_S 24 +#define MAC_IA0_MACOCT3_S 16 +#define MAC_IA0_MACOCT2_S 8 +#define MAC_IA0_MACOCT1_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_IA1 register. +// +//***************************************************************************** +#define MAC_IA1_MACOCT6_M 0x0000FF00 // MAC Address Octet 6 +#define MAC_IA1_MACOCT5_M 0x000000FF // MAC Address Octet 5 +#define MAC_IA1_MACOCT6_S 8 +#define MAC_IA1_MACOCT5_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_THR register. +// +//***************************************************************************** +#define MAC_THR_THRESH_M 0x0000003F // Threshold Value +#define MAC_THR_THRESH_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_MCTL register. +// +//***************************************************************************** +#define MAC_MCTL_REGADR_M 0x000000F8 // MII Register Address +#define MAC_MCTL_WRITE 0x00000002 // MII Register Transaction Type +#define MAC_MCTL_START 0x00000001 // MII Register Transaction Enable +#define MAC_MCTL_REGADR_S 3 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_MDV register. +// +//***************************************************************************** +#define MAC_MDV_DIV_M 0x000000FF // Clock Divider +#define MAC_MDV_DIV_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_MTXD register. +// +//***************************************************************************** +#define MAC_MTXD_MDTX_M 0x0000FFFF // MII Register Transmit Data +#define MAC_MTXD_MDTX_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_MRXD register. +// +//***************************************************************************** +#define MAC_MRXD_MDRX_M 0x0000FFFF // MII Register Receive Data +#define MAC_MRXD_MDRX_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_NP register. +// +//***************************************************************************** +#define MAC_NP_NPR_M 0x0000003F // Number of Packets in Receive + // FIFO +#define MAC_NP_NPR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the MAC_O_TR register. +// +//***************************************************************************** +#define MAC_TR_NEWTX 0x00000001 // New Transmission + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR0 register. +// +//***************************************************************************** +#define PHY_MR0_RESET 0x00008000 // Reset Registers +#define PHY_MR0_LOOPBK 0x00004000 // Loopback Mode +#define PHY_MR0_SPEEDSL 0x00002000 // Speed Select +#define PHY_MR0_ANEGEN 0x00001000 // Auto-Negotiation Enable +#define PHY_MR0_PWRDN 0x00000800 // Power Down +#define PHY_MR0_ISO 0x00000400 // Isolate +#define PHY_MR0_RANEG 0x00000200 // Restart Auto-Negotiation +#define PHY_MR0_DUPLEX 0x00000100 // Set Duplex Mode +#define PHY_MR0_COLT 0x00000080 // Collision Test + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR1 register. +// +//***************************************************************************** +#define PHY_MR1_100X_F 0x00004000 // 100BASE-TX Full-Duplex Mode +#define PHY_MR1_100X_H 0x00002000 // 100BASE-TX Half-Duplex Mode +#define PHY_MR1_10T_F 0x00001000 // 10BASE-T Full-Duplex Mode +#define PHY_MR1_10T_H 0x00000800 // 10BASE-T Half-Duplex Mode +#define PHY_MR1_MFPS 0x00000040 // Management Frames with Preamble + // Suppressed +#define PHY_MR1_ANEGC 0x00000020 // Auto-Negotiation Complete +#define PHY_MR1_RFAULT 0x00000010 // Remote Fault +#define PHY_MR1_ANEGA 0x00000008 // Auto-Negotiation +#define PHY_MR1_LINK 0x00000004 // Link Made +#define PHY_MR1_JAB 0x00000002 // Jabber Condition +#define PHY_MR1_EXTD 0x00000001 // Extended Capabilities + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR2 register. +// +//***************************************************************************** +#define PHY_MR2_OUI_M 0x0000FFFF // Organizationally Unique + // Identifier[21:6] +#define PHY_MR2_OUI_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR3 register. +// +//***************************************************************************** +#define PHY_MR3_OUI_M 0x0000FC00 // Organizationally Unique + // Identifier[5:0] +#define PHY_MR3_MN_M 0x000003F0 // Model Number +#define PHY_MR3_RN_M 0x0000000F // Revision Number +#define PHY_MR3_OUI_S 10 +#define PHY_MR3_MN_S 4 +#define PHY_MR3_RN_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR4 register. +// +//***************************************************************************** +#define PHY_MR4_NP 0x00008000 // Next Page +#define PHY_MR4_RF 0x00002000 // Remote Fault +#define PHY_MR4_A3 0x00000100 // Technology Ability Field [3] +#define PHY_MR4_A2 0x00000080 // Technology Ability Field [2] +#define PHY_MR4_A1 0x00000040 // Technology Ability Field [1] +#define PHY_MR4_A0 0x00000020 // Technology Ability Field [0] +#define PHY_MR4_S_M 0x0000001F // Selector Field +#define PHY_MR4_S_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR5 register. +// +//***************************************************************************** +#define PHY_MR5_NP 0x00008000 // Next Page +#define PHY_MR5_ACK 0x00004000 // Acknowledge +#define PHY_MR5_RF 0x00002000 // Remote Fault +#define PHY_MR5_A_M 0x00001FE0 // Technology Ability Field +#define PHY_MR5_S_M 0x0000001F // Selector Field +#define PHY_MR5_S_8023 0x00000001 // IEEE Std 802.3 +#define PHY_MR5_S_8029 0x00000002 // IEEE Std 802.9 ISLAN-16T +#define PHY_MR5_S_8025 0x00000003 // IEEE Std 802.5 +#define PHY_MR5_S_1394 0x00000004 // IEEE Std 1394 +#define PHY_MR5_A_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR6 register. +// +//***************************************************************************** +#define PHY_MR6_PDF 0x00000010 // Parallel Detection Fault +#define PHY_MR6_LPNPA 0x00000008 // Link Partner is Next Page Able +#define PHY_MR6_PRX 0x00000002 // New Page Received +#define PHY_MR6_LPANEGA 0x00000001 // Link Partner is Auto-Negotiation + // Able + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR16 register. +// +//***************************************************************************** +#define PHY_MR16_RPTR 0x00008000 // Repeater Mode +#define PHY_MR16_INPOL 0x00004000 // Interrupt Polarity +#define PHY_MR16_TXHIM 0x00001000 // Transmit High Impedance Mode +#define PHY_MR16_SQEI 0x00000800 // SQE Inhibit Testing +#define PHY_MR16_NL10 0x00000400 // Natural Loopback Mode +#define PHY_MR16_APOL 0x00000020 // Auto-Polarity Disable +#define PHY_MR16_RVSPOL 0x00000010 // Receive Data Polarity +#define PHY_MR16_PCSBP 0x00000002 // PCS Bypass +#define PHY_MR16_RXCC 0x00000001 // Receive Clock Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR17 register. +// +//***************************************************************************** +#define PHY_MR17_JABBER_IE 0x00008000 // Jabber Interrupt Enable +#define PHY_MR17_RXER_IE 0x00004000 // Receive Error Interrupt Enable +#define PHY_MR17_PRX_IE 0x00002000 // Page Received Interrupt Enable +#define PHY_MR17_PDF_IE 0x00001000 // Parallel Detection Fault + // Interrupt Enable +#define PHY_MR17_LPACK_IE 0x00000800 // LP Acknowledge Interrupt Enable +#define PHY_MR17_LSCHG_IE 0x00000400 // Link Status Change Interrupt + // Enable +#define PHY_MR17_RFAULT_IE 0x00000200 // Remote Fault Interrupt Enable +#define PHY_MR17_ANEGCOMP_IE 0x00000100 // Auto-Negotiation Complete + // Interrupt Enable +#define PHY_MR17_JABBER_INT 0x00000080 // Jabber Event Interrupt +#define PHY_MR17_RXER_INT 0x00000040 // Receive Error Interrupt +#define PHY_MR17_PRX_INT 0x00000020 // Page Receive Interrupt +#define PHY_MR17_PDF_INT 0x00000010 // Parallel Detection Fault + // Interrupt +#define PHY_MR17_LPACK_INT 0x00000008 // LP Acknowledge Interrupt +#define PHY_MR17_LSCHG_INT 0x00000004 // Link Status Change Interrupt +#define PHY_MR17_RFAULT_INT 0x00000002 // Remote Fault Interrupt +#define PHY_MR17_ANEGCOMP_INT 0x00000001 // Auto-Negotiation Complete + // Interrupt + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR18 register. +// +//***************************************************************************** +#define PHY_MR18_ANEGF 0x00001000 // Auto-Negotiation Failure +#define PHY_MR18_DPLX 0x00000800 // Duplex Mode +#define PHY_MR18_RATE 0x00000400 // Rate +#define PHY_MR18_RXSD 0x00000200 // Receive Detection +#define PHY_MR18_RX_LOCK 0x00000100 // Receive PLL Lock + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR19 register. +// +//***************************************************************************** +#define PHY_MR19_TXO_M 0x0000C000 // Transmit Amplitude Selection +#define PHY_MR19_TXO_00DB 0x00000000 // Gain set for 0.0dB of insertion + // loss +#define PHY_MR19_TXO_04DB 0x00004000 // Gain set for 0.4dB of insertion + // loss +#define PHY_MR19_TXO_08DB 0x00008000 // Gain set for 0.8dB of insertion + // loss +#define PHY_MR19_TXO_12DB 0x0000C000 // Gain set for 1.2dB of insertion + // loss + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR23 register. +// +//***************************************************************************** +#define PHY_MR23_LED1_M 0x000000F0 // LED1 Source +#define PHY_MR23_LED1_LINK 0x00000000 // Link OK +#define PHY_MR23_LED1_RXTX 0x00000010 // RX or TX Activity (Default LED1) +#define PHY_MR23_LED1_100 0x00000050 // 100BASE-TX mode +#define PHY_MR23_LED1_10 0x00000060 // 10BASE-T mode +#define PHY_MR23_LED1_DUPLEX 0x00000070 // Full-Duplex +#define PHY_MR23_LED1_LINKACT 0x00000080 // Link OK & Blink=RX or TX + // Activity +#define PHY_MR23_LED0_M 0x0000000F // LED0 Source +#define PHY_MR23_LED0_LINK 0x00000000 // Link OK (Default LED0) +#define PHY_MR23_LED0_RXTX 0x00000001 // RX or TX Activity +#define PHY_MR23_LED0_100 0x00000005 // 100BASE-TX mode +#define PHY_MR23_LED0_10 0x00000006 // 10BASE-T mode +#define PHY_MR23_LED0_DUPLEX 0x00000007 // Full-Duplex +#define PHY_MR23_LED0_LINKACT 0x00000008 // Link OK & Blink=RX or TX + // Activity + +//***************************************************************************** +// +// The following are defines for the bit fields in the PHY_MR24 register. +// +//***************************************************************************** +#define PHY_MR24_PD_MODE 0x00000080 // Parallel Detection Mode +#define PHY_MR24_AUTO_SW 0x00000040 // Auto-Switching Enable +#define PHY_MR24_MDIX 0x00000020 // Auto-Switching Configuration +#define PHY_MR24_MDIX_CM 0x00000010 // Auto-Switching Complete +#define PHY_MR24_MDIX_SD_M 0x0000000F // Auto-Switching Seed +#define PHY_MR24_MDIX_SD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_RTCC register. +// +//***************************************************************************** +#define HIB_RTCC_M 0xFFFFFFFF // RTC Counter +#define HIB_RTCC_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_RTCM0 register. +// +//***************************************************************************** +#define HIB_RTCM0_M 0xFFFFFFFF // RTC Match 0 +#define HIB_RTCM0_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_RTCM1 register. +// +//***************************************************************************** +#define HIB_RTCM1_M 0xFFFFFFFF // RTC Match 1 +#define HIB_RTCM1_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_RTCLD register. +// +//***************************************************************************** +#define HIB_RTCLD_M 0xFFFFFFFF // RTC Load +#define HIB_RTCLD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_CTL register. +// +//***************************************************************************** +#define HIB_CTL_VABORT 0x00000080 // Power Cut Abort Enable +#define HIB_CTL_CLK32EN 0x00000040 // Clocking Enable +#define HIB_CTL_LOWBATEN 0x00000020 // Low Battery Monitoring Enable +#define HIB_CTL_PINWEN 0x00000010 // External WAKE Pin Enable +#define HIB_CTL_RTCWEN 0x00000008 // RTC Wake-up Enable +#define HIB_CTL_CLKSEL 0x00000004 // Hibernation Module Clock Select +#define HIB_CTL_HIBREQ 0x00000002 // Hibernation Request +#define HIB_CTL_RTCEN 0x00000001 // RTC Timer Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_IM register. +// +//***************************************************************************** +#define HIB_IM_EXTW 0x00000008 // External Wake-Up Interrupt Mask +#define HIB_IM_LOWBAT 0x00000004 // Low Battery Voltage Interrupt + // Mask +#define HIB_IM_RTCALT1 0x00000002 // RTC Alert 1 Interrupt Mask +#define HIB_IM_RTCALT0 0x00000001 // RTC Alert 0 Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_RIS register. +// +//***************************************************************************** +#define HIB_RIS_EXTW 0x00000008 // External Wake-Up Raw Interrupt + // Status +#define HIB_RIS_LOWBAT 0x00000004 // Low Battery Voltage Raw + // Interrupt Status +#define HIB_RIS_RTCALT1 0x00000002 // RTC Alert 1 Raw Interrupt Status +#define HIB_RIS_RTCALT0 0x00000001 // RTC Alert 0 Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_MIS register. +// +//***************************************************************************** +#define HIB_MIS_EXTW 0x00000008 // External Wake-Up Masked + // Interrupt Status +#define HIB_MIS_LOWBAT 0x00000004 // Low Battery Voltage Masked + // Interrupt Status +#define HIB_MIS_RTCALT1 0x00000002 // RTC Alert 1 Masked Interrupt + // Status +#define HIB_MIS_RTCALT0 0x00000001 // RTC Alert 0 Masked Interrupt + // Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_IC register. +// +//***************************************************************************** +#define HIB_IC_EXTW 0x00000008 // External Wake-Up Masked + // Interrupt Clear +#define HIB_IC_LOWBAT 0x00000004 // Low Battery Voltage Masked + // Interrupt Clear +#define HIB_IC_RTCALT1 0x00000002 // RTC Alert1 Masked Interrupt + // Clear +#define HIB_IC_RTCALT0 0x00000001 // RTC Alert0 Masked Interrupt + // Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_RTCT register. +// +//***************************************************************************** +#define HIB_RTCT_TRIM_M 0x0000FFFF // RTC Trim Value +#define HIB_RTCT_TRIM_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the HIB_DATA register. +// +//***************************************************************************** +#define HIB_DATA_RTD_M 0xFFFFFFFF // Hibernation Module NV Data +#define HIB_DATA_RTD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FMA register. +// +//***************************************************************************** +#define FLASH_FMA_OFFSET_M 0x0003FFFF // Address Offset +#define FLASH_FMA_OFFSET_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FMD register. +// +//***************************************************************************** +#define FLASH_FMD_DATA_M 0xFFFFFFFF // Data Value +#define FLASH_FMD_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FMC register. +// +//***************************************************************************** +#define FLASH_FMC_WRKEY 0xA4420000 // FLASH write key +#define FLASH_FMC_COMT 0x00000008 // Commit Register Value +#define FLASH_FMC_MERASE 0x00000004 // Mass Erase Flash Memory +#define FLASH_FMC_ERASE 0x00000002 // Erase a Page of Flash Memory +#define FLASH_FMC_WRITE 0x00000001 // Write a Word into Flash Memory + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FCRIS register. +// +//***************************************************************************** +#define FLASH_FCRIS_PRIS 0x00000002 // Programming Raw Interrupt Status +#define FLASH_FCRIS_ARIS 0x00000001 // Access Raw Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FCIM register. +// +//***************************************************************************** +#define FLASH_FCIM_PMASK 0x00000002 // Programming Interrupt Mask +#define FLASH_FCIM_AMASK 0x00000001 // Access Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_FCMISC register. +// +//***************************************************************************** +#define FLASH_FCMISC_PMISC 0x00000002 // Programming Masked Interrupt + // Status and Clear +#define FLASH_FCMISC_AMISC 0x00000001 // Access Masked Interrupt Status + // and Clear + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USECRL register. +// +//***************************************************************************** +#define FLASH_USECRL_M 0x000000FF // Microsecond Reload Value +#define FLASH_USECRL_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USERDBG register. +// +//***************************************************************************** +#define FLASH_USERDBG_NW 0x80000000 // User Debug Not Written +#define FLASH_USERDBG_DATA_M 0x7FFFFFFC // User Data +#define FLASH_USERDBG_DBG1 0x00000002 // Debug Control 1 +#define FLASH_USERDBG_DBG0 0x00000001 // Debug Control 0 +#define FLASH_USERDBG_DATA_S 2 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USERREG0 register. +// +//***************************************************************************** +#define FLASH_USERREG0_NW 0x80000000 // Not Written +#define FLASH_USERREG0_DATA_M 0x7FFFFFFF // User Data +#define FLASH_USERREG0_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the FLASH_USERREG1 register. +// +//***************************************************************************** +#define FLASH_USERREG1_NW 0x80000000 // Not Written +#define FLASH_USERREG1_DATA_M 0x7FFFFFFF // User Data +#define FLASH_USERREG1_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the erase size of the FLASH block that is +// erased by an erase operation, and the protect size is the size of the FLASH +// block that is protected by each protection register. +// +//***************************************************************************** +#define FLASH_PROTECT_SIZE 0x00000800 +#define FLASH_ERASE_SIZE 0x00000400 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DID0 register. +// +//***************************************************************************** +#define SYSCTL_DID0_VER_M 0x70000000 // DID0 Version +#define SYSCTL_DID0_VER_1 0x10000000 // Second version of the DID0 + // register format +#define SYSCTL_DID0_CLASS_M 0x00FF0000 // Device Class +#define SYSCTL_DID0_CLASS_FURY 0x00010000 // Stellaris(R) Fury-class devices +#define SYSCTL_DID0_MAJ_M 0x0000FF00 // Major Revision +#define SYSCTL_DID0_MAJ_REVA 0x00000000 // Revision A (initial device) +#define SYSCTL_DID0_MAJ_REVB 0x00000100 // Revision B (first base layer + // revision) +#define SYSCTL_DID0_MAJ_REVC 0x00000200 // Revision C (second base layer + // revision) +#define SYSCTL_DID0_MIN_M 0x000000FF // Minor Revision +#define SYSCTL_DID0_MIN_0 0x00000000 // Initial device, or a major + // revision update +#define SYSCTL_DID0_MIN_1 0x00000001 // First metal layer change +#define SYSCTL_DID0_MIN_2 0x00000002 // Second metal layer change + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DID1 register. +// +//***************************************************************************** +#define SYSCTL_DID1_VER_M 0xF0000000 // DID1 Version +#define SYSCTL_DID1_VER_1 0x10000000 // Second version of the DID1 + // register format +#define SYSCTL_DID1_FAM_M 0x0F000000 // Family +#define SYSCTL_DID1_FAM_STELLARIS \ + 0x00000000 // Stellaris family of + // microcontollers, that is, all + // devices with external part + // numbers starting with LM3S +#define SYSCTL_DID1_PRTNO_M 0x00FF0000 // Part Number +#define SYSCTL_DID1_PRTNO_6965 0x00730000 // LM3S6965 +#define SYSCTL_DID1_PINCNT_M 0x0000E000 // Package Pin Count +#define SYSCTL_DID1_PINCNT_100 0x00004000 // 100-pin package +#define SYSCTL_DID1_TEMP_M 0x000000E0 // Temperature Range +#define SYSCTL_DID1_TEMP_C 0x00000000 // Commercial temperature range (0C + // to 70C) +#define SYSCTL_DID1_TEMP_I 0x00000020 // Industrial temperature range + // (-40C to 85C) +#define SYSCTL_DID1_TEMP_E 0x00000040 // Extended temperature range (-40C + // to 105C) +#define SYSCTL_DID1_PKG_M 0x00000018 // Package Type +#define SYSCTL_DID1_PKG_SOIC 0x00000000 // SOIC package +#define SYSCTL_DID1_PKG_QFP 0x00000008 // LQFP package +#define SYSCTL_DID1_PKG_BGA 0x00000010 // BGA package +#define SYSCTL_DID1_ROHS 0x00000004 // RoHS-Compliance +#define SYSCTL_DID1_QUAL_M 0x00000003 // Qualification Status +#define SYSCTL_DID1_QUAL_ES 0x00000000 // Engineering Sample (unqualified) +#define SYSCTL_DID1_QUAL_PP 0x00000001 // Pilot Production (unqualified) +#define SYSCTL_DID1_QUAL_FQ 0x00000002 // Fully Qualified + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC0 register. +// +//***************************************************************************** +#define SYSCTL_DC0_SRAMSZ_M 0xFFFF0000 // SRAM Size +#define SYSCTL_DC0_SRAMSZ_64KB 0x00FF0000 // 64 KB of SRAM +#define SYSCTL_DC0_FLASHSZ_M 0x0000FFFF // Flash Size +#define SYSCTL_DC0_FLASHSZ_256K 0x0000007F // 256 KB of Flash +#define SYSCTL_DC0_SRAMSZ_S 16 // SRAM size shift +#define SYSCTL_DC0_FLASHSZ_S 0 // Flash size shift + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC1 register. +// +//***************************************************************************** +#define SYSCTL_DC1_PWM 0x00100000 // PWM Module Present +#define SYSCTL_DC1_ADC 0x00010000 // ADC Module Present +#define SYSCTL_DC1_MINSYSDIV_M 0x0000F000 // System Clock Divider +#define SYSCTL_DC1_MINSYSDIV_50 0x00003000 // Specifies a 50-MHz CPU clock + // with a PLL divider of 4 +#define SYSCTL_DC1_ADCSPD_M 0x00000300 // Max ADC Speed +#define SYSCTL_DC1_ADCSPD_1M 0x00000300 // 1M samples/second +#define SYSCTL_DC1_MPU 0x00000080 // MPU Present +#define SYSCTL_DC1_HIB 0x00000040 // Hibernation Module Present +#define SYSCTL_DC1_TEMP 0x00000020 // Temp Sensor Present +#define SYSCTL_DC1_PLL 0x00000010 // PLL Present +#define SYSCTL_DC1_WDT0 0x00000008 // Watchdog Timer 0 Present +#define SYSCTL_DC1_SWO 0x00000004 // SWO Trace Port Present +#define SYSCTL_DC1_SWD 0x00000002 // SWD Present +#define SYSCTL_DC1_JTAG 0x00000001 // JTAG Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC2 register. +// +//***************************************************************************** +#define SYSCTL_DC2_COMP1 0x02000000 // Analog Comparator 1 Present +#define SYSCTL_DC2_COMP0 0x01000000 // Analog Comparator 0 Present +#define SYSCTL_DC2_TIMER3 0x00080000 // Timer Module 3 Present +#define SYSCTL_DC2_TIMER2 0x00040000 // Timer Module 2 Present +#define SYSCTL_DC2_TIMER1 0x00020000 // Timer Module 1 Present +#define SYSCTL_DC2_TIMER0 0x00010000 // Timer Module 0 Present +#define SYSCTL_DC2_I2C1 0x00004000 // I2C Module 1 Present +#define SYSCTL_DC2_I2C0 0x00001000 // I2C Module 0 Present +#define SYSCTL_DC2_QEI1 0x00000200 // QEI Module 1 Present +#define SYSCTL_DC2_QEI0 0x00000100 // QEI Module 0 Present +#define SYSCTL_DC2_SSI0 0x00000010 // SSI Module 0 Present +#define SYSCTL_DC2_UART2 0x00000004 // UART Module 2 Present +#define SYSCTL_DC2_UART1 0x00000002 // UART Module 1 Present +#define SYSCTL_DC2_UART0 0x00000001 // UART Module 0 Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC3 register. +// +//***************************************************************************** +#define SYSCTL_DC3_32KHZ 0x80000000 // 32KHz Input Clock Available +#define SYSCTL_DC3_CCP3 0x08000000 // CCP3 Pin Present +#define SYSCTL_DC3_CCP2 0x04000000 // CCP2 Pin Present +#define SYSCTL_DC3_CCP1 0x02000000 // CCP1 Pin Present +#define SYSCTL_DC3_CCP0 0x01000000 // CCP0 Pin Present +#define SYSCTL_DC3_ADC3 0x00080000 // ADC3 Pin Present +#define SYSCTL_DC3_ADC2 0x00040000 // ADC2 Pin Present +#define SYSCTL_DC3_ADC1 0x00020000 // ADC1 Pin Present +#define SYSCTL_DC3_ADC0 0x00010000 // ADC0 Pin Present +#define SYSCTL_DC3_PWMFAULT 0x00008000 // PWM Fault Pin Present +#define SYSCTL_DC3_C1PLUS 0x00000400 // C1+ Pin Present +#define SYSCTL_DC3_C1MINUS 0x00000200 // C1- Pin Present +#define SYSCTL_DC3_C0O 0x00000100 // C0o Pin Present +#define SYSCTL_DC3_C0PLUS 0x00000080 // C0+ Pin Present +#define SYSCTL_DC3_C0MINUS 0x00000040 // C0- Pin Present +#define SYSCTL_DC3_PWM5 0x00000020 // PWM5 Pin Present +#define SYSCTL_DC3_PWM4 0x00000010 // PWM4 Pin Present +#define SYSCTL_DC3_PWM3 0x00000008 // PWM3 Pin Present +#define SYSCTL_DC3_PWM2 0x00000004 // PWM2 Pin Present +#define SYSCTL_DC3_PWM1 0x00000002 // PWM1 Pin Present +#define SYSCTL_DC3_PWM0 0x00000001 // PWM0 Pin Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DC4 register. +// +//***************************************************************************** +#define SYSCTL_DC4_EPHY0 0x40000000 // Ethernet PHY Layer 0 Present +#define SYSCTL_DC4_EMAC0 0x10000000 // Ethernet MAC Layer 0 Present +#define SYSCTL_DC4_GPIOG 0x00000040 // GPIO Port G Present +#define SYSCTL_DC4_GPIOF 0x00000020 // GPIO Port F Present +#define SYSCTL_DC4_GPIOE 0x00000010 // GPIO Port E Present +#define SYSCTL_DC4_GPIOD 0x00000008 // GPIO Port D Present +#define SYSCTL_DC4_GPIOC 0x00000004 // GPIO Port C Present +#define SYSCTL_DC4_GPIOB 0x00000002 // GPIO Port B Present +#define SYSCTL_DC4_GPIOA 0x00000001 // GPIO Port A Present + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_PBORCTL register. +// +//***************************************************************************** +#define SYSCTL_PBORCTL_BORIOR 0x00000002 // BOR Interrupt or Reset + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_LDOPCTL register. +// +//***************************************************************************** +#define SYSCTL_LDOPCTL_M 0x0000003F // LDO Output Voltage +#define SYSCTL_LDOPCTL_2_50V 0x00000000 // 2.50 +#define SYSCTL_LDOPCTL_2_45V 0x00000001 // 2.45 +#define SYSCTL_LDOPCTL_2_40V 0x00000002 // 2.40 +#define SYSCTL_LDOPCTL_2_35V 0x00000003 // 2.35 +#define SYSCTL_LDOPCTL_2_30V 0x00000004 // 2.30 +#define SYSCTL_LDOPCTL_2_25V 0x00000005 // 2.25 +#define SYSCTL_LDOPCTL_2_75V 0x0000001B // 2.75 +#define SYSCTL_LDOPCTL_2_70V 0x0000001C // 2.70 +#define SYSCTL_LDOPCTL_2_65V 0x0000001D // 2.65 +#define SYSCTL_LDOPCTL_2_60V 0x0000001E // 2.60 +#define SYSCTL_LDOPCTL_2_55V 0x0000001F // 2.55 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SRCR0 register. +// +//***************************************************************************** +#define SYSCTL_SRCR0_PWM 0x00100000 // PWM Reset Control +#define SYSCTL_SRCR0_ADC 0x00010000 // ADC0 Reset Control +#define SYSCTL_SRCR0_HIB 0x00000040 // HIB Reset Control +#define SYSCTL_SRCR0_WDT 0x00000008 // WDT Reset Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SRCR1 register. +// +//***************************************************************************** +#define SYSCTL_SRCR1_COMP1 0x02000000 // Analog Comp 1 Reset Control +#define SYSCTL_SRCR1_COMP0 0x01000000 // Analog Comp 0 Reset Control +#define SYSCTL_SRCR1_TIMER3 0x00080000 // Timer 3 Reset Control +#define SYSCTL_SRCR1_TIMER2 0x00040000 // Timer 2 Reset Control +#define SYSCTL_SRCR1_TIMER1 0x00020000 // Timer 1 Reset Control +#define SYSCTL_SRCR1_TIMER0 0x00010000 // Timer 0 Reset Control +#define SYSCTL_SRCR1_I2C1 0x00004000 // I2C1 Reset Control +#define SYSCTL_SRCR1_I2C0 0x00001000 // I2C0 Reset Control +#define SYSCTL_SRCR1_QEI1 0x00000200 // QEI1 Reset Control +#define SYSCTL_SRCR1_QEI0 0x00000100 // QEI0 Reset Control +#define SYSCTL_SRCR1_SSI0 0x00000010 // SSI0 Reset Control +#define SYSCTL_SRCR1_UART2 0x00000004 // UART2 Reset Control +#define SYSCTL_SRCR1_UART1 0x00000002 // UART1 Reset Control +#define SYSCTL_SRCR1_UART0 0x00000001 // UART0 Reset Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SRCR2 register. +// +//***************************************************************************** +#define SYSCTL_SRCR2_EPHY0 0x40000000 // PHY0 Reset Control +#define SYSCTL_SRCR2_EMAC0 0x10000000 // MAC0 Reset Control +#define SYSCTL_SRCR2_GPIOG 0x00000040 // Port G Reset Control +#define SYSCTL_SRCR2_GPIOF 0x00000020 // Port F Reset Control +#define SYSCTL_SRCR2_GPIOE 0x00000010 // Port E Reset Control +#define SYSCTL_SRCR2_GPIOD 0x00000008 // Port D Reset Control +#define SYSCTL_SRCR2_GPIOC 0x00000004 // Port C Reset Control +#define SYSCTL_SRCR2_GPIOB 0x00000002 // Port B Reset Control +#define SYSCTL_SRCR2_GPIOA 0x00000001 // Port A Reset Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RIS register. +// +//***************************************************************************** +#define SYSCTL_RIS_PLLLRIS 0x00000040 // PLL Lock Raw Interrupt Status +#define SYSCTL_RIS_BORRIS 0x00000002 // Brown-Out Reset Raw Interrupt + // Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_IMC register. +// +//***************************************************************************** +#define SYSCTL_IMC_PLLLIM 0x00000040 // PLL Lock Interrupt Mask +#define SYSCTL_IMC_BORIM 0x00000002 // Brown-Out Reset Interrupt Mask + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_MISC register. +// +//***************************************************************************** +#define SYSCTL_MISC_PLLLMIS 0x00000040 // PLL Lock Masked Interrupt Status +#define SYSCTL_MISC_BORMIS 0x00000002 // BOR Masked Interrupt Status + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RESC register. +// +//***************************************************************************** +#define SYSCTL_RESC_SW 0x00000010 // Software Reset +#define SYSCTL_RESC_WDT 0x00000008 // Watchdog Timer Reset +#define SYSCTL_RESC_BOR 0x00000004 // Brown-Out Reset +#define SYSCTL_RESC_POR 0x00000002 // Power-On Reset +#define SYSCTL_RESC_EXT 0x00000001 // External Reset + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RCC register. +// +//***************************************************************************** +#define SYSCTL_RCC_ACG 0x08000000 // Auto Clock Gating +#define SYSCTL_RCC_SYSDIV_M 0x07800000 // System Clock Divisor +#define SYSCTL_RCC_SYSDIV_2 0x00800000 // System clock /2 +#define SYSCTL_RCC_SYSDIV_3 0x01000000 // System clock /3 +#define SYSCTL_RCC_SYSDIV_4 0x01800000 // System clock /4 +#define SYSCTL_RCC_SYSDIV_5 0x02000000 // System clock /5 +#define SYSCTL_RCC_SYSDIV_6 0x02800000 // System clock /6 +#define SYSCTL_RCC_SYSDIV_7 0x03000000 // System clock /7 +#define SYSCTL_RCC_SYSDIV_8 0x03800000 // System clock /8 +#define SYSCTL_RCC_SYSDIV_9 0x04000000 // System clock /9 +#define SYSCTL_RCC_SYSDIV_10 0x04800000 // System clock /10 +#define SYSCTL_RCC_SYSDIV_11 0x05000000 // System clock /11 +#define SYSCTL_RCC_SYSDIV_12 0x05800000 // System clock /12 +#define SYSCTL_RCC_SYSDIV_13 0x06000000 // System clock /13 +#define SYSCTL_RCC_SYSDIV_14 0x06800000 // System clock /14 +#define SYSCTL_RCC_SYSDIV_15 0x07000000 // System clock /15 +#define SYSCTL_RCC_SYSDIV_16 0x07800000 // System clock /16 +#define SYSCTL_RCC_USESYSDIV 0x00400000 // Enable System Clock Divider +#define SYSCTL_RCC_USEPWMDIV 0x00100000 // Enable PWM Clock Divisor +#define SYSCTL_RCC_PWMDIV_M 0x000E0000 // PWM Unit Clock Divisor +#define SYSCTL_RCC_PWMDIV_2 0x00000000 // PWM clock /2 +#define SYSCTL_RCC_PWMDIV_4 0x00020000 // PWM clock /4 +#define SYSCTL_RCC_PWMDIV_8 0x00040000 // PWM clock /8 +#define SYSCTL_RCC_PWMDIV_16 0x00060000 // PWM clock /16 +#define SYSCTL_RCC_PWMDIV_32 0x00080000 // PWM clock /32 +#define SYSCTL_RCC_PWMDIV_64 0x000A0000 // PWM clock /64 +#define SYSCTL_RCC_PWRDN 0x00002000 // PLL Power Down +#define SYSCTL_RCC_BYPASS 0x00000800 // PLL Bypass +#define SYSCTL_RCC_XTAL_M 0x000003C0 // Crystal Value +#define SYSCTL_RCC_XTAL_1MHZ 0x00000000 // 1 MHz +#define SYSCTL_RCC_XTAL_1_84MHZ 0x00000040 // 1.8432 MHz +#define SYSCTL_RCC_XTAL_2MHZ 0x00000080 // 2 MHz +#define SYSCTL_RCC_XTAL_2_45MHZ 0x000000C0 // 2.4576 MHz +#define SYSCTL_RCC_XTAL_3_57MHZ 0x00000100 // 3.579545 MHz +#define SYSCTL_RCC_XTAL_3_68MHZ 0x00000140 // 3.6864 MHz +#define SYSCTL_RCC_XTAL_4MHZ 0x00000180 // 4 MHz +#define SYSCTL_RCC_XTAL_4_09MHZ 0x000001C0 // 4.096 MHz +#define SYSCTL_RCC_XTAL_4_91MHZ 0x00000200 // 4.9152 MHz +#define SYSCTL_RCC_XTAL_5MHZ 0x00000240 // 5 MHz +#define SYSCTL_RCC_XTAL_5_12MHZ 0x00000280 // 5.12 MHz +#define SYSCTL_RCC_XTAL_6MHZ 0x000002C0 // 6 MHz +#define SYSCTL_RCC_XTAL_6_14MHZ 0x00000300 // 6.144 MHz +#define SYSCTL_RCC_XTAL_7_37MHZ 0x00000340 // 7.3728 MHz +#define SYSCTL_RCC_XTAL_8MHZ 0x00000380 // 8 MHz +#define SYSCTL_RCC_XTAL_8_19MHZ 0x000003C0 // 8.192 MHz +#define SYSCTL_RCC_OSCSRC_M 0x00000030 // Oscillator Source +#define SYSCTL_RCC_OSCSRC_MAIN 0x00000000 // MOSC +#define SYSCTL_RCC_OSCSRC_INT 0x00000010 // IOSC +#define SYSCTL_RCC_OSCSRC_INT4 0x00000020 // IOSC/4 +#define SYSCTL_RCC_OSCSRC_30 0x00000030 // 30 kHz +#define SYSCTL_RCC_IOSCDIS 0x00000002 // Internal Oscillator Disable +#define SYSCTL_RCC_MOSCDIS 0x00000001 // Main Oscillator Disable +#define SYSCTL_RCC_SYSDIV_S 23 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_PLLCFG register. +// +//***************************************************************************** +#define SYSCTL_PLLCFG_F_M 0x00003FE0 // PLL F Value +#define SYSCTL_PLLCFG_R_M 0x0000001F // PLL R Value +#define SYSCTL_PLLCFG_F_S 5 +#define SYSCTL_PLLCFG_R_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RCC2 register. +// +//***************************************************************************** +#define SYSCTL_RCC2_USERCC2 0x80000000 // Use RCC2 +#define SYSCTL_RCC2_SYSDIV2_M 0x1F800000 // System Clock Divisor 2 +#define SYSCTL_RCC2_SYSDIV2_2 0x00800000 // System clock /2 +#define SYSCTL_RCC2_SYSDIV2_3 0x01000000 // System clock /3 +#define SYSCTL_RCC2_SYSDIV2_4 0x01800000 // System clock /4 +#define SYSCTL_RCC2_SYSDIV2_5 0x02000000 // System clock /5 +#define SYSCTL_RCC2_SYSDIV2_6 0x02800000 // System clock /6 +#define SYSCTL_RCC2_SYSDIV2_7 0x03000000 // System clock /7 +#define SYSCTL_RCC2_SYSDIV2_8 0x03800000 // System clock /8 +#define SYSCTL_RCC2_SYSDIV2_9 0x04000000 // System clock /9 +#define SYSCTL_RCC2_SYSDIV2_10 0x04800000 // System clock /10 +#define SYSCTL_RCC2_SYSDIV2_11 0x05000000 // System clock /11 +#define SYSCTL_RCC2_SYSDIV2_12 0x05800000 // System clock /12 +#define SYSCTL_RCC2_SYSDIV2_13 0x06000000 // System clock /13 +#define SYSCTL_RCC2_SYSDIV2_14 0x06800000 // System clock /14 +#define SYSCTL_RCC2_SYSDIV2_15 0x07000000 // System clock /15 +#define SYSCTL_RCC2_SYSDIV2_16 0x07800000 // System clock /16 +#define SYSCTL_RCC2_SYSDIV2_17 0x08000000 // System clock /17 +#define SYSCTL_RCC2_SYSDIV2_18 0x08800000 // System clock /18 +#define SYSCTL_RCC2_SYSDIV2_19 0x09000000 // System clock /19 +#define SYSCTL_RCC2_SYSDIV2_20 0x09800000 // System clock /20 +#define SYSCTL_RCC2_SYSDIV2_21 0x0A000000 // System clock /21 +#define SYSCTL_RCC2_SYSDIV2_22 0x0A800000 // System clock /22 +#define SYSCTL_RCC2_SYSDIV2_23 0x0B000000 // System clock /23 +#define SYSCTL_RCC2_SYSDIV2_24 0x0B800000 // System clock /24 +#define SYSCTL_RCC2_SYSDIV2_25 0x0C000000 // System clock /25 +#define SYSCTL_RCC2_SYSDIV2_26 0x0C800000 // System clock /26 +#define SYSCTL_RCC2_SYSDIV2_27 0x0D000000 // System clock /27 +#define SYSCTL_RCC2_SYSDIV2_28 0x0D800000 // System clock /28 +#define SYSCTL_RCC2_SYSDIV2_29 0x0E000000 // System clock /29 +#define SYSCTL_RCC2_SYSDIV2_30 0x0E800000 // System clock /30 +#define SYSCTL_RCC2_SYSDIV2_31 0x0F000000 // System clock /31 +#define SYSCTL_RCC2_SYSDIV2_32 0x0F800000 // System clock /32 +#define SYSCTL_RCC2_SYSDIV2_33 0x10000000 // System clock /33 +#define SYSCTL_RCC2_SYSDIV2_34 0x10800000 // System clock /34 +#define SYSCTL_RCC2_SYSDIV2_35 0x11000000 // System clock /35 +#define SYSCTL_RCC2_SYSDIV2_36 0x11800000 // System clock /36 +#define SYSCTL_RCC2_SYSDIV2_37 0x12000000 // System clock /37 +#define SYSCTL_RCC2_SYSDIV2_38 0x12800000 // System clock /38 +#define SYSCTL_RCC2_SYSDIV2_39 0x13000000 // System clock /39 +#define SYSCTL_RCC2_SYSDIV2_40 0x13800000 // System clock /40 +#define SYSCTL_RCC2_SYSDIV2_41 0x14000000 // System clock /41 +#define SYSCTL_RCC2_SYSDIV2_42 0x14800000 // System clock /42 +#define SYSCTL_RCC2_SYSDIV2_43 0x15000000 // System clock /43 +#define SYSCTL_RCC2_SYSDIV2_44 0x15800000 // System clock /44 +#define SYSCTL_RCC2_SYSDIV2_45 0x16000000 // System clock /45 +#define SYSCTL_RCC2_SYSDIV2_46 0x16800000 // System clock /46 +#define SYSCTL_RCC2_SYSDIV2_47 0x17000000 // System clock /47 +#define SYSCTL_RCC2_SYSDIV2_48 0x17800000 // System clock /48 +#define SYSCTL_RCC2_SYSDIV2_49 0x18000000 // System clock /49 +#define SYSCTL_RCC2_SYSDIV2_50 0x18800000 // System clock /50 +#define SYSCTL_RCC2_SYSDIV2_51 0x19000000 // System clock /51 +#define SYSCTL_RCC2_SYSDIV2_52 0x19800000 // System clock /52 +#define SYSCTL_RCC2_SYSDIV2_53 0x1A000000 // System clock /53 +#define SYSCTL_RCC2_SYSDIV2_54 0x1A800000 // System clock /54 +#define SYSCTL_RCC2_SYSDIV2_55 0x1B000000 // System clock /55 +#define SYSCTL_RCC2_SYSDIV2_56 0x1B800000 // System clock /56 +#define SYSCTL_RCC2_SYSDIV2_57 0x1C000000 // System clock /57 +#define SYSCTL_RCC2_SYSDIV2_58 0x1C800000 // System clock /58 +#define SYSCTL_RCC2_SYSDIV2_59 0x1D000000 // System clock /59 +#define SYSCTL_RCC2_SYSDIV2_60 0x1D800000 // System clock /60 +#define SYSCTL_RCC2_SYSDIV2_61 0x1E000000 // System clock /61 +#define SYSCTL_RCC2_SYSDIV2_62 0x1E800000 // System clock /62 +#define SYSCTL_RCC2_SYSDIV2_63 0x1F000000 // System clock /63 +#define SYSCTL_RCC2_SYSDIV2_64 0x1F800000 // System clock /64 +#define SYSCTL_RCC2_PWRDN2 0x00002000 // Power-Down PLL 2 +#define SYSCTL_RCC2_BYPASS2 0x00000800 // PLL Bypass 2 +#define SYSCTL_RCC2_OSCSRC2_M 0x00000070 // Oscillator Source 2 +#define SYSCTL_RCC2_OSCSRC2_MO 0x00000000 // MOSC +#define SYSCTL_RCC2_OSCSRC2_IO 0x00000010 // PIOSC +#define SYSCTL_RCC2_OSCSRC2_IO4 0x00000020 // PIOSC/4 +#define SYSCTL_RCC2_OSCSRC2_30 0x00000030 // 30 kHz +#define SYSCTL_RCC2_OSCSRC2_32 0x00000070 // 32.768 kHz +#define SYSCTL_RCC2_SYSDIV2_S 23 + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RCGC0 register. +// +//***************************************************************************** +#define SYSCTL_RCGC0_PWM 0x00100000 // PWM Clock Gating Control +#define SYSCTL_RCGC0_ADC 0x00010000 // ADC0 Clock Gating Control +#define SYSCTL_RCGC0_ADCSPD_M 0x00000300 // ADC Sample Speed +#define SYSCTL_RCGC0_ADCSPD125K 0x00000000 // 125K samples/second +#define SYSCTL_RCGC0_ADCSPD250K 0x00000100 // 250K samples/second +#define SYSCTL_RCGC0_ADCSPD500K 0x00000200 // 500K samples/second +#define SYSCTL_RCGC0_ADCSPD1M 0x00000300 // 1M samples/second +#define SYSCTL_RCGC0_HIB 0x00000040 // HIB Clock Gating Control +#define SYSCTL_RCGC0_WDT 0x00000008 // WDT Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RCGC1 register. +// +//***************************************************************************** +#define SYSCTL_RCGC1_COMP1 0x02000000 // Analog Comparator 1 Clock Gating +#define SYSCTL_RCGC1_COMP0 0x01000000 // Analog Comparator 0 Clock Gating +#define SYSCTL_RCGC1_TIMER3 0x00080000 // Timer 3 Clock Gating Control +#define SYSCTL_RCGC1_TIMER2 0x00040000 // Timer 2 Clock Gating Control +#define SYSCTL_RCGC1_TIMER1 0x00020000 // Timer 1 Clock Gating Control +#define SYSCTL_RCGC1_TIMER0 0x00010000 // Timer 0 Clock Gating Control +#define SYSCTL_RCGC1_I2C1 0x00004000 // I2C1 Clock Gating Control +#define SYSCTL_RCGC1_I2C0 0x00001000 // I2C0 Clock Gating Control +#define SYSCTL_RCGC1_QEI1 0x00000200 // QEI1 Clock Gating Control +#define SYSCTL_RCGC1_QEI0 0x00000100 // QEI0 Clock Gating Control +#define SYSCTL_RCGC1_SSI0 0x00000010 // SSI0 Clock Gating Control +#define SYSCTL_RCGC1_UART2 0x00000004 // UART2 Clock Gating Control +#define SYSCTL_RCGC1_UART1 0x00000002 // UART1 Clock Gating Control +#define SYSCTL_RCGC1_UART0 0x00000001 // UART0 Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_RCGC2 register. +// +//***************************************************************************** +#define SYSCTL_RCGC2_EPHY0 0x40000000 // PHY0 Clock Gating Control +#define SYSCTL_RCGC2_EMAC0 0x10000000 // MAC0 Clock Gating Control +#define SYSCTL_RCGC2_GPIOG 0x00000040 // Port G Clock Gating Control +#define SYSCTL_RCGC2_GPIOF 0x00000020 // Port F Clock Gating Control +#define SYSCTL_RCGC2_GPIOE 0x00000010 // Port E Clock Gating Control +#define SYSCTL_RCGC2_GPIOD 0x00000008 // Port D Clock Gating Control +#define SYSCTL_RCGC2_GPIOC 0x00000004 // Port C Clock Gating Control +#define SYSCTL_RCGC2_GPIOB 0x00000002 // Port B Clock Gating Control +#define SYSCTL_RCGC2_GPIOA 0x00000001 // Port A Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SCGC0 register. +// +//***************************************************************************** +#define SYSCTL_SCGC0_PWM 0x00100000 // PWM Clock Gating Control +#define SYSCTL_SCGC0_ADC 0x00010000 // ADC0 Clock Gating Control +#define SYSCTL_SCGC0_ADCSPD_M 0x00000300 // ADC Sample Speed +#define SYSCTL_SCGC0_ADCSPD125K 0x00000000 // 125K samples/second +#define SYSCTL_SCGC0_ADCSPD250K 0x00000100 // 250K samples/second +#define SYSCTL_SCGC0_ADCSPD500K 0x00000200 // 500K samples/second +#define SYSCTL_SCGC0_ADCSPD1M 0x00000300 // 1M samples/second +#define SYSCTL_SCGC0_HIB 0x00000040 // HIB Clock Gating Control +#define SYSCTL_SCGC0_WDT 0x00000008 // WDT Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SCGC1 register. +// +//***************************************************************************** +#define SYSCTL_SCGC1_COMP1 0x02000000 // Analog Comparator 1 Clock Gating +#define SYSCTL_SCGC1_COMP0 0x01000000 // Analog Comparator 0 Clock Gating +#define SYSCTL_SCGC1_TIMER3 0x00080000 // Timer 3 Clock Gating Control +#define SYSCTL_SCGC1_TIMER2 0x00040000 // Timer 2 Clock Gating Control +#define SYSCTL_SCGC1_TIMER1 0x00020000 // Timer 1 Clock Gating Control +#define SYSCTL_SCGC1_TIMER0 0x00010000 // Timer 0 Clock Gating Control +#define SYSCTL_SCGC1_I2C1 0x00004000 // I2C1 Clock Gating Control +#define SYSCTL_SCGC1_I2C0 0x00001000 // I2C0 Clock Gating Control +#define SYSCTL_SCGC1_QEI1 0x00000200 // QEI1 Clock Gating Control +#define SYSCTL_SCGC1_QEI0 0x00000100 // QEI0 Clock Gating Control +#define SYSCTL_SCGC1_SSI0 0x00000010 // SSI0 Clock Gating Control +#define SYSCTL_SCGC1_UART2 0x00000004 // UART2 Clock Gating Control +#define SYSCTL_SCGC1_UART1 0x00000002 // UART1 Clock Gating Control +#define SYSCTL_SCGC1_UART0 0x00000001 // UART0 Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_SCGC2 register. +// +//***************************************************************************** +#define SYSCTL_SCGC2_EPHY0 0x40000000 // PHY0 Clock Gating Control +#define SYSCTL_SCGC2_EMAC0 0x10000000 // MAC0 Clock Gating Control +#define SYSCTL_SCGC2_GPIOG 0x00000040 // Port G Clock Gating Control +#define SYSCTL_SCGC2_GPIOF 0x00000020 // Port F Clock Gating Control +#define SYSCTL_SCGC2_GPIOE 0x00000010 // Port E Clock Gating Control +#define SYSCTL_SCGC2_GPIOD 0x00000008 // Port D Clock Gating Control +#define SYSCTL_SCGC2_GPIOC 0x00000004 // Port C Clock Gating Control +#define SYSCTL_SCGC2_GPIOB 0x00000002 // Port B Clock Gating Control +#define SYSCTL_SCGC2_GPIOA 0x00000001 // Port A Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DCGC0 register. +// +//***************************************************************************** +#define SYSCTL_DCGC0_PWM 0x00100000 // PWM Clock Gating Control +#define SYSCTL_DCGC0_ADC 0x00010000 // ADC0 Clock Gating Control +#define SYSCTL_DCGC0_HIB 0x00000040 // HIB Clock Gating Control +#define SYSCTL_DCGC0_WDT 0x00000008 // WDT Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DCGC1 register. +// +//***************************************************************************** +#define SYSCTL_DCGC1_COMP1 0x02000000 // Analog Comparator 1 Clock Gating +#define SYSCTL_DCGC1_COMP0 0x01000000 // Analog Comparator 0 Clock Gating +#define SYSCTL_DCGC1_TIMER3 0x00080000 // Timer 3 Clock Gating Control +#define SYSCTL_DCGC1_TIMER2 0x00040000 // Timer 2 Clock Gating Control +#define SYSCTL_DCGC1_TIMER1 0x00020000 // Timer 1 Clock Gating Control +#define SYSCTL_DCGC1_TIMER0 0x00010000 // Timer 0 Clock Gating Control +#define SYSCTL_DCGC1_I2C1 0x00004000 // I2C1 Clock Gating Control +#define SYSCTL_DCGC1_I2C0 0x00001000 // I2C0 Clock Gating Control +#define SYSCTL_DCGC1_QEI1 0x00000200 // QEI1 Clock Gating Control +#define SYSCTL_DCGC1_QEI0 0x00000100 // QEI0 Clock Gating Control +#define SYSCTL_DCGC1_SSI0 0x00000010 // SSI0 Clock Gating Control +#define SYSCTL_DCGC1_UART2 0x00000004 // UART2 Clock Gating Control +#define SYSCTL_DCGC1_UART1 0x00000002 // UART1 Clock Gating Control +#define SYSCTL_DCGC1_UART0 0x00000001 // UART0 Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DCGC2 register. +// +//***************************************************************************** +#define SYSCTL_DCGC2_EPHY0 0x40000000 // PHY0 Clock Gating Control +#define SYSCTL_DCGC2_EMAC0 0x10000000 // MAC0 Clock Gating Control +#define SYSCTL_DCGC2_GPIOG 0x00000040 // Port G Clock Gating Control +#define SYSCTL_DCGC2_GPIOF 0x00000020 // Port F Clock Gating Control +#define SYSCTL_DCGC2_GPIOE 0x00000010 // Port E Clock Gating Control +#define SYSCTL_DCGC2_GPIOD 0x00000008 // Port D Clock Gating Control +#define SYSCTL_DCGC2_GPIOC 0x00000004 // Port C Clock Gating Control +#define SYSCTL_DCGC2_GPIOB 0x00000002 // Port B Clock Gating Control +#define SYSCTL_DCGC2_GPIOA 0x00000001 // Port A Clock Gating Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the SYSCTL_DSLPCLKCFG +// register. +// +//***************************************************************************** +#define SYSCTL_DSLPCLKCFG_D_M 0x1F800000 // Divider Field Override +#define SYSCTL_DSLPCLKCFG_D_1 0x00000000 // System clock /1 +#define SYSCTL_DSLPCLKCFG_D_2 0x00800000 // System clock /2 +#define SYSCTL_DSLPCLKCFG_D_3 0x01000000 // System clock /3 +#define SYSCTL_DSLPCLKCFG_D_4 0x01800000 // System clock /4 +#define SYSCTL_DSLPCLKCFG_D_5 0x02000000 // System clock /5 +#define SYSCTL_DSLPCLKCFG_D_6 0x02800000 // System clock /6 +#define SYSCTL_DSLPCLKCFG_D_7 0x03000000 // System clock /7 +#define SYSCTL_DSLPCLKCFG_D_8 0x03800000 // System clock /8 +#define SYSCTL_DSLPCLKCFG_D_9 0x04000000 // System clock /9 +#define SYSCTL_DSLPCLKCFG_D_10 0x04800000 // System clock /10 +#define SYSCTL_DSLPCLKCFG_D_11 0x05000000 // System clock /11 +#define SYSCTL_DSLPCLKCFG_D_12 0x05800000 // System clock /12 +#define SYSCTL_DSLPCLKCFG_D_13 0x06000000 // System clock /13 +#define SYSCTL_DSLPCLKCFG_D_14 0x06800000 // System clock /14 +#define SYSCTL_DSLPCLKCFG_D_15 0x07000000 // System clock /15 +#define SYSCTL_DSLPCLKCFG_D_16 0x07800000 // System clock /16 +#define SYSCTL_DSLPCLKCFG_D_17 0x08000000 // System clock /17 +#define SYSCTL_DSLPCLKCFG_D_18 0x08800000 // System clock /18 +#define SYSCTL_DSLPCLKCFG_D_19 0x09000000 // System clock /19 +#define SYSCTL_DSLPCLKCFG_D_20 0x09800000 // System clock /20 +#define SYSCTL_DSLPCLKCFG_D_21 0x0A000000 // System clock /21 +#define SYSCTL_DSLPCLKCFG_D_22 0x0A800000 // System clock /22 +#define SYSCTL_DSLPCLKCFG_D_23 0x0B000000 // System clock /23 +#define SYSCTL_DSLPCLKCFG_D_24 0x0B800000 // System clock /24 +#define SYSCTL_DSLPCLKCFG_D_25 0x0C000000 // System clock /25 +#define SYSCTL_DSLPCLKCFG_D_26 0x0C800000 // System clock /26 +#define SYSCTL_DSLPCLKCFG_D_27 0x0D000000 // System clock /27 +#define SYSCTL_DSLPCLKCFG_D_28 0x0D800000 // System clock /28 +#define SYSCTL_DSLPCLKCFG_D_29 0x0E000000 // System clock /29 +#define SYSCTL_DSLPCLKCFG_D_30 0x0E800000 // System clock /30 +#define SYSCTL_DSLPCLKCFG_D_31 0x0F000000 // System clock /31 +#define SYSCTL_DSLPCLKCFG_D_32 0x0F800000 // System clock /32 +#define SYSCTL_DSLPCLKCFG_D_33 0x10000000 // System clock /33 +#define SYSCTL_DSLPCLKCFG_D_34 0x10800000 // System clock /34 +#define SYSCTL_DSLPCLKCFG_D_35 0x11000000 // System clock /35 +#define SYSCTL_DSLPCLKCFG_D_36 0x11800000 // System clock /36 +#define SYSCTL_DSLPCLKCFG_D_37 0x12000000 // System clock /37 +#define SYSCTL_DSLPCLKCFG_D_38 0x12800000 // System clock /38 +#define SYSCTL_DSLPCLKCFG_D_39 0x13000000 // System clock /39 +#define SYSCTL_DSLPCLKCFG_D_40 0x13800000 // System clock /40 +#define SYSCTL_DSLPCLKCFG_D_41 0x14000000 // System clock /41 +#define SYSCTL_DSLPCLKCFG_D_42 0x14800000 // System clock /42 +#define SYSCTL_DSLPCLKCFG_D_43 0x15000000 // System clock /43 +#define SYSCTL_DSLPCLKCFG_D_44 0x15800000 // System clock /44 +#define SYSCTL_DSLPCLKCFG_D_45 0x16000000 // System clock /45 +#define SYSCTL_DSLPCLKCFG_D_46 0x16800000 // System clock /46 +#define SYSCTL_DSLPCLKCFG_D_47 0x17000000 // System clock /47 +#define SYSCTL_DSLPCLKCFG_D_48 0x17800000 // System clock /48 +#define SYSCTL_DSLPCLKCFG_D_49 0x18000000 // System clock /49 +#define SYSCTL_DSLPCLKCFG_D_50 0x18800000 // System clock /50 +#define SYSCTL_DSLPCLKCFG_D_51 0x19000000 // System clock /51 +#define SYSCTL_DSLPCLKCFG_D_52 0x19800000 // System clock /52 +#define SYSCTL_DSLPCLKCFG_D_53 0x1A000000 // System clock /53 +#define SYSCTL_DSLPCLKCFG_D_54 0x1A800000 // System clock /54 +#define SYSCTL_DSLPCLKCFG_D_55 0x1B000000 // System clock /55 +#define SYSCTL_DSLPCLKCFG_D_56 0x1B800000 // System clock /56 +#define SYSCTL_DSLPCLKCFG_D_57 0x1C000000 // System clock /57 +#define SYSCTL_DSLPCLKCFG_D_58 0x1C800000 // System clock /58 +#define SYSCTL_DSLPCLKCFG_D_59 0x1D000000 // System clock /59 +#define SYSCTL_DSLPCLKCFG_D_60 0x1D800000 // System clock /60 +#define SYSCTL_DSLPCLKCFG_D_61 0x1E000000 // System clock /61 +#define SYSCTL_DSLPCLKCFG_D_62 0x1E800000 // System clock /62 +#define SYSCTL_DSLPCLKCFG_D_63 0x1F000000 // System clock /63 +#define SYSCTL_DSLPCLKCFG_D_64 0x1F800000 // System clock /64 +#define SYSCTL_DSLPCLKCFG_O_M 0x00000070 // Clock Source +#define SYSCTL_DSLPCLKCFG_O_IGN 0x00000000 // MOSC +#define SYSCTL_DSLPCLKCFG_O_IO 0x00000010 // PIOSC +#define SYSCTL_DSLPCLKCFG_O_30 0x00000030 // 30 kHz +#define SYSCTL_DSLPCLKCFG_O_32 0x00000070 // 32.768 kHz +#define SYSCTL_DSLPCLKCFG_D_S 23 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_INT_TYPE register. +// +//***************************************************************************** +#define NVIC_INT_TYPE_LINES_M 0x0000001F // Number of interrupt lines (x32) +#define NVIC_INT_TYPE_LINES_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ST_CTRL register. +// +//***************************************************************************** +#define NVIC_ST_CTRL_COUNT 0x00010000 // Count Flag +#define NVIC_ST_CTRL_CLK_SRC 0x00000004 // Clock Source +#define NVIC_ST_CTRL_INTEN 0x00000002 // Interrupt Enable +#define NVIC_ST_CTRL_ENABLE 0x00000001 // Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ST_RELOAD register. +// +//***************************************************************************** +#define NVIC_ST_RELOAD_M 0x00FFFFFF // Reload Value +#define NVIC_ST_RELOAD_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ST_CURRENT +// register. +// +//***************************************************************************** +#define NVIC_ST_CURRENT_M 0x00FFFFFF // Current Value +#define NVIC_ST_CURRENT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ST_CAL register. +// +//***************************************************************************** +#define NVIC_ST_CAL_NOREF 0x80000000 // No reference clock +#define NVIC_ST_CAL_SKEW 0x40000000 // Clock skew +#define NVIC_ST_CAL_ONEMS_M 0x00FFFFFF // 1ms reference value +#define NVIC_ST_CAL_ONEMS_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_EN0 register. +// +//***************************************************************************** +#define NVIC_EN0_INT_M 0xFFFFFFFF // Interrupt Enable +#define NVIC_EN0_INT0 0x00000001 // Interrupt 0 enable +#define NVIC_EN0_INT1 0x00000002 // Interrupt 1 enable +#define NVIC_EN0_INT2 0x00000004 // Interrupt 2 enable +#define NVIC_EN0_INT3 0x00000008 // Interrupt 3 enable +#define NVIC_EN0_INT4 0x00000010 // Interrupt 4 enable +#define NVIC_EN0_INT5 0x00000020 // Interrupt 5 enable +#define NVIC_EN0_INT6 0x00000040 // Interrupt 6 enable +#define NVIC_EN0_INT7 0x00000080 // Interrupt 7 enable +#define NVIC_EN0_INT8 0x00000100 // Interrupt 8 enable +#define NVIC_EN0_INT9 0x00000200 // Interrupt 9 enable +#define NVIC_EN0_INT10 0x00000400 // Interrupt 10 enable +#define NVIC_EN0_INT11 0x00000800 // Interrupt 11 enable +#define NVIC_EN0_INT12 0x00001000 // Interrupt 12 enable +#define NVIC_EN0_INT13 0x00002000 // Interrupt 13 enable +#define NVIC_EN0_INT14 0x00004000 // Interrupt 14 enable +#define NVIC_EN0_INT15 0x00008000 // Interrupt 15 enable +#define NVIC_EN0_INT16 0x00010000 // Interrupt 16 enable +#define NVIC_EN0_INT17 0x00020000 // Interrupt 17 enable +#define NVIC_EN0_INT18 0x00040000 // Interrupt 18 enable +#define NVIC_EN0_INT19 0x00080000 // Interrupt 19 enable +#define NVIC_EN0_INT20 0x00100000 // Interrupt 20 enable +#define NVIC_EN0_INT21 0x00200000 // Interrupt 21 enable +#define NVIC_EN0_INT22 0x00400000 // Interrupt 22 enable +#define NVIC_EN0_INT23 0x00800000 // Interrupt 23 enable +#define NVIC_EN0_INT24 0x01000000 // Interrupt 24 enable +#define NVIC_EN0_INT25 0x02000000 // Interrupt 25 enable +#define NVIC_EN0_INT26 0x04000000 // Interrupt 26 enable +#define NVIC_EN0_INT27 0x08000000 // Interrupt 27 enable +#define NVIC_EN0_INT28 0x10000000 // Interrupt 28 enable +#define NVIC_EN0_INT29 0x20000000 // Interrupt 29 enable +#define NVIC_EN0_INT30 0x40000000 // Interrupt 30 enable +#define NVIC_EN0_INT31 0x80000000 // Interrupt 31 enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_EN1 register. +// +//***************************************************************************** +#define NVIC_EN1_INT_M 0x00000FFF // Interrupt Enable +#define NVIC_EN1_INT32 0x00000001 // Interrupt 32 enable +#define NVIC_EN1_INT33 0x00000002 // Interrupt 33 enable +#define NVIC_EN1_INT34 0x00000004 // Interrupt 34 enable +#define NVIC_EN1_INT35 0x00000008 // Interrupt 35 enable +#define NVIC_EN1_INT36 0x00000010 // Interrupt 36 enable +#define NVIC_EN1_INT37 0x00000020 // Interrupt 37 enable +#define NVIC_EN1_INT38 0x00000040 // Interrupt 38 enable +#define NVIC_EN1_INT39 0x00000080 // Interrupt 39 enable +#define NVIC_EN1_INT40 0x00000100 // Interrupt 40 enable +#define NVIC_EN1_INT41 0x00000200 // Interrupt 41 enable +#define NVIC_EN1_INT42 0x00000400 // Interrupt 42 enable +#define NVIC_EN1_INT43 0x00000800 // Interrupt 43 enable +#define NVIC_EN1_INT44 0x00001000 // Interrupt 44 enable +#define NVIC_EN1_INT45 0x00002000 // Interrupt 45 enable +#define NVIC_EN1_INT46 0x00004000 // Interrupt 46 enable +#define NVIC_EN1_INT47 0x00008000 // Interrupt 47 enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DIS0 register. +// +//***************************************************************************** +#define NVIC_DIS0_INT_M 0xFFFFFFFF // Interrupt Disable +#define NVIC_DIS0_INT0 0x00000001 // Interrupt 0 disable +#define NVIC_DIS0_INT1 0x00000002 // Interrupt 1 disable +#define NVIC_DIS0_INT2 0x00000004 // Interrupt 2 disable +#define NVIC_DIS0_INT3 0x00000008 // Interrupt 3 disable +#define NVIC_DIS0_INT4 0x00000010 // Interrupt 4 disable +#define NVIC_DIS0_INT5 0x00000020 // Interrupt 5 disable +#define NVIC_DIS0_INT6 0x00000040 // Interrupt 6 disable +#define NVIC_DIS0_INT7 0x00000080 // Interrupt 7 disable +#define NVIC_DIS0_INT8 0x00000100 // Interrupt 8 disable +#define NVIC_DIS0_INT9 0x00000200 // Interrupt 9 disable +#define NVIC_DIS0_INT10 0x00000400 // Interrupt 10 disable +#define NVIC_DIS0_INT11 0x00000800 // Interrupt 11 disable +#define NVIC_DIS0_INT12 0x00001000 // Interrupt 12 disable +#define NVIC_DIS0_INT13 0x00002000 // Interrupt 13 disable +#define NVIC_DIS0_INT14 0x00004000 // Interrupt 14 disable +#define NVIC_DIS0_INT15 0x00008000 // Interrupt 15 disable +#define NVIC_DIS0_INT16 0x00010000 // Interrupt 16 disable +#define NVIC_DIS0_INT17 0x00020000 // Interrupt 17 disable +#define NVIC_DIS0_INT18 0x00040000 // Interrupt 18 disable +#define NVIC_DIS0_INT19 0x00080000 // Interrupt 19 disable +#define NVIC_DIS0_INT20 0x00100000 // Interrupt 20 disable +#define NVIC_DIS0_INT21 0x00200000 // Interrupt 21 disable +#define NVIC_DIS0_INT22 0x00400000 // Interrupt 22 disable +#define NVIC_DIS0_INT23 0x00800000 // Interrupt 23 disable +#define NVIC_DIS0_INT24 0x01000000 // Interrupt 24 disable +#define NVIC_DIS0_INT25 0x02000000 // Interrupt 25 disable +#define NVIC_DIS0_INT26 0x04000000 // Interrupt 26 disable +#define NVIC_DIS0_INT27 0x08000000 // Interrupt 27 disable +#define NVIC_DIS0_INT28 0x10000000 // Interrupt 28 disable +#define NVIC_DIS0_INT29 0x20000000 // Interrupt 29 disable +#define NVIC_DIS0_INT30 0x40000000 // Interrupt 30 disable +#define NVIC_DIS0_INT31 0x80000000 // Interrupt 31 disable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DIS1 register. +// +//***************************************************************************** +#define NVIC_DIS1_INT_M 0x00000FFF // Interrupt Disable +#define NVIC_DIS1_INT32 0x00000001 // Interrupt 32 disable +#define NVIC_DIS1_INT33 0x00000002 // Interrupt 33 disable +#define NVIC_DIS1_INT34 0x00000004 // Interrupt 34 disable +#define NVIC_DIS1_INT35 0x00000008 // Interrupt 35 disable +#define NVIC_DIS1_INT36 0x00000010 // Interrupt 36 disable +#define NVIC_DIS1_INT37 0x00000020 // Interrupt 37 disable +#define NVIC_DIS1_INT38 0x00000040 // Interrupt 38 disable +#define NVIC_DIS1_INT39 0x00000080 // Interrupt 39 disable +#define NVIC_DIS1_INT40 0x00000100 // Interrupt 40 disable +#define NVIC_DIS1_INT41 0x00000200 // Interrupt 41 disable +#define NVIC_DIS1_INT42 0x00000400 // Interrupt 42 disable +#define NVIC_DIS1_INT43 0x00000800 // Interrupt 43 disable +#define NVIC_DIS1_INT44 0x00001000 // Interrupt 44 disable +#define NVIC_DIS1_INT45 0x00002000 // Interrupt 45 disable +#define NVIC_DIS1_INT46 0x00004000 // Interrupt 46 disable +#define NVIC_DIS1_INT47 0x00008000 // Interrupt 47 disable +#define NVIC_DIS1_INT48 0x00010000 // Interrupt 48 disable +#define NVIC_DIS1_INT49 0x00020000 // Interrupt 49 disable +#define NVIC_DIS1_INT50 0x00040000 // Interrupt 50 disable +#define NVIC_DIS1_INT51 0x00080000 // Interrupt 51 disable +#define NVIC_DIS1_INT52 0x00100000 // Interrupt 52 disable +#define NVIC_DIS1_INT53 0x00200000 // Interrupt 53 disable +#define NVIC_DIS1_INT54 0x00400000 // Interrupt 54 disable +#define NVIC_DIS1_INT55 0x00800000 // Interrupt 55 disable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PEND0 register. +// +//***************************************************************************** +#define NVIC_PEND0_INT_M 0xFFFFFFFF // Interrupt Set Pending +#define NVIC_PEND0_INT0 0x00000001 // Interrupt 0 pend +#define NVIC_PEND0_INT1 0x00000002 // Interrupt 1 pend +#define NVIC_PEND0_INT2 0x00000004 // Interrupt 2 pend +#define NVIC_PEND0_INT3 0x00000008 // Interrupt 3 pend +#define NVIC_PEND0_INT4 0x00000010 // Interrupt 4 pend +#define NVIC_PEND0_INT5 0x00000020 // Interrupt 5 pend +#define NVIC_PEND0_INT6 0x00000040 // Interrupt 6 pend +#define NVIC_PEND0_INT7 0x00000080 // Interrupt 7 pend +#define NVIC_PEND0_INT8 0x00000100 // Interrupt 8 pend +#define NVIC_PEND0_INT9 0x00000200 // Interrupt 9 pend +#define NVIC_PEND0_INT10 0x00000400 // Interrupt 10 pend +#define NVIC_PEND0_INT11 0x00000800 // Interrupt 11 pend +#define NVIC_PEND0_INT12 0x00001000 // Interrupt 12 pend +#define NVIC_PEND0_INT13 0x00002000 // Interrupt 13 pend +#define NVIC_PEND0_INT14 0x00004000 // Interrupt 14 pend +#define NVIC_PEND0_INT15 0x00008000 // Interrupt 15 pend +#define NVIC_PEND0_INT16 0x00010000 // Interrupt 16 pend +#define NVIC_PEND0_INT17 0x00020000 // Interrupt 17 pend +#define NVIC_PEND0_INT18 0x00040000 // Interrupt 18 pend +#define NVIC_PEND0_INT19 0x00080000 // Interrupt 19 pend +#define NVIC_PEND0_INT20 0x00100000 // Interrupt 20 pend +#define NVIC_PEND0_INT21 0x00200000 // Interrupt 21 pend +#define NVIC_PEND0_INT22 0x00400000 // Interrupt 22 pend +#define NVIC_PEND0_INT23 0x00800000 // Interrupt 23 pend +#define NVIC_PEND0_INT24 0x01000000 // Interrupt 24 pend +#define NVIC_PEND0_INT25 0x02000000 // Interrupt 25 pend +#define NVIC_PEND0_INT26 0x04000000 // Interrupt 26 pend +#define NVIC_PEND0_INT27 0x08000000 // Interrupt 27 pend +#define NVIC_PEND0_INT28 0x10000000 // Interrupt 28 pend +#define NVIC_PEND0_INT29 0x20000000 // Interrupt 29 pend +#define NVIC_PEND0_INT30 0x40000000 // Interrupt 30 pend +#define NVIC_PEND0_INT31 0x80000000 // Interrupt 31 pend + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PEND1 register. +// +//***************************************************************************** +#define NVIC_PEND1_INT_M 0x00000FFF // Interrupt Set Pending +#define NVIC_PEND1_INT32 0x00000001 // Interrupt 32 pend +#define NVIC_PEND1_INT33 0x00000002 // Interrupt 33 pend +#define NVIC_PEND1_INT34 0x00000004 // Interrupt 34 pend +#define NVIC_PEND1_INT35 0x00000008 // Interrupt 35 pend +#define NVIC_PEND1_INT36 0x00000010 // Interrupt 36 pend +#define NVIC_PEND1_INT37 0x00000020 // Interrupt 37 pend +#define NVIC_PEND1_INT38 0x00000040 // Interrupt 38 pend +#define NVIC_PEND1_INT39 0x00000080 // Interrupt 39 pend +#define NVIC_PEND1_INT40 0x00000100 // Interrupt 40 pend +#define NVIC_PEND1_INT41 0x00000200 // Interrupt 41 pend +#define NVIC_PEND1_INT42 0x00000400 // Interrupt 42 pend +#define NVIC_PEND1_INT43 0x00000800 // Interrupt 43 pend +#define NVIC_PEND1_INT44 0x00001000 // Interrupt 44 pend +#define NVIC_PEND1_INT45 0x00002000 // Interrupt 45 pend +#define NVIC_PEND1_INT46 0x00004000 // Interrupt 46 pend +#define NVIC_PEND1_INT47 0x00008000 // Interrupt 47 pend +#define NVIC_PEND1_INT48 0x00010000 // Interrupt 48 pend +#define NVIC_PEND1_INT49 0x00020000 // Interrupt 49 pend +#define NVIC_PEND1_INT50 0x00040000 // Interrupt 50 pend +#define NVIC_PEND1_INT51 0x00080000 // Interrupt 51 pend +#define NVIC_PEND1_INT52 0x00100000 // Interrupt 52 pend +#define NVIC_PEND1_INT53 0x00200000 // Interrupt 53 pend +#define NVIC_PEND1_INT54 0x00400000 // Interrupt 54 pend +#define NVIC_PEND1_INT55 0x00800000 // Interrupt 55 pend + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_UNPEND0 register. +// +//***************************************************************************** +#define NVIC_UNPEND0_INT_M 0xFFFFFFFF // Interrupt Clear Pending +#define NVIC_UNPEND0_INT0 0x00000001 // Interrupt 0 unpend +#define NVIC_UNPEND0_INT1 0x00000002 // Interrupt 1 unpend +#define NVIC_UNPEND0_INT2 0x00000004 // Interrupt 2 unpend +#define NVIC_UNPEND0_INT3 0x00000008 // Interrupt 3 unpend +#define NVIC_UNPEND0_INT4 0x00000010 // Interrupt 4 unpend +#define NVIC_UNPEND0_INT5 0x00000020 // Interrupt 5 unpend +#define NVIC_UNPEND0_INT6 0x00000040 // Interrupt 6 unpend +#define NVIC_UNPEND0_INT7 0x00000080 // Interrupt 7 unpend +#define NVIC_UNPEND0_INT8 0x00000100 // Interrupt 8 unpend +#define NVIC_UNPEND0_INT9 0x00000200 // Interrupt 9 unpend +#define NVIC_UNPEND0_INT10 0x00000400 // Interrupt 10 unpend +#define NVIC_UNPEND0_INT11 0x00000800 // Interrupt 11 unpend +#define NVIC_UNPEND0_INT12 0x00001000 // Interrupt 12 unpend +#define NVIC_UNPEND0_INT13 0x00002000 // Interrupt 13 unpend +#define NVIC_UNPEND0_INT14 0x00004000 // Interrupt 14 unpend +#define NVIC_UNPEND0_INT15 0x00008000 // Interrupt 15 unpend +#define NVIC_UNPEND0_INT16 0x00010000 // Interrupt 16 unpend +#define NVIC_UNPEND0_INT17 0x00020000 // Interrupt 17 unpend +#define NVIC_UNPEND0_INT18 0x00040000 // Interrupt 18 unpend +#define NVIC_UNPEND0_INT19 0x00080000 // Interrupt 19 unpend +#define NVIC_UNPEND0_INT20 0x00100000 // Interrupt 20 unpend +#define NVIC_UNPEND0_INT21 0x00200000 // Interrupt 21 unpend +#define NVIC_UNPEND0_INT22 0x00400000 // Interrupt 22 unpend +#define NVIC_UNPEND0_INT23 0x00800000 // Interrupt 23 unpend +#define NVIC_UNPEND0_INT24 0x01000000 // Interrupt 24 unpend +#define NVIC_UNPEND0_INT25 0x02000000 // Interrupt 25 unpend +#define NVIC_UNPEND0_INT26 0x04000000 // Interrupt 26 unpend +#define NVIC_UNPEND0_INT27 0x08000000 // Interrupt 27 unpend +#define NVIC_UNPEND0_INT28 0x10000000 // Interrupt 28 unpend +#define NVIC_UNPEND0_INT29 0x20000000 // Interrupt 29 unpend +#define NVIC_UNPEND0_INT30 0x40000000 // Interrupt 30 unpend +#define NVIC_UNPEND0_INT31 0x80000000 // Interrupt 31 unpend + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_UNPEND1 register. +// +//***************************************************************************** +#define NVIC_UNPEND1_INT_M 0x00000FFF // Interrupt Clear Pending +#define NVIC_UNPEND1_INT32 0x00000001 // Interrupt 32 unpend +#define NVIC_UNPEND1_INT33 0x00000002 // Interrupt 33 unpend +#define NVIC_UNPEND1_INT34 0x00000004 // Interrupt 34 unpend +#define NVIC_UNPEND1_INT35 0x00000008 // Interrupt 35 unpend +#define NVIC_UNPEND1_INT36 0x00000010 // Interrupt 36 unpend +#define NVIC_UNPEND1_INT37 0x00000020 // Interrupt 37 unpend +#define NVIC_UNPEND1_INT38 0x00000040 // Interrupt 38 unpend +#define NVIC_UNPEND1_INT39 0x00000080 // Interrupt 39 unpend +#define NVIC_UNPEND1_INT40 0x00000100 // Interrupt 40 unpend +#define NVIC_UNPEND1_INT41 0x00000200 // Interrupt 41 unpend +#define NVIC_UNPEND1_INT42 0x00000400 // Interrupt 42 unpend +#define NVIC_UNPEND1_INT43 0x00000800 // Interrupt 43 unpend +#define NVIC_UNPEND1_INT44 0x00001000 // Interrupt 44 unpend +#define NVIC_UNPEND1_INT45 0x00002000 // Interrupt 45 unpend +#define NVIC_UNPEND1_INT46 0x00004000 // Interrupt 46 unpend +#define NVIC_UNPEND1_INT47 0x00008000 // Interrupt 47 unpend +#define NVIC_UNPEND1_INT48 0x00010000 // Interrupt 48 unpend +#define NVIC_UNPEND1_INT49 0x00020000 // Interrupt 49 unpend +#define NVIC_UNPEND1_INT50 0x00040000 // Interrupt 50 unpend +#define NVIC_UNPEND1_INT51 0x00080000 // Interrupt 51 unpend +#define NVIC_UNPEND1_INT52 0x00100000 // Interrupt 52 unpend +#define NVIC_UNPEND1_INT53 0x00200000 // Interrupt 53 unpend +#define NVIC_UNPEND1_INT54 0x00400000 // Interrupt 54 unpend +#define NVIC_UNPEND1_INT55 0x00800000 // Interrupt 55 unpend + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ACTIVE0 register. +// +//***************************************************************************** +#define NVIC_ACTIVE0_INT_M 0xFFFFFFFF // Interrupt Active +#define NVIC_ACTIVE0_INT0 0x00000001 // Interrupt 0 active +#define NVIC_ACTIVE0_INT1 0x00000002 // Interrupt 1 active +#define NVIC_ACTIVE0_INT2 0x00000004 // Interrupt 2 active +#define NVIC_ACTIVE0_INT3 0x00000008 // Interrupt 3 active +#define NVIC_ACTIVE0_INT4 0x00000010 // Interrupt 4 active +#define NVIC_ACTIVE0_INT5 0x00000020 // Interrupt 5 active +#define NVIC_ACTIVE0_INT6 0x00000040 // Interrupt 6 active +#define NVIC_ACTIVE0_INT7 0x00000080 // Interrupt 7 active +#define NVIC_ACTIVE0_INT8 0x00000100 // Interrupt 8 active +#define NVIC_ACTIVE0_INT9 0x00000200 // Interrupt 9 active +#define NVIC_ACTIVE0_INT10 0x00000400 // Interrupt 10 active +#define NVIC_ACTIVE0_INT11 0x00000800 // Interrupt 11 active +#define NVIC_ACTIVE0_INT12 0x00001000 // Interrupt 12 active +#define NVIC_ACTIVE0_INT13 0x00002000 // Interrupt 13 active +#define NVIC_ACTIVE0_INT14 0x00004000 // Interrupt 14 active +#define NVIC_ACTIVE0_INT15 0x00008000 // Interrupt 15 active +#define NVIC_ACTIVE0_INT16 0x00010000 // Interrupt 16 active +#define NVIC_ACTIVE0_INT17 0x00020000 // Interrupt 17 active +#define NVIC_ACTIVE0_INT18 0x00040000 // Interrupt 18 active +#define NVIC_ACTIVE0_INT19 0x00080000 // Interrupt 19 active +#define NVIC_ACTIVE0_INT20 0x00100000 // Interrupt 20 active +#define NVIC_ACTIVE0_INT21 0x00200000 // Interrupt 21 active +#define NVIC_ACTIVE0_INT22 0x00400000 // Interrupt 22 active +#define NVIC_ACTIVE0_INT23 0x00800000 // Interrupt 23 active +#define NVIC_ACTIVE0_INT24 0x01000000 // Interrupt 24 active +#define NVIC_ACTIVE0_INT25 0x02000000 // Interrupt 25 active +#define NVIC_ACTIVE0_INT26 0x04000000 // Interrupt 26 active +#define NVIC_ACTIVE0_INT27 0x08000000 // Interrupt 27 active +#define NVIC_ACTIVE0_INT28 0x10000000 // Interrupt 28 active +#define NVIC_ACTIVE0_INT29 0x20000000 // Interrupt 29 active +#define NVIC_ACTIVE0_INT30 0x40000000 // Interrupt 30 active +#define NVIC_ACTIVE0_INT31 0x80000000 // Interrupt 31 active + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_ACTIVE1 register. +// +//***************************************************************************** +#define NVIC_ACTIVE1_INT_M 0x00000FFF // Interrupt Active +#define NVIC_ACTIVE1_INT32 0x00000001 // Interrupt 32 active +#define NVIC_ACTIVE1_INT33 0x00000002 // Interrupt 33 active +#define NVIC_ACTIVE1_INT34 0x00000004 // Interrupt 34 active +#define NVIC_ACTIVE1_INT35 0x00000008 // Interrupt 35 active +#define NVIC_ACTIVE1_INT36 0x00000010 // Interrupt 36 active +#define NVIC_ACTIVE1_INT37 0x00000020 // Interrupt 37 active +#define NVIC_ACTIVE1_INT38 0x00000040 // Interrupt 38 active +#define NVIC_ACTIVE1_INT39 0x00000080 // Interrupt 39 active +#define NVIC_ACTIVE1_INT40 0x00000100 // Interrupt 40 active +#define NVIC_ACTIVE1_INT41 0x00000200 // Interrupt 41 active +#define NVIC_ACTIVE1_INT42 0x00000400 // Interrupt 42 active +#define NVIC_ACTIVE1_INT43 0x00000800 // Interrupt 43 active +#define NVIC_ACTIVE1_INT44 0x00001000 // Interrupt 44 active +#define NVIC_ACTIVE1_INT45 0x00002000 // Interrupt 45 active +#define NVIC_ACTIVE1_INT46 0x00004000 // Interrupt 46 active +#define NVIC_ACTIVE1_INT47 0x00008000 // Interrupt 47 active +#define NVIC_ACTIVE1_INT48 0x00010000 // Interrupt 48 active +#define NVIC_ACTIVE1_INT49 0x00020000 // Interrupt 49 active +#define NVIC_ACTIVE1_INT50 0x00040000 // Interrupt 50 active +#define NVIC_ACTIVE1_INT51 0x00080000 // Interrupt 51 active +#define NVIC_ACTIVE1_INT52 0x00100000 // Interrupt 52 active +#define NVIC_ACTIVE1_INT53 0x00200000 // Interrupt 53 active +#define NVIC_ACTIVE1_INT54 0x00400000 // Interrupt 54 active +#define NVIC_ACTIVE1_INT55 0x00800000 // Interrupt 55 active + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI0 register. +// +//***************************************************************************** +#define NVIC_PRI0_INT3_M 0xE0000000 // Interrupt 3 Priority Mask +#define NVIC_PRI0_INT2_M 0x00E00000 // Interrupt 2 Priority Mask +#define NVIC_PRI0_INT1_M 0x0000E000 // Interrupt 1 Priority Mask +#define NVIC_PRI0_INT0_M 0x000000E0 // Interrupt 0 Priority Mask +#define NVIC_PRI0_INT3_S 29 +#define NVIC_PRI0_INT2_S 21 +#define NVIC_PRI0_INT1_S 13 +#define NVIC_PRI0_INT0_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI1 register. +// +//***************************************************************************** +#define NVIC_PRI1_INT7_M 0xE0000000 // Interrupt 7 Priority Mask +#define NVIC_PRI1_INT6_M 0x00E00000 // Interrupt 6 Priority Mask +#define NVIC_PRI1_INT5_M 0x0000E000 // Interrupt 5 Priority Mask +#define NVIC_PRI1_INT4_M 0x000000E0 // Interrupt 4 Priority Mask +#define NVIC_PRI1_INT7_S 29 +#define NVIC_PRI1_INT6_S 21 +#define NVIC_PRI1_INT5_S 13 +#define NVIC_PRI1_INT4_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI2 register. +// +//***************************************************************************** +#define NVIC_PRI2_INT11_M 0xE0000000 // Interrupt 11 Priority Mask +#define NVIC_PRI2_INT10_M 0x00E00000 // Interrupt 10 Priority Mask +#define NVIC_PRI2_INT9_M 0x0000E000 // Interrupt 9 Priority Mask +#define NVIC_PRI2_INT8_M 0x000000E0 // Interrupt 8 Priority Mask +#define NVIC_PRI2_INT11_S 29 +#define NVIC_PRI2_INT10_S 21 +#define NVIC_PRI2_INT9_S 13 +#define NVIC_PRI2_INT8_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI3 register. +// +//***************************************************************************** +#define NVIC_PRI3_INT15_M 0xE0000000 // Interrupt 15 Priority Mask +#define NVIC_PRI3_INT14_M 0x00E00000 // Interrupt 14 Priority Mask +#define NVIC_PRI3_INT13_M 0x0000E000 // Interrupt 13 Priority Mask +#define NVIC_PRI3_INT12_M 0x000000E0 // Interrupt 12 Priority Mask +#define NVIC_PRI3_INT15_S 29 +#define NVIC_PRI3_INT14_S 21 +#define NVIC_PRI3_INT13_S 13 +#define NVIC_PRI3_INT12_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI4 register. +// +//***************************************************************************** +#define NVIC_PRI4_INT19_M 0xE0000000 // Interrupt 19 Priority Mask +#define NVIC_PRI4_INT18_M 0x00E00000 // Interrupt 18 Priority Mask +#define NVIC_PRI4_INT17_M 0x0000E000 // Interrupt 17 Priority Mask +#define NVIC_PRI4_INT16_M 0x000000E0 // Interrupt 16 Priority Mask +#define NVIC_PRI4_INT19_S 29 +#define NVIC_PRI4_INT18_S 21 +#define NVIC_PRI4_INT17_S 13 +#define NVIC_PRI4_INT16_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI5 register. +// +//***************************************************************************** +#define NVIC_PRI5_INT23_M 0xE0000000 // Interrupt 23 Priority Mask +#define NVIC_PRI5_INT22_M 0x00E00000 // Interrupt 22 Priority Mask +#define NVIC_PRI5_INT21_M 0x0000E000 // Interrupt 21 Priority Mask +#define NVIC_PRI5_INT20_M 0x000000E0 // Interrupt 20 Priority Mask +#define NVIC_PRI5_INT23_S 29 +#define NVIC_PRI5_INT22_S 21 +#define NVIC_PRI5_INT21_S 13 +#define NVIC_PRI5_INT20_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI6 register. +// +//***************************************************************************** +#define NVIC_PRI6_INT27_M 0xE0000000 // Interrupt 27 Priority Mask +#define NVIC_PRI6_INT26_M 0x00E00000 // Interrupt 26 Priority Mask +#define NVIC_PRI6_INT25_M 0x0000E000 // Interrupt 25 Priority Mask +#define NVIC_PRI6_INT24_M 0x000000E0 // Interrupt 24 Priority Mask +#define NVIC_PRI6_INT27_S 29 +#define NVIC_PRI6_INT26_S 21 +#define NVIC_PRI6_INT25_S 13 +#define NVIC_PRI6_INT24_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI7 register. +// +//***************************************************************************** +#define NVIC_PRI7_INT31_M 0xE0000000 // Interrupt 31 Priority Mask +#define NVIC_PRI7_INT30_M 0x00E00000 // Interrupt 30 Priority Mask +#define NVIC_PRI7_INT29_M 0x0000E000 // Interrupt 29 Priority Mask +#define NVIC_PRI7_INT28_M 0x000000E0 // Interrupt 28 Priority Mask +#define NVIC_PRI7_INT31_S 29 +#define NVIC_PRI7_INT30_S 21 +#define NVIC_PRI7_INT29_S 13 +#define NVIC_PRI7_INT28_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI8 register. +// +//***************************************************************************** +#define NVIC_PRI8_INT35_M 0xE0000000 // Interrupt 35 Priority Mask +#define NVIC_PRI8_INT34_M 0x00E00000 // Interrupt 34 Priority Mask +#define NVIC_PRI8_INT33_M 0x0000E000 // Interrupt 33 Priority Mask +#define NVIC_PRI8_INT32_M 0x000000E0 // Interrupt 32 Priority Mask +#define NVIC_PRI8_INT35_S 29 +#define NVIC_PRI8_INT34_S 21 +#define NVIC_PRI8_INT33_S 13 +#define NVIC_PRI8_INT32_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI9 register. +// +//***************************************************************************** +#define NVIC_PRI9_INT39_M 0xE0000000 // Interrupt 39 Priority Mask +#define NVIC_PRI9_INT38_M 0x00E00000 // Interrupt 38 Priority Mask +#define NVIC_PRI9_INT37_M 0x0000E000 // Interrupt 37 Priority Mask +#define NVIC_PRI9_INT36_M 0x000000E0 // Interrupt 36 Priority Mask +#define NVIC_PRI9_INT39_S 29 +#define NVIC_PRI9_INT38_S 21 +#define NVIC_PRI9_INT37_S 13 +#define NVIC_PRI9_INT36_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_PRI10 register. +// +//***************************************************************************** +#define NVIC_PRI10_INT43_M 0xE0000000 // Interrupt 43 Priority Mask +#define NVIC_PRI10_INT42_M 0x00E00000 // Interrupt 42 Priority Mask +#define NVIC_PRI10_INT41_M 0x0000E000 // Interrupt 41 Priority Mask +#define NVIC_PRI10_INT40_M 0x000000E0 // Interrupt 40 Priority Mask +#define NVIC_PRI10_INT43_S 29 +#define NVIC_PRI10_INT42_S 21 +#define NVIC_PRI10_INT41_S 13 +#define NVIC_PRI10_INT40_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_CPUID register. +// +//***************************************************************************** +#define NVIC_CPUID_IMP_M 0xFF000000 // Implementer Code +#define NVIC_CPUID_IMP_ARM 0x41000000 // ARM +#define NVIC_CPUID_VAR_M 0x00F00000 // Variant Number +#define NVIC_CPUID_CON_M 0x000F0000 // Constant +#define NVIC_CPUID_PARTNO_M 0x0000FFF0 // Part Number +#define NVIC_CPUID_PARTNO_CM3 0x0000C230 // Cortex-M3 processor +#define NVIC_CPUID_REV_M 0x0000000F // Revision Number + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_INT_CTRL register. +// +//***************************************************************************** +#define NVIC_INT_CTRL_NMI_SET 0x80000000 // NMI Set Pending +#define NVIC_INT_CTRL_PEND_SV 0x10000000 // PendSV Set Pending +#define NVIC_INT_CTRL_UNPEND_SV 0x08000000 // PendSV Clear Pending +#define NVIC_INT_CTRL_PENDSTSET 0x04000000 // SysTick Set Pending +#define NVIC_INT_CTRL_PENDSTCLR 0x02000000 // SysTick Clear Pending +#define NVIC_INT_CTRL_ISR_PRE 0x00800000 // Debug Interrupt Handling +#define NVIC_INT_CTRL_ISR_PEND 0x00400000 // Interrupt Pending +#define NVIC_INT_CTRL_VEC_PEN_M 0x0003F000 // Interrupt Pending Vector Number +#define NVIC_INT_CTRL_VEC_PEN_NMI \ + 0x00002000 // NMI +#define NVIC_INT_CTRL_VEC_PEN_HARD \ + 0x00003000 // Hard fault +#define NVIC_INT_CTRL_VEC_PEN_MEM \ + 0x00004000 // Memory management fault +#define NVIC_INT_CTRL_VEC_PEN_BUS \ + 0x00005000 // Bus fault +#define NVIC_INT_CTRL_VEC_PEN_USG \ + 0x00006000 // Usage fault +#define NVIC_INT_CTRL_VEC_PEN_SVC \ + 0x0000B000 // SVCall +#define NVIC_INT_CTRL_VEC_PEN_PNDSV \ + 0x0000E000 // PendSV +#define NVIC_INT_CTRL_VEC_PEN_TICK \ + 0x0000F000 // SysTick +#define NVIC_INT_CTRL_RET_BASE 0x00000800 // Return to Base +#define NVIC_INT_CTRL_VEC_ACT_M 0x0000003F // Interrupt Pending Vector Number +#define NVIC_INT_CTRL_VEC_ACT_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_VTABLE register. +// +//***************************************************************************** +#define NVIC_VTABLE_BASE 0x20000000 // Vector Table Base +#define NVIC_VTABLE_OFFSET_M 0x1FFFFF00 // Vector Table Offset +#define NVIC_VTABLE_OFFSET_S 8 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_APINT register. +// +//***************************************************************************** +#define NVIC_APINT_VECTKEY_M 0xFFFF0000 // Register Key +#define NVIC_APINT_VECTKEY 0x05FA0000 // Vector key +#define NVIC_APINT_ENDIANESS 0x00008000 // Data Endianess +#define NVIC_APINT_PRIGROUP_M 0x00000700 // Interrupt Priority Grouping +#define NVIC_APINT_PRIGROUP_7_1 0x00000000 // Priority group 7.1 split +#define NVIC_APINT_PRIGROUP_6_2 0x00000100 // Priority group 6.2 split +#define NVIC_APINT_PRIGROUP_5_3 0x00000200 // Priority group 5.3 split +#define NVIC_APINT_PRIGROUP_4_4 0x00000300 // Priority group 4.4 split +#define NVIC_APINT_PRIGROUP_3_5 0x00000400 // Priority group 3.5 split +#define NVIC_APINT_PRIGROUP_2_6 0x00000500 // Priority group 2.6 split +#define NVIC_APINT_PRIGROUP_1_7 0x00000600 // Priority group 1.7 split +#define NVIC_APINT_PRIGROUP_0_8 0x00000700 // Priority group 0.8 split +#define NVIC_APINT_SYSRESETREQ 0x00000004 // System Reset Request +#define NVIC_APINT_VECT_CLR_ACT 0x00000002 // Clear Active NMI / Fault +#define NVIC_APINT_VECT_RESET 0x00000001 // System Reset + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SYS_CTRL register. +// +//***************************************************************************** +#define NVIC_SYS_CTRL_SEVONPEND 0x00000010 // Wake Up on Pending +#define NVIC_SYS_CTRL_SLEEPDEEP 0x00000004 // Deep Sleep Enable +#define NVIC_SYS_CTRL_SLEEPEXIT 0x00000002 // Sleep on ISR Exit + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_CFG_CTRL register. +// +//***************************************************************************** +#define NVIC_CFG_CTRL_STKALIGN 0x00000200 // Stack Alignment on Exception + // Entry +#define NVIC_CFG_CTRL_BFHFNMIGN 0x00000100 // Ignore Bus Fault in NMI and + // Fault +#define NVIC_CFG_CTRL_DIV0 0x00000010 // Trap on Divide by 0 +#define NVIC_CFG_CTRL_UNALIGNED 0x00000008 // Trap on Unaligned Access +#define NVIC_CFG_CTRL_MAIN_PEND 0x00000002 // Allow Main Interrupt Trigger +#define NVIC_CFG_CTRL_BASE_THR 0x00000001 // Thread State Control + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SYS_PRI1 register. +// +//***************************************************************************** +#define NVIC_SYS_PRI1_USAGE_M 0x00E00000 // Usage Fault Priority +#define NVIC_SYS_PRI1_BUS_M 0x0000E000 // Bus Fault Priority +#define NVIC_SYS_PRI1_MEM_M 0x000000E0 // Memory Management Fault Priority +#define NVIC_SYS_PRI1_USAGE_S 21 +#define NVIC_SYS_PRI1_BUS_S 13 +#define NVIC_SYS_PRI1_MEM_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SYS_PRI2 register. +// +//***************************************************************************** +#define NVIC_SYS_PRI2_SVC_M 0xE0000000 // SVCall Priority +#define NVIC_SYS_PRI2_SVC_S 29 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SYS_PRI3 register. +// +//***************************************************************************** +#define NVIC_SYS_PRI3_TICK_M 0xE0000000 // SysTick Exception Priority +#define NVIC_SYS_PRI3_PENDSV_M 0x00E00000 // PendSV Priority +#define NVIC_SYS_PRI3_DEBUG_M 0x000000E0 // Debug Priority +#define NVIC_SYS_PRI3_TICK_S 29 +#define NVIC_SYS_PRI3_PENDSV_S 21 +#define NVIC_SYS_PRI3_DEBUG_S 5 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SYS_HND_CTRL +// register. +// +//***************************************************************************** +#define NVIC_SYS_HND_CTRL_USAGE 0x00040000 // Usage Fault Enable +#define NVIC_SYS_HND_CTRL_BUS 0x00020000 // Bus Fault Enable +#define NVIC_SYS_HND_CTRL_MEM 0x00010000 // Memory Management Fault Enable +#define NVIC_SYS_HND_CTRL_SVC 0x00008000 // SVC Call Pending +#define NVIC_SYS_HND_CTRL_BUSP 0x00004000 // Bus Fault Pending +#define NVIC_SYS_HND_CTRL_MEMP 0x00002000 // Memory Management Fault Pending +#define NVIC_SYS_HND_CTRL_USAGEP \ + 0x00001000 // Usage Fault Pending +#define NVIC_SYS_HND_CTRL_TICK 0x00000800 // SysTick Exception Active +#define NVIC_SYS_HND_CTRL_PNDSV 0x00000400 // PendSV Exception Active +#define NVIC_SYS_HND_CTRL_MON 0x00000100 // Debug Monitor Active +#define NVIC_SYS_HND_CTRL_SVCA 0x00000080 // SVC Call Active +#define NVIC_SYS_HND_CTRL_USGA 0x00000008 // Usage Fault Active +#define NVIC_SYS_HND_CTRL_BUSA 0x00000002 // Bus Fault Active +#define NVIC_SYS_HND_CTRL_MEMA 0x00000001 // Memory Management Fault Active + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_FAULT_STAT +// register. +// +//***************************************************************************** +#define NVIC_FAULT_STAT_DIV0 0x02000000 // Divide-by-Zero Usage Fault +#define NVIC_FAULT_STAT_UNALIGN 0x01000000 // Unaligned Access Usage Fault +#define NVIC_FAULT_STAT_NOCP 0x00080000 // No Coprocessor Usage Fault +#define NVIC_FAULT_STAT_INVPC 0x00040000 // Invalid PC Load Usage Fault +#define NVIC_FAULT_STAT_INVSTAT 0x00020000 // Invalid State Usage Fault +#define NVIC_FAULT_STAT_UNDEF 0x00010000 // Undefined Instruction Usage + // Fault +#define NVIC_FAULT_STAT_BFARV 0x00008000 // Bus Fault Address Register Valid +#define NVIC_FAULT_STAT_BSTKE 0x00001000 // Stack Bus Fault +#define NVIC_FAULT_STAT_BUSTKE 0x00000800 // Unstack Bus Fault +#define NVIC_FAULT_STAT_IMPRE 0x00000400 // Imprecise Data Bus Error +#define NVIC_FAULT_STAT_PRECISE 0x00000200 // Precise Data Bus Error +#define NVIC_FAULT_STAT_IBUS 0x00000100 // Instruction Bus Error +#define NVIC_FAULT_STAT_MMARV 0x00000080 // Memory Management Fault Address + // Register Valid +#define NVIC_FAULT_STAT_MSTKE 0x00000010 // Stack Access Violation +#define NVIC_FAULT_STAT_MUSTKE 0x00000008 // Unstack Access Violation +#define NVIC_FAULT_STAT_DERR 0x00000002 // Data Access Violation +#define NVIC_FAULT_STAT_IERR 0x00000001 // Instruction Access Violation + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_HFAULT_STAT +// register. +// +//***************************************************************************** +#define NVIC_HFAULT_STAT_DBG 0x80000000 // Debug Event +#define NVIC_HFAULT_STAT_FORCED 0x40000000 // Forced Hard Fault +#define NVIC_HFAULT_STAT_VECT 0x00000002 // Vector Table Read Fault + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DEBUG_STAT +// register. +// +//***************************************************************************** +#define NVIC_DEBUG_STAT_EXTRNL 0x00000010 // EDBGRQ asserted +#define NVIC_DEBUG_STAT_VCATCH 0x00000008 // Vector catch +#define NVIC_DEBUG_STAT_DWTTRAP 0x00000004 // DWT match +#define NVIC_DEBUG_STAT_BKPT 0x00000002 // Breakpoint instruction +#define NVIC_DEBUG_STAT_HALTED 0x00000001 // Halt request + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MM_ADDR register. +// +//***************************************************************************** +#define NVIC_MM_ADDR_M 0xFFFFFFFF // Fault Address +#define NVIC_MM_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_FAULT_ADDR +// register. +// +//***************************************************************************** +#define NVIC_FAULT_ADDR_M 0xFFFFFFFF // Fault Address +#define NVIC_FAULT_ADDR_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_TYPE register. +// +//***************************************************************************** +#define NVIC_MPU_TYPE_IREGION_M 0x00FF0000 // Number of I Regions +#define NVIC_MPU_TYPE_DREGION_M 0x0000FF00 // Number of D Regions +#define NVIC_MPU_TYPE_SEPARATE 0x00000001 // Separate or Unified MPU +#define NVIC_MPU_TYPE_IREGION_S 16 +#define NVIC_MPU_TYPE_DREGION_S 8 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_CTRL register. +// +//***************************************************************************** +#define NVIC_MPU_CTRL_PRIVDEFEN 0x00000004 // MPU Default Region +#define NVIC_MPU_CTRL_HFNMIENA 0x00000002 // MPU Enabled During Faults +#define NVIC_MPU_CTRL_ENABLE 0x00000001 // MPU Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_NUMBER +// register. +// +//***************************************************************************** +#define NVIC_MPU_NUMBER_M 0x00000007 // MPU Region to Access +#define NVIC_MPU_NUMBER_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_BASE register. +// +//***************************************************************************** +#define NVIC_MPU_BASE_ADDR_M 0xFFFFFFE0 // Base Address Mask +#define NVIC_MPU_BASE_VALID 0x00000010 // Region Number Valid +#define NVIC_MPU_BASE_REGION_M 0x00000007 // Region Number +#define NVIC_MPU_BASE_ADDR_S 5 +#define NVIC_MPU_BASE_REGION_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_ATTR register. +// +//***************************************************************************** +#define NVIC_MPU_ATTR_M 0xFFFF0000 // Attributes +#define NVIC_MPU_ATTR_XN 0x10000000 // Instruction Access Disable +#define NVIC_MPU_ATTR_AP_M 0x07000000 // Access Privilege +#define NVIC_MPU_ATTR_AP_NO_NO 0x00000000 // prv: no access, usr: no access +#define NVIC_MPU_ATTR_AP_RW_NO 0x01000000 // prv: rw, usr: none +#define NVIC_MPU_ATTR_AP_RW_RO 0x02000000 // prv: rw, usr: read-only +#define NVIC_MPU_ATTR_AP_RW_RW 0x03000000 // prv: rw, usr: rw +#define NVIC_MPU_ATTR_AP_RO_NO 0x05000000 // prv: ro, usr: none +#define NVIC_MPU_ATTR_AP_RO_RO 0x06000000 // prv: ro, usr: ro +#define NVIC_MPU_ATTR_TEX_M 0x00380000 // Type Extension Mask +#define NVIC_MPU_ATTR_SHAREABLE 0x00040000 // Shareable +#define NVIC_MPU_ATTR_CACHEABLE 0x00020000 // Cacheable +#define NVIC_MPU_ATTR_BUFFRABLE 0x00010000 // Bufferable +#define NVIC_MPU_ATTR_SRD_M 0x0000FF00 // Subregion Disable Bits +#define NVIC_MPU_ATTR_SRD_0 0x00000100 // Sub-region 0 disable +#define NVIC_MPU_ATTR_SRD_1 0x00000200 // Sub-region 1 disable +#define NVIC_MPU_ATTR_SRD_2 0x00000400 // Sub-region 2 disable +#define NVIC_MPU_ATTR_SRD_3 0x00000800 // Sub-region 3 disable +#define NVIC_MPU_ATTR_SRD_4 0x00001000 // Sub-region 4 disable +#define NVIC_MPU_ATTR_SRD_5 0x00002000 // Sub-region 5 disable +#define NVIC_MPU_ATTR_SRD_6 0x00004000 // Sub-region 6 disable +#define NVIC_MPU_ATTR_SRD_7 0x00008000 // Sub-region 7 disable +#define NVIC_MPU_ATTR_SIZE_M 0x0000003E // Region Size Mask +#define NVIC_MPU_ATTR_SIZE_32B 0x00000008 // Region size 32 bytes +#define NVIC_MPU_ATTR_SIZE_64B 0x0000000A // Region size 64 bytes +#define NVIC_MPU_ATTR_SIZE_128B 0x0000000C // Region size 128 bytes +#define NVIC_MPU_ATTR_SIZE_256B 0x0000000E // Region size 256 bytes +#define NVIC_MPU_ATTR_SIZE_512B 0x00000010 // Region size 512 bytes +#define NVIC_MPU_ATTR_SIZE_1K 0x00000012 // Region size 1 Kbytes +#define NVIC_MPU_ATTR_SIZE_2K 0x00000014 // Region size 2 Kbytes +#define NVIC_MPU_ATTR_SIZE_4K 0x00000016 // Region size 4 Kbytes +#define NVIC_MPU_ATTR_SIZE_8K 0x00000018 // Region size 8 Kbytes +#define NVIC_MPU_ATTR_SIZE_16K 0x0000001A // Region size 16 Kbytes +#define NVIC_MPU_ATTR_SIZE_32K 0x0000001C // Region size 32 Kbytes +#define NVIC_MPU_ATTR_SIZE_64K 0x0000001E // Region size 64 Kbytes +#define NVIC_MPU_ATTR_SIZE_128K 0x00000020 // Region size 128 Kbytes +#define NVIC_MPU_ATTR_SIZE_256K 0x00000022 // Region size 256 Kbytes +#define NVIC_MPU_ATTR_SIZE_512K 0x00000024 // Region size 512 Kbytes +#define NVIC_MPU_ATTR_SIZE_1M 0x00000026 // Region size 1 Mbytes +#define NVIC_MPU_ATTR_SIZE_2M 0x00000028 // Region size 2 Mbytes +#define NVIC_MPU_ATTR_SIZE_4M 0x0000002A // Region size 4 Mbytes +#define NVIC_MPU_ATTR_SIZE_8M 0x0000002C // Region size 8 Mbytes +#define NVIC_MPU_ATTR_SIZE_16M 0x0000002E // Region size 16 Mbytes +#define NVIC_MPU_ATTR_SIZE_32M 0x00000030 // Region size 32 Mbytes +#define NVIC_MPU_ATTR_SIZE_64M 0x00000032 // Region size 64 Mbytes +#define NVIC_MPU_ATTR_SIZE_128M 0x00000034 // Region size 128 Mbytes +#define NVIC_MPU_ATTR_SIZE_256M 0x00000036 // Region size 256 Mbytes +#define NVIC_MPU_ATTR_SIZE_512M 0x00000038 // Region size 512 Mbytes +#define NVIC_MPU_ATTR_SIZE_1G 0x0000003A // Region size 1 Gbytes +#define NVIC_MPU_ATTR_SIZE_2G 0x0000003C // Region size 2 Gbytes +#define NVIC_MPU_ATTR_SIZE_4G 0x0000003E // Region size 4 Gbytes +#define NVIC_MPU_ATTR_ENABLE 0x00000001 // Region Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_BASE1 register. +// +//***************************************************************************** +#define NVIC_MPU_BASE1_ADDR_M 0xFFFFFFE0 // Base Address Mask +#define NVIC_MPU_BASE1_VALID 0x00000010 // Region Number Valid +#define NVIC_MPU_BASE1_REGION_M 0x00000007 // Region Number +#define NVIC_MPU_BASE1_ADDR_S 5 +#define NVIC_MPU_BASE1_REGION_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_ATTR1 register. +// +//***************************************************************************** +#define NVIC_MPU_ATTR1_XN 0x10000000 // Instruction Access Disable +#define NVIC_MPU_ATTR1_AP_M 0x07000000 // Access Privilege +#define NVIC_MPU_ATTR1_TEX_M 0x00380000 // Type Extension Mask +#define NVIC_MPU_ATTR1_SHAREABLE \ + 0x00040000 // Shareable +#define NVIC_MPU_ATTR1_CACHEABLE \ + 0x00020000 // Cacheable +#define NVIC_MPU_ATTR1_BUFFRABLE \ + 0x00010000 // Bufferable +#define NVIC_MPU_ATTR1_SRD_M 0x0000FF00 // Subregion Disable Bits +#define NVIC_MPU_ATTR1_SIZE_M 0x0000003E // Region Size Mask +#define NVIC_MPU_ATTR1_ENABLE 0x00000001 // Region Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_BASE2 register. +// +//***************************************************************************** +#define NVIC_MPU_BASE2_ADDR_M 0xFFFFFFE0 // Base Address Mask +#define NVIC_MPU_BASE2_VALID 0x00000010 // Region Number Valid +#define NVIC_MPU_BASE2_REGION_M 0x00000007 // Region Number +#define NVIC_MPU_BASE2_ADDR_S 5 +#define NVIC_MPU_BASE2_REGION_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_ATTR2 register. +// +//***************************************************************************** +#define NVIC_MPU_ATTR2_XN 0x10000000 // Instruction Access Disable +#define NVIC_MPU_ATTR2_AP_M 0x07000000 // Access Privilege +#define NVIC_MPU_ATTR2_TEX_M 0x00380000 // Type Extension Mask +#define NVIC_MPU_ATTR2_SHAREABLE \ + 0x00040000 // Shareable +#define NVIC_MPU_ATTR2_CACHEABLE \ + 0x00020000 // Cacheable +#define NVIC_MPU_ATTR2_BUFFRABLE \ + 0x00010000 // Bufferable +#define NVIC_MPU_ATTR2_SRD_M 0x0000FF00 // Subregion Disable Bits +#define NVIC_MPU_ATTR2_SIZE_M 0x0000003E // Region Size Mask +#define NVIC_MPU_ATTR2_ENABLE 0x00000001 // Region Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_BASE3 register. +// +//***************************************************************************** +#define NVIC_MPU_BASE3_ADDR_M 0xFFFFFFE0 // Base Address Mask +#define NVIC_MPU_BASE3_VALID 0x00000010 // Region Number Valid +#define NVIC_MPU_BASE3_REGION_M 0x00000007 // Region Number +#define NVIC_MPU_BASE3_ADDR_S 5 +#define NVIC_MPU_BASE3_REGION_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_MPU_ATTR3 register. +// +//***************************************************************************** +#define NVIC_MPU_ATTR3_XN 0x10000000 // Instruction Access Disable +#define NVIC_MPU_ATTR3_AP_M 0x07000000 // Access Privilege +#define NVIC_MPU_ATTR3_TEX_M 0x00380000 // Type Extension Mask +#define NVIC_MPU_ATTR3_SHAREABLE \ + 0x00040000 // Shareable +#define NVIC_MPU_ATTR3_CACHEABLE \ + 0x00020000 // Cacheable +#define NVIC_MPU_ATTR3_BUFFRABLE \ + 0x00010000 // Bufferable +#define NVIC_MPU_ATTR3_SRD_M 0x0000FF00 // Subregion Disable Bits +#define NVIC_MPU_ATTR3_SIZE_M 0x0000003E // Region Size Mask +#define NVIC_MPU_ATTR3_ENABLE 0x00000001 // Region Enable + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DBG_CTRL register. +// +//***************************************************************************** +#define NVIC_DBG_CTRL_DBGKEY_M 0xFFFF0000 // Debug key mask +#define NVIC_DBG_CTRL_DBGKEY 0xA05F0000 // Debug key +#define NVIC_DBG_CTRL_S_RESET_ST \ + 0x02000000 // Core has reset since last read +#define NVIC_DBG_CTRL_S_RETIRE_ST \ + 0x01000000 // Core has executed insruction + // since last read +#define NVIC_DBG_CTRL_S_LOCKUP 0x00080000 // Core is locked up +#define NVIC_DBG_CTRL_S_SLEEP 0x00040000 // Core is sleeping +#define NVIC_DBG_CTRL_S_HALT 0x00020000 // Core status on halt +#define NVIC_DBG_CTRL_S_REGRDY 0x00010000 // Register read/write available +#define NVIC_DBG_CTRL_C_SNAPSTALL \ + 0x00000020 // Breaks a stalled load/store +#define NVIC_DBG_CTRL_C_MASKINT 0x00000008 // Mask interrupts when stepping +#define NVIC_DBG_CTRL_C_STEP 0x00000004 // Step the core +#define NVIC_DBG_CTRL_C_HALT 0x00000002 // Halt the core +#define NVIC_DBG_CTRL_C_DEBUGEN 0x00000001 // Enable debug + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DBG_XFER register. +// +//***************************************************************************** +#define NVIC_DBG_XFER_REG_WNR 0x00010000 // Write or not read +#define NVIC_DBG_XFER_REG_SEL_M 0x0000001F // Register +#define NVIC_DBG_XFER_REG_R0 0x00000000 // Register R0 +#define NVIC_DBG_XFER_REG_R1 0x00000001 // Register R1 +#define NVIC_DBG_XFER_REG_R2 0x00000002 // Register R2 +#define NVIC_DBG_XFER_REG_R3 0x00000003 // Register R3 +#define NVIC_DBG_XFER_REG_R4 0x00000004 // Register R4 +#define NVIC_DBG_XFER_REG_R5 0x00000005 // Register R5 +#define NVIC_DBG_XFER_REG_R6 0x00000006 // Register R6 +#define NVIC_DBG_XFER_REG_R7 0x00000007 // Register R7 +#define NVIC_DBG_XFER_REG_R8 0x00000008 // Register R8 +#define NVIC_DBG_XFER_REG_R9 0x00000009 // Register R9 +#define NVIC_DBG_XFER_REG_R10 0x0000000A // Register R10 +#define NVIC_DBG_XFER_REG_R11 0x0000000B // Register R11 +#define NVIC_DBG_XFER_REG_R12 0x0000000C // Register R12 +#define NVIC_DBG_XFER_REG_R13 0x0000000D // Register R13 +#define NVIC_DBG_XFER_REG_R14 0x0000000E // Register R14 +#define NVIC_DBG_XFER_REG_R15 0x0000000F // Register R15 +#define NVIC_DBG_XFER_REG_FLAGS 0x00000010 // xPSR/Flags register +#define NVIC_DBG_XFER_REG_MSP 0x00000011 // Main SP +#define NVIC_DBG_XFER_REG_PSP 0x00000012 // Process SP +#define NVIC_DBG_XFER_REG_DSP 0x00000013 // Deep SP +#define NVIC_DBG_XFER_REG_CFBP 0x00000014 // Control/Fault/BasePri/PriMask + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DBG_DATA register. +// +//***************************************************************************** +#define NVIC_DBG_DATA_M 0xFFFFFFFF // Data temporary cache +#define NVIC_DBG_DATA_S 0 + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_DBG_INT register. +// +//***************************************************************************** +#define NVIC_DBG_INT_HARDERR 0x00000400 // Debug trap on hard fault +#define NVIC_DBG_INT_INTERR 0x00000200 // Debug trap on interrupt errors +#define NVIC_DBG_INT_BUSERR 0x00000100 // Debug trap on bus error +#define NVIC_DBG_INT_STATERR 0x00000080 // Debug trap on usage fault state +#define NVIC_DBG_INT_CHKERR 0x00000040 // Debug trap on usage fault check +#define NVIC_DBG_INT_NOCPERR 0x00000020 // Debug trap on coprocessor error +#define NVIC_DBG_INT_MMERR 0x00000010 // Debug trap on mem manage fault +#define NVIC_DBG_INT_RESET 0x00000008 // Core reset status +#define NVIC_DBG_INT_RSTPENDCLR 0x00000004 // Clear pending core reset +#define NVIC_DBG_INT_RSTPENDING 0x00000002 // Core reset is pending +#define NVIC_DBG_INT_RSTVCATCH 0x00000001 // Reset vector catch + +//***************************************************************************** +// +// The following are defines for the bit fields in the NVIC_SW_TRIG register. +// +//***************************************************************************** +#define NVIC_SW_TRIG_INTID_M 0x0000003F // Interrupt ID +#define NVIC_SW_TRIG_INTID_S 0 + +//***************************************************************************** +// +// The following definitions are deprecated. +// +//***************************************************************************** +#ifndef DEPRECATED + +//***************************************************************************** +// +// Deprecated defines for the Watchdog +// +//***************************************************************************** +#define WATCHDOG_LOAD_R (*((volatile unsigned long *)0x40000000)) +#define WATCHDOG_VALUE_R (*((volatile unsigned long *)0x40000004)) +#define WATCHDOG_CTL_R (*((volatile unsigned long *)0x40000008)) +#define WATCHDOG_ICR_R (*((volatile unsigned long *)0x4000000C)) +#define WATCHDOG_RIS_R (*((volatile unsigned long *)0x40000010)) +#define WATCHDOG_MIS_R (*((volatile unsigned long *)0x40000014)) +#define WATCHDOG_TEST_R (*((volatile unsigned long *)0x40000418)) +#define WATCHDOG_LOCK_R (*((volatile unsigned long *)0x40000C00)) + +//***************************************************************************** +// +// Deprecated defines for the bit fields in the I2C_O_SICR register. +// +//***************************************************************************** +#define I2C_SICR_IC 0x00000001 // Clear Interrupt + +//***************************************************************************** +// +// Deprecated defines for the bit fields in the I2C_O_SMIS register. +// +//***************************************************************************** +#define I2C_SMIS_MIS 0x00000001 // Masked Interrupt Status + +//***************************************************************************** +// +// Deprecated defines for the bit fields in the I2C_O_SRIS register. +// +//***************************************************************************** +#define I2C_SRIS_RIS 0x00000001 // Raw Interrupt Status + +//***************************************************************************** +// +// Deprecated defines for the bit fields in the I2C_O_SIMR register. +// +//***************************************************************************** +#define I2C_SIMR_IM 0x00000001 // Interrupt Mask + +//***************************************************************************** +// +// Deprecated defines for the bit fields in the the interpretation of the data +// in the SSFIFOx when the ADC TMLB is enabled. register. +// +//***************************************************************************** +#define ADC_TMLB_CNT_M 0x000003C0 // Continuous Sample Counter +#define ADC_TMLB_CONT 0x00000020 // Continuation Sample Indicator +#define ADC_TMLB_DIFF 0x00000010 // Differential Sample Indicator +#define ADC_TMLB_TS 0x00000008 // Temp Sensor Sample Indicator +#define ADC_TMLB_MUX_M 0x00000007 // Analog Input Indicator +#define ADC_TMLB_CNT_S 6 // Sample counter shift +#define ADC_TMLB_MUX_S 0 // Input channel number shift + +//***************************************************************************** +// +// Deprecated defines for the ADC register offsets. +// +//***************************************************************************** +#define ADC_ACTSS_R (*((volatile unsigned long *)0x40038000)) +#define ADC_RIS_R (*((volatile unsigned long *)0x40038004)) +#define ADC_IM_R (*((volatile unsigned long *)0x40038008)) +#define ADC_ISC_R (*((volatile unsigned long *)0x4003800C)) +#define ADC_OSTAT_R (*((volatile unsigned long *)0x40038010)) +#define ADC_EMUX_R (*((volatile unsigned long *)0x40038014)) +#define ADC_USTAT_R (*((volatile unsigned long *)0x40038018)) +#define ADC_SSPRI_R (*((volatile unsigned long *)0x40038020)) +#define ADC_PSSI_R (*((volatile unsigned long *)0x40038028)) +#define ADC_SAC_R (*((volatile unsigned long *)0x40038030)) +#define ADC_SSMUX0_R (*((volatile unsigned long *)0x40038040)) +#define ADC_SSCTL0_R (*((volatile unsigned long *)0x40038044)) +#define ADC_SSFIFO0_R (*((volatile unsigned long *)0x40038048)) +#define ADC_SSFSTAT0_R (*((volatile unsigned long *)0x4003804C)) +#define ADC_SSMUX1_R (*((volatile unsigned long *)0x40038060)) +#define ADC_SSCTL1_R (*((volatile unsigned long *)0x40038064)) +#define ADC_SSFIFO1_R (*((volatile unsigned long *)0x40038068)) +#define ADC_SSFSTAT1_R (*((volatile unsigned long *)0x4003806C)) +#define ADC_SSMUX2_R (*((volatile unsigned long *)0x40038080)) +#define ADC_SSCTL2_R (*((volatile unsigned long *)0x40038084)) +#define ADC_SSFIFO2_R (*((volatile unsigned long *)0x40038088)) +#define ADC_SSFSTAT2_R (*((volatile unsigned long *)0x4003808C)) +#define ADC_SSMUX3_R (*((volatile unsigned long *)0x400380A0)) +#define ADC_SSCTL3_R (*((volatile unsigned long *)0x400380A4)) +#define ADC_SSFIFO3_R (*((volatile unsigned long *)0x400380A8)) +#define ADC_SSFSTAT3_R (*((volatile unsigned long *)0x400380AC)) +#define ADC_TMLB_R (*((volatile unsigned long *)0x40038100)) + +//***************************************************************************** +// +// Deprecated defines for the bit fields in the FLASH_FMC register. +// +//***************************************************************************** +#define FLASH_FMC_WRKEY_M 0xFFFF0000 // Flash Memory Write Key +#define FLASH_FMC_WRKEY_S 16 + +//***************************************************************************** +// +// Deprecated defines for the bit fields in the SYSCTL_DC1 register. +// +//***************************************************************************** +#define SYSCTL_DC1_WDT 0x00000008 // Watchdog Timer Present + +//***************************************************************************** +// +// Deprecated defines for the bit fields in the SYSCTL_DID1 register. +// +//***************************************************************************** +#define SYSCTL_DID1_PKG_28SOIC 0x00000000 // SOIC package +#define SYSCTL_DID1_PKG_48QFP 0x00000008 // QFP package + +//***************************************************************************** +// +// Deprecated defines for the NVIC register addresses. +// +//***************************************************************************** +#define NVIC_MPU_R (*((volatile unsigned long *)0xE000ED9C)) + +#endif + +#endif // __LM3S6965_H__ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/main.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/main.c new file mode 100644 index 00000000..871181a4 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/main.c @@ -0,0 +1,120 @@ +/**************************************************************************************** +| Description: demo program application source file +| File Name: main.c +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "header.h" /* generic header */ + + +/**************************************************************************************** +* Function prototypes +****************************************************************************************/ +static void Init(void); + + +/**************************************************************************************** +** NAME: main +** PARAMETER: none +** RETURN VALUE: program return code +** DESCRIPTION: This is the entry point for the bootloader application and is called +** by the reset interrupt vector after the C-startup routines executed. +** +****************************************************************************************/ +int main(void) +{ + /* initialize the microcontroller */ + Init(); + /* initialize the bootloader interface */ + BootComInit(); + + /* start the infinite program loop */ + while (1) + { + /* toggle LED with a fixed frequency */ + LedToggle(); + /* check for bootloader activation request */ + BootComCheckActivationRequest(); + } + + /* program should never get here */ + return 0; +} /*** end of main ***/ + + +/**************************************************************************************** +** NAME: Init +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Initializes the microcontroller. +** +****************************************************************************************/ +static void Init(void) +{ + /* set the clocking to run at 50MHz from the PLL */ + SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); + /* init the led driver */ + LedInit(); + /* init the timer driver */ + TimeInit(); + /* enable IRQ's, because they were initially disabled by the bootloader */ + IrqInterruptEnable(); +} /*** end of Init ***/ + + +/**************************************************************************************** +** NAME: __error__ +** PARAMETER: pcFilename name of the source file where the assertion occurred. +** ulLine linenumber in the source file where the assertion occurred. +** RETURN VALUE: none +** DESCRIPTION: Called when a runtime assertion failed. It stores information about +** where the assertion occurred and halts the software program. +** +****************************************************************************************/ +#ifdef DEBUG +void __error__(char *pcFilename, unsigned long ulLine) +{ + static volatile char *assert_failure_file; + static volatile unsigned long assert_failure_line; + + /* store the file string and line number so that it can be read on a breakpoint*/ + assert_failure_file = pcFilename; + assert_failure_line = ulLine; + + /* hang the software so that it requires a hard reset */ + for(;;) + { + } +} /*** end of __error__ ***/ +#endif + + +/*********************************** end of main.c *************************************/ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/makefile b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/makefile new file mode 100644 index 00000000..bf2b894e --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/makefile @@ -0,0 +1,226 @@ +#**************************************************************************************** +#| Description: Makefile for STM32 using CodeSourcery GNU GCC compiler toolset +#| File Name: makefile +#| +#|--------------------------------------------------------------------------------------- +#| C O P Y R I G H T +#|--------------------------------------------------------------------------------------- +#| Copyright (c) 2012 by Feaser LLC http://www.feaser.com All rights reserved +#| +#|--------------------------------------------------------------------------------------- +#| L I C E N S E +#|--------------------------------------------------------------------------------------- +#| This file is part of OpenBTL. OpenBTL is free software: you can redistribute it and/or +#| modify it under the terms of the GNU General Public License as published by the Free +#| Software Foundation, either version 3 of the License, or (at your option) any later +#| version. +#| +#| OpenBTL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +#| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +#| PURPOSE. See the GNU General Public License for more details. +#| +#| You should have received a copy of the GNU General Public License along with OpenBTL. +#| If not, see . +#| +#**************************************************************************************** +SHELL = sh + +#|---------------------------------------------------------------------------------------| +#| Configure project name | +#|---------------------------------------------------------------------------------------| +PROJ_NAME=demoprog_ek_lm3s6965 + + +#|---------------------------------------------------------------------------------------| +#| Speficy project source files | +#|---------------------------------------------------------------------------------------| +PROJ_FILES= \ +boot.c \ +boot.h \ +cstart.c \ +header.h \ +irq.c \ +irq.h \ +led.c \ +led.h \ +main.c \ +time.c \ +time.h \ +vectors.c \ +lib/inc/asmdefs.h \ +lib/inc/hw_adc.h \ +lib/inc/hw_comp.h \ +lib/inc/hw_epi.h \ +lib/inc/hw_ethernet.h \ +lib/inc/hw_flash.h \ +lib/inc/hw_gpio.h \ +lib/inc/hw_hibernate.h \ +lib/inc/hw_i2c.h \ +lib/inc/hw_i2s.h \ +lib/inc/hw_ints.h \ +lib/inc/hw_memmap.h \ +lib/inc/hw_nvic.h \ +lib/inc/hw_pwm.h \ +lib/inc/hw_qei.h \ +lib/inc/hw_ssi.h \ +lib/inc/hw_sysctl.h \ +lib/inc/hw_timer.h \ +lib/inc/hw_types.h \ +lib/inc/hw_uart.h \ +lib/inc/hw_udma.h \ +lib/inc/hw_usb.h \ +lib/inc/hw_watchdog.h \ +lib/inc/lm3s6965.h \ +lib/driverlib/adc.c \ +lib/driverlib/adc.h \ +lib/driverlib/comp.c \ +lib/driverlib/comp.h \ +lib/driverlib/cpu.c \ +lib/driverlib/cpu.h \ +lib/driverlib/debug.h \ +lib/driverlib/epi.c \ +lib/driverlib/epi.h \ +lib/driverlib/ethernet.c \ +lib/driverlib/ethernet.h \ +lib/driverlib/flash.c \ +lib/driverlib/flash.h \ +lib/driverlib/gpio.c \ +lib/driverlib/gpio.h \ +lib/driverlib/hibernate.c \ +lib/driverlib/hibernate.h \ +lib/driverlib/i2c.c \ +lib/driverlib/i2c.h \ +lib/driverlib/i2s.c \ +lib/driverlib/i2s.h \ +lib/driverlib/interrupt.c \ +lib/driverlib/interrupt.h \ +lib/driverlib/mpu.c \ +lib/driverlib/mpu.h \ +lib/driverlib/pin_map.h \ +lib/driverlib/pwm.c \ +lib/driverlib/pwm.h \ +lib/driverlib/qei.c \ +lib/driverlib/qei.h \ +lib/driverlib/rom.h \ +lib/driverlib/rom_map.h \ +lib/driverlib/ssi.c \ +lib/driverlib/ssi.h \ +lib/driverlib/sysctl.c \ +lib/driverlib/sysctl.h \ +lib/driverlib/systick.c \ +lib/driverlib/systick.h \ +lib/driverlib/timer.c \ +lib/driverlib/timer.h \ +lib/driverlib/uart.c \ +lib/driverlib/uart.h \ +lib/driverlib/udma.c \ +lib/driverlib/udma.h \ +lib/driverlib/usb.c \ +lib/driverlib/usb.h \ +lib/driverlib/watchdog.c \ +lib/driverlib/watchdog.h + + +#|---------------------------------------------------------------------------------------| +#| Compiler binaries | +#|---------------------------------------------------------------------------------------| +CC = arm-none-eabi-gcc +LN = arm-none-eabi-gcc +OC = arm-none-eabi-objcopy +OD = arm-none-eabi-objdump +AS = arm-none-eabi-as +SZ = arm-none-eabi-size + + +#|---------------------------------------------------------------------------------------| +#| Extract file names | +#|---------------------------------------------------------------------------------------| +PROJ_ASRCS = $(filter %.s,$(foreach file,$(PROJ_FILES),$(notdir $(file)))) +PROJ_CSRCS = $(filter %.c,$(foreach file,$(PROJ_FILES),$(notdir $(file)))) +PROJ_CHDRS = $(filter %.h,$(foreach file,$(PROJ_FILES),$(notdir $(file)))) +PROJ_CCMPL = $(patsubst %.c,%.cpl,$(PROJ_CSRCS)) +PROJ_ACMPL = $(patsubst %.s,%.cpl,$(PROJ_ASRCS)) + + +#|---------------------------------------------------------------------------------------| +#| Set important path variables | +#|---------------------------------------------------------------------------------------| +VPATH = $(foreach path,$(sort $(foreach file,$(PROJ_FILES),$(dir $(file)))) $(subst \,/,$(OBJ_PATH)),$(path) :) +OBJ_PATH = obj +BIN_PATH = bin +INC_PATH = $(patsubst %,-I%,$(sort $(foreach file,$(filter %.h,$(PROJ_FILES)),$(dir $(file))))) +INC_PATH += -I. -I./lib +LIB_PATH = + + +#|---------------------------------------------------------------------------------------| +#| Options for compiler binaries | +#|---------------------------------------------------------------------------------------| +CFLAGS = -g -D inline= -mthumb -mcpu=cortex-m3 -O1 -T memory.x +CFLAGS += -D PACK_STRUCT_END=__attribute\(\(packed\)\) -D sprintf=usprintf -Wno-main +CFLAGS += -D ALIGN_STRUCT_END=__attribute\(\(aligned\(4\)\)\) -D snprintf=usnprintf +CFLAGS += -D printf=uipprintf -ffunction-sections -fdata-sections $(INC_PATH) +CFLAGS += -D DEBUG -D gcc +LFLAGS = -nostartfiles -Xlinker -M -Xlinker -Map=$(BIN_PATH)/$(PROJ_NAME).map +LFLAGS += $(LIB_PATH) -Xlinker --no-gc-sections +OFLAGS = -O srec +ODFLAGS = -x +SZFLAGS = -B -d + + +#|---------------------------------------------------------------------------------------| +#| Specify library files | +#|---------------------------------------------------------------------------------------| +LIBS = + + +#|---------------------------------------------------------------------------------------| +#| Define targets | +#|---------------------------------------------------------------------------------------| +AOBJS = $(patsubst %.s,%.o,$(PROJ_ASRCS)) +COBJS = $(patsubst %.c,%.o,$(PROJ_CSRCS)) + + +#|---------------------------------------------------------------------------------------| +#| Make ALL | +#|---------------------------------------------------------------------------------------| +all : $(BIN_PATH)/$(PROJ_NAME).srec + + +$(BIN_PATH)/$(PROJ_NAME).srec : $(BIN_PATH)/$(PROJ_NAME).elf + @$(OC) $< $(OFLAGS) $@ + @$(OD) $(ODFLAGS) $< > $(BIN_PATH)/$(PROJ_NAME).map + @echo +++ Summary of memory consumption: + @$(SZ) $(SZFLAGS) $< + @echo +++ Build complete [$(notdir $@)] + +$(BIN_PATH)/$(PROJ_NAME).elf : $(AOBJS) $(COBJS) + @echo +++ Linking [$(notdir $@)] + @$(LN) $(CFLAGS) -o $@ $(patsubst %.o,$(OBJ_PATH)/%.o,$(^F)) $(LIBS) $(LFLAGS) + + +#|---------------------------------------------------------------------------------------| +#| Compile and assemble | +#|---------------------------------------------------------------------------------------| +$(AOBJS): %.o: %.s $(PROJ_CHDRS) + @echo +++ Assembling [$(notdir $<)] + @$(AS) $(AFLAGS) $< -o $(OBJ_PATH)/$(@F) + +$(COBJS): %.o: %.c $(PROJ_CHDRS) + @echo +++ Compiling [$(notdir $<)] + @$(CC) $(CFLAGS) -c $< -o $(OBJ_PATH)/$(@F) + + +#|---------------------------------------------------------------------------------------| +#| Make CLEAN | +#|---------------------------------------------------------------------------------------| +clean : + @echo +++ Cleaning build environment + @rm -f $(foreach file,$(AOBJS),$(OBJ_PATH)/$(file)) + @rm -f $(foreach file,$(COBJS),$(OBJ_PATH)/$(file)) + @rm -f $(patsubst %.o,%.lst,$(foreach file,$(COBJS),$(OBJ_PATH)/$(file))) + @rm -f $(BIN_PATH)/$(PROJ_NAME).elf $(BIN_PATH)/$(PROJ_NAME).map + @rm -f $(BIN_PATH)/$(PROJ_NAME).srec + @echo +++ Clean complete + + \ No newline at end of file diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/memory.x b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/memory.x new file mode 100644 index 00000000..2016bd61 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/memory.x @@ -0,0 +1,37 @@ +MEMORY +{ + FLASH (rx) : ORIGIN = 0x00004000, LENGTH = 240K + SRAM (rwx) : ORIGIN = 0x20000000, LENGTH = 64K +} + +SECTIONS +{ + __STACKSIZE__ = 256; + + .text : + { + KEEP(*(.isr_vector)) + *(.text*) + *(.rodata*) + _etext = .; + } > FLASH + + .data : AT (ADDR(.text) + SIZEOF(.text)) + { + _data = .; + *(vtable) + *(.data*) + _edata = .; + } > SRAM + + .bss : + { + _bss = .; + *(.bss*) + *(COMMON) + _ebss = .; + _stack = .; + . = ALIGN(MAX(_stack + __STACKSIZE__ , .), 4); + _estack = .; + } > SRAM +} diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/time.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/time.c new file mode 100644 index 00000000..ef3e5bd2 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/time.c @@ -0,0 +1,118 @@ +/**************************************************************************************** +| Description: Timer driver source file +| File Name: time.c +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "header.h" /* generic header */ + + +/**************************************************************************************** +* Local data declarations +****************************************************************************************/ +static unsigned long millisecond_counter; + + +/**************************************************************************************** +** NAME: TimeInit +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Initializes the timer. +** +****************************************************************************************/ +void TimeInit(void) +{ + /* configure the SysTick timer for 1 ms period */ + SysTickPeriodSet((unsigned long)SysCtlClockGet() / 1000); + SysTickEnable(); + SysTickIntEnable(); + /* reset the millisecond counter */ + TimeSet(0); +} /*** end of TimeInit ***/ + + +/**************************************************************************************** +** NAME: TimeDeinit +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Stops and disables the timer. +** +****************************************************************************************/ +void TimeDeinit(void) +{ + SysTickIntDisable(); + SysTickDisable(); +} /*** end of TimeDeinit ***/ + + +/**************************************************************************************** +** NAME: TimeSet +** PARAMETER: timer_value initialize value of the millisecond timer. +** RETURN VALUE: none +** DESCRIPTION: Sets the initial counter value of the millisecond timer. +** +****************************************************************************************/ +void TimeSet(unsigned long timer_value) +{ + /* set the millisecond counter */ + millisecond_counter = timer_value; +} /*** end of TimeSet ***/ + + +/**************************************************************************************** +** NAME: TimeGet +** PARAMETER: none +** RETURN VALUE: current value of the millisecond timer +** DESCRIPTION: Obtains the counter value of the millisecond timer. +** +****************************************************************************************/ +unsigned long TimeGet(void) +{ + /* read and return the millisecond counter value */ + return millisecond_counter; +} /*** end of TimeGet ***/ + + +/**************************************************************************************** +** NAME: TimeISRHandler +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Interrupt service routine of the timer. +** +****************************************************************************************/ +void TimeISRHandler(void) +{ + /* increment the millisecond counter */ + millisecond_counter++; +} /*** end of TimeISRHandler ***/ + + +/*********************************** end of time.c *************************************/ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/time.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/time.h new file mode 100644 index 00000000..a01f7e58 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/time.h @@ -0,0 +1,44 @@ +/**************************************************************************************** +| Description: Timer driver header file +| File Name: time.h +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ +#ifndef TIME_H +#define TIME_H + +/**************************************************************************************** +* Function prototypes +****************************************************************************************/ +void TimeInit(void); +void TimeDeinit(void); +void TimeSet(unsigned long timer_value); +unsigned long TimeGet(void); +void TimeISRHandler(void); + +#endif /* TIME_H */ +/*********************************** end of time.h *************************************/ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/vectors.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/vectors.c new file mode 100644 index 00000000..6462dc81 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/vectors.c @@ -0,0 +1,142 @@ +/**************************************************************************************** +| Description: bootloader interrupt vector table source file +| File Name: vectors.c +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "header.h" /* generic header */ + + +/**************************************************************************************** +* External functions +****************************************************************************************/ +extern void reset_handler(void); /* implemented in cstart.s */ + + +/**************************************************************************************** +* External data declarations +****************************************************************************************/ +extern unsigned long _estack; /* stack end address (memory.x) */ + + +/**************************************************************************************** +** NAME: UnusedISR +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Catch-all for unused interrrupt service routines. +** +****************************************************************************************/ +void UnusedISR(void) +{ + /* unexpected interrupt occured, so halt the system */ + while (1) { ; } +} /*** end of UnusedISR ***/ + + +/**************************************************************************************** +* I N T E R R U P T V E C T O R T A B L E +****************************************************************************************/ +typedef union +{ + void (*func)(void); /* for ISR function pointers */ + unsigned long ptr; /* for stack pointer entry */ +}tIsrFunc; /* type for vector table entries */ + +__attribute__ ((section(".isr_vector"))) +const tIsrFunc _vectab[] = +{ + { .ptr = (unsigned long)&_estack }, /* the initial stack pointer */ + { reset_handler }, /* the reset handler */ + { UnusedISR }, /* NMI Handler */ + { UnusedISR }, /* Hard Fault Handler */ + { UnusedISR }, /* MPU Fault Handler */ + { UnusedISR }, /* Bus Fault Handler */ + { UnusedISR }, /* Usage Fault Handler */ + { UnusedISR }, /* Reserved */ + { UnusedISR }, /* Reserved */ + { UnusedISR }, /* Reserved */ + { UnusedISR }, /* Reserved */ + { UnusedISR }, /* SVCall Handler */ + { UnusedISR }, /* Debug Monitor Handler */ + { UnusedISR }, /* Reserved */ + { UnusedISR }, /* PendSV Handler */ + { TimeISRHandler }, /* SysTick Handler */ + { UnusedISR }, /* GPIO Port A */ + { UnusedISR }, /* GPIO Port B */ + { UnusedISR }, /* GPIO Port C */ + { UnusedISR }, /* GPIO Port D */ + { UnusedISR }, /* GPIO Port E */ + { UnusedISR }, /* UART0 Rx and Tx */ + { UnusedISR }, /* UART1 Rx and Tx */ + { UnusedISR }, /* SSI Rx and Tx */ + { UnusedISR }, /* I2C Master and Slave */ + { UnusedISR }, /* PWM Fault */ + { UnusedISR }, /* PWM Generator 0 */ + { UnusedISR }, /* PWM Generator 1 */ + { UnusedISR }, /* PWM Generator 2 */ + { UnusedISR }, /* Quadrature Encoder */ + { UnusedISR }, /* ADC Sequence 0 */ + { UnusedISR }, /* ADC Sequence 1 */ + { UnusedISR }, /* ADC Sequence 2 */ + { UnusedISR }, /* ADC Sequence 3 */ + { UnusedISR }, /* Watchdog timer */ + { UnusedISR }, /* Timer 0 subtimer A */ + { UnusedISR }, /* Timer 0 subtimer B */ + { UnusedISR }, /* Timer 1 subtimer A */ + { UnusedISR }, /* Timer 1 subtimer B */ + { UnusedISR }, /* Timer 2 subtimer A */ + { UnusedISR }, /* Timer 2 subtimer B */ + { UnusedISR }, /* Analog Comparator 0 */ + { UnusedISR }, /* Analog Comparator 1 */ + { UnusedISR }, /* Analog Comparator 2 */ + { UnusedISR }, /* System Control (PLL, OSC, BO) */ + { UnusedISR }, /* FLASH Control */ + { UnusedISR }, /* GPIO Port F */ + { UnusedISR }, /* GPIO Port G */ + { UnusedISR }, /* GPIO Port H */ + { UnusedISR }, /* UART2 Rx and Tx */ + { UnusedISR }, /* SSI1 Rx and Tx */ + { UnusedISR }, /* Timer 3 subtimer A */ + { UnusedISR }, /* Timer 3 subtimer B */ + { UnusedISR }, /* I2C1 Master and Slave */ + { UnusedISR }, /* Quadrature Encoder 1 */ + { UnusedISR }, /* CAN0 */ + { UnusedISR }, /* CAN1 */ + { UnusedISR }, /* CAN2 */ + { UnusedISR }, /* Ethernet */ + { UnusedISR }, /* Hibernate */ + { (void*)0x55AA11EE } /* Reserved for OpenBLT checksum */ +}; + + +/************************************ end of hw.c **************************************/ + + diff --git a/Target/Source/ARMCM3_LM3S/GCC/cstart.c b/Target/Source/ARMCM3_LM3S/GCC/cstart.c new file mode 100644 index 00000000..9d245783 --- /dev/null +++ b/Target/Source/ARMCM3_LM3S/GCC/cstart.c @@ -0,0 +1,151 @@ +/**************************************************************************************** +| Description: bootloader C startup source file +| File Name: cstart.c +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "boot.h" /* bootloader generic header */ + + +/**************************************************************************************** +* External function protoypes +****************************************************************************************/ +extern int main(void); +extern void ComSetConnectEntryState(void); + + +/**************************************************************************************** +* External data declarations +****************************************************************************************/ +/* these externals are declared by the linker */ +extern blt_int32u _etext; +extern blt_int32u _data; +extern blt_int32u _edata; +extern blt_int32u _bss; +extern blt_int32u _ebss; +extern blt_int32u _estack; + + +/**************************************************************************************** +** NAME: EntryFromProg +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Called by the user program to activate the bootloader. Do not place +** any assembly code before this function and the end of the vector +** table. This guarantees that this function is located at address +** 0x08000150. The user program can call this function from C in the +** following way: +** void ActivateBootloader(void) +** { +** void (*pEntryFromProgFnc)(void); +** +** pEntryFromProgFnc = (void*)0x08000150; +** pEntryFromProgFnc(); +** } +** +****************************************************************************************/ +__attribute__ ((section (".entry"))) +void EntryFromProg(void) +{ + blt_int32u *pSrc, *pDest; + + /* disable interrupts first */ + __asm(" cpsid i"); + /* configure vector table offset register to use bootloader's vector table*/ + __asm(" ldr r0, =0xE000ED08\n" + " ldr r1, =_vectab\n" + " str r1, [r0]"); + /* initialize stack pointer */ + __asm(" ldr r1, =_estack\n" + " mov sp, r1"); + /* copy the data segment initializers from flash to SRAM */ + pSrc = &_etext; + for(pDest = &_data; pDest < &_edata; ) + { + *pDest++ = *pSrc++; + } + /* zero fill the bss segment. this is done with inline assembly since this will + * clear the value of pDest if it is not kept in a register. + */ + __asm(" ldr r0, =_bss\n" + " ldr r1, =_ebss\n" + " mov r2, #0\n" + " .thumb_func\n" + "zero_loop2:\n" + " cmp r0, r1\n" + " it lt\n" + " strlt r2, [r0], #4\n" + " blt zero_loop2"); + /* this part makes the difference with the normal reset_handler */ + ComSetConnectEntryState(); + /* start the software application by calling its entry point */ + main(); +} /*** end of EntryFromProg ***/ + + +/**************************************************************************************** +** NAME: reset_handler +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Reset interrupt service routine. Configures the stack, initializes +** RAM and jumps to function main. +** +****************************************************************************************/ +void reset_handler(void) +{ + blt_int32u *pSrc, *pDest; + + /* disable interrupts first */ + __asm(" cpsid i"); + /* copy the data segment initializers from flash to SRAM */ + pSrc = &_etext; + for(pDest = &_data; pDest < &_edata; ) + { + *pDest++ = *pSrc++; + } + /* zero fill the bss segment. this is done with inline assembly since this will + * clear the value of pDest if it is not kept in a register. + */ + __asm(" ldr r0, =_bss\n" + " ldr r1, =_ebss\n" + " mov r2, #0\n" + " .thumb_func\n" + "zero_loop:\n" + " cmp r0, r1\n" + " it lt\n" + " strlt r2, [r0], #4\n" + " blt zero_loop"); + /* start the software application by calling its entry point */ + main(); +} /*** end of reset_handler ***/ + + +/************************************ end of cstart.c **********************************/ \ No newline at end of file diff --git a/Target/Source/ARMCM3_LM3S/GCC/memory.x b/Target/Source/ARMCM3_LM3S/GCC/memory.x new file mode 100644 index 00000000..0c533192 --- /dev/null +++ b/Target/Source/ARMCM3_LM3S/GCC/memory.x @@ -0,0 +1,39 @@ +MEMORY +{ + FLASH (rx) : ORIGIN = 0x00000000, LENGTH = 16K + SRAM (rwx) : ORIGIN = 0x20000000, LENGTH = 4K +} + +SECTIONS +{ + __STACKSIZE__ = 256; + + .text : + { + KEEP(*(.isr_vector)) + *(.entry*) + *(.text*) + *(.rodata*) + _etext = .; + } > FLASH + + .data : AT (ADDR(.text) + SIZEOF(.text)) + { + _data = .; + *(vtable) + *(.data*) + _edata = .; + } > SRAM + + .bss : + { + _bss = .; + *(.bss*) + *(COMMON) + _ebss = .; + _stack = .; + . = ALIGN(MAX(_stack + __STACKSIZE__ , .), 4); + _estack = .; + + } > SRAM +} diff --git a/Target/Source/ARMCM3_LM3S/GCC/vectors.c b/Target/Source/ARMCM3_LM3S/GCC/vectors.c new file mode 100644 index 00000000..1e7785ec --- /dev/null +++ b/Target/Source/ARMCM3_LM3S/GCC/vectors.c @@ -0,0 +1,137 @@ +/**************************************************************************************** +| Description: bootloader interrupt vector table source file +| File Name: vectors.c +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "boot.h" /* bootloader generic header */ + + +/**************************************************************************************** +* External data declarations +****************************************************************************************/ +extern blt_int32u _estack; /* stack end address (memory.x) */ + + +/**************************************************************************************** +** NAME: UnusedISR +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Catch-all for unused interrrupt service routines. +** +****************************************************************************************/ +void UnusedISR(void) +{ + /* unexpected interrupt occured, so trigger an assertion to halt the system */ + ASSERT_RT(BLT_FALSE); +} /*** end of UnusedISR ***/ + + +/**************************************************************************************** +* I N T E R R U P T V E C T O R T A B L E +****************************************************************************************/ +extern void reset_handler(void); /* implemented in cstart.c */ + +typedef union +{ + void (*func)(void); /* for ISR function pointers */ + blt_int32u ptr; /* for stack pointer entry */ +}tIsrFunc; /* type for vector table entries */ + +__attribute__ ((section(".isr_vector"))) +const tIsrFunc _vectab[] = +{ + { .ptr = (blt_int32u)&_estack }, /* the initial stack pointer */ + { reset_handler }, /* the reset handler */ + { UnusedISR }, /* NMI Handler */ + { UnusedISR }, /* Hard Fault Handler */ + { UnusedISR }, /* MPU Fault Handler */ + { UnusedISR }, /* Bus Fault Handler */ + { UnusedISR }, /* Usage Fault Handler */ + { UnusedISR }, /* Reserved */ + { UnusedISR }, /* Reserved */ + { UnusedISR }, /* Reserved */ + { UnusedISR }, /* Reserved */ + { UnusedISR }, /* SVCall Handler */ + { UnusedISR }, /* Debug Monitor Handler */ + { UnusedISR }, /* Reserved */ + { UnusedISR }, /* PendSV Handler */ + { UnusedISR }, /* SysTick Handler */ + { UnusedISR }, /* GPIO Port A */ + { UnusedISR }, /* GPIO Port B */ + { UnusedISR }, /* GPIO Port C */ + { UnusedISR }, /* GPIO Port D */ + { UnusedISR }, /* GPIO Port E */ + { UnusedISR }, /* UART0 Rx and Tx */ + { UnusedISR }, /* UART1 Rx and Tx */ + { UnusedISR }, /* SSI Rx and Tx */ + { UnusedISR }, /* I2C Master and Slave */ + { UnusedISR }, /* PWM Fault */ + { UnusedISR }, /* PWM Generator 0 */ + { UnusedISR }, /* PWM Generator 1 */ + { UnusedISR }, /* PWM Generator 2 */ + { UnusedISR }, /* Quadrature Encoder */ + { UnusedISR }, /* ADC Sequence 0 */ + { UnusedISR }, /* ADC Sequence 1 */ + { UnusedISR }, /* ADC Sequence 2 */ + { UnusedISR }, /* ADC Sequence 3 */ + { UnusedISR }, /* Watchdog timer */ + { UnusedISR }, /* Timer 0 subtimer A */ + { UnusedISR }, /* Timer 0 subtimer B */ + { UnusedISR }, /* Timer 1 subtimer A */ + { UnusedISR }, /* Timer 1 subtimer B */ + { UnusedISR }, /* Timer 2 subtimer A */ + { UnusedISR }, /* Timer 2 subtimer B */ + { UnusedISR }, /* Analog Comparator 0 */ + { UnusedISR }, /* Analog Comparator 1 */ + { UnusedISR }, /* Analog Comparator 2 */ + { UnusedISR }, /* System Control (PLL, OSC, BO) */ + { UnusedISR }, /* FLASH Control */ + { UnusedISR }, /* GPIO Port F */ + { UnusedISR }, /* GPIO Port G */ + { UnusedISR }, /* GPIO Port H */ + { UnusedISR }, /* UART2 Rx and Tx */ + { UnusedISR }, /* SSI1 Rx and Tx */ + { UnusedISR }, /* Timer 3 subtimer A */ + { UnusedISR }, /* Timer 3 subtimer B */ + { UnusedISR }, /* I2C1 Master and Slave */ + { UnusedISR }, /* Quadrature Encoder 1 */ + { UnusedISR }, /* CAN0 */ + { UnusedISR }, /* CAN1 */ + { UnusedISR }, /* CAN2 */ + { UnusedISR }, /* Ethernet */ + { UnusedISR } /* Hibernate */ +}; + + +/************************************ end of vectors.c *********************************/ + +

    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�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�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 z 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

    • 4*iGjjMd5Z}vg%8B!HK4CWy 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 Lu(12WkJGm+ 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 literal 0 HcmV?d00001 diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/bin/demoprog_ek_lm3s6965.map b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/bin/demoprog_ek_lm3s6965.map new file mode 100644 index 00000000..6a8a9bd2 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/bin/demoprog_ek_lm3s6965.map @@ -0,0 +1,687 @@ + +bin/demoprog_ek_lm3s6965.elf: file format elf32-littlearm +bin/demoprog_ek_lm3s6965.elf +architecture: arm, flags 0x00000112: +EXEC_P, HAS_SYMS, D_PAGED +start address 0x00004000 + +Program Header: + LOAD off 0x00000000 vaddr 0x00000000 paddr 0x00000000 align 2**15 + filesz 0x00010584 memsz 0x00010584 flags r-x + LOAD off 0x00018000 vaddr 0x20000000 paddr 0x00010584 align 2**15 + filesz 0x0000011c memsz 0x00000284 flags rw- +private flags = 5000002: [Version5 EABI] [has entry point] + +Sections: +Idx Name Size VMA LMA File off Algn + 0 .text 0000c584 00004000 00004000 00004000 2**2 + CONTENTS, ALLOC, LOAD, READONLY, CODE + 1 .data 0000011c 20000000 00010584 00018000 2**2 + CONTENTS, ALLOC, LOAD, DATA + 2 .bss 00000168 2000011c 000106a0 0001811c 2**2 + ALLOC + 3 .debug_abbrev 00001afb 00000000 00000000 0001811c 2**0 + CONTENTS, READONLY, DEBUGGING + 4 .debug_info 00008981 00000000 00000000 00019c17 2**0 + CONTENTS, READONLY, DEBUGGING + 5 .debug_line 0000565e 00000000 00000000 00022598 2**0 + CONTENTS, READONLY, DEBUGGING + 6 .debug_loc 0000bd77 00000000 00000000 00027bf6 2**0 + CONTENTS, READONLY, DEBUGGING + 7 .debug_pubnames 0000305b 00000000 00000000 0003396d 2**0 + CONTENTS, READONLY, DEBUGGING + 8 .debug_pubtypes 00000326 00000000 00000000 000369c8 2**0 + CONTENTS, READONLY, DEBUGGING + 9 .debug_aranges 00001440 00000000 00000000 00036cee 2**0 + CONTENTS, READONLY, DEBUGGING + 10 .debug_ranges 00001270 00000000 00000000 0003812e 2**0 + CONTENTS, READONLY, DEBUGGING + 11 .debug_str 00003310 00000000 00000000 0003939e 2**0 + CONTENTS, READONLY, DEBUGGING + 12 .comment 0000002a 00000000 00000000 0003c6ae 2**0 + CONTENTS, READONLY + 13 .ARM.attributes 00000031 00000000 00000000 0003c6d8 2**0 + CONTENTS, READONLY + 14 .debug_frame 00003904 00000000 00000000 0003c70c 2**2 + CONTENTS, READONLY, DEBUGGING +SYMBOL TABLE: +00004000 l d .text 00000000 .text +20000000 l d .data 00000000 .data +2000011c l d .bss 00000000 .bss +00000000 l d .debug_abbrev 00000000 .debug_abbrev +00000000 l d .debug_info 00000000 .debug_info +00000000 l d .debug_line 00000000 .debug_line +00000000 l d .debug_loc 00000000 .debug_loc +00000000 l d .debug_pubnames 00000000 .debug_pubnames +00000000 l d .debug_pubtypes 00000000 .debug_pubtypes +00000000 l d .debug_aranges 00000000 .debug_aranges +00000000 l d .debug_ranges 00000000 .debug_ranges +00000000 l d .debug_str 00000000 .debug_str +00000000 l d .comment 00000000 .comment +00000000 l d .ARM.attributes 00000000 .ARM.attributes +00000000 l d .debug_frame 00000000 .debug_frame +00000000 l df *ABS* 00000000 vectors.c +00000000 l df *ABS* 00000000 boot.c +000040f4 l F .text 0000001e UartReceiveByte +2000011c l O .bss 00000001 xcpCtoRxInProgress.1651 +2000011d l O .bss 00000001 xcpCtoRxLength.1650 +20000120 l O .bss 00000041 xcpCtoReqPacket.1649 +00000000 l df *ABS* 00000000 cstart.c +0000424e l F .text 00000000 zero_loop +00000000 l df *ABS* 00000000 irq.c +20000164 l O .bss 00000001 interruptNesting +00000000 l df *ABS* 00000000 led.c +20000168 l O .bss 00000004 timer_counter_last.1643 +2000016c l O .bss 00000001 led_toggle_state.1642 +00000000 l df *ABS* 00000000 main.c +20000170 l O .bss 00000004 assert_failure_file.1649 +20000174 l O .bss 00000004 assert_failure_line.1650 +00000000 l df *ABS* 00000000 time.c +20000178 l O .bss 00000004 millisecond_counter +00000000 l df *ABS* 00000000 adc.c +2000017c l O .bss 00000003 g_pucOversampleFactor +00000000 l df *ABS* 00000000 comp.c +00000000 l df *ABS* 00000000 cpu.c +00000000 l df *ABS* 00000000 epi.c +00000000 l df *ABS* 00000000 ethernet.c +00005c4c l F .text 000000b6 EthernetPacketGetInternal +00005d04 l F .text 00000094 EthernetPacketPutInternal +00000000 l df *ABS* 00000000 flash.c +00010290 l O .text 00000010 g_pulFMPPERegs +000102b8 l O .text 00000010 g_pulFMPRERegs +00000000 l df *ABS* 00000000 gpio.c +00006a5c l F .text 00000188 GPIOBaseValid +00006be4 l F .text 00000172 GPIOGetIntNumber +000102e0 l O .text 00000048 g_pulGPIOBaseAddrs +00000000 l df *ABS* 00000000 hibernate.c +20000180 l O .bss 00000004 g_ulWriteDelay +00000000 l df *ABS* 00000000 i2c.c +00000000 l df *ABS* 00000000 i2s.c +00000000 l df *ABS* 00000000 interrupt.c +00008af4 l F .text 00000002 IntDefaultHandler +20000000 l O .data 0000011c g_pfnRAMVectors +00010388 l O .text 00000020 g_pulPriority +000103a8 l O .text 00000048 g_pulRegs +00000000 l df *ABS* 00000000 mpu.c +00000000 l df *ABS* 00000000 pwm.c +000090fc l F .text 0000002e PWMGenValid +0000912c l F .text 0000005c PWMOutValid +00000000 l df *ABS* 00000000 qei.c +00000000 l df *ABS* 00000000 ssi.c +00000000 l df *ABS* 00000000 sysctl.c +0000a86c l F .text 0000039c SysCtlPeripheralValid +00010440 l O .text 00000010 g_pulDCRegs +00010450 l O .text 0000005c g_pulXtals +000104c4 l O .text 0000000c g_pulRCGCRegs +000104d0 l O .text 0000000c g_pulSCGCRegs +000104dc l O .text 0000000c g_pulSRCRRegs +000104e8 l O .text 0000000c g_pulDCGCRegs +00000000 l df *ABS* 00000000 systick.c +00000000 l df *ABS* 00000000 timer.c +0000bc1c l F .text 0000004e TimerBaseValid +00000000 l df *ABS* 00000000 uart.c +0000c608 l F .text 0000003c UARTBaseValid +00000000 l df *ABS* 00000000 udma.c +00000000 l df *ABS* 00000000 usb.c +0000d994 l F .text 00000066 USBIndexRead +0000d9fc l F .text 00000072 USBIndexWrite +00000000 l df *ABS* 00000000 watchdog.c +0000ed50 g F .text 0000012e USBFIFOConfigGet +0000c6a8 g F .text 00000022 UARTParityModeGet +00007fec g F .text 0000004e I2CMasterIntStatus +0000b0f8 g F .text 0000000c SysCtlLDOGet +0000feac g F .text 0000003a WatchdogResetEnable +0000437c g F .text 00000016 __error__ +0000eec8 g F .text 000000f6 USBEndpointDataAvail +0000b080 g F .text 0000001a SysCtlIntStatus +00007d6c g F .text 0000004a I2CSlaveDisable +00004f88 g F .text 00000074 ADCComparatorReset +0000db0c g F .text 00000044 USBHostSpeedGet +00007360 g F .text 0000003a GPIOPinTypeGPIOInput +000074c8 g F .text 0000003a GPIOPinTypeSSI +0000d2b8 g F .text 00000026 UARTDMADisable +0000518c g F .text 0000003e ADCReferenceGet +0000d440 g F .text 0000000c uDMAControlAlternateBaseGet +00009818 g F .text 00000064 PWMGenIntTrigDisable +0000d654 g F .text 00000140 uDMAChannelTransferSet +00004208 g F .text 00000056 reset_handler +0000de5c g F .text 0000003c USBIntEnableEndpoint +0000b94c g F .text 000000b2 SysCtlGPIOAHBDisable +0000a710 g F .text 00000046 SSIDataGet +0000b7d8 g F .text 00000032 SysCtlADCSpeedGet +00005b40 g F .text 00000030 EPIIntStatus +00009308 g F .text 00000044 PWMGenDisable +00007234 g F .text 0000002e GPIOPortIntUnregister +00009a38 g F .text 000000a4 PWMGenFaultConfigure +0000ddbc g F .text 00000062 USBIntStatusControl +0000d5fc g F .text 00000058 uDMAChannelControlSet +0000e480 g F .text 00000120 USBDevEndpointStall +0000eea4 g F .text 00000024 USBEndpointDMADisable +0000d854 g F .text 0000005e uDMAChannelSizeGet +0000def8 g F .text 00000030 USBIntUnregister +000099fc g F .text 0000003c PWMFaultIntClearExt +000056ac g F .text 00000072 EPIConfigGPModeSet +0000e398 g F .text 000000e8 USBEndpointDataToggleClear +0000fb84 g F .text 00000036 USBHostPwrFaultDisable +0000a578 g F .text 00000042 SSIIntDisable +0000d220 g F .text 00000026 UARTIntDisable +0000d270 g F .text 00000020 UARTIntClear +0000a408 g F .text 00000040 SSIEnable +00009e7c g F .text 0000004a QEIConfigure +000085cc g F .text 0000003a I2STxFIFOLimitSet +00007cd4 g F .text 00000058 I2CSlaveInit +0000b1c8 g F .text 00000006 SysCtlDelay +00009f40 g F .text 00000048 QEIDirectionGet +00007a04 g F .text 0000008c HibernateDataSet +00006a20 g F .text 00000012 FlashIntDisable +0000426c g F .text 00000008 IrqInterruptEnable +0000d390 g F .text 0000002c uDMAChannelDisable +00007c88 g F .text 0000004a I2CSlaveEnable +00009bcc g F .text 00000082 PWMGenFaultTriggerGet +00004914 g F .text 0000005c ADCSequenceOverflow +0000803c g F .text 0000004e I2CSlaveIntStatus +00005fcc g F .text 0000002c EthernetPacketAvail +00009f88 g F .text 0000003e QEIErrorGet +0000c540 g F .text 00000026 TimerIntDisable +0000bfe0 g F .text 00000080 TimerControlWaitOnTrigger +0000b708 g F .text 00000046 SysCtlPWMClockGet +0000d354 g F .text 00000010 uDMAErrorStatusClear +00007a90 g F .text 0000004c HibernateDataGet +00008ff0 g F .text 00000068 MPURegionSet +0000862c g F .text 00000024 I2STxFIFOLevelGet +00006a0c g F .text 00000012 FlashIntEnable +00007200 g F .text 00000032 GPIOPortIntRegister +0000f700 g F .text 0000002a USBHostRequestStatus +00007860 g F .text 0000003c HibernateLowBatSet +0000808c g F .text 0000007a I2CSlaveIntStatusEx +0000d794 g F .text 000000c0 uDMAChannelScatterGatherSet +0000a7e8 g F .text 00000042 SSIDMADisable +0000a2b0 g F .text 00000158 SSIConfigSetExpClk +0000a6a4 g F .text 0000006a SSIDataPutNonBlocking +0000bf70 g F .text 0000006e TimerControlStall +000086ec g F .text 0000003a I2SRxDataGetNonBlocking +0000d44c g F .text 0000002c uDMAChannelRequest +0000530c g F .text 0000005a ComparatorIntRegister +000096fc g F .text 00000052 PWMGenIntUnregister +00010018 g F .text 00000034 WatchdogReloadGet +000099a8 g F .text 00000028 PWMFaultIntClear +000043a0 g F .text 0000000c TimeSet +00009188 g F .text 0000006c PWMGenConfigure +0000987c g F .text 00000048 PWMGenIntStatus +00005514 g F .text 0000004c EPIModeSet +00008514 g F .text 0000002c I2STxDataPut +00010584 g .text 00000000 _etext +000087a8 g F .text 0000003c I2SRxFIFOLimitSet +0000ae20 g F .text 00000064 SysCtlPeripheralReset +000058b4 g F .text 00000024 EPINonBlockingReadAvail +00009784 g F .text 00000030 PWMFaultIntUnregister +0000b13c g F .text 00000008 SysCtlSleep +0000b164 g F .text 0000000c SysCtlResetCauseGet +00008c88 g F .text 0000003e IntPriorityGet +0000c5b0 g F .text 00000056 TimerQuiesce +0000d504 g F .text 0000008c uDMAChannelAttributeDisable +00008c00 g F .text 00000038 IntPriorityGroupingGet +00008148 g F .text 0000003e I2CSlaveIntClear +000084b0 g F .text 00000034 I2STxEnable +00008a7c g F .text 00000046 I2SIntRegister +00007158 g F .text 0000002a GPIOPinIntEnable +0000d108 g F .text 00000038 UARTBreakCtl +0000ffe0 g F .text 00000036 WatchdogReloadSet +00007288 g F .text 00000024 GPIOPinWrite +00005720 g F .text 0000003a EPIAddressMapSet +0000a82c g F .text 0000003e SSIBusy +00008a3c g F .text 00000040 I2SIntClear +00004b04 g F .text 00000068 ADCProcessorTrigger +0000d590 g F .text 0000006a uDMAChannelAttributeGet +0000f90c g F .text 000000f0 USBHostHubAddrSet +00007b48 g F .text 00000016 HibernateIntRegister +0000f9fc g F .text 000000f0 USBHostHubAddrGet +0000bf08 g F .text 00000068 TimerControlEvent +0000fe20 g F .text 0000000a USBPHYPowerOff +00007b60 g F .text 00000014 HibernateIntUnregister +0000550c g F .text 00000006 CPUbasepriGet +00008f64 g F .text 00000012 MPUDisable +0000446c g F .text 0000006e ADCIntUnregister +0000d038 g F .text 00000028 UARTSpaceAvail +00005588 g F .text 0000004a EPIConfigSDRAMSet +0000934c g F .text 00000070 PWMPulseWidthSet +0000af7c g F .text 0000003c SysCtlPeripheralDeepSleepEnable +00008e18 g F .text 00000092 IntPendSet +000061b0 g F .text 00000046 EthernetIntRegister +000055d4 g F .text 0000006c EPIConfigHB8Set +0000d164 g F .text 0000004c UARTIntRegister +000078ac g F .text 00000044 HibernateRTCSet +0000d0b4 g F .text 0000002c UARTCharPutNonBlocking +0000da70 g F .text 0000002a USBHostSuspend +0000fe70 g F .text 0000003a WatchdogEnable +0000a1ec g F .text 00000042 QEIIntDisable +0000bb74 g F .text 0000001e SysTickIntRegister +0000772c g F .text 00000010 HibernateWriteComplete +00009554 g F .text 0000004a PWMOutputState +00007fa8 g F .text 00000042 I2CSlaveIntDisableEx +00004ffc g F .text 0000005e ADCComparatorIntDisable +0000d1f8 g F .text 00000026 UARTIntEnable +00004624 g F .text 00000058 ADCIntClear +00004a7c g F .text 00000086 ADCSequenceDataGet +00007d2c g F .text 00000040 I2CMasterDisable +0000d8b4 g F .text 00000066 uDMAChannelModeGet +0000efc0 g F .text 0000012c USBEndpointDataGet +000101f4 g F .text 0000003e WatchdogStallDisable +00005d98 g F .text 00000036 EthernetInitExpClk +0000c9d4 g F .text 00000024 UARTDisableSIR +0000d91c g F .text 00000012 uDMAChannelSelectSecondary +00007090 g F .text 000000c8 GPIOPadConfigGet +00007940 g F .text 0000000c HibernateRTCMatch0Get +0000a1a8 g F .text 00000042 QEIIntEnable +000101b4 g F .text 0000003e WatchdogStallEnable +0000cd8c g F .text 000000ac UARTModemStatusGet +0000d338 g F .text 00000010 uDMADisable +000088a4 g F .text 0000008c I2STxRxConfigSet +000052c4 g F .text 00000046 ComparatorValueGet +00007450 g F .text 0000003a GPIOPinTypePWM +00005408 g F .text 00000048 ComparatorIntDisable +000093bc g F .text 0000005a PWMPulseWidthGet +0000a4e0 g F .text 00000054 SSIIntUnregister +0000bcc8 g F .text 0000005a TimerDisable +0000467c g F .text 0000005c ADCSequenceEnable +0000608c g F .text 0000005e EthernetPacketGet +00008930 g F .text 0000004c I2SMasterClockSelect +0000af00 g F .text 0000003c SysCtlPeripheralSleepEnable +00008688 g F .text 0000002e I2SRxDisable +00006150 g F .text 0000005e EthernetPacketPut +00005640 g F .text 0000006c EPIConfigHB16Set +000081c4 g F .text 00000058 I2CMasterSlaveAddrSet +0000832c g F .text 00000056 I2CMasterErr +0000ae84 g F .text 0000003c SysCtlPeripheralEnable +0000d0e0 g F .text 00000028 UARTCharPut +0000fc24 g F .text 00000026 USBFrameNumberGet +00009494 g F .text 00000048 PWMDeadBandDisable +0000be28 g F .text 0000006e TimerControlLevel +0000c9f8 g F .text 000000b2 UARTSmartCardEnable +0001017c g F .text 00000038 WatchdogIntClear +00009cf0 g F .text 0000010c PWMGenFaultClear +00008f28 g F .text 00000008 IntPriorityMaskSet +0000fc98 g F .text 0000002a USBModeGet +000057cc g F .text 0000005a EPINonBlockingReadStart +00008f38 g F .text 0000002a MPUEnable +00005954 g F .text 0000007a EPINonBlockingReadGet16 +00008874 g F .text 0000002e I2STxRxDisable +0000d3bc g F .text 00000034 uDMAChannelIsEnabled +00009278 g F .text 0000004c PWMGenPeriodGet +0000c770 g F .text 0000004a UARTConfigGetExpClk +00004738 g F .text 000000c0 ADCSequenceConfigure +00007f28 g F .text 0000003e I2CMasterIntDisable +0000bc6c g F .text 0000005a TimerEnable +0000b128 g F .text 00000014 SysCtlReset +000083fc g F .text 0000003a I2CSlaveStatus +00005870 g F .text 00000042 EPINonBlockingReadCount +0000fe2c g F .text 0000000a USBPHYPowerOn +000077bc g F .text 0000003a HibernateClockSelect +0000c0a8 g F .text 00000070 TimerPrescaleSet +00008188 g F .text 0000003c I2CSlaveIntClearEx +00004970 g F .text 00000058 ADCSequenceOverflowClear +00004ef0 g F .text 00000098 ADCComparatorRegionSet +00007184 g F .text 0000002a GPIOPinIntDisable +000063b0 g F .text 00000020 EthernetPHYPowerOff +0000cb54 g F .text 000000c6 UARTModemControlSet +0000dd50 g F .text 0000006a USBIntEnableControl +0000ff24 g F .text 0000003a WatchdogLock +20000184 g .bss 00000000 _ebss +0000bb60 g F .text 00000012 SysTickDisable +000059d0 g F .text 00000078 EPINonBlockingReadGet8 +00009f04 g F .text 0000003c QEIPositionSet +00008438 g F .text 0000003c I2CSlaveDataPut +0000505c g F .text 0000005c ADCComparatorIntEnable +0000bc00 g F .text 00000010 SysTickPeriodGet +0000f72c g F .text 000000f0 USBHostAddrSet +0000b060 g F .text 00000012 SysCtlIntDisable +0000d478 g F .text 0000008c uDMAChannelAttributeEnable +0000ac20 g F .text 00000016 SysCtlFlashSizeGet +00005ab8 g F .text 00000044 EPIIntEnable +00008fbc g F .text 00000034 MPURegionDisable +00007ea4 g F .text 00000040 I2CSlaveIntEnable +00000100 g *ABS* 00000000 __STACKSIZE__ +00010140 g F .text 0000003c WatchdogIntStatus +0000b170 g F .text 00000012 SysCtlResetCauseClear +000043f8 g F .text 00000002 UnusedISR +00006028 g F .text 00000064 EthernetPacketGetNonBlocking +000075b8 g F .text 0000003a GPIOPinTypeUSBAnalog +00004e98 g F .text 00000058 ADCComparatorConfigure +0000ac08 g F .text 00000018 SysCtlSRAMSizeGet +000042b4 g F .text 00000030 LedInit +00007264 g F .text 00000022 GPIOPinRead +0000a048 g F .text 00000076 QEIVelocityConfigure +00010080 g F .text 00000044 WatchdogIntRegister +0000dc54 g F .text 00000092 USBIntEnable +0000c28c g F .text 0000004a TimerLoadGet +0000c380 g F .text 0000004a TimerMatchGet +000078fc g F .text 00000044 HibernateRTCMatch0Set +0000af3c g F .text 0000003e SysCtlPeripheralSleepDisable +000043e4 g F .text 00000012 TimeISRHandler +00007630 g F .text 0000003a GPIOPinTypeEthernetLED +00006db8 g F .text 00000058 GPIODirModeGet +000072ac g F .text 0000003a GPIOPinTypeADC +0000fc4c g F .text 00000040 USBOTGSessionRequest +0000c1dc g F .text 00000054 TimerPrescaleMatchGet +000058d8 g F .text 0000007a EPINonBlockingReadGet32 +00005ee4 g F .text 0000005e EthernetMACAddrGet +00007f68 g F .text 00000040 I2CSlaveIntDisable +0000ce38 g F .text 000000c2 UARTFlowControlSet +00007af0 g F .text 0000002a HibernateIntEnable +0000b89c g F .text 000000b0 SysCtlGPIOAHBEnable +0000bc10 g F .text 0000000c SysTickValueGet +00004a24 g F .text 00000058 ADCSequenceUnderflowClear +0000aff8 g F .text 00000026 SysCtlPeripheralClockGating +0000a488 g F .text 00000058 SSIIntRegister +00010104 g F .text 0000003a WatchdogIntEnable +00007990 g F .text 0000000c HibernateRTCMatch1Get +0000d010 g F .text 00000028 UARTCharsAvail +00006228 g F .text 00000042 EthernetIntEnable +000078f0 g F .text 0000000c HibernateRTCGet +0000ac38 g F .text 00000188 SysCtlPinPresent +0000caac g F .text 000000a6 UARTSmartCardDisable +00007850 g F .text 00000010 HibernateWakeGet +0000c324 g F .text 0000005c TimerMatchSet +00008608 g F .text 00000024 I2STxFIFOLimitGet +0000c084 g F .text 00000024 TimerRTCDisable +000077f8 g F .text 00000012 HibernateRTCEnable +00007414 g F .text 0000003a GPIOPinTypeI2C +0000575c g F .text 0000006e EPINonBlockingReadConfigure +00004298 g F .text 0000001c IrqInterruptRestore +00008108 g F .text 00000040 I2CMasterIntClear +0000c518 g F .text 00000026 TimerIntEnable +0000d060 g F .text 0000002a UARTCharGetNonBlocking +00009c50 g F .text 0000009e PWMGenFaultStatus +00008eac g F .text 0000007c IntPendClear +0000a63c g F .text 00000066 SSIDataPut +000073d8 g F .text 0000003a GPIOPinTypeGPIOOutputOD +00005b70 g F .text 00000026 EPIIntErrorStatus +2000011c g .bss 00000000 _bss +0000c118 g F .text 00000054 TimerPrescaleGet +000050b8 g F .text 0000003a ADCComparatorIntStatus +00008474 g F .text 0000003a I2CSlaveDataGet +0000e754 g F .text 00000024 USBDevAddrGet +00007adc g F .text 00000012 HibernateRequest +0000f3f0 g F .text 000000fe USBEndpointDataSend +000044dc g F .text 0000005e ADCIntDisable +0000c97c g F .text 00000024 UARTFIFODisable +0000b104 g F .text 00000024 SysCtlLDOConfigSet +00008f78 g F .text 00000010 MPURegionCountGet +0000fbbc g F .text 00000030 USBHostPwrEnable +00007b98 g F .text 0000002a HibernateIntClear +000068e8 g F .text 00000052 FlashUserSet +0000dbc0 g F .text 00000092 USBIntDisable +0000dec4 g F .text 00000034 USBIntRegister +00005b98 g F .text 0000003c EPIIntErrorClear +0000748c g F .text 0000003a GPIOPinTypeQEI +0000bbc4 g F .text 00000012 SysTickIntDisable +00008ac4 g F .text 00000030 I2SIntUnregister +0000829c g F .text 00000090 I2CMasterControl +000047f8 g F .text 0000011c ADCSequenceStepConfigure +00009518 g F .text 0000003c PWMSyncTimeBase +00009ec8 g F .text 0000003a QEIPositionGet +0000a5bc g F .text 00000042 SSIIntStatus +00008bc8 g F .text 00000038 IntPriorityGroupingSet +00005368 g F .text 00000058 ComparatorIntUnregister +0000453c g F .text 0000005e ADCIntEnable +0000bbd8 g F .text 00000028 SysTickPeriodSet +00006e10 g F .text 000000aa GPIOIntTypeSet +000063f0 g F .text 00000010 FlashUsecGet +000061f8 g F .text 00000030 EthernetIntUnregister +000089c4 g F .text 00000048 I2SIntDisable +0000cc1c g F .text 000000c6 UARTModemControlClear +0000db50 g F .text 00000070 USBIntStatus +000054e8 g F .text 00000008 CPUcpsid +000099d0 g F .text 0000002c PWMIntStatus +0000773c g F .text 0000006c HibernateEnableExpClk +0000d984 g F .text 00000010 uDMAIntUnregister +0000d944 g F .text 00000040 uDMAIntRegister +0000e254 g F .text 00000142 USBHostEndpointDataToggle +00006a50 g F .text 0000000c FlashIntClear +00005500 g F .text 00000004 CPUwfi +00005a90 g F .text 00000026 EPIWriteFIFOCountGet +0000c2d8 g F .text 0000004a TimerValueGet +0000f0ec g F .text 000000f8 USBDevEndpointDataAck +000094dc g F .text 0000003c PWMSyncUpdate +0000d434 g F .text 0000000c uDMAControlBaseGet +0000b144 g F .text 00000020 SysCtlDeepSleep +0000e940 g F .text 00000154 USBDevEndpointConfigSet +00009fc8 g F .text 00000040 QEIVelocityEnable +000054f0 g F .text 00000006 CPUprimask +0000a274 g F .text 0000003c QEIIntClear +0000cce4 g F .text 000000a8 UARTModemControlGet +0000c060 g F .text 00000024 TimerRTCEnable +00006484 g F .text 00000120 FlashProgram +000063d0 g F .text 00000020 EthernetPHYPowerOn +0000825c g F .text 0000003e I2CMasterBusBusy +00004d1c g F .text 000000d4 ADCSoftwareOversampleDataGet +00005f88 g F .text 00000042 EthernetDisable +0000a154 g F .text 00000054 QEIIntUnregister +0000c740 g F .text 0000002e UARTFIFOLevelGet +000062b0 g F .text 0000002c EthernetIntStatus +0000f81c g F .text 000000f0 USBHostAddrGet +00009920 g F .text 00000042 PWMIntEnable +0000a600 g F .text 0000003c SSIIntClear +0000fbec g F .text 00000036 USBHostPwrDisable +000067f8 g F .text 0000006e FlashProtectSave +0000c3cc g F .text 000000a8 TimerIntRegister +00006410 g F .text 00000072 FlashErase +000079f8 g F .text 0000000c HibernateRTCTrimGet +0000b09c g F .text 0000005c SysCtlLDOSet +000051cc g F .text 00000050 ADCPhaseDelaySet +00005258 g F .text 00000044 ComparatorConfigure +00005c1c g F .text 00000030 EPIIntUnregister +00004354 g F .text 00000028 main +000084e4 g F .text 0000002e I2STxDisable +00005afc g F .text 00000044 EPIIntDisable +0000b394 g F .text 000002e2 SysCtlClockGet +0000a7a4 g F .text 00000042 SSIDMAEnable +00007b74 g F .text 00000024 HibernateIntStatus +00005450 g F .text 00000052 ComparatorIntStatus +0000883c g F .text 00000038 I2STxRxEnable +000054a4 g F .text 00000042 ComparatorIntClear +0000c230 g F .text 0000005c TimerLoadSet +0000ba28 g F .text 00000122 SysCtlI2SMClkSet +0000d3f0 g F .text 00000042 uDMAControlBaseSet +0000b80c g F .text 00000026 SysCtlIOSCVerificationSet +000069f8 g F .text 00000014 FlashIntUnregister +000060ec g F .text 00000064 EthernetPacketPutNonBlocking +0000cfa0 g F .text 0000004c UARTTxIntModeSet +0000c7ec g F .text 00000038 UARTDisable +000050f4 g F .text 0000003c ADCComparatorIntClear +00005f44 g F .text 00000042 EthernetEnable +0000fcc4 g F .text 00000102 USBEndpointDMAChannel +000092c4 g F .text 00000044 PWMGenEnable +0000897c g F .text 00000048 I2SIntEnable +0000b020 g F .text 00000016 SysCtlIntRegister +00008f88 g F .text 00000034 MPURegionEnable +00008384 g F .text 0000003c I2CMasterDataPut +0000ba00 g F .text 00000012 SysCtlUSBPLLEnable +00008b98 g F .text 0000002e IntUnregister +000072e8 g F .text 0000003a GPIOPinTypeCAN +0000b038 g F .text 00000014 SysCtlIntUnregister +00008728 g F .text 0000007e I2SRxConfigSet +0000766c g F .text 0000003a GPIOPinTypeEPI +0000f1e4 g F .text 000000f6 USBHostEndpointDataAck +00004114 g F .text 00000046 BootComInit +000053c0 g F .text 00000046 ComparatorIntEnable +00005bd4 g F .text 00000046 EPIIntRegister +0000521c g F .text 0000003a ADCPhaseDelayGet +0000de20 g F .text 0000003c USBIntDisableEndpoint +00009658 g F .text 0000004a PWMOutputFault +00008814 g F .text 00000026 I2SRxFIFOLevelGet +00006a34 g F .text 0000001a FlashIntStatus +0000d248 g F .text 00000026 UARTIntStatus +00009e3c g F .text 00000040 QEIDisable +00004b6c g F .text 000000a6 ADCSoftwareOversampleConfigure +00009418 g F .text 0000007a PWMDeadBandEnable +000075f4 g F .text 0000003a GPIOPinTypeI2S +0000a758 g F .text 0000004a SSIDataGetNonBlocking +00008af8 g F .text 0000000a IntMasterEnable +0000dce8 g F .text 00000068 USBIntDisableControl +000043ac g F .text 0000002c TimeInit +00008b10 g F .text 00000086 IntRegister +0000c590 g F .text 00000020 TimerIntClear +0000fe38 g F .text 00000038 WatchdogRunning +00005e78 g F .text 0000006c EthernetMACAddrSet +000095a0 g F .text 0000004a PWMOutputInvert +0000d2e0 g F .text 00000022 UARTRxErrorGet +00009750 g F .text 00000034 PWMFaultIntRegister +0000b750 g F .text 00000086 SysCtlADCSpeedSet +0000780c g F .text 00000012 HibernateRTCDisable +000095ec g F .text 0000006a PWMOutputFaultLevel +0000b184 g F .text 00000042 SysCtlBrownOutConfigSet +0000459c g F .text 00000086 ADCIntStatus +00005a48 g F .text 00000048 EPIFIFOConfig +0000d348 g F .text 0000000c uDMAErrorStatusGet +00008b04 g F .text 0000000a IntMasterDisable +0000e6d4 g F .text 0000002a USBDevConnect +0000757c g F .text 0000003a GPIOPinTypeUSBDigital +00008d70 g F .text 000000a8 IntDisable +0000ee80 g F .text 00000024 USBEndpointDMAEnable +00008c38 g F .text 00000050 IntPrioritySet +000071dc g F .text 00000022 GPIOPinIntClear +000069e0 g F .text 00000016 FlashIntRegister +00004394 g F .text 0000000c TimeDeinit +20000000 g .data 00000000 _data +00006364 g F .text 0000004a EthernetPHYRead +000042e4 g F .text 0000006e LedToggle +0000d328 g F .text 00000010 uDMAEnable +0000a534 g F .text 00000042 SSIIntEnable +0000a008 g F .text 00000040 QEIVelocityDisable +0000d08c g F .text 00000026 UARTCharGet +000043fc g F .text 0000006e ADCIntRegister +0000c6cc g F .text 00000074 UARTFIFOLevelSet +0000f4f0 g F .text 00000122 USBFIFOFlush +0000a448 g F .text 00000040 SSIDisable +00007e10 g F .text 00000054 I2CIntUnregister +00005560 g F .text 00000026 EPIDividerSet +0000d930 g F .text 00000012 uDMAChannelSelectDefault +0000c958 g F .text 00000024 UARTFIFOEnable +0000693c g F .text 000000a2 FlashUserSave +0000fdc8 g F .text 0000002a USBHostMode +000097b4 g F .text 00000064 PWMGenIntTrigEnable +00007db8 g F .text 00000058 I2CIntRegister +00007820 g F .text 0000002e HibernateWakeSet +0000b834 g F .text 00000026 SysCtlMOSCVerificationSet +0000dad4 g F .text 00000038 USBHostResume +0000b04c g F .text 00000012 SysCtlIntEnable +00005130 g F .text 0000005a ADCReferenceSet +0000cefc g F .text 000000a4 UARTFlowControlGet +00009dfc g F .text 00000040 QEIEnable +20000284 g .bss 00000000 _estack +0000a0fc g F .text 00000058 QEIIntRegister +00009964 g F .text 00000042 PWMIntDisable +0000e014 g F .text 00000106 USBHostEndpointStatusClear +00005dd0 g F .text 0000006e EthernetConfigSet +0000cfec g F .text 00000022 UARTTxIntModeGet +00007c14 g F .text 00000072 I2CMasterInitExpClk +000086b8 g F .text 00000034 I2SRxDataGet +2000011c g .data 00000000 _edata +0000df28 g F .text 000000ea USBEndpointStatus +0000ff60 g F .text 0000003e WatchdogUnlock +0000ea94 g F .text 00000184 USBDevEndpointConfigGet +00006400 g F .text 00000010 FlashUsecSet +0000ffa0 g F .text 0000003e WatchdogLockState +000083c0 g F .text 0000003a I2CMasterDataGet +0000529c g F .text 00000026 ComparatorRefSet +0000faec g F .text 00000066 USBHostPwrConfig +00009058 g F .text 00000064 MPURegionGet +00004000 g O .text 000000f4 _vectab +00007bc4 g F .text 00000010 HibernateIsActive +00007ee4 g F .text 00000042 I2CSlaveIntEnableEx +0000fdf4 g F .text 0000002a USBDevMode +00006868 g F .text 00000080 FlashUserGet +0000c568 g F .text 00000026 TimerIntStatus +00008f30 g F .text 00000008 IntPriorityMaskGet +00007504 g F .text 0000003a GPIOPinTypeTimer +00008a0c g F .text 00000030 I2SIntStatus +0000b85c g F .text 00000026 SysCtlPLLVerificationSet +000046d8 g F .text 0000005e ADCSequenceDisable +00007540 g F .text 0000003a GPIOPinTypeUART +00007324 g F .text 0000003a GPIOPinTypeComparator +000091f4 g F .text 00000082 PWMGenPeriodSet +0000d364 g F .text 0000002c uDMAChannelEnable +00005ff8 g F .text 0000002e EthernetSpaceAvail +000098c4 g F .text 0000005a PWMGenIntClear +000077a8 g F .text 00000012 HibernateDisable +0000bb94 g F .text 0000001c SysTickIntUnregister +00005504 g F .text 00000006 CPUbasepriSet +0000c16c g F .text 00000070 TimerPrescaleMatchSet +00007bd4 g F .text 00000040 I2CMasterEnable +0000739c g F .text 0000003a GPIOPinTypeGPIOOutput +0000b678 g F .text 0000008e SysCtlPWMClockSet +0000de98 g F .text 0000002c USBIntStatusEndpoint +0000fc8c g F .text 0000000a USBFIFOAddrGet +000065a4 g F .text 000000c4 FlashProtectGet +00007b1c g F .text 0000002c HibernateIntDisable +0000799c g F .text 0000005c HibernateRTCTrimSet +00004274 g F .text 00000024 IrqInterruptDisable +0000fee8 g F .text 0000003a WatchdogResetDisable +000090e8 g F .text 00000014 MPUIntUnregister +0000626c g F .text 00000042 EthernetIntDisable +0000b074 g F .text 0000000c SysCtlIntClear +0000c474 g F .text 000000a2 TimerIntUnregister +00005e40 g F .text 00000038 EthernetConfigGet +00008cc8 g F .text 000000a8 IntEnable +0000415c g F .text 000000ac BootComCheckActivationRequest +0000e72c g F .text 00000028 USBDevAddrSet +000062dc g F .text 0000003c EthernetIntClear +0000e11c g F .text 00000138 USBDevEndpointStatusClear +0000d140 g F .text 00000022 UARTBusy +0000ec18 g F .text 00000136 USBFIFOConfigSet +0000794c g F .text 00000044 HibernateRTCMatch1Set +000043d8 g F .text 0000000c TimeGet +0000e778 g F .text 000001c6 USBHostEndpointConfig +000100c4 g F .text 00000040 WatchdogIntUnregister +00007e64 g F .text 0000003e I2CMasterIntEnable +00006318 g F .text 0000004c EthernetPHYWrite +000076a8 g F .text 00000084 GPIOPinConfigure +00008570 g F .text 0000005a I2STxConfigSet +0000b884 g F .text 00000016 SysCtlClkVerificationClear +000054f8 g F .text 00000008 CPUcpsie +00006d58 g F .text 0000005e GPIODirModeSet +0000d1b0 g F .text 00000048 UARTIntUnregister +00004df0 g F .text 000000a6 ADCHardwareOversampleConfigure +0000afb8 g F .text 0000003e SysCtlPeripheralDeepSleepDisable +20000184 g .bss 00000000 _stack +0000fb54 g F .text 00000030 USBHostPwrFaultEnable +0000a0c0 g F .text 0000003a QEIVelocityGet +000049c8 g F .text 0000005c ADCSequenceUnderflow +00009adc g F .text 000000f0 PWMGenFaultTriggerSet +00006ebc g F .text 0000006a GPIOIntTypeGet +0000bb4c g F .text 00000012 SysTickEnable +00006668 g F .text 00000190 FlashProtectSet +0000d304 g F .text 00000022 UARTRxErrorClear +00008540 g F .text 00000030 I2STxDataPutNonBlocking +0000aec0 g F .text 0000003e SysCtlPeripheralDisable +0000f2dc g F .text 00000114 USBEndpointDataPut +0000da9c g F .text 00000038 USBHostReset +0000789c g F .text 00000010 HibernateLowBatGet +0000bbb0 g F .text 00000012 SysTickIntEnable +0000d290 g F .text 00000026 UARTDMAEnable +0000c824 g F .text 00000134 UARTConfigSetExpClk +0000f614 g F .text 000000ec USBHostRequestIN +000087e4 g F .text 0000002e I2SRxFIFOLimitGet +0000821c g F .text 0000003e I2CMasterBusy +000071b0 g F .text 0000002a GPIOPinIntStatus +00005828 g F .text 00000046 EPINonBlockingReadStop +0000ba14 g F .text 00000012 SysCtlUSBPLLDisable +0000e700 g F .text 0000002a USBDevDisconnect +0000b1d0 g F .text 000001c2 SysCtlClockSet +0000bd24 g F .text 00000104 TimerConfigure +0000be98 g F .text 0000006e TimerControlTrigger +0000adc0 g F .text 00000060 SysCtlPeripheralPresent +00006f28 g F .text 00000168 GPIOPadConfigSet +0000c9a0 g F .text 00000032 UARTEnableSIR +000090bc g F .text 0000002a MPUIntRegister +00004c14 g F .text 00000108 ADCSoftwareOversampleStepConfigure +0000e5a0 g F .text 00000132 USBDevEndpointStallClear +0000a230 g F .text 00000042 QEIIntStatus +0000c7bc g F .text 00000030 UARTEnable +00008650 g F .text 00000036 I2SRxEnable +0000c644 g F .text 00000064 UARTParityModeSet +0001004c g F .text 00000034 WatchdogValueGet +000096a4 g F .text 00000056 PWMGenIntRegister + + diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/bin/demoprog_ek_lm3s6965.srec b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/bin/demoprog_ek_lm3s6965.srec new file mode 100644 index 00000000..a0136dfc --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/bin/demoprog_ek_lm3s6965.srec @@ -0,0 +1,3181 @@ +S020000062696E2F64656D6F70726F675F656B5F6C6D3373363936352E7372656358 +S2140040008402002009420000F9430000F943000042 +S214004010F9430000F9430000F9430000F9430000AB +S214004020F9430000F9430000F9430000F94300009B +S214004030F9430000F9430000F9430000E54300009F +S214004040F9430000F9430000F9430000F94300007B +S214004050F9430000F9430000F9430000F94300006B +S214004060F9430000F9430000F9430000F94300005B +S214004070F9430000F9430000F9430000F94300004B +S214004080F9430000F9430000F9430000F94300003B +S214004090F9430000F9430000F9430000F94300002B +S2140040A0F9430000F9430000F9430000F94300001B +S2140040B0F9430000F9430000F9430000F94300000B +S2140040C0F9430000F9430000F9430000F9430000FB +S2140040D0F9430000F9430000F9430000F9430000EB +S2140040E0F9430000F9430000F9430000F9430000DB +S2140040F0EE11AA5510B504464FF44040C4F2000035 +S21400410008F0AEFFB0F1FF3F1ABF2070012000207C +S21400411010BD00BF08B54FF00100C1F2000006F068 +S214004120B1FE4FF00100C2F2000006F0ABFE4FF405 +S2140041308040C4F200004FF0030103F001FA07F0DC +S21400414029F901464FF44040C4F200004FF46142A2 +S2140041504FF0600308F066FB08BD00BF08B540F2EC +S2140041601C13C2F200031B78B3B940F22010C2F24F +S2140041700000FFF7BFFF012842D140F21C13C2F235 +S21400418000034FF001021A7040F21D13C2F2000342 +S2140041904FF000021A7008BD40F21D13C2F2000371 +S2140041A01878184BC018FFF7A5FF012828D140F251 +S2140041B01D13C2F200031A7802F10102D2B21A707D +S2140041C040F22013C2F200031B78934218D140F24B +S2140041D01C13C2F200034FF000021A7040F22013C4 +S2140041E0C2F200035B78FF2B0AD140F22013C2F222 +S2140041F000039B7823B900F0CDF84FF0F103984701 +S21400420008BD00BF2101002008B515498D4640F2C3 +S2140042100002C2F2000240F21C13C2F200039A42ED +S21400422011D240F28452C0F2010240F20003C2F200 +S214004230000340F21C10C2F2000052F8041B43F8C0 +S214004240041B8342F9D3074807494FF0000288420F +S214004250B8BF40F8042BFADB00F07CF808BD00007D +S214004260840200201C0100208401002008B504F010 +S21400427043FC08BD08B540F26413C2F200031B7885 +S2140042800BB904F03FFC40F26413C2F200031A7844 +S21400429002F101021A7008BD08B540F26413C2F2BA +S2140042A000031A7802F1FF32D2B21A700AB904F08B +S2140042B023FC08BD10B54FF02000C2F2000006F047 +S2140042C0E1FD4FF4A044C4F2020420464FF0010181 +S2140042D003F064F820464FF001014FF0000202F0B0 +S2140042E0D3FF10BD10B500F077F8044640F268130F +S2140042F0C2F200031B68C31AB3F5FA7F28D340F254 +S2140043006C13C2F200031B7873B940F26C13C2F24E +S21400431000034FF001021A704FF4A040C4F20200EE +S214004320114602F0B1FF0EE040F26C13C2F2000339 +S2140043304FF000021A704FF4A040C4F202004FF093 +S214004340010102F0A1FF40F26813C2F200031C60F4 +S21400435010BD00BF08B54FF46070C0F2C01006F084 +S21400436037FFFFF7A7FF00F021F8FFF77FFFFFF703 +S214004370D1FEFFF7B7FFFFF7F1FEFAE740F2701342 +S214004380C2F20003186040F27413C2F20003196010 +S214004390FEE700BF08B507F015FC07F0E1FB08BD17 +S2140043A040F27813C2F200031860704708B506F0B2 +S2140043B0F1FF44F6D353C1F26203A3FB00204FEA99 +S2140043C0901007F009FC07F0C1FB07F0F1FB4FF077 +S2140043D00000FFF7E5FF08BD40F27813C2F20003C5 +S2140043E01868704740F27813C2F200031A6802F1A8 +S2140043F001021A60704700BFFEE700BF70B50446B2 +S2140044000D4616464FF40043C4F203034FF4104221 +S214004410C4F20302821A18BF012298420CBF00237E +S21400442002F001033BB140F23420C0F201004FF02D +S2140044305D01FFF7A3FF032D07D940F23420C0F239 +S21400444001004FF05E01FFF799FF4FF40043C4F2FE +S21400445003039C420CBF1E3540352846314604F007 +S21400446057FB284604F030FC70BD00BF38B5044644 +S2140044700D464FF40043C4F203034FF41042C4F257 +S2140044800302821A18BF012298420CBF002302F0D2 +S21400449001033BB140F23420C0F201004FF08A0124 +S2140044A0FFF76CFF032D07D940F23420C0F201005D +S2140044B04FF08B01FFF762FF4FF40043C4F2030393 +S2140044C09C420CBF05F11E0405F14004204604F092 +S2140044D04FFC204604F060FB38BD00BF38B50446EC +S2140044E00D464FF40043C4F203034FF41042C4F2E7 +S2140044F00302821A18BF012298420CBF002302F062 +S21400450001033BB140F23420C0F201004FF0B0018D +S214004510FFF734FF032D07D940F23420C0F2010024 +S2140045204FF0B101FFF72AFFA3684FF0010202FA2D +S21400453005F523EA0505A56038BD00BF38B5044675 +S2140045400D464FF40043C4F203034FF41042C4F286 +S2140045500302821A18BF012298420CBF002302F001 +S21400456001033BB140F23420C0F201004FF0CD0110 +S214004570FFF704FF032D07D940F23420C0F20100F4 +S2140045804FF0CE01FFF7FAFE4FF0010303FA05F5F0 +S214004590E560A3681D43A56038BD00BF70B504463E +S2140045A00D4616464FF40043C4F203034FF4104280 +S2140045B0C4F20302821A18BF012298420CBF0023DD +S2140045C002F001033BB140F23420C0F201004FF08C +S2140045D0F401FFF7D3FE032D07D940F23420C0F2D2 +S2140045E001004FF0F501FFF7C9FE3EB1E3684FF05A +S2140045F0011000FA05F505EA030070BD63684FF088 +S214004600010000FA05F040F48030184010F4803FB6 +S2140046101FBF4FF4803303FA05F540F47020A8431B +S21400462070BD00BF38B504460D464FF40043C4F2D3 +S21400463003034FF41042C4F20302821A18BF012289 +S21400464098420CBF002302F001033BB140F2342035 +S214004650C0F2010040F23111FFF790FE032D07D99A +S21400466040F23420C0F201004FF49971FFF786FE45 +S2140046704FF0010303FA05F5E56038BD38B504468A +S2140046800D464FF40043C4F203034FF41042C4F245 +S2140046900302821A18BF012298420CBF002302F0C0 +S2140046A001033BB140F23420C0F2010040F24D114C +S2140046B0FFF764FE032D07D940F23420C0F2010054 +S2140046C04FF4A771FFF75AFE23684FF0010202FA73 +S2140046D005F51D43256038BD38B504460D464FF434 +S2140046E00043C4F203034FF41042C4F20302821ADA +S2140046F018BF012298420CBF002302F001033BB111 +S21400470040F23420C0F2010040F26911FFF736FE95 +S214004710032D07D940F23420C0F201004FF4B571E2 +S214004720FFF72CFE23684FF0010202FA05F523EA94 +S2140047300505256038BD00BFF8B504460E4615468B +S2140047401F464FF40043C4F203034FF41042C4F272 +S2140047500302821A18BF012298420CBF002302F0FF +S21400476001033BB140F23420C0F201004FF4D8718F +S214004770FFF704FE032E07D940F23420C0F20100F2 +S21400478040F2B111FFF7FAFDB5F10F0318BF012390 +S214004790092D94BF002303F001033BB140F23420FF +S2140047A0C0F201004FF4DE71FFF7E8FD032F07D9D2 +S2140047B040F23420C0F2010040F2BD11FFF7DEFDEA +S2140047C062694FEA86064FF00F0303FA06F36FEAB4 +S2140047D0030303EA020205F00F0505FA06F542EAAE +S2140047E005056561226A134007F0030707FA06F617 +S2140047F043EA06062662F8BDF8B504460D46174697 +S2140048001E464FF40043C4F203034FF41042C4F2B2 +S2140048100302821A18BF012298420CBF002302F03E +S21400482001033BB140F23420C0F201004FF40471A2 +S214004830FFF7A4FD032D07D940F23420C0F2010093 +S21400484040F21121FFF79AFD072F94BF00230123A2 +S214004850002D18BF43F00103F3B1032F94BF0023CC +S2140048600123012D0CBF1A4643F00102A2B1022D0E +S21400487018BF43F001037BB13B1E18BF0123032D75 +S21400488018BF43F001033BB140F23420C0F20100F0 +S21400489040F21521FFF772FD05F102054FEA4515B6 +S2140048A02B1928594FEA87074FF00F0202FA07F232 +S2140048B06FEA020202EA000006F00F0101FA07F1B1 +S2140048C040EA0101295158681040C6F3031101FA65 +S2140048D007F140EA0101596016F4702F11D05969AA +S2140048E001EA0202C6F3024606FA07F632435A61A6 +S2140048F01A694FF0010101FA07F742EA07071F613C +S214004900F8BD1A694FF0010101FA07F722EA070716 +S2140049101F61F8BD38B504460D464FF40043C4F297 +S21400492003034FF41042C4F20302821A18BF012296 +S21400493098420CBF002302F001033BB140F2342042 +S214004940C0F201004FF41971FFF718FD032D07D9C7 +S21400495040F23420C0F2010040F26521FFF70EFD60 +S21400496023694FF0010202FA05F505EA030038BD97 +S21400497038B504460D464FF40043C4F203034FF423 +S2140049801042C4F20302821A18BF012298420CBFDA +S214004990002302F001033BB140F23420C0F20100D4 +S2140049A040F28121FFF7EAFC032D07D940F23420BC +S2140049B0C0F2010040F28221FFF7E0FC4FF0010355 +S2140049C003FA05F5256138BD38B504460D464FF4A3 +S2140049D00043C4F203034FF41042C4F20302821AE7 +S2140049E018BF012298420CBF002302F001033BB11E +S2140049F040F23420C0F2010040F29E21FFF7BEFCD8 +S214004A00032D07D940F23420C0F2010040F29F2166 +S214004A10FFF7B4FCA3694FF0010202FA05F505EAB8 +S214004A20030038BD38B504460D464FF40043C4F2C3 +S214004A3003034FF41042C4F20302821A18BF012285 +S214004A4098420CBF002302F001033BB140F2342031 +S214004A50C0F2010040F2BB21FFF790FC032D07D9FE +S214004A6040F23420C0F201004FF42F71FFF786FCAD +S214004A704FF0010303FA05F5A56138BD70B505468C +S214004A800E4614464FF40043C4F203034FF410429C +S214004A90C4F20302821A18BF012298420CBF0023F8 +S214004AA002F001033BB140F23420C0F2010040F2B4 +S214004AB0DF21FFF763FC032E07D940F23420C0F253 +S214004AC001004FF43871FFF759FC06F102064FEA71 +S214004AD04616751905F10C02EB6813F4807F0DD1AC +S214004AE04FF00000AB6844F8043B00F10100136887 +S214004AF013F4807F04D10828F4D170BD4FF0000075 +S214004B0070BD00BF38B504460D464FF40043C4F2EE +S214004B1003034FF41042C4F20302821A18BF0122A4 +S214004B2098420CBF002302F001033BB140F2342050 +S214004B30C0F2010040F21731FFF720FC05F00F032A +S214004B40032B07D940F23420C0F201004FF446711F +S214004B50FFF714FC05F00F034FF0010202FA03F30F +S214004B604FEA154543EA0545A56238BD38B50D46FA +S214004B7014464FF40043C4F203034FF41042C4F249 +S214004B800302821A18BF012298420CBF002202F0CC +S214004B9001023AB140F23420C0F2010040F2423144 +S214004BA0FFF7ECFB022D07D940F23420C0F20100DB +S214004BB040F24331FFF7E2FB231F18BF0123022C0C +S214004BC00CBF002303F001030BB1082C09D1082CFD +S214004BD014BF00230123002D0CBF002303F00103A4 +S214004BE03BB140F23420C0F2010040F24531FFF7FD +S214004BF0C5FB640808BF002305D04FF0000303F18F +S214004C0001036408FBD140F27C12C2F20002535545 +S214004C1038BD00BF2DE9F04105460C4616461F4636 +S214004C204FF40043C4F203034FF41042C4F20302ED +S214004C30821A18BF012298420CBF002302F001031B +S214004C403BB140F23420C0F2010040F26E31FFF773 +S214004C5095FB022C07D940F23420C0F2010040F246 +S214004C606F31FFF78BFB54B940F27C13C2F200039E +S214004C701B784FF0080242FA03F3B34212D840F210 +S214004C807C13C2F200031B5D4FF0040242FA03F3EA +S214004C909E4207D340F23420C0F2010040F2723147 +S214004CA0FFF76CFB04F102034FEA43135D1940F271 +S214004CB07C13C2F200031A5D4FF0010393402BD021 +S214004CC04FF0040101FA02F206FB02F6C7F30314E2 +S214004CD04FF00F0007404FF0060C296800FA06F266 +S214004CE06FEA020202EA010107FA06F841EA080141 +S214004CF0296069680A4004FA06F10A436A60012BD3 +S214004D000AD06A680CFA06F122EA01026A60013BE0 +S214004D1002D006F10406E0E7BDE8F0812DE9F04197 +S214004D2006460D4617461C464FF40043C4F20303DE +S214004D304FF41042C4F20302821A18BF01229842AE +S214004D400CBF002302F001033BB140F23420C0F256 +S214004D5001004FF46F71FFF711FB022D07D940F2E7 +S214004D603420C0F2010040F2BD31FFF707FB55B911 +S214004D7040F27C13C2F200031B784FF0080242FA9E +S214004D8003F3A34212D840F27C13C2F200035B5D29 +S214004D904FF0040242FA03F39C4207D340F2342059 +S214004DA0C0F201004FF47071FFF7E8FA05F1020354 +S214004DB04FEA43139E19CCB140F27C13C2F20003B3 +S214004DC05D5D4FF0010000FA05F04FF0000C8046E4 +S214004DD0624628B143466246B1685218013BFBD191 +S214004DE022FA05F247F8042B013CF1D1BDE8F08128 +S214004DF038B505460C464FF40043C4F203034FF49F +S214004E001042C4F20302821A18BF012298420CBF55 +S214004E10002302F001033BB140F23420C0F201004F +S214004E2040F20441FFF7AAFAA31E18BF0123002C84 +S214004E300CBF002303F00103EBB1B4F1080318BF65 +S214004E400123042C0CBF002303F001039BB1B4F133 +S214004E50200318BF0123102C0CBF002303F001030E +S214004E604BB1402C12D040F23420C0F2010040F288 +S214004E700741FFF783FA640808BF002308D103E060 +S214004E8003F101036408FBD12B6338BD4FF0200407 +S214004E904FF00003F4E700BF70B504460D46164613 +S214004EA04FF40043C4F203034FF41042C4F203026B +S214004EB0821A18BF012298420CBF002302F0010399 +S214004EC03BB140F23420C0F2010040F26441FFF7EB +S214004ED055FA072D07D940F23420C0F2010040F2FF +S214004EE06541FFF74BFA04F5606444F8256070BD31 +S214004EF0F8B505460F4616461C464FF40043C4F266 +S214004F0003034FF41042C4F20302821A18BF0122B0 +S214004F1098420CBF002302F001033BB140F234205C +S214004F20C0F201004FF49161FFF728FA072F07D966 +S214004F3040F23420C0F2010040F28941FFF71EFA29 +S214004F40A64294BF00230123B6F5806F28BF43F026 +S214004F5001033BB140F23420C0F2010040F28A4126 +S214004F60FFF70CFAB4F5806F07D340F23420C0F296 +S214004F70010040F28B41FFF701FA05F5646546EA49 +S214004F80044445F82740F8BDF8B504460D461646D5 +S214004F901F464FF40043C4F203034FF41042C4F21A +S214004FA00302821A18BF012298420CBF002302F0A7 +S214004FB001033BB140F23420C0F2010040F2AC41A4 +S214004FC0FFF7DCF9072D07D940F23420C0F20100C4 +S214004FD040F2AD41FFF7D2F905F110034FF00102A0 +S214004FE002FA03F30EB94FF0000327B14FF00102A7 +S214004FF002FA05F52B43C4F8003DF8BD38B5044663 +S2140050000D464FF40043C4F203034FF41042C4F2BB +S2140050100302821A18BF012298420CBF002302F036 +S21400502001033BB140F23420C0F2010040F2D1410E +S214005030FFF7A4F9032D07D940F23420C0F201008F +S21400504040F2D241FFF79AF9A3684FF4803202FA91 +S21400505005F523EA0505A56038BD00BF38B504464A +S2140050600D464FF40043C4F203034FF41042C4F25B +S2140050700302821A18BF012298420CBF002302F0D6 +S21400508001033BB140F23420C0F2010040F2EC4193 +S214005090FFF774F9032D07D940F23420C0F201005F +S2140050A040F2ED41FFF76AF9A3684FF4803202FA46 +S2140050B005F51D43A56038BD10B504464FF4004302 +S2140050C0C4F203034FF41042C4F20302821A18BF5C +S2140050D0012298420CBF002302F001033BB140F2CC +S2140050E03420C0F2010040F20751FFF747F9606B29 +S2140050F010BD00BF38B504460D464FF40043C4F259 +S21400510003034FF41042C4F20302821A18BF0122AE +S21400511098420CBF002302F001033BB140F234205A +S214005120C0F2010040F22151FFF728F9656338BD4F +S21400513038B504460D464FF40043C4F203034FF45B +S2140051401042C4F20302821A18BF012298420CBF12 +S214005150002302F001033BB140F23420C0F201000C +S21400516040F24351FFF70AF9012D07D940F23420E7 +S214005170C0F2010040F24451FFF700F9A36B23F0A0 +S214005180010343EA0505A56338BD00BF10B5044614 +S2140051904FF40043C4F203034FF41042C4F2030278 +S2140051A0821A18BF012298420CBF002302F00103A6 +S2140051B03BB140F23420C0F2010040F26351FFF7E9 +S2140051C0DDF8A06B00F0010010BD00BF38B5044646 +S2140051D00D464FF40043C4F203034FF41042C4F2EA +S2140051E00302821A18BF012298420CBF002302F065 +S2140051F001033BB140F23420C0F2010040F28B5173 +S214005200FFF7BCF80F2D07D940F23420C0F201009A +S21400521040F29351FFF7B2F8656238BD10B5044608 +S2140052204FF40043C4F203034FF41042C4F20302E7 +S214005230821A18BF012298420CBF002302F0010315 +S2140052403BB140F23420C0F2010040F2B151FFF70A +S21400525095F8606A10BD00BF70B505460C46164648 +S2140052604FF44043C4F20303984207D040F248206C +S214005270C0F201004FF06801FFF780F8022C07D952 +S21400528040F24820C0F201004FF06901FFF776F8BF +S21400529005F124054FEA44142E5170BD38B5044676 +S2140052A00D464FF44043C4F20303984207D040F241 +S2140052B04820C0F201004FF0A201FFF75FF8256119 +S2140052C038BD00BF38B505460C464FF44043C4F21F +S2140052D00303984207D040F24820C0F201004FF086 +S2140052E0BD01FFF74BF8022C07D940F24820C0F268 +S2140052F001004FF0BE01FFF741F805F120054FEA27 +S21400530044142859C0F3400038BD00BFF8B506461F +S2140053100C4617464FF44043C4F20303984207D0A6 +S21400532040F24820C0F201004FF0E901FFF726F8EE +S214005330022C07D940F24820C0F201004FF0EA01E3 +S214005340FFF71CF804F129052846394603F0E0FB70 +S214005350284603F0B9FCB3684FF0010202FA04F4E1 +S2140053601C43B460F8BD00BF38B505460C464FF484 +S2140053704043C4F20303984207D040F24820C0F2EC +S214005380010040F21311FEF7F9FF022C07D940F294 +S2140053904820C0F201004FF48A71FEF7EFFFAA68BA +S2140053A04FF0010303FA04F322EA0303AB6004F1AF +S2140053B02904204603F0DCFC204603F0EDFB38BD54 +S2140053C038B504460D464FF44043C4F203039842F2 +S2140053D007D040F24820C0F201004FF49D71FEF75E +S2140053E0CDFF022D07D940F24820C0F2010040F25E +S2140053F03B11FEF7C3FFA3684FF0010202FA05F562 +S2140054001D43A56038BD00BF38B504460D464FF4B1 +S2140054104043C4F20303984207D040F24820C0F24B +S214005420010040F25711FEF7A9FF022D07D940F2FE +S2140054304820C0F201004FF4AC71FEF79FFFA3684E +S2140054404FF0010202FA05F523EA0505A56038BD0E +S21400545070B505460C4616464FF44043C4F20303A7 +S214005460984207D040F24820C0F2010040F277117F +S214005470FEF784FF022C07D940F24820C0F2010054 +S2140054804FF4BC71FEF77AFF2EB1286820FA04F4B8 +S21400549004F0010070BD686820FA04F404F001000E +S2140054A070BD00BF38B504460D464FF44043C4F205 +S2140054B00303984207D040F24820C0F201004FF4A0 +S2140054C0D371FEF75BFF022D07D940F24820C0F2E9 +S2140054D0010040F2A711FEF751FF4FF0010303FA57 +S2140054E005F5256038BD00BFEFF3108072B6704733 +S2140054F0EFF31080704700BFEFF3108062B670477E +S21400550030BF704780F31188704700BFEFF31180FB +S214005510704700BF38B505460C464FF00003C4F28E +S2140055200D03984207D040F26020C0F201004FF011 +S2140055304401FEF723FFA4F11002231E18BF012327 +S214005540032A94BF002303F001033BB140F260201E +S214005550C0F201004FF04901FEF710FF2C6038BD85 +S21400556038B504460D464FF00003C4F20D039842CA +S21400557007D040F26020C0F201004FF07201FEF743 +S214005580FDFE656038BD00BF70B504460E46154684 +S2140055904FF00003C4F20D03984207D040F260209B +S2140055A0C0F201004FF0A601FEF7E8FEB5F5006F69 +S2140055B007D340F26020C0F201004FF0A701FEF7CB +S2140055C0DDFE26F0FE6626F4702646EA05452561D1 +S2140055D070BD00BF70B505460C4616464FF000037A +S2140055E0C4F20D03984207D040F26020C0F20100DA +S2140055F04FF0F401FEF7C2FEFF2E07D940F26020FE +S214005600C0F201004FF0F501FEF7B8FE04F4807119 +S214005610002914BF4FF00041002104F40062002A64 +S21400562014BF4FF08062002204F4C06341EAC33323 +S21400563013436B6124F47F4444EA06262E6170BD52 +S21400564070B505460C4616464FF00003C4F20D032F +S214005650984207D040F26020C0F2010040F24D119F +S214005660FEF78CFEFF2E07D940F26020C0F2010044 +S2140056704FF4A771FEF782FE04F48071002914BF70 +S2140056804FF00041002104F40062002A14BF4FF0DE +S2140056908062002204F4C06341EAC33313436B61A3 +S2140056A024F47F4444EA06262E6170BDF8B504460D +S2140056B00D4616461F464FF00003C4F20D039842EF +S2140056C007D040F26020C0F201004FF4D371FEF71D +S2140056D055FE0F2E07D940F26020C0F2010040F2BE +S2140056E0A711FEF74BFEFF2F07D940F26020C0F24D +S2140056F001004FF4D471FEF741FE05F48073002BD1 +S21400570014BF4FF000430023636125F0707545EA2F +S214005710865626F47F4646EA07272761F8BD00BF6F +S21400572038B504460D464FF00003C4F20D03984208 +S21400573007D040F26020C0F2010040F2E511FEF70B +S2140057401DFEFF2D07D940F26020C0F201004FF485 +S214005750F371FEF713FEE56138BD00BFF8B50446E9 +S2140057600D4616461F464FF00003C4F20D0398423E +S21400577007D040F26020C0F2010040F21521FEF78B +S214005780FDFD012D07D940F26020C0F2010040F275 +S2140057901621FEF7F3FD032E07D940F26020C0F273 +S2140057A0010040F21721FEF7E9FDB7F1005F07D3CD +S2140057B040F26020C0F201004FF40671FEF7DEFDF5 +S2140057C004EB051426626762F8BD00BF70B5054697 +S2140057D00C4616464FF00003C4F20D03984207D05D +S2140057E040F26020C0F2010040F24921FEF7C6FDFB +S2140057F0012C07D940F26020C0F2010040F24A2195 +S214005800FEF7BCFDB6F5805F07D340F26020C0F21D +S214005810010040F24B21FEF7B1FD05F128054FEAE5 +S21400582004142E5170BD00BF38B505460C464FF027 +S2140058300003C4F20D03984207D040F26020C0F285 +S214005840010040F26D21FEF799FD012C07D940F2C8 +S2140058506020C0F2010040F26E21FEF78FFD05F1D8 +S21400586028054FEA04144FF000032B5138BD00BF43 +S21400587038B505460C464FF00003C4F20D039842B7 +S21400588007D040F26020C0F201004FF42471FEF70A +S21400589075FD012C07D940F26020C0F2010040F2ED +S2140058A09121FEF76BFD05F128054FEA04142859EF +S2140058B038BD00BF10B504464FF00003C4F20D0318 +S2140058C0984207D040F26020C0F2010040F2B221B8 +S2140058D0FEF754FDE06E10BD70B505460E46144644 +S2140058E04FF00003C4F20D03984207D040F2602048 +S2140058F0C0F2010040F2D521FEF740FDB6F5805F0C +S21400590007D340F26020C0F2010040F2D621FEF735 +S21400591035FD3CB940F26020C0F2010040F2D721CC +S214005920FEF72CFD05F16C02EB6E63B176B14FF01D +S21400593000002B6F44F8043B00F1010013683BB1F4 +S2140059408642F6D170BD4FF0000070BD4FF00000EB +S21400595070BD00BF70B505460E4614464FF00003F6 +S214005960C4F20D03984207D040F26020C0F2010056 +S2140059704FF44371FEF702FDB6F5805F07D340F2A1 +S2140059806020C0F2010040F20D31FEF7F7FC3CB992 +S21400599040F26020C0F2010040F20E31FEF7EEFC4D +S2140059A005F16C02EB6E63B176B14FF000002B6F21 +S2140059B024F8023B00F1010013683BB18642F6D1A1 +S2140059C070BD4FF0000070BD4FF0000070BD00BF0E +S2140059D070B504460D4616464FF00003C4F20D039C +S2140059E0984207D040F26020C0F2010040F24331F6 +S2140059F0FEF7C4FCB5F5805F07D340F26020C0F226 +S214005A0001004FF45171FEF7B9FC3EB940F2602038 +S214005A10C0F2010040F24531FEF7B0FC04F16C0222 +S214005A20E36E5BB16DB14FF00000236F335400F1AD +S214005A30010013683BB18542F7D170BD4FF00000FE +S214005A4070BD4FF0000070BD38B505460C464FF0EF +S214005A500003C4F20D03984207D040F26020C0F263 +S214005A60010040F27F31FEF789FC4FF07703C0F269 +S214005A70030304EA0303A34207D040F26020C0F207 +S214005A8001004FF46071FEF779FCC5F8004238BD9E +S214005A9010B504464FF00003C4F20D03984207D039 +S214005AA040F26020C0F2010040F29B31FEF766FC37 +S214005AB0D4F8040210BD00BF38B504460D464FF0BA +S214005AC00003C4F20D03984207D040F26020C0F2F3 +S214005AD0010040F2BB31FEF751FC0F2D07D940F212 +S214005AE06020C0F201004FF46F71FEF747FCD4F857 +S214005AF0103243EA0505C4F8105238BD38B50446DE +S214005B000D464FF00003C4F20D03984207D040F252 +S214005B106020C0F2010040F2D931FEF72FFC0F2DB5 +S214005B2007D940F26020C0F2010040F2DA31FEF7F9 +S214005B3025FCD4F8103223EA0505C4F8105238BD07 +S214005B4038B504460D464FF00003C4F20D039842E4 +S214005B5007D040F26020C0F201004FF47E71FEF7DD +S214005B600DFC15B1D4F8180238BDD4F8140238BDAF +S214005B7010B504464FF00003C4F20D03984207D058 +S214005B8040F26020C0F2010040F22641FEF7F6FB2C +S214005B90D4F81C0210BD00BF38B504460D464FF0C1 +S214005BA00003C4F20D03984207D040F26020C0F212 +S214005BB0010040F24241FEF7E1FB0F2D07D940F20B +S214005BC06020C0F2010040F24341FEF7D7FBC4F864 +S214005BD01C5238BD10B50C464FF00003C4F20D033E +S214005BE0984207D040F26020C0F2010040F26341C4 +S214005BF0FEF7C4FB3CB940F26020C0F2010040F260 +S214005C006441FEF7BBFB4FF04500214602F080FFE3 +S214005C104FF0450003F058F810BD00BF08B54FF030 +S214005C200003C4F20D03984207D040F26020C0F291 +S214005C30010040F28641FEF7A1FB4FF0450003F05D +S214005C4097F84FF0450002F0A7FF08BD2DE9F001D8 +S214005C50034600F1100500691FFA80F84FEA104469 +S214005C600C704FEA10604870A8F106009042B4BF6E +S214005C7084469446ACF10407012FD8BF022407DD02 +S214005C804FF002042E680E5104F10404BC42F9DD04 +S214005C90A44527DD1E69ACF10303A3420DD1CE5403 +S214005CA0ACF102034FEA1624CC5403F101044FEA88 +S214005CB016460E5503F1030414E0ACF10203A342AA +S214005CC008D1CE540CF1FF344FEA16260E550CF1CF +S214005CD0020407E00CF1FF3CA44504BF01F80C6089 +S214005CE00CF10404A8F10203A34204DD296804F1C0 +S214005CF00404A342FADC9042C8BF4042BDE8F0016B +S214005D00704700BFF0B4034640F2FE708242C8BF40 +S214005D1052423EDCA2F10E000C7840EA04404C7879 +S214005D2040EA046003F110071861A2F10406012E90 +S214005D30D8BF022407DD4FF002040D593D6004F180 +S214005D400404B442F9DD944220D0A2F10300A0423C +S214005D500BD10C5CA2F102000D5C44EA0524081885 +S214005D60417844EA0141196110E0A2F10200A04224 +S214005D7006D10C5C0918497844EA0121196105E04E +S214005D8002F1FF30A04204BF095C19614FF0010127 +S214005D9099631046F0BC704738B504460D464FF47C +S214005DA00043C4F20403984207D040F27420C0F2C5 +S214005DB001004FF04E01FEF7E1FA4CF66B23C6F6F3 +S214005DC05F33A3FB0523C3F34753636238BD00BFAD +S214005DD038B504460D464FF40043C4F20403984217 +S214005DE007D040F27420C0F201004FF09501FEF794 +S214005DF0C5FA4FF2E913CFF6FE7305EA03033BB18B +S214005E0040F27420C0F201004FF09901FEF7B6FA96 +S214005E10E36823F0160305F0FF021343E360A3686C +S214005E2023F00E03C5F307221343A360E36B23F0AE +S214005E300103C5F3074543EA0505E56338BD00BF22 +S214005E4010B504464FF40043C4F20403984207D04A +S214005E5040F27420C0F201004FF0CB01FEF78EFA3C +S214005E60E26BA068E36823F0010343EA024320F0F4 +S214005E70010043EA002010BD30B583B005460C464D +S214005E804FF40043C4F20403984207D040F2742053 +S214005E90C0F201004FF48171FEF770FA3CB940F28F +S214005EA07420C0F2010040F20311FEF767FA23786F +S214005EB08DF8043063788DF80530A3788DF80630B9 +S214005EC0E3788DF80730019B6B614FF00003019378 +S214005ED023798DF8043063798DF80530019BAB612A +S214005EE003B030BD30B583B005460C464FF40043D2 +S214005EF0C4F20403984207D040F27420C0F20100B6 +S214005F0040F22F11FEF73AFA3CB940F27420C0F284 +S214005F1001004FF49871FEF731FA6B690193237014 +S214005F20C3F3072363709DF80630A3709DF807300F +S214005F30E370AB69019323719DF80530637103B07C +S214005F4030BD00BF10B504464FF40043C4F204034E +S214005F50984207D040F27420C0F201004FF4AC71B2 +S214005F60FEF70CFAA36843F01003A360A36843F09F +S214005F700103A360E36843F00103E360A36843F012 +S214005F801003A36010BD00BF10B504464FF40043D5 +S214005F90C4F20403984207D040F27420C0F2010015 +S214005FA04FF4C171FEF7EAF9A36843F01003A3604B +S214005FB0E36823F00103E360A36823F00103A36012 +S214005FC0A36843F01003A36010BD00BF10B50446DD +S214005FD04FF40043C4F20403984207D040F2742002 +S214005FE0C0F2010040F2B111FEF7C8F9606B10F084 +S214005FF03F0018BF012010BD10B504464FF4004303 +S214006000C4F20403984207D040F27420C0F20100A4 +S2140060104FF4E871FEF7B2F9A36B13F0010F14BF4B +S2140060200020012010BD00BF70B504460D46164680 +S2140060304FF40043C4F20403984207D040F27420A1 +S214006040C0F2010040F27F21FEF798F93DB940F218 +S2140060507420C0F201004FF42071FEF78FF9002E75 +S21400606007DC40F27420C0F2010040F28121FEF706 +S21400607085F9636B13F03F0F05D02046294632465C +S214006080FFF7E4FD70BD4FF0000070BD70B504462C +S2140060900D4616464FF40043C4F20403984207D058 +S2140060A040F27420C0F201004FF42C71FEF766F93E +S2140060B03DB940F27420C0F2010040F2B121FEF773 +S2140060C05DF9002E07DC40F27420C0F2010040F2B9 +S2140060D0B221FEF753F9636B13F03F0FFBD0204657 +S2140060E029463246FFF7B2FD70BD00BF70B50446C4 +S2140060F00D4616464FF40043C4F20403984207D0F8 +S21400610040F27420C0F2010040F25D31FEF736F92D +S2140061103DB940F27420C0F2010040F25E31FEF755 +S2140061202DF9002E07DC40F27420C0F2010040F288 +S2140061305F31FEF723F9A36B13F0010F05D120465C +S21400614029463246FFF7DEFD70BD4FF0000070BDF9 +S21400615070B504460D4616464FF40043C4F20403D9 +S214006160984207D040F27420C0F2010040F28E310F +S214006170FEF704F93DB940F27420C0F2010040F287 +S2140061808F31FEF7FBF8002E07DC40F27420C0F2D9 +S21400619001004FF46471FEF7F1F8A36B13F0010FE2 +S2140061A0FBD1204629463246FFF7ACFD70BD00BF46 +S2140061B010B50C464FF40043C4F20403984207D0CF +S2140061C040F27420C0F201004FF46E71FEF7D6F86C +S2140061D03CB940F27420C0F2010040F2B931FEF73B +S2140061E0CDF84FF03A00214602F092FC4FF03A000C +S2140061F002F06AFD10BD00BF08B54FF40043C4F2BC +S2140062000403984207D040F27420C0F201004FF415 +S2140062107771FEF7B3F84FF03A0002F0A9FD4FF0A1 +S2140062203A0002F0B9FC08BD38B504460D464FF4F6 +S2140062300043C4F20403984207D040F27420C0F230 +S214006240010040F21341FEF799F835F07F0307D0BE +S21400625040F27420C0F2010040F21641FEF78EF8BC +S214006260636843EA0505656038BD00BF38B5044677 +S2140062700D464FF40043C4F20403984207D040F2A0 +S2140062807420C0F2010040F23541FEF777F835F091 +S2140062907F0307D040F27420C0F201004FF48761FC +S2140062A0FEF76CF8636823EA0505656038BD00BF35 +S2140062B038B504460D464FF40043C4F20403984232 +S2140062C007D040F27420C0F201004FF48B61FEF755 +S2140062D055F820680DB16368184038BD38B50446D7 +S2140062E00D464FF40043C4F20403984207D040F230 +S2140062F07420C0F2010040F28D41FEF73FF835F001 +S2140063007F0307D040F27420C0F201004FF4926180 +S214006310FEF734F8256038BD70B504460E461546BF +S2140063204FF40043C4F20403984207D040F27420AE +S214006330C0F2010040F2AD41FEF720F804F1200360 +S214006340226A12F0010FF9D1ADB2E5624FEAC60635 +S21400635006F0FF0646F003061E601A6812F0010FEC +S214006360FBD170BD38B504460D464FF40043C4F269 +S2140063700403984207D040F27420C0F2010040F2B5 +S214006380DC41FDF7FBFF04F12003226A12F0010F47 +S214006390F9D14FEAC50505F0FF0545F001051D607A +S2140063A01A6812F0010FFBD1206B80B238BD00BF17 +S2140063B010B504464FF00001FFF7D4FF20F4C0529A +S2140063C020464FF0000142F40062FFF7A5FF10BD23 +S2140063D010B504464FF00001FFF7C4FF20F4C0528A +S2140063E020464FF0000142F48052FFF795FF10BDA3 +S2140063F04EF24013C4F20F03186800F10100704714 +S21400640000F1FF304EF24013C4F20F0318607047DD +S21400641010B504464FEA80534FEA93533BB140F21F +S214006420A020C0F201004FF08401FDF7A7FF4DF257 +S2140064301403C4F20F034FF001021A604FF45043E6 +S214006440C4F20F031C604DF20803C4F20F034FF0B2 +S2140064500202CAF242421A604DF20802C4F20F0269 +S214006460136813F0020FFBD14DF20C03C4F20F03B6 +S214006470186800F00100002814BF4FF0FF3000201D +S21400648010BD00BF2DE9F04106460C46154611F03A +S214006490030F07D040F2A020C0F201004FF0C80161 +S2140064A0FDF76CFF15F0030F07D040F2A020C0F2F6 +S2140064B001004FF0C901FDF761FF4DF21403C4F26D +S2140064C00F034FF001021A604EF2A013C4F20F033E +S2140064D01B6813F0010F33D1002D37D154E04FF471 +S2140064E05048C4F20F084DF23000C4F20F004FF4CB +S2140064F05141C4F20F014DF22007C4F20F074FF0CE +S214006500010CCAF2424C24F07F03C8F8003006E0C3 +S21400651056F8042B5A5004F10404A5F1040514F0AF +S2140065207C0301D102681AB9002DF1D12A4600E099 +S2140065302A46C7F800C03B6813F0010FFBD102E003 +S214006540002DCCD120E0002ADDD11DE04FF45047CD +S214006550C4F20F074DF20400C4F20F004DF2080219 +S214006560C4F20F024FF00101CAF242413C6056F8F5 +S214006570043B03601160136813F0010FFBD1043D68 +S21400658002D004F10404F1E74DF20C03C4F20F0349 +S214006590186800F00100002814BF4FF0FF300020FC +S2140065A0BDE8F08110B504464FEA40534FEA535316 +S2140065B03BB140F2A020C0F2010040F23F11FDF7CF +S2140065C0DDFEC4F30142A4B240F2B823C0F20103D8 +S2140065D053F82230196840F29023C0F2010353F8B2 +S2140065E022301A684FF46043C4F20F031B6813F09E +S2140065F0E04F0DD04FF46043C4F20F0318684FF01D +S2140066000003C7F2FF0300EA0303B3F1805F15D16E +S2140066104FF46043C4F20F03186880B240F20123BF +S214006620984209D04FF46043C4F20F03186880B252 +S21400663040F20223984201D141F040414FEAD4246F +S21400664021FA04F000F0010022FA04F404F0010438 +S21400665044EA4000012804D9022814BF0020012083 +S21400666010BD4FF0020010BDF8B504460D464FEAC7 +S21400667040534FEA53533BB140F2A020C0F2010012 +S21400668040F2A311FDF77AFE022D07D940F2A020B2 +S214006690C0F2010040F2A511FDF770FEC4F30141FF +S2140066A0C4F3C42440F2B823C0F2010353F8210017 +S2140066B0026840F29023C0F2010353F821100E68DE +S2140066C04FF46043C4F20F031B6813F0E04F0DD085 +S2140066D04FF46043C4F20F031F684FF00003C7F285 +S2140066E0FF0307EA0303B3F1805F1ED14FF4604354 +S2140066F0C4F20F031F68BFB240F201239F4209D0C5 +S2140067004FF46043C4F20F031F68BFB240F2022387 +S2140067109F420AD1022D14BF002301231D2C94BFD3 +S214006720002303F00103002B5DD1012D0BD0022DB9 +S21400673015D14FF0010303FA04F46FEA0404224073 +S21400674004EA06061AE022FA04F313F0010F4DD00D +S2140067504FF0010303FA04F426EA04060EE022FAD8 +S21400676004F212F0010F44D026FA04F000F0010003 +S21400677000280CBF4FF0FF300020F8BD4FF46043F8 +S214006780C4F20F031B6813F0E04F0DD04FF46043C4 +S214006790C4F20F031C684FF00003C7F2FF0304EABD +S2140067A00303B3F1805F19D14FF46043C4F20F03C3 +S2140067B01C68A4B240F201239C4209D04FF4604307 +S2140067C0C4F20F031C68A4B240F202239C4205D117 +S2140067D022F04042036803F040431A4302600E6012 +S2140067E04FF00000F8BD4FF0FF30F8BD4FF0FF301F +S2140067F0F8BD4FF0FF30F8BD30B44FF46043C4F23C +S2140068000F031B6813F0E04F08BF02200FD04FF4B1 +S2140068106043C4F20F031B684FF00000C7F2FF008E +S21400682003EA0000B0F1805F14BF082002204FF09A +S21400683000014FF45045C4F20F054DF20802C4F2B1 +S2140068400F024FF00804CAF242442960146013682D +S21400685013F0080FFBD101F101018842F5DC4FF07F +S214006860000030BC704700BF38B50C46054638B946 +S21400687040F2A020C0F2010040F26B21FDF77EFD41 +S2140068803CB940F2A020C0F201004FF41B71FDF7A6 +S21400689075FD4FF46043C4F20F031B6813F0E04F1E +S2140068A01CD04FF46043C4F20F031A684FF0000385 +S2140068B0C7F2FF0302EA0303B3F1805F11D04EF282 +S2140068C0E013C4F20F031B682B604EF2E413C4F20D +S2140068D00F031B6823604FF0000038BD4FF0FF30F9 +S2140068E038BD4FF0FF3038BD4FF46043C4F20F039D +S2140068F01B6813F0E04F1AD04FF46043C4F20F0346 +S2140069001A684FF00003C7F2FF0302EA0303B3F16D +S214006910805F0FD04EF2E013C4F20F0318604EF201 +S214006920E413C4F20F0319604FF0000070474FF0F5 +S214006930FF3070474FF0FF30704700BF4FF46043A2 +S214006940C4F20F031B6813F0E04F42D04FF46043CD +S214006950C4F20F031A684FF00003C7F2FF0302EAFF +S2140069600303B3F1805F37D04FF45043C4F20F03F4 +S2140069704FF000421A604DF20803C4F20F034FF0C6 +S2140069800802CAF242421A604DF20802C4F20F022E +S214006990136813F0080FFBD14FF45043C4F20F03F3 +S2140069A04FF00102C8F200021A604DF20803C4F26A +S2140069B00F034FF00802CAF242421A604DF2080274 +S2140069C0C4F20F02136813F0080FFBD14FF000005B +S2140069D070474FF0FF3070474FF0FF30704700BFF2 +S2140069E008B501464FF02D0002F092F84FF02D004A +S2140069F002F06AF908BD00BF08B54FF02D0002F09E +S214006A00B7F94FF02D0002F0C7F808BD4DF210039D +S214006A10C4F20F031A6840EA02021A60704700BF09 +S214006A204DF21003C4F20F031A6822EA00021A603D +S214006A30704700BF28B14DF21403C4F20F03186864 +S214006A4070474DF20C03C4F20F031868704700BF7E +S214006A504DF21403C4F20F03186070474FF48043DE +S214006A60C4F200034FF40042C4F20502904214BF81 +S214006A7000220122984214BF134642F00103002B65 +S214006A8040F098804FF4A043C4F200034FF4104245 +S214006A90C4F20502904214BF00220122984214BF9D +S214006AA0134642F00103002B40F087804FF4C043AA +S214006AB0C4F200034FF42042C4F20502904214BF11 +S214006AC000220122984214BF134642F00103002B15 +S214006AD076D14FF4E043C4F200034FF43042C4F2E0 +S214006AE00502904214BF00220122984214BF1346AA +S214006AF042F00103002B66D14FF48043C4F2020338 +S214006B004FF44042C4F20502904214BF0022012214 +S214006B10984214BF134642F00103002B56D14FF49F +S214006B20A043C4F202034FF45042C4F2050290425E +S214006B3014BF00220122984214BF134642F00103FC +S214006B40002B46D14FF4C043C4F202034FF4604218 +S214006B50C4F20502904214BF00220122984214BFDC +S214006B60134642F00103002B36D14FF4E043C4F243 +S214006B7002034FF47042C4F20502904214BF002292 +S214006B800122984214BF134642F00103002B26D17F +S214006B904FF45043C4F203034FF00002C4F206025F +S214006BA0904214BF00220122984214BF104642F0C1 +S214006BB0010070474FF0010070474FF0010070472A +S214006BC04FF0010070474FF0010070474FF0010092 +S214006BD070474FF0010070474FF0010070474FF0CC +S214006BE0010070474FF45043C4F20303984200F08C +S214006BF0A9804FF45043C4F20303984241D84FF49F +S214006C00E043C4F20003984200F08D804FF4E04366 +S214006C10C4F20003984214D84FF4A043C4F2000311 +S214006C20984200F092804FF4C043C4F200039842AA +S214006C3076D04FF48043C4F20003984240F0888038 +S214006C406BE04FF4A043C4F20203984271D04FF4B5 +S214006C50A043C4F20203984206D84FF48043C4F21D +S214006C600203984274D161E04FF4C043C4F20203B9 +S214006C70984261D04FF4E043C4F20203984267D1D1 +S214006C805DE04FF44043C4F2050398424ED04FF403 +S214006C904043C4F2050398421FD84FF41043C4F291 +S214006CA00503984251D04FF41043C4F205039842AE +S214006CB006D84FF40043C4F20503984248D12CE0AE +S214006CC04FF42043C4F20503984229D04FF43043D2 +S214006CD0C4F2050398423BD125E04FF46043C4F26A +S214006CE00503984228D04FF46043C4F20503984247 +S214006CF006D84FF45043C4F20503984228D118E052 +S214006D004FF47043C4F20503984218D04FF00003C6 +S214006D10C4F2060398421BD114E04FF010007047EF +S214006D204FF0120070474FF0130070474FF01400FA +S214006D3070474FF02E0070474FF02F0070474FF00F +S214006D40300070474FF0460070474FF01100704714 +S214006D504FF0FF30704700BF70B504460E4615462C +S214006D60FFF77CFE38B940F2C820C0F201004FF0B1 +S214006D70E401FDF703FB022D07D940F2C820C0F25C +S214006D8001004FF0E601FDF7F9FA15F0010F04F5E2 +S214006D908063D4F8002414BF3243B2431A6015F05F +S214006DA0020F04F58463D4F8202414BF164322EAA5 +S214006DB006061E6070BD00BF38B504460D46FFF7D8 +S214006DC04DFE38B940F2C820C0F201004FF486717B +S214006DD0FDF7D4FA072D07D940F2C820C0F201000B +S214006DE040F20D11FDF7CAFA4FF0010303FA05F55C +S214006DF0D4F80034D4F82004EDB21D420CBF0023B2 +S214006E0001230540002D14BF02200020184338BD82 +S214006E1070B505460E461446FFF720FE38B940F218 +S214006E20C820C0F201004FF4A371FDF7A7FA231F94 +S214006E3018BF0123002C0CBF002303F0010393B1FD +S214006E40A31E18BF0123012C0CBF002303F001036F +S214006E504BB1072C0AD040F2C820C0F2010040F225 +S214006E604911FDF78BFA14F0010F05D005F5816383 +S214006E70D5F80824324305E005F58163D5F80824E3 +S214006E8022EA06021A6014F0020F05F5806303F189 +S214006E900403D5F8042414BF3243B2431A6014F036 +S214006EA0040F05F5806303F10C03D5F80C2414BF1A +S214006EB0164322EA06061E6070BD00BF38B50446BB +S214006EC00D46FFF7CBFD38B940F2C820C0F20100EE +S214006ED04FF4B971FDF752FA072D07D940F2C820D2 +S214006EE0C0F2010040F27311FDF748FA4FF00103BB +S214006EF003FA05F5D4F80824D4F80404D4F80C34BE +S214006F00EDB215420CBF0022012205EA000000285F +S214006F1014BF0220002010431D40002D14BF04257E +S214006F200025284338BD00BFF8B504460D46174671 +S214006F301E46FFF793FD38B940F2C820C0F20100A4 +S214006F404FF4DD71FDF71AFA07F1FF323B1F18BF49 +S214006F500123012A94BF002303F001034BB10C2F39 +S214006F6007D040F2C820C0F201004FF4DF71FDF7F1 +S214006F7005FAB6F10A0318BF0123082E0CBF00233A +S214006F8003F00103E3B1B6F1090318BF01230C2E89 +S214006F900CBF002303F0010393B1B6F10D0318BF35 +S214006FA001230B2E0CBF002303F0010343B13EB1B7 +S214006FB040F2C820C0F2010040F2C511FDF7DEF92C +S214006FC017F0010F04F5A063D4F8002514BF2A4378 +S214006FD0AA431A6017F0020F04F5A06303F1040336 +S214006FE0D4F8042514BF2A43AA431A6017F0040FE6 +S214006FF004F5A163D4F8082514BF2A43AA431A60EF +S21400700017F0080F04F5A363D4F8182514BF2A4315 +S214007010AA431A6016F0010F04F5A06303F10C03EF +S214007020D4F80C2514BF2A43AA431A6016F0020FA0 +S21400703004F5A263D4F8102514BF2A43AA431A60A5 +S21400704016F0040F04F5A26303F10403D4F8142524 +S21400705014BF2A43AA431A6016F0080F04F5A26369 +S21400706003F10C03D4F81C2514BF2A43AA431A6064 +S21400707036B904F5A563D4F8282542EA050505E0E7 +S21400708004F5A563D4F8282522EA05051D60F8BD99 +S214007090F8B504460D4616461F46FFF7DFFC38B91E +S2140070A040F2C820C0F2010040F20E21FDF766F95A +S2140070B0072D07D940F2C820C0F2010040F20F2188 +S2140070C0FDF75CF94FF0010303FA05F5D4F8000567 +S2140070D0D4F80435D4F80815D4F81825EDB20542CE +S2140070E00CBF0020012005EA0303002B14BF022377 +S2140070F00023034305EA0101002914BF04210021EF +S2140071000B4305EA0202002A14BF0822002213439A +S2140071103360D4F80C05D4F81035D4F81415D4F828 +S2140071201C2505420CBF0020012005EA0303002BA6 +S21400713014BF02230023034305EA0101002914BFFC +S214007140042100210B431540002D14BF08250025FF +S21400715043EA05053D60F8BD38B504460D46FFF721 +S2140071607DFC38B940F2C820C0F2010040F241214F +S214007170FDF704F9D4F8103443EA0505C4F81054B2 +S21400718038BD00BF38B504460D46FFF767FC38B972 +S21400719040F2C820C0F2010040F25F21FDF7EEF891 +S2140071A0D4F8103423EA0505C4F8105438BD00BFDF +S2140071B038B504460D46FFF751FC38B940F2C820F2 +S2140071C0C0F2010040F27E21FDF7D8F815B1D4F8E0 +S2140071D0180438BDD4F8140438BD00BF38B50446CA +S2140071E00D46FFF73BFC38B940F2C820C0F201005C +S2140071F04FF42B71FDF7C2F8C4F81C5438BD00BF1D +S21400720038B504460D46FFF729FC38B940F2C820C9 +S214007210C0F2010040F2CE21FDF7B0F82046FFF79D +S214007220E1FC0446294601F073FC204601F04CFDC3 +S21400723038BD00BF10B50446FFF710FC38B940F261 +S214007240C820C0F2010040F2F721FDF797F820466B +S214007250FFF7C8FC044601F08BFD204601F09CFCBD +S21400726010BD00BF38B504460D46FFF7F7FB38B92A +S21400727040F2C820C0F201004FF44971FDF77EF8D5 +S21400728054F8250038BD00BF70B506460C461546B6 +S214007290FFF7E4FB38B940F2C820C0F201004FF413 +S2140072A05171FDF76BF846F8245070BD38B50546A9 +S2140072B00C46FFF7D3FB38B940F2C820C0F20100F5 +S2140072C040F26731FDF75AF8284621464FF0000293 +S2140072D0FFF742FD284621464FF001024FF000031B +S2140072E0FFF722FE38BD00BF38B505460C46FFF74F +S2140072F0B5FB38B940F2C820C0F201004FF4647103 +S214007300FDF73CF8284621464FF00202FFF724FD21 +S214007310284621464FF004024FF00803FFF704FE0C +S21400732038BD00BF38B505460C46FFF797FB38B9A1 +S21400733040F2C820C0F201004FF46E71FDF71EF84F +S214007340284621464FF00002FFF706FD2846214654 +S2140073504FF001024FF00003FFF7E6FD38BD00BF17 +S21400736038B505460C46FFF779FB38B940F2C82019 +S214007370C0F2010040F2DE31FDF700F82846214653 +S2140073804FF00002FFF7E8FC284621464FF00102C6 +S2140073904FF00803FFF7C8FD38BD00BF38B50546F7 +S2140073A00C46FFF75BFB38B940F2C820C0F201007C +S2140073B040F20441FCF7E2FF284621464FF0010266 +S2140073C0FFF7CAFC284621464FF001024FF008039B +S2140073D0FFF7AAFD38BD00BF38B505460C46FFF7D7 +S2140073E03DFB38B940F2C820C0F2010040F22A4105 +S2140073F0FCF7C4FF284621464FF00102FFF7ACFC1D +S214007400284621464FF001024FF00903FFF78CFD96 +S21400741038BD00BF38B505460C46FFF71FFB38B928 +S21400742040F2C820C0F2010040F25241FCF7A6FF2D +S214007430284621464FF00202FFF78EFC28462146DA +S2140074404FF001024FF00B03FFF76EFD38BD00BF93 +S21400745038B505460C46FFF701FB38B940F2C820A0 +S214007460C0F2010040F27B41FCF788FF2846214627 +S2140074704FF00202FFF770FC284621464FF001024B +S2140074804FF00803FFF750FD38BD00BF38B505467E +S2140074900C46FFF7E3FA38B940F2C820C0F2010004 +S2140074A040F2A441FCF76AFF284621464FF002024C +S2140074B0FFF752FC284621464FF001024FF00A0320 +S2140074C0FFF732FD38BD00BF38B505460C46FFF75E +S2140074D0C5FA38B940F2C820C0F2010040F2CD41EA +S2140074E0FCF74CFF284621464FF00202FFF734FC1B +S2140074F0284621464FF001024FF00803FFF714FD1F +S21400750038BD00BF38B505460C46FFF7A7FA38B9B0 +S21400751040F2C820C0F2010040F2F641FCF72EFF10 +S214007520284621464FF00202FFF716FC2846214661 +S2140075304FF001024FF00803FFF7F6FC38BD00BF1E +S21400754038B505460C46FFF789FA38B940F2C82028 +S214007550C0F2010040F21F51FCF710FF28462146FA +S2140075604FF00202FFF7F8FB284621464FF00102D3 +S2140075704FF00803FFF7D8FC38BD00BF38B5054606 +S2140075800C46FFF76BFA38B940F2C820C0F201008B +S21400759040F24C51FCF7F2FE284621464FF002021C +S2140075A0FFF7DAFB284621464FF001024FF00803AA +S2140075B0FFF7BAFC38BD00BF38B505460C46FFF7E6 +S2140075C04DFA38B940F2C820C0F2010040F27551B9 +S2140075D0FCF7D4FE284621464FF00002FFF7BCFB1E +S2140075E0284621464FF001024FF00003FFF79CFCAF +S2140075F038BD00BF38B505460C46FFF72FFA38B938 +S21400760040F2C820C0F2010040F29E51FCF7B6FEE0 +S214007610284621464FF00202FFF79EFB28462146E9 +S2140076204FF001024FF00803FFF77EFC38BD00BFA5 +S21400763038B505460C46FFF711FA38B940F2C820AF +S214007640C0F2010040F2C651FCF798FE28462146DB +S2140076504FF00202FFF780FB284621464FF0040257 +S2140076604FF00803FFF760FC38BD00BF38B505468D +S2140076700C46FFF7F3F938B940F2C820C0F2010013 +S21400768040F2F151FCF77AFE284621464FF00202FE +S214007690FFF762FB284621464FF004024FF008032E +S2140076A0FFF742FC38BD00BF70B50446C0F307457F +S2140076B0082D07D940F2C820C0F201004FF4C3617C +S2140076C0FCF75CFE4FEA142616F0E30F07D040F2F4 +S2140076D0C820C0F2010040F21961FCF74FFE4EF2DE +S2140076E06C03C4F20F031B684FF0010202FA05F2A6 +S2140076F01A4240F2E023C0F201031ABF03EBC505AD +S2140077006B6853F83530D3F82C1506F0FF064FF0AB +S2140077100F0202FA06F221EA020204F00F0404FA4B +S21400772006F642EA0606C3F82C6570BD4CF2100257 +S214007730C4F20F021368002BFCDA70474CF21003F9 +S214007740C4F20F031A6842F040021A604FF4604316 +S214007750C4F20F031A684FF00003C7F2FF0302EAF1 +S21400776003034FF00002C1F2010293421BD140F224 +S2140077708013C2F2000344F6D352C1F26202A2FBA7 +S21400778000104FEA901000EB40024FEA4212101A27 +S21400779041F6F112C0F27652A2FB00124FEA9212A4 +S2140077A002F101021A6070474CF21003C4F20F0394 +S2140077B01A6822F040021A60704700BF10B50446EF +S2140077C0031E18BF012304280CBF002303F0010387 +S2140077D03BB140F22830C0F201004FF0B101FCF797 +S2140077E0CDFD4CF21003C4F20F031A6822F0040217 +S2140077F014431C6010BD00BF4CF21003C4F20F030C +S2140078001A6842F001021A60704700BF4CF210037B +S214007810C4F20F031A6822F001021A60704700BF14 +S21400782010B5044630F0180307D040F22830C0F2F6 +S21400783001004FF0F701FCF7A1FD4CF21003C4F273 +S2140078400F031A6822F0180214431C6010BD00BF14 +S2140078504CF21003C4F20F03186800F018007047CB +S21400786010B50446B0F1A00318BF012320280CBFB2 +S214007870002303F001033BB140F22830C0F20100C0 +S2140078804FF49A71FCF77AFD4CF21003C4F20F0322 +S2140078901A6822F0A00214431C6010BD4CF21003BC +S2140078A0C4F20F03186800F0A000704708B54CF249 +S2140078B00C03C4F20F0318604FF46043C4F20F03C6 +S2140078C01A684FF00003C7F2FF0302EA03034FF003 +S2140078D00002C1F20102934207D140F28013C2F2C5 +S2140078E00003186803F070FC08BDFFF71FFF08BD13 +S2140078F04FF44043C4F20F031868704708B54CF2C3 +S2140079000403C4F20F0318604FF46043C4F20F037D +S2140079101A684FF00003C7F2FF0302EA03034FF0B2 +S2140079200002C1F20102934207D140F28013C2F274 +S2140079300003186803F048FC08BDFFF7F7FE08BD13 +S2140079404CF20403C4F20F031868704708B54CF2F3 +S2140079500803C4F20F0318604FF46043C4F20F0329 +S2140079601A684FF00003C7F2FF0302EA03034FF062 +S2140079700002C1F20102934207D140F28013C2F224 +S2140079800003186803F020FC08BDFFF7CFFE08BD13 +S2140079904CF20803C4F20F031868704710B504468B +S2140079A0B0F5803F07D340F22830C0F2010040F225 +S2140079B01F21FCF7E3FC4CF22403C4F20F031C6007 +S2140079C04FF46043C4F20F031A684FF00003C7F287 +S2140079D0FF0302EA03034FF00002C1F201029342E2 +S2140079E007D140F28013C2F20003186803F0ECFBE4 +S2140079F010BDFFF79BFE10BD4CF22403C4F20F032C +S214007A00186870472DE9F04706468946402907D989 +S214007A1040F22830C0F201004FF41A71FCF7AEFCB9 +S214007A203EB940F22830C0F2010040F26921FCF76E +S214007A30A5FCB9F1000F29D04CF23004C4F20F04B3 +S214007A404FF000054FF46047C4F20F07A846C7F290 +S214007A50FF0840F2801AC2F2000A56F8043B236080 +S214007A603A6802EA08024FF00003C1F201039A42A4 +S214007A7004D1DAF8000003F0A7FB01E0FFF756FE9A +S214007A8005F1010504F10404A945E6D8BDE8F08730 +S214007A9038B505460C46402907D940F22830C0F2D2 +S214007AA0010040F2A121FCF769FC3DB940F2283004 +S214007AB0C0F2010040F2A221FCF760FC6CB14CF26F +S214007AC03002C4F20F024FF0000352F8041B45F8D0 +S214007AD0041B03F101039C42F7D838BD4CF2100397 +S214007AE0C4F20F031A6842F002021A60704700BF21 +S214007AF010B5044630F00F0307D040F22830C0F22D +S214007B00010040F2F721FCF739FC4CF21403C4F2F2 +S214007B100F031A6814431C6010BD00BF10B504465E +S214007B2030F00F0307D040F22830C0F2010040F2D8 +S214007B301531FCF723FC4CF21403C4F20F031A6849 +S214007B4022EA04041C6010BD08B501464FF03B0055 +S214007B5000F0DEFF4FF03B0001F0B6F808BD00BFB6 +S214007B6008B54FF03B0001F003F94FF03B0001F081 +S214007B7013F808BD012801BF4CF21C03C4F20F0322 +S214007B80186800F00F001FBF4CF21803C4F20F0372 +S214007B90186800F00F00704710B5044630F00F0369 +S214007BA007D040F22830C0F2010040F29731FCF7CF +S214007BB0E5FB4CF22003C4F20F031A6814431C6062 +S214007BC010BD00BF4CF21003C4F20F031868C0F3D8 +S214007BD08010704710B504464FF00003C4F202034D +S214007BE04FF48052C4F20202821A18BF0122984251 +S214007BF00CBF002302F001033BB140F24430C0F258 +S214007C0001004FF0A201FCF7B9FB236A43F0100312 +S214007C10236210BD70B504460E4615464FF00003AD +S214007C20C4F202034FF48052C4F20202821A18BF52 +S214007C30012298420CBF002302F001033BB140F240 +S214007C404430C0F201004FF04F01FCF797FB20468E +S214007C50FFF7C0FF48F2A062C0F201024FF4D4530F +S214007C60C0F20603012D14BF15461D4605EB85051B +S214007C704FEA850506F1FF367619B6FBF5F505F1F0 +S214007C80FF35E56070BD00BF10B504464FF40063D5 +S214007C90C4F202034FF4C052C4F20202821A18BFA2 +S214007CA0012298420CBF002302F001033BB140F2D0 +S214007CB04430C0F201004FF0BB01FCF75FFBA4F5B7 +S214007CC0FC631A6842F020021A604FF001036360FA +S214007CD010BD00BF38B504460D464FF40063C4F22D +S214007CE002034FF4C052C4F20202821A18BF0122E5 +S214007CF098420CBF002302F001033BB140F244302F +S214007D00C0F201004FF08301FCF738FB15F0800F3E +S214007D1007D040F24430C0F201004FF08401FCF777 +S214007D202DFB2046FFF7B0FF256038BD10B5044692 +S214007D304FF00003C4F202034FF48052C4F2020272 +S214007D40821A18BF012298420CBF002302F00103DA +S214007D503BB140F24430C0F201004FF0DA01FCF7CC +S214007D600DFB236A23F01003236210BD10B50446F2 +S214007D704FF40063C4F202034FF4C052C4F202028E +S214007D80821A18BF012298420CBF002302F001039A +S214007D903BB140F24430C0F201004FF0F301FCF773 +S214007DA0EDFA4FF000036360A4F5FC64236823F04B +S214007DB02003236010BD00BF38B504460D464FF0C3 +S214007DC00003C4F202034FF48052C4F20202821A85 +S214007DD018BF012298420CBF002302F001033BB1FA +S214007DE040F24430C0F201004FF48F71FCF7C6FA3F +S214007DF04FF00003C4F202039C4214BF352418243B +S214007E002046294600F084FE204600F05DFF38BD7F +S214007E1010B504464FF00003C4F202034FF480523C +S214007E20C4F20202821A18BF012298420CBF002335 +S214007E3002F001033BB140F24430C0F201004FF4BF +S214007E40A471FCF79BFA4FF00003C4F202039C42B5 +S214007E5014BF35241824204600F08AFF204600F080 +S214007E609BFE10BD10B504464FF00003C4F202039B +S214007E704FF48052C4F20202821A18BF01229842BE +S214007E800CBF002302F001033BB140F24430C0F2C5 +S214007E90010040F26B11FCF771FA4FF00103236109 +S214007EA010BD00BF10B504464FF40063C4F20203D1 +S214007EB04FF4C052C4F20202821A18BF012298423E +S214007EC00CBF002302F001033BB140F24430C0F285 +S214007ED001004FF4C271FCF751FAE36843F0010366 +S214007EE0E36010BD38B504460D464FF40063C4F297 +S214007EF002034FF4C052C4F20202821A18BF0122D3 +S214007F0098420CBF002302F001033BB140F244301C +S214007F10C0F201004FF4D371FCF730FAE36843EA8D +S214007F200505E56038BD00BF10B504464FF00003F8 +S214007F30C4F202034FF48052C4F20202821A18BF3F +S214007F40012298420CBF002302F001033BB140F22D +S214007F504430C0F2010040F2BF11FCF70FFA4FF0B8 +S214007F600003236110BD00BF10B504464FF4006344 +S214007F70C4F202034FF4C052C4F20202821A18BFBF +S214007F80012298420CBF002302F001033BB140F2ED +S214007F904430C0F201004FF4EC71FCF7EFF9E368EF +S214007FA023F00103E36010BD38B504460D464FF4D8 +S214007FB00063C4F202034FF4C052C4F20202821AF3 +S214007FC018BF012298420CBF002302F001033BB108 +S214007FD040F24430C0F2010040F2F711FCF7CEF94F +S214007FE0E36823EA0505E56038BD00BF38B50446FA +S214007FF00D464FF00003C4F202034FF48052C4F261 +S2140080000202821A18BF012298420CBF002302F017 +S21400801001033BB140F24430C0F2010040F21521AA +S214008020FCF7ACF925B1A069003818BF012038BDAF +S2140080306069003818BF012038BD00BF38B5044657 +S2140080400D464FF40063C4F202034FF4C052C4F26C +S2140080500202821A18BF012298420CBF002302F0C7 +S21400806001033BB140F24430C0F2010040F23B2134 +S214008070FCF784F925B16069003818BF012038BDC7 +S2140080802069003818BF012038BD00BF38B5044647 +S2140080900D464FF40063C4F202034FF4C052C4F21C +S2140080A00202821A18BF012298420CBF002302F077 +S2140080B001033BB140F24430C0F2010040F26321BC +S2140080C0FCF75CF9EDB14FF46043C4F20F031A6895 +S2140080D04FF00003C7F2FF0302EA03034FF000026B +S2140080E0C1F2030293420AD14FF46043C4F20F0375 +S2140080F01B689BB21BB92369E068184038BD6069ED +S21400810038BD206938BD00BF10B504464FF00003E7 +S214008110C4F202034FF48052C4F20202821A18BF5D +S214008120012298420CBF002302F001033BB140F24B +S2140081304430C0F2010040F29B21FCF71FF94FF0DB +S2140081400103E361A36110BD10B504464FF400635C +S214008150C4F202034FF4C052C4F20202821A18BFDD +S214008160012298420CBF002302F001033BB140F20B +S2140081704430C0F2010040F2C621FCF7FFF84FF091 +S2140081800103A36110BD00BF38B504460D464FF489 +S2140081900063C4F202034FF4C052C4F20202821A11 +S2140081A018BF012298420CBF002302F001033BB126 +S2140081B040F24430C0F2010040F2EE21FCF7DEF857 +S2140081C0A56138BD70B504460D4616464FF000034F +S2140081D0C4F202034FF48052C4F20202821A18BF9D +S2140081E0012298420CBF002302F001033BB140F28B +S2140081F04430C0F2010040F20E31FCF7BFF815F033 +S214008200800F07D040F24430C0F2010040F20F3138 +S214008210FCF7B4F846EA4505256070BD10B504467F +S2140082204FF00003C4F202034FF48052C4F202027D +S214008230821A18BF012298420CBF002302F00103E5 +S2140082403BB140F24430C0F2010040F22A31FCF764 +S21400825095F8606800F0010010BD00BF10B5044638 +S2140082604FF00003C4F202034FF48052C4F202023D +S214008270821A18BF012298420CBF002302F00103A5 +S2140082803BB140F24430C0F2010040F24D31FCF701 +S21400829075F86068C0F3801010BD00BF38B505469D +S2140082A00C464FF00003C4F202034FF48052C4F2AF +S2140082B00202821A18BF012298420CBF002302F065 +S2140082C001033BB140F24430C0F2010040F27B3182 +S2140082D0FCF754F8E31E18BF0123072C0CBF00233D +S2140082E003F0010303B3631F18BF0123012C0CBF67 +S2140082F0002203F00102BAB1221F18BF01220B2C84 +S2140083000CBF002102F0010171B1092C0CBF002343 +S21400831003F0010343B13AB140F24430C0F2010029 +S21400832040F28531FCF72AF86C6038BD10B504467B +S2140083304FF00003C4F202034FF48052C4F202026C +S214008340821A18BF012298420CBF002302F00103D4 +S2140083503BB140F24430C0F2010040F2A331FCF7DA +S2140083600DF8606810F0010F05D110F0120F05D05F +S21400837000F01C0010BD4FF0000010BD4FF00000D4 +S21400838010BD00BF38B504460D464FF00003C4F2DA +S21400839002034FF48052C4F20202821A18BF01226E +S2140083A098420CBF002302F001033BB140F2443078 +S2140083B0C0F2010040F2D231FBF7E0FFA56038BD05 +S2140083C010B504464FF00003C4F202034FF4805287 +S2140083D0C4F20202821A18BF012298420CBF002380 +S2140083E002F001033BB140F24430C0F201004FF40A +S2140083F07B71FBF7C3FFA06810BD00BF10B5044635 +S2140084004FF40063C4F202034FF4C052C4F20202F7 +S214008410821A18BF012298420CBF002302F0010303 +S2140084203BB140F24430C0F2010040F21141FBF78C +S214008430A5FF606810BD00BF38B504460D464FF472 +S2140084400063C4F202034FF4C052C4F20202821A5E +S21400845018BF012298420CBF002302F001033BB173 +S21400846040F24430C0F2010040F22B41FBF786FF99 +S214008470A56038BD10B504464FF40063C4F202038D +S2140084804FF4C052C4F20202821A18BF0122984268 +S2140084900CBF002302F001033BB140F24430C0F2AF +S2140084A0010040F24541FBF769FFA06810BD00BF20 +S2140084B010B504464FF48043C4F20503984207D033 +S2140084C040F25830C0F201004FF03B01FBF756FF78 +S2140084D04FF001032361D4F8003C43F00103C4F8D5 +S2140084E0003C10BD10B504464FF48043C4F20503AB +S2140084F0984207D040F25830C0F201004FF05B01BE +S214008500FBF73CFFD4F8003C23F00103C4F8003C22 +S21400851010BD00BF38B504460D464FF48043C4F284 +S2140085200503984207D040F25830C0F201004FF0E1 +S2140085308801FBF723FFA3690F2BFCD8256038BD05 +S21400854038B504460D464FF48043C4F205039842FE +S21400855007D040F25830C0F201004FF0BC01FBF7E4 +S2140085600DFFA3690F2B9ABF25600120002038BDA0 +S21400857038B505460C464FF48043C4F205039842CE +S21400858007D040F25830C0F201004FF0F301FBF77D +S214008590F5FE4FF6F073C3F6C07304EA0303A34276 +S2140085A007D040F25830C0F201004FF0F701FBF759 +S2140085B0E5FE04F04073B3F1407F06BF24F000747C +S2140085C0022300236B60AC6038BD00BF38B504469C +S2140085D00D464FF48043C4F20503984207D040F29C +S2140085E05830C0F2010040F23911FBF7C7FE102DDB +S2140085F007D940F25830C0F201004FF49D71FBF7E6 +S214008600BDFEE56038BD00BF10B504464FF480439C +S214008610C4F20503984207D040F25830C0F2010079 +S21400862040F25511FBF7AAFEE06810BD10B50446EF +S2140086304FF48043C4F20503984207D040F2583006 +S214008640C0F201004FF4BC71FBF798FEA06910BDA4 +S21400865010B504464FF48043C4F20503984207D091 +S21400866040F25830C0F2010040F29311FBF786FE4C +S2140086704FF00103C4F81038D4F8003C43F002036E +S214008680C4F8003C10BD00BF10B504464FF480434C +S214008690C4F20503984207D040F25830C0F20100F9 +S2140086A040F2B311FBF76AFED4F8003C23F0020355 +S2140086B0C4F8003C10BD00BF38B504460D464FF464 +S2140086C08043C4F20503984207D040F25830C0F207 +S2140086D001004FF4F071FBF751FE04F50062936958 +S2140086E0002BFCD0D4F800382B6038BD38B50446D3 +S2140086F00D464FF48043C4F20503984207D040F27B +S2140087005830C0F201004FF40571FBF737FED4F87D +S21400871018382BB1D4F800382B604FF0010038BD64 +S2140087204FF0000038BD00BF38B504460D464FF484 +S2140087308043C4F20503984207D040F25830C0F296 +S21400874001004FF41271FBF719FE4FF6F073C3F6F3 +S214008750407305EA0303AB4207D040F25830C0F23C +S214008760010040F24B21FBF709FE4FF00003C4F86E +S214008770043805F04073B3F1007F06D1D4F804380E +S21400878043F00403C4F8043808E0B3F1407F02BFA6 +S214008790D4F8043843F00203C4F8043825F0007512 +S2140087A0C4F8085838BD00BF38B504460D464FF427 +S2140087B08043C4F20503984207D040F25830C0F216 +S2140087C0010040F29321FBF7D9FD102D07D940F2A6 +S2140087D05830C0F201004FF42571FBF7CFFDC4F806 +S2140087E00C5838BD10B504464FF48043C4F2050358 +S2140087F0984207D040F25830C0F2010040F2AF2154 +S214008800FBF7BCFDD4F80C384FF6FE7003EA000008 +S21400881010BD00BF10B504464FF48043C4F20503F4 +S214008820984207D040F25830C0F2010040F2D321FF +S214008830FBF7A4FDD4F8180810BD00BF10B5044619 +S2140088404FF48043C4F20503984207D040F25830F4 +S214008850C0F2010040F2EF21FBF790FD4FF001035C +S2140088602361C4F81038D4F8003C43F00303C4F87E +S214008870003C10BD10B504464FF48043C4F2050317 +S214008880984207D040F25830C0F201004FF44571CC +S214008890FBF774FDD4F8003C23F00303C4F8003C57 +S2140088A010BD00BF38B504460D464FF48043C4F2F1 +S2140088B00503984207D040F25830C0F2010040F25B +S2140088C04331FBF75BFD4FF6F073C3F6C07305EA62 +S2140088D00303AB4207D040F25830C0F2010040F22A +S2140088E04731FBF74BFD4FF000036360C4F80438D4 +S2140088F005F04073B3F1007F01BFD4F8043843F0AD +S2140089000403C4F8043825F0007505F04073B3F18D +S214008910407F09D1636843F002036360D4F80438EB +S21400892043F00203C4F80438A560C4F8085838BDFC +S21400893038B504460D464FF48043C4F2050398420A +S21400894007D040F25830C0F2010040F28631FBF703 +S21400895015FD05F03003AB4207D040F25830C0F2A8 +S214008960010040F28731FBF709FDD4F8003C23F004 +S214008970300343EA0505C4F8005C38BD38B5044644 +S2140089800D464FF48043C4F20503984207D040F2E8 +S2140089905830C0F2010040F2AA31FBF7EFFC05F0B8 +S2140089A03303AB4207D040F25830C0F201004FF418 +S2140089B06B71FBF7E3FCD4F8103C43EA0505C4F8FA +S2140089C0105C38BD38B504460D464FF48043C4F2FB +S2140089D00503984207D040F25830C0F2010040F23A +S2140089E0C931FBF7CBFC05F03303AB4207D040F2AE +S2140089F05830C0F2010040F2CB31FBF7BFFCD4F890 +S214008A00103C23EA0505C4F8105C38BD38B50446AA +S214008A100D464FF48043C4F20503984207D040F257 +S214008A205830C0F2010040F2E931FBF7A7FC15B15F +S214008A30D4F8180C38BDD4F8140C38BD38B5054633 +S214008A400C464FF48043C4F20503984207D040F228 +S214008A505830C0F201004FF48361FBF78FFC04F03E +S214008A603303A34207D040F25830C0F2010040F270 +S214008A701A41FBF783FCC5F81C4C38BD10B50C46F4 +S214008A804FF48043C4F20503984207D040F25830B2 +S214008A90C0F2010040F23B41FBF770FC3CB940F2EB +S214008AA05830C0F2010040F23C41FBF767FC4FF043 +S214008AB04400214600F02CF84FF0440000F004F982 +S214008AC010BD00BF08B54FF48043C4F205039842BA +S214008AD007D040F25830C0F2010040F25E41FBF78A +S214008AE04DFC4FF0440000F043F94FF0440000F016 +S214008AF053F808BDFEE700BF08B5FCF7FDFCC0B2A2 +S214008B0008BD00BF08B5FCF7EFFCC0B208BD00BF4B +S214008B1070B505460E46462807D940F26C30C0F2BE +S214008B2001004FF0C901FBF729FC40F20004C2F235 +S214008B3000044FEA84534FEA93533BB140F26C3043 +S214008B40C0F201004FF0CE01FBF718FC4EF60853BA +S214008B50CEF200031B689C4216D04EF60853CEF2A7 +S214008B60000318684FF0000340F20001C2F2000153 +S214008B701A58CA5003F10403B3F58E7FF8D14EF6A7 +S214008B800853CEF200031C6040F20003C2F200035A +S214008B9043F8256070BD00BF10B50446462807D9C7 +S214008BA040F26C30C0F201004FF48171FBF7E6FB37 +S214008BB040F20003C2F2000348F6F522C0F20002BB +S214008BC043F8242010BD00BF10B50446072807D977 +S214008BD040F26C30C0F201004FF49071FBF7CEFB10 +S214008BE040F28833C0F2010353F8242042F0BE62FC +S214008BF042F420224EF60C53CEF200031A6010BD4B +S214008C004EF60C53CEF20003196801F4E061B1F59C +S214008C10E06F0ED040F28833C0F201034FF001003F +S214008C2053F8042F8A4206D000F101000828F7D135 +S214008C3070474FF00000704738B504460D46A0F167 +S214008C400403422B07D940F26C30C0F201004FF407 +S214008C50B871FBF793FB40F2A833C0F201034FEA6A +S214008C60940253F82230196804F003044FEAC4044F +S214008C704FF0FF0202FA04F221EA020205FA04F5B6 +S214008C8042EA05041C6038BD10B50446A0F1040392 +S214008C90422B07D940F26C30C0F201004FF4C77186 +S214008CA0FBF76CFB40F2A833C0F201034FEA9402D4 +S214008CB053F82230186804F003044FEAC40420FA7C +S214008CC004F0C0B210BD00BF10B50446462807D950 +S214008CD040F26C30C0F201004FF4D571FBF74EFB4A +S214008CE0042C08D14EF62453CEF200031A6842F440 +S214008CF080321A6010BD052C08D14EF62453CEF2F1 +S214008D0000031A6842F400321A6010BD062C08D11F +S214008D104EF62453CEF200031A6842F480221A60FC +S214008D2010BD0F2C08D14EF21003CEF200031A68C5 +S214008D3042F002021A6010BDA4F110031F2B09D8DE +S214008D404FF0010202FA03F34FF46142CEF2000242 +S214008D50136010BD2F2C0AD9A4F130044FF0010384 +S214008D6003FA04F44EF20413CEF200031C6010BDA6 +S214008D7010B50446462807D940F26C30C0F2010010 +S214008D804FF4F771FBF7FAFA042C08D14EF6245389 +S214008D90CEF200031A6822F480321A6010BD052C49 +S214008DA008D14EF62453CEF200031A6822F400329D +S214008DB01A6010BD062C08D14EF62453CEF20003DE +S214008DC01A6822F480221A6010BD0F2C08D14EF2C9 +S214008DD01003CEF200031A6822F002021A6010BDD9 +S214008DE0A4F110031F2B09D84FF0010202FA03F377 +S214008DF04EF28012CEF20002136010BD2F2C0AD95C +S214008E00A4F130044FF0010303FA04F44EF2841385 +S214008E10CEF200031C6010BD10B50446462807D9E4 +S214008E2040F26C30C0F2010040F23621FBF7A6FAA1 +S214008E30022C08D14EF60453CEF200031A6842F014 +S214008E4000421A6010BD0E2C08D14EF60453CEF226 +S214008E5000031A6842F080521A6010BD0F2C08D129 +S214008E604EF60453CEF200031A6842F080621A608F +S214008E7010BDA4F110031F2B09D84FF0010202FA0F +S214008E8003F34FF46242CEF20002136010BD2F2CA3 +S214008E900AD9A4F130044FF0010303FA04F44EF2A9 +S214008EA00423CEF200031C6010BD00BF10B50446BC +S214008EB0462807D940F26C30C0F201004FF41D710D +S214008EC0FBF75CFA0E2C08D14EF60453CEF20003E4 +S214008ED01A6842F000621A6010BD0F2C08D14EF6D8 +S214008EE00453CEF200031A6842F000721A6010BDF6 +S214008EF0A4F110031F2B09D84FF0010202FA03F366 +S214008F004EF28022CEF20002136010BD2F2C0AD93A +S214008F10A4F130044FF0010303FA04F44EF2842364 +S214008F20CEF200031C6010BD08B5FCF7EBFA08BDD6 +S214008F3008B5FCF7EBFA08BD10B5044630F006039A +S214008F4007D040F2F030C0F201004FF04F01FBF7BF +S214008F5015FA44F001044EF69453CEF200031C605A +S214008F6010BD00BF4EF69453CEF200031A6822F0EE +S214008F7001021A60704700BF4EF69053CEF200030F +S214008F801868C0F30720704710B50446072807D9AD +S214008F9040F2F030C0F201004FF09701FBF7EEF917 +S214008FA04EF69853CEF200031C604EF6A053CEF257 +S214008FB000031A6842F001021A6010BD10B504469C +S214008FC0072807D940F2F030C0F201004FF0B80190 +S214008FD0FBF7D4F94EF69853CEF200031C604EF61B +S214008FE0A053CEF200031A6822F001021A6010BDE8 +S214008FF070B505460C461646072807D940F2F030ED +S214009000C0F201004FF49C71FBF7B8F9C6F34403B5 +S21400901003F101034FF0FF3202FA03F32340A342A9 +S21400902007D040F2F030C0F201004FF49D71FBF71C +S214009030A5F945F0100545EA04044EF69C53CEF219 +S21400904000031C6026F47C1646F4A0264EF6A053B9 +S214009050CEF200031E6070BD70B505460C4616467F +S214009060072807D940F2F030C0F2010040F267113D +S214009070FBF784F93CB940F2F030C0F201004FF43F +S214009080B471FBF77BF93EB940F2F030C0F2010054 +S21400909040F26911FBF772F94EF69853CEF20003D0 +S2140090A01D604EF69C53CEF200031B6823604EF6FE +S2140090B0A053CEF200031B68336070BD10B50446A3 +S2140090C038B940F2F030C0F2010040F29111FBF7DF +S2140090D055F94FF004002146FFF71AFD4FF0040043 +S2140090E0FFF7F2FD10BD00BF08B54FF00400FFF714 +S2140090F03FFE4FF00400FFF74FFD08BD802814BF69 +S21400910000230123402808BF43F0010353B9B0F5FC +S214009110807F14BF00230123C02814BF184643F0E5 +S214009120010070474FF00100704700BFA0F14002F9 +S214009130822814BF00230123012A98BF43F00103AD +S214009140CBB9C42814BF00230123832808BF43F0EB +S21400915001039BB9B0F5837F14BF00230123C52804 +S21400916008BF43F0010363B940F20713984214BFE7 +S2140091700020012070474FF0010070474FF00100BB +S21400918070474FF00100704770B504460D4616460E +S2140091904FF40043C4F20203984207D040F2044062 +S2140091A0C0F201004FF0BD01FBF7E8F82846FFF7D4 +S2140091B0A5FF38B940F20440C0F201004FF0BE01EE +S2140091C0FBF7DCF82A1929594FF00103CFF6F8739C +S2140091D001EA030333432B5116F0020F1DBFB023E1 +S2140091E013624FF430638C2304BF136240F60C0303 +S2140091F0536270BDF8B504460D4616464FF400435C +S214009200C4F20203984207D040F20440C0F20100C4 +S2140092104FF48571FBF7B2F82846FFF76FFF38B9B1 +S21400922040F20440C0F2010040F20B11FBF7A6F832 +S2140092302F192B5913F0020F0ED0B6F5003F07D3A7 +S21400924040F20440C0F2010040F21B11FBF796F812 +S2140092504FEA56063E61F8BD06F1FF36B6F5803F8A +S21400926007D340F20440C0F201004FF49271FBF7BE +S21400927085F83E61F8BD00BF38B504460D464FF48C +S2140092800043C4F20203984207D040F20440C0F202 +S214009290010040F24311FBF771F82846FFF72EFF56 +S2140092A038B940F20440C0F201004FF4A271FBF757 +S2140092B065F82B192A5912F0020F186914BF4000DE +S2140092C0013038BD38B504460D464FF40043C4F2AD +S2140092D00203984207D040F20440C0F201004FF467 +S2140092E0B971FBF74BF82846FFF708FF38B940F28C +S2140092F00440C0F2010040F27311FBF73FF82B590F +S21400930043F001032B5138BD38B504460D464FF4E3 +S2140093100043C4F20203984207D040F20440C0F271 +S214009320010040F28F11FBF729F82846FFF7E6FE0A +S21400933038B940F20440C0F201004FF4C871FBF7A0 +S2140093401DF82B5923F001032B5138BDF8B50546FF +S2140093500E4614464FF40043C4F20203984207D068 +S21400936040F20440C0F201004FF4DA71FBF706F851 +S2140093703046FFF7DBFE38B940F20440C0F2010089 +S21400938040F2B511FAF7FAFF26F03F035F195B5972 +S21400939013F0020F18BF64083D69AC4207D340F2D1 +S2140093A00440C0F201004FF4E671FAF7E7FF2C1B09 +S2140093B016F0010F14BFFC61BC61F8BD38B5044659 +S2140093C00D464FF40043C4F20203984207D040F221 +S2140093D00440C0F201004FF4FD71FAF7CFFF2846B3 +S2140093E0FFF7A4FE38B940F20440C0F2010040F294 +S2140093F0FB11FAF7C3FF25F03F031A19106915F0A1 +S214009400010F14BFD2699269801A1B5913F0020F1C +S21400941018BF400038BD00BFF8B504460D461646D6 +S2140094201F464FF40043C4F20203984207D040F2AE +S2140094300440C0F201004FF40E71FAF79FFF284671 +S214009440FFF75CFE38B940F20440C0F2010040F27B +S2140094503921FAF793FFB6F5805F07D340F2044050 +S214009460C0F2010040F23A21FAF788FFB7F5805FB4 +S21400947007D340F20440C0F2010040F23B21FAF765 +S2140094807DFF2C19E6622763A36A43F00103A362FB +S214009490F8BD00BF38B505460C464FF40043C4F28D +S2140094A00203984207D040F20440C0F2010040F2A6 +S2140094B06221FAF763FF2046FFF720FE38B940F234 +S2140094C00440C0F2010040F26321FAF757FF05F1AD +S2140094D028052B5923F001032B5138BD38B5044617 +S2140094E00D464FF40043C4F20203984207D040F200 +S2140094F00440C0F2010040F28221FAF73FFF35F047 +S2140095000F0307D040F20440C0F201004FF421716F +S214009510FAF734FF256038BD38B504460D464FF4DB +S2140095200043C4F20203984207D040F20440C0F25F +S214009530010040F2A221FAF721FF35F00F0307D011 +S21400954040F20440C0F201004FF42971FAF716FF0A +S214009550656038BD70B504460D4616464FF40043A8 +S214009560C4F20203984207D040F20440C0F2010061 +S21400957040F2C921FAF702FF35F0FF0307D040F2A8 +S2140095800440C0F201004FF43371FAF7F7FE012EE3 +S214009590A3680CBF1D4323EA0505A56070BD00BF88 +S2140095A070B504460D4616464FF40043C4F2020357 +S2140095B0984207D040F20440C0F2010040F2F92180 +S2140095C0FAF7DCFE35F0FF0307D040F20440C0F2A5 +S2140095D001004FF43F71FAF7D1FE012EE3680CBF8D +S2140095E01D4323EA0505E56070BD00BF70B504465F +S2140095F00D4616464EF22003C4F20F031B6813F402 +S214009600001F07D140F20440C0F2010040F23131A1 +S214009610FAF7B4FE4FF40043C4F202039C4207D0AC +S21400962040F20440C0F2010040F23231FAF7A6FEE2 +S21400963035F0FF0307D040F20440C0F2010040F2CC +S2140096403531FAF79BFE012E636A0CBF1D4323EAF1 +S2140096500505656270BD00BF70B504460D4616462A +S2140096604FF40043C4F20203984207D040F204408D +S214009670C0F2010040F26731FAF780FE35F0FF03D2 +S21400968007D040F20440C0F2010040F26A31FAF717 +S21400969075FE012E23690CBF1D4323EA05052561CF +S2140096A070BD00BF38B50C4615464FF40043C4F2F3 +S2140096B00203984207D040F20440C0F2010040F294 +S2140096C09A31FAF75BFE2046FFF718FD38B940F2EC +S2140096D00440C0F2010040F29B31FAF74FFEB4F5A9 +S2140096E0807F1ABFA40919343D2420462946FFF777 +S2140096F00FFA2046FFF7E8FA38BD00BF10B50C4653 +S2140097004FF40043C4F20203984207D040F20440EC +S214009710C0F201004FF47471FAF730FE2046FFF7EE +S214009720EDFC38B940F20440C0F2010040F2D131FD +S214009730FAF724FEB4F5807F1ABFA40919343D2435 +S2140097402046FFF715FB2046FFF726FA10BD00BFA0 +S21400975010B50C464FF40043C4F20203984207D0FB +S21400976040F20440C0F2010040F20541FAF706FE5E +S2140097704FF019002146FFF7CBF94FF01900FFF71D +S214009780A3FA10BD08B54FF40043C4F20203984292 +S21400979007D040F20440C0F2010040F22941FAF737 +S2140097A0EDFD4FF01900FFF7E3FA4FF01900FFF751 +S2140097B0F3F908BD70B505460C4616464FF400434F +S2140097C0C4F20203984207D040F20440C0F20100FF +S2140097D040F25141FAF7D2FD2046FFF78FFC38B928 +S2140097E040F20440C0F2010040F25241FAF7C6FDD2 +S2140097F026F47C5333F03F0207D040F20440C0F218 +S214009800010040F25741FAF7B9FD05F104052B595E +S21400981043EA06062E5170BD70B505460C46164640 +S2140098204FF40043C4F20203984207D040F20440CB +S214009830C0F2010040F27A41FAF7A0FD2046FFF799 +S2140098405DFC38B940F20440C0F2010040F27B41B2 +S214009850FAF794FD26F47C5333F03F0207D040F22B +S2140098600440C0F201004FF49061FAF787FD05F15D +S21400987004052B5923EA06062E5170BD70B5044622 +S2140098800D4616464FF40043C4F20203984207D032 +S21400989040F20440C0F201004FF49461FAF76EFD06 +S2140098A02846FFF72BFC38B940F20440C0F201000E +S2140098B040F2A141FAF762FD2C19012E0CBFE068B8 +S2140098C0A06870BD70B505460E4614464FF40043BA +S2140098D0C4F20203984207D040F20440C0F20100EE +S2140098E040F2D741FAF74AFD3046FFF707FC38B991 +S2140098F040F20440C0F201004FF49B61FAF73EFDCF +S21400990034F03F0307D040F20440C0F2010040F2BA +S214009910DB41FAF733FD05F10C05AC5170BD00BF15 +S21400992038B504460D464FF40043C4F2020398428D +S21400993007D040F20440C0F2010040F2FA41FAF7C4 +S2140099401DFD35F00F1307D040F20440C0F20100B1 +S21400995040F2FD41FAF712FD636943EA05056561C9 +S21400996038BD00BF38B504460D464FF40043C4F278 +S2140099700203984207D040F20440C0F2010040F2D1 +S2140099801C51FAF7FBFC35F00F1307D040F20440E9 +S214009990C0F2010040F21F51FAF7F0FC636923EAB7 +S2140099A00505656138BD00BF10B504464FF4004399 +S2140099B0C4F20203984207D040F20440C0F201000D +S2140099C04FF4A961FAF7DAFC4FF48033E36110BD77 +S2140099D038B504460D464FF40043C4F202039842DD +S2140099E007D040F20440C0F2010040F26751FAF797 +S2140099F0C5FC012D0CBFE069A06938BD38B504462A +S214009A000D464FF40043C4F20203984207D040F2DA +S214009A100440C0F2010040F29C51FAF7AFFC35F466 +S214009A20702307D040F20440C0F2010040F29E517D +S214009A30FAF7A4FCE56138BDF8B505460C461646AF +S214009A401F464EF22003C4F20F031B6813F4001FD8 +S214009A5007D140F20440C0F2010040F2CA51FAF7C2 +S214009A608DFC4FF40043C4F202039D4207D040F23F +S214009A700440C0F2010040F2CB51FAF77FFC2046CA +S214009A80FFF73CFB38B940F20440C0F2010040F258 +S214009A90CC51FAF773FC4FF6FE739E4207D940F29C +S214009AA00440C0F2010040F2CD51FAF767FC37F0EF +S214009AB00F0307D040F20440C0F2010040F2D2513A +S214009AC0FAF75CFC05F13C031E5105F5006504F150 +S214009AD00044A4F1400445F81470F8BDF8B50746F4 +S214009AE00E4614461D464EF22003C4F20F031B68B2 +S214009AF013F4001F07D140F20440C0F2010040F208 +S214009B000A61FAF73BFC4FF40043C4F202039F429B +S214009B1007D040F20440C0F2010040F20B61FAF7B1 +S214009B202DFC3046FFF7EAFA38B940F20440C0F29E +S214009B30010040F20C61FAF721FC012C07D940F233 +S214009B400440C0F2010040F20D61FAF717FC1CB9A0 +S214009B5035F00F031FD127E040F20440C0F20100A9 +S214009B604FF4C261FAF70AFC012C03D135F0FF036B +S214009B7023D10CE040F20440C0F2010040F215612F +S214009B80FAF7FCFB1CB907F13407BD51F8BD07F125 +S214009B903807BD51F8BD40F20440C0F201004FF452 +S214009BA0C261FAF7EBFBE5E740F20440C0F20100C1 +S214009BB040F21561FAF7E2FBE5E740F20440C0F236 +S214009BC0010040F21561FAF7D9FBE0E770B50446EC +S214009BD00E4615464EF22003C4F20F031B6813F41C +S214009BE0001F07D140F20440C0F201004FF4C961E3 +S214009BF0FAF7C4FB4FF40043C4F202039C4207D0BA +S214009C0040F20440C0F2010040F24961FAF7B6FBA8 +S214009C103046FFF773FA38B940F20440C0F201004C +S214009C2040F24A61FAF7AAFB012D07D940F2044038 +S214009C30C0F2010040F24B61FAF7A0FB1DB904F137 +S214009C403404A05970BD04F13804A05970BD00BF9B +S214009C5070B504460E4615464EF22003C4F20F03B6 +S214009C601B6813F4001F07D140F20440C0F2010045 +S214009C7040F28361FAF782FB4FF40043C4F202031A +S214009C809C4207D040F20440C0F2010040F28461DA +S214009C90FAF774FB3046FFF731FA38B940F2044061 +S214009CA0C0F2010040F28561FAF768FB012D07D982 +S214009CB040F20440C0F2010040F28661FAF75EFB13 +S214009CC055B904F5006404F1040406F10046A6F153 +S214009CD0400654F8160070BD04F5006404F108044C +S214009CE006F10046A6F1400654F8160070BD00BF07 +S214009CF0F8B507460E4614461D464EF22003C4F23B +S214009D000F031B6813F4001F07D140F20440C0F293 +S214009D10010040F2B361FAF731FB4FF40043C4F29E +S214009D2002039F4207D040F20440C0F2010040F216 +S214009D30B461FAF723FB3046FFF7E0F938B940F292 +S214009D400440C0F2010040F2B561FAF717FB012C9F +S214009D5007D940F20440C0F2010040F2B661FAF7BB +S214009D600DFB1CB935F00F032DD135E040F2044051 +S214009D70C0F2010040F2B961FAF700FB012C03D1F2 +S214009D8035F0FF0331D113E040F20440C0F2010089 +S214009D9040F2BE61FAF7F2FA54B907F5006707F128 +S214009DA0040706F10046A6F1400647F81650F8BD2F +S214009DB007F5006707F1080706F10046A6F140061A +S214009DC047F81650F8BD40F20440C0F2010040F2D9 +S214009DD0B961FAF7D3FAD7E740F20440C0F20100BF +S214009DE040F2BE61FAF7CAFAD7E740F20440C0F282 +S214009DF0010040F2BE61FAF7C1FAD9E710B5044691 +S214009E004FF44043C4F202034FF45042C4F202023D +S214009E10821A18BF012298420CBF002302F00103E9 +S214009E203BB140F21840C0F201004FF03C01FAF797 +S214009E30A5FA236843F00103236010BD10B504465D +S214009E404FF44043C4F202034FF45042C4F20202FD +S214009E50821A18BF012298420CBF002302F00103A9 +S214009E603BB140F21840C0F201004FF05501FAF73E +S214009E7085FA236823F00103236010BD70B50446FD +S214009E800D4616464FF44043C4F202034FF45042C8 +S214009E90C4F20202821A18BF012298420CBF0023A5 +S214009EA002F001033BB140F21840C0F201004FF04F +S214009EB08301FAF763FA236823F01E0343EA0505D5 +S214009EC02560E66070BD00BF10B504464FF4404301 +S214009ED0C4F202034FF45042C4F20202821A18BFC0 +S214009EE0012298420CBF002302F001033BB140F26E +S214009EF01840C0F201004FF0A801FAF73FFAA06838 +S214009F0010BD00BF38B504460D464FF44043C4F2BA +S214009F1002034FF45042C4F20202821A18BF012212 +S214009F2098420CBF002302F001033BB140F21840F8 +S214009F30C0F201004FF0C301FAF720FAA56038BD61 +S214009F4010B504464FF44043C4F202034FF45042A7 +S214009F50C4F20202821A18BF012298420CBF0023E4 +S214009F6002F001033BB140F21840C0F201004FF08E +S214009F70DF01FAF703FA606800F0020000280CBF61 +S214009F8001204FF0FF3010BD10B504464FF440439B +S214009F90C4F202034FF45042C4F20202821A18BFFF +S214009FA0012298420CBF002302F001033BB140F2AD +S214009FB01840C0F201004FF0FA01FAF7DFF96068C6 +S214009FC000F0010010BD00BF10B504464FF440433A +S214009FD0C4F202034FF45042C4F20202821A18BFBF +S214009FE0012298420CBF002302F001033BB140F26D +S214009FF01840C0F2010040F21711FAF7BFF92368C3 +S21400A00043F02003236010BD10B504464FF44043D0 +S21400A010C4F202034FF45042C4F20202821A18BF7E +S21400A020012298420CBF002302F001033BB140F22C +S21400A0301840C0F2010040F23111FAF79FF9236888 +S21400A04023F02003236010BD70B504460D46164667 +S21400A0504FF44043C4F202034FF45042C4F20202EB +S21400A060821A18BF012298420CBF002302F0010397 +S21400A0703BB140F21840C0F2010040F25511FAF729 +S21400A0807DF935F4E07307D040F21840C0F20100C5 +S21400A0904FF4AB71FAF772F93EB940F21840C0F2CD +S21400A0A0010040F25711FAF769F9236823F4E073C8 +S21400A0B043EA0505256006F1FF36266170BD00BF40 +S21400A0C010B504464FF44043C4F202034FF4504226 +S21400A0D0C4F20202821A18BF012298420CBF002363 +S21400A0E002F001033BB140F21840C0F201004FF409 +S21400A0F0BD71FAF743F9E06910BD00BF38B50446F4 +S21400A1000D464FF44043C4F202034FF45042C4F2EB +S21400A1100202821A18BF012298420CBF002302F0E6 +S21400A12001033BB140F21840C0F201004FF4CF717A +S21400A130FAF724F94FF44043C4F202039C4214BFDA +S21400A14036241D2420462946FEF7E2FC2046FEF76C +S21400A150BBFD38BD10B504464FF44043C4F20203BD +S21400A1604FF45042C4F20202821A18BF01229842EB +S21400A1700CBF002302F001033BB140F21840C0F2CE +S21400A18001004FF4E471FAF7F9F84FF44043C4F2D3 +S21400A19002039C4214BF36241D242046FEF7E8FD29 +S21400A1A02046FEF7F9FC10BD38B504460D464FF4C0 +S21400A1B04043C4F202034FF45042C4F20202821A31 +S21400A1C018BF012298420CBF002302F001033BB1E6 +S21400A1D040F21840C0F201004FF4F871FAF7CEF8DA +S21400A1E0236A43EA0505256238BD00BF38B5044634 +S21400A1F00D464FF44043C4F202034FF45042C4F2FB +S21400A2000202821A18BF012298420CBF002302F0F5 +S21400A21001033BB140F21840C0F2010040F20E21AB +S21400A220FAF7ACF8236A23EA0505256238BD00BFB5 +S21400A23038B504460D464FF44043C4F202034FF4CB +S21400A2405042C4F20202821A18BF012298420CBF82 +S21400A250002302F001033BB140F21840C0F20100B7 +S21400A2604FF40B71FAF78AF80DB1A06A38BD606A30 +S21400A27038BD00BF38B504460D464FF44043C4F21F +S21400A28002034FF45042C4F20202821A18BF01229F +S21400A29098420CBF002302F001033BB140F2184085 +S21400A2A0C0F2010040F25B21FAF768F8A56238BDFB +S21400A2B02DE9F84306460C4615461F46DDF8208075 +S21400A2C0DDF824904FF40043C4F200034FF410422C +S21400A2D0C4F20002821A18BF012298420CBF002363 +S21400A2E002F001033BB140F22C40C0F201004FF0F7 +S21400A2F06F01FAF743F8AB1E18BF0123002D0CBF01 +S21400A300002303F00103D3B1EB1E18BF0123012D78 +S21400A3100CBF002303F001038BB1B5F1200318BF77 +S21400A3200123102D0CBF002303F001033BB140F2C4 +S21400A3302C40C0F201004FF07501FAF71FF8022F0B +S21400A34007D940F22C40C0F201004FF07801FAF72E +S21400A35015F81FB9B8EB540F09D810E04AF6AB232E +S21400A360CAF6AA23A3FB0423B8EBD30F07D940F2FF +S21400A3702C40C0F201004FF07A01F9F7FFFFB4FB62 +S21400A380F8F4B4F57E4F07D940F22C40C0F2010035 +S21400A3904FF07B01F9F7F2FFA9F104030C2B07D964 +S21400A3A040F22C40C0F201004FF07C01F9F7E6FFC6 +S21400A3B0022F03D04FF000032FB101E04FF0080347 +S21400A3C04FF0040202E04FF000031A461343736096 +S21400A3D04FF0000303F10203B4FBF3F202F1FF3285 +S21400A3E0FF2AF7D833614FEA851303F0FF0305F021 +S21400A3F0300543EA050509F1FF3945EA090949EA46 +S21400A40002223260BDE8F88310B504464FF40043DC +S21400A410C4F200034FF41042C4F20002821A18BFBE +S21400A420012298420CBF002302F001033BB140F228 +S21400A4302C40C0F201004FF0AD01F9F79FFF6368B2 +S21400A44043F00203636010BD10B504464FF40043AA +S21400A450C4F200034FF41042C4F20002821A18BF7E +S21400A460012298420CBF002302F001033BB140F2E8 +S21400A4702C40C0F201004FF0C601F9F77FFF636879 +S21400A48023F00203636010BD38B504460D464FF452 +S21400A4900043C4F200034FF41042C4F20002821AD2 +S21400A4A018BF012298420CBF002302F001033BB103 +S21400A4B040F22C40C0F201004FF0EA01F9F75EFFCF +S21400A4C04FF40043C4F200039C4214BF3224172406 +S21400A4D020462946FEF71CFB2046FEF7F5FB38BD56 +S21400A4E010B504464FF40043C4F200034FF4104284 +S21400A4F0C4F20002821A18BF012298420CBF002341 +S21400A50002F001033BB140F22C40C0F201004FF4D0 +S21400A5108A71F9F733FF4FF40043C4F200039C42FC +S21400A52014BF322417242046FEF722FC2046FEF7EE +S21400A53033FB10BD38B504460D464FF40043C4F255 +S21400A54000034FF41042C4F20002821A18BF012220 +S21400A55098420CBF002302F001033BB140F22C40AE +S21400A560C0F2010040F23B11F9F708FF636943EAC5 +S21400A5700505656138BD00BF38B504460D464FF485 +S21400A5800043C4F200034FF41042C4F20002821AE1 +S21400A59018BF012298420CBF002302F001033BB112 +S21400A5A040F22C40C0F2010040F25711F9F7E6FEE7 +S21400A5B0636923EA0505656138BD00BF38B5044602 +S21400A5C00D464FF40043C4F200034FF41042C4F2A9 +S21400A5D00002821A18BF012298420CBF002302F024 +S21400A5E001033BB140F22C40C0F2010040F275116D +S21400A5F0F9F7C4FE0DB1E06938BDA06938BD00BFEB +S21400A60038B504460D464FF40043C4F200034FF439 +S21400A6101042C4F20002821A18BF012298420CBFF0 +S21400A620002302F001033BB140F22C40C0F20100CF +S21400A6304FF4D271F9F7A2FE256238BD38B504464C +S21400A6400D464FF40043C4F200034FF41042C4F228 +S21400A6500002821A18BF012298420CBF002302F0A3 +S21400A66001033BB140F22C40C0F201004FF4E2710E +S21400A670F9F784FE236803F00F036FF0010202FA75 +S21400A68003F32B4207D040F22C40C0F201004FF4F7 +S21400A690E371F9F773FEE36813F0020FFBD0A560D1 +S21400A6A038BD00BF38B504460D464FF40043C4F22B +S21400A6B000034FF41042C4F20002821A18BF0122AF +S21400A6C098420CBF002302F001033BB140F22C403D +S21400A6D0C0F201004FF4F971F9F750FE236803F059 +S21400A6E00F036FF0010202FA03F32B4207D040F289 +S21400A6F02C40C0F201004FF4FA71F9F73FFEE36810 +S21400A70013F0020F1ABFA5600120002038BD00BF5D +S21400A71038B504460D464FF40043C4F200034FF428 +S21400A7201042C4F20002821A18BF012298420CBFDF +S21400A730002302F001033BB140F22C40C0F20100BE +S21400A74040F21F21F9F71AFEE36813F0040FFBD05E +S21400A750A3682B6038BD00BF38B504460D464FF4DD +S21400A7600043C4F200034FF41042C4F20002821AFF +S21400A77018BF012298420CBF002302F001033BB130 +S21400A78040F22C40C0F2010040F24E21F9F7F6FDEF +S21400A790E36813F0040F1DBFA3682B6001200020A0 +S21400A7A038BD00BF38B504460D464FF40043C4F22A +S21400A7B000034FF41042C4F20002821A18BF0122AE +S21400A7C098420CBF002302F001033BB140F22C403C +S21400A7D0C0F2010040F27921F9F7D0FD636A43EA3E +S21400A7E00505656238BD00BF38B504460D464FF412 +S21400A7F00043C4F200034FF41042C4F20002821A6F +S21400A80018BF012298420CBF002302F001033BB19F +S21400A81040F22C40C0F201004FF42671F9F7AEFD6D +S21400A820636A23EA0505656238BD00BF10B50446B5 +S21400A8304FF40043C4F200034FF41042C4F2000287 +S21400A840821A18BF012298420CBF002302F00103AF +S21400A8503BB140F22C40C0F2010040F2B521F9F7BE +S21400A8608DFDE068C0F3001010BD00BFA0F580139A +S21400A87003F1FF334FF48072C0F21002904214BF0F +S21400A88000220122012B8CBF134642F00103002B4D +S21400A89040F07E814FF40073C0F210034FF48062E4 +S21400A8A0C0F21002904214BF00220122984214BF48 +S21400A8B0134642F00103002B40F06D814FF4807385 +S21400A8C0C1F210034FF40072C1F21002904214BF9E +S21400A8D000220122984214BF134642F00103002BC7 +S21400A8E040F05C814FF48063C1F210034FF4804265 +S21400A8F0C1F21002904214BF00220122984214BFF7 +S21400A900134642F00103002B40F04B814FF4A04366 +S21400A910C2F210034FF00102C2F20002904214BFCE +S21400A92000220122984214BF134642F00103002B76 +S21400A93040F03A814FF00203C2F200034FF00402E7 +S21400A940C2F20002904214BF00220122984214BFB5 +S21400A950134642F00103002B40F029814FF0080314 +S21400A960C2F200034FF01002C2F20002904214BF7F +S21400A97000220122984214BF134642F00103002B26 +S21400A98040F018814FF02003C2F200034FF040025F +S21400A990C2F20002904214BF00220122984214BF65 +S21400A9A0134642F00103002B40F007814FF080036E +S21400A9B0C2F200034FF48072C2F20002904214BF4B +S21400A9C000220122984214BF134642F00103002BD6 +S21400A9D040F0F6804FF48053C1F20003984214BF53 +S21400A9E000230123402808BF43F00103002B40F05A +S21400A9F0EA804FF48043C1F200034FF48052C1F264 +S21400AA001002904214BF00220122984214BF13463F +S21400AA1042F00103002B40F0D9804FF48073C2F25D +S21400AA2010034FF08002C3F20002904214BF0022CF +S21400AA300122984214BF134642F00103002B40F057 +S21400AA40C8804FF01003C3F20003B0F1101F14BF0C +S21400AA5000220122984214BF134642F00103002B45 +S21400AA6040F0BA804FF48073C1F200034FF40072D6 +S21400AA70C1F20002904214BF00220122984214BF85 +S21400AA80134642F00103002B40F0A9804FF010035C +S21400AA90C1F200034FF02002C1F20002904214BF40 +S21400AAA000220122984214BF134642F00103002BF5 +S21400AAB040F0988003F12003C3F200034FF0010238 +S21400AAC0C1F21002904214BF00220122984214BF25 +S21400AAD0134642F00103002B40F0878003F1020387 +S21400AAE0C1F210034FF00402C1F21002904214BFEC +S21400AAF000220122984214BF134642F00103002BA5 +S21400AB0076D103F10803C1F210034FF00102C1F23F +S21400AB100002904214BF00220122984214BF13463E +S21400AB2042F00103002B66D103F10203C1F20003D9 +S21400AB304FF00402C1F20002904214BF002201222C +S21400AB40984214BF134642F00103002B56D14FF42F +S21400AB500053C2F200034FF00102C2F2100290420C +S21400AB6014BF00220122984214BF134642F001038C +S21400AB70002B46D14FF48053C0F21003984214BF06 +S21400AB8000230123082814BF184643F0010070472D +S21400AB904FF0010070474FF0010070474FF0010082 +S21400ABA070474FF0010070474FF0010070474FF0BC +S21400ABB0010070474FF0010070474FF001007047EA +S21400ABC04FF0010070474FF0010070474FF0010052 +S21400ABD070474FF0010070474FF0010070474FF08C +S21400ABE0010070474FF0010070474FF001007047BA +S21400ABF04FF0010070474FF0010070474FF0010022 +S21400AC0070474FF0010070474EF20803C4F20F037E +S21400AC1018684FEA10404FEA002000F58070704731 +S21400AC204EF20803C4F20F03186880B24FEAC02041 +S21400AC3000F50060704700BF10B5044600F1FF3213 +S21400AC40031F18BF0123012A94BF002303F001034A +S21400AC50002B00F0AB80B0F1100318BF01230828CA +S21400AC600CBF002303F00103002B00F09F80B0F11F +S21400AC70400318BF012320280CBF002303F0010364 +S21400AC80002B00F09380B0F5807318BF0123802856 +S21400AC900CBF002303F00103002B00F08780B0F503 +S21400ACA0806318BF0123B0F5007F0CBF002303F0BC +S21400ACB00103002B7AD0B0F5805318BF0123B0F5FE +S21400ACC0006F0CBF002303F00103002B6ED0B0F51D +S21400ACD0804318BF0123B0F5005F0CBF002303F0CC +S21400ACE00103002B62D0B0F5803318BF0123B0F506 +S21400ACF0004F0CBF002303F00103002B56D0B0F525 +S21400AD00802318BF0123B0F5003F0CBF002303F0DB +S21400AD100103002B4AD0B0F5801318BF0123B0F50D +S21400AD20002F0CBF002303F00103002B3ED0B0F52C +S21400AD30800318BF0123B0F5001F0CBF002303F0EB +S21400AD4001039BB3B0F1807318BF0123B0F5000F69 +S21400AD500CBF002303F0010343B3B0F1806318BFB8 +S21400AD600123B0F1007F0CBF002303F00103EBB119 +S21400AD70B0F1805318BF0123B0F1006F0CBF002361 +S21400AD8003F0010393B1B0F1004318BF0123B0F103 +S21400AD90005F0CBF002303F001033BB140F2AC4060 +S21400ADA0C0F2010040F24111F9F7E8FA4EF218033A +S21400ADB0C4F20F031B681C420CBF0020012010BD0C +S21400ADC010B50446FFF752FD38B940F2AC40C0F269 +S21400ADD0010040F27511F9F7D1FA4FF00103C2F203 +S21400ADE010039C4209D14EF22403C4F20F031868E4 +S21400ADF010F0030018BF012010BD40F24043C0F21F +S21400AE0001034FEA147253F822301B68A2B2C4F34F +S21400AE10044402FA04F41C420CBF0020012010BDBA +S21400AE2010B582B00446FFF721FD38B940F2AC40B9 +S21400AE30C0F2010040F2B911F9F7A0FA40F2DC4383 +S21400AE40C0F201034FEA147253F822201368A1B22D +S21400AE50C4F3044401FA04F444EA030313604FF015 +S21400AE6000030193019B0F2B06D8019B03F10103FE +S21400AE700193019B0F2BF8D9136823EA040414608E +S21400AE8002B010BD10B50446FFF7F0FC38B940F22A +S21400AE90AC40C0F201004FF4FC71F9F76FFA40F2D3 +S21400AEA0C443C0F201034FEA147253F822301A6802 +S21400AEB0A1B2C4F3044401FA04F414431C6010BDA8 +S21400AEC010B50446FFF7D2FC38B940F2AC40C0F2E9 +S21400AED0010040F22321F9F751FA40F2C443C0F2D0 +S21400AEE001034FEA147253F822301A68A1B2C4F371 +S21400AEF0044401FA04F422EA04041C6010BD00BFF6 +S21400AF0010B50446FFF7B2FC38B940F2AC40C0F2C8 +S21400AF10010040F25521F9F731FA40F2D043C0F271 +S21400AF2001034FEA147253F822301A68A1B2C4F330 +S21400AF30044401FA04F414431C6010BD10B5044622 +S21400AF40FFF794FC38B940F2AC40C0F201004FF471 +S21400AF502271F9F713FA40F2D043C0F201034FEA28 +S21400AF60147253F822301A68A1B2C4F3044401FAEA +S21400AF7004F422EA04041C6010BD00BF10B50446A9 +S21400AF80FFF774FC38B940F2AC40C0F201004FF451 +S21400AF902F71F9F7F3F940F2E843C0F201034FEAE4 +S21400AFA0147253F822301A68A1B2C4F3044401FAAA +S21400AFB004F414431C6010BD10B50446FFF756FC9D +S21400AFC038B940F2AC40C0F2010040F2F221F9F785 +S21400AFD0D5F940F2E843C0F201034FEA147253F881 +S21400AFE022301A68A1B2C4F3044401FA04F422EA37 +S21400AFF004041C6010BD00BF40B14EF26003C4F2F2 +S21400B0000F031A6842F000621A6070474EF260033F +S21400B010C4F20F031A6822F000621A60704700BF7D +S21400B02008B501464FF02C00FDF772FD4FF02C00DE +S21400B030FDF74AFE08BD00BF08B54FF02C00FDF72F +S21400B04097FE4FF02C00FDF7A7FD08BD4EF2540307 +S21400B050C4F20F031A6840EA02021A60704700BF83 +S21400B0604EF25403C4F20F031A6822EA00021A6072 +S21400B070704700BF4EF25803C4F20F0318607047C3 +S21400B08028B14EF25803C4F20F03186870474EF208 +S21400B0905003C4F20F031868704700BF10B504468B +S21400B0A0B0F11F0318BF0123052894BF002303F047 +S21400B0B00103DBB1B0F11D0318BF01231E280CBF2E +S21400B0C0002303F001038BB1B0F11B0318BF01236B +S21400B0D01C280CBF002303F001033BB140F2AC4038 +S21400B0E0C0F201004FF47D71F9F748F94EF23403CF +S21400B0F0C4F20F031C6010BD4EF23403C4F20F03FB +S21400B1001868704710B50446012807D940F2AC40CD +S21400B110C0F2010040F22941F9F730F94EF260130F +S21400B120C4F20F031C6010BD4EF60C53CEF20003A3 +S21400B1304FF00402C0F2FA521A60FEE708B5FAF7BA +S21400B140DFF908BD10B54EF61054CEF200042368A1 +S21400B15043F004032360FAF7D3F9236823F00403CB +S21400B160236010BD4EF25C03C4F20F0318687047EC +S21400B1704EF25C03C4F20F031A6822EA00021A6059 +S21400B180704700BF38B504460D4630F0030307D0BD +S21400B19040F2AC40C0F2010040F2D341F9F7EEF8BD +S21400B1A0B5F5005F07D340F2AC40C0F2010040F2B4 +S21400B1B0D441F9F7E3F844EA85044EF23003C4F2CA +S21400B1C00F031C6038BD00BF0138FDD1704700BFBB +S21400B1D0F8B504464FF46043C4F20F031B6813F03F +S21400B1E0E04F0DD04FF46043C4F20F031A684FF0DF +S21400B1F00003C7F2FF0302EA0303B3F1805F02D144 +S21400B200002CC0F2C5804EF26002C4F20F02116834 +S21400B2104EF27003C4F20F031E6841F4006121F47D +S21400B220800546F4006615601E6011F0020F02D01D +S21400B23014F0020F05D015F0010F26D014F0010F00 +S21400B24023D164F003031D404EF26003C4F20F03E3 +S21400B2501D60002E0CDA06F07003702B14BF00225F +S21400B2600122302B14BF134642F0010323B908E035 +S21400B27005F03003302B04D14FF48050FFF7A4FFC5 +S21400B28003E04FF40020FFF79FFF25F45E5727F0FA +S21400B290700743F2F07304EA03031F434DF68F73FF +S21400B2A0C7F6FF7306EA030342F23005C8F200054C +S21400B2B004EA05051D4304F008034EF25802C4F2E2 +S21400B2C00F024FF04001116055EAC3050AD54EF251 +S21400B2D07003C4F20F031D604EF26003C4F20F0346 +S21400B2E01F6009E04EF26003C4F20F031F604EF2C7 +S21400B2F07003C4F20F031D604FF01000FFF764FFE9 +S21400B30027F0F86727F003074FF00303C0F2C07377 +S21400B31004EA03031F4325F0FC5504F0FC531D43C9 +S21400B32014F0804F1FBF47F4800725F480000023E9 +S21400B330C4F240031ABF2340184325F0804014F49B +S21400B340006F17D14EF25003C4F20F031B6813F0C0 +S21400B350400F0BD147F6FF734EF25001C4F20F01B7 +S21400B3600A6812F0400F01D1013BF9D127F40067BB +S21400B37020F400604EF26003C4F20F031F604EF22A +S21400B3807003C4F20F0318604FF01000FFF71CFFA5 +S21400B390F8BD00BF30B44EF26003C4F20F031B6862 +S21400B3A04EF27002C4F20F021268002AB4BF02F016 +S21400B3B0700103F03001202900F0858004D881B1A7 +S21400B3C0102940F0548115E0602900F0E5807029CE +S21400B3D000F0DF80302908BF47F2305040F0478148 +S21400B3E0DCE040F25041C0F20101C3F3841051F892 +S21400B3F02000D3E04FF46041C4F20F01096811F059 +S21400B400E04F04BF4EF2C010C0F2E40000F0C68069 +S21400B4104FF46041C4F20F0108684FF00001C7F214 +S21400B420FF0100EA0101B1F1805F04BF4EF2C010D7 +S21400B430C0F2E40000F0B2804FF46041C4F20F01A5 +S21400B44008684FF00001C7F2FF0100EA01014FF063 +S21400B4500000C1F2010081420DD14FF46041C4F2F8 +S21400B4600F01096889B2022904BF4FF4D850C0F210 +S21400B470B70000F093804FF46041C4F20F010868F3 +S21400B4804FF00001C7F2FF0100EA01014FF0000093 +S21400B490C1F2030081421CBF4FF41050C0F2F4000A +S21400B4A07CD14FF46041C4F20F010C68A4B24FF493 +S21400B4B0D850C0F2B7004FF41051C0F2F401002C7F +S21400B4C018BF08466AE04FF46041C4F20F010968ED +S21400B4D011F0E04F04BF43F67000C0F239005DD0B3 +S21400B4E04FF46041C4F20F0108684FF00001C7F244 +S21400B4F0FF0100EA0101B1F1805F04BF43F670006E +S21400B500C0F239004AD04FF46041C4F20F01086817 +S21400B5104FF00001C7F2FF0100EA01014FF0000002 +S21400B520C1F2010081420CD14FF46041C4F20F0118 +S21400B530096889B2022904BF4CF2C060C0F22D002F +S21400B5402CD04FF46041C4F20F0108684FF00001A0 +S21400B550C7F2FF0100EA01014FF00000C1F203004C +S21400B56081421CBF4FF41060C0F23D0016D14FF46C +S21400B5706041C4F20F010C68A4B24CF2C060C0F285 +S21400B5802D004FF41061C0F23D01002C18BF084694 +S21400B59004E04FF4004001E04FF48000002A03DA94 +S21400B5A012F4006F03D040E013F4006F3DD14EF26A +S21400B5B06401C4F20F0109684FF46044C4F20F043A +S21400B5C0246814F0E04F0DD04FF46044C4F20F042A +S21400B5D025684FF00004C7F2FF0405EA0404B4F13E +S21400B5E0805F0CD1C1F3481404F1020404FB00F0A0 +S21400B5F001F01F0404F10204B0FBF4F00BE0C1F309 +S21400B600481404FB00F001F01F0404F101044FEAA3 +S21400B6104404B0FBF4F011F4804F18BF400811F456 +S21400B620004F18BF800843F4800313F4800F20D027 +S21400B630002A15DA12F0804F0BD012F4006F08D1F2 +S21400B6404FEA4000C2F3865202F10102B0FBF2F06C +S21400B6500FE0C2F3C55202F10102B0FBF2F008E0BF +S21400B660C3F3C35303F10103B0FBF3F001E04FF063 +S21400B670000030BC704700BF10B50446B0F580131C +S21400B68018BF012300280CBF002303F0010303B3F7 +S21400B690B0F5A01318BF0123B0F5901F0CBF002310 +S21400B6A003F00103ABB1B0F5C01318BF0123B0F52A +S21400B6B0B01F0CBF002303F0010353B1B0F5D01F39 +S21400B6C007D040F2AC40C0F2010040F22E71F8F70D +S21400B6D055FE4EF21003C4F20F031B6813F4801FCE +S21400B6E007D140F2AC40C0F2010040F23371F8F7E7 +S21400B6F045FE4EF26003C4F20F031A6822F4F012FD +S21400B70014431C6010BD00BF08B54EF21003C4F20F +S21400B7100F031B6813F4801F07D140F2AC40C0F241 +S21400B72001004FF4EA61F8F729FE4EF26003C4F216 +S21400B7300F031B6813F4801F1FBF4EF26003C4F292 +S21400B7400F03186800F4F01008BF002008BD00BF03 +S21400B75010B50446B0F5206318BF0123B0F5706F2E +S21400B7600CBF002303F001038BB1031E18BF012397 +S21400B770B0F5A06F0CBF002303F001033BB140F20D +S21400B780AC40C0F201004FF4F061F8F7F7FD4EF25E +S21400B7901003C4F20F031B6813F4803F07D140F276 +S21400B7A0AC40C0F2010040F28571F8F7E7FD4FF4B7 +S21400B7B06143C4F20F031A6822F4706244EA02027C +S21400B7C01A604EF21013C4F20F031A6822F4706265 +S21400B7D014431C6010BD00BF08B54EF21003C4F23F +S21400B7E00F031B6813F4803F07D140F2AC40C0F251 +S21400B7F0010040F2A171F8F7C1FD4FF46143C4F2B5 +S21400B8000F03186800F4706008BD00BF40B14EF228 +S21400B8106003C4F20F031A6842F008021A60704709 +S21400B8204EF26003C4F20F031A6822F008021A6090 +S21400B830704700BF40B14EF26003C4F20F031A68AF +S21400B84042F004021A6070474EF26003C4F20F031F +S21400B8501A6822F004021A60704700BF40B14EF228 +S21400B8606003C4F20F031A6842F480621A607047DD +S21400B8704EF26003C4F20F031A6822F480621A6064 +S21400B880704700BF4EF25013C4F20F034FF0010290 +S21400B8901A604FF000021A60704700BF10B50446E9 +S21400B8A000F1604303F1FF334FF00402C2F20002DE +S21400B8B0821A18BF0122012B94BF002302F0010355 +S21400B8C0002B3AD04FF00803C2F200034FF01002EC +S21400B8D0C2F20002821A18BF012298420CBF00234F +S21400B8E002F001034BB34FF02003C2F200034FF007 +S21400B8F04002C2F20002821A18BF012298420CBF10 +S21400B900002302F00103C3B14FF08003C2F200032C +S21400B9104FF48072C2F20002821A18BF01229842C7 +S21400B9200CBF002302F001033BB140F2AC40C0F272 +S21400B930010040F65601F8F721FD4EF26C03C4F202 +S21400B9400F031A68A4B214431C6010BD10B5044659 +S21400B95000F1604303F1FF334FF00402C2F200022D +S21400B960821A18BF0122012B94BF002302F00103A4 +S21400B970002B3AD04FF00803C2F200034FF010023B +S21400B980C2F20002821A18BF012298420CBF00239E +S21400B99002F001034BB34FF02003C2F200034FF056 +S21400B9A04002C2F20002821A18BF012298420CBF5F +S21400B9B0002302F00103C3B14FF08003C2F200037C +S21400B9C04FF48072C2F20002821A18BF0122984217 +S21400B9D00CBF002302F001033BB140F2AC40C0F2C2 +S21400B9E0010040F67E01F8F7C9FC4EF26C03C4F283 +S21400B9F00F031A68A4B222EA04041C6010BD00BF3C +S21400BA004EF27003C4F20F031A6822F480421A60E2 +S21400BA10704700BF4EF27003C4F20F031A6842F478 +S21400BA2080421A60704700BF38B505460C4639B9E3 +S21400BA304EF27013C4F20F034FF000021A6082E059 +S21400BA4018BB4EF26403C4F20F031B684EF260028A +S21400BA50C4F20F02106840F25042C0F20102C0F376 +S21400BA608410C3F3481152F8205005FB01F503F08B +S21400BA701F0202F10102B5FBF2F513F4804F18BF66 +S21400BA806D0813F4004F18BFAD08A54207D840F262 +S21400BA90AC40C0F2010040F60311F8F76FFC4FEA25 +S21400BAA0541101F1FF335D19B5FBF4F34FF4604216 +S21400BAB0C4F20F0210684FF00002C7F2FF0200EA5D +S21400BAC002024FF00000C1F2040082420ED14FF491 +S21400BAD06042C4F20F02106880B240F20112904237 +S21400BAE004D1FF2B84BF0F24FF230BD8B3F5806F40 +S21400BAF03DBF04FB13521201B2FBF4F40F2428BF1F +S21400BB0040F2FF3344F0004040F4004040EA035067 +S21400BB1040EA04404FEA031318434EF27012C4F290 +S21400BB200F021060C1F101014D191B19B5FBF3F2AC +S21400BB304FEA02124FEA121403FB14554FEA05159A +S21400BB40B5FBF3F39C18204638BD00BF4EF2100339 +S21400BB50CEF200031A6842F005021A60704700BF72 +S21400BB604EF21003CEF200031A6822F001021A60A9 +S21400BB70704700BF08B501464FF00F00FCF7C8FF3E +S21400BB804EF21003CEF200031A6842F002021A6068 +S21400BB9008BD00BF08B54EF21003CEF200031A68C7 +S21400BBA022F002021A604FF00F00FCF7F5FF08BD06 +S21400BBB04EF21003CEF200031A6842F002021A6038 +S21400BBC0704700BF4EF21003CEF200031A6822F050 +S21400BBD002021A60704700BF10B500F1FF34B4F1DE +S21400BBE0807F07D340F2F440C0F201004FF0D0014E +S21400BBF0F8F7C4FB4EF21403CEF200031C6010BD2F +S21400BC004EF21403CEF20003186800F101007047EC +S21400BC104EF21803CEF20003186870474FF0000388 +S21400BC20C4F203034FF48052C4F20302904214BFDE +S21400BC3000220122984214BF134642F001038BB93A +S21400BC404FF40053C4F203034FF44052C4F203020D +S21400BC50904214BF00220122984214BF104642F0C0 +S21400BC60010070474FF00100704700BF38B5054629 +S21400BC700C46FFF7D3FF38B940F20C50C0F2010073 +S21400BC804FF05201F8F77AFBB4F57F4318BF012353 +S21400BC90FF2C0CBF002303F001035BB14FF6FF73CC +S21400BCA09C4207D040F20C50C0F201004FF0540105 +S21400BCB0F8F764FBEA6840F2011304EA030342EA79 +S21400BCC00303EB6038BD00BF38B505460C46FFF7EA +S21400BCD0A5FF38B940F20C50C0F201004FF06F01DA +S21400BCE0F8F74CFBB4F57F4318BF0123FF2C0CBFBD +S21400BCF0002303F001035BB14FF6FF739C4207D0AD +S21400BD0040F20C50C0F201004FF07101F8F736FB1C +S21400BD10EA6840F2011304EA030322EA0303EB6035 +S21400BD2038BD00BF38B505460C46FFF777FF38B973 +S21400BD3040F20C50C0F201004FF0AB01F8F71EFBCA +S21400BD40B4F1110318BF0123012C0CBF002303F02C +S21400BD500103D3B1B4F1120318BF0123022C0CBFA8 +S21400BD60002303F0010383B1B4F1807F4CD004F0CC +S21400BD707F43B3F1806F0DD040F20C50C0F201004B +S21400BD804FF0B101F8F7FAFA3EE004F07F43B3F162 +S21400BD90806F39D104F0FF03B3F1110218BF0122FE +S21400BDA0012B0CBF002202F001024AB1022B07D081 +S21400BDB0122B05D0032B03D0072B01D00A2B1BD147 +S21400BDC004F47F43B3F5885218BF0122B3F5807F91 +S21400BDD00CBF002202F00102B2B1B3F5007F13D00F +S21400BDE0B3F5905F10D0B3F5407F0DD0B3F5E06F9C +S21400BDF00AD0B3F5206F07D040F20C50C0F2010015 +S21400BE004FF0C001F8F7BAFAEB6823F4807323F01A +S21400BE100103EB604FEA14632B6004F0FF036B60D2 +S21400BE20C4F30724AC6038BD70B505460C4616460C +S21400BE30FFF7F4FE38B940F20C50C0F201004FF0A4 +S21400BE40EB01F8F79BFAB4F57F4318BF0123FF2CEC +S21400BE500CBF002303F001035BB14FF6FF739C4257 +S21400BE6007D040F20C50C0F201004FF0ED01F8F799 +S21400BE7085FA44F2400304EA03032EB105F10C02EE +S21400BE80E96841EA030304E005F10C02E96821EAE7 +S21400BE900303136070BD00BF70B505460C4616461A +S21400BEA0FFF7BCFE38B940F20C50C0F2010040F279 +S21400BEB00F11F8F763FAB4F57F4318BF0123FF2C80 +S21400BEC00CBF002303F001035BB14FF6FF739C42E7 +S21400BED007D040F20C50C0F2010040F21111F8F702 +S21400BEE04DFA42F2200304EA03032EB105F10C02D8 +S21400BEF0E96841EA030304E005F10C02E96821EA77 +S21400BF000303136070BD00BF70B505460C461646A9 +S21400BF10FFF784FE38B940F20C50C0F201004FF42F +S21400BF209A71F8F72BFAB4F57F4318BF0123FF2C5C +S21400BF300CBF002303F001035BB14FF6FF739C4276 +S21400BF4007D040F20C50C0F201004FF49B71F8F796 +S21400BF5015FAEA6822F4406222F00C0240F60C431E +S21400BF6004EA030303EA060642EA0603EB6070BD32 +S21400BF7070B505460C461646FFF750FE38B940F237 +S21400BF800C50C0F2010040F25911F8F7F7F9B4F579 +S21400BF907F4318BF0123FF2C0CBF002303F00103CF +S21400BFA05BB14FF6FF739C4207D040F20C50C0F2D4 +S21400BFB0010040F25B11F8F7E1F940F2022304EACF +S21400BFC003032EB105F10C02E96841EA030304E01D +S21400BFD005F10C02E96821EA0303136070BD00BF97 +S21400BFE070B505460C461646FFF718FE38B940F2FF +S21400BFF00C50C0F201004FF4C071F8F7BFF9B4F569 +S21400C0007F4318BF0123FF2C0CBF002303F001035E +S21400C0105BB14FF6FF739C420AD040F20C50C0F260 +S21400C02001004FF4C171F8F7A9F914F0FF0F09D019 +S21400C03026B16B6843F040036B6003E06B6823F047 +S21400C04040036B6014F47F4F09D026B1AB6843F011 +S21400C0504003AB6070BDAB6823F04003AB6070BDBF +S21400C06010B50446FFF7DAFD38B940F20C50C0F2BE +S21400C070010040F2B511F8F781F9E36843F01003C8 +S21400C080E36010BD10B50446FFF7C8FD38B940F2AE +S21400C0900C50C0F201004FF4E771F8F76FF9E3684F +S21400C0A023F01003E36010BD70B506460C46154637 +S21400C0B0FFF7B4FD38B940F20C50C0F201004FF45F +S21400C0C0F771F8F75BF9B4F57F4318BF0123FF2C2F +S21400C0D00CBF002303F001035BB14FF6FF739C42D5 +S21400C0E007D040F20C50C0F201004FF4F871F8F798 +S21400C0F045F9FF2D07D940F20C50C0F2010040F27E +S21400C100F111F8F73BF914F0FF0F18BFB56314F4FC +S21400C1107F4F18BFF56370BD38B505460C46FFF770 +S21400C1207DFD38B940F20C50C0F2010040F21921F2 +S21400C130F8F724F9B4F57F4318BF0123FF2C0CBF92 +S21400C140002303F001035BB14FF6FF739C420BD054 +S21400C15040F20C50C0F2010040F21B21F8F70EF935 +S21400C160FF2C01D1A86B38BDE86B38BD70B506460C +S21400C1700C461546FFF752FD38B940F20C50C0F297 +S21400C180010040F23E21F8F7F9F8B4F57F4318BFF6 +S21400C1900123FF2C0CBF002303F001035BB14FF615 +S21400C1A0FF739C4207D040F20C50C0F201004FF4DF +S21400C1B01071F8F7E3F8FF2D07D940F20C50C0F2E3 +S21400C1C0010040F24121F8F7D9F814F0FF0F18BF2C +S21400C1D0356414F47F4F18BF756470BD38B50546D6 +S21400C1E00C46FFF71BFD38B940F20C50C0F20100B8 +S21400C1F040F26B21F8F7C2F8B4F57F4318BF01236D +S21400C200FF2C0CBF002303F001035BB14FF6FF7356 +S21400C2109C420BD040F20C50C0F2010040F26D215F +S21400C220F8F7ACF8FF2C01D1286C38BD686C38BD27 +S21400C23070B506460C461546FFF7F0FC38B940F2D6 +S21400C2400C50C0F2010040F28D21F8F797F8B4F5D3 +S21400C2507F4318BF0123FF2C0CBF002303F001030C +S21400C2605BB14FF6FF739C420AD040F20C50C0F20E +S21400C270010040F28F21F8F781F814F0FF0F00D08C +S21400C280B56214F47F4F18BFF56270BD38B5054629 +S21400C2900C46FFF7C3FC38B940F20C50C0F2010060 +S21400C2A040F2B721F8F76AF8B4F57F4318BF0123C8 +S21400C2B0FF2C0CBF002303F001033BB140F20C50EF +S21400C2C0C0F201004FF42E71F8F758F8FF2C0CBF9F +S21400C2D0A86AE86A38BD00BF38B505460C46FFF7C1 +S21400C2E09DFC38B940F20C50C0F2010040F2D52156 +S21400C2F0F8F744F8B4F57F4318BF0123FF2C0CBFB2 +S21400C300002303F001033BB140F20C50C0F20100E1 +S21400C31040F2D621F8F732F8FF2C0CBFA86CE86C78 +S21400C32038BD00BF70B506460C461546FFF776FCCE +S21400C33038B940F20C50C0F2010040F2F721F8F78D +S21400C3401DF8B4F57F4318BF0123FF2C0CBF002354 +S21400C35003F001035BB14FF6FF739C420AD040F234 +S21400C3600C50C0F2010040F2F921F8F707F814F07B +S21400C370FF0F00D0356314F47F4F18BF756370BD90 +S21400C38038B505460C46FFF749FC38B940F20C5064 +S21400C390C0F201004FF44871F7F7F0FFB4F57F43A1 +S21400C3A018BF0123FF2C0CBF002303F001033BB191 +S21400C3B040F20C50C0F2010040F22131F7F7DEFFE8 +S21400C3C0FF2C0CBF286B686B38BD00BF70B50546E8 +S21400C3D00C461646FFF722FC38B940F20C50C0F265 +S21400C3E0010040F24631F7F7C9FFB4F57F4318BFA6 +S21400C3F00123FF2C0CBF002303F001035BB14FF6B3 +S21400C400FF739C4207D040F20C50C0F201004FF47C +S21400C4105271F7F7B3FF4FF00003C4F203039D42D7 +S21400C42008BF23250FD04FF48053C4F203039D4268 +S21400C43008BF252507D04FF40053C4F203039D42DE +S21400C44014BF3325272514F0FF0F06D028463146A3 +S21400C450FCF75EFB2846FCF737FC14F47F4F08D049 +S21400C46005F1010528463146FCF752FB2846FCF745 +S21400C4702BFC70BD38B505460C46FFF7CFFB38B928 +S21400C48040F20C50C0F2010040F28A31F7F776FF16 +S21400C490B4F57F4318BF0123FF2C0CBF002303F025 +S21400C4A001035BB14FF6FF739C4207D040F20C507D +S21400C4B0C0F201004FF46371F7F760FF4FF000031E +S21400C4C0C4F203039D4208BF23250FD04FF48053C8 +S21400C4D0C4F203039D4208BF252507D04FF400533E +S21400C4E0C4F203039D4214BF3325272514F0FF0F23 +S21400C4F005D02846FCF73CFC2846FCF74DFB14F418 +S21400C5007F4F07D005F101052846FCF731FC284689 +S21400C510FCF742FB38BD00BF38B504460D46FFF7B2 +S21400C5207DFB38B940F20C50C0F2010040F2D53124 +S21400C530F7F724FFA36943EA0505A56138BD00BFE8 +S21400C54038B504460D46FFF769FB38B940F20C5083 +S21400C550C0F201004FF47D71F7F710FFA36923EADC +S21400C5600505A56138BD00BF38B504460D46FFF782 +S21400C57055FB38B940F20C50C0F2010040F21241AF +S21400C580F7F7FCFE0DB1206A38BDE06938BD00BF84 +S21400C59038B504460D46FFF741FB38B940F20C505B +S21400C5A0C0F2010040F23C41F7F7E8FE656238BD94 +S21400C5B070B50446FFF732FB38B940F20C50C0F2B3 +S21400C5C001004FF48B61F7F7D9FE4FF00005E560E8 +S21400C5D0A5614FF0FF36666220464FF6FF71FFF703 +S21400C5E049FF25606560A560E5612562A6624FF695 +S21400C5F0FF73E36226636363A563E563256465648E +S21400C600A664E36470BD00BF4FF44043C4F2000369 +S21400C6104FF45042C4F20002904214BF002201229E +S21400C620984214BF134642F0010343B94FF46043E7 +S21400C630C4F20003984214BF0020012070474FF058 +S21400C6400100704738B505460C46FFF7DDFF38B9E0 +S21400C65040F22450C0F201004FF06001F7F78EFE62 +S21400C660A31F18BF0123002C0CBF002303F00103F7 +S21400C6709BB1B4F1820318BF0123022C0CBF002328 +S21400C68003F001034BB1862C07D040F22450C0F2D1 +S21400C69001004FF06501F7F771FEEB6A23F08603A1 +S21400C6A043EA0404EC6238BD10B50446FFF7ACFF5D +S21400C6B038B940F22450C0F201004FF08301F7F77A +S21400C6C05DFEE06A00F0860010BD00BF70B506464D +S21400C6D00D461446FFF798FF38B940F22450C0F2D2 +S21400C6E001004FF0A501F7F749FE042D07D940F2E7 +S21400C6F02450C0F201004FF0AA01F7F73FFEB4F154 +S21400C700080318BF0123002C0CBF002303F001030D +S21400C7109BB1B4F1180318BF0123102C0CBF0023E3 +S21400C72003F001034BB1202C07D040F22450C0F296 +S21400C73001004FF0AF01F7F721FE2C43746370BD84 +S21400C74070B505460C461646FFF75EFF38B940F250 +S21400C7502450C0F201004FF0D201F7F70FFE6B6BCA +S21400C76003F00702226003F03803336070BD00BF99 +S21400C770F8B504460E4615461F46FFF745FF38B97E +S21400C78040F22450C0F2010040F26F11F7F7F6FDB8 +S21400C790636AA26A4FEA86064FEA83139B18B6FBC3 +S21400C7A0F3F62E60236B13F0200F1CBF76002E606E +S21400C7B0E36A03F0EE033B60F8BD00BF10B5044625 +S21400C7C0FFF722FF38B940F22450C0F201004FF4C0 +S21400C7D0CF71F7F7D3FDE36A43F01003E362236BF0 +S21400C7E043F4407343F00103236310BD10B50446C1 +S21400C7F0FFF70AFF38B940F22450C0F201004FF4A8 +S21400C800DF71F7F7BBFDA36913F0080FFBD1E36AEE +S21400C81023F01003E362236B23F4407323F0010339 +S21400C820236310BDF8B504460E4615461F46FFF7AF +S21400C830EBFE38B940F22450C0F2010040F20D1170 +S21400C840F7F79CFD3DB940F22450C0F201004FF4CA +S21400C8508771F7F793FD4FF46043C4F20F031B682C +S21400C86013F0E04F08BF102347D04FF46043C4F2E4 +S21400C8700F031A684FF00003C7F2FF0302EA030330 +S21400C880B3F1805F08BF102337D04FF46043C4F283 +S21400C8900F031A684FF00003C7F2FF0302EA030310 +S21400C8A04FF00002C1F20102934209D14FF46043F7 +S21400C8B0C4F20F031B689BB2022B08BF10231CD0C8 +S21400C8C04FF46043C4F20F031A684FF00003C7F238 +S21400C8D0FF0302EA03034FF00002C1F20302934291 +S21400C8E018BF082309D14FF46043C4F20F031B6836 +S21400C8F09BB2002B0CBF1023082305FB03F3B342A7 +S21400C90007D940F22450C0F2010040F20F11F7F7A9 +S21400C91035FD2046FFF76AFFB6EB051F236B3DBFCC +S21400C92043F0200323636D0823F0200328BF23630E +S21400C9304FEAC606B6FBF5F505F101054FEAD51335 +S21400C9406362C5F34505A562E7624FF00003A36185 +S21400C9502046FFF733FFF8BD10B50446FFF754FE38 +S21400C96038B940F22450C0F201004FF4F271F7F7E4 +S21400C97005FDE36A43F01003E36210BD10B50446FC +S21400C980FFF742FE38B940F22450C0F2010040F2F0 +S21400C990FD11F7F7F3FCE36A23F01003E36210BD22 +S21400C9A038B504460D46FFF72FFE38B940F224503E +S21400C9B0C0F2010040F21A21F7F7E0FC25B1236B24 +S21400C9C043F00603236338BD236B43F0020323635F +S21400C9D038BD00BF10B50446FFF716FE38B940F262 +S21400C9E02450C0F201004FF40F71F7F7C7FC236B19 +S21400C9F023F00603236310BD10B504464FF46043CE +S21400CA00C4F20F031B6813F0E04F2FD04FF46043BF +S21400CA10C4F20F031A684FF00003C7F2FF0302EADE +S21400CA200303B3F1805F21D04FF46043C4F20F03D9 +S21400CA301A684FF00003C7F2FF0302EA03034FF041 +S21400CA400002C1F20102934210D04FF46043C4F2D8 +S21400CA500F031A684FF00003C7F2FF0302EA03034E +S21400CA604FF00002C1F20302934207D140F2245075 +S21400CA70C0F2010040F25D21F7F780FC2046FFF788 +S21400CA80C3FD38B940F22450C0F2010040F25E21E6 +S21400CA90F7F774FCE36A23F0E60343F06E03E36201 +S21400CAA0236B43F00803236310BD00BF10B5044694 +S21400CAB04FF46043C4F20F031B6813F0E04F2FD00F +S21400CAC04FF46043C4F20F031A684FF00003C7F236 +S21400CAD0FF0302EA0303B3F1805F21D04FF4604303 +S21400CAE0C4F20F031A684FF00003C7F2FF0302EA0E +S21400CAF003034FF00002C1F20102934210D04FF43C +S21400CB006043C4F20F031A684FF00003C7F2FF0336 +S21400CB1002EA03034FF00002C1F20302934207D178 +S21400CB2040F22450C0F2010040F28621F7F726FCBE +S21400CB302046FFF769FD38B940F22450C0F20100E4 +S21400CB4040F28721F7F71AFC236B23F008032363D0 +S21400CB5010BD00BF38B504460D464FF46043C4F21E +S21400CB600F031B6813F0E04F2FD04FF46043C4F25E +S21400CB700F031A684FF00003C7F2FF0302EA03032D +S21400CB80B3F1805F21D04FF46043C4F20F031A68FC +S21400CB904FF00003C7F2FF0302EA03034FF0000260 +S21400CBA0C1F20102934210D04FF46043C4F20F0367 +S21400CBB01A684FF00003C7F2FF0302EA03034FF0C0 +S21400CBC00002C1F20302934207D140F22450C0F2A1 +S21400CBD0010040F2AD21F7F7D1FB4FF45043C4F209 +S21400CBE000039C4207D040F22450C0F2010040F2FD +S21400CBF0AE21F7F7C3FB35F4406307D040F224506C +S21400CC00C0F2010040F2AF21F7F7B8FB236B05F442 +S21400CC10406543EA0505256338BD00BF38B50446C0 +S21400CC200D464FF46043C4F20F031B6813F0E04F49 +S21400CC302FD04FF46043C4F20F031A684FF000037E +S21400CC40C7F2FF0302EA0303B3F1805F21D04FF47B +S21400CC506043C4F20F031A684FF00003C7F2FF03E5 +S21400CC6002EA03034FF00002C1F20102934210D021 +S21400CC704FF46043C4F20F031A684FF00003C7F284 +S21400CC80FF0302EA03034FF00002C1F203029342DD +S21400CC9007D140F22450C0F2010040F2D721F7F746 +S21400CCA06DFB4FF45043C4F200039C4207D040F2A1 +S21400CCB02450C0F201004FF43671F7F75FFB35F4ED +S21400CCC0406307D040F22450C0F2010040F2D92160 +S21400CCD0F7F754FB236B05F4406523EA0505256347 +S21400CCE038BD00BF10B504464FF46043C4F20F03CE +S21400CCF01B6813F0E04F2FD04FF46043C4F20F03CD +S21400CD001A684FF00003C7F2FF0302EA0303B3F109 +S21400CD10805F21D04FF46043C4F20F031A684FF0CF +S21400CD200003C7F2FF0302EA03034FF00002C1F25A +S21400CD300102934210D04FF46043C4F20F031A6806 +S21400CD404FF00003C7F2FF0302EA03034FF00002AE +S21400CD50C1F20302934207D140F22450C0F2010010 +S21400CD604FF43F71F7F70AFB4FF45043C4F2000349 +S21400CD709C4207D040F22450C0F2010040F2FD2150 +S21400CD80F7F7FCFA206B00F4406010BD10B50446BF +S21400CD904FF46043C4F20F031B6813F0E04F2FD02C +S21400CDA04FF46043C4F20F031A684FF00003C7F253 +S21400CDB0FF0302EA0303B3F1805F21D04FF4604320 +S21400CDC0C4F20F031A684FF00003C7F2FF0302EA2B +S21400CDD003034FF00002C1F20102934210D04FF459 +S21400CDE06043C4F20F031A684FF00003C7F2FF0354 +S21400CDF002EA03034FF00002C1F20302934207D196 +S21400CE0040F22450C0F2010040F21B31F7F7B6FAA8 +S21400CE104FF45043C4F200039C4207D040F2245023 +S21400CE20C0F201004FF44771F7F7A8FAA36940F281 +S21400CE30071003EA000010BD38B504460D464FF44F +S21400CE406043C4F20F031B6813F0E04F2FD04FF47B +S21400CE506043C4F20F031A684FF00003C7F2FF03E3 +S21400CE6002EA0303B3F1805F21D04FF46043C4F2BB +S21400CE700F031A684FF00003C7F2FF0302EA03032A +S21400CE804FF00002C1F20102934210D04FF460430B +S21400CE90C4F20F031A684FF00003C7F2FF0302EA5A +S21400CEA003034FF00002C1F20302934207D140F29F +S21400CEB02450C0F201004FF45071F7F75FFA204695 +S21400CEC0FFF7A2FB38B940F22450C0F2010040F24E +S21400CED04131F7F753FA35F4404307D040F2245077 +S21400CEE0C0F2010040F24231F7F748FA236B23F410 +S21400CEF0404343EA0505256338BD00BF10B5044628 +S21400CF004FF46043C4F20F031B6813F0E04F2FD0BA +S21400CF104FF46043C4F20F031A684FF00003C7F2E1 +S21400CF20FF0302EA0303B3F1805F21D04FF46043AE +S21400CF30C4F20F031A684FF00003C7F2FF0302EAB9 +S21400CF4003034FF00002C1F20102934210D04FF4E7 +S21400CF506043C4F20F031A684FF00003C7F2FF03E2 +S21400CF6002EA03034FF00002C1F20302934207D124 +S21400CF7040F22450C0F2010040F26531F7F7FEF9A6 +S21400CF802046FFF741FB38B940F22450C0F20100BA +S21400CF9040F26631F7F7F2F9206B00F4404010BD1E +S21400CFA038B505460C46FFF72FFB38B940F224503B +S21400CFB0C0F2010040F28B31F7F7E0F9231E18BFEC +S21400CFC00123102C0CBF002303F001033BB140F2F9 +S21400CFD02450C0F2010040F28D31F7F7CFF92B6BE9 +S21400CFE023F0100343EA04042C6338BD10B504464E +S21400CFF0FFF70AFB38B940F22450C0F2010040F2B5 +S21400D000B231F7F7BBF9206B00F0100010BD00BF7F +S21400D01010B50446FFF7F8FA38B940F22450C0F2CB +S21400D020010040F2CE31F7F7A9F9A36913F0100F0B +S21400D03014BF0020012010BD10B50446FFF7E4FA27 +S21400D04038B940F22450C0F2010040F2E931F7F757 +S21400D05095F9A36913F0200F14BF0020012010BD1E +S21400D06010B50446FFF7D0FA38B940F22450C0F2A3 +S21400D070010040F20941F7F781F9A36913F0100F98 +S21400D0800CBF20684FF0FF3010BD00BF10B504463F +S21400D090FFF7BAFA38B940F22450C0F2010040F265 +S21400D0A03241F7F76BF9A36913F0100FFBD1206834 +S21400D0B010BD00BF38B504460D46FFF7A5FA38B9CF +S21400D0C040F22450C0F2010040F25B41F7F756F9F7 +S21400D0D0A36913F0200F06BF25600120002038BD8D +S21400D0E038B504460D46FFF78FFA38B940F224509B +S21400D0F0C0F2010040F28941F7F740F9A36913F046 +S21400D100200FFBD1256038BD38B504460D46FFF725 +S21400D1107BFA38B940F22450C0F2010040F2AD412B +S21400D120F7F72CF92DB104F12C03E26A42F0010264 +S21400D13004E004F12C03E26A22F001021A6038BD12 +S21400D14010B50446FFF760FA38B940F22450C0F232 +S21400D150010040F2CD41F7F711F9A069C0F3C00015 +S21400D16010BD00BF38B504460D46FFF74DFA38B976 +S21400D17040F22450C0F201004FF49E61F7F7FEF82B +S21400D1804FF44043C4F200039C4208BF152407D066 +S21400D1904FF45043C4F200039C4214BF31241624BB +S21400D1A020462946FBF7B4FC2046FBF78DFD38BD2C +S21400D1B010B50446FFF728FA38B940F22450C0F2FA +S21400D1C0010040F21C51F7F7D9F84FF44043C4F27F +S21400D1D000039C4208BF152407D04FF45043C4F206 +S21400D1E000039C4214BF312416242046FBF7C0FDE2 +S21400D1F02046FBF7D1FC10BD38B504460D46FFF7B8 +S21400D20003FA38B940F22450C0F2010040F25151FE +S21400D210F7F7B4F8A36B43EA0505A56338BD00BF6E +S21400D22038B504460D46FFF7EFF938B940F22450FA +S21400D230C0F201004FF4AE61F7F7A0F8A36B23EA43 +S21400D2400505A56338BD00BF38B504460D46FFF793 +S21400D250DBF938B940F22450C0F2010040F28E519A +S21400D260F7F78CF80DB1206C38BDE06B38BD00BF09 +S21400D27038B504460D46FFF7C7F938B940F22450D2 +S21400D280C0F2010040F2BE51F7F778F8656438BD89 +S21400D29038B504460D46FFF7B7F938B940F22450C2 +S21400D2A0C0F2010040F2E251F7F768F8A36C43EAD7 +S21400D2B00505A56438BD00BF38B504460D46FFF722 +S21400D2C0A3F938B940F22450C0F2010040F20261DE +S21400D2D0F7F754F8A36C23EA0505A56438BD00BF2C +S21400D2E010B50446FFF790F938B940F22450C0F262 +S21400D2F0010040F22161F7F741F8606800F00F0086 +S21400D30010BD00BF10B50446FFF77EF938B940F2ED +S21400D3102450C0F2010040F23D61F7F72FF84FF0BD +S21400D3200003636010BD00BF4FF20403C4F20F0396 +S21400D3304FF001021A6070474FF20403C4F20F0365 +S21400D3404FF000021A6070474FF24C03C4F20F030E +S21400D350186870474FF24C03C4F20F034FF00102F7 +S21400D3601A60704710B504461F2807D940F23C5093 +S21400D370C0F201004FF08A01F7F700F84FF0010302 +S21400D38003FA04F44FF22803C4F20F031C6010BD26 +S21400D39010B504461F2807D940F23C50C0F20100E1 +S21400D3A04FF0A501F6F7EAFF4FF0010303FA04F485 +S21400D3B04FF22C03C4F20F031C6010BD10B50446D8 +S21400D3C01F2807D940F23C50C0F201004FF0C001C0 +S21400D3D0F6F7D4FF4FF22803C4F20F031B684FF092 +S21400D3E0010202FA04F41C420CBF0020012010BD0A +S21400D3F010B5044620F47E7323F00703984207D046 +S21400D40040F23C50C0F201004FF0E401F6F7B6FFE0 +S21400D410B4F1005F07D240F23C50C0F201004FF07A +S21400D420E501F6F7ABFF4FF20803C4F20F031C60EA +S21400D43010BD00BF4FF20803C4F20F031868704710 +S21400D4404FF20C03C4F20F031868704710B5044679 +S21400D4501F2807D940F23C50C0F2010040F23111BB +S21400D460F6F78CFF4FF0010303FA04F44FF21403AF +S21400D470C4F20F031C6010BD38B505460C461F28C5 +S21400D48007D940F23C50C0F2010040F25311F6F7C3 +S21400D49075FF34F00F0307D040F23C50C0F2010095 +S21400D4A040F25511F6F76AFF14F0010F1FBF012274 +S21400D4B0AA404FF21803C4F20F0318BF1A6014F004 +S21400D4C0020F1FBF0122AA404FF23003C4F20F031F +S21400D4D018BF1A6014F0040F1FBF0122AA404FF2B3 +S21400D4E03803C4F20F0318BF1A6014F0080F1FBFEA +S21400D4F0012303FA05F54FF22003C4F20F0318BF09 +S21400D5001D6038BD38B505460C461F2807D940F2C1 +S21400D5103C50C0F2010040F29511F6F72FFF34F0B0 +S21400D5200F0307D040F23C50C0F2010040F29711C2 +S21400D530F6F724FF14F0010F1FBF0122AA404FF296 +S21400D5401C03C4F20F0318BF1A6014F0020F1FBFAB +S21400D5500122AA404FF23403C4F20F0318BF1A6028 +S21400D56014F0040F1FBF0122AA404FF23C03C4F27E +S21400D5700F0318BF1A6014F0080F1FBF012303FA29 +S21400D58005F54FF22403C4F20F0318BF1D6038BD23 +S21400D59010B504461F2807D940F23C50C0F20100DF +S21400D5A040F2D711F6F7EAFE4FF21803C4F20F0363 +S21400D5B01B684FF0010202FA04F41C420CBF002064 +S21400D5C001204FF23003C4F20F031B681C4218BF41 +S21400D5D040F002004FF23803C4F20F031B681C42EF +S21400D5E018BF40F004004FF22003C4F20F031B687C +S21400D5F01C4218BF40F0080010BD00BF38B50446F6 +S21400D6000D463F2807D940F23C50C0F201004FF4C7 +S21400D6100E71F6F7B3FE4FF20803C4F20F031B6851 +S21400D6203BB940F23C50C0F2010040F23921F6F717 +S21400D630A5FE4FF20803C4F20F031B6803EB0414A5 +S21400D640A26843F6F773C0F2FC0302EA03031D4325 +S21400D650A56038BD2DE9F84F07460C4616461D4610 +S21400D660DDF828903F2807D940F23C50C0F2010070 +S21400D67040F2A121F6F782FE4FF20803C4F20F0330 +S21400D6801B683BB940F23C50C0F2010040F2A221B8 +S21400D690F6F774FE062C07D940F23C50C0F20100A3 +S21400D6A040F2A321F6F76AFEB246B6F1005F07D253 +S21400D6B040F23C50C0F201004FF42971F6F75EFECE +S21400D6C0AB46B5F1005F07D240F23C50C0F2010015 +S21400D6D040F2A521F6F752FE09F1FF38B8F5806F43 +S21400D6E007D340F23C50C0F2010040F2A621F6F704 +S21400D6F045FE4FF20803C4F20F031A684FEA0711FB +S21400D7005318986820F47E5020F0770017F0200F0A +S21400D7100ED0062C14BF4FF0000C4FF0010C042C5A +S21400D72008BF4CF0010CBCF1000F01D044F001041E +S21400D73040EA0810204300F0406CBCF1406F1FBF69 +S21400D7400AF1FF3A4FEA9C6C09FA0CFC0AEB0C064D +S21400D750565000F04041B1F1404F17D0062C14BF90 +S21400D76000250125042C14BF2C4645F0010447F083 +S21400D770200502EB051505F10C053CB90BF1FF3B46 +S21400D7804FEA917109FA01F90BEB09055D609860A3 +S21400D790BDE8F88FF8B505460C4616461F461F2806 +S21400D7A007D940F23C50C0F2010040F22E31F6F7A5 +S21400D7B0E5FD4FF20803C4F20F031B683BB940F2C5 +S21400D7C03C50C0F2010040F22F31F6F7D7FD3EB9CB +S21400D7D040F23C50C0F201004FF44C71F6F7CEFD1B +S21400D7E0B4F5806F07D940F23C50C0F2010040F219 +S21400D7F03131F6F7C3FD3CB940F23C50C0F20100AF +S21400D80040F23231F6F7BAFD4FF20803C4F20F03C6 +S21400D8101B684FEA05115A1804F1FF3006EB001694 +S21400D82006F10C065E5045F0200503EB051303F1E8 +S21400D8300C0353604FEA8414A4F11004002F0CBFAD +S21400D8400427062744F02A4444F4004444EA070721 +S21400D8509760F8BD10B504463F2807D940F23C5003 +S21400D860C0F201004FF45D71F6F788FD4FF2080331 +S21400D870C4F20F031B683BB940F23C50C0F20100F3 +S21400D88040F27531F6F77AFD4FF20803C4F20F0343 +S21400D8901B6803EB0414A36843F6F77003EA000062 +S21400D8A020B14FEA101000F1010010BD4FF000004B +S21400D8B010BD00BF10B504463F2807D940F23C50C3 +S21400D8C0C0F2010040F2B331F6F758FD4FF20803FC +S21400D8D0C4F20F031B683BB940F23C50C0F2010093 +S21400D8E04FF46D71F6F74AFD4FF20803C4F20F03CA +S21400D8F01B6803EB0414A36803F0070203F0060397 +S21400D900062B14BF00200120042B08BF40F00100A6 +S21400D910002814BF1846104610BD00BF4FF47543CC +S21400D920C4F20F031A6840EA02021A60704700BF8A +S21400D9304FF47543C4F20F031A6822EA00021A6015 +S21400D940704700BF38B504460D4639B940F23C5022 +S21400D950C0F201004FF48D61F6F710FDA4F13E030E +S21400D960012B07D940F23C50C0F2010040F2694159 +S21400D970F6F704FD20462946FBF7CAF82046FBF7D3 +S21400D980A3F938BD10B50446FBF7F2F92046FBF7BD +S21400D99003F910BDF8B504460D4617461E464FF06F +S21400D9A00003C4F20503984207D040F25450C0F278 +S21400D9B001004FF0A801F6F7E1FC032D07D940F26D +S21400D9C05450C0F201004FF0AA01F6F7D7FC06F15A +S21400D9D0FF33012B07D940F25450C0F201004FF03C +S21400D9E0AB01F6F7CBFCA37BEDB2A573012E0EBF01 +S21400D9F0385D385BC0B2A373F8BD00BF2DE9F041B7 +S21400DA0004460D4690461F46069E4FF00003C4F29D +S21400DA100503984207D040F25450C0F201004FF080 +S21400DA206801F6F7ABFC032D07D940F25450C0F25C +S21400DA3001004FF06A01F6F7A1FC06F1FF33012B57 +S21400DA4007D940F25450C0F201004FF06B01F6F7D0 +S21400DA5095FCA37BEDB2A573012E07BFFFB208F8B5 +S21400DA600470BFB228F80470A373BDE8F08100BF4D +S21400DA7010B504464FF00003C4F20503984207D0E1 +S21400DA8040F25450C0F201004FF0E801F6F776FC81 +S21400DA90637843F00203637010BD00BF38B50446D8 +S21400DAA00D464FF00003C4F20503984207D040F23B +S21400DAB05450C0F201004FF48471F6F75FFC25B1B4 +S21400DAC0637843F00803637038BD637803F0F703A8 +S21400DAD0637038BD38B504460D464FF00003C4F2F7 +S21400DAE00503984207D040F25450C0F2010040F2BD +S21400DAF03511F6F743FC25B1637843F004036370F1 +S21400DB0038BD637803F0FB03637038BD10B5044678 +S21400DB104FF00003C4F20503984207D040F2545079 +S21400DB20C0F201004FF4AC71F6F728FC94F86030B0 +S21400DB3013F0400F09D194F8600000F02000002890 +S21400DB400CBF4FF00040002010BD4FF0010010BD8C +S21400DB5010B504464FF00003C4F20503984207D000 +S21400DB6040F25450C0F2010040F29111F6F706FC64 +S21400DB70A3782279A07A4FEA006040EA0220184390 +S21400DB80D4F80C3413F0010F1FBF40F4803094F823 +S21400DB900C3443F0010384F80C3440F24C43C4F2D6 +S21400DBA005031B6813F0010F09D040F4003040F263 +S21400DBB04C43C4F205031A6842F001021A6010BD15 +S21400DBC038B505460C464FF00003C4F205039842EC +S21400DBD007D040F25450C0F201004FF4F271F6F74D +S21400DBE0CDFB4FF2F013C0F2FC0304EA03033BB193 +S21400DBF040F25450C0F2010040F2E511F6F7BEFBC9 +S21400DC0014F00F0F1FBFEB889BB204F00F02934374 +S21400DC1018BFEB8014F460631FBF2A8992B222EA11 +S21400DC2013232B8114F07F4F1EBFEB7A23EA146375 +S21400DC30EB7214F4803F1CBF0023C5F8083414F4BC +S21400DC40003F1FBF4FF48963C4F2050300221A6029 +S21400DC5038BD00BF38B505460C464FF00003C4F289 +S21400DC600503984207D040F25450C0F2010040F23B +S21400DC703B21F6F783FB4FF2F013C0F2FC0304EAF5 +S21400DC8003033BB140F25450C0F201004FF40F7151 +S21400DC90F6F774FB14F00F0F1FBFEB889BB204F06F +S21400DCA00F02134318BFEB8014F460631FBF2A896A +S21400DCB092B242EA13232B8114F07F4F1EBFEB7AF9 +S21400DCC043EA1463EB7214F4803F1CBF0123C5F8CB +S21400DCD0083414F4003F1FBF4FF48963C4F20503F1 +S21400DCE001221A6038BD00BF38B505460C464FF015 +S21400DCF00003C4F20503984207D040F25450C0F225 +S21400DD00010040F28521F6F739FB24F47E7333F0E8 +S21400DD10070207D040F25450C0F2010040F28621BC +S21400DD20F6F72CFB14F0FF0F1EBFEB7AA343EB7243 +S21400DD3014F4807F1CBF0023C5F8083414F4007F59 +S21400DD401FBF4FF48963C4F2050300221A6038BD72 +S21400DD5038B505460C464FF00003C4F2050398425A +S21400DD6007D040F25450C0F201004FF42E71F6F77F +S21400DD7005FB24F47E7333F0070207D040F25450BC +S21400DD80C0F2010040F2B921F6F7F8FA14F0FF0FDE +S21400DD901FBFEB7A2343DBB2EB7214F4807F1CBF09 +S21400DDA00123C5F8083414F4007F1FBF4FF48963BD +S21400DDB0C4F2050301221A6038BD00BF10B5044640 +S21400DDC04FF00003C4F20503984207D040F25450C7 +S21400DDD0C0F2010040F20731F6F7D0FAA07AD4F884 +S21400DDE00C3413F0010F1FBF40F4807094F80C340D +S21400DDF043F0010384F80C3440F24C43C4F20503AC +S21400DE001B6813F0010F09D040F4007040F24C4339 +S21400DE10C4F205031A6842F001021A6010BD00BF82 +S21400DE2038B504460D464FF00003C4F20503984289 +S21400DE3007D040F25450C0F201004FF45271F6F78A +S21400DE409DFAE3889BB223EA0503E38023899BB20D +S21400DE504FEA554523EA4505258138BD38B50446C1 +S21400DE600D464FF00003C4F20503984207D040F277 +S21400DE705450C0F201004FF45C71F6F77FFAE38865 +S21400DE8045EA03039BB2E38023899BB24FEA5545DC +S21400DE9043EA4505258138BD10B504464FF000031A +S21400DEA0C4F20503984207D040F25450C0F2010075 +S21400DEB040F29B31F6F762FA63889BB2A08843EA89 +S21400DEC0004010BD10B50C464FF00003C4F2050329 +S21400DED0984207D040F25450C0F2010040F2C531DB +S21400DEE0F6F74CFA4FF03C002146FAF711FE4FF0D9 +S21400DEF03C00FAF7E9FE10BD08B54FF00003C4F287 +S21400DF000503984207D040F25450C0F2010040F298 +S21400DF10E731F6F733FA4FF03C00FAF73DFE4FF0E4 +S21400DF203C00FAF725FF08BD38B505460C464FF00D +S21400DF300003C4F20503984207D040F25450C0F2E2 +S21400DF40010040F24341F6F719FAB4F1100318BF86 +S21400DF500123002C0CBF002303F00103002B4FD03D +S21400DF60B4F1300318BF0123202C0CBF002303F0AC +S21400DF700103002B44D0B4F1500318BF0123402CFA +S21400DF800CBF002303F00103002B39D0B4F170035B +S21400DF9018BF0123602C0CBF002303F001037BB3E2 +S21400DFA0B4F1900318BF0123802C0CBF002303F0AC +S21400DFB001032BB3B4F1B00318BF0123A02C0CBF90 +S21400DFC0002303F00103DBB1B4F1D00318BF012333 +S21400DFD0C02C0CBF002303F001038BB1B4F1F00397 +S21400DFE018BF0123E02C0CBF002303F001033BB154 +S21400DFF040F25450C0F2010040F24B41F6F7BEF931 +S21400E0006419B4F802319BB2B4F8060143EA004042 +S21400E01038BD00BF70B505460C4616464FF00003E7 +S21400E020C4F20503984207D040F25450C0F20100F3 +S21400E03040F27641F6F7A2F9B4F1100318BF0123B7 +S21400E040002C0CBF002303F00103002B4FD0B4F1CB +S21400E050300318BF0123202C0CBF002303F001035C +S21400E060002B44D0B4F1500318BF0123402C0CBF42 +S21400E070002303F00103002B39D0B4F1700318BF5E +S21400E0800123602C0CBF002303F001037BB3B4F123 +S21400E090900318BF0123802C0CBF002303F001035C +S21400E0A02BB3B4F1B00318BF0123A02C0CBF002380 +S21400E0B003F00103DBB1B4F1D00318BF0123C02C79 +S21400E0C00CBF002303F001038BB1B4F1F00318BFBB +S21400E0D00123E02C0CBF002303F001033BB140F208 +S21400E0E05450C0F2010040F27E41F6F747F934B9C9 +S21400E0F095F8023123EA060685F8026170BD6419B8 +S21400E10094F8023123EA060384F8023194F80631C3 +S21400E11023EA164684F8066170BD00BF70B5054652 +S21400E1200C4616464FF00003C4F20503984207D08B +S21400E13040F25450C0F2010040F2A741F6F71EF933 +S21400E140B4F1100318BF0123002C0CBF002303F00A +S21400E1500103002B4FD0B4F1300318BF0123202C4D +S21400E1600CBF002303F00103002B44D0B4F150038E +S21400E17018BF0123402C0CBF002303F00103002B23 +S21400E18039D0B4F1700318BF0123602C0CBF0023F4 +S21400E19003F001037BB3B4F1900318BF0123802C76 +S21400E1A00CBF002303F001032BB3B4F1B00318BF78 +S21400E1B00123A02C0CBF002303F00103DBB1B4F154 +S21400E1C0D00318BF0123C02C0CBF002303F00103AB +S21400E1D08BB1B4F1F00318BF0123E02C0CBF002371 +S21400E1E003F001033BB140F25450C0F2010040F28C +S21400E1F0AF41F6F7C3F8DCB916F0010F1EBF95F86D +S21400E200023143F0400385F8023116F0100F1EBFAE +S21400E21095F8023143F0800385F8023116F0040FBA +S21400E22017D095F8023103F0FB0385F8023170BD74 +S21400E230641994F8023106F0240223EA020384F8F3 +S21400E240023194F8063106F4980623EA164684F856 +S21400E250066170BDF8B505460C4616461F464FF0DB +S21400E2600003C4F20503984207D040F25450C0F2AF +S21400E270010040F20151F6F781F8B4F1100318BF1F +S21400E2800123002C0CBF002303F00103002B4FD00A +S21400E290B4F1300318BF0123202C0CBF002303F079 +S21400E2A00103002B44D0B4F1500318BF0123402CC7 +S21400E2B00CBF002303F00103002B39D0B4F1700328 +S21400E2C018BF0123602C0CBF002303F001037BB3AF +S21400E2D0B4F1900318BF0123802C0CBF002303F079 +S21400E2E001032BB3B4F1B00318BF0123A02C0CBF5D +S21400E2F0002303F00103DBB1B4F1D00318BF012300 +S21400E300C02C0CBF002303F001038BB1B4F1F00363 +S21400E31018BF0123E02C0CBF002303F001033BB120 +S21400E32040F25450C0F2010040F20951F6F726F8C8 +S21400E3303EB14FF002023CB1002F0CBF0223012376 +S21400E3400EE04FF000024CB995F8033103F0F903E4 +S21400E35043F00403134385F80331F8BD4FF0000380 +S21400E36067B905F5827505F103052A5D02F0F90225 +S21400E37042F0040242EA03032B55F8BD05F580750A +S21400E38005F103052A5D02F0FC0242F0020242EAB1 +S21400E39003032B55F8BD00BF70B505460C46164660 +S21400E3A04FF00003C4F20503984207D040F25450E1 +S21400E3B0C0F2010040F26251F5F7E0FFB4F120032D +S21400E3C018BF0123102C0CBF002303F00103002B01 +S21400E3D046D0B4F1400318BF0123302C0CBF0023F5 +S21400E3E003F00103002B3BD0B4F1600318BF0123F8 +S21400E3F0502C0CBF002303F001038BB3B4F1800351 +S21400E40018BF0123702C0CBF002303F001033BB39D +S21400E410B4F1A00318BF0123902C0CBF002303F017 +S21400E4200103EBB1B4F1C00318BF0123B02C0CBF3D +S21400E430002303F001039BB1B4F1E00318BF0123EE +S21400E440D02C0CBF002303F001034BB1F02C07D0F7 +S21400E45040F25450C0F2010040F26A51F5F78EFFC8 +S21400E46016F4005F1DBF05F581752B5D43F0400374 +S21400E47005F5837504BF2B5D43F080032B5570BDF7 +S21400E48070B505460C4616464FF00003C4F2050369 +S21400E490984207D040F25450C0F2010040F2955125 +S21400E4A0F5F76CFF36F4005307D040F25450C0F234 +S21400E4B0010040F29651F5F761FFB4F1100318BF62 +S21400E4C00123002C0CBF002303F00103002B4FD0C8 +S21400E4D0B4F1300318BF0123202C0CBF002303F037 +S21400E4E00103002B44D0B4F1500318BF0123402C85 +S21400E4F00CBF002303F00103002B39D0B4F17003E6 +S21400E50018BF0123602C0CBF002303F001037BB36C +S21400E510B4F1900318BF0123802C0CBF002303F036 +S21400E52001032BB3B4F1B00318BF0123A02C0CBF1A +S21400E530002303F00103DBB1B4F1D00318BF0123BD +S21400E540C02C0CBF002303F001038BB1B4F1F00321 +S21400E55018BF0123E02C0CBF002303F001033BB1DE +S21400E56040F25450C0F2010040F29E51F5F706FF0B +S21400E57034B995F8023143F0600385F8023170BD76 +S21400E580B6F5005F03BF05F581752B5D43F01003FC +S21400E59005F583751CBF2B5D43F020032B5570BD1E +S21400E5A070B505460C4616464FF00003C4F2050348 +S21400E5B0984207D040F25450C0F201004FF4BB61BD +S21400E5C0F5F7DCFEB4F1100318BF0123002C0CBFD6 +S21400E5D0002303F00103002B4FD0B4F1300318BF23 +S21400E5E00123202C0CBF002303F00103002B44D092 +S21400E5F0B4F1500318BF0123402C0CBF002303F0D6 +S21400E6000103002B39D0B4F1700318BF0123602C2E +S21400E6100CBF002303F001037BB3B4F1900318BFD3 +S21400E6200123802C0CBF002303F001032BB3B4F1AD +S21400E630B00318BF0123A02C0CBF002303F0010376 +S21400E640DBB1B4F1D00318BF0123C02C0CBF0023EC +S21400E65003F001038BB1B4F1F00318BF0123E02CE3 +S21400E6600CBF002303F001033BB140F25450C0F24C +S21400E67001004FF4BC61F5F781FE36F4005307D075 +S21400E68040F25450C0F2010040F2E151F5F776FE38 +S21400E69034B995F8023103F0FB0385F8023170BDFA +S21400E6A0B6F5005F0AD105F581752B5D03F0CF0343 +S21400E6B02B552B5D43F040032B5570BD05F5837538 +S21400E6C02B5D03F09F032B552B5D43F080032B55EA +S21400E6D070BD00BF10B504464FF00003C4F205033A +S21400E6E0984207D040F25450C0F2010040F21F6139 +S21400E6F0F5F744FE637843F04003637010BD00BF37 +S21400E70010B504464FF00003C4F20503984207D044 +S21400E71040F25450C0F2010040F23C61F5F72EFE84 +S21400E720637803F0BF03637010BD00BF38B50446BE +S21400E7300D464FF00003C4F20503984207D040F29E +S21400E7405450C0F2010040F25961F5F717FEEDB2E1 +S21400E750257038BD10B504464FF00003C4F205031B +S21400E760984207D040F25450C0F2010040F2756162 +S21400E770F5F704FE207810BD2DE9F84305460C4653 +S21400E78090461F46DDF82090099E4FF00003C4F225 +S21400E7900503984207D040F25450C0F2010040F200 +S21400E7A0CE61F5F7EBFDB4F1100318BF0123002C82 +S21400E7B00CBF002303F00103002B4FD0B4F130034D +S21400E7C018BF0123202C0CBF002303F00103002BED +S21400E7D044D0B4F1500318BF0123402C0CBF0023D3 +S21400E7E003F00103002B39D0B4F1700318BF0123E6 +S21400E7F0602C0CBF002303F001037BB3B4F190033D +S21400E80018BF0123802C0CBF002303F001032BB399 +S21400E810B4F1B00318BF0123A02C0CBF002303F0F3 +S21400E8200103DBB1B4F1D00318BF0123C02C0CBF29 +S21400E830002303F001038BB1B4F1F00318BF0123EA +S21400E840E02C0CBF002303F001033BB140F2545010 +S21400E850C0F2010040F2D661F5F790FD1F2F07D9F0 +S21400E86040F25450C0F2010040F2D761F5F786FD41 +S21400E87064B9FFB285F80B7106F48056002E0CBF03 +S21400E880C026802685F8FA60BDE8F88316F4805F17 +S21400E89014BF49F0800949F0C00906F44073B3F587 +S21400E8A0807F08BF49F0200908D0B3F5007F08BF75 +S21400E8B049F0300902D00BB949F0100916F4005F90 +S21400E8C01FD064195FFA89F984F80A91FFB284F8B8 +S21400E8D00B715FFA88F884F8008106F001034FEAAE +S21400E8E0C31316F0100F18BF43F0140304D116F02C +S21400E8F0080F18BF43F01003DBB284F80331BDE8FD +S21400E900F88364195FFA89F984F80C91FFB284F8E9 +S21400E9100D7106F00403002B14BF8023002316F0AD +S21400E920100F18BF43F0280304D116F0080F18BFC5 +S21400E93043F02003DBB284F80731BDE8F88300BF5C +S21400E940F8B506460C4617461D464FF00003C4F2BF +S21400E9500503984207D040F25450C0F2010040F23E +S21400E960C971F5F70BFDB4F1200318BF0123102C75 +S21400E9700CBF002303F00103002B46D0B4F1400384 +S21400E98018BF0123302C0CBF002303F00103002B1B +S21400E9903BD0B4F1600318BF0123502C0CBF0023FA +S21400E9A003F001038BB3B4F1800318BF0123702C6E +S21400E9B00CBF002303F001033BB3B4F1A00318BF60 +S21400E9C00123902C0CBF002303F00103EBB1B4F13C +S21400E9D0C00318BF0123B02C0CBF002303F00103B3 +S21400E9E09BB1B4F1E00318BF0123D02C0CBF002369 +S21400E9F003F001034BB1F02C07D040F25450C0F2A4 +S21400EA00010040F2D171F5F7B9FC15F4005F1FD094 +S21400EA10A419FFB284F8007105F001034FEAC3138E +S21400EA2015F0100F18BF43F0140304D115F0080FAB +S21400EA3018BF43F0100315F4407F08BF43F04003AF +S21400EA40DBB284F803314FF0400384F80231F8BD9E +S21400EA50A419FFB284F8047105F00403002B14BF58 +S21400EA608023002315F0100F18BF43F0280304D1AD +S21400EA7015F0080F18BF43F0200315F4407F08BFB9 +S21400EA8043F04003DBB284F807314FF0800384F88C +S21400EA900631F8BDF8B506460D4617461C464FF03B +S21400EAA00003C4F20503984207D040F25450C0F267 +S21400EAB0010040F66501F5F761FCD4F1010338BFAB +S21400EAC00023002F08BF43F001033BB140F254502F +S21400EAD0C0F2010040F66601F5F750FCB5F12003E0 +S21400EAE018BF0123102D0CBF002303F00103002BD9 +S21400EAF046D0B5F1400318BF0123302D0CBF0023CC +S21400EB0003F00103002B3BD0B5F1600318BF0123CF +S21400EB10502D0CBF002303F001038BB3B5F1800327 +S21400EB2018BF0123702D0CBF002303F001033BB375 +S21400EB30B5F1A00318BF0123902D0CBF002303F0EE +S21400EB400103EBB1B5F1C00318BF0123B02D0CBF14 +S21400EB50002303F001039BB1B5F1E00318BF0123C6 +S21400EB60D02D0CBF002303F001034BB1F02D07D0CE +S21400EB7040F25450C0F2010040F66E01F5F7FEFB7D +S21400EB80236813F4005F23D04FF400532360AD19BD +S21400EB9095F800313B6095F8033113F0800F1EBFE7 +S21400EBA0226842F00102226013F0100F08D013F022 +S21400EBB0040F226814BF42F0100242F008022260DE +S21400EBC013F0400F27D1236843F480732360F8BD09 +S21400EBD04FF000032360AD1995F804313B6095F8BB +S21400EBE0073113F0800F1EBF226842F00402226035 +S21400EBF013F0200F08D013F0080F226814BF42F05D +S21400EC00100242F00802226013F0400F02BF236891 +S21400EC1043F480732360F8BDF0B583B005460C4618 +S21400EC2017461E464FF00003C4F20503984207D06D +S21400EC3040F25450C0F201004FF41261F5F79EFB0B +S21400EC40B4F1200318BF0123102C0CBF002303F0DF +S21400EC500103002B46D0B4F1400318BF0123302C2B +S21400EC600CBF002303F00103002B3BD0B4F160037C +S21400EC7018BF0123502C0CBF002303F001038BB3F5 +S21400EC80B4F1800318BF0123702C0CBF002303F0DF +S21400EC9001033BB3B4F1A00318BF0123902C0CBFB3 +S21400ECA0002303F00103EBB1B4F1C00318BF012346 +S21400ECB0B02C0CBF002303F001039BB1B4F1E003BA +S21400ECC018BF0123D02C0CBF002303F001034BB167 +S21400ECD0F02C07D040F25450C0F2010040F6281144 +S21400ECE0F5F74CFB089B13F4005F17D04FEA14149B +S21400ECF04FF001030093284621464FF06202334648 +S21400ED00FEF77CFE4FF002030093284621464FF0A4 +S21400ED1064024FEAD703FEF771FE16E04FEA1414BA +S21400ED204FF001030093284621464FF06302334616 +S21400ED30FEF764FE4FF002030093284621464FF08C +S21400ED4066024FEAD703FEF759FE03B0F0BD00BFD8 +S21400ED50F8B505460C4616461F464FF00003C4F2AB +S21400ED600503984207D040F25450C0F201004FF419 +S21400ED701661F5F703FBB4F1200318BF0123102C2E +S21400ED800CBF002303F00103002B46D0B4F1400370 +S21400ED9018BF0123302C0CBF002303F00103002B07 +S21400EDA03BD0B4F1600318BF0123502C0CBF0023E6 +S21400EDB003F001038BB3B4F1800318BF0123702C5A +S21400EDC00CBF002303F001033BB3B4F1A00318BF4C +S21400EDD00123902C0CBF002303F00103EBB1B4F128 +S21400EDE0C00318BF0123B02C0CBF002303F001039F +S21400EDF09BB1B4F1E00318BF0123D02C0CBF002355 +S21400EE0003F001034BB1F02C07D040F25450C0F28F +S21400EE10010040F66811F5F7B1FA069B13F4005F9F +S21400EE2016D04FEA1414284621464FF064024FF0DD +S21400EE300203FEF7AFFD4FEAC000306028462146C9 +S21400EE404FF062024FF00103FEF7A4FD3860F8BDF4 +S21400EE504FEA1414284621464FF066024FF002038C +S21400EE60FEF798FD4FEAC0003060284621464FF076 +S21400EE7063024FF00103FEF78DFD3860F8BD00BF5A +S21400EE8012F4005F1FBF00F580700330435C43F050 +S21400EE90100301BF00F582700330435C43F020038B +S21400EEA04354704712F4005F1FBF00F580700330B4 +S21400EEB0435C03F0EF0301BF00F582700330435C50 +S21400EEC003F0DF034354704738B505460C464FF051 +S21400EED00003C4F20503984207D040F25450C0F233 +S21400EEE001004FF41F61F5F749FAB4F1100318BF9B +S21400EEF00123002C0CBF002303F00103002B4FD08E +S21400EF00B4F1300318BF0123202C0CBF002303F0FC +S21400EF100103002B44D0B4F1500318BF0123402C4A +S21400EF200CBF002303F00103002B39D0B4F17003AB +S21400EF3018BF0123602C0CBF002303F001037BB332 +S21400EF40B4F1900318BF0123802C0CBF002303F0FC +S21400EF5001032BB3B4F1B00318BF0123A02C0CBFE0 +S21400EF60002303F00103DBB1B4F1D00318BF012383 +S21400EF70C02C0CBF002303F001038BB1B4F1F003E7 +S21400EF8018BF0123E02C0CBF002303F001033BB1A4 +S21400EF9040F25450C0F2010040F6F811F5F7EEF9D1 +S21400EFA004F583730CB94FF481735B5B13F0010FA8 +S21400EFB01DBF05F58475285B80B2002038BD00BFF4 +S21400EFC0F8B506460D4614461F464FF00003C4F239 +S21400EFD00503984207D040F25450C0F2010040F6B4 +S21400EFE03521F5F7CBF9B5F1100318BF0123002D35 +S21400EFF00CBF002303F00103002B4FD0B5F1300304 +S21400F00018BF0123202D0CBF002303F00103002BA3 +S21400F01044D0B5F1500318BF0123402D0CBF002388 +S21400F02003F00103002B39D0B5F1700318BF01239C +S21400F030602D0CBF002303F001037BB3B5F19003F2 +S21400F04018BF0123802D0CBF002303F001032BB350 +S21400F050B5F1B00318BF0123A02D0CBF002303F0A9 +S21400F0600103DBB1B5F1D00318BF0123C02D0CBFDF +S21400F070002303F001038BB1B5F1F00318BF0123A1 +S21400F080E02D0CBF002303F001033BB140F25450C7 +S21400F090C0F2010040F63D21F5F770F905F58373DF +S21400F0A00DB94FF481739B5B13F0010F05D14FF040 +S21400F0B000033B604FF0FF30F8BD06F584735B5BE2 +S21400F0C09BB23A68934228BF13463B6006F120067F +S21400F0D006EB95053BB12A7804F8012B013BFAD1E3 +S21400F0E04FF00000F8BD4FF00000F8BD70B50546C3 +S21400F0F00C4616464FF00003C4F20503984207D0AC +S21400F10040F25450C0F2010040F69D21F5F736F962 +S21400F110B4F1100318BF0123002C0CBF002303F02A +S21400F1200103002B4FD0B4F1300318BF0123202C6D +S21400F1300CBF002303F00103002B44D0B4F15003AE +S21400F14018BF0123402C0CBF002303F00103002B43 +S21400F15039D0B4F1700318BF0123602C0CBF002314 +S21400F16003F001037BB3B4F1900318BF0123802C96 +S21400F1700CBF002303F001032BB3B4F1B00318BF98 +S21400F1800123A02C0CBF002303F00103DBB1B4F174 +S21400F190D00318BF0123C02C0CBF002303F00103CB +S21400F1A08BB1B4F1F00318BF0123E02C0CBF002391 +S21400F1B003F001033BB140F25450C0F2010040F6A8 +S21400F1C0A521F5F7DBF834B9002E0CBF40264826FB +S21400F1D085F8026170BD05F583752B5D03F0FE03AF +S21400F1E02B5570BD38B505460C464FF00003C4F2EB +S21400F1F00503984207D040F25450C0F2010040F692 +S21400F200D321F5F7BBF8B4F1100318BF0123002C87 +S21400F2100CBF002303F00103002B4FD0B4F13003E2 +S21400F22018BF0123202C0CBF002303F00103002B82 +S21400F23044D0B4F1500318BF0123402C0CBF002368 +S21400F24003F00103002B39D0B4F1700318BF01237B +S21400F250602C0CBF002303F001037BB3B4F19003D2 +S21400F26018BF0123802C0CBF002303F001032BB32F +S21400F270B4F1B00318BF0123A02C0CBF002303F089 +S21400F2800103DBB1B4F1D00318BF0123C02C0CBFBF +S21400F290002303F001038BB1B4F1F00318BF012380 +S21400F2A0E02C0CBF002303F001033BB140F25450A6 +S21400F2B0C0F2010040F6DB21F5F760F834B995F8A6 +S21400F2C0023103F0FE0385F8023138BD05F583757B +S21400F2D02B5D03F0FE032B5538BD00BFF8B507467F +S21400F2E00E4615461C464FF00003C4F2050398422E +S21400F2F007D040F25450C0F2010040F60931F5F74D +S21400F3003DF8B6F1100318BF0123002E0CBF0023F2 +S21400F31003F00103002B4FD0B6F1300318BF0123D2 +S21400F320202E0CBF002303F00103002B44D0B6F1BF +S21400F330500318BF0123402E0CBF002303F0010327 +S21400F340002B39D0B6F1700318BF0123602E0CBF16 +S21400F350002303F001037BB3B6F1900318BF01232B +S21400F360802E0CBF002303F001032BB3B6F1B003CD +S21400F37018BF0123A02E0CBF002303F00103DBB14E +S21400F380B6F1D00318BF0123C02E0CBF002303F034 +S21400F39001038BB1B6F1F00318BF0123E02E0CBFBA +S21400F3A0002303F001033BB140F25450C0F20100C9 +S21400F3B040F61131F4F7E2FF002E14BF01220222BC +S21400F3C007F581739B5D1A420CD107F1200707EB06 +S21400F3D0960654B115F8013B3370013CFAD14FF054 +S21400F3E00000F8BD4FF0FF30F8BD4FF00000F8BD4C +S21400F3F070B505460C4616464FF00003C4F20503EA +S21400F400984207D040F25450C0F2010040F65C31FA +S21400F410F4F7B4FFB4F1100318BF0123002C0CBF9F +S21400F420002303F00103002B4FD0B4F1300318BFC4 +S21400F4300123202C0CBF002303F00103002B44D033 +S21400F440B4F1500318BF0123402C0CBF002303F077 +S21400F4500103002B39D0B4F1700318BF0123602CD0 +S21400F4600CBF002303F001037BB3B4F1900318BF75 +S21400F4700123802C0CBF002303F001032BB3B4F14F +S21400F480B00318BF0123A02C0CBF002303F0010318 +S21400F490DBB1B4F1D00318BF0123C02C0CBF00238E +S21400F4A003F001038BB1B4F1F00318BF0123E02C85 +S21400F4B00CBF002303F001033BB140F25450C0F2EE +S21400F4C0010040F66431F4F759FF14B906F0FF0660 +S21400F4D001E0C6F3072605F581752B5D13F0020FD4 +S21400F4E003BFF6B22E5500204FF0FF3070BD00BFB0 +S21400F4F070B505460C4616464FF00003C4F20503E9 +S21400F500984207D040F25450C0F2010040F69C31B9 +S21400F510F4F734FFB4F1100318BF0123002C0CBF1E +S21400F520002303F00103002B4FD0B4F1300318BFC3 +S21400F5300123202C0CBF002303F00103002B44D032 +S21400F540B4F1500318BF0123402C0CBF002303F076 +S21400F5500103002B39D0B4F1700318BF0123602CCF +S21400F5600CBF002303F001037BB3B4F1900318BF74 +S21400F5700123802C0CBF002303F001032BB3B4F14E +S21400F580B00318BF0123A02C0CBF002303F0010317 +S21400F590DBB1B4F1D00318BF0123C02C0CBF00238D +S21400F5A003F001038BB1B4F1F00318BF0123E02C84 +S21400F5B00CBF002303F001033BB140F25450C0F2ED +S21400F5C0010040F6A431F4F7D9FE4CB995F80231A3 +S21400F5D013F0030F1CD04FF0010385F8033170BD04 +S21400F5E016F4005F0AD005F581752B5D13F0010F48 +S21400F5F00ED02B5D43F008032B5570BD05F58375C3 +S21400F6002B5D13F0010F1EBF2B5D43F010032B552F +S21400F61070BD00BF38B505460C464FF00003C4F277 +S21400F6200503984207D040F25450C0F2010040F65D +S21400F630F531F4F7A3FEB4F1100318BF0123002C34 +S21400F6400CBF002303F00103002B4FD0B4F13003AE +S21400F65018BF0123202C0CBF002303F00103002B4E +S21400F66044D0B4F1500318BF0123402C0CBF002334 +S21400F67003F00103002B39D0B4F1700318BF012347 +S21400F680602C0CBF002303F001037BB3B4F190039E +S21400F69018BF0123802C0CBF002303F001032BB3FB +S21400F6A0B4F1B00318BF0123A02C0CBF002303F055 +S21400F6B00103DBB1B4F1D00318BF0123C02C0CBF8B +S21400F6C0002303F001038BB1B4F1F00318BF01234C +S21400F6D0E02C0CBF002303F001033BB140F2545072 +S21400F6E0C0F2010040F6FD31F4F748FE14B104F50F +S21400F6F0837401E04FF481744FF02003635538BDE6 +S21400F70010B504464FF00003C4F20503984207D034 +S21400F71040F25450C0F2010040F62641F4F72EFEA7 +S21400F7204FF0600384F8023110BD00BFF8B50546FF +S21400F7300C4617461E464FF00003C4F205039842D7 +S21400F74007D040F25450C0F2010040F64A41F4F7A8 +S21400F75015FEB4F1100318BF0123002C0CBF0023C4 +S21400F76003F00103002B4FD0B4F1300318BF012380 +S21400F770202C0CBF002303F00103002B44D0B4F16F +S21400F780500318BF0123402C0CBF002303F00103D5 +S21400F790002B39D0B4F1700318BF0123602C0CBFC6 +S21400F7A0002303F001037BB3B4F1900318BF0123D9 +S21400F7B0802C0CBF002303F001032BB3B4F1B0037D +S21400F7C018BF0123A02C0CBF002303F00103DBB1FC +S21400F7D0B4F1D00318BF0123C02C0CBF002303F0E4 +S21400F7E001038BB1B4F1F00318BF0123E02C0CBF6A +S21400F7F0002303F001033BB140F25450C0F2010075 +S21400F80040F65241F4F7BAFD16F4005F14BF803597 +S21400F81084354FEA5404FFB22F55F8BD70B505463F +S21400F8200C4616464FF00003C4F20503984207D074 +S21400F83040F25450C0F2010040F67F41F4F79EFDBE +S21400F840B4F1100318BF0123002C0CBF002303F0F3 +S21400F8500103002B4FD0B4F1300318BF0123202C36 +S21400F8600CBF002303F00103002B44D0B4F1500377 +S21400F87018BF0123402C0CBF002303F00103002B0C +S21400F88039D0B4F1700318BF0123602C0CBF0023DD +S21400F89003F001037BB3B4F1900318BF0123802C5F +S21400F8A00CBF002303F001032BB3B4F1B00318BF61 +S21400F8B00123A02C0CBF002303F00103DBB1B4F13D +S21400F8C0D00318BF0123C02C0CBF002303F0010394 +S21400F8D08BB1B4F1F00318BF0123E02C0CBF00235A +S21400F8E003F001033BB140F25450C0F2010040F671 +S21400F8F08741F4F743FD16F4005F1DBF80356408AA +S21400F900285D843504BF6408285D70BDF8B50546DB +S21400F9100C4617461E464FF00003C4F205039842F5 +S21400F92007D040F25450C0F2010040F6B541F4F75B +S21400F93025FDB4F1100318BF0123002C0CBF0023D3 +S21400F94003F00103002B4FD0B4F1300318BF01239E +S21400F950202C0CBF002303F00103002B44D0B4F18D +S21400F960500318BF0123402C0CBF002303F00103F3 +S21400F970002B39D0B4F1700318BF0123602C0CBFE4 +S21400F980002303F001037BB3B4F1900318BF0123F7 +S21400F990802C0CBF002303F001032BB3B4F1B0039B +S21400F9A018BF0123A02C0CBF002303F00103DBB11A +S21400F9B0B4F1D00318BF0123C02C0CBF002303F002 +S21400F9C001038BB1B4F1F00318BF0123E02C0CBF88 +S21400F9D0002303F001033BB140F25450C0F2010093 +S21400F9E040F6BD41F4F7CAFC16F4005F14BF82353A +S21400F9F086354FEA5404FFB22F55F8BD70B505465C +S21400FA000C4616464FF00003C4F20503984207D092 +S21400FA1040F25450C0F2010040F6EB41F4F7AEFC61 +S21400FA20B4F1100318BF0123002C0CBF002303F011 +S21400FA300103002B4FD0B4F1300318BF0123202C54 +S21400FA400CBF002303F00103002B44D0B4F1500395 +S21400FA5018BF0123402C0CBF002303F00103002B2A +S21400FA6039D0B4F1700318BF0123602C0CBF0023FB +S21400FA7003F001037BB3B4F1900318BF0123802C7D +S21400FA800CBF002303F001032BB3B4F1B00318BF7F +S21400FA900123A02C0CBF002303F00103DBB1B4F15B +S21400FAA0D00318BF0123C02C0CBF002303F00103B2 +S21400FAB08BB1B4F1F00318BF0123E02C0CBF002378 +S21400FAC003F001033BB140F25450C0F2010040F68F +S21400FAD0F341F4F753FC16F4005F1DBF823564084B +S21400FAE0285D863504BF6408285D70BD38B50446B9 +S21400FAF00D464FF00003C4F20503984207D040F2CB +S21400FB005450C0F201004FF45561F4F737FC4FF63D +S21400FB109C43CFF6FE7305EA03033BB140F2545014 +S21400FB20C0F2010040F65351F4F728FC4FEA1543A3 +S21400FB30C4F83034B4F8003423F4587323F00303C5 +S21400FB404FEA03434FEA13432B439BB2A4F8003417 +S21400FB5038BD00BF10B504464FF00003C4F20503DD +S21400FB60984207D040F25450C0F2010040F6795156 +S21400FB70F4F704FCB4F800349BB243F01003A4F886 +S21400FB80003410BD10B504464FF00003C4F2050360 +S21400FB90984207D040F25450C0F2010040F694510B +S21400FBA0F4F7ECFBB4F8003423F010034FEA0343F9 +S21400FBB04FEA1343A4F8003410BD00BF10B5044646 +S21400FBC04FF00003C4F20503984207D040F25450A9 +S21400FBD0C0F201004FF45B61F4F7D0FBB4F80034D8 +S21400FBE09BB243F00403A4F8003410BD10B50446DD +S21400FBF04FF00003C4F20503984207D040F2545079 +S21400FC00C0F2010040F6CC51F4F7B8FBB4F800346B +S21400FC1023F004034FEA03434FEA1343A4F80034E7 +S21400FC2010BD00BF10B504464FF00003C4F2050334 +S21400FC30984207D040F25450C0F2010040F6E55119 +S21400FC40F4F79CFBA08980B210BD00BF38B504460F +S21400FC500D464FF00003C4F20503984207D040F269 +S21400FC605450C0F2010040F60161F4F787FB35B14D +S21400FC7094F8603043F0010384F8603038BD94F89F +S21400FC80603003F0FE0384F8603038BD00F12000D9 +S21400FC9000EB9100704700BF10B504464FF000031C +S21400FCA0C4F20503984207D040F25450C0F2010057 +S21400FCB040F66161F4F762FB94F8600000F09D0086 +S21400FCC010BD00BF70B505460C4616464FF0000343 +S21400FCD0C4F20503984207D040F25450C0F2010027 +S21400FCE040F69261F4F74AFBB4F1200318BF0123F3 +S21400FCF0102C0CBF002303F00103002B46D0B4F1F8 +S21400FD00400318BF0123302C0CBF002303F001036F +S21400FD10002B3BD0B4F1600318BF0123502C0CBF5E +S21400FD20002303F001038BB3B4F1800318BF012353 +S21400FD30702C0CBF002303F001033BB3B4F1A00307 +S21400FD4018BF0123902C0CBF002303F00103EBB176 +S21400FD50B4F1C00318BF0123B02C0CBF002303F07E +S21400FD6001039BB1B4F1E00318BF0123D02C0CBFF4 +S21400FD70002303F001034BB1F02C07D040F254509F +S21400FD80C0F2010040F69A61F4F7F8FA052E07D99A +S21400FD9040F25450C0F2010040F69B61F4F7EEFAD0 +S21400FDA04FEA8606D5F850244FF00F0303FA06F301 +S21400FDB022EA03034FEA141404FA06F643EA060698 +S21400FDC0C5F8506470BD00BF10B504464FF0000380 +S21400FDD0C4F20503984207D040F25450C0F2010026 +S21400FDE040F6C761F4F7CAFA4FF0020384F81C34F1 +S21400FDF010BD00BF10B504464FF00003C4F2050363 +S21400FE00984207D040F25450C0F2010040F6E56137 +S21400FE10F4F7B4FA4FF0030384F81C3410BD00BFA7 +S21400FE20437843F001034370704700BF437803F004 +S21400FE30FE034370704700BF10B504464FF480536E +S21400FE40C4F20003C31A18BF0123B0F1804F0CBFE1 +S21400FE50002303F001033BB140F26850C0F20100FA +S21400FE604FF03A01F4F78AFAA06800F0010010BDDE +S21400FE7010B504464FF48053C4F20003C31A18BFEB +S21400FE800123B0F1804F0CBF002303F001033BB108 +S21400FE9040F26850C0F201004FF05801F4F76EFAD5 +S21400FEA0A36843F00103A36010BD00BF10B504466D +S21400FEB04FF48053C4F20003C31A18BF0123B0F1F5 +S21400FEC0804F0CBF002303F001033BB140F26850A3 +S21400FED0C0F201004FF07701F4F750FAA36843F040 +S21400FEE00203A36010BD00BF10B504464FF4805354 +S21400FEF0C4F20003C31A18BF0123B0F1804F0CBF31 +S21400FF00002303F001033BB140F26850C0F2010049 +S21400FF104FF09601F4F732FAA36823F00203A360C9 +S21400FF2010BD00BF10B504464FF48053C4F2000362 +S21400FF30C31A18BF0123B0F1804F0CBF002303F093 +S21400FF4001033BB140F26850C0F201004FF0AF0130 +S21400FF50F4F714FA4FF00103C4F8003C10BD00BFDC +S21400FF6010B504464FF48053C4F20003C31A18BFFA +S21400FF700123B0F1804F0CBF002303F001033BB117 +S21400FF8040F26850C0F201004FF0C901F4F7F6F9EC +S21400FF904EF25153C1F6CC23C4F8003C10BD00BF4E +S21400FFA010B504464FF48053C4F20003C31A18BFBA +S21400FFB00123B0F1804F0CBF002303F001033BB1D7 +S21400FFC040F26850C0F201004FF0E301F4F7D6F9B2 +S21400FFD0D4F8000C012814BF0020012010BD00BF7B +S21400FFE038B504460D464FF48053C4F20003C31AD6 +S21400FFF018BF0123B0F1804F0CBF002303F00103AC +S2140100003BB140F26850C0F201004FF48371F4F73F +S214010010B5F9256038BD00BF10B504464FF48053CE +S214010020C4F20003C31A18BF0123B0F1804F0CBFFE +S214010030002303F001033BB140F26850C0F2010017 +S2140100404FF49171F4F79AF9206810BD10B5044683 +S2140100504FF48053C4F20003C31A18BF0123B0F152 +S214010060804F0CBF002303F001033BB140F2685000 +S214010070C0F2010040F23B11F4F780F9606810BD50 +S21401008010B50C464FF48053C4F20003C31A18BFD0 +S2140100900123B0F1804F0CBF002303F001033BB1F5 +S2140100A040F26850C0F2010040F25D11F4F766F9C3 +S2140100B04FF022002146F8F72BFD4FF02200F8F70B +S2140100C003FE10BD08B54FF48053C4F20003C31AF3 +S2140100D018BF0123B0F1804F0CBF002303F00103CA +S2140100E03BB140F26850C0F2010040F28111F4F7D2 +S2140100F045F94FF02200F8F73BFE4FF02200F8F7E3 +S2140101004BFD08BD10B504464FF48053C4F20003FE +S214010110C31A18BF0123B0F1804F0CBF002303F0B0 +S21401012001033BB140F26850C0F201004FF4D271B6 +S214010130F4F724F9A36843F00103A36010BD00BFE0 +S21401014038B504460D464FF48053C4F20003C31A73 +S21401015018BF0123B0F1804F0CBF002303F0010349 +S2140101603BB140F26850C0F201004FF4E171F4F780 +S21401017005F90DB1606938BD206938BD10B5044672 +S2140101804FF48053C4F20003C31A18BF0123B0F121 +S214010190804F0CBF002303F001033BB140F26850CF +S2140101A0C0F2010040F2ED11F4F7E8F84FF0010358 +S2140101B0E36010BD10B504464FF48053C4F200034B +S2140101C0C31A18BF0123B0F1804F0CBF002303F000 +S2140101D001033BB140F26850C0F201004FF40371D5 +S2140101E0F4F7CCF8D4F8183443F48073C4F8183410 +S2140101F010BD00BF10B504464FF48053C4F200038F +S214010200C31A18BF0123B0F1804F0CBF002303F0BF +S21401021001033BB140F26850C0F2010040F22721D1 +S214010220F4F7ACF8D4F8183423F48073C4F818340F +S21401023010BD00BF6C69622F6472697665726C6965 +S214010240622F6164632E63006C69622F6472697643 +S21401025065726C69622F636F6D702E63000000001B +S2140102606C69622F6472697665726C69622F65705B +S214010270692E63006C69622F6472697665726C69B7 +S214010280622F65746865726E65742E6300000000E7 +S21401029034E10F4004E40F4008E40F400CE40F4043 +S2140102A06C69622F6472697665726C69622F666C1E +S2140102B06173682E6300000030E10F4004E20F40D6 +S2140102C008E20F400CE20F406C69622F6472697697 +S2140102D065726C69622F6770696F2E63000000009B +S2140102E0004000400080054000500040009005405E +S2140102F00060004000A005400070004000B00540CE +S2140103000040024000C005400050024000D00540B9 +S2140103100060024000E005400070024000F0054029 +S21401032000D00340000006406C69622F6472697653 +S21401033065726C69622F68696265726E6174652E9A +S214010340630000006C69622F6472697665726C697D +S214010350622F6932632E63006C69622F647269765C +S21401036065726C69622F6932732E63006C69622F45 +S2140103706472697665726C69622F696E74657272F1 +S2140103807570742E63000000000700000006000070 +S2140103900005000000040000000300000002000049 +S2140103A000010000000000000000000018ED00E061 +S2140103B01CED00E020ED00E000E400E004E400E0D5 +S2140103C008E400E00CE400E010E400E014E400E0DF +S2140103D018E400E01CE400E020E400E024E400E08F +S2140103E028E400E02CE400E030E400E034E400E03F +S2140103F06C69622F6472697665726C69622F6D70C2 +S214010400752E63006C69622F6472697665726C6919 +S214010410622F70776D2E63006C69622F6472697645 +S21401042065726C69622F7165692E63006C69622F53 +S2140104306472697665726C69622F7373692E6300E4 +S21401044010E00F4014E00F401CE00F4010E00F409A +S21401045040420F0000201C0080841E000080250002 +S214010460999E36000040380000093D0000803E009D +S21401047000004B00404B4C0000204E00808D5B007E +S21401048000C05D000080700000127A0000007D0050 +S21401049080969800001BB7000080BB00C0E8CE0025 +S2140104A0647ADA000024F4000000FA006C69622F16 +S2140104B06472697665726C69622F73797363746CA2 +S2140104C02E63000000E10F4004E10F4008E10F40F9 +S2140104D010E10F4014E10F4018E10F4040E00F40DB +S2140104E044E00F4048E00F4020E10F4024E10F4078 +S2140104F028E10F406C69622F6472697665726C69D7 +S214010500622F7379737469636B2E63006C69622F53 +S2140105106472697665726C69622F74696D65722E94 +S214010520630000006C69622F6472697665726C699B +S214010530622F756172742E63000000006C69622F71 +S2140105406472697665726C69622F75646D612E637B +S214010550000000006C69622F6472697665726C69CE +S214010560622F7573622E63006C69622F64726976FE +S21401057065726C69622F7761746368646F672E6356 +S2080105800000000071 +S2140105840000000000000000000000000000000061 +S2140105940000000000000000000000000000000051 +S2140105A40000000000000000000000000000000041 +S2140105B40000000000000000000000000000000031 +S2140105C40000000000000000000000000000000021 +S2140105D40000000000000000000000000000000011 +S2140105E40000000000000000000000000000000001 +S2140105F400000000000000000000000000000000F1 +S21401060400000000000000000000000000000000E0 +S21401061400000000000000000000000000000000D0 +S21401062400000000000000000000000000000000C0 +S21401063400000000000000000000000000000000B0 +S21401064400000000000000000000000000000000A0 +S2140106540000000000000000000000000000000090 +S2140106640000000000000000000000000000000080 +S2140106740000000000000000000000000000000070 +S2140106840000000000000000000000000000000060 +S21001069400000000000000000000000054 +S804004000BB diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/boot.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/boot.c new file mode 100644 index 00000000..2caf18da --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/boot.c @@ -0,0 +1,172 @@ +/**************************************************************************************** +| Description: demo program bootloader interface source file +| File Name: boot.c +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "header.h" /* generic header */ + + +/**************************************************************************************** +** NAME: BootActivate +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Bootloader activation function. +** +****************************************************************************************/ +static void BootActivate(void) +{ + void (*pEntryFromProgFnc)(void); + + /* stop the timer from generating interrupts */ + TimeDeinit(); + /* set pointer to the address of function EntryFromProg in the bootloader. note that + * 1 is added to this address to enable a switch from Thumb2 to Thumb mode + */ + pEntryFromProgFnc = (void*)0x000000F0 + 1; + /* call EntryFromProg to activate the bootloader. */ + pEntryFromProgFnc(); +} /*** end of BootActivate ***/ + + +#if (BOOT_COM_UART_ENABLE > 0) +/**************************************************************************************** +* U N I V E R S A L A S Y N C H R O N O U S R X T X I N T E R F A C E +****************************************************************************************/ + +/**************************************************************************************** +* Function prototypes +****************************************************************************************/ +static unsigned char UartReceiveByte(unsigned char *data); + + +/**************************************************************************************** +** NAME: BootComInit +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Initializes the UART communication interface +** +****************************************************************************************/ +void BootComInit(void) +{ + /* enable the UART0 peripheral */ + SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); + /* enable the and configure UART0 related peripherals and pins */ + SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); + GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); + /* configure the UART0 baudrate and communication parameters */ + UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), BOOT_COM_UART_BAUDRATE, + (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | + UART_CONFIG_PAR_NONE)); +} /*** end of BootComInit ***/ + + +/**************************************************************************************** +** NAME: BootComCheckActivationRequest +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Receives the CONNECT request from the host, which indicates that the +** bootloader should be activated and, if so, activates it. +** +****************************************************************************************/ +void BootComCheckActivationRequest(void) +{ + static unsigned char xcpCtoReqPacket[BOOT_COM_UART_RX_MAX_DATA+1]; + static unsigned char xcpCtoRxLength; + static unsigned char xcpCtoRxInProgress = 0; + + /* start of cto packet received? */ + if (xcpCtoRxInProgress == 0) + { + /* store the message length when received */ + if (UartReceiveByte(&xcpCtoReqPacket[0]) == 1) + { + /* indicate that a cto packet is being received */ + xcpCtoRxInProgress = 1; + + /* reset packet data count */ + xcpCtoRxLength = 0; + } + } + else + { + /* store the next packet byte */ + if (UartReceiveByte(&xcpCtoReqPacket[xcpCtoRxLength+1]) == 1) + { + /* increment the packet data count */ + xcpCtoRxLength++; + + /* check to see if the entire packet was received */ + if (xcpCtoRxLength == xcpCtoReqPacket[0]) + { + /* done with cto packet reception */ + xcpCtoRxInProgress = 0; + + /* check if this was an XCP CONNECT command */ + if ((xcpCtoReqPacket[1] == 0xff) && (xcpCtoReqPacket[2] == 0x00)) + { + /* connection request received so start the bootloader */ + BootActivate(); + } + } + } + } +} /*** end of BootComCheckActivationRequest ***/ + + +/**************************************************************************************** +** NAME: UartReceiveByte +** PARAMETER: data pointer to byte where the data is to be stored. +** RETURN VALUE: 1 if a byte was received, 0 otherwise. +** DESCRIPTION: Receives a communication interface byte if one is present. +** +****************************************************************************************/ +static unsigned char UartReceiveByte(unsigned char *data) +{ + signed long result; + + /* try to read a newly received byte */ + result = UARTCharGetNonBlocking(UART0_BASE); + /* check if a new byte was received */ + if(result != -1) + { + /* store the received byte */ + *data = (unsigned char)result; + /* inform caller of the newly received byte */ + return 1; + } + /* inform caller that no new data was received */ + return 0; +} /*** end of UartReceiveByte ***/ +#endif /* BOOT_COM_UART_ENABLE > 0 */ + + +/*********************************** end of boot.c *************************************/ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/boot.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/boot.h new file mode 100644 index 00000000..6da3f21c --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/boot.h @@ -0,0 +1,42 @@ +/**************************************************************************************** +| Description: demo program bootloader interface header file +| File Name: boot.h +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ +#ifndef BOOT_H +#define BOOT_H + +/**************************************************************************************** +* Function prototypes +****************************************************************************************/ +void BootComInit(void); +void BootComCheckActivationRequest(void); + + +#endif /* BOOT_H */ +/*********************************** end of boot.h *************************************/ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/cmd/build.bat b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/cmd/build.bat new file mode 100644 index 00000000..44c0c1b8 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/cmd/build.bat @@ -0,0 +1,2 @@ +@echo off +make --directory=../ all diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/cmd/clean.bat b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/cmd/clean.bat new file mode 100644 index 00000000..32c4b5f2 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/cmd/clean.bat @@ -0,0 +1,2 @@ +@echo off +make --directory=../ clean diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/cstart.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/cstart.c new file mode 100644 index 00000000..348255d9 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/cstart.c @@ -0,0 +1,94 @@ +/**************************************************************************************** +| Description: Demo program C startup source file +| File Name: cstart.c +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2011 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "header.h" /* generic header */ + + +/**************************************************************************************** +* External function protoypes +****************************************************************************************/ +extern int main(void); + + +/**************************************************************************************** +* External data declarations +****************************************************************************************/ +/* these externals are declared by the linker */ +extern unsigned long _etext; +extern unsigned long _data; +extern unsigned long _edata; +extern unsigned long _bss; +extern unsigned long _ebss; +extern unsigned long _estack; + + +/**************************************************************************************** +** NAME: reset_handler +** PARAMETER: none +** RETURN VALUE: none +** DESCRIPTION: Reset interrupt service routine. Configures the stack, initializes +** RAM and jumps to function main. +** +****************************************************************************************/ +void reset_handler(void) +{ + unsigned long *pSrc, *pDest; + + /* initialize stack pointer */ + __asm(" ldr r1, =_estack\n" + " mov sp, r1"); + /* copy the data segment initializers from flash to SRAM */ + pSrc = &_etext; + for(pDest = &_data; pDest < &_edata; ) + { + *pDest++ = *pSrc++; + } + /* zero fill the bss segment. this is done with inline assembly since this will + * clear the value of pDest if it is not kept in a register. + */ + __asm(" ldr r0, =_bss\n" + " ldr r1, =_ebss\n" + " mov r2, #0\n" + " .thumb_func\n" + "zero_loop:\n" + " cmp r0, r1\n" + " it lt\n" + " strlt r2, [r0], #4\n" + " blt zero_loop"); + /* start the software application by calling its entry point */ + main(); +} /*** end of reset_handler ***/ + + +/************************************ end of cstart.c **********************************/ \ No newline at end of file diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/header.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/header.h new file mode 100644 index 00000000..f14127dc --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/header.h @@ -0,0 +1,56 @@ +/**************************************************************************************** +| Description: generic header file +| File Name: header.h +| +|---------------------------------------------------------------------------------------- +| C O P Y R I G H T +|---------------------------------------------------------------------------------------- +| Copyright (c) 2012 by Feaser http://www.feaser.com All rights reserved +| +|---------------------------------------------------------------------------------------- +| L I C E N S E +|---------------------------------------------------------------------------------------- +| This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +| modify it under the terms of the GNU General Public License as published by the Free +| Software Foundation, either version 3 of the License, or (at your option) any later +| version. +| +| OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +| PURPOSE. See the GNU General Public License for more details. +| +| You should have received a copy of the GNU General Public License along with OpenBLT. +| If not, see . +| +| A special exception to the GPL is included to allow you to distribute a combined work +| that includes OpenBLT without being obliged to provide the source code for any +| proprietary components. The exception text is included at the bottom of the license +| file . +| +****************************************************************************************/ +#ifndef HEADER_H +#define HEADER_H + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "../Boot/config.h" /* bootloader configuration */ +#include "boot.h" /* bootloader interface driver */ +#include "irq.h" /* IRQ driver */ +#include "led.h" /* LED driver */ +#include "time.h" /* Timer driver */ +#include "inc/hw_ints.h" +#include "inc/hw_memmap.h" +#include "inc/hw_nvic.h" +#include "inc/hw_sysctl.h" +#include "inc/hw_types.h" +#include "driverlib/sysctl.h" +#include "driverlib/gpio.h" +#include "driverlib/uart.h" +#include "driverlib/interrupt.h" +#include "driverlib/systick.h" + + + +#endif /* HEADER_H */ +/*********************************** end of header.h ***********************************/ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/DemoProg.project b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/DemoProg.project new file mode 100644 index 00000000..7d0e7bf3 --- /dev/null +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/DemoProg.project @@ -0,0 +1,177 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + break main +continue + + + + + + + make clean + make + + + + None + $(WorkspacePath)/.. + + + + + + + + + + + + + + + + + + + + + + + make clean + make + + + + None + $(WorkspacePath) + + + + + + + + diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/DemoProg.tags b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Prog/ide/DemoProg.tags new file mode 100644 index 0000000000000000000000000000000000000000..8f5123c9e9660a69d8dbb081c8d4ca7284f9c171 GIT binary patch literal 9706496 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