core/arch/arm/plat-ti/main.c

   1 /*
   2  * Copyright (c) 2015, Linaro Limited
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  * 1. Redistributions of source code must retain the above copyright notice,
   9  * this list of conditions and the following disclaimer.
  10  *
  11  * 2. Redistributions in binary form must reproduce the above copyright notice,
  12  * this list of conditions and the following disclaimer in the documentation
  13  * and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  19  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  20  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  21  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  24  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  25  * POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include <platform_config.h>
  29 #include <console.h>
  30 #include <stdint.h>
  31 #include <string.h>
  32 #include <assert.h>
  33 #include <drivers/gic.h>
  34 #include <drivers/serial8250_uart.h>
  35 #include <arm.h>
  36 #include <kernel/generic_boot.h>
  37 #include <kernel/panic.h>
  38 #include <kernel/pm_stubs.h>
  39 #include <trace.h>
  40 #include <kernel/misc.h>
  41 #include <kernel/mutex.h>
  42 #include <kernel/tee_time.h>
  43 #include <mm/core_mmu.h>
  44 #include <mm/core_memprot.h>
  45 #include <tee/entry_std.h>
  46 #include <tee/entry_fast.h>
  47 #include <console.h>
  48 #include <sm/sm.h>
  49
  50 static struct gic_data gic_data;
  51 static struct serial8250_uart_data console_data __early_bss;
  52
  53 register_phys_mem(MEM_AREA_IO_SEC, GICC_BASE, GICC_SIZE);
  54 register_phys_mem(MEM_AREA_IO_SEC, GICD_BASE, GICD_SIZE);
  55 register_phys_mem(MEM_AREA_IO_NSEC, CONSOLE_UART_BASE,
  56                   SERIAL8250_UART_REG_SIZE);
  57
  58 void main_init_gic(void)
  59 {
  60         vaddr_t gicc_base;
  61         vaddr_t gicd_base;
  62
  63         gicc_base = (vaddr_t)phys_to_virt(GICC_BASE, MEM_AREA_IO_SEC);
  64         gicd_base = (vaddr_t)phys_to_virt(GICD_BASE, MEM_AREA_IO_SEC);
  65
  66         if (!gicc_base || !gicd_base)
  67                 panic();
  68
  69         gic_init(&gic_data, gicc_base, gicd_base);
  70         itr_init(&gic_data.chip);
  71 }
  72
  73 void main_secondary_init_gic(void)
  74 {
  75         gic_cpu_init(&gic_data);
  76 }
  77
  78 static void main_fiq(void)
  79 {
  80         gic_it_handle(&gic_data);
  81 }
  82
  83 static const struct thread_handlers handlers = {
  84         .std_smc = tee_entry_std,
  85         .fast_smc = tee_entry_fast,
  86         .nintr = main_fiq,
  87         .cpu_on = pm_panic,
  88         .cpu_off = pm_panic,
  89         .cpu_suspend = pm_panic,
  90         .cpu_resume = pm_panic,
  91         .system_off = pm_panic,
  92         .system_reset = pm_panic,
  93 };
  94
  95 const struct thread_handlers *generic_boot_get_handlers(void)
  96 {
  97         return &handlers;
  98 }
  99
 100 struct plat_nsec_ctx {
 101         uint32_t usr_sp;
 102         uint32_t usr_lr;
 103         uint32_t svc_sp;
 104         uint32_t svc_lr;
 105         uint32_t svc_spsr;
 106         uint32_t abt_sp;
 107         uint32_t abt_lr;
 108         uint32_t abt_spsr;
 109         uint32_t und_sp;
 110         uint32_t und_lr;
 111         uint32_t und_spsr;
 112         uint32_t irq_sp;
 113         uint32_t irq_lr;
 114         uint32_t irq_spsr;
 115         uint32_t fiq_sp;
 116         uint32_t fiq_lr;
 117         uint32_t fiq_spsr;
 118         uint32_t fiq_rx[5];
 119         uint32_t mon_lr;
 120         uint32_t mon_spsr;
 121 };
 122
 123 void init_sec_mon(unsigned long nsec_entry)
 124 {
 125         struct plat_nsec_ctx *plat_ctx;
 126         struct sm_nsec_ctx *nsec_ctx;
 127
 128         plat_ctx = phys_to_virt(nsec_entry, MEM_AREA_IO_SEC);
 129         if (!plat_ctx)
 130                 panic();
 131
 132         /* Invalidate cache to fetch data from external memory */
 133         cache_op_inner(DCACHE_AREA_INVALIDATE,
 134                         plat_ctx, sizeof(*plat_ctx));
 135
 136         /* Initialize secure monitor */
 137         nsec_ctx = sm_get_nsec_ctx();
 138
 139         nsec_ctx->mode_regs.usr_sp = plat_ctx->usr_sp;
 140         nsec_ctx->mode_regs.usr_lr = plat_ctx->usr_lr;
 141         nsec_ctx->mode_regs.irq_spsr = plat_ctx->irq_spsr;
 142         nsec_ctx->mode_regs.irq_sp = plat_ctx->irq_sp;
 143         nsec_ctx->mode_regs.irq_lr = plat_ctx->irq_lr;
 144         nsec_ctx->mode_regs.svc_spsr = plat_ctx->svc_spsr;
 145         nsec_ctx->mode_regs.svc_sp = plat_ctx->svc_sp;
 146         nsec_ctx->mode_regs.svc_lr = plat_ctx->svc_lr;
 147         nsec_ctx->mode_regs.abt_spsr = plat_ctx->abt_spsr;
 148         nsec_ctx->mode_regs.abt_sp = plat_ctx->abt_sp;
 149         nsec_ctx->mode_regs.abt_lr = plat_ctx->abt_lr;
 150         nsec_ctx->mode_regs.und_spsr = plat_ctx->und_spsr;
 151         nsec_ctx->mode_regs.und_sp = plat_ctx->und_sp;
 152         nsec_ctx->mode_regs.und_lr = plat_ctx->und_lr;
 153         nsec_ctx->mon_lr = plat_ctx->mon_lr;
 154         nsec_ctx->mon_spsr = plat_ctx->mon_spsr;
 155 }
 156
 157 void console_init(void)
 158 {
 159         serial8250_uart_init(&console_data, CONSOLE_UART_BASE,
 160                              CONSOLE_UART_CLK_IN_HZ, CONSOLE_BAUDRATE);
 161         register_serial_console(&console_data.chip);
 162 }