// SPDX-License-Identifier: GPL-2.0-only
/*
 *  Driver for Dell laptop extras
 *
 *  Copyright (c) Lyndon Sanche <lsanche@lyndeno.ca>
 *
 *  Based on documentation in the libsmbios package:
 *  Copyright (C) 2005-2014 Dell Inc.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/bitfield.h>
#include <linux/bitops.h>
#include <linux/bits.h>
#include <linux/device/faux.h>
#include <linux/dmi.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_profile.h>
#include <linux/slab.h>

#include "dell-smbios.h"

static struct faux_device *dell_pc_fdev;
static int supported_modes;

static const struct dmi_system_id dell_device_table[] __initconst = {
        {
                .ident = "Dell Inc.",
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
                },
        },
        {
                .ident = "Dell Computer Corporation",
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
                },
        },
        { }
};
MODULE_DEVICE_TABLE(dmi, dell_device_table);

/* Derived from smbios-thermal-ctl
 *
 * cbClass 17
 * cbSelect 19
 * User Selectable Thermal Tables(USTT)
 * cbArg1 determines the function to be performed
 * cbArg1 0x0 = Get Thermal Information
 *  cbRES1         Standard return codes (0, -1, -2)
 *  cbRES2, byte 0  Bitmap of supported thermal modes. A mode is supported if
 *                  its bit is set to 1
 *     Bit 0 Balanced
 *     Bit 1 Cool Bottom
 *     Bit 2 Quiet
 *     Bit 3 Performance
 *  cbRES2, byte 1 Bitmap of supported Active Acoustic Controller (AAC) modes.
 *                 Each mode corresponds to the supported thermal modes in
 *                  byte 0. A mode is supported if its bit is set to 1.
 *     Bit 0 AAC (Balanced)
 *     Bit 1 AAC (Cool Bottom
 *     Bit 2 AAC (Quiet)
 *     Bit 3 AAC (Performance)
 *  cbRes3, byte 0 Current Thermal Mode
 *     Bit 0 Balanced
 *     Bit 1 Cool Bottom
 *     Bit 2 Quiet
 *     Bit 3 Performanc
 *  cbRes3, byte 1  AAC Configuration type
 *          0       Global (AAC enable/disable applies to all supported USTT modes)
 *          1       USTT mode specific
 *  cbRes3, byte 2  Current Active Acoustic Controller (AAC) Mode
 *     If AAC Configuration Type is Global,
 *          0       AAC mode disabled
 *          1       AAC mode enabled
 *     If AAC Configuration Type is USTT mode specific (multiple bits may be set),
 *          Bit 0 AAC (Balanced)
 *          Bit 1 AAC (Cool Bottom
 *          Bit 2 AAC (Quiet)
 *          Bit 3 AAC (Performance)
 *  cbRes3, byte 3  Current Fan Failure Mode
 *     Bit 0 Minimal Fan Failure (at least one fan has failed, one fan working)
 *     Bit 1 Catastrophic Fan Failure (all fans have failed)
 *
 * cbArg1 0x1   (Set Thermal Information), both desired thermal mode and
 *               desired AAC mode shall be applied
 * cbArg2, byte 0  Desired Thermal Mode to set
 *                  (only one bit may be set for this parameter)
 *     Bit 0 Balanced
 *     Bit 1 Cool Bottom
 *     Bit 2 Quiet
 *     Bit 3 Performance
 * cbArg2, byte 1  Desired Active Acoustic Controller (AAC) Mode to set
 *     If AAC Configuration Type is Global,
 *         0  AAC mode disabled
 *         1  AAC mode enabled
 *     If AAC Configuration Type is USTT mode specific
 *     (multiple bits may be set for this parameter),
 *         Bit 0 AAC (Balanced)
 *         Bit 1 AAC (Cool Bottom
 *         Bit 2 AAC (Quiet)
 *         Bit 3 AAC (Performance)
 */

#define DELL_ACC_GET_FIELD      GENMASK(19, 16)
#define DELL_ACC_SET_FIELD      GENMASK(11, 8)
#define DELL_THERMAL_SUPPORTED  GENMASK(3, 0)

enum thermal_mode_bits {
        DELL_BALANCED    = BIT(0),
        DELL_COOL_BOTTOM = BIT(1),
        DELL_QUIET       = BIT(2),
        DELL_PERFORMANCE = BIT(3),
};

static int thermal_get_mode(void)
{
        struct calling_interface_buffer buffer;
        int state;
        int ret;

        dell_fill_request(&buffer, 0x0, 0, 0, 0);
        ret = dell_send_request(&buffer, CLASS_INFO, SELECT_THERMAL_MANAGEMENT);
        if (ret)
                return ret;
        state = buffer.output[2];
        if (state & DELL_BALANCED)
                return DELL_BALANCED;
        else if (state & DELL_COOL_BOTTOM)
                return DELL_COOL_BOTTOM;
        else if (state & DELL_QUIET)
                return DELL_QUIET;
        else if (state & DELL_PERFORMANCE)
                return DELL_PERFORMANCE;
        else
                return -ENXIO;
}

static int thermal_get_supported_modes(int *supported_bits)
{
        struct calling_interface_buffer buffer;
        int ret;

        dell_fill_request(&buffer, 0x0, 0, 0, 0);
        ret = dell_send_request(&buffer, CLASS_INFO, SELECT_THERMAL_MANAGEMENT);
        if (ret)
                return ret;
        *supported_bits = FIELD_GET(DELL_THERMAL_SUPPORTED, buffer.output[1]);
        return 0;
}

static int thermal_get_acc_mode(int *acc_mode)
{
        struct calling_interface_buffer buffer;
        int ret;

        dell_fill_request(&buffer, 0x0, 0, 0, 0);
        ret = dell_send_request(&buffer, CLASS_INFO, SELECT_THERMAL_MANAGEMENT);
        if (ret)
                return ret;
        *acc_mode = FIELD_GET(DELL_ACC_GET_FIELD, buffer.output[3]);
        return 0;
}

static int thermal_set_mode(enum thermal_mode_bits state)
{
        struct calling_interface_buffer buffer;
        int ret;
        int acc_mode;

        ret = thermal_get_acc_mode(&acc_mode);
        if (ret)
                return ret;

        dell_fill_request(&buffer, 0x1, FIELD_PREP(DELL_ACC_SET_FIELD, acc_mode) | state, 0, 0);
        return dell_send_request(&buffer, CLASS_INFO, SELECT_THERMAL_MANAGEMENT);
}

static int thermal_platform_profile_set(struct device *dev,
                                        enum platform_profile_option profile)
{
        switch (profile) {
        case PLATFORM_PROFILE_BALANCED:
                return thermal_set_mode(DELL_BALANCED);
        case PLATFORM_PROFILE_PERFORMANCE:
                return thermal_set_mode(DELL_PERFORMANCE);
        case PLATFORM_PROFILE_QUIET:
                return thermal_set_mode(DELL_QUIET);
        case PLATFORM_PROFILE_COOL:
                return thermal_set_mode(DELL_COOL_BOTTOM);
        default:
                return -EOPNOTSUPP;
        }
}

static int thermal_platform_profile_get(struct device *dev,
                                        enum platform_profile_option *profile)
{
        int ret;

        ret = thermal_get_mode();
        if (ret < 0)
                return ret;

        switch (ret) {
        case DELL_BALANCED:
                *profile = PLATFORM_PROFILE_BALANCED;
                break;
        case DELL_PERFORMANCE:
                *profile = PLATFORM_PROFILE_PERFORMANCE;
                break;
        case DELL_COOL_BOTTOM:
                *profile = PLATFORM_PROFILE_COOL;
                break;
        case DELL_QUIET:
                *profile = PLATFORM_PROFILE_QUIET;
                break;
        default:
                return -EINVAL;
        }

        return 0;
}

static int thermal_platform_profile_probe(void *drvdata, unsigned long *choices)
{
        int current_mode;

        if (supported_modes & DELL_QUIET)
                __set_bit(PLATFORM_PROFILE_QUIET, choices);
        if (supported_modes & DELL_COOL_BOTTOM)
                __set_bit(PLATFORM_PROFILE_COOL, choices);
        if (supported_modes & DELL_BALANCED)
                __set_bit(PLATFORM_PROFILE_BALANCED, choices);
        if (supported_modes & DELL_PERFORMANCE)
                __set_bit(PLATFORM_PROFILE_PERFORMANCE, choices);

        /* Make sure that ACPI is in sync with the profile set by USTT */
        current_mode = thermal_get_mode();
        if (current_mode < 0)
                return current_mode;

        thermal_set_mode(current_mode);

        return 0;
}

static const struct platform_profile_ops dell_pc_platform_profile_ops = {
        .probe = thermal_platform_profile_probe,
        .profile_get = thermal_platform_profile_get,
        .profile_set = thermal_platform_profile_set,
};

static int dell_pc_faux_probe(struct faux_device *fdev)
{
        struct device *ppdev;
        int ret;

        if (!dell_smbios_class_is_supported(CLASS_INFO))
                return -ENODEV;

        ret = thermal_get_supported_modes(&supported_modes);
        if (ret < 0)
                return ret;

        ppdev = devm_platform_profile_register(&fdev->dev, "dell-pc", NULL,
                                               &dell_pc_platform_profile_ops);

        return PTR_ERR_OR_ZERO(ppdev);
}

static const struct faux_device_ops dell_pc_faux_ops = {
        .probe = dell_pc_faux_probe,
};

static int __init dell_init(void)
{
        if (!dmi_check_system(dell_device_table))
                return -ENODEV;

        dell_pc_fdev = faux_device_create("dell-pc", NULL, &dell_pc_faux_ops);
        if (!dell_pc_fdev)
                return -ENODEV;

        return 0;
}

static void __exit dell_exit(void)
{
        faux_device_destroy(dell_pc_fdev);
}

module_init(dell_init);
module_exit(dell_exit);

MODULE_AUTHOR("Lyndon Sanche <lsanche@lyndeno.ca>");
MODULE_DESCRIPTION("Dell PC driver");
MODULE_LICENSE("GPL");