static int _mtk_cl_sd_send_signal(void)
{
int ret = 0;
if (tm_input_pid == 0) {
mtk_cooler_shutdown_dprintk("%s pid is empty\n", __func__);
ret = -1;
}
mtk_cooler_shutdown_dprintk("%s pid is %d, %d\n", __func__, tm_pid, tm_input_pid);
if (ret == 0 && tm_input_pid != tm_pid) {
tm_pid = tm_input_pid;
pg_task = get_pid_task(find_vpid(tm_pid), PIDTYPE_PID);
}
if (ret == 0 && pg_task) {
siginfo_t info;
info.si_signo = SIGIO;
info.si_errno = 0;
info.si_code = 1;
info.si_addr = NULL;
ret = send_sig_info(SIGIO, &info, pg_task);
}
if (ret != 0)
mtk_cooler_shutdown_dprintk("%s ret=%d\n", __func__, ret);
return ret;
}
static int __init mtk_cooler_shutdown_init(void)
{
int err = 0;
int i;
for (i = MAX_NUM_INSTANCE_MTK_COOLER_SHUTDOWN; i-- > 0;) {
cl_shutdown_dev[i] = NULL;
cl_sd_state[i].state = 0;
cl_sd_state[i].sd_cnt = 0;
}
mtk_cooler_shutdown_dprintk("init\n");
#if defined(MTK_COOLER_SHUTDOWN_SIGNAL)
{
struct proc_dir_entry *entry = NULL;
struct proc_dir_entry *dir_entry = mtk_thermal_get_proc_drv_therm_dir_entry();
if (!dir_entry) {
mtk_cooler_shutdown_dprintk("%s mkdir /proc/driver/thermal failed\n",
__func__);
return 0;
}
entry =
proc_create("clsd_pid", S_IRUGO | S_IWUSR | S_IWGRP, dir_entry,
&_cl_sd_pid_fops);
if (!entry)
mtk_cooler_shutdown_dprintk("%s clsd_pid creation failed\n", __func__);
else
proc_set_user(entry, uid, gid);
entry =
proc_create("clsd_rst", S_IRUGO | S_IWUSR | S_IWGRP, dir_entry,
&_cl_sd_rst_fops);
if (!entry)
mtk_cooler_shutdown_dprintk("%s clsd_rst creation failed\n", __func__);
else
proc_set_user(entry, uid, gid);
entry =
proc_create("clsd_dbt", S_IRUGO | S_IWUSR | S_IWGRP, dir_entry,
&_cl_sd_debouncet_fops);
if (!entry)
mtk_cooler_shutdown_dprintk("%s clsd_dbt creation failed\n", __func__);
else
proc_set_user(entry, uid, gid);
}
#endif
err = mtk_cooler_shutdown_register_ltf();
if (err)
goto err_unreg;
return 0;
err_unreg:
mtk_cooler_shutdown_unregister_ltf();
return err;
}
static ssize_t _mtk_cl_sd_rst_write(struct file *filp, const char __user *buf, size_t len,
loff_t *data)
{
int ret = 0;
char tmp[MAX_LEN] = { 0 };
/* write data to the buffer */
if (copy_from_user(tmp, buf, len))
return -EFAULT;
ret = kstrtouint(tmp, 10, &mtk_cl_sd_rst);
if (ret)
WARN_ON(1);
if (1 == mtk_cl_sd_rst) {
int i;
for (i = MAX_NUM_INSTANCE_MTK_COOLER_SHUTDOWN; i-- > 0;) {
cl_sd_state[i].state = 0;
cl_sd_state[i].sd_cnt = 0;
}
mtk_cl_sd_rst = 0;
sd_happened = 0;
/* sd_cnt = 0; */
}
mtk_cooler_shutdown_dprintk("%s %s = %d\n", __func__, tmp, mtk_cl_sd_rst);
return len;
}
static int _mtk_cl_sd_debouncet_read(struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", sd_debouncet);
mtk_cooler_shutdown_dprintk("[%s] %d\n", __func__, sd_debouncet);
return 0;
}
static int _mtk_cl_sd_pid_read(struct seq_file *m, void *v)
{
seq_printf(m, "%d\n", tm_input_pid);
mtk_cooler_shutdown_dprintk("%s %d\n", __func__, tm_input_pid);
return 0;
}
static int
mtk_cl_shutdown_set_cur_state(struct thermal_cooling_device *cdev,
unsigned long state)
{
mtk_cooler_shutdown_dprintk("mtk_cl_shutdown_set_cur_state() %s %d\n", cdev->type, state);
#if 1
*((unsigned long*) cdev->devdata) = state;
#else
cl_shutdown_state[(int) cdev->type[16]] = state;
#endif
if(1 == state)
{
// send uevent to notify current call must be dropped
char event[] = "SHUTDOWN=1";
char *envp[] = { event, NULL };
kobject_uevent_env(&(cdev->device.kobj), KOBJ_CHANGE, envp);
}
#if 0 // unnecessary...only send uevent when needed
else
{
// send uevent to notify no drop call is necessary
char event[] = "SHUTDOWN=0";
char *envp[] = { event, NULL };
kobject_uevent_env(&(cdev->device.kobj), KOBJ_CHANGE, envp);
}
#endif
return 0;
}
static int __init mtk_cooler_shutdown_init(void)
{
int err = 0;
int i;
for (i = MAX_NUM_INSTANCE_MTK_COOLER_SHUTDOWN; i-- > 0; )
{
cl_shutdown_dev[i] = NULL;
cl_shutdown_state[i] = 0;
}
//cl_shutdown_dev = NULL;
mtk_cooler_shutdown_dprintk("init\n");
err = mtk_cooler_shutdown_register_ltf();
if (err)
goto err_unreg;
return 0;
err_unreg:
mtk_cooler_shutdown_unregister_ltf();
return err;
}
static int
mtk_cl_shutdown_get_max_state(struct thermal_cooling_device *cdev,
unsigned long *state)
{
*state = 1;
mtk_cooler_shutdown_dprintk("mtk_cl_shutdown_get_max_state() %s %d\n", cdev->type, *state);
return 0;
}
static int
mtk_cl_shutdown_get_cur_state(struct thermal_cooling_device *cdev,
unsigned long *state)
{
#if 1 // cannot use this way for now since devdata is used by mtk_thermal_monitor
*state = *((unsigned long*) cdev->devdata);
#else
*state = cl_shutdown_state[(int) cdev->type[16]];
#endif
mtk_cooler_shutdown_dprintk("mtk_cl_shutdown_get_cur_state() %s %d\n", cdev->type, *state);
return 0;
}
static ssize_t _mtk_cl_sd_debouncet_write(struct file *filp, const char __user *buf, size_t len,
loff_t *data)
{
char desc[MAX_LEN] = { 0 };
int tmp_dbt = -1;
/* write data to the buffer */
if (copy_from_user(desc, buf, len))
return -EFAULT;
if (kstrtoint(desc, 10, &tmp_dbt) == 0) {
if (tmp_dbt >= 0 && tmp_dbt <= 5)
sd_debouncet = tmp_dbt;
else
mtk_cooler_shutdown_dprintk("[%s] oo range %s = %d\n", __func__, desc, sd_debouncet);
} else {
mtk_cooler_shutdown_dprintk("[%s] bad arg %s = %d\n", __func__, desc, sd_debouncet);
}
mtk_cooler_shutdown_dprintk("[%s] %s = %d\n", __func__, desc, sd_debouncet);
return len;
}
static void mtk_cooler_shutdown_unregister_ltf(void)
{
int i;
mtk_cooler_shutdown_dprintk("unregister ltf\n");
for (i = MAX_NUM_INSTANCE_MTK_COOLER_SHUTDOWN; i-- > 0;) {
if (cl_shutdown_dev[i]) {
mtk_thermal_cooling_device_unregister(cl_shutdown_dev[i]);
cl_shutdown_dev[i] = NULL;
cl_sd_state[i].state = 0;
cl_sd_state[i].sd_cnt = 0;
}
}
}
static int mtk_cooler_shutdown_register_ltf(void)
{
int i;
mtk_cooler_shutdown_dprintk("register ltf\n");
for (i = MAX_NUM_INSTANCE_MTK_COOLER_SHUTDOWN; i-- > 0; )
{
char temp[20] = {0};
sprintf(temp, "mtk-cl-shutdown%02d", i);
cl_shutdown_dev[i] = mtk_thermal_cooling_device_register(temp,
(void*) &cl_shutdown_state[i],
&mtk_cl_shutdown_ops);
}
return 0;
}
static ssize_t _mtk_cl_sd_pid_write(struct file *filp, const char __user *buf, size_t len,
loff_t *data)
{
int ret = 0;
char tmp[MAX_LEN] = { 0 };
/* write data to the buffer */
if (copy_from_user(tmp, buf, len))
return -EFAULT;
ret = kstrtouint(tmp, 10, &tm_input_pid);
if (ret)
WARN_ON(1);
mtk_cooler_shutdown_dprintk("%s %s = %d\n", __func__, tmp, tm_input_pid);
return len;
}
static void __exit mtk_cooler_shutdown_exit(void)
{
mtk_cooler_shutdown_dprintk("exit\n");
mtk_cooler_shutdown_unregister_ltf();
}
static int __init mtk_cooler_shutdown_init(void)
{
int err = 0;
int i;
for (i = MAX_NUM_INSTANCE_MTK_COOLER_SHUTDOWN; i-- > 0; )
{
cl_shutdown_dev[i] = NULL;
cl_shutdown_state[i] = 0;
}
mtk_cooler_shutdown_dprintk("init\n");
#if defined(MTK_COOLER_SHUTDOWN_SIGNAL)
{
struct proc_dir_entry *entry;
#if 0
entry = create_proc_entry("driver/mtk_cl_sd_pid", S_IRUGO | S_IWUSR, NULL);
if (NULL != entry)
{
entry->read_proc = _mtk_cl_sd_pid_read;
entry->write_proc = _mtk_cl_sd_pid_write;
}
#endif
entry = proc_create("driver/mtk_cl_sd_pid", S_IRUGO | S_IWUSR | S_IWGRP, NULL, &_cl_sd_pid_fops);
if (!entry)
{
xlog_printk(ANDROID_LOG_DEBUG, "thermal/cooler/shutdown", "mtk_cooler_shutdown_init driver/mtk_cl_sd_pid creation failed\n");
}
else
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)
proc_set_user(entry, 0, 1000);
#else
entry->gid = 1000;
#endif
}
}
{
struct proc_dir_entry *entry;
#if 0
entry = create_proc_entry("driver/mtk_cl_sd_rst", S_IRUGO | S_IWUSR | S_IWGRP, NULL);
if (NULL != entry)
{
entry->write_proc = _mtk_cl_sd_rst_write;
entry->gid = 1000;
}
#endif
entry = proc_create("driver/mtk_cl_sd_rst", S_IRUGO | S_IWUSR | S_IWGRP, NULL, &_cl_sd_rst_fops);
if (!entry)
{
xlog_printk(ANDROID_LOG_DEBUG, "thermal/cooler/shutdown", "mtk_cooler_shutdown_init driver/mtk_cl_sd_rst creation failed\n");
}
else
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)
proc_set_user(entry, 0, 1000);
#else
entry->gid = 1000;
#endif
}
}
{
struct proc_dir_entry *entry;
entry = proc_create("driver/mtk_cl_sd_dbt", S_IRUGO | S_IWUSR | S_IWGRP, NULL, &_cl_sd_debouncet_fops);
if (!entry)
{
xlog_printk(ANDROID_LOG_DEBUG, "thermal/cooler/shutdown", "mtk_cooler_shutdown_init driver/mtk_cl_sd_dbt creation failed\n");
}
else
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)
proc_set_user(entry, 0, 1000);
#else
entry->gid = 1000;
#endif
}
}
#endif
err = mtk_cooler_shutdown_register_ltf();
if (err)
goto err_unreg;
return 0;
err_unreg:
mtk_cooler_shutdown_unregister_ltf();
return err;
}
