// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2015-2021, Linaro Limited
 * Copyright (c) 2016, EPAM Systems
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/crash_dump.h>
#include <linux/errno.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/rpmb.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/tee_core.h>
#include <linux/types.h>
#include "optee_private.h"

struct blocking_notifier_head optee_rpmb_intf_added =
        BLOCKING_NOTIFIER_INIT(optee_rpmb_intf_added);

static int rpmb_add_dev(struct device *dev)
{
        blocking_notifier_call_chain(&optee_rpmb_intf_added, 0,
                                     to_rpmb_dev(dev));

        return 0;
}

static struct class_interface rpmb_class_intf = {
        .add_dev = rpmb_add_dev,
};

void optee_bus_scan_rpmb(struct work_struct *work)
{
        struct optee *optee = container_of(work, struct optee,
                                           rpmb_scan_bus_work);
        int ret;

        if (!optee->rpmb_scan_bus_done) {
                ret = optee_enumerate_devices(PTA_CMD_GET_DEVICES_RPMB);
                optee->rpmb_scan_bus_done = !ret;
                if (ret && ret != -ENODEV)
                        pr_info("Scanning for RPMB device: ret %d\n", ret);
        }
}

int optee_rpmb_intf_rdev(struct notifier_block *intf, unsigned long action,
                         void *data)
{
        struct optee *optee = container_of(intf, struct optee, rpmb_intf);

        schedule_work(&optee->rpmb_scan_bus_work);

        return 0;
}

int optee_set_dma_mask(struct optee *optee, u_int pa_width)
{
        u64 mask = DMA_BIT_MASK(min(64, pa_width));

        return dma_coerce_mask_and_coherent(&optee->teedev->dev, mask);
}

int optee_get_revision(struct tee_device *teedev, char *buf, size_t len)
{
        struct optee *optee = tee_get_drvdata(teedev);
        u64 build_id;

        if (!optee)
                return -ENODEV;
        if (!buf || !len)
                return -EINVAL;

        build_id = optee->revision.os_build_id;
        if (build_id)
                scnprintf(buf, len, "%u.%u (%016llx)",
                          optee->revision.os_major,
                          optee->revision.os_minor,
                          (unsigned long long)build_id);
        else
                scnprintf(buf, len, "%u.%u", optee->revision.os_major,
                          optee->revision.os_minor);

        return 0;
}

static void optee_bus_scan(struct work_struct *work)
{
        WARN_ON(optee_enumerate_devices(PTA_CMD_GET_DEVICES_SUPP));
}

static ssize_t rpmb_routing_model_show(struct device *dev,
                                       struct device_attribute *attr, char *buf)
{
        struct optee *optee = dev_get_drvdata(dev);
        const char *s;

        if (optee->in_kernel_rpmb_routing)
                s = "kernel";
        else
                s = "user";

        return sysfs_emit(buf, "%s\n", s);
}
static DEVICE_ATTR_RO(rpmb_routing_model);

static struct attribute *optee_dev_attrs[] = {
        &dev_attr_rpmb_routing_model.attr,
        NULL
};

ATTRIBUTE_GROUPS(optee_dev);

void optee_set_dev_group(struct optee *optee)
{
        tee_device_set_dev_groups(optee->teedev, optee_dev_groups);
        tee_device_set_dev_groups(optee->supp_teedev, optee_dev_groups);
}

int optee_open(struct tee_context *ctx, bool cap_memref_null)
{
        struct optee_context_data *ctxdata;
        struct tee_device *teedev = ctx->teedev;
        struct optee *optee = tee_get_drvdata(teedev);

        ctxdata = kzalloc_obj(*ctxdata);
        if (!ctxdata)
                return -ENOMEM;

        if (teedev == optee->supp_teedev) {
                bool busy = true;

                mutex_lock(&optee->supp.mutex);
                if (!optee->supp.ctx) {
                        busy = false;
                        optee->supp.ctx = ctx;
                }
                mutex_unlock(&optee->supp.mutex);
                if (busy) {
                        kfree(ctxdata);
                        return -EBUSY;
                }

                if (!optee->scan_bus_done) {
                        INIT_WORK(&optee->scan_bus_work, optee_bus_scan);
                        schedule_work(&optee->scan_bus_work);
                        optee->scan_bus_done = true;
                }
        }
        mutex_init(&ctxdata->mutex);
        INIT_LIST_HEAD(&ctxdata->sess_list);

        ctx->cap_memref_null = cap_memref_null;
        ctx->data = ctxdata;
        return 0;
}

static void optee_release_helper(struct tee_context *ctx,
                                 int (*close_session)(struct tee_context *ctx,
                                                      u32 session,
                                                      bool system_thread))
{
        struct optee_context_data *ctxdata = ctx->data;
        struct optee_session *sess;
        struct optee_session *sess_tmp;

        if (!ctxdata)
                return;

        list_for_each_entry_safe(sess, sess_tmp, &ctxdata->sess_list,
                                 list_node) {
                list_del(&sess->list_node);
                close_session(ctx, sess->session_id, sess->use_sys_thread);
                kfree(sess);
        }
        kfree(ctxdata);
        ctx->data = NULL;
}

void optee_release(struct tee_context *ctx)
{
        optee_release_helper(ctx, optee_close_session_helper);
}

void optee_release_supp(struct tee_context *ctx)
{
        struct optee *optee = tee_get_drvdata(ctx->teedev);

        optee_release_helper(ctx, optee_close_session_helper);

        optee_supp_release(&optee->supp);
}

void optee_remove_common(struct optee *optee)
{
        blocking_notifier_chain_unregister(&optee_rpmb_intf_added,
                                           &optee->rpmb_intf);
        cancel_work_sync(&optee->rpmb_scan_bus_work);
        /* Unregister OP-TEE specific client devices on TEE bus */
        optee_unregister_devices();

        optee_notif_uninit(optee);
        optee_shm_arg_cache_uninit(optee);
        teedev_close_context(optee->ctx);
        /*
         * The two devices have to be unregistered before we can free the
         * other resources.
         */
        tee_device_unregister(optee->supp_teedev);
        tee_device_unregister(optee->teedev);

        tee_shm_pool_free(optee->pool);
        optee_supp_uninit(&optee->supp);
        mutex_destroy(&optee->call_queue.mutex);
        rpmb_dev_put(optee->rpmb_dev);
        mutex_destroy(&optee->rpmb_dev_mutex);
}

static int smc_abi_rc;
static int ffa_abi_rc;
static bool intf_is_regged;

static int __init optee_core_init(void)
{
        int rc;

        /*
         * The kernel may have crashed at the same time that all available
         * secure world threads were suspended and we cannot reschedule the
         * suspended threads without access to the crashed kernel's wait_queue.
         * Therefore, we cannot reliably initialize the OP-TEE driver in the
         * kdump kernel.
         */
        if (is_kdump_kernel())
                return -ENODEV;

        if (IS_REACHABLE(CONFIG_RPMB)) {
                rc = rpmb_interface_register(&rpmb_class_intf);
                if (rc)
                        return rc;
                intf_is_regged = true;
        }

        smc_abi_rc = optee_smc_abi_register();
        ffa_abi_rc = optee_ffa_abi_register();

        /* If both failed there's no point with this module */
        if (smc_abi_rc && ffa_abi_rc) {
                if (IS_REACHABLE(CONFIG_RPMB)) {
                        rpmb_interface_unregister(&rpmb_class_intf);
                        intf_is_regged = false;
                }
                return smc_abi_rc;
        }

        return 0;
}
module_init(optee_core_init);

static void __exit optee_core_exit(void)
{
        if (IS_REACHABLE(CONFIG_RPMB) && intf_is_regged) {
                rpmb_interface_unregister(&rpmb_class_intf);
                intf_is_regged = false;
        }

        if (!smc_abi_rc)
                optee_smc_abi_unregister();
        if (!ffa_abi_rc)
                optee_ffa_abi_unregister();
}
module_exit(optee_core_exit);

MODULE_AUTHOR("Linaro");
MODULE_DESCRIPTION("OP-TEE driver");
MODULE_VERSION("1.0");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:optee");