/*
 * Copyright (c) 2013-2016 Google Inc. All rights reserved
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files
 * (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

/* Reference:
 * ARM document DEN 0028A: SMC CALLING CONVENTION
 * version: 0.9.0
 */

#include <arch/ops.h>
#include <compiler.h>
#include <debug.h>
#include <err.h>
#include <kernel/mutex.h>
#include <lib/sm.h>
#include <lib/sm/sm_err.h>
#include <lib/sm/smcall.h>
#include <lib/sm/trusty_sched_share_api.h>
#include <lk/init.h>
#include <string.h>
#include <trace.h>
#include <version.h>

#define LOCAL_TRACE 1

static mutex_t smc_table_lock = MUTEX_INITIAL_VALUE(smc_table_lock);

#define TRACE_SMC(msg, args)                                                \
    do {                                                                    \
        u_int _i;                                                           \
        LTRACEF("%s\n", msg);                                               \
        LTRACEF("SMC: 0x%x (%s entity %d function 0x%x)\n", (args)->smc_nr, \
                SMC_IS_FASTCALL(args->smc_nr) ? "Fastcall" : "Stdcall",     \
                SMC_ENTITY(args->smc_nr), SMC_FUNCTION(args->smc_nr));      \
        for (_i = 0; _i < SMC_NUM_PARAMS; _i++)                             \
            LTRACEF("param%d: 0x%x\n", _i, (args)->params[_i]);             \
    } while (0)

long smc_undefined(struct smc32_args* args) {
    TRACE_SMC("Undefined monitor call!", args);
    return SM_ERR_UNDEFINED_SMC;
}

/* Restarts should never be dispatched like this */
static long smc_restart_stdcall(struct smc32_args* args) {
    TRACE_SMC("Unexpected stdcall restart!", args);
    return SM_ERR_UNEXPECTED_RESTART;
}

/*
 * Switch to secure mode and return. This function does no work on its own,
 * but if an interrupt is pending, it will be handled, and can in turn trigger a
 * context switch that will perform other secure work.
 */
static long smc_nop_stdcall(struct smc32_args* args) {
    return 0;
}

/*
 * parameterized nop call handler
 */
static long smc_nop_secure_monitor(struct smc32_args* args) {
    return (!args->params[0]) ? 0 : SM_ERR_UNDEFINED_SMC;
}

static smc32_handler_t sm_stdcall_function_table[] = {
        [SMC_FUNCTION(SMC_SC_RESTART_LAST)] = smc_restart_stdcall,
        [SMC_FUNCTION(SMC_SC_LOCKED_NOP)] = smc_nop_stdcall,
        [SMC_FUNCTION(SMC_SC_RESTART_FIQ)] = smc_restart_stdcall,
        [SMC_FUNCTION(SMC_SC_SCHED_SHARE_REGISTER)] =
                smc_trusty_sched_share_register,
        [SMC_FUNCTION(SMC_SC_SCHED_SHARE_UNREGISTER)] =
                smc_trusty_sched_share_unregister,
        /* reserve slot in table, not called */
        [SMC_FUNCTION(SMC_SC_NOP)] = smc_undefined,
};

static long smc_stdcall_secure_monitor(struct smc32_args* args) {
    u_int function = SMC_FUNCTION(args->smc_nr);
    smc32_handler_t handler_fn = NULL;

    if (function < countof(sm_stdcall_function_table))
        handler_fn = sm_stdcall_function_table[function];

    if (!handler_fn)
        handler_fn = smc_undefined;

    return handler_fn(args);
}

static long smc_fiq_enter(struct smc32_args* args) {
    return sm_intc_fiq_enter();
}

#if !WITH_LIB_SM_MONITOR
static long smc_cpu_suspend(struct smc32_args* args) {
    lk_init_level_all(args->params[0] ? LK_INIT_FLAG_CPU_OFF
                                      : LK_INIT_FLAG_CPU_ENTER_IDLE);

    return 0;
}

static long smc_cpu_resume(struct smc32_args* args) {
    lk_init_level_all(args->params[0] ? LK_INIT_FLAG_CPU_ON
                                      : LK_INIT_FLAG_CPU_EXIT_IDLE);

    return 0;
}
#endif

static long smc_get_version_str(struct smc32_args* args) {
    int32_t index = (int32_t)args->params[0];
    size_t version_len = strlen(lk_version);

    if (index == -1)
        return version_len;

    if (index < 0 || (size_t)index >= version_len)
        return SM_ERR_INVALID_PARAMETERS;

    return lk_version[index];
}

static smc32_handler_t sm_fastcall_function_table[] = {
        [SMC_FUNCTION(SMC_FC_GET_NEXT_IRQ)] = smc_intc_get_next_irq,
        [SMC_FUNCTION(SMC_FC_FIQ_ENTER)] = smc_fiq_enter,
#if !WITH_LIB_SM_MONITOR
        [SMC_FUNCTION(SMC_FC_CPU_SUSPEND)] = smc_cpu_suspend,
        [SMC_FUNCTION(SMC_FC_CPU_RESUME)] = smc_cpu_resume,
#endif
        [SMC_FUNCTION(SMC_FC_GET_VERSION_STR)] = smc_get_version_str,
        [SMC_FUNCTION(SMC_FC_API_VERSION)] = smc_sm_api_version,
        [SMC_FUNCTION(SMC_FC_GET_SMP_MAX_CPUS)] = smc_get_smp_max_cpus,
};

static long smc_fastcall_secure_monitor(struct smc32_args* args) {
    smc32_handler_t func = NULL;
    uint16_t index = SMC_FUNCTION(args->smc_nr);

    if (index < countof(sm_fastcall_function_table)) {
        func = sm_fastcall_function_table[index];
    }

    if (func == NULL) {
        func = smc_undefined;
    }

    return func(args);
}

/* SMC dispatch tables */
smc32_handler_t sm_fastcall_table[SMC_NUM_ENTITIES] = {
        [0 ... SMC_ENTITY_SECURE_MONITOR - 1] = smc_undefined,
        [SMC_ENTITY_SECURE_MONITOR] = smc_fastcall_secure_monitor,
        [SMC_ENTITY_SECURE_MONITOR + 1 ... SMC_NUM_ENTITIES - 1] =
                smc_undefined};

smc32_handler_t sm_nopcall_table[SMC_NUM_ENTITIES] = {
        [0] = smc_nop_secure_monitor,
        [1 ... SMC_NUM_ENTITIES - 1] = smc_undefined};

smc32_handler_t sm_stdcall_table[SMC_NUM_ENTITIES] = {
        [0 ... SMC_ENTITY_SECURE_MONITOR - 1] = smc_undefined,
        [SMC_ENTITY_SECURE_MONITOR] = smc_stdcall_secure_monitor,
        [SMC_ENTITY_SECURE_MONITOR + 1 ... SMC_NUM_ENTITIES - 1] =
                smc_undefined};

status_t sm_register_entity(uint entity_nr, struct smc32_entity* entity) {
    status_t err = NO_ERROR;

    if (entity_nr >= SMC_NUM_ENTITIES)
        return ERR_INVALID_ARGS;

    if (entity_nr >= SMC_ENTITY_RESERVED && entity_nr < SMC_ENTITY_TRUSTED_APP)
        return ERR_NOT_ALLOWED;

    if (!entity)
        return ERR_INVALID_ARGS;

    if (!entity->fastcall_handler && !entity->stdcall_handler &&
        !entity->nopcall_handler)
        return ERR_NOT_VALID;

    mutex_acquire(&smc_table_lock);

    /* Check if entity is already claimed */
    if (sm_fastcall_table[entity_nr] != smc_undefined ||
        sm_nopcall_table[entity_nr] != smc_undefined ||
        sm_stdcall_table[entity_nr] != smc_undefined) {
        err = ERR_ALREADY_EXISTS;
        goto unlock;
    }

    if (entity->fastcall_handler)
        sm_fastcall_table[entity_nr] = entity->fastcall_handler;

    if (entity->nopcall_handler)
        sm_nopcall_table[entity_nr] = entity->nopcall_handler;

    if (entity->stdcall_handler)
        sm_stdcall_table[entity_nr] = entity->stdcall_handler;
unlock:
    mutex_release(&smc_table_lock);
    return err;
}