// SPDX-License-Identifier: GPL-2.0-only
/* acpi_thermal_rel.c driver for exporting ACPI thermal relationship
 *
 * Copyright (c) 2014 Intel Corp
 */

/*
 * Two functionalities included:
 * 1. Export _TRT, _ART, via misc device interface to the userspace.
 * 2. Provide parsing result to kernel drivers
 *
 */
#include <linux/init.h>
#include <linux/export.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/acpi.h>
#include <linux/uaccess.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include "acpi_thermal_rel.h"

static acpi_handle acpi_thermal_rel_handle;
static DEFINE_SPINLOCK(acpi_thermal_rel_chrdev_lock);
static int acpi_thermal_rel_chrdev_count;       /* #times opened */
static int acpi_thermal_rel_chrdev_exclu;       /* already open exclusive? */

static int acpi_thermal_rel_open(struct inode *inode, struct file *file)
{
        spin_lock(&acpi_thermal_rel_chrdev_lock);
        if (acpi_thermal_rel_chrdev_exclu ||
            (acpi_thermal_rel_chrdev_count && (file->f_flags & O_EXCL))) {
                spin_unlock(&acpi_thermal_rel_chrdev_lock);
                return -EBUSY;
        }

        if (file->f_flags & O_EXCL)
                acpi_thermal_rel_chrdev_exclu = 1;
        acpi_thermal_rel_chrdev_count++;

        spin_unlock(&acpi_thermal_rel_chrdev_lock);

        return nonseekable_open(inode, file);
}

static int acpi_thermal_rel_release(struct inode *inode, struct file *file)
{
        spin_lock(&acpi_thermal_rel_chrdev_lock);
        acpi_thermal_rel_chrdev_count--;
        acpi_thermal_rel_chrdev_exclu = 0;
        spin_unlock(&acpi_thermal_rel_chrdev_lock);

        return 0;
}

/**
 * acpi_parse_trt - Thermal Relationship Table _TRT for passive cooling
 *
 * @handle: ACPI handle of the device contains _TRT
 * @trt_count: the number of valid entries resulted from parsing _TRT
 * @trtp: pointer to pointer of array of _TRT entries in parsing result
 * @create_dev: whether to create platform devices for target and source
 *
 */
int acpi_parse_trt(acpi_handle handle, int *trt_count, struct trt **trtp,
                bool create_dev)
{
        acpi_status status;
        int result = 0;
        int i;
        int nr_bad_entries = 0;
        struct trt *trts;
        union acpi_object *p;
        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
        struct acpi_buffer element = { 0, NULL };
        struct acpi_buffer trt_format = { sizeof("RRNNNNNN"), "RRNNNNNN" };

        status = acpi_evaluate_object(handle, "_TRT", NULL, &buffer);
        if (ACPI_FAILURE(status))
                return -ENODEV;

        p = buffer.pointer;
        if (!p || (p->type != ACPI_TYPE_PACKAGE)) {
                pr_err("Invalid _TRT data\n");
                result = -EFAULT;
                goto end;
        }

        *trt_count = p->package.count;
        trts = kzalloc_objs(struct trt, *trt_count);
        if (!trts) {
                result = -ENOMEM;
                goto end;
        }

        for (i = 0; i < *trt_count; i++) {
                struct trt *trt = &trts[i - nr_bad_entries];

                element.length = sizeof(struct trt);
                element.pointer = trt;

                status = acpi_extract_package(&(p->package.elements[i]),
                                              &trt_format, &element);
                if (ACPI_FAILURE(status)) {
                        nr_bad_entries++;
                        pr_warn("_TRT package %d is invalid, ignored\n", i);
                        continue;
                }
                if (!create_dev)
                        continue;

                if (!acpi_fetch_acpi_dev(trt->source))
                        pr_warn("Failed to get source ACPI device\n");

                if (!acpi_fetch_acpi_dev(trt->target))
                        pr_warn("Failed to get target ACPI device\n");
        }

        result = 0;

        *trtp = trts;
        /* don't count bad entries */
        *trt_count -= nr_bad_entries;
end:
        kfree(buffer.pointer);
        return result;
}
EXPORT_SYMBOL(acpi_parse_trt);

/**
 * acpi_parse_art - Parse Active Relationship Table _ART
 *
 * @handle: ACPI handle of the device contains _ART
 * @art_count: the number of valid entries resulted from parsing _ART
 * @artp: pointer to pointer of array of art entries in parsing result
 * @create_dev: whether to create platform devices for target and source
 *
 */
int acpi_parse_art(acpi_handle handle, int *art_count, struct art **artp,
                bool create_dev)
{
        acpi_status status;
        int result = 0;
        int i;
        int nr_bad_entries = 0;
        struct art *arts;
        union acpi_object *p;
        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
        struct acpi_buffer element = { 0, NULL };
        struct acpi_buffer art_format = {
                sizeof("RRNNNNNNNNNNN"), "RRNNNNNNNNNNN" };

        status = acpi_evaluate_object(handle, "_ART", NULL, &buffer);
        if (ACPI_FAILURE(status))
                return -ENODEV;

        p = buffer.pointer;
        if (!p || (p->type != ACPI_TYPE_PACKAGE)) {
                pr_err("Invalid _ART data\n");
                result = -EFAULT;
                goto end;
        }

        /* ignore p->package.elements[0], as this is _ART Revision field */
        *art_count = p->package.count - 1;
        arts = kzalloc_objs(struct art, *art_count);
        if (!arts) {
                result = -ENOMEM;
                goto end;
        }

        for (i = 0; i < *art_count; i++) {
                struct art *art = &arts[i - nr_bad_entries];

                element.length = sizeof(struct art);
                element.pointer = art;

                status = acpi_extract_package(&(p->package.elements[i + 1]),
                                              &art_format, &element);
                if (ACPI_FAILURE(status)) {
                        pr_warn("_ART package %d is invalid, ignored", i);
                        nr_bad_entries++;
                        continue;
                }
                if (!create_dev)
                        continue;

                if (!acpi_fetch_acpi_dev(art->source))
                        pr_warn("Failed to get source ACPI device\n");

                if (!acpi_fetch_acpi_dev(art->target))
                        pr_warn("Failed to get target ACPI device\n");
        }

        *artp = arts;
        /* don't count bad entries */
        *art_count -= nr_bad_entries;
end:
        kfree(buffer.pointer);
        return result;
}
EXPORT_SYMBOL(acpi_parse_art);

/*
 * acpi_parse_psvt - Passive Table (PSVT) for passive cooling
 *
 * @handle: ACPI handle of the device which contains PSVT
 * @psvt_count: the number of valid entries resulted from parsing PSVT
 * @psvtp: pointer to array of psvt entries
 *
 */
static int acpi_parse_psvt(acpi_handle handle, int *psvt_count, struct psvt **psvtp)
{
        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
        int nr_bad_entries = 0, revision = 0;
        union acpi_object *p;
        acpi_status status;
        int i, result = 0;
        struct psvt *psvts;

        status = acpi_evaluate_object(handle, "PSVT", NULL, &buffer);
        if (ACPI_FAILURE(status))
                return -ENODEV;

        p = buffer.pointer;
        if (!p || (p->type != ACPI_TYPE_PACKAGE)) {
                result = -EFAULT;
                goto end;
        }

        /* first package is the revision number */
        if (p->package.count > 0) {
                union acpi_object *prev = &(p->package.elements[0]);

                if (prev->type == ACPI_TYPE_INTEGER)
                        revision = (int)prev->integer.value;
        } else {
                result = -EFAULT;
                goto end;
        }

        /* Support only version 2 */
        if (revision != 2) {
                result = -EFAULT;
                goto end;
        }

        *psvt_count = p->package.count - 1;
        if (!*psvt_count) {
                result = -EFAULT;
                goto end;
        }

        psvts = kzalloc_objs(*psvts, *psvt_count);
        if (!psvts) {
                result = -ENOMEM;
                goto end;
        }

        /* Start index is 1 because the first package is the revision number */
        for (i = 1; i < p->package.count; i++) {
                struct acpi_buffer psvt_int_format = { sizeof("RRNNNNNNNNNN"), "RRNNNNNNNNNN" };
                struct acpi_buffer psvt_str_format = { sizeof("RRNNNNNSNNNN"), "RRNNNNNSNNNN" };
                union acpi_object *package = &(p->package.elements[i]);
                struct psvt *psvt = &psvts[i - 1 - nr_bad_entries];
                struct acpi_buffer *psvt_format = &psvt_int_format;
                struct acpi_buffer element = { 0, NULL };
                union acpi_object *knob;
                struct acpi_device *res;
                struct psvt *psvt_ptr;

                element.length = ACPI_ALLOCATE_BUFFER;
                element.pointer = NULL;

                if (package->package.count >= ACPI_NR_PSVT_ELEMENTS) {
                        knob = &(package->package.elements[ACPI_PSVT_CONTROL_KNOB]);
                } else {
                        nr_bad_entries++;
                        pr_info("PSVT package %d is invalid, ignored\n", i);
                        continue;
                }

                if (knob->type == ACPI_TYPE_STRING) {
                        psvt_format = &psvt_str_format;
                        if (knob->string.length > ACPI_LIMIT_STR_MAX_LEN - 1) {
                                pr_info("PSVT package %d limit string len exceeds max\n", i);
                                knob->string.length = ACPI_LIMIT_STR_MAX_LEN - 1;
                        }
                }

                status = acpi_extract_package(&(p->package.elements[i]), psvt_format, &element);
                if (ACPI_FAILURE(status)) {
                        nr_bad_entries++;
                        pr_info("PSVT package %d is invalid, ignored\n", i);
                        continue;
                }

                psvt_ptr = (struct psvt *)element.pointer;

                memcpy(psvt, psvt_ptr, sizeof(*psvt));

                /* The limit element can be string or U64 */
                psvt->control_knob_type = (u64)knob->type;

                if (knob->type == ACPI_TYPE_STRING) {
                        memset(&psvt->limit, 0, sizeof(u64));
                        strscpy(psvt->limit.string, psvt_ptr->limit.str_ptr, ACPI_LIMIT_STR_MAX_LEN);
                } else {
                        psvt->limit.integer = psvt_ptr->limit.integer;
                }

                kfree(element.pointer);

                res = acpi_fetch_acpi_dev(psvt->source);
                if (!res) {
                        nr_bad_entries++;
                        pr_info("Failed to get source ACPI device\n");
                        continue;
                }

                res = acpi_fetch_acpi_dev(psvt->target);
                if (!res) {
                        nr_bad_entries++;
                        pr_info("Failed to get target ACPI device\n");
                        continue;
                }
        }

        /* don't count bad entries */
        *psvt_count -= nr_bad_entries;

        if (!*psvt_count) {
                result = -EFAULT;
                kfree(psvts);
                goto end;
        }

        *psvtp = psvts;

        return 0;

end:
        kfree(buffer.pointer);
        return result;
}

/* get device name from acpi handle */
static void get_single_name(acpi_handle handle, char *name)
{
        struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER};

        if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer)))
                pr_warn("Failed to get device name from acpi handle\n");
        else {
                memcpy(name, buffer.pointer, ACPI_NAMESEG_SIZE);
                kfree(buffer.pointer);
        }
}

static int fill_art(char __user *ubuf)
{
        int i;
        int ret;
        int count;
        int art_len;
        struct art *arts = NULL;
        union art_object *art_user;

        ret = acpi_parse_art(acpi_thermal_rel_handle, &count, &arts, false);
        if (ret)
                goto free_art;
        art_len = count * sizeof(union art_object);
        art_user = kzalloc(art_len, GFP_KERNEL);
        if (!art_user) {
                ret = -ENOMEM;
                goto free_art;
        }
        /* now fill in user art data */
        for (i = 0; i < count; i++) {
                /* userspace art needs device name instead of acpi reference */
                get_single_name(arts[i].source, art_user[i].source_device);
                get_single_name(arts[i].target, art_user[i].target_device);
                /* copy the rest int data in addition to source and target */
                BUILD_BUG_ON(sizeof(art_user[i].data) !=
                             sizeof(u64) * (ACPI_NR_ART_ELEMENTS - 2));
                memcpy(&art_user[i].data, &arts[i].data, sizeof(art_user[i].data));
        }

        if (copy_to_user(ubuf, art_user, art_len))
                ret = -EFAULT;
        kfree(art_user);
free_art:
        kfree(arts);
        return ret;
}

static int fill_trt(char __user *ubuf)
{
        int i;
        int ret;
        int count;
        int trt_len;
        struct trt *trts = NULL;
        union trt_object *trt_user;

        ret = acpi_parse_trt(acpi_thermal_rel_handle, &count, &trts, false);
        if (ret)
                goto free_trt;
        trt_len = count * sizeof(union trt_object);
        trt_user = kzalloc(trt_len, GFP_KERNEL);
        if (!trt_user) {
                ret = -ENOMEM;
                goto free_trt;
        }
        /* now fill in user trt data */
        for (i = 0; i < count; i++) {
                /* userspace trt needs device name instead of acpi reference */
                get_single_name(trts[i].source, trt_user[i].source_device);
                get_single_name(trts[i].target, trt_user[i].target_device);
                trt_user[i].sample_period = trts[i].sample_period;
                trt_user[i].influence = trts[i].influence;
        }

        if (copy_to_user(ubuf, trt_user, trt_len))
                ret = -EFAULT;
        kfree(trt_user);
free_trt:
        kfree(trts);
        return ret;
}

static int fill_psvt(char __user *ubuf)
{
        int i, ret, count, psvt_len;
        union psvt_object *psvt_user;
        struct psvt *psvts;

        ret = acpi_parse_psvt(acpi_thermal_rel_handle, &count, &psvts);
        if (ret)
                return ret;

        psvt_len = count * sizeof(*psvt_user);

        psvt_user = kzalloc(psvt_len, GFP_KERNEL);
        if (!psvt_user) {
                ret = -ENOMEM;
                goto free_psvt;
        }

        /* now fill in user psvt data */
        for (i = 0; i < count; i++) {
                /* userspace psvt needs device name instead of acpi reference */
                get_single_name(psvts[i].source, psvt_user[i].source_device);
                get_single_name(psvts[i].target, psvt_user[i].target_device);

                psvt_user[i].priority = psvts[i].priority;
                psvt_user[i].sample_period = psvts[i].sample_period;
                psvt_user[i].passive_temp = psvts[i].passive_temp;
                psvt_user[i].source_domain = psvts[i].source_domain;
                psvt_user[i].control_knob = psvts[i].control_knob;
                psvt_user[i].step_size = psvts[i].step_size;
                psvt_user[i].limit_coeff = psvts[i].limit_coeff;
                psvt_user[i].unlimit_coeff = psvts[i].unlimit_coeff;
                psvt_user[i].control_knob_type = psvts[i].control_knob_type;
                if (psvt_user[i].control_knob_type == ACPI_TYPE_STRING)
                        strscpy(psvt_user[i].limit.string, psvts[i].limit.string,
                                ACPI_LIMIT_STR_MAX_LEN);
                else
                        psvt_user[i].limit.integer = psvts[i].limit.integer;

        }

        if (copy_to_user(ubuf, psvt_user, psvt_len))
                ret = -EFAULT;

        kfree(psvt_user);

free_psvt:
        kfree(psvts);
        return ret;
}

static long acpi_thermal_rel_ioctl(struct file *f, unsigned int cmd,
                                   unsigned long __arg)
{
        int ret = 0;
        unsigned long length = 0;
        int count = 0;
        char __user *arg = (void __user *)__arg;
        struct trt *trts = NULL;
        struct art *arts = NULL;
        struct psvt *psvts;

        switch (cmd) {
        case ACPI_THERMAL_GET_TRT_COUNT:
                ret = acpi_parse_trt(acpi_thermal_rel_handle, &count,
                                &trts, false);
                kfree(trts);
                if (!ret)
                        return put_user(count, (unsigned long __user *)__arg);
                return ret;
        case ACPI_THERMAL_GET_TRT_LEN:
                ret = acpi_parse_trt(acpi_thermal_rel_handle, &count,
                                &trts, false);
                kfree(trts);
                length = count * sizeof(union trt_object);
                if (!ret)
                        return put_user(length, (unsigned long __user *)__arg);
                return ret;
        case ACPI_THERMAL_GET_TRT:
                return fill_trt(arg);
        case ACPI_THERMAL_GET_ART_COUNT:
                ret = acpi_parse_art(acpi_thermal_rel_handle, &count,
                                &arts, false);
                kfree(arts);
                if (!ret)
                        return put_user(count, (unsigned long __user *)__arg);
                return ret;
        case ACPI_THERMAL_GET_ART_LEN:
                ret = acpi_parse_art(acpi_thermal_rel_handle, &count,
                                &arts, false);
                kfree(arts);
                length = count * sizeof(union art_object);
                if (!ret)
                        return put_user(length, (unsigned long __user *)__arg);
                return ret;

        case ACPI_THERMAL_GET_ART:
                return fill_art(arg);

        case ACPI_THERMAL_GET_PSVT_COUNT:
                ret = acpi_parse_psvt(acpi_thermal_rel_handle, &count, &psvts);
                if (!ret) {
                        kfree(psvts);
                        return put_user(count, (unsigned long __user *)__arg);
                }
                return ret;

        case ACPI_THERMAL_GET_PSVT_LEN:
                /* total length of the data retrieved (count * PSVT entry size) */
                ret = acpi_parse_psvt(acpi_thermal_rel_handle, &count, &psvts);
                length = count * sizeof(union psvt_object);
                if (!ret) {
                        kfree(psvts);
                        return put_user(length, (unsigned long __user *)__arg);
                }
                return ret;

        case ACPI_THERMAL_GET_PSVT:
                return fill_psvt(arg);

        default:
                return -ENOTTY;
        }
}

static const struct file_operations acpi_thermal_rel_fops = {
        .owner          = THIS_MODULE,
        .open           = acpi_thermal_rel_open,
        .release        = acpi_thermal_rel_release,
        .unlocked_ioctl = acpi_thermal_rel_ioctl,
};

static struct miscdevice acpi_thermal_rel_misc_device = {
        .minor  = MISC_DYNAMIC_MINOR,
        "acpi_thermal_rel",
        &acpi_thermal_rel_fops
};

int acpi_thermal_rel_misc_device_add(acpi_handle handle)
{
        acpi_thermal_rel_handle = handle;

        return misc_register(&acpi_thermal_rel_misc_device);
}
EXPORT_SYMBOL(acpi_thermal_rel_misc_device_add);

int acpi_thermal_rel_misc_device_remove(acpi_handle handle)
{
        misc_deregister(&acpi_thermal_rel_misc_device);

        return 0;
}
EXPORT_SYMBOL(acpi_thermal_rel_misc_device_remove);

MODULE_AUTHOR("Zhang Rui <rui.zhang@intel.com>");
MODULE_AUTHOR("Jacob Pan <jacob.jun.pan@intel.com");
MODULE_DESCRIPTION("Intel acpi thermal rel misc dev driver");
MODULE_LICENSE("GPL v2");