src/arch/arm64/armv8/secmon/smc.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright 2014 Google Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; version 2 of the License.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  */
  15
  16 #include <string.h>
  17 #include <stdlib.h>
  18 #include <arch/cpu.h>
  19 #include <arch/smc.h>
  20 #include <arch/exception.h>
  21 #include <arch/lib_helpers.h>
  22 #include <console/console.h>
  23
  24 enum {
  25         /* SMC called from AARCH32 */
  26         EC_SMC_AARCH32 = 0x13,
  27         /* SMC called from AARCH64 */
  28         EC_SMC_AARCH64 = 0x17,
  29
  30         SMC_NUM_RANGES = 8,
  31 };
  32
  33 struct smc_range {
  34         uint32_t func_begin;
  35         uint32_t func_end;
  36         int (*handler)(struct smc_call *);
  37 };
  38
  39 struct smc_ranges {
  40         size_t used;
  41         struct smc_range handlers[SMC_NUM_RANGES];
  42 };
  43
  44 static struct smc_ranges smc_functions;
  45
  46 static struct smc_range *smc_handler_by_function(uint32_t fid)
  47 {
  48         int i;
  49
  50         for (i = 0; i < smc_functions.used; i++) {
  51                 struct smc_range *r = &smc_functions.handlers[i];
  52
  53                 if (fid >= r->func_begin && fid <= r->func_end)
  54                         return r;
  55         }
  56
  57         return NULL;
  58 }
  59
  60 int smc_register_range(uint32_t min, uint32_t max, int (*h)(struct smc_call *))
  61 {
  62         struct smc_range *r;
  63
  64         if (smc_functions.used == SMC_NUM_RANGES)
  65                 return -1;
  66
  67         if (min > max)
  68                 return -1;
  69
  70         /* This check isn't exhaustive but it's fairly quick. */
  71         if (smc_handler_by_function(min) || smc_handler_by_function(max))
  72                 return -1;
  73
  74         r = &smc_functions.handlers[smc_functions.used];
  75         r->func_begin = min;
  76         r->func_end = max;
  77         r->handler = h;
  78         smc_functions.used++;
  79
  80         return 0;
  81 }
  82
  83 static int smc_cleanup(struct exc_state *state, struct smc_call *smc, int ret)
  84 {
  85         memcpy(&state->regs.x, &smc->results, sizeof(smc->results));
  86
  87         return ret;
  88 }
  89
  90 static int smc_return_with_error(struct exc_state *state, struct smc_call *smc)
  91 {
  92         smc32_return(smc, SMC_UNKNOWN_FUNC);
  93         return smc_cleanup(state, smc, EXC_RET_HANDLED);
  94 }
  95
  96 static int smc_handler(struct exc_state *state, uint64_t vector_id)
  97 {
  98         struct smc_call smc_storage;
  99         struct smc_call *smc = &smc_storage;
 100         uint32_t exception_class;
 101         uint32_t esr;
 102         struct smc_range *r;
 103
 104         memcpy(&smc->args, &state->regs.x, sizeof(smc->args));
 105         memcpy(&smc->results, &state->regs.x, sizeof(smc->results));
 106
 107         esr = raw_read_esr_el3();
 108         exception_class = (esr >> 26) & 0x3f;
 109
 110         /* No support for SMC calls from AARCH32 */
 111         if (exception_class == EC_SMC_AARCH32)
 112                 return smc_return_with_error(state, smc);
 113
 114         /* Check to ensure this is an SMC from AARCH64. */
 115         if (exception_class != EC_SMC_AARCH64)
 116                 return EXC_RET_IGNORED;
 117
 118         /* Ensure immediate value is 0. */
 119         if ((esr & 0xffff) != 0)
 120                 return smc_return_with_error(state, smc);
 121
 122         r = smc_handler_by_function(smc_function_id(smc));
 123
 124         if (r != NULL) {
 125                 if (!r->handler(smc))
 126                         return smc_cleanup(state, smc, EXC_RET_HANDLED);
 127         }
 128
 129         return smc_return_with_error(state, smc);
 130 }
 131
 132 /* SMC calls can be generated by 32-bit or 64-bit code. */
 133 static struct exception_handler smc_handler64 = {
 134         .handler = &smc_handler,
 135 };
 136
 137 static struct exception_handler smc_handler32 = {
 138         .handler = &smc_handler,
 139 };
 140
 141 static void enable_smc(void *arg)
 142 {
 143         uint32_t scr;
 144
 145         /* Enable SMC */
 146         scr = raw_read_scr_el3();
 147         scr &= ~(SCR_SMC_MASK);
 148         scr |= SCR_SMC_ENABLE;
 149         raw_write_scr_el3(scr);
 150 }
 151
 152 void smc_init(void)
 153 {
 154         struct cpu_action action = {
 155                 .run = enable_smc,
 156         };
 157
 158         arch_run_on_all_cpus_async(&action);
 159
 160         /* Register SMC handlers. */
 161         exception_handler_register(EXC_VID_LOW64_SYNC, &smc_handler64);
 162         exception_handler_register(EXC_VID_LOW32_SYNC, &smc_handler32);
 163 }