// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) 2014 Imagination Technologies
 * Author: Paul Burton <paul.burton@mips.com>
 */

#include <linux/cpu_pm.h>
#include <linux/cpuidle.h>
#include <linux/init.h>

#include <asm/idle.h>
#include <asm/pm-cps.h>

/* Enumeration of the various idle states this driver may enter */
enum cps_idle_state {
        STATE_WAIT = 0,         /* MIPS wait instruction, coherent */
        STATE_NC_WAIT,          /* MIPS wait instruction, non-coherent */
        STATE_CLOCK_GATED,      /* Core clock gated */
        STATE_POWER_GATED,      /* Core power gated */
        STATE_COUNT
};

static int cps_nc_enter(struct cpuidle_device *dev,
                        struct cpuidle_driver *drv, int index)
{
        enum cps_pm_state pm_state;
        int err;

        /*
         * At least one core must remain powered up & clocked in order for the
         * system to have any hope of functioning.
         *
         * TODO: don't treat core 0 specially, just prevent the final core
         * TODO: remap interrupt affinity temporarily
         */
        if (cpus_are_siblings(0, dev->cpu) && (index > STATE_NC_WAIT))
                index = STATE_NC_WAIT;

        /* Select the appropriate cps_pm_state */
        switch (index) {
        case STATE_NC_WAIT:
                pm_state = CPS_PM_NC_WAIT;
                break;
        case STATE_CLOCK_GATED:
                pm_state = CPS_PM_CLOCK_GATED;
                break;
        case STATE_POWER_GATED:
                pm_state = CPS_PM_POWER_GATED;
                break;
        default:
                BUG();
                return -EINVAL;
        }

        /* Notify listeners the CPU is about to power down */
        if ((pm_state == CPS_PM_POWER_GATED) && cpu_pm_enter())
                return -EINTR;

        /* Enter that state */
        err = cps_pm_enter_state(pm_state);

        /* Notify listeners the CPU is back up */
        if (pm_state == CPS_PM_POWER_GATED)
                cpu_pm_exit();

        return err ?: index;
}

static struct cpuidle_driver cps_driver = {
        .name                   = "cpc_cpuidle",
        .owner                  = THIS_MODULE,
        .states = {
                [STATE_WAIT] = MIPS_CPUIDLE_WAIT_STATE,
                [STATE_NC_WAIT] = {
                        .enter  = cps_nc_enter,
                        .exit_latency           = 200,
                        .target_residency       = 450,
                        .name   = "nc-wait",
                        .desc   = "non-coherent MIPS wait",
                },
                [STATE_CLOCK_GATED] = {
                        .enter  = cps_nc_enter,
                        .exit_latency           = 300,
                        .target_residency       = 700,
                        .flags  = CPUIDLE_FLAG_TIMER_STOP,
                        .name   = "clock-gated",
                        .desc   = "core clock gated",
                },
                [STATE_POWER_GATED] = {
                        .enter  = cps_nc_enter,
                        .exit_latency           = 600,
                        .target_residency       = 1000,
                        .flags  = CPUIDLE_FLAG_TIMER_STOP,
                        .name   = "power-gated",
                        .desc   = "core power gated",
                },
        },
        .state_count            = STATE_COUNT,
        .safe_state_index       = 0,
};

static void __init cps_cpuidle_unregister(void)
{
        int cpu;
        struct cpuidle_device *device;

        for_each_possible_cpu(cpu) {
                device = &per_cpu(cpuidle_dev, cpu);
                cpuidle_unregister_device(device);
        }

        cpuidle_unregister_driver(&cps_driver);
}

static int __init cps_cpuidle_init(void)
{
        int err, cpu, i;
        struct cpuidle_device *device;

        /* Detect supported states */
        if (!cps_pm_support_state(CPS_PM_POWER_GATED))
                cps_driver.state_count = STATE_CLOCK_GATED + 1;
        if (!cps_pm_support_state(CPS_PM_CLOCK_GATED))
                cps_driver.state_count = STATE_NC_WAIT + 1;
        if (!cps_pm_support_state(CPS_PM_NC_WAIT))
                cps_driver.state_count = STATE_WAIT + 1;

        /* Inform the user if some states are unavailable */
        if (cps_driver.state_count < STATE_COUNT) {
                pr_info("cpuidle-cps: limited to ");
                switch (cps_driver.state_count - 1) {
                case STATE_WAIT:
                        pr_cont("coherent wait\n");
                        break;
                case STATE_NC_WAIT:
                        pr_cont("non-coherent wait\n");
                        break;
                case STATE_CLOCK_GATED:
                        pr_cont("clock gating\n");
                        break;
                }
        }

        /*
         * Set the coupled flag on the appropriate states if this system
         * requires it.
         */
        if (coupled_coherence)
                for (i = STATE_NC_WAIT; i < cps_driver.state_count; i++)
                        cps_driver.states[i].flags |= CPUIDLE_FLAG_COUPLED;

        err = cpuidle_register_driver(&cps_driver);
        if (err) {
                pr_err("Failed to register CPS cpuidle driver\n");
                return err;
        }

        for_each_possible_cpu(cpu) {
                device = &per_cpu(cpuidle_dev, cpu);
                device->cpu = cpu;
#ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED
                cpumask_copy(&device->coupled_cpus, &cpu_sibling_map[cpu]);
#endif

                err = cpuidle_register_device(device);
                if (err) {
                        pr_err("Failed to register CPU%d cpuidle device\n",
                               cpu);
                        goto err_out;
                }
        }

        return 0;
err_out:
        cps_cpuidle_unregister();
        return err;
}
device_initcall(cps_cpuidle_init);