static int mtk_cooler_amutt_register_ltf(void)
{
mtk_cooler_amutt_dprintk("[%s]\n", __func__);
cl_upper_dev = mtk_thermal_cooling_device_register("cl-amutt-upper", NULL,
&amutt_cooler_upper_ops);
cl_lower_dev = mtk_thermal_cooling_device_register("cl-amutt-lower", NULL,
&amutt_cooler_lower_ops);
return 0;
}
int mtktspa_register_cooler(void)
{
/* cooling devices */
cl_dev_sysrst = mtk_thermal_cooling_device_register("mtktspa-sysrst", NULL,
&mtktspa_cooling_sysrst_ops);
return 0;
}
int mtktscpu_register_DVFS_hotplug_cooler(void)
{
mtktscpu_dprintk("[mtktscpu_register_DVFS_hotplug_cooler] \n");
cl_dev_sysrst = mtk_thermal_cooling_device_register("mtktscpu-sysrst", NULL,
&mtktscpu_cooling_sysrst_ops);
return 0;
}
static int mtk_cooler_dropcall_register_ltf(void)
{
mtk_cooler_dropcall_dprintk("register ltf\n");
cl_dropcall_dev = mtk_thermal_cooling_device_register("mtk-cooler-dropcall",
NULL,
&mtk_cl_dropcall_ops);
return 0;
}
int mtkts6311_register_cooler(void)
{
cl_dev_sysrst = mtk_thermal_cooling_device_register("mtkts6311-sysrst", NULL,
&mtkts6311_cooling_sysrst_ops);
/*
cl_dev_6311 = mtk_thermal_cooling_device_register("cpu01", NULL,
&mtktscpu_cooler_cpu_ops);
*/
return 0;
}
static int mtk_cooler_kshutdown_register_ltf(void)
{
int i;
mtk_cooler_kshutdown_dprintk("register ltf\n");
for (i = MAX_NUM_INSTANCE_MTK_COOLER_KSHUTDOWN; i-- > 0;) {
char temp[20] = { 0 };
sprintf(temp, "mtk-cl-kshutdown%02d", i);
cl_kshutdown_dev[i] = mtk_thermal_cooling_device_register(temp,
(void *)
&cl_kshutdown_state[i],
&mtk_cl_kshutdown_ops);
}
#if 0
cl_kshutdown_dev = mtk_thermal_cooling_device_register("mtk-cl-shutdown",
NULL, &mtk_cl_kshutdown_ops);
#endif
return 0;
}
static int mtk_cooler_fps_register_ltf(void)
{
int i;
mtk_cooler_fps_dprintk("register ltf\n");
for (i = MAX_NUM_INSTANCE_MTK_COOLER_FPS; i-- > 0; ) {
char temp[20] = { 0 };
sprintf(temp, "mtk-cl-fps%02d", i);
/* put fps state to cooler devdata */
cl_fps_dev[i] = mtk_thermal_cooling_device_register(temp, (void *) &cl_fps_state[i],
&mtk_cl_fps_ops);
}
#if ADAPTIVE_FPS_COOLER
cl_adp_fps_dev = mtk_thermal_cooling_device_register("mtk-cl-adp-fps", NULL,
&mtk_cl_adp_fps_ops);
#endif
return 0;
}
static int mtk_cooler_vrt_register_ltf(void)
{
int i;
mtk_cooler_vrt_dprintk("register ltf\n");
for (i = MAX_NUM_INSTANCE_MTK_COOLER_VRT; i-- > 0;) {
char temp[20] = { 0 };
sprintf(temp, "mtk-cl-vrt%02d", i);
cl_vrt_dev[i] = mtk_thermal_cooling_device_register(temp,
(void *)&cl_vrt_state[i],
&mtk_cl_vrt_ops);
}
return 0;
}
static int mtk_cooler_mddtxpwr_register_ltf(void)
{
int i;
mtk_cooler_mddtxpwr_dprintk("register ltf\n");
for (i = MAX_NUM_INSTANCE_MTK_COOLER_MDDTXPWR; i-- > 0; )
{
char temp[20] = {0};
sprintf(temp, "mtk-cl-mddtxpwr%02d", i);
cl_mddtxpwr_dev[i] = mtk_thermal_cooling_device_register(temp,
(void*) &cl_mddtxpwr_state[i], // put mddtxpwr state to cooler devdata
&mtk_cl_mddtxpwr_ops);
}
return 0;
}
static int mtk_cooler_backlight_register_ltf(void)
{
int i;
mtk_cooler_backlight_dprintk("register ltf\n");
for (i = 0; i < BACKLIGHT_COOLER_NR; i++) {
char temp[20] = { 0 };
sprintf(temp, "mtk-cl-backlight%02d", i + 1); /* /< Cooler Name: mtk-cl-backlight01 */
g_cl_id[i] = i;
cl_backlight_dev[i] = mtk_thermal_cooling_device_register(temp, (void *)&g_cl_id[i], /* /< 0, 1, 2 ... */
&mtk_cl_backlight_ops);
}
return 0;
}
static int mtk_cooler_bcct_register_ltf(void)
{
int i;
mtk_cooler_bcct_dprintk("register ltf\n");
for (i = MAX_NUM_INSTANCE_MTK_COOLER_BCCT; i-- > 0;) {
char temp[20] = { 0 };
sprintf(temp, "mtk-cl-bcct%02d", i);
/* put bcct state to cooler devdata */
cl_bcct_dev[i] = mtk_thermal_cooling_device_register(temp, (void *)&cl_bcct_state[i],
&mtk_cl_bcct_ops);
}
return 0;
}
static int mtk_cooler_tm_nth_register_ltf(void)
{
#if 0 // nth is not a cooler for now
int i;
mtk_cooler_tm_nth_dprintk("register ltf\n");
for (i = MAX_NUM_INSTANCE_MTK_COOLER_TM_NTH; i-- > 0; )
{
char temp[20] = {0};
sprintf(temp, "mtk-cl-tm_nth%02d", i);
cl_tm_nth_dev[i] = mtk_thermal_cooling_device_register(temp,
(void*) &cl_tm_nth_state[i], // put tm_nth state to cooler devdata
&mtk_cl_tm_nth_ops);
}
#endif
return 0;
}
static ssize_t mtktscpu_cooler_write(struct file *file, const char *buffer, unsigned long count, void *data)
{
int len;
unsigned int cooler_cnt;
char desc[512];
unsigned int cooler_value[CPU_COOLER_COUNT];
int i;
bool is_pass = 0;
len = (count < (sizeof(desc) - 1)) ? count : (sizeof(desc) - 1);
if (copy_from_user(desc, buffer, len))
{
return 0;
}
desc[len] = '\0';
len = sscanf(desc, "%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d",
&cooler_cnt,
&cooler_value[0],&cooler_value[1],&cooler_value[2], &cooler_value[3],&cooler_value[4],
&cooler_value[5],&cooler_value[6],&cooler_value[7], &cooler_value[8],&cooler_value[9],
&cooler_value[10],&cooler_value[11],&cooler_value[12], &cooler_value[13],&cooler_value[14]);
if((len > 1) && (cooler_cnt == (len -1)))
{
if(cooler_cnt <= CPU_COOLER_COUNT)
{
for(i=0; i<cooler_cnt; i++)
{
if (!((cooler_value[i] > 0) && (cooler_value[i] < 10000)))
break;
}
is_pass = 1;
}
}
if(is_pass == 1)
{
for(i=0; i<CPU_COOLER_COUNT; i++)
{
if(mtk_cl_dev[i].cl_dev)
{
mtk_thermal_cooling_device_unregister(mtk_cl_dev[i].cl_dev);
mtk_cl_dev[i].cl_dev = NULL;
}
}
for(i=0; i<cooler_cnt; i++)
{
mtk_cl_dev[i].cl_limit = cooler_value[i];
sprintf(mtk_cl_dev[i].cooler_name,"%d", cooler_value[i]);
mtk_cl_dev[i].cl_dev = mtk_thermal_cooling_device_register(mtk_cl_dev[i].cooler_name, &mtk_cl_dev[i],
&mtktscpu_cooling_ops);
}
cl_dvfs_cooler_cnt = cooler_cnt;
return count;
}
else
{
mtktscpu_dprintk("[mtktscpu_write] bad argument\n");
}
return -EINVAL;
}
