blob: 0bb843246f5925606d84a7c7ca959384412fd84a [file] [log] [blame]
 // SPDX-License-Identifier: GPL-2.0 /* * Copyright (C) 2019 Linaro Limited. * * Author: Daniel Lezcano * */ #include #include #include #include #include #include #include /** * struct cpuidle_cooling_device - data for the idle cooling device * @ii_dev: an atomic to keep track of the last task exiting the idle cycle * @state: a normalized integer giving the state of the cooling device */ struct cpuidle_cooling_device { struct idle_inject_device *ii_dev; unsigned long state; }; static DEFINE_IDA(cpuidle_ida); /** * cpuidle_cooling_runtime - Running time computation * @idle_duration_us: the idle cooling device * @state: a percentile based number * * The running duration is computed from the idle injection duration * which is fixed. If we reach 100% of idle injection ratio, that * means the running duration is zero. If we have a 50% ratio * injection, that means we have equal duration for idle and for * running duration. * * The formula is deduced as follows: * * running = idle x ((100 / ratio) - 1) * * For precision purpose for integer math, we use the following: * * running = (idle x 100) / ratio - idle * * For example, if we have an injected duration of 50%, then we end up * with 10ms of idle injection and 10ms of running duration. * * Return: An unsigned int for a usec based runtime duration. */ static unsigned int cpuidle_cooling_runtime(unsigned int idle_duration_us, unsigned long state) { if (!state) return 0; return ((idle_duration_us * 100) / state) - idle_duration_us; } /** * cpuidle_cooling_get_max_state - Get the maximum state * @cdev : the thermal cooling device * @state : a pointer to the state variable to be filled * * The function always returns 100 as the injection ratio. It is * percentile based for consistency accross different platforms. * * Return: The function can not fail, it is always zero */ static int cpuidle_cooling_get_max_state(struct thermal_cooling_device *cdev, unsigned long *state) { /* * Depending on the configuration or the hardware, the running * cycle and the idle cycle could be different. We want to * unify that to an 0..100 interval, so the set state * interface will be the same whatever the platform is. * * The state 100% will make the cluster 100% ... idle. A 0% * injection ratio means no idle injection at all and 50% * means for 10ms of idle injection, we have 10ms of running * time. */ *state = 100; return 0; } /** * cpuidle_cooling_get_cur_state - Get the current cooling state * @cdev: the thermal cooling device * @state: a pointer to the state * * The function just copies the state value from the private thermal * cooling device structure, the mapping is 1 <-> 1. * * Return: The function can not fail, it is always zero */ static int cpuidle_cooling_get_cur_state(struct thermal_cooling_device *cdev, unsigned long *state) { struct cpuidle_cooling_device *idle_cdev = cdev->devdata; *state = idle_cdev->state; return 0; } /** * cpuidle_cooling_set_cur_state - Set the current cooling state * @cdev: the thermal cooling device * @state: the target state * * The function checks first if we are initiating the mitigation which * in turn wakes up all the idle injection tasks belonging to the idle * cooling device. In any case, it updates the internal state for the * cooling device. * * Return: The function can not fail, it is always zero */ static int cpuidle_cooling_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state) { struct cpuidle_cooling_device *idle_cdev = cdev->devdata; struct idle_inject_device *ii_dev = idle_cdev->ii_dev; unsigned long current_state = idle_cdev->state; unsigned int runtime_us, idle_duration_us; idle_cdev->state = state; idle_inject_get_duration(ii_dev, &runtime_us, &idle_duration_us); runtime_us = cpuidle_cooling_runtime(idle_duration_us, state); idle_inject_set_duration(ii_dev, runtime_us, idle_duration_us); if (current_state == 0 && state > 0) { idle_inject_start(ii_dev); } else if (current_state > 0 && !state) { idle_inject_stop(ii_dev); } return 0; } /** * cpuidle_cooling_ops - thermal cooling device ops */ static struct thermal_cooling_device_ops cpuidle_cooling_ops = { .get_max_state = cpuidle_cooling_get_max_state, .get_cur_state = cpuidle_cooling_get_cur_state, .set_cur_state = cpuidle_cooling_set_cur_state, }; /** * cpuidle_of_cooling_register - Idle cooling device initialization function * @drv: a cpuidle driver structure pointer * @np: a node pointer to a device tree cooling device node * * This function is in charge of creating a cooling device per cpuidle * driver and register it to thermal framework. * * Return: zero on success, or negative value corresponding to the * error detected in the underlying subsystems. */ int cpuidle_of_cooling_register(struct device_node *np, struct cpuidle_driver *drv) { struct idle_inject_device *ii_dev; struct cpuidle_cooling_device *idle_cdev; struct thermal_cooling_device *cdev; char dev_name[THERMAL_NAME_LENGTH]; int id, ret; idle_cdev = kzalloc(sizeof(*idle_cdev), GFP_KERNEL); if (!idle_cdev) { ret = -ENOMEM; goto out; } id = ida_simple_get(&cpuidle_ida, 0, 0, GFP_KERNEL); if (id < 0) { ret = id; goto out_kfree; } ii_dev = idle_inject_register(drv->cpumask); if (!ii_dev) { ret = -EINVAL; goto out_id; } idle_inject_set_duration(ii_dev, TICK_USEC, TICK_USEC); idle_cdev->ii_dev = ii_dev; snprintf(dev_name, sizeof(dev_name), "thermal-idle-%d", id); cdev = thermal_of_cooling_device_register(np, dev_name, idle_cdev, &cpuidle_cooling_ops); if (IS_ERR(cdev)) { ret = PTR_ERR(cdev); goto out_unregister; } return 0; out_unregister: idle_inject_unregister(ii_dev); out_id: ida_simple_remove(&cpuidle_ida, id); out_kfree: kfree(idle_cdev); out: return ret; } /** * cpuidle_cooling_register - Idle cooling device initialization function * @drv: a cpuidle driver structure pointer * * This function is in charge of creating a cooling device per cpuidle * driver and register it to thermal framework. * * Return: zero on success, or negative value corresponding to the * error detected in the underlying subsystems. */ int cpuidle_cooling_register(struct cpuidle_driver *drv) { return cpuidle_of_cooling_register(NULL, drv); }