From bdf2306f1690fa3232595b65901f4b846d8aa77a Mon Sep 17 00:00:00 2001 From: Gabor Toth Date: Wed, 24 Jun 2020 17:06:45 +0200 Subject: [PATCH 1/2] Add platform support to Musca S1 Change-Id: Iebdd4bc402446caba6b7bd894eddb0a85ed884d8 Signed-off-by: Mark Horvath Signed-off-by: Gabor Toth --- cmsis/device/rtos/mbed_lib.json | 6 + platform/mbed_lib.json | 4 + .../kvstore/kv_config/global/mbed_lib.json | 3 + .../kv_config/tdb_internal/mbed_lib.json | 4 + .../TARGET_ARM_SSG/TARGET_MUSCA_S1/LICENSE | 2 + .../TARGET_MUSCA_S1/LICENSE-BSD-3-Clause | 26 + .../LICENSE-permissive-binary-license-1.0.txt | 49 + .../Libraries/mt25ql_flash_lib.c | 903 +++++++++++ .../Libraries/mt25ql_flash_lib.h | 273 ++++ .../TARGET_MUSCA_S1/PeripheralNames.h | 49 + .../TARGET_ARM_SSG/TARGET_MUSCA_S1/PinNames.h | 117 ++ .../TARGET_ARM_SSG/TARGET_MUSCA_S1/device.h | 24 + .../device/TOOLCHAIN_ARMC6/musca_ns.sct | 68 + .../TOOLCHAIN_ARMC6/startup_cmsdk_musca_ns.S | 242 +++ .../device/TOOLCHAIN_GCC_ARM/musca_ns.ld | 197 +++ .../startup_cmsdk_musca_ns.S | 357 +++++ .../TARGET_MUSCA_S1/device/cmsis.h | 86 ++ .../TARGET_MUSCA_S1/device/cmsis_nvic.h | 35 + .../device/cmsis_nvic_virtual.h | 52 + .../TARGET_MUSCA_S1/device/device_cfg.h | 99 ++ .../device/device_definition.c | 573 +++++++ .../device/device_definition.h | 283 ++++ .../device/drivers/cache_drv.c | 340 ++++ .../device/drivers/cache_drv.h | 381 +++++ .../device/drivers/gpio_cmsdk_drv.c | 326 ++++ .../device/drivers/gpio_cmsdk_drv.h | 281 ++++ .../device/drivers/i2c_ip6510_drv.c | 1364 +++++++++++++++++ .../device/drivers/i2c_ip6510_drv.h | 649 ++++++++ .../device/drivers/musca_s1_scc_drv.c | 419 +++++ .../device/drivers/musca_s1_scc_drv.h | 136 ++ .../device/drivers/qspi_ip6514e_drv.c | 757 +++++++++ .../device/drivers/qspi_ip6514e_drv.h | 418 +++++ .../device/drivers/timer_cmsdk_drv.c | 227 +++ .../device/drivers/timer_cmsdk_drv.h | 256 ++++ .../device/drivers/timer_gp_drv.c | 170 ++ .../device/drivers/timer_gp_drv.h | 203 +++ .../device/drivers/uart_pl011_drv.c | 1021 ++++++++++++ .../device/drivers/uart_pl011_drv.h | 854 +++++++++++ .../device/platform_base_address.h | 179 +++ .../device/platform_description.h | 27 + .../TARGET_MUSCA_S1/device/platform_irq.h | 135 ++ .../TARGET_MUSCA_S1/device/platform_pins.h | 47 + .../TARGET_MUSCA_S1/device/platform_regs.h | 341 +++++ .../TARGET_MUSCA_S1/device/system_core_init.c | 75 + .../TARGET_MUSCA_S1/device/system_core_init.h | 58 + .../TARGET_MUSCA_S1/flash_api_qspi.c | 136 ++ .../TARGET_MUSCA_S1/gpio_api_ns.c | 141 ++ .../TARGET_MUSCA_S1/gpio_irq_api.c | 71 + .../TARGET_MUSCA_S1/gpio_object.h | 51 + .../TARGET_ARM_SSG/TARGET_MUSCA_S1/i2c_api.c | 427 ++++++ .../TARGET_MUSCA_S1/lp_ticker.c | 91 ++ .../TARGET_MUSCA_S1/mbed_serial_platform.c | 139 ++ .../TARGET_MUSCA_S1/mbed_serial_platform.h | 42 + .../TARGET_MUSCA_S1/mcuboot.bin | Bin 0 -> 40060 bytes .../TARGET_ARM_SSG/TARGET_MUSCA_S1/objects.h | 76 + .../TARGET_MUSCA_S1/partition/flash_layout.h | 239 +++ .../partition/image_macros_preprocessed_ns.c | 25 + .../partition/image_macros_preprocessed_s.c | 25 + .../TARGET_MUSCA_S1/partition/region_defs.h | 160 ++ .../TARGET_ARM_SSG/TARGET_MUSCA_S1/pinmap.c | 123 ++ .../TARGET_MUSCA_S1/s_veneers.o | Bin 0 -> 644 bytes .../TARGET_MUSCA_S1/serial_api.c | 217 +++ .../TARGET_MUSCA_S1/sleep_api.c | 48 + .../TARGET_MUSCA_S1/tfm_ioctl_api.h | 251 +++ .../TARGET_MUSCA_S1/tfm_ioctl_ns_api.c | 299 ++++ .../TARGET_ARM_SSG/TARGET_MUSCA_S1/tfm_s.axf | Bin 0 -> 1038136 bytes .../TARGET_ARM_SSG/TARGET_MUSCA_S1/tfm_s.bin | Bin 0 -> 389408 bytes .../TARGET_MUSCA_S1/us_ticker.c | 124 ++ targets/TARGET_ARM_SSG/mbed_rtx.h | 4 +- targets/targets.json | 60 + tools/targets/ARM_MUSCA_S1.py | 111 ++ tools/targets/__init__.py | 15 + tools/targets/musca_s1-root-rsa-3072.md | 11 + tools/targets/musca_s1-root-rsa-3072.pem | 39 + tools/targets/musca_s1-root-rsa-3072_1.pem | 39 + 75 files changed, 15078 insertions(+), 2 deletions(-) create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/LICENSE create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/LICENSE-BSD-3-Clause create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/LICENSE-permissive-binary-license-1.0.txt create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/Libraries/mt25ql_flash_lib.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/Libraries/mt25ql_flash_lib.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/PeripheralNames.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/PinNames.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_ARMC6/musca_ns.sct create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_ARMC6/startup_cmsdk_musca_ns.S create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_GCC_ARM/musca_ns.ld create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_GCC_ARM/startup_cmsdk_musca_ns.S create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/cmsis.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/cmsis_nvic.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/cmsis_nvic_virtual.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/device_cfg.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/device_definition.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/device_definition.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/cache_drv.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/cache_drv.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/gpio_cmsdk_drv.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/gpio_cmsdk_drv.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/i2c_ip6510_drv.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/i2c_ip6510_drv.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/musca_s1_scc_drv.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/musca_s1_scc_drv.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/qspi_ip6514e_drv.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/qspi_ip6514e_drv.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_cmsdk_drv.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_cmsdk_drv.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_gp_drv.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_gp_drv.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/uart_pl011_drv.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/uart_pl011_drv.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/platform_base_address.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/platform_description.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/platform_irq.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/platform_pins.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/platform_regs.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/system_core_init.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/system_core_init.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/flash_api_qspi.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/gpio_api_ns.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/gpio_irq_api.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/gpio_object.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/i2c_api.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/lp_ticker.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/mbed_serial_platform.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/mbed_serial_platform.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/mcuboot.bin create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/objects.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/flash_layout.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/image_macros_preprocessed_ns.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/image_macros_preprocessed_s.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/region_defs.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/pinmap.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/s_veneers.o create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/serial_api.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/sleep_api.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/tfm_ioctl_api.h create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/tfm_ioctl_ns_api.c create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/tfm_s.axf create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/tfm_s.bin create mode 100644 targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/us_ticker.c create mode 100644 tools/targets/ARM_MUSCA_S1.py create mode 100644 tools/targets/musca_s1-root-rsa-3072.md create mode 100644 tools/targets/musca_s1-root-rsa-3072.pem create mode 100644 tools/targets/musca_s1-root-rsa-3072_1.pem diff --git a/cmsis/device/rtos/mbed_lib.json b/cmsis/device/rtos/mbed_lib.json index 6ef6c49d6fc..46bc00ce052 100644 --- a/cmsis/device/rtos/mbed_lib.json +++ b/cmsis/device/rtos/mbed_lib.json @@ -84,6 +84,12 @@ }, "MCU_PSOC6_M4": { "target.macros_add": ["CY_RTOS_AWARE"] + }, + "ARM_MUSCA_S1": { + "mutex-num": 4, + "semaphore-num": 4, + "thread-num": 9, + "thread-user-stack-size": 8096 } } } diff --git a/platform/mbed_lib.json b/platform/mbed_lib.json index 8c1b1c9e5f0..c08a43330e2 100644 --- a/platform/mbed_lib.json +++ b/platform/mbed_lib.json @@ -230,6 +230,10 @@ "NUCLEO_L452RE-P": { "crash-capture-enabled": true, "fatal-error-auto-reboot-enabled": true + }, + "ARM_MUSCA_S1": { + "stdio-convert-newlines": true, + "stdio-baud-rate": 115200 } } } diff --git a/storage/kvstore/kv_config/global/mbed_lib.json b/storage/kvstore/kv_config/global/mbed_lib.json index 173a7422af8..b15e4bfda97 100644 --- a/storage/kvstore/kv_config/global/mbed_lib.json +++ b/storage/kvstore/kv_config/global/mbed_lib.json @@ -43,6 +43,9 @@ }, "ARM_MUSCA_B1_S": { "storage_type": "TDB_INTERNAL" + }, + "ARM_MUSCA_S1_S": { + "storage_type": "TDB_INTERNAL" } } } diff --git a/storage/kvstore/kv_config/tdb_internal/mbed_lib.json b/storage/kvstore/kv_config/tdb_internal/mbed_lib.json index ec7ee1bd64b..42518aaed12 100644 --- a/storage/kvstore/kv_config/tdb_internal/mbed_lib.json +++ b/storage/kvstore/kv_config/tdb_internal/mbed_lib.json @@ -31,6 +31,10 @@ "internal_size": "0x8000", "internal_base_address": "0x10000000" }, + "ARM_MUSCA_S1_S": { + "internal_size": "0x8000", + "internal_base_address": "0x1A1CA000" + }, "FVP_MPS2": { "internal_size": "0x200000", "internal_base_address": "0x00200000" diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/LICENSE b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/LICENSE new file mode 100644 index 00000000000..d859683ac7e --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/LICENSE @@ -0,0 +1,2 @@ +Unless specifically indicated otherwise in a file, MUSCA_S1 files in this directory are licensed under the BSD-3-Clause license, +as can be found in: LICENSE-bsd-3-clause.txt diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/LICENSE-BSD-3-Clause b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/LICENSE-BSD-3-Clause new file mode 100644 index 00000000000..2c212ccd579 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/LICENSE-BSD-3-Clause @@ -0,0 +1,26 @@ +Copyright 2019-2020 Arm Limited and affiliates. +SPDX-License-Identifier: BSD-3-Clause + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of the copyright holder nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/LICENSE-permissive-binary-license-1.0.txt b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/LICENSE-permissive-binary-license-1.0.txt new file mode 100644 index 00000000000..92d2328166e --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/LICENSE-permissive-binary-license-1.0.txt @@ -0,0 +1,49 @@ +Permissive Binary License + +Version 1.0, December 2020 + +Redistribution. Redistribution and use in binary form, without +modification, are permitted provided that the following conditions are +met: + +1) Redistributions must reproduce the above copyright notice and the + following disclaimer in the documentation and/or other materials + provided with the distribution. + +2) Unless to the extent explicitly permitted by law, no reverse + engineering, decompilation, or disassembly of this software is + permitted. + +3) Redistribution as part of a software development kit must include the + accompanying file named DEPENDENCIES and any dependencies listed in + that file. + +4) Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +Limited patent license. The copyright holders (and contributors) grant a +worldwide, non-exclusive, no-charge, royalty-free patent license to +make, have made, use, offer to sell, sell, import, and otherwise +transfer this software, where such license applies only to those patent +claims licensable by the copyright holders (and contributors) that are +necessarily infringed by this software. This patent license shall not +apply to any combinations that include this software. No hardware is +licensed hereunder. + +If you institute patent litigation against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that the software +itself infringes your patent(s), then your rights granted under this +license shall terminate as of the date such litigation is filed. + +DISCLAIMER. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND +CONTRIBUTORS "AS IS." ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT +NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED +TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/Libraries/mt25ql_flash_lib.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/Libraries/mt25ql_flash_lib.c new file mode 100644 index 00000000000..3b57c6c6a2d --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/Libraries/mt25ql_flash_lib.c @@ -0,0 +1,903 @@ +/* + * Copyright (c) 2018-2019 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +/* Use memcpy function */ +#include + +#include "mt25ql_flash_lib.h" +#include "qspi_ip6514e_drv.h" + +/** Setter bit manipulation macro */ +#define SET_BIT(WORD, BIT_INDEX) ((WORD) |= (1U << (BIT_INDEX))) +/** Clearing bit manipulation macro */ +#define CLR_BIT(WORD, BIT_INDEX) ((WORD) &= ~(1U << (BIT_INDEX))) +/** Getter bit manipulation macro */ +#define GET_BIT(WORD, BIT_INDEX) (bool)(((WORD) & (1U << (BIT_INDEX)))) + +#define BITS_PER_WORD 32U +#define BYTES_PER_WORD 4U + +#define ARG_NOT_USED 0 +#define ARG_PTR_NOT_USED NULL + +/** MT25QL used command */ +#define WRITE_ENABLE_CMD 0x06U +#define READ_ENHANCED_VOLATILE_CFG_REG_CMD 0x65U +#define WRITE_ENHANCED_VOLATILE_CFG_REG_CMD 0x61U +#define READ_VOLATILE_CFG_REG_CMD 0x85U +#define WRITE_VOLATILE_CFG_REG_CMD 0x81U +#define READ_FLAG_STATUS_REG_CMD 0x70U +#define SUBSECTOR_ERASE_32KB_CMD 0x52U +#define SUBSECTOR_ERASE_4KB_CMD 0x20U +#define SECTOR_ERASE_CMD 0xD8U +#define BULK_ERASE_CMD 0xC7U +/* + * The baud rate divisor in \ref mt25ql_dev_t needs to be configured adequately + * to handle those commands. + */ +#define QUAD_OUTPUT_FAST_READ_CMD 0x6BU +#define FAST_READ_CMD 0x0BU +#define READ_CMD 0x03U +#define QUAD_INPUT_FAST_PROGRAM_CMD 0x32U +#define PAGE_PROGRAM_CMD 0x02U + +/** MT25QL Enhanced Volatile Configuration Register access */ +#define ENHANCED_VOLATILE_CFG_REG_LEN 1U +#define ENHANCED_VOLATILE_CFG_REG_QSPI_POS 7U +#define ENHANCED_VOLATILE_CFG_REG_DSPI_POS 6U + +/** MT25QL Volatile Configuration Register access */ +#define VOLATILE_CFG_REG_LEN 1U +#define VOLATILE_CFG_REG_DUMMY_CYCLES_POS 4U +#define VOLATILE_CFG_REG_DUMMY_CYCLES_BITS 4U + +/** MT25QL Flag Status Register access */ +#define FLAG_STATUS_REG_LEN 1U +#define FLAG_STATUS_REG_READY_POS 7U + +/* + * 10 is the minimal number of dummy clock cycles needed to reach the maximal + * frequency of the Quad Output Fast Read Command. + */ +#define QUAD_OUTPUT_FAST_READ_DUMMY_CYCLES 10U +#define FAST_READ_DUMMY_CYCLES 8U +#define RESET_STATE_DUMMY_CYCLES 8U +#define DEFAULT_READ_DUMMY_CYCLES 0U +#define QUAD_INPUT_FAST_PROGRAM_DUMMY_CYCLES 0U +#define PAGE_PROGRAM_DUMMY_CYCLES 0U + +/* Only up to 8 bytes can be read or written using the Flash commands. */ +#define CMD_DATA_MAX_SIZE 8U + +/** + * \brief Change specific bits in a 32 bits word. + * + * \param[in,out] word Pointer of the word to change + * \param[in] bits bits_length bits to put at bits_pos in the word + * pointed + * \param[in] bits_length Number of bits to change + * \param[in] bits_pos Position of the bits to change + * + * \note This function will do nothing if the parameters given are incorrect: + * * word is NULL + * * bits_length + bits_pos > 32 + * * bits_length is 0 + */ +static void change_bits_in_word(volatile uint32_t *word, + uint32_t bits, + uint32_t bits_length, + uint32_t bits_pos) +{ + uint32_t mask; + + if ((word == NULL) || + ((bits_length + bits_pos) > BITS_PER_WORD) || + (bits_length == 0U)) { + /* Silently fail */ + return; + } + + /* Change all the bits */ + if (bits_length == BITS_PER_WORD) { + *word = bits; + return; + } + + mask = ((1U << bits_length) - 1); + /* + * We change the bits in three steps: + * - clear bits_length bits with zeroes at bits_pos in the word + * - mask bits in case it contains more than bits_length bits + * - set the new bits in the cleared word + * Because the data pointed by word is only read once, the data will still + * be coherent after an interruption that changes it. + */ + *word = ((*word & ~(mask << bits_pos)) | ((bits & mask) << bits_pos)); +} + +/** + * \brief Send the Write Enable command, needed before any write. + * + * \param[in] dev Pointer to MT25QL device structure \ref mt25ql_dev_t + */ +static void send_write_enable(struct mt25ql_dev_t* dev) +{ + qspi_ip6514e_send_simple_cmd(dev->controller, WRITE_ENABLE_CMD); +} + +/** + * \brief Set SPI mode on the flash device and on the controller. + * + * \param[in] dev Pointer to MT25QL device structure \ref mt25ql_dev_t + * \param[in] spi_mode SPI mode to be set on flash device and controller + * \ref qspi_ip6514e_spi_mode_t + * + * \return Return error code as specified in \ref mt25ql_error_t + */ +static enum mt25ql_error_t set_spi_mode(struct mt25ql_dev_t* dev, + enum qspi_ip6514e_spi_mode_t spi_mode) +{ + uint8_t enhanced_volatile_cfg_reg = 0; + enum qspi_ip6514e_error_t controller_error; + + /* Read the Enhanced Volatile Configuration Register, modify it according + * to the requested SPI mode then write back the modified value to the + * register. This will activate the SPI mode on the flash side. + */ + controller_error = qspi_ip6514e_send_read_cmd( + dev->controller, + READ_ENHANCED_VOLATILE_CFG_REG_CMD, + &enhanced_volatile_cfg_reg, + ENHANCED_VOLATILE_CFG_REG_LEN, + ARG_NOT_USED, + ARG_NOT_USED, + 0); /* No dummy cycles needed for + this command. */ + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + + switch(spi_mode) { + case QSPI_IP6514E_SPI_MODE: + /* Disable the Dual- and Quad-SPI modes. + * Clearing the bit enables the mode, setting it disables it. + */ + SET_BIT(enhanced_volatile_cfg_reg, ENHANCED_VOLATILE_CFG_REG_DSPI_POS); + SET_BIT(enhanced_volatile_cfg_reg, ENHANCED_VOLATILE_CFG_REG_QSPI_POS); + break; + case QSPI_IP6514E_DSPI_MODE: + /* Disable the Quad-SPI mode and activate DSPI mode. + * Clearing the bit enables the mode, setting it disables it. + */ + CLR_BIT(enhanced_volatile_cfg_reg, ENHANCED_VOLATILE_CFG_REG_DSPI_POS); + SET_BIT(enhanced_volatile_cfg_reg, ENHANCED_VOLATILE_CFG_REG_QSPI_POS); + break; + case QSPI_IP6514E_QSPI_MODE: + /* Disable the Dual-SPI mode and activate QSPI mode. + * Clearing the bit enables the mode, setting it disables it. + */ + SET_BIT(enhanced_volatile_cfg_reg, ENHANCED_VOLATILE_CFG_REG_DSPI_POS); + CLR_BIT(enhanced_volatile_cfg_reg, ENHANCED_VOLATILE_CFG_REG_QSPI_POS); + break; + default: + return MT25QL_ERR_WRONG_ARGUMENT; + } + + send_write_enable(dev); + + controller_error = qspi_ip6514e_send_write_cmd( + dev->controller, + WRITE_ENHANCED_VOLATILE_CFG_REG_CMD, + &enhanced_volatile_cfg_reg, + ENHANCED_VOLATILE_CFG_REG_LEN, + ARG_NOT_USED, + ARG_NOT_USED, + 0); /* No dummy cycles needed for + this command. */ + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + + /* Activate the requested SPI mode on the controller side as well. */ + controller_error = qspi_ip6514e_set_spi_mode(dev->controller, + spi_mode, + spi_mode, + spi_mode); + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + + return MT25QL_ERR_NONE; +} + +/** + * \brief Change the number of dummy clock cycles subsequent to all FAST READ + * commands. + * + * \param[in] dev Pointer to MT25QL device structure \ref mt25ql_dev_t + * \param[in] dummy_cycles Dummy clock cycles to set + * + * \return Return error code as specified in \ref mt25ql_error_t + */ +static enum mt25ql_error_t change_dummy_cycles(struct mt25ql_dev_t* dev, + uint32_t dummy_cycles) +{ + uint32_t volatile_cfg_reg = 0; + enum qspi_ip6514e_error_t controller_error; + + /* + * Changes the number of dummy cycles in the Volatile Configuration + * Register. + */ + controller_error = qspi_ip6514e_send_read_cmd(dev->controller, + READ_VOLATILE_CFG_REG_CMD, + &volatile_cfg_reg, + VOLATILE_CFG_REG_LEN, + ARG_NOT_USED, + ARG_NOT_USED, + 0); /* No dummy cycles needed + for this command. */ + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + + change_bits_in_word(&volatile_cfg_reg, + dummy_cycles, + VOLATILE_CFG_REG_DUMMY_CYCLES_BITS, + VOLATILE_CFG_REG_DUMMY_CYCLES_POS); + + send_write_enable(dev); + + controller_error = qspi_ip6514e_send_write_cmd(dev->controller, + WRITE_VOLATILE_CFG_REG_CMD, + &volatile_cfg_reg, + VOLATILE_CFG_REG_LEN, + ARG_NOT_USED, + ARG_NOT_USED, + 0); /* No dummy cycles needed + for this command. */ + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + + return MT25QL_ERR_NONE; +} + +/** + * \brief Wait until the current program/erase is finished. + * + * \param[in] dev Pointer to MT25QL device structure \ref mt25ql_dev_t + * + * \return Return error code as specified in \ref mt25ql_error_t + */ +static enum mt25ql_error_t wait_program_or_erase_complete( + struct mt25ql_dev_t* dev) +{ + enum qspi_ip6514e_error_t controller_error; + uint8_t flag_status_reg = 0; + + /* Wait until the ready bit of the Flag Status Register is set */ + while (!GET_BIT(flag_status_reg, FLAG_STATUS_REG_READY_POS)) { + controller_error = qspi_ip6514e_send_read_cmd(dev->controller, + READ_FLAG_STATUS_REG_CMD, + &flag_status_reg, + FLAG_STATUS_REG_LEN, + ARG_NOT_USED, + ARG_NOT_USED, + 0); /* No dummy cycles + needed for this + command. */ + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + } + + return MT25QL_ERR_NONE; +} + +/** + * \brief Execute a program command that crosses the page size boundary. + * + * \param[in] dev Pointer to MT25QL device structure + * \ref mt25ql_dev_t + * \param[in] opcode Opcode for the command. + * \param[in] write_data Pointer to a memory zone where the write_len + * number of bytes are located to write for this + * command. + * \param[in] write_len Number of bytes to write for the command. + * Between 1 and 8 bytes (both included) can be + * written. + * \param[in] addr Address used for the command + * \param[in] addr_bytes_number Number of address bytes for this command. + * If an address is not needed for the command, + * use 0 for argument, otherwise between 1 and + * 4 bytes (both included) can be used. + * \param[in] dummy_cycles Number of dummy cycles required for the + * command, between 0 and 31 (both included). + * + * \return Return error code as specified in \ref mt25ql_error_t + * + * \note This function will execute two commands: one to program the bytes up to + * the page boundary and another one to program the rest. It will wait + * that bytes are programmed from first command before triggering the + * second one. + * \note This function does not send a write enable command before the first + * command and does not check that bytes were programmed after the second + * command. + */ +static enum mt25ql_error_t send_boundary_cross_write_cmd( + struct mt25ql_dev_t* dev, + uint8_t opcode, + const void *write_data, + uint32_t write_len, + uint32_t addr, + uint32_t addr_bytes_number, + uint32_t dummy_cycles) +{ + enum qspi_ip6514e_error_t controller_error; + enum mt25ql_error_t library_error; + /* + * Remaining bytes between the current address and the end of the current + * page. + */ + uint32_t page_remainder = FLASH_PAGE_SIZE - (addr % FLASH_PAGE_SIZE); + + /* First write up to the end of the current page. */ + controller_error = qspi_ip6514e_send_write_cmd(dev->controller, opcode, + write_data, page_remainder, + addr, addr_bytes_number, + dummy_cycles); + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + + write_data = (void *)((uint32_t)write_data + page_remainder); + addr += page_remainder; + + /* Wait for the page to be written before sending new commands. */ + library_error = wait_program_or_erase_complete(dev); + if (library_error != MT25QL_ERR_NONE) { + return library_error; + } + + /* Then write the remaining data of the write_len bytes. */ + send_write_enable(dev); + controller_error = qspi_ip6514e_send_write_cmd(dev->controller, opcode, + write_data, + write_len - page_remainder, + addr, addr_bytes_number, + dummy_cycles); + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + + return MT25QL_ERR_NONE; +} + +enum mt25ql_error_t mt25ql_config_mode(struct mt25ql_dev_t* dev, + enum mt25ql_functional_state_t f_state) +{ + enum qspi_ip6514e_error_t controller_error; + enum mt25ql_error_t library_error; + + switch(f_state) { + case MT25QL_FUNC_STATE_DEFAULT: + dev->config_state.spi_mode = QSPI_IP6514E_SPI_MODE; + dev->config_state.opcode_read = READ_CMD; + dev->config_state.dummy_cycles_read = DEFAULT_READ_DUMMY_CYCLES; + dev->config_state.opcode_write = PAGE_PROGRAM_CMD; + dev->config_state.dummy_cycles_write = PAGE_PROGRAM_DUMMY_CYCLES; + break; + case MT25QL_FUNC_STATE_FAST: + dev->config_state.spi_mode = QSPI_IP6514E_SPI_MODE; + dev->config_state.opcode_read = FAST_READ_CMD; + dev->config_state.dummy_cycles_read = FAST_READ_DUMMY_CYCLES; + dev->config_state.opcode_write = PAGE_PROGRAM_CMD; + dev->config_state.dummy_cycles_write = PAGE_PROGRAM_DUMMY_CYCLES; + break; + case MT25QL_FUNC_STATE_QUAD_FAST: + dev->config_state.spi_mode = QSPI_IP6514E_QSPI_MODE; + dev->config_state.opcode_read = QUAD_OUTPUT_FAST_READ_CMD; + dev->config_state.dummy_cycles_read = + QUAD_OUTPUT_FAST_READ_DUMMY_CYCLES; + dev->config_state.opcode_write = QUAD_INPUT_FAST_PROGRAM_CMD; + dev->config_state.dummy_cycles_write = + QUAD_INPUT_FAST_PROGRAM_DUMMY_CYCLES; + break; + default: + return MT25QL_ERR_WRONG_ARGUMENT; + } + + dev->config_state.func_state = f_state; + + /* This function will first set the Flash memory SPI mode and then set + * the controller's SPI mode. It will fail if the two sides do not have + * the same mode when this function is called. + */ + library_error = set_spi_mode(dev, dev->config_state.spi_mode); + if (library_error != MT25QL_ERR_NONE) { + return library_error; + } + + /* Set the number of dummy cycles for read commands. */ + library_error = change_dummy_cycles( + dev, dev->config_state.dummy_cycles_read); + if (library_error != MT25QL_ERR_NONE) { + return library_error; + } + + /* The rest of the configuration needs the controller to be disabled */ + while(!qspi_ip6514e_is_idle(dev->controller)); + qspi_ip6514e_disable(dev->controller); + + /* Set the baud rate divisor as configured in the device structure. */ + controller_error = qspi_ip6514e_set_baud_rate_div(dev->controller, + dev->baud_rate_div); + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + + /* Set opcode and dummy cycles needed for read commands. */ + controller_error = qspi_ip6514e_cfg_reads( + dev->controller, dev->config_state.opcode_read, + dev->config_state.dummy_cycles_read); + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + + /* Set opcode and dummy cycles needed for write commands. */ + controller_error = qspi_ip6514e_cfg_writes( + dev->controller, dev->config_state.opcode_write, + dev->config_state.dummy_cycles_write); + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + + /* Set Flash memory constants: bytes per page and address bytes. */ + controller_error = qspi_ip6514e_cfg_page_size(dev->controller, + FLASH_PAGE_SIZE); + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + + controller_error = qspi_ip6514e_cfg_addr_bytes(dev->controller, + ADDR_BYTES); + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + + qspi_ip6514e_enable(dev->controller); + + return MT25QL_ERR_NONE; +} + +enum mt25ql_error_t mt25ql_restore_reset_state(struct mt25ql_dev_t* dev) +{ + enum mt25ql_error_t library_error; + + /* + * This function will first change the Flash memory mode to single SPI and + * then change the controller to single SPI. It will fail if the two sides + * do not have the same mode when this function is called. + */ + library_error = set_spi_mode(dev, QSPI_IP6514E_SPI_MODE); + if (library_error != MT25QL_ERR_NONE) { + return library_error; + } + + /* Set the default number of dummy cycles for direct read commands. */ + library_error = change_dummy_cycles(dev, RESET_STATE_DUMMY_CYCLES); + if (library_error != MT25QL_ERR_NONE) { + return library_error; + } + + /* The rest of the configuration needs the controller to be disabled */ + while(!qspi_ip6514e_is_idle(dev->controller)); + qspi_ip6514e_disable(dev->controller); + + /* Restore the default value of the QSPI controller registers. */ + qspi_ip6514e_reset_regs(dev->controller); + + qspi_ip6514e_enable(dev->controller); + + dev->config_state = (struct mt25ql_config_state_t){ 0 }; + dev->config_state.func_state = MT25QL_FUNC_STATE_NOT_INITED; + + return MT25QL_ERR_NONE; +} + +enum mt25ql_error_t mt25ql_direct_read(struct mt25ql_dev_t* dev, + uint32_t addr, + void *data, + uint32_t len) +{ + /* + * The direct access window size is the size of the memory that can be + * accessed with a direct access. + */ + uint32_t direct_access_window_size = dev->controller->cfg->addr_mask + 1; + /* + * The window number is the number of times it will be needed to remap the + * address with the remap register. We move this Direct Access window first + * window_number times starting at the beginning address to read full + * windows of direct_access_window_size bytes. Then we read the remainder + * bytes. + */ + uint32_t window_number = len / direct_access_window_size; + + if (data == NULL || len == 0) { + return MT25QL_ERR_WRONG_ARGUMENT; + } + + if ((addr + len) >= dev->size) { + return MT25QL_ERR_ADDR_TOO_BIG; + } + + /* + * There is no limitation reading through a Flash page boundary hence we + * do not add the same logic here than in the write function. + */ + + /* Transfer the bytes for the window_number windows first. */ + for (uint32_t window = 0; window < window_number; window++) { + qspi_ip6514e_remap_addr(dev->controller, addr); + + /* + * The AHB address to access the Flash memory does not change but it + * will be translated differently thanks to the remap function. + */ + memcpy(data, + (void *)dev->direct_access_start_addr, + direct_access_window_size); + + len -= direct_access_window_size; + data = (void *)((uint32_t)data + direct_access_window_size); + addr += direct_access_window_size; + } + + if (len) { + /* Transfer the reminder bytes */ + qspi_ip6514e_remap_addr(dev->controller, addr); + + memcpy(data, (void *)dev->direct_access_start_addr, len); + } + + /* Disable remapping for direct accesses outside of this function. */ + qspi_ip6514e_disable_remap(dev->controller); + + return MT25QL_ERR_NONE; +} + +enum mt25ql_error_t mt25ql_direct_write(struct mt25ql_dev_t* dev, + uint32_t addr, + const void *data, + uint32_t len) +{ + enum mt25ql_error_t library_error; + /* + * The direct access window size is the size of the memory that can be + * accessed with a direct access. + */ + uint32_t direct_access_window_size = dev->controller->cfg->addr_mask + 1; + uint32_t window_number; + /* Offset between address and the previous 32 bits aligned word */ + uint32_t word_offset; + + if (data == NULL || len == 0) { + return MT25QL_ERR_WRONG_ARGUMENT; + } + + if ((addr + len) >= dev->size) { + return MT25QL_ERR_ADDR_TOO_BIG; + } + + /* + * If the remapping address is not aligned on a 32 bits boundary, a direct + * access of one word could cross a Flash page boundary. If that happens, + * the bytes of that word that are over the page boundary will instead be + * written at the beginning of the same page. + * To counter this problem, we align the remapping address and add the word + * offset to the address of the direct access for the first window only. + */ + word_offset = addr % BYTES_PER_WORD; + /* Make address aligned on a 32 bits alignment. */ + addr -= word_offset; + /* + * Only direct_access_window_size address locations are available by direct + * access. We calculate the number of windows that we will need to transfer + * len bytes. We have to add in the window the offset that we add in the + * beginning. + */ + window_number = (len + word_offset) / direct_access_window_size; + + /* + * This function assumes that the flash has already been erased. + * Transfer the bytes for the window_number windows first. + */ + for (uint32_t window = 0; window < window_number; window++) { + /* The controller needs to be disabled while remapping is done. */ + qspi_ip6514e_remap_addr(dev->controller, addr); + + /* + * The AHB address to access the Flash memory does not change but it + * will be translated differently thanks to the remap function. + */ + memcpy((void *)(dev->direct_access_start_addr + word_offset), + data, + direct_access_window_size - word_offset); + + len -= (direct_access_window_size - word_offset); + data = (void *)((uint32_t)data + + (direct_access_window_size - word_offset)); + addr += direct_access_window_size; + + /* + * The address is now aligned, there is no need to add an offset for the + * remaining windows. + */ + word_offset = 0; + + /* + * Wait until the last program operation is complete before changing + * the remap address. + */ + library_error = wait_program_or_erase_complete(dev); + if (library_error != MT25QL_ERR_NONE) { + return library_error; + } + } + + if (len) { + /* Transfer the reminder bytes */ + qspi_ip6514e_remap_addr(dev->controller, addr); + + memcpy((void *)(dev->direct_access_start_addr + word_offset), + data, + len); + + /* Wait until the last program operation is complete */ + library_error = wait_program_or_erase_complete(dev); + if (library_error != MT25QL_ERR_NONE) { + return library_error; + } + } + + /* + * Disable the default remap address for direct accesses outside of this + * function. + */ + qspi_ip6514e_disable_remap(dev->controller); + + return MT25QL_ERR_NONE; +} + +enum mt25ql_error_t mt25ql_command_read(struct mt25ql_dev_t* dev, + uint32_t addr, + void *data, + uint32_t len) +{ + /* With one single command only 8 bytes can be read. */ + uint32_t cmd_number = len / CMD_DATA_MAX_SIZE; + enum qspi_ip6514e_error_t controller_error; + + if (dev->config_state.func_state == MT25QL_FUNC_STATE_NOT_INITED) { + return MT25QL_ERR_NOT_INITED; + } + + for (uint32_t cmd_index = 0; cmd_index < cmd_number; cmd_index++) { + controller_error = qspi_ip6514e_send_read_cmd( + dev->controller, + dev->config_state.opcode_read, + data, CMD_DATA_MAX_SIZE, addr, + ADDR_BYTES, + dev->config_state.dummy_cycles_read); + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + + data = (void *)((uint32_t)data + CMD_DATA_MAX_SIZE); + addr += CMD_DATA_MAX_SIZE; + len -= CMD_DATA_MAX_SIZE; + } + + if (len) { + /* Read the remainder. */ + controller_error = qspi_ip6514e_send_read_cmd( + dev->controller, + dev->config_state.opcode_read, + data, len, addr, ADDR_BYTES, + dev->config_state.dummy_cycles_read); + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + } + + return MT25QL_ERR_NONE; + +} + +enum mt25ql_error_t mt25ql_command_write(struct mt25ql_dev_t* dev, + uint32_t addr, + const void *data, + uint32_t len) +{ + /* With one single command only 8 bytes can be written. */ + uint32_t cmd_number = len / CMD_DATA_MAX_SIZE; + enum qspi_ip6514e_error_t controller_error; + enum mt25ql_error_t library_error; + + if (dev->config_state.func_state == MT25QL_FUNC_STATE_NOT_INITED) { + return MT25QL_ERR_NOT_INITED; + } + + for (uint32_t cmd_index = 0; cmd_index < cmd_number; cmd_index++) { + send_write_enable(dev); + + /* + * Check if this command is not writing over a page boundary: first and + * last bytes are in the same page. + */ + if ((addr / FLASH_PAGE_SIZE) != + ((addr + CMD_DATA_MAX_SIZE - 1) / FLASH_PAGE_SIZE)) { + /* The CMD_DATA_MAX_SIZE bytes written are crossing the boundary. */ + library_error = send_boundary_cross_write_cmd( + dev, dev->config_state.opcode_write, + data, CMD_DATA_MAX_SIZE, addr, + ADDR_BYTES, + dev->config_state.dummy_cycles_write); + if (library_error != MT25QL_ERR_NONE) { + return library_error; + } + } else { + /* Normal case: not crossing the boundary. */ + controller_error = qspi_ip6514e_send_write_cmd( + dev->controller, + dev->config_state.opcode_write, + data, CMD_DATA_MAX_SIZE, addr, + ADDR_BYTES, + dev->config_state.dummy_cycles_write); + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + } + + /* Wait until the write operation is complete. */ + library_error = wait_program_or_erase_complete(dev); + if (library_error != MT25QL_ERR_NONE) { + return library_error; + } + + data = (void *)((uint32_t)data + CMD_DATA_MAX_SIZE); + addr += CMD_DATA_MAX_SIZE; + len -= CMD_DATA_MAX_SIZE; + } + + if (len) { + /* Write the remainder. */ + send_write_enable(dev); + /* + * Check if this command is not writing over a page boundary: first and + * last bytes are in the same page. + */ + if ((addr / FLASH_PAGE_SIZE) != ((addr + len - 1) / FLASH_PAGE_SIZE)) { + /* The CMD_DATA_MAX_SIZE bytes written are crossing the boundary. */ + library_error = send_boundary_cross_write_cmd( + dev, dev->config_state.opcode_write, + data, len, addr, ADDR_BYTES, + dev->config_state.dummy_cycles_write); + if (library_error != MT25QL_ERR_NONE) { + return library_error; + } + } else { + /* Normal case: not crossing the boundary. */ + controller_error = qspi_ip6514e_send_write_cmd( + dev->controller, + dev->config_state.opcode_write, + data, len, addr, ADDR_BYTES, + dev->config_state.dummy_cycles_write); + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + } + + /* Wait until the write operation is complete. */ + library_error = wait_program_or_erase_complete(dev); + if (library_error != MT25QL_ERR_NONE) { + return library_error; + } + } + + return MT25QL_ERR_NONE; + +} + +enum mt25ql_error_t mt25ql_erase(struct mt25ql_dev_t* dev, + uint32_t addr, + enum mt25ql_erase_t erase_type) +{ + enum qspi_ip6514e_error_t controller_error; + enum mt25ql_error_t library_error; + uint8_t erase_cmd; + uint32_t addr_bytes; + + if (dev->config_state.func_state == MT25QL_FUNC_STATE_NOT_INITED) { + return MT25QL_ERR_NOT_INITED; + } + + send_write_enable(dev); + + switch (erase_type) { + case MT25QL_ERASE_ALL_FLASH: + if (addr != 0) { + return MT25QL_ERR_ADDR_NOT_ALIGNED; + } + erase_cmd = BULK_ERASE_CMD; + addr_bytes = ARG_NOT_USED; + break; + case MT25QL_ERASE_SECTOR_64K: + erase_cmd = SECTOR_ERASE_CMD; + addr_bytes = ADDR_BYTES; + if ((addr % SECTOR_64KB) != 0) { + return MT25QL_ERR_ADDR_NOT_ALIGNED; + } + break; + case MT25QL_ERASE_SUBSECTOR_32K: + erase_cmd = SUBSECTOR_ERASE_32KB_CMD; + addr_bytes = ADDR_BYTES; + if ((addr % SUBSECTOR_32KB) != 0) { + return MT25QL_ERR_ADDR_NOT_ALIGNED; + } + break; + case MT25QL_ERASE_SUBSECTOR_4K: + erase_cmd = SUBSECTOR_ERASE_4KB_CMD; + addr_bytes = ADDR_BYTES; + if ((addr % SUBSECTOR_4KB) != 0) { + return MT25QL_ERR_ADDR_NOT_ALIGNED; + } + break; + default: + return MT25QL_ERR_WRONG_ARGUMENT; + } + + if (addr >= dev->size) { + return MT25QL_ERR_ADDR_TOO_BIG; + } + + controller_error = qspi_ip6514e_send_cmd(dev->controller, + erase_cmd, + ARG_PTR_NOT_USED, + ARG_NOT_USED, + ARG_PTR_NOT_USED, + ARG_NOT_USED, + addr, + addr_bytes, + 0); /* No dummy cycles needed for + any erase command. */ + if (controller_error != QSPI_IP6514E_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + + /* Wait until the erase operation is complete */ + library_error = wait_program_or_erase_complete(dev); + if (library_error != MT25QL_ERR_NONE) { + return (enum mt25ql_error_t)controller_error; + } + + return MT25QL_ERR_NONE; +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/Libraries/mt25ql_flash_lib.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/Libraries/mt25ql_flash_lib.h new file mode 100644 index 00000000000..d0c5dc99fa2 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/Libraries/mt25ql_flash_lib.h @@ -0,0 +1,273 @@ +/* + * Copyright (c) 2018-2019 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * This library provides functions to control the MT25QL256ABA-1EW7-OSIT flash + * memory from Micron and should work for similar devices from the same vendor. + */ + +#ifndef __MT25QL_H__ +#define __MT25QL_H__ + +#include "qspi_ip6514e_drv.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * \brief MT25QL Flash Memory documentation defined values. + */ +#define FLASH_PAGE_SIZE (256U) /* 256B */ +#define SUBSECTOR_4KB (0x00001000U) /* 4KB */ +#define SUBSECTOR_32KB (0x00008000U) /* 32KB */ +#define SECTOR_64KB (0x00010000U) /* 64KB */ +#define ADDR_BYTES (3U) + +enum mt25ql_error_t { + MT25QL_ERR_NONE = QSPI_IP6514E_ERR_NONE, + MT25QL_ERR_WRONG_ARGUMENT = QSPI_IP6514E_ERR_WRONG_ARGUMENT, + MT25QL_ERR_CTRL_NOT_DISABLED = QSPI_IP6514E_ERR_CONTROLLER_NOT_DISABLED, + MT25QL_ERR_READ_IN_PROGRESS = QSPI_IP6514E_ERR_READ_IN_PROGRESS, + MT25QL_ERR_WRITE_IN_PROGRESS = QSPI_IP6514E_ERR_WRITE_IN_PROGRESS, + MT25QL_ERR_ADDR_NOT_ALIGNED, + MT25QL_ERR_NOT_INITED, + MT25QL_ERR_ADDR_TOO_BIG, +}; + +enum mt25ql_erase_t { + MT25QL_ERASE_ALL_FLASH = 0U, /*!< Erase all flash */ + MT25QL_ERASE_SUBSECTOR_4K = SUBSECTOR_4KB, /*!< Erase a 4 KB subsector */ + MT25QL_ERASE_SUBSECTOR_32K = SUBSECTOR_32KB, /*!< Erase a 32 KB subsector */ + MT25QL_ERASE_SECTOR_64K = SECTOR_64KB, /*!< Erase a sector (64 KB) */ +}; + +enum mt25ql_functional_state_t { + MT25QL_FUNC_STATE_NOT_INITED = 0U, + /*!< QSPI Flash controller is not initialized, only direct read + * is guaranteed to be working + */ + MT25QL_FUNC_STATE_DEFAULT = 1U, + /*!< The QSPI Flash controller and memory is in default state, + * using basic read/write commands + */ + MT25QL_FUNC_STATE_FAST = 2U, + /*!< The QSPI Flash controller and memory is configured to operate in + * single SPI mode and fast Flash commands could be used for read and + * program operations. + */ + MT25QL_FUNC_STATE_QUAD_FAST = 3U, + /*!< The QSPI Flash controller and memory is configured to operate in + * Quad SPI mode and fast Flash commands could be used for read and + * program operations. + */ +}; + +struct mt25ql_config_state_t { + enum mt25ql_functional_state_t func_state; + /*!< Functional state id */ + enum qspi_ip6514e_spi_mode_t spi_mode; + /*!< SPI mode for the current functional state */ + uint8_t opcode_read; + /*!< Read opcode for the current functional state */ + uint8_t opcode_write; + /*!< Write opcode for the current functional state */ + uint32_t dummy_cycles_read; + /*!< Dummy cycles for the read command for the current functional state */ + uint32_t dummy_cycles_write; + /*!< Dummy cycles for the write command for the current functional state */ +}; + +struct mt25ql_dev_t { + struct qspi_ip6514e_dev_t *controller; + /*!< QSPI Flash controller. */ + uint32_t direct_access_start_addr; + /*!< AHB address to directly access the contents of the Flash memory + * through the QSPI Controller. + */ + uint32_t baud_rate_div; + /*!< Clock divisor that will be used to configure the QSPI Flash + * Controller to access the Flash memory. The clock which frequency is + * divived is the one linked to the QSPI Flash controller. It can only + * be an even number between 2 and 32 (both included). It needs to be + * high enough to support the Quad Output Fast Read command with 8 + * dummy cycles and the Quad Input Fast Program with 0 dummy cycles. + */ + uint32_t size; /*!< Total size of the MT25QL Flash memory */ + struct mt25ql_config_state_t config_state; + /*!< Configured functional state (with parameter settings) of the + * QSPI Flash controller and memory. + */ + +}; + +/** + * \brief Change configuration of the QSPI Flash controller and MT25QL memory + * + * Changes the configuration of the QSPI Flash controller and MT25QL + * Flash memory to operate in the specified SPI mode and to use the + * appropriate Flash commands for read and program operations. + * It also sets: + * + The number of dummy cycles for each operation + * + The bytes per page constant to 256 (MT25QL Flash specific) + * + The number of address bytes to 3 + * + * \param[in] dev Pointer to MT25QL device structure \ref mt25ql_dev_t + * \param[in] f_state Functional state to be set on flash controller + * and device \ref mt25ql_functional_state_t + * + * \return Return error code as specified in \ref mt25ql_error_t + * + * \note This function assumes that the Flash memory device and the QSPI Flash + * controller operates with the same SPI protocol. This function will fail + * if the Flash device is in a different configuration. + */ +enum mt25ql_error_t mt25ql_config_mode(struct mt25ql_dev_t* dev, + enum mt25ql_functional_state_t f_state); + +/** + * \brief Restore the QSPI Flash controller and MT25QL to reset state. + * + * \param[in] dev Pointer to MT25QL device structure \ref mt25ql_dev_t + * + * \return Return error code as specified in \ref mt25ql_error_t + * + * \note This function assumes that the Flash memory device and the QSPI Flash + * controller operates with the same SPI protocol. This function will fail + * if the Flash device is in a different configuration. + */ +enum mt25ql_error_t mt25ql_restore_reset_state(struct mt25ql_dev_t* dev); + +/** + * \brief Read bytes from the flash memory (direct access) + * + * \param[in] dev Pointer to MT25QL device structure \ref mt25ql_dev_t + * \param[in] addr Flash memory address for the read operation + * \param[out] data Pointer where len bytes read from the flash memory will be + * written to + * \param[in] len Number of bytes to read + * + * \return Return error code as specified in \ref mt25ql_error_t + * + * \note This function will use direct access to read from the Flash memory. It + * can be used to access above the direct accessible memory zone if + * not all the AHB address wires are connected. + * \note The address given should be the address of the data inside the flash + * memory. To read the first byte inside the memory, use 0x00000000. + */ +enum mt25ql_error_t mt25ql_direct_read(struct mt25ql_dev_t* dev, + uint32_t addr, + void *data, + uint32_t len); + +/** + * \brief Write bytes in the flash memory, at a location where data has already + * been erased (direct access) + * + * \param[in] dev Pointer to MT25QL device structure \ref mt25ql_dev_t + * \param[in] addr Flash memory address for the write operation + * \param[in] data Pointer to the len bytes that will be written to the flash + * memory + * \param[in] len Number of bytes to write + * + * \return Return error code as specified in \ref mt25ql_error_t + * + * \note This function will use direct access to write to the Flash memory. It + * can be used to access outside of the direct accessible memory zone if + * not all the AHB address wires are connected. + * \note The address given should be the address of the data inside the flash + * memory. To write the first byte inside the memory, use 0x00000000. + * \note Writing bytes in the flash memory clear them from 1 to 0, for that + * matter the location where data is written needs to be erased + * beforehand. + */ +enum mt25ql_error_t mt25ql_direct_write(struct mt25ql_dev_t* dev, + uint32_t addr, + const void *data, + uint32_t len); + +/** + * \brief Read bytes from the flash memory (using Flash commands) + * + * \param[in] dev Pointer to MT25QL device structure \ref mt25ql_dev_t + * \param[in] addr Flash memory address for the read operation + * \param[out] data Pointer where len bytes read from the flash memory will be + * written to + * \param[in] len Number of bytes to read + * + * \return Return error code as specified in \ref mt25ql_error_t + * + * \note This function will use the Software Triggered Instruction Generator to + * read from the Flash memory using Flash commands. + * \note The address given should be the address of the data inside the flash + * memory. To read the first byte inside the memory, use 0x00000000. + */ +enum mt25ql_error_t mt25ql_command_read(struct mt25ql_dev_t* dev, + uint32_t addr, + void *data, + uint32_t len); + +/** + * \brief Write bytes in the flash memory, at a location where data has already + * been erased (using Flash commands) + * + * \param[in] dev Pointer to MT25QL device structure \ref mt25ql_dev_t + * \param[in] addr Flash memory address for the write operation + * \param[in] data Pointer to the len bytes that will be written to the flash + * memory + * \param[in] len Number of bytes to write + * + * \return Return error code as specified in \ref mt25ql_error_t + * + * \note This function will use the Software Triggered Instruction Generator to + * write to the Flash memory using Flash commands. + * \note The address given should be the address of the data inside the flash + * memory. To write the first byte inside the memory, use 0x00000000. + * \note Writing bytes in the flash memory clear them from 1 to 0, for that + * matter the location where data is written needs to be erased + * beforehand. + */ +enum mt25ql_error_t mt25ql_command_write(struct mt25ql_dev_t* dev, + uint32_t addr, + const void *data, + uint32_t len); + +/** + * \brief Erase all flash memory, a sector (64 KiB) or a subsector + * (32 KiB or 4 KiB) + * + * \param[in] dev Pointer to MT25QL device structure \ref mt25ql_dev_t + * \param[in] addr Address where to erase in the flash memory + * \param[in] erase_type Type of what to erase at the specified address: + * * whole flash memory + * * a subsector (4 KiB or 32 KiB) + * * a sector (64 KiB) + * \return Return error code as specified in \ref mt25ql_error_t + * + * \note The address need to be aligned with the size of what is erased or 0 if + * all flash memory is to be erased. + */ +enum mt25ql_error_t mt25ql_erase(struct mt25ql_dev_t* dev, + uint32_t addr, + enum mt25ql_erase_t erase_type); + +#ifdef __cplusplus +} +#endif + +#endif /* __MT25QL_H__ */ diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/PeripheralNames.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/PeripheralNames.h new file mode 100644 index 00000000000..158beff3fb7 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/PeripheralNames.h @@ -0,0 +1,49 @@ +/* mbed Microcontroller Library + * Copyright (c) 2019-2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MBED_PERIPHERALNAMES_H +#define MBED_PERIPHERALNAMES_H + +#include "cmsis.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + UART_0 = 0, + UART_1 +} UARTName; + +typedef enum { + I2C_0 = 0, + I2C_1 +} I2CName; + +#define STDIO_UART_TX UART1_TX +#define STDIO_UART_RX UART1_RX +#define STDIO_UART UART_1 + +#define USBTX STDIO_UART_TX +#define USBRX STDIO_UART_RX + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/PinNames.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/PinNames.h new file mode 100644 index 00000000000..9223c0a416f --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/PinNames.h @@ -0,0 +1,117 @@ +/* mbed Microcontroller Library + * Copyright (c) 2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MBED_PINNAMES_H +#define MBED_PINNAMES_H + +#include "cmsis.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + PIN_INPUT, + PIN_OUTPUT +} PinDirection; + +typedef enum { + PA0 = 0, + PA1 = 1, + PA2 = 2, + PA3 = 3, + PA4 = 4, + PA5 = 5, + PA6 = 6, + PA7 = 7, + PA8 = 8, + PA9 = 9, + PA10 = 10, + PA11 = 11, + PA12 = 12, + PA13 = 13, + PA14 = 14, + PA15 = 15, + PA16 = 16, + PA17 = 17, + PA18 = 18, + PA19 = 19, + PA20 = 20, + PA21 = 21, + PA22 = 22, + PA23 = 23, + PA24 = 24, + PA25 = 25, + + /* Arduino Connector Namings */ + D0 = PA0, + D1 = PA1, + D2 = PA2, + D3 = PA3, + D4 = PA4, + D5 = PA5, + D6 = PA6, + D7 = PA7, + D8 = PA8, + D9 = PA9, + D10 = PA10, + D11 = PA11, + D12 = PA12, + D13 = PA13, + D14 = PA14, + D15 = PA15, + + /* UART pins */ + UART0_RX = PA0, /* Alternate Function - 1 */ + UART0_TX = PA1, /* Alternate Function - 1 */ + UART1_RX = PA16, + UART1_TX = PA17, + + LED1 = PA2, + LED2 = PA3, + LED3 = PA4, + + /* I2C pins */ + I2C0_SDA = PA14, /* Alternate Function - 1 */ + I2C0_SCL = PA15, /* Alternate Function - 1 */ + I2C1_SDA = PA18, + I2C1_SCL = PA19, + + /* Not connected */ + NC = (int)0xFFFFFFFF +} PinName; + +typedef enum { + PRIMARY_FUNC = 0, + ALTERNATE_FUNC_1 = 1, + ALTERNATE_FUNC_2 = 2 +} PinFunction; + +typedef enum { + PullNone = 0, + PullUp, + PullDown, + PullDefault = PullNone +} PinMode; + +#ifdef __cplusplus +} +#endif + +#endif + diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device.h new file mode 100644 index 00000000000..6059d391934 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device.h @@ -0,0 +1,24 @@ +/* mbed Microcontroller Library + * Copyright (c) 2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MBED_DEVICE_H +#define MBED_DEVICE_H + +#include "objects.h" + +#endif diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_ARMC6/musca_ns.sct b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_ARMC6/musca_ns.sct new file mode 100644 index 00000000000..77554e2d884 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_ARMC6/musca_ns.sct @@ -0,0 +1,68 @@ +#! armclang --target=arm-arm-none-eabi -march=armv8-m.main -E -xc + +/* + * Copyright (c) 2019-2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "../../partition/region_defs.h" +#include "../cmsis_nvic.h" + +#if !defined(MBED_ROM_START) + #define MBED_ROM_START NS_CODE_START // 0x0A080400 +#endif + +#if !defined(MBED_ROM_SIZE) + #define MBED_ROM_SIZE NS_CODE_SIZE // 0x7f400 +#endif + +#if !defined(MBED_RAM_START) + #define MBED_RAM_START NS_DATA_START // 0x20040000 +#endif + +#if !defined(MBED_RAM_SIZE) + #define MBED_RAM_SIZE NS_DATA_SIZE // 0x40000 +#endif + +#define VECTOR_SIZE NVIC_RAM_VECTOR_SIZE + +#if !defined(MBED_CONF_TARGET_BOOT_STACK_SIZE) +# if defined(MBED_BOOT_STACK_SIZE) +# define MBED_CONF_TARGET_BOOT_STACK_SIZE MBED_BOOT_STACK_SIZE +# else +# define MBED_CONF_TARGET_BOOT_STACK_SIZE 0x400 +# endif +#endif + +#define RAM_FIXED_SIZE (MBED_CONF_TARGET_BOOT_STACK_SIZE+VECTOR_SIZE) + +LR_CODE MBED_ROM_START MBED_ROM_SIZE { + ER_CODE MBED_ROM_START MBED_ROM_SIZE { + *.o (VECTOR +First) + .ANY (+RO) + } + + RW_IRAM1 (MBED_RAM_START+VECTOR_SIZE) (MBED_RAM_SIZE-VECTOR_SIZE) { + * (+RW) ; RW data that gets copied from Flash to SRAM + * (+ZI) ; ZI data that gets initialised to zero in SRAM + } + + ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (MBED_RAM_SIZE-RAM_FIXED_SIZE+MBED_RAM_START-AlignExpr(ImageLimit(RW_IRAM1), 16)) { + } + + ARM_LIB_STACK (MBED_RAM_START+MBED_RAM_SIZE) EMPTY -MBED_CONF_TARGET_BOOT_STACK_SIZE { ; stack + } +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_ARMC6/startup_cmsdk_musca_ns.S b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_ARMC6/startup_cmsdk_musca_ns.S new file mode 100644 index 00000000000..368c289c06a --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_ARMC6/startup_cmsdk_musca_ns.S @@ -0,0 +1,242 @@ +;/* +; * Copyright (c) 2019-2020 Arm Limited +; * +; * SPDX-License-Identifier: Apache-2.0 +; * +; * Licensed under the Apache License, Version 2.0 (the "License"); +; * you may not use this file except in compliance with the License. +; * You may obtain a copy of the License at +; * +; * http://www.apache.org/licenses/LICENSE-2.0 +; * +; * Unless required by applicable law or agreed to in writing, software +; * distributed under the License is distributed on an "AS IS" BASIS, +; * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +; * See the License for the specific language governing permissions and +; * limitations under the License. +; */ +; +; This file is derivative of CMSIS V5.01 startup_ARMv8MML.s +; Git SHA: 8a1d9d6ee18b143ae5befefa14d89fb5b3f99c75 + +;/* +;//-------- <<< Use Configuration Wizard in Context Menu >>> ------------------ +;*/ + +; Vector Table Mapped to Address 0 at Reset + + AREA VECTOR, DATA, READONLY + EXPORT __Vectors + EXPORT __Vectors_End + EXPORT __Vectors_Size + + IMPORT |Image$$ARM_LIB_STACK$$ZI$$Limit| + +__Vectors ;Core Interrupts + DCD |Image$$ARM_LIB_STACK$$ZI$$Limit|; Top of Stack + DCD Reset_Handler ; Reset Handler + DCD NMI_Handler ; NMI Handler + DCD HardFault_Handler ; Hard Fault Handler + DCD MemManage_Handler ; MPU Fault Handler + DCD BusFault_Handler ; Bus Fault Handler + DCD UsageFault_Handler ; Usage Fault Handler + DCD 0 ; Reserved + DCD 0 ; Reserved + DCD 0 ; Reserved + DCD 0 ; Reserved + DCD SVC_Handler ; SVCall Handler + DCD DebugMon_Handler ; Debug Monitor Handler + DCD 0 ; Reserved + DCD PendSV_Handler ; PendSV Handler + DCD SysTick_Handler ; SysTick Handler + ;SSE-200 Interrupts + DCD NS_WATCHDOG_RESET_IRQHandler ; 0: Non-Secure Watchdog Reset Request Interrupt + DCD NS_WATCHDOG_IRQHandler ; 1: Non-Secure Watchdog Interrupt + DCD S32K_TIMER_IRQHandler ; 2: S32K Timer Interrupt + DCD TIMER0_IRQHandler ; 3: CMSDK Timer 0 Interrupt + DCD TIMER1_IRQHandler ; 4: CMSDK Timer 1 Interrupt + DCD DUALTIMER_IRQHandler ; 5: CMSDK Dual Timer Interrupt + DCD MHU0_IRQHandler ; 6: Message Handling Unit 0 Interrupt + DCD MHU1_IRQHandler ; 7: Message Handling Unit 1 Interrupt + DCD CRYPTOCELL_IRQHandler ; 8: CryptoCell-312 Interrupt + DCD 0 ; 9: Reserved + DCD 0 ; 10: Reserved + DCD 0 ; 11: Reserved + DCD 0 ; 12: Reserved + DCD I_CACHE_INV_ERR_IRQHandler ; 13: Intsruction Cache Invalidation Interrupt + DCD 0 ; 14: Reserved + DCD SYS_PPU_IRQHandler ; 15: System PPU Interrupt + DCD CPU0_PPU_IRQHandler ; 16: CPU0 PPU Interrupt + DCD CPU1_PPU_IRQHandler ; 17: CPU1 PPU Interrupt + DCD CPU0_DGB_PPU_IRQHandler ; 18: CPU0 Debug PPU Interrupt + DCD CPU1_DGB_PPU_IRQHandler ; 19: CPU1 Debug PPU Interrupt + DCD CRYPTOCELL_PPU_IRQHandler ; 20: CryptoCell PPU Interrupt + DCD 0 ; 21: Reserved + DCD RAM0_PPU_IRQHandler ; 22: RAM 0 PPU Interrupt + DCD RAM1_PPU_IRQHandler ; 23: RAM 1 PPU Interrupt + DCD RAM2_PPU_IRQHandler ; 24: RAM 2 PPU Interrupt + DCD RAM3_PPU_IRQHandler ; 25: RAM 3 PPU Interrupt + DCD DEBUG_PPU_IRQHandler ; 26: Debug PPU Interrupt + DCD 0 ; 27: Reserved + DCD CPU0_CTI_IRQHandler ; 28: CPU0 CTI Interrupt + DCD CPU1_CTI_IRQHandler ; 29: CPU1 CTI Interrupt + DCD 0 ; 30: Reserved + DCD 0 ; 31: Reserved + ;Expansion Interrupts + DCD 0 ; 32: Reserved + DCD GpTimer_IRQHandler ; 33: General Purpose Timer + DCD I2C0_IRQHandler ; 34: I2C0 + DCD I2C1_IRQHandler ; 35: I2C1 + DCD I2S_IRQHandler ; 36: I2S + DCD SPI_IRQHandler ; 37: SPI + DCD QSPI_IRQHandler ; 38: QSPI + DCD UART0_Rx_IRQHandler ; 39: UART0 receive FIFO interrupt + DCD UART0_Tx_IRQHandler ; 40: UART0 transmit FIFO interrupt + DCD UART0_RxTimeout_IRQHandler ; 41: UART0 receive timeout interrupt + DCD UART0_ModemStatus_IRQHandler ; 42: UART0 modem status interrupt + DCD UART0_Error_IRQHandler ; 43: UART0 error interrupt + DCD UART0_IRQHandler ; 44: UART0 interrupt + DCD UART1_Rx_IRQHandler ; 45: UART0 receive FIFO interrupt + DCD UART1_Tx_IRQHandler ; 46: UART0 transmit FIFO interrupt + DCD UART1_RxTimeout_IRQHandler ; 47: UART0 receive timeout interrupt + DCD UART1_ModemStatus_IRQHandler ; 48: UART0 modem status interrupt + DCD UART1_Error_IRQHandler ; 49: UART0 error interrupt + DCD UART1_IRQHandler ; 50: UART0 interrupt + DCD GPIO_0_IRQHandler ; 51: GPIO 0 interrupt + DCD GPIO_1_IRQHandler ; 52: GPIO 1 interrupt + DCD GPIO_2_IRQHandler ; 53: GPIO 2 interrupt + DCD GPIO_3_IRQHandler ; 54: GPIO 3 interrupt + DCD GPIO_4_IRQHandler ; 55: GPIO 4 interrupt + DCD GPIO_5_IRQHandler ; 56: GPIO 5 interrupt + DCD GPIO_6_IRQHandler ; 57: GPIO 6 interrupt + DCD GPIO_7_IRQHandler ; 58: GPIO 7 interrupt + DCD GPIO_8_IRQHandler ; 59: GPIO 8 interrupt + DCD GPIO_9_IRQHandler ; 60: GPIO 9 interrupt + DCD GPIO_10_IRQHandler ; 61: GPIO 10 interrupt + DCD GPIO_11_IRQHandler ; 62: GPIO 11 interrupt + DCD GPIO_12_IRQHandler ; 63: GPIO 12 interrupt + DCD GPIO_13_IRQHandler ; 64: GPIO 13 interrupt + DCD GPIO_14_IRQHandler ; 65: GPIO 14 interrupt + DCD GPIO_15_IRQHandler ; 66: GPIO 15 interrupt + DCD GPIO_Combined_IRQHandler ; 67: GPIO Combined interrupt + DCD PVT_IRQHandler ; 68: PVT sensor interrupt + DCD 0 ; 69: Reserved + DCD PWM_0_IRQHandler ; 70: PWM0 interrupt + DCD RTC_IRQHandler ; 71: RTC interrupt + DCD GpTimer1_IRQHandler ; 72: General Purpose Timer1 + DCD GpTimer0_IRQHandler ; 73: General Purpose Timer0 + DCD PWM_1_IRQHandler ; 74: PWM1 interrupt + DCD PWM_2_IRQHandler ; 75: PWM2 interrupt + DCD IOMUX_IRQHandler ; 76: IOMUX interrupt + + +__Vectors_End + +__Vectors_Size EQU __Vectors_End - __Vectors + +; Reset Handler + AREA RESET, CODE, READONLY +Reset_Handler PROC + EXPORT Reset_Handler [WEAK] + IMPORT SystemInit + IMPORT __main + LDR R0, =SystemInit + BLX R0 + LDR R0, =__main + BX R0 + ENDP +End_Of_Main + B . + + ALIGN 4 + +; Dummy Exception Handlers (infinite loops which can be modified) + MACRO + Default_Handler $handler_name +$handler_name PROC + EXPORT $handler_name [WEAK] + B . + ENDP + MEND + + Default_Handler NMI_Handler + Default_Handler HardFault_Handler + Default_Handler MemManage_Handler + Default_Handler BusFault_Handler + Default_Handler UsageFault_Handler + Default_Handler SVC_Handler + Default_Handler DebugMon_Handler + Default_Handler PendSV_Handler + Default_Handler SysTick_Handler + + Default_Handler NS_WATCHDOG_RESET_IRQHandler + Default_Handler NS_WATCHDOG_IRQHandler + Default_Handler S32K_TIMER_IRQHandler + Default_Handler TIMER0_IRQHandler + Default_Handler TIMER1_IRQHandler + Default_Handler DUALTIMER_IRQHandler + Default_Handler MHU0_IRQHandler + Default_Handler MHU1_IRQHandler + Default_Handler CRYPTOCELL_IRQHandler + Default_Handler I_CACHE_INV_ERR_IRQHandler + Default_Handler SYS_PPU_IRQHandler + Default_Handler CPU0_PPU_IRQHandler + Default_Handler CPU1_PPU_IRQHandler + Default_Handler CPU0_DGB_PPU_IRQHandler + Default_Handler CPU1_DGB_PPU_IRQHandler + Default_Handler CRYPTOCELL_PPU_IRQHandler + Default_Handler RAM0_PPU_IRQHandler + Default_Handler RAM1_PPU_IRQHandler + Default_Handler RAM2_PPU_IRQHandler + Default_Handler RAM3_PPU_IRQHandler + Default_Handler DEBUG_PPU_IRQHandler + Default_Handler CPU0_CTI_IRQHandler + Default_Handler CPU1_CTI_IRQHandler + + Default_Handler GpTimer_IRQHandler + Default_Handler I2C0_IRQHandler + Default_Handler I2C1_IRQHandler + Default_Handler I2S_IRQHandler + Default_Handler SPI_IRQHandler + Default_Handler QSPI_IRQHandler + Default_Handler UART0_Rx_IRQHandler + Default_Handler UART0_Tx_IRQHandler + Default_Handler UART0_RxTimeout_IRQHandler + Default_Handler UART0_ModemStatus_IRQHandler + Default_Handler UART0_Error_IRQHandler + Default_Handler UART0_IRQHandler + Default_Handler UART1_Rx_IRQHandler + Default_Handler UART1_Tx_IRQHandler + Default_Handler UART1_RxTimeout_IRQHandler + Default_Handler UART1_ModemStatus_IRQHandler + Default_Handler UART1_Error_IRQHandler + Default_Handler UART1_IRQHandler + Default_Handler GPIO_0_IRQHandler + Default_Handler GPIO_1_IRQHandler + Default_Handler GPIO_2_IRQHandler + Default_Handler GPIO_3_IRQHandler + Default_Handler GPIO_4_IRQHandler + Default_Handler GPIO_5_IRQHandler + Default_Handler GPIO_6_IRQHandler + Default_Handler GPIO_7_IRQHandler + Default_Handler GPIO_8_IRQHandler + Default_Handler GPIO_9_IRQHandler + Default_Handler GPIO_10_IRQHandler + Default_Handler GPIO_11_IRQHandler + Default_Handler GPIO_12_IRQHandler + Default_Handler GPIO_13_IRQHandler + Default_Handler GPIO_14_IRQHandler + Default_Handler GPIO_15_IRQHandler + Default_Handler GPIO_Combined_IRQHandler + Default_Handler PVT_IRQHandler + Default_Handler PWM_0_IRQHandler + Default_Handler RTC_IRQHandler + Default_Handler GpTimer1_IRQHandler + Default_Handler GpTimer0_IRQHandler + Default_Handler PWM_1_IRQHandler + Default_Handler PWM_2_IRQHandler + Default_Handler IOMUX_IRQHandler + + ALIGN + + END diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_GCC_ARM/musca_ns.ld b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_GCC_ARM/musca_ns.ld new file mode 100644 index 00000000000..4d43c72e89d --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_GCC_ARM/musca_ns.ld @@ -0,0 +1,197 @@ +;/* +; * Copyright (c) 2019 ARM Limited +; * +; * SPDX-License-Identifier: Apache-2.0 +; * +; * Licensed under the Apache License, Version 2.0 (the "License"); +; * you may not use this file except in compliance with the License. +; * You may obtain a copy of the License at +; * +; * http://www.apache.org/licenses/LICENSE-2.0 +; * +; * Unless required by applicable law or agreed to in writing, software +; * distributed under the License is distributed on an "AS IS" BASIS, +; * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +; * See the License for the specific language governing permissions and +; * limitations under the License. +; * +; * +; * This file is derivative of CMSIS V5.00 gcc_arm.ld +; */ + +/* Linker script to configure memory regions. */ +/* This file will be run trough the pre-processor. */ + +#include "../../partition/region_defs.h" +#include "../cmsis_nvic.h" + +/* Stack size is 1K for Mbed-OS */ +#if !defined(MBED_CONF_TARGET_BOOT_STACK_SIZE) + #define MBED_CONF_TARGET_BOOT_STACK_SIZE 0x400 +#endif + +MEMORY +{ + FLASH (rx) : ORIGIN = NS_CODE_START, LENGTH = NS_CODE_SIZE + /* Vector table is copied to RAM, so RAM address needs to be adjusted */ + RAM (rwx) : ORIGIN = NVIC_RAM_VECTOR_LIMIT, LENGTH = (NS_DATA_SIZE - NVIC_RAM_VECTOR_SIZE) +} + +__stack_size__ = MBED_CONF_TARGET_BOOT_STACK_SIZE; + +/* Library configurations */ +GROUP(libgcc.a libc.a libm.a libnosys.a) + +ENTRY(Reset_Handler) + +SECTIONS +{ + .text : + { + KEEP(*(.vectors)) + __Vectors_End = .; + __Vectors_Size = __Vectors_End - __Vectors; + __end__ = .; + + *(.text*) + KEEP(*(.init)) + KEEP(*(.fini)) + + + + + + /* .ctors */ + *crtbegin.o(.ctors) + *crtbegin?.o(.ctors) + *(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors) + *(SORT(.ctors.*)) + *(.ctors) + + /* .dtors */ + *crtbegin.o(.dtors) + *crtbegin?.o(.dtors) + *(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors) + *(SORT(.dtors.*)) + *(.dtors) + + *(.rodata*) + + KEEP(*(.eh_frame*)) + } > FLASH + + .ARM.extab : + { + *(.ARM.extab* .gnu.linkonce.armextab.*) + } > FLASH + + __exidx_start = .; + .ARM.exidx : + { + *(.ARM.exidx* .gnu.linkonce.armexidx.*) + } > FLASH + __exidx_end = .; + + /* To copy multiple ROM to RAM sections, + * define etext2/data2_start/data2_end and + * define __STARTUP_COPY_MULTIPLE in startup_cmsdk_musca_ns.S */ + .copy.table : + { + . = ALIGN(4); + __copy_table_start__ = .; + LONG (__etext) + LONG (__data_start__) + LONG (__data_end__ - __data_start__) + LONG (DEFINED(__etext2) ? __etext2 : 0) + LONG (DEFINED(__data2_start__) ? __data2_start__ : 0) + LONG (DEFINED(__data2_start__) ? __data2_end__ - __data2_start__ : 0) + __copy_table_end__ = .; + } > FLASH + + /* To clear multiple BSS sections, + * uncomment .zero.table section and, + * define __STARTUP_CLEAR_BSS_MULTIPLE in startup_cmsdk_musca_ns.S */ + .zero.table : + { + . = ALIGN(4); + __zero_table_start__ = .; + LONG (__bss_start__) + LONG (__bss_end__ - __bss_start__) + LONG (DEFINED(__bss2_start__) ? __bss2_start__ : 0) + LONG (DEFINED(__bss2_start__) ? __bss2_end__ - __bss2_start__ : 0) + __zero_table_end__ = .; + } > FLASH + + __etext = .; + + .data : AT (__etext) + { + __data_start__ = .; + *(vtable) + *(.data*) + + . = ALIGN(4); + /* preinit data */ + PROVIDE_HIDDEN (__preinit_array_start = .); + KEEP(*(.preinit_array)) + PROVIDE_HIDDEN (__preinit_array_end = .); + + . = ALIGN(4); + /* init data */ + PROVIDE_HIDDEN (__init_array_start = .); + KEEP(*(SORT(.init_array.*))) + KEEP(*(.init_array)) + PROVIDE_HIDDEN (__init_array_end = .); + + + . = ALIGN(4); + /* finit data */ + PROVIDE_HIDDEN (__fini_array_start = .); + KEEP(*(SORT(.fini_array.*))) + KEEP(*(.fini_array)) + PROVIDE_HIDDEN (__fini_array_end = .); + + KEEP(*(.jcr*)) + . = ALIGN(4); + /* All data end */ + __data_end__ = .; + + } > RAM + + .bss : + { + . = ALIGN(4); + __bss_start__ = .; + *(.bss*) + *(COMMON) + . = ALIGN(4); + __bss_end__ = .; + } > RAM + + bss_size = __bss_end__ - __bss_start__; + + .stack : + { + . = ALIGN(8); + __StackLimit = .; + KEEP(*(.stack*)) + . += __stack_size__; + __StackTop = .; + } > RAM + PROVIDE(__stack = __StackTop); + + .heap (COPY): + { + . = ALIGN(8); + __HeapBase = .; + __end__ = .; + end = __end__; + KEEP(*(.heap*)) + . += (ORIGIN(RAM) + LENGTH(RAM) - .); + __HeapLimit = .; + __heap_limit = .; /* Add for _sbrk */ + } > RAM + + /* Check if data + heap + stack exceeds RAM limit */ + ASSERT(__StackTop <= (NS_DATA_START + NS_DATA_SIZE), "RAM region overflowed") +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_GCC_ARM/startup_cmsdk_musca_ns.S b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_GCC_ARM/startup_cmsdk_musca_ns.S new file mode 100644 index 00000000000..91bac468381 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/TOOLCHAIN_GCC_ARM/startup_cmsdk_musca_ns.S @@ -0,0 +1,357 @@ +;/* +; * Copyright (c) 2019-2020 Arm Limited +; * +; * SPDX-License-Identifier: Apache-2.0 +; * +; * Licensed under the Apache License, Version 2.0 (the "License"); +; * you may not use this file except in compliance with the License. +; * You may obtain a copy of the License at +; * +; * http://www.apache.org/licenses/LICENSE-2.0 +; * +; * Unless required by applicable law or agreed to in writing, software +; * distributed under the License is distributed on an "AS IS" BASIS, +; * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +; * See the License for the specific language governing permissions and +; * limitations under the License. +; * +; * +; * This file is derivative of CMSIS V5.00 startup_ARMCM33.S +; */ + + .syntax unified + .arch armv8-m.main + + .section .vectors + .align 2 + .globl __Vectors +__Vectors: + .long __StackTop /* Top of Stack */ + .long Reset_Handler /* Reset Handler */ + .long NMI_Handler /* NMI Handler */ + .long HardFault_Handler /* Hard Fault Handler */ + .long MemManage_Handler /* MPU Fault Handler */ + .long BusFault_Handler /* Bus Fault Handler */ + .long UsageFault_Handler /* Usage Fault Handler */ + .long 0 /* Reserved */ + .long 0 /* Reserved */ + .long 0 /* Reserved */ + .long 0 /* Reserved */ + .long SVC_Handler /* SVCall Handler */ + .long DebugMon_Handler /* Debug Monitor Handler */ + .long 0 /* Reserved */ + .long PendSV_Handler /* PendSV Handler */ + .long SysTick_Handler /* SysTick Handler */ + + /* Core interrupts */ + .long NS_WATCHDOG_RESET_IRQHandler /* 0: Non-Secure Watchdog Reset Request Interrupt */ + .long NS_WATCHDOG_IRQHandler /* 1: Non-Secure Watchdog Interrupt */ + .long S32K_TIMER_IRQHandler /* 2: S32K Timer Interrupt */ + .long TIMER0_IRQHandler /* 3: CMSDK Timer 0 Interrupt */ + .long TIMER1_IRQHandler /* 4: CMSDK Timer 1 Interrupt */ + .long DUALTIMER_IRQHandler /* 5: CMSDK Dual Timer Interrupt */ + .long MHU0_IRQHandler /* 6: Message Handling Unit 0 Interrupt */ + .long MHU1_IRQHandler /* 7: Message Handling Unit 1 Interrupt */ + .long CRYPTOCELL_IRQHandler /* 8: CryptoCell-312 Interrupt */ + .long 0 /* 9: Reserved */ + .long 0 /* 10: Reserved */ + .long 0 /* 11: Reserved */ + .long 0 /* 12: Reserved */ + .long I_CACHE_INV_ERR_IRQHandler /* 13: Intsruction Cache Invalidation Interrupt */ + .long 0 /* 14: Reserved */ + .long SYS_PPU_IRQHandler /* 15: System PPU Interrupt */ + .long CPU0_PPU_IRQHandler /* 16: CPU0 PPU Interrupt */ + .long CPU1_PPU_IRQHandler /* 17: CPU1 PPU Interrupt */ + .long CPU0_DGB_PPU_IRQHandler /* 18: CPU0 Debug PPU Interrupt */ + .long CPU1_DGB_PPU_IRQHandler /* 19: CPU1 Debug PPU Interrupt */ + .long CRYPTOCELL_PPU_IRQHandler /* 20: CryptoCell PPU Interrupt */ + .long 0 /* 21: Reserved */ + .long RAM0_PPU_IRQHandler /* 22: RAM 0 PPU Interrupt */ + .long RAM1_PPU_IRQHandler /* 23: RAM 1 PPU Interrupt */ + .long RAM2_PPU_IRQHandler /* 24: RAM 2 PPU Interrupt */ + .long RAM3_PPU_IRQHandler /* 25: RAM 3 PPU Interrupt */ + .long DEBUG_PPU_IRQHandler /* 26: Debug PPU Interrupt */ + .long 0 /* 27: Reserved */ + .long CPU0_CTI_IRQHandler /* 28: CPU0 CTI Interrupt */ + .long CPU1_CTI_IRQHandler /* 29: CPU1 CTI Interrupt */ + .long 0 /* 30: Reserved */ + .long 0 /* 31: Reserved */ + + /* External interrupts */ + .long 0 /* 32: Reserved */ + .long GpTimer_IRQHandler /* 33: General Purpose Timer */ + .long I2C0_IRQHandler /* 34: I2C0 */ + .long I2C1_IRQHandler /* 35: I2C1 */ + .long I2S_IRQHandler /* 36: I2S */ + .long SPI_IRQHandler /* 37: SPI */ + .long QSPI_IRQHandler /* 38: QSPI */ + .long UART0_Rx_IRQHandler /* 39: UART0 receive FIFO interrupt */ + .long UART0_Tx_IRQHandler /* 40: UART0 transmit FIFO interrupt */ + .long UART0_RxTimeout_IRQHandler /* 41: UART0 receive timeout interrupt */ + .long UART0_ModemStatus_IRQHandler /* 42: UART0 modem status interrupt */ + .long UART0_Error_IRQHandler /* 43: UART0 error interrupt */ + .long UART0_IRQHandler /* 44: UART0 interrupt */ + .long UART1_Rx_IRQHandler /* 45: UART1 receive FIFO interrupt */ + .long UART1_Tx_IRQHandler /* 46: UART1 transmit FIFO interrupt */ + .long UART1_RxTimeout_IRQHandler /* 47: UART1 receive timeout interrupt */ + .long UART1_ModemStatus_IRQHandler /* 48: UART1 modem status interrupt */ + .long UART1_Error_IRQHandler /* 49: UART1 error interrupt */ + .long UART1_IRQHandler /* 50: UART1 interrupt */ + .long GPIO_0_IRQHandler /* 51: GPIO 0 interrupt */ + .long GPIO_1_IRQHandler /* 52: GPIO 1 interrupt */ + .long GPIO_2_IRQHandler /* 53: GPIO 2 interrupt */ + .long GPIO_3_IRQHandler /* 54: GPIO 3 interrupt */ + .long GPIO_4_IRQHandler /* 55: GPIO 4 interrupt */ + .long GPIO_5_IRQHandler /* 56: GPIO 5 interrupt */ + .long GPIO_6_IRQHandler /* 57: GPIO 6 interrupt */ + .long GPIO_7_IRQHandler /* 58: GPIO 7 interrupt */ + .long GPIO_8_IRQHandler /* 59: GPIO 8 interrupt */ + .long GPIO_9_IRQHandler /* 60: GPIO 9 interrupt */ + .long GPIO_10_IRQHandler /* 61: GPIO 10 interrupt */ + .long GPIO_11_IRQHandler /* 62: GPIO 11 interrupt */ + .long GPIO_12_IRQHandler /* 63: GPIO 12 interrupt */ + .long GPIO_13_IRQHandler /* 64: GPIO 13 interrupt */ + .long GPIO_14_IRQHandler /* 65: GPIO 14 interrupt */ + .long GPIO_15_IRQHandler /* 66: GPIO 15 interrupt */ + .long GPIO_Combined_IRQHandler /* 67: GPIO Combined interrupt */ + .long PVT_IRQHandler /* 68: PVT sensor interrupt */ + .long 0 /* 69: Reserved */ + .long PWM_0_IRQHandler /* 70: PWM0 interrupt */ + .long RTC_IRQHandler /* 71: RTC interrupt */ + .long GpTimer1_IRQHandler /* 72: General Purpose Timer0 */ + .long GpTimer0_IRQHandler /* 73: General Purpose Timer1 */ + .long PWM_1_IRQHandler /* 74: PWM1 interrupt */ + .long PWM_2_IRQHandler /* 75: PWM2 interrupt */ + .long IOMUX_IRQHandler /* 76: IOMUX interrupt */ + + + .size __Vectors, . - __Vectors + + .text + .thumb + .thumb_func + .align 2 + .globl Reset_Handler + .type Reset_Handler, %function +Reset_Handler: +/* Firstly it copies data from read only memory to RAM. There are two schemes + * to copy. One can copy more than one sections. Another can only copy + * one section. The former scheme needs more instructions and read-only + * data to implement than the latter. + * Macro __STARTUP_COPY_MULTIPLE is used to choose between two schemes. */ + +#ifdef __STARTUP_COPY_MULTIPLE +/* Multiple sections scheme. + * + * Between symbol address __copy_table_start__ and __copy_table_end__, + * there are array of triplets, each of which specify: + * offset 0: LMA of start of a section to copy from + * offset 4: VMA of start of a section to copy to + * offset 8: size of the section to copy. Must be multiply of 4 + * + * All addresses must be aligned to 4 bytes boundary. + */ + ldr r4, =__copy_table_start__ + ldr r5, =__copy_table_end__ + +.L_loop0: + cmp r4, r5 + bge .L_loop0_done + ldr r1, [r4] + ldr r2, [r4, #4] + ldr r3, [r4, #8] + +.L_loop0_0: + subs r3, #4 + ittt ge + ldrge r0, [r1, r3] + strge r0, [r2, r3] + bge .L_loop0_0 + + adds r4, #12 + b .L_loop0 + +.L_loop0_done: +#else +/* Single section scheme. + * + * The ranges of copy from/to are specified by following symbols + * __etext: LMA of start of the section to copy from. Usually end of text + * __data_start__: VMA of start of the section to copy to + * __data_end__: VMA of end of the section to copy to + * + * All addresses must be aligned to 4 bytes boundary. + */ + ldr r1, =__etext + ldr r2, =__data_start__ + ldr r3, =__data_end__ + +.L_loop1: + cmp r2, r3 + ittt lt + ldrlt r0, [r1], #4 + strlt r0, [r2], #4 + blt .L_loop1 +#endif /*__STARTUP_COPY_MULTIPLE */ + +/* This part of work usually is done in C library startup code. Otherwise, + * define this macro to enable it in this startup. + * + * There are two schemes too. One can clear multiple BSS sections. Another + * can only clear one section. The former is more size expensive than the + * latter. + * + * Define macro __STARTUP_CLEAR_BSS_MULTIPLE to choose the former. + * Otherwise efine macro __STARTUP_CLEAR_BSS to choose the later. + */ +#ifdef __STARTUP_CLEAR_BSS_MULTIPLE +/* Multiple sections scheme. + * + * Between symbol address __copy_table_start__ and __copy_table_end__, + * there are array of tuples specifying: + * offset 0: Start of a BSS section + * offset 4: Size of this BSS section. Must be multiply of 4 + */ + ldr r3, =__zero_table_start__ + ldr r4, =__zero_table_end__ + +.L_loop2: + cmp r3, r4 + bge .L_loop2_done + ldr r1, [r3] + ldr r2, [r3, #4] + movs r0, 0 + +.L_loop2_0: + subs r2, #4 + itt ge + strge r0, [r1, r2] + bge .L_loop2_0 + + adds r3, #8 + b .L_loop2 +.L_loop2_done: +#elif defined (__STARTUP_CLEAR_BSS) +/* Single BSS section scheme. + * + * The BSS section is specified by following symbols + * __bss_start__: start of the BSS section. + * __bss_end__: end of the BSS section. + * + * Both addresses must be aligned to 4 bytes boundary. + */ + ldr r1, =__bss_start__ + ldr r2, =__bss_end__ + + movs r0, 0 +.L_loop3: + cmp r1, r2 + itt lt + strlt r0, [r1], #4 + blt .L_loop3 +#endif /* __STARTUP_CLEAR_BSS_MULTIPLE || __STARTUP_CLEAR_BSS */ + +#ifndef __NO_SYSTEM_INIT + bl SystemInit +#endif + +#ifndef __START +#define __START _start +#endif + bl __START + + .pool + .size Reset_Handler, . - Reset_Handler + + +/* Macro to define default handlers. */ + .macro def_irq_handler handler_name + .align 1 + .thumb_func + .weak \handler_name + \handler_name: + b \handler_name + .endm + + def_irq_handler NMI_Handler + def_irq_handler HardFault_Handler + def_irq_handler MemManage_Handler + def_irq_handler BusFault_Handler + def_irq_handler UsageFault_Handler + def_irq_handler SVC_Handler + def_irq_handler DebugMon_Handler + def_irq_handler PendSV_Handler + def_irq_handler SysTick_Handler + + /* Core interrupts */ + def_irq_handler NS_WATCHDOG_RESET_IRQHandler /* 0: Non-Secure Watchdog Reset Request Interrupt */ + def_irq_handler NS_WATCHDOG_IRQHandler /* 1: Non-Secure Watchdog Interrupt */ + def_irq_handler S32K_TIMER_IRQHandler /* 2: S32K Timer Interrupt */ + def_irq_handler TIMER0_IRQHandler /* 3: CMSDK Timer 0 Interrupt */ + def_irq_handler TIMER1_IRQHandler /* 4: CMSDK Timer 1 Interrupt */ + def_irq_handler DUALTIMER_IRQHandler /* 5: CMSDK Dual Timer Interrupt */ + def_irq_handler MHU0_IRQHandler /* 6: Message Handling Unit 0 Interrupt */ + def_irq_handler MHU1_IRQHandler /* 7: Message Handling Unit 1 Interrupt */ + def_irq_handler CRYPTOCELL_IRQHandler /* 8: CryptoCell-312 Interrupt */ + def_irq_handler I_CACHE_INV_ERR_IRQHandler /* 13: Intsruction Cache Invalidation Interrupt */ + def_irq_handler SYS_PPU_IRQHandler /* 15: System PPU Interrupt */ + def_irq_handler CPU0_PPU_IRQHandler /* 16: CPU0 PPU Interrupt */ + def_irq_handler CPU1_PPU_IRQHandler /* 17: CPU1 PPU Interrupt */ + def_irq_handler CPU0_DGB_PPU_IRQHandler /* 18: CPU0 Debug PPU Interrupt */ + def_irq_handler CPU1_DGB_PPU_IRQHandler /* 19: CPU1 Debug PPU Interrupt */ + def_irq_handler CRYPTOCELL_PPU_IRQHandler /* 20: CryptoCell PPU Interrupt */ + def_irq_handler RAM0_PPU_IRQHandler /* 22: RAM 0 PPU Interrupt */ + def_irq_handler RAM1_PPU_IRQHandler /* 23: RAM 1 PPU Interrupt */ + def_irq_handler RAM2_PPU_IRQHandler /* 24: RAM 2 PPU Interrupt */ + def_irq_handler RAM3_PPU_IRQHandler /* 25: RAM 3 PPU Interrupt */ + def_irq_handler DEBUG_PPU_IRQHandler /* 26: Debug PPU Interrupt */ + def_irq_handler CPU0_CTI_IRQHandler /* 28: CPU0 CTI Interrupt */ + def_irq_handler CPU1_CTI_IRQHandler /* 29: CPU1 CTI Interrupt */ + + /* External interrupts */ + def_irq_handler GpTimer_IRQHandler /* 33: General Purpose Timer */ + def_irq_handler I2C0_IRQHandler /* 34: I2C0 */ + def_irq_handler I2C1_IRQHandler /* 35: I2C1 */ + def_irq_handler I2S_IRQHandler /* 36: I2S */ + def_irq_handler SPI_IRQHandler /* 37: SPI */ + def_irq_handler QSPI_IRQHandler /* 38: QSPI */ + def_irq_handler UART0_Rx_IRQHandler /* 39: UART0 receive FIFO interrupt */ + def_irq_handler UART0_Tx_IRQHandler /* 40: UART0 transmit FIFO interrupt */ + def_irq_handler UART0_RxTimeout_IRQHandler /* 41: UART0 receive timeout interrupt */ + def_irq_handler UART0_ModemStatus_IRQHandler /* 42: UART0 modem status interrupt */ + def_irq_handler UART0_Error_IRQHandler /* 43: UART0 error interrupt */ + def_irq_handler UART0_IRQHandler /* 44: UART0 interrupt */ + def_irq_handler UART1_Rx_IRQHandler /* 45: UART1 receive FIFO interrupt */ + def_irq_handler UART1_Tx_IRQHandler /* 46: UART1 transmit FIFO interrupt */ + def_irq_handler UART1_RxTimeout_IRQHandler /* 47: UART1 receive timeout interrupt */ + def_irq_handler UART1_ModemStatus_IRQHandler /* 48: UART1 modem status interrupt */ + def_irq_handler UART1_Error_IRQHandler /* 49: UART1 error interrupt */ + def_irq_handler UART1_IRQHandler /* 50: UART1 interrupt */ + def_irq_handler GPIO_0_IRQHandler /* 51: GPIO 0 interrupt */ + def_irq_handler GPIO_1_IRQHandler /* 52: GPIO 1 interrupt */ + def_irq_handler GPIO_2_IRQHandler /* 53: GPIO 2 interrupt */ + def_irq_handler GPIO_3_IRQHandler /* 54: GPIO 3 interrupt */ + def_irq_handler GPIO_4_IRQHandler /* 55: GPIO 4 interrupt */ + def_irq_handler GPIO_5_IRQHandler /* 56: GPIO 5 interrupt */ + def_irq_handler GPIO_6_IRQHandler /* 57: GPIO 6 interrupt */ + def_irq_handler GPIO_7_IRQHandler /* 58: GPIO 7 interrupt */ + def_irq_handler GPIO_8_IRQHandler /* 59: GPIO 8 interrupt */ + def_irq_handler GPIO_9_IRQHandler /* 60: GPIO 9 interrupt */ + def_irq_handler GPIO_10_IRQHandler /* 61: GPIO 10 interrupt */ + def_irq_handler GPIO_11_IRQHandler /* 62: GPIO 11 interrupt */ + def_irq_handler GPIO_12_IRQHandler /* 63: GPIO 12 interrupt */ + def_irq_handler GPIO_13_IRQHandler /* 64: GPIO 13 interrupt */ + def_irq_handler GPIO_14_IRQHandler /* 65: GPIO 14 interrupt */ + def_irq_handler GPIO_15_IRQHandler /* 66: GPIO 15 interrupt */ + def_irq_handler GPIO_Combined_IRQHandler /* 67: GPIO Combined interrupt */ + def_irq_handler PVT_IRQHandler /* 68: PVT sensor interrupt */ + def_irq_handler PWM_0_IRQHandler /* 70: PWM0 interrupt */ + def_irq_handler RTC_IRQHandler /* 71: RTC interrupt */ + def_irq_handler GpTimer1_IRQHandler /* 72: General Purpose Timer0 */ + def_irq_handler GpTimer0_IRQHandler /* 73: General Purpose Timer1 */ + def_irq_handler PWM_1_IRQHandler /* 74: PWM1 interrupt */ + def_irq_handler PWM_2_IRQHandler /* 75: PWM2 interrupt */ + def_irq_handler IOMUX_IRQHandler /* 76: IOMUX interrupt */ + + + .end diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/cmsis.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/cmsis.h new file mode 100644 index 00000000000..22a3aada8a3 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/cmsis.h @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2017-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __MUSCA_S1_CMSIS_H__ +#define __MUSCA_S1_CMSIS_H__ + +/* Processor and Core Peripherals and configurations */ + +/* ========================================================================== */ +/* ============= Processor and Core Peripheral Section ============= */ +/* ========================================================================== */ + +/* ----- Start of section using anonymous unions and disabling warnings ----- */ +#if defined (__CC_ARM) + #pragma push + #pragma anon_unions +#elif defined (__ICCARM__) + #pragma language=extended +#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wc11-extensions" + #pragma clang diagnostic ignored "-Wreserved-id-macro" +#elif defined (__GNUC__) + /* anonymous unions are enabled by default */ +#elif defined (__TMS470__) + /* anonymous unions are enabled by default */ +#elif defined (__TASKING__) + #pragma warning 586 +#elif defined (__CSMC__) + /* anonymous unions are enabled by default */ +#else + #warning Not supported compiler type +#endif + + +/* -- Configuration of the Cortex-M33 Processor and Core Peripherals -- */ +#define __CM33_REV 0x0002U /* Core revision r0p2 */ +#define __SAUREGION_PRESENT 1U /* SAU regions present */ +#define __MPU_PRESENT 1U /* MPU present */ +#define __VTOR_PRESENT 1U /* VTOR present */ +#define __NVIC_PRIO_BITS 4U /* Number of Bits used for the + * Priority Levels */ +#define __Vendor_SysTickConfig 0U /* Set to 1 if different SysTick + * Config is used */ +#define __FPU_PRESENT 1U /* FPU present */ +#define __DSP_PRESENT 1U /* DSP extension present */ + +#include "system_core_init.h" +#include "platform_irq.h" +#include /*!< Arm Cortex-M33 processor and core peripherals */ + +/* ------ End of section using anonymous unions and disabling warnings ------ */ +#if defined (__CC_ARM) + #pragma pop +#elif defined (__ICCARM__) + /* leave anonymous unions enabled */ +#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) + #pragma clang diagnostic pop +#elif defined (__GNUC__) + /* anonymous unions are enabled by default */ +#elif defined (__TMS470__) + /* anonymous unions are enabled by default */ +#elif defined (__TASKING__) + #pragma warning restore +#elif defined (__CSMC__) + /* anonymous unions are enabled by default */ +#else + #warning Not supported compiler type +#endif + +#endif /*__MUSCA_S1_CMSIS_H__ */ diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/cmsis_nvic.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/cmsis_nvic.h new file mode 100644 index 00000000000..b83a445f9be --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/cmsis_nvic.h @@ -0,0 +1,35 @@ +/* mbed Microcontroller Library + * Copyright (c) 2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * This file is included from the linker script, + * limited set of C constructs can be used here + */ + +#ifndef MBED_CMSIS_NVIC_H +#define MBED_CMSIS_NVIC_H + +#include "../partition/region_defs.h" + +#define NVIC_NUM_VECTORS (16 + 77) +/** Location of vectors to move in RAM */ +#define NVIC_RAM_VECTOR_ADDRESS NS_DATA_START +#define NVIC_RAM_VECTOR_SIZE (NVIC_NUM_VECTORS * 4) +#define NVIC_RAM_VECTOR_LIMIT (NVIC_RAM_VECTOR_ADDRESS + NVIC_RAM_VECTOR_SIZE) + +#endif diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/cmsis_nvic_virtual.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/cmsis_nvic_virtual.h new file mode 100644 index 00000000000..5e6c6f3c42c --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/cmsis_nvic_virtual.h @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "cmsis.h" + +#ifndef NVIC_VIRTUAL_H +#define NVIC_VIRTUAL_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* NVIC functions */ +#define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping +#define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping +#define NVIC_EnableIRQ __NVIC_EnableIRQ +#define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ +#define NVIC_DisableIRQ __NVIC_DisableIRQ +#define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ +#define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ +#define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ +#define NVIC_GetActive __NVIC_GetActive +#define NVIC_SetPriority __NVIC_SetPriority +#define NVIC_GetPriority __NVIC_GetPriority + +/** + * \brief Overriding the default CMSIS system reset implementation by calling + * secure TFM service. + * + */ +void NVIC_SystemReset(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/device_cfg.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/device_cfg.h new file mode 100644 index 00000000000..cc4301f67bf --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/device_cfg.h @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2017-2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __MUSCA_S1_DEVICE_CFG_H__ +#define __MUSCA_S1_DEVICE_CFG_H__ + +/** + * \file device_cfg.h + * \brief Configuration file native driver re-targeting + * + * \details This file can be used to add native driver specific macro + * definitions to select which peripherals are available in the build. + * + * This is a default device configuration file with all peripherals enabled. + */ + +/*ARM UART Controller PL011*/ + +#define UART0_PL011_NS +#define UART0_PL011_DEV UART0_PL011_DEV_NS +#define uart0_tx_irq_handler UART0_Tx_IRQHandler +#define uart0_rx_irq_handler UART0_Rx_IRQHandler +#define uart0_rx_timeout_irq_handler UART0_RxTimeout_IRQHandler + +#define UART1_PL011_NS +#define UART1_PL011_DEV UART1_PL011_DEV_NS +#define uart1_tx_irq_handler UART1_Tx_IRQHandler +#define uart1_rx_irq_handler UART1_Rx_IRQHandler +#define uart1_rx_timeout_irq_handler UART1_RxTimeout_IRQHandler + +/* CMSDK Timers */ +#define CMSDK_TIMER0_NS +#define CMSDK_TIMER0_DEV CMSDK_TIMER0_DEV_NS +#define CMSDK_TIMER1_NS +#define CMSDK_TIMER1_DEV CMSDK_TIMER1_DEV_NS + +/* GPIO */ +#define GPIO0_CMSDK_NS +#define GPIO0_CMSDK_DEV GPIO0_CMSDK_DEV_NS; + +/* GP Timer */ +#define GP_TIMER_NS +#define GP_TIMER_DEV GP_TIMER_DEV_NS + +#define GP_TIMER_ALARM0_IRQ GpTimer0_IRQn +#define GP_TIMER_IRQ0_HANDLER GpTimer0_IRQHandler +#define GP_TIMER_ALARM_NR TIMER_GP_READ_ALARM_0 +#define GP_TIMER_FREQ_HZ 32768UL /* System Ref Clock */ +#define GP_TIMER_BIT_WIDTH 32U + +/* I2C IP6510 */ +#define I2C0_IP6510_NS +#define I2C0_IP6510_DEV I2C0_IP6510_DEV_NS +#define I2C1_IP6510_NS +#define I2C1_IP6510_DEV I2C1_IP6510_DEV_NS + +/** + * mbed usec high-resolution ticker configuration + */ +#define USEC_TIMER_DEV CMSDK_TIMER0_DEV_NS +#define usec_interval_irq_handler TIMER0_IRQHandler +#define USEC_INTERVAL_IRQ TIMER0_IRQn +/** Timer frequency is equal to SYSTEM_CLOCK, defined in system_core_clk.c */ +#define TIMER_FREQ_HZ 50000000U +/** The us Ticker uses CMSDK Timer, that does not have HW prescaler. + * The reported shift define is necessary for the software emulated + * prescaler behavior, so the ticker works as if it was ticking on a + * virtually slower frequency. The value 6 sets up the ticker to work + * properly in the specified frequency interval. + */ +#define USEC_REPORTED_SHIFT 6 +#define USEC_REPORTED_FREQ_HZ (TIMER_FREQ_HZ >> USEC_REPORTED_SHIFT) +#define USEC_REPORTED_BITS (32 - USEC_REPORTED_SHIFT) + +#define UART_DEFAULT_BAUD_RATE 115200U + +/* Cadence QSPI Flash Controller */ +#define QSPI_IP6514E_NS + +/* MT25QL Flash memory library */ +#define MT25QL_NS +#define FLASH_DEV MT25QL_DEV_NS + +#endif /* __ARM_LTD_DEVICE_CFG_H__ */ diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/device_definition.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/device_definition.c new file mode 100644 index 00000000000..4b1841572f4 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/device_definition.c @@ -0,0 +1,573 @@ +/* + * Copyright (c) 2017-2020 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * \file device_definition.c + * \brief This file defines exports the structures based on the peripheral + * definitions from device_cfg.h. + * This file is meant to be used as a helper for baremetal + * applications and/or as an example of how to configure the generic + * driver structures. + */ + +#include "device_cfg.h" +#include "device_definition.h" +#include "platform_base_address.h" + +/* ======= Peripheral configuration structure definitions ======= */ +/* MUSCA S1 SCC driver structures */ +#ifdef MUSCA_S1_SCC_S +static const struct musca_s1_scc_dev_cfg_t MUSCA_S1_SCC_DEV_CFG_S = { + .base = MUSCA_S1_SCC_S_BASE}; +struct musca_s1_scc_dev_t MUSCA_S1_SCC_DEV_S = {&(MUSCA_S1_SCC_DEV_CFG_S)}; +#endif +#ifdef MUSCA_S1_SCC_NS +static const struct musca_s1_scc_dev_cfg_t MUSCA_S1_SCC_DEV_CFG_NS = { + .base = MUSCA_S1_SCC_NS_BASE}; +struct musca_s1_scc_dev_t MUSCA_S1_SCC_DEV_NS = {&(MUSCA_S1_SCC_DEV_CFG_NS)}; +#endif + +/* CMSDK GPIO driver structures */ +#ifdef GPIO0_CMSDK_S +static const struct gpio_cmsdk_dev_cfg_t GPIO0_CMSDK_DEV_CFG_S = { + .base = MUSCA_S1_GPIO_S_BASE}; +struct gpio_cmsdk_dev_t GPIO0_CMSDK_DEV_S = {&(GPIO0_CMSDK_DEV_CFG_S)}; +#endif +#ifdef GPIO0_CMSDK_NS +static const struct gpio_cmsdk_dev_cfg_t GPIO0_CMSDK_DEV_CFG_NS = { + .base = MUSCA_S1_GPIO_NS_BASE}; +struct gpio_cmsdk_dev_t GPIO0_CMSDK_DEV_NS = {&(GPIO0_CMSDK_DEV_CFG_NS)}; +#endif + +/* ARM PPC SSE 200 driver structures */ +#ifdef AHB_PPC0_S +static struct ppc_sse200_dev_cfg_t AHB_PPC0_DEV_CFG_S = { + .spctrl_base = MUSCA_S1_SPCTRL_S_BASE, + .nspctrl_base = MUSCA_S1_NSPCTRL_NS_BASE }; +static struct ppc_sse200_dev_data_t AHB_PPC0_DEV_DATA_S = { + .p_ns_ppc = 0, + .p_sp_ppc = 0, + .p_nsp_ppc = 0, + .int_bit_mask = 0, + .state = 0 }; +struct ppc_sse200_dev_t AHB_PPC0_DEV_S = { + &AHB_PPC0_DEV_CFG_S, &AHB_PPC0_DEV_DATA_S }; +#endif + +#ifdef AHB_PPCEXP0_S +static struct ppc_sse200_dev_cfg_t AHB_PPCEXP0_DEV_CFG_S = { + .spctrl_base = MUSCA_S1_SPCTRL_S_BASE, + .nspctrl_base = MUSCA_S1_NSPCTRL_NS_BASE }; +static struct ppc_sse200_dev_data_t AHB_PPCEXP0_DEV_DATA_S = { + .p_ns_ppc = 0, + .p_sp_ppc = 0, + .p_nsp_ppc = 0, + .int_bit_mask = 0, + .state = 0 }; +struct ppc_sse200_dev_t AHB_PPCEXP0_DEV_S = { + &AHB_PPCEXP0_DEV_CFG_S, &AHB_PPCEXP0_DEV_DATA_S }; +#endif + +#ifdef APB_PPC0_S +static struct ppc_sse200_dev_cfg_t APB_PPC0_DEV_CFG_S = { + .spctrl_base = MUSCA_S1_SPCTRL_S_BASE, + .nspctrl_base = MUSCA_S1_NSPCTRL_NS_BASE }; +static struct ppc_sse200_dev_data_t APB_PPC0_DEV_DATA_S = { + .p_ns_ppc = 0, + .p_sp_ppc = 0, + .p_nsp_ppc = 0, + .int_bit_mask = 0, + .state = 0 }; +struct ppc_sse200_dev_t APB_PPC0_DEV_S = { + &APB_PPC0_DEV_CFG_S, &APB_PPC0_DEV_DATA_S }; +#endif + +#ifdef APB_PPC1_S +static struct ppc_sse200_dev_cfg_t APB_PPC1_DEV_CFG_S = { + .spctrl_base = MUSCA_S1_SPCTRL_S_BASE, + .nspctrl_base = MUSCA_S1_NSPCTRL_NS_BASE }; +static struct ppc_sse200_dev_data_t APB_PPC1_DEV_DATA_S = { + .p_ns_ppc = 0, + .p_sp_ppc = 0, + .p_nsp_ppc = 0, + .int_bit_mask = 0, + .state = 0 }; +struct ppc_sse200_dev_t APB_PPC1_DEV_S = { + &APB_PPC1_DEV_CFG_S, &APB_PPC1_DEV_DATA_S}; +#endif + +#ifdef APB_PPCEXP0_S +static struct ppc_sse200_dev_cfg_t APB_PPCEXP0_DEV_CFG_S = { + .spctrl_base = MUSCA_S1_SPCTRL_S_BASE, + .nspctrl_base = MUSCA_S1_NSPCTRL_NS_BASE }; +static struct ppc_sse200_dev_data_t APB_PPCEXP0_DEV_DATA_S = { + .p_ns_ppc = 0, + .p_sp_ppc = 0, + .p_nsp_ppc = 0, + .int_bit_mask = 0, + .state = 0 }; +struct ppc_sse200_dev_t APB_PPCEXP0_DEV_S = { + &APB_PPCEXP0_DEV_CFG_S, &APB_PPCEXP0_DEV_DATA_S }; +#endif + +#ifdef APB_PPCEXP1_S +static struct ppc_sse200_dev_cfg_t APB_PPCEXP1_DEV_CFG = { + .spctrl_base = MUSCA_S1_SPCTRL_S_BASE, + .nspctrl_base = MUSCA_S1_NSPCTRL_NS_BASE }; +static struct ppc_sse200_dev_data_t APB_PPCEXP1_DEV_DATA_S = { + .p_ns_ppc = 0, + .p_sp_ppc = 0, + .p_nsp_ppc = 0, + .int_bit_mask = 0, + .state = 0 }; +struct ppc_sse200_dev_t APB_PPCEXP1_DEV_S = { + &APB_PPCEXP1_DEV_CFG, &APB_PPCEXP1_DEV_DATA_S }; +#endif + +/* ARM MPC SIE 200 driver structures */ +#ifdef MPC_ISRAM0_S +static const struct mpc_sie_dev_cfg_t MPC_ISRAM0_DEV_CFG_S = { + .base = MUSCA_S1_MPC_SRAM0_S_BASE}; +static struct mpc_sie_dev_data_t MPC_ISRAM0_DEV_DATA_S = { + .range_list = 0, + .nbr_of_ranges = 0, + .is_initialized = false}; +struct mpc_sie_dev_t MPC_ISRAM0_DEV_S = { + &(MPC_ISRAM0_DEV_CFG_S), + &(MPC_ISRAM0_DEV_DATA_S)}; +#endif + +#ifdef MPC_ISRAM1_S +static const struct mpc_sie_dev_cfg_t MPC_ISRAM1_DEV_CFG_S = { + .base = MUSCA_S1_MPC_SRAM1_S_BASE}; +static struct mpc_sie_dev_data_t MPC_ISRAM1_DEV_DATA_S = { + .range_list = 0, + .nbr_of_ranges = 0, + .is_initialized = false}; +struct mpc_sie_dev_t MPC_ISRAM1_DEV_S = { + &(MPC_ISRAM1_DEV_CFG_S), + &(MPC_ISRAM1_DEV_DATA_S)}; +#endif + +#ifdef MPC_ISRAM2_S +static const struct mpc_sie_dev_cfg_t MPC_ISRAM2_DEV_CFG_S = { + .base = MUSCA_S1_MPC_SRAM2_S_BASE}; +static struct mpc_sie_dev_data_t MPC_ISRAM2_DEV_DATA_S = { + .range_list = 0, + .nbr_of_ranges = 0, + .is_initialized = false}; +struct mpc_sie_dev_t MPC_ISRAM2_DEV_S = { + &(MPC_ISRAM2_DEV_CFG_S), + &(MPC_ISRAM2_DEV_DATA_S)}; +#endif + +#ifdef MPC_ISRAM3_S +static const struct mpc_sie_dev_cfg_t MPC_ISRAM3_DEV_CFG_S = { + .base = MUSCA_S1_MPC_SRAM3_S_BASE}; +static struct mpc_sie_dev_data_t MPC_ISRAM3_DEV_DATA_S = { + .range_list = 0, + .nbr_of_ranges = 0, + .is_initialized = false}; +struct mpc_sie_dev_t MPC_ISRAM3_DEV_S = { + &(MPC_ISRAM3_DEV_CFG_S), + &(MPC_ISRAM3_DEV_DATA_S)}; +#endif + +#ifdef MPC_CODE_SRAM_NS +static const struct mpc_sie_dev_cfg_t MPC_CODE_SRAM_DEV_CFG_NS = { + .base = MUSCA_S1_CODE_SRAM_MPC_NS_BASE}; +static struct mpc_sie_dev_data_t MPC_CODE_SRAM_DEV_DATA_NS = { + .range_list = 0, + .nbr_of_ranges = 0, + .is_initialized = false}; +struct mpc_sie_dev_t MPC_CODE_SRAM_DEV_NS = { + &(MPC_CODE_SRAM_DEV_CFG_NS), + &(MPC_CODE_SRAM_DEV_DATA_NS)}; +#endif + +#ifdef MPC_CODE_SRAM_S +static const struct mpc_sie_dev_cfg_t MPC_CODE_SRAM_DEV_CFG_S = { + .base = MUSCA_S1_CODE_SRAM_MPC_S_BASE}; +static struct mpc_sie_dev_data_t MPC_CODE_SRAM_DEV_DATA_S = { + .range_list = 0, + .nbr_of_ranges = 0, + .is_initialized = false}; +struct mpc_sie_dev_t MPC_CODE_SRAM_DEV_S = { + &(MPC_CODE_SRAM_DEV_CFG_S), + &(MPC_CODE_SRAM_DEV_DATA_S)}; +#endif + +#ifdef MPC_QSPI_S +static const struct mpc_sie_dev_cfg_t MPC_QSPI_DEV_CFG_S = { + .base = MUSCA_S1_QSPI_MPC_S_BASE}; +static struct mpc_sie_dev_data_t MPC_QSPI_DEV_DATA_S = { + .range_list = 0, + .nbr_of_ranges = 0, + .is_initialized = false}; +struct mpc_sie_dev_t MPC_QSPI_DEV_S = { + &(MPC_QSPI_DEV_CFG_S), + &(MPC_QSPI_DEV_DATA_S)}; +#endif + +#ifdef MPC_QSPI_NS +static const struct mpc_sie_dev_cfg_t MPC_QSPI_DEV_CFG_NS = { + .base = MUSCA_S1_QSPI_MPC_NS_BASE}; +static struct mpc_sie_dev_data_t MPC_QSPI_DEV_DATA_NS = { + .range_list = 0, + .nbr_of_ranges = 0, + .is_initialized = false}; +struct mpc_sie_dev_t MPC_QSPI_DEV_NS = { + &(MPC_QSPI_DEV_CFG_NS), + &(MPC_QSPI_DEV_DATA_NS)}; +#endif + +#ifdef MPC_MRAM_S +static const struct mpc_sie_dev_cfg_t MPC_MRAM_DEV_CFG_S = { + .base = MUSCA_S1_MRAM_MPC_S_BASE}; +static struct mpc_sie_dev_data_t MPC_MRAM_DEV_DATA_S = { + .range_list = 0, + .nbr_of_ranges = 0, + .is_initialized = false}; +struct mpc_sie_dev_t MPC_MRAM_DEV_S = { + &(MPC_MRAM_DEV_CFG_S), + &(MPC_MRAM_DEV_DATA_S)}; +#endif + +#ifdef MPC_MRAM_NS +static const struct mpc_sie_dev_cfg_t MPC_MRAM_DEV_CFG_NS = { + .base = MUSCA_S1_MRAM_MPC_NS_BASE}; +static struct mpc_sie_dev_data_t MPC_MRAM_DEV_DATA_NS = { + .range_list = 0, + .nbr_of_ranges = 0, + .is_initialized = false}; +struct mpc_sie_dev_t MPC_MRAM_DEV_NS = { + &(MPC_MRAM_DEV_CFG_NS), + &(MPC_MRAM_DEV_DATA_NS)}; +#endif + +/* ARM MHU driver structures */ +#ifdef ARM_MHU0_S +static const struct arm_mhu_sse_200_dev_cfg_t ARM_MHU0_DEV_CFG_S = { + .base = MUSCA_S1_MHU0_S_BASE}; +struct arm_mhu_sse_200_dev_t ARM_MHU0_DEV_S = {&(ARM_MHU0_DEV_CFG_S)}; +#endif +#ifdef ARM_MHU0_NS +static const struct arm_mhu_sse_200_dev_cfg_t ARM_MHU0_DEV_CFG_NS = { + .base = MUSCA_S1_MHU0_NS_BASE}; +struct arm_mhu_sse_200_dev_t ARM_MHU0_DEV_NS = {&(ARM_MHU0_DEV_CFG_NS)}; +#endif + +#ifdef ARM_MHU1_S +static const struct arm_mhu_sse_200_dev_cfg_t ARM_MHU1_DEV_CFG_S = { + .base = MUSCA_S1_MHU1_S_BASE}; +struct arm_mhu_sse_200_dev_t ARM_MHU1_DEV_S = {&(ARM_MHU1_DEV_CFG_S)}; +#endif +#ifdef ARM_MHU1_NS +static const struct arm_mhu_sse_200_dev_cfg_t ARM_MHU1_DEV_CFG_NS = { + .base = MUSCA_S1_MHU1_NS_BASE}; +struct arm_mhu_sse_200_dev_t ARM_MHU1_DEV_NS = {&(ARM_MHU1_DEV_CFG_NS)}; +#endif + +/* SSE-200 Cache driver structure */ +#ifdef SSE_200_CACHE_S +static const struct arm_cache_dev_cfg_t SSE_200_CACHE_CFG_S = { + .base = MUSCA_S1_CPU_ELEMENT_S_BASE}; +struct arm_cache_dev_t SSE_200_CACHE_DEV_S = {&(SSE_200_CACHE_CFG_S)}; +#endif + +#ifdef SSE_200_CACHE_NS +static const struct arm_cache_dev_cfg_t SSE_200_CACHE_CFG_NS = { + .base = MUSCA_S1_CPU_ELEMENT_NS_BASE}; +struct arm_cache_dev_t SSE_200_CACHE_DEV_NS = {&(SSE_200_CACHE_CFG_NS)}; +#endif + +/* I2C IP6510 driver structures */ +#ifdef I2C0_IP6510_S +static const struct i2c_ip6510_dev_cfg_t I2C0_IP6510_DEV_CFG_S = { + .base = MUSCA_S1_I2C0_S_BASE, + .default_mode = I2C_IP6510_MASTER_MODE, + .default_bus_speed = I2C_IP6510_SPEED_100KHZ}; +static struct i2c_ip6510_dev_data_t I2C0_IP6510_DEV_DATA_S = { + .state = 0, + .mode = 0, + .bus_speed = 0}; +struct i2c_ip6510_dev_t I2C0_IP6510_DEV_S = { + &(I2C0_IP6510_DEV_CFG_S), + &(I2C0_IP6510_DEV_DATA_S)}; +#endif + +#ifdef I2C0_IP6510_NS +static const struct i2c_ip6510_dev_cfg_t I2C0_IP6510_DEV_CFG_NS = { + .base = MUSCA_S1_I2C0_NS_BASE, + .default_mode = I2C_IP6510_MASTER_MODE, + .default_bus_speed = I2C_IP6510_SPEED_100KHZ}; +static struct i2c_ip6510_dev_data_t I2C0_IP6510_DEV_DATA_NS = { + .state = 0, + .mode = 0, + .bus_speed = 0}; +struct i2c_ip6510_dev_t I2C0_IP6510_DEV_NS = { + &(I2C0_IP6510_DEV_CFG_NS), + &(I2C0_IP6510_DEV_DATA_NS)}; +#endif + +#ifdef I2C1_IP6510_S +static const struct i2c_ip6510_dev_cfg_t I2C1_IP6510_DEV_CFG_S = { + .base = MUSCA_S1_I2C1_S_BASE, + .default_mode = I2C_IP6510_MASTER_MODE, + .default_bus_speed = I2C_IP6510_SPEED_100KHZ}; +static struct i2c_ip6510_dev_data_t I2C1_IP6510_DEV_DATA_S = { + .state = 0, + .mode = 0, + .bus_speed = 0}; +struct i2c_ip6510_dev_t I2C1_IP6510_DEV_S = { + &(I2C1_IP6510_DEV_CFG_S), + &(I2C1_IP6510_DEV_DATA_S)}; +#endif + +#ifdef I2C1_IP6510_NS +static const struct i2c_ip6510_dev_cfg_t I2C1_IP6510_DEV_CFG_NS = { + .base = MUSCA_S1_I2C1_NS_BASE, + .default_mode = I2C_IP6510_MASTER_MODE, + .default_bus_speed = I2C_IP6510_SPEED_100KHZ}; +static struct i2c_ip6510_dev_data_t I2C1_IP6510_DEV_DATA_NS = { + .state = 0, + .mode = 0, + .bus_speed = 0}; +struct i2c_ip6510_dev_t I2C1_IP6510_DEV_NS = { + &(I2C1_IP6510_DEV_CFG_NS), + &(I2C1_IP6510_DEV_DATA_NS)}; +#endif + +/* CMSDK Timers driver structures */ +#ifdef CMSDK_TIMER0_S +static const struct timer_cmsdk_dev_cfg_t CMSDK_TIMER0_DEV_CFG_S = { + .base = MUSCA_S1_CMSDK_TIMER0_S_BASE}; +static struct timer_cmsdk_dev_data_t CMSDK_TIMER0_DEV_DATA_S = { + .is_initialized = 0}; +struct timer_cmsdk_dev_t CMSDK_TIMER0_DEV_S = {&(CMSDK_TIMER0_DEV_CFG_S), + &(CMSDK_TIMER0_DEV_DATA_S)}; +#endif +#ifdef CMSDK_TIMER0_NS +static const struct timer_cmsdk_dev_cfg_t CMSDK_TIMER0_DEV_CFG_NS = { + .base = MUSCA_S1_CMSDK_TIMER0_NS_BASE}; +static struct timer_cmsdk_dev_data_t CMSDK_TIMER0_DEV_DATA_NS = { + .is_initialized = 0}; +struct timer_cmsdk_dev_t CMSDK_TIMER0_DEV_NS = {&(CMSDK_TIMER0_DEV_CFG_NS), + &(CMSDK_TIMER0_DEV_DATA_NS)}; +#endif + +#ifdef CMSDK_TIMER1_S +static const struct timer_cmsdk_dev_cfg_t CMSDK_TIMER1_DEV_CFG_S = { + .base = MUSCA_S1_CMSDK_TIMER1_S_BASE}; +static struct timer_cmsdk_dev_data_t CMSDK_TIMER1_DEV_DATA_S = { + .is_initialized = 0}; +struct timer_cmsdk_dev_t CMSDK_TIMER1_DEV_S = {&(CMSDK_TIMER1_DEV_CFG_S), + &(CMSDK_TIMER1_DEV_DATA_S)}; +#endif +#ifdef CMSDK_TIMER1_NS +static const struct timer_cmsdk_dev_cfg_t CMSDK_TIMER1_DEV_CFG_NS = { + .base = MUSCA_S1_CMSDK_TIMER1_NS_BASE}; +static struct timer_cmsdk_dev_data_t CMSDK_TIMER1_DEV_DATA_NS = { + .is_initialized = 0}; +struct timer_cmsdk_dev_t CMSDK_TIMER1_DEV_NS = {&(CMSDK_TIMER1_DEV_CFG_NS), + &(CMSDK_TIMER1_DEV_DATA_NS)}; +#endif + +/* CMSDK Dualtimer driver structures */ +#ifdef CMSDK_DUALTIMER_S +static const struct dualtimer_cmsdk_dev_cfg_t CMSDK_DUALTIMER_DEV_CFG_S = { + .base = MUSCA_S1_CMSDK_DUALTIMER_S_BASE}; +static struct dualtimer_cmsdk_dev_data_t CMSDK_DUALTIMER_DEV_DATA_S = { + .is_initialized = 0}; + +struct dualtimer_cmsdk_dev_t CMSDK_DUALTIMER_DEV_S = { + &(CMSDK_DUALTIMER_DEV_CFG_S), + &(CMSDK_DUALTIMER_DEV_DATA_S)}; +#endif + +#ifdef CMSDK_DUALTIMER_NS +static const struct dualtimer_cmsdk_dev_cfg_t CMSDK_DUALTIMER_DEV_CFG_NS = { + .base = MUSCA_S1_CMSDK_DUALTIMER_NS_BASE}; +static struct dualtimer_cmsdk_dev_data_t CMSDK_DUALTIMER_DEV_DATA_NS = { + .is_initialized = 0}; + +struct dualtimer_cmsdk_dev_t CMSDK_DUALTIMER_DEV_NS = { + &(CMSDK_DUALTIMER_DEV_CFG_NS), + &(CMSDK_DUALTIMER_DEV_DATA_NS)}; +#endif + +/* General-Purpose Timer driver structures */ +#ifdef GP_TIMER_S +static const struct timer_gp_dev_cfg_t GP_TIMER_DEV_CFG_S = { + .base = MUSCA_S1_TIMER_S_BASE}; +static struct timer_gp_dev_data_t GP_TIMER_DEV_DATA_S = { + .is_initialized = false, + .alarm0_init = 0, + .alarm1_init = 0}; +struct timer_gp_dev_t GP_TIMER_DEV_S = { + &(GP_TIMER_DEV_CFG_S), + &(GP_TIMER_DEV_DATA_S)}; +#endif + +#ifdef GP_TIMER_NS +static const struct timer_gp_dev_cfg_t GP_TIMER_DEV_CFG_NS = { + .base = MUSCA_S1_TIMER_NS_BASE}; +static struct timer_gp_dev_data_t GP_TIMER_DEV_DATA_NS = { + .is_initialized = false, + .alarm0_init = 0, + .alarm1_init = 0}; +struct timer_gp_dev_t GP_TIMER_DEV_NS = { + &(GP_TIMER_DEV_CFG_NS), + &(GP_TIMER_DEV_DATA_NS)}; +#endif + +/* PL031 Real-Time Clock structure */ +#ifdef RTC_PL031_S +static const struct rtc_pl031_dev_cfg_t RTC_PL031_DEV_CFG_S = { + .base = MUSCA_S1_RTC_S_BASE}; +struct rtc_pl031_dev_t RTC_PL031_DEV_S = {&(RTC_PL031_DEV_CFG_S)}; +#endif + +#ifdef RTC_PL031_NS +static const struct rtc_pl031_dev_cfg_t RTC_PL031_DEV_CFG_NS = { + .base = MUSCA_S1_RTC_NS_BASE}; +struct rtc_pl031_dev_t RTC_PL031_DEV_NS = {&(RTC_PL031_DEV_CFG_NS)}; +#endif + +#ifdef UART0_PL011_S +static const struct uart_pl011_dev_cfg_t UART0_PL011_DEV_CFG_S = { + .base = MUSCA_S1_UART0_S_BASE, + .def_baudrate = UART_DEFAULT_BAUD_RATE, + .def_wlen = UART_PL011_WLEN_8, + .def_parity = UART_PL011_PARITY_DISABLED, + .def_stopbit = UART_PL011_STOPBIT_1}; +static struct uart_pl011_dev_data_t UART0_PL011_DEV_DATA_S = { + .state = 0, + .uart_clk = 0, + .baudrate = 0}; +struct uart_pl011_dev_t UART0_PL011_DEV_S = {&(UART0_PL011_DEV_CFG_S), + &(UART0_PL011_DEV_DATA_S)}; +#endif + +#ifdef UART0_PL011_NS +static const struct uart_pl011_dev_cfg_t UART0_PL011_DEV_CFG_NS = { + .base = MUSCA_S1_UART0_NS_BASE, + .def_baudrate = UART_DEFAULT_BAUD_RATE, + .def_wlen = UART_PL011_WLEN_8, + .def_parity = UART_PL011_PARITY_DISABLED, + .def_stopbit = UART_PL011_STOPBIT_1}; +static struct uart_pl011_dev_data_t UART0_PL011_DEV_DATA_NS = { + .state = 0, + .uart_clk = 0, + .baudrate = 0}; +struct uart_pl011_dev_t UART0_PL011_DEV_NS = {&(UART0_PL011_DEV_CFG_NS), + &(UART0_PL011_DEV_DATA_NS)}; +#endif + +#ifdef UART1_PL011_S +static const struct uart_pl011_dev_cfg_t UART1_PL011_DEV_CFG_S = { + .base = MUSCA_S1_UART1_S_BASE, + .def_baudrate = UART_DEFAULT_BAUD_RATE, + .def_wlen = UART_PL011_WLEN_8, + .def_parity = UART_PL011_PARITY_DISABLED, + .def_stopbit = UART_PL011_STOPBIT_1}; +static struct uart_pl011_dev_data_t UART1_PL011_DEV_DATA_S = { + .state = 0, + .uart_clk = 0, + .baudrate = 0}; +struct uart_pl011_dev_t UART1_PL011_DEV_S = {&(UART1_PL011_DEV_CFG_S), + &(UART1_PL011_DEV_DATA_S)}; +#endif + +#ifdef UART1_PL011_NS +static const struct uart_pl011_dev_cfg_t UART1_PL011_DEV_CFG_NS = { + .base = MUSCA_S1_UART1_NS_BASE, + .def_baudrate = UART_DEFAULT_BAUD_RATE, + .def_wlen = UART_PL011_WLEN_8, + .def_parity = UART_PL011_PARITY_DISABLED, + .def_stopbit = UART_PL011_STOPBIT_1}; +static struct uart_pl011_dev_data_t UART1_PL011_DEV_DATA_NS = { + .state = 0, + .uart_clk = 0, + .baudrate = 0}; +struct uart_pl011_dev_t UART1_PL011_DEV_NS = {&(UART1_PL011_DEV_CFG_NS), + &(UART1_PL011_DEV_DATA_NS)}; +#endif + +/* SPI IP6524 driver structures */ +#ifdef SPI0_IP6524_S +static const struct spi_ip6524_dev_cfg_t SPI0_DEV_CFG_S = { + .base = MUSCA_S1_SPI0_S_BASE}; +static struct spi_ip6524_dev_data_t SPI0_DEV_DATA_S = { + .state = 0}; +struct spi_ip6524_dev_t SPI0_DEV_S = {&(SPI0_DEV_CFG_S), + &(SPI0_DEV_DATA_S)}; +#endif + +#ifdef SPI0_IP6524_NS +static const struct spi_ip6524_dev_cfg_t SPI0_DEV_CFG_NS = { + .base = MUSCA_S1_SPI0_NS_BASE}; +static struct spi_ip6524_dev_data_t SPI0_DEV_DATA_NS = { + .state = 0}; +struct spi_ip6524_dev_t SPI0_DEV_NS = {&(SPI0_DEV_CFG_NS), + &(SPI0_DEV_DATA_NS)}; +#endif + +/* QSPI IP6514E driver structures */ +#ifdef QSPI_IP6514E_S +static const struct qspi_ip6514e_dev_cfg_t QSPI_DEV_CFG_S = { + .base = MUSCA_S1_QSPI_REG_S_BASE, + .addr_mask = (1U << 25) - 1, /* 32 MiB minus 1 byte */ +}; +struct qspi_ip6514e_dev_t QSPI_DEV_S = { + &QSPI_DEV_CFG_S +}; +#endif + +#ifdef QSPI_IP6514E_NS +static const struct qspi_ip6514e_dev_cfg_t QSPI_DEV_CFG_NS = { + .base = MUSCA_S1_QSPI_REG_NS_BASE, + .addr_mask = (1U << 25) - 1, /* 32 MiB minus 1 byte */ +}; +struct qspi_ip6514e_dev_t QSPI_DEV_NS = { + &QSPI_DEV_CFG_NS +}; +#endif + +/* ======= External peripheral configuration structure definitions ======= */ + +/* MT25QL Flash memory library structures */ +#if (defined(MT25QL_S) && defined(QSPI_IP6514E_S)) +struct mt25ql_dev_t MT25QL_DEV_S = { + .controller = &QSPI_DEV_S, + .direct_access_start_addr = MUSCA_S1_QSPI_FLASH_S_BASE, + .baud_rate_div = 4U, + .size = 0x01000000U, /* 16 MiB */ + .config_state = { 0 }, +}; +#endif + +#if (defined(MT25QL_NS) && defined(QSPI_IP6514E_NS)) +struct mt25ql_dev_t MT25QL_DEV_NS = { + .controller = &QSPI_DEV_NS, + .direct_access_start_addr = MUSCA_S1_QSPI_FLASH_NS_BASE, + .baud_rate_div = 4U, + .size = 0x01000000U, /* 16 MiB */ + .config_state = { 0 }, +}; +#endif diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/device_definition.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/device_definition.h new file mode 100644 index 00000000000..723664f1a07 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/device_definition.h @@ -0,0 +1,283 @@ +/* + * Copyright (c) 2017-2020 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * \file device_definition.h + * \brief The structure definitions in this file are exported based + * on the peripheral definitions from device_cfg.h. + * This file is meant to be used as a helper for baremetal + * applications and/or as an example of how to configure the generic + * driver structures. + */ + +#ifndef __DEVICE_DEFINITION_H__ +#define __DEVICE_DEFINITION_H__ + +#include "device_cfg.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* ======= Peripheral configuration structure declarations ======= */ + +/* ARM SCC driver structures */ +#ifdef MUSCA_S1_SCC_S +#include "musca_s1_scc_drv.h" +extern struct musca_s1_scc_dev_t MUSCA_S1_SCC_DEV_S; +#endif +#ifdef MUSCA_S1_SCC_NS +#include "musca_s1_scc_drv.h" +extern struct musca_s1_scc_dev_t MUSCA_S1_SCC_DEV_NS; +#endif + +/* ARM GPIO driver structures */ +#ifdef GPIO0_CMSDK_S +#include "gpio_cmsdk_drv.h" +extern struct gpio_cmsdk_dev_t GPIO0_CMSDK_DEV_S; +#endif +#ifdef GPIO0_CMSDK_NS +#include "gpio_cmsdk_drv.h" +extern struct gpio_cmsdk_dev_t GPIO0_CMSDK_DEV_NS; +#endif + +/* ARM MPC SIE 200 driver structures */ +#ifdef MPC_ISRAM0_S +#include "mpc_sie_drv.h" +extern struct mpc_sie_dev_t MPC_ISRAM0_DEV_S; +#endif +#ifdef MPC_ISRAM1_S +#include "mpc_sie_drv.h" +extern struct mpc_sie_dev_t MPC_ISRAM1_DEV_S; +#endif +#ifdef MPC_ISRAM2_S +#include "mpc_sie_drv.h" +extern struct mpc_sie_dev_t MPC_ISRAM2_DEV_S; +#endif +#ifdef MPC_ISRAM3_S +#include "mpc_sie_drv.h" +extern struct mpc_sie_dev_t MPC_ISRAM3_DEV_S; +#endif +#ifdef MPC_CODE_SRAM_S +#include "mpc_sie_drv.h" +extern struct mpc_sie_dev_t MPC_CODE_SRAM_DEV_S; +#endif +#ifdef MPC_CODE_SRAM_NS +#include "mpc_sie_drv.h" +extern struct mpc_sie_dev_t MPC_CODE_SRAM_DEV_NS; +#endif +#ifdef MPC_QSPI_S +#include "mpc_sie_drv.h" +extern struct mpc_sie_dev_t MPC_QSPI_DEV_S; +#endif +#ifdef MPC_QSPI_NS +#include "mpc_sie_drv.h" +extern struct mpc_sie_dev_t MPC_QSPI_DEV_NS; +#endif +#ifdef MPC_MRAM_S +#include "mpc_sie_drv.h" +extern struct mpc_sie_dev_t MPC_MRAM_DEV_S; +#endif +#ifdef MPC_MRAM_NS +#include "mpc_sie_drv.h" +extern struct mpc_sie_dev_t MPC_MRAM_DEV_NS; +#endif + +/* ARM MHU driver structures */ +#ifdef ARM_MHU0_S +#include "mhu_sse_200_drv.h" +extern struct arm_mhu_sse_200_dev_t ARM_MHU0_DEV_S; +#endif +#ifdef ARM_MHU0_NS +#include "mhu_sse_200_drv.h" +extern struct arm_mhu_sse_200_dev_t ARM_MHU0_DEV_NS; +#endif +#ifdef ARM_MHU1_S +#include "mhu_sse_200_drv.h" +extern struct arm_mhu_sse_200_dev_t ARM_MHU1_DEV_S; +#endif +#ifdef ARM_MHU1_NS +#include "mhu_sse_200_drv.h" +extern struct arm_mhu_sse_200_dev_t ARM_MHU1_DEV_NS; +#endif + +/* ARM UART PL011 driver structures */ +#ifdef UART0_PL011_S +#include "uart_pl011_drv.h" +extern struct uart_pl011_dev_t UART0_PL011_DEV_S; +#endif +#ifdef UART0_PL011_NS +#include "uart_pl011_drv.h" +extern struct uart_pl011_dev_t UART0_PL011_DEV_NS; +#endif +#ifdef UART1_PL011_S +#include "uart_pl011_drv.h" +extern struct uart_pl011_dev_t UART1_PL011_DEV_S; +#endif +#ifdef UART1_PL011_NS +#include "uart_pl011_drv.h" +extern struct uart_pl011_dev_t UART1_PL011_DEV_NS; +#endif + +/* SSE-200 Cache driver structure */ +#ifdef SSE_200_CACHE_S +#include "cache_drv.h" +extern struct arm_cache_dev_t SSE_200_CACHE_DEV_S; +#endif +#ifdef SSE_200_CACHE_NS +#include "cache_drv.h" +extern struct arm_cache_dev_t SSE_200_CACHE_DEV_NS; +#endif + +/* I2C IP6510 driver structures */ +#ifdef I2C0_IP6510_S +#include "i2c_ip6510_drv.h" +extern struct i2c_ip6510_dev_t I2C0_IP6510_DEV_S; +#endif +#ifdef I2C0_IP6510_NS +#include "i2c_ip6510_drv.h" +extern struct i2c_ip6510_dev_t I2C0_IP6510_DEV_NS; +#endif +#ifdef I2C1_IP6510_S +#include "i2c_ip6510_drv.h" +extern struct i2c_ip6510_dev_t I2C1_IP6510_DEV_S; +#endif +#ifdef I2C1_IP6510_NS +#include "i2c_ip6510_drv.h" +extern struct i2c_ip6510_dev_t I2C1_IP6510_DEV_NS; +#endif + +/* CMSDK Dualtimer driver structures */ +#ifdef CMSDK_DUALTIMER_S +#include "dualtimer_cmsdk_drv.h" +extern struct dualtimer_cmsdk_dev_t CMSDK_DUALTIMER_DEV_S; +#endif +#ifdef CMSDK_DUALTIMER_NS +#include "dualtimer_cmsdk_drv.h" +extern struct dualtimer_cmsdk_dev_t CMSDK_DUALTIMER_DEV_NS; +#endif + +/* CMSDK Timer driver structures */ +#ifdef CMSDK_TIMER0_S +#include "timer_cmsdk_drv.h" +extern struct timer_cmsdk_dev_t CMSDK_TIMER0_DEV_S; +#endif +#ifdef CMSDK_TIMER0_NS +#include "timer_cmsdk_drv.h" +extern struct timer_cmsdk_dev_t CMSDK_TIMER0_DEV_NS; +#endif + +#ifdef CMSDK_TIMER1_S +#include "timer_cmsdk_drv.h" +extern struct timer_cmsdk_dev_t CMSDK_TIMER1_DEV_S; +#endif +#ifdef CMSDK_TIMER1_NS +#include "timer_cmsdk_drv.h" +extern struct timer_cmsdk_dev_t CMSDK_TIMER1_DEV_NS; +#endif + +/* General-Purpose Timer driver structures */ +#ifdef GP_TIMER_S +#include "timer_gp_drv.h" +extern struct timer_gp_dev_t GP_TIMER_DEV_S; +#endif +#ifdef GP_TIMER_NS +#include "timer_gp_drv.h" +extern struct timer_gp_dev_t GP_TIMER_DEV_NS; +#endif + +/* RTC PL031 */ +#ifdef RTC_PL031_S +#include "rtc_pl031_drv.h" +extern struct rtc_pl031_dev_t RTC_PL031_DEV_S; +#endif + +#ifdef RTC_PL031_NS +#include "rtc_pl031_drv.h" +extern struct rtc_pl031_dev_t RTC_PL031_DEV_NS; +#endif + +/* Cadence SPI IP6524 driver structures */ +#ifdef SPI0_IP6524_S +#include "spi_ip6524_drv.h" +extern struct spi_ip6524_dev_t SPI0_DEV_S; +#endif +#ifdef SPI0_IP6524_NS +#include "spi_ip6524_drv.h" +extern struct spi_ip6524_dev_t SPI0_DEV_NS; +#endif + +/* QSPI Flash Controller driver structures */ +#ifdef QSPI_IP6514E_S +#include "qspi_ip6514e_drv.h" +extern struct qspi_ip6514e_dev_t QSPI_DEV_S; +#endif + +#ifdef QSPI_IP6514E_NS +#include "qspi_ip6514e_drv.h" +extern struct qspi_ip6514e_dev_t QSPI_DEV_NS; +#endif + +/* ARM PPC driver structures */ +#ifdef AHB_PPC0_S +#include "ppc_sse200_drv.h" +extern struct ppc_sse200_dev_t AHB_PPC0_DEV_S; +#endif + +#ifdef AHB_PPCEXP0_S +#include "ppc_sse200_drv.h" +extern struct ppc_sse200_dev_t AHB_PPCEXP0_DEV_S; +#endif + +#ifdef APB_PPC0_S +#include "ppc_sse200_drv.h" +extern struct ppc_sse200_dev_t APB_PPC0_DEV_S; +#endif + +#ifdef APB_PPC1_S +#include "ppc_sse200_drv.h" +extern struct ppc_sse200_dev_t APB_PPC1_DEV_S; +#endif + +#ifdef APB_PPCEXP0_S +#include "ppc_sse200_drv.h" +extern struct ppc_sse200_dev_t APB_PPCEXP0_DEV_S; +#endif + +#ifdef APB_PPCEXP1_S +#include "ppc_sse200_drv.h" +extern struct ppc_sse200_dev_t APB_PPCEXP1_DEV_S; +#endif + +/* ======= External peripheral configuration structure declarations ======= */ + +/* MT25QL Flash memory library structures */ +#if (defined(MT25QL_S) && defined(QSPI_IP6514E_S)) +#include "mt25ql_flash_lib.h" +extern struct mt25ql_dev_t MT25QL_DEV_S; +#endif +#if (defined(MT25QL_NS) && defined(QSPI_IP6514E_NS)) +#include "mt25ql_flash_lib.h" +extern struct mt25ql_dev_t MT25QL_DEV_NS; +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* __DEVICE_DEFINITION_H__ */ diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/cache_drv.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/cache_drv.c new file mode 100644 index 00000000000..638fc8f35b7 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/cache_drv.c @@ -0,0 +1,340 @@ +/* + * Copyright (c) 2017-2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * \file cache_drv.c + * \brief Driver for L1 instruction cache based on SSE-200 version r1p0 + */ + +#include "cache_drv.h" + +/** + * \brief L1 cache register map structure + */ +struct _arm_cache_reg_map_t { + volatile uint32_t cacheichwparams; + /*!< Offset: 0x000 (R/ ) HW Parameters Register */ + volatile uint32_t cacheicctrl; + /*!< Offset: 0x004 (R/W) Control Register */ + volatile uint32_t reserved_0[62]; + /*!< Offset: 0x00C-0x0FC Reserved */ + volatile uint32_t cacheicirqstat; + /*!< Offset: 0x100 (R/ ) Interrupt Request Status Register */ + volatile uint32_t cacheicirqsclr; + /*!< Offset: 0x104 ( /W) Interrupt Status Clear Register */ + volatile uint32_t cacheicirqen; + /*!< Offset: 0x108 (R/W) Interrupt Enable Register */ + volatile uint32_t cacheicdbgfillerr; + /*!< Offset: 0x10C (R/ ) Fill Error Address Register */ + volatile uint32_t reserved_1[124]; + /*!< Offset: 0x110-0x2FC Reserved */ + volatile uint32_t cacheicsh; + /*!< Offset: 0x300 (R/ ) Cache Statistic Hit Register */ + volatile uint32_t cacheicsm; + /*!< Offset: 0x304 (R/ ) Cache Statistic Miss Register */ + volatile uint32_t cacheicsuc; + /*!< Offset: 0x308 (R/ ) Cache Statistic Uncached Register */ + volatile uint32_t reserved_2[331]; + /*!< Offset: 0x30C-0xFCC Reserved */ + volatile uint32_t cachepidr4; + /*!< Offset: 0xFD0 (R/ ) Product ID Register 4 */ + volatile uint32_t cachepidr5; + /*!< Offset: 0xFD4 (R/ ) Product ID Register 5 */ + volatile uint32_t cachepidr6; + /*!< Offset: 0xFD8 (R/ ) Product ID Register 6 */ + volatile uint32_t cachepidr7; + /*!< Offset: 0xFDC (R/ ) Product ID Register 7 */ + volatile uint32_t cachepidr0; + /*!< Offset: 0xFE0 (R/ ) Product ID Register 0 */ + volatile uint32_t cachepidr1; + /*!< Offset: 0xFE4 (R/ ) Product ID Register 1 */ + volatile uint32_t cachepidr2; + /*!< Offset: 0xFE8 (R/ ) Product ID Register 2 */ + volatile uint32_t cachepidr3; + /*!< Offset: 0xFEC (R/ ) Product ID Register 3 */ + volatile uint32_t cachecidr0; + /*!< Offset: 0xFF0 (R/ ) Component ID Register 0 */ + volatile uint32_t cachecidr1; + /*!< Offset: 0xFF4 (R/ ) Component ID Register 1 */ + volatile uint32_t cachecidr2; + /*!< Offset: 0xFF8 (R/ ) Component ID Register 2 */ + volatile uint32_t cachecidr3; + /*!< Offset: 0xFFC (R/ ) Component ID Register 3 */ +}; + +#define ARM_CACHEICHWPARAMS_CSIZE_MASK (0xFu<cfg->base; + + enum arm_cache_size_t val = (enum arm_cache_size_t) + (p_cache->cacheichwparams & ARM_CACHEICHWPARAMS_CSIZE_MASK); + /** + * 9: 512 byte + * 10: 1 KB + * 11: 2 KB + * 12: 4 KB + * 13: 8 KB + * 14: 16 KB + * Other values are reserved, returning error + */ + if(val < arm_cache_size_512B || val > arm_cache_size_16KB) { + return arm_cache_size_err; + } else { + return val; + } +} + +bool arm_cache_is_stat_func_available(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + return (bool)(p_cache->cacheichwparams & ARM_CACHEICHWPARAMS_STATS_MASK); +} + +bool arm_cache_is_invalidate_cache_line_enabled(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + return (bool)(p_cache->cacheichwparams & ARM_CACHEICHWPARAMS_INVMAT_MASK); +} + +void arm_cache_enable(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + p_cache->cacheicctrl |= ARM_CACHEICCTRL_CACHEEN_MASK; + + return; +} + +void arm_cache_enable_blocking(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + p_cache->cacheicctrl |= ARM_CACHEICCTRL_CACHEEN_MASK; + + while(!(arm_cache_get_raw_intr_status(dev) & arm_cache_cec_intr_mask)); + + arm_cache_clear_intr(dev, arm_cache_cec_intr_mask); + + return; +} + +void arm_cache_disable(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + p_cache->cacheicctrl &= ~ARM_CACHEICCTRL_CACHEEN_MASK; + + return; +} + +void arm_cache_disable_blocking(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + p_cache->cacheicctrl &= ~ARM_CACHEICCTRL_CACHEEN_MASK; + + while(!(arm_cache_get_raw_intr_status(dev) & arm_cache_cdc_intr_mask)); + + arm_cache_clear_intr(dev, arm_cache_cdc_intr_mask); + + return; +} + +bool arm_cache_is_enabled(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + return (bool)(p_cache->cacheicctrl & ARM_CACHEICCTRL_CACHEEN_MASK); +} + +void arm_cache_full_invalidate(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + p_cache->cacheicctrl |= ARM_CACHEICCTRL_FINV_MASK; + + return; +} + +void arm_cache_full_invalidate_blocking(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + p_cache->cacheicctrl |= ARM_CACHEICCTRL_FINV_MASK; + + while(!(arm_cache_get_raw_intr_status(dev) & arm_cache_ic_intr_mask)); + + arm_cache_clear_intr(dev, arm_cache_ic_intr_mask); + + return; +} + +void arm_cache_statistic_enable(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + p_cache->cacheicctrl |= ARM_CACHEICCTRL_STATEN_MASK; + + return; +} + +void arm_cache_statistic_disable(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + p_cache->cacheicctrl &= ~ARM_CACHEICCTRL_STATEN_MASK; + + return; +} + +void arm_cache_clear_statistic_value(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + p_cache->cacheicctrl |= ARM_CACHEICCTRL_STATC_MASK; + + return; +} + +void arm_cache_handler_alloc_enable(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + p_cache->cacheicctrl |= ARM_CACHEICCTRL_HALLOC_MASK; + + return; +} + +void arm_cache_handler_alloc_disable(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + p_cache->cacheicctrl &= ~ARM_CACHEICCTRL_HALLOC_MASK; + + return; +} + +void arm_cache_enable_intr(struct arm_cache_dev_t* dev, + enum arm_cache_intr_t mask) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + p_cache->cacheicirqen |= (uint32_t)(mask); + + return; +} + +void arm_cache_disable_intr(struct arm_cache_dev_t* dev, + enum arm_cache_intr_t mask) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + p_cache->cacheicirqen &= ~(uint32_t)(mask); + + return; +} +void arm_cache_clear_intr(struct arm_cache_dev_t* dev, + enum arm_cache_intr_t mask) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + p_cache->cacheicirqsclr = (uint32_t)mask; + + return; +} + +enum arm_cache_intr_t arm_cache_get_masked_intr_status( + struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + return (enum arm_cache_intr_t) + (p_cache->cacheicirqstat & p_cache->cacheicirqen); +} + +enum arm_cache_intr_t arm_cache_get_raw_intr_status( + struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + return (enum arm_cache_intr_t)(p_cache->cacheicirqstat); +} + +uint32_t arm_cache_get_debug_fill_address(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + return p_cache->cacheicdbgfillerr; +} + +uint32_t arm_cache_get_hit_count(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + return p_cache->cacheicsh; +} + +uint32_t arm_cache_get_miss_count(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + return p_cache->cacheicsm; +} + +uint32_t arm_cache_get_uncached_count(struct arm_cache_dev_t* dev) +{ + struct _arm_cache_reg_map_t* p_cache = + (struct _arm_cache_reg_map_t*)dev->cfg->base; + + return p_cache->cacheicsuc; +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/cache_drv.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/cache_drv.h new file mode 100644 index 00000000000..f213cc22a7d --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/cache_drv.h @@ -0,0 +1,381 @@ +/* + * Copyright (c) 2017-2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * \file cache_drv.h + * \brief Driver for L1 instruction cache based on SSE-200 version r1p0 + */ + +#ifndef __ARM_CACHE_DRV_H__ +#define __ARM_CACHE_DRV_H__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * \brief L1 cache configuration structure + */ +struct arm_cache_dev_cfg_t { + const uint32_t base; /*!< L1 cache base address */ +}; + +/** + * \brief L1 cache device structure + */ +struct arm_cache_dev_t { + const struct arm_cache_dev_cfg_t* const cfg; /*!< L1 cache configuration */ +}; + +#define ARM_CACHEICHWPARAMS_CSIZE_OFF 0x0u + /*!< Instruction cache size bit field offset */ +#define ARM_CACHEICHWPARAMS_STATS_OFF 0x4u + /*!< Statistic functionality bit field offset */ +#define ARM_CACHEICHWPARAMS_DMA_OFF 0x5u + /*!< DMA engine bit field offset */ +#define ARM_CACHEICHWPARAMS_INVMAT_OFF 0x6u + /*!< Bit field offset to indicates whether + * invalidate cache line on write match is + * enabled */ +#define ARM_CACHEICHWPARAMS_COFFSIZE_OFF 0xCu + /*!< Cacheable Block Size bit field offset */ +#define ARM_CACHEICHWPARAMS_COFFSET_OFF 0x10u + /*!< Cacheable Offset Addr bit field offset */ + +#define ARM_CACHEICCTRL_CACHEEN_OFF 0x0u + /*!< Cache enable bit field offset */ +#define ARM_CACHEICCTRL_FINV_OFF 0x2u + /*!< Full invalidate bit field offset */ +#define ARM_CACHEICCTRL_STATEN_OFF 0x3u + /*!< Enable Statistic bit field offset */ +#define ARM_CACHEICCTRL_STATC_OFF 0x4u + /*!< Clear Statistic bit field offset */ +#define ARM_CACHEICCTRL_HALLOC_OFF 0x5u + /*!< Enable handler alloc bit field offset */ + +#define ARM_CACHE_INTR_IC_OFF 0x0u /*!< Invalidate Complete IRQ offset */ +#define ARM_CACHE_INTR_CDC_OFF 0x1u /*!< Cache Disable Complete IRQ offset */ +#define ARM_CACHE_INTR_CEC_OFF 0x2u /*!< Cache Enable Complete IRQ offset */ +#define ARM_CACHE_INTR_CFE_OFF 0x3u /*!< Cache Fill Error IRQ offset */ +#define ARM_CACHE_INTR_SV_OFF 0x4u /*!< Security violation IRQ offset */ +#define ARM_CACHE_INTR_SS_OFF 0x5u /*!< Statistics Saturated IRQ offset */ + +/** + * \brief L1 Cache Interrupt data structure + */ +enum arm_cache_intr_t { + arm_cache_ic_intr_mask = (0x1u< +#include +#include "gpio_cmsdk_drv.h" + +/* GPIO register map structure */ +struct gpio_cmsdk_reg_map_t { + volatile uint32_t data; /* Offset: 0x000 (R/W) Data register */ + volatile uint32_t dataout; /* Offset: 0x004 (R/W) Data output + * latch register */ + volatile uint32_t reserved0[2]; + volatile uint32_t outenableset; /* Offset: 0x010 (R/W) Output enable + * set register */ + volatile uint32_t outenableclr; /* Offset: 0x014 (R/W) Output enable + * clear register */ + volatile uint32_t altfuncset; /* Offset: 0x018 (R/W) Alternate function + * set register */ + volatile uint32_t altfuncclr; /* Offset: 0x01C (R/W) Alternate function + * clear register */ + volatile uint32_t intenset; /* Offset: 0x020 (R/W) Interrupt enable + * set register */ + volatile uint32_t intenclr; /* Offset: 0x024 (R/W) Interrupt enable + * clear register */ + volatile uint32_t inttypeset; /* Offset: 0x028 (R/W) Interrupt type + * set register */ + volatile uint32_t inttypeclr; /* Offset: 0x02C (R/W) Interrupt type + * clear register */ + volatile uint32_t intpolset; /* Offset: 0x030 (R/W) Interrupt polarity + * set register */ + volatile uint32_t intpolclr; /* Offset: 0x034 (R/W) Interrupt polarity + * clear register */ + union { + volatile uint32_t intstatus; /* Offset: 0x038 (R/ ) Interrupt status + * register */ + volatile uint32_t intclear; /* Offset: 0x038 ( /W) Interrupt clear + * register */ + }intreg; + volatile uint32_t reserved1[997]; + volatile uint32_t pid4; /* Peripheral ID Register 4 */ + volatile uint32_t pid0; /* Peripheral ID Register 0 */ + volatile uint32_t pid1; /* Peripheral ID Register 1 */ + volatile uint32_t pid2; /* Peripheral ID Register 2 */ + volatile uint32_t pid3; /* Peripheral ID Register 3 */ + volatile uint32_t cid0; /* Component ID Register 0 */ + volatile uint32_t cid1; /* Component ID Register 1 */ + volatile uint32_t cid2; /* Component ID Register 2 */ + volatile uint32_t cid4; /* Component ID Register 3 */ +}; + +void gpio_cmsdk_init(struct gpio_cmsdk_dev_t* dev) +{ + /* Nothing to init on the GPIO device */ +} + +/** + * \brief Configures port. + * + * \param[in] dev GPIO device to initalize \ref gpio_cmsdk_dev_t + * \param[in] pin_mask Pin mask for port access + * \param[in] direction Input or output \ref gpio_cmsdk_direction_t + * \param[in] altfunc_flags Alternate function \ref gpio_cmsdk_altfunc_t + * + */ +static void set_port_config(struct gpio_cmsdk_dev_t* dev, uint32_t pin_mask, + enum gpio_cmsdk_direction_t direction, + enum gpio_cmsdk_altfunc_t altfunc_flags) +{ + struct gpio_cmsdk_reg_map_t* p_gpio_port = + (struct gpio_cmsdk_reg_map_t*)dev->cfg->base; + + if(direction == GPIO_CMSDK_INPUT) { + p_gpio_port->outenableclr = pin_mask; + } else { + p_gpio_port->outenableset = pin_mask; + } + + if (altfunc_flags == GPIO_CMSDK_MAIN_FUNC) { + p_gpio_port->altfuncclr = pin_mask; + } else { + p_gpio_port->altfuncset = pin_mask; + } + + return; +} + +enum gpio_cmsdk_error_t +gpio_cmsdk_pin_config(struct gpio_cmsdk_dev_t* dev, uint32_t pin_num, + enum gpio_cmsdk_direction_t direction, + enum gpio_cmsdk_altfunc_t altfunc_flags) +{ + uint32_t pin_mask = (1UL << pin_num); + + if(pin_num >= GPIO_CMSDK_MAX_PIN_NUM) { + return GPIO_CMSDK_ERR_INVALID_ARG; + } + + set_port_config(dev, pin_mask, direction, altfunc_flags); + + return GPIO_CMSDK_ERR_NONE; +} + +enum gpio_cmsdk_error_t +gpio_cmsdk_port_config(struct gpio_cmsdk_dev_t* dev, uint32_t pin_mask, + enum gpio_cmsdk_direction_t direction, + enum gpio_cmsdk_altfunc_t altfunc_flags) +{ + if(pin_mask > GPIO_CMSDK_MAX_PORT_MASK) { + return GPIO_CMSDK_ERR_INVALID_ARG; + } + + set_port_config(dev, pin_mask, direction, altfunc_flags); + + return GPIO_CMSDK_ERR_NONE; +} + +void gpio_cmsdk_config_irq(struct gpio_cmsdk_dev_t* dev, uint32_t pin_mask, + enum gpio_cmsdk_irq_type_t irq_type, + enum gpio_cmsdk_irq_polarity_t irq_pol) +{ + struct gpio_cmsdk_reg_map_t* p_gpio_port = + (struct gpio_cmsdk_reg_map_t*)dev->cfg->base; + + /* Interrupt type: EDGE = 1 - LEVEL = 0 */ + if(irq_type == GPIO_CMSDK_IRQ_EDGE) { + p_gpio_port->inttypeset = pin_mask; + } else if(irq_type == GPIO_CMSDK_IRQ_LEVEL) { + p_gpio_port->inttypeclr = pin_mask; + } + + /* Interrupt polarity */ + if(irq_pol == GPIO_CMSDK_IRQ_LOW_OR_FALLING_EDGE) { + p_gpio_port->intpolclr = pin_mask; + } else if(irq_pol == GPIO_CMSDK_IRQ_HIGH_OR_RISING_EDGE) { + p_gpio_port->intpolset = pin_mask; + } +} + +enum gpio_cmsdk_error_t gpio_cmsdk_pin_write(struct gpio_cmsdk_dev_t* dev, + uint32_t pin_num, + uint32_t value) +{ + struct gpio_cmsdk_reg_map_t* p_gpio_port = + (struct gpio_cmsdk_reg_map_t*)dev->cfg->base; + + /* GPIO data output register is a read-modify-write register, + * so before writing a value on a GPIO pin it is required to disable + * the interrupts to prevent concurrency problems. + */ + if(pin_num >= GPIO_CMSDK_MAX_PIN_NUM) { + return GPIO_CMSDK_ERR_INVALID_ARG; + } + if(value) { + /* Sets the pin */ + p_gpio_port->dataout |= (1UL << pin_num); + } else { + /* Clears the pin */ + p_gpio_port->dataout &= ~(1UL << pin_num); + } + + return GPIO_CMSDK_ERR_NONE; +} + +enum gpio_cmsdk_error_t gpio_cmsdk_port_write(struct gpio_cmsdk_dev_t* dev, + uint32_t pin_mask, + uint32_t value) +{ + struct gpio_cmsdk_reg_map_t* p_gpio_port = + (struct gpio_cmsdk_reg_map_t*)dev->cfg->base; + + /* GPIO data output register is a read-modify-write register, + * so before writing a value on a GPIO pin it is required to disable + * the interrupts to prevent concurrency problems. + */ + if(pin_mask > GPIO_CMSDK_MAX_PORT_MASK) { + return GPIO_CMSDK_ERR_INVALID_ARG; + } + + /* Clear all bits defined in the mask, + * and set selected bits from value parameter. + */ + p_gpio_port->dataout = + ((~pin_mask & p_gpio_port->dataout) | (pin_mask & value)); + + return GPIO_CMSDK_ERR_NONE; +} + +enum gpio_cmsdk_error_t +gpio_cmsdk_pin_read(struct gpio_cmsdk_dev_t* dev, + uint32_t pin_num, + uint32_t *data) +{ + uint32_t value; + struct gpio_cmsdk_reg_map_t* p_gpio_port = + (struct gpio_cmsdk_reg_map_t*)dev->cfg->base; + + if(pin_num >= GPIO_CMSDK_MAX_PIN_NUM) { + return GPIO_CMSDK_ERR_INVALID_ARG; + } + + value = p_gpio_port->data; + + *data = (value >> pin_num) & 1UL; + + return GPIO_CMSDK_ERR_NONE; +} + +enum gpio_cmsdk_error_t +gpio_cmsdk_port_read(struct gpio_cmsdk_dev_t* dev, uint32_t pin_mask, + uint32_t *data) +{ + struct gpio_cmsdk_reg_map_t* p_gpio_port = + (struct gpio_cmsdk_reg_map_t*)dev->cfg->base; + + if(pin_mask > GPIO_CMSDK_MAX_PORT_MASK) { + return GPIO_CMSDK_ERR_INVALID_ARG; + } + + *data = p_gpio_port->data & pin_mask; + + return GPIO_CMSDK_ERR_NONE; +} + +enum gpio_cmsdk_error_t +gpio_cmsdk_set_pin_irq_cfg(struct gpio_cmsdk_dev_t* dev, uint32_t pin_num, + enum gpio_cmsdk_irq_status_t status) +{ + struct gpio_cmsdk_reg_map_t* p_gpio_port = + (struct gpio_cmsdk_reg_map_t*)dev->cfg->base; + + if(pin_num >= GPIO_CMSDK_MAX_PIN_NUM) { + return GPIO_CMSDK_ERR_INVALID_ARG; + } + + if(status == GPIO_CMSDK_IRQ_ENABLE) { + p_gpio_port->intenset = (1UL << pin_num); + } else { + p_gpio_port->intenclr = (1UL << pin_num); + } + + return GPIO_CMSDK_ERR_NONE; +} + +enum gpio_cmsdk_error_t +gpio_cmsdk_set_port_irq_cfg(struct gpio_cmsdk_dev_t* dev, uint32_t pin_mask, + enum gpio_cmsdk_irq_status_t status) +{ + struct gpio_cmsdk_reg_map_t* p_gpio_port = + (struct gpio_cmsdk_reg_map_t*)dev->cfg->base; + + if(pin_mask > GPIO_CMSDK_MAX_PORT_MASK) { + return GPIO_CMSDK_ERR_INVALID_ARG; + } + + if(status == GPIO_CMSDK_IRQ_ENABLE) { + p_gpio_port->intenset = pin_mask; + } else { + p_gpio_port->intenclr = pin_mask; + } + + return GPIO_CMSDK_ERR_NONE; +} + +enum gpio_cmsdk_error_t +gpio_cmsdk_get_pin_irq_status(struct gpio_cmsdk_dev_t* dev, + uint32_t pin_num, uint32_t* status) +{ + struct gpio_cmsdk_reg_map_t* p_gpio_port = + (struct gpio_cmsdk_reg_map_t*)dev->cfg->base; + + if(pin_num >= GPIO_CMSDK_MAX_PIN_NUM) { + return GPIO_CMSDK_ERR_INVALID_ARG; + } + + *status = ((p_gpio_port->intreg.intstatus >> pin_num) & 1UL); + + return GPIO_CMSDK_ERR_NONE; +} + +enum gpio_cmsdk_error_t +gpio_cmsdk_get_port_irq_status(struct gpio_cmsdk_dev_t* dev, + uint32_t pin_mask, uint32_t* status) +{ + struct gpio_cmsdk_reg_map_t* p_gpio_port = + (struct gpio_cmsdk_reg_map_t*)dev->cfg->base; + + if(pin_mask > GPIO_CMSDK_MAX_PORT_MASK) { + return GPIO_CMSDK_ERR_INVALID_ARG; + } + + *status = (p_gpio_port->intreg.intstatus & pin_mask); + + return GPIO_CMSDK_ERR_NONE; +} + + +enum gpio_cmsdk_error_t gpio_cmsdk_clear_irq(struct gpio_cmsdk_dev_t* dev, + uint8_t pin_num) +{ + struct gpio_cmsdk_reg_map_t* p_gpio_port = + (struct gpio_cmsdk_reg_map_t*)dev->cfg->base; + + if(pin_num >= GPIO_CMSDK_MAX_PIN_NUM) { + return GPIO_CMSDK_ERR_INVALID_ARG; + } + + p_gpio_port->intreg.intclear = (1UL << pin_num); + + return GPIO_CMSDK_ERR_NONE; +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/gpio_cmsdk_drv.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/gpio_cmsdk_drv.h new file mode 100644 index 00000000000..7374ed9d95c --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/gpio_cmsdk_drv.h @@ -0,0 +1,281 @@ +/* + * Copyright (c) 2016-2018 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * \file gpio_cmsdk_drv.h + * \brief Generic driver for ARM GPIO. + */ + +#ifndef __GPIO_CMSDK_DRV_H__ +#define __GPIO_CMSDK_DRV_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define GPIO_CMSDK_MAX_PIN_NUM 16U +#define GPIO_CMSDK_MAX_PORT_MASK ((1U << GPIO_CMSDK_MAX_PIN_NUM) - 1U) + +/* GPIO enumeration types */ +enum gpio_cmsdk_direction_t { + GPIO_CMSDK_INPUT = 0, /*!< GPIO is input */ + GPIO_CMSDK_OUTPUT /*!< GPIO is output */ +}; + +enum gpio_cmsdk_altfunc_t { + GPIO_CMSDK_MAIN_FUNC = 0, /*!< Alternate function is not enabled */ + GPIO_CMSDK_ALT_FUNC /*!< Alternate function is enabled */ +}; + +enum gpio_cmsdk_irq_status_t { + GPIO_CMSDK_IRQ_DISABLE = 0, /*!< Disable interruptions */ + GPIO_CMSDK_IRQ_ENABLE /*!< Enable interruptions */ +}; + +enum gpio_cmsdk_irq_type_t { + GPIO_CMSDK_IRQ_LEVEL = 0, /*!< Level Interrupt */ + GPIO_CMSDK_IRQ_EDGE /*!< Edge Interrupt */ +}; + +enum gpio_cmsdk_irq_polarity_t { + GPIO_CMSDK_IRQ_LOW_OR_FALLING_EDGE = 0, /*!< Interrupt active low or + falling edge */ + GPIO_CMSDK_IRQ_HIGH_OR_RISING_EDGE /*!< Interrupt active high or + rising edge */ +}; + +enum gpio_cmsdk_error_t { + GPIO_CMSDK_ERR_NONE = 0, /*!< No error */ + GPIO_CMSDK_ERR_INVALID_ARG, /*!< Error invalid input argument */ + GPIO_CMSDK_ALTFUNC_EERROR, /*!< Alternate function returned error */ +}; + +/* CMSDK GPIO device configuration structure */ +struct gpio_cmsdk_dev_cfg_t { + const uint32_t base; /*!< GPIO base address */ +}; + +/* CMSDK GPIO device structure */ +struct gpio_cmsdk_dev_t { + const struct gpio_cmsdk_dev_cfg_t* const cfg; /*!< GPIO configuration */ +}; + +/** + * \brief Initializes GPIO port. + * + * \param[in] dev GPIO device to initalize \ref gpio_cmsdk_dev_t + * + * \note This function doesn't check if dev is NULL. + */ +void gpio_cmsdk_init(struct gpio_cmsdk_dev_t* dev); + +/** + * \brief Configures pin. + * + * \param[in] dev GPIO device to configure \ref gpio_cmsdk_dev_t + * \param[in] pin_num Pin number for pin access + * \param[in] direction Input or output \ref gpio_cmsdk_direction_t + * \param[in] altfunc_flags Alternate function \ref gpio_cmsdk_altfunc_t + * + * \return Returns error code as specified in \ref gpio_cmsdk_flags_t + * + * \note This function doesn't check if dev is NULL. + */ +enum gpio_cmsdk_error_t +gpio_cmsdk_pin_config(struct gpio_cmsdk_dev_t* dev, uint32_t pin_num, + enum gpio_cmsdk_direction_t direction, + enum gpio_cmsdk_altfunc_t altfunc_flags); + +/** + * \brief Configures port. + * + * \param[in] dev GPIO device to configure \ref gpio_cmsdk_dev_t + * \param[in] pin_mask Bitmask of the selected pins + * \param[in] direction Input or output \ref gpio_cmsdk_direction_t + * \param[in] altfunc_flags Alternate function \ref gpio_cmsdk_altfunc_t + * + * \return Returns error code as specified in \ref gpio_cmsdk_error_t + * + * \note This function doesn't check if dev is NULL. + */ +enum gpio_cmsdk_error_t +gpio_cmsdk_port_config(struct gpio_cmsdk_dev_t* dev, uint32_t pin_mask, + enum gpio_cmsdk_direction_t direction, + enum gpio_cmsdk_altfunc_t altfunc_flags); + + +/** + * \brief Configures interrupt type + * + * \param[in] dev GPIO device to initalize \ref gpio_cmsdk_dev_t + * \param[in] pin_mask Bitmask of the selected pins + * \param[in] irq_type Interrupt type \ref gpio_cmsdk_irq_type_t + * \param[in] irq_pol Interrupt polarity \ref gpio_cmsdk_irq_polarity_t + * + * \note This function doesn't check if dev is NULL. + */ +void gpio_cmsdk_config_irq(struct gpio_cmsdk_dev_t* dev, uint32_t pin_mask, + enum gpio_cmsdk_irq_type_t irq_type, + enum gpio_cmsdk_irq_polarity_t irq_pol); + +/** + * \brief Sets state of the output pin. + * + * \param[in] dev GPIO device to use for the pin \ref gpio_cmsdk_dev_t + * \param[in] pin_num Pin number for pin access + * \param[in] value Value(s) to set. + * + * \return Returns error code as specified in \ref gpio_cmsdk_error_t + * + * \note This function doesn't check if dev is NULL. + * \note GPIO data output register is a read-modify-write register, + * so before writing a value on a GPIO pin it is required to disable + * the interrupts to prevent concurrency problems. + */ +enum gpio_cmsdk_error_t gpio_cmsdk_pin_write(struct gpio_cmsdk_dev_t* dev, + uint32_t pin_num, + uint32_t value); + +/** + * \brief Sets state of the output port. + * + * \param[in] dev GPIO device to use for the pins \ref gpio_cmsdk_dev_t + * \param[in] pin_mask Bitmask of the selected pins + * \param[in] value Bitmask of pins states to set + * + * \return Returns error code as specified in \ref gpio_cmsdk_error_t + * + * \note This function doesn't check if dev is NULL. + * \note GPIO data output register is a read-modify-write register, + * so before writing a value on a GPIO pin it is required to disable + * the interrupts to prevent concurrency problems. + */ +enum gpio_cmsdk_error_t gpio_cmsdk_port_write(struct gpio_cmsdk_dev_t* dev, + uint32_t pin_mask, + uint32_t value); + +/** + * \brief Reads the pin status. + * + * \param[in] dev GPIO device to use for the pin \ref gpio_cmsdk_dev_t + * \param[in] pin_num Pin number for pin access + * \param[out] data Bit value read from the IO pin + * + * \return Returns error code as specified in \ref gpio_cmsdk_error_t + * + * \note This function doesn't check if dev is NULL. + */ +enum gpio_cmsdk_error_t +gpio_cmsdk_pin_read(struct gpio_cmsdk_dev_t* dev, uint32_t pin_num, uint32_t *data); + +/** + * \brief Reads the port status. + * + * \param[in] dev GPIO device to use for the pins \ref gpio_cmsdk_dev_t + * \param[in] pin_mask Bitmask of the selected pins + * \param[out] data Bit values for the mask read from the IO pin + * + * \return Returns error code as specified in \ref gpio_cmsdk_error_t + * + * \note This function doesn't check if dev is NULL. + */ +enum gpio_cmsdk_error_t +gpio_cmsdk_port_read(struct gpio_cmsdk_dev_t* dev, uint32_t pin_mask, + uint32_t *data); + +/** + * \brief Enables/disables interrupt for the given pin. + * + * \param[in] dev GPIO device to initalize \ref gpio_cmsdk_dev_t + * \param[in] pin_num Pin number to configure + * \param[in] status Interrupt status \ref gpio_cmsdk_irq_status + * + * \return Returns error code as specified in \ref gpio_cmsdk_error_t + * + * \note This function doesn't check if dev is NULL. + */ +enum gpio_cmsdk_error_t +gpio_cmsdk_set_pin_irq_cfg(struct gpio_cmsdk_dev_t* dev, uint32_t pin_num, + enum gpio_cmsdk_irq_status_t status); + +/** + * \brief Enables/disables interrupt for the given pins. + * + * \param[in] dev GPIO device to use for the pins \ref gpio_cmsdk_dev_t + * \param[in] pin_mask Bitmask of the pins to configure + * \param[in] status Interrupt status \ref gpio_cmsdk_irq_status + * + * \return Returns error code as specified in \ref gpio_cmsdk_error_t + * + * \note This function doesn't check if dev is NULL. + */ +enum gpio_cmsdk_error_t +gpio_cmsdk_set_port_irq_cfg(struct gpio_cmsdk_dev_t* dev, uint32_t pin_mask, + enum gpio_cmsdk_irq_status_t status); + +/** + * \brief Get interrupt status for the given pin. + * + * \param[in] dev GPIO device to use for the pin \ref gpio_cmsdk_dev_t + * \param[in] pin_num Pin number for the access + * \param[out] status Interrupt status values. If the access is by pin, then + * the status will be 0 or 1. + * + * \return Returns error code as specified in \ref gpio_cmsdk_error_t + * + * \note This function doesn't check if dev is NULL. + */ +enum gpio_cmsdk_error_t +gpio_cmsdk_get_pin_irq_status(struct gpio_cmsdk_dev_t* dev, + uint32_t pin_num, uint32_t* status); + +/** + * \brief Get interrupt status for the given port. + * + * \param[in] dev GPIO device to use for the pins \ref gpio_cmsdk_dev_t + * \param[in] pin_mask Bitmask of the pins to configure + * \param[out] status Interrupt status values. If the access is by pin, + * then the status will be 0 or 1. + * + * \return Returns error code as specified in \ref gpio_cmsdk_error_t + * + * \note This function doesn't check if dev is NULL. + */ +enum gpio_cmsdk_error_t +gpio_cmsdk_get_port_irq_status(struct gpio_cmsdk_dev_t* dev, + uint32_t pin_mask, uint32_t* status); + +/** + * \brief Clears gpio interrupt. + * + * \param[in] dev GPIO device to initalize \ref gpio_cmsdk_dev_t + * \param[in] pin_num Pin number. + * + * \return Returns error code as specified in \ref gpio_cmsdk_error_t + * + * \note This function doesn't check if dev is NULL. + */ +enum gpio_cmsdk_error_t gpio_cmsdk_clear_irq(struct gpio_cmsdk_dev_t* dev, + uint8_t pin_num); + +#ifdef __cplusplus +} +#endif +#endif /* __GPIO_CMSDK_DRV_H__ */ diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/i2c_ip6510_drv.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/i2c_ip6510_drv.c new file mode 100644 index 00000000000..74d60304b02 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/i2c_ip6510_drv.c @@ -0,0 +1,1364 @@ +/* + * Copyright (c) 2018-2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * \file i2c_ip6510_drv.c + * \brief Driver for IP6510 I2C controller. + */ + +#include "i2c_ip6510_drv.h" + +#include +#include +#include "cmsis_compiler.h" + +/******************************************************************************* + * Cadence IP6510 I2C device specific definitions based on: + * I2C Controller IP User Guide + * Part Number: IP6510 + * IP Version Number: r115_f01 + * User Guide Revision: 1.20 + * + ******************************************************************************/ + +/** Setter bit manipulation macro */ +#define SET_BIT(WORD, BIT_INDEX) ((WORD) |= (1U << (BIT_INDEX))) +/** Clearing bit manipulation macro */ +#define CLR_BIT(WORD, BIT_INDEX) ((WORD) &= ~(1U << (BIT_INDEX))) +/** Getter bit manipulation macro */ +#define GET_BIT(WORD, BIT_INDEX) (bool)(((WORD) & (1U << (BIT_INDEX)))) +/** Clear-and-Set bit manipulation macro */ +#define ASSIGN_BIT(WORD, BIT_INDEX, VALUE) \ + (WORD = ((WORD & ~(1U << (BIT_INDEX))) | (VALUE << (BIT_INDEX)))) + +/** Getter bit-field manipulation macro */ +#define GET_BIT_FIELD(WORD, BIT_MASK, BIT_OFFSET) \ + ((WORD & BIT_MASK) >> BIT_OFFSET) + +/** Clear-and-Set bit-field manipulation macro */ +#define ASSIGN_BIT_FIELD(WORD, BIT_MASK, BIT_OFFSET, VALUE) \ + (WORD = ((WORD & ~(BIT_MASK)) | ((VALUE << BIT_OFFSET) & BIT_MASK))) + +#define BITMASK(width) ((1u<<(width))-1) + +/** + * \brief I2C (IP6510) register map structure + */ +struct i2c_ip6510_reg_map_t { + volatile uint32_t control_reg; + /*!< Offset: 0x00 (R/W) Control Register */ + volatile uint32_t status_reg; + /*!< Offset: 0x04 (R/ ) Status Register */ + volatile uint32_t address_reg; + /*!< Offset: 0x08 (R/W) I2C Address Register */ + volatile uint32_t data_reg; + /*!< Offset: 0x0C (R/W) I2C Data Register */ + volatile uint32_t irq_status_reg; + /*!< Offset: 0x10 (R/ ) Interrupt Status Register */ + volatile uint32_t transfer_size_reg; + /*!< Offset: 0x14 (R/W) Transfer Size Register */ + volatile uint32_t slave_monitor_pause_reg; + /*!< Offset: 0x18 (R/W) Slave Monitor Pause Register */ + volatile uint32_t time_out_reg; + /*!< Offset: 0x1C (R/W) Time Out Register */ + volatile uint32_t irq_mask_reg; + /*!< Offset: 0x20 (R/ ) Interrupt Mask Register */ + volatile uint32_t irq_enable_reg; + /*!< Offset: 0x24 ( /W) Interrupt Enable Register */ + volatile uint32_t irq_disable_reg; + /*!< Offset: 0x28 ( /W) Interrupt Disable Register */ + volatile uint32_t glitch_filter_control_reg; + /*!< Offset: 0x2C (R/W) Glitch Filter Control Register */ +}; + +#define I2C_IP6510_I2CCR_RW_OFF (0u) + /*!< Control Register Read/Write bit field offset */ +#define I2C_IP6510_I2CCR_MS_OFF (1u) + /*!< Control Register Master/Slave bit field offset */ +#define I2C_IP6510_I2CCR_NEA_OFF (2u) + /*!< Control Register Normal/Extended address bit field offset */ +#define I2C_IP6510_I2CCR_ACKEN_OFF (3u) + /*!< Control Register Acknowledge Enable bit field offset */ +#define I2C_IP6510_I2CCR_HOLD_OFF (4u) + /*!< Control Register Hold mode bit field offset */ +#define I2C_IP6510_I2CCR_SLVMON_OFF (5u) + /*!< Control Register Slave Monitor mode bit field offset */ +#define I2C_IP6510_I2CCR_CLRFIFO_OFF (6u) + /*!< Control Register Clear FIFO bit field offset */ +#define I2C_IP6510_I2CCR_DIV_B_OFF (8u) + /*!< Control Register Divisor B bit field offset */ +#define I2C_IP6510_I2CCR_DIV_A_OFF (14u) + /*!< Control Register Divisor A bit field offset */ + +#define I2C_IP6510_I2CSR_RXRW_OFF (3u) + /*!< Status Register RX read/write flag bit field offset*/ +#define I2C_IP6510_I2CSR_RXDV_OFF (5u) + /*!< Status Register Receiver Data Valid bit field offset */ +#define I2C_IP6510_I2CSR_TXDV_OFF (6u) + /*!< Status Register Transmitter Data Valid bit field offset */ +#define I2C_IP6510_I2CSR_BA_OFF (8u) + /*!< Status Register Bus Active bit field offset */ + + +/* Bit mask to determine the I2C address mode, if at least one of the upper + * 3bits (from 10bits) is used (set to 1) than it is a 10bit I2C address */ +#define I2C_10BIT_ADDR_MASK (0x0380u) + +/* Valid range of I2C addresses based on specification */ +#define I2C_7BIT_ADDR_LOWEST (0x8u) +#define I2C_10BIT_ADDR_HIGHEST (0x3FFu) + +/* The default value is based on the Cadence I2C IP User Guide */ +#define I2C_TIMEOUT_REG_DEFAULT_VALUE (0x001Fu) + +/* The frequency of the inner clock_enable signal is 22 times faster than the + * required SCL output frequency */ +#define I2C_SPEED_100KHZ_CLOCK_EN_FREQ (2200000u) +#define I2C_SPEED_400KHZ_CLOCK_EN_FREQ (8800000u) + +/* In case of slave mode with FIFO implemented, to support the minimum + * SCL period specification for fast-mode (400kHz), the device must be + * programmed to run at higher frequency. The value is based on the + * Cadence I2C IP User Guide and the clock divisor calculation method */ +#define I2C_SPEED_MAX_SUPP_CLOCK_EN_FREQ (13200000u) + +/* Mask for Divisor A field in the Control Register */ +#define I2C_IP6510_I2CCR_DIV_A_WIDTH (2u) +#define I2C_IP6510_I2CCR_DIV_A_MASK (BITMASK(I2C_IP6510_I2CCR_DIV_A_WIDTH) \ + << I2C_IP6510_I2CCR_DIV_A_OFF) + +/* Mask for Divisor B field in the Control Register */ +#define I2C_IP6510_I2CCR_DIV_B_WIDTH (6u) +#define I2C_IP6510_I2CCR_DIV_B_MASK (BITMASK(I2C_IP6510_I2CCR_DIV_B_WIDTH) \ + << I2C_IP6510_I2CCR_DIV_B_OFF) + +/* The maximum value of stage A clock divider is 3.*/ +#define I2C_IP6510_DIVISOR_A_MAX_VALUE (3u) + +/* The maximum value of stage B clock divider is 63.*/ +#define I2C_IP6510_DIVISOR_B_MAX_VALUE (63u) + +/* The maximum number of received bytes in one (not combined) transfer + * is 0xF (due to Transfer Size Register constraints). */ +#define I2C_RECEIVED_BYTE_MAX_NUMBER (15u) + + +/** + * \brief Sets the direction of the I2C transfer. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + * \param[in] transf_dir Required direction of the I2C transfer. + * \ref i2c_ip6510_transf_dir_t + */ + static void set_transfer_dir(struct i2c_ip6510_reg_map_t *p_i2c, + enum i2c_ip6510_transf_dir_t transf_dir) +{ + if(transf_dir == I2C_IP6510_TRANSMITTER) { + CLR_BIT(p_i2c->control_reg, I2C_IP6510_I2CCR_RW_OFF); + + } else { + /* I2C_IP6510_RECEIVER */ + SET_BIT(p_i2c->control_reg, I2C_IP6510_I2CCR_RW_OFF); + } +} + +/** + * \brief Determines and sets the I2C addressing mode based on the address. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + * \param[in] addr I2C device address (7bits or 10bits). + * + * \return Returns with the determined addressing mode. + * \ref i2c_ip6510_addr_mode_t + */ +static enum i2c_ip6510_addr_mode_t set_address_mode( + struct i2c_ip6510_reg_map_t *p_i2c, + uint16_t addr) +{ + /* If at least one of the upper 3bits (from 10bits) is used (set to 1) + * than it is a 10bit I2C address */ + if(addr & I2C_10BIT_ADDR_MASK) { + /* Using I2C Extended Address mode */ + CLR_BIT(p_i2c->control_reg, I2C_IP6510_I2CCR_NEA_OFF); + return I2C_IP6510_EXT_ADDR_MODE; + + } else { + /* Using I2C Normal Address mode */ + SET_BIT(p_i2c->control_reg, I2C_IP6510_I2CCR_NEA_OFF); + return I2C_IP6510_NOR_ADDR_MODE; + } +} + +/** + * \brief Enables Slave Monitor mode (in master mode only). + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + */ +static void enable_slave_monitor(struct i2c_ip6510_reg_map_t *p_i2c) +{ + SET_BIT(p_i2c->control_reg, I2C_IP6510_I2CCR_SLVMON_OFF); +} + +/** + * \brief Disables Slave Monitor mode (in master mode only). + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + */ +static void disable_slave_monitor(struct i2c_ip6510_reg_map_t *p_i2c) +{ + CLR_BIT(p_i2c->control_reg, I2C_IP6510_I2CCR_SLVMON_OFF); +} + +/** + * \brief Check if Slave Monitor mode is enabled. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + * + * \return Returns bool, true if Slave Monitor is enabled, false otherwise + */ +static bool is_slave_monitor_enabled(const struct i2c_ip6510_reg_map_t *p_i2c) +{ + return GET_BIT(p_i2c->control_reg, I2C_IP6510_I2CCR_SLVMON_OFF); +} + +/** + * \brief Configures the clock dividers (A and B) with the given values. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + * \param[in] div_a Value of divisor stage A. + * \param[in] div_b Value of divisor stage B. + */ +static void set_divisor(struct i2c_ip6510_reg_map_t *p_i2c, + uint32_t div_a, uint32_t div_b) +{ + ASSIGN_BIT_FIELD(p_i2c->control_reg, + I2C_IP6510_I2CCR_DIV_A_MASK, + I2C_IP6510_I2CCR_DIV_A_OFF, + div_a); + + ASSIGN_BIT_FIELD(p_i2c->control_reg, + I2C_IP6510_I2CCR_DIV_B_MASK, + I2C_IP6510_I2CCR_DIV_B_OFF, + div_b); +} + +/** + * \brief Enables transmission of ACK. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + */ +static void ack_enable(struct i2c_ip6510_reg_map_t *p_i2c) +{ + SET_BIT(p_i2c->control_reg, I2C_IP6510_I2CCR_ACKEN_OFF); +} + +/** + * \brief Disables transmission of ACK. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + */ +static void ack_disable(struct i2c_ip6510_reg_map_t *p_i2c) +{ + CLR_BIT(p_i2c->control_reg, I2C_IP6510_I2CCR_ACKEN_OFF); +} + +/** + * \brief Enables Hold mode. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + */ +static void hold_enable(struct i2c_ip6510_reg_map_t *p_i2c) +{ + SET_BIT(p_i2c->control_reg, I2C_IP6510_I2CCR_HOLD_OFF); +} + +/** + * \brief Disables Hold mode. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + */ +static void hold_disable(struct i2c_ip6510_reg_map_t *p_i2c) +{ + CLR_BIT(p_i2c->control_reg, I2C_IP6510_I2CCR_HOLD_OFF); +} + +/** + * \brief Clears FIFO (and clears the Transfer Size register). + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + */ +static void clr_fifo(struct i2c_ip6510_reg_map_t *p_i2c) +{ + __DMB(); + SET_BIT(p_i2c->control_reg, I2C_IP6510_I2CCR_CLRFIFO_OFF); + __DSB(); +} + +/** + * \brief Clears the specified I2C interrupts. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + * \param[in] mask Bit mask for clearing interrupts. Values from + * \ref i2c_ip6510_intr_t could be used to create the mask. + */ +static void clr_irq(struct i2c_ip6510_reg_map_t *p_i2c, uint32_t mask) +{ + p_i2c->irq_status_reg = mask; +} + +/** + * \brief Configures the address register with the given address. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + * \param[in] addr I2C device address (7bits or 10bits). + */ +static void set_address(struct i2c_ip6510_reg_map_t *p_i2c, uint16_t addr) +{ + __DMB(); + p_i2c->address_reg = (uint32_t)addr; + __DSB(); +} + +/** + * \brief Checks if new and valid data is available to be read. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + * + * \return Returns bool, true if received data is available, false otherwise. + */ +static bool is_rx_data_ready(const struct i2c_ip6510_reg_map_t *p_i2c) +{ + return GET_BIT(p_i2c->status_reg, I2C_IP6510_I2CSR_RXDV_OFF); +} + +/** + * \brief Checks if there is still data to be transmitted. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + * + * \return Returns bool, true if there is still data to be transmitted, + * false otherwise. + */ +static bool is_tx_data_waiting(const struct i2c_ip6510_reg_map_t *p_i2c) +{ + return GET_BIT(p_i2c->status_reg, I2C_IP6510_I2CSR_TXDV_OFF); +} + +/** + * \brief Reads a data byte from the FIFO. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + * + * \return Returns the received data byte. + */ +static uint8_t rx_byte(const struct i2c_ip6510_reg_map_t *p_i2c) +{ + return (uint8_t)(p_i2c->data_reg); +} + +/** + * \brief Writes a data byte into the FIFO to be transmitted. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + * \param[in] data Data byte to be transmitted. + */ +static void tx_byte(struct i2c_ip6510_reg_map_t *p_i2c, uint8_t data) +{ + __DMB(); + p_i2c->data_reg = (uint32_t)data; + __DSB(); +} + +/** + * \brief Checks if I2C transfer is successful. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + * + * \return Returns bool, true if transfer is successful, false otherwise. + */ +static bool is_transfer_complete(const struct i2c_ip6510_reg_map_t *p_i2c) +{ + return GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_COMP_OFF); +} + +/** + * \brief Clears the complete interrupt status register. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + */ +static void clear_irq_status_reg(struct i2c_ip6510_reg_map_t *p_i2c) +{ + p_i2c->irq_status_reg = I2C_IP6510_ALL_INTR_MASK; +} + +/** + * \brief Sets the Transfer Size register with the given value. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + * \param[in] byte_num New Transfer Size register value. + */ +static void set_transfer_size(struct i2c_ip6510_reg_map_t *p_i2c, + uint32_t byte_num) +{ + p_i2c->transfer_size_reg = byte_num; +} + +/** + * \brief Returns the value of the Transfer Size register. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + */ +static uint32_t get_transfer_size(struct i2c_ip6510_reg_map_t *p_i2c) +{ + return p_i2c->transfer_size_reg; +} + +/** + * \brief Writes the default values into the registers where it is applicable. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + */ +static void reset_regs(struct i2c_ip6510_reg_map_t *p_i2c) +{ + p_i2c->control_reg = 0U; + p_i2c->address_reg = 0U; + p_i2c->transfer_size_reg = 0U; + p_i2c->slave_monitor_pause_reg = 0U; + p_i2c->time_out_reg = I2C_TIMEOUT_REG_DEFAULT_VALUE; + p_i2c->glitch_filter_control_reg = 0U; +} + +/** + * \brief Sets the I2C interface mode. + * + * \param[in] dev I2C (IP6510) device structure \ref i2c_ip6510_dev_t + * \param[in] mode I2C interface mode \ref i2c_ip6510_device_mode_t + * + * \note This function doesn't check if dev is NULL. + */ +static void set_device_mode(struct i2c_ip6510_dev_t *dev, + enum i2c_ip6510_device_mode_t mode) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + ASSIGN_BIT(p_i2c->control_reg, I2C_IP6510_I2CCR_MS_OFF, mode); + + dev->data->mode = mode; +} + +enum i2c_ip6510_error_t i2c_ip6510_init(struct i2c_ip6510_dev_t *dev, + uint32_t sys_clk) +{ + enum i2c_ip6510_error_t err = I2C_IP6510_ERR_NONE; + + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + if(dev->data->state != I2C_IP6510_UNINITIALIZED) { + return I2C_IP6510_ERR_ALREADY_INIT; + } + + if(sys_clk == 0U) { + return I2C_IP6510_ERR_INVALID_ARG; + } + + i2c_ip6510_disable_irq(dev, I2C_IP6510_ALL_INTR_MASK); + + clear_irq_status_reg(p_i2c); + clr_fifo(p_i2c); + + /* Updating the system clock frequency */ + dev->data->sys_clk = sys_clk; + + set_device_mode(dev, dev->cfg->default_mode); + err = i2c_ip6510_set_speed(dev, dev->cfg->default_bus_speed); + + if(err != I2C_IP6510_ERR_NONE) { + return err; + } + + dev->data->state = I2C_IP6510_INITIALIZED; + + return I2C_IP6510_ERR_NONE; +} + +void i2c_ip6510_uninit(struct i2c_ip6510_dev_t *dev) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + i2c_ip6510_disable_irq(dev, I2C_IP6510_ALL_INTR_MASK); + + clear_irq_status_reg(p_i2c); + + reset_regs(p_i2c); + + clr_fifo(p_i2c); + + dev->data->state = I2C_IP6510_UNINITIALIZED; +} + +void i2c_ip6510_hold_enable(const struct i2c_ip6510_dev_t *dev) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + hold_enable(p_i2c); +} + +void i2c_ip6510_hold_disable(const struct i2c_ip6510_dev_t *dev) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + hold_disable(p_i2c); +} + +enum i2c_ip6510_state_t i2c_ip6510_get_state(const struct i2c_ip6510_dev_t *dev) +{ + return dev->data->state; +} + +enum i2c_ip6510_device_mode_t i2c_ip6510_get_device_mode( + const struct i2c_ip6510_dev_t *dev) +{ + return dev->data->mode; +} + +enum i2c_ip6510_error_t i2c_ip6510_set_speed(struct i2c_ip6510_dev_t *dev, + enum i2c_ip6510_speed_t speed) +{ + uint32_t div_a = 0U; + uint32_t div_b = 0U; + uint32_t clock_enable_freq = 0U; + + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + if(dev->data->sys_clk == 0U) { + /* Invalid system clock frequency */ + return I2C_IP6510_ERR; + } + + /* The required frequency of SCL output is 22 times slower than the + * frequency of the inner clock_enable signal. */ + switch(speed) { + + case I2C_IP6510_SPEED_100KHZ: + clock_enable_freq = I2C_SPEED_100KHZ_CLOCK_EN_FREQ; + dev->data->bus_speed = I2C_IP6510_SPEED_100KHZ; + break; + + case I2C_IP6510_SPEED_400KHZ: + clock_enable_freq = I2C_SPEED_400KHZ_CLOCK_EN_FREQ; + dev->data->bus_speed = I2C_IP6510_SPEED_400KHZ; + break; + + case I2C_IP6510_SPEED_MAX_SUPPORTED: + /* In case of slave mode with FIFO implemented, to support the minimum + * SCL period specification for fast-mode (400kHz), the device must be + * programmed to run at higher frequency. */ + clock_enable_freq = I2C_SPEED_MAX_SUPP_CLOCK_EN_FREQ; + dev->data->bus_speed = I2C_IP6510_SPEED_MAX_SUPPORTED; + break; + + default: + return I2C_IP6510_ERR_INVALID_ARG; + } + + /* Calculating the value of stage A and B clock dividers */ + div_a = 0U; + div_b = (uint32_t)(dev->data->sys_clk / clock_enable_freq); + + if(div_b > I2C_IP6510_DIVISOR_B_MAX_VALUE) { + + /* (div_a+1)x(div_b+1) must be equal to former div_b value */ + div_a = I2C_IP6510_DIVISOR_A_MAX_VALUE; + div_b = (uint32_t)(div_b+1U) >> I2C_IP6510_I2CCR_DIV_A_WIDTH; + } + + set_divisor(p_i2c, div_a, div_b); + + return I2C_IP6510_ERR_NONE; +} + +enum i2c_ip6510_speed_t i2c_ip6510_get_speed(const struct i2c_ip6510_dev_t *dev) +{ + return dev->data->bus_speed; +} + +enum i2c_ip6510_bus_state_t i2c_ip6510_get_bus_status( + const struct i2c_ip6510_dev_t *dev) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + return (GET_BIT(p_i2c->status_reg, I2C_IP6510_I2CSR_BA_OFF)) ? + I2C_IP6510_BUS_ACTIVE : I2C_IP6510_BUS_INACTIVE; +} + +int i2c_ip6510_get_transfer_size(const struct i2c_ip6510_dev_t *dev) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + return p_i2c->transfer_size_reg; +} + +uint32_t i2c_ip6510_get_irq_status(const struct i2c_ip6510_dev_t *dev) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + return p_i2c->irq_status_reg; +} + +uint32_t i2c_ip6510_get_irq_mask(const struct i2c_ip6510_dev_t *dev) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + return p_i2c->irq_mask_reg; +} + +void i2c_ip6510_clear_irq(struct i2c_ip6510_dev_t *dev, uint32_t mask) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + clr_irq(p_i2c, mask); +} + +void i2c_ip6510_enable_irq(struct i2c_ip6510_dev_t *dev, uint32_t mask) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + p_i2c->irq_enable_reg = mask; +} + +void i2c_ip6510_disable_irq(struct i2c_ip6510_dev_t *dev, uint32_t mask) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + p_i2c->irq_disable_reg = mask; +} + +void i2c_ip6510_set_timeout(struct i2c_ip6510_dev_t *dev, + uint8_t interval) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + p_i2c->time_out_reg = (uint32_t)interval; +} + +void i2c_ip6510_set_slave_monitor_pause_interval(struct i2c_ip6510_dev_t *dev, + uint8_t interval) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + p_i2c->slave_monitor_pause_reg = (uint32_t)interval; +} + +uint8_t i2c_ip6510_get_slave_monitor_pause_interval( + struct i2c_ip6510_dev_t *dev) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + return (uint8_t)(p_i2c->slave_monitor_pause_reg); +} + +void i2c_ip6510_set_glitch_filter_length(struct i2c_ip6510_dev_t *dev, + uint32_t length) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + p_i2c->glitch_filter_control_reg = length; +} + +uint8_t i2c_ip6510_get_glitch_filter_length(const struct i2c_ip6510_dev_t *dev) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + return (uint8_t)(p_i2c->glitch_filter_control_reg); +} + +enum i2c_ip6510_error_t i2c_ip6510_monitor_slave(struct i2c_ip6510_dev_t *dev, + uint16_t addr) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + if(i2c_ip6510_get_state(dev) != I2C_IP6510_INITIALIZED) { + return I2C_IP6510_ERR_NOT_INIT; + } + + clear_irq_status_reg(p_i2c); + set_address_mode(p_i2c, addr); + set_transfer_dir(p_i2c, I2C_IP6510_TRANSMITTER); + enable_slave_monitor(p_i2c); + + /* Initiates slave addressing */ + set_address(p_i2c, addr); + + /* Slave Monitor Mode gets disabled if given slave is present */ + while(is_slave_monitor_enabled(p_i2c) || + !(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_SLVRDY_OFF))) { + + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_NACK_OFF)) { + disable_slave_monitor(p_i2c); + return I2C_IP6510_ERR_NACK; + } + } + return I2C_IP6510_ERR_NONE; +} + +/** + * \brief Initiates transfer and writes the given number of data bytes to send. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + * \param[in] addr I2C device address (7 bits or 10 bits). + * \param[in] tx_data Data buffer pointer to write. + * \param[in] tx_length Data buffer length (number of bytes to write). + * \param[out] write_cntr Number of bytes written. + * + * \return Returns error code as specified in \ref i2c_ip6510_error_t + */ +static enum i2c_ip6510_error_t tx_transfer( + struct i2c_ip6510_reg_map_t *p_i2c, + uint16_t addr, + const uint8_t *tx_data, + uint32_t *tx_length) +{ + uint32_t write_cntr = *tx_length; + + ack_enable(p_i2c); + clear_irq_status_reg(p_i2c); + set_address_mode(p_i2c, addr); + set_transfer_dir(p_i2c, I2C_IP6510_TRANSMITTER); + + /* Initiates I2C transfer */ + set_address(p_i2c, addr); + + while(write_cntr) { + + tx_byte(p_i2c, *tx_data); + + /* If the sent data byte or slave addressing is not acknowledged */ + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_NACK_OFF)) { + *tx_length -= write_cntr; + return I2C_IP6510_ERR_NACK; + + } else if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_TXOVF_OFF)) { + /* In case of FIFO overflow the last written byte is ignored and + * the Data Register access must be repeated. */ + clr_irq(p_i2c, I2C_IP6510_INTR_TXOVF_MASK); + continue; + } + + tx_data++; + write_cntr--; + } + *tx_length -= write_cntr; + + return I2C_IP6510_ERR_NONE; +} + +enum i2c_ip6510_error_t i2c_ip6510_master_write(struct i2c_ip6510_dev_t *dev, + uint16_t addr, + const uint8_t *tx_data, + bool stop, + uint32_t *tx_length) +{ + enum i2c_ip6510_error_t err = I2C_IP6510_ERR_NONE; + + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + if(*tx_length == 0U) { + return I2C_IP6510_ERR_INVALID_ARG; + } + + if(i2c_ip6510_get_state(dev) != I2C_IP6510_INITIALIZED) { + return I2C_IP6510_ERR_NOT_INIT; + } + + clr_fifo(p_i2c); + + /* Prevents the I2C interface from generating a STOP condition */ + hold_enable(p_i2c); + + /* Initiates transfer and transmits the given number of data bytes */ + err = tx_transfer(p_i2c, addr, tx_data, tx_length); + + if(err != I2C_IP6510_ERR_NONE) { + hold_disable(p_i2c); + + return err; + } + + while(!is_transfer_complete(p_i2c)) { + + /* If the last transmitted byte did not get an ACK */ + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_NACK_OFF)) { + return I2C_IP6510_ERR_NACK; + } + } + + /* If enabled, the host can terminate the transfer with disabled hold mode + */ + if (stop) { + hold_disable(p_i2c); + } + + return I2C_IP6510_ERR_NONE; +} + +/** + * \brief Initiates transfer and reads the received data bytes. + * + * \param[in] p_i2c I2C (IP6510) register map structure. + * \ref i2c_ip6510_reg_map_t + * \param[in] addr I2C device address (7 bits or 10 bits). + * \param[in] rx_data Buffer pointer to store the read data. + * \param[in] rx_length Buffer length (number of bytes to read). + * \param[out] read_cntr Number of bytes read. + * + * \return Returns error code as specified in \ref i2c_ip6510_error_t + */ +static enum i2c_ip6510_error_t rx_transfer_combined( + struct i2c_ip6510_reg_map_t *p_i2c, + uint16_t addr, + uint8_t *rx_data, + uint32_t *rx_length) +{ + uint32_t read_cntr = *rx_length; + uint32_t part_rx_length = (read_cntr > I2C_RECEIVED_BYTE_MAX_NUMBER) ? + I2C_RECEIVED_BYTE_MAX_NUMBER : read_cntr; + + /* The I2C controller handles the Acknowledge generation. And Acknowledge + * has to be enabled. */ + ack_enable(p_i2c); + clear_irq_status_reg(p_i2c); + set_address_mode(p_i2c, addr); + set_transfer_dir(p_i2c, I2C_IP6510_RECEIVER); + + /* Initiates I2C transfer */ + set_address(p_i2c, addr); + set_transfer_size(p_i2c, part_rx_length); + + while(read_cntr) { + + /* The maximum number of received bytes in one transfer is limited. If + * the read length is more than the maximum number of bytes that can be + * received in one transfer, the transfer size register has to be + * adjusted before reaching 0. If the transfer size register reaches + * zero, the I2C controller terminates the transfer before completion. + */ + if (get_transfer_size(p_i2c) == 1U) { + part_rx_length = (read_cntr > I2C_RECEIVED_BYTE_MAX_NUMBER) ? + I2C_RECEIVED_BYTE_MAX_NUMBER : read_cntr; + + set_transfer_size(p_i2c, part_rx_length); + } + + /* Waiting for new valid data to read */ + while(!is_rx_data_ready(p_i2c)) { + + /* If the previous slave addressing is not acknowledged */ + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_NACK_OFF)) { + *rx_length -= read_cntr; + return I2C_IP6510_ERR_NACK; + + } else if(GET_BIT(p_i2c->irq_status_reg, + I2C_IP6510_INTR_RXOVF_OFF)) { + + *rx_length -= read_cntr; + /* In case of Receive Overflow return with error code */ + return I2C_IP6510_ERR_RXOVF; + } + } + + *rx_data = rx_byte(p_i2c); + + rx_data++; + read_cntr--; + } + *rx_length -= read_cntr; + + return I2C_IP6510_ERR_NONE; +} + +enum i2c_ip6510_error_t i2c_ip6510_master_read(struct i2c_ip6510_dev_t *dev, + uint16_t addr, + uint8_t *rx_data, + bool stop, + uint32_t *rx_length) +{ + enum i2c_ip6510_error_t err = I2C_IP6510_ERR_NONE; + + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + if(*rx_length == 0U) { + return I2C_IP6510_ERR_INVALID_ARG; + } + + if(i2c_ip6510_get_state(dev) != I2C_IP6510_INITIALIZED) { + return I2C_IP6510_ERR_NOT_INIT; + } + + clr_fifo(p_i2c); + + /* Receive overflow can be avoided and combined read transfer can be + * realized if Hold Mode is enabled */ + hold_enable(p_i2c); + + /* It reads the given number of received bytes from the FIFO + * (in a combined transfer if necessary) */ + err = rx_transfer_combined(p_i2c, addr, rx_data, rx_length); + + if(err != I2C_IP6510_ERR_NONE) { + hold_disable(p_i2c); + + return err; + } + + /* If enabled, the host can terminate the transfer with disabled hold mode + */ + if (stop) { + hold_disable(p_i2c); + } + + /* Waiting for the whole transfer to be complete */ + while(!is_transfer_complete(p_i2c)) { + /* If there is more, unexpected data byte received due to + * any kind of error. */ + if(is_rx_data_ready(p_i2c)) { + return I2C_IP6510_ERR; + } + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_RXOVF_OFF)) { + return I2C_IP6510_ERR_RXOVF; + } + } + + return I2C_IP6510_ERR_NONE; +} + +enum i2c_ip6510_error_t i2c_ip6510_master_write_read( + struct i2c_ip6510_dev_t *dev, + uint16_t addr, + const uint8_t *tx_data, + uint8_t *rx_data, + uint32_t *tx_length, + uint32_t *rx_length) +{ + enum i2c_ip6510_error_t err = I2C_IP6510_ERR_NONE; + + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + if((*tx_length == 0U) || (*rx_length == 0U)) { + return I2C_IP6510_ERR_INVALID_ARG; + } + + if(i2c_ip6510_get_state(dev) != I2C_IP6510_INITIALIZED) { + return I2C_IP6510_ERR_NOT_INIT; + } + + /* Prevents the I2C interface from generating a STOP condition */ + hold_enable(p_i2c); + + /* Initiates transfer and transmits the given number of data bytes */ + err = tx_transfer(p_i2c, addr, tx_data, tx_length); + + if(err != I2C_IP6510_ERR_NONE) { + hold_disable(p_i2c); + return err; + } + + while(!is_transfer_complete(p_i2c)) { + + /* If the last transmitted byte did not get an ACK */ + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_NACK_OFF)) { + hold_disable(p_i2c); + return I2C_IP6510_ERR_NACK; + } + } + + clr_irq(p_i2c, I2C_IP6510_INTR_COMP_MASK); + + /* Write transaction is complete, continue with read transaction */ + + /* The host does not need to ACK only 1 byte, + * it generates a STOP condition after reception */ + if(*rx_length == 1U) { + ack_disable(p_i2c); + } + + /* It reads the given number of received bytes from the FIFO + * (in a combined transfer if necessary) */ + err = rx_transfer_combined(p_i2c, addr, rx_data, rx_length); + + if(err != I2C_IP6510_ERR_NONE) { + hold_disable(p_i2c); + return err; + } + + /* The host can terminate the transfer with disabled hold mode */ + hold_disable(p_i2c); + + /* Waiting for the whole combined transfer to be complete */ + while(!is_transfer_complete(p_i2c)) { + + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_RXOVF_OFF)) { + return I2C_IP6510_ERR_RXOVF; + } + } + + return I2C_IP6510_ERR_NONE; +} + +enum i2c_ip6510_error_t i2c_ip6510_master_byte_write( + const struct i2c_ip6510_dev_t *dev, + uint16_t addr, + const uint8_t *tx_data, + bool set_addr) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + if(i2c_ip6510_get_state(dev) != I2C_IP6510_INITIALIZED) { + return I2C_IP6510_ERR_NOT_INIT; + } + + clear_irq_status_reg(p_i2c); + + if(set_addr == true) { + clr_fifo(p_i2c); + set_address_mode(p_i2c, addr); + set_transfer_dir(p_i2c, I2C_IP6510_TRANSMITTER); + } + ack_enable(p_i2c); + + /* Write the data byte to the FIFO */ + tx_byte(p_i2c, *tx_data); + + /* If the first data byte was written, only then set the address */ + if(set_addr == true) { + /* Initiates I2C transfer */ + set_address(p_i2c, addr); + } + + /* If the sent data byte or slave addressing is not acknowledged */ + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_NACK_OFF)) { + return I2C_IP6510_ERR_NACK; + } else if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_TXOVF_OFF)) { + /* In case of FIFO overflow the last written byte is ignored */ + clr_irq(p_i2c, I2C_IP6510_INTR_TXOVF_MASK); + return I2C_IP6510_ERR_TXOVF; + } + + /* Waiting for the written byte to be transmitted */ + while(!is_transfer_complete(p_i2c)) { + /* If the last transmitted byte did not get an ACK */ + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_NACK_OFF)) { + return I2C_IP6510_ERR_NACK; + } + } + + return I2C_IP6510_ERR_NONE; +} + +enum i2c_ip6510_error_t i2c_ip6510_master_byte_read( + const struct i2c_ip6510_dev_t *dev, + uint16_t addr, + bool last_byte, + bool set_addr, + uint8_t *rx_data) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + if(i2c_ip6510_get_state(dev) != I2C_IP6510_INITIALIZED) { + return I2C_IP6510_ERR_NOT_INIT; + } + + clear_irq_status_reg(p_i2c); + + if(last_byte) { + /* This is the last byte to receive */ + ack_disable(p_i2c); + set_transfer_size(p_i2c, 1U); + } else { + /* There will be more then one data bytes */ + ack_enable(p_i2c); + set_transfer_size(p_i2c, I2C_RECEIVED_BYTE_MAX_NUMBER); + } + + /* If its the first read, the I2C controller has to be configured */ + if (set_addr){ + clr_fifo(p_i2c); + set_address_mode(p_i2c, addr); + set_transfer_dir(p_i2c, I2C_IP6510_RECEIVER); + set_address(p_i2c, addr); + } + + /* Waiting for new valid data to read */ + while(!is_rx_data_ready(p_i2c)) { + + /* If the previous slave addressing is not acknowledged */ + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_NACK_OFF)) { + return I2C_IP6510_ERR_NACK; + + } else if(GET_BIT(p_i2c->irq_status_reg, + I2C_IP6510_INTR_RXOVF_OFF)) { + /* In case of Receive Overflow return with error code */ + return I2C_IP6510_ERR_RXOVF; + } + } + + /* Read the data byte from the FIFO */ + *rx_data = rx_byte(p_i2c); + + return I2C_IP6510_ERR_NONE; +} + +enum i2c_ip6510_error_t i2c_ip6510_set_slave_mode( + struct i2c_ip6510_dev_t *dev, + uint16_t addr) +{ + enum i2c_ip6510_error_t err = I2C_IP6510_ERR_NONE; + + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + /* Checking whether the address is a valid 7/10bit I2C slave address */ + if((addr < I2C_7BIT_ADDR_LOWEST) || (addr > I2C_10BIT_ADDR_HIGHEST)) { + return I2C_IP6510_ERR_INVALID_ARG; + } + + if(i2c_ip6510_get_state(dev) != I2C_IP6510_INITIALIZED) { + return I2C_IP6510_ERR_NOT_INIT; + } + + /* I2C speed must be set to the fastest SCL frequency supported */ + err = i2c_ip6510_set_speed(dev, I2C_IP6510_SPEED_MAX_SUPPORTED); + + if(err != I2C_IP6510_ERR_NONE) { + return err; + } + + set_device_mode(dev, I2C_IP6510_SLAVE_MODE); + clear_irq_status_reg(p_i2c); + ack_enable(p_i2c); + hold_enable(p_i2c); + set_address_mode(p_i2c, addr); + set_address(p_i2c, addr); + + return I2C_IP6510_ERR_NONE; +} + +void i2c_ip6510_set_master_mode(struct i2c_ip6510_dev_t *dev) +{ + set_device_mode(dev, I2C_IP6510_MASTER_MODE); +} + +enum i2c_ip6510_transf_dir_t i2c_ip6510_get_slave_tranf_dir( + struct i2c_ip6510_dev_t *dev) +{ + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + return (GET_BIT(p_i2c->status_reg, I2C_IP6510_I2CSR_RXRW_OFF)) ? + I2C_IP6510_TRANSMITTER : I2C_IP6510_RECEIVER; +} + +enum i2c_ip6510_error_t i2c_ip6510_slave_write(struct i2c_ip6510_dev_t *dev, + const uint8_t *tx_data, + uint32_t *tx_length) +{ + uint32_t write_cntr = *tx_length; + + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + if(write_cntr == 0U) { + return I2C_IP6510_ERR_INVALID_ARG; + } + + if(i2c_ip6510_get_state(dev) != I2C_IP6510_INITIALIZED) { + return I2C_IP6510_ERR_NOT_INIT; + } + + clr_fifo(p_i2c); + ack_enable(p_i2c); + hold_enable(p_i2c); + + /* The amount of data to be transferred is a system known parameter */ + while(write_cntr) { + + /* If the previously sent data byte is not acknowledged */ + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_NACK_OFF)) { + + hold_disable(p_i2c); + clr_fifo(p_i2c); + *tx_length -= write_cntr; + return I2C_IP6510_ERR_NACK; + } + + tx_byte(p_i2c, *tx_data); + + /* In case of FIFO overflow the last written byte is ignored and + * the Data Register access must be repeated. */ + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_TXOVF_OFF)) { + + clr_irq(p_i2c, I2C_IP6510_INTR_TXOVF_MASK); + continue; + } + + tx_data++; + write_cntr--; + } + *tx_length -= write_cntr; + + hold_disable(p_i2c); + + /* Waiting for the last byte to be transmitted from the FIFO */ + while(is_tx_data_waiting(p_i2c)) { + + /* If the transfer is terminated by the Master before completion */ + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_NACK_OFF) && + is_tx_data_waiting(p_i2c)) { + + clr_fifo(p_i2c); + return I2C_IP6510_ERR_NACK; + } + + /* DATA interrupt flag is set when there are only 2 bytes left in + * the FIFO, so at this point there is still data in the FIFO to be + * transmitted and DATA flag should be cleared for further + * examination. */ + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_DATA_OFF)) { + + clr_irq(p_i2c, I2C_IP6510_INTR_DATA_MASK); + } + } + + clr_fifo(p_i2c); + + while(!is_transfer_complete(p_i2c)) { + + /* If DATA interrupt flag is set while the TXDV flag in the Status + * Register is cleared the Master wants to continue the transfer. */ + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_DATA_OFF) && + !is_tx_data_waiting(p_i2c)) { + + return I2C_IP6510_ERR; + } + } + + return I2C_IP6510_ERR_NONE; +} + +enum i2c_ip6510_error_t i2c_ip6510_slave_read(struct i2c_ip6510_dev_t *dev, + uint8_t *rx_data, + uint32_t *rx_length) +{ + uint32_t read_cntr = *rx_length; + + struct i2c_ip6510_reg_map_t *p_i2c = + (struct i2c_ip6510_reg_map_t*)dev->cfg->base; + + if(read_cntr == 0U) { + return I2C_IP6510_ERR_INVALID_ARG; + } + + if(i2c_ip6510_get_state(dev) != I2C_IP6510_INITIALIZED) { + return I2C_IP6510_ERR_NOT_INIT; + } + + ack_enable(p_i2c); + + /* Receive overflow can be avoided if Hold Mode is enabled */ + hold_enable(p_i2c); + + while(read_cntr) { + + while(!is_rx_data_ready(p_i2c)) { + + /* With HOLD enabled the overflow conditions are avoided */ + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_RXOVF_OFF)) { + hold_disable(p_i2c); + *rx_length -= read_cntr; + return I2C_IP6510_ERR_RXOVF; + } + } + + *rx_data = rx_byte(p_i2c); + + rx_data++; + read_cntr--; + } + *rx_length -= read_cntr; + + hold_disable(p_i2c); + + /* Waiting for the master to terminate the transfer */ + while(!is_transfer_complete(p_i2c)) { + + if(GET_BIT(p_i2c->irq_status_reg, I2C_IP6510_INTR_RXOVF_OFF)) { + return I2C_IP6510_ERR_RXOVF; + + } else if(is_rx_data_ready(p_i2c)) { + /* If there are more, unexpected data bytes received from the Master + */ + return I2C_IP6510_ERR; + } + } + + return I2C_IP6510_ERR_NONE; +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/i2c_ip6510_drv.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/i2c_ip6510_drv.h new file mode 100644 index 00000000000..f57233da282 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/i2c_ip6510_drv.h @@ -0,0 +1,649 @@ +/* + * Copyright (c) 2018-2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * \file i2c_ip6510_drv.h + * \brief Driver for IP6510 I2C controller. + */ + +#ifndef __I2C_IP6510_DRV_H__ +#define __I2C_IP6510_DRV_H__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * \brief I2C (IP6510) device state types. + */ +enum i2c_ip6510_state_t { + I2C_IP6510_UNINITIALIZED = 0u, + I2C_IP6510_INITIALIZED = 1u, +}; + +/** + * \brief I2C (IP6510) bus state types. + */ +enum i2c_ip6510_bus_state_t { + I2C_IP6510_BUS_INACTIVE = 0u, + I2C_IP6510_BUS_ACTIVE = 1u, +}; + +/** + * \brief Allowed transfer direction options. + */ +enum i2c_ip6510_transf_dir_t { + I2C_IP6510_TRANSMITTER = 0u, + I2C_IP6510_RECEIVER = 1u, +}; + +/** + * \brief Supported I2C (IP6510) device mode options. + */ +enum i2c_ip6510_device_mode_t { + I2C_IP6510_SLAVE_MODE = 0u, + I2C_IP6510_MASTER_MODE = 1u, +}; + +/** + * \brief Supported I2C (IP6510) addressing options. + */ +enum i2c_ip6510_addr_mode_t { + I2C_IP6510_EXT_ADDR_MODE = 0u, + I2C_IP6510_NOR_ADDR_MODE = 1u, +}; + +/** + * \brief Supported I2C (IP6510) bus data rate options. + */ +enum i2c_ip6510_speed_t { + I2C_IP6510_SPEED_100KHZ = 0u, + I2C_IP6510_SPEED_400KHZ = 1u, + I2C_IP6510_SPEED_MAX_SUPPORTED = 2u, +}; + +#define I2C_IP6510_INTR_COMP_OFF (0u) + /*!< Transfer complete interrupt bit field offset */ +#define I2C_IP6510_INTR_DATA_OFF (1u) + /*!< More data interrupt bit field offset */ +#define I2C_IP6510_INTR_NACK_OFF (2u) + /*!< Transfer not ACKed interrupt bit field offset */ +#define I2C_IP6510_INTR_TO_OFF (3u) + /*!< Transfer time out interrupt bit field offset */ +#define I2C_IP6510_INTR_SLVRDY_OFF (4u) + /*!< Monitored slave ready interrupt bit field offset */ +#define I2C_IP6510_INTR_RXOVF_OFF (5u) + /*!< Receive overflow interrupt bit field offset */ +#define I2C_IP6510_INTR_TXOVF_OFF (6u) + /*!< FIFO transmit overflow interrupt bit field offset */ +#define I2C_IP6510_INTR_RXUNF_OFF (7u) + /*!< FIFO receive underflow interrupt bit field offset */ +#define I2C_IP6510_INTR_ARBLOST_OFF (9u) + /*!< Arbitration lost interrupt bit field offset */ + +#define I2C_IP6510_ALL_INTR_MASK (0x2FFu) + +/** + * \brief I2C (IP6510) interrupt data structure + */ +enum i2c_ip6510_intr_t { + I2C_IP6510_INTR_COMP_MASK = (0x1u<iomux_main_insel &= ~pin_mask; + scc_regs->iomux_main_outsel &= ~pin_mask; + scc_regs->iomux_main_oensel &= ~pin_mask; + } + if (func_mask & GPIO_ALTFUNC_1_MASK) { + scc_regs->iomux_altf1_insel &= ~pin_mask; + scc_regs->iomux_altf1_outsel &= ~pin_mask; + scc_regs->iomux_altf1_oensel &= ~pin_mask; + } + if (func_mask & GPIO_ALTFUNC_2_MASK) { + scc_regs->iomux_altf2_insel &= ~pin_mask; + scc_regs->iomux_altf2_outsel &= ~pin_mask; + scc_regs->iomux_altf2_oensel &= ~pin_mask; + } +} + +void musca_s1_scc_set_alt_func(struct musca_s1_scc_dev_t* dev, + enum gpio_altfunc_t altfunc, uint32_t pin_mask) +{ + struct musca_s1_scc_reg_map_t* scc_regs = + (struct musca_s1_scc_reg_map_t*) dev->cfg->base; + enum gpio_altfunc_mask_t altfunc_to_clear = GPIO_ALTFUNC_NONE; + volatile uint32_t *insel = NULL; + volatile uint32_t *outsel = NULL; + volatile uint32_t *oensel = NULL; + + if (altfunc >= GPIO_ALTFUNC_MAX) { + /* If no altfunction is selected, then nothing to do. + * This is possible during init and we do not + * want to change the reset values set by the HW + */ + return; + } + + switch (altfunc) { + case GPIO_MAIN_FUNC: + insel = &scc_regs->iomux_main_insel; + outsel = &scc_regs->iomux_main_outsel; + oensel = &scc_regs->iomux_main_oensel; + altfunc_to_clear = GPIO_MAIN_FUNC_NEG_MASK; + break; + + case GPIO_ALTFUNC_1: + insel = &scc_regs->iomux_altf1_insel; + outsel = &scc_regs->iomux_altf1_outsel; + oensel = &scc_regs->iomux_altf1_oensel; + altfunc_to_clear = GPIO_ALTFUNC_1_NEG_MASK; + break; + + case GPIO_ALTFUNC_2: + insel = &scc_regs->iomux_altf2_insel; + outsel = &scc_regs->iomux_altf2_outsel; + oensel = &scc_regs->iomux_altf2_oensel; + altfunc_to_clear = GPIO_ALTFUNC_2_NEG_MASK; + break; + default: + break; + } + + /* Select the wanted function's output enable bit first. + * This way the output won't be disabled which is desired + * if we switch from output to output function + */ + *oensel |= pin_mask; + + /* Clear all alternate function registers which are not selected */ + scc_clear_alt_func(scc_regs, altfunc_to_clear, pin_mask); + + /* Enable input and output data line */ + *insel |= pin_mask; + *outsel |= pin_mask; +} + +void musca_s1_scc_set_pinmode(struct musca_s1_scc_dev_t* dev, uint32_t pin_mask, + enum pinmode_select_t mode) +{ + struct musca_s1_scc_reg_map_t* scc_regs = + (struct musca_s1_scc_reg_map_t*) dev->cfg->base; + + switch (mode) { + case PINMODE_NONE: + scc_regs->iopad_pe &= ~pin_mask; + break; + case PINMODE_PULL_DOWN: + /* If the pull select bit is set to 0 it means pull down */ + scc_regs->iopad_ps &= ~pin_mask; + scc_regs->iopad_pe |= pin_mask; + break; + case PINMODE_PULL_UP: + /* If the pull select bit is set to 1 it means pull up */ + scc_regs->iopad_ps |= pin_mask; + scc_regs->iopad_pe |= pin_mask; + break; + default: + break; + } +} + +void musca_s1_scc_set_default_in(struct musca_s1_scc_dev_t* dev, + enum gpio_altfunc_t altfunc, + uint32_t default_in_mask, + uint32_t default_in_value) +{ + struct musca_s1_scc_reg_map_t* scc_regs = + (struct musca_s1_scc_reg_map_t*) dev->cfg->base; + uint32_t iomux_value = 0; + + if (altfunc >= GPIO_ALTFUNC_MAX) { + /* If no altfunction is selected, then nothing to do */ + return; + } + + switch (altfunc) { + case GPIO_MAIN_FUNC: + iomux_value = scc_regs->iomux_main_default_in & ~default_in_mask; + iomux_value |= (default_in_value & default_in_mask); + scc_regs->iomux_main_default_in = iomux_value; + scc_regs->iomux_main_insel = + (scc_regs->iomux_main_insel & ~default_in_mask); + break; + + case GPIO_ALTFUNC_1: + iomux_value = scc_regs->iomux_altf1_default_in & ~default_in_mask; + iomux_value |= (default_in_value & default_in_mask); + scc_regs->iomux_altf1_default_in = iomux_value; + scc_regs->iomux_altf1_insel = + (scc_regs->iomux_altf1_insel & ~default_in_mask); + break; + + case GPIO_ALTFUNC_2: + iomux_value = scc_regs->iomux_altf2_default_in & ~default_in_mask; + iomux_value |= (default_in_value & default_in_mask); + scc_regs->iomux_altf2_default_in = iomux_value; + scc_regs->iomux_altf2_insel = + (scc_regs->iomux_altf2_insel & ~default_in_mask); + break; + default: + break; + } +} + +void musca_s1_scc_mram_fast_read_enable(struct musca_s1_scc_dev_t* dev) +{ + struct musca_s1_scc_reg_map_t* scc_regs = + (struct musca_s1_scc_reg_map_t*) dev->cfg->base; + __DSB(); + SET_BIT(scc_regs->scc_mram_ctrl0, SCC_MRAM_CTRL0_FAST_READ_EN); + __DSB(); + __ISB(); +} + +void musca_s1_scc_mram_fast_read_disable(struct musca_s1_scc_dev_t* dev) +{ + struct musca_s1_scc_reg_map_t* scc_regs = + (struct musca_s1_scc_reg_map_t*) dev->cfg->base; + __DSB(); + CLR_BIT(scc_regs->scc_mram_ctrl0, SCC_MRAM_CTRL0_FAST_READ_EN); + __DSB(); + __ISB(); +} + +bool musca_s1_scc_mram_is_fast_read_enabled(struct musca_s1_scc_dev_t* dev) +{ + struct musca_s1_scc_reg_map_t* scc_regs = + (struct musca_s1_scc_reg_map_t*) dev->cfg->base; + return (bool)(scc_regs->scc_mram_ctrl0 & + (1u << SCC_MRAM_CTRL0_FAST_READ_EN)); +} \ No newline at end of file diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/musca_s1_scc_drv.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/musca_s1_scc_drv.h new file mode 100644 index 00000000000..63694e6e63b --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/musca_s1_scc_drv.h @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2017-2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef __MUSCA_S1_SCC_DRV_H__ +#define __MUSCA_S1_SCC_DRV_H__ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * \brief Enum to store alternate function values. + * They are used as shift operand, must be unsigned. + */ +enum gpio_altfunc_t { + GPIO_MAIN_FUNC = 0UL, + GPIO_ALTFUNC_1, + GPIO_ALTFUNC_2, + GPIO_ALTFUNC_MAX +}; + +#define GPIO_ALTFUNC_ALL_MASK ((1U << GPIO_ALTFUNC_MAX) - 1) + +/** +* \brief Enum to store alternate function mask values. +*/ +enum gpio_altfunc_mask_t { + GPIO_ALTFUNC_NONE = 0, + GPIO_MAIN_FUNC_MASK = (1UL << GPIO_MAIN_FUNC), + GPIO_ALTFUNC_1_MASK = (1UL << GPIO_ALTFUNC_1), + GPIO_ALTFUNC_2_MASK = (1UL << GPIO_ALTFUNC_2), + GPIO_MAIN_FUNC_NEG_MASK = (~GPIO_MAIN_FUNC_MASK & GPIO_ALTFUNC_ALL_MASK), + GPIO_ALTFUNC_1_NEG_MASK = (~GPIO_ALTFUNC_1_MASK & GPIO_ALTFUNC_ALL_MASK), + GPIO_ALTFUNC_2_NEG_MASK = (~GPIO_ALTFUNC_2_MASK & GPIO_ALTFUNC_ALL_MASK) +}; + +enum pinmode_select_t { + PINMODE_NONE, + PINMODE_PULL_DOWN, + PINMODE_PULL_UP +}; + +/* MUSCA SCC device configuration structure */ +struct musca_s1_scc_dev_cfg_t { + const uint32_t base; /*!< SCC base address */ +}; + +/* MUSCA SCC device structure */ +struct musca_s1_scc_dev_t { + const struct musca_s1_scc_dev_cfg_t* const cfg; /*!< SCC configuration */ +}; + +/** + * \brief Sets selected alternate functions for selected pins + * + * \param[in] dev SCC device pointer \ref musca_s1_scc_dev_t + * \param[in] altfunc Alternate function to set \ref gpio_altfunc_t + * \param[in] pin_mask Pin mask for the alternate functions + * + * \note This function doesn't check if scc dev is NULL. + * \note If no alternate function is selected, the function won't do anything + */ +void musca_s1_scc_set_alt_func(struct musca_s1_scc_dev_t* dev, + enum gpio_altfunc_t altfunc, uint32_t pin_mask); + +/** + * \brief Sets pinmode for the given pins + * + * \param[in] dev SCC device pointer \ref musca_s1_scc_dev_t + * \param[in] pin_mask Pin mask for the alternate functions + * \param[in] mode Pin mode to set \ref pinmode_select_t + * + * \note This function doesn't check if scc dev is NULL. + */ +void musca_s1_scc_set_pinmode(struct musca_s1_scc_dev_t* dev, uint32_t pin_mask, + enum pinmode_select_t mode); + +/** + * \brief Sets default input values for the selected pins + * + * \param[in] dev SCC device pointer \ref musca_s1_scc_dev_t + * \param[in] altfunc The selected alternate function that is set the + * specified default in value \ref gpio_altfunc_t + * \param[in] default_in_mask Pin mask for selecting pins + * \param[in] default_in_value Pin values for the selected pins + * + * \note This function doesn't check if scc_base is NULL. + * \note If no alternate function is selected, the function won't do anything + */ +void musca_s1_scc_set_default_in(struct musca_s1_scc_dev_t* dev, + enum gpio_altfunc_t altfunc, + uint32_t default_in_mask, + uint32_t default_in_value); + +/** + * \brief Enables eMRAM fast read + * + */ +void musca_s1_scc_mram_fast_read_enable(struct musca_s1_scc_dev_t* dev); + +/** + * \brief Disables eMRAM fast read + * + */ +void musca_s1_scc_mram_fast_read_disable(struct musca_s1_scc_dev_t* dev); + +/** + * \brief Check if eMRAM fast read is enabled + * + * \return Returns bool, true if fast read is enabled, false otherwise + */ +bool musca_s1_scc_mram_is_fast_read_enabled(struct musca_s1_scc_dev_t* dev); + +#ifdef __cplusplus +} +#endif + +#endif /* __MUSCA_S1_SCC_DRV_H__ */ diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/qspi_ip6514e_drv.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/qspi_ip6514e_drv.c new file mode 100644 index 00000000000..2c1b42798dd --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/qspi_ip6514e_drv.c @@ -0,0 +1,757 @@ +/* + * Copyright (c) 2018-2019 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +/* Use memcpy */ +#include + +#include "qspi_ip6514e_drv.h" + +/** Setter bit manipulation macro */ +#define SET_BIT(WORD, BIT_INDEX) ((WORD) |= (1U << (BIT_INDEX))) +/** Clearing bit manipulation macro */ +#define CLR_BIT(WORD, BIT_INDEX) ((WORD) &= ~(1U << (BIT_INDEX))) +/** Getter bit manipulation macro */ +#define GET_BIT(WORD, BIT_INDEX) (bool)(((WORD) & (1U << (BIT_INDEX)))) + +#define WORD_ALIGN_4B_MASK 0x3U /* Mask the first 2 bits */ +#define IS_ADDR_ALIGNED(ADDR) (((uint32_t)(ADDR) & (WORD_ALIGN_4B_MASK)) == 0U) + +#define BITS_PER_BYTE 8U +#define BITS_PER_WORD 32U + +#define CFG_READS true +#define CFG_WRITES false + +#define ARG_NOT_USED 0 +#define ARG_PTR_NOT_USED NULL + +#define DATA_REG_NUMBER 2U +#define DATA_REG_LOWER 0U +#define DATA_REG_UPPER 1U + +#define ERROR_VALUE 0xFFFFFFFFU + +/** + * \brief QSPI IP6514E register map structure + */ +struct _qspi_ip6514e_reg_map_t { + volatile uint32_t qspi_cfg; /*!< 0x00 (R/W) */ + volatile uint32_t device_read_inst; /*!< 0x04 (R/W) */ + volatile uint32_t device_write_inst; /*!< 0x08 (R/W) */ + volatile uint32_t hidden1[2]; + volatile uint32_t device_size; /*!< 0x14 (R/W) */ + volatile uint32_t hidden2[3]; + volatile uint32_t remap_addr; /*!< 0x24 (R/W) */ + volatile uint32_t hidden3[26]; + volatile uint32_t flash_cmd_ctrl; /*!< 0x90 (R/W) */ + volatile uint32_t flash_cmd_addr; /*!< 0x94 (R/W) */ + volatile uint32_t hidden4[2]; + volatile uint32_t flash_cmd_read_data_lower; /*!< 0xA0 (R/ ) */ + volatile uint32_t flash_cmd_read_data_upper; /*!< 0xA4 (R/ ) */ + volatile uint32_t flash_cmd_write_data_lower; /*!< 0xA8 (R/W) */ + volatile uint32_t flash_cmd_write_data_upper; /*!< 0xAC (R/W) */ + volatile uint32_t hidden5[2]; +}; + +/** QSPI Configuration register description (offset 0x00) */ +#define QSPI_CFG_ENABLE_POS 0U +#define QSPI_CFG_ENABLE_ADDR_REMAP_POS 16U +#define QSPI_CFG_BAUD_DIV_POS 19U + #define QSPI_CFG_BAUD_DIV_MIN 2U + #define QSPI_CFG_BAUD_DIV_MAX 32U + #define QSPI_CFG_BAUD_DIV_BITS 4U +#define QSPI_CFG_IDLE_POS 31U + +/** + * Device Read/Write Instruction registers description (offset 0x04 and 0x08). + * These values are the same for the Device Read Instruction register at offset + * 0x04 and the Device Write Instruction register at offset 0x08. + */ +#define DEVICE_READ_WRITE_INST_OPCODE_POS 0U +#define DEVICE_READ_INST_INST_TYPE_POS 8U /* Only applies to the Read + * register. */ +#define DEVICE_READ_WRITE_INST_ADDR_TYPE_POS 12U +#define DEVICE_READ_WRITE_INST_DATA_TYPE_POS 16U + #define DEVICE_READ_WRITE_INST_MODE_QSPI 2U + #define DEVICE_READ_WRITE_INST_MODE_DSPI 1U + #define DEVICE_READ_WRITE_INST_MODE_SPI 0U + #define DEVICE_READ_WRITE_INST_MODE_BITS 2U +#define DEVICE_READ_WRITE_INST_DUMMY_CYCLES_POS 24U + #define DEVICE_READ_WRITE_INST_DUMMY_CYCLES_BITS 5U + #define DEVICE_READ_WRITE_INST_DUMMY_CYCLES_MAX 31U + +/** Device Size Configuration register description (offset 0x14) */ +#define DEVICE_SIZE_ADDR_BYTES_POS 0U + #define DEVICE_SIZE_ADDR_BYTES_MIN 1U + #define DEVICE_SIZE_ADDR_BYTES_MAX 16U + #define DEVICE_SIZE_ADDR_BYTES_BITS 4U +#define DEVICE_SIZE_PAGE_BYTES_POS 4U + #define DEVICE_SIZE_PAGE_BYTES_MAX 4095U + #define DEVICE_SIZE_PAGE_BYTES_BITS 12U + +/** Flash Command Control register description (offset 0x90) */ +#define FLASH_CMD_CTRL_EXECUTE_POS 0U +#define FLASH_CMD_CTRL_BUSY_POS 1U +#define FLASH_CMD_CTRL_DUMMY_CYCLES_POS 7U + #define FLASH_CMD_CTRL_DUMMY_CYCLES_MAX 31U + #define FLASH_CMD_CTRL_DUMMY_CYCLES_BITS 5U +#define FLASH_CMD_CTRL_WRITE_BYTES_POS 12U + #define FLASH_CMD_CTRL_WRITE_BYTES_MAX 8U + #define FLASH_CMD_CTRL_WRITE_BYTES_BITS 3U +#define FLASH_CMD_CTRL_WRITE_ENABLE_POS 15U +#define FLASH_CMD_CTRL_ADDR_BYTES_POS 16U + #define FLASH_CMD_CTRL_ADDR_BYTES_MAX 4U + #define FLASH_CMD_CTRL_ADDR_BYTES_BITS 2U +#define FLASH_CMD_CTRL_ADDR_ENABLE_POS 19U +#define FLASH_CMD_CTRL_READ_BYTES_POS 20U + #define FLASH_CMD_CTRL_READ_BYTES_MAX 8U + #define FLASH_CMD_CTRL_READ_BYTES_BITS 3U +#define FLASH_CMD_CTRL_READ_ENABLE_POS 23U +#define FLASH_CMD_CTRL_OPCODE_POS 24U + +/** Default register values of the QSPI Flash controller */ +#define QSPI_CFG_REG_RESET_VALUE (0x80080080U) +#define DEVICE_READ_INSTR_REG_RESET_VALUE (0x080220EBU) +#define DEVICE_WRITE_INSTR_REG_RESET_VALUE (0x00000002U) +#define DEVICE_SIZE_CFG_REG_RESET_VALUE (0x00101002U) +#define REMAP_ADDR_REG_RESET_VALUE (0x00000000U) +#define FLASH_CMD_CONTROL_REG_RESET_VALUE (0x00000000U) +#define FLASH_CMD_ADDRESS_REG_RESET_VALUE (0x00000000U) +#define FLASH_CMD_WRITE_DATA_REG_RESET_VALUE (0x00000000U) + +/** + * \brief Change specific bits in a 32 bits word. + * + * \param[in,out] word Pointer of the word to change + * \param[in] bits bits_length bits to put at bits_pos in the word + * pointed + * \param[in] bits_length Number of bits to change + * \param[in] bits_pos Position of the bits to change + * + * \note This function will do nothing if the parameters given are incorret: + * * word is NULL + * * bits_length + bits_pos > 32 + * * bits_length is 0 + */ +static void change_bits_in_word(volatile uint32_t *word, + uint32_t bits, + uint32_t bits_length, + uint32_t bits_pos) +{ + uint32_t mask; + + if ((word == NULL) || + ((bits_length + bits_pos) > BITS_PER_WORD) || + (bits_length == 0U)) { + /* Silently fail */ + return; + } + + /* Change all the bits */ + if (bits_length == BITS_PER_WORD) { + *word = bits; + return; + } + + mask = ((1U << bits_length) - 1); + /* + * We change the bits in three steps: + * - clear bits_length bits with zeroes at bits_pos in the word + * - mask bits in case it contains more than bits_length bits + * - set the new bits in the cleared word + * Because the data pointed by word is only read once, the data will still + * be coherent after an interruption that changes it. + */ + *word = ((*word & ~(mask << bits_pos)) | ((bits & mask) << bits_pos)); +} + +/** + * \brief Configure reads or writes commands for direct operations. + * + * \param[in] dev QSPI IP6514E device struct \ref qspi_ip6514e_dev_t + * \param[in] opcode Read/write opcode that will be used for every + * direct read/write + * \param[in] dummy_cycles Number of dummy cycles to wait before triggering + * the command, this value must be between 0 and 31 + * (both included) + * \param[in] is_reads_cfg true to configure direct reads, false to configure + * direct writes + * + * \return Returns error code as specified in \ref qspi_ip6514e_error_t + * + * \note The QSPI controller should be idle before calling this function. + */ +static enum qspi_ip6514e_error_t qspi_ip6514e_cfg_reads_writes( + struct qspi_ip6514e_dev_t* dev, + uint8_t opcode, + uint32_t dummy_cycles, + bool is_reads_cfg) +{ + struct _qspi_ip6514e_reg_map_t *reg_map = + (struct _qspi_ip6514e_reg_map_t *)dev->cfg->base; + /* + * Select the good register address if we want to configure reads or writes. + */ + volatile uint32_t *device_read_write_inst_reg = is_reads_cfg ? + &(reg_map->device_read_inst) : + &(reg_map->device_write_inst); + uint32_t device_read_write_inst_reg_copy = *device_read_write_inst_reg; + + /* + * Wait for the Serial Interface and QSPI pipeline to be IDLE when + * all low level synchronization has been done. + */ + while(!qspi_ip6514e_is_idle(dev)); + + if (dummy_cycles > DEVICE_READ_WRITE_INST_DUMMY_CYCLES_MAX) { + return QSPI_IP6514E_ERR_WRONG_ARGUMENT; + } + + change_bits_in_word(&device_read_write_inst_reg_copy, + (uint32_t)opcode, + BITS_PER_BYTE, + DEVICE_READ_WRITE_INST_OPCODE_POS); + change_bits_in_word(&device_read_write_inst_reg_copy, + dummy_cycles, + DEVICE_READ_WRITE_INST_DUMMY_CYCLES_BITS, + DEVICE_READ_WRITE_INST_DUMMY_CYCLES_POS); + + *device_read_write_inst_reg = device_read_write_inst_reg_copy; + + return QSPI_IP6514E_ERR_NONE; +} + +/** + * \brief Given the public SPI mode enumeration, returns the private value it + * maps to in the register field. + * + * \param[in] spi_mode Read/write opcode that will be used for every direct + * read/write + * + * \return Return the correct DEVICE_READ_WRITE_INST_MODE value. + */ +static uint32_t spi_mode_field_value(enum qspi_ip6514e_spi_mode_t spi_mode) +{ + switch (spi_mode) { + case QSPI_IP6514E_SPI_MODE: + return DEVICE_READ_WRITE_INST_MODE_SPI; + case QSPI_IP6514E_DSPI_MODE: + return DEVICE_READ_WRITE_INST_MODE_DSPI; + case QSPI_IP6514E_QSPI_MODE: + return DEVICE_READ_WRITE_INST_MODE_QSPI; + default: + return ERROR_VALUE; + } +} + +bool qspi_ip6514e_is_idle(struct qspi_ip6514e_dev_t* dev) +{ + struct _qspi_ip6514e_reg_map_t *reg_map = + (struct _qspi_ip6514e_reg_map_t *)dev->cfg->base; + + return GET_BIT(reg_map->qspi_cfg, QSPI_CFG_IDLE_POS); +} + +bool qspi_ip6514e_is_enabled(struct qspi_ip6514e_dev_t* dev) +{ + struct _qspi_ip6514e_reg_map_t *reg_map = + (struct _qspi_ip6514e_reg_map_t *)dev->cfg->base; + + return GET_BIT(reg_map->qspi_cfg, QSPI_CFG_ENABLE_POS); +} + +void qspi_ip6514e_disable(struct qspi_ip6514e_dev_t* dev) +{ + struct _qspi_ip6514e_reg_map_t *reg_map = + (struct _qspi_ip6514e_reg_map_t *)dev->cfg->base; + + CLR_BIT(reg_map->qspi_cfg, QSPI_CFG_ENABLE_POS); +} + +void qspi_ip6514e_enable(struct qspi_ip6514e_dev_t* dev) +{ + struct _qspi_ip6514e_reg_map_t *reg_map = + (struct _qspi_ip6514e_reg_map_t *)dev->cfg->base; + + SET_BIT(reg_map->qspi_cfg, QSPI_CFG_ENABLE_POS); +} + +enum qspi_ip6514e_error_t qspi_ip6514e_set_baud_rate_div( + struct qspi_ip6514e_dev_t* dev, + uint32_t div) +{ + struct _qspi_ip6514e_reg_map_t *reg_map = + (struct _qspi_ip6514e_reg_map_t *)dev->cfg->base; + + /* + * Wait for the Serial Interface and QSPI pipeline to be IDLE when + * all low level synchronization has been done. + */ + while(!qspi_ip6514e_is_idle(dev)); + + /* div should be an even number. */ + if (((div & 1U) == 1) || + (div < QSPI_CFG_BAUD_DIV_MIN) || + (div > QSPI_CFG_BAUD_DIV_MAX)) { + return QSPI_IP6514E_ERR_WRONG_ARGUMENT; + } + + /* + * The div value (between 2 and 32) needs to be stored in the register on a + * 4 bits field. + */ + change_bits_in_word(&(reg_map->qspi_cfg), + (div / 2) - 1, + QSPI_CFG_BAUD_DIV_BITS, + QSPI_CFG_BAUD_DIV_POS); + + return QSPI_IP6514E_ERR_NONE; +} + +enum qspi_ip6514e_error_t qspi_ip6514e_set_spi_mode( + struct qspi_ip6514e_dev_t* dev, + enum qspi_ip6514e_spi_mode_t inst_type, + enum qspi_ip6514e_spi_mode_t addr_type, + enum qspi_ip6514e_spi_mode_t data_type) +{ + struct _qspi_ip6514e_reg_map_t *reg_map = + (struct _qspi_ip6514e_reg_map_t *)dev->cfg->base; + uint32_t inst_spi_mode, addr_spi_mode, data_spi_mode; + /* + * A local copy of the Device Read Instruction and Device Write Instruction + * registers is used to limit APB accesses. + */ + uint32_t device_read_inst_cpy = reg_map->device_read_inst; + uint32_t device_write_inst_cpy = reg_map->device_write_inst; + + /* + * Wait for the Serial Interface and QSPI pipeline to be IDLE when + * all low level synchronization has been done. + */ + while(!qspi_ip6514e_is_idle(dev)); + + /* + * First check that the instruction mode is not SPI. If that is the case, + * the address and data mode register fields become DO NOT CARE. + */ + inst_spi_mode = spi_mode_field_value(inst_type); + if (inst_spi_mode == ERROR_VALUE) { + return QSPI_IP6514E_ERR_WRONG_ARGUMENT; + } + if (inst_type != QSPI_IP6514E_SPI_MODE) { + change_bits_in_word(&(reg_map->device_read_inst), + inst_spi_mode, + DEVICE_READ_WRITE_INST_MODE_BITS, + DEVICE_READ_INST_INST_TYPE_POS); + return QSPI_IP6514E_ERR_NONE; + } + + /* Now check and set address and data modes. */ + addr_spi_mode = spi_mode_field_value(addr_type); + data_spi_mode = spi_mode_field_value(data_type); + if ((addr_spi_mode == ERROR_VALUE) || (data_spi_mode == ERROR_VALUE)) { + return QSPI_IP6514E_ERR_WRONG_ARGUMENT; + } + + /* Change the Device Read Instruction register. */ + change_bits_in_word(&device_read_inst_cpy, + inst_spi_mode, + DEVICE_READ_WRITE_INST_MODE_BITS, + DEVICE_READ_INST_INST_TYPE_POS); + change_bits_in_word(&device_read_inst_cpy, + addr_spi_mode, + DEVICE_READ_WRITE_INST_MODE_BITS, + DEVICE_READ_WRITE_INST_ADDR_TYPE_POS); + change_bits_in_word(&device_read_inst_cpy, + data_spi_mode, + DEVICE_READ_WRITE_INST_MODE_BITS, + DEVICE_READ_WRITE_INST_DATA_TYPE_POS); + + /* Change the Device Write Instruction register. */ + change_bits_in_word(&device_write_inst_cpy, + addr_spi_mode, + DEVICE_READ_WRITE_INST_MODE_BITS, + DEVICE_READ_WRITE_INST_ADDR_TYPE_POS); + change_bits_in_word(&device_write_inst_cpy, + data_spi_mode, + DEVICE_READ_WRITE_INST_MODE_BITS, + DEVICE_READ_WRITE_INST_DATA_TYPE_POS); + + /* Save the changes. */ + reg_map->device_read_inst = device_read_inst_cpy; + reg_map->device_write_inst = device_write_inst_cpy; + + return QSPI_IP6514E_ERR_NONE; +} + +enum qspi_ip6514e_error_t qspi_ip6514e_cfg_reads(struct qspi_ip6514e_dev_t* dev, + uint8_t opcode, + uint32_t dummy_cycles) +{ + return qspi_ip6514e_cfg_reads_writes(dev, opcode, dummy_cycles, CFG_READS); +} + +enum qspi_ip6514e_error_t qspi_ip6514e_cfg_writes( + struct qspi_ip6514e_dev_t* dev, + uint8_t opcode, + uint32_t dummy_cycles) +{ + return qspi_ip6514e_cfg_reads_writes(dev, opcode, dummy_cycles, CFG_WRITES); +} + +enum qspi_ip6514e_error_t qspi_ip6514e_cfg_page_size( + struct qspi_ip6514e_dev_t* dev, + uint32_t page_size) +{ + struct _qspi_ip6514e_reg_map_t *reg_map = + (struct _qspi_ip6514e_reg_map_t *)dev->cfg->base; + + /* + * Wait for the Serial Interface and QSPI pipeline to be IDLE when + * all low level synchronization has been done. + */ + while(!qspi_ip6514e_is_idle(dev)); + + if (page_size > DEVICE_SIZE_PAGE_BYTES_MAX) { + return QSPI_IP6514E_ERR_WRONG_ARGUMENT; + } + + change_bits_in_word(&(reg_map->device_size), + page_size, + DEVICE_SIZE_PAGE_BYTES_BITS, + DEVICE_SIZE_PAGE_BYTES_POS); + + return QSPI_IP6514E_ERR_NONE; +} + +enum qspi_ip6514e_error_t qspi_ip6514e_cfg_addr_bytes( + struct qspi_ip6514e_dev_t* dev, + uint32_t bytes_number) +{ + struct _qspi_ip6514e_reg_map_t *reg_map = + (struct _qspi_ip6514e_reg_map_t *)dev->cfg->base; + + /* + * Wait for the Serial Interface and QSPI pipeline to be IDLE when + * all low level synchronization has been done. + */ + while(!qspi_ip6514e_is_idle(dev)); + + if (bytes_number < DEVICE_SIZE_ADDR_BYTES_MIN || + bytes_number > DEVICE_SIZE_ADDR_BYTES_MAX) { + return QSPI_IP6514E_ERR_WRONG_ARGUMENT; + } + + change_bits_in_word(&(reg_map->device_size), + bytes_number - 1, + DEVICE_SIZE_ADDR_BYTES_BITS, + DEVICE_SIZE_ADDR_BYTES_POS); + + + return QSPI_IP6514E_ERR_NONE; +} + +void qspi_ip6514e_remap_addr(struct qspi_ip6514e_dev_t* dev, uint32_t offset) +{ + struct _qspi_ip6514e_reg_map_t *reg_map = + (struct _qspi_ip6514e_reg_map_t *)dev->cfg->base; + /* Save the enable state to restore it after. */ + bool is_enabled = qspi_ip6514e_is_enabled(dev); + + if (is_enabled) { + qspi_ip6514e_disable(dev); + } + + reg_map->remap_addr = offset; + SET_BIT(reg_map->qspi_cfg, QSPI_CFG_ENABLE_ADDR_REMAP_POS); + + if (is_enabled) { + qspi_ip6514e_enable(dev); + } +} + +void qspi_ip6514e_disable_remap(struct qspi_ip6514e_dev_t* dev) +{ + struct _qspi_ip6514e_reg_map_t *reg_map = + (struct _qspi_ip6514e_reg_map_t *)dev->cfg->base; + /* Save the enable state to restore it after. */ + bool is_enabled = qspi_ip6514e_is_enabled(dev); + + if (is_enabled) { + qspi_ip6514e_disable(dev); + } + + CLR_BIT(reg_map->qspi_cfg, QSPI_CFG_ENABLE_ADDR_REMAP_POS); + + if (is_enabled) { + qspi_ip6514e_enable(dev); + } +} + +void qspi_ip6514e_reset_regs(struct qspi_ip6514e_dev_t* dev) +{ + struct _qspi_ip6514e_reg_map_t *reg_map = + (struct _qspi_ip6514e_reg_map_t *)dev->cfg->base; + + /* Restore the default value of the QSPI Configuration register. */ + reg_map->qspi_cfg = QSPI_CFG_REG_RESET_VALUE; + + /* Restore the default value of the Device R/W Instruction registers. */ + reg_map->device_read_inst = DEVICE_READ_INSTR_REG_RESET_VALUE; + reg_map->device_write_inst = DEVICE_WRITE_INSTR_REG_RESET_VALUE; + + /* Restore the default value of the Device Size Configuration register. */ + reg_map->device_size = DEVICE_SIZE_CFG_REG_RESET_VALUE; + + /* Restore the default value of the Remap Address register. */ + reg_map->remap_addr = REMAP_ADDR_REG_RESET_VALUE; + + /* Restore the default value of the Flash Command Control register. */ + reg_map->flash_cmd_ctrl = FLASH_CMD_CONTROL_REG_RESET_VALUE; + /* Restore the default value of the Flash Command Address register. */ + reg_map->flash_cmd_addr = FLASH_CMD_ADDRESS_REG_RESET_VALUE; + + /* Restore the default value of the Flash Command Write Data registers. */ + reg_map->flash_cmd_write_data_lower = FLASH_CMD_WRITE_DATA_REG_RESET_VALUE; + reg_map->flash_cmd_write_data_upper = FLASH_CMD_WRITE_DATA_REG_RESET_VALUE; + + /* + * This function does not affect the Flash Command Read Data registers + * which are completely Read-Only. + */ +} + +enum qspi_ip6514e_error_t qspi_ip6514e_send_cmd(struct qspi_ip6514e_dev_t* dev, + uint8_t opcode, + void *read_data, + uint32_t read_len, + const void *write_data, + uint32_t write_len, + uint32_t addr, + uint32_t addr_bytes_number, + uint32_t dummy_cycles) +{ + struct _qspi_ip6514e_reg_map_t *reg_map = + (struct _qspi_ip6514e_reg_map_t *)dev->cfg->base; + /* To limit APB accesses, we set this reg up locally before */ + uint32_t flash_cmd_ctrl = 0U; + bool read_requested = ((read_data != NULL) && (read_len != 0)); + bool write_requested = ((write_data != NULL) && (write_len != 0)); + bool addr_requested = (addr_bytes_number != 0); + /* + * To prevent unaligned and byte or halfbyte accesses to the APB registers, + * a word aligned buffer is used to temporary transfer the data before doing + * word accesses on these registers from that buffer. + */ + uint32_t data_regs[DATA_REG_NUMBER] = {0}; + + if (read_len > FLASH_CMD_CTRL_READ_BYTES_MAX) { + return QSPI_IP6514E_ERR_WRONG_ARGUMENT; + } + + if (write_len > FLASH_CMD_CTRL_WRITE_BYTES_MAX) { + return QSPI_IP6514E_ERR_WRONG_ARGUMENT; + } + + if (addr_bytes_number > FLASH_CMD_CTRL_ADDR_BYTES_MAX) { + return QSPI_IP6514E_ERR_WRONG_ARGUMENT; + } + + if (dummy_cycles > FLASH_CMD_CTRL_DUMMY_CYCLES_MAX) { + return QSPI_IP6514E_ERR_WRONG_ARGUMENT; + } + + if (read_requested && write_requested) { + return QSPI_IP6514E_ERR_WRONG_ARGUMENT; + } + + change_bits_in_word(&flash_cmd_ctrl, + (uint32_t)opcode, + BITS_PER_BYTE, + FLASH_CMD_CTRL_OPCODE_POS); + + /* Enable read if requested */ + if (read_requested) { + SET_BIT(flash_cmd_ctrl, FLASH_CMD_CTRL_READ_ENABLE_POS); + change_bits_in_word(&flash_cmd_ctrl, + read_len - 1, + FLASH_CMD_CTRL_READ_BYTES_BITS, + FLASH_CMD_CTRL_READ_BYTES_POS); + } + + /* Enable write if requested */ + if (write_requested) { + SET_BIT(flash_cmd_ctrl, FLASH_CMD_CTRL_WRITE_ENABLE_POS); + change_bits_in_word(&flash_cmd_ctrl, + write_len - 1, + FLASH_CMD_CTRL_WRITE_BYTES_BITS, + FLASH_CMD_CTRL_WRITE_BYTES_POS); + + if (IS_ADDR_ALIGNED(write_data) && IS_ADDR_ALIGNED(write_len)) { + /* + * Optimised case when write_data is word aligned and write_len is + * 4 or 8. + */ + reg_map->flash_cmd_write_data_lower = *(uint32_t *)write_data; + if (write_len == FLASH_CMD_CTRL_WRITE_BYTES_MAX) { + reg_map->flash_cmd_write_data_upper = + *((uint32_t *)write_data + 1); + } + } else { + /* + * data_regs is used as a buffer to only do unaligned access on the + * AHB bus and word aligned accesses to the APB registers. + */ + memcpy((void *)data_regs, write_data, write_len); + /* + * Only write_len bytes will be written even if both data registers + * are written. + */ + reg_map->flash_cmd_write_data_lower = data_regs[DATA_REG_LOWER]; + reg_map->flash_cmd_write_data_upper = data_regs[DATA_REG_UPPER]; + } + } + + /* Enable the address if requested */ + if (addr_requested) { + SET_BIT(flash_cmd_ctrl, FLASH_CMD_CTRL_ADDR_ENABLE_POS); + reg_map->flash_cmd_addr = addr; + change_bits_in_word(&flash_cmd_ctrl, + addr_bytes_number - 1, + FLASH_CMD_CTRL_ADDR_BYTES_BITS, + FLASH_CMD_CTRL_ADDR_BYTES_POS); + } + + /* Put dummy cycles number */ + change_bits_in_word(&flash_cmd_ctrl, + dummy_cycles, + FLASH_CMD_CTRL_DUMMY_CYCLES_BITS, + FLASH_CMD_CTRL_DUMMY_CYCLES_POS); + + /* Copy the Flash Command Control register and execute the command */ + reg_map->flash_cmd_ctrl = flash_cmd_ctrl; + SET_BIT(reg_map->flash_cmd_ctrl, FLASH_CMD_CTRL_EXECUTE_POS); + + /* Wait for termination */ + while (GET_BIT(reg_map->flash_cmd_ctrl, FLASH_CMD_CTRL_BUSY_POS)); + + /* + * Recolt the read data if it was requested. read_len validity has already + * been verified at this point. + */ + if (read_requested) { + if (IS_ADDR_ALIGNED(read_data) && IS_ADDR_ALIGNED(read_len)) { + /* + * Optimised case when read_data is word aligned and read_len is + * 4 or 8. + */ + *(uint32_t *)read_data = reg_map->flash_cmd_read_data_lower; + if (read_len == FLASH_CMD_CTRL_READ_BYTES_MAX) { + *((uint32_t *)read_data + 1) = + reg_map->flash_cmd_read_data_upper; + } + } else { + /* + * Only read_len bytes have been written even if both data registers + * are written. + */ + data_regs[DATA_REG_LOWER] = reg_map->flash_cmd_read_data_lower; + data_regs[DATA_REG_UPPER] = reg_map->flash_cmd_read_data_upper; + /* + * data_regs is used as a buffer to only do unaligned access on the + * AHB bus and word aligned accesses to the APB registers. + */ + memcpy(read_data, (void *)data_regs, read_len); + } + } + + return QSPI_IP6514E_ERR_NONE; +} + +void qspi_ip6514e_send_simple_cmd(struct qspi_ip6514e_dev_t* dev, + uint8_t opcode) +{ + /* + * No read/write data, no address, no dummy cycles. + * Given the arguments, this function can not fail. + */ + (void)qspi_ip6514e_send_cmd(dev, + opcode, + ARG_PTR_NOT_USED, + ARG_NOT_USED, + ARG_PTR_NOT_USED, + ARG_NOT_USED, + ARG_NOT_USED, + ARG_NOT_USED, + 0); +} + +enum qspi_ip6514e_error_t qspi_ip6514e_send_read_cmd( + struct qspi_ip6514e_dev_t* dev, + uint8_t opcode, + void *read_data, + uint32_t read_len, + uint32_t addr, + uint32_t addr_bytes_number, + uint32_t dummy_cycles) +{ + /* Read arguments are expected */ + if (read_data == ARG_PTR_NOT_USED || read_len == ARG_NOT_USED) { + return QSPI_IP6514E_ERR_WRONG_ARGUMENT; + } + + /* No write data */ + return qspi_ip6514e_send_cmd(dev, + opcode, + read_data, + read_len, + ARG_PTR_NOT_USED, + ARG_NOT_USED, + addr, + addr_bytes_number, + dummy_cycles); +} + +enum qspi_ip6514e_error_t qspi_ip6514e_send_write_cmd( + struct qspi_ip6514e_dev_t* dev, + uint8_t opcode, + const void *write_data, + uint32_t write_len, + uint32_t addr, + uint32_t addr_bytes_number, + uint32_t dummy_cycles) +{ + /* Write arguments are expected */ + if (write_data == ARG_PTR_NOT_USED || write_len == ARG_NOT_USED) { + return QSPI_IP6514E_ERR_WRONG_ARGUMENT; + } + + /* No read data, no dummy cycles */ + return qspi_ip6514e_send_cmd(dev, + opcode, + ARG_PTR_NOT_USED, + ARG_NOT_USED, + write_data, + write_len, + addr, + addr_bytes_number, + dummy_cycles); +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/qspi_ip6514e_drv.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/qspi_ip6514e_drv.h new file mode 100644 index 00000000000..9dabbb99895 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/qspi_ip6514e_drv.h @@ -0,0 +1,418 @@ +/* + * Copyright (c) 2018 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * \file qspi_ip6514e_drv.h + * \brief Driver for Cadence QSPI Flash Controller IP. + * There are two ways to communicate with the flash memory device: + * - issue AHB requests for direct read and writes in the Flash memory + * mapped address zone. The commands used for those can be configured + * by the driver + * - send a command to the device to access his internal registers and + * do other operations like erasing a sector + * At reset, the QSPI controller will work in a default mode which will + * allow to do basic commands. It should be configured with the + * flash memory device specifications for optimal use for commands and + * direct reads/writes. Here is an example of configuration: + * - send command to activate QSPI mode on the flash memory device + * - send command to change dummy cycles on the flash memory device + * - check if any operation is ungoing + * - disable the QSPI controller + * - change the baud rate divisor + * - activate the QSPI mode on the controller + * - change the dummy cycles number and opcode for reads/writes + * - change the number of bytes per page + * - change the number of address bytes + * - activate the QSPI controller + * + * Warning: none of the functions declared here check if the dev + * argument points to NULL. + */ + +#ifndef __QSPI_IP6514E_DRV_H__ +#define __QSPI_IP6514E_DRV_H__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * \brief Cadence QSPI IP6514E error enumeration types + */ +enum qspi_ip6514e_error_t { + QSPI_IP6514E_ERR_NONE, + QSPI_IP6514E_ERR_WRONG_ARGUMENT, + QSPI_IP6514E_ERR_CONTROLLER_NOT_DISABLED, + QSPI_IP6514E_ERR_READ_IN_PROGRESS, + QSPI_IP6514E_ERR_WRITE_IN_PROGRESS, + /* Any new error should be added to the enumeration type error of + * the corresponding Flash device library as well. + */ +}; + +/** + * \brief Cadence QSPI IP6514E SPI modes + */ +enum qspi_ip6514e_spi_mode_t { + QSPI_IP6514E_SPI_MODE, + /*!< Use 1 line for Instruction, Address and Data */ + QSPI_IP6514E_DSPI_MODE, + /*!< Use 2 lines for Instruction, Address and Data */ + QSPI_IP6514E_QSPI_MODE, + /*!< Use 4 lines for Instruction, Address and Data */ +}; + +/** + * \brief Cadence QSPI IP6514E device configuration structure + */ +struct qspi_ip6514e_dev_cfg_t { + const uint32_t base; /*!< QSPI IP6514E base address */ + /* + * If not all the AHB wires are connected to the QSPI Flash Controller the + * driver can still access all of the Flash memory. The bits of this value + * should be put to 1 for every wire that is connected. Set it to + * 0xFFFFFFFFU if all AHB address wires are connected to the + * QSPI Flash Controller. + */ + uint32_t addr_mask; +}; + +/** + * \brief Cadence QSPI IP6514E device structure + */ +struct qspi_ip6514e_dev_t { + const struct qspi_ip6514e_dev_cfg_t* const cfg; + /*!< QSPI IP6514E configuration */ +}; + +/** + * \brief Check if the controller is idle. + * + * \param[in] dev QSPI IP6514E device struct \ref qspi_ip6514e_dev_t + * + * \return true if the controller is idle, false otherwise. + */ +bool qspi_ip6514e_is_idle(struct qspi_ip6514e_dev_t* dev); + +/** + * \brief Check if the controller is enabled. + * + * \param[in] dev QSPI IP6514E device struct \ref qspi_ip6514e_dev_t + * + * \return true if the controller is enabled, false otherwise. + */ +bool qspi_ip6514e_is_enabled(struct qspi_ip6514e_dev_t* dev); + +/** + * \brief Disable the QSPI controller. + * + * \param[in] dev QSPI IP6514E device struct \ref qspi_ip6514e_dev_t + */ +void qspi_ip6514e_disable(struct qspi_ip6514e_dev_t* dev); + +/** + * \brief Enable the QSPI controller. + * + * \param[in] dev QSPI IP6514E device struct \ref qspi_ip6514e_dev_t + */ +void qspi_ip6514e_enable(struct qspi_ip6514e_dev_t* dev); + +/** + * \brief Change the baud rate divisor. + * + * \param[in] dev QSPI IP6514E device struct \ref qspi_ip6514e_dev_t + * \param[in] div Baud rate divisor value. It can only be an even number + * between 2 and 32 (both included). + * + * \return Returns error code as specified in \ref qspi_ip6514e_error_t + * + * \note The QSPI frequency is calculated dividing the QSPI controller clock by + * this divisor. Please check Flash memory device specifications to know + * the maximal frequency that can be used. + * \note The QSPI controller should be disabled before calling this function. + */ +enum qspi_ip6514e_error_t qspi_ip6514e_set_baud_rate_div( + struct qspi_ip6514e_dev_t* dev, + uint32_t div); + +/** + * \brief Set SPI mode for instruction, address and data. + * + * \param[in] dev QSPI IP6514E device struct \ref qspi_ip6514e_dev_t + * \param[in] inst_type SPI mode to use for the instruction part of the command + * \param[in] addr_type SPI mode to use for the address part of the command + * \param[in] data_type SPI mode to use for the data part of the command + * + * \return Returns error code as specified in \ref qspi_ip6514e_error_t + * + * \note The QSPI controller should be idle before calling this function. + * \note Changing this setting will affect commands and direct operations. + */ +enum qspi_ip6514e_error_t qspi_ip6514e_set_spi_mode( + struct qspi_ip6514e_dev_t* dev, + enum qspi_ip6514e_spi_mode_t inst_type, + enum qspi_ip6514e_spi_mode_t addr_type, + enum qspi_ip6514e_spi_mode_t data_type); + +/** + * \brief Configure read commands for direct reads. + * + * \param[in] dev QSPI IP6514E device struct \ref qspi_ip6514e_dev_t + * \param[in] opcode Read opcode that will be used for every direct read + * \param[in] dummy_cycles Number of dummy cycles to wait before triggering the + * command, this value must be between 0 and 31 + * (both included) + * + * \return Returns error code as specified in \ref qspi_ip6514e_error_t + * + * \note The QSPI controller should be idle before calling this function. + */ +enum qspi_ip6514e_error_t qspi_ip6514e_cfg_reads(struct qspi_ip6514e_dev_t* dev, + uint8_t opcode, + uint32_t dummy_cycles); + +/** + * \brief Configure write commands for direct writes. + * + * \param[in] dev QSPI IP6514E device struct \ref qspi_ip6514e_dev_t + * \param[in] opcode Write opcode that will be used for every direct write + * \param[in] dummy_cycles Number of dummy cycles to wait before triggering the + * command, this value must be between 0 and 31 + * (both included) + * + * \return Returns error code as specified in \ref qspi_ip6514e_error_t + * + * \note The QSPI controller should be idle before calling this function. + */ +enum qspi_ip6514e_error_t qspi_ip6514e_cfg_writes( + struct qspi_ip6514e_dev_t* dev, + uint8_t opcode, + uint32_t dummy_cycles); + +/** + * \brief Change the number of bytes per device page. + * + * \param[in] dev QSPI IP6514E device struct \ref qspi_ip6514e_dev_t + * \param[in] page_size Number of bytes per device page, must be between 0 + * and 4095 (both included) + * + * \return Returns error code as specified in \ref qspi_ip6514e_error_t + * + * \note The QSPI controller should be idle before calling this function. + * \note This function will affect direct reads/writes. + */ +enum qspi_ip6514e_error_t qspi_ip6514e_cfg_page_size( + struct qspi_ip6514e_dev_t* dev, + uint32_t page_size); + +/** + * \brief Change the number of device address bytes. + * + * \param[in] dev QSPI IP6514E device struct \ref qspi_ip6514e_dev_t + * \param[in] bytes_number Number of device address bytes, must be between 1 + * and 16 (both included) + * + * \return Returns error code as specified in \ref qspi_ip6514e_error_t + * + * \note The QSPI controller should be idle before calling this function. + * \note This function will affect direct reads/writes. + */ +enum qspi_ip6514e_error_t qspi_ip6514e_cfg_addr_bytes( + struct qspi_ip6514e_dev_t* dev, + uint32_t bytes_number); + +/** + * \brief Remap the incoming AHB address with an offset for direct accesses. + * + * \param[in] dev QSPI IP6514E device struct \ref qspi_ip6514e_dev_t + * \param[in] offset Offset that will be added to the incoming AHB address to + * access the Flash memory + * + * \note This function will only affect direct reads/writes. + * \note This function does not check if the resulting address is out of memory + * bounds. + */ +void qspi_ip6514e_remap_addr(struct qspi_ip6514e_dev_t* dev, uint32_t offset); + +/** + * \brief Disable AHB address remapping for direct accesses. + * + * \param[in] dev QSPI IP6514E device struct \ref qspi_ip6514e_dev_t + * + * \note This function will disable the controller if it is not already + * disabled and enable it again (if it was). + * \note This function will only affect direct reads/writes. + */ +void qspi_ip6514e_disable_remap(struct qspi_ip6514e_dev_t* dev); + +/** + * \brief Restore the default value of the QSPI controller registers. + * + * \param[in] dev QSPI IP6514E device struct \ref qspi_ip6514e_dev_t + * + * \note The QSPI controller should be disabled before calling this function. + */ +void qspi_ip6514e_reset_regs(struct qspi_ip6514e_dev_t* dev); + +/** + * \brief Send a command to the flash memory device using the Software Triggered + * Instruction Generator (STIG). + * + * \param[in] dev QSPI IP6514E device struct + * \ref qspi_ip6514e_dev_t + * \param[in] opcode Opcode for the command. + * \param[out] read_data Pointer to a memory zone where the read_len + * bytes read will be written to. If no data is to + * be read for the command, + * this argument should be NULL. + * \param[in] read_len Number of bytes to read for the command. If + * no bytes are to be read, use 0 for argument + * otherwise between 1 and 8 bytes (both + * included) can be read. + * \param[in] write_data Pointer to a memory zone where are + * located the write_len bytes to write for + * this command. If no bytes are to be written, + * use NULL as argument. + * \param[in] write_len Number of bytes to write for the command. If + * no bytes are to be written, use 0 for + * argument otherwise between 1 and 8 bytes + * (both included) can be written. + * \param[in] addr Address used for the command + * \param[in] addr_bytes_number Number of address bytes for this command. + * If an address is not needed for the command, + * use 0 for argument, otherwise between 1 and + * 4 bytes (both included) can be used. + * \param[in] dummy_cycles Number of dummy cycles required for the + * command, between 0 and 31 (both included). + * + * \return Returns error code as specified in \ref qspi_ip6514e_error_t + * + * \note Check the flash memory device specifications for the possible opcodes + * that can be used and the other informations needed for this function. + * \note The SPI mode used for this command is the one set with the + * \ref qspi_ip6514e_activate_qspi_mode function or the default one. + */ +enum qspi_ip6514e_error_t qspi_ip6514e_send_cmd(struct qspi_ip6514e_dev_t* dev, + uint8_t opcode, + void *read_data, + uint32_t read_len, + const void *write_data, + uint32_t write_len, + uint32_t addr, + uint32_t addr_bytes_number, + uint32_t dummy_cycles); + +/** + * \brief Send a simple command to the flash memory device using the Software + * Triggered Instruction Generator (STIG) with no data arguments. + * This command can be used for example to send the WRITE ENABLE command. + * + * \param[in] dev QSPI IP6514E device struct \ref qspi_ip6514e_dev_t + * \param[in] opcode Opcode for the command. + * + * \note Check the flash memory device specifications for the possible opcodes + * that can be used and the other informations needed for this function. + * \note The SPI mode used for this command is the one set with the + * \ref qspi_ip6514e_activate_qspi_mode function or the default one. + */ +void qspi_ip6514e_send_simple_cmd(struct qspi_ip6514e_dev_t* dev, + uint8_t opcode); + +/** + * \brief Send a read command to the flash memory device using the Software + * Triggered Instruction Generator (STIG). This command can be used to + * read Flash memory data or registers. + * + * \param[in] dev QSPI IP6514E device struct + * \ref qspi_ip6514e_dev_t + * \param[in] opcode Opcode for the command. + * \param[out] read_data Pointer to a memory zone where the + * read_len bytes read will be written to. + * \param[in] read_len Number of bytes to read for the command. + * Between 1 and 8 bytes (both included) can be + * read. + * \param[in] addr Address used for the command + * \param[in] addr_bytes_number Number of address bytes for this command. + * If an address is not needed for the command, + * use 0 for argument, otherwise between 1 and + * 4 bytes (both included) can be used. + * \param[in] dummy_cycles Number of dummy cycles required for the + * command, between 0 and 31 (both included). + * + * \return Returns error code as specified in \ref qspi_ip6514e_error_t + * + * \note Check the flash memory device specifications for the possible opcodes + * that can be used and the other informations needed for this function. + * \note The SPI mode used for this command is the one set with the + * \ref qspi_ip6514e_activate_qspi_mode function or the default one. + */ +enum qspi_ip6514e_error_t qspi_ip6514e_send_read_cmd( + struct qspi_ip6514e_dev_t* dev, + uint8_t opcode, + void *read_data, + uint32_t read_len, + uint32_t addr, + uint32_t addr_bytes_number, + uint32_t dummy_cycles); + +/** + * \brief Send a write command to the flash memory device using the Software + * Triggered Instruction Generator (STIG). This command can be used to + * write Flash memory or registers. + * + * \param[in] dev QSPI IP6514E device struct + * \ref qspi_ip6514e_dev_t + * \param[in] opcode Opcode for the command. + * \param[in] write_data Pointer to a memory zone where are + * located the write_len bytes to write for + * this command. + * \param[in] write_len Number of bytes to write for the command. + * Between 1 and 8 bytes (both included) can be + * written. + * \param[in] addr Address used for the command + * \param[in] addr_bytes_number Number of address bytes for this command. + * If an address is not needed for the command, + * use 0 for argument, otherwise between 1 and + * 4 bytes (both included) can be used. + * \param[in] dummy_cycles Number of dummy cycles required for the + * command, between 0 and 31 (both included). + * + * \return Returns error code as specified in \ref qspi_ip6514e_error_t + * + * \note Check the flash memory device specifications for the possible opcodes + * that can be used and the other informations needed for this function. + * \note The SPI mode used for this command is the one set with the + * \ref qspi_ip6514e_activate_qspi_mode function or the default one. + */ +enum qspi_ip6514e_error_t qspi_ip6514e_send_write_cmd( + struct qspi_ip6514e_dev_t* dev, + uint8_t opcode, + const void *write_data, + uint32_t write_len, + uint32_t addr, + uint32_t addr_bytes_number, + uint32_t dummy_cycles); + +#ifdef __cplusplus +} +#endif + +#endif /* __QSPI_IP6514E_DRV_H__ */ diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_cmsdk_drv.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_cmsdk_drv.c new file mode 100644 index 00000000000..547d83c4373 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_cmsdk_drv.c @@ -0,0 +1,227 @@ +/* + * Copyright (c) 2016-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * \file timer_cmsdk_drv.c + * \brief Generic driver for CMSDK APB Timers. + * The timer is a 32-bit down-counter with the following features: + * - optional programmable external clock source + * - programmable interrupt source, triggered if counter reaches 0 + * - automatic reload if counter reaches 0 + */ + +#include "timer_cmsdk_drv.h" + +/** Setter bit manipulation macro */ +#define SET_BIT(WORD, BIT_INDEX) ((WORD) |= (1U << (BIT_INDEX))) +/** Clearing bit manipulation macro */ +#define CLR_BIT(WORD, BIT_INDEX) ((WORD) &= ~(1U << (BIT_INDEX))) +/** Getter bit manipulation macro */ +#define GET_BIT(WORD, BIT_INDEX) (bool)(((WORD) & (1U << (BIT_INDEX)))) + +/** + * \brief Timer register map structure + * + */ +struct timer_cmsdk_reg_map_t { + volatile uint32_t ctrl; /* Offset: 0x000 (R/W) control register */ + volatile uint32_t value; /* Offset: 0x004 (R/W) current value register */ + volatile uint32_t reload; /* Offset: 0x008 (R/W) reload value register */ + union { + volatile uint32_t intstatus; /* Offset: 0x00C (R/ ) interrupt + * status register + */ + volatile uint32_t intclear; /* Offset: 0x00C ( /W) interrupt + * clear register + */ + }intreg; +}; + +/** + * \brief CTRL register bit definitions + * + */ +enum ctrl_reg_bits_t { + CTRL_REG_ENUM_ENABLE_INDEX = 0, + CTRL_REG_ENUM_EXTERNAL_INPUT_ENABLE_INDEX = 1, + CTRL_REG_ENUM_EXTERNAL_INPUT_CLOCK_INDEX = 2, + CTRL_REG_ENUM_IRQ_ENABLE_INDEX = 3 +}; + +/** + * \brief INTSTATUS/INTCLEAR register bit definitions + * + */ +enum interrupt_reg_bits_t { + INTERRUPT_REG_ENUM_STATUS_AND_CLEAR_INDEX = 0 +}; + +void timer_cmsdk_init(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + + if (dev->data->is_initialized == 0) { + register_map->ctrl = 0; + register_map->reload = TIMER_CMSDK_DEFAULT_RELOAD; + dev->data->is_initialized = 1; + } +} + +bool timer_cmsdk_is_initialized(const struct timer_cmsdk_dev_t* dev) +{ + return dev->data->is_initialized; +} + +void timer_cmsdk_enable_external_input(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + SET_BIT(register_map->ctrl, CTRL_REG_ENUM_EXTERNAL_INPUT_ENABLE_INDEX); +} + +void timer_cmsdk_disable_external_input(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + CLR_BIT(register_map->ctrl, CTRL_REG_ENUM_EXTERNAL_INPUT_ENABLE_INDEX); +} + +bool timer_cmsdk_is_external_input_enabled(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + return GET_BIT(register_map->ctrl, + CTRL_REG_ENUM_EXTERNAL_INPUT_ENABLE_INDEX); +} + +void timer_cmsdk_set_clock_to_internal(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + CLR_BIT(register_map->ctrl, CTRL_REG_ENUM_EXTERNAL_INPUT_CLOCK_INDEX); +} + +void timer_cmsdk_set_clock_to_external(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + SET_BIT(register_map->ctrl, CTRL_REG_ENUM_EXTERNAL_INPUT_CLOCK_INDEX); +} + +bool timer_cmsdk_is_clock_external(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + return GET_BIT(register_map->ctrl, + CTRL_REG_ENUM_EXTERNAL_INPUT_CLOCK_INDEX); +} + +void timer_cmsdk_enable(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + SET_BIT(register_map->ctrl, CTRL_REG_ENUM_ENABLE_INDEX); +} + +void timer_cmsdk_disable(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + CLR_BIT(register_map->ctrl, CTRL_REG_ENUM_ENABLE_INDEX); +} + +bool timer_cmsdk_is_enabled(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + return GET_BIT(register_map->ctrl, CTRL_REG_ENUM_ENABLE_INDEX); +} + +void timer_cmsdk_enable_interrupt(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + SET_BIT(register_map->ctrl, CTRL_REG_ENUM_IRQ_ENABLE_INDEX); +} + +void timer_cmsdk_disable_interrupt(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + CLR_BIT(register_map->ctrl, CTRL_REG_ENUM_IRQ_ENABLE_INDEX); +} + +bool timer_cmsdk_is_interrupt_enabled(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + return GET_BIT(register_map->ctrl, CTRL_REG_ENUM_IRQ_ENABLE_INDEX); +} + +bool timer_cmsdk_is_interrupt_active(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + return GET_BIT(register_map->intreg.intstatus, + INTERRUPT_REG_ENUM_STATUS_AND_CLEAR_INDEX); +} + +void timer_cmsdk_clear_interrupt(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + SET_BIT(register_map->intreg.intclear, + INTERRUPT_REG_ENUM_STATUS_AND_CLEAR_INDEX); +} + +uint32_t timer_cmsdk_get_current_value(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + return register_map->value; +} + +void timer_cmsdk_set_reload_value(const struct timer_cmsdk_dev_t* dev, + uint32_t reload) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + register_map->reload = reload; +} + +void timer_cmsdk_reset(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + register_map->value = register_map->reload; +} + +uint32_t timer_cmsdk_get_reload_value(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + return register_map->reload; +} + +uint32_t timer_cmsdk_get_elapsed_value(const struct timer_cmsdk_dev_t* dev) +{ + struct timer_cmsdk_reg_map_t* register_map = + (struct timer_cmsdk_reg_map_t*)dev->cfg->base; + return register_map->reload - register_map->value; +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_cmsdk_drv.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_cmsdk_drv.h new file mode 100644 index 00000000000..42e810bf860 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_cmsdk_drv.h @@ -0,0 +1,256 @@ +/* + * Copyright (c) 2016-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * \file timer_cmsdk_drv.h + * \brief Generic driver for CMSDK APB Timers. + * The timer is a 32-bit down-counter with the following features: + * - optional programmable external clock source + * - programmable interrupt source, triggered if counter reaches 0 + * - automatic reload if counter reaches 0 + */ + +#ifndef __TIMER_CMSDK_DRV_H__ +#define __TIMER_CMSDK_DRV_H__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Maximum reload value */ +#define TIMER_CMSDK_MAX_RELOAD UINT32_MAX /* max of 32-bit */ +#define TIMER_CMSDK_DEFAULT_RELOAD TIMER_CMSDK_MAX_RELOAD + +/** CMSDK timer device configuration structure */ +struct timer_cmsdk_dev_cfg_t { + const uintptr_t base; /*!< Timer base address */ +}; + +/** CMSDK timer device data structure */ +struct timer_cmsdk_dev_data_t { + bool is_initialized; /*!< Indicates if the timer is initialized */ +}; + +/* CMSDK timer device structure */ +struct timer_cmsdk_dev_t { + const struct timer_cmsdk_dev_cfg_t* const cfg; /*!< Timer configuration */ + struct timer_cmsdk_dev_data_t* const data; /*!< Timer data */ +}; + +/** + * \brief Initializes timer to a known default state, which is: + * - timer disabled + * - timer interrupt disabled + * - clock source set to internal + * - external input disabled + * - reload value maxed out + * Init should be called prior to any other process and + * it's the caller's responsibility to follow proper call order. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + */ +void timer_cmsdk_init(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Checks if a timer is initialized. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + * + * \return true if initialized, false otherwise + */ +bool timer_cmsdk_is_initialized(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Enables external input, which could be used as clock source + * by calling \ref timer_cmsdk_set_clock_to_external. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + */ +void timer_cmsdk_enable_external_input(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Disables external input. + * Make sure if the timer is explicitly wanted to be stopped or set + * the clock source to internal by \ref timer_cmsdk_set_clock_to_internal + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + */ +void timer_cmsdk_disable_external_input(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Checks if external input is enabled. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + * + * \return true if enabled, false otherwise + */ +bool timer_cmsdk_is_external_input_enabled(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Sets the clock source to internal. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + */ +void timer_cmsdk_set_clock_to_internal(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Sets the clock source to external. + * Make sure external input is enabled correspondingly + * by \ref timer_cmsdk_enable_external_input. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + */ +void timer_cmsdk_set_clock_to_external(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Checks if clock source is external input. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + * + * \return true if external, false if internal + */ +bool timer_cmsdk_is_clock_external(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Enables timer operation. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + */ +void timer_cmsdk_enable(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Disables the given hardware timer. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + */ +void timer_cmsdk_disable(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Checks if a timer is enabled. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + * + * \return true if enabled, false otherwise + */ +bool timer_cmsdk_is_enabled(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Enables timer interrupt. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + */ +void timer_cmsdk_enable_interrupt(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Disables timer interrupt. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + */ +void timer_cmsdk_disable_interrupt(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Checks if a timer interrupt is enabled. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + * + * \return true if enabled, false otherwise + */ +bool timer_cmsdk_is_interrupt_enabled(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Gets timer interrupt status + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + * + * * \return true if active, false otherwise + */ +bool timer_cmsdk_is_interrupt_active(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Clears timer interrupt + * The interrupt request is held until it is cleared. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + */ +void timer_cmsdk_clear_interrupt(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Reads timer current value. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + * + * \return Timer value + */ +uint32_t timer_cmsdk_get_current_value(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Sets the reload value of the selected timer. + * + * New reload value takes effect when: + * - timer is restarted + * - on timer underflow + * - when timer_cmsdk_reset is called + * + * \note In r1p0 technical reference manual it's incorrectly stated + * writing the reload value automatically sets the current value also. + * r1p1 technical reference manual includes the fix. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + * \param[in] reload Timer reload value to set. + * This is the start value of the 32-bit down counter, + * which automatically reloaded if 0 is reached. + */ +void timer_cmsdk_set_reload_value(const struct timer_cmsdk_dev_t* dev, + uint32_t reload); + +/** + * \brief Resets the timer counter to the reload value instantly + * (i.e. without waiting for underflow). + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + */ +void timer_cmsdk_reset(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Gets the reload value of the selected timer. + * This is the start value of the 32-bit down counter, + * which is automatically reloaded if 0 is reached by the counter. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + * + * \return Reload value of the selected timer. + */ +uint32_t timer_cmsdk_get_reload_value(const struct timer_cmsdk_dev_t* dev); + +/** + * \brief Reads the number of ticks elapsed in the current cycle. + * + * \param[in] dev Timer configuration \ref timer_cmsdk_dev_t + * + * \return Get elapsed number of ticks since last reload was set. + * Elapsed = (Reload value - Current value) + */ +uint32_t timer_cmsdk_get_elapsed_value(const struct timer_cmsdk_dev_t* dev); + +#ifdef __cplusplus +} +#endif +#endif /* __TIMER_CMSDK_DRV_H__ */ diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_gp_drv.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_gp_drv.c new file mode 100644 index 00000000000..d6868283eb6 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_gp_drv.c @@ -0,0 +1,170 @@ +/* + * Copyright (c) 2018 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * \file timer_gp_drv.c + * + * \brief Generic driver for general purpose timer. + */ + +#include "timer_gp_drv.h" + +/** Setter bit manipulation macro */ +#define SET_BIT(WORD, BIT_INDEX) ((WORD) |= (1U << (BIT_INDEX))) +/** Clearing bit manipulation macro */ +#define CLR_BIT(WORD, BIT_INDEX) ((WORD) &= ~(1U << (BIT_INDEX))) +/** Getter bit manipulation macro */ +#define GET_BIT(WORD, BIT_INDEX) (bool)(((WORD) & (1U << (BIT_INDEX)))) + +/** + * \brief Timer register map structure + * + */ +struct timer_gp_reg_map_t { + volatile uint32_t reset; /*!< Offset: 0x000 (R/W) Control Reset */ + volatile uint32_t irq_mask; /*!< Offset: 0x004 (R/W) Masked Interrupt */ + volatile uint32_t irq_clear; /*!< Offset: 0x008 (R/W) Interrupt Clear */ + volatile uint32_t reserved; /*!< Offset: 0x00C Reserved */ + volatile uint32_t alarm0; /*!< Offset: 0x010 (R/W) Alarm0 data value */ + volatile uint32_t alarm1; /*!< Offset: 0x014 (R/W) Alarm1 data value */ + volatile uint32_t irq_status; /*!< Offset: 0x018 (R) Raw Interrupt status */ + volatile uint32_t counter; /*!< Offset: 0x01C (R) Counter data value */ +}; + +/** + * \brief Reset control register bit identifiers + * + */ +enum reset_reg_bits_t{ + RESET_REG_INDEX = 0 + /* 1-31: Reserved. Read as zero. Do No Modify (DNM). */ +}; + +void timer_gp_init(const struct timer_gp_dev_t* dev) +{ + if (dev->data->is_initialized == false) { + timer_gp_interrupt_disable(dev, TIMER_GP_ALARM_0); + timer_gp_interrupt_clear(dev, TIMER_GP_ALARM_0); + timer_gp_interrupt_disable(dev, TIMER_GP_ALARM_1); + timer_gp_interrupt_clear(dev, TIMER_GP_ALARM_1); + timer_gp_set_alarm_value(dev, TIMER_GP_ALARM_0, dev->data->alarm0_init); + timer_gp_set_alarm_value(dev, TIMER_GP_ALARM_1, dev->data->alarm1_init); + timer_gp_counter_reset(dev); + dev->data->is_initialized = true; + } +} + +void timer_gp_counter_reset(const struct timer_gp_dev_t* dev) +{ + struct timer_gp_reg_map_t* const register_map = + (struct timer_gp_reg_map_t*)dev->cfg->base; + + SET_BIT(register_map->reset, RESET_REG_INDEX); + /* Reset bit is not self-clearing and some pulse width is required + * for successful reset, so we have to check whether the + * timer counter is set to reset value. Until this bit is asserted + * the timer won't be started. + * The timer is running only if the reset bit is cleared.*/ + while (timer_gp_get_counter(dev) != TIMER_GP_DEFAULT_RESET) + ; + CLR_BIT(register_map->reset, RESET_REG_INDEX); +} + +uint32_t timer_gp_get_counter(const struct timer_gp_dev_t* dev) +{ + struct timer_gp_reg_map_t* const register_map = + (struct timer_gp_reg_map_t*)dev->cfg->base; + return register_map->counter; +} + +void timer_gp_interrupt_enable(const struct timer_gp_dev_t* dev, + const enum timer_gp_alarm_identifier_t alarm) +{ + struct timer_gp_reg_map_t* const register_map = + (struct timer_gp_reg_map_t*)dev->cfg->base; + SET_BIT(register_map->irq_mask, alarm); +} + +void timer_gp_interrupt_disable(const struct timer_gp_dev_t* dev, + const enum timer_gp_alarm_identifier_t alarm) +{ + struct timer_gp_reg_map_t* const register_map = + (struct timer_gp_reg_map_t*)dev->cfg->base; + CLR_BIT(register_map->irq_mask, alarm); +} + +bool timer_gp_interrupt_is_enabled(const struct timer_gp_dev_t* dev, + const enum timer_gp_alarm_identifier_t alarm) +{ + struct timer_gp_reg_map_t* const register_map = + (struct timer_gp_reg_map_t*)dev->cfg->base; + return GET_BIT(register_map->irq_mask, alarm); +} + +bool timer_gp_interrupt_is_active(const struct timer_gp_dev_t* dev, + const enum timer_gp_read_alarm_identifier_t alarm) +{ + struct timer_gp_reg_map_t* const register_map = + (struct timer_gp_reg_map_t*)dev->cfg->base; + return GET_BIT(register_map->irq_status, alarm); +} + +void timer_gp_interrupt_clear(const struct timer_gp_dev_t* dev, + const enum timer_gp_alarm_identifier_t alarm) +{ + struct timer_gp_reg_map_t* const register_map = + (struct timer_gp_reg_map_t*)dev->cfg->base; + enum timer_gp_read_alarm_identifier_t read_alarm = + ((alarm == TIMER_GP_ALARM_0) ? + (TIMER_GP_READ_ALARM_0) : + (TIMER_GP_READ_ALARM_1)); + + SET_BIT(register_map->irq_clear, alarm); + + /* Clear bit is not self-clearing and some pulse width is required + * for successful interrupt clear, so we have to check whether the + * interrupt is cleared. */ + while(timer_gp_interrupt_is_active(dev, read_alarm)) + ; + CLR_BIT(register_map->irq_clear, alarm); +} + +void timer_gp_set_alarm_value(const struct timer_gp_dev_t* dev, + const enum timer_gp_alarm_identifier_t alarm, + const uint32_t value) +{ + struct timer_gp_reg_map_t* const register_map = + (struct timer_gp_reg_map_t*)dev->cfg->base; + if (alarm == TIMER_GP_ALARM_0) { + register_map->alarm0 = value; + } else { + register_map->alarm1 = value; + } +} + +uint32_t timer_gp_get_alarm_value(const struct timer_gp_dev_t* dev, + const enum timer_gp_alarm_identifier_t alarm) +{ + struct timer_gp_reg_map_t* const register_map = + (struct timer_gp_reg_map_t*)dev->cfg->base; + if (alarm == TIMER_GP_ALARM_0) { + return register_map->alarm0; + } else { + return register_map->alarm1; + } +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_gp_drv.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_gp_drv.h new file mode 100644 index 00000000000..73fa5594b92 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/timer_gp_drv.h @@ -0,0 +1,203 @@ +/* + * Copyright (c) 2018 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * \file timer_gp_drv.h + * + * \brief Generic driver for general purpose timer. + * + * \details + * The free running counter is a 32 bit size counter that counts + * up to 0xFFFFFFFF. + * At this maximum value it wraps around to 0x00000000 and continues + * incrementing. + * Software can reset the counter to default 1 by calling + * \ref timer_gp_counter_reset. + * The counter implements two compare interrupts. When the counter + * reaches compare value "alarm0" or "alarm1" value it can trigger a + * corresponding interrupt. + */ + +#ifndef __TIMER_GP_DRV_H__ +#define __TIMER_GP_DRV_H__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define TIMER_GP_MAX_VALUE UINT32_MAX /*!< max of 32-bit */ +#define TIMER_GP_DEFAULT_RESET 1U +/*!< Counter's reset value will be set at HW level if reset bit is asserted */ + +/** GP timer device structure */ +struct timer_gp_dev_cfg_t { + const uintptr_t base; /*!< Timer base address */ +}; + +/** GP timer device data structure */ +struct timer_gp_dev_data_t { + bool is_initialized; + uint32_t alarm0_init; /*!< Alarm0 value will be set by init */ + uint32_t alarm1_init; /*!< Alarm1 value will be set by init */ +}; + +/** GP timer device structure */ +struct timer_gp_dev_t { + const struct timer_gp_dev_cfg_t* const cfg; /*!< Timer configuration */ + struct timer_gp_dev_data_t* const data; /*!< Timer data */ +}; + +/** + * \brief GP Timer alarm number identifiers + * + */ +enum timer_gp_alarm_identifier_t{ + TIMER_GP_ALARM_0 = 0, + TIMER_GP_ALARM_1 = 1 +}; + +/** + * \brief GP Timer read alarm number identifiers + * + */ +enum timer_gp_read_alarm_identifier_t{ + TIMER_GP_READ_ALARM_0 = 0, + TIMER_GP_READ_ALARM_1 = 1, + TIMER_GP_READ_ALARM_COMBINED = 2 + /*!< Combined is asserted if Alarm1 OR Alarm2 is asserted */ +}; + +/** + * \brief Initializes timer to a known default state, which is: + * - interrupts disabled + * - alarm0 and alarm1 set to init value in \ref timer_gp_dev_data_t + * - timer reset to default reset value \ref TIMER_GP_DEFAULT_RESET + * Init should be called prior to any other process and + * it's the caller's responsibility to follow proper call order. + * More than one call results fall through. + * + * \param[in] dev Timer device struct \ref timer_gp_dev_t + */ +void timer_gp_init(const struct timer_gp_dev_t* dev); + +/** + * \brief Resets the timer counter to 1. + * + * \param[in] dev Timer device struct \ref timer_gp_dev_t + */ +void timer_gp_counter_reset(const struct timer_gp_dev_t* dev); + +/** + * \brief Read the 32bit free runnning counter's current value + * + * \param[in] dev Timer device struct \ref timer_gp_dev_t + * + * \return 32bit counter current value + */ +uint32_t timer_gp_get_counter(const struct timer_gp_dev_t* dev); + +/** + * \brief Enable alarm interrupt of the given source + * Note: This function is not interrupt safe. + * + * \param[in] dev Timer device struct \ref timer_gp_dev_t + * \param[in] alarm Alarm source of the interrupt + * \ref timer_gp_alarm_identifier_t + * + */ +void timer_gp_interrupt_enable(const struct timer_gp_dev_t* dev, + const enum timer_gp_alarm_identifier_t alarm); + +/** + * \brief Disable alarm interrupt of the given source + * Note: This function is not interrupt safe. + * + * \param[in] dev Timer device struct \ref timer_gp_dev_t + * \param[in] alarm Alarm source of the interrupt + * \ref timer_gp_alarm_identifier_t + * + */ +void timer_gp_interrupt_disable(const struct timer_gp_dev_t* dev, + const enum timer_gp_alarm_identifier_t alarm); + +/** + * \brief Get alarm interrupt enabled status of the given source + * + * \param[in] dev Timer device struct \ref timer_gp_dev_t + * \param[in] alarm Alarm source of the interrupt + * \ref timer_gp_alarm_identifier_t + * + * \return true if enabled, false if not + */ +bool timer_gp_interrupt_is_enabled(const struct timer_gp_dev_t* dev, + const enum + timer_gp_alarm_identifier_t alarm); + +/** + * \brief Get alarm interrupt pending status of the given source + * + * \param[in] dev Timer device struct \ref timer_gp_dev_t + * \param[in] alarm Alarm source of the interrupt + * \ref timer_gp_read_alarm_identifier_t + * + * \return true if active, false if not + */ +bool timer_gp_interrupt_is_active(const struct timer_gp_dev_t* dev, + const enum timer_gp_read_alarm_identifier_t alarm); + +/** + * \brief Clear alarm interrupt of the given source + * + * \param[in] dev Timer device struct \ref timer_gp_dev_t + * \param[in] alarm Alarm source of the interrupt + * \ref timer_gp_alarm_identifier_t + * + */ +void timer_gp_interrupt_clear(const struct timer_gp_dev_t* dev, + const enum timer_gp_alarm_identifier_t alarm); + +/** + * \brief Set alarm value of the given source + * + * \param[in] dev Timer device struct \ref timer_gp_dev_t + * \param[in] alarm Alarm source \ref timer_gp_alarm_identifier_t + * \param[in] value When the counter reaches this tick value + * corresponding interrupt status will be asserted. + */ +void timer_gp_set_alarm_value(const struct timer_gp_dev_t* dev, + const enum timer_gp_alarm_identifier_t alarm, + const uint32_t value); + +/** + * \brief Get alarm value of the given source + * + * \param[in] dev Timer device struct \ref timer_gp_dev_t + * \param[in] alarm Alarm source \ref timer_gp_alarm_identifier_t + * + * \return value Counter value when the alarm is asserted. + */ +uint32_t timer_gp_get_alarm_value(const struct timer_gp_dev_t* dev, + const enum timer_gp_alarm_identifier_t alarm); + +#ifdef __cplusplus +} +#endif +#endif /* __TIMER_GP_DRV_H__ */ diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/uart_pl011_drv.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/uart_pl011_drv.c new file mode 100644 index 00000000000..557f2565ef5 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/uart_pl011_drv.c @@ -0,0 +1,1021 @@ +/* + * Copyright (c) 2016-2019 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "uart_pl011_drv.h" + +#include +#include "cmsis_compiler.h" + +#define FREQ_IRLPBAUD16_MIN (1420000u) /* 1.42 MHz */ +#define FREQ_IRLPBAUD16_MAX (2120000u) /* 2.12 MHz */ +#define SAMPLING_FACTOR (16u) +#define UART_PL011_FBRD_WIDTH (6u) + +/** + * \brief UART PL011 register map structure + */ +struct _uart_pl011_reg_map_t { + volatile uint32_t uartdr; /*!< Offset: 0x000 (R/W) Data register */ + union { + volatile uint32_t uartrsr; + /*!< Offset: 0x004 (R/ ) Receive status register */ + volatile uint32_t uartecr; + /*!< Offset: 0x004 ( /W) Error clear register */ + }; + volatile uint32_t reserved_0[4]; /*!< Offset: 0x008-0x014 Reserved */ + volatile uint32_t uartfr; /*!< Offset: 0x018 (R/ ) Flag register */ + volatile uint32_t reserved_1; /*!< Offset: 0x01C Reserved */ + volatile uint32_t uartilpr; + /*!< Offset: 0x020 (R/W) IrDA low-power counter register */ + volatile uint32_t uartibrd; + /*!< Offset: 0x024 (R/W) Integer baud rate register */ + volatile uint32_t uartfbrd; + /*!< Offset: 0x028 (R/W) Fractional baud rate register */ + volatile uint32_t uartlcr_h; + /*!< Offset: 0x02C (R/W) Line control register */ + volatile uint32_t uartcr; + /*!< Offset: 0x030 (R/W) Control register */ + volatile uint32_t uartifls; + /*!< Offset: 0x034 (R/W) Interrupt FIFO level select register */ + volatile uint32_t uartimsc; + /*!< Offset: 0x038 (R/W) Interrupt mask set/clear register */ + volatile uint32_t uartris; + /*!< Offset: 0x03C (R/ ) Raw interrupt status register */ + volatile uint32_t uartmis; + /*!< Offset: 0x040 (R/ ) Masked interrupt status register */ + volatile uint32_t uarticr; + /*!< Offset: 0x044 ( /W) Interrupt clear register */ + volatile uint32_t uartdmacr; + /*!< Offset: 0x048 (R/W) DMA control register */ + volatile uint32_t reserved_2[13]; /*!< Offset: 0x04C-0x07C Reserved */ + volatile uint32_t reserved_3[4]; + /*!< Offset: 0x080-0x08C Reserved for test purposes */ + volatile uint32_t reserved_4[976]; /*!< Offset: 0x090-0xFCC Reserved */ + volatile uint32_t reserved_5[4]; + /*!< Offset: 0xFD0-0xFDC Reserved for future ID expansion */ + volatile uint32_t uartperiphid0; + /*!< Offset: 0xFE0 (R/ ) UARTPeriphID0 register */ + volatile uint32_t uartperiphid1; + /*!< Offset: 0xFE4 (R/ ) UARTPeriphID1 register */ + volatile uint32_t uartperiphid2; + /*!< Offset: 0xFE8 (R/ ) UARTPeriphID2 register */ + volatile uint32_t uartperiphid3; + /*!< Offset: 0xFEC (R/ ) UARTPeriphID3 register */ + volatile uint32_t uartpcellid0; + /*!< Offset: 0xFF0 (R/ ) UARTPCellID0 register */ + volatile uint32_t uartpcellid1; + /*!< Offset: 0xFF4 (R/ ) UARTPCellID1 register */ + volatile uint32_t uartpcellid2; + /*!< Offset: 0xFF8 (R/ ) UARTPCellID2 register */ + volatile uint32_t uartpcellid3; + /*!< Offset: 0xFFC (R/ ) UARTPCellID3 register */ +}; + +#define UART_PL011_UARTFR_CTS_MASK ( \ + 0x1u<uartcr |= UART_PL011_UARTCR_EN_MASK; +} + +static void _uart_pl011_disable(struct _uart_pl011_reg_map_t* p_uart) +{ + p_uart->uartcr &= ~UART_PL011_UARTCR_EN_MASK; +} + +static bool _uart_pl011_is_enabled(struct _uart_pl011_reg_map_t* p_uart) +{ + return (bool)(p_uart->uartcr & UART_PL011_UARTCR_EN_MASK); +} + +static void _uart_pl011_enable_fifo(struct _uart_pl011_reg_map_t* p_uart) +{ + p_uart->uartlcr_h |= UART_PL011_UARTLCR_H_FEN_MASK; +} + +static void _uart_pl011_disable_fifo(struct _uart_pl011_reg_map_t* p_uart) +{ + p_uart->uartlcr_h &= ~UART_PL011_UARTLCR_H_FEN_MASK; +} + +static bool _uart_pl011_is_fifo_enabled(struct _uart_pl011_reg_map_t* p_uart) +{ + return (bool)(p_uart->uartlcr_h & UART_PL011_UARTLCR_H_FEN_MASK); +} + +static bool _uart_pl011_is_busy(struct _uart_pl011_reg_map_t* p_uart) +{ + return (bool)(p_uart->uartfr & UART_PL011_UARTFR_BUSYBIT); +} + +static enum uart_pl011_error_t _uart_pl011_set_baudrate( + struct _uart_pl011_reg_map_t* p_uart, + uint32_t clk, uint32_t baudrate) +{ + /* Avoiding float calculations, bauddiv is left shifted by 6 */ + uint64_t bauddiv = (((uint64_t)clk)<= 16 x baud_rate (max) + * uart_clk (max) <= 16 x 65535 x baud_rate (min) + */ + if((bauddiv < (1u< (65535u<uartibrd = (uint32_t)(bauddiv >> UART_PL011_FBRD_WIDTH); + p_uart->uartfbrd = (uint32_t)(bauddiv & + ((1u << UART_PL011_FBRD_WIDTH) - 1u)); + + __DMB(); + + /* In order to internally update the contents of uartibrd or uartfbrd, a + * uartlcr_h write must always be performed at the end + * ARM DDI 0183F, Pg 3-13 + */ + p_uart->uartlcr_h = p_uart->uartlcr_h; + + return UART_PL011_ERR_NONE; +} + +static void _uart_pl011_set_format(struct _uart_pl011_reg_map_t* p_uart, + enum uart_pl011_wlen_t word_len, + enum uart_pl011_parity_t parity, + enum uart_pl011_stopbit_t stop_bits) +{ + uint32_t ctrl_reg = p_uart->uartlcr_h & ~(UART_PL011_FORMAT_MASK); + + /* Making sure other bit are not changed */ + word_len &= UART_PL011_UARTLCR_H_WLEN_MASK; + parity &= UART_PL011_UARTLCR_H_PARITY_MASK; + stop_bits &= UART_PL011_UARTLCR_H_STOPBIT_MASK; + + p_uart->uartlcr_h = ctrl_reg | word_len | parity | stop_bits; + +} + +static void _uart_pl011_set_cr_bit(struct _uart_pl011_reg_map_t* p_uart, + uint32_t mask) +{ + bool uart_enabled = _uart_pl011_is_enabled(p_uart); + bool fifo_enabled = _uart_pl011_is_fifo_enabled(p_uart); + + /* UART must be disabled before any Control Register or + * Line Control Register are reprogrammed */ + _uart_pl011_disable(p_uart); + + /* Flush the transmit FIFO by disabling bit 4 (FEN) in + * the line control register (UARTCLR_H) */ + _uart_pl011_disable_fifo(p_uart); + + p_uart->uartcr |= (mask); + + /* Enabling the FIFOs if previously enabled */ + if(fifo_enabled) { + _uart_pl011_enable_fifo(p_uart); + } + + /* Enabling the UART if previously enabled */ + if(uart_enabled) { + _uart_pl011_enable(p_uart); + } +} + +static void _uart_pl011_clear_cr_bit(struct _uart_pl011_reg_map_t* p_uart, + uint32_t mask) +{ + bool uart_enabled = _uart_pl011_is_enabled(p_uart); + bool fifo_enabled = _uart_pl011_is_fifo_enabled(p_uart); + + /* UART must be disabled before any Control Register or + * Line Control Register are reprogrammed */ + _uart_pl011_disable(p_uart); + + /* Flush the transmit FIFO by disabling bit 4 (FEN) in + * the line control register (UARTCLR_H) */ + _uart_pl011_disable_fifo(p_uart); + + p_uart->uartcr &= ~(mask); + + /* Enabling the FIFOs if previously enabled */ + if(fifo_enabled) { + _uart_pl011_enable_fifo(p_uart); + } + + /* Enabling the UART if previously enabled */ + if(uart_enabled) { + _uart_pl011_enable(p_uart); + } +} + +static void _uart_pl011_set_lcr_h_bit(struct _uart_pl011_reg_map_t* p_uart, + uint32_t mask) +{ + bool uart_enabled = _uart_pl011_is_enabled(p_uart); + + /* UART must be disabled before any Control Register or + * Line Control Register are reprogrammed */ + _uart_pl011_disable(p_uart); + + p_uart->uartlcr_h |= (mask); + + /* Enabling the UART if previously enabled */ + if(uart_enabled) { + _uart_pl011_enable(p_uart); + } +} + +static void _uart_pl011_clear_lcr_h_bit(struct _uart_pl011_reg_map_t* p_uart, + uint32_t mask) +{ + bool uart_enabled = _uart_pl011_is_enabled(p_uart); + + /* UART must be disabled before any Control Register or + * Line Control Register are reprogrammed */ + _uart_pl011_disable(p_uart); + + p_uart->uartlcr_h &= ~(mask); + + /* Enabling the UART if previously enabled */ + if(uart_enabled) { + _uart_pl011_enable(p_uart); + } +} + +static void _uart_pl011_reset_regs(struct _uart_pl011_reg_map_t* p_uart) +{ + /* Restore the default value of UART registers, the registers which + * are not listed below are Read-Only */ + + /* Will disable the UART */ + p_uart->uartcr = UART_PL011_CR_REG_RESET_VALUE; + p_uart->uartdr = UART_PL011_DATA_REG_RESET_VALUE; + /* Clear all the errors */ + p_uart->uartecr = UART_PL011_ECR_REG_CLEAR_VALUE; + p_uart->uartilpr = UART_PL011_ILPR_REG_RESET_VALUE; + p_uart->uartibrd = UART_PL011_IBRD_REG_RESET_VALUE; + p_uart->uartfbrd = UART_PL011_FBRD_REG_RESET_VALUE; + p_uart->uartlcr_h = UART_PL011_LCR_H_REG_RESET_VALUE; + p_uart->uartifls = UART_PL011_IFLS_REG_RESET_VALUE; + p_uart->uartimsc = UART_PL011_IMSC_REG_RESET_VALUE; + /* Clear all the interrupts */ + p_uart->uarticr = UART_PL011_ICR_REG_CLEAR_VALUE; + p_uart->uartdmacr = UART_PL011_DMACR_REG_RESET_VALUE; +} + +enum uart_pl011_error_t uart_pl011_init(struct uart_pl011_dev_t* dev, + uint32_t uart_clk) +{ + enum uart_pl011_error_t err; + + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + uint32_t def_baud = dev->cfg->def_baudrate; + + if(uart_clk == 0) { + return UART_PL011_ERR_INVALID_ARG; + } + + if(def_baud == 0) { + return UART_PL011_ERR_INVALID_BAUD; + } + + /* Updating the system clock */ + dev->data->uart_clk = uart_clk; + + /* Setting the default baudrate */ + err = _uart_pl011_set_baudrate(p_uart, uart_clk, def_baud); + + if(err != UART_PL011_ERR_NONE) { + return err; + } + + /* Setting the default character format */ + _uart_pl011_set_format(p_uart, dev->cfg->def_wlen, + dev->cfg->def_parity, + dev->cfg->def_stopbit); + + /* Enabling the FIFOs */ + _uart_pl011_enable_fifo(p_uart); + + dev->data->state = UART_PL011_INITIALIZED; + + return UART_PL011_ERR_NONE; +} + +void uart_pl011_uninit(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + while(_uart_pl011_is_busy(p_uart)); + + /* Disable and restore the default configuration of the peripheral */ + _uart_pl011_reset_regs(p_uart); + + dev->data->state = UART_PL011_UNINITIALIZED; + + return; +} + +enum uart_pl011_state_t uart_pl011_get_state(struct uart_pl011_dev_t* dev) +{ + return dev->data->state; +} + +enum uart_pl011_error_t uart_pl011_set_baudrate( + struct uart_pl011_dev_t* dev, uint32_t baudrate) +{ + enum uart_pl011_error_t err = UART_PL011_ERR_NONE; + + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + bool uart_enabled = _uart_pl011_is_enabled(p_uart); + + if(uart_pl011_get_state(dev) != UART_PL011_INITIALIZED) { + return UART_PL011_ERR_NOT_INIT; + } + + if(baudrate == 0) { + return UART_PL011_ERR_INVALID_BAUD; + } + + /* UART must be disabled before any Control Register or + * Line Control Register are reprogrammed */ + _uart_pl011_disable(p_uart); + + /* If baudrate is not valid ie UART_PL011_ERR_NONE is not returned then + * the UART will continue to function at the old baudrate */ + err = _uart_pl011_set_baudrate(p_uart, dev->data->uart_clk, baudrate); + + if(err == UART_PL011_ERR_NONE) { + dev->data->baudrate = baudrate; + } + + if(uart_enabled) { + _uart_pl011_enable(p_uart); + } + + return err; +} + +uint32_t uart_pl011_get_baudrate(struct uart_pl011_dev_t* dev) +{ + return dev->data->baudrate; +} + +void uart_pl011_enable_intr(struct uart_pl011_dev_t* dev, + enum uart_pl011_intr_t mask) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + p_uart->uartimsc |= (uint32_t)(mask); + + return; +} + +void uart_pl011_disable_intr(struct uart_pl011_dev_t* dev, + enum uart_pl011_intr_t mask) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + p_uart->uartimsc &= (uint32_t)(~mask); + + return; +} + +void uart_pl011_clear_intr(struct uart_pl011_dev_t* dev, + enum uart_pl011_intr_t mask) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + p_uart->uarticr = (uint32_t)mask; + + return; +} + + +enum uart_pl011_intr_t uart_pl011_get_masked_intr_status( + struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + return (enum uart_pl011_intr_t)(p_uart->uartmis); + +} + +enum uart_pl011_intr_t uart_pl011_get_raw_intr_status( + struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + return (enum uart_pl011_intr_t)(p_uart->uartris); +} + +void uart_pl011_set_rx_fifo_lvl(struct uart_pl011_dev_t* dev, + enum uart_pl011_rx_fifo_lvl_t rx_lvl) +{ + uint32_t fifo_lvl; + + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + /* Check if rx_lvl have valid values */ + rx_lvl &= UART_PL011_UARTIFLS_RX_FIFO_LVL_MASK; + + fifo_lvl = p_uart->uartifls + & ~(UART_PL011_UARTIFLS_RX_FIFO_LVL_MASK); + p_uart->uartifls = fifo_lvl | rx_lvl; + + return; +} + +void uart_pl011_set_tx_fifo_lvl(struct uart_pl011_dev_t* dev, + enum uart_pl011_tx_fifo_lvl_t tx_lvl) +{ + uint32_t fifo_lvl; + + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + /* Check if tx_lvl have valid values */ + tx_lvl &= UART_PL011_UARTIFLS_TX_FIFO_LVL_MASK; + + fifo_lvl = p_uart->uartifls + & ~(UART_PL011_UARTIFLS_TX_FIFO_LVL_MASK); + p_uart->uartifls = fifo_lvl | tx_lvl; + + return; +} + +void uart_pl011_set_tx_dma(struct uart_pl011_dev_t* dev, + enum uart_pl011_tx_dma_t enable) +{ + uint32_t dma_cr; + + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + enable &= UART_PL011_UARTDMACR_TX_MASK; + + dma_cr = p_uart->uartdmacr + & ~(UART_PL011_UARTDMACR_TX_MASK); + + p_uart->uartdmacr = dma_cr | enable; + + return; +} + +void uart_pl011_set_rx_dma(struct uart_pl011_dev_t* dev, + enum uart_pl011_rx_dma_t enable) +{ + uint32_t dma_cr; + + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + enable &= UART_PL011_UARTDMACR_RX_MASK; + + dma_cr = p_uart->uartdmacr + & ~(UART_PL011_UARTDMACR_RX_MASK); + + p_uart->uartdmacr = dma_cr | enable; + + return; +} + +bool uart_pl011_is_readable(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + if( (uart_pl011_get_state(dev) == UART_PL011_INITIALIZED) && + /* UART is initialized */ + (p_uart->uartcr & UART_PL011_UARTCR_EN_MASK) && + /* UART is enabled */ + (p_uart->uartcr & UART_PL011_UARTCR_RX_EN_MASK) && + /* Receive is enabled */ + ((p_uart->uartfr & UART_PL011_UARTFR_RX_FIFO_EMPTY) == 0)) { + /* Receive Fifo is not empty */ + return true; + } + + return false; + +} + +enum uart_pl011_error_t uart_pl011_read( + struct uart_pl011_dev_t* dev, uint8_t* byte) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + *byte = p_uart->uartdr; + + return (enum uart_pl011_error_t)(p_uart->uartrsr + & UART_PL011_RX_ERR_MASK); +} + +bool uart_pl011_is_writable(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + if( (uart_pl011_get_state(dev) == UART_PL011_INITIALIZED) && + /* UART is initialized */ + (p_uart->uartcr & UART_PL011_UARTCR_EN_MASK) && + /* UART is enabled */ + (p_uart->uartcr & UART_PL011_UARTCR_TX_EN_MASK) && + /* Transmit is enabled */ + ((p_uart->uartfr & UART_PL011_UARTFR_TX_FIFO_FULL) == 0)) { + /* Transmit Fifo is not full */ + return true; + } + return false; + +} + +void uart_pl011_write(struct uart_pl011_dev_t* dev, uint8_t byte) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + p_uart->uartdr = byte; + + return; +} + +enum uart_pl011_error_t uart_pl011_set_format(struct uart_pl011_dev_t* dev, + enum uart_pl011_wlen_t word_len, + enum uart_pl011_parity_t parity, + enum uart_pl011_stopbit_t stop_bits) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + bool uart_enabled = _uart_pl011_is_enabled(p_uart); + + if(uart_pl011_get_state(dev) != UART_PL011_INITIALIZED) { + return UART_PL011_ERR_NOT_INIT; + } + + /* UART must be disabled before any Control Register or + * Line Control Register are reprogrammed */ + _uart_pl011_disable(p_uart); + + _uart_pl011_set_format(p_uart, word_len, parity, stop_bits); + + /* Enabling the UART if previously enabled */ + if(uart_enabled) { + _uart_pl011_enable(p_uart); + } + + return UART_PL011_ERR_NONE; +} + +void uart_pl011_enable_fifo(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_set_lcr_h_bit(p_uart, UART_PL011_UARTLCR_H_FEN_MASK); + + return; +} + +void uart_pl011_disable_fifo(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_clear_lcr_h_bit(p_uart, UART_PL011_UARTLCR_H_FEN_MASK); + + return; +} + +void uart_pl011_enable_break(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_set_lcr_h_bit(p_uart, UART_PL011_UARTLCR_H_BRK_MASK); + + return; +} + +void uart_pl011_disable_break(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_clear_lcr_h_bit(p_uart, UART_PL011_UARTLCR_H_BRK_MASK); + + return; +} + +void uart_pl011_enable_cts_flowcontrol(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_set_cr_bit(p_uart, UART_PL011_UARTCR_CTSE_MASK); + + return; +} + +void uart_pl011_disable_cts_flowcontrol(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_clear_cr_bit(p_uart, UART_PL011_UARTCR_CTSE_MASK); + + return; +} + +void uart_pl011_enable_rts_flowcontrol(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_set_cr_bit(p_uart, UART_PL011_UARTCR_RTSE_MASK); + + return; +} + +void uart_pl011_disable_rts_flowcontrol(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_clear_cr_bit(p_uart, UART_PL011_UARTCR_RTSE_MASK); + + return; +} + +void uart_pl011_enable_ri(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_set_cr_bit(p_uart, UART_PL011_UARTCR_OUT2_MASK); + + return; +} + +void uart_pl011_disable_ri(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_clear_cr_bit(p_uart, UART_PL011_UARTCR_OUT2_MASK); + + return; +} + +void uart_pl011_enable_dcd(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_set_cr_bit(p_uart, UART_PL011_UARTCR_OUT1_MASK); + + return; +} + +void uart_pl011_disable_dcd(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_clear_cr_bit(p_uart, UART_PL011_UARTCR_OUT1_MASK); + + return; +} + +void uart_pl011_set_rts(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_set_cr_bit(p_uart, UART_PL011_UARTCR_RTS_MASK); + + return; +} + +void uart_pl011_clear_rts(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_clear_cr_bit(p_uart, UART_PL011_UARTCR_RTS_MASK); + + return; +} + +void uart_pl011_set_dtr(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_set_cr_bit(p_uart, UART_PL011_UARTCR_DTR_MASK); + + return; +} + +void uart_pl011_clear_dtr(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_clear_cr_bit(p_uart, UART_PL011_UARTCR_DTR_MASK); + + return; +} + +void uart_pl011_enable_receive(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_set_cr_bit(p_uart, UART_PL011_UARTCR_RX_EN_MASK); + + return; +} + +void uart_pl011_disable_receive(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_clear_cr_bit(p_uart, UART_PL011_UARTCR_RX_EN_MASK); + + return; +} + +void uart_pl011_enable_transmit(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_set_cr_bit(p_uart, UART_PL011_UARTCR_TX_EN_MASK); + + return; +} + +void uart_pl011_disable_transmit(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_clear_cr_bit(p_uart, UART_PL011_UARTCR_TX_EN_MASK); + + return; +} + +void uart_pl011_set_loopback(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_set_cr_bit(p_uart, UART_PL011_UARTCR_LBE_MASK); + + return; +} + +void uart_pl011_clear_loopback(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_clear_cr_bit(p_uart, UART_PL011_UARTCR_LBE_MASK); + + return; +} + +void uart_pl011_enable_sirlp(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_set_cr_bit(p_uart, + UART_PL011_UARTCR_SIREN_MASK | UART_PL011_UARTCR_SIRLP_MASK); + + return; +} + +void uart_pl011_disable_sirlp(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_clear_cr_bit(p_uart, + UART_PL011_UARTCR_SIREN_MASK | UART_PL011_UARTCR_SIRLP_MASK); + + return; +} + +void uart_pl011_enable_sir(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_set_cr_bit(p_uart, UART_PL011_UARTCR_SIREN_MASK); + + return; +} + +void uart_pl011_disable_sir(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_clear_cr_bit(p_uart, UART_PL011_UARTCR_SIREN_MASK); + + return; +} + +void uart_pl011_enable(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_enable(p_uart); + + return; +} + +void uart_pl011_disable(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + _uart_pl011_disable(p_uart); + + return; +} + +bool uart_pl011_get_cts_status(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + return (bool)(p_uart->uartfr & UART_PL011_UARTFR_CTS_MASK); + +} + +bool uart_pl011_get_dsr_status(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + return (bool)(p_uart->uartfr & UART_PL011_UARTFR_DSR_MASK); + +} + +bool uart_pl011_get_dcd_status(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + return (bool)(p_uart->uartfr & UART_PL011_UARTFR_DCD_MASK); + +} + +bool uart_pl011_get_ri_status(struct uart_pl011_dev_t* dev) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + return (bool)(p_uart->uartfr & UART_PL011_UARTFR_RI_MASK); + +} + +enum uart_pl011_error_t uart_pl011_set_sirlp_divisor( + struct uart_pl011_dev_t* dev, uint32_t value) +{ + struct _uart_pl011_reg_map_t* p_uart = + (struct _uart_pl011_reg_map_t*)dev->cfg->base; + + uint32_t irlp_baud16_clk; + + if(uart_pl011_get_state(dev) != UART_PL011_INITIALIZED) { + return UART_PL011_ERR_NOT_INIT; + } + + if(value == 0) { + return UART_PL011_ERR_INVALID_ARG; + } + + irlp_baud16_clk = dev->data->uart_clk/value; + + /* Chose the divisor so that 1.42MHz < FIrLPBaud16 < 2.12MHz, that + * results in a low-power pulse duration of 1.41–2.11μs (three times + * the period of IrLPBaud16). ARM DDI0183F Pg 3-9 */ + if(irlp_baud16_clk < FREQ_IRLPBAUD16_MIN || + irlp_baud16_clk > FREQ_IRLPBAUD16_MAX) { + return UART_PL011_ERR_INVALID_ARG; + } + + p_uart->uartilpr = value; + + return UART_PL011_ERR_NONE; +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/uart_pl011_drv.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/uart_pl011_drv.h new file mode 100644 index 00000000000..1cf5b622c38 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/drivers/uart_pl011_drv.h @@ -0,0 +1,854 @@ +/* + * Copyright (c) 2016-2018 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * \file uart_pl011_drv.h + * \brief Driver for ARM UART PL011. + */ + +#ifndef __UART_PL011_DRV_H__ +#define __UART_PL011_DRV_H__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * \brief ARM UART PL011 state types + */ +enum uart_pl011_state_t { + UART_PL011_UNINITIALIZED = 0x0u, + UART_PL011_INITIALIZED = 0x1u, +}; + +#define UART_PL011_UARTRSR_FE_ERR_OFF 0x0u + /*!< Receive Status Register Frame Error bit field offset */ +#define UART_PL011_UARTRSR_PE_ERR_OFF 0x1u + /*!< Receive Status Register Parity Error bit field offset */ +#define UART_PL011_UARTRSR_BE_ERR_OFF 0x2u + /*!< Receive Status Register Break Error bit field offset */ +#define UART_PL011_UARTRSR_OE_ERR_OFF 0x3u + /*!< Receive Status Register Overrun Error bit field offset */ + +#define UART_PL011_RX_ERR_MASK ( \ + 0x1u< +#include "platform_base_address.h" + +/* sysinfo memory mapped register access structure */ +struct sysinfo_t { + volatile uint32_t sysversion; /* (R/ ) 0x000 System version */ + volatile uint32_t sysconfig; /* (R/ ) 0x004 System configuration */ + volatile uint32_t reserved0[1010]; /* 0x010-0xFCC Reserved */ + volatile uint32_t pidr4; /* (R/ ) 0xFD0 Peripheral ID 4 */ + volatile uint32_t reserved1[3]; /* 0xFD4-0xFDC Reserved */ + volatile uint32_t pidr0; /* (R/ ) 0xFE0 Peripheral ID 0 */ + volatile uint32_t pidr1; /* (R/ ) 0xFE4 Peripheral ID 1 */ + volatile uint32_t pidr2; /* (R/ ) 0xFE8 Peripheral ID 2 */ + volatile uint32_t pidr3; /* (R/ ) 0xFEC Peripheral ID 3 */ + volatile uint32_t cidr0; /* (R/ ) 0xFF0 Component ID 0 */ + volatile uint32_t cidr1; /* (R/ ) 0xFF4 Component ID 1 */ + volatile uint32_t cidr2; /* (R/ ) 0xFF8 Component ID 2 */ + volatile uint32_t cidr3; /* (R/ ) 0xFFC Component ID 3 */ +}; + +/* Secure System Control (SYSCTRL) Alias */ +#define CMSDK_SYSCTRL_BASE_S MUSCA_S1_SYSTEM_CTRL_S_BASE + +/* sysctrl memory mapped register access structure */ +struct sysctrl_t { + /* (R/ ) 0x000 Secure Debug Configuration Status Register*/ + volatile uint32_t secdbgstat; + /* ( /W) 0x004 Secure Debug Configuration Set Register */ + volatile uint32_t secdbgset; + /* ( /W) 0x008 Secure Debug Configuration Clear Register */ + volatile uint32_t secdbgclr; + /* (R/W) 0x00C System Control Security Control Register */ + volatile uint32_t scsecctrl; + /* (R/W) 0x010 Fast Clock Divider Configuration Register */ + volatile uint32_t fclk_div; + /* (R/W) 0x014 System Clock Divider Configuration Register */ + volatile uint32_t sysclk_div; + /* (R/W) 0x018 Clock Forces */ + volatile uint32_t clockforce; + /* 0x01C-0x0FC Reserved */ + volatile uint32_t reserved0[57]; + /* (R/W) 0x100 Reset syndrome */ + volatile uint32_t resetsyndrome; + /* (R/W) 0x104 Reset MASK */ + volatile uint32_t resetmask; + /* ( /W) 0x108 Software Reset */ + volatile uint32_t swreset; + /* (R/W) 0x10C General Purpose Retention Register */ + volatile uint32_t gretreg; + /* (R/W) 0x110 Initial Secure Reset Vector Register For CPU 0 */ + volatile uint32_t initsvtor0; + /* (R/W) 0x114 Initial Secure Reset Vector Register For CPU 1*/ + volatile uint32_t initsvtor1; + /* (R/W) 0x118 CPU Boot wait control after reset */ + volatile uint32_t cpuwait; + /* (R/W) 0x11C NMI Enable */ + volatile uint32_t nmi_enable; + /* (R/W) 0x120 CPU WIC Request and Acknowledgement */ + volatile uint32_t wicctrl; + /* (R/W) 0x124 External Wakeup Control */ + volatile uint32_t ewctrl; + /* 0x128-0x1FC Reserved */ + volatile uint32_t reserved2[54]; + /* (R/W) 0x200 Power Control Dependency Matrix + * PD_SYS Power Domain Sensitivity.*/ + volatile uint32_t pdcm_pd_sys_sense; + /* 0x204-0x208 Reserved */ + volatile uint32_t reserved3[2]; + /* (R/W) 0x20C Power Control Dependency Matrix + * PD_SRAM0 Power Domain Sensitivity.*/ + volatile uint32_t pdcm_pd_sram0_sense; + /* (R/W) 0x210 Power Control Dependency Matrix + * PD_SRAM1 Power Domain Sensitivity.*/ + volatile uint32_t pdcm_pd_sram1_sense; + /* 0x214(R/W) Power Control Dependency Matrix + * PD_SRAM2 Power Domain Sensitivity.*/ + volatile uint32_t pdcm_pd_sram2_sense; + /* (R/W) 0x218 Power Control Dependency Matrix + * PD_SRAM3 Power Domain Sensitivity.*/ + volatile uint32_t pdcm_pd_sram3_sense; + /* 0x21C-0xFCC Reserved */ + volatile uint32_t reserved4[877]; + /* (R/ ) 0xFD0 Peripheral ID 4 */ + volatile uint32_t pidr4; + /* 0xFD4-0xFDC Reserved */ + volatile uint32_t reserved5[3]; + /* (R/ ) 0xFE0 Peripheral ID 0 */ + volatile uint32_t pidr0; + /* (R/ ) 0xFE4 Peripheral ID 1 */ + volatile uint32_t pidr1; + /* (R/ ) 0xFE8 Peripheral ID 2 */ + volatile uint32_t pidr2; + /* (R/ ) 0xFEC Peripheral ID 3 */ + volatile uint32_t pidr3; + /* (R/ ) 0xFF0 Component ID 0 */ + volatile uint32_t cidr0; + /* (R/ ) 0xFF4 Component ID 1 */ + volatile uint32_t cidr1; + /* (R/ ) 0xFF8 Component ID 2 */ + volatile uint32_t cidr2; + /* (R/ ) 0xFFC Component ID 3 */ + volatile uint32_t cidr3; +}; + +/* Secure Privilege Control */ +#define CMSDK_SPCTRL ((struct spctrl_def*)MUSCA_S1_SPCTRL_S_BASE) + +/* SPCTRL memory mapped register access structure */ +struct spctrl_def { + /* (R/W) 0x000 Secure Configuration Control Register */ + volatile uint32_t spcsecctrl; + /* (R/W) 0x004 Bus Access wait control after reset.*/ + volatile uint32_t buswait; + /* 0x008-0x00C Reserved */ + volatile uint32_t reserved1[2]; + /* (R/W) 0x010Security Violation Response Configuration register.*/ + volatile uint32_t secrespcfg; + /* (R/W) 0x014 Non Secure Callable Configuration for IDAU. */ + volatile uint32_t nsccfg; + /* 0x018 Reserved */ + volatile uint32_t reserved2; + /* (R/W) 0x01C Secure MPC Interrupt Status. */ + volatile uint32_t secmpcintstat; + /* (R/W) 0x020 Secure PPC Interrupt Status. */ + volatile uint32_t secppcintstat; + /* (R/W) 0x024 Secure PPC Interrupt Clear. */ + volatile uint32_t secppcintclr; + /* (R/W) 0x28 Secure PPC Interrupt Enable. */ + volatile uint32_t secppcinten; + /* 0x02C-0x03C Reserved */ + volatile uint32_t reserved3[5]; + /* (R/W) 0x040 Bridge Buffer Error Interrupt Status. */ + volatile uint32_t brgintstat; + /* (R/W) 0x044 Bridge Buffer Error Interrupt Clear. */ + volatile uint32_t brgintclr; + /* (R/W) 0x048 Bridge Buffer Error Interrupt Enable. */ + volatile uint32_t brginten; + /* 0x04C-0x05C Reserved */ + volatile uint32_t reserved4[5]; + /* (R/W) 0x060 Expansion 0 Non_Secure Access + * AHB slave Peripheral Protection Control */ + volatile uint32_t ahbnsppcexp0; + /* 0x064-0x06C Reserved */ + volatile uint32_t reserved5[3]; + /* (R/W) 0x070 Non-Secure Access + * APB slave Peripheral Protection Control #0 */ + volatile uint32_t apbnsppc0; + /* (R/W) 0x074 Non-Secure Access + * APB slave Peripheral Protection Control #1 */ + volatile uint32_t apbnsppc1; + /* 0x078-0x07C Reserved */ + volatile uint32_t reserved6[2]; + /* (R/W) 0x080 Expansion 0 Non_Secure Access + * APB slave Peripheral Protection Control */ + volatile uint32_t apbnsppcexp0; + /* (R/W) 0x084 Expansion 1 Non_Secure Access + * APB slave Peripheral Protection Control */ + volatile uint32_t apbnsppcexp1; + /* 0x088-0x08C Reserved */ + volatile uint32_t reserved7[2]; + /* (R/W) 0x090 Secure Unprivileged Access + * AHB slave Peripheral Protection Control #0. */ + volatile uint32_t ahbspppc0; + /* 0x094-0x09C Reserved */ + volatile uint32_t reserved8[3]; + /* (R/W) 0x0A0 Expansion 0 Secure Unprivileged Access + * AHB slave Peripheral Protection Control. */ + volatile uint32_t ahbspppcexp0; + /* 0x0A4-0x0AC Reserved */ + volatile uint32_t reserved9[3]; + /* (R/W) 0x0B0 Secure Unprivileged Access + * APB slave Peripheral Protection Control #0 */ + volatile uint32_t apbspppc0; + /* (R/W) 0x0B4 Secure Unprivileged Access + * APB slave Peripheral Protection Control #1 */ + volatile uint32_t apbspppc1; + /* 0x0B8-0x0BC Reserved */ + volatile uint32_t reserved10[2]; + /* (R/W) 0x0C0 Expansion 0 Secure Unprivileged Access + * APB slave Peripheral Protection Control */ + volatile uint32_t apbspppcexp0; + /* (R/W) 0x0C4 Expansion 1 Secure Unprivileged Access + * APB slave Peripheral Protection Control */ + volatile uint32_t apbspppcexp1; + /* 0x0C8-0xFCC Reserved */ + volatile uint32_t reserved11[962]; + /* (R/W) 0xFD0 Peripheral ID 4 */ + volatile uint32_t pid4; + /* 0xFD4-0xFDC Reserved */ + volatile uint32_t reserved12[3]; + /* (R/W) 0xFE0 Peripheral ID 0 */ + volatile uint32_t pid0; + /* (R/W) 0xFE4 Peripheral ID 1 */ + volatile uint32_t pid1; + /* (R/W) 0xFE8 Peripheral ID 2 */ + volatile uint32_t pid2; + /* (R/W) 0xFEC Peripheral ID 3 */ + volatile uint32_t pid3; + /* (R/W) 0xFF0 Component ID 0 */ + volatile uint32_t cid0; + /* (R/W) 0xFF4 Component ID 1 */ + volatile uint32_t cid1; + /* (R/W) 0xFF8 Component ID 2 */ + volatile uint32_t cid2; + /* (R/W) 0xFFC Component ID 3 */ + volatile uint32_t cid3; +}; + +/* Secure PPC interrupt position mask */ +#define CMSDK_APB_PPC0_INT_POS_MASK (1UL << 0) +#define CMSDK_APB_PPC1_INT_POS_MASK (1UL << 1) +#define CMSDK_APB_PPCEXP0_INT_POS_MASK (1UL << 4) +#define CMSDK_APB_PPCEXP1_INT_POS_MASK (1UL << 5) +#define CMSDK_APB_PPCEXP2_INT_POS_MASK (1UL << 6) +#define CMSDK_APB_PPCEXP3_INT_POS_MASK (1UL << 7) +#define CMSDK_AHB_PPCEXP0_INT_POS_MASK (1UL << 20) +#define CMSDK_AHB_PPCEXP1_INT_POS_MASK (1UL << 21) +#define CMSDK_AHB_PPCEXP2_INT_POS_MASK (1UL << 22) +#define CMSDK_AHB_PPCEXP3_INT_POS_MASK (1UL << 23) + +/* Non-Secure Privilege Control */ +#define CMSDK_NSPCTRL ((struct nspctrl_def*)MUSCA_S1_NSPCTRL_NS_BASE) + +/* NSPCTRL memory mapped register access structure */ +struct nspctrl_def { + /* 0x000-0x09C Reserved */ + volatile uint32_t reserved1[40]; + /* (R/W) 0x0A0 Expansion 0 Non-Secure Unprivileged Access + * AHB slave Peripheral Protection Control */ + volatile uint32_t ahbnspppcexp0; + /* 0x0A4-0x0AC Reserved */ + volatile uint32_t reserved2[3]; + /* (R/W) 0x0B0 Non-Secure Unprivileged Access + * APB slave Peripheral Protection Control #0 */ + volatile uint32_t apbnspppc0; + /* (R/W) 0x0B4 Non-Secure Unprivileged Access + * APB slave Peripheral Protection Control #1 */ + volatile uint32_t apbnspppc1; + /* 0x0B8-0x0BC Reserved */ + volatile uint32_t reserved3[2]; + /* (R/W) 0x0C0 Expansion 0 Non-Secure Unprivileged Access + * APB slave Peripheral Protection Control */ + volatile uint32_t apbnspppcexp0; + /* (R/W) 0x0C4 Expansion 1 Non-Secure Unprivileged Access + * APB slave Peripheral Protection Control */ + volatile uint32_t apbnspppcexp1; + /* 0x0C8-0xFCC Reserved */ + volatile uint32_t reserved4[962]; + /* (R/W) 0xFD0 Peripheral ID 4 */ + volatile uint32_t pidr4; + /* 0xFD4-0xFDC Reserved */ + volatile uint32_t reserved5[3]; + /* (R/W) 0xFE0 Peripheral ID 0 */ + volatile uint32_t pidr0; + /* (R/W) 0xFE4 Peripheral ID 1 */ + volatile uint32_t pidr1; + /* (R/W) 0xFE8 Peripheral ID 2 */ + volatile uint32_t pidr2; + /* (R/W) 0xFEC Peripheral ID 3 */ + volatile uint32_t pidr3; + /* (R/W) 0xFF0 Component ID 0 */ + volatile uint32_t cidr0; + /* (R/W) 0xFF4 Component ID 1 */ + volatile uint32_t cidr1; + /* (R/W) 0xFF8 Component ID 2 */ + volatile uint32_t cidr2; + /* (R/W) 0xFFC Component ID 3 */ + volatile uint32_t cidr3; +}; + +/* ARM APB PPC0 peripherals definition */ +#define CMSDK_TIMER0_APB_PPC_POS 0U +#define CMSDK_TIMER1_APB_PPC_POS 1U +#define CMSDK_DTIMER_APB_PPC_POS 2U +#define CMSDK_MHU0_APB_PPC_POS 3U +#define CMSDK_MHU1_APB_PPC_POS 4U +/* The bits 31:5 are reserved */ + +/* ARM APB PPC1 peripherals definition */ +#define CMSDK_S32K_TIMER_PPC_POS 0U +/* The bits 31:1 are reserved */ + +/* ARM AHB PPC0 peripherals definition */ +/* The bits 31:0 are reserved */ + +/* ARM AHB PPCEXP0 peripherals definition */ +#define MUSCA_S1_GPIO_AHB_PPC_POS 1U +/* The bits 31:1 are reserved */ + +/* ARM AHB PPCEXP1 peripherals definition */ +/* The bits 31:0 are reserved */ + +/* ARM AHB PPCEXP2 peripherals definition */ +/* The bits 31:0 are reserved */ + +/* ARM AHB PPCEXP3 peripherals definition */ +/* The bits 31:0 are reserved */ + +/* ARM APB PPCEXP0 peripherals definition */ +#define MUSCA_S1_QSPI_MPC_APB_PPC_POS 0U +#define MUSCA_S1_SRAM_MPC_APB_PPC_POS 1U +#define MUSCA_S1_MRAM_MPC_APB_PPC_POS 2U + +/* ARM APB PPCEXP1 peripherals definition */ +#define MUSCA_S1_UART0_APB_PPC_POS 0U +#define MUSCA_S1_UART1_APB_PPC_POS 1U +#define MUSCA_S1_SPI_APB_PPC_POS 2U +#define MUSCA_S1_I2C0_APB_PPC_POS 3U +#define MUSCA_S1_I2C1_APB_PPC_POS 4U +#define MUSCA_S1_I2S_APB_PPC_POS 5U +#define MUSCA_S1_PWM0_APB_PPC_POS 6U +#define MUSCA_S1_RTC_APB_PPC_POS 7U +#define MUSCA_S1_PVT_APB_PPC_POS 8U +#define MUSCA_S1_QSPI_APB_PPC_POS 9U +#define MUSCA_S1_GPTIMER_APB_PPC_POS 10U +#define MUSCA_S1_SCC_APB_PPC_POS 11U +#define MUSCA_S1_PWM1_APB_PPC_POS 12U +#define MUSCA_S1_PWM2_APB_PPC_POS 13U + +#endif /* __MUSCA_S1_PLATFORM_REGS__ */ diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/system_core_init.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/system_core_init.c new file mode 100644 index 00000000000..f0bd9715362 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/system_core_init.c @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2009-2020 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * This file is derivative of CMSIS V5.01 \Device\ARM\ARMCM33\Source\system_ARMCM33.c + * https://github.com/ARM-software/CMSIS_5/tree/5.0.1 + * Git SHA: 8a1d9d6ee18b143ae5befefa14d89fb5b3f99c75 + */ + +#include +#include "system_core_init.h" +#include "platform_description.h" + +/*---------------------------------------------------------------------------- + Define clocks + *----------------------------------------------------------------------------*/ +#define XTAL (50000000UL) +#define SYSTEM_CLOCK (XTAL) +#define SYSTEM_REFCLK (32768UL) + +/*---------------------------------------------------------------------------- + Externals + *----------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------- + System Core Clock Variable + *----------------------------------------------------------------------------*/ +uint32_t SystemCoreClock = SYSTEM_CLOCK; +uint32_t PeripheralClock = SYSTEM_CLOCK; +uint32_t RefClock = SYSTEM_REFCLK; + +/*---------------------------------------------------------------------------- + System Core Clock update function + *----------------------------------------------------------------------------*/ +void SystemCoreClockUpdate (void) +{ + SystemCoreClock = SYSTEM_CLOCK; + PeripheralClock = SYSTEM_CLOCK; + RefClock = SYSTEM_REFCLK; +} + +/*---------------------------------------------------------------------------- + System initialization function + *----------------------------------------------------------------------------*/ +void SystemInit (void) +{ +#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U) + extern uint32_t __Vectors; + SCB->VTOR = (uint32_t) &__Vectors; +#endif + +#if defined (__FPU_USED) && (__FPU_USED == 1U) + SCB->CPACR |= ((3U << 10U*2U) | /* set CP10 Full Access */ + (3U << 11U*2U) ); /* set CP11 Full Access */ +#endif + +#ifdef UNALIGNED_SUPPORT_DISABLE + SCB->CCR |= SCB_CCR_UNALIGN_TRP_Msk; +#endif + + SystemCoreClock = SYSTEM_CLOCK; +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/system_core_init.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/system_core_init.h new file mode 100644 index 00000000000..77780249d71 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/device/system_core_init.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2017-2019 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * This file is derivative of CMSIS V5.01 \Device\ARM\ARMCM33\Include\system_ARMCM33.h + * Git SHA: 8a1d9d6ee18b143ae5befefa14d89fb5b3f99c75 + * + */ + +#ifndef __SYSTEM_CORE_INIT_H__ +#define __SYSTEM_CORE_INIT_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +extern uint32_t SystemCoreClock; /*!< System Clock Frequency (Core Clock) */ +extern uint32_t PeripheralClock; /*!< Peripheral Clock Frequency */ +extern uint32_t RefClock; /*!< External Reference Clock Frequency */ + +/** + \brief Setup the microcontroller system. + + Initialize the System and update the SystemCoreClock variable. + It should be called from Reset Handler within the first few steps. + The minimal feature set should be initialised for successful exit + from Reset Handler to main entry point. + */ +extern void SystemInit (void); + + +/** + \brief Update SystemCoreClock variable. + + Updates the SystemCoreClock with current core Clock retrieved from cpu registers. + */ +extern void SystemCoreClockUpdate (void); + +#ifdef __cplusplus +} +#endif + +#endif /* __SYSTEM_CORE_INIT_H__ */ diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/flash_api_qspi.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/flash_api_qspi.c new file mode 100644 index 00000000000..1ce1ccbd918 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/flash_api_qspi.c @@ -0,0 +1,136 @@ +/* mbed Microcontroller Library + * Copyright (c) 2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "device.h" +#include "flash_layout.h" +#include "flash_api.h" + +#if DEVICE_FLASH + +int32_t flash_init(flash_t *obj) +{ + (void)(obj); + enum mt25ql_error_t err = MT25QL_ERR_NONE; + + qspi_ip6514e_enable(FLASH_DEV.controller); + + /* Configure QSPI Flash controller to operate in single SPI mode and + * to use fast Flash commands */ + err = mt25ql_config_mode(&FLASH_DEV, MT25QL_FUNC_STATE_FAST); + if (err != MT25QL_ERR_NONE) { + return -1; + } + + return 0; +} + +int32_t flash_free(flash_t *obj) +{ + (void)(obj); + enum mt25ql_error_t err = MT25QL_ERR_NONE; + + /* Restores the QSPI Flash controller and MT25QL to reset state */ + err = mt25ql_restore_reset_state(&FLASH_DEV); + if (err != MT25QL_ERR_NONE) { + return -1; + } + + return 0; +} + +int32_t flash_erase_sector(flash_t *obj, uint32_t address) +{ + (void)(obj); + enum mt25ql_error_t err = MT25QL_ERR_NONE; + + address -= FLASH_DEV.direct_access_start_addr; + + err = mt25ql_erase(&FLASH_DEV, address, MT25QL_ERASE_SUBSECTOR_4K); + if (err != MT25QL_ERR_NONE) { + return -1; + } + + return 0; +} + +int32_t flash_read(flash_t *obj, uint32_t address, + uint8_t *data, uint32_t size) +{ + (void)obj; + enum mt25ql_error_t err = MT25QL_ERR_NONE; + + address -= FLASH_DEV.direct_access_start_addr; + + err = mt25ql_command_read(&FLASH_DEV, address, data, size); + if (err != MT25QL_ERR_NONE) { + return -1; + } + + return 0; +} + +int32_t flash_program_page(flash_t *obj, uint32_t address, const uint8_t *data, uint32_t size) +{ + (void)(obj); + enum mt25ql_error_t err = MT25QL_ERR_NONE; + + address -= FLASH_DEV.direct_access_start_addr; + + err = mt25ql_command_write(&FLASH_DEV, address, data, size); + if (err != MT25QL_ERR_NONE) { + return -1; + } + + return 0; +} + +uint32_t flash_get_sector_size(const flash_t *obj, uint32_t address) +{ + (void)(obj); + if ((address >= NS_QSPI_ALIAS_BASE) && (address < NS_QSPI_ALIAS_BASE + QSPI_FLASH_TOTAL_SIZE)) { + return SUBSECTOR_4KB; + } + + return MBED_FLASH_INVALID_SIZE; +} + +uint32_t flash_get_page_size(const flash_t *obj) +{ + (void)(obj); + return FLASH_PAGE_SIZE; +} + +uint32_t flash_get_start_address(const flash_t *obj) +{ + (void)(obj); + return NS_QSPI_ALIAS_BASE; +} + +uint32_t flash_get_size(const flash_t *obj) +{ + (void)(obj); + return QSPI_FLASH_TOTAL_SIZE; +} + +uint8_t flash_get_erase_value(const flash_t *obj) +{ + (void)obj; + return 0xFF; +} + +#endif // DEVICE_FLASH diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/gpio_api_ns.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/gpio_api_ns.c new file mode 100644 index 00000000000..aa09bc18dbf --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/gpio_api_ns.c @@ -0,0 +1,141 @@ +/* mbed Microcontroller Library + * Copyright (c) 2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * This file implements APIS defined in hal/gpio_api.h + * Note: Due to a HW limitation, GPIO in Musca-S1 is Secure only, so secure + * service should be used for GPIO in NS domain. + */ + +#include +#include "gpio_api.h" +#include "pinmap.h" +#include "objects.h" +#include "mbed_error.h" +#include "mbed_assert.h" +#include "rtx_lib.h" +#include "tfm_platform_api.h" +#include "tfm_ioctl_api.h" + +#define RETURN_VOID_true return; +#define RETURN_VOID_false return 0; + +#define IRQ_MODE_CHECK(is_func_void) \ + /* Secure service can't be called in interrupt context. */ \ + if (IsIrqMode()) { \ + MBED_WARNING(MBED_MAKE_ERROR(MBED_MODULE_HAL, \ + MBED_ERROR_INVALID_OPERATION), \ + "GPIO secure service can't be called in interrupt context\n"); \ + RETURN_VOID_ ## is_func_void \ + } + + +uint32_t gpio_set(PinName pin) +{ + pin_function(pin, (int)PRIMARY_FUNC); + + /* Return the correct mask of the given PIN */ + return (1 << GPIO_PIN_NUMBER(pin)); + +} + +void gpio_init(gpio_t *obj, PinName pin) +{ + obj->pin_num = (uint32_t)NC; + uint32_t result = 0; + enum tfm_platform_err_t ret = TFM_PLATFORM_ERR_SUCCESS; + + if (pin >= PA0 && pin <= PA15) { + IRQ_MODE_CHECK(true); + ret = tfm_platform_gpio_init(&result); + if (ret || result) { + return; + } + + obj->pin_num = pin; + /* GPIO is input by default */ + obj->direction = PIN_INPUT; + return; + } +} + +void gpio_mode(gpio_t *obj, PinMode mode) +{ + pin_mode(obj->pin_num, mode); + +} + +void gpio_dir(gpio_t *obj, PinDirection direction) +{ + uint32_t pin_dir = (direction == PIN_INPUT ? 0 : 1); + uint32_t result = 0; + enum tfm_platform_err_t ret = TFM_PLATFORM_ERR_SUCCESS; + + IRQ_MODE_CHECK(true); + + ret = tfm_platform_gpio_pin_config(obj->pin_num, pin_dir, &result); + if (ret || result) { + error("gpio_dir failed, error %d, gpio error %d", ret, result); + } + obj->direction = direction; +} + + +int gpio_is_connected(const gpio_t *obj) +{ + if (obj->pin_num == (uint32_t)NC) { + return 0; + } else { + return 1; + } + +} + +void gpio_write(gpio_t *obj, int value) +{ + enum tfm_platform_err_t ret = TFM_PLATFORM_ERR_SUCCESS; + uint32_t result = 0; + + IRQ_MODE_CHECK(true); + + ret = tfm_platform_gpio_pin_write(obj->pin_num, (uint32_t)value, &result); + + if (ret || result) { + error("Can not write pin %d; error %d, gpio error %d", + obj->pin_num, ret, result); + } + +} + +int gpio_read(gpio_t *obj) +{ + enum tfm_platform_err_t ret = TFM_PLATFORM_ERR_SUCCESS; + uint32_t result = 0; + uint32_t data = 0; + + IRQ_MODE_CHECK(false); + + ret = tfm_platform_gpio_pin_read(obj->pin_num, &data, &result); + + /* The valid return values of this API are 0 and 1 */ + if (ret || result) { + return 0; + } else { + return data; + } +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/gpio_irq_api.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/gpio_irq_api.c new file mode 100644 index 00000000000..9d98f8defff --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/gpio_irq_api.c @@ -0,0 +1,71 @@ +/* mbed Microcontroller Library + * Copyright (c) 2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * This file implements APIS defined in hal/gpio_irq_api.h + * Note: Due to a HW limitation, GPIO in Musca-S1 is Secure only, in NS domain, + * GPIO platform service is used. The current implementation of GPIO + * platform service does not support IRQ handling. + */ + +#include +#include "gpio_irq_api.h" +#include "objects.h" +#include "mbed_error.h" + +int gpio_irq_init(gpio_irq_t *obj, PinName pin, gpio_irq_handler handler, + uint32_t id) +{ + /* Due to a HW limitation, GPIO in Musca-S1 is Secure only, in NS domain, + * GPIO platform service is used. The current implementation of GPIO + * platform service does not support IRQ handling. + */ + return 0; +} + +void gpio_irq_free(gpio_irq_t *obj) +{ + /* Due to a HW limitation, GPIO in Musca-S1 is Secure only, in NS domain, + * GPIO platform service is used. The current implementation of GPIO + * platform service does not support IRQ handling. + */ +} + +void gpio_irq_set(gpio_irq_t *obj, gpio_irq_event event, uint32_t enable) +{ + /* Due to a HW limitation, GPIO in Musca-S1 is Secure only, in NS domain, + * GPIO platform service is used. The current implementation of GPIO + * platform service does not support IRQ handling. + */ +} + +void gpio_irq_enable(gpio_irq_t *obj) +{ + /* Due to a HW limitation, GPIO in Musca-S1 is Secure only, in NS domain, + * GPIO platform service is used. The current implementation of GPIO + * platform service does not support IRQ handling. + */ +} + +void gpio_irq_disable(gpio_irq_t *obj) +{ + /* Due to a HW limitation, GPIO in Musca-S1 is Secure only, in NS domain, + * GPIO platform service is used. The current implementation of GPIO + * platform service does not support IRQ handling. + */ +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/gpio_object.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/gpio_object.h new file mode 100644 index 00000000000..bfbc072c849 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/gpio_object.h @@ -0,0 +1,51 @@ +/* mbed Microcontroller Library + * Copyright (c) 2019-2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MBED_GPIO_OBJECT_H +#define MBED_GPIO_OBJECT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define GPIO_PIN_NUMBER(pin) ((pin) & 0xF) + +#define PINS_NUMBER (16) + +/** + * \brief Object to store GPIO specific data through the configuration + */ +typedef struct gpio_s { + struct gpio_cmsdk_dev_t *gpio_dev; + uint32_t pin_num; + PinDirection direction; +} gpio_t; + + +struct gpio_irq_s { + /** GPIO is not available in Musca-S1 in non-secure domain, so this dummy + * structure is needed for successful build. + */ + uint32_t dummy; +}; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/i2c_api.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/i2c_api.c new file mode 100644 index 00000000000..a811eb00e7c --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/i2c_api.c @@ -0,0 +1,427 @@ +/* mbed Microcontroller Library + * Copyright (c) 2017-2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "i2c_api.h" +#include "mbed_error.h" +#include "i2c_ip6510_drv.h" +#include "objects.h" +#include "pinmap.h" +#include "PeripheralNames.h" + +/* Return error codes for the i2c_byte_write api */ +#define BYTE_TRANSFER_ERR_NACK (0) +#define BYTE_TRANSFER_ERR_NONE (1) +#define BYTE_TRANSFER_ERR_TIMEOUT (2) + +/* Macros for frequency configuration */ +#define I2C_SPEED_100KHZ (100000) +#define I2C_SPEED_400KHZ (400000) + +#if DEVICE_I2CSLAVE +/* Return values for slave addressing specified in mbed I2C slave driver */ +#define I2C_SLAVE_READ_ADDRESS (1) +#define I2C_SLAVE_WRITE_ALL_ADDRESS (2) +#define I2C_SLAVE_WRITE_ADDRESS (3) +#define I2C_SLAVE_NOT_ADDRESSED (0) +#endif + +extern const PinMap PinMap_I2C_SDA[]; +extern const PinMap PinMap_I2C_SCL[]; + +/* Extend the return values defined in i2c_api.h */ +enum { + I2C_ERROR_NONE = 0, + /* I2C_ERROR_NO_SLAVE = -1, + * I2C_ERROR_BUS_BUSY = -2, */ + I2C_ERROR_GENERAL = -3 +}; + +void i2c_init(i2c_t *obj, PinName sda, PinName scl) +{ + enum i2c_ip6510_error_t ret; + + /* Determine the I2C to use */ + I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA); + I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL); + I2CName i2c = (I2CName)pinmap_merge(i2c_sda, i2c_scl); + if (i2c == (I2CName)NC) { + error("I2C pinout mapping failed, invalid pins."); + return; + } + + /* Initialize the parent object */ + switch (i2c) { +#ifdef I2C0_IP6510_DEV + case I2C_0: + obj->dev = &I2C0_IP6510_DEV; + break; +#endif +#ifdef I2C1_IP6510_DEV + case I2C_1: + obj->dev = &I2C1_IP6510_DEV; + break; +#endif + default: + error("Failed to initialize I2C, bad reference."); + return; + } + obj->last_address = 0U; + obj->sda = sda; + obj->scl = scl; + obj->byte_state = BYTE_TRANSFER_STATE_NONE; + + /* If already init, uninit */ + if (i2c_ip6510_get_state(obj->dev) == I2C_IP6510_INITIALIZED) { + i2c_ip6510_uninit(obj->dev); + } + + /* Set the GPIO pins */ + pinmap_pinout(sda, PinMap_I2C_SDA); + pinmap_pinout(scl, PinMap_I2C_SCL); + + /* Initialize peripheral */ + ret = i2c_ip6510_init(obj->dev, SystemCoreClock); + i2c_ip6510_set_speed(obj->dev, I2C_IP6510_SPEED_100KHZ); + i2c_ip6510_set_timeout(obj->dev, 0xFFU); + + if (ret != I2C_IP6510_ERR_NONE) { + error("Failed to initialize I2C, error occured in native driver."); + return; + } +} + +void i2c_frequency(i2c_t *obj, int hz) +{ + /* The peripheral only supports 100k and 400k clock in master mode */ + switch (hz) { + case I2C_SPEED_100KHZ: + i2c_ip6510_set_speed(obj->dev, I2C_IP6510_SPEED_100KHZ); + break; + + case I2C_SPEED_400KHZ: + i2c_ip6510_set_speed(obj->dev, I2C_IP6510_SPEED_400KHZ); + break; + + default: + error("Invalid I2C frequency."); + return; + } +} + +void i2c_reset(i2c_t *obj) +{ + i2c_ip6510_uninit(obj->dev); + i2c_init(obj, obj->sda, obj->scl); +} + +int i2c_read(i2c_t *obj, int address, char *data, int length, int stop) +{ + enum i2c_ip6510_error_t ret; + + /* Shifted 8 bit address is used in upper layer */ + address = ((uint32_t)address)>>1; + + ret = i2c_ip6510_master_read(obj->dev, (uint16_t)address, (uint8_t*)data, + stop, (uint32_t*)(&length)); + + if (ret != I2C_IP6510_ERR_NONE) { + return I2C_ERROR_GENERAL; + } + + return length; +} + +int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop) +{ + enum i2c_ip6510_error_t ret; + + /* Shifted 8 bit address is used in upper layer */ + address = ((uint32_t)address)>>1; + + /* Parameter checking */ + if (data == NULL || length == 0) { + ret = i2c_ip6510_monitor_slave(obj->dev, (uint16_t)address); + if (ret != I2C_IP6510_ERR_NONE) { + return I2C_ERROR_NO_SLAVE; + } + return length; + } + + ret = i2c_ip6510_master_write(obj->dev, (uint16_t)address, (uint8_t*)data, + stop, (uint32_t*)(&length)); + + if (ret != I2C_IP6510_ERR_NONE) { + return I2C_ERROR_GENERAL; + } + return length; +} + +int i2c_start(i2c_t *obj) +{ + /** \note The peripheral does not support building up the transaction by + * instructions. The functionality is achieved with a software + * state machine. + * The i2c transaction is started later, when the address and the + * first data byte is written. + */ + obj->byte_state = BYTE_TRANSFER_STATE_START; + obj->last_address = 0U; + i2c_ip6510_hold_enable(obj->dev); + + return I2C_ERROR_NONE; +} + +int i2c_stop(i2c_t *obj) +{ + /* Both the master and slave api calls this function */ + if (i2c_ip6510_get_device_mode(obj->dev) == I2C_IP6510_MASTER_MODE) { + + /** \note The peripheral does not support building up the transaction by + * instructions. The functionality is achieved with a software + * state machine. + * STOP condition is generated on hold disable. + */ + i2c_ip6510_hold_disable(obj->dev); + + /* If there was only one byte written (the slave address) before calling + * stop, the state machine is in ADDRESS state. Writing just the address + * is equal to a slave monitoring + */ + if (obj->byte_state == BYTE_TRANSFER_STATE_ADDRESS) { + /* Return value is not needed because signalling to the caller is + * not defined + */ + (void)i2c_ip6510_monitor_slave(obj->dev, obj->last_address); + } + + obj->byte_state = BYTE_TRANSFER_STATE_NONE; + obj->last_address = 0U; + + } else { + /* In slave mode the the I2C controller only writes and reads data from + * the I2C bus. The function just clears the interrupts for + * further adressing detection. + */ + i2c_ip6510_clear_irq(obj->dev, I2C_IP6510_ALL_INTR_MASK); + } + return I2C_ERROR_NONE; +} + +int i2c_byte_read(i2c_t *obj, int last) +{ + uint8_t read_byte = 0U; + uint32_t slave_read_cntr = 1U; + + /* Both the master and slave api calls this function */ + if (i2c_ip6510_get_device_mode(obj->dev) == I2C_IP6510_MASTER_MODE) { + + /** \note The peripheral does not support building up the transaction by + * instructions. The functionality is achieved with a software + * state machine. + */ + switch (obj->byte_state) { + case BYTE_TRANSFER_STATE_ADDRESS: + obj->byte_state = BYTE_TRANSFER_STATE_DATA; + i2c_ip6510_master_byte_read( + obj->dev, obj->last_address, last, true, &read_byte); + return read_byte; + + case BYTE_TRANSFER_STATE_DATA: + i2c_ip6510_master_byte_read( + obj->dev, obj->last_address, last, false, &read_byte); + return read_byte; + + case BYTE_TRANSFER_STATE_NONE: + case BYTE_TRANSFER_STATE_START: + default: + /* Reading is invalid in these states */ + return I2C_ERROR_GENERAL; + } + } else { + /* In slave mode the driver only writes and reads data from the + * I2C controller, no need to track states. + */ + i2c_ip6510_slave_read( + obj->dev, &read_byte, &slave_read_cntr); + return read_byte; + } +} + +int i2c_byte_write(i2c_t *obj, int data) +{ + enum i2c_ip6510_error_t ret = I2C_IP6510_ERR_NONE; + uint32_t slave_write_cntr = 1U; + + /* Both the master and slave api calls this function */ + if (i2c_ip6510_get_device_mode(obj->dev) == I2C_IP6510_MASTER_MODE) { + + /** \note The peripheral does not support building up the transaction by + * instructions. The functionality is achieved with a software + * state machine. + */ + switch (obj->byte_state) { + case BYTE_TRANSFER_STATE_NONE: + /* Writing is invalid before start symbol + * BYTE_TRANSFER_ERR_TIMEOUT is the only error code mbed defines, + * this is the only way to signal an error + */ + return BYTE_TRANSFER_ERR_TIMEOUT; + + case BYTE_TRANSFER_STATE_START: + obj->byte_state = BYTE_TRANSFER_STATE_ADDRESS; + obj->last_address = ((uint32_t)data)>>1; + return BYTE_TRANSFER_ERR_NONE; + + case BYTE_TRANSFER_STATE_ADDRESS: + obj->byte_state = BYTE_TRANSFER_STATE_DATA; + ret = i2c_ip6510_master_byte_write( + obj->dev, obj->last_address, (uint8_t*)&data, true); + break; + + case BYTE_TRANSFER_STATE_DATA: + ret = i2c_ip6510_master_byte_write( + obj->dev, obj->last_address, (uint8_t*)&data, false); + break; + + default: + return BYTE_TRANSFER_ERR_TIMEOUT; + } + } else { + /* In slave mode the driver only writes and reads data from the + * I2C controller, no need to track states. + */ + ret = i2c_ip6510_slave_write( + obj->dev, (uint8_t*)&data, &slave_write_cntr); + } + + if (ret != I2C_IP6510_ERR_NONE) { + /* No need to reset the state machine. The host might try to resend + * the data byte. Also the start and stop functions reset the states. + */ + if (ret == I2C_IP6510_ERR_NACK) { + return BYTE_TRANSFER_ERR_NACK; + } + return BYTE_TRANSFER_ERR_TIMEOUT; + } + return BYTE_TRANSFER_ERR_NONE; +} + +#if DEVICE_I2CSLAVE + +void i2c_slave_mode(i2c_t *obj, int enable_slave) +{ + if (!enable_slave) { + /* Check if master mode is already set */ + if (i2c_ip6510_get_device_mode(obj->dev) != I2C_IP6510_MASTER_MODE) { + /* Set Master Mode */ + i2c_ip6510_set_master_mode(obj->dev); + } + } else { + /* Check if slave mode is already set */ + if (i2c_ip6510_get_device_mode(obj->dev) != I2C_IP6510_SLAVE_MODE) { + /* Set Slave Mode */ + i2c_ip6510_set_slave_mode(obj->dev, obj->last_address); + } + } +} + +int i2c_slave_receive(i2c_t *obj) +{ + uint32_t irq_status = i2c_ip6510_get_irq_status(obj->dev); + enum i2c_ip6510_transf_dir_t dir = i2c_ip6510_get_slave_tranf_dir(obj->dev); + uint32_t transfer_size = i2c_ip6510_get_transfer_size(obj->dev); + + if (irq_status & I2C_IP6510_INTR_DATA_MASK) { + + if (dir == I2C_IP6510_TRANSMITTER) { + /* Slave is adressed for writing */ + return I2C_SLAVE_WRITE_ADDRESS; + } + if ((dir == I2C_IP6510_RECEIVER) && (transfer_size != 0U)) { + /* Slave is adressed for reading */ + return I2C_SLAVE_READ_ADDRESS; + } + } + + if ((irq_status & I2C_IP6510_INTR_COMP_MASK) + && (dir == I2C_IP6510_RECEIVER) && (transfer_size != 0U)) { + /* An I2C transfer is complete with less then FIFO_SIZE-2 bytes */ + return I2C_SLAVE_READ_ADDRESS; + } + + return I2C_SLAVE_NOT_ADDRESSED; +} + +int i2c_slave_read(i2c_t *obj, char *data, int length) +{ + enum i2c_ip6510_error_t ret; + + ret = i2c_ip6510_slave_read( + obj->dev, (uint8_t*)data, (uint32_t*)&length); + i2c_ip6510_clear_irq(obj->dev, I2C_IP6510_ALL_INTR_MASK); + + if (ret != I2C_IP6510_ERR_NONE) { + return 0; + } + + return length; +} + +int i2c_slave_write(i2c_t *obj, const char *data, int length) +{ + enum i2c_ip6510_error_t ret; + + ret = i2c_ip6510_slave_write( + obj->dev, (uint8_t*)data, (uint32_t*)&length); + i2c_ip6510_clear_irq(obj->dev, I2C_IP6510_ALL_INTR_MASK); + + if (ret != I2C_IP6510_ERR_NONE) { + return 0; + } + + return length; +} + +void i2c_slave_address(i2c_t *obj, int idx, uint32_t address, uint32_t mask) +{ + /* Shifted 8 bit address is used in upper layer */ + i2c_ip6510_set_slave_mode(obj->dev, ((uint16_t)address)>>1); + obj->last_address = address>>1; +} + +const PinMap *i2c_slave_sda_pinmap() +{ + return PinMap_I2C_SDA; +} + +const PinMap *i2c_slave_scl_pinmap() +{ + return PinMap_I2C_SCL; +} + +#endif + +const PinMap *i2c_master_sda_pinmap() +{ + return PinMap_I2C_SDA; +} + +const PinMap *i2c_master_scl_pinmap() +{ + return PinMap_I2C_SCL; +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/lp_ticker.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/lp_ticker.c new file mode 100644 index 00000000000..6b06f1a0834 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/lp_ticker.c @@ -0,0 +1,91 @@ +/* mbed Microcontroller Library + * Copyright (c) 2019 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Low-power elapsed time measure and interval ticker, + * using General Purpose Timer \ref timer_gp_dev_t. + */ + +#include "cmsis.h" +#include "device_cfg.h" +#include "timer_gp_drv.h" +#include "lp_ticker_api.h" + +/* Check if the module configuration is right. These definitions + are usually located in device_cfg.h */ +#ifndef GP_TIMER_DEV +#error "Configuration macro GP_TIMER_DEV is undefined!" +#endif + +void lp_ticker_init(void) +{ + timer_gp_init(&GP_TIMER_DEV); + NVIC_EnableIRQ(GP_TIMER_ALARM0_IRQ); + timer_gp_interrupt_disable(&GP_TIMER_DEV, GP_TIMER_ALARM_NR); +} + +void lp_ticker_free(void) +{ + /* This function should stop the ticker from counting, but GP Timer cannot + * be stopped. + */ + timer_gp_interrupt_disable(&GP_TIMER_DEV, GP_TIMER_ALARM_NR); +} + +uint32_t lp_ticker_read(void) +{ + return timer_gp_get_counter(&GP_TIMER_DEV); +} + +void lp_ticker_set_interrupt(timestamp_t timestamp) +{ + timer_gp_set_alarm_value(&GP_TIMER_DEV, GP_TIMER_ALARM_NR, (uint32_t)timestamp); + timer_gp_interrupt_enable(&GP_TIMER_DEV, GP_TIMER_ALARM_NR); +} + +void lp_ticker_disable_interrupt(void) +{ + timer_gp_interrupt_disable(&GP_TIMER_DEV, GP_TIMER_ALARM_NR); +} + +void lp_ticker_clear_interrupt(void) +{ + timer_gp_interrupt_clear(&GP_TIMER_DEV, GP_TIMER_ALARM_NR); +} + +void lp_ticker_fire_interrupt(void) +{ + NVIC_SetPendingIRQ(GP_TIMER_ALARM0_IRQ); +} + +const ticker_info_t* lp_ticker_get_info(void) +{ + static const ticker_info_t info = { + GP_TIMER_FREQ_HZ, + GP_TIMER_BIT_WIDTH + }; + return &info; +} + +#ifndef GP_TIMER_IRQ0_HANDLER +#error "GP_TIMER_IRQ0_HANDLER should be defined, check device_cfg.h!" +#endif +void GP_TIMER_IRQ0_HANDLER(void) +{ + lp_ticker_irq_handler(); +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/mbed_serial_platform.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/mbed_serial_platform.c new file mode 100644 index 00000000000..ae49d67d410 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/mbed_serial_platform.c @@ -0,0 +1,139 @@ +/* mbed Microcontroller Library + * Copyright (c) 2017-2019 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "mbed_error.h" +#include "mbed_serial_platform.h" +#include "serial_api.h" + +#define UART_DEVICES_NUMBER 2 + +struct uart_irq_t uart_irq[UART_DEVICES_NUMBER]; + +const PinMap PinMap_UART_TX[] = { + {UART0_TX, UART_0, ALTERNATE_FUNC_1}, + {UART1_TX, UART_1, PRIMARY_FUNC}, + {NC, NC, 0} +}; + +const PinMap PinMap_UART_RX[] = { + {UART0_RX, UART_0, ALTERNATE_FUNC_1}, + {UART1_RX, UART_1, PRIMARY_FUNC}, + {NC, NC, 0} +}; + +const PinMap *serial_tx_pinmap() +{ + return PinMap_UART_TX; +} + +const PinMap *serial_rx_pinmap() +{ + return PinMap_UART_RX; +} + +#ifdef UART0_PL011_DEV +#ifndef uart0_tx_irq_handler +#error "uart0_tx_irq_handler should be defined, check device_cfg.h!" +#endif +void uart0_tx_irq_handler(void) +{ + uart_pl011_clear_intr(&UART0_PL011_DEV, UART_PL011_TX_INTR_MASK); + if(uart_irq[UART_0].handler != 0) { + uart_irq[UART_0].handler(uart_irq[UART_0].id, TxIrq); + } +} + +#ifndef uart0_rx_irq_handler +#error "uart0_rx_irq_handler should be defined, check device_cfg.h!" +#endif +void uart0_rx_irq_handler(void) +{ + uart_pl011_clear_intr(&UART0_PL011_DEV, UART_PL011_RX_INTR_MASK); + if(uart_irq[UART_0].handler != 0) { + uart_irq[UART_0].handler(uart_irq[UART_0].id, RxIrq); + } +} + +#ifndef uart0_rx_timeout_irq_handler +#error "uart0_rx_timeout_irq_handler should be defined, check device_cfg.h!" +#endif +void uart0_rx_timeout_irq_handler(void) +{ + if(uart_irq[UART_0].handler != 0) { + uart_irq[UART_0].handler(uart_irq[UART_0].id, RxIrq); + } +} +#endif + +#ifdef UART1_PL011_DEV +#ifndef uart1_tx_irq_handler +#error "uart1_tx_irq_handler should be defined, check device_cfg.h!" +#endif +void uart1_tx_irq_handler(void) +{ + uart_pl011_clear_intr(&UART1_PL011_DEV, UART_PL011_TX_INTR_MASK); + if(uart_irq[UART_1].handler != 0) { + uart_irq[UART_1].handler(uart_irq[UART_1].id, TxIrq); + } +} + +#ifndef uart1_rx_irq_handler +#error "uart1_rx_irq_handler should be defined, check device_cfg.h!" +#endif +void uart1_rx_irq_handler(void) +{ + uart_pl011_clear_intr(&UART1_PL011_DEV, UART_PL011_RX_INTR_MASK); + if(uart_irq[UART_1].handler != 0) { + uart_irq[UART_1].handler(uart_irq[UART_1].id, RxIrq); + } +} + +#ifndef uart1_rx_timeout_irq_handler +#error "uart1_rx_timeout_irq_handler should be defined, check device_cfg.h!" +#endif +void uart1_rx_timeout_irq_handler(void) +{ + if(uart_irq[UART_1].handler != 0) { + uart_irq[UART_1].handler(uart_irq[UART_1].id, RxIrq); + } +} +#endif + +void mbed_uart_platform_init(serial_t *obj, UARTName uart) +{ + switch (uart) { +#ifdef UART0_PL011_DEV + case UART_0: + obj->uart_dev = &UART0_PL011_DEV; + obj->tx_irq = UART0_Tx_IRQn; + obj->rx_irq = UART0_Rx_IRQn; + obj->rx_timeout_irq = UART0_RxTimeout_IRQn; + break; +#endif +#ifdef UART1_PL011_DEV + case UART_1: + obj->uart_dev = &UART1_PL011_DEV; + obj->tx_irq = UART1_Tx_IRQn; + obj->rx_irq = UART1_Rx_IRQn; + obj->rx_timeout_irq = UART1_RxTimeout_IRQn; + break; +#endif + default: + error("serial_init: No uart selected"); + } +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/mbed_serial_platform.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/mbed_serial_platform.h new file mode 100644 index 00000000000..15fa82550cc --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/mbed_serial_platform.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2018-2019 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __MBED_SERIAL_PLATFORM_H__ +#define __MBED_SERIAL_PLATFORM_H__ + +#include "serial_api.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct uart_irq_t { + uart_irq_handler handler; + uint32_t id; +}; + +/* Handlers registered */ +extern struct uart_irq_t uart_irq[]; + +void mbed_uart_platform_init(serial_t *obj, UARTName uart); + +#ifdef __cplusplus +} +#endif + +#endif /* __SERIAL_PLATFORM_H__ */ diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/mcuboot.bin b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/mcuboot.bin new file mode 100644 index 0000000000000000000000000000000000000000..ed2cb0a0e241a7753bc93ad8a2847899f1f545e3 GIT binary patch literal 40060 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 \ + FLASH_NS_PARTITION_SIZE) ? \ + FLASH_S_PARTITION_SIZE : \ + FLASH_NS_PARTITION_SIZE) + +/* Sector size of the flash hardware */ +#define FLASH_AREA_IMAGE_SECTOR_SIZE (0x1000) /* 4KB */ +#define FLASH_TOTAL_SIZE (0x200000) /* MRAM size 2MB */ + +/* Flash layout info for BL2 bootloader */ +#define FLASH_BASE_ADDRESS (0x1A000000) /* MRAM base address */ + +/* Offset and size definitions of the flash partitions that are handled by the + * bootloader. The image swapping is done between IMAGE_PRIMARY and + * IMAGE_SECONDARY, SCRATCH is used as a temporary storage during image + * swapping. + */ +#define FLASH_AREA_BL2_OFFSET (0x0) +#define FLASH_AREA_BL2_SIZE (0x20000) /* 128KB */ + +#if !defined(MCUBOOT_IMAGE_NUMBER) || (MCUBOOT_IMAGE_NUMBER == 1) +/* Secure + Non-secure image primary slot */ +#define FLASH_AREA_0_ID (1) +#define FLASH_AREA_0_OFFSET (FLASH_AREA_BL2_OFFSET + FLASH_AREA_BL2_SIZE) +#define FLASH_AREA_0_SIZE (FLASH_S_PARTITION_SIZE + \ + FLASH_NS_PARTITION_SIZE) +/* Secure + Non-secure secondary slot */ +#define FLASH_AREA_2_ID (FLASH_AREA_0_ID + 1) +#define FLASH_AREA_2_OFFSET (FLASH_AREA_0_OFFSET + FLASH_AREA_0_SIZE) +#define FLASH_AREA_2_SIZE (FLASH_S_PARTITION_SIZE + \ + FLASH_NS_PARTITION_SIZE) + +/* Scratch area */ +#define FLASH_AREA_SCRATCH_ID (FLASH_AREA_2_ID + 1) +#define FLASH_AREA_SCRATCH_OFFSET (FLASH_AREA_2_OFFSET + FLASH_AREA_2_SIZE) +#define FLASH_AREA_SCRATCH_SIZE (4 * FLASH_AREA_IMAGE_SECTOR_SIZE) +/* The maximum number of status entries supported by the bootloader. */ +#define MCUBOOT_STATUS_MAX_ENTRIES ((FLASH_S_PARTITION_SIZE + \ + FLASH_NS_PARTITION_SIZE) / \ + FLASH_AREA_SCRATCH_SIZE) +/* Maximum number of image sectors supported by the bootloader. */ +#define MCUBOOT_MAX_IMG_SECTORS ((FLASH_S_PARTITION_SIZE + \ + FLASH_NS_PARTITION_SIZE) / \ + FLASH_AREA_IMAGE_SECTOR_SIZE) +#elif (MCUBOOT_IMAGE_NUMBER == 2) +/* Secure image primary slot */ +#define FLASH_AREA_0_ID (1) +#define FLASH_AREA_0_OFFSET (FLASH_AREA_BL2_OFFSET + FLASH_AREA_BL2_SIZE) +#define FLASH_AREA_0_SIZE (FLASH_S_PARTITION_SIZE) +/* Non-secure image primary slot */ +#define FLASH_AREA_1_ID (FLASH_AREA_0_ID + 1) +#define FLASH_AREA_1_OFFSET (FLASH_AREA_0_OFFSET + FLASH_AREA_0_SIZE) +#define FLASH_AREA_1_SIZE (FLASH_NS_PARTITION_SIZE) +/* Secure image secondary slot */ +#define FLASH_AREA_2_ID (FLASH_AREA_1_ID + 1) +#define FLASH_AREA_2_OFFSET (FLASH_AREA_1_OFFSET + FLASH_AREA_1_SIZE) +#define FLASH_AREA_2_SIZE (FLASH_S_PARTITION_SIZE) +/* Non-secure image secondary slot */ +#define FLASH_AREA_3_ID (FLASH_AREA_2_ID + 1) +#define FLASH_AREA_3_OFFSET (FLASH_AREA_2_OFFSET + FLASH_AREA_2_SIZE) +#define FLASH_AREA_3_SIZE (FLASH_NS_PARTITION_SIZE) +/* Scratch area */ +#define FLASH_AREA_SCRATCH_ID (FLASH_AREA_3_ID + 1) +#define FLASH_AREA_SCRATCH_OFFSET (FLASH_AREA_3_OFFSET + FLASH_AREA_3_SIZE) +#define FLASH_AREA_SCRATCH_SIZE (4 * FLASH_AREA_IMAGE_SECTOR_SIZE) +/* The maximum number of status entries supported by the bootloader. */ +#define MCUBOOT_STATUS_MAX_ENTRIES (FLASH_MAX_PARTITION_SIZE / \ + FLASH_AREA_SCRATCH_SIZE) +/* Maximum number of image sectors supported by the bootloader. */ +#define MCUBOOT_MAX_IMG_SECTORS (FLASH_MAX_PARTITION_SIZE / \ + FLASH_AREA_IMAGE_SECTOR_SIZE) +#else /* MCUBOOT_IMAGE_NUMBER > 2 */ +#error "Only MCUBOOT_IMAGE_NUMBER 1 and 2 are supported!" +#endif /* MCUBOOT_IMAGE_NUMBER */ + +/* Note: FLASH_SST_AREA_OFFSET, FLASH_ITS_AREA_OFFSET and + * FLASH_NV_COUNTERS_AREA_OFFSET point to offsets in flash, but reads and writes + * to these addresses are redirected to Code SRAM by Driver_Flash.c. + */ +#define FLASH_SST_AREA_OFFSET (FLASH_AREA_SCRATCH_OFFSET + \ + FLASH_AREA_SCRATCH_SIZE) +#define FLASH_SST_AREA_SIZE (0x5000) /* 20 KB */ + +/* Internal Trusted Storage (ITS) Service definitions */ +#define FLASH_ITS_AREA_OFFSET (FLASH_SST_AREA_OFFSET + \ + FLASH_SST_AREA_SIZE) +#define FLASH_ITS_AREA_SIZE (0x4000) /* 16 KB */ + +/* NV Counters definitions */ +#define FLASH_NV_COUNTERS_AREA_OFFSET (FLASH_ITS_AREA_OFFSET + \ + FLASH_ITS_AREA_SIZE) +#define FLASH_NV_COUNTERS_AREA_SIZE (FLASH_AREA_IMAGE_SECTOR_SIZE) + +/* TF-M crypto key area definitions */ +#define FLASH_TFM_CRYPTO_KEY_AREA_OFFSET (FLASH_NV_COUNTERS_AREA_OFFSET + \ + FLASH_NV_COUNTERS_AREA_SIZE) +#define FLASH_TFM_CRYPTO_KEY_AREA_SIZE (0x100) + +/* Offset and size definition in flash area used by assemble.py */ +#define SECURE_IMAGE_OFFSET (0x0) +#define SECURE_IMAGE_MAX_SIZE FLASH_S_PARTITION_SIZE + +#define NON_SECURE_IMAGE_OFFSET (SECURE_IMAGE_OFFSET + \ + SECURE_IMAGE_MAX_SIZE) +#define NON_SECURE_IMAGE_MAX_SIZE FLASH_NS_PARTITION_SIZE + +/* Flash device name used by BL2 + * Name is defined in flash driver file: Driver_Flash_MRAM.c + */ +#define FLASH_DEV_NAME Driver_FLASH0 + +/* Secure Storage (SST) Service definitions + * Note: Further documentation of these definitions can be found in the + * TF-M SST Integration Guide. + */ +#define SST_FLASH_DEV_NAME Driver_FLASH0 + +/* In this target the CMSIS driver requires only the offset from the base + * address instead of the full memory address. + */ +#define SST_FLASH_AREA_ADDR FLASH_SST_AREA_OFFSET +/* Dedicated flash area for SST */ +#define SST_FLASH_AREA_SIZE FLASH_SST_AREA_SIZE +#define SST_SECTOR_SIZE FLASH_AREA_IMAGE_SECTOR_SIZE +/* Number of SST_SECTOR_SIZE per block */ +#define SST_SECTORS_PER_BLOCK (0x1) +/* Specifies the smallest flash programmable unit in bytes */ +#define SST_FLASH_PROGRAM_UNIT (0x1) +/* The maximum asset size to be stored in the SST area */ +#define SST_MAX_ASSET_SIZE (2048) +/* The maximum number of assets to be stored in the SST area */ +#define SST_NUM_ASSETS (10) + +/* Internal Trusted Storage (ITS) Service definitions + * Note: Further documentation of these definitions can be found in the + * TF-M ITS Integration Guide. The ITS should be in the internal flash, but is + * allocated in the external flash just for development platforms that don't + * have internal flash available. + */ +#define ITS_FLASH_DEV_NAME Driver_FLASH0 + +/* In this target the CMSIS driver requires only the offset from the base + * address instead of the full memory address. + */ +#define ITS_FLASH_AREA_ADDR FLASH_ITS_AREA_OFFSET +/* Dedicated flash area for ITS */ +#define ITS_FLASH_AREA_SIZE FLASH_ITS_AREA_SIZE +#define ITS_SECTOR_SIZE FLASH_AREA_IMAGE_SECTOR_SIZE +/* Number of ITS_SECTOR_SIZE per block */ +#define ITS_SECTORS_PER_BLOCK (0x1) +/* Specifies the smallest flash programmable unit in bytes */ +#define ITS_FLASH_PROGRAM_UNIT (0x1) +/* The maximum asset size to be stored in the ITS area */ +#define ITS_MAX_ASSET_SIZE (512) +/* The maximum number of assets to be stored in the ITS area */ +#define ITS_NUM_ASSETS (10) + +/* NV Counters definitions */ +#define TFM_NV_COUNTERS_AREA_ADDR FLASH_NV_COUNTERS_AREA_OFFSET +#define TFM_NV_COUNTERS_AREA_SIZE (0x18) /* 24 Bytes */ +#define TFM_NV_COUNTERS_SECTOR_ADDR FLASH_NV_COUNTERS_AREA_OFFSET +#define TFM_NV_COUNTERS_SECTOR_SIZE FLASH_AREA_IMAGE_SECTOR_SIZE + +/* Use MRAM to store Code data */ +#define S_ROM_ALIAS_BASE (0x1A000000) +#define NS_ROM_ALIAS_BASE (0x0A000000) + +/* FIXME: Use SRAM2 memory to store RW data */ +#define S_RAM_ALIAS_BASE (0x30000000) +#define NS_RAM_ALIAS_BASE (0x20000000) + +#define TOTAL_ROM_SIZE FLASH_TOTAL_SIZE +#define TOTAL_RAM_SIZE (0x80000) /* 512 KB */ + +#endif /* __FLASH_LAYOUT_H__ */ diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/image_macros_preprocessed_ns.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/image_macros_preprocessed_ns.c new file mode 100644 index 00000000000..68ffe4a75c0 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/image_macros_preprocessed_ns.c @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +enum image_attributes { + RE_SECURE_IMAGE_OFFSET = (0x0), + RE_SECURE_IMAGE_MAX_SIZE = (0x60000), + RE_NON_SECURE_IMAGE_OFFSET = ((0x0) + (0x60000)), + RE_NON_SECURE_IMAGE_MAX_SIZE = (0x80000), + RE_SIGN_BIN_SIZE = ((0x80000)), +}; diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/image_macros_preprocessed_s.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/image_macros_preprocessed_s.c new file mode 100644 index 00000000000..bcc7223033f --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/image_macros_preprocessed_s.c @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +enum image_attributes { + RE_SECURE_IMAGE_OFFSET = (0x0), + RE_SECURE_IMAGE_MAX_SIZE = (0x60000), + RE_NON_SECURE_IMAGE_OFFSET = ((0x0) + (0x60000)), + RE_NON_SECURE_IMAGE_MAX_SIZE = (0x80000), + RE_SIGN_BIN_SIZE = ((0x60000)), +}; diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/region_defs.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/region_defs.h new file mode 100644 index 00000000000..207ce8067c8 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/region_defs.h @@ -0,0 +1,160 @@ +/* + * Copyright (c) 2017-2020 Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __REGION_DEFS_H__ +#define __REGION_DEFS_H__ + +#include "flash_layout.h" + +#define BL2_HEAP_SIZE (0x0001000) +#define BL2_MSP_STACK_SIZE (0x0001800) + +#define S_HEAP_SIZE (0x0001000) +#define S_MSP_STACK_SIZE_INIT (0x0000400) +#define S_MSP_STACK_SIZE (0x0000800) +#define S_PSP_STACK_SIZE (0x0000800) + +#define NS_HEAP_SIZE (0x0001000) +#define NS_MSP_STACK_SIZE (0x00000A0) +#define NS_PSP_STACK_SIZE (0x0000140) + +/* This size of buffer is big enough to store an attestation + * token produced by initial attestation service + */ +#define PSA_INITIAL_ATTEST_TOKEN_MAX_SIZE (0x250) + +/* + * MRAM MPC granularity is 4 KB on Musca. Alignment + * of partitions is defined in accordance with this constraint. + */ +#ifdef BL2 +#ifndef LINK_TO_SECONDARY_PARTITION +#define S_IMAGE_PRIMARY_PARTITION_OFFSET (FLASH_AREA_0_OFFSET) +#define S_IMAGE_SECONDARY_PARTITION_OFFSET (FLASH_AREA_2_OFFSET) +#else +#define S_IMAGE_PRIMARY_PARTITION_OFFSET (FLASH_AREA_2_OFFSET) +#define S_IMAGE_SECONDARY_PARTITION_OFFSET (FLASH_AREA_0_OFFSET) +#endif /* !LINK_TO_SECONDARY_PARTITION */ +#else +#define S_IMAGE_PRIMARY_PARTITION_OFFSET (0x0) +#endif /* BL2 */ + +#ifndef LINK_TO_SECONDARY_PARTITION +#define NS_IMAGE_PRIMARY_PARTITION_OFFSET (FLASH_AREA_0_OFFSET \ + + FLASH_S_PARTITION_SIZE) +#else +#define NS_IMAGE_PRIMARY_PARTITION_OFFSET (FLASH_AREA_2_OFFSET \ + + FLASH_S_PARTITION_SIZE) +#endif /* !LINK_TO_SECONDARY_PARTITION */ + +/* Boot partition structure if MCUBoot is used: + * 0x0_0000 Bootloader header + * 0x0_0400 Image area + * 0x1_FC00 Trailer + */ +/* IMAGE_CODE_SIZE is the space available for the software binary image. + * It is less than the FLASH_S_PARTITION_SIZE + FLASH_NS_PARTITION_SIZE + * because we reserve space for the image header and trailer introduced + * by the bootloader. + */ +#ifdef BL2 +#define BL2_HEADER_SIZE (0x400) /* 1 KB */ +#define BL2_TRAILER_SIZE (0x800) /* 2 KB */ +#else +/* No header if no bootloader, but keep IMAGE_CODE_SIZE the same */ +#define BL2_HEADER_SIZE (0x0) +#define BL2_TRAILER_SIZE (0xC00) +#endif /* BL2 */ + +#define IMAGE_S_CODE_SIZE \ + (FLASH_S_PARTITION_SIZE - BL2_HEADER_SIZE - BL2_TRAILER_SIZE) +#define IMAGE_NS_CODE_SIZE \ + (FLASH_NS_PARTITION_SIZE - BL2_HEADER_SIZE - BL2_TRAILER_SIZE) + +#define CMSE_VENEER_REGION_SIZE (0x340) + +/* Alias definitions for secure and non-secure areas*/ +#define S_ROM_ALIAS(x) (S_ROM_ALIAS_BASE + (x)) +#define NS_ROM_ALIAS(x) (NS_ROM_ALIAS_BASE + (x)) + +#define S_RAM_ALIAS(x) (S_RAM_ALIAS_BASE + (x)) +#define NS_RAM_ALIAS(x) (NS_RAM_ALIAS_BASE + (x)) + +/* Secure regions */ +#define S_IMAGE_PRIMARY_AREA_OFFSET \ + (S_IMAGE_PRIMARY_PARTITION_OFFSET + BL2_HEADER_SIZE) +#define S_CODE_START (S_ROM_ALIAS(S_IMAGE_PRIMARY_AREA_OFFSET)) +#define S_CODE_SIZE (IMAGE_S_CODE_SIZE - CMSE_VENEER_REGION_SIZE) +#define S_CODE_LIMIT (S_CODE_START + S_CODE_SIZE - 1) + +#define S_DATA_START (S_RAM_ALIAS(0x0)) +#define S_DATA_SIZE (TOTAL_RAM_SIZE / 2) +#define S_DATA_LIMIT (S_DATA_START + S_DATA_SIZE - 1) + +/* CMSE Veneers region */ +#define CMSE_VENEER_REGION_START (S_CODE_LIMIT + 1) + +/* Non-secure regions */ +#define NS_IMAGE_PRIMARY_AREA_OFFSET \ + (NS_IMAGE_PRIMARY_PARTITION_OFFSET + BL2_HEADER_SIZE) +#define NS_CODE_START (NS_ROM_ALIAS(NS_IMAGE_PRIMARY_AREA_OFFSET)) +#define NS_CODE_SIZE (IMAGE_NS_CODE_SIZE) +#define NS_CODE_LIMIT (NS_CODE_START + NS_CODE_SIZE - 1) + +#define NS_DATA_START (NS_RAM_ALIAS(TOTAL_RAM_SIZE / 2)) +#define NS_DATA_SIZE (TOTAL_RAM_SIZE / 2) +#define NS_DATA_LIMIT (NS_DATA_START + NS_DATA_SIZE - 1) + +/* NS partition information is used for MPC and SAU configuration */ +#define NS_PARTITION_START \ + (NS_ROM_ALIAS(NS_IMAGE_PRIMARY_PARTITION_OFFSET)) + +#define NS_PARTITION_SIZE (FLASH_NS_PARTITION_SIZE) + +/* Secondary partition for new images in case of firmware upgrade */ +#define SECONDARY_PARTITION_START \ + (NS_ROM_ALIAS(S_IMAGE_SECONDARY_PARTITION_OFFSET)) +#define SECONDARY_PARTITION_SIZE (FLASH_S_PARTITION_SIZE + \ + FLASH_NS_PARTITION_SIZE) + +/* Code SRAM area */ +#define TOTAL_CODE_SRAM_SIZE (0x00080000) /* 512 KB */ +#define S_CODE_SRAM_ALIAS_BASE (0x1A400000) +#define NS_CODE_SRAM_ALIAS_BASE (0x0A400000) + +#ifdef BL2 +/* Bootloader regions */ +#define BL2_CODE_START (S_ROM_ALIAS(FLASH_AREA_BL2_OFFSET)) +#define BL2_CODE_SIZE (FLASH_AREA_BL2_SIZE) +#define BL2_CODE_LIMIT (BL2_CODE_START + BL2_CODE_SIZE - 1) + +#define BL2_DATA_START (S_RAM_ALIAS(0x0)) +#define BL2_DATA_SIZE (TOTAL_RAM_SIZE) +#define BL2_DATA_LIMIT (BL2_DATA_START + BL2_DATA_SIZE - 1) +#endif /* BL2 */ + +/* Shared data area between bootloader and runtime firmware. + * Shared data area is allocated at the beginning of the RAM, it is overlapping + * with TF-M Secure code's MSP stack + */ +#define BOOT_TFM_SHARED_DATA_BASE S_RAM_ALIAS_BASE +#define BOOT_TFM_SHARED_DATA_SIZE (0x400) +#define BOOT_TFM_SHARED_DATA_LIMIT (BOOT_TFM_SHARED_DATA_BASE + \ + BOOT_TFM_SHARED_DATA_SIZE - 1) + +#endif /* __REGION_DEFS_H__ */ diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/pinmap.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/pinmap.c new file mode 100644 index 00000000000..c7da0da9348 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/pinmap.c @@ -0,0 +1,123 @@ +/* mbed Microcontroller Library + * Copyright (c) 2017-2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * This file implements APIS defined in hal/pinmap.h + * + * Pin functions are not available in interrupt context, because the + * NS side is only allowed to call TF-M secure functions (veneers) from + * the NS Thread mode. + * + */ + +#include "mbed_assert.h" +#include "mbed_error.h" +#include "device_definition.h" +#include "objects.h" +#include "pinmap.h" +#include "musca_s1_scc_drv.h" +#include "tfm_ioctl_api.h" + +#if DEVICE_I2C || DEVICE_I2CSLAVE +const PinMap PinMap_I2C_SDA[] = { + {I2C0_SDA, I2C_0, ALTERNATE_FUNC_1}, + {I2C1_SDA, I2C_1, PRIMARY_FUNC}, + {NC, NC, 0} +}; + +const PinMap PinMap_I2C_SCL[] = { + {I2C0_SCL, I2C_0, ALTERNATE_FUNC_1}, + {I2C1_SCL, I2C_1, PRIMARY_FUNC}, + {NC, NC, 0} +}; +#endif // DEVICE_I2C || DEVICE_I2CSLAVE + +/** + * \brief Translates between different pin mode enums + * + * \param[in] mode Pin mode to translate \ref PinMode + * + * \return Translated pin mode \ref pinmode_select_t + */ +static enum pinmode_select_t translate_pinmode(PinMode mode) +{ + switch (mode) { + case PullNone: + return PINMODE_NONE; + case PullDown: + return PINMODE_PULL_DOWN; + case PullUp: + return PINMODE_PULL_UP; + default: + return PINMODE_NONE; + } +} + +/** + * \brief Configures the GPIO pin and sets the alternate function + * + * \param[in] pin GPIO pin number \ref PinName + * \param[in] function Alternate function to set \ref PinFunction + */ +void pin_function(PinName pin, int function) +{ + enum gpio_altfunc_t flags; + uint32_t result = 0; + enum tfm_platform_err_t ret = TFM_PLATFORM_ERR_SUCCESS; + + MBED_ASSERT(pin != NC); + + switch (function) { + case PRIMARY_FUNC: + flags = GPIO_MAIN_FUNC; + break; + case ALTERNATE_FUNC_1: + flags = GPIO_ALTFUNC_1; + break; + case ALTERNATE_FUNC_2: + flags = GPIO_ALTFUNC_2; + break; + default: + return; + } + + ret = tfm_platform_set_pin_alt_func(flags, (1u<JflWMqH=Mg|QA1doB?35dhQz-j_kpuxbxzzkCgr$I^%eqop50MbGXAO9-> z>61u&OCbLu65k8Rzlp?81o9su@ymexmq`3xApav0e+iKP6N$eE$Y=bDu>Ty8&xyom zC`rqWFDOooPb*5yO)bwa%8oBfEh^5;&jZqVsi{Q_AyM(3d6^~7`FSO&6(zxy#U-h^ z@xdTrpZvrWs4!3fW)PZom~e7VesL<2nQld?slNFsr8%jXMkMFw<)tQc_L^VP+D9$$kF%uAj + +#include "mbed_error.h" +#include "objects.h" +#include "pinmap.h" +#include "serial_api.h" +#include "mbed_serial_platform.h" + +#define STDIO_UART_NOT_INITED 0 +#define STDIO_UART_INITED 1 + +extern const PinMap PinMap_UART_TX[]; +extern const PinMap PinMap_UART_RX[]; + +/* Global variables needed for mbed */ +int stdio_uart_inited = STDIO_UART_NOT_INITED; +serial_t stdio_uart; + + +void serial_init(serial_t *obj, PinName tx, PinName rx) +{ + /* Determine the UART to use */ + UARTName uart_tx = (UARTName)pinmap_peripheral(tx, PinMap_UART_TX); + UARTName uart_rx = (UARTName)pinmap_peripheral(rx, PinMap_UART_RX); + UARTName uart = (UARTName)pinmap_merge(uart_tx, uart_rx); + if (uart == (UARTName)NC) { + error("Serial pinout mapping failed"); + } + mbed_uart_platform_init(obj, uart); + obj->uart_index = uart; + + /* Pinout the chosen uart */ + pinmap_pinout(tx, PinMap_UART_TX); + pinmap_pinout(rx, PinMap_UART_RX); + + uart_pl011_init(obj->uart_dev, SystemCoreClock); + + uart_pl011_set_baudrate(obj->uart_dev, + MBED_CONF_PLATFORM_DEFAULT_SERIAL_BAUD_RATE); + + uart_pl011_enable(obj->uart_dev); + + if (uart == STDIO_UART) { + stdio_uart_inited = STDIO_UART_INITED; + memcpy(&stdio_uart, obj, sizeof(serial_t)); + } +} + +void serial_free(serial_t *obj) +{ + uart_pl011_uninit(obj->uart_dev); +} + +void serial_baud(serial_t *obj, int baudrate) +{ + if(uart_pl011_set_baudrate(obj->uart_dev,baudrate) != UART_PL011_ERR_NONE) { + error("serial_baud: invalid baudrate"); + } +} + +void serial_format(serial_t *obj, int data_bits, SerialParity parity, + int stop_bits) +{ + enum uart_pl011_wlen_t uart_word_len = UART_PL011_WLEN_8; + enum uart_pl011_parity_t uart_parity = UART_PL011_PARITY_DISABLED; + enum uart_pl011_stopbit_t uart_stop_bits = UART_PL011_STOPBIT_1; + switch (data_bits) { + case 5: + uart_word_len = UART_PL011_WLEN_5; + break; + case 6: + uart_word_len = UART_PL011_WLEN_6; + break; + case 7: + uart_word_len = UART_PL011_WLEN_7; + break; + case 8: + uart_word_len = UART_PL011_WLEN_8; + break; + default: + error("serial_format: unexpected data bits"); + } + switch (parity) { + case ParityNone: + uart_parity = UART_PL011_PARITY_DISABLED; + break; + case ParityOdd: + uart_parity = UART_PL011_PARITY_ODD; + break; + case ParityEven: + uart_parity = UART_PL011_PARITY_EVEN; + break; + case ParityForced1: + uart_parity = UART_PL011_PARITY_STICKY_ONE; + break; + case ParityForced0: + uart_parity = UART_PL011_PARITY_STICKY_ZERO; + break; + default: + error("serial_format: unexpected parity"); + } + switch (stop_bits) { + case 1: + uart_stop_bits = UART_PL011_STOPBIT_1; + break; + case 2: + uart_stop_bits = UART_PL011_STOPBIT_2; + break; + default: + error("serial_format: unexpected stop bit"); + } + (void)uart_pl011_set_format(obj->uart_dev, + uart_word_len, uart_parity, uart_stop_bits); +} + +void serial_irq_handler(serial_t *obj, uart_irq_handler handler, uint32_t id) +{ + uart_irq[obj->uart_index].handler = handler; + uart_irq[obj->uart_index].id = id; +} + +void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable) +{ + switch(irq) { + case RxIrq: + if (enable) { + NVIC_EnableIRQ(obj->rx_irq); + uart_pl011_enable_intr(obj->uart_dev, UART_PL011_RX_INTR_MASK); + NVIC_EnableIRQ(obj->rx_timeout_irq); + uart_pl011_enable_intr(obj->uart_dev, UART_PL011_RT_INTR_MASK); + } else { + uart_pl011_disable_intr(obj->uart_dev, UART_PL011_RX_INTR_MASK); + NVIC_DisableIRQ(obj->rx_irq); + uart_pl011_disable_intr(obj->uart_dev, UART_PL011_RT_INTR_MASK); + NVIC_DisableIRQ(obj->rx_timeout_irq); + } + break; + case TxIrq: + if (enable) { + NVIC_EnableIRQ(obj->tx_irq); + uart_pl011_enable_intr(obj->uart_dev, UART_PL011_TX_INTR_MASK); + } else { + uart_pl011_disable_intr(obj->uart_dev, UART_PL011_TX_INTR_MASK); + NVIC_DisableIRQ(obj->tx_irq); + } + break; + default : return; + } +} + +int serial_readable(serial_t *obj) +{ + return (int)uart_pl011_is_readable(obj->uart_dev); +} + +int serial_writable(serial_t *obj) +{ + return (int)uart_pl011_is_writable(obj->uart_dev); +} + +int serial_getc(serial_t *obj) +{ + uint8_t byte = 0; + while(!uart_pl011_is_readable(obj->uart_dev)); + (void)uart_pl011_read(obj->uart_dev, &byte); + return byte; +} + +void serial_putc(serial_t *obj, int c) +{ + while(!uart_pl011_is_writable(obj->uart_dev)); + uart_pl011_write(obj->uart_dev, (uint8_t)c); +} + +void serial_clear(serial_t *obj) +{ + uart_pl011_write(obj->uart_dev, (uint8_t)0); +} + +void serial_pinout_tx(PinName tx) +{ + pinmap_pinout(tx, PinMap_UART_TX); +} + +void serial_break_set(serial_t *obj) +{ + uart_pl011_enable_break(obj->uart_dev); +} + +void serial_break_clear(serial_t *obj) +{ + uart_pl011_disable_break(obj->uart_dev); +} + +void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, + PinName txflow) +{ + error("serial_set_flow_control: Flow control is not supported in MUSCA"); +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/sleep_api.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/sleep_api.c new file mode 100644 index 00000000000..d0f38f05149 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/sleep_api.c @@ -0,0 +1,48 @@ +/* mbed Microcontroller Library + * Copyright (c) 2019-2020 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "device_cfg.h" +#include "sleep_api.h" +#include "timer_cmsdk_drv.h" + +#if DEVICE_SLEEP + +void hal_sleep(void) +{ + __WFI(); +} + +/* Since there is no power management implemented in Musca, Deep Sleep could + * be supported only by additional software components, registering and managing + * the currently configured IPs. This would also mean a huge implementation + * overhead, that is not intended to be added. Therefore, Deep Sleep is almost + * identical to Sleep, representing a "Waiting For Interrupt" state, and + * disabling the Microsec ticker in addition. + */ +void hal_deepsleep(void) +{ +#ifdef USEC_TIMER_DEV + timer_cmsdk_disable(&USEC_TIMER_DEV); +#endif + __WFI(); +#ifdef USEC_TIMER_DEV + timer_cmsdk_enable(&USEC_TIMER_DEV); +#endif +} + +#endif diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/tfm_ioctl_api.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/tfm_ioctl_api.h new file mode 100644 index 00000000000..345f2106217 --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/tfm_ioctl_api.h @@ -0,0 +1,251 @@ +/* + * Copyright (c) 2019-2020, Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + * + */ + +#ifndef __TFM_IOCTL_API__ +#define __TFM_IOCTL_API__ + +#include +#include +#include +#include "tfm_api.h" +#include "tfm_platform_api.h" + +#ifdef __cplusplus +extern "C" { +#endif + +enum tfm_platform_ioctl_request_types_t { + TFM_PLATFORM_IOCTL_PIN_SERVICE, + TFM_PLATFORM_IOCTL_GPIO_SERVICE, +}; + +/*! + * \enum tfm_gpio_service_type_t + * + * \brief GPIO service types (supported types may vary based on the platform) + */ +enum tfm_gpio_service_type_t { + TFM_GPIO_SERVICE_TYPE_INIT = 0, /*!< Init */ + TFM_GPIO_SERVICE_TYPE_PIN_CONFIG, /*!< Pin config */ + TFM_GPIO_SERVICE_TYPE_PIN_WRITE, /*!< Pin write */ + TFM_GPIO_SERVICE_TYPE_PIN_READ, /*!< Pin read */ + TFM_GPIO_SERVICE_TYPE_PORT_CONFIG, /*!< Port config */ + TFM_GPIO_SERVICE_TYPE_PORT_WRITE, /*!< Port write */ + TFM_GPIO_SERVICE_TYPE_PORT_READ, /*!< Port read */ + TFM_GPIO_SERVICE_TYPE_MAX = INT_MAX /*!< Max to force enum max size */ +}; + +/*! + * \struct tfm_gpio_service_args_t + * + * \brief Argument list for each platform GPIO service + */ +struct tfm_gpio_service_args_t { + enum tfm_gpio_service_type_t type; + union { + struct gpio_config_args { /*!< TFM_GPIO_SERVICE_TYPE_PIN_CONFIG || + TFM_GPIO_SERVICE_TYPE_PORT_CONFIG */ + uint32_t pin_num_or_mask; + uint32_t direction; + } gpio_config; + struct gpio_write_args { /*!< TFM_GPIO_SERVICE_TYPE_PIN_WRITE || + TFM_GPIO_SERVICE_TYPE_PORT_WRITE */ + uint32_t pin_num_or_mask; + uint32_t value; + } gpio_write; + struct gpio_read_args { /*!< TFM_GPIO_SERVICE_TYPE_PIN_READ || + TFM_GPIO_SERVICE_TYPE_PORT_READ */ + uint32_t pin_num_or_mask; + } gpio_read; + } u; +}; + +/*! + * \struct tfm_gpio_service_out_t + * + * \brief Output list for each GPIO platform service + */ +struct tfm_gpio_service_out_t { + union { + uint32_t result; /*!< Generic result */ + struct gpio_read_result { /*!< TFM_GPIO_SERVICE_TYPE_PIN_READ || + TFM_GPIO_SERVICE_TYPE_PORT_READ */ + uint32_t result; + uint32_t data; + } gpio_read_result; + } u; +}; + +/*! + * \enum tfm_pin_service_type_t + * + * \brief Pin service types + */ +enum tfm_pin_service_type_t { + TFM_PIN_SERVICE_TYPE_SET_ALTFUNC = 0, /*!< Set alternate function type */ + TFM_PIN_SERVICE_TYPE_SET_DEFAULT_IN, /*!< Set default in function type */ + TFM_PIN_SERVICE_TYPE_SET_PIN_MODE, /*!< Set pin mode function type */ + TFM_PIN_SERVICE_TYPE_MAX = INT_MAX /*!< Max to force enum max size */ +}; + +/*! + * \struct tfm_pin_service_args_t + * + * \brief Argument list for each platform pin service + */ +struct tfm_pin_service_args_t { + enum tfm_pin_service_type_t type; + union { + struct set_altfunc { /*!< TFM_PIN_SERVICE_TYPE_SET_ALTFUNC */ + uint32_t alt_func; + uint64_t pin_mask; + } set_altfunc; + struct set_default_in { /*!< TFM_PIN_SERVICE_TYPE_SET_DEFAULT_IN */ + uint32_t alt_func; + uint32_t pin_value; + bool default_in_value; + } set_default_in; + struct set_pin_mode { /*!< TFM_PIN_SERVICE_TYPE_SET_PIN_MODE */ + uint64_t pin_mask; + uint32_t pin_mode; + } set_pin_mode; + } u; +}; + +/*! + * \brief Sets pin alternate function for the given pins + * + * \param[in] alt_func Alternate function to set (allowed values vary + * based on the platform) + * \param[in] pin_mask Pin mask of the selected pins + * \param[out] result Return error value + * + * \return Returns values as specified by the \ref tfm_platform_err_t + */ +enum tfm_platform_err_t +tfm_platform_set_pin_alt_func(uint32_t alt_func, uint64_t pin_mask, + uint32_t *result); + +/*! + * \brief Sets default in value to use when the alternate function is not + * selected for the pin + * + * \param[in] alt_func Alternate function to use (allowed values vary + * based on the platform) + * \param[in] pin_value Pin value to use + * \param[in] default_in_value Default in value to set + * \param[out] result Return error value + * + * \return Returns values as specified by the \ref tfm_platform_err_t + */ +enum tfm_platform_err_t +tfm_platform_set_pin_default_in(uint32_t alt_func, uint32_t pin_value, + bool default_in_value, uint32_t *result); + +/*! + * \brief Sets pin mode for the selected pins + * + * \param[in] pin_mask Pin mask of the selected pins + * \param[in] pin_mode Pin mode to set for the selected pins + * \param[out] result Return error value + * + * \return Returns values as specified by the \ref tfm_platform_err_t + */ +enum tfm_platform_err_t +tfm_platform_set_pin_mode(uint64_t pin_mask, uint32_t pin_mode, + uint32_t *result); + +/*! + * \brief Initializes GPIO module + * + * \param[out] result Return error value + * + * \return Returns values as specified by the \ref tfm_platform_err_t + */ +enum tfm_platform_err_t tfm_platform_gpio_init(uint32_t *result); + +/*! + * \brief Configures a GPIO pin as input or output + * + * \param[in] pin_num Pin number of the selected pin + * \param[in] direction Direction of the pin: 0 for input, 1 for output + * \param[out] result Return error value + * + * \return Returns values as specified by the \ref tfm_platform_err_t + */ +enum tfm_platform_err_t +tfm_platform_gpio_pin_config(uint32_t pin_num, uint32_t direction, + uint32_t *result); + +/*! + * \brief Sets state of a selected GPIO pin + * + * \param[in] pin_num Pin number of the selected pin + * \param[in] value Value to set for the pin + * \param[out] result Return error value + * + * \return Returns values as specified by the \ref tfm_platform_err_t + */ +enum tfm_platform_err_t +tfm_platform_gpio_pin_write(uint32_t pin_num, uint32_t value, uint32_t *result); + +/*! + * \brief Reads state of a selected GPIO pin + * + * \param[in] pin_num Pin number of the selected pin + * \param[in,out] data Bit value read from the IO pin + * \param[out] result Return error value + * + * \return Returns values as specified by the \ref tfm_platform_err_t + */ +enum tfm_platform_err_t +tfm_platform_gpio_pin_read(uint32_t pin_num, uint32_t *data, uint32_t *result); + +/*! + * \brief Configures GPIO pins as input or output + * + * \param[in] pin_mask Pin mask of the selected pins + * \param[in] direction Direction of the pin: 0 for input, 1 for output + * \param[out] result Return error value + * + * \return Returns values as specified by the \ref tfm_platform_err_t + */ +enum tfm_platform_err_t +tfm_platform_gpio_port_config(uint32_t pin_mask, uint32_t direction, + uint32_t *result); + +/*! + * \brief Sets state of a selected GPIO pins + * + * \param[in] pin_mask Pin mask of the selected pins + * \param[in] value Value mask to set for the pins + * \param[out] result Return error value + * + * \return Returns values as specified by the \ref tfm_platform_err_t + */ +enum tfm_platform_err_t +tfm_platform_gpio_port_write(uint32_t pin_mask, uint32_t value, + uint32_t *result); + +/*! + * \brief Reads state of a selected GPIO pins + * + * \param[in] pin_mask Pin mask of the selected pins + * \param[in,out] data Bit value mask read from the IO pins + * \param[out] result Return error value + * + * \return Returns values as specified by the \ref tfm_platform_err_t + */ +enum tfm_platform_err_t +tfm_platform_gpio_port_read(uint32_t pin_mask, uint32_t *data, + uint32_t *result); + +#ifdef __cplusplus +} +#endif + +#endif /* __TFM_IOCTL_API__ */ diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/tfm_ioctl_ns_api.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/tfm_ioctl_ns_api.c new file mode 100644 index 00000000000..d834f87007e --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/tfm_ioctl_ns_api.c @@ -0,0 +1,299 @@ +/* + * Copyright (c) 2019-2020, Arm Limited. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + * + */ + +#include +#include +#include "tfm_platform_api.h" +#include "tfm_ioctl_api.h" + +enum tfm_platform_err_t +tfm_platform_set_pin_alt_func(uint32_t alt_func, uint64_t pin_mask, + uint32_t *result) +{ + enum tfm_platform_err_t ret; + psa_invec in_vec; + psa_outvec out_vec; + struct tfm_pin_service_args_t args; + + if (result == NULL) { + return TFM_PLATFORM_ERR_INVALID_PARAM; + } + + args.type = TFM_PIN_SERVICE_TYPE_SET_ALTFUNC; + args.u.set_altfunc.alt_func = alt_func; + args.u.set_altfunc.pin_mask = pin_mask; + + in_vec.base = (const void *)&args; + in_vec.len = sizeof(args); + + out_vec.base = (void *)result; + out_vec.len = sizeof(*result); + + ret = tfm_platform_ioctl(TFM_PLATFORM_IOCTL_PIN_SERVICE, + &in_vec, + &out_vec); + + return ret; +} + +enum tfm_platform_err_t +tfm_platform_set_pin_default_in(uint32_t alt_func, uint32_t pin_value, + bool default_in_value, uint32_t *result) +{ + enum tfm_platform_err_t ret; + psa_invec in_vec; + psa_outvec out_vec; + struct tfm_pin_service_args_t args; + + if (result == NULL) { + return TFM_PLATFORM_ERR_INVALID_PARAM; + } + + args.type = TFM_PIN_SERVICE_TYPE_SET_DEFAULT_IN; + args.u.set_default_in.alt_func = alt_func; + args.u.set_default_in.pin_value = pin_value; + args.u.set_default_in.default_in_value = default_in_value; + + in_vec.base = (const void *)&args; + in_vec.len = sizeof(args); + + out_vec.base = (void *)result; + out_vec.len = sizeof(*result); + + ret = tfm_platform_ioctl(TFM_PLATFORM_IOCTL_PIN_SERVICE, + &in_vec, + &out_vec); + + return ret; +} + +enum tfm_platform_err_t +tfm_platform_set_pin_mode(uint64_t pin_mask, uint32_t pin_mode, + uint32_t *result) +{ + enum tfm_platform_err_t ret; + psa_invec in_vec; + psa_outvec out_vec; + struct tfm_pin_service_args_t args; + + if (result == NULL) { + return TFM_PLATFORM_ERR_INVALID_PARAM; + } + + args.type = TFM_PIN_SERVICE_TYPE_SET_PIN_MODE; + args.u.set_pin_mode.pin_mask = pin_mask; + args.u.set_pin_mode.pin_mode = pin_mode; + + in_vec.base = (const void *)&args; + in_vec.len = sizeof(args); + + out_vec.base = (void *)result; + out_vec.len = sizeof(*result); + + ret = tfm_platform_ioctl(TFM_PLATFORM_IOCTL_PIN_SERVICE, + &in_vec, + &out_vec); + + return ret; +} + +enum tfm_platform_err_t tfm_platform_gpio_init(uint32_t *result) +{ + enum tfm_platform_err_t ret; + psa_invec in_vec; + psa_outvec out_vec; + struct tfm_gpio_service_args_t args; + struct tfm_gpio_service_out_t out; + + args.type = TFM_GPIO_SERVICE_TYPE_INIT; + + in_vec.base = (const void *)&args; + in_vec.len = sizeof(args); + + out_vec.base = (void *)&out; + out_vec.len = sizeof(out); + + ret = tfm_platform_ioctl(TFM_PLATFORM_IOCTL_GPIO_SERVICE, + &in_vec, + &out_vec); + + *result = out.u.result; + + return ret; +} + +enum tfm_platform_err_t +tfm_platform_gpio_pin_config(uint32_t pin_num, uint32_t direction, + uint32_t *result) +{ + enum tfm_platform_err_t ret; + psa_invec in_vec; + psa_outvec out_vec; + struct tfm_gpio_service_args_t args; + struct tfm_gpio_service_out_t out; + + args.type = TFM_GPIO_SERVICE_TYPE_PIN_CONFIG; + args.u.gpio_config.pin_num_or_mask = pin_num; + args.u.gpio_config.direction = direction; + + in_vec.base = (const void *)&args; + in_vec.len = sizeof(args); + + out_vec.base = (void *)&out; + out_vec.len = sizeof(out); + + ret = tfm_platform_ioctl(TFM_PLATFORM_IOCTL_GPIO_SERVICE, + &in_vec, + &out_vec); + + *result = out.u.result; + + return ret; +} + +enum tfm_platform_err_t +tfm_platform_gpio_pin_write(uint32_t pin_num, uint32_t value, uint32_t *result) +{ + enum tfm_platform_err_t ret; + psa_invec in_vec; + psa_outvec out_vec; + struct tfm_gpio_service_args_t args; + struct tfm_gpio_service_out_t out; + + args.type = TFM_GPIO_SERVICE_TYPE_PIN_WRITE; + args.u.gpio_write.pin_num_or_mask = pin_num; + args.u.gpio_write.value = value; + + in_vec.base = (const void *)&args; + in_vec.len = sizeof(args); + + out_vec.base = (void *)&out; + out_vec.len = sizeof(out); + + ret = tfm_platform_ioctl(TFM_PLATFORM_IOCTL_GPIO_SERVICE, + &in_vec, + &out_vec); + + *result = out.u.result; + + return ret; +} + +enum tfm_platform_err_t +tfm_platform_gpio_pin_read(uint32_t pin_num, uint32_t *data, uint32_t *result) +{ + enum tfm_platform_err_t ret; + psa_invec in_vec; + psa_outvec out_vec; + struct tfm_gpio_service_args_t args; + struct tfm_gpio_service_out_t out; + + args.type = TFM_GPIO_SERVICE_TYPE_PIN_READ; + args.u.gpio_read.pin_num_or_mask = pin_num; + + in_vec.base = (const void *)&args; + in_vec.len = sizeof(args); + + out_vec.base = (void *)&out; + out_vec.len = sizeof(out); + + ret = tfm_platform_ioctl(TFM_PLATFORM_IOCTL_GPIO_SERVICE, + &in_vec, + &out_vec); + + *result = out.u.gpio_read_result.result; + *data = out.u.gpio_read_result.data; + + return ret; +} + +enum tfm_platform_err_t +tfm_platform_gpio_port_config(uint32_t pin_mask, uint32_t direction, + uint32_t *result) +{ + enum tfm_platform_err_t ret; + psa_invec in_vec; + psa_outvec out_vec; + struct tfm_gpio_service_args_t args; + struct tfm_gpio_service_out_t out; + + args.type = TFM_GPIO_SERVICE_TYPE_PORT_CONFIG; + args.u.gpio_config.pin_num_or_mask = pin_mask; + args.u.gpio_config.direction = direction; + + in_vec.base = (const void *)&args; + in_vec.len = sizeof(args); + + out_vec.base = (void *)&out; + out_vec.len = sizeof(out); + + ret = tfm_platform_ioctl(TFM_PLATFORM_IOCTL_GPIO_SERVICE, + &in_vec, + &out_vec); + + *result = out.u.result; + + return ret; +} + +enum tfm_platform_err_t +tfm_platform_gpio_port_write(uint32_t pin_mask, uint32_t value, + uint32_t *result) +{ + enum tfm_platform_err_t ret; + psa_invec in_vec; + psa_outvec out_vec; + struct tfm_gpio_service_args_t args; + struct tfm_gpio_service_out_t out; + + args.type = TFM_GPIO_SERVICE_TYPE_PORT_WRITE; + args.u.gpio_write.pin_num_or_mask = pin_mask; + args.u.gpio_write.value = value; + + in_vec.base = (const void *)&args; + in_vec.len = sizeof(args); + + out_vec.base = (void *)&out; + out_vec.len = sizeof(out); + + ret = tfm_platform_ioctl(TFM_PLATFORM_IOCTL_GPIO_SERVICE, + &in_vec, + &out_vec); + + *result = out.u.result; + + return ret; + +} + +enum tfm_platform_err_t +tfm_platform_gpio_port_read(uint32_t pin_mask, uint32_t *data, uint32_t *result) +{ + enum tfm_platform_err_t ret; + psa_invec in_vec; + psa_outvec out_vec; + struct tfm_gpio_service_args_t args; + struct tfm_gpio_service_out_t out; + + args.type = TFM_GPIO_SERVICE_TYPE_PORT_READ; + args.u.gpio_read.pin_num_or_mask = pin_mask; + + in_vec.base = (const void *)&args; + in_vec.len = sizeof(args); + + out_vec.base = (void *)&out; + out_vec.len = sizeof(out); + + ret = tfm_platform_ioctl(TFM_PLATFORM_IOCTL_GPIO_SERVICE, + &in_vec, + &out_vec); + + *result = out.u.gpio_read_result.result; + *data = out.u.gpio_read_result.data; + + return ret; +} diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/tfm_s.axf b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/tfm_s.axf new file mode 100644 index 0000000000000000000000000000000000000000..33fdcfffd7e87e7d294addc5b674eb6aae7912d3 GIT binary patch literal 1038136 zcmeFa4R{pg)i-|6&Te+|0a-}EWRt)q3mRC2KtKbF8a83TL>oV9tDujY1nBGrFiQJ2 zWZTC@P(iR&;|GFTDz^2jEkW~0*wWBytL>xhu0SQAb*6l?A zv$717&0y21ytVjpo)uqiuuw9g9woh&QhKwXv1J14QZk~Pp*5BJYIr18QH}Q1c&3zr zG+h1>%0FTiK9oOz29#3E_nze0-jhZPB^O#zG9V?|tI)6tWKd$&kz{*%{(t}e9|is& z1wa84s~}l_59tG>9~ljn?MOdE`Ygi$`Az=28+rYxLphJ5jLXnj3`m(sBalWRjX^3z zDnTkmnus)}&|sNP3HP&*W+PD_m*F}OX+F}GNLM3Wi$rBN;Cd6%El7<>OOYtwjq3{S zo}TI7?RfqU(rTpdBdtNY8)*a5{YVcYJ%aQ&(vwI(M*0cTb4Wi&>O|^7>PFgw^c$q# zA^idAEuBMl-EOq>z4LCQoLfiwzf3{oLd{#9eH ze$knEs8nncw~Knm(>-t87`P@D&Y5{4oLg_cYP-{Ps8C!aGOK>hGd=6Ck;A6Sli@r5 zYpRqr@Q)MuzG_Lwd?)hPXDsxc$XsuiE*@g682x@vOZ#zUW>yi84E0c|kPh!krtjhY z_q){mtCVY^-np*RrEhmnmwesls`Gza8Ld6E2GQC>>lCwUYsqQ%zB$Q!Wlh8UD{bFa z^XZ062XohY~B zihglnY#*L!(M8|esQw|;%c6qhzYMFXi%B_yoOOou*&t)%yYdB#kXdgKio}EBRh`Cq z_Mq{~w~lZ#?E;e~N8^!?ixp{$Am?6C~$a)Bh9JCwxGT+6&zzK$h*GKhsCUPB2YUtPP zxFxDT#_wodKz+4#jkua!IO3`$MbDUj>dXvg<0<>98PX$zYK|e;y61+d-oah6dBNx5 z#NF|*2{cTk9Ng>bRR|k)sqj~HakJTkr=47oSq&ln7H;Nzp>hc(7*NkDaCf>ex|ZS~RSy<%Ijt z(!3`x%3ZBPiXe{{I+Wf}r>H+%)uofUQ%J=3<8@p zKX7eSKR0JQv+wHpsDMdge0*J=Xcj8Fn_c;?a$(OWRn<&t?%D3l?uE7}=y2+KEaGDE zx`Jkxsi(}PcYPYR2#dw+&h5@v?#3~utZ!K>IiY(i&`9ru& zSR%d|eyw?KMa&wsP1x^t9UQ?XYeS&YeMP}IR~?MxXdpb4?XPO?&J<X|FbKYbivRI8;XqF z0lWKHw@QJd^4`vtmG2ry9%zu_6(u|Nd?NkOi`HDQOME}P8h56iQ{tiU3mY~YK2!Sm zV(>_q+1`rg_!=ZG^Zn=>Yce~mw)>-#Dk|_hxxyxF5x{Tutj>v(`-8iW>9ex~i-j_Q z#*0Tf;#>ujp7&*LSyY?((3U84gPloF`aZ$eSwpj?Ar&+RTn`g>z)xj2wZp{sdIzW)kd$ zf}z7Im_fseIhm9BUS|JY!0_O!sL7S;1pY77Y z7d9-;xZ>34UuJF|mD0vk&!oGeAAv8IK<}+Xszov*S&&E{p2*T!#^N6QwP399xNx6n z6tdkp!h2Dxufw^kClB)SV6?`X)yY*>x@_X(8P1+cQHT49;utBzkP+1P6=r=X&Jed+ zUT{u&_hHn{8&@V4^l-L^GN$g=_togG6sm;13%H8XfK9Z_{Cafc&AgPs&k)&#di&R- zqvx7>es1}CG;2zJ51Tmg=-ucu6*uOZ)ZM!CFlln%&e#(U{hihs& zQ{E^u>`K%b6YXW(XNxo<@m-b+<5qCC?V*XHNt~L&`t*F(0fU(BVi)s= zF1D?3u8Y=G{Kvv9TVZI7RGmvD1w9w<{6{!joG2EQm|W!<+<_8N7jkFF2TIo8HtqU_ zIXxy@mW`F7rFogirvB9RbWf>RD(SgW*NAR5_3FS_p-Vo|$IGL>`T8vxQSSTGgb{+@ zd9v4J&kowe_l>3lHg}`=xbv?)6*iR5&FG6?@=#G(W4*vXUn*1!Z$;U*cqBB$Ra~Xa zjGpw$y|Wgsi_UMgi6h1F8Q+NN7msx1ALxY)*GN|0<|^s7i8kfVY})}ntmd}a%BfYw zhvEOoSlILPogatC3Vz^rp;%Jla*uG$$|w@K0|hQ!=yu>&06j8Rur=;R4NFOui=yn|lWMp;`!l3ts>iZZ+oZ4~hKN&EW6?;TiBtvV3cR zoAsf{KfW0JeEi*GVKxyQo^c8?R0=tnfz;YHQZNkb;MZa=xL*|Wy2~;4uVYi{pKw}( z%f;rEhoO(RLzn9IZ-YK=khgCrG?svxhda5;w~J$=+<4Bh-8I|K>{W-#gsf6(|NAIc zF)ENXaa5=X{cyn-p^q)NGxdBb9tf8TR41dKmA@B&6wGQ~c}N*!t2V|sxm;-7!|eJ) zPrJ7`Gv3XbqzA5xipyMut-r&{MXevf2tC2~LG`SOR8rDSgSeJSH-DC3V(AozJS z6#~{nFwBr1+C@5))&XvEdCwMSBoMH)F5s2biA|P+1s1NVb%E5C)3&6O7c6ZB!haNJ zb(;l4=wYWRI6@c$D@xZbk@a-vV`yC|d>Upfih0gYndv|GmtrpLnBDE}?XK+`EXHY= z&z6^L?k{#)#Y=^~mS*=_r~X}ao+k8H__vE(1 z!MWk({v2zeamxPpGDhvsgtg?9s(G5F?Q1R%P1MFa7M`Gu_i^|}|s;;(f8<+zU!um;Lm_-#r6%0jD`cvBIcqcyVJIO zuZ7uk!pEL+q13ZuK~3@Y4H>~nV#%Z_2Pf72vHCB@@&l}_SKs6+bHjQ);4J2dySrUW z8(XHi*rY!O5_BjB9ahAc)z$o)aH)s0l?yu-%qxB!wVD03K#83TjJ0#YX|B#N(WM%6 z`FS|k&89sU=rE2Hb6q(-^=@YS=`o{eqia_m%YE{_8etA#Di?kVxLA3{yW2O=yr^w| z7&g{EdyJWmggI7it?J5l8!*Fp-E3kxto4NTcW*Qw^Hzj;#w^3S`bVH?Wx%N4|G1_P z#`FVgz`Z!$ywV^XGKQd!wi@13^pUB*H*C=6|NXFDoBu;;x`5ftknOduHERlmnq|LT zV=7zQxc3OF+Fc*6eTZahHp6CLU7)jUMcRiHLE^4t(l6ov zj2T0^vu>O?ainlVjiK+`Ts$%=rWdN=u^IYA9r_-dQ?bnzkNmjb3Qfi>WYSA$R|OfT z`(LEo{|xt)TK?18JwY3fNb&9NqRu^^n5%K$^V*TomA0i;VRU_7U6J^7({`sGmdW-; zCRw8{7wMTvs-_G=#ghIJJ8ld`dp#0pJqt zGGe?JYI^|=NM$Kvsek3?%Sg!KaJTc~Fj?LWdj(%r{p8V*bl*_24I3feci_Js|c z-PqgJKeB?WEz6DtE zZH=6*xlxBQ?gbBU`D2_tZcx00QT+?MiF>yg{;}UC@qCS>gY0}59#Q{N)AkKkSB>Q3 zt&Pw+TbmoXt&2Nf27I*2|0r7CNg9b-aA>h@gQ4apYu*aey!>G&FX(E`T^-H>f&6Sf zq;KOYH#xt6f6Oh6M>b$>nW^wjJhD!^H+SVIxHIWt;P*mLGc-w2f$gO4`WJhemu_EU z-b1=*ys&WtN#bF{Six{WXJchVFZjvP?HgtY1Y5a4ZMLs*fa20T_+h(}J>P(}Yx{;V zJ+7rxr$(t)&_jKzz2xm8KU^JZvhS>H{#|1o@}*1WSeN0V+HcduM(ow#J;s)?(z*t1vrLWpHZ#&Hwc8w=Q6?8<{m8=?DK52!=!sMjmwyA^_L0 zYNTtBTu3YrDgPQ~HCMCWa?0Ki+iON1cMZI}vWIJ|(9>mtO_(TLC|o3L6Mif_Eo>K_ z5%`z&7-_`&-&V#Osaq~*)MwR6kHp%RdRNdodz-YDH;0UU z`8v+Vbr}0{c-8@~FKt_)lkSUEEv4&^VvZFB!i|?=+&#XohcPNI$Ud|g9(DH+Z}T?F z>%D6!S9VPq9?2DJTjEt#bQ&oaBjxDe8+R}p>)>ddZHYOS7YGZrah||9 zQCGLC-Q@s=Gl$1oH>9_Dn<+;IhK?p#^fndS{7rsQZt{wbW{2o))B$r9Q){eknRjI> zro|ej`M{JX2v+K(F|n#;be$Y?tSk`3b6`4u$Z!@+kM(~wrXTdHn10cpis_>YMQ6K+ zrp3c}nukEob(EvcBxbO9n65APN0-RMbUl3riLy~p^tt|BOX&LRem^LCjfNNTjY?O{ z8Z>pIA%qE)zaN=hiGvT|J>Q1 z%0Fix{jovgSByUUyhfjzHhOj1=vx$86ZVAplwoS$G-$HPg!w&`JB+!)S>7~`ibSJJ zZhth4(f=c8RkgyZ%OS zHfF%lq;m8tY2(ujOwj2R*(HuvW*+0di1FumXa)$1Uq{ajMJfdj4vb5KAxQ(w{xB>m z4BttEfw=EXH1KFNxHD~Zn*XRPTWEKA(|B+5KoMr&3*PfWl8F{1~&vSfEIu-xw@j2;eoW|#*cszCdv+1>hf$`953f@ad zyQw^o&}s?%9pDAWZ7MHtQfE9>yPeJpiXLCdNk5HOEt})<-UeyJ)2?``jw9XE=1SE& z`{hy_@mmpQA*p>ZCoZfbidN;M@5H}a`*4ycPTGf)?u@5upR>upX4#s?e`l8gPMQ@@ zmBG{TR%L*bCdZR9z)5rCsWPDAO>1XT<9<`l2IdZ|C+Eigi=p$u{@9R;Jv$5bsj_F0 zbJB1>yXZLXv(bJz#!u)U zPWsQYK#@v=&9RYbFr149v(jKV8x1CFG`J#d^e=P#;#lria{R#H`OJCWpgQLnL#Z5p zCSEIzna?mLq+5|P2VxEx0S9CdmP_C^X+2*QBFzWsJuf(ZuEFu!!BjZTrg;zd=bg9a zYa2Wt&9`Du)qHmirfR;kjlZ=&|GdYqIEjWW5q^~xY51fzeRSu}Kw{Rep=bys*mTK!J{RmgIjMm!?-h2J9x*&N= z{kI|h7?kl#GItNZIK*u7vZSZ+PSjW7ZF(oVt^(f1ZLm>pb2PsbU0>mCd?&i80=|}L zw(EMS<>etSBsUL{OLKGaKJ|PuY?c0QuUNL>BCs6t{_=WoxQ|5eK59*JSEs> zv|1mHrON6(X}lZV@Xx}1Y-rkPaC?>50Hh2&>mazB0Jq{_aMHbLaFfTLKkTuSzf5p` zA5hcvp)`2OvQ4F2h2~uiMxGz4usI-WGAQS7b|`Y@9hS2yj8Vb+0h8+IIEbFN`J23u zG5>9jM)@|cW_QkppY9m;=1D@l%cwV9&(NF zPP$)-8*tLoUy2*3-fJ>uFc|sOU=>zx`80pcpAt3Tq+8Pb_S4r4)nDVJ>)^Myfvdii z=CM<}sSW<3*OwRNR?nz~l0_KBBpT?1TG;uC|B%)v_`!`=;! zdmPX|L~S)vpsv(jVD5(m%UZ-hT~D4q4=McaVpmUQkP0U{Obj$S1F-`D8 zROPW*sWE|<@7=+M<1)8NcVir{yFe(W6@enH|HATrNAGt7`ZgE!EW2c}K*&#nJE@V+ zHuk^0MwiOj6v-vtPFkLWktbz`!q>#p6z@6Ln#!cvU-J9Eyrwc~D*XP$n#!c=ukiZ^ zBa7u3;A;nDh;+!=q8?0&ormAgq<<)WKTeOO`TeREqj*CiYCaelFV7_XrRXiPAJTOf z&YBH4Mb-f64koP| zN|mN`D?o`W;lxY(5XlmgemLYv*&jHQmo*r9E;bwU>_1I!Va~r4VP%pqlxjJhzFMf3 z6O$Z6WP>p2npE%pJSA0)KAue;64Al4m#Y$U?(+YWQimeVr)i?5CfNhqNZI2V0~^bnZpV3;^!VVerYNqz81#F1 zSW)D=u#n$VAXI49@abdvF(zcCL>P`g`hvA9y9*ffl}vCjlckzhbXyfFv(bES7+yeWfiP2OQ_$DTHxVqsvs z(!r{xHe4?mbfn`!x!GSic2nkw}G?<2Isr2n;(uskp z#x`6{gAS}61zLaW(BEy+8s6(-*w5!mtI^wE2C7`jn)xng%Y%=p?uKDU410K0@JIeM z(B`7+hXdqAa)&TN$P2x0()xS=eX4dC$q)4|H!#;#y9 z7vk_sed+=nEL#p^KL=#{mjb|HO-_^s7F8VtN%QcO9rq*KZ9F ztu?$;Xh~e4;;oDVoE^Y92mF9>6n^l77uE453{*8aGr)V&4pDJnso|vvpEF&()e=UUQV`^X(%KzW)g?T`^+Bh=oXrf7jy1 z%-+?p{n!hJ?J#~y^(T8z7-x<8md4VvmcW3Ob<8__C?Xz-*nC`@5 z)el!&V_e_7qkLAw(F+zf9L>LKeC*!--EwruB#+xZQqJtV>L_3HxHF?yF3`RGxRV{9 zux4am{PLSD+jn-#QOP8mM=?3Gzvd`c`{VhB-noUkw|_jJ9Ur-dt9s^GroQ^<$ZDJl z?c86@Y`;IkYUo_5t~>r$f`d(N2>y2w#{C+`jB=$Db6%2%21d%o6?VZS=k(7%%H}^e zKdblqg;Q`^h}oW-ufy4FCiVJq`r>ncaxBxZeP@?EB#o5KH<)A=tvPC_-KN2?4KVz{ zM=+QGLr(Rc@J6SpmrZ3-r;n8a5`&4(hTQv7Y;7N#Bm`e@?v;M#yUSU9{28A~U{jwD zpibS-!k`p;teOL@2+rSBPl&No1ntAsB{iKG+n$5bK>^bMC{Xjn{7ldZ(3Y~&CkWa} zIO_>0wjaykf4&pg^^KHARdT33|0qBIMZo%f(CbCOy1~cI{t0T$JIdy@hkw&&)o-lU z#khze#tr-pbEJ>{y_&_ip}d-fM{{%yNAoaOqcK-&`@7_5%p_ZG$dWUqtBxA3a)Dxb z$8vH2#Y7xxn$PvJi*E>I^~LABc#P#dwDVW$ti4II<~*8n)dzrr>T_>@FyC>ItExVl zRsG_z%$#kqal@PQ=L>a$ZeK?5_w)5{b5*;J84d1Zyl(1CzdmN*mmkyR*kauAoS6RP zlo)q{mFCyb9Os0m<5W>*c%5bGF`nnFTZC_fU+mN6Tvj_FtgD(^J5%}n$H%|u(~Wf0 z_I^BFIPtNr>WSLlAm33dhM(`#Wj#^*v#@UVWwqbNsVLUt>$*#^pR)zIm29z_ird9e zu68l6Hr8gjopQ$8O})^BWfqrL)K^+@&cZG|6lFaLeY{R-KN}iec4dVeIFCEWRn%4} zwBbxyATEoD^g-VjwK2OCB>OxOX}VAII`Rbhc7}DEv?kerG}0oMA6gqdHp;7);0*>p zw07p9i%X;E^QUpIhpU9gCoXn6nr3?}_1k66cF2?`Y-M@1i`gG7Z|{`dHx>6cR?K*N zr?Ib`%dX|41ydZJ+`6Y_-gejo-wFEegW$*zVoDCO9n3n}omWdx(+Jq>XiS}wK?DK-sUd$0avh+Jj>4(Fm?zB>&j@nkl z6Kxlzl~yaIrNgE5v!#$>sHbZG)8g4N|>(8PYtJXXYFg`ZwUb|F?dt1VugNXh;bd`;1ulC?it;(Xr(Glo`Xo*Y3)aA*L>|dR=HlF{92S>d_Z9M2wbCb;w|~C9*L`HV{GvaD_4D|we_|;zP)sb z_3Mq_xSyEr*Hre@LQT8^_k)NEFkV5Y3H8{Bg3( zOj@0S&`6ZdDbd?>DEqlmmS~R|tKTfX0~=tq$UV5)%^t*A(SE{HwRWLP@gC^|T^kW| zAE%99j1d#YvcYuM%_*w7Izl*n@P! zcY2JVpm@y#dz5!sp`&!aEYx7Q0Hfw;_?3n7l+n!^_H*OWMtKbi*yPw9yvIa4|&|YAnM9OUOzY*XSs*6LK(v~ULWE^@yH+I^u}4r z*veW+Qo*FH*cE|I9EeB$E8ZZnd1MpDBTpz2!b^y++x3CbSDJA`^7;7ZVJ~#PRmmH9 zr4@PG;vXq_)ki;UR(|E1nN5WOuvUj6Qy*!JHYOvH|c; zwgTZS+3(H{#oS)lJjs6jus4E;V<%;M2k7@Jq#eXVieCLP9j^~fNuk?c6(}HG!bNo# zDr4DVYU}_r=DsXc2HBnC+2U09iD!kz)mub|XP>3r)8Q<~yO^-*JnbG>nkkfWG!pbr z4iRP!&m0A_2V}KZeE?9CW$Mli&30#l4&NQZ-aqhiG_~Wp&w{8X@cN5_S3*yp4_>4x zll*Xpg4bf;HL`Amg4ZkkNxX7GnF<~jmr=Pcf-G(UURz)xCRT^Um}jHoMWL}NOsvr%8K)UH*u>go9UUM4+&Q?IwntNA+EfE7s{P<^Y; zvZLz_$O@!hZ-rf8Vw`I>-aMQmowNsWuW!}s(fsM89g4)8v6h;3vjse{ zcaRI3Ma!pWicH+L;Pt4Pdnan1PBKQQrp&kT)TZz55q99zHti)RPM&(j zt>PSf{<4{EbeyC#wx){QD_rYBizGhk#~@?QyvwWv`i-boA6)~n%9f|aQXn{ z*^1qh@Ql>*Hj$IQtL(8S@*jnTkbp*phqZN+MevIF)_`();%-o>g0~3Wu%wvu(?k?p zi7$Q^WixplPO6)EIHLZ;3Q5=FtiIb)Ie14_eoMZDh?{4XDsah^aeu`1lIp4@< zhHz3;T;zgo#EiD%UX|g6iY2R_{!h$Y>MZR`!EPh(OQ8sp)}%pr2QW`il1br|vbFpY z%&t0H4$KzTIm{T%){oL^T^pJs0=inidkel0LHBvJ>9f~9m_B=#N0Vc6(n5_()VZIW z0xKuooK{vmJbRfb_|Y2^G<&qFFzKVT5_R6XFn)60=!5~;aqwHj!yCQJU|Zm%!a~g8 zY_SbJ%o^Oa)K4eMG4mVwr$YYa@Ru=zRQ91(hE;IIgP=}1W{>2wTCvX57I$Mk^e&Y> zj-}of88ckYTa~v#p=G zKBr&<{TKy&Po{AfY;UZN3CX%gu~2D;&@{{$Hx6q14)kVlC3a>ohPtNhKqMro(JAUe zlAX{AbG6+NK;iihvU4CIa-*tGKb5PRXuoE30I?{M_F7cEm?!LRneD;*kcf$s#h^;Z z6|moSw`_5a>80Aga(~~AXLonYeHQK^)?vpxP1L42t<6MOYr92N>#Z4bz~f7WZNre- ze+K;a*&d?GZ9`s9HgIEhBVdAzh%s?AzDcur0o7FZW_Ij(pld@4#(vbJ5$LT+q7ivO zWY>~x(vAnk?;MTP+sz_DPMY5V%W}1Q8{QgE_=-C;+gRPtBTiJIUIYu)i(clS7cY7# z5dG-KFP0!J7I%x+iL2d73UniK@Hd(KNRlntT^*uvpHRnbA&a)Xr5ocWYfQtMy9j#g zu+~561&iRvy8O0slqo?Es!;@uUxdM-|TlvJ=IUpES2wffyT4I?=tGE{3VNp zZbT)B$6#+JIh!J-!>f+l+eEzPXo3{j=R(&L<~Tiy(J#{YNtO16A+N`;X&@?(NA@c5 zk%Ts=f}OMw&th~)-zeBqi&hgiBBp)^QK=(Z zUJ+{tPbj(}Q8RhAN2M-#=Zo99%0oLLmv`ZOB~ z_LvQDbP1w9urpKVdf7{|{S>!@Kq|VU-YY=5ote}aT?mF@6pckR1P zx}Q(%r9aShzk)HXT(nDYFTAZJ_E-@p0!QzGmL@b~E^Lf^Ud7u4yeaPX7+P_a)Ryo~ zZJ(pH=hE8eXzf2yY}(ZJ*!yl$db4Ns!smidkgr9lUk3)>ri>7kVpf$|Cf(ZZIRrnP z*>jW~!oxdBXIikgT_8*uo{yxA`N98(5e-)P`u4#pMIJ~4Vts`M_qyjO8vLzjQX)zf ziBK`VQE5TCMSZ?zFzSjy|HHz=7D-o|yy<1g62oF%p%>j?a&?QNo zo%A9=(Ipe1>&R|c4KIh`3}Dp~2fbCQ$dy$oBX0rx0gu7kjCHIf+9F5pS1dq1MrdDd z0Z(LyyvxB8OB61nwPksS^KEd$MsP#IzEO9{XaYEvJ*n0Jo%zfe){l>+%vJ$t zsY;QqNUBL3MWNoHlNvl;VmX2X8NsAL)1pR1&Ucqqk zX;5qx35sXZpeWGr;Snn=!U|;!rsDL1+=hN(Z$Xxbv%U;8nDv`EV>!McQB@DD449wW}xG>Z)}99hw&v?9oeK02D!^F!pTsru_RIXT)E ztgngsRMWAvFa^qXv3*JVa+)#SWZ04TGACa;XGK;mL97$JEAnc*OX1B|I+hY0UWtK% z@bvz=k32b=jR$!T`gbfHhdv$9J_&4a8Y;w>Iaa{8Z=&`IKNhhY4K`Iv)Q6J2uh)9- z-A6W#OjtErhxJx0vTTS(BEL-Wu@wKZIdN`S(RmZJ-c)+Qf(5MMeFXW@v{7lF5)>WQ zE=g*s8tOiLQEB*_35wOL%06ZTSj+Gs7NuIeh|eWrJATyQArls|BybKv<-h?gimc+S z52?91N;FRO2vhAuwR9TV$bd3wDUycqo^C0oK(||zhvR~op%^?6M5c#xPWKH|D;;mH zx{RO(?bg!1EQhzAGD5PrXk5(2?8hM)v&+)7l+uWNMBsJHAr%CIX+CQhY z-}=?IVkHsR5eUb_IN8Y$WnkNjtxEQ7`F!|p0Tlw9u~B{dK(ti3MuqW#uC2qehx$u#f_52p{1CaS(&A{bNZkOPa8aXb zu}BU2z&A!h>N`jDbrEC0yK>PuS=7(CK3WDFvJcOs?a4cNB}CQ}-fe1zSGsf-BqO#$ ztw%PndQPH6i;VHuZG8mi)t^MI8xdnj*3Cj}4yU){h}Wz*%#3{^&h*qoE2a$Bu%_lu znWDzlVk^9e%>8bkE`+$6!=b!8WehkJSWUyQLc1@Wq`;--CE*&M0@sy*>smUSn=<}2 z%J@pFwDGSR9^ZlSgZpGeHpuS_4i(jTMeMs&(|KS}m^oIiUb$_-uB8OS7zJyse_dYf z^-=UcJlgfqtL737z7yv;!0;c+02>s?0Pjf~x3 z_4_-q$SgUrS3VfYz;_oME7iU7+3>n6;G3AOgOMS{H(`OHFuW`~e~9+*`9l|l=$-Eg z@Z4w*e=zdJ5ZT{Tl%1stXwZ0M3%>RsdnnRn3dB6Lp2S1edb?A%>>1NXSUNI{~-~38G>+tM}!#Ymv)#E$^otvQ=4JUK% z(8>G>b7gTIMed0wkas(WJc<^QB9 zO0YOB4_2G2-F?B8O1)MFs$|#dD=n_Pv|6Uh7__A9UQ`So#WhJ)(x9q7Ho|sBj2)CP z+JB3^wRM0xac)J$OLa=Q4XO_ODI$c?S{Uag^1i zV!+ui2~uuJN-p44Y>7!q3H2BsqB{90b<}-p&XJpvXR1u(W~Suo)m)8=9C-a6K&i@O z5)aj?pqZ!LK^ha1p~Qv2q3+q3A7-D4Q}HJI^n-rzSW(Id;5nSEq1-Vkxx|Yx*gu6z zNh+L#ANl5VGLv&8X`eAndxCQPFqEuEg_F)Ns&G;SM@C!(J`cv$A#$ZtbkQ1q9`xX1 zaSE(J*a@O~dTI@S337`>KjM@{N<6O!@jS0c5R#8*s$5KdqQ~NPz(3J^dJo0vZjVQs zWJED2hKW-_%IShO*p{YBedTUv^UN>IZaWW1K@*L-2}tKd8i}f8V-uChnq0%r zNre>jggk)Khw%k2zh^5^coS)5ChZH}?{vh#lc_M6WE`=)ckE~df$(ctMEl6)gYiA%!oBCb|BB*E2RJ0pkGD0Fu; zJ6ej|s*mY!QaQw{To<2#%N;EiH#i+D32BQ(8n^c=+#VZjYsLynYf{UYP=e3ZQw%cM z@g6*fq_hlkpbybqiP9!1t;y5bYK%Bl!z5&Ybjg=Bj9r}z#E~%7lDSFS0R&AEMcRk=Y4jnw!@EpPi9I}64k^B-`i@(Qw|B0xFGar3 zgw>ogO7^rAtQ-nfGO*eTZArMvDsGTsGo+XYc18^oaFAzIXpU0Di^y$(z)Ls<0Bq>w zBgM*G^wtn;jzq*;J)Qn#?f&o5lmzWvcqcbOcEZ%yS4-}{8i$4Ffy1}YiNkeiIK0{a)i@;Wg~S^5ud^tL=AWm)o2n<- zFr>7We)l{f{dd~}1o0y&5TC9m4`_CRs@;nLwQ37optSj)(vt-BoD`^2_2i3b5WgBt zK>X`yx@JF zu%kENaX?cdq86Vh%oR@W!`lMyn=Is(MYt}as~gYQ$v;HTxWe-BY@zE$T-SQB!;h;= z_RMKH1iw_Zg#p9M8x_du%mqP!IEDs61@t(+6^%&6BG(qzA(y3bQR5c82}L;NC^$X* zi4pi1nU_v6AwuC57vTz6u(N?Hbm$^n58-(Wu7FM4vJuy{xT4+`1q#|z+(BPpQDS(! zK;KBFCAccvW-konC7#yD)^Bl+3g+VZx@e_U zhG%bt4@;Oia1xFpG+FT4*YViTK-|QO*g>xSAmS$Xrugv-pF{jenQe;q%dU~3oH|)d zj7EFn6qjK(#9ov)KV>o3{u%n%ggz3xAW9$F?go9?h&Y43-iA46NBEWNV$r*V{Al&eaf0uE62%N5+Ur2H>0bQZFM1jg znq22aoL8MMKFBF02AuW89AM8g*Zz6$W2n1U;`qZmX|{-(mnfD5QSF7nXtS*Nd~%Cj zIbE!re_kGs+%l9b8Hf7$%(1+Ec{jd@{g&2dba0M4`%3Q$qOxOo;d)S7fh0>%D6QNR zrDgbsH!8NXI(H5Z)6*Azz z0(@1b`&=87Xy=Ggj;0GJn}i*`o#V1 z-rfuIc4U% z!J~Adh4PZ;ZvGj_2pTU=k{1j^^M@g_=tOMwpS1!6<^)mOG{q_^{Q(r#rp zT;&vXw;?H^s>Swy()*9ndZ*JJ$==iDKdCQOsn-wdO;u7zUqVvw{rclC-+Oi7s_xqHR@u;8Ay#nakF>^X;iB^`X zFTMXC^yS0npjVqV*JoQ_#L(F(^!-7s!AlbBNj=sRc?qp2pl#ZEQeR;R$vC4%R9DxN z`qS1EdN)g@(Arp%LU=m_98T*AQD{~Qg-VD*3SaA`X03%v9eFuvS(Q2}9IBR8?-Q%Z zHHwyHJ*rOIvcojYPnh#1O7s+a73nMSH`Aoz8ikMi&Hk1GtQ7th=-qq#EnBgkcw78P zMc60MxJrwqCcJYmWJlQ}1Lb6#?&Imil(Kd^w6$Bt%0#hM?+;WRbh)N!#$Y9b#Qh)x z=SU2AH%yOrEqR>h!dF%4J%Z&pU*g&A>G$x`DCI4Sq#pW83}GX!;s56_d@H8v((}jA zl8)gyJb-iBUjNs(Q{N#V8BRGJqn#k36E7*bT@R$Z8JO5XNNDYZ-=}I(HLfcoE(pHA zTSi3p+}!THU*+Up?c^ZsY>t3t0XN^T12?Dc5$L2%%6@kuT1sC*OKN*nCKFZ=MHG|! zNK+M=JU3LDm5g|!8P+ts3=OhPDUfA_+U`FcCZ}?qRE3GY53p@VMhaA9U7oHl)~3Ps zJry?m^%7cl7FEbAK(nQqhET4Hu_{6PC~v6IeEF9sngW(U(k^)|mZ~qj%Tz2J%U(f` zDuv7OJykkIOcsKZw5pEE$YQ}?0*EKeW@;KY9*M$ESG6y_$GuCt=cGk(e~V4>T|c_6 z!-@U67GvdM6UDLHalV+|72SYyLo|cvpXoci%lQufa$N_#Lx%G=9rE%yD^}yLpWLj_ zP1N))!&|-d9^+Th?#eXUIaS)7liSFO$4aEw^nS%Yp{Q0;w|bj3S~VwTyd#?QT@kZY zcoBF&qx#*z0~!^cKQt`uTj``b6g*VxJaJ0vH2Kk_N;z*;M_y=BwpcFPk=UVV*S^H* z-B5j;D+4XzQQgDO*5+d{qKij?sp5xvriL7Vi*`7f^!Gu0T}C_v&OHpwDXv7q%vO`*hO8@7j%T zYE-$Sk<0rD{)EMOKC!ELnB~P^+I?2{_8rR3n**E!>rmUHBHM!~TPWypa;RH-caHX^ zinYBdzk4L4BLn9wXpbr$8AKiU&f1RE$id`})nLSkFDs=+(p8>Fg*)NnC3G(B34VDO z#i~ey7kgnvZU<(U;05<9=VI_ytA}8nrJaq@jZ6lRp*zakLy_szB_%~e!N@cS3JAa5$!1>lI~312}rCni81LcKvJWVmkazL4@GW2 zez&fd*PU)vC1L1RaDOEQ28x0fiP@MVW3bKLzlo$7aZ>PO2KJ}bXI{EV@r*Rx-t*P- zQl185X*yk$`S1b z*Ah+SjkF>RMaHMmgY4!6JY^{*c<;#_+t>|zfR_#_-d4G)voT-i^0&UL(c*0W!?zUb zIB*KR$PN2niBw3m-fAB{b6=}z$Ds(*zKshhTtPaM z{NllgIFPJ66_}`g@vh}V5lc!hc;g2r+(&^MOu^ZBH@ko*|0*7VkH6FyO6Ks=doi^? zBO+AZv2@t#Et zaZ=*wT;O1U)*fjWBNOrBzPJfU%Rxd*ZTug1~`BY#Lc3BWWSPq(a8KRO|YiQPt3 z_EjC3ltXaZ8RXD`FL7-}{7F{M>kLKyrp0t9&ZB$-m-ZeN8U1@oi78a&j%`}K5t<6V z3@`mg(H05oFL{2{;Y#SIgnk^Q@tz7}7PLD!N?H3Ijdb#mmp)VaN~}ERvTqZ*R_%*4 zAL$+H(U0H7WZ%Ndb>NqzOygs1*P6!ESN3m&C5yLL5EFzIvD;k*Tn?n+LgyZ7jdjo) zlD8xFU1n(=T}JN<#3Jjplc5fJZ={u0HuJFj(TPuRh%2X*?0^sOm5{2sJX#HJr{`Wg z&%*P1rSxq)RVt<9l+r)qxdP8q>WdKD&JNg>t1&QHx#I8CD%Y{W3AoZ~yQ`nRl0$bd z;qP&)cfaT#uiZV@PiJnGZ;6S8b)yk$A4?^;Tja{aT^{bp*3?T?z{l%?A8Q{I7@@Vk zuRmM6ySqP2yYuy%v^y_WeD$1!deZd`#QNVv3Lx!A;zV8;QTL#8Oz`PGbJ=g)Pxt*} z^n=ck!Mj9ma`wUBilaL@_kGTcz>V(m&aLhu%Z<((=d~{2ly9uw@H~r;z~AzIO8jXj z{T<<6{I%b8sKF1#ed0?wBC7BaC*r%5AHOM2wW)fI{l1KMLyIhKIm+C z`x!Tz(jTP1&n~T*Asi2Hu;}}&M%$$QM+`ZZgZP`ru5F!rqXm1nyZO!=p$A?&VyLvc z4;ys{=v$N9{4?-QP!)EWB9Y$@91j03nzQ#vSl4GYS!e5ynfOnG5DtJS*U@m9x!!`eV^P>ehuXOs++JWcdxqP2hM{k*UT{lF{a~+L* z=ll5E&~&mt68YwU4OosBtZr6b5m<{h7YCa~r)aIrs|Bq}n_axy*7(QnzHX;`jk~Gw z$Bl#D-v>{fW_0i9*` z4{?qfwB?BB>HDWO;A`!E9qx7Y1ukaQ)fc+3?}lf}%MuDZb@i;2TF^IB*CWr|cW3T} zhpL_IWW1)`{%Rj%)hBv=FP+-Zz@-27nQ>kIuKCnl=DedUwMksJX7;Mf~2=@B`%h=dD)+3@E>=;d11yX?QAZm3+*6>U+25_YlSj zY?j~pP#_QW?zr`NrT+iA^*+@9_O175^;?JQuTx-JcI%@`JrCNMPl>nESW9mG3GSP2 zz4PQv`1<%msCS#xq5N)AejlNheeJpNFYLc$eeHa^{faMYf2p3gzr90eu|0J5v{oxi z)Vn}?-l|={ueGn&p1*@K_ zcY+3Ix)O}3?Ww;+qPBET*E6Nl+fkiFe?$)|CpyzTT5IVT0z z9_3gC?k5DtT=f&R#jO0VO_bt>F8DclxatG*CEs_%0O+pNMkj01a+M3SHnBI&Vt_pvU7-YVOO2*%|4EzZfo4|YZLoqgTtMz{&DA}0j~0K zr$zZKSAJ(Izjoz!a)3waMCE>h@@rFm%Mekxo8^YAwowc3avB4p@v9G_=Xsg4xk=K& zSC8>FW_ehF06+c0UqC3+*|Wf-`<95X{(P-!B;tbcFJ?^?DI8@ z3VJ+GsC$08 zz&*=#{dID&g?RO`Pc9@+mZ>S^MjrM@>@2FP^J=1Vh%J`TTptU7nZ zz6ll`zWzP4wiK;yicUs*TKl}w%Um16+nn;-YWeg+tmRSay|wTkVdz!EQ~2Fr*cxVx zZ>9JjWAT6B-W9!0Z`q8LElOP(!iF6qguG52zC$-V*y8DUsZtzQN72U)=k%cNmsP?D z{6$;Cvm>N$#hIn_SyY`C7Sh^Fdvi zzOTBPtJ0Te;cpc%>GBy<=FDZKs96%A-{OGwHwtiH5HKDbhwIot34V_Uv&ur@V%&We z%qTk?w&3m)ykGv8FkiMmY%F^_Y$ywaO=W)y>&xB@8?1b1L96*!xzd{M>PguF-=qdf z&rSySmL3lqtx`DC3jVNu8s@D>ftQZ$)pN|JHz0A!eRT$ptAVi$9jiv#s|!TSXJ){^ zpXy#d*ACZ)MhsJsdO;vqA%%rhhIza$?>% zNa%Xu0wLSQJ;!zEq{jyJ!W-S(lSwYOyG=b8Nu2T0qdad8eywx5Ama4u3vp}rbm3Xt z{WM7tVvQBjHl1n)lg14RqrBlt&akdOvIx-V1Y# zT@&fj3%Noy-gz7=6uPRrZEoAi==G#ES9OwXm_l3`duaa=-DsV3FXW$$D=KlYm5G4tbaDRD$_-Nuhh=9%w@$0_j#deR@O)i0X)mvB*9PTkD6!bLe3 z)D`JFoWBd``dXbG&di>58`%UJUEi~WaWj7v<^qbD+XZ5_gli6w{-zpw!stIpsKHOufg9gFc zytxPO^s+ojh;gMl_#=BhF;^R;vAaN@(dD!CmZ~oDXkIL(w?|&>FL(Jm%@QAbrf)R! z?aV2Ev?l|;Md8im;%KQ>-t$Qn^kSf!IGg;ILbQ)`l|cGH=jSdExDK2nf$zMxo7?OV z;G6cX=giXA2l1V1XkHPyYK|W{KSz$Wo7-xKk4GGhvU1q`k}1Y*jz`w@pTLaL`WxIa zR$v$T1pe6#LW!VzELRH1Gu!Hfc>*{0qn$ZZ9__KzR|y5T=w66Nx-quY&6VjM=bz1$ z^aJ=-GDdl}TZh$(a%36r+#$!+J+gkXa1&~A9Xa^2?TuS=r4rO`Mj6$6Rn~1bORx6p z0Lc~oR^eJ@g~dC|z_;~9Rx$fg-eNuJt0ceQ1|9W)Fs_ay8S{~WSaQI6vbs`tip`+1 z4y^9^xN?Ei`FXTwbRC8GWHbSS$x?!IfdFk)Zr zgRrswDcCk8p#I&AbW~z3(wS)+Y-@WRd+0;J3HMWlUTvZzyR8y{?&h)?wFWo*K;Yv+Y* zIcpad>DM}|r62g1ZQD*mN6k30yN8@=4uK0^R_Q|-8#dT_LL3w$guzW(mf@@KES)drH1ZiA(PEVDM*`9KaBU&Jq zK`maKs?Pu6yUom z!=i>onM{&PHb?-qxYe*}0F{8KP-&U4iHe$#fSC*+E!MJB$q-S~fWa1P)zZ$Ov;oAX zMHw=&?F}T%%{uS*xk*rezyJSzKW{#nd(S!d+_OCAInQ~X=RD`R;Ol~cco?%-{srEyC1A0B9nc&OhjxG;us3RIsIMFC5%O4IVyPlXEe#sr=0;$v5h;%%rKTaT zKvTn3jm49JijO;}Eu?`WG($JK?5}rPuRIXC)87d#dmkrGa;@O7yw+!H+M#}aQ77`8`{LC2J%Knf$ zOtz*r>1Jqkk44HjMexuA9=xAfsR7H?1{~MrTOG8PFe}Y6r~C^o+ar+vWvFbbNA!k6 zXPe6A#A5xd@Un+Fc|T?@=!@sU(iHC(_zoKgIr_(;5QI1%B$^w9Xt^a&)&%qESkwF~SIbrf9&K6v=EfJ^d1E zwXL2)hk97ag;lp7r@IB|nwOQF;HD$woL;Oa4WG1%xfJW~8V3HfALoE=xSEjD?4|Xu zI&6`&D&HbVK|m}@6QK35WYdWx(B=qfxWpf3Q>@@kN_*@LOobJ+dA!5}Ibq;ZQ%;T%uspC8F1XE{YZUxqX+F2?x$AaTUc<9$NPR zzLI5k9a|wt4$QQ0XudM7;dhXQcwYmq4*5lwt$}1C&d1#DkT<*1R!o)*9#e((P^^PL za<wnu{%2H)CRKl7HX$NNtb*Cgs&?!YV=hM3A5f%hTahroRB{1ekDf!d>4!+5v@=a%aqw!4Nbn<0E zqS^&66~>4hbACz7z2sa4HuV*&q66UoNhH>0>6o z>!((As*rrgZVXl{=VFzyQkiYLi(iqwln33hPHp z8qB0@*|l!CB%p<)8M*5Mg-A0p?Sj2vuk#LQI`%@6r0Z1mnx1*PH0A}v}rBoF~LCGm}>#Y zn5%)LG2a9%WBwJek7>b9!X~F-2AkH_oGA@Jc63;183^;Tt-C+;SuZ&82Aedi1o)B} z4&D3^(!7>NslDH>?rM-Og~o#V`zz>DsK4y4i^rX^Yc0xGdu+czA?oqO3;Af>B=n%x zIZ?e%P_NX#TD5<*&Sdns77{Y0j8w0rHG;o~CI|en>C`d}=`qdI^ZxR%Yf=<2W1E0J zrnCp*QvMror2IROl+qTkq_hU?DWH>Mk30X}%+?-vCS4%uA{_cg)fuq0nQCk-s4QsV zQCA9gn4Ve@FY&sPxkLS-%wCI>qSD<&Zzl91ouRM7+;73jT2ml3Ci}UgQxfk?j?eB4 zg~Du&rd{Egc7@w3rDa#aZ^e|vhm%Y2tTjAP?;({>@cXA=-JzOV5&tX@y`G&~F5k&= z3On-4Kpd{+@=BJ+{i^`MHiLN56Qd+p3t0t8*jMYE;5**QZqoXY5?iZEtlOEgQ(M+o zH9qMbuTrDG_LP*E!AI_7t_RY<8+V3W;a``q(3Bl4YYl8!&!#8&jS@YH2fawaUdh*f z&U&!y5}tAJO!&xPIY)b1N*LQk-#{5Z4W};Vtt7wfVE!0zrDMdibkZN{c1V>{k~FnB zqFt+Hk`tv@6ph`Et6=U7tqM;~*ry1VJc)gK%6)$j7WHj=HumCI;n1D{Mim!me89NXe2>UNu9qSjGt>=(0(g+Q^s2(aNJz z{K#e|o%TqG+7bO7qQ@qhb<9nok1Vy3lm8J;ho3lW$#=KXSov~)huU83w>1sWYg!fB zykx(i_lwYc-lL>!U@R%}XwFiSvL>p<0Nv(s^qj}jaOiUHe*^F~1l@Bd&Sy~z%%|d| z-T>*TsP7Y7Ls_FnML`Fkf#x=jz77I!Moei+$HoVk@ecU|7r)^&aKwtQi1KS5DRAeE zMY$1jI6TUmz9CCC^XY4>;KW#rG-w^P4iyax3(nlo+0NY1jAPyIoLv9TmwD(FaV1y;4r0{@lcY562|RykR}Ib|%Z%Fc>WtWCKffU4hq!3sD-*A6`%=qs+! ztm7K3UO`_G9^vD09sYy#7&R>V9Vsi<7)p;r4;DdknRXjEk5y}2psUwGUuDqN|A5|p z7w|*#N^1xBwBBFRXlr+1cXf8h6WIOQrmej-R?um%M9)|&XlxUMtECCNzy^)ftmD6= znN1P{<_^QzLXf3#Ub8fPO$6qS$xr2L5x+tFrWGScwUBHLPRWw!O~&4OXDFdBeZwWKd|s80QEoiZ3h9Z4aOgJ( z#W$?lKz!A|AXN?IXZyawceC967Xo}Kt$M&3Xs?&n>o$y#%{rUELeaP?az+7yD^OZ{ z-=S;))NQ4dnG@lEqv6d4vOxG5N_Hfd0;i&&e^9xxa?Hz_F$!zUa*WQpM)OjjoXh)( zJnTL-b)_M=hzbB7MhWv5AAUF5@ zH83mR;Fy*7l5?4VOowaAj6BjQzvTRfpL$_9bV*rMY?2@7i8!RY!zAC=^KWq#^Fdoq zl(s7Wi?|NgY-9UI-j+8$f4UEv8bMbT-$Wc4xUg(-77q>6xLn3ktc+n|AdQd88=Wsy z8V>6`XaR>7?1?zC2>S^QkZejC(jZ$H4w>W?SVL@xZAgefYzbnNItnc?$s>E137a~8 zeoX5DEbQw8C?|Q56mi6Gm`c;g>$)!lOodl5s@pWVxW1@ar}E&O`3JJLd1#*ms`&x^ zk2f3!wiUfrH%f|tE*x}j$>rAgDovG9(qY6`^$OAl4LVO=enM%o>?*EsN`50o+D0So z>JPmRjLT?nV5IHc8qXH!MG3awL-bD_e&S1h90Bw>T1>o$$N3EV#AzE>?}ez!&XH9=h1hU<1=vnoH+ zKIi`p<^=0k>fBPY95!No^^CxbD|LxgBRsk)!2O^e{?myrOe*l?=zKa)I%)KwLyu75 zX{DLC)`)R=qeqK*aNTco8%XO0ebDKmR(yxrwSeh#**81y^hd139-O?qOYf<1PH7&Q zU+o<3pDHEhkIb`4XR&&nZDoHZz?O~X809SPLcN${YE2jc zf1BFN>xve=Z1E4r?2p80<6-&3sF$r=Ek^BGK|a}|mWf`y@*%!6mh<^wuYQJJ8PF@D zJNmq{ir_liD&QRs?`-Y@RpK; zt^;e#;H`ErJ>V%rS!_D^NbD&Lmue&vaTFUc(>4${QRBk;PWrCZqDr?4Q#wOEU9@Ka zdbWitA)UW#$1m3~vcfoIjyd3>oySkX*-gdQmRZ2Zt;*l4{j3}NXOdS*s?e9_W6VD9 z!d?ih$|(O)b$`c!JXv@vL(;E|fWDe&>7D+G&=AjnEVSP_+h68SCvBj-}^-hH9Z z)Yk0u4QmmwRz}F9uz&oK4?2zCMfKZpCbxL=`>(2(9aGrR`j9h#?z zwy`DHZ)6;__Rm$<{(P+cSjjiw>*iSRhx6*`sR#55O1}k`4l6e# zgC+Hm>Yi_D7y@|cJQ4+slgtV>hqK)MbFMTIaxv@w!^)|!`CFk%;}No^w*);9(F4Xxa>CS-zEB7&XgIX1 zKdNO)X`1(Ukn~qz-gkyxQ_SEe`a%Kq`DRdii@Kjj)b1Z@KUK*M^3%Y0&|H7}`n_|> z`eBC@(OJ2CxJt7wD_gU7U$YoK2W>M-BCz(JuFb%{8U9R3gyfUcy;(ZYxKEioEioZK zC%^f!k{g$nFfO+obDT{!91?b)ZPiS-uS!-%n44R^^M{zR(-J zo23jd>E#4pKD4wXS>3Nt>8BOa*$G%p=8lQWMjIT(QUqE_977c97zU}vaEM18f|crk zT&C8+s&&AE7&V;iK1=;I{0-M_hOg0I+DoH-wShht&K(A)(tmA7H#`e*A}(sInxe0bDRH}_+n1(7nc=>U}$5x)S?fZ z>3;DLC=$wDH!ThH7aSUTEkNf_{eA%bw)SrMQNJBhN9bah%Fb3A(Ql1^pOP~M?V9#x zVp0ishU*Kjc4IU3+<2aPZu~kh)b9a(y`WMr$D^_S zG4gW`*fM}hG53-kPdsUi{5IH(f6$|W6y6`Q0DssPX2O5{Hb6#P(-&$S(CBxBpN@oO z28(^K7=I~jZ4cwEw|h!)t?jvn`1qB5p@C|1+>hiJ4NXBc5l6hPdiy!{!#N zGy}S9t=iuM{X}8g{gjVQS#pErw<9z}+mV_Q1IykhzZLc%18=;bzR~4FR*?%}4d8WX0A*+Z{{s!+chCR^ zRk)zN9G^D3W6iOLbhA63I`-V+BJXtQk@`YMyX}iB>ZuPMp-20vBqo(8GQp-SkbrS8 z!0Iatnj~$znIY>h=Jo#2A<(8+Jd5|!NPKggo~fg>M)c2wv<;frdg1$!+9wpx7YNbeSC7>p%kQAw7md}%sTUUq7}C@*0wL#Y^b zJOgJ#vRP3TIN5&Z$JjGH4lLs!(?^ds~d^_iP zb1DC(a=x#hq%GCf@6-9`QXj_L$`s-Ft#^+nUJjqQXWIs`2XYUgKEmqmB-V2)s!Dz z!Qsgc5&aW+&qb^y17!+TvGxa^JZ$>i7gA9hMhfL&q;Q?3 zUP*JmpSUhu!FAzEn(h7SJl?O)2=X=*878z7sHyYYD`S`#Rtl_f;Ti+{J)pTywxa?r-XPJ}_5e zp&D)8rGjC2^I!;onI)OfyC6GQaqSBO}*XHy-a=8V1Vw9APTY-%V0-&O3~4c1P|pL7IJ)^840&5co+By~owmG|iF@wdr&_ znjY(ZJmv%hA{dn&EoW{jFnaxa2r#%yi9u$ z&=03OeMV?zo#$yMb250Osc1uP<7LQJhhM$`KIgBuk*#M~q`mC1{sP??>@^boONS0a ztY@)KI6xWxhPQ0!)p)?CFEkxG58{wVD`T+p*%z8aeZtjsE2CY190f;QTVXnT83lZLNoeM~K!lMxnkk zodMkm`Ys^@&Gt`v`MO6Gp=Xo26K2Lva5{9Lt_6LeC74S#FVVCx)^5@u6Fuf@Nhh%1 z$u$jW6c^&eQtZkYoco=OH(J40%P4C!xa!yI(n}*%3QE-TZa~t+74I5UG zQ!>u?5Z^zsH9Tjt^o4dK@A`(nwTdk4=76J&&FRy%WW(Yz*Z)3jOLU~U7dT*Sp}Ipqy=8=~<2w9% zy~2d{=A>-w42<0C%nWiVUH-UH*Dm>zVVQ~V6uW@?gvI{^HDcp15-HK(YI}Q`>Y38S z{7HEZ#D>wl@{;x_zuzJChAJU(^@1O04Ezx~D5~>a6<$q4P$=gIce~&9$7BrHquo|e z1Zo@$t)>H`wz8j@@Rn*lebC3)e(Bq?;|*Ask~Ldz=wX$rz3YpRJ^c{{5&5LIij@D+ zuLF+_?TGw^T6Q3ckL zrMTZ#u(ZTlnv`2JCn?t??+a5NobbzAa>L1w$lr<>Z{<2il`&QPQIq_ea4%@J1{Q6U zj{_g- zI3E~Q>C}Hw+(5bwqS-duYhlR#hiv8s=%kFVJ~CFuHcVPA#kyXAMM>Ia{;(O;@Hl3L z*vRi^t(qfGmuTVt?{z$dq?Ww}cLDZR_%1Z|8EnwhUj{eRhp)~E6awEjx@(M=2Oj?d zzK_VdMW<4!?LrqQvK^L6;ZR=K3_Hla(35>bba|D;AEAn1bUc+oiz*rHaWD$(I)_U-NlZz}!#6d-we>)zep=o=Wj`OV+9JbywC+U4i&BOP*2V z&s=%tX^KC)FXT$*&{xpc!;CE1>C+KTV(q(^SWmm5!A zQyd+kc^_n94q3-fY*n(vHw5g5Rzim+zy_gGW5ceCvPDdZ&+7*jBVehr0j&^?TKF76>5m`$ns8J@YV@}ue-~%$S zrxy-A6o&ovvlN4l^jX;Vg<0EZA7gbQWinQ%bc{l{?@tYyBNV?GdKOg2(f}=H4oQ=h z!a(W)XnlIYmsli`s5|V-UlKaerb^ZJ?iKaA6RSRHBt>s;C=NLXs7Sbx)WtuUJcU)TY-k%lrk9zsMSa*%J<>VIKUO;3oV#&}^i& z4Sn2LHm5m7JaHqmEG(X47$$|Wo^GWdXJy8x`^O*rLX8R5p^(;U8%z^#g$&klgK4H) zp-Ai4!8G%&P>l7o;xm&3XT4SKP)KV{xmE5^$Y4#rRqjwI(rUR??m*}qa6$a^Q~PE&1YM;z4Lfux>DW0_Qq4Q+V8yW(HWgZzxHpw`u3&;k@H7CaZmcrQjKTTsmz|E zuyfsz{EOIxvn>xb@7H|v$iBwUb>}zUnKr(5$%xBk_6OMqDyKgX8EXFS_FCK|<4{ysoF^5K$fd`SdJ9B;>RTX#C3=7j@{&H)S z5M3o-gZ2WyXzax({xOHxc9%{o<*yefM=N4sj1aA8cVb6ymNO_UiB@o^A}FRtEBu74 zpkZ0GqS=`pi-A{f?j@ycpE!vVz-}ZVm2{ znZcaJ+k@waKj7FDPdPtqFOK?s>!@|_`cpiSc|w)d!&Yjll04d~+pwQv@rYH)9(~m) zkD+R`$5=Jo!(pH0a%;<&bnZxp=q_^T-TzM59%QwGn|h?#|71Mx z&Ti9cA4)J)Ioq`SG^r?FW02MJ?yR7mHw0PnM*N(h zsB=OddMH7tLW_A#73=YovbCc7Tq)>B&d7wEHjaBJUhj6cv081d!Mz#p8Qr?te22*` zA{^m1I1KI`YHDnoD4IOTp^I=A1)-vB({V+?%IR6b@;N3?UT}-#F(ICZ_*9cSFIYY; z!u`BsJD~R$jma$q=a2oXCc^z9#(Pe1{x}Vu#kcW1;GiAV#&hDX!Zt0Z-zC%zi_+A_ zMdbv!VL~mibcCk1T1TN>!YDN?InLnV zF$#hk@QBp7oxw;B@Gu$NM*tC%E*lVuY2!uK!`9Ae)9OdASg^v^D%^sG5xt9lW&k24 zcTP}041G35s8A8zCWQ5Xiq^doA)Pz6&14c)sOWzPm3s&(qG#R^ROS&>ME5*EMLz(Q z$iHZSBf*4q1CY_XU;P1OvV-D?qTq|`k^rIXV2waf;%d?RVBX{B(2M2~hFyH^)}T(v z4C-}jGj&0O&bX^6xMQs|=mvC(g1Jka!3!}25r`H+kz<1*V8I2A2EJVsQHRTSYdm}JIWBQB6Fo+pOz;ggI9(P6{zzc$dmf&DyJ@>5~xzg7vI!7iL2B8q)HmXn%0R_E#F6Oz(5$TS=T&H+a zg3hxIvmJBeu1F7hpov6Vw#?ga)On=fmclnok)Ay!9i>gxqSu?Jyc*@jg7YVB4@O1~j~XaD>nVauJY;yl z0qe}>XT{2*;Ff3d+Du5P(i(%DUSF9L+@;Zij%hJE&eGM6%pkAfuo`?39|0I_4~kmQ z4RK!Z+$f@YTK5aVNF5vGBXfg#kp&Hij2zJx8Hu$_9MvX7`dUqo`&&&pxv1Fy*bG3% zh(5A9om<$4`Js(;Yxd0rW<&xrB7iCLfGNNZQFOnh&J#W6iKs#Ur(;&+ibOB-cY?AY zC6DHbnsS#OZ5D)=f;#rBmf1W^a7@xpZ=Hh+6l6Cu9BLR=d9G%-?e^Xr@ z2~#57`Zowy1oRyv4GIydQjCH43xEZ|jvzpg6Lqf|0fRiE2j%&%fMVnX%QIdDd|wQT zdZdA7yac$O1@7ep=cf`3jP7R~)O#)E5#!oKfkr}~psg%u)3CZq4$zEVkF_8wH^{~l zjMxO;{Tf!xIl)TZtAGUYFH*1)(8yfD5q^kyL4U$LEe{OPV&V5^@=(beq-N}^(_ozyvdoLc?r^*jTRle+Og%lV8u2JRNn|w2cL`YRdWa}O$#WXM$ zNK>zYgE`7rNn4WG#xc0-4e}=4Lv1`e23l>FwA%Vb;2u71Wmv86d@DDFo$737xQ`J! z=KZAIr7z5h{zB7UEKY`{f!L;FZiJrb8nBA~RX1b%v)?sqUiPePoisLE(?WX0*OB@W zQa4R_3p2E{nVHbw!}|=*BV^wQ&FeZIP+;93fpdYyS{JOjHt~Y=U=p8QmZn7uwvJu5C|OE930x>#povwQlK3q~Y4Ot{ReW`ZG&+u6o8wX}GpMQ?1-?Pk;8x zE32NpLTR|RJzK4$+tZ(0`pT;34pJJfZO>IJciFco7WH!_tG1!c zYGo>(jj=DqvsAlPeKr>NZD>QaG8@lq_A9S#Q^wn`sL#@H--bG>m6>=p!M+sFCfX0G z&nDr%4Q={T@!{LJGyT=d9OSXv-&G{sC)<}kK{ZdoeH&`6ROu@ zg{%+hoF-$t;b*0?6uYEcl~251mxMjxD5+E$hNtf<$q0o*zsGsEMbNq9JU3!LS7q<< zYWOpRDeW!ABHaZo3}mf2@N{ism zr-OFXAy>Ivb0gZ5BDso)cDwiwC4Sc#SmZJXqRzg96JYl#!py&5k09#o#M0j)4lTiR zuyAOW~?6D&NfJalJNM!1cS?8eDy|wN-jK5jHcWekP@~0Hqe6 zZPlfmZPlkleZB*womb@9<`mswSiM!9S2|{kxGJ;txc1IA;N9L{9&KFU&%8NpG2Uhj zi(om%8HyB(q?%jURGSp1>Ztity<7=w;0CzYp#UbhCBY5*QpEmVIK$qGc(916&z5u5jG9}$1y2Jdt#ZqcXse|95H~q$=v4=Bn#;;wd2t@=Lw==F-@p}SMxqA8W-cJLOxG(M9 z5-{d!(4(LB?ng*3KiKr|7*u_6(&wf|MP2Pdu^M%Z}IiIlO&PVQh4^;7&%wehpn&q}C|3S0kQa z0oPqhyf9J??+03MX&-N5qk|x+SZ7xPH&+18g zim^<|PJ4_>(X=n)Q>1a(caDtD*2|N6&Z7mE>@7~)V;}on>3GTthipwQYa(XG=pM!@ z92%&x^~q>?1nO)+oxvxm&IPFRxWDa5+hc@(>%DYRUrrYAp1#LnwMeNYSC)(NurQNB zI^zs@$e?k8&D&FN)?vr&oo{gx9^O!}AGxGts8?5e%wEY50v3$)cPp{;=LXWgk!{XJ0Po#8c~n2s}S^9F0hiCUaxV=ZR2_6+Z2 zFN<%4@Dgh;cP5r~`_Ur#Vk0B}2fxUZW%QltF%kPr`?b|kdjaR=k^A^+Zg=!v^FHX; z?`34JS48dq-}wYJA82~k3w3+27a3U#ORLkd9-{A0mw(vlnvK(ia#}e%p1D4*oIKb$ z40 zn2t@3;aOaY6#VEhDs?W07u6OV|3RBN)phW&%bYBNpPT!bw zAK$Twrxs4lI(_3O!_%_R=3&~7O;T3yqs7kP=_Q(uO*xD;SDKPFK1(z9;Ie-%Gbf*E zHBVux2)-31(em@Cb)nyEC1^%Kj}R^IL7n-2bE?)Vw3lgfk*eWv_HCE?hJC8U?2g6> zamJSGPgkD}jKlL?uEsBw9mUMVsqm&!t?abK)#&BIE?rA>O}sY-qrR!*@;j^LSdB$G zkgS(;VBM?g&bRO>!XentRuEjdBT+ar9SuAB+y?ab790xErr8~fkD&(GbVfk~AFa6< zun*MZ*2}}ylgobJ!1Mq53Cc03Kc=fSV8FhOotcgi)^ru&M9-C_Q=plT)qJS#7!WN# zpwjYi=MA;)5=!MMNu!q!klKe8pnCArUS|0knuyNDI9WqNb_`GO{Di0q}S?3*O=-rACJUo1t$4p_=mWy zR($7l(&u+ z$IrO1S~lG}sleJoesfx9Gkb8Mk|HxrfB1$=Z1~srzmLBCK1}JS{zv?Wc`2N5g-g^W zM@;;)KjZlw&QJYC!Oz({yV)CO{5*WbJYwN@VPp)WYR$>kbph}Y;?S8QvXon&Y%yHYyKF)ML%z>ZZ?OEoZU_X^w1LlaM0HPj-oi8LRdPTS>JL-gSVE zJLEsO;O*>)7Bj*uM}S{)$iH*Z>6D1}@ysiVtwNMr!mQPB*ql;~vzT|;MY%bg;9=4q z_0OwM#C>+hy~jqX_u^xuU&lH1b5pZxonctx7>)gVqOYxusm zxA$f=WP(OKVxiSqz-s*h=4hlavSu<$lCV!Wa6(6${M)OVQZ}q>wAhe}&b=_i5UbC;xxZ7L!U_oXanYW?~G72*M2!TGw&$}(5H`-66KR7$hH zUWCP1CH68iV971YtNKUOB-TRbVd5(+((t`gCEYHpe%1NXu)V_TY<1k;vr3$csXhx& zyWvn>pL%j;3n0OC1u_eq`Q~?>h1__t$tqPiA8W3jQQ>^}!aez1c2(NF@Fu{?#s7!D zCvK%JEH1|X|LO0kxy1|V56_-@N(~KND1C0(!u-MbK(?WW|La~{jI8-9si2`}#UpZw z>mRrdSHqC;?3BjX%qMXc7BSjWHRA+jn=g8*DbIWoXDORR>D8kzPu1Nl~3 zgtc#2msTpqJ-Vx|li74{^Fe$|V7~7?g!7xPK!Ts+)3pntfK>_&fA+5V`~o+>=xZJ+d$ZC-tXgit;$s>xJ^#CyL4GkUml3-{j>_u;XrN&=t&t$6=wc zHJ~XB;P-7nLvY7Wi{C#yKZ(u8eHebUjxy~NbT8I1?HPJVP3_qtbZZ89BdgTQzkmdl z3%=oDqh4MQDVt>RbqWgzvUs{0p+yph&`N~JdWlDPnQ{W0fTm)6^Lx0DZNA*fPT2#g zX`j>b1@GDCyzPrCPmnG`FBd6GR=F_0w7c~1DWvmkmBe_w{i$ zy>A2huKHAb?YUc_VvNY51A2La;zAq0R2&t0$oRZkM!v*PEtUpK*oYG1{WN~dTo`|} zGy~yj6;bF*B=YA=T}iMfn>vttIdb#9M+-j>JX-i^K&XwrjqB8I;5u`k<2tvMih%sG zH9D+(D|&N5_ZP1cA?pjC40yxgJKtKF`~=_m3DWNE#Troi&nG|)T%tU;w^-t8fBB>j z_%WxKuU#Z9eoB;`y{$>P(nYjVC-3TOPr|tkHN3Nrb!$EFnm0LKjc@J4ek~x+Pp(np z8~b>7IYxk=Om9BZw;Ag?6E)q}*!FSMoz2YcclzFM`(xD9W;**4-$W&_?>ww+O??Kz{&`pp?7F6B(?mdQ93r)t@Z1?eRt0>;Ag_LX-PTX(eUW5B}++Dc;2lsWj2XQaO z{VMJc$BINU$OU1Vt07v(c2Nv9AAAA!T* z_auF^kj`8f)^MhE%5vymzz=-VJrL#){;2yufotFgn(-TYr(*D(``}042S^_6CT}4F zK6b*Pb4@(n`*pV*p!a{-eeKr!%y?h{r0iAYOd2DXmJ_Xe1!tQ#0GWxJ{5LJb@lq24>JY8qC|0rI71zVo$SCl;(sV-%8S7V2K%oE{-JzO z-U1Hqeq%oPe2esuq>;DxxX_7j4r2{^k}_P@ z@kCd+w)+r4LFPcRbc0Rz5M9KJS=Tt@9-6{AjR*>|;6)wWE$n z0DRsXOr4H$Clu?hPg`QNg6po(T_01R+cibf)M)qV_G9F5ZUsJL4&elG9k-juY5Z^1 zUTx|~I`#l~Omm$9Gw4B-_{w03=40cf2hq1;)V*aeO?&J?;J5*E4}Q~-)_3(EN|H+( z;B&13OX^owx!lnK2Got_IPp*{)2XiIZmF_vevso|k}9Mv(#U;gKS^ToO|%*?@?+(M znLjOO#x4Rqd#(3O(wm~Og{<~yH{)xUDE$=aTh#Pr3_OT2Lh@3^A!@3+LVpVro|A4& zcSw}K>^9(v6BZMH>Ptcm5BZX68Ee$;h+RwASCoV zKE9UiVIC467)4Ux*z)0>TXTSGsmvs?iAi17Lbx68YewmikOoU1^?xmWBuXcV_Mhb0 zLPO!_q{URqBV`<$?Pq@Fs$l#`LqxrS=AwNQ>xs@J!XzC_RGUN)I{KYY*CcH}af zoCt|hMEK3i52!rhbC8|)Uwi=4t|+fTxaJ}=@h<;RX#?&5zIRz(b~5I)WqLNv_LrSz z%=QeaE0h$b){Ii&KC(N)`&Q>xtV#o(E_A8I0VZvYk30m4^1&V&*JaG80FC`;YCAvi zvB|}Fb`te(3N1RuLXH%H{S=#jED>{yN+sT4 z9X~s!I}9lmYtH@Pr)gfTImW6b?4%MqY`04M<=`8O@y0-zn+H=C9fSW>wbTuRDMhzR zO&=^(8Z33OI$E|=tEZEdB_SpB(HhS-nqyWM9iGG5>Q(e^0RbBHT#YSo81sKR9>+5ln244RP z>gh``WBtEhky4+zf*qgiA6a@qH|l&Wc=?g%!7FG;=l*Fo{A;d`{er@Opzxy+&2iI+ z^E%nh+H@DlhXQmiknP!v40P^XF7)o0$*_q>T_lUXtnM)$b_t*nA3<7o$Om2IFOFys z#rC?e=IXHiidb`@{fX0X6*x@aTel({VpFE0_R}~k zTHzgrFIcSf4eKl~dfZ33WHr~n!M|@UTH&`#s-J`{`6x4+rT3puPncc-b_nX&FH)_n zFJXt3p1y`2Wr4zHN>tWsYTmPcdb?PCd#;*t=GNQO)wfR$zFpR9Yjh&-!z{hMUCsNB zUl_!hQZ@b-;xll1MlX+4-`$UQDfa@5uf0L7Rqeq}6dyy`vW<_61dzyElF8FuY)gM~eqpubB();>d zVzJ({kHf`1eR2@W2B9icN`gZw3?wGjUMHpxmu^xJOtrKdx?vaZbA4b@F&37?(yYe_V$O)sVA#v_^G!MR`MDHpQ0{aUAeGx zUjlv8efmQjqyzYvXv|gR_5M(0H$l7@@9*p`2ArothU^O20qrOi+9ui&pVJ=-d}so+ zO@Ouu&^FDL@%s;c-vPRe!8mtusU2mk>^>LJ&n3TSKZF^I^H$v@VFvmOLq9tFO8l5a<39@Ok)dA(3G3#E;-lW3nAT!d1dyg4>ILS_~i-w}Iv=o9>b3 zgJu9*Z@&-pA{^SSQng&{+WZNYG;<+onr9O9@`064tXYIM#PtvsX8RVYFzA9$zb%N* z^37MVGC{@43_taru`VuUQzM|6=PMtO*xlS7Z52~RednMLhtJ@~fu4^A&7so!A-7Pk z7om4|cTrv6s5tu1Zl=Ykj*Y5+De4c^oDwlMBF07pb^;@fxiH0 zp!rYmTmTBNNcA3cpGpS=sY3ZPQ|B!9-!b~%$AyW7&FKY17Zxh16hoqgdlUs0*^ATeM(_5=HeYKJd>@mB-^3!{5$7ZRbQOm4 zo3StQ+{FBW72>`2@NBW^9tr;U4|IicRUN=AU*`3DSz3=Bst#b9k5--O>Z+50Ri_GH zb(juZs;9Hf4Xni~1(R@^t|FK4#l?`PyQ4Vo3NKt4fYO*QS{;(Rgci_iJDYyY7X{rX zo2*i1%)>7mO@-J^h1bnt(%S(;A@D{2uYkVrJN&-J?<@Q+2K1otWa0TkJQ|`&x7G;2 zlxTa|iS2-nt@r?-`e#R+_nYItg$J#O{m|x5<9BQJnDz_R+#ch8%+LG7IBBS*9ogKT zz~H(thu+QrOwG>{P1;wVHkzpY?eOn;m;bH$H|nhgIP0%+FxXcG)ZT{XwxoUtW^XCw z@ML~v#q;%6{Fas$09u)VRuZ7q(jZg>lbCAOO1@5rs}K*cuXFNafK_BmqzV`9;Od#% zXaro0g&p`2OdNpXFBF31^GYzF!!sS8=?br_xJCFxbBpE}!R3cA`G3c;(xw3%+x#OO z6TR?X^daq#O!t-HyB319*h^YOJ2d>!eP-{0&T>cDDT?`eOG@sB7hIgTfL22X4IN|q zuV3St=_SqDW%x|c$qIPEZ~Zzo&4M%?(*A?AOYne3`QnhKN7^??^TVE(#$!MyKoV;W zzR)1@Ofs!KZtzOb^XsAIH^fU~l}>)YA3P)ER(_XG_VzRQvPUs-`nrXQ2JA-{8^Mc< zq{|VI_m}E(0XiDvt_6umP0``4J!%Qm3JqefArH76=}CH?s@<)Vw-fIRc}$P63r}hP zKqo)nuK{m5qh9MtuNNSn&h(*QRwnH(pWgjm_x9`F?s9o@R#9+4Oi{4dJPET9)&>?w zZ*nQy{w^0=8d(+TY1Vb0x2|F=OICfP)Er=wS($;aZ_e^% zYt$4L5*VATMOcq;hay;ccqxHxjfL3-&&er_T&>peYZsMRhZ3V;w|xmEK2q?J;<68= znybueJ&S&n8eJ8w=DqhvsWDYCYTlwBrN&mps(A~3lo|(beAIsFN2$ZAhN*d-KS~{r z6LggKZZ*|j%Bbxffirc~-suH=O7g1HXmhT_$`2?w2fHc{V-*L_vx^!8Jfrlv%A&z^ z5$OlK5jCtl0y9+!z19B~=1B}ZYsX8(UGu=fjs3hwtf%>-#rLTON|>Nfxek;Zz={=7 z!^oj9y}!MmnKZlOzwcZMP};xMw2l37xdWIIFR`gQ*$fZX28{ovj-Geeu^L!#Uc5RW zhZ8*`yUEi`Vjg4WYz%8Uz_5vVF0;YrNH!lpngwBtBYEqQwL~}ZqdB&v4jlG!_1mrO zqWBW#J_9XFC2Y%dGSj!d;jXL)f;xTy_V}16r!N!pO(*{fI|S2wsvnQnKnIL8UvzRS z=5xRYI)K@W)}r?78`)I+X4A-|l7I z8HhcJ*k}Gby};jg3#)@SNXGVi|J_7I*g-E;MLPLG_TW)ppC`IdCvD+mCj$Q zr&Hn7GtoX=?O9dt4t4i}XxJ;gi_~xi!Y}mN)G)QTyjSs3+o`qB_x{N{5k5Fnt%97= zwZ37J+9qfTTv7j@IyxqmGLdy{go0rgHcU{X(zrW^V8|lO}7b6nu9Ib%HtJFoqVcGf0&cfi8jkceI<>WL*qPSYlWLhGuWzRiP`m# z#8<#K7PQUc0gWtlHNz4$pEQ^9MYQ^~R|DB-pxyjbC$$I1I0KV_0 z=%lLw1J3B=tCafx;qJ}jqbl$H@w3gIWs*rC2_c!uuw-GGB&a~BOlFcpHb_`RP}HEd z9=B^i+giIgA*d*}CNnI_3_-NE1@+d1rPrvGDA>|ly`5pvpdz$-oifvVdxAjDB!PV2 zpEH?A`@8q``~Ca<{c&c_dCqg5{quP~&u686e;yVZTX8)JDyjwam!}7`6#T?`_Q%(J zFUDOAc8UuzlCEGyK;^<7VM-PSlSN>1j4Lzy#^5B8dvKHJJ@DRxn+~)WB<(d}bYD>R z>pxM}^=KBFiVFsA#t0NRG(O`#KeVe;Y?|dKRCfkydv4a(WDu4u^ zbQ^aWcoo9zAT-LXecN#64G^5AYO+4@*OQq2mJc)V7CkMt-$VQgDLWdX!99J=YNii z&W``XxK=(7&0{U(W&GYw@VjP@E;;b612-O^(X|JQ!1p!E3o$|t#N#o@x1%L0@1WHZ zaER%CL~4O99piP0sd5y#n8GNc1sUWDM4z4y?>$QEVCxnbY8+3#I{&(H7q%e}`gq?O&&+dn%!Nb-I@ z=$TFY1i-1?eh+Jp=*drnnfc-#t^DCAL2X0mE*r73CS| z;50_oWHCh#2YK*l9ti3lV&>i#{8;fY8RDJyn|sT0UUuDda${aW)&7wy7ujNAV6@LF zsuXS;yD)jstY_?nqIQJ40&Qi`)Z|?uMgA!$tE!L-+REja;}kg=a?+bauS~h2ikWpz zExiC*7%h(Zh=BC{QPgIIzxb-(<3C<rINRWSBebW;cU;}u zS2tdIvi$j&rw?T~Hs+xOCb#PAoL8nyg-5h_i+_3MRmdrSf$Qh0{D#JX=_VdCk0_Ob z_)Jgv0nJ0x4`4jLP8DxA#CnBapH@6(?o|!ygm2m%DTtrBM~xPMbVnij^Ds0sq`o52 zTmW4PdD5u$q0P3dL$~3qMVuTS6gpoM3y<@d$Ls6s<;A2LXm?BIgOyiiJ!W0QKx<}` z)9=!q(NWyDcXFz{j75SUl_i3z`@^fam-a>G&1bYs5lCyqq@E(BOQ5D$E`+$7khn7? zBf)gYPZ4v`uCeoKn)7^K&SqTc&^u_9wMjJJPxa(1CF(K-{zb@V%JvxN*&Y+xGXSS6 zGI4(FXXN)|e}xuXnW(cdRz_Yo$`l|Hj@_)Du4(ic=qd})c7YG50_fh!(?=0$NWKC* zry*?6#?@%$u936hJ-}OJV_}jU2L z*kqqU38$3T!Ar^(-#o$(=Cc;e0F62yU2j>Nmv+jcwvlQwWgSz#bRhn`@|lCmqyCii zu?zm|#2QxUp)q1hahh_~uzNr~aOc_it*(nfiwkr*rv&3UsBJPVNjCSea=xyrFMqB! zXqMam7s}&pbEHiC< zd}u_dr)>tayqIAJ1(qLVX*8@^RUTHqoKt&A<>5WoD0lLWk=8W4FK`^>qV4JW2DWUv zDN@|ROB{kFS5r8#t^m2slq;Sp zvdgEV;yL!BDUl!ToGz|76Y238_H0>JXi=F<1;%OTH+CcVS+IFp)-pS(Y zrgO@y_t^GMfxdS}+AR2AOl zk_|pXzyhCGv0!@bEFh+iu&}@ zV7ozklW~wW!b39GubgTjE~Z_oj~E|l1m=2aaD(osGGJX6F`CM1pMC(gtP zxet1i)Psz(=aim)$j@!{82|gkU9jPc=cH3J^@%M-zLw{!FMgJd^*mA zsqbr!tZ}*XmPPn-c)@`O*M7HIN^4J3*9!XMu++>%?F<8~kC~#=HI+#_y;Z_kTd1yV zH;prmu|=YjHjP>%Jem8PGgN#9fA~vqHL7PzoFy5VZKgf3zTw#(%&13?vDz(8oxqRN z%GN+yg56WqQ(%fT*daB8Y|;o03&BJSJ_?WDr9kh@L3`DwfP(?$ zM^<{K9qJsOQM&b~C_P&(O)cL{`S5%}hySP*})C+jJ`w;V!H6maAVGfR*W8 zxrjT>v|-Me=`^BkG-pk*&~%B?6?98L;Sjh*i z=#xt6U`|;t>p!iIj}>rD>yT#nBjt5kwWJvaoVCK-I?{5q|8)P}Gfr*yH_oq%5AgA)_o=1Ya*oDg~mR3bP&YL6+QDuVl zy3zGCF~yniADN%>CM;$0HBIp2oeyY#Z;(lOIBiAH&o<_sQx1CI38cXlX>&1FS40Po zIC}j&&<{NT};Q@m~3F$8Q&5YB4 zXVFjK94mRxvD7-G1@1UTBAEIt{?44>Atorlkg|n&Bw}^|H-G{JHQUNB>kc>OQv3dy z4jjiHjr$sY4*zaD#OYFZtfvR-g6WPO?B`U7`xy0{R@z%M*nhYQxZ7R#KH8;HPDs^z z^(r);R<>A!!h2sc3)4+LWF0hDB0tNDw=BtLJav#`lxh=^UO~w}riLDShvXw5D_InQkhDlTy8@YWeg% zYOg_#_B)r-u3R1YSv4n_y=L`2>!%&x6=83n97euco?or*-Cj;g^QNhJ`0+ejGbs=J z?xa^kIhk?^$d&F*S949Kox77tBU;jl6*V2S*{$i7HEdbUc9 zrN2+zN0DlUFSXB+%HDuA-M_Ee9#nUJP&HHGX^q}kY3H|o8cuwX507h94imr^j!#tl zf%8ix!))HG?t`=+%It5LC+i-SD&@MEFOCl+t*swV5e-A%;+@rs)uUIxvq(h8Bv!S$ zPhoFQ&@q5S$LE6SRAvp)2lD{~S+ETwm_{#|IMst_u6&l;DNk#%NZGz@we9pa0U^-c z+>^L3hbN}z!r1$Z7(KTf|F$B~w}i#E^e{#L63i5t;+9}?$z20xKU;juKn8yA97yvg ziDiB1{(|0m=)c81KwA7X+nYU0>TJM|)uB{>N*7anN=Yh!9-}Q?*6Fa~W~OxLq9=4z z%8~swLF3$q&!h)TKWux z*oT;sm3T%(LVpo>Dxj|rNtm?i7Kh^c7#jKf$o}w*iMCB!_F8z_#FKsE&NgvpUFHv4 zmvx5M<_Sd?2J-6C11r{X<$Tn|zwNq+wx#;>hucOo0x7$-prJS~ztfCpJiJV~mT53eV=`1=F-Vn={2d3az4e!n;1RXNI? z9v}XH7~G~lz2Mod{&#t9t7oxyem~S62tu=)DZzZqOdHpY=E00Z&lDg0d)^tM(!L$^ z1&k#RpJApaBc6i|I!#_X_#5qv{DC^gPH?WfKyxuA>(%@Z1iKX0!Ij(wuf<&It!I)4 zvpJl|%iYz>gNW{y&lD*kclFN)Ii~g#9jp^*R=0Ph=NPa`?m4-=i!I;QX>2yYi;qSg zL)0qL`_RbD2y=cmW+xfFC+wcf;HL`oS@H9q#B7 zyn+4O{M+8iae;!_%DOo5p(WbICa@s%rDu5(A*~GmFzfZPHAp)a2?0o z(!A3A(puPz>p5JckAk^gg2*&ISXJd8UeK14X3f)*PWsJ(`QW@hEA}jbWzpN!&}?Gu zORIj^Yc9AS{KK9l=7LS|3zHn>*j1uNUN%M zTE=XzVHE_bG_rA+^c-E#$Ed~ASS%?}46O}5YGh0b`y-8fB?ca`y07y!@qcdoe+9;D zJ+4z2Q^Hq>Xdavl>qrh3GNp)~;t0VnQ_&LWGgSn&fP^a8)p1YWGyoXb)Od+QjLkwZ zYXS-e^cwkCteot%ve|Hc)M^u-%O#~l3p?~VY-s(9g(PIO~1KMUqGH=w#?pO)@|1SquUy#2Z zj`v=V-roccZoKzp@!mg^6YtqGe^7hx81KDF?R^G%pMl<+$McN${+Vxj4{kX0j+>yx zS{6p{K@I?J5*h%!CV2a@By1u*HAouwpdJn!%(RYK%psnv6U`rkvFkzp0 zaDYQhjpRP2__ok$(7Rh)4~C#Sv%%Q8#U(+r<~zZUFfQyu#NgAf(6K@NAgd=W5J;+g z8u=Zit`7EN>sH*s6fX?c)FCcL^nIpGxxws`UQx1gLwUy(>nyhD`6Fhl)vB5OiZU%} z+Y#2r*fuLOax2c@q-UU3tPC;*uzjBfjT1xy*sN5}BaJQCvnW)1c`Y-YX2#fQYsM~V ze?@T#m?0i^YV$PbXD@~B30kC)zpISPL)(g=@m2(lw<73c7D0PSg^jkEOD~WPoPKwB zM(vh$M!5u0+NA@+l@D&3FB)YBJi{{uuv?MWLKngTPPI{f?iw2)?W@-ji_Iw8ul*qm zUzbx;WJuG_0WK1imHP1>p7f7Q-WyW!W)-1 zp)~J!3kCU&v4m_osAQ~QE>wZmehYH#n693@ z7)=$og=rk9|Fg!&fadE~T=Jo|9{sMQZe|;Hob9F;q1yvJtD0;2ULJCsGGH&#RL_OX z>79V1C4dG|E~=_)o1dDbjhb1)HS|s zxghh2ac!%?8n3|`C-@PA%uLdQB&ZbR!E0_nWz$^*m46Oa{u5L-QhOt&|`qI_@WZ^Fe(-@uiCvZAGX z!*QJP-q(N9tPe zI7mopC*UCE%`X)%Q9H zKhjzzocTY%+U1t-#9?hVI;Me-+m7e;ushiD2zX z)puDO){ARnbj2hHz=ss7w$zg7RIEPE?VmOgO`M7WX!{b!?` zH+lwgYNqgy!9N4)8Wsyz);)eoS(T6X8v{6PkyH>dNz{0#K}dYph%3>qzprO@jt$LF zt$+>(kA-P$2>yz25$w^vmXB*39|4ZYHY80ny_h4KcUwgx;`B1#gKp3L&|H2T@fWU{ z0g*%_6Lb?y>H(9N5shUb`+PBOk1xiz`(i>53ww?E=wTMLW>h)n z3&o-xIuVFqG<6aHXXlC+@T?ND7{-Bra8D#IT@N&H^W!q?vRkzfHs`-fV+s1g-@!fv<9i zN3;m5B;FPQa~8jYpC8bP#Q!Av8`wV(%3Q`jQmb3##RHXTaxun*ZVZlrcBRl=HhFuZ`SKEvORmW;}!uR%)EY&BfL*#bqqbsxA z&`RU3x}nE2YlRNBch`nSMm2V{`EH$!wO$*#Gzt#6Uk44$YeWA%x}#1L*a1)I&qCgi zJq?wvPHrGAl^jWtLVDn}T=-6EH~fre@|P@Y~8fx+j**fLs@m zw7gj=kCMtI9~%1fYeVUymG$)zLs^!Dm1LxH>Qrro1Ye5@6cGln!pDY+0Uj99V{|HD zBQr%kHI@Sd#P8y8r*fgDXYY)|-QNdh)o1TJrQ{y`2I2(IwV^+$XZt_Hms$a+xHvAm zXC%G~DNo9=h)kU$HWmc@Yt6B5sxKg zuS~$DVzQ#~erQLs(T|UZ6RjWDwE*s-F(kYKS%!YH_^X~kLmblmOHDp~^wzBI*fB^# zP#>QHkNR74wG^A7u3PDMG(-?P(wFI;7a-jZKDvb$eBH6*4&FBpdy0Q=U;CdrF<0+j`TMB=6D!ADK-Nr{UZ=VDqW_@l(Tycd2_;k}xTw}nO0xS~M!( z?MsirzaRFGF2pMU=l&j}KU+-o0nd~t`_CyK^dOz#{U$fXn&8ULDgEtkIm?~A!{{!q zZHO2Qddh2ZMp&NrFB1*EeWHcG0~Y)9dy;(GE~4W9B{nZ0_}8i&P+cc4Z-y>|Q$FNb z2puK2iX{xgiLspGo1)?YeE@xPBvNw`kz~BT&1&B;Tf{dfj6r?-M94f%l5kC6W%V)G zUi<(stnQ)L$&5+&htV@lOcvKfJZZ}Wr{3@nbrIj4%0>O^nj)PfaPR%;IGx9^3zJsT z@l$<+Y^v*wG4NY4sVmzJKjH35Sx-BRib;tRpTMLf!6Zyw;44u30I7GpTs5a15m!h; zOy!;v3Qr|UnC6?Nreh5^)5<=m=AQ1Gu9h2b1$T-fmmUi-c9TDOx1~iNtVGgZv;eNf}D^c{bS>;C?#=h=p5mpXQ*`rxmze@BdUK=zRby)56d$n(o~#5jlE zOR{<$o;8{sG2W5VZs;)j;&KAo?Wh-t*-7ZSYiS$-agRbPq-~iMn6OR7s8ii>d`vi( zU{d`KBSNwQf;Yo%`mTrlPJOT7j6Cf$cR;hiozzZi-63VQXQ{GYUFSK))4D9;$uoDZ zYvkO^B1t!wp|{Ut)#~-jWV>t6pkP9)4ar_;^!e`;&natO@-k`LX(jCtleiU87HQSr5V)5llQcsSQhL6lSsR6J*vGS3H?;>)ba9C z_T)(U-u&_MzTDGVZCB;oBpDJR=jMVA7W9U9OzwScsc(S2zv@i4h|RqS-X7 zE$GJ?mG&rY$-6x%?dcuPi{>_OjA{9G!`p&4#xjT5f2~dRc>xd5j%t_z4a3Sv66*y# znA)*7F$TO792Wd)92xl4I*gziX8KC(Hb7!t5klGax zw%0umFCOlQwprL&9npT<>`Q7#JQs6&ZMAH@HL1Hp)Vu9cru#;%ww(vfY3S5%uZ(yy zHC^C=Z+ezZ-l^N3*1_8Nj#f6aLu2Eh)$}aX5z?gWj_j^Kp;n>m_?k2+rz5B9Lp&XY z-U#PcXU58_dq81pVti)#W~uE|VcC&Lo$Z^g(rvnbz?5@*bH;Z!f-t*8ZA+8pcFgTM zj#^H_BkvysW>EG(hkv@E^Jk(M`B?+aQ3K*786}6;p{|mnkdr39E$t{(+nf0Igy)=6 z^-}yBqtPgpdCUAHlgBrE)NgbPrE+h%S`NOkJ`zbUBRuVt4|^ISKTE5W`z!Ia?qh}N z`A`YM;vv{GMP^g41W|&SN=Uprg?FdEc{g5q{JR0X8yJ6wT6);BDVIEVod^-Xc7b$L z$4#mnd8IOE&jM*d#{%`~sPZMsfObm@MunZf^Q>}yPpY(V=R!!Thfl9mtUamHqMeJ> zC*%cI3PBU5!dDSsidO`ANFmv|`k)TFpqjbR!=DSy-~y&#g^OaC^Cg;)5j^m>26^~i zS>fVFG?%dxlO~qVbbeyr!#+pw3VCT0?R^WSZ+X8p4wv7|*3BI^UpL~DPa%#;8T%rQ z_(HcU;&HiTt1DGnymPVI(hVZU&HA)xhflZ3VYcAk!t4#1L9UA{<)9-&KAHKBqhB!v zkA@Q~C$XO=t1IV^Uzz+=_JJD2twy+%_LC%kT7c3m?mhS}Tm8l&C1mGjf9CjG|8;K(lhU`((k-5B8>1SW1~AwPer?kqf0x+9wMjBZ$|?D2}UBe`XLtr;{Z{~P$NY&Yyat2DF+ z#B%7oK1+Jf=Q*7Aq4QCig1r;*f077W5M5xA2vZa0;{va;|AAWFk*CajfWFCcBR5O? zo>SI4O%rqi8$dp$A;Kq7F2IaK&8OyxQw_tXDMvzIAWktr!rvu~pBFWVe*~}n>K>dk zu05T=f51RioC*qxa4NVuG$m$4{OIK(&A{N*X6VVgMRxHV*cCime;iW1E^+Be&=u}2 z@N%^!O$b;)w;OPBehNB!hEk$g^xkau-S7=nDKpD0(hT1Wb;bzKxls$*o?IRJtD;xG zd^#7g?9!3~L?g%PCW|!FH&gv0acWQEbOD=`?>CB7qybs zE1l*`d?o5U5mkBgYX-EQ@ig`&Yr5akQmN8YhMM?)dLU~&1@`r%k4UtpnX5^_Trqen zw6{zZ&-G;3Q^kk$y7sJnlfd~hY|HXtoMW&g1s(j9M+(3eq)uBNk)73Ray{(T zq2!ogTZuU}#F7K|gKILiYK1bL;i69^Ic3J_!u1R7HcD1d1 zarHi30I`cT;6dym?ooPuljw_St(xe^aEYaHYQ6CNyRByl2TQ9gL>4r5YQ0y74vlF2 zX7Mg{j1Pgk#aw)-t=(oV5XMK~$JndsObN{(ekJ*oMP!|^`Or->t=>nLN=BR}_~@;c zKMq=TN2{QNVJIBdDa^2G1uJm`o$$Ot6RPE>d^5K zt8MjOUd|dR7FX|Ug1nk$=Zz4)SZ72eGmZX@#{bBNebb(rh)J`0UrL}!L<#GR;_7al zjYe^Ho-M%x%H`T!7=PmopxEGpCBD(`tXghbt z*q$_a9lCLt>U#3h58im7d*!RQytW*6h}?E|2k~DE$KO5phE4oA`$7ZGqwW`=Io4X6 zfDT?FYLrfy+D?LvHkK2gu5FBXkav^YI>8r9U{Nh%2yRKIHSdb>Wi}~`cgZ{~61G^< ziQ;A^fr3e3SNH{qY|WukyMzsOb)e@{K%2**l2@@T(eG)5+pRCMgcY{Bmq7Q3AUgx+ zd3`zQ^lE_>?7)G9cgMB*%y;6P3~efwa>lVEVfZvZwQC95ZIish>YB;kEW!ZDL8m9G z3pFu`y@jw~LZhewHlov|8q%i&PKi^RRHEKbIKBb&^>itnchy>er{br5!h}>}Vpk#P zC%k1*b;wDZ&#Os0Z3$5BB@v#Tte){^0lN{dN_@%Kr%S2+*@(BcDKE{R#xKJe88jF$ z`XpeVLT{nEyQNbrn$yHo{|xYmH@Q+NDxT(9p<3pv^&Oxjp(#n2iZqXjmoaJS3~&)N zn)sVyZ}G$%b^k-|5^sr`hH~Tl3#85R&Qft5rPW4soCdmDX6h}Qg!AyP5`1N%34p8m zQ(@D|Y<|@!&GycoD2sug?({a=H(vu^b(6&k+l_2@x;H*gbA5Bwo}2xa@jYgfJ3WDM zIk(JXmK{EaIxFUY-cK6gG^1AV5jl0PD`gtNQeWxB{*b`DWxg_XS0>E6Ta$K5@7Gc! zJ=mN;M=g@VIOQbhiIw}xC+6HH=>zl@JMAKz29aYHa?Aslh-N;qQfOXp@ZIqLq3j!d zH(pnEO2CAOew!wxs&!=XmUc11JL0Xl$#;`lM+U8YrY^!8*JC}`O|0knzWHi>@xI5$ zZh>!sT6&xpgpuK`(#l$TN9%Q=Z{fsO+gc7x?IJ5jEO zb!R|Rv{0PXu>iEgrj(2qGj@Cjyr4B?#i45G=SWVkQ(bMh!}c~us`OT>Ptb@5y^M2r zdpsw>yvyfO#{_ztOdt<&EM3##J40-N6R;O{>sQmwc4y3*^t_5W0Qov#k7=P6qMkH74$`yQ^xzJ%AKvR$26w-aY&XH93V1-=u`DGzP3xF_BiJQ#{+;x(z7Bzdk_0X2lp;~@ z2QMKNTJ?+hDoZoj^|ZOT6MAV%4lL73e^&i>_=_lz%H71vB))}STG75j<<$@e^WCse z`fN29yjkH=`zOu=4Za4IzDifm0|`vN)VEX}S<649F7qu@^QurbaTaa#HL7_tC-M@6 zH~E?-=(bOUU8m!_#&X|sH80{8Tg`sJs)MzscAZtG?P0-bU^lN>{#yeFOJ%v0wZOXUSWM??XJGbpPZD z3LR%fc@}7N;s{XRFw)k~zRZHHz7alWQ`Jc7U1E2S-o6ErXm%gs>oQ(wNQ@5s3ncMb z@M{qF5&+vGU0lcOR!9rjnegy`jf1RjbZGBLHmF=(bnWDCDBUg#QMsc-{t;aP+eI$&3H~feKdH>0)Dt`>b|sQ`QtIQX#4VAUkX1fb_ZX#HX~);x5MS}+ z;f20HdJ|Jb@lX;yB*`SLXQ}@Fn){d1XeHhx{IVdeDUp`28$%kSg)IIf_<|-Y=S-Xk z;%A>*ETcnTTutOBc@C8x_wABMP55hx`*umBCV1F!-!6&Ng#0G%+l5jI*ARb?<~S~S zXdcHk2@c<)e^?I$?bL?(|By;BP9>D9sR^D&g3~;=9zoI{6QBVHO3q=$%3OKX03F{K zU2_IjDRwJc@uF+y08^|4Z_DE<-g2=g-*&}L(Au?%w}@mf9v_VrmahG*Ja+ZCk}K@` zD$ysBnNi)7>L=Hvs$*Ui&RqKZS4{EQ5cz35r!?&0J0#rW6sGx|O7<+7K_GB!EWGFqK!lZqHN<0UwTDq@(F8mHB~X94hvdt7fL zL-h5e7I?%A`DSgZXxzv9(8?J`uQs|ZqZv?q|F9L-^;x1tJprCmj=xJMJ(qeC-4)Z2 z9f*BbjA8WK>6EuCrfq^3>Fv8>x+d+52K<|vjZ5|BeB7mZ_sgioaZXK8wr_KI4XGoHOwzqrSX#ICq_B}!QLmOBSoca(JL!yM?kXx zsi_^QDo3a>ZI(nCWF4rcWgueCf5yuNT^lbqb6cjG4>;bOcFD6` z2sKqF2OSD`*PHORY4sa-Sz3}YUm9qq#mBQ-ndV@p+58NwtW7WSIF$?DjnKa#-yizU zTxb*7RsSbngscHyi~+6lc}Qp1)mgi)4N1^^{#f-5k>E2EJ+@zTS*asxTvS!<4P4pT4oA3sb;n^da+9B1qr=I8JmBY!ey5R|u z@j5We@H@Kd+Rz=>cyUW#vj62i4Rr1oK$3YBRvyqpf6OGejqvc_Q6#49WlGKkbAi3$ z*u&)4T;BA!aofwVAb5FDFuXjdH@-ZWWYR}@;oT~Il;hv4I$EV^CtaZ&Q4_EYhs4ZSMG>&OZ{AjRvjgi54D9m$~z#86rQ ztvFWxH~7DPEokyr;)#>ri~S-j;9bS|+r4<(2HSzwU~#?)8fu>JTEOEI@(~?3)$cMl z7c~!s9t~4WpQ+HuBQH+RjC*@}2A;CXUgs$fH~X=H%w7}TJ_bAHH_HxOHa~gaz}nnX z$~)W^*WCl~)TG)(>7plflV#qZ>Twth(Vd3A!L-yB13N&Qyfvsx{qDe9gPPQhL8GkY zxsv;XKV;Z)pGyiE1C5vN*uX0bA_uy zIkJ$N9yA7?KpuXuL0?u?0h)}3t&QhxC%kpnB0npaAn(m6+Xij_n>O-;+ZawRk1aVgjyoDY7F_3(L^ zWthKh*CQqiu5?@}xRP;kxXidxap`a�YrAikm4~70icLDS5PI3Rl6JEvUQ+Ek5&; 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

pYg%`f53~7h|aBBG2q6 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

d% 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 iwu<PSRX+m+J%yesidZ45 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�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 OQT_h&cb-0bQ`3Lkr#Bq{ literal 0 HcmV?d00001 diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/us_ticker.c b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/us_ticker.c new file mode 100644 index 00000000000..006d7fbc50c --- /dev/null +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/us_ticker.c @@ -0,0 +1,124 @@ +/* mbed Microcontroller Library + * Copyright (c) 2017-2019 Arm Limited + * + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Supports the High-resolution Ticker for mbed by implementing + * \ref us_ticker_api.h, using a CMSDK Timer \ref timer_cmsdk_dev_t. + */ + +#include "device.h" +#include "mbed_critical.h" +#include "timer_cmsdk_drv.h" +#include "us_ticker_api.h" + +static uint64_t total_ticks = 0; +/* Stores the last reload value, or the last tick value read when a read API + * call occurs from the upper layer, needed to keep total_ticks + * accumulated properly. + */ +static uint32_t previous_ticks = 0; + +static void restart_timer(uint32_t new_reload) +{ + timer_cmsdk_disable(&USEC_TIMER_DEV); + timer_cmsdk_set_reload_value(&USEC_TIMER_DEV, + new_reload); + timer_cmsdk_reset(&USEC_TIMER_DEV); + timer_cmsdk_clear_interrupt(&USEC_TIMER_DEV); + timer_cmsdk_enable_interrupt(&USEC_TIMER_DEV); + timer_cmsdk_enable(&USEC_TIMER_DEV); +} + +static void update_ticker(void) +{ + if (timer_cmsdk_is_interrupt_active(&USEC_TIMER_DEV)) { + total_ticks += previous_ticks; + previous_ticks = TIMER_CMSDK_MAX_RELOAD; + restart_timer(previous_ticks); + } else { + uint32_t tick = timer_cmsdk_get_current_value(&USEC_TIMER_DEV); + + if (tick < previous_ticks) { + uint32_t delta = previous_ticks - tick; + total_ticks += delta; + previous_ticks = tick; + } + } +} + +void us_ticker_init(void) +{ + timer_cmsdk_init(&USEC_TIMER_DEV); + previous_ticks = TIMER_CMSDK_MAX_RELOAD; + NVIC_EnableIRQ(USEC_INTERVAL_IRQ); + restart_timer(previous_ticks); +} + +void us_ticker_free(void) +{ + timer_cmsdk_disable(&USEC_TIMER_DEV); +} + +uint32_t us_ticker_read(void) +{ + core_util_critical_section_enter(); + update_ticker(); + core_util_critical_section_exit(); + + return (uint32_t)(total_ticks >> USEC_REPORTED_SHIFT); +} + +void us_ticker_set_interrupt(timestamp_t timestamp) +{ + uint32_t reload = (timestamp - us_ticker_read()) << USEC_REPORTED_SHIFT; + previous_ticks = reload; + restart_timer(previous_ticks); +} + +void us_ticker_disable_interrupt(void) +{ + timer_cmsdk_disable_interrupt(&USEC_TIMER_DEV); +} + +void us_ticker_clear_interrupt(void) +{ + timer_cmsdk_clear_interrupt(&USEC_TIMER_DEV); +} + +void us_ticker_fire_interrupt(void) +{ + NVIC_SetPendingIRQ(USEC_INTERVAL_IRQ); +} + +const ticker_info_t* us_ticker_get_info() +{ + static const ticker_info_t info = { + USEC_REPORTED_FREQ_HZ, + USEC_REPORTED_BITS + }; + return &info; +} + +#ifndef usec_interval_irq_handler +#error "usec_interval_irq_handler should be defined, check device_cfg.h!" +#endif +void usec_interval_irq_handler(void) +{ + update_ticker(); + us_ticker_irq_handler(); +} diff --git a/targets/TARGET_ARM_SSG/mbed_rtx.h b/targets/TARGET_ARM_SSG/mbed_rtx.h index 91056db4e35..02608931255 100644 --- a/targets/TARGET_ARM_SSG/mbed_rtx.h +++ b/targets/TARGET_ARM_SSG/mbed_rtx.h @@ -43,7 +43,7 @@ #define INITIAL_SP (ZBT_SSRAM23_START + ZBT_SSRAM23_SIZE) #endif -#elif defined(TARGET_MUSCA_A1) || defined(TARGET_MUSCA_B1) +#elif defined(TARGET_MUSCA_A1) || defined(TARGET_MUSCA_B1) || defined(TARGET_MUSCA_S1) #if defined(__ARMCC_VERSION) extern uint32_t Image$$ARM_LIB_HEAP$$ZI$$Base[]; @@ -58,6 +58,6 @@ #error "no toolchain defined" #endif -#endif /* defined(TARGET_MUSCA_A1) || defined(TARGET_MUSCA_B1) */ +#endif /* defined(TARGET_MUSCA_A1) || defined(TARGET_MUSCA_B1) || defined(TARGET_MUSCA_S1) */ #endif /* MBED_MBED_RTX_H */ diff --git a/targets/targets.json b/targets/targets.json index 67b809954a2..35df6877994 100644 --- a/targets/targets.json +++ b/targets/targets.json @@ -4077,6 +4077,66 @@ "ARM_MUSCA_B1" ] }, + "ARM_MUSCA_S1": { + "inherits": [ + "PSA_V8_M" + ], + "default_toolchain": "ARMC6", + "features_add": [ + "EXPERIMENTAL_API" + ], + "forced_reset_timeout": 20, + "release_versions": [ + "5" + ], + "core": "Cortex-M33-NS", + "supported_toolchains": [ + "ARMC6", + "GCC_ARM" + ], + "device_has_add": [ + "INTERRUPTIN", + "I2C", + "I2CSLAVE", + "LPTICKER", + "SERIAL", + "SLEEP", + "USTICKER" + ], + "macros_add": [ + "__STARTUP_CLEAR_BSS", + "MBED_FAULT_HANDLER_DISABLED", + "CMSIS_NVIC_VIRTUAL", + "LPTICKER_DELAY_TICKS=3", + "MBED_MPU_CUSTOM", + "BL2" + ], + "extra_labels_add": [ + "ARM_SSG", + "MUSCA_S1", + "MUSCA_S1_NS" + ], + "post_binary_hook": { + "function": "ArmMuscaS1Code.binary_hook" + }, + "secure_image_filename": "tfm_s.bin", + "tfm_target_name": "MUSCA_S1", + "tfm_bootloader_supported": true, + "tfm_default_toolchain": "ARMCLANG", + "tfm_supported_toolchains": [ + "ARMCLANG", + "GNUARM" + ], + "tfm_delivery_dir": "TARGET_ARM_SSG/TARGET_MUSCA_S1", + "detect_code": [ + "5009" + ] + }, + "ARM_MUSCA_S1_NS": { + "inherits": [ + "ARM_MUSCA_S1" + ] + }, "RZ_A1XX": { "inherits": [ "Target" diff --git a/tools/targets/ARM_MUSCA_S1.py b/tools/targets/ARM_MUSCA_S1.py new file mode 100644 index 00000000000..8a38a617a11 --- /dev/null +++ b/tools/targets/ARM_MUSCA_S1.py @@ -0,0 +1,111 @@ +#!/usr/bin/python +# Copyright (c) 2017-2020 Arm Limited +# +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +from os.path import abspath, basename, dirname, splitext, isdir +from os.path import join as path_join +import re +from argparse import Namespace +from tools.psa.tfm.bin_utils.assemble import Assembly +from tools.psa.tfm.bin_utils.imgtool import do_sign +from tools.psa.tfm.bin_utils.imgtool_lib import version + +SCRIPT_DIR = dirname(abspath(__file__)) +MBED_OS_ROOT = abspath(path_join(SCRIPT_DIR, os.pardir, os.pardir)) +MUSCA_S1_BASE = path_join(MBED_OS_ROOT, 'targets', 'TARGET_ARM_SSG', 'TARGET_MUSCA_S1') + + +def musca_tfm_bin(t_self, non_secure_bin, secure_bin): + + assert os.path.isfile(secure_bin) + assert os.path.isfile(non_secure_bin) + + build_dir = dirname(non_secure_bin) + tempdir = path_join(build_dir, 'temp') + if not isdir(tempdir): + os.makedirs(tempdir) + flash_layout = path_join(MUSCA_S1_BASE, 'partition', 'flash_layout.h') + mcuboot_bin = path_join(MUSCA_S1_BASE, 'mcuboot.bin') + image_macros_s = path_join(MUSCA_S1_BASE, 'partition', 'image_macros_preprocessed_s.c') + image_macros_ns = path_join(MUSCA_S1_BASE, 'partition', 'image_macros_preprocessed_ns.c') + s_bin_name, s_bin_ext = splitext(basename(secure_bin)) + s_signed_bin = path_join(tempdir, s_bin_name + '_signed' + s_bin_ext) + ns_bin_name, ns_bin_ext = splitext(basename(non_secure_bin)) + ns_signed_bin = path_join(tempdir, 'tfm_' + ns_bin_name + '_signed' + ns_bin_ext) + concatenated_bin = path_join(tempdir, s_bin_name + '_' + ns_bin_name + '_concat' + ns_bin_ext) + + assert os.path.isfile(image_macros_s) + assert os.path.isfile(image_macros_ns) + + #1. Run imgtool to sign the secure binary + sign_args = Namespace( + layout=image_macros_s, + key=path_join(SCRIPT_DIR, 'musca_s1-root-rsa-3072.pem'), + public_key_format=None, + align=1, + dependencies=None, + version=version.decode_version('1.0'), + header_size=0x400, + security_counter=None, + rsa_pkcs1_15=False, + included_header=False, + infile=secure_bin, + outfile=s_signed_bin + ) + do_sign(sign_args) + + #2. Run imgtool to sign the non-secure mbed binary + sign_args = Namespace( + layout=image_macros_ns, + key=path_join(SCRIPT_DIR, 'musca_s1-root-rsa-3072_1.pem'), + public_key_format=None, + align=1, + dependencies=None, + version=version.decode_version('1.0'), + header_size=0x400, + security_counter=None, + rsa_pkcs1_15=False, + included_header=False, + infile=non_secure_bin, + outfile=ns_signed_bin + ) + do_sign(sign_args) + + #1. Concatenate signed secure TFM and non-secure mbed binaries + output = Assembly(image_macros_s, concatenated_bin) + output.add_image(s_signed_bin, "SECURE") + output.add_image(ns_signed_bin, "NON_SECURE") + + #3. Concatenate mcuboot and signed binary and overwrite mbed built binary file + mcuboot_image_size = find_bl2_size(flash_layout) + with open(mcuboot_bin, "rb") as mcuboot_fh, open(concatenated_bin, "rb") as concat_fh: + with open(non_secure_bin, "w+b") as out_fh: + out_fh.write(mcuboot_fh.read()) + out_fh.seek(mcuboot_image_size) + out_fh.write(concat_fh.read()) + + +def find_bl2_size(configFile): + bl2_size_re = re.compile(r"^#define\s+FLASH_AREA_BL2_SIZE\s+\({0,1}(0x[0-9a-fA-F]+)\){0,1}") + bl2_size = None + with open(configFile, 'r') as flash_layout_file: + for line in flash_layout_file: + m = bl2_size_re.match(line) + if m is not None: + bl2_size = int(m.group(1), 0) + break + return bl2_size diff --git a/tools/targets/__init__.py b/tools/targets/__init__.py index 79d9819ade9..fd843998b8f 100644 --- a/tools/targets/__init__.py +++ b/tools/targets/__init__.py @@ -711,6 +711,21 @@ def binary_hook(t_self, resources, elf, binf): ) musca_tfm_bin(t_self, binf, secure_bin) +class ArmMuscaS1Code(object): + """Musca-S1 Hooks""" + @staticmethod + def binary_hook(t_self, resources, elf, binf): + from tools.targets.ARM_MUSCA_S1 import musca_tfm_bin + configured_secure_image_filename = t_self.target.secure_image_filename + secure_bin = find_secure_image( + t_self.notify, + resources, + binf, + configured_secure_image_filename, + FileType.BIN + ) + musca_tfm_bin(t_self, binf, secure_bin) + def find_secure_image(notify, resources, ns_image_path, configured_s_image_filename, image_type): """ Find secure image. """ diff --git a/tools/targets/musca_s1-root-rsa-3072.md b/tools/targets/musca_s1-root-rsa-3072.md new file mode 100644 index 00000000000..c7cccb80900 --- /dev/null +++ b/tools/targets/musca_s1-root-rsa-3072.md @@ -0,0 +1,11 @@ +# Musca-S1 RSA keypair + +A default RSA key pair is given to the Musca-S1 target. + +Public keys were pre-compiled to `targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/prebuilt/mcuboot.bin` and private key is in `musca_s1-root-rsa-3072.pem` for Secure image and `musca_s1-root-rsa-3072_1.pem` for Non-Secure image. + +DO NOT use them in production code, they are exclusively for testing! + +Private key must be stored in a safe place outside of the repository. + +`tools/psa/tfm/bin_utils/imgtool.py` can be used to generate new key pairs. diff --git a/tools/targets/musca_s1-root-rsa-3072.pem b/tools/targets/musca_s1-root-rsa-3072.pem new file mode 100644 index 00000000000..23288bc1010 --- /dev/null +++ b/tools/targets/musca_s1-root-rsa-3072.pem @@ -0,0 +1,39 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIG4gIBAAKCAYEAnLrCWr/MxU8gDE9vbFFPXAqrgLhrEMSbK8RSMglLOyeUah3V +TKhcoMB2lXsmBLETfngn1gy06LAtklKK+2n/QhCqVgyDyGVuug1fjvcrKZL8Qi0t ++YD1hSGH6qxAqMvQqDvi0uzwFEgOzyuKS6TNoQVbF2Yd3m5E/kajDdBpv4ytqRZo +Uet5kSDmgQMHiUBVS+vPZ/gxxxxUTlILYOiiUAfRz84SJs2Ogo1OZKn3xyGZJQfd +xdVf9GP6zCvaBlxZZ7AGNemqkkU15aAD/xwCtcdOlEturXOdzm8Js7GPYGyi+s13 +D8wn5jZYs1L3j75JmLfpYP2XV83q0wvfokL3RNOH3uAQA5Ta/LzdvpOzSitY3JYS +8m8jujs3/vwYH3V9VAEOvj0YE7MouTQs1fvFM72HvTvkHdcCPRxyZXJDQzao+uZz +LaRh6AKcOlZNHNF2nIyqXxvrHEr1ubhvQUsnh972lB/d5vGpwgLCT6P8pANa2W94 +/YTw5f09pU0brVtLAgMBAAECggGAG786mltbctEL0PIdPVV10cs3yq2bktfjys9S +Z/ZaQcpDjbfjY9NotrLsK5GmTO1WkKzQDKaqPom2P7HqVhFRdg5CQcKscAV5IWot +sT9T/mO90i9ydLoefWfOyr6dIeUXdzlG8mWtKUIKkSXZsYOnPesXUeCryA3InCXA +RzlPB3Dt68ICTQJ9vrJO7KcvJd7kWvEQAo2frmr3B/iheBInbji8LeiDMShyIu3G +Y67tpWzu0m3+lsAsYTV0GMJosniVulaZ3hYQQazHUk+zDzMSC7zryICrpjEbgzWU +HZI9EGi1B890nwUtdhlCpkr8zoWDb0BjawpftiGz7fRm7q2TQkYAWGzNKm3DZlIS +4LsRACvHnPZ17wUSze9tqP14Pb593WR3nOTiVjrJWm+4Z5hgV3QfoEqW5swOAYl4 +6QmKZsCXAfGkozJiHnYcyaULkGBVegn1LQ5rcb8JUMribQddrHZxCVHrbgwh2zm/ +v9CYfTtpWCnKHq+wF3mwjl6w7m4JAoHBALolVbgs919Dx0xjcPnW5MSxW3ctflI9 +2ZE1BOH/Rtg5gfBwR/aToUM3a/ZgIJHQYhVty2TzUVtthtmLNTRKu2FSqWN8//GJ +wmj4bcNBshMgniHEfkutlBiP9exhdvCZX4bYpdTkJAyvOmUGjEM8QBFsod60u0z7 +Bd0EIXs7PIURP0fNAUXCgSHMPjdICLljhwHinr31VEIU2/xehw8DBIJwkR/rCsPq +xBmlIwPWVjzCRTnYUxQuxCAYf+qvgNylKQKBwQDXi3UGI7t30rYNMdIjMn1GPkhW +o62BOJNCusoXiGnbVOkj8qBayf7kPu10ONBzHcYL7+SQYeVVXQY+DH033ji8oa0J +p1xMGIlx4JZEduQYlk0ke4hUNrcBQczTRA47DmMm2kIdWlaTHtB7aCJNx72IrwWn +lVTY9TWm6+yOPcpV5JfyCMM6GqoRycikgNS5IQug5hl2pFVLw+UTfxo6msYaAOnp +ICUjoeDUKS0Z8+FtzGhAkWTk8GXIiPbfu7RoN1MCgcAcah6Poq2QKTR/AJ76REdf +jwM7SgKCY1aWx9Ua+nDCCOVA4qLZjOeM7yTX0wyltX2Db+MgYdQFdM6k3o8ckFvS +G2AoA6i+Ih0/EM0QhTK9oLkCxo/Q1YpJxY/wqWASkhb26pNF0B2Aoi7zxPAcQ1I0 +VrTO3h/JPHhEqKDDwuMWHO/f8fdDwtEba6YDokdSpVKygvlgXdaiz7RU7ckIDZne +n3hHuwVFqsyMbZzOtSUs2SrgDZmA9zKRA6xjEq9E/yECgcAnm7XecfSCGVNg61XN +J/sDTHCokx1QEKBm88ItPuEM7/aDp5M1+8Z+FN43rDUJ4l/BU8zxhzvISvbZshvU +h15vs1oD2yBHz356UaXrYNmbdwsn+BdeOku4zGmiLPBcg9FOk27wy+f60v/GnaUo +G9tFYbwtRnC4CZ9ZVCM9JDepPv9494lAhSPZbvYS3KW6e0sSvxXQynPuH0paIdIl +EMn0f1R8hW6ttJKHCiYCjeFP9u71ZoJe25oolpqfFHQbbocCgcAuBR4w3Qmnbscm +3b7fyy8n3AXa1gIfYjjPpR35qyp1K9thiLyj66YZIl0ACC/dt08lmI9/lguRoNIQ +AfjzZ8DByZa0caiSiFIMlgNZXdh7N3BUNNbIQk98Wd91gBlWDAiFEhrJKFPpRkmv +FySATPYcq0lcrjJb3IW2GDK4uo/jb4Nb7Cfog95W6T76XcSKHS5O8k1aI4kFPRsr +1wGZw64OkA8VXVaCaEBQ4brZ1YKB3mx4/tDqwn0I6bqkGRX3RJg= +-----END RSA PRIVATE KEY----- diff --git a/tools/targets/musca_s1-root-rsa-3072_1.pem b/tools/targets/musca_s1-root-rsa-3072_1.pem new file mode 100644 index 00000000000..1214eb58061 --- /dev/null +++ b/tools/targets/musca_s1-root-rsa-3072_1.pem @@ -0,0 +1,39 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIG5AIBAAKCAYEAv7ewn+jI0f4WHVOHl3kcFceZFmzKuC3Kwg1i+euP6ToYQ0fX +u9VivOMzY6ejqFzzI3j9LQchH7lUcCipCNpQfp6OzGhOf0gN6ifoxu+tX51GSrxp +mjBfO8FSkvi8ddQ8J3BAAKYuKH9Z5WBDEdwxCX3PL0E/tlIao0kW8rWznDz7Xiwf +Ioa9rr42Ur3E8FhpNqeAPoGzVJjkXZXtIfC6riH7xBmHVdErTwDYQVjL26maU+ls +Z8t8XfaRBnVS8sB+sWtdMEBAL9gelTwFl3/wBPBOLNU5DpQ9fAMIHQkI8o1EDc+z +lj1aduj27pNk6FfR4vULGGlv6eE9+IlJKOavuKjGQlUtwduMXbJtf/4m6nXZ/R/c +IjukG6et63HfvbQ30eu+CBAceIQcmnXEreXvcxesaXi81jeMDBQhBke9+AqsGQmd +DR1y4T4adOqG2VxKzczGlKf+2guHEbtr8DrjT4JPseSkzbxwPJ2cSfnPKG242m99 +OFdVQypzjbYY/XCnAgMBAAECggGAWmcsjuMumzMEy5RhWlB+KVkC+7uWRg41z5aP +ZwkoxdIiscs1U/nVwvsh9uqMdi5Kap45SFvVx0dVpUPPHYEQtvxems3Owh9AjHuA +PRq09uLLTB+XbmFD7wIExZAsEiXfrbs1Ovkhx+/xfIONbOUXbIHaSk6q0/bYX8nt +28pJpTFuWORWVCoUVMuWAyNANBOEnYSTqSXw4cHs4aJ6fOgup0EYHsro8dMd6HWe +BAZyrqTFxK7L8w/Vl9tWXKTDVfvlj8DHRwWBQhvS1P4XWaEcVopv7Sy4XK7UUeXm +tllsi5byGlNmr9ADK7Gd+eft/y/APyWo6SFPBLiyVLCSJ+6X4/7FwmLGYYt1WysH +/86W55qTRgtHQmb+oPBn8NYDxnYhEYFzGbpoAPD83U4CyGbnoqp5tsmssw8SfvWH +BTUdJiPjVLpHRuH1pwAyHMi+MvIVB6A8f5yWbtVwAho3Q+pIwd62aZqCpelUg9Vp +F1ssr723gQxPJqS/mwm1SfIe0GfNAoHBAMVgHdTANplIZIadWDulggjYXH5qkU+b +nB8bxv35s1Rl8iTQuD/UtxflIaLwciOl1mAfUUqG+6JH8c1OpVIaGmWKDeVThliH +tN8/OGdCPkPOFKyY8MHl83tNpsNk7P3F/WJOxCqxWziK3YoDwSr+l96XokAg/SDu +LoTax3DZPMAd2HSZuBPMGBlIbbfdkAaWzB0QJBSWv6ednt0kue+F1O/sdQ15SXoz +jGzCrEf60HIOWdAnnCCq0iT+ZeZTX1gMhQKBwQD4qVxxlSJUv+w3pGC17IN3uC3K +yq988GVqOND21RdwZ/YeYZrmORjnpXyrpJsbj9IGwYd/hpwkLe8qwOj67mZCXmND +Eca4xE7s4gtAiHXOZKXRgISEs+9giWd/8U7pczVsUwiTS77j6C7nd1f5ZgKajxJd +Tdy4bIWErCKijmpT/IEQVVYb+Ki8khTKxzbaDxWtrHv/iM+7+bgUfsKefDcO6MCb +jmhj/aOSzcmcJNfx1bdqCyxuK6iw583awBtctjsCgcEArcdwvG74I4GPsM48b1fL +48nLtipSAot5rBIi5F7Du91+k1eJwfmhs1I0iWe2txg+ZadtRXcPetRpW2CRQnZl +I12n2m/t62igoabiHFhAxiZeIZEO+UljVP8LgyILX2zBKZs8MHKzZFcvs2KW4yoB +wSQ04M2q0SGkp6iQzRUX3fbpK9BkOFoMJcaVg7t6IbMHx9b8TXxlBklLJF4/r1pg +H1ZLwS82uHdGfkPwt/dnK+Tiwtj9J+3+1D+ArIhffACZAoHBANghRLOIv41QP73h +Rxn5GA//6vVflIaQ4GUiOya/8p6GDhs8FQnUSPxXD3SVHygmqpOqtN44HxEnR8Eu +aZJpkkJPjhFmqwY/wqYMl2Eg+txJCQN+pDA/wWl0JJzFHiS1OZMM3OBCLwoi7lnL +lpC0hMDYaErm+VjnImo9v+DwziRvzbJnqe+oAuncQuw5mUiRYfNRf3mM7ZpiJAjU +YM6mAqkXzwmmDsASXpGkAn+QWo3dh41JZvXfRsF0ya0/2siLrwKBwBBX7YegsNPJ +skp5AAwYDvujDISc3aLxqEc1UHyM5SmKVt1U0/Dsyod0ZBMe27N8t9INFqy+G7hI +Y1sthsk6DyM1hSiZsLBTossJgyu3Tf3e300NTmc6CpFSRqL1L4lcSzKAGNTWvS9H +5q+MpRkZLzug83pmFw0qTWTw8p79cpELM4sklLg8L5cnLDLZyU+Gr5ZshkgpkXJI +egyV0maL40d5fDsX2ZqCZQPrQ7+FhDHKg/jf3Z3lXHwTAKBNrQGN6g== +-----END RSA PRIVATE KEY----- From 37f26692b1db388a272c9037b28cad27734fda90 Mon Sep 17 00:00:00 2001 From: Mark Horvath Date: Mon, 22 Jun 2020 16:35:43 +0200 Subject: [PATCH 2/2] Workaround to fix clang build Change-Id: Ib0d207d4ca22ae239f6b40b95618b66eb329a29c Signed-off-by: Mark Horvath --- .../TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/region_defs.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/region_defs.h b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/region_defs.h index 207ce8067c8..0e9a4323850 100644 --- a/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/region_defs.h +++ b/targets/TARGET_ARM_SSG/TARGET_MUSCA_S1/partition/region_defs.h @@ -19,6 +19,10 @@ #ifndef __REGION_DEFS_H__ #define __REGION_DEFS_H__ +#ifndef BL2 +#define BL2 +#endif + #include "flash_layout.h" #define BL2_HEAP_SIZE (0x0001000)