Initial file dump from open source releaseHEADmaster

1 files changed, 681 insertions, 0 deletions

diff --git a/drivers/thermal/sprd_ddie_thm.c b/drivers/thermal/sprd_ddie_thm.c
new file mode 100644
index 00000000..269bda77
--- /dev/null
+++ b/drivers/thermal/sprd_ddie_thm.c
@@ -0,0 +1,681 @@
+/*
+ * Copyright (C) 2013 Spreadtrum Communications Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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 <linux/kernel.h>
+#include <linux/err.h>
+#include <soc/sprd/sci.h>
+#include <soc/sprd/sci_glb_regs.h>
+#include <linux/io.h>
+#include <soc/sprd/adi.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/err.h>
+#include<linux/string.h>
+#include <soc/sprd/arch_misc.h>
+#include <soc/sprd/hardware.h>
+#include <linux/thermal.h>
+#include <linux/sprd_thm.h>
+#include "thm.h"
+
+#ifdef CONFIG_OF
+#include <linux/slab.h>
+#include <linux/of_device.h>
+#include <linux/of_irq.h>
+#endif
+
+#define THM_SENOR_NUM 8
+#define SPRD_THM_DEBUG
+#ifdef SPRD_THM_DEBUG
+#define THM_DEBUG(format, arg...) printk( "sprd thm: " "@@@" format, ## arg)
+#else
+#define THM_DEBUG(format, arg...)
+#endif
+
+#define THM_CTRL            (0x0000)
+#define THM_INT_CTRL       (0x0004)
+#define SENSOR_CTRL         (0x0020)
+#define SENSOR_DET_PERI     (0x0024)
+#define SENSOR_INT_CTRL     (0x0028)
+#define SENSOR_INT_STS      (0x002C)
+#define SENSOR_INT_RAW_STS      (0x0030)
+#define SENSOR_INT_CLR      (0x0034)
+#define SENSOR_OVERHEAT_THRES   (0X0040)
+#define SENSOR_HOT_THRES   (0X0044)
+#define SENSOR_HOT2NOR_THRES   (0X0048)
+#define SENSOR_HIGHOFF_THRES   (0X004C)
+#define SENSOR_LOWOFF_THRES (0X0050)
+#define SENSOR_MON_PERI		(0X0058)
+#define SENSOR_MON_CTL		(0X005c)
+#define SENSOR_TEMPER0_READ	(0x0060)
+#define SENSOR_READ_STATUS	(0x0070)
+
+
+#define A_SEN_OVERHEAT_INT_BIT (1 << 5)
+#define A_SEN_HOT_INT_BIT      (1 << 4)
+#define A_SEN_HOT2NOR_INT_BIT  (1 << 3)
+#define A_SEN_HIGHOFF_BIT  (1 << 2)
+#define A_SEN_LOWOFF_INT_BIT  (1 << 1)
+
+#define A_RAW_TEMP_OFFSET 8
+#define A_RAW_TEMP_RANGE_MSK  0x7F
+
+#define A_HIGH_BITS_OFFSET   4
+
+#define A_HIGH_TAB_SZ 8
+#define A_LOW_TAB_SZ  16
+
+#define A_HOT2NOR_RANGE   15
+#define A_LOCAL_SENSOR_ADDR_OFF 0x100
+#define A_DELAY_TEMPERATURE 3
+#define INTOFFSET 3
+
+#define A_TSMC_DOLPHINW4T_CHIP_ID_1  0x7715A001
+#define A_TSMC_DOLPHINW4T_CHIP_ID_2  0x7715A003
+#define A_TSMC_DOLPHINWT4T_CHIP_ID_1 0x8815A001
+
+static const short a_temp_search_high_152nm[A_HIGH_TAB_SZ] =
+    { -56, -29, -2, 26, 53, 79, 106, 133 };
+static const short a_temp_search_low_152nm[A_LOW_TAB_SZ] =
+    { 0, 2, 3, 5, 7, 8, 10, 11, 13, 15, 17, 18, 20, 21, 23, 25 };
+
+#define SEN_OVERHEAT_INT_BIT (1 << 5)
+#define SEN_HOT_INT_BIT      (1 << 4)
+#define SEN_HOT2NOR_INT_BIT  (1 << 3)
+#define SEN_HIGHOFF_BIT  (1 << 2)
+#define SEN_LOWOFF_INT_BIT  (1 << 1)
+#define SEN_OVERHEAT_ALARM_EN (1 << 7)
+#define SEN0_OVERHEAT_ALARM_EN (1 << 8)
+
+
+#define RAW_TEMP_RANGE_MSK  0x3FFF
+#define RAW_READ_RANGE_MSK  0x7FFF
+
+#define HIGH_BITS_OFFSET   4
+
+#define HOT2NOR_RANGE   15
+#define LOCAL_SENSOR_ADDR_OFF  0x100
+#define DELAY_TEMPERATURE 3
+
+#define LOCAL_THM_ADDR_OFF  0x200
+
+
+#define SEN_DET_PRECISION  (0x50)
+
+#define TSMC_DOLPHINW4T_CHIP_ID_1  0x7715A001
+#define TSMC_DOLPHINW4T_CHIP_ID_2  0x7715A003
+#define TSMC_DOLPHINWT4T_CHIP_ID_1 0x8815A001
+
+#define TEMP_TO_RAM_DEGREE 8
+#define TEMP_LOW         (-40000)
+#define TEMP_HIGH        (120000)
+#ifdef CONFIG_ARCH_SCX20
+#define RAW_DATA_LOW         (627)
+#define RAW_DATA_HIGH        (1075)
+#else
+#define RAW_DATA_LOW         (623)
+#define RAW_DATA_HIGH        (1030)
+#endif
+#define  CRITIC_TEMP	80000
+
+#define RAW_ADC_LOW         (550)
+#define RAW_ADC_HIGH        (1200)
+
+//static const u32 temp_to_raw[TEMP_TO_RAM_DEGREE + 1] = { RAW_DATA_LOW, 676, 725, 777, 828, 878, 928, 980,RAW_DATA_HIGH };
+
+unsigned long SPRD_THM_BASE = 0;
+unsigned int SPRD_THM_SIZE = 0;
+extern int sprd_thermal_init(struct sprd_thermal_zone *pzone);
+extern void sprd_thermal_remove(struct sprd_thermal_zone *pzone);
+
+static inline void __thm_reg_write(unsigned long reg, u16 bits, u16 clear_msk);
+static inline u32 __thm_reg_read(unsigned long reg);
+int sprd_thm_set_active_trip(struct sprd_thermal_zone *pzone, int trip );
+u32 sprd_thm_temp2rawdata( int temp);
+
+static inline void __thm_reg_write(unsigned long reg, u16 bits, u16 clear_msk)
+{
+		__raw_writel(((__raw_readl((volatile void *)reg) & ~clear_msk) | bits), ((volatile void *)reg));
+}
+
+static inline u32 __thm_reg_read(unsigned long reg)
+{
+		return __raw_readl((volatile void *)reg);
+}
+
+u32 sprd_thm_temp2rawdata( int temp)
+{
+	u32 raw_result;
+	 if ((temp < TEMP_LOW) || (temp > TEMP_HIGH))
+		return 0;
+	 raw_result = RAW_DATA_LOW +
+	 	(temp - TEMP_LOW) * (RAW_DATA_HIGH - RAW_DATA_LOW) / (TEMP_HIGH - TEMP_LOW);
+
+	return raw_result;
+}
+
+int sprd_thm_rawdata2temp( int rawdata)
+{
+	int temp_result;
+	if ((rawdata < RAW_ADC_LOW) || (rawdata > RAW_ADC_HIGH))
+		return 0;
+	temp_result = TEMP_LOW +
+		(rawdata - RAW_DATA_LOW) * (TEMP_HIGH - TEMP_LOW) / (RAW_DATA_HIGH - RAW_DATA_LOW);
+
+	return temp_result;
+}
+
+static unsigned long sprd_thm_temp_read(struct sprd_thermal_zone *pzone)
+{
+	u32 rawdata = 0;
+	int cal_offset = 0;
+	u32 sensor = pzone->sensor_id, local_sen_id = 0;
+	unsigned long  local_sensor_addr;
+	unsigned long  temp;
+	if(pzone->sensor_id == SPRD_GPU_SENSOR)
+			local_sen_id = 1;
+	local_sensor_addr = pzone->reg_base + local_sen_id * LOCAL_SENSOR_ADDR_OFF;
+	rawdata = __thm_reg_read(local_sensor_addr + SENSOR_TEMPER0_READ);
+	rawdata = rawdata & RAW_READ_RANGE_MSK;
+	cal_offset = pzone->thm_cal;
+	temp = sprd_thm_rawdata2temp( rawdata) -cal_offset;
+	printk("sensor id:%d, rawdata:0x%x, temp:%lu\n", sensor, rawdata,temp);
+	return temp;
+
+}
+
+
+#ifdef THM_TEST
+static int sprd_thm_regs_read(struct sprd_thermal_zone *pzone,unsigned int *regs)
+{
+	unsigned long base_addr = 0;
+	printk(" sprd_thm_regs_read\n");
+	if(pzone->sensor_id == SPRD_ARM_SENSOR){
+		base_addr = (unsigned long) pzone->reg_base;
+		*regs =  __thm_reg_read((base_addr + SENSOR_DET_PERI));
+		*(regs + 1) =  __thm_reg_read((base_addr + SENSOR_MON_CTL));
+		*(regs + 2) =  __thm_reg_read((base_addr + SENSOR_MON_PERI));
+		*(regs + 3) =  __thm_reg_read((base_addr + SENSOR_CTRL));
+	}
+	return 0;
+}
+
+static int sprd_thm_regs_set(struct sprd_thermal_zone *pzone,unsigned int*regs)
+{
+	u32 pre_data[4] = {0};
+	unsigned long  gpu_sensor_addr,base_addr;
+	gpu_sensor_addr =
+	    (unsigned long ) pzone->reg_base +LOCAL_SENSOR_ADDR_OFF;
+	printk("sprd_thm_regs_set\n");
+	base_addr = (unsigned long) pzone->reg_base;
+	pre_data[0] = __thm_reg_read(base_addr + SENSOR_DET_PERI);
+	pre_data[1] = __thm_reg_read(base_addr + SENSOR_MON_CTL);
+	pre_data[2] = __thm_reg_read(base_addr + SENSOR_MON_PERI);
+	pre_data[3] = __thm_reg_read(base_addr + SENSOR_CTRL);
+	__thm_reg_write((base_addr + SENSOR_CTRL), 0x00, 0x01);
+	__thm_reg_write((base_addr+ SENSOR_CTRL), 0x8, 0x08);
+	__thm_reg_write((base_addr + SENSOR_DET_PERI), regs[0], pre_data[0]);
+	__thm_reg_write((base_addr + SENSOR_MON_CTL), regs[1], pre_data[1]);
+	__thm_reg_write((base_addr + SENSOR_MON_PERI), regs[2], pre_data[2] |0x100 );
+	__thm_reg_write((base_addr + SENSOR_CTRL), regs[3], pre_data[3]);
+	__thm_reg_write((base_addr + SENSOR_CTRL), 0x8, 0x8);
+
+	pre_data[0] = __thm_reg_read(gpu_sensor_addr + SENSOR_DET_PERI);
+	pre_data[1] = __thm_reg_read(gpu_sensor_addr + SENSOR_MON_CTL);
+	pre_data[2] = __thm_reg_read(gpu_sensor_addr + SENSOR_MON_PERI);
+	pre_data[3] = __thm_reg_read(gpu_sensor_addr + SENSOR_CTRL);
+	__thm_reg_write((gpu_sensor_addr + SENSOR_CTRL), 0x00, 0x01);
+	__thm_reg_write((gpu_sensor_addr+ SENSOR_CTRL), 0x8, 0x08);	
+	__thm_reg_write((gpu_sensor_addr + SENSOR_DET_PERI), regs[0], pre_data[0]);
+	__thm_reg_write((gpu_sensor_addr + SENSOR_MON_CTL), regs[1], pre_data[1]);
+	__thm_reg_write((gpu_sensor_addr + SENSOR_MON_PERI), regs[2], pre_data[2] |0x100 );
+	__thm_reg_write((gpu_sensor_addr + SENSOR_CTRL), regs[3], pre_data[3]);
+	__thm_reg_write((gpu_sensor_addr + SENSOR_CTRL), 0x8, 0x8);
+	return 0;
+}
+
+static int sprd_thm_trip_set(struct sprd_thermal_zone *pzone,int trip)
+{
+	THM_DEBUG("sprd_thm_trip_set trip=%d, temp=%ld,lowoff =%ld\n",
+		trip,pzone->trip_tab->trip_points[trip].temp,pzone->trip_tab->trip_points[trip].lowoff);
+	return 0;
+}
+
+#endif
+
+int sprd_thm_get_trend(struct sprd_thermal_zone *pzone, int trip, enum thermal_trend *ptrend)
+{
+	*ptrend = pzone->trend_val;
+	return 0;
+}
+
+int sprd_thm_get_hyst(struct sprd_thermal_zone *pzone, int trip, unsigned long *physt)
+{
+
+	struct sprd_thm_platform_data *trip_tab = pzone->trip_tab;
+	if (trip >= trip_tab->num_trips - 2){
+	*physt = 0;
+	}else{
+	*physt = trip_tab->trip_points[trip].temp - trip_tab->trip_points[trip + 1].lowoff;
+	}
+	return 0;
+}
+
+int init_flag=0;
+
+static int sprd_thm_hw_init(struct sprd_thermal_zone *pzone)
+{
+	unsigned long  local_sensor_addr, base_addr = 0;
+	u32 local_sen_id = 0;
+	u32 raw_temp = 0;
+	int ret = 0;
+	int i;
+	struct sprd_thm_platform_data *trip_tab = pzone->trip_tab;
+	ret = sci_efuse_thermal_cal_get(&pzone->thm_cal) ;
+	THM_DEBUG("arm_sen_cal_offset =%d,ret =%d\n",pzone->thm_cal,ret);
+	if(pzone->sensor_id == SPRD_GPU_SENSOR)
+			local_sen_id = 1;
+	base_addr = (unsigned long) pzone->reg_base ;
+	local_sensor_addr = base_addr + local_sen_id * LOCAL_SENSOR_ADDR_OFF;
+
+	printk(KERN_NOTICE "sprd_thm_hw_init 2713s_thm id:%d,base 0x%lx \n",
+		pzone->sensor_id, base_addr);
+	if(init_flag ==0)
+		{
+			sci_glb_set(REG_AON_APB_APB_EB1, BIT_THM_EB);
+			sci_glb_set(REG_AON_APB_APB_RTC_EB,
+			(BIT_THM_RTC_EB | BIT_GPU_THMA_RTC_EB |
+			BIT_GPU_THMA_RTC_AUTO_EN | BIT_ARM_THMA_RTC_EB |BIT_ARM_THMA_RTC_AUTO_EN ) );
+			sci_glb_set(REG_AON_APB_APB_RST1,BIT_THM_SOFT_RST);
+			for(i=0; i < 10000; i++);
+			sci_glb_clr(REG_AON_APB_APB_RST1,BIT_THM_SOFT_RST);
+			__thm_reg_write((base_addr + THM_CTRL), 0x3, 0);
+			__thm_reg_write((base_addr + THM_INT_CTRL), 0x1, 0);
+			init_flag =1;
+		}
+			__thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), 0, ~0);	//disable all int
+			__thm_reg_write((local_sensor_addr + SENSOR_INT_CLR), ~0, 0);	//clr all int
+#if 0
+	if (SPRD_ARM_SENSOR== pzone->sensor_id){
+		if (trip_tab->trip_points[trip_tab->num_trips - 1].type ==
+			THERMAL_TRIP_CRITICAL) {
+			raw_temp =
+			sprd_thm_temp2rawdata( trip_tab->trip_points[trip_tab->num_trips - 1].temp - cal_offset);
+			}
+//		raw_temp = sprd_thm_temp2rawdata(CRITIC_TEMP - cal_offset);
+		__thm_reg_write((local_sensor_addr + SENSOR_OVERHEAT_THRES),raw_temp, RAW_TEMP_RANGE_MSK);//set overheat  temp value
+		__thm_reg_write((base_addr + THM_INT_CTRL), SEN0_OVERHEAT_ALARM_EN, 0);
+		__thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL),SEN_OVERHEAT_ALARM_EN, 0);
+	}
+#endif
+	printk(KERN_NOTICE "sprd_thm_hw_init addr 0x:%lx,int ctrl 0x%x\n",
+			local_sensor_addr,
+			__thm_reg_read((local_sensor_addr + SENSOR_INT_CTRL)));
+
+	__thm_reg_write((local_sensor_addr + SENSOR_DET_PERI), 0x4000, 0x4000);
+	__thm_reg_write((local_sensor_addr + SENSOR_MON_CTL), 0x21, 0X21);
+	__thm_reg_write((local_sensor_addr + SENSOR_MON_PERI), 0x400, 0x100);
+	if (SPRD_ARM_SENSOR== pzone->sensor_id)
+		__thm_reg_write((base_addr + SENSOR_CTRL + LOCAL_SENSOR_ADDR_OFF), 0x030, 0x030);
+	__thm_reg_write((local_sensor_addr + SENSOR_CTRL), 0x39, 0x030);
+	return 0;
+}
+
+int sprd_thm_hw_disable_sensor(struct sprd_thermal_zone *pzone)
+{
+	int ret = 0;
+	/* Sensor minitor disable */
+	if (SPRD_ARM_SENSOR == pzone->sensor_id) {
+		/*__thm_reg_write((u32)(pzone->reg_base + SENSOR_CTRL), 0x00, 0x01);*/
+		__thm_reg_write((pzone->reg_base + SENSOR_CTRL), 0x8, 0x01);
+	} else if (SPRD_GPU_SENSOR == pzone->sensor_id) {
+		/*__thm_reg_write((u32)(pzone->reg_base + SENSOR_CTRL+ LOCAL_SENSOR_ADDR_OFF), 0x00, 0x01);*/
+		__thm_reg_write((pzone->reg_base + SENSOR_CTRL + LOCAL_SENSOR_ADDR_OFF), 0x8, 0x01);
+	} else {
+		THM_DEBUG("the sensor id is error \n");
+	}
+	return ret;
+}
+
+int sprd_thm_hw_enable_sensor(struct sprd_thermal_zone *pzone)
+{
+	int ret = 0;
+	// Sensor minitor enable
+	THM_DEBUG("sprd_2713S_thm enable sensor sensor_ID:0x%x \n",pzone->sensor_id);
+	if (SPRD_ARM_SENSOR == pzone->sensor_id) {
+		sci_glb_set(REG_AON_APB_APB_RTC_EB,
+				(BIT_THM_RTC_EB | BIT_GPU_THMA_RTC_EB |
+				BIT_GPU_THMA_RTC_AUTO_EN | BIT_ARM_THMA_RTC_EB | BIT_ARM_THMA_RTC_AUTO_EN));
+		__thm_reg_write((pzone->reg_base + SENSOR_CTRL + LOCAL_SENSOR_ADDR_OFF), 0x030, 0x0);
+		__thm_reg_write((pzone->reg_base + SENSOR_CTRL), 0x31, 0x0);
+	} else if (SPRD_GPU_SENSOR == pzone->sensor_id) {
+		/*sci_glb_set(REG_AON_APB_APB_RTC_EB,
+				(BIT_THM_RTC_EB | BIT_GPU_THMA_RTC_EB |
+				BIT_GPU_THMA_RTC_AUTO_EN | BIT_ARM_THMA_RTC_EB |BIT_ARM_THMA_RTC_AUTO_EN ) );*/
+		__thm_reg_write((pzone->reg_base + SENSOR_CTRL+LOCAL_SENSOR_ADDR_OFF), 0x31, 0x0);
+	} else {
+		THM_DEBUG("the sensor id is error \n");
+	}
+
+	return ret;
+}
+
+
+u16 int_ctrl_reg[SPRD_MAX_SENSOR];
+int sprd_thm_hw_suspend(struct sprd_thermal_zone *pzone)
+{
+	unsigned long local_sensor_addr;
+	int ret = 0;
+
+	local_sensor_addr = pzone->reg_base ;
+	/*int_ctrl_reg[pzone->sensor_id] = __thm_reg_read((local_sensor_addr + SENSOR_INT_CTRL));*/
+
+	sprd_thm_hw_disable_sensor(pzone);
+	if (SPRD_ARM_SENSOR == pzone->sensor_id) {
+		int_ctrl_reg[pzone->sensor_id] = __thm_reg_read((local_sensor_addr + SENSOR_INT_CTRL));
+		__thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), 0, ~0);	//disable all int
+		__thm_reg_write((local_sensor_addr + SENSOR_INT_CLR), ~0, 0);	//clr all int
+
+	} else if (SPRD_GPU_SENSOR == pzone->sensor_id) {
+		int_ctrl_reg[pzone->sensor_id] =
+			__thm_reg_read((local_sensor_addr + SENSOR_INT_CTRL+LOCAL_SENSOR_ADDR_OFF));
+		__thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL+LOCAL_SENSOR_ADDR_OFF), 0, ~0);	/*disable all int*/
+		__thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL+LOCAL_SENSOR_ADDR_OFF), ~0, 0);	/*clr all int*/
+
+	} else {
+		THM_DEBUG("the sensor id is error \n");
+	}
+	return ret;
+}
+int sprd_thm_hw_resume(struct sprd_thermal_zone *pzone)
+{
+	unsigned long local_sensor_addr;
+	int ret = 0;
+
+	local_sensor_addr = pzone->reg_base ;
+
+	sprd_thm_hw_enable_sensor(pzone);
+	if (SPRD_ARM_SENSOR == pzone->sensor_id) {
+		__thm_reg_write((local_sensor_addr + SENSOR_INT_CLR), ~0, 0);	//clr all int
+		__thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), int_ctrl_reg[pzone->sensor_id], ~0);	//enable int of saved
+		__thm_reg_write((local_sensor_addr + SENSOR_CTRL+LOCAL_SENSOR_ADDR_OFF), 0x30, 0);
+		__thm_reg_write((local_sensor_addr + SENSOR_CTRL), 0x39, 0);
+	} else if (SPRD_GPU_SENSOR == pzone->sensor_id) {
+		__thm_reg_write((local_sensor_addr + SENSOR_INT_CLR+LOCAL_SENSOR_ADDR_OFF), ~0, 0);	/*clr all int*/
+		__thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL+LOCAL_SENSOR_ADDR_OFF), int_ctrl_reg[pzone->sensor_id], ~0);	/*enable int of saved*/
+		__thm_reg_write((local_sensor_addr + SENSOR_CTRL+LOCAL_SENSOR_ADDR_OFF), 0x39, 0);
+	} else {
+		THM_DEBUG("the sensor id is error \n");
+	}
+	return ret;
+}
+
+struct thm_handle_ops sprd_ddie_ops =
+{
+		.hw_init = sprd_thm_hw_init,
+		.read_temp = sprd_thm_temp_read,
+		.get_trend = sprd_thm_get_trend,
+		.get_hyst = sprd_thm_get_hyst,
+		.suspend = sprd_thm_hw_suspend,
+		.resume = sprd_thm_hw_resume,
+		.trip_debug_set = sprd_thm_trip_set,
+		.reg_debug_get = sprd_thm_regs_read,
+		.reg_debug_set = sprd_thm_regs_set,
+};
+
+#ifdef CONFIG_OF
+static struct sprd_thm *thermal_detect_parse_dt(
+                         struct device *dev)
+{
+	struct sprd_thm_platform_data *pdata;
+	struct sprd_thm *thm_data;
+	struct device_node *np = dev->of_node,*sensor_child = NULL;
+	int nsensor,sensor_id;
+	int ret;
+	u32 trip_points_critical,trip_num;
+	int i = 0,j = 0,temp_interval;
+	char prop_name[32];
+	const char *tmp_str;
+	const char *thm_name;
+	u32 tmp_data,tmp_lowoff;
+	nsensor = of_get_child_count(np);
+	if (nsensor == 0) {
+		dev_err(dev, "fail to get child node \n");
+		goto fail;
+	}
+	printk("the nubutton %d\n",nsensor);
+	thm_data = kzalloc(sizeof(*thm_data), GFP_KERNEL);
+	if (!thm_data) {
+		dev_err(dev, "could not allocate memory for platform sprd_thm\n");
+		return NULL;
+	}
+	thm_data->nsensor = nsensor;
+	pdata = kzalloc(thm_data->nsensor*sizeof(*pdata), GFP_KERNEL);
+	if (!pdata) {
+		dev_err(dev, "could not allocate memory for platform data\n");
+		goto fail;
+	}
+	thm_data->sprd_data = pdata;
+	for_each_child_of_node(np,sensor_child) {
+	ret = of_property_read_u32(sensor_child, "trip-points-critical", &trip_points_critical);
+	if(ret){
+		dev_err(dev, "fail to get trip_points_critical\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(sensor_child, "trip-num", &trip_num);
+	if(ret){
+		dev_err(dev, "fail to get trip_num\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(sensor_child, "id", &sensor_id);
+	if (ret) {
+		dev_err(dev, "fail to get id\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(sensor_child, "temp-inteval", &temp_interval);
+	if(ret){
+		dev_err(dev, "fail to get temp-inteval\n");
+		goto fail;
+	}
+	of_property_read_string(sensor_child, "thermal-name",
+					&thm_name);
+	strcpy(pdata->thm_name, thm_name);
+	for (i = 0; i <trip_num-1; ++i) {
+		sprintf(prop_name, "trip%d-temp-active", i);
+		if (of_property_read_u32(sensor_child, prop_name, &tmp_data)){
+			dev_err(dev, "fail to get trip%d-temp-active\n",i);
+			goto fail;
+		}
+		pdata->trip_points[i].temp = tmp_data;
+        sprintf(prop_name, "trip%d-temp-lowoff", i);
+		if (of_property_read_u32(sensor_child, prop_name, &tmp_lowoff)){
+			dev_err(dev, "fail to get trip%d-temp-lowoff\n",i);
+			goto fail;
+		}
+		pdata->trip_points[i].lowoff = tmp_lowoff;
+		sprintf(prop_name, "trip%d-type", i);
+		if (of_property_read_string(sensor_child, prop_name, &tmp_str))
+			goto  fail;
+
+		if (!strcmp(tmp_str, "active"))
+			pdata->trip_points[i].type = THERMAL_TRIP_ACTIVE;
+		else if (!strcmp(tmp_str, "passive"))
+			pdata->trip_points[i].type = THERMAL_TRIP_PASSIVE;
+		else if (!strcmp(tmp_str, "hot"))
+			pdata->trip_points[i].type = THERMAL_TRIP_HOT;
+		else if (!strcmp(tmp_str, "critical"))
+			pdata->trip_points[i].type = THERMAL_TRIP_CRITICAL;
+		else
+			goto  fail;
+
+		sprintf(prop_name, "trip%d-cdev-num", i);
+		if (of_property_read_u32(sensor_child, prop_name, &tmp_data))
+			goto  fail;
+		for (j = 0; j < tmp_data; j++) {
+			sprintf(prop_name, "trip%d-cdev-name%d", i, j);
+			if (of_property_read_string(sensor_child, prop_name, &tmp_str))
+				goto  fail;
+			strcpy(pdata->trip_points[i].cdev_name[j], tmp_str);
+			dev_info(dev,"cdev name: %s \n", pdata->trip_points[i].cdev_name[j]);
+		}
+		dev_info(dev, "trip[%d] temp: %lu lowoff: %lu\n",
+					i, pdata->trip_points[i].temp, pdata->trip_points[i].lowoff);
+	}
+	pdata->trip_points[i].temp = trip_points_critical;
+	pdata->trip_points[i].type = THERMAL_TRIP_CRITICAL;
+	dev_info(dev, "trip[%d] temp: %lu \n",
+					i, pdata->trip_points[i].temp);
+	pdata->num_trips = trip_num;
+	pdata->sensor_id = sensor_id;
+	pdata->temp_interval = temp_interval;
+	printk("the trip_num=%d,sensor_id =%d\n",pdata->num_trips,pdata->sensor_id);
+	pdata++;
+	};
+	return thm_data;
+
+fail:
+	kfree(pdata);
+	kfree(thm_data);
+	return NULL;
+
+}
+#endif
+
+static int sprd_ddie_thm_probe(struct platform_device *pdev)
+{
+	struct sprd_thm_platform_data *ptrips = NULL;
+	struct sprd_thermal_zone *pzone = NULL;
+	struct resource *res;
+	struct sprd_thm *pthm = NULL;
+	unsigned long ddie_thm_base;
+	int ret,i;
+#ifdef CONFIG_OF
+	struct device_node *np = pdev->dev.of_node;
+	if (!np) {
+		dev_err(&pdev->dev, "device node not found\n");
+		return -EINVAL;
+	}
+#endif
+	printk("sprd_ddie_thm_probe start\n");
+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	ddie_thm_base = (unsigned long)devm_ioremap_resource(&pdev->dev, res);
+	if (!ddie_thm_base) {
+		pr_err("thermal ioremap failed!\n");
+		return -ENOMEM;
+	}
+#ifdef CONFIG_OF
+	pthm = thermal_detect_parse_dt(&pdev->dev);
+#else
+	pthm = dev_get_platdata(&pdev->dev);
+#endif
+	if (!pthm){
+	dev_err(&pdev->dev, "not found pthm\n");
+		return -EINVAL;
+	}
+	for (i = 0; i < pthm->nsensor; i++) {
+	pzone = devm_kzalloc(&pdev->dev, sizeof(*pzone), GFP_KERNEL);
+	mutex_init(&pzone->th_lock);
+	mutex_lock(&pzone->th_lock);
+	if (!pzone)
+		return -ENOMEM;
+	pzone->reg_base= ddie_thm_base;
+	ptrips = &pthm->sprd_data[i];
+	pzone->trip_tab = ptrips;
+	pzone->temp_inteval = ptrips->temp_interval;
+	pzone->sensor_id = ptrips->sensor_id;
+	memcpy(pzone->thermal_zone_name,
+							ptrips->thm_name, strlen(ptrips->thm_name)+1);
+	printk("the thermal-name1 is %s\n",pzone->thermal_zone_name);
+	pzone->ops = &sprd_ddie_ops;
+	ret = sprd_thm_hw_init(pzone);
+	if(ret){
+		dev_err(&pdev->dev, " pzone hw init error id =%d\n",pzone->sensor_id);
+		return -ENODEV;
+	}
+    ret = sprd_thermal_init(pzone);
+	if(ret){
+		dev_err(&pdev->dev, " pzone sw init error id =%d\n",pzone->sensor_id);
+		return -ENODEV;
+	}
+	platform_set_drvdata(pdev, pzone);
+	printk("sprd_ddie_thm_probe---end\n");
+	mutex_unlock(&pzone->th_lock);
+	pzone++;
+	}
+	return 0;
+}
+
+static int sprd_ddie_thm_remove(struct platform_device *pdev)
+{
+
+	struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev);
+	sprd_thermal_remove(pzone);
+	return 0;
+}
+
+static int sprd_ddie_thm_suspend(struct platform_device *pdev,
+				pm_message_t state)
+{
+	struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev);
+	flush_delayed_work(&pzone->thm_read_work);
+	//flush_delayed_work(&pzone->thm_logtime_work);
+	flush_delayed_work(&pzone->resume_delay_work);
+	pzone->ops->suspend(pzone);
+	return 0;
+}
+
+static int sprd_ddie_thm_resume(struct platform_device *pdev)
+{
+
+	struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev);
+	schedule_delayed_work(&pzone->resume_delay_work, (HZ * 1));
+	schedule_delayed_work(&pzone->thm_read_work, (HZ * 5));
+	//schedule_delayed_work(&pzone->thm_logtime_work, (HZ * 7));
+	//pzone->ops->resume(pzone);
+	return 0;
+}
+
+static const struct of_device_id thermal_of_match[] = {
+	{ .compatible = "sprd,ddie-thermal", },
+       {}
+};
+
+static struct platform_driver sprd_thermal_driver = {
+	.probe = sprd_ddie_thm_probe,
+	.suspend = sprd_ddie_thm_suspend,
+	.resume = sprd_ddie_thm_resume,
+	.remove = sprd_ddie_thm_remove,
+	.driver = {
+		   .owner = THIS_MODULE,
+		   .name = "ddie-thermal",
+		   .of_match_table = of_match_ptr(thermal_of_match),
+		   },
+};
+static int __init sprd_ddie_thermal_init(void)
+{
+	return platform_driver_register(&sprd_thermal_driver);
+}
+
+static void __exit sprd_ddie_thermal_exit(void)
+{
+	platform_driver_unregister(&sprd_thermal_driver);
+}
+
+
+device_initcall_sync(sprd_ddie_thermal_init);
+module_exit(sprd_ddie_thermal_exit);
+MODULE_AUTHOR("Freeman Liu <freeman.liu@spreadtrum.com>");
+MODULE_DESCRIPTION("sprd thermal driver");
+MODULE_LICENSE("GPL");
+