diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile index 01dce2d5db6..0d17026c539 100644 --- a/drivers/thermal/Makefile +++ b/drivers/thermal/Makefile @@ -7,7 +7,7 @@ obj-$(CONFIG_THERMAL_MSM_POPMEM) += msm_popmem-tm.o obj-$(CONFIG_THERMAL_TSENS) += msm_tsens.o obj-$(CONFIG_THERMAL_TSENS8960) += msm8960_tsens.o obj-$(CONFIG_THERMAL_PM8XXX) += pm8xxx-tm.o -obj-$(CONFIG_THERMAL_MONITOR) += msm_thermal.o +obj-$(CONFIG_THERMAL_MONITOR) += msm_thermal.o msm_thermal-dev.o obj-$(CONFIG_SPEAR_THERMAL) += spear_thermal.o obj-$(CONFIG_THERMAL_TSENS8974) += msm8974-tsens.o obj-$(CONFIG_THERMAL_QPNP) += qpnp-temp-alarm.o diff --git a/drivers/thermal/msm_thermal-dev.c b/drivers/thermal/msm_thermal-dev.c new file mode 100644 index 00000000000..c34dd272274 --- /dev/null +++ b/drivers/thermal/msm_thermal-dev.c @@ -0,0 +1,224 @@ +/* Copyright (c) 2013, The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct msm_thermal_ioctl_dev { + struct semaphore sem; + struct cdev char_dev; +}; + +static int msm_thermal_major; +static struct class *thermal_class; +static struct msm_thermal_ioctl_dev *msm_thermal_dev; + +static int msm_thermal_ioctl_open(struct inode *node, struct file *filep) +{ + int ret = 0; + struct msm_thermal_ioctl_dev *dev; + + dev = container_of(node->i_cdev, struct msm_thermal_ioctl_dev, + char_dev); + filep->private_data = dev; + + return ret; +} + +static int msm_thermal_ioctl_release(struct inode *node, struct file *filep) +{ + pr_debug("%s: IOCTL: release\n", KBUILD_MODNAME); + return 0; +} + +static long validate_and_copy(unsigned int *cmd, unsigned long *arg, + struct msm_thermal_ioctl *query) +{ + long ret = 0, err_val = 0; + + if ((_IOC_TYPE(*cmd) != MSM_THERMAL_MAGIC_NUM) || + (_IOC_NR(*cmd) >= MSM_CMD_MAX_NR)) { + ret = -ENOTTY; + goto validate_exit; + } + + if (_IOC_DIR(*cmd) & _IOC_READ) { + err_val = !access_ok(VERIFY_WRITE, (void __user *)*arg, + _IOC_SIZE(*cmd)); + } else if (_IOC_DIR(*cmd) & _IOC_WRITE) { + err_val = !access_ok(VERIFY_READ, (void __user *)*arg, + _IOC_SIZE(*cmd)); + } + if (err_val) { + ret = -EFAULT; + goto validate_exit; + } + + if (copy_from_user(query, (void __user *)(*arg), + sizeof(struct msm_thermal_ioctl))) { + ret = -EACCES; + goto validate_exit; + } + + if (query->size != sizeof(struct msm_thermal_ioctl)) { + pr_err("%s: Invalid input argument size\n", __func__); + ret = -EINVAL; + goto validate_exit; + } + + switch (*cmd) { + case MSM_THERMAL_SET_CPU_MAX_FREQUENCY: + case MSM_THERMAL_SET_CPU_MIN_FREQUENCY: + if (query->cpu_freq.cpu_num >= num_possible_cpus()) { + pr_err("%s: Invalid CPU number: %u\n", __func__, + query->cpu_freq.cpu_num); + ret = -EINVAL; + goto validate_exit; + } + break; + default: + ret = -ENOTTY; + goto validate_exit; + break; + } + +validate_exit: + return ret; +} + +static long msm_thermal_ioctl_process(struct file *filep, unsigned int cmd, + unsigned long arg) +{ + long ret = 0; + struct msm_thermal_ioctl query; + + pr_debug("%s: IOCTL: processing cmd:%u\n", KBUILD_MODNAME, cmd); + + ret = validate_and_copy(&cmd, &arg, &query); + if (ret) + goto process_exit; + + switch (cmd) { + case MSM_THERMAL_SET_CPU_MAX_FREQUENCY: + ret = msm_thermal_set_frequency(query.cpu_freq.cpu_num, + query.cpu_freq.freq_req, true); + break; + case MSM_THERMAL_SET_CPU_MIN_FREQUENCY: + ret = msm_thermal_set_frequency(query.cpu_freq.cpu_num, + query.cpu_freq.freq_req, false); + break; + default: + ret = -ENOTTY; + goto process_exit; + } +process_exit: + return ret; +} + +static const struct file_operations msm_thermal_fops = { + .owner = THIS_MODULE, + .open = msm_thermal_ioctl_open, + .unlocked_ioctl = msm_thermal_ioctl_process, + .release = msm_thermal_ioctl_release, +}; + +int msm_thermal_ioctl_init() +{ + int ret = 0; + dev_t thermal_dev; + struct device *therm_device; + + ret = alloc_chrdev_region(&thermal_dev, 0, 1, + MSM_THERMAL_IOCTL_NAME); + if (ret < 0) { + pr_err("%s: Error in allocating char device region. Err:%d\n", + KBUILD_MODNAME, ret); + goto ioctl_init_exit; + } + + msm_thermal_major = MAJOR(thermal_dev); + + thermal_class = class_create(THIS_MODULE, "msm_thermal"); + if (IS_ERR(thermal_class)) { + pr_err("%s: Error in creating class\n", + KBUILD_MODNAME); + ret = PTR_ERR(thermal_class); + goto ioctl_class_fail; + } + + therm_device = device_create(thermal_class, NULL, thermal_dev, NULL, + MSM_THERMAL_IOCTL_NAME); + if (IS_ERR(therm_device)) { + pr_err("%s: Error in creating character device\n", + KBUILD_MODNAME); + ret = PTR_ERR(therm_device); + goto ioctl_dev_fail; + } + msm_thermal_dev = kmalloc(sizeof(struct msm_thermal_ioctl_dev), + GFP_KERNEL); + if (!msm_thermal_dev) { + pr_err("%s: Error allocating memory\n", + KBUILD_MODNAME); + ret = -ENOMEM; + goto ioctl_clean_all; + } + + memset(msm_thermal_dev, 0, sizeof(struct msm_thermal_ioctl_dev)); + sema_init(&msm_thermal_dev->sem, 1); + cdev_init(&msm_thermal_dev->char_dev, &msm_thermal_fops); + ret = cdev_add(&msm_thermal_dev->char_dev, thermal_dev, 1); + if (ret < 0) { + pr_err("%s: Error in adding character device\n", + KBUILD_MODNAME); + goto ioctl_clean_all; + } + + return ret; + +ioctl_clean_all: + device_destroy(thermal_class, thermal_dev); +ioctl_dev_fail: + class_destroy(thermal_class); +ioctl_class_fail: + unregister_chrdev_region(thermal_dev, 1); +ioctl_init_exit: + return ret; +} + +void msm_thermal_ioctl_cleanup() +{ + dev_t thermal_dev = MKDEV(msm_thermal_major, 0); + + if (!msm_thermal_dev) { + pr_err("%s: Thermal IOCTL cleanup already done\n", + KBUILD_MODNAME); + return; + } + + device_destroy(thermal_class, thermal_dev); + class_destroy(thermal_class); + cdev_del(&msm_thermal_dev->char_dev); + unregister_chrdev_region(thermal_dev, 1); + kfree(msm_thermal_dev); + msm_thermal_dev = NULL; + thermal_class = NULL; +} diff --git a/drivers/thermal/msm_thermal.c b/drivers/thermal/msm_thermal.c index 0c44dfbeded..b26840e5d87 100644 --- a/drivers/thermal/msm_thermal.c +++ b/drivers/thermal/msm_thermal.c @@ -35,6 +35,7 @@ #include #include #include +#include #define MAX_RAILS 5 #define MAX_THRESHOLD 2 @@ -94,6 +95,8 @@ struct cpu_info { bool hotplug_thresh_clear; struct sensor_threshold threshold[THRESHOLD_MAX_NR]; bool max_freq; + uint32_t user_max_freq; + uint32_t user_min_freq; uint32_t limited_max_freq; uint32_t limited_min_freq; bool freq_thresh_clear; @@ -1174,7 +1177,7 @@ init_kthread: static __ref int do_freq_mitigation(void *data) { int ret = 0; - uint32_t cpu = 0, max_freq_req = 0; + uint32_t cpu = 0, max_freq_req = 0, min_freq_req = 0; while (!kthread_should_stop()) { wait_for_completion(&freq_mitigation_complete); @@ -1185,17 +1188,23 @@ static __ref int do_freq_mitigation(void *data) max_freq_req = (cpus[cpu].max_freq) ? msm_thermal_info.freq_limit : UINT_MAX; + max_freq_req = min(max_freq_req, + cpus[cpu].user_max_freq); + + min_freq_req = max(min_freq_limit, + cpus[cpu].user_min_freq); if ((max_freq_req == cpus[cpu].limited_max_freq) - && (min_freq_limit == + && (min_freq_req == cpus[cpu].limited_min_freq)) goto reset_threshold; cpus[cpu].limited_max_freq = max_freq_req; - cpus[cpu].limited_min_freq = min_freq_limit; + cpus[cpu].limited_min_freq = min_freq_req; update_cpu_freq(cpu); reset_threshold: - if (cpus[cpu].freq_thresh_clear) { + if (freq_mitigation_enabled && + cpus[cpu].freq_thresh_clear) { set_threshold(cpus[cpu].sensor_id, &cpus[cpu].threshold[FREQ_THRESHOLD_HIGH]); @@ -1257,8 +1266,10 @@ static void freq_mitigation_init(void) uint32_t cpu = 0; struct sensor_threshold *hi_thresh = NULL, *low_thresh = NULL; - if (!freq_mitigation_enabled || freq_mitigation_task) + if (freq_mitigation_task) return; + if (!freq_mitigation_enabled) + goto init_freq_thread; for_each_possible_cpu(cpu) { if (!(msm_thermal_info.freq_mitig_control_mask & BIT(cpu))) @@ -1277,7 +1288,7 @@ static void freq_mitigation_init(void) set_threshold(cpus[cpu].sensor_id, hi_thresh); } - +init_freq_thread: init_completion(&freq_mitigation_complete); freq_mitigation_task = kthread_run(do_freq_mitigation, NULL, "msm_thermal:freq_mitig"); @@ -1289,6 +1300,41 @@ static void freq_mitigation_init(void) } } +int msm_thermal_set_frequency(uint32_t cpu, uint32_t freq, bool is_max) +{ + int ret = 0; + + if (cpu >= num_possible_cpus()) { + pr_err("%s: Invalid input\n", KBUILD_MODNAME); + ret = -EINVAL; + goto set_freq_exit; + } + + if (is_max) { + if (cpus[cpu].user_max_freq == freq) + goto set_freq_exit; + + cpus[cpu].user_max_freq = freq; + } else { + if (cpus[cpu].user_min_freq == freq) + goto set_freq_exit; + + cpus[cpu].user_min_freq = freq; + } + + if (freq_mitigation_task) { + complete(&freq_mitigation_complete); + } else { + pr_err("%s: Frequency mitigation task is not initialized\n", + KBUILD_MODNAME); + ret = -ESRCH; + goto set_freq_exit; + } + +set_freq_exit: + return ret; +} + /* * We will reset the cpu frequencies limits here. The core online/offline * status will be carried over to the process stopping the msm_thermal, as @@ -2097,6 +2143,8 @@ static int probe_freq_mitigation(struct device_node *node, freq_mitigation_enabled = 1; for_each_possible_cpu(cpu) { cpus[cpu].max_freq = false; + cpus[cpu].user_max_freq = UINT_MAX; + cpus[cpu].user_min_freq = 0; cpus[cpu].limited_max_freq = UINT_MAX; cpus[cpu].limited_min_freq = 0; cpus[cpu].freq_thresh_clear = false; @@ -2176,6 +2224,7 @@ static int __devinit msm_thermal_dev_probe(struct platform_device *pdev) msm_thermal_add_vdd_rstr_nodes(); vdd_rstr_nodes_called = false; } + msm_thermal_ioctl_init(); ret = msm_thermal_init(&data); return ret; @@ -2189,6 +2238,7 @@ fail: static int msm_thermal_dev_exit(struct platform_device *inp_dev) { + msm_thermal_ioctl_cleanup(); return 0; } diff --git a/include/linux/Kbuild b/include/linux/Kbuild index f66a03461bc..6d74157716e 100644 --- a/include/linux/Kbuild +++ b/include/linux/Kbuild @@ -453,3 +453,4 @@ header-y += ci-bridge-spi.h header-y += msm_audio_amrwbplus.h header-y += avtimer.h header-y += msm_ipa.h +header-y += msm_thermal_ioctl.h diff --git a/include/linux/msm_thermal.h b/include/linux/msm_thermal.h index 616058d892c..46843dea86d 100644 --- a/include/linux/msm_thermal.h +++ b/include/linux/msm_thermal.h @@ -39,6 +39,8 @@ struct msm_thermal_data { #ifdef CONFIG_THERMAL_MONITOR extern int msm_thermal_init(struct msm_thermal_data *pdata); extern int msm_thermal_device_init(void); +extern int msm_thermal_set_frequency(uint32_t cpu, uint32_t freq, + bool is_max); #else static inline int msm_thermal_init(struct msm_thermal_data *pdata) { @@ -48,6 +50,11 @@ static inline int msm_thermal_device_init(void) { return -ENOSYS; } +static inline int msm_thermal_set_frequency(uint32_t cpu, uint32_t freq, + bool is_max) +{ + return -ENOSYS; +} #endif #endif /*__MSM_THERMAL_H*/ diff --git a/include/linux/msm_thermal_ioctl.h b/include/linux/msm_thermal_ioctl.h new file mode 100644 index 00000000000..7b364934bda --- /dev/null +++ b/include/linux/msm_thermal_ioctl.h @@ -0,0 +1,41 @@ +#ifndef _MSM_THERMAL_IOCTL_H +#define _MSM_THERMAL_IOCTL_H + +#include + +#define MSM_THERMAL_IOCTL_NAME "msm_thermal_query" + +struct __attribute__((__packed__)) cpu_freq_arg { + uint32_t cpu_num; + uint32_t freq_req; +}; + +struct __attribute__((__packed__)) msm_thermal_ioctl { + uint32_t size; + union { + struct cpu_freq_arg cpu_freq; + }; +}; + +enum { + /*Set CPU Frequency*/ + MSM_SET_CPU_MAX_FREQ = 0x00, + MSM_SET_CPU_MIN_FREQ = 0x01, + + MSM_CMD_MAX_NR, +}; + +#define MSM_THERMAL_MAGIC_NUM 0xCA /*Unique magic number*/ + +#define MSM_THERMAL_SET_CPU_MAX_FREQUENCY _IOW(MSM_THERMAL_MAGIC_NUM,\ + MSM_SET_CPU_MAX_FREQ, struct msm_thermal_ioctl) + +#define MSM_THERMAL_SET_CPU_MIN_FREQUENCY _IOW(MSM_THERMAL_MAGIC_NUM,\ + MSM_SET_CPU_MIN_FREQ, struct msm_thermal_ioctl) + +#ifdef __KERNEL__ +extern int msm_thermal_ioctl_init(void); +extern void msm_thermal_ioctl_cleanup(void); +#endif + +#endif