/* * Copyright (c) 2015-2016, 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 __UVISOR_API_UNSUPPORTED_H__ #define __UVISOR_API_UNSUPPORTED_H__ #include "uvisor/api/inc/uvisor_exports.h" #include <stddef.h> #include <stdint.h> /* uVisor hook for unsupported platforms */ UVISOR_EXTERN void uvisor_init(void); /******************************************************************************* * Re-definitions from: ******************************************************************************/ /* uvisor-lib/box-config.h */ UVISOR_EXTERN const uint32_t __uvisor_mode; #define UVISOR_DISABLED 0 #define UVISOR_SET_MODE(mode) \ UVISOR_SET_MODE_ACL_COUNT(mode, NULL, 0) #define UVISOR_SET_MODE_ACL(mode, acl_list) \ UVISOR_SET_MODE_ACL_COUNT(mode, acl_list, UVISOR_ARRAY_COUNT(acl_list)) #define UVISOR_SET_MODE_ACL_COUNT(mode, acl_list, acl_list_count) \ UVISOR_EXTERN const uint32_t __uvisor_mode = UVISOR_DISABLED; \ static const void *public_box_acl = acl_list; \ extern const __attribute__((section(".keep.uvisor.cfgtbl_ptr_first"), aligned(4))) void * const public_box_cfg_ptr = &public_box_acl; #define __UVISOR_BOX_CONFIG_NOCONTEXT(box_name, acl_list, stack_size) \ static const void *box_acl_ ## box_name = acl_list; \ extern const __attribute__((section(".keep.uvisor.cfgtbl_ptr"), aligned(4))) void * const box_name ## _cfg_ptr = &box_acl_ ## box_name; #define __UVISOR_BOX_CONFIG_CONTEXT(box_name, acl_list, stack_size, context_type) \ context_type box_ctx_ ## box_name; \ context_type * const uvisor_ctx = &box_ctx_ ## box_name; \ static const void *box_acl_ ## box_name = acl_list; \ const __attribute__((section(".keep.uvisor.cfgtbl_ptr"), aligned(4))) volatile void *box_name ## _cfg_ptr = \ &box_acl_ ## box_name; #define __UVISOR_BOX_MACRO(_1, _2, _3, _4, NAME, ...) NAME #define UVISOR_BOX_CONFIG(...) \ __UVISOR_BOX_MACRO(__VA_ARGS__, __UVISOR_BOX_CONFIG_CONTEXT, \ __UVISOR_BOX_CONFIG_NOCONTEXT)(__VA_ARGS__) #define UVISOR_BOX_CONFIG_ACL(...) UVISOR_BOX_CONFIG(__VA_ARGS__) #define UVISOR_BOX_CONFIG_CTX(...) UVISOR_BOX_CONFIG(__VA_ARGS__) #define UVISOR_BOX_NAMESPACE(...) #define UVISOR_BOX_HEAPSIZE(...) /* uvisor-lib/interrupts.h */ #define vIRQ_SetVector(irqn, vector) NVIC_SetVector((IRQn_Type) (irqn), (uint32_t) (vector)) #define vIRQ_GetVector(irqn) NVIC_GetVector((IRQn_Type) (irqn)) #define vIRQ_EnableIRQ(irqn) NVIC_EnableIRQ((IRQn_Type) (irqn)) #define vIRQ_DisableIRQ(irqn) NVIC_DisableIRQ((IRQn_Type) (irqn)) #define vIRQ_DisableAll __disable_irq #define vIRQ_EnableAll __enable_irq #define vIRQ_ClearPendingIRQ(irqn) NVIC_ClearPendingIRQ((IRQn_Type) (irqn)) #define vIRQ_SetPendingIRQ(irqn) NVIC_SetPendingIRQ((IRQn_Type) (irqn)) #define vIRQ_GetPendingIRQ(irqn) NVIC_GetPendingIRQ((IRQn_Type) (irqn)) #define vIRQ_SetPriority(irqn, priority) NVIC_SetPriority((IRQn_Type) (irqn), (uint32_t) (priority)) #define vIRQ_GetPriority(irqn) NVIC_GetPriority((IRQn_Type) (irqn)) /* uvisor-lib/register_gateway.h */ #define UVISOR_OP_READ(op) (op) #define UVISOR_OP_WRITE(op) ((1 << 4) | (op)) #define UVISOR_OP_NOP 0x0 #define UVISOR_OP_AND 0x1 #define UVISOR_OP_OR 0x2 #define UVISOR_OP_XOR 0x3 /* Default mask for whole register operatins */ #define __UVISOR_OP_DEFAULT_MASK 0x0 static UVISOR_FORCEINLINE uint32_t uvisor_read(uint32_t addr, uint32_t op, uint32_t mask) { switch(op) { case UVISOR_OP_READ(UVISOR_OP_NOP): return *((uint32_t *) addr); case UVISOR_OP_READ(UVISOR_OP_AND): return *((uint32_t *) addr) & mask; case UVISOR_OP_READ(UVISOR_OP_OR): return *((uint32_t *) addr) | mask; case UVISOR_OP_READ(UVISOR_OP_XOR): return *((uint32_t *) addr) ^ mask; default: /* FIXME */ return 0; } } #define uvisor_read(addr) uvisor_read((uint32_t) (addr), UVISOR_OP_READ(UVISOR_OP_NOP), __UVISOR_OP_DEFAULT_MASK) static UVISOR_FORCEINLINE void uvisor_write(uint32_t addr, uint32_t val, uint32_t op, uint32_t mask) { switch(op) { case UVISOR_OP_WRITE(UVISOR_OP_NOP): *((uint32_t *) addr) = val; case UVISOR_OP_WRITE(UVISOR_OP_AND): *((uint32_t *) addr) &= val | ~mask; case UVISOR_OP_WRITE(UVISOR_OP_OR): *((uint32_t *) addr) |= val & mask; case UVISOR_OP_WRITE(UVISOR_OP_XOR): *((uint32_t *) addr) ^= val & mask; default: /* FIXME */ return; } } #define uvisor_write(addr, val) uvisor_write((uint32_t) (addr), (uint32_t) (val), \ UVISOR_OP_WRITE(UVISOR_OP_NOP), __UVISOR_OP_DEFAULT_MASK) /* uvisor-lib/secure_access.h */ static UVISOR_FORCEINLINE void uvisor_write32(uint32_t volatile *addr, uint32_t val) { *(addr) = val; } static UVISOR_FORCEINLINE void uvisor_write16(uint16_t volatile *addr, uint16_t val) { *(addr) = val; } static UVISOR_FORCEINLINE void uvisor_write8(uint8_t volatile *addr, uint8_t val) { *(addr) = val; } static UVISOR_FORCEINLINE uint32_t uvisor_read32(uint32_t volatile *addr) { return *(addr); } static UVISOR_FORCEINLINE uint16_t uvisor_read16(uint16_t volatile *addr) { return *(addr); } static UVISOR_FORCEINLINE uint8_t uvisor_read8(uint8_t volatile *addr) { return *(addr); } /* The conditional statement will be optimised away since the compiler already * knows the sizeof(type). */ #define ADDRESS_READ(type, addr) \ (sizeof(type) == 4 ? uvisor_read32((volatile uint32_t *) (addr)) : \ sizeof(type) == 2 ? uvisor_read16((volatile uint16_t *) (addr)) : \ sizeof(type) == 1 ? uvisor_read8((volatile uint8_t *) (addr)) : 0) /* The switch statement will be optimised away since the compiler already knows * the sizeof_type. */ static UVISOR_FORCEINLINE void __address_write(size_t sizeof_type, volatile uint32_t *addr, uint32_t val) { switch(sizeof_type) { case 4: uvisor_write32((volatile uint32_t *) addr, (uint32_t) val); break; case 2: uvisor_write16((volatile uint16_t *) addr, (uint16_t) val); break; case 1: uvisor_write8((volatile uint8_t *) addr, (uint8_t) val); break; } } #define ADDRESS_WRITE(type, addr, val) __address_write(sizeof(type), (volatile uint32_t *) addr, (uint32_t) val) #define UNION_READ(type, addr, fieldU, fieldB) ((*((volatile type *) (addr))).fieldB) /* uvisor-lib/secure_gateway.h */ #define secure_gateway(dst_box, dst_fn, ...) dst_fn(__VA_ARGS__) #endif /* __UVISOR_API_UNSUPPORTED_H__ */