Initial file dump from open source releaseHEADmaster

1 files changed, 535 insertions, 0 deletions

diff --git a/drivers/thermal/sprd_board_sensor.c b/drivers/thermal/sprd_board_sensor.c
new file mode 100644
index 00000000..ed730e1f
--- /dev/null
+++ b/drivers/thermal/sprd_board_sensor.c
@@ -0,0 +1,535 @@
+/*
+ * 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 "thm.h"
+#include <linux/sprd_thm.h>
+#include <soc/sprd/arch_misc.h>
+#include <soc/sprd/hardware.h>
+#include "thermal_core.h"
+#include <soc/sprd/adc.h>
+#include <linux/module.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/thermal.h>
+#include <linux/slab.h>
+
+//#define SPRD_THM_BOARD_DEBUG
+#ifdef SPRD_THM_BOARD_DEBUG
+#define THM_BOARD_DEBUG(format, arg...) printk("sprd board thm: " "@@@" format, ## arg)
+#else
+#define THM_BOARD_DEBUG(format, arg...)
+#endif
+
+#define THM_SENOR_NUM 8
+extern int sprd_thermal_init(struct sprd_thermal_zone *pzone);
+extern void sprd_thermal_remove(struct sprd_thermal_zone *pzone);
+
+
+struct sprd_board_sensor_config *pthm_config;
+//extern uint16_t sprdchg_bat_adc_to_vol(uint16_t adcvalue);
+
+static int sprdthm_read_temp_adc(void)
+{
+#define SAMPLE_NUM  15
+	int cnt = pthm_config->temp_adc_sample_cnt;
+
+	if (cnt > SAMPLE_NUM) {
+		cnt = SAMPLE_NUM;
+	} else if (cnt < 1) {
+		cnt = 1;
+	}
+
+	if (pthm_config->temp_support) {
+		int ret, i, j, temp;
+		int adc_val[cnt];
+		struct adc_sample_data data = {
+			.channel_id = pthm_config->temp_adc_ch,
+			.channel_type = 0,	/*sw */
+			.hw_channel_delay = 0,	/*reserved */
+			.scale = pthm_config->temp_adc_scale,	/*small scale */
+			.pbuf = &adc_val[0],
+			.sample_num = cnt,
+			.sample_bits = 1,
+			.sample_speed = 0,	/*quick mode */
+			.signal_mode = 0,	/*resistance path */
+		};
+
+		ret = sci_adc_get_values(&data);
+		WARN_ON(0 != ret);
+
+		for (j = 1; j <= cnt - 1; j++) {
+			for (i = 0; i < cnt - j; i++) {
+				if (adc_val[i] > adc_val[i + 1]) {
+					temp = adc_val[i];
+					adc_val[i] = adc_val[i + 1];
+					adc_val[i + 1] = temp;
+				}
+			}
+		}
+		THM_BOARD_DEBUG("sprdthm: channel:%d,sprdthm_read_temp_adc:%d\n",
+		       data.channel_id, adc_val[cnt / 2]);
+		return adc_val[cnt / 2];
+	} else {
+		return 3000;
+	}
+}
+
+static int sprdthm_interpolate(int x, int n, struct sprdboard_table_data *tab)
+{
+	int index;
+	int y;
+
+	if (x >= tab[0].x)
+		y = tab[0].y;
+	else if (x <= tab[n - 1].x)
+		y = tab[n - 1].y;
+	else {
+		/*  find interval */
+		for (index = 1; index < n; index++)
+			if (x > tab[index].x)
+				break;
+		/*  interpolate */
+		y = (tab[index - 1].y - tab[index].y) * (x - tab[index].x)
+		    * 2 / (tab[index - 1].x - tab[index].x);
+		y = (y + 1) / 2;
+		y += tab[index].y;
+	}
+	return y;
+}
+static uint16_t sprdthm_adc_to_vol(uint16_t channel, int scale,
+				   uint16_t adcvalue)
+{
+	uint32_t result;
+	uint32_t vthm_vol = adc2vbat(adcvalue,scale);
+	uint32_t m, n;
+	uint32_t thm_numerators, thm_denominators;
+	uint32_t numerators, denominators;
+
+	sci_adc_get_vol_ratio(ADC_CHANNEL_VBAT, 0, &thm_numerators,
+			      &thm_denominators);
+	sci_adc_get_vol_ratio(channel, scale, &numerators, &denominators);
+
+	///v1 = vbat_vol*0.268 = vol_bat_m * r2 /(r1+r2)
+	n = thm_denominators * numerators;
+	m = vthm_vol * thm_numerators * (denominators);
+	result = (m + n / 2) / n;
+	return result;
+}
+
+static int sprdthm_search_temp_tab(int val)
+{
+	return sprdthm_interpolate(val, pthm_config->temp_tab_size,
+				   pthm_config->temp_tab);
+}
+
+static int sprd_board_thm_get_reg_base(struct sprd_thermal_zone *pzone ,struct resource *regs)
+{
+	return 0;
+}
+static int sprd_board_thm_set_active_trip(struct sprd_thermal_zone *pzone, int trip )
+{
+	return 0;
+}
+
+static unsigned long  sprd_board_thm_temp_read(struct sprd_thermal_zone *pzone)
+{
+    int temp;
+	if (pthm_config->temp_support) {
+		int val = sprdthm_read_temp_adc();
+		//voltage mode
+		if (pthm_config->temp_table_mode) {
+			val =sprdthm_adc_to_vol(pthm_config->temp_adc_ch,
+					       pthm_config->temp_adc_scale, val);
+			THM_BOARD_DEBUG("sprdthm: sprdthm_read_temp voltage:%d\n", val);
+		}
+        THM_BOARD_DEBUG("sprd_board_thm_temp_read y=%d\n",sprdthm_search_temp_tab(val));
+		temp = sprdthm_search_temp_tab(val);
+		printk("sensor id:%d,rawdata:0x%x, temp:%lu\n", pzone->sensor_id, val, temp*1000);
+		return temp*1000;
+	} else {
+		return -35000;
+	}
+	
+}
+
+static int sprd_board_thm_hw_init(struct sprd_thermal_zone *pzone)
+{
+    THM_BOARD_DEBUG("sprd_board_thm_hw_init\n");
+	pthm_config=pzone->sensor_config;
+
+	return 0;
+}
+
+
+static int sprd_board_thm_hw_suspend(struct sprd_thermal_zone *pzone)
+{
+     THM_BOARD_DEBUG("sprd_board_thm_hw_suspend\n");
+	
+	return 0;
+}
+static int sprd_board_thm_hw_resume(struct sprd_thermal_zone *pzone)
+{
+
+    THM_BOARD_DEBUG("sprd_board_thm_hw_resume\n");
+
+	return 0;
+}
+#ifdef  THM_TEST
+static int sprd_board_thm_trip_set(struct sprd_thermal_zone *pzone,int trip)
+{
+	THM_BOARD_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
+
+static int sprd_board_thm_get_trend(struct sprd_thermal_zone *pzone, int trip, enum thermal_trend *ptrend)
+{
+	*ptrend = pzone->trend_val;
+	return 0;
+}
+
+static int sprd_board_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;
+}
+
+struct thm_handle_ops sprd_boardthm_ops =
+{
+	.hw_init = sprd_board_thm_hw_init,
+	.get_reg_base = sprd_board_thm_get_reg_base,
+	.read_temp = sprd_board_thm_temp_read,
+	.get_trend = sprd_board_thm_get_trend,
+	.get_hyst = sprd_board_thm_get_hyst,
+	.suspend = sprd_board_thm_hw_suspend,
+	.resume = sprd_board_thm_hw_resume,
+	.trip_debug_set = sprd_board_thm_trip_set,
+};
+
+#ifdef CONFIG_OF
+static struct sprd_thm_platform_data *thermal_detect_parse_dt(
+                         struct device *dev)
+{
+	struct sprd_thm_platform_data *pdata;
+	struct device_node *np = dev->of_node;
+	u32 trip_points_critical,trip_num;
+	char prop_name[32];
+	const char *tmp_str;
+	u32 tmp_data,tmp_lowoff;
+	int ret,i ,j = 0;
+	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+	if (!pdata) {
+		dev_err(dev, "could not allocate memory for platform data\n");
+		return NULL;
+	}
+	ret = of_property_read_u32(np, "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(np, "trip-num", &trip_num);
+	if(ret){
+		dev_err(dev, "fail to get trip_num\n");
+		goto fail;
+	}
+	for (i = 0; i <trip_num-1; ++i) {
+		sprintf(prop_name, "trip%d-temp-active", i);
+		if (of_property_read_u32(np, 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(np, 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(np, 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(np, 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(np, 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;
+
+	return pdata;
+
+fail:
+	kfree(pdata);
+	return NULL;
+
+}
+
+static struct sprd_board_sensor_config *sprdboard_thermal_parse_dt(
+							   struct device *dev)
+{
+    struct sprd_board_sensor_config *pconfig;
+	struct device_node *np = dev->of_node;
+	int ret,i;
+	int temp;
+	int temp_adc_ch,temp_adc_scale,temp_adc_sample_cnt;
+	int temp_table_mode,temp_tab_size,temp_support;
+	pconfig = kzalloc(sizeof(*pconfig), GFP_KERNEL);
+	if (!pconfig) {
+		dev_err(dev, "could not allocate memory for platform data\n");
+		return NULL;
+	}
+	ret =of_property_read_u32(np, "temp-adc-ch",&temp_adc_ch);
+	if(ret){
+		dev_err(dev, "sprd_thermal_probe No temp-adc-ch\n");
+		goto fail;
+	}
+	ret =of_property_read_u32(np, "temp-adc-scale",&temp_adc_scale);
+	if(ret){
+		dev_err(dev, "sprd_thermal_probe No temp_adc_scale\n");
+		goto fail;
+	}
+	ret =of_property_read_u32(np, "temp-adc-sample-cnt",&temp_adc_sample_cnt);
+	if(ret){
+		dev_err(dev, "fail to get temp_adc_sample_cnt\n");
+		goto fail;
+	}
+	ret =of_property_read_u32(np, "temp-table-mode",&temp_table_mode);
+	if(ret){
+		dev_err(dev, "fail to get temp_table_mode\n");
+		goto fail;
+	}
+	ret =of_property_read_u32(np, "temp-tab-size",&temp_tab_size);
+	if(ret){
+		dev_err(dev, "fail to get  temp_tab_size\n");
+		goto fail;
+	}
+	ret =of_property_read_u32(np, "temp-support",&temp_support);
+	if(ret){
+		dev_err(dev, "fail to get temp_support\n");
+		goto fail;
+	}
+	pconfig->temp_adc_ch=temp_adc_ch;
+	pconfig->temp_adc_sample_cnt=temp_adc_sample_cnt;
+	pconfig->temp_adc_scale=temp_adc_scale;
+	pconfig->temp_table_mode=temp_table_mode;
+	pconfig->temp_support=temp_support;
+	pconfig->temp_tab_size=temp_tab_size;
+	pconfig->temp_tab = kzalloc(sizeof(struct sprdboard_table_data) *
+				  pconfig->temp_tab_size-1, GFP_KERNEL);
+	for (i = 0; i < pconfig->temp_tab_size-1; i++) {
+		ret = of_property_read_u32_index(np, "temp-tab-val", i,
+						 &pconfig->temp_tab[i].x);
+		if(ret){
+			dev_err(dev, "fail to get temp-tab-va\n");
+			goto fail;
+		}
+		ret = of_property_read_u32_index(np, "temp-tab-temp", i, &temp);
+		if(ret){
+			dev_err(dev, "fail to get temp-tab-temp\n");
+			goto fail;
+		}
+		pconfig->temp_tab[i].y = temp - 1000;
+	}
+	return pconfig;
+fail:
+	kfree(pconfig);
+	return NULL;
+}
+
+#endif
+static int sprd_board_thm_probe(struct platform_device *pdev)
+{
+	struct sprd_thermal_zone *pzone = NULL;
+	struct sprd_thm_platform_data *ptrips = NULL;
+	struct sprd_board_sensor_config *pconfig = NULL;
+	const char *thm_name;
+	int ret,temp_interval,sensor_id;
+	printk("sprd_thermal_probe---------start\n");
+#ifdef CONFIG_OF
+	struct device_node *np = pdev->dev.of_node;
+#endif
+
+#ifdef CONFIG_OF
+	if (!np) {
+		dev_err(&pdev->dev, "device node not found\n");
+		return -EINVAL;
+	}
+	pconfig = sprdboard_thermal_parse_dt(&pdev->dev);
+	if (!pconfig){
+		dev_err(&pdev->dev, "not found ptrips\n");
+		return -EINVAL;
+	}
+	ptrips = thermal_detect_parse_dt(&pdev->dev);
+#else
+	ptrips = dev_get_platdata(&pdev->dev);
+#endif
+    if (!ptrips){
+		dev_err(&pdev->dev, "not found ptrips\n");
+		return -EINVAL;
+	}
+	pzone = devm_kzalloc(&pdev->dev, sizeof(*pzone), GFP_KERNEL);
+	if (!pzone){
+		kfree(pconfig);
+		kfree(ptrips);
+		return -ENOMEM;
+		}
+	mutex_init(&pzone->th_lock);
+	mutex_lock(&pzone->th_lock);
+	printk("sprd_ddie_thm_probe start\n");
+#if 0
+	pdev->id = of_alias_get_id(np, "thmzone");
+	printk(KERN_INFO " sprd_thermal_probe id:%d\n", pdev->id);
+	if (unlikely(pdev->id < 0 || pdev->id >= THM_SENOR_NUM)) {
+		dev_err(&pdev->dev, "does not support id %d\n", pdev->id);
+		return -ENXIO;
+	}
+#endif
+	ret = of_property_read_u32(np, "temp-inteval", &temp_interval);
+	if(ret){
+		dev_err(&pdev->dev, "fail to get temp-inteval\n");
+		return -EINVAL;
+	}
+	ret = of_property_read_u32(np, "id", &sensor_id);
+	if (ret) {
+		dev_err(&pdev->dev, "fail to get id\n");
+		return -EINVAL;
+	}
+	of_property_read_string(np, "thermal-name",&thm_name);
+	strcpy(pzone->thermal_zone_name, thm_name);
+	pzone->trip_tab = ptrips;
+	pzone->mode = THERMAL_DEVICE_DISABLED;
+	pzone->trip_tab = ptrips;
+	pzone->sensor_config= pconfig;
+	pzone->trend_val = THERMAL_TREND_STABLE;
+	pzone->temp_inteval = temp_interval;
+	pzone->sensor_id = sensor_id;
+	pzone->ops = &sprd_boardthm_ops;
+	ret = sprd_board_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);
+	return 0;
+}
+
+static int sprd_board_thm_remove(struct platform_device *pdev)
+{
+
+	struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev);
+	sprd_thermal_remove(pzone);
+	return 0;
+}
+static int sprd_board_thm_suspend(struct platform_device *pdev,
+				pm_message_t state)
+{
+	struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev);
+	//flush_delayed_work(&pzone->thm_logtime_work);
+	flush_delayed_work(&pzone->thm_read_work);
+	flush_delayed_work(&pzone->resume_delay_work);
+	pzone->ops->suspend(pzone);
+	return 0;
+}
+static int sprd_board_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;
+}
+
+#ifdef CONFIG_OF
+static const struct of_device_id thermal_of_match[] = {
+	{ .compatible = "sprd,board-thermal", },
+       {}
+};
+#endif
+
+static struct platform_driver sprd_thermal_driver = {
+	.probe = sprd_board_thm_probe,
+	.suspend = sprd_board_thm_suspend,
+	.resume = sprd_board_thm_resume,
+	.remove = sprd_board_thm_remove,
+	.driver = {
+		   .owner = THIS_MODULE,
+		   .name = "board-thermal",
+#ifdef CONFIG_OF
+			.of_match_table = of_match_ptr(thermal_of_match),
+#endif
+		   },
+};
+static int __init sprd_board_thermal_init(void)
+{
+	return platform_driver_register(&sprd_thermal_driver);
+}
+
+static void __exit sprd_board_thermal_exit(void)
+{
+	platform_driver_unregister(&sprd_thermal_driver);
+}
+
+device_initcall_sync(sprd_board_thermal_init);
+module_exit(sprd_board_thermal_exit);
+MODULE_AUTHOR("Freeman Liu <freeman.liu@spreadtrum.com>");
+MODULE_DESCRIPTION("sprd thermal driver");
+MODULE_LICENSE("GPL");
+