[PATCH v1 0/2] 96boards: add thermal senor support to hikey board

[PATCH v1 0/2] 96boards: add thermal senor support to hikey board

[Xinwei Kong]

From: kongxinwei <kong.kongxinwei@hisilicon.com>

Thank you all for giving this RFC patches stages some comments. Here is v1
patches and address all the issues raised as part of RFC review.

The Linaro connect introduce 96boards series in Hong Kong,The HiKey board
is the first board to be certified 96Boards Consumer Edition compatible.
This board is based on the HiSilicon SoC. you can get more information
from https://www.96boards.org.

The hisilicon SoC contains thermal module, this thermal module has 4 sensors,

	- sensor 0: local sensor;
	- sensor 1: remote sensor for ACPU cluster 1;
	- sensor 2: remote sensor for ACPU cluster 2;
	- sensor 3: remote sensor for GPU;

It can obtain this device temperature by operating this hardware. The new
sensor driver satisfies thermal framework and to realize the ACPU ,GPU and
so on to cool function.

Changes v0->v1;
* Delete this hi6220 dtsi.
* Fix documentation and error checks.
* Modify this driver which makes use of kernel to decide dynamically bind
  the interrupt to hottest sensor.
* Delete "sensor-thres-temp" property in DTS and write thermal_zone trips
  points value to register.
* Delete "sensor-reset-temp" property and define the fixed value.

kongxinwei (2):
  thermal: hisilicon: add new hisilicon thermal sensor driver
  dt-bindings: Document the hi6220 thermal sensor bindings

 .../bindings/thermal/hisilicon-thermal.txt         |  45 ++
 drivers/thermal/Kconfig                            |   8 +
 drivers/thermal/Makefile                           |   1 +
 drivers/thermal/hisi_thermal.c                     | 526 +++++++++++++++++++++
 4 files changed, 580 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/thermal/hisilicon-thermal.txt
 create mode 100644 drivers/thermal/hisi_thermal.c

-- 
1.9.1

[PATCH v1 0/2] 96boards: add thermal senor support to hikey board

[Xinwei Kong]

From: kongxinwei <kong.kongxinwei@hisilicon.com>

Thank you all for giving this RFC patches stages some comments. Here is v1
patches and address all the issues raised as part of RFC review.

The Linaro connect introduce 96boards series in Hong Kong,The HiKey board
is the first board to be certified 96Boards Consumer Edition compatible.
This board is based on the HiSilicon SoC. you can get more information
from https://www.96boards.org.

The hisilicon SoC contains thermal module, this thermal module has 4 sensors,

	- sensor 0: local sensor;
	- sensor 1: remote sensor for ACPU cluster 1;
	- sensor 2: remote sensor for ACPU cluster 2;
	- sensor 3: remote sensor for GPU;

It can obtain this device temperature by operating this hardware. The new
sensor driver satisfies thermal framework and to realize the ACPU ,GPU and
so on to cool function.

Changes v0->v1;
* Delete this hi6220 dtsi.
* Fix documentation and error checks.
* Modify this driver which makes use of kernel to decide dynamically bind
  the interrupt to hottest sensor.
* Delete "sensor-thres-temp" property in DTS and write thermal_zone trips
  points value to register.
* Delete "sensor-reset-temp" property and define the fixed value.

kongxinwei (2):
  thermal: hisilicon: add new hisilicon thermal sensor driver
  dt-bindings: Document the hi6220 thermal sensor bindings

 .../bindings/thermal/hisilicon-thermal.txt         |  45 ++
 drivers/thermal/Kconfig                            |   8 +
 drivers/thermal/Makefile                           |   1 +
 drivers/thermal/hisi_thermal.c                     | 526 +++++++++++++++++++++
 4 files changed, 580 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/thermal/hisilicon-thermal.txt
 create mode 100644 drivers/thermal/hisi_thermal.c

-- 
1.9.1

[PATCH v1 0/2] 96boards: add thermal senor support to hikey board

[Xinwei Kong]

From: kongxinwei <kong.kongxinwei@hisilicon.com>

Thank you all for giving this RFC patches stages some comments. Here is v1
patches and address all the issues raised as part of RFC review.

The Linaro connect introduce 96boards series in Hong Kong,The HiKey board
is the first board to be certified 96Boards Consumer Edition compatible.
This board is based on the HiSilicon SoC. you can get more information
from https://www.96boards.org.

The hisilicon SoC contains thermal module, this thermal module has 4 sensors,

	- sensor 0: local sensor;
	- sensor 1: remote sensor for ACPU cluster 1;
	- sensor 2: remote sensor for ACPU cluster 2;
	- sensor 3: remote sensor for GPU;

It can obtain this device temperature by operating this hardware. The new
sensor driver satisfies thermal framework and to realize the ACPU ,GPU and
so on to cool function.

Changes v0->v1;
* Delete this hi6220 dtsi.
* Fix documentation and error checks.
* Modify this driver which makes use of kernel to decide dynamically bind
  the interrupt to hottest sensor.
* Delete "sensor-thres-temp" property in DTS and write thermal_zone trips
  points value to register.
* Delete "sensor-reset-temp" property and define the fixed value.

kongxinwei (2):
  thermal: hisilicon: add new hisilicon thermal sensor driver
  dt-bindings: Document the hi6220 thermal sensor bindings

 .../bindings/thermal/hisilicon-thermal.txt         |  45 ++
 drivers/thermal/Kconfig                            |   8 +
 drivers/thermal/Makefile                           |   1 +
 drivers/thermal/hisi_thermal.c                     | 526 +++++++++++++++++++++
 4 files changed, 580 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/thermal/hisilicon-thermal.txt
 create mode 100644 drivers/thermal/hisi_thermal.c

-- 
1.9.1

[PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[Xinwei Kong]

From: kongxinwei <kong.kongxinwei@hisilicon.com>

This patch adds the support for hisilicon thermal sensor, within
hisilicon SoC. there will register sensors for thermal framework
and use device tree to bind cooling device.

Signed-off-by: Leo Yan <leo.yan@linaro.org>
Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
---
 drivers/thermal/Kconfig        |   8 +
 drivers/thermal/Makefile       |   1 +
 drivers/thermal/hisi_thermal.c | 526 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 535 insertions(+)
 create mode 100644 drivers/thermal/hisi_thermal.c

diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
index af40db0..81aee01 100644
--- a/drivers/thermal/Kconfig
+++ b/drivers/thermal/Kconfig
@@ -136,6 +136,14 @@ config THERMAL_EMULATION
 	  because userland can easily disable the thermal policy by simply
 	  flooding this sysfs node with low temperature values.
 
+config HISI_THERMAL
+	tristate "Hisilicon thermal driver"
+	depends on ARCH_HISI && CPU_THERMAL && OF
+	help
+	  Enable this to plug hisilicon's thermal sensor driver into the Linux
+	  thermal framework. cpufreq is used as the cooling device to throttle
+	  CPUs when the passive trip is crossed.
+
 config IMX_THERMAL
 	tristate "Temperature sensor driver for Freescale i.MX SoCs"
 	depends on CPU_THERMAL
diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
index fa0dc48..08ae7ac 100644
--- a/drivers/thermal/Makefile
+++ b/drivers/thermal/Makefile
@@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)	+= ti-soc-thermal/
 obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
 obj-$(CONFIG_ST_THERMAL)	+= st/
 obj-$(CONFIG_TEGRA_SOCTHERM)	+= tegra_soctherm.o
+obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
diff --git a/drivers/thermal/hisi_thermal.c b/drivers/thermal/hisi_thermal.c
new file mode 100644
index 0000000..8edf83a
--- /dev/null
+++ b/drivers/thermal/hisi_thermal.c
@@ -0,0 +1,526 @@
+/*
+ * Hisilicon thermal sensor driver
+ *
+ * Copyright (c) 2014-2015 Hisilicon Limited.
+ * Copyright (c) 2014-2015 Linaro Limited.
+ *
+ * Xinwei Kong <kong.kongxinwei@hisilicon.com>
+ * Leo Yan <leo.yan@linaro.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/cpu_cooling.h>
+#include <linux/cpufreq.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/mfd/syscon.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+#include <linux/thermal.h>
+#include <linux/types.h>
+
+#include "thermal_core.h"
+
+#define TEMP0_LAG			(0x0)
+#define TEMP0_TH			(0x4)
+#define TEMP0_RST_TH			(0x8)
+#define TEMP0_CFG			(0xC)
+#define TEMP0_EN			(0x10)
+#define TEMP0_INT_EN			(0x14)
+#define TEMP0_INT_CLR			(0x18)
+#define TEMP0_RST_MSK			(0x1C)
+#define TEMP0_RAW_INT			(0x20)
+#define TEMP0_MSK_INT			(0x24)
+#define TEMP0_VALUE			(0x28)
+
+#define HISI_TEMP_BASE			(-60)
+#define HISI_TEMP_RESET			(100000)
+#define HISI_TEMP_PASSIVE		(85000)
+
+#define HISI_MAX_SENSORS		4
+
+struct hisi_thermal_sensor {
+	struct hisi_thermal_data *thermal;
+	struct thermal_zone_device *tzd;
+	const struct thermal_trip *trip;
+
+	uint32_t id;
+	uint32_t thres_temp, reset_temp;
+};
+
+struct hisi_thermal_data {
+	struct platform_device *pdev;
+	struct clk *clk;
+
+	int irq, irq_bind_sensor;
+	bool irq_enabled;
+
+	unsigned int sensors_num;
+	long sensor_temp[HISI_MAX_SENSORS];
+	struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
+
+	void __iomem *regs;
+};
+
+static DEFINE_SPINLOCK(thermal_lock);
+
+/* in millicelsius */
+static inline int _step_to_temp(int step)
+{
+	/*
+	 * Every step equals (1 * 200) / 255 celsius, and finally
+	 * need convert to millicelsius.
+	 */
+	return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
+}
+
+static inline int _temp_to_step(int temp)
+{
+	return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
+}
+
+static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data *data,
+					 struct hisi_thermal_sensor *sensor)
+{
+	unsigned long flags;
+	int val;
+
+	spin_lock_irqsave(&thermal_lock, flags);
+
+	/* disable module firstly */
+	writel(0x0, data->regs + TEMP0_EN);
+
+	/* select sensor id */
+	writel((sensor->id << 12), data->regs + TEMP0_CFG);
+
+	/* enable module */
+	writel(0x1, data->regs + TEMP0_EN);
+
+	mdelay(5);
+
+	val = readl(data->regs + TEMP0_VALUE);
+	val = _step_to_temp(val);
+
+	/* adjust for negative value */
+	val = (val < 0) ? 0 : val;
+
+	spin_unlock_irqrestore(&thermal_lock, flags);
+
+	return val;
+}
+
+static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
+{
+	struct hisi_thermal_sensor *sensor;
+	unsigned long flags;
+
+	sensor = &data->sensors[data->irq_bind_sensor];
+
+	spin_lock_irqsave(&thermal_lock, flags);
+
+	/* setting the hdak time */
+	writel(0x0, data->regs + TEMP0_CFG);
+
+	/* disable module firstly */
+	writel(0x0, data->regs + TEMP0_RST_MSK);
+	writel(0x0, data->regs + TEMP0_EN);
+
+	/* select sensor id */
+	writel((sensor->id << 12), data->regs + TEMP0_CFG);
+
+	/* enable for interrupt */
+	writel(_temp_to_step(sensor->thres_temp)
+			| 0x0FFFFFF00, data->regs + TEMP0_TH);
+
+	writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
+
+	/* enable module */
+	writel(0x1, data->regs + TEMP0_RST_MSK);
+	writel(0x1, data->regs + TEMP0_EN);
+
+	writel(0x0, data->regs + TEMP0_INT_CLR);
+	writel(0x1, data->regs + TEMP0_INT_EN);
+
+	mdelay(5);
+
+	spin_unlock_irqrestore(&thermal_lock, flags);
+
+}
+
+static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
+{
+	struct hisi_thermal_sensor *sensor;
+	unsigned long flags;
+
+	sensor = &data->sensors[data->irq_bind_sensor];
+
+	spin_lock_irqsave(&thermal_lock, flags);
+
+	/* setting the hdak time */
+	writel(0x0, data->regs + TEMP0_CFG);
+
+	/* disable module firstly */
+	writel(0x0, data->regs + TEMP0_RST_MSK);
+	writel(0x0, data->regs + TEMP0_EN);
+
+	/* select sensor id */
+	writel((sensor->id << 12), data->regs + TEMP0_CFG);
+
+	/* enable for interrupt */
+	writel(_temp_to_step(sensor->thres_temp)
+			| 0x0FFFFFF00, data->regs + TEMP0_TH);
+
+	writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
+
+	/* enable module */
+	writel(0x1, data->regs + TEMP0_RST_MSK);
+	writel(0x1, data->regs + TEMP0_EN);
+
+	writel(0x0, data->regs + TEMP0_INT_CLR);
+	writel(0x1, data->regs + TEMP0_INT_EN);
+
+	mdelay(5);
+
+	spin_unlock_irqrestore(&thermal_lock, flags);
+
+}
+
+static void hisi_thermal_disable_sensor(struct hisi_thermal_data *data)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&thermal_lock, flags);
+
+	/* disable sensor module */
+	writel(0x0, data->regs + TEMP0_INT_EN);
+	writel(0x0, data->regs + TEMP0_RST_MSK);
+	writel(0x0, data->regs + TEMP0_EN);
+
+	spin_unlock_irqrestore(&thermal_lock, flags);
+
+}
+
+static int hisi_thermal_get_temp(void *_sensor, long *temp)
+{
+	struct hisi_thermal_sensor *sensor = _sensor;
+	struct hisi_thermal_data *data = sensor->thermal;
+
+	int sensor_id = 0, i;
+	long max_temp = 0;
+
+	*temp = hisi_thermal_get_sensor_temp(data, sensor);
+
+	data->sensor_temp[sensor->id] = *temp;
+
+	for (i = 0; i < HISI_MAX_SENSORS; i++) {
+		if (data->sensor_temp[i] >= max_temp) {
+			max_temp = data->sensor_temp[i];
+			sensor_id = i;
+		}
+	}
+
+	data->irq_bind_sensor = sensor_id;
+
+	dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
+		sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
+
+	/*
+	 * Bind irq to sensor for two cases:
+	 *   Reenable alarm IRQ if temperature below threshold;
+	 *   if irq has been enabled, always set it;
+	 */
+	if (!data->irq_enabled && max_temp < sensor->thres_temp) {
+		data->irq_enabled = true;
+		hisi_thermal_bind_irq(data);
+	} else if (data->irq_enabled)
+		hisi_thermal_bind_irq(data);
+
+	return 0;
+}
+
+static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
+	.get_temp = hisi_thermal_get_temp,
+};
+
+static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
+{
+	struct hisi_thermal_data *data = dev;
+	unsigned long flags;
+
+	spin_lock_irqsave(&thermal_lock, flags);
+
+	/* disable interrupt */
+	writel(0x0, data->regs + TEMP0_INT_EN);
+	writel(0x1, data->regs + TEMP0_INT_CLR);
+
+	spin_unlock_irqrestore(&thermal_lock, flags);
+	data->irq_enabled = false;
+
+	return IRQ_WAKE_THREAD;
+}
+
+static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
+{
+	struct hisi_thermal_data *data = dev;
+	struct hisi_thermal_sensor *sensor;
+	int i;
+
+	sensor = &data->sensors[data->irq_bind_sensor];
+
+	dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
+		 sensor->thres_temp / 1000);
+
+	for (i = 0; i < data->sensors_num; i++)
+		thermal_zone_device_update(data->sensors[i].tzd);
+
+	return IRQ_HANDLED;
+}
+
+static int hisi_thermal_init_sensor(struct platform_device *pdev,
+					struct device_node *np,
+					struct hisi_thermal_data *data,
+					int index)
+{
+	struct hisi_thermal_sensor *sensor;
+	int ret, i;
+
+	sensor = &data->sensors[index];
+
+	ret = of_property_read_u32(np, "hisilicon,tsensor-id",
+					&sensor->id);
+	if (ret) {
+		dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
+		return ret;
+	}
+
+	sensor->thermal = data;
+	sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev, sensor->id,
+				sensor, &hisi_of_thermal_ops);
+	if (IS_ERR(sensor->tzd)) {
+		ret = PTR_ERR(sensor->tzd);
+		dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
+			sensor->id, ret);
+		return ret;
+	}
+
+	sensor->trip = of_thermal_get_trip_points(sensor->tzd);
+
+	for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
+		if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
+			sensor->thres_temp = sensor->trip[i].temperature;
+			break;
+		}
+	}
+
+	return 0;
+}
+
+static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
+{
+	struct hisi_thermal_data *data = platform_get_drvdata(pdev);
+	struct device_node *np = pdev->dev.of_node;
+	struct device_node *child_np;
+	int ret, i, index;
+
+	/* sensor initialization */
+	index = 0;
+	for_each_child_of_node(np, child_np) {
+
+		if (index >= HISI_MAX_SENSORS) {
+			dev_err(&pdev->dev, "unsupported sensor number\n");
+			ret = -EINVAL;
+			goto err_init_sensors;
+		}
+
+		ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
+		if (ret)
+			goto err_init_sensors;
+
+		index++;
+	}
+
+	data->sensors_num = index;
+	return 0;
+
+err_init_sensors:
+	for (i = 0; i < index; i++)
+		thermal_zone_of_sensor_unregister(&pdev->dev,
+				data->sensors[i].tzd);
+	return ret;
+}
+
+static const struct of_device_id of_hisi_thermal_match[] = {
+	{ .compatible = "hisilicon,tsensor" },
+	{ /* end */ }
+};
+MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
+
+static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor *sensor,
+				       bool on)
+{
+	struct thermal_zone_device *tzd = sensor->tzd;
+
+	tzd->ops->set_mode(tzd,
+		on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
+}
+
+static int hisi_thermal_probe(struct platform_device *pdev)
+{
+	struct hisi_thermal_data *data;
+	struct resource *res;
+	int i;
+	int ret;
+
+	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
+	if (!data)
+		return -ENOMEM;
+
+	data->pdev = pdev;
+
+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	data->regs = devm_ioremap_resource(&pdev->dev, res);
+	if (IS_ERR(data->regs)) {
+		dev_err(&pdev->dev, "failed to get io address\n");
+		return PTR_ERR(data->regs);
+	}
+
+	data->irq = platform_get_irq(pdev, 0);
+	if (data->irq < 0)
+		return data->irq;
+
+	ret = devm_request_threaded_irq(&pdev->dev, data->irq,
+			hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
+			0, "hisi_thermal", data);
+	if (ret < 0) {
+		dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
+		return ret;
+	}
+
+	platform_set_drvdata(pdev, data);
+
+	data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
+	if (IS_ERR(data->clk)) {
+		ret = PTR_ERR(data->clk);
+		if (ret != -EPROBE_DEFER)
+			dev_err(&pdev->dev,
+				"failed to get thermal clk: %d\n", ret);
+		return ret;
+	}
+
+	/* enable clock for thermal */
+	ret = clk_prepare_enable(data->clk);
+	if (ret) {
+		dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
+		return ret;
+	}
+
+	ret = hisi_thermal_get_sensor_data(pdev);
+	if (ret) {
+		dev_err(&pdev->dev, "failed to get sensor data\n");
+		goto err_get_sensor_data;
+		return ret;
+	}
+
+	hisi_thermal_enable_sensor(data);
+	data->irq_enabled = true;
+
+	for (i = 0; i < data->sensors_num; i++)
+		hisi_thermal_toggle_sensor(&data->sensors[i], true);
+
+	return 0;
+
+err_get_sensor_data:
+	clk_disable_unprepare(data->clk);
+	return ret;
+}
+
+static int hisi_thermal_remove(struct platform_device *pdev)
+{
+	struct hisi_thermal_data *data = platform_get_drvdata(pdev);
+	int i;
+
+	for (i = 0; i < data->sensors_num; i++) {
+		struct hisi_thermal_sensor *sensor = &data->sensors[i];
+
+		hisi_thermal_toggle_sensor(sensor, false);
+		thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
+	}
+
+	hisi_thermal_disable_sensor(data);
+	clk_disable_unprepare(data->clk);
+	return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int hisi_thermal_suspend(struct device *dev)
+{
+	struct hisi_thermal_data *data = dev_get_drvdata(dev);
+
+	hisi_thermal_disable_sensor(data);
+	data->irq_enabled = false;
+
+	clk_disable_unprepare(data->clk);
+
+	return 0;
+}
+
+static int hisi_thermal_resume(struct device *dev)
+{
+	struct hisi_thermal_data *data = dev_get_drvdata(dev);
+
+	clk_prepare_enable(data->clk);
+
+	data->irq_enabled = true;
+	hisi_thermal_enable_sensor(data);
+
+	return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
+			 hisi_thermal_suspend, hisi_thermal_resume);
+
+static struct platform_driver hisi_thermal_driver = {
+	.driver = {
+		.name	= "hisi_thermal",
+		.owner  = THIS_MODULE,
+		.pm	= &hisi_thermal_pm_ops,
+		.of_match_table = of_hisi_thermal_match,
+	},
+	.probe		= hisi_thermal_probe,
+	.remove		= hisi_thermal_remove,
+};
+
+static int __init hisi_thermal_init(void)
+{
+	return platform_driver_register(&hisi_thermal_driver);
+}
+
+static void __exit hisi_thermal_exit(void)
+{
+	platform_driver_unregister(&hisi_thermal_driver);
+}
+
+late_initcall(hisi_thermal_init);
+module_exit(hisi_thermal_exit);
+
+MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
+MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
+MODULE_DESCRIPTION("Hisilicon thermal driver");
+MODULE_LICENSE("GPL v2");
-- 
1.9.1

[PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[Xinwei Kong]

From: kongxinwei <kong.kongxinwei@hisilicon.com>

This patch adds the support for hisilicon thermal sensor, within
hisilicon SoC. there will register sensors for thermal framework
and use device tree to bind cooling device.

Signed-off-by: Leo Yan <leo.yan@linaro.org>
Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
---
 drivers/thermal/Kconfig        |   8 +
 drivers/thermal/Makefile       |   1 +
 drivers/thermal/hisi_thermal.c | 526 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 535 insertions(+)
 create mode 100644 drivers/thermal/hisi_thermal.c

diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
index af40db0..81aee01 100644
--- a/drivers/thermal/Kconfig
+++ b/drivers/thermal/Kconfig
@@ -136,6 +136,14 @@ config THERMAL_EMULATION
 	  because userland can easily disable the thermal policy by simply
 	  flooding this sysfs node with low temperature values.
 
+config HISI_THERMAL
+	tristate "Hisilicon thermal driver"
+	depends on ARCH_HISI && CPU_THERMAL && OF
+	help
+	  Enable this to plug hisilicon's thermal sensor driver into the Linux
+	  thermal framework. cpufreq is used as the cooling device to throttle
+	  CPUs when the passive trip is crossed.
+
 config IMX_THERMAL
 	tristate "Temperature sensor driver for Freescale i.MX SoCs"
 	depends on CPU_THERMAL
diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
index fa0dc48..08ae7ac 100644
--- a/drivers/thermal/Makefile
+++ b/drivers/thermal/Makefile
@@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)	+= ti-soc-thermal/
 obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
 obj-$(CONFIG_ST_THERMAL)	+= st/
 obj-$(CONFIG_TEGRA_SOCTHERM)	+= tegra_soctherm.o
+obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
diff --git a/drivers/thermal/hisi_thermal.c b/drivers/thermal/hisi_thermal.c
new file mode 100644
index 0000000..8edf83a
--- /dev/null
+++ b/drivers/thermal/hisi_thermal.c
@@ -0,0 +1,526 @@
+/*
+ * Hisilicon thermal sensor driver
+ *
+ * Copyright (c) 2014-2015 Hisilicon Limited.
+ * Copyright (c) 2014-2015 Linaro Limited.
+ *
+ * Xinwei Kong <kong.kongxinwei@hisilicon.com>
+ * Leo Yan <leo.yan@linaro.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/cpu_cooling.h>
+#include <linux/cpufreq.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/mfd/syscon.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+#include <linux/thermal.h>
+#include <linux/types.h>
+
+#include "thermal_core.h"
+
+#define TEMP0_LAG			(0x0)
+#define TEMP0_TH			(0x4)
+#define TEMP0_RST_TH			(0x8)
+#define TEMP0_CFG			(0xC)
+#define TEMP0_EN			(0x10)
+#define TEMP0_INT_EN			(0x14)
+#define TEMP0_INT_CLR			(0x18)
+#define TEMP0_RST_MSK			(0x1C)
+#define TEMP0_RAW_INT			(0x20)
+#define TEMP0_MSK_INT			(0x24)
+#define TEMP0_VALUE			(0x28)
+
+#define HISI_TEMP_BASE			(-60)
+#define HISI_TEMP_RESET			(100000)
+#define HISI_TEMP_PASSIVE		(85000)
+
+#define HISI_MAX_SENSORS		4
+
+struct hisi_thermal_sensor {
+	struct hisi_thermal_data *thermal;
+	struct thermal_zone_device *tzd;
+	const struct thermal_trip *trip;
+
+	uint32_t id;
+	uint32_t thres_temp, reset_temp;
+};
+
+struct hisi_thermal_data {
+	struct platform_device *pdev;
+	struct clk *clk;
+
+	int irq, irq_bind_sensor;
+	bool irq_enabled;
+
+	unsigned int sensors_num;
+	long sensor_temp[HISI_MAX_SENSORS];
+	struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
+
+	void __iomem *regs;
+};
+
+static DEFINE_SPINLOCK(thermal_lock);
+
+/* in millicelsius */
+static inline int _step_to_temp(int step)
+{
+	/*
+	 * Every step equals (1 * 200) / 255 celsius, and finally
+	 * need convert to millicelsius.
+	 */
+	return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
+}
+
+static inline int _temp_to_step(int temp)
+{
+	return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
+}
+
+static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data *data,
+					 struct hisi_thermal_sensor *sensor)
+{
+	unsigned long flags;
+	int val;
+
+	spin_lock_irqsave(&thermal_lock, flags);
+
+	/* disable module firstly */
+	writel(0x0, data->regs + TEMP0_EN);
+
+	/* select sensor id */
+	writel((sensor->id << 12), data->regs + TEMP0_CFG);
+
+	/* enable module */
+	writel(0x1, data->regs + TEMP0_EN);
+
+	mdelay(5);
+
+	val = readl(data->regs + TEMP0_VALUE);
+	val = _step_to_temp(val);
+
+	/* adjust for negative value */
+	val = (val < 0) ? 0 : val;
+
+	spin_unlock_irqrestore(&thermal_lock, flags);
+
+	return val;
+}
+
+static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
+{
+	struct hisi_thermal_sensor *sensor;
+	unsigned long flags;
+
+	sensor = &data->sensors[data->irq_bind_sensor];
+
+	spin_lock_irqsave(&thermal_lock, flags);
+
+	/* setting the hdak time */
+	writel(0x0, data->regs + TEMP0_CFG);
+
+	/* disable module firstly */
+	writel(0x0, data->regs + TEMP0_RST_MSK);
+	writel(0x0, data->regs + TEMP0_EN);
+
+	/* select sensor id */
+	writel((sensor->id << 12), data->regs + TEMP0_CFG);
+
+	/* enable for interrupt */
+	writel(_temp_to_step(sensor->thres_temp)
+			| 0x0FFFFFF00, data->regs + TEMP0_TH);
+
+	writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
+
+	/* enable module */
+	writel(0x1, data->regs + TEMP0_RST_MSK);
+	writel(0x1, data->regs + TEMP0_EN);
+
+	writel(0x0, data->regs + TEMP0_INT_CLR);
+	writel(0x1, data->regs + TEMP0_INT_EN);
+
+	mdelay(5);
+
+	spin_unlock_irqrestore(&thermal_lock, flags);
+
+}
+
+static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
+{
+	struct hisi_thermal_sensor *sensor;
+	unsigned long flags;
+
+	sensor = &data->sensors[data->irq_bind_sensor];
+
+	spin_lock_irqsave(&thermal_lock, flags);
+
+	/* setting the hdak time */
+	writel(0x0, data->regs + TEMP0_CFG);
+
+	/* disable module firstly */
+	writel(0x0, data->regs + TEMP0_RST_MSK);
+	writel(0x0, data->regs + TEMP0_EN);
+
+	/* select sensor id */
+	writel((sensor->id << 12), data->regs + TEMP0_CFG);
+
+	/* enable for interrupt */
+	writel(_temp_to_step(sensor->thres_temp)
+			| 0x0FFFFFF00, data->regs + TEMP0_TH);
+
+	writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
+
+	/* enable module */
+	writel(0x1, data->regs + TEMP0_RST_MSK);
+	writel(0x1, data->regs + TEMP0_EN);
+
+	writel(0x0, data->regs + TEMP0_INT_CLR);
+	writel(0x1, data->regs + TEMP0_INT_EN);
+
+	mdelay(5);
+
+	spin_unlock_irqrestore(&thermal_lock, flags);
+
+}
+
+static void hisi_thermal_disable_sensor(struct hisi_thermal_data *data)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&thermal_lock, flags);
+
+	/* disable sensor module */
+	writel(0x0, data->regs + TEMP0_INT_EN);
+	writel(0x0, data->regs + TEMP0_RST_MSK);
+	writel(0x0, data->regs + TEMP0_EN);
+
+	spin_unlock_irqrestore(&thermal_lock, flags);
+
+}
+
+static int hisi_thermal_get_temp(void *_sensor, long *temp)
+{
+	struct hisi_thermal_sensor *sensor = _sensor;
+	struct hisi_thermal_data *data = sensor->thermal;
+
+	int sensor_id = 0, i;
+	long max_temp = 0;
+
+	*temp = hisi_thermal_get_sensor_temp(data, sensor);
+
+	data->sensor_temp[sensor->id] = *temp;
+
+	for (i = 0; i < HISI_MAX_SENSORS; i++) {
+		if (data->sensor_temp[i] >= max_temp) {
+			max_temp = data->sensor_temp[i];
+			sensor_id = i;
+		}
+	}
+
+	data->irq_bind_sensor = sensor_id;
+
+	dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
+		sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
+
+	/*
+	 * Bind irq to sensor for two cases:
+	 *   Reenable alarm IRQ if temperature below threshold;
+	 *   if irq has been enabled, always set it;
+	 */
+	if (!data->irq_enabled && max_temp < sensor->thres_temp) {
+		data->irq_enabled = true;
+		hisi_thermal_bind_irq(data);
+	} else if (data->irq_enabled)
+		hisi_thermal_bind_irq(data);
+
+	return 0;
+}
+
+static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
+	.get_temp = hisi_thermal_get_temp,
+};
+
+static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
+{
+	struct hisi_thermal_data *data = dev;
+	unsigned long flags;
+
+	spin_lock_irqsave(&thermal_lock, flags);
+
+	/* disable interrupt */
+	writel(0x0, data->regs + TEMP0_INT_EN);
+	writel(0x1, data->regs + TEMP0_INT_CLR);
+
+	spin_unlock_irqrestore(&thermal_lock, flags);
+	data->irq_enabled = false;
+
+	return IRQ_WAKE_THREAD;
+}
+
+static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
+{
+	struct hisi_thermal_data *data = dev;
+	struct hisi_thermal_sensor *sensor;
+	int i;
+
+	sensor = &data->sensors[data->irq_bind_sensor];
+
+	dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
+		 sensor->thres_temp / 1000);
+
+	for (i = 0; i < data->sensors_num; i++)
+		thermal_zone_device_update(data->sensors[i].tzd);
+
+	return IRQ_HANDLED;
+}
+
+static int hisi_thermal_init_sensor(struct platform_device *pdev,
+					struct device_node *np,
+					struct hisi_thermal_data *data,
+					int index)
+{
+	struct hisi_thermal_sensor *sensor;
+	int ret, i;
+
+	sensor = &data->sensors[index];
+
+	ret = of_property_read_u32(np, "hisilicon,tsensor-id",
+					&sensor->id);
+	if (ret) {
+		dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
+		return ret;
+	}
+
+	sensor->thermal = data;
+	sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev, sensor->id,
+				sensor, &hisi_of_thermal_ops);
+	if (IS_ERR(sensor->tzd)) {
+		ret = PTR_ERR(sensor->tzd);
+		dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
+			sensor->id, ret);
+		return ret;
+	}
+
+	sensor->trip = of_thermal_get_trip_points(sensor->tzd);
+
+	for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
+		if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
+			sensor->thres_temp = sensor->trip[i].temperature;
+			break;
+		}
+	}
+
+	return 0;
+}
+
+static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
+{
+	struct hisi_thermal_data *data = platform_get_drvdata(pdev);
+	struct device_node *np = pdev->dev.of_node;
+	struct device_node *child_np;
+	int ret, i, index;
+
+	/* sensor initialization */
+	index = 0;
+	for_each_child_of_node(np, child_np) {
+
+		if (index >= HISI_MAX_SENSORS) {
+			dev_err(&pdev->dev, "unsupported sensor number\n");
+			ret = -EINVAL;
+			goto err_init_sensors;
+		}
+
+		ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
+		if (ret)
+			goto err_init_sensors;
+
+		index++;
+	}
+
+	data->sensors_num = index;
+	return 0;
+
+err_init_sensors:
+	for (i = 0; i < index; i++)
+		thermal_zone_of_sensor_unregister(&pdev->dev,
+				data->sensors[i].tzd);
+	return ret;
+}
+
+static const struct of_device_id of_hisi_thermal_match[] = {
+	{ .compatible = "hisilicon,tsensor" },
+	{ /* end */ }
+};
+MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
+
+static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor *sensor,
+				       bool on)
+{
+	struct thermal_zone_device *tzd = sensor->tzd;
+
+	tzd->ops->set_mode(tzd,
+		on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
+}
+
+static int hisi_thermal_probe(struct platform_device *pdev)
+{
+	struct hisi_thermal_data *data;
+	struct resource *res;
+	int i;
+	int ret;
+
+	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
+	if (!data)
+		return -ENOMEM;
+
+	data->pdev = pdev;
+
+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	data->regs = devm_ioremap_resource(&pdev->dev, res);
+	if (IS_ERR(data->regs)) {
+		dev_err(&pdev->dev, "failed to get io address\n");
+		return PTR_ERR(data->regs);
+	}
+
+	data->irq = platform_get_irq(pdev, 0);
+	if (data->irq < 0)
+		return data->irq;
+
+	ret = devm_request_threaded_irq(&pdev->dev, data->irq,
+			hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
+			0, "hisi_thermal", data);
+	if (ret < 0) {
+		dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
+		return ret;
+	}
+
+	platform_set_drvdata(pdev, data);
+
+	data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
+	if (IS_ERR(data->clk)) {
+		ret = PTR_ERR(data->clk);
+		if (ret != -EPROBE_DEFER)
+			dev_err(&pdev->dev,
+				"failed to get thermal clk: %d\n", ret);
+		return ret;
+	}
+
+	/* enable clock for thermal */
+	ret = clk_prepare_enable(data->clk);
+	if (ret) {
+		dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
+		return ret;
+	}
+
+	ret = hisi_thermal_get_sensor_data(pdev);
+	if (ret) {
+		dev_err(&pdev->dev, "failed to get sensor data\n");
+		goto err_get_sensor_data;
+		return ret;
+	}
+
+	hisi_thermal_enable_sensor(data);
+	data->irq_enabled = true;
+
+	for (i = 0; i < data->sensors_num; i++)
+		hisi_thermal_toggle_sensor(&data->sensors[i], true);
+
+	return 0;
+
+err_get_sensor_data:
+	clk_disable_unprepare(data->clk);
+	return ret;
+}
+
+static int hisi_thermal_remove(struct platform_device *pdev)
+{
+	struct hisi_thermal_data *data = platform_get_drvdata(pdev);
+	int i;
+
+	for (i = 0; i < data->sensors_num; i++) {
+		struct hisi_thermal_sensor *sensor = &data->sensors[i];
+
+		hisi_thermal_toggle_sensor(sensor, false);
+		thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
+	}
+
+	hisi_thermal_disable_sensor(data);
+	clk_disable_unprepare(data->clk);
+	return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int hisi_thermal_suspend(struct device *dev)
+{
+	struct hisi_thermal_data *data = dev_get_drvdata(dev);
+
+	hisi_thermal_disable_sensor(data);
+	data->irq_enabled = false;
+
+	clk_disable_unprepare(data->clk);
+
+	return 0;
+}
+
+static int hisi_thermal_resume(struct device *dev)
+{
+	struct hisi_thermal_data *data = dev_get_drvdata(dev);
+
+	clk_prepare_enable(data->clk);
+
+	data->irq_enabled = true;
+	hisi_thermal_enable_sensor(data);
+
+	return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
+			 hisi_thermal_suspend, hisi_thermal_resume);
+
+static struct platform_driver hisi_thermal_driver = {
+	.driver = {
+		.name	= "hisi_thermal",
+		.owner  = THIS_MODULE,
+		.pm	= &hisi_thermal_pm_ops,
+		.of_match_table = of_hisi_thermal_match,
+	},
+	.probe		= hisi_thermal_probe,
+	.remove		= hisi_thermal_remove,
+};
+
+static int __init hisi_thermal_init(void)
+{
+	return platform_driver_register(&hisi_thermal_driver);
+}
+
+static void __exit hisi_thermal_exit(void)
+{
+	platform_driver_unregister(&hisi_thermal_driver);
+}
+
+late_initcall(hisi_thermal_init);
+module_exit(hisi_thermal_exit);
+
+MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
+MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
+MODULE_DESCRIPTION("Hisilicon thermal driver");
+MODULE_LICENSE("GPL v2");
-- 
1.9.1

[PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[Xinwei Kong]

From: kongxinwei <kong.kongxinwei@hisilicon.com>

This patch adds the support for hisilicon thermal sensor, within
hisilicon SoC. there will register sensors for thermal framework
and use device tree to bind cooling device.

Signed-off-by: Leo Yan <leo.yan@linaro.org>
Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
---
 drivers/thermal/Kconfig        |   8 +
 drivers/thermal/Makefile       |   1 +
 drivers/thermal/hisi_thermal.c | 526 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 535 insertions(+)
 create mode 100644 drivers/thermal/hisi_thermal.c

diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
index af40db0..81aee01 100644
--- a/drivers/thermal/Kconfig
+++ b/drivers/thermal/Kconfig
@@ -136,6 +136,14 @@ config THERMAL_EMULATION
 	  because userland can easily disable the thermal policy by simply
 	  flooding this sysfs node with low temperature values.
 
+config HISI_THERMAL
+	tristate "Hisilicon thermal driver"
+	depends on ARCH_HISI && CPU_THERMAL && OF
+	help
+	  Enable this to plug hisilicon's thermal sensor driver into the Linux
+	  thermal framework. cpufreq is used as the cooling device to throttle
+	  CPUs when the passive trip is crossed.
+
 config IMX_THERMAL
 	tristate "Temperature sensor driver for Freescale i.MX SoCs"
 	depends on CPU_THERMAL
diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
index fa0dc48..08ae7ac 100644
--- a/drivers/thermal/Makefile
+++ b/drivers/thermal/Makefile
@@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)	+= ti-soc-thermal/
 obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
 obj-$(CONFIG_ST_THERMAL)	+= st/
 obj-$(CONFIG_TEGRA_SOCTHERM)	+= tegra_soctherm.o
+obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
diff --git a/drivers/thermal/hisi_thermal.c b/drivers/thermal/hisi_thermal.c
new file mode 100644
index 0000000..8edf83a
--- /dev/null
+++ b/drivers/thermal/hisi_thermal.c
@@ -0,0 +1,526 @@
+/*
+ * Hisilicon thermal sensor driver
+ *
+ * Copyright (c) 2014-2015 Hisilicon Limited.
+ * Copyright (c) 2014-2015 Linaro Limited.
+ *
+ * Xinwei Kong <kong.kongxinwei@hisilicon.com>
+ * Leo Yan <leo.yan@linaro.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/cpu_cooling.h>
+#include <linux/cpufreq.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/mfd/syscon.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+#include <linux/thermal.h>
+#include <linux/types.h>
+
+#include "thermal_core.h"
+
+#define TEMP0_LAG			(0x0)
+#define TEMP0_TH			(0x4)
+#define TEMP0_RST_TH			(0x8)
+#define TEMP0_CFG			(0xC)
+#define TEMP0_EN			(0x10)
+#define TEMP0_INT_EN			(0x14)
+#define TEMP0_INT_CLR			(0x18)
+#define TEMP0_RST_MSK			(0x1C)
+#define TEMP0_RAW_INT			(0x20)
+#define TEMP0_MSK_INT			(0x24)
+#define TEMP0_VALUE			(0x28)
+
+#define HISI_TEMP_BASE			(-60)
+#define HISI_TEMP_RESET			(100000)
+#define HISI_TEMP_PASSIVE		(85000)
+
+#define HISI_MAX_SENSORS		4
+
+struct hisi_thermal_sensor {
+	struct hisi_thermal_data *thermal;
+	struct thermal_zone_device *tzd;
+	const struct thermal_trip *trip;
+
+	uint32_t id;
+	uint32_t thres_temp, reset_temp;
+};
+
+struct hisi_thermal_data {
+	struct platform_device *pdev;
+	struct clk *clk;
+
+	int irq, irq_bind_sensor;
+	bool irq_enabled;
+
+	unsigned int sensors_num;
+	long sensor_temp[HISI_MAX_SENSORS];
+	struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
+
+	void __iomem *regs;
+};
+
+static DEFINE_SPINLOCK(thermal_lock);
+
+/* in millicelsius */
+static inline int _step_to_temp(int step)
+{
+	/*
+	 * Every step equals (1 * 200) / 255 celsius, and finally
+	 * need convert to millicelsius.
+	 */
+	return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
+}
+
+static inline int _temp_to_step(int temp)
+{
+	return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
+}
+
+static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data *data,
+					 struct hisi_thermal_sensor *sensor)
+{
+	unsigned long flags;
+	int val;
+
+	spin_lock_irqsave(&thermal_lock, flags);
+
+	/* disable module firstly */
+	writel(0x0, data->regs + TEMP0_EN);
+
+	/* select sensor id */
+	writel((sensor->id << 12), data->regs + TEMP0_CFG);
+
+	/* enable module */
+	writel(0x1, data->regs + TEMP0_EN);
+
+	mdelay(5);
+
+	val = readl(data->regs + TEMP0_VALUE);
+	val = _step_to_temp(val);
+
+	/* adjust for negative value */
+	val = (val < 0) ? 0 : val;
+
+	spin_unlock_irqrestore(&thermal_lock, flags);
+
+	return val;
+}
+
+static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
+{
+	struct hisi_thermal_sensor *sensor;
+	unsigned long flags;
+
+	sensor = &data->sensors[data->irq_bind_sensor];
+
+	spin_lock_irqsave(&thermal_lock, flags);
+
+	/* setting the hdak time */
+	writel(0x0, data->regs + TEMP0_CFG);
+
+	/* disable module firstly */
+	writel(0x0, data->regs + TEMP0_RST_MSK);
+	writel(0x0, data->regs + TEMP0_EN);
+
+	/* select sensor id */
+	writel((sensor->id << 12), data->regs + TEMP0_CFG);
+
+	/* enable for interrupt */
+	writel(_temp_to_step(sensor->thres_temp)
+			| 0x0FFFFFF00, data->regs + TEMP0_TH);
+
+	writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
+
+	/* enable module */
+	writel(0x1, data->regs + TEMP0_RST_MSK);
+	writel(0x1, data->regs + TEMP0_EN);
+
+	writel(0x0, data->regs + TEMP0_INT_CLR);
+	writel(0x1, data->regs + TEMP0_INT_EN);
+
+	mdelay(5);
+
+	spin_unlock_irqrestore(&thermal_lock, flags);
+
+}
+
+static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
+{
+	struct hisi_thermal_sensor *sensor;
+	unsigned long flags;
+
+	sensor = &data->sensors[data->irq_bind_sensor];
+
+	spin_lock_irqsave(&thermal_lock, flags);
+
+	/* setting the hdak time */
+	writel(0x0, data->regs + TEMP0_CFG);
+
+	/* disable module firstly */
+	writel(0x0, data->regs + TEMP0_RST_MSK);
+	writel(0x0, data->regs + TEMP0_EN);
+
+	/* select sensor id */
+	writel((sensor->id << 12), data->regs + TEMP0_CFG);
+
+	/* enable for interrupt */
+	writel(_temp_to_step(sensor->thres_temp)
+			| 0x0FFFFFF00, data->regs + TEMP0_TH);
+
+	writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
+
+	/* enable module */
+	writel(0x1, data->regs + TEMP0_RST_MSK);
+	writel(0x1, data->regs + TEMP0_EN);
+
+	writel(0x0, data->regs + TEMP0_INT_CLR);
+	writel(0x1, data->regs + TEMP0_INT_EN);
+
+	mdelay(5);
+
+	spin_unlock_irqrestore(&thermal_lock, flags);
+
+}
+
+static void hisi_thermal_disable_sensor(struct hisi_thermal_data *data)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&thermal_lock, flags);
+
+	/* disable sensor module */
+	writel(0x0, data->regs + TEMP0_INT_EN);
+	writel(0x0, data->regs + TEMP0_RST_MSK);
+	writel(0x0, data->regs + TEMP0_EN);
+
+	spin_unlock_irqrestore(&thermal_lock, flags);
+
+}
+
+static int hisi_thermal_get_temp(void *_sensor, long *temp)
+{
+	struct hisi_thermal_sensor *sensor = _sensor;
+	struct hisi_thermal_data *data = sensor->thermal;
+
+	int sensor_id = 0, i;
+	long max_temp = 0;
+
+	*temp = hisi_thermal_get_sensor_temp(data, sensor);
+
+	data->sensor_temp[sensor->id] = *temp;
+
+	for (i = 0; i < HISI_MAX_SENSORS; i++) {
+		if (data->sensor_temp[i] >= max_temp) {
+			max_temp = data->sensor_temp[i];
+			sensor_id = i;
+		}
+	}
+
+	data->irq_bind_sensor = sensor_id;
+
+	dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
+		sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
+
+	/*
+	 * Bind irq to sensor for two cases:
+	 *   Reenable alarm IRQ if temperature below threshold;
+	 *   if irq has been enabled, always set it;
+	 */
+	if (!data->irq_enabled && max_temp < sensor->thres_temp) {
+		data->irq_enabled = true;
+		hisi_thermal_bind_irq(data);
+	} else if (data->irq_enabled)
+		hisi_thermal_bind_irq(data);
+
+	return 0;
+}
+
+static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
+	.get_temp = hisi_thermal_get_temp,
+};
+
+static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
+{
+	struct hisi_thermal_data *data = dev;
+	unsigned long flags;
+
+	spin_lock_irqsave(&thermal_lock, flags);
+
+	/* disable interrupt */
+	writel(0x0, data->regs + TEMP0_INT_EN);
+	writel(0x1, data->regs + TEMP0_INT_CLR);
+
+	spin_unlock_irqrestore(&thermal_lock, flags);
+	data->irq_enabled = false;
+
+	return IRQ_WAKE_THREAD;
+}
+
+static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
+{
+	struct hisi_thermal_data *data = dev;
+	struct hisi_thermal_sensor *sensor;
+	int i;
+
+	sensor = &data->sensors[data->irq_bind_sensor];
+
+	dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
+		 sensor->thres_temp / 1000);
+
+	for (i = 0; i < data->sensors_num; i++)
+		thermal_zone_device_update(data->sensors[i].tzd);
+
+	return IRQ_HANDLED;
+}
+
+static int hisi_thermal_init_sensor(struct platform_device *pdev,
+					struct device_node *np,
+					struct hisi_thermal_data *data,
+					int index)
+{
+	struct hisi_thermal_sensor *sensor;
+	int ret, i;
+
+	sensor = &data->sensors[index];
+
+	ret = of_property_read_u32(np, "hisilicon,tsensor-id",
+					&sensor->id);
+	if (ret) {
+		dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
+		return ret;
+	}
+
+	sensor->thermal = data;
+	sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev, sensor->id,
+				sensor, &hisi_of_thermal_ops);
+	if (IS_ERR(sensor->tzd)) {
+		ret = PTR_ERR(sensor->tzd);
+		dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
+			sensor->id, ret);
+		return ret;
+	}
+
+	sensor->trip = of_thermal_get_trip_points(sensor->tzd);
+
+	for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
+		if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
+			sensor->thres_temp = sensor->trip[i].temperature;
+			break;
+		}
+	}
+
+	return 0;
+}
+
+static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
+{
+	struct hisi_thermal_data *data = platform_get_drvdata(pdev);
+	struct device_node *np = pdev->dev.of_node;
+	struct device_node *child_np;
+	int ret, i, index;
+
+	/* sensor initialization */
+	index = 0;
+	for_each_child_of_node(np, child_np) {
+
+		if (index >= HISI_MAX_SENSORS) {
+			dev_err(&pdev->dev, "unsupported sensor number\n");
+			ret = -EINVAL;
+			goto err_init_sensors;
+		}
+
+		ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
+		if (ret)
+			goto err_init_sensors;
+
+		index++;
+	}
+
+	data->sensors_num = index;
+	return 0;
+
+err_init_sensors:
+	for (i = 0; i < index; i++)
+		thermal_zone_of_sensor_unregister(&pdev->dev,
+				data->sensors[i].tzd);
+	return ret;
+}
+
+static const struct of_device_id of_hisi_thermal_match[] = {
+	{ .compatible = "hisilicon,tsensor" },
+	{ /* end */ }
+};
+MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
+
+static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor *sensor,
+				       bool on)
+{
+	struct thermal_zone_device *tzd = sensor->tzd;
+
+	tzd->ops->set_mode(tzd,
+		on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
+}
+
+static int hisi_thermal_probe(struct platform_device *pdev)
+{
+	struct hisi_thermal_data *data;
+	struct resource *res;
+	int i;
+	int ret;
+
+	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
+	if (!data)
+		return -ENOMEM;
+
+	data->pdev = pdev;
+
+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	data->regs = devm_ioremap_resource(&pdev->dev, res);
+	if (IS_ERR(data->regs)) {
+		dev_err(&pdev->dev, "failed to get io address\n");
+		return PTR_ERR(data->regs);
+	}
+
+	data->irq = platform_get_irq(pdev, 0);
+	if (data->irq < 0)
+		return data->irq;
+
+	ret = devm_request_threaded_irq(&pdev->dev, data->irq,
+			hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
+			0, "hisi_thermal", data);
+	if (ret < 0) {
+		dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
+		return ret;
+	}
+
+	platform_set_drvdata(pdev, data);
+
+	data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
+	if (IS_ERR(data->clk)) {
+		ret = PTR_ERR(data->clk);
+		if (ret != -EPROBE_DEFER)
+			dev_err(&pdev->dev,
+				"failed to get thermal clk: %d\n", ret);
+		return ret;
+	}
+
+	/* enable clock for thermal */
+	ret = clk_prepare_enable(data->clk);
+	if (ret) {
+		dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
+		return ret;
+	}
+
+	ret = hisi_thermal_get_sensor_data(pdev);
+	if (ret) {
+		dev_err(&pdev->dev, "failed to get sensor data\n");
+		goto err_get_sensor_data;
+		return ret;
+	}
+
+	hisi_thermal_enable_sensor(data);
+	data->irq_enabled = true;
+
+	for (i = 0; i < data->sensors_num; i++)
+		hisi_thermal_toggle_sensor(&data->sensors[i], true);
+
+	return 0;
+
+err_get_sensor_data:
+	clk_disable_unprepare(data->clk);
+	return ret;
+}
+
+static int hisi_thermal_remove(struct platform_device *pdev)
+{
+	struct hisi_thermal_data *data = platform_get_drvdata(pdev);
+	int i;
+
+	for (i = 0; i < data->sensors_num; i++) {
+		struct hisi_thermal_sensor *sensor = &data->sensors[i];
+
+		hisi_thermal_toggle_sensor(sensor, false);
+		thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
+	}
+
+	hisi_thermal_disable_sensor(data);
+	clk_disable_unprepare(data->clk);
+	return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int hisi_thermal_suspend(struct device *dev)
+{
+	struct hisi_thermal_data *data = dev_get_drvdata(dev);
+
+	hisi_thermal_disable_sensor(data);
+	data->irq_enabled = false;
+
+	clk_disable_unprepare(data->clk);
+
+	return 0;
+}
+
+static int hisi_thermal_resume(struct device *dev)
+{
+	struct hisi_thermal_data *data = dev_get_drvdata(dev);
+
+	clk_prepare_enable(data->clk);
+
+	data->irq_enabled = true;
+	hisi_thermal_enable_sensor(data);
+
+	return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
+			 hisi_thermal_suspend, hisi_thermal_resume);
+
+static struct platform_driver hisi_thermal_driver = {
+	.driver = {
+		.name	= "hisi_thermal",
+		.owner  = THIS_MODULE,
+		.pm	= &hisi_thermal_pm_ops,
+		.of_match_table = of_hisi_thermal_match,
+	},
+	.probe		= hisi_thermal_probe,
+	.remove		= hisi_thermal_remove,
+};
+
+static int __init hisi_thermal_init(void)
+{
+	return platform_driver_register(&hisi_thermal_driver);
+}
+
+static void __exit hisi_thermal_exit(void)
+{
+	platform_driver_unregister(&hisi_thermal_driver);
+}
+
+late_initcall(hisi_thermal_init);
+module_exit(hisi_thermal_exit);
+
+MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
+MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
+MODULE_DESCRIPTION("Hisilicon thermal driver");
+MODULE_LICENSE("GPL v2");
-- 
1.9.1

Re: [PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[YiPing Xu]

在 2015/3/25 15:50, Xinwei Kong 写道:
> From: kongxinwei <kong.kongxinwei@hisilicon.com>
>
> This patch adds the support for hisilicon thermal sensor, within
> hisilicon SoC. there will register sensors for thermal framework
> and use device tree to bind cooling device.
>
> Signed-off-by: Leo Yan <leo.yan@linaro.org>
> Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
> ---
>   drivers/thermal/Kconfig        |   8 +
>   drivers/thermal/Makefile       |   1 +
>   drivers/thermal/hisi_thermal.c | 526 +++++++++++++++++++++++++++++++++++++++++
>   3 files changed, 535 insertions(+)
>   create mode 100644 drivers/thermal/hisi_thermal.c
>
> diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
> index af40db0..81aee01 100644
> --- a/drivers/thermal/Kconfig
> +++ b/drivers/thermal/Kconfig
> @@ -136,6 +136,14 @@ config THERMAL_EMULATION
>   	  because userland can easily disable the thermal policy by simply
>   	  flooding this sysfs node with low temperature values.
>
> +config HISI_THERMAL
> +	tristate "Hisilicon thermal driver"
> +	depends on ARCH_HISI && CPU_THERMAL && OF
> +	help
> +	  Enable this to plug hisilicon's thermal sensor driver into the Linux
> +	  thermal framework. cpufreq is used as the cooling device to throttle
> +	  CPUs when the passive trip is crossed.
> +
>   config IMX_THERMAL
>   	tristate "Temperature sensor driver for Freescale i.MX SoCs"
>   	depends on CPU_THERMAL
> diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
> index fa0dc48..08ae7ac 100644
> --- a/drivers/thermal/Makefile
> +++ b/drivers/thermal/Makefile
> @@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)	+= ti-soc-thermal/
>   obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
>   obj-$(CONFIG_ST_THERMAL)	+= st/
>   obj-$(CONFIG_TEGRA_SOCTHERM)	+= tegra_soctherm.o
> +obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
> diff --git a/drivers/thermal/hisi_thermal.c b/drivers/thermal/hisi_thermal.c
> new file mode 100644
> index 0000000..8edf83a
> --- /dev/null
> +++ b/drivers/thermal/hisi_thermal.c

    are you sure all the SOCs in hisilicon use the same thermal IP ?

    if not, this driver should not use the "hisi_" prefix.

> @@ -0,0 +1,526 @@
> +/*
> + * Hisilicon thermal sensor driver
> + *
> + * Copyright (c) 2014-2015 Hisilicon Limited.
> + * Copyright (c) 2014-2015 Linaro Limited.
> + *
> + * Xinwei Kong <kong.kongxinwei@hisilicon.com>
> + * Leo Yan <leo.yan@linaro.org>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed "as is" WITHOUT ANY WARRANTY of any
> + * kind, whether express or implied; without even the implied warranty
> + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + */
> +
> +#include <linux/cpu_cooling.h>
> +#include <linux/cpufreq.h>
> +#include <linux/delay.h>
> +#include <linux/device.h>
> +#include <linux/init.h>
> +#include <linux/interrupt.h>
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/mfd/syscon.h>
> +#include <linux/module.h>
> +#include <linux/of.h>
> +#include <linux/of_device.h>
> +#include <linux/platform_device.h>
> +#include <linux/regmap.h>
> +#include <linux/slab.h>
> +#include <linux/thermal.h>
> +#include <linux/types.h>
> +
> +#include "thermal_core.h"
> +
> +#define TEMP0_LAG			(0x0)
> +#define TEMP0_TH			(0x4)
> +#define TEMP0_RST_TH			(0x8)
> +#define TEMP0_CFG			(0xC)
> +#define TEMP0_EN			(0x10)
> +#define TEMP0_INT_EN			(0x14)
> +#define TEMP0_INT_CLR			(0x18)
> +#define TEMP0_RST_MSK			(0x1C)
> +#define TEMP0_RAW_INT			(0x20)
> +#define TEMP0_MSK_INT			(0x24)
> +#define TEMP0_VALUE			(0x28)
> +
> +#define HISI_TEMP_BASE			(-60)
> +#define HISI_TEMP_RESET			(100000)
> +#define HISI_TEMP_PASSIVE		(85000)
> +
> +#define HISI_MAX_SENSORS		4
> +
> +struct hisi_thermal_sensor {
> +	struct hisi_thermal_data *thermal;
> +	struct thermal_zone_device *tzd;
> +	const struct thermal_trip *trip;
> +
> +	uint32_t id;
> +	uint32_t thres_temp, reset_temp;
> +};
> +
> +struct hisi_thermal_data {
> +	struct platform_device *pdev;
> +	struct clk *clk;
> +
> +	int irq, irq_bind_sensor;
> +	bool irq_enabled;
> +
> +	unsigned int sensors_num;
> +	long sensor_temp[HISI_MAX_SENSORS];
> +	struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
> +
> +	void __iomem *regs;
> +};
> +
> +static DEFINE_SPINLOCK(thermal_lock);
> +

    "thermal_lock" should be defined in "hisi_thermal_data" to support 
multi device instance.

> +/* in millicelsius */
> +static inline int _step_to_temp(int step)
> +{
> +	/*
> +	 * Every step equals (1 * 200) / 255 celsius, and finally
> +	 * need convert to millicelsius.
> +	 */
> +	return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
> +}
> +
> +static inline int _temp_to_step(int temp)
> +{
> +	return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
> +}
> +
> +static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data *data,
> +					 struct hisi_thermal_sensor *sensor)
> +{
> +	unsigned long flags;
> +	int val;
> +
> +	spin_lock_irqsave(&thermal_lock, flags);
> +
> +	/* disable module firstly */
> +	writel(0x0, data->regs + TEMP0_EN);
> +
> +	/* select sensor id */
> +	writel((sensor->id << 12), data->regs + TEMP0_CFG);
> +
> +	/* enable module */
> +	writel(0x1, data->regs + TEMP0_EN);
> +
> +	mdelay(5);
> +
> +	val = readl(data->regs + TEMP0_VALUE);
> +	val = _step_to_temp(val);
> +
> +	/* adjust for negative value */
> +	val = (val < 0) ? 0 : val;
> +
> +	spin_unlock_irqrestore(&thermal_lock, flags);
> +
> +	return val;
> +}
> +
> +static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
> +{
> +	struct hisi_thermal_sensor *sensor;
> +	unsigned long flags;
> +
> +	sensor = &data->sensors[data->irq_bind_sensor];
> +
> +	spin_lock_irqsave(&thermal_lock, flags);
> +
> +	/* setting the hdak time */
> +	writel(0x0, data->regs + TEMP0_CFG);
> +
> +	/* disable module firstly */
> +	writel(0x0, data->regs + TEMP0_RST_MSK);
> +	writel(0x0, data->regs + TEMP0_EN);
> +
> +	/* select sensor id */
> +	writel((sensor->id << 12), data->regs + TEMP0_CFG);
> +
> +	/* enable for interrupt */
> +	writel(_temp_to_step(sensor->thres_temp)
> +			| 0x0FFFFFF00, data->regs + TEMP0_TH);
> +
> +	writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
> +
> +	/* enable module */
> +	writel(0x1, data->regs + TEMP0_RST_MSK);
> +	writel(0x1, data->regs + TEMP0_EN);
> +
> +	writel(0x0, data->regs + TEMP0_INT_CLR);
> +	writel(0x1, data->regs + TEMP0_INT_EN);
> +
> +	mdelay(5);
> +
> +	spin_unlock_irqrestore(&thermal_lock, flags);
> +
> +}
> +
> +static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
> +{
> +	struct hisi_thermal_sensor *sensor;
> +	unsigned long flags;
> +
> +	sensor = &data->sensors[data->irq_bind_sensor];
> +
> +	spin_lock_irqsave(&thermal_lock, flags);
> +
> +	/* setting the hdak time */
> +	writel(0x0, data->regs + TEMP0_CFG);
> +
> +	/* disable module firstly */
> +	writel(0x0, data->regs + TEMP0_RST_MSK);
> +	writel(0x0, data->regs + TEMP0_EN);
> +
> +	/* select sensor id */
> +	writel((sensor->id << 12), data->regs + TEMP0_CFG);
> +
> +	/* enable for interrupt */
> +	writel(_temp_to_step(sensor->thres_temp)
> +			| 0x0FFFFFF00, data->regs + TEMP0_TH);
> +
> +	writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
> +
> +	/* enable module */
> +	writel(0x1, data->regs + TEMP0_RST_MSK);
> +	writel(0x1, data->regs + TEMP0_EN);
> +
> +	writel(0x0, data->regs + TEMP0_INT_CLR);
> +	writel(0x1, data->regs + TEMP0_INT_EN);
> +
> +	mdelay(5);
> +
> +	spin_unlock_irqrestore(&thermal_lock, flags);
> +
> +}
> +
> +static void hisi_thermal_disable_sensor(struct hisi_thermal_data *data)
> +{
> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&thermal_lock, flags);
> +
> +	/* disable sensor module */
> +	writel(0x0, data->regs + TEMP0_INT_EN);
> +	writel(0x0, data->regs + TEMP0_RST_MSK);
> +	writel(0x0, data->regs + TEMP0_EN);
> +
> +	spin_unlock_irqrestore(&thermal_lock, flags);
> +
> +}
> +
> +static int hisi_thermal_get_temp(void *_sensor, long *temp)
> +{
> +	struct hisi_thermal_sensor *sensor = _sensor;
> +	struct hisi_thermal_data *data = sensor->thermal;
> +
> +	int sensor_id = 0, i;
> +	long max_temp = 0;
> +
> +	*temp = hisi_thermal_get_sensor_temp(data, sensor);
> +
> +	data->sensor_temp[sensor->id] = *temp;
> +
> +	for (i = 0; i < HISI_MAX_SENSORS; i++) {
> +		if (data->sensor_temp[i] >= max_temp) {
> +			max_temp = data->sensor_temp[i];
> +			sensor_id = i;
> +		}
> +	}
> +
> +	data->irq_bind_sensor = sensor_id;
> +
> +	dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
> +		sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
> +
> +	/*
> +	 * Bind irq to sensor for two cases:
> +	 *   Reenable alarm IRQ if temperature below threshold;
> +	 *   if irq has been enabled, always set it;
> +	 */
> +	if (!data->irq_enabled && max_temp < sensor->thres_temp) {
> +		data->irq_enabled = true;
> +		hisi_thermal_bind_irq(data);
> +	} else if (data->irq_enabled)
> +		hisi_thermal_bind_irq(data);
> +
> +	return 0;
> +}
> +
> +static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
> +	.get_temp = hisi_thermal_get_temp,
> +};
> +
> +static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
> +{
> +	struct hisi_thermal_data *data = dev;
> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&thermal_lock, flags);
> +
> +	/* disable interrupt */
> +	writel(0x0, data->regs + TEMP0_INT_EN);
> +	writel(0x1, data->regs + TEMP0_INT_CLR);
> +
> +	spin_unlock_irqrestore(&thermal_lock, flags);
> +	data->irq_enabled = false;
> +
> +	return IRQ_WAKE_THREAD;
> +}
> +
> +static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
> +{
> +	struct hisi_thermal_data *data = dev;
> +	struct hisi_thermal_sensor *sensor;
> +	int i;
> +
> +	sensor = &data->sensors[data->irq_bind_sensor];
> +
> +	dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
> +		 sensor->thres_temp / 1000);
> +
> +	for (i = 0; i < data->sensors_num; i++)
> +		thermal_zone_device_update(data->sensors[i].tzd);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static int hisi_thermal_init_sensor(struct platform_device *pdev,
> +					struct device_node *np,
> +					struct hisi_thermal_data *data,
> +					int index)
> +{
> +	struct hisi_thermal_sensor *sensor;
> +	int ret, i;
> +
> +	sensor = &data->sensors[index];
> +
> +	ret = of_property_read_u32(np, "hisilicon,tsensor-id",
> +					&sensor->id);
> +	if (ret) {
> +		dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
> +		return ret;
> +	}
> +
> +	sensor->thermal = data;
> +	sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev, sensor->id,
> +				sensor, &hisi_of_thermal_ops);
> +	if (IS_ERR(sensor->tzd)) {
> +		ret = PTR_ERR(sensor->tzd);
> +		dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
> +			sensor->id, ret);
> +		return ret;
> +	}
> +
> +	sensor->trip = of_thermal_get_trip_points(sensor->tzd);
> +
> +	for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
> +		if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
> +			sensor->thres_temp = sensor->trip[i].temperature;
> +			break;
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
> +{
> +	struct hisi_thermal_data *data = platform_get_drvdata(pdev);
> +	struct device_node *np = pdev->dev.of_node;
> +	struct device_node *child_np;
> +	int ret, i, index;
> +
> +	/* sensor initialization */
> +	index = 0;
> +	for_each_child_of_node(np, child_np) {
> +
> +		if (index >= HISI_MAX_SENSORS) {
> +			dev_err(&pdev->dev, "unsupported sensor number\n");
> +			ret = -EINVAL;
> +			goto err_init_sensors;
> +		}
> +
> +		ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
> +		if (ret)
> +			goto err_init_sensors;
> +
> +		index++;
> +	}
> +
> +	data->sensors_num = index;
> +	return 0;
> +
> +err_init_sensors:
> +	for (i = 0; i < index; i++)
> +		thermal_zone_of_sensor_unregister(&pdev->dev,
> +				data->sensors[i].tzd);
> +	return ret;
> +}
> +
> +static const struct of_device_id of_hisi_thermal_match[] = {
> +	{ .compatible = "hisilicon,tsensor" },
> +	{ /* end */ }
> +};
> +MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
> +
> +static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor *sensor,
> +				       bool on)
> +{
> +	struct thermal_zone_device *tzd = sensor->tzd;
> +
> +	tzd->ops->set_mode(tzd,
> +		on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
> +}
> +
> +static int hisi_thermal_probe(struct platform_device *pdev)
> +{
> +	struct hisi_thermal_data *data;
> +	struct resource *res;
> +	int i;
> +	int ret;
> +
> +	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
> +	if (!data)
> +		return -ENOMEM;
> +
> +	data->pdev = pdev;
> +
> +	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> +	data->regs = devm_ioremap_resource(&pdev->dev, res);
> +	if (IS_ERR(data->regs)) {
> +		dev_err(&pdev->dev, "failed to get io address\n");
> +		return PTR_ERR(data->regs);
> +	}
> +
> +	data->irq = platform_get_irq(pdev, 0);
> +	if (data->irq < 0)
> +		return data->irq;
> +
> +	ret = devm_request_threaded_irq(&pdev->dev, data->irq,
> +			hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
> +			0, "hisi_thermal", data);
> +	if (ret < 0) {
> +		dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
> +		return ret;
> +	}
> +
> +	platform_set_drvdata(pdev, data);
> +
> +	data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
> +	if (IS_ERR(data->clk)) {
> +		ret = PTR_ERR(data->clk);
> +		if (ret != -EPROBE_DEFER)
> +			dev_err(&pdev->dev,
> +				"failed to get thermal clk: %d\n", ret);
> +		return ret;
> +	}
> +
> +	/* enable clock for thermal */
> +	ret = clk_prepare_enable(data->clk);
> +	if (ret) {
> +		dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
> +		return ret;
> +	}
> +
> +	ret = hisi_thermal_get_sensor_data(pdev);
> +	if (ret) {
> +		dev_err(&pdev->dev, "failed to get sensor data\n");
> +		goto err_get_sensor_data;
> +		return ret;
> +	}
> +
> +	hisi_thermal_enable_sensor(data);
> +	data->irq_enabled = true;
> +
> +	for (i = 0; i < data->sensors_num; i++)
> +		hisi_thermal_toggle_sensor(&data->sensors[i], true);
> +
> +	return 0;
> +
> +err_get_sensor_data:
> +	clk_disable_unprepare(data->clk);
> +	return ret;
> +}
> +
> +static int hisi_thermal_remove(struct platform_device *pdev)
> +{
> +	struct hisi_thermal_data *data = platform_get_drvdata(pdev);
> +	int i;
> +
> +	for (i = 0; i < data->sensors_num; i++) {
> +		struct hisi_thermal_sensor *sensor = &data->sensors[i];
> +
> +		hisi_thermal_toggle_sensor(sensor, false);
> +		thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
> +	}
> +
> +	hisi_thermal_disable_sensor(data);
> +	clk_disable_unprepare(data->clk);
> +	return 0;
> +}
> +
> +#ifdef CONFIG_PM_SLEEP
> +static int hisi_thermal_suspend(struct device *dev)
> +{
> +	struct hisi_thermal_data *data = dev_get_drvdata(dev);
> +
> +	hisi_thermal_disable_sensor(data);
> +	data->irq_enabled = false;
> +
> +	clk_disable_unprepare(data->clk);
> +
> +	return 0;
> +}
> +
> +static int hisi_thermal_resume(struct device *dev)
> +{
> +	struct hisi_thermal_data *data = dev_get_drvdata(dev);
> +
> +	clk_prepare_enable(data->clk);
> +
> +	data->irq_enabled = true;
> +	hisi_thermal_enable_sensor(data);
> +
> +	return 0;
> +}
> +#endif
> +
> +static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
> +			 hisi_thermal_suspend, hisi_thermal_resume);
> +
> +static struct platform_driver hisi_thermal_driver = {
> +	.driver = {
> +		.name	= "hisi_thermal",
> +		.owner  = THIS_MODULE,
> +		.pm	= &hisi_thermal_pm_ops,
> +		.of_match_table = of_hisi_thermal_match,
> +	},
> +	.probe		= hisi_thermal_probe,
> +	.remove		= hisi_thermal_remove,
> +};
> +
> +static int __init hisi_thermal_init(void)
> +{
> +	return platform_driver_register(&hisi_thermal_driver);
> +}
> +
> +static void __exit hisi_thermal_exit(void)
> +{
> +	platform_driver_unregister(&hisi_thermal_driver);
> +}
> +
> +late_initcall(hisi_thermal_init);
> +module_exit(hisi_thermal_exit);
> +
> +MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
> +MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
> +MODULE_DESCRIPTION("Hisilicon thermal driver");
> +MODULE_LICENSE("GPL v2");
>

[PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[YiPing Xu]

? 2015/3/25 15:50, Xinwei Kong ??:
> From: kongxinwei <kong.kongxinwei@hisilicon.com>
>
> This patch adds the support for hisilicon thermal sensor, within
> hisilicon SoC. there will register sensors for thermal framework
> and use device tree to bind cooling device.
>
> Signed-off-by: Leo Yan <leo.yan@linaro.org>
> Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
> ---
>   drivers/thermal/Kconfig        |   8 +
>   drivers/thermal/Makefile       |   1 +
>   drivers/thermal/hisi_thermal.c | 526 +++++++++++++++++++++++++++++++++++++++++
>   3 files changed, 535 insertions(+)
>   create mode 100644 drivers/thermal/hisi_thermal.c
>
> diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
> index af40db0..81aee01 100644
> --- a/drivers/thermal/Kconfig
> +++ b/drivers/thermal/Kconfig
> @@ -136,6 +136,14 @@ config THERMAL_EMULATION
>   	  because userland can easily disable the thermal policy by simply
>   	  flooding this sysfs node with low temperature values.
>
> +config HISI_THERMAL
> +	tristate "Hisilicon thermal driver"
> +	depends on ARCH_HISI && CPU_THERMAL && OF
> +	help
> +	  Enable this to plug hisilicon's thermal sensor driver into the Linux
> +	  thermal framework. cpufreq is used as the cooling device to throttle
> +	  CPUs when the passive trip is crossed.
> +
>   config IMX_THERMAL
>   	tristate "Temperature sensor driver for Freescale i.MX SoCs"
>   	depends on CPU_THERMAL
> diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
> index fa0dc48..08ae7ac 100644
> --- a/drivers/thermal/Makefile
> +++ b/drivers/thermal/Makefile
> @@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)	+= ti-soc-thermal/
>   obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
>   obj-$(CONFIG_ST_THERMAL)	+= st/
>   obj-$(CONFIG_TEGRA_SOCTHERM)	+= tegra_soctherm.o
> +obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
> diff --git a/drivers/thermal/hisi_thermal.c b/drivers/thermal/hisi_thermal.c
> new file mode 100644
> index 0000000..8edf83a
> --- /dev/null
> +++ b/drivers/thermal/hisi_thermal.c

    are you sure all the SOCs in hisilicon use the same thermal IP ?

    if not, this driver should not use the "hisi_" prefix.

> @@ -0,0 +1,526 @@
> +/*
> + * Hisilicon thermal sensor driver
> + *
> + * Copyright (c) 2014-2015 Hisilicon Limited.
> + * Copyright (c) 2014-2015 Linaro Limited.
> + *
> + * Xinwei Kong <kong.kongxinwei@hisilicon.com>
> + * Leo Yan <leo.yan@linaro.org>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed "as is" WITHOUT ANY WARRANTY of any
> + * kind, whether express or implied; without even the implied warranty
> + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + */
> +
> +#include <linux/cpu_cooling.h>
> +#include <linux/cpufreq.h>
> +#include <linux/delay.h>
> +#include <linux/device.h>
> +#include <linux/init.h>
> +#include <linux/interrupt.h>
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/mfd/syscon.h>
> +#include <linux/module.h>
> +#include <linux/of.h>
> +#include <linux/of_device.h>
> +#include <linux/platform_device.h>
> +#include <linux/regmap.h>
> +#include <linux/slab.h>
> +#include <linux/thermal.h>
> +#include <linux/types.h>
> +
> +#include "thermal_core.h"
> +
> +#define TEMP0_LAG			(0x0)
> +#define TEMP0_TH			(0x4)
> +#define TEMP0_RST_TH			(0x8)
> +#define TEMP0_CFG			(0xC)
> +#define TEMP0_EN			(0x10)
> +#define TEMP0_INT_EN			(0x14)
> +#define TEMP0_INT_CLR			(0x18)
> +#define TEMP0_RST_MSK			(0x1C)
> +#define TEMP0_RAW_INT			(0x20)
> +#define TEMP0_MSK_INT			(0x24)
> +#define TEMP0_VALUE			(0x28)
> +
> +#define HISI_TEMP_BASE			(-60)
> +#define HISI_TEMP_RESET			(100000)
> +#define HISI_TEMP_PASSIVE		(85000)
> +
> +#define HISI_MAX_SENSORS		4
> +
> +struct hisi_thermal_sensor {
> +	struct hisi_thermal_data *thermal;
> +	struct thermal_zone_device *tzd;
> +	const struct thermal_trip *trip;
> +
> +	uint32_t id;
> +	uint32_t thres_temp, reset_temp;
> +};
> +
> +struct hisi_thermal_data {
> +	struct platform_device *pdev;
> +	struct clk *clk;
> +
> +	int irq, irq_bind_sensor;
> +	bool irq_enabled;
> +
> +	unsigned int sensors_num;
> +	long sensor_temp[HISI_MAX_SENSORS];
> +	struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
> +
> +	void __iomem *regs;
> +};
> +
> +static DEFINE_SPINLOCK(thermal_lock);
> +

    "thermal_lock" should be defined in "hisi_thermal_data" to support 
multi device instance.

> +/* in millicelsius */
> +static inline int _step_to_temp(int step)
> +{
> +	/*
> +	 * Every step equals (1 * 200) / 255 celsius, and finally
> +	 * need convert to millicelsius.
> +	 */
> +	return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
> +}
> +
> +static inline int _temp_to_step(int temp)
> +{
> +	return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
> +}
> +
> +static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data *data,
> +					 struct hisi_thermal_sensor *sensor)
> +{
> +	unsigned long flags;
> +	int val;
> +
> +	spin_lock_irqsave(&thermal_lock, flags);
> +
> +	/* disable module firstly */
> +	writel(0x0, data->regs + TEMP0_EN);
> +
> +	/* select sensor id */
> +	writel((sensor->id << 12), data->regs + TEMP0_CFG);
> +
> +	/* enable module */
> +	writel(0x1, data->regs + TEMP0_EN);
> +
> +	mdelay(5);
> +
> +	val = readl(data->regs + TEMP0_VALUE);
> +	val = _step_to_temp(val);
> +
> +	/* adjust for negative value */
> +	val = (val < 0) ? 0 : val;
> +
> +	spin_unlock_irqrestore(&thermal_lock, flags);
> +
> +	return val;
> +}
> +
> +static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
> +{
> +	struct hisi_thermal_sensor *sensor;
> +	unsigned long flags;
> +
> +	sensor = &data->sensors[data->irq_bind_sensor];
> +
> +	spin_lock_irqsave(&thermal_lock, flags);
> +
> +	/* setting the hdak time */
> +	writel(0x0, data->regs + TEMP0_CFG);
> +
> +	/* disable module firstly */
> +	writel(0x0, data->regs + TEMP0_RST_MSK);
> +	writel(0x0, data->regs + TEMP0_EN);
> +
> +	/* select sensor id */
> +	writel((sensor->id << 12), data->regs + TEMP0_CFG);
> +
> +	/* enable for interrupt */
> +	writel(_temp_to_step(sensor->thres_temp)
> +			| 0x0FFFFFF00, data->regs + TEMP0_TH);
> +
> +	writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
> +
> +	/* enable module */
> +	writel(0x1, data->regs + TEMP0_RST_MSK);
> +	writel(0x1, data->regs + TEMP0_EN);
> +
> +	writel(0x0, data->regs + TEMP0_INT_CLR);
> +	writel(0x1, data->regs + TEMP0_INT_EN);
> +
> +	mdelay(5);
> +
> +	spin_unlock_irqrestore(&thermal_lock, flags);
> +
> +}
> +
> +static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
> +{
> +	struct hisi_thermal_sensor *sensor;
> +	unsigned long flags;
> +
> +	sensor = &data->sensors[data->irq_bind_sensor];
> +
> +	spin_lock_irqsave(&thermal_lock, flags);
> +
> +	/* setting the hdak time */
> +	writel(0x0, data->regs + TEMP0_CFG);
> +
> +	/* disable module firstly */
> +	writel(0x0, data->regs + TEMP0_RST_MSK);
> +	writel(0x0, data->regs + TEMP0_EN);
> +
> +	/* select sensor id */
> +	writel((sensor->id << 12), data->regs + TEMP0_CFG);
> +
> +	/* enable for interrupt */
> +	writel(_temp_to_step(sensor->thres_temp)
> +			| 0x0FFFFFF00, data->regs + TEMP0_TH);
> +
> +	writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
> +
> +	/* enable module */
> +	writel(0x1, data->regs + TEMP0_RST_MSK);
> +	writel(0x1, data->regs + TEMP0_EN);
> +
> +	writel(0x0, data->regs + TEMP0_INT_CLR);
> +	writel(0x1, data->regs + TEMP0_INT_EN);
> +
> +	mdelay(5);
> +
> +	spin_unlock_irqrestore(&thermal_lock, flags);
> +
> +}
> +
> +static void hisi_thermal_disable_sensor(struct hisi_thermal_data *data)
> +{
> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&thermal_lock, flags);
> +
> +	/* disable sensor module */
> +	writel(0x0, data->regs + TEMP0_INT_EN);
> +	writel(0x0, data->regs + TEMP0_RST_MSK);
> +	writel(0x0, data->regs + TEMP0_EN);
> +
> +	spin_unlock_irqrestore(&thermal_lock, flags);
> +
> +}
> +
> +static int hisi_thermal_get_temp(void *_sensor, long *temp)
> +{
> +	struct hisi_thermal_sensor *sensor = _sensor;
> +	struct hisi_thermal_data *data = sensor->thermal;
> +
> +	int sensor_id = 0, i;
> +	long max_temp = 0;
> +
> +	*temp = hisi_thermal_get_sensor_temp(data, sensor);
> +
> +	data->sensor_temp[sensor->id] = *temp;
> +
> +	for (i = 0; i < HISI_MAX_SENSORS; i++) {
> +		if (data->sensor_temp[i] >= max_temp) {
> +			max_temp = data->sensor_temp[i];
> +			sensor_id = i;
> +		}
> +	}
> +
> +	data->irq_bind_sensor = sensor_id;
> +
> +	dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
> +		sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
> +
> +	/*
> +	 * Bind irq to sensor for two cases:
> +	 *   Reenable alarm IRQ if temperature below threshold;
> +	 *   if irq has been enabled, always set it;
> +	 */
> +	if (!data->irq_enabled && max_temp < sensor->thres_temp) {
> +		data->irq_enabled = true;
> +		hisi_thermal_bind_irq(data);
> +	} else if (data->irq_enabled)
> +		hisi_thermal_bind_irq(data);
> +
> +	return 0;
> +}
> +
> +static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
> +	.get_temp = hisi_thermal_get_temp,
> +};
> +
> +static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
> +{
> +	struct hisi_thermal_data *data = dev;
> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&thermal_lock, flags);
> +
> +	/* disable interrupt */
> +	writel(0x0, data->regs + TEMP0_INT_EN);
> +	writel(0x1, data->regs + TEMP0_INT_CLR);
> +
> +	spin_unlock_irqrestore(&thermal_lock, flags);
> +	data->irq_enabled = false;
> +
> +	return IRQ_WAKE_THREAD;
> +}
> +
> +static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
> +{
> +	struct hisi_thermal_data *data = dev;
> +	struct hisi_thermal_sensor *sensor;
> +	int i;
> +
> +	sensor = &data->sensors[data->irq_bind_sensor];
> +
> +	dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
> +		 sensor->thres_temp / 1000);
> +
> +	for (i = 0; i < data->sensors_num; i++)
> +		thermal_zone_device_update(data->sensors[i].tzd);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static int hisi_thermal_init_sensor(struct platform_device *pdev,
> +					struct device_node *np,
> +					struct hisi_thermal_data *data,
> +					int index)
> +{
> +	struct hisi_thermal_sensor *sensor;
> +	int ret, i;
> +
> +	sensor = &data->sensors[index];
> +
> +	ret = of_property_read_u32(np, "hisilicon,tsensor-id",
> +					&sensor->id);
> +	if (ret) {
> +		dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
> +		return ret;
> +	}
> +
> +	sensor->thermal = data;
> +	sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev, sensor->id,
> +				sensor, &hisi_of_thermal_ops);
> +	if (IS_ERR(sensor->tzd)) {
> +		ret = PTR_ERR(sensor->tzd);
> +		dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
> +			sensor->id, ret);
> +		return ret;
> +	}
> +
> +	sensor->trip = of_thermal_get_trip_points(sensor->tzd);
> +
> +	for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
> +		if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
> +			sensor->thres_temp = sensor->trip[i].temperature;
> +			break;
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
> +{
> +	struct hisi_thermal_data *data = platform_get_drvdata(pdev);
> +	struct device_node *np = pdev->dev.of_node;
> +	struct device_node *child_np;
> +	int ret, i, index;
> +
> +	/* sensor initialization */
> +	index = 0;
> +	for_each_child_of_node(np, child_np) {
> +
> +		if (index >= HISI_MAX_SENSORS) {
> +			dev_err(&pdev->dev, "unsupported sensor number\n");
> +			ret = -EINVAL;
> +			goto err_init_sensors;
> +		}
> +
> +		ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
> +		if (ret)
> +			goto err_init_sensors;
> +
> +		index++;
> +	}
> +
> +	data->sensors_num = index;
> +	return 0;
> +
> +err_init_sensors:
> +	for (i = 0; i < index; i++)
> +		thermal_zone_of_sensor_unregister(&pdev->dev,
> +				data->sensors[i].tzd);
> +	return ret;
> +}
> +
> +static const struct of_device_id of_hisi_thermal_match[] = {
> +	{ .compatible = "hisilicon,tsensor" },
> +	{ /* end */ }
> +};
> +MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
> +
> +static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor *sensor,
> +				       bool on)
> +{
> +	struct thermal_zone_device *tzd = sensor->tzd;
> +
> +	tzd->ops->set_mode(tzd,
> +		on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
> +}
> +
> +static int hisi_thermal_probe(struct platform_device *pdev)
> +{
> +	struct hisi_thermal_data *data;
> +	struct resource *res;
> +	int i;
> +	int ret;
> +
> +	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
> +	if (!data)
> +		return -ENOMEM;
> +
> +	data->pdev = pdev;
> +
> +	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> +	data->regs = devm_ioremap_resource(&pdev->dev, res);
> +	if (IS_ERR(data->regs)) {
> +		dev_err(&pdev->dev, "failed to get io address\n");
> +		return PTR_ERR(data->regs);
> +	}
> +
> +	data->irq = platform_get_irq(pdev, 0);
> +	if (data->irq < 0)
> +		return data->irq;
> +
> +	ret = devm_request_threaded_irq(&pdev->dev, data->irq,
> +			hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
> +			0, "hisi_thermal", data);
> +	if (ret < 0) {
> +		dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
> +		return ret;
> +	}
> +
> +	platform_set_drvdata(pdev, data);
> +
> +	data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
> +	if (IS_ERR(data->clk)) {
> +		ret = PTR_ERR(data->clk);
> +		if (ret != -EPROBE_DEFER)
> +			dev_err(&pdev->dev,
> +				"failed to get thermal clk: %d\n", ret);
> +		return ret;
> +	}
> +
> +	/* enable clock for thermal */
> +	ret = clk_prepare_enable(data->clk);
> +	if (ret) {
> +		dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
> +		return ret;
> +	}
> +
> +	ret = hisi_thermal_get_sensor_data(pdev);
> +	if (ret) {
> +		dev_err(&pdev->dev, "failed to get sensor data\n");
> +		goto err_get_sensor_data;
> +		return ret;
> +	}
> +
> +	hisi_thermal_enable_sensor(data);
> +	data->irq_enabled = true;
> +
> +	for (i = 0; i < data->sensors_num; i++)
> +		hisi_thermal_toggle_sensor(&data->sensors[i], true);
> +
> +	return 0;
> +
> +err_get_sensor_data:
> +	clk_disable_unprepare(data->clk);
> +	return ret;
> +}
> +
> +static int hisi_thermal_remove(struct platform_device *pdev)
> +{
> +	struct hisi_thermal_data *data = platform_get_drvdata(pdev);
> +	int i;
> +
> +	for (i = 0; i < data->sensors_num; i++) {
> +		struct hisi_thermal_sensor *sensor = &data->sensors[i];
> +
> +		hisi_thermal_toggle_sensor(sensor, false);
> +		thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
> +	}
> +
> +	hisi_thermal_disable_sensor(data);
> +	clk_disable_unprepare(data->clk);
> +	return 0;
> +}
> +
> +#ifdef CONFIG_PM_SLEEP
> +static int hisi_thermal_suspend(struct device *dev)
> +{
> +	struct hisi_thermal_data *data = dev_get_drvdata(dev);
> +
> +	hisi_thermal_disable_sensor(data);
> +	data->irq_enabled = false;
> +
> +	clk_disable_unprepare(data->clk);
> +
> +	return 0;
> +}
> +
> +static int hisi_thermal_resume(struct device *dev)
> +{
> +	struct hisi_thermal_data *data = dev_get_drvdata(dev);
> +
> +	clk_prepare_enable(data->clk);
> +
> +	data->irq_enabled = true;
> +	hisi_thermal_enable_sensor(data);
> +
> +	return 0;
> +}
> +#endif
> +
> +static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
> +			 hisi_thermal_suspend, hisi_thermal_resume);
> +
> +static struct platform_driver hisi_thermal_driver = {
> +	.driver = {
> +		.name	= "hisi_thermal",
> +		.owner  = THIS_MODULE,
> +		.pm	= &hisi_thermal_pm_ops,
> +		.of_match_table = of_hisi_thermal_match,
> +	},
> +	.probe		= hisi_thermal_probe,
> +	.remove		= hisi_thermal_remove,
> +};
> +
> +static int __init hisi_thermal_init(void)
> +{
> +	return platform_driver_register(&hisi_thermal_driver);
> +}
> +
> +static void __exit hisi_thermal_exit(void)
> +{
> +	platform_driver_unregister(&hisi_thermal_driver);
> +}
> +
> +late_initcall(hisi_thermal_init);
> +module_exit(hisi_thermal_exit);
> +
> +MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
> +MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
> +MODULE_DESCRIPTION("Hisilicon thermal driver");
> +MODULE_LICENSE("GPL v2");
>

Re: [PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[YiPing Xu]

在 2015/3/25 15:50, Xinwei Kong 写道:
> From: kongxinwei <kong.kongxinwei@hisilicon.com>
>
> This patch adds the support for hisilicon thermal sensor, within
> hisilicon SoC. there will register sensors for thermal framework
> and use device tree to bind cooling device.
>
> Signed-off-by: Leo Yan <leo.yan@linaro.org>
> Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
> ---
>   drivers/thermal/Kconfig        |   8 +
>   drivers/thermal/Makefile       |   1 +
>   drivers/thermal/hisi_thermal.c | 526 +++++++++++++++++++++++++++++++++++++++++
>   3 files changed, 535 insertions(+)
>   create mode 100644 drivers/thermal/hisi_thermal.c
>
> diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
> index af40db0..81aee01 100644
> --- a/drivers/thermal/Kconfig
> +++ b/drivers/thermal/Kconfig
> @@ -136,6 +136,14 @@ config THERMAL_EMULATION
>   	  because userland can easily disable the thermal policy by simply
>   	  flooding this sysfs node with low temperature values.
>
> +config HISI_THERMAL
> +	tristate "Hisilicon thermal driver"
> +	depends on ARCH_HISI && CPU_THERMAL && OF
> +	help
> +	  Enable this to plug hisilicon's thermal sensor driver into the Linux
> +	  thermal framework. cpufreq is used as the cooling device to throttle
> +	  CPUs when the passive trip is crossed.
> +
>   config IMX_THERMAL
>   	tristate "Temperature sensor driver for Freescale i.MX SoCs"
>   	depends on CPU_THERMAL
> diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
> index fa0dc48..08ae7ac 100644
> --- a/drivers/thermal/Makefile
> +++ b/drivers/thermal/Makefile
> @@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)	+= ti-soc-thermal/
>   obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
>   obj-$(CONFIG_ST_THERMAL)	+= st/
>   obj-$(CONFIG_TEGRA_SOCTHERM)	+= tegra_soctherm.o
> +obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
> diff --git a/drivers/thermal/hisi_thermal.c b/drivers/thermal/hisi_thermal.c
> new file mode 100644
> index 0000000..8edf83a
> --- /dev/null
> +++ b/drivers/thermal/hisi_thermal.c

    are you sure all the SOCs in hisilicon use the same thermal IP ?

    if not, this driver should not use the "hisi_" prefix.

> @@ -0,0 +1,526 @@
> +/*
> + * Hisilicon thermal sensor driver
> + *
> + * Copyright (c) 2014-2015 Hisilicon Limited.
> + * Copyright (c) 2014-2015 Linaro Limited.
> + *
> + * Xinwei Kong <kong.kongxinwei@hisilicon.com>
> + * Leo Yan <leo.yan@linaro.org>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed "as is" WITHOUT ANY WARRANTY of any
> + * kind, whether express or implied; without even the implied warranty
> + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + */
> +
> +#include <linux/cpu_cooling.h>
> +#include <linux/cpufreq.h>
> +#include <linux/delay.h>
> +#include <linux/device.h>
> +#include <linux/init.h>
> +#include <linux/interrupt.h>
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/mfd/syscon.h>
> +#include <linux/module.h>
> +#include <linux/of.h>
> +#include <linux/of_device.h>
> +#include <linux/platform_device.h>
> +#include <linux/regmap.h>
> +#include <linux/slab.h>
> +#include <linux/thermal.h>
> +#include <linux/types.h>
> +
> +#include "thermal_core.h"
> +
> +#define TEMP0_LAG			(0x0)
> +#define TEMP0_TH			(0x4)
> +#define TEMP0_RST_TH			(0x8)
> +#define TEMP0_CFG			(0xC)
> +#define TEMP0_EN			(0x10)
> +#define TEMP0_INT_EN			(0x14)
> +#define TEMP0_INT_CLR			(0x18)
> +#define TEMP0_RST_MSK			(0x1C)
> +#define TEMP0_RAW_INT			(0x20)
> +#define TEMP0_MSK_INT			(0x24)
> +#define TEMP0_VALUE			(0x28)
> +
> +#define HISI_TEMP_BASE			(-60)
> +#define HISI_TEMP_RESET			(100000)
> +#define HISI_TEMP_PASSIVE		(85000)
> +
> +#define HISI_MAX_SENSORS		4
> +
> +struct hisi_thermal_sensor {
> +	struct hisi_thermal_data *thermal;
> +	struct thermal_zone_device *tzd;
> +	const struct thermal_trip *trip;
> +
> +	uint32_t id;
> +	uint32_t thres_temp, reset_temp;
> +};
> +
> +struct hisi_thermal_data {
> +	struct platform_device *pdev;
> +	struct clk *clk;
> +
> +	int irq, irq_bind_sensor;
> +	bool irq_enabled;
> +
> +	unsigned int sensors_num;
> +	long sensor_temp[HISI_MAX_SENSORS];
> +	struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
> +
> +	void __iomem *regs;
> +};
> +
> +static DEFINE_SPINLOCK(thermal_lock);
> +

    "thermal_lock" should be defined in "hisi_thermal_data" to support 
multi device instance.

> +/* in millicelsius */
> +static inline int _step_to_temp(int step)
> +{
> +	/*
> +	 * Every step equals (1 * 200) / 255 celsius, and finally
> +	 * need convert to millicelsius.
> +	 */
> +	return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
> +}
> +
> +static inline int _temp_to_step(int temp)
> +{
> +	return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
> +}
> +
> +static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data *data,
> +					 struct hisi_thermal_sensor *sensor)
> +{
> +	unsigned long flags;
> +	int val;
> +
> +	spin_lock_irqsave(&thermal_lock, flags);
> +
> +	/* disable module firstly */
> +	writel(0x0, data->regs + TEMP0_EN);
> +
> +	/* select sensor id */
> +	writel((sensor->id << 12), data->regs + TEMP0_CFG);
> +
> +	/* enable module */
> +	writel(0x1, data->regs + TEMP0_EN);
> +
> +	mdelay(5);
> +
> +	val = readl(data->regs + TEMP0_VALUE);
> +	val = _step_to_temp(val);
> +
> +	/* adjust for negative value */
> +	val = (val < 0) ? 0 : val;
> +
> +	spin_unlock_irqrestore(&thermal_lock, flags);
> +
> +	return val;
> +}
> +
> +static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
> +{
> +	struct hisi_thermal_sensor *sensor;
> +	unsigned long flags;
> +
> +	sensor = &data->sensors[data->irq_bind_sensor];
> +
> +	spin_lock_irqsave(&thermal_lock, flags);
> +
> +	/* setting the hdak time */
> +	writel(0x0, data->regs + TEMP0_CFG);
> +
> +	/* disable module firstly */
> +	writel(0x0, data->regs + TEMP0_RST_MSK);
> +	writel(0x0, data->regs + TEMP0_EN);
> +
> +	/* select sensor id */
> +	writel((sensor->id << 12), data->regs + TEMP0_CFG);
> +
> +	/* enable for interrupt */
> +	writel(_temp_to_step(sensor->thres_temp)
> +			| 0x0FFFFFF00, data->regs + TEMP0_TH);
> +
> +	writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
> +
> +	/* enable module */
> +	writel(0x1, data->regs + TEMP0_RST_MSK);
> +	writel(0x1, data->regs + TEMP0_EN);
> +
> +	writel(0x0, data->regs + TEMP0_INT_CLR);
> +	writel(0x1, data->regs + TEMP0_INT_EN);
> +
> +	mdelay(5);
> +
> +	spin_unlock_irqrestore(&thermal_lock, flags);
> +
> +}
> +
> +static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
> +{
> +	struct hisi_thermal_sensor *sensor;
> +	unsigned long flags;
> +
> +	sensor = &data->sensors[data->irq_bind_sensor];
> +
> +	spin_lock_irqsave(&thermal_lock, flags);
> +
> +	/* setting the hdak time */
> +	writel(0x0, data->regs + TEMP0_CFG);
> +
> +	/* disable module firstly */
> +	writel(0x0, data->regs + TEMP0_RST_MSK);
> +	writel(0x0, data->regs + TEMP0_EN);
> +
> +	/* select sensor id */
> +	writel((sensor->id << 12), data->regs + TEMP0_CFG);
> +
> +	/* enable for interrupt */
> +	writel(_temp_to_step(sensor->thres_temp)
> +			| 0x0FFFFFF00, data->regs + TEMP0_TH);
> +
> +	writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
> +
> +	/* enable module */
> +	writel(0x1, data->regs + TEMP0_RST_MSK);
> +	writel(0x1, data->regs + TEMP0_EN);
> +
> +	writel(0x0, data->regs + TEMP0_INT_CLR);
> +	writel(0x1, data->regs + TEMP0_INT_EN);
> +
> +	mdelay(5);
> +
> +	spin_unlock_irqrestore(&thermal_lock, flags);
> +
> +}
> +
> +static void hisi_thermal_disable_sensor(struct hisi_thermal_data *data)
> +{
> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&thermal_lock, flags);
> +
> +	/* disable sensor module */
> +	writel(0x0, data->regs + TEMP0_INT_EN);
> +	writel(0x0, data->regs + TEMP0_RST_MSK);
> +	writel(0x0, data->regs + TEMP0_EN);
> +
> +	spin_unlock_irqrestore(&thermal_lock, flags);
> +
> +}
> +
> +static int hisi_thermal_get_temp(void *_sensor, long *temp)
> +{
> +	struct hisi_thermal_sensor *sensor = _sensor;
> +	struct hisi_thermal_data *data = sensor->thermal;
> +
> +	int sensor_id = 0, i;
> +	long max_temp = 0;
> +
> +	*temp = hisi_thermal_get_sensor_temp(data, sensor);
> +
> +	data->sensor_temp[sensor->id] = *temp;
> +
> +	for (i = 0; i < HISI_MAX_SENSORS; i++) {
> +		if (data->sensor_temp[i] >= max_temp) {
> +			max_temp = data->sensor_temp[i];
> +			sensor_id = i;
> +		}
> +	}
> +
> +	data->irq_bind_sensor = sensor_id;
> +
> +	dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
> +		sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
> +
> +	/*
> +	 * Bind irq to sensor for two cases:
> +	 *   Reenable alarm IRQ if temperature below threshold;
> +	 *   if irq has been enabled, always set it;
> +	 */
> +	if (!data->irq_enabled && max_temp < sensor->thres_temp) {
> +		data->irq_enabled = true;
> +		hisi_thermal_bind_irq(data);
> +	} else if (data->irq_enabled)
> +		hisi_thermal_bind_irq(data);
> +
> +	return 0;
> +}
> +
> +static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
> +	.get_temp = hisi_thermal_get_temp,
> +};
> +
> +static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
> +{
> +	struct hisi_thermal_data *data = dev;
> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&thermal_lock, flags);
> +
> +	/* disable interrupt */
> +	writel(0x0, data->regs + TEMP0_INT_EN);
> +	writel(0x1, data->regs + TEMP0_INT_CLR);
> +
> +	spin_unlock_irqrestore(&thermal_lock, flags);
> +	data->irq_enabled = false;
> +
> +	return IRQ_WAKE_THREAD;
> +}
> +
> +static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
> +{
> +	struct hisi_thermal_data *data = dev;
> +	struct hisi_thermal_sensor *sensor;
> +	int i;
> +
> +	sensor = &data->sensors[data->irq_bind_sensor];
> +
> +	dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
> +		 sensor->thres_temp / 1000);
> +
> +	for (i = 0; i < data->sensors_num; i++)
> +		thermal_zone_device_update(data->sensors[i].tzd);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static int hisi_thermal_init_sensor(struct platform_device *pdev,
> +					struct device_node *np,
> +					struct hisi_thermal_data *data,
> +					int index)
> +{
> +	struct hisi_thermal_sensor *sensor;
> +	int ret, i;
> +
> +	sensor = &data->sensors[index];
> +
> +	ret = of_property_read_u32(np, "hisilicon,tsensor-id",
> +					&sensor->id);
> +	if (ret) {
> +		dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
> +		return ret;
> +	}
> +
> +	sensor->thermal = data;
> +	sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev, sensor->id,
> +				sensor, &hisi_of_thermal_ops);
> +	if (IS_ERR(sensor->tzd)) {
> +		ret = PTR_ERR(sensor->tzd);
> +		dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
> +			sensor->id, ret);
> +		return ret;
> +	}
> +
> +	sensor->trip = of_thermal_get_trip_points(sensor->tzd);
> +
> +	for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
> +		if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
> +			sensor->thres_temp = sensor->trip[i].temperature;
> +			break;
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
> +{
> +	struct hisi_thermal_data *data = platform_get_drvdata(pdev);
> +	struct device_node *np = pdev->dev.of_node;
> +	struct device_node *child_np;
> +	int ret, i, index;
> +
> +	/* sensor initialization */
> +	index = 0;
> +	for_each_child_of_node(np, child_np) {
> +
> +		if (index >= HISI_MAX_SENSORS) {
> +			dev_err(&pdev->dev, "unsupported sensor number\n");
> +			ret = -EINVAL;
> +			goto err_init_sensors;
> +		}
> +
> +		ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
> +		if (ret)
> +			goto err_init_sensors;
> +
> +		index++;
> +	}
> +
> +	data->sensors_num = index;
> +	return 0;
> +
> +err_init_sensors:
> +	for (i = 0; i < index; i++)
> +		thermal_zone_of_sensor_unregister(&pdev->dev,
> +				data->sensors[i].tzd);
> +	return ret;
> +}
> +
> +static const struct of_device_id of_hisi_thermal_match[] = {
> +	{ .compatible = "hisilicon,tsensor" },
> +	{ /* end */ }
> +};
> +MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
> +
> +static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor *sensor,
> +				       bool on)
> +{
> +	struct thermal_zone_device *tzd = sensor->tzd;
> +
> +	tzd->ops->set_mode(tzd,
> +		on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
> +}
> +
> +static int hisi_thermal_probe(struct platform_device *pdev)
> +{
> +	struct hisi_thermal_data *data;
> +	struct resource *res;
> +	int i;
> +	int ret;
> +
> +	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
> +	if (!data)
> +		return -ENOMEM;
> +
> +	data->pdev = pdev;
> +
> +	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> +	data->regs = devm_ioremap_resource(&pdev->dev, res);
> +	if (IS_ERR(data->regs)) {
> +		dev_err(&pdev->dev, "failed to get io address\n");
> +		return PTR_ERR(data->regs);
> +	}
> +
> +	data->irq = platform_get_irq(pdev, 0);
> +	if (data->irq < 0)
> +		return data->irq;
> +
> +	ret = devm_request_threaded_irq(&pdev->dev, data->irq,
> +			hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
> +			0, "hisi_thermal", data);
> +	if (ret < 0) {
> +		dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
> +		return ret;
> +	}
> +
> +	platform_set_drvdata(pdev, data);
> +
> +	data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
> +	if (IS_ERR(data->clk)) {
> +		ret = PTR_ERR(data->clk);
> +		if (ret != -EPROBE_DEFER)
> +			dev_err(&pdev->dev,
> +				"failed to get thermal clk: %d\n", ret);
> +		return ret;
> +	}
> +
> +	/* enable clock for thermal */
> +	ret = clk_prepare_enable(data->clk);
> +	if (ret) {
> +		dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
> +		return ret;
> +	}
> +
> +	ret = hisi_thermal_get_sensor_data(pdev);
> +	if (ret) {
> +		dev_err(&pdev->dev, "failed to get sensor data\n");
> +		goto err_get_sensor_data;
> +		return ret;
> +	}
> +
> +	hisi_thermal_enable_sensor(data);
> +	data->irq_enabled = true;
> +
> +	for (i = 0; i < data->sensors_num; i++)
> +		hisi_thermal_toggle_sensor(&data->sensors[i], true);
> +
> +	return 0;
> +
> +err_get_sensor_data:
> +	clk_disable_unprepare(data->clk);
> +	return ret;
> +}
> +
> +static int hisi_thermal_remove(struct platform_device *pdev)
> +{
> +	struct hisi_thermal_data *data = platform_get_drvdata(pdev);
> +	int i;
> +
> +	for (i = 0; i < data->sensors_num; i++) {
> +		struct hisi_thermal_sensor *sensor = &data->sensors[i];
> +
> +		hisi_thermal_toggle_sensor(sensor, false);
> +		thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
> +	}
> +
> +	hisi_thermal_disable_sensor(data);
> +	clk_disable_unprepare(data->clk);
> +	return 0;
> +}
> +
> +#ifdef CONFIG_PM_SLEEP
> +static int hisi_thermal_suspend(struct device *dev)
> +{
> +	struct hisi_thermal_data *data = dev_get_drvdata(dev);
> +
> +	hisi_thermal_disable_sensor(data);
> +	data->irq_enabled = false;
> +
> +	clk_disable_unprepare(data->clk);
> +
> +	return 0;
> +}
> +
> +static int hisi_thermal_resume(struct device *dev)
> +{
> +	struct hisi_thermal_data *data = dev_get_drvdata(dev);
> +
> +	clk_prepare_enable(data->clk);
> +
> +	data->irq_enabled = true;
> +	hisi_thermal_enable_sensor(data);
> +
> +	return 0;
> +}
> +#endif
> +
> +static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
> +			 hisi_thermal_suspend, hisi_thermal_resume);
> +
> +static struct platform_driver hisi_thermal_driver = {
> +	.driver = {
> +		.name	= "hisi_thermal",
> +		.owner  = THIS_MODULE,
> +		.pm	= &hisi_thermal_pm_ops,
> +		.of_match_table = of_hisi_thermal_match,
> +	},
> +	.probe		= hisi_thermal_probe,
> +	.remove		= hisi_thermal_remove,
> +};
> +
> +static int __init hisi_thermal_init(void)
> +{
> +	return platform_driver_register(&hisi_thermal_driver);
> +}
> +
> +static void __exit hisi_thermal_exit(void)
> +{
> +	platform_driver_unregister(&hisi_thermal_driver);
> +}
> +
> +late_initcall(hisi_thermal_init);
> +module_exit(hisi_thermal_exit);
> +
> +MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
> +MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
> +MODULE_DESCRIPTION("Hisilicon thermal driver");
> +MODULE_LICENSE("GPL v2");
>

Re: [PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[Xinwei Kong]

On 2015/3/26 17:14, YiPing Xu wrote:
> 在 2015/3/25 15:50, Xinwei Kong 写道:
>> From: kongxinwei <kong.kongxinwei@hisilicon.com>
>>
>> This patch adds the support for hisilicon thermal sensor, within
>> hisilicon SoC. there will register sensors for thermal framework
>> and use device tree to bind cooling device.
>>
>> Signed-off-by: Leo Yan <leo.yan@linaro.org>
>> Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
>> ---
>>   drivers/thermal/Kconfig        |   8 +
>>   drivers/thermal/Makefile       |   1 +
>>   drivers/thermal/hisi_thermal.c | 526 +++++++++++++++++++++++++++++++++++++++++
>>   3 files changed, 535 insertions(+)
>>   create mode 100644 drivers/thermal/hisi_thermal.c
>>
>> diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
>> index af40db0..81aee01 100644
>> --- a/drivers/thermal/Kconfig
>> +++ b/drivers/thermal/Kconfig
>> @@ -136,6 +136,14 @@ config THERMAL_EMULATION
>>         because userland can easily disable the thermal policy by simply
>>         flooding this sysfs node with low temperature values.
>>
>> +config HISI_THERMAL
>> +    tristate "Hisilicon thermal driver"
>> +    depends on ARCH_HISI && CPU_THERMAL && OF
>> +    help
>> +      Enable this to plug hisilicon's thermal sensor driver into the Linux
>> +      thermal framework. cpufreq is used as the cooling device to throttle
>> +      CPUs when the passive trip is crossed.
>> +
>>   config IMX_THERMAL
>>       tristate "Temperature sensor driver for Freescale i.MX SoCs"
>>       depends on CPU_THERMAL
>> diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
>> index fa0dc48..08ae7ac 100644
>> --- a/drivers/thermal/Makefile
>> +++ b/drivers/thermal/Makefile
>> @@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)    += ti-soc-thermal/
>>   obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
>>   obj-$(CONFIG_ST_THERMAL)    += st/
>>   obj-$(CONFIG_TEGRA_SOCTHERM)    += tegra_soctherm.o
>> +obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
>> diff --git a/drivers/thermal/hisi_thermal.c b/drivers/thermal/hisi_thermal.c
>> new file mode 100644
>> index 0000000..8edf83a
>> --- /dev/null
>> +++ b/drivers/thermal/hisi_thermal.c
> 
>    are you sure all the SOCs in hisilicon use the same thermal IP ?
> 
>    if not, this driver should not use the "hisi_" prefix.

We can use this hisi thermal driver framework to satisfy diff thermal
IP, all of SoC will use this drvier by adding a struct about diff IP.
We may talk about hisi thermal diff IP how to satisfy this driver.

Thanks
Xinwei

> 
>> @@ -0,0 +1,526 @@
>> +/*
>> + * Hisilicon thermal sensor driver
>> + *
>> + * Copyright (c) 2014-2015 Hisilicon Limited.
>> + * Copyright (c) 2014-2015 Linaro Limited.
>> + *
>> + * Xinwei Kong <kong.kongxinwei@hisilicon.com>
>> + * Leo Yan <leo.yan@linaro.org>
>> + *
>> + * This program is free software; you can redistribute it and/or modify
>> + * it under the terms of the GNU General Public License version 2 as
>> + * published by the Free Software Foundation.
>> + *
>> + * This program is distributed "as is" WITHOUT ANY WARRANTY of any
>> + * kind, whether express or implied; without even the implied warranty
>> + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>> + * GNU General Public License for more details.
>> + */
>> +
>> +#include <linux/cpu_cooling.h>
>> +#include <linux/cpufreq.h>
>> +#include <linux/delay.h>
>> +#include <linux/device.h>
>> +#include <linux/init.h>
>> +#include <linux/interrupt.h>
>> +#include <linux/io.h>
>> +#include <linux/kernel.h>
>> +#include <linux/mfd/syscon.h>
>> +#include <linux/module.h>
>> +#include <linux/of.h>
>> +#include <linux/of_device.h>
>> +#include <linux/platform_device.h>
>> +#include <linux/regmap.h>
>> +#include <linux/slab.h>
>> +#include <linux/thermal.h>
>> +#include <linux/types.h>
>> +
>> +#include "thermal_core.h"
>> +
>> +#define TEMP0_LAG            (0x0)
>> +#define TEMP0_TH            (0x4)
>> +#define TEMP0_RST_TH            (0x8)
>> +#define TEMP0_CFG            (0xC)
>> +#define TEMP0_EN            (0x10)
>> +#define TEMP0_INT_EN            (0x14)
>> +#define TEMP0_INT_CLR            (0x18)
>> +#define TEMP0_RST_MSK            (0x1C)
>> +#define TEMP0_RAW_INT            (0x20)
>> +#define TEMP0_MSK_INT            (0x24)
>> +#define TEMP0_VALUE            (0x28)
>> +
>> +#define HISI_TEMP_BASE            (-60)
>> +#define HISI_TEMP_RESET            (100000)
>> +#define HISI_TEMP_PASSIVE        (85000)
>> +
>> +#define HISI_MAX_SENSORS        4
>> +
>> +struct hisi_thermal_sensor {
>> +    struct hisi_thermal_data *thermal;
>> +    struct thermal_zone_device *tzd;
>> +    const struct thermal_trip *trip;
>> +
>> +    uint32_t id;
>> +    uint32_t thres_temp, reset_temp;
>> +};
>> +
>> +struct hisi_thermal_data {
>> +    struct platform_device *pdev;
>> +    struct clk *clk;
>> +
>> +    int irq, irq_bind_sensor;
>> +    bool irq_enabled;
>> +
>> +    unsigned int sensors_num;
>> +    long sensor_temp[HISI_MAX_SENSORS];
>> +    struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
>> +
>> +    void __iomem *regs;
>> +};
>> +
>> +static DEFINE_SPINLOCK(thermal_lock);
>> +
> 
>    "thermal_lock" should be defined in "hisi_thermal_data" to support multi device instance.
> 

ok,good comments

>> +/* in millicelsius */
>> +static inline int _step_to_temp(int step)
>> +{
>> +    /*
>> +     * Every step equals (1 * 200) / 255 celsius, and finally
>> +     * need convert to millicelsius.
>> +     */
>> +    return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
>> +}
>> +
>> +static inline int _temp_to_step(int temp)
>> +{
>> +    return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
>> +}
>> +
>> +static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data *data,
>> +                     struct hisi_thermal_sensor *sensor)
>> +{
>> +    unsigned long flags;
>> +    int val;
>> +
>> +    spin_lock_irqsave(&thermal_lock, flags);
>> +
>> +    /* disable module firstly */
>> +    writel(0x0, data->regs + TEMP0_EN);
>> +
>> +    /* select sensor id */
>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>> +
>> +    /* enable module */
>> +    writel(0x1, data->regs + TEMP0_EN);
>> +
>> +    mdelay(5);
>> +
>> +    val = readl(data->regs + TEMP0_VALUE);
>> +    val = _step_to_temp(val);
>> +
>> +    /* adjust for negative value */
>> +    val = (val < 0) ? 0 : val;
>> +
>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>> +
>> +    return val;
>> +}
>> +
>> +static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
>> +{
>> +    struct hisi_thermal_sensor *sensor;
>> +    unsigned long flags;
>> +
>> +    sensor = &data->sensors[data->irq_bind_sensor];
>> +
>> +    spin_lock_irqsave(&thermal_lock, flags);
>> +
>> +    /* setting the hdak time */
>> +    writel(0x0, data->regs + TEMP0_CFG);
>> +
>> +    /* disable module firstly */
>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>> +    writel(0x0, data->regs + TEMP0_EN);
>> +
>> +    /* select sensor id */
>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>> +
>> +    /* enable for interrupt */
>> +    writel(_temp_to_step(sensor->thres_temp)
>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>> +
>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>> +
>> +    /* enable module */
>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>> +    writel(0x1, data->regs + TEMP0_EN);
>> +
>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>> +
>> +    mdelay(5);
>> +
>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>> +
>> +}
>> +
>> +static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
>> +{
>> +    struct hisi_thermal_sensor *sensor;
>> +    unsigned long flags;
>> +
>> +    sensor = &data->sensors[data->irq_bind_sensor];
>> +
>> +    spin_lock_irqsave(&thermal_lock, flags);
>> +
>> +    /* setting the hdak time */
>> +    writel(0x0, data->regs + TEMP0_CFG);
>> +
>> +    /* disable module firstly */
>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>> +    writel(0x0, data->regs + TEMP0_EN);
>> +
>> +    /* select sensor id */
>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>> +
>> +    /* enable for interrupt */
>> +    writel(_temp_to_step(sensor->thres_temp)
>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>> +
>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>> +
>> +    /* enable module */
>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>> +    writel(0x1, data->regs + TEMP0_EN);
>> +
>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>> +
>> +    mdelay(5);
>> +
>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>> +
>> +}
>> +
>> +static void hisi_thermal_disable_sensor(struct hisi_thermal_data *data)
>> +{
>> +    unsigned long flags;
>> +
>> +    spin_lock_irqsave(&thermal_lock, flags);
>> +
>> +    /* disable sensor module */
>> +    writel(0x0, data->regs + TEMP0_INT_EN);
>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>> +    writel(0x0, data->regs + TEMP0_EN);
>> +
>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>> +
>> +}
>> +
>> +static int hisi_thermal_get_temp(void *_sensor, long *temp)
>> +{
>> +    struct hisi_thermal_sensor *sensor = _sensor;
>> +    struct hisi_thermal_data *data = sensor->thermal;
>> +
>> +    int sensor_id = 0, i;
>> +    long max_temp = 0;
>> +
>> +    *temp = hisi_thermal_get_sensor_temp(data, sensor);
>> +
>> +    data->sensor_temp[sensor->id] = *temp;
>> +
>> +    for (i = 0; i < HISI_MAX_SENSORS; i++) {
>> +        if (data->sensor_temp[i] >= max_temp) {
>> +            max_temp = data->sensor_temp[i];
>> +            sensor_id = i;
>> +        }
>> +    }
>> +
>> +    data->irq_bind_sensor = sensor_id;
>> +
>> +    dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
>> +        sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
>> +
>> +    /*
>> +     * Bind irq to sensor for two cases:
>> +     *   Reenable alarm IRQ if temperature below threshold;
>> +     *   if irq has been enabled, always set it;
>> +     */
>> +    if (!data->irq_enabled && max_temp < sensor->thres_temp) {
>> +        data->irq_enabled = true;
>> +        hisi_thermal_bind_irq(data);
>> +    } else if (data->irq_enabled)
>> +        hisi_thermal_bind_irq(data);
>> +
>> +    return 0;
>> +}
>> +
>> +static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
>> +    .get_temp = hisi_thermal_get_temp,
>> +};
>> +
>> +static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
>> +{
>> +    struct hisi_thermal_data *data = dev;
>> +    unsigned long flags;
>> +
>> +    spin_lock_irqsave(&thermal_lock, flags);
>> +
>> +    /* disable interrupt */
>> +    writel(0x0, data->regs + TEMP0_INT_EN);
>> +    writel(0x1, data->regs + TEMP0_INT_CLR);
>> +
>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>> +    data->irq_enabled = false;
>> +
>> +    return IRQ_WAKE_THREAD;
>> +}
>> +
>> +static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
>> +{
>> +    struct hisi_thermal_data *data = dev;
>> +    struct hisi_thermal_sensor *sensor;
>> +    int i;
>> +
>> +    sensor = &data->sensors[data->irq_bind_sensor];
>> +
>> +    dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
>> +         sensor->thres_temp / 1000);
>> +
>> +    for (i = 0; i < data->sensors_num; i++)
>> +        thermal_zone_device_update(data->sensors[i].tzd);
>> +
>> +    return IRQ_HANDLED;
>> +}
>> +
>> +static int hisi_thermal_init_sensor(struct platform_device *pdev,
>> +                    struct device_node *np,
>> +                    struct hisi_thermal_data *data,
>> +                    int index)
>> +{
>> +    struct hisi_thermal_sensor *sensor;
>> +    int ret, i;
>> +
>> +    sensor = &data->sensors[index];
>> +
>> +    ret = of_property_read_u32(np, "hisilicon,tsensor-id",
>> +                    &sensor->id);
>> +    if (ret) {
>> +        dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
>> +        return ret;
>> +    }
>> +
>> +    sensor->thermal = data;
>> +    sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev, sensor->id,
>> +                sensor, &hisi_of_thermal_ops);
>> +    if (IS_ERR(sensor->tzd)) {
>> +        ret = PTR_ERR(sensor->tzd);
>> +        dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
>> +            sensor->id, ret);
>> +        return ret;
>> +    }
>> +
>> +    sensor->trip = of_thermal_get_trip_points(sensor->tzd);
>> +
>> +    for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
>> +        if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
>> +            sensor->thres_temp = sensor->trip[i].temperature;
>> +            break;
>> +        }
>> +    }
>> +
>> +    return 0;
>> +}
>> +
>> +static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
>> +{
>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>> +    struct device_node *np = pdev->dev.of_node;
>> +    struct device_node *child_np;
>> +    int ret, i, index;
>> +
>> +    /* sensor initialization */
>> +    index = 0;
>> +    for_each_child_of_node(np, child_np) {
>> +
>> +        if (index >= HISI_MAX_SENSORS) {
>> +            dev_err(&pdev->dev, "unsupported sensor number\n");
>> +            ret = -EINVAL;
>> +            goto err_init_sensors;
>> +        }
>> +
>> +        ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
>> +        if (ret)
>> +            goto err_init_sensors;
>> +
>> +        index++;
>> +    }
>> +
>> +    data->sensors_num = index;
>> +    return 0;
>> +
>> +err_init_sensors:
>> +    for (i = 0; i < index; i++)
>> +        thermal_zone_of_sensor_unregister(&pdev->dev,
>> +                data->sensors[i].tzd);
>> +    return ret;
>> +}
>> +
>> +static const struct of_device_id of_hisi_thermal_match[] = {
>> +    { .compatible = "hisilicon,tsensor" },
>> +    { /* end */ }
>> +};
>> +MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
>> +
>> +static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor *sensor,
>> +                       bool on)
>> +{
>> +    struct thermal_zone_device *tzd = sensor->tzd;
>> +
>> +    tzd->ops->set_mode(tzd,
>> +        on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
>> +}
>> +
>> +static int hisi_thermal_probe(struct platform_device *pdev)
>> +{
>> +    struct hisi_thermal_data *data;
>> +    struct resource *res;
>> +    int i;
>> +    int ret;
>> +
>> +    data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
>> +    if (!data)
>> +        return -ENOMEM;
>> +
>> +    data->pdev = pdev;
>> +
>> +    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
>> +    data->regs = devm_ioremap_resource(&pdev->dev, res);
>> +    if (IS_ERR(data->regs)) {
>> +        dev_err(&pdev->dev, "failed to get io address\n");
>> +        return PTR_ERR(data->regs);
>> +    }
>> +
>> +    data->irq = platform_get_irq(pdev, 0);
>> +    if (data->irq < 0)
>> +        return data->irq;
>> +
>> +    ret = devm_request_threaded_irq(&pdev->dev, data->irq,
>> +            hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
>> +            0, "hisi_thermal", data);
>> +    if (ret < 0) {
>> +        dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
>> +        return ret;
>> +    }
>> +
>> +    platform_set_drvdata(pdev, data);
>> +
>> +    data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
>> +    if (IS_ERR(data->clk)) {
>> +        ret = PTR_ERR(data->clk);
>> +        if (ret != -EPROBE_DEFER)
>> +            dev_err(&pdev->dev,
>> +                "failed to get thermal clk: %d\n", ret);
>> +        return ret;
>> +    }
>> +
>> +    /* enable clock for thermal */
>> +    ret = clk_prepare_enable(data->clk);
>> +    if (ret) {
>> +        dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
>> +        return ret;
>> +    }
>> +
>> +    ret = hisi_thermal_get_sensor_data(pdev);
>> +    if (ret) {
>> +        dev_err(&pdev->dev, "failed to get sensor data\n");
>> +        goto err_get_sensor_data;
>> +        return ret;
>> +    }
>> +
>> +    hisi_thermal_enable_sensor(data);
>> +    data->irq_enabled = true;
>> +
>> +    for (i = 0; i < data->sensors_num; i++)
>> +        hisi_thermal_toggle_sensor(&data->sensors[i], true);
>> +
>> +    return 0;
>> +
>> +err_get_sensor_data:
>> +    clk_disable_unprepare(data->clk);
>> +    return ret;
>> +}
>> +
>> +static int hisi_thermal_remove(struct platform_device *pdev)
>> +{
>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>> +    int i;
>> +
>> +    for (i = 0; i < data->sensors_num; i++) {
>> +        struct hisi_thermal_sensor *sensor = &data->sensors[i];
>> +
>> +        hisi_thermal_toggle_sensor(sensor, false);
>> +        thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
>> +    }
>> +
>> +    hisi_thermal_disable_sensor(data);
>> +    clk_disable_unprepare(data->clk);
>> +    return 0;
>> +}
>> +
>> +#ifdef CONFIG_PM_SLEEP
>> +static int hisi_thermal_suspend(struct device *dev)
>> +{
>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>> +
>> +    hisi_thermal_disable_sensor(data);
>> +    data->irq_enabled = false;
>> +
>> +    clk_disable_unprepare(data->clk);
>> +
>> +    return 0;
>> +}
>> +
>> +static int hisi_thermal_resume(struct device *dev)
>> +{
>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>> +
>> +    clk_prepare_enable(data->clk);
>> +
>> +    data->irq_enabled = true;
>> +    hisi_thermal_enable_sensor(data);
>> +
>> +    return 0;
>> +}
>> +#endif
>> +
>> +static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
>> +             hisi_thermal_suspend, hisi_thermal_resume);
>> +
>> +static struct platform_driver hisi_thermal_driver = {
>> +    .driver = {
>> +        .name    = "hisi_thermal",
>> +        .owner  = THIS_MODULE,
>> +        .pm    = &hisi_thermal_pm_ops,
>> +        .of_match_table = of_hisi_thermal_match,
>> +    },
>> +    .probe        = hisi_thermal_probe,
>> +    .remove        = hisi_thermal_remove,
>> +};
>> +
>> +static int __init hisi_thermal_init(void)
>> +{
>> +    return platform_driver_register(&hisi_thermal_driver);
>> +}
>> +
>> +static void __exit hisi_thermal_exit(void)
>> +{
>> +    platform_driver_unregister(&hisi_thermal_driver);
>> +}
>> +
>> +late_initcall(hisi_thermal_init);
>> +module_exit(hisi_thermal_exit);
>> +
>> +MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
>> +MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
>> +MODULE_DESCRIPTION("Hisilicon thermal driver");
>> +MODULE_LICENSE("GPL v2");
>>
> 
> 
> 
> .
> 

[PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[Xinwei Kong]

On 2015/3/26 17:14, YiPing Xu wrote:
> ? 2015/3/25 15:50, Xinwei Kong ??:
>> From: kongxinwei <kong.kongxinwei@hisilicon.com>
>>
>> This patch adds the support for hisilicon thermal sensor, within
>> hisilicon SoC. there will register sensors for thermal framework
>> and use device tree to bind cooling device.
>>
>> Signed-off-by: Leo Yan <leo.yan@linaro.org>
>> Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
>> ---
>>   drivers/thermal/Kconfig        |   8 +
>>   drivers/thermal/Makefile       |   1 +
>>   drivers/thermal/hisi_thermal.c | 526 +++++++++++++++++++++++++++++++++++++++++
>>   3 files changed, 535 insertions(+)
>>   create mode 100644 drivers/thermal/hisi_thermal.c
>>
>> diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
>> index af40db0..81aee01 100644
>> --- a/drivers/thermal/Kconfig
>> +++ b/drivers/thermal/Kconfig
>> @@ -136,6 +136,14 @@ config THERMAL_EMULATION
>>         because userland can easily disable the thermal policy by simply
>>         flooding this sysfs node with low temperature values.
>>
>> +config HISI_THERMAL
>> +    tristate "Hisilicon thermal driver"
>> +    depends on ARCH_HISI && CPU_THERMAL && OF
>> +    help
>> +      Enable this to plug hisilicon's thermal sensor driver into the Linux
>> +      thermal framework. cpufreq is used as the cooling device to throttle
>> +      CPUs when the passive trip is crossed.
>> +
>>   config IMX_THERMAL
>>       tristate "Temperature sensor driver for Freescale i.MX SoCs"
>>       depends on CPU_THERMAL
>> diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
>> index fa0dc48..08ae7ac 100644
>> --- a/drivers/thermal/Makefile
>> +++ b/drivers/thermal/Makefile
>> @@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)    += ti-soc-thermal/
>>   obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
>>   obj-$(CONFIG_ST_THERMAL)    += st/
>>   obj-$(CONFIG_TEGRA_SOCTHERM)    += tegra_soctherm.o
>> +obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
>> diff --git a/drivers/thermal/hisi_thermal.c b/drivers/thermal/hisi_thermal.c
>> new file mode 100644
>> index 0000000..8edf83a
>> --- /dev/null
>> +++ b/drivers/thermal/hisi_thermal.c
> 
>    are you sure all the SOCs in hisilicon use the same thermal IP ?
> 
>    if not, this driver should not use the "hisi_" prefix.

We can use this hisi thermal driver framework to satisfy diff thermal
IP, all of SoC will use this drvier by adding a struct about diff IP.
We may talk about hisi thermal diff IP how to satisfy this driver.

Thanks
Xinwei

> 
>> @@ -0,0 +1,526 @@
>> +/*
>> + * Hisilicon thermal sensor driver
>> + *
>> + * Copyright (c) 2014-2015 Hisilicon Limited.
>> + * Copyright (c) 2014-2015 Linaro Limited.
>> + *
>> + * Xinwei Kong <kong.kongxinwei@hisilicon.com>
>> + * Leo Yan <leo.yan@linaro.org>
>> + *
>> + * This program is free software; you can redistribute it and/or modify
>> + * it under the terms of the GNU General Public License version 2 as
>> + * published by the Free Software Foundation.
>> + *
>> + * This program is distributed "as is" WITHOUT ANY WARRANTY of any
>> + * kind, whether express or implied; without even the implied warranty
>> + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>> + * GNU General Public License for more details.
>> + */
>> +
>> +#include <linux/cpu_cooling.h>
>> +#include <linux/cpufreq.h>
>> +#include <linux/delay.h>
>> +#include <linux/device.h>
>> +#include <linux/init.h>
>> +#include <linux/interrupt.h>
>> +#include <linux/io.h>
>> +#include <linux/kernel.h>
>> +#include <linux/mfd/syscon.h>
>> +#include <linux/module.h>
>> +#include <linux/of.h>
>> +#include <linux/of_device.h>
>> +#include <linux/platform_device.h>
>> +#include <linux/regmap.h>
>> +#include <linux/slab.h>
>> +#include <linux/thermal.h>
>> +#include <linux/types.h>
>> +
>> +#include "thermal_core.h"
>> +
>> +#define TEMP0_LAG            (0x0)
>> +#define TEMP0_TH            (0x4)
>> +#define TEMP0_RST_TH            (0x8)
>> +#define TEMP0_CFG            (0xC)
>> +#define TEMP0_EN            (0x10)
>> +#define TEMP0_INT_EN            (0x14)
>> +#define TEMP0_INT_CLR            (0x18)
>> +#define TEMP0_RST_MSK            (0x1C)
>> +#define TEMP0_RAW_INT            (0x20)
>> +#define TEMP0_MSK_INT            (0x24)
>> +#define TEMP0_VALUE            (0x28)
>> +
>> +#define HISI_TEMP_BASE            (-60)
>> +#define HISI_TEMP_RESET            (100000)
>> +#define HISI_TEMP_PASSIVE        (85000)
>> +
>> +#define HISI_MAX_SENSORS        4
>> +
>> +struct hisi_thermal_sensor {
>> +    struct hisi_thermal_data *thermal;
>> +    struct thermal_zone_device *tzd;
>> +    const struct thermal_trip *trip;
>> +
>> +    uint32_t id;
>> +    uint32_t thres_temp, reset_temp;
>> +};
>> +
>> +struct hisi_thermal_data {
>> +    struct platform_device *pdev;
>> +    struct clk *clk;
>> +
>> +    int irq, irq_bind_sensor;
>> +    bool irq_enabled;
>> +
>> +    unsigned int sensors_num;
>> +    long sensor_temp[HISI_MAX_SENSORS];
>> +    struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
>> +
>> +    void __iomem *regs;
>> +};
>> +
>> +static DEFINE_SPINLOCK(thermal_lock);
>> +
> 
>    "thermal_lock" should be defined in "hisi_thermal_data" to support multi device instance.
> 

ok,good comments

>> +/* in millicelsius */
>> +static inline int _step_to_temp(int step)
>> +{
>> +    /*
>> +     * Every step equals (1 * 200) / 255 celsius, and finally
>> +     * need convert to millicelsius.
>> +     */
>> +    return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
>> +}
>> +
>> +static inline int _temp_to_step(int temp)
>> +{
>> +    return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
>> +}
>> +
>> +static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data *data,
>> +                     struct hisi_thermal_sensor *sensor)
>> +{
>> +    unsigned long flags;
>> +    int val;
>> +
>> +    spin_lock_irqsave(&thermal_lock, flags);
>> +
>> +    /* disable module firstly */
>> +    writel(0x0, data->regs + TEMP0_EN);
>> +
>> +    /* select sensor id */
>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>> +
>> +    /* enable module */
>> +    writel(0x1, data->regs + TEMP0_EN);
>> +
>> +    mdelay(5);
>> +
>> +    val = readl(data->regs + TEMP0_VALUE);
>> +    val = _step_to_temp(val);
>> +
>> +    /* adjust for negative value */
>> +    val = (val < 0) ? 0 : val;
>> +
>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>> +
>> +    return val;
>> +}
>> +
>> +static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
>> +{
>> +    struct hisi_thermal_sensor *sensor;
>> +    unsigned long flags;
>> +
>> +    sensor = &data->sensors[data->irq_bind_sensor];
>> +
>> +    spin_lock_irqsave(&thermal_lock, flags);
>> +
>> +    /* setting the hdak time */
>> +    writel(0x0, data->regs + TEMP0_CFG);
>> +
>> +    /* disable module firstly */
>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>> +    writel(0x0, data->regs + TEMP0_EN);
>> +
>> +    /* select sensor id */
>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>> +
>> +    /* enable for interrupt */
>> +    writel(_temp_to_step(sensor->thres_temp)
>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>> +
>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>> +
>> +    /* enable module */
>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>> +    writel(0x1, data->regs + TEMP0_EN);
>> +
>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>> +
>> +    mdelay(5);
>> +
>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>> +
>> +}
>> +
>> +static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
>> +{
>> +    struct hisi_thermal_sensor *sensor;
>> +    unsigned long flags;
>> +
>> +    sensor = &data->sensors[data->irq_bind_sensor];
>> +
>> +    spin_lock_irqsave(&thermal_lock, flags);
>> +
>> +    /* setting the hdak time */
>> +    writel(0x0, data->regs + TEMP0_CFG);
>> +
>> +    /* disable module firstly */
>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>> +    writel(0x0, data->regs + TEMP0_EN);
>> +
>> +    /* select sensor id */
>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>> +
>> +    /* enable for interrupt */
>> +    writel(_temp_to_step(sensor->thres_temp)
>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>> +
>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>> +
>> +    /* enable module */
>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>> +    writel(0x1, data->regs + TEMP0_EN);
>> +
>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>> +
>> +    mdelay(5);
>> +
>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>> +
>> +}
>> +
>> +static void hisi_thermal_disable_sensor(struct hisi_thermal_data *data)
>> +{
>> +    unsigned long flags;
>> +
>> +    spin_lock_irqsave(&thermal_lock, flags);
>> +
>> +    /* disable sensor module */
>> +    writel(0x0, data->regs + TEMP0_INT_EN);
>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>> +    writel(0x0, data->regs + TEMP0_EN);
>> +
>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>> +
>> +}
>> +
>> +static int hisi_thermal_get_temp(void *_sensor, long *temp)
>> +{
>> +    struct hisi_thermal_sensor *sensor = _sensor;
>> +    struct hisi_thermal_data *data = sensor->thermal;
>> +
>> +    int sensor_id = 0, i;
>> +    long max_temp = 0;
>> +
>> +    *temp = hisi_thermal_get_sensor_temp(data, sensor);
>> +
>> +    data->sensor_temp[sensor->id] = *temp;
>> +
>> +    for (i = 0; i < HISI_MAX_SENSORS; i++) {
>> +        if (data->sensor_temp[i] >= max_temp) {
>> +            max_temp = data->sensor_temp[i];
>> +            sensor_id = i;
>> +        }
>> +    }
>> +
>> +    data->irq_bind_sensor = sensor_id;
>> +
>> +    dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
>> +        sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
>> +
>> +    /*
>> +     * Bind irq to sensor for two cases:
>> +     *   Reenable alarm IRQ if temperature below threshold;
>> +     *   if irq has been enabled, always set it;
>> +     */
>> +    if (!data->irq_enabled && max_temp < sensor->thres_temp) {
>> +        data->irq_enabled = true;
>> +        hisi_thermal_bind_irq(data);
>> +    } else if (data->irq_enabled)
>> +        hisi_thermal_bind_irq(data);
>> +
>> +    return 0;
>> +}
>> +
>> +static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
>> +    .get_temp = hisi_thermal_get_temp,
>> +};
>> +
>> +static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
>> +{
>> +    struct hisi_thermal_data *data = dev;
>> +    unsigned long flags;
>> +
>> +    spin_lock_irqsave(&thermal_lock, flags);
>> +
>> +    /* disable interrupt */
>> +    writel(0x0, data->regs + TEMP0_INT_EN);
>> +    writel(0x1, data->regs + TEMP0_INT_CLR);
>> +
>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>> +    data->irq_enabled = false;
>> +
>> +    return IRQ_WAKE_THREAD;
>> +}
>> +
>> +static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
>> +{
>> +    struct hisi_thermal_data *data = dev;
>> +    struct hisi_thermal_sensor *sensor;
>> +    int i;
>> +
>> +    sensor = &data->sensors[data->irq_bind_sensor];
>> +
>> +    dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
>> +         sensor->thres_temp / 1000);
>> +
>> +    for (i = 0; i < data->sensors_num; i++)
>> +        thermal_zone_device_update(data->sensors[i].tzd);
>> +
>> +    return IRQ_HANDLED;
>> +}
>> +
>> +static int hisi_thermal_init_sensor(struct platform_device *pdev,
>> +                    struct device_node *np,
>> +                    struct hisi_thermal_data *data,
>> +                    int index)
>> +{
>> +    struct hisi_thermal_sensor *sensor;
>> +    int ret, i;
>> +
>> +    sensor = &data->sensors[index];
>> +
>> +    ret = of_property_read_u32(np, "hisilicon,tsensor-id",
>> +                    &sensor->id);
>> +    if (ret) {
>> +        dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
>> +        return ret;
>> +    }
>> +
>> +    sensor->thermal = data;
>> +    sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev, sensor->id,
>> +                sensor, &hisi_of_thermal_ops);
>> +    if (IS_ERR(sensor->tzd)) {
>> +        ret = PTR_ERR(sensor->tzd);
>> +        dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
>> +            sensor->id, ret);
>> +        return ret;
>> +    }
>> +
>> +    sensor->trip = of_thermal_get_trip_points(sensor->tzd);
>> +
>> +    for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
>> +        if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
>> +            sensor->thres_temp = sensor->trip[i].temperature;
>> +            break;
>> +        }
>> +    }
>> +
>> +    return 0;
>> +}
>> +
>> +static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
>> +{
>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>> +    struct device_node *np = pdev->dev.of_node;
>> +    struct device_node *child_np;
>> +    int ret, i, index;
>> +
>> +    /* sensor initialization */
>> +    index = 0;
>> +    for_each_child_of_node(np, child_np) {
>> +
>> +        if (index >= HISI_MAX_SENSORS) {
>> +            dev_err(&pdev->dev, "unsupported sensor number\n");
>> +            ret = -EINVAL;
>> +            goto err_init_sensors;
>> +        }
>> +
>> +        ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
>> +        if (ret)
>> +            goto err_init_sensors;
>> +
>> +        index++;
>> +    }
>> +
>> +    data->sensors_num = index;
>> +    return 0;
>> +
>> +err_init_sensors:
>> +    for (i = 0; i < index; i++)
>> +        thermal_zone_of_sensor_unregister(&pdev->dev,
>> +                data->sensors[i].tzd);
>> +    return ret;
>> +}
>> +
>> +static const struct of_device_id of_hisi_thermal_match[] = {
>> +    { .compatible = "hisilicon,tsensor" },
>> +    { /* end */ }
>> +};
>> +MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
>> +
>> +static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor *sensor,
>> +                       bool on)
>> +{
>> +    struct thermal_zone_device *tzd = sensor->tzd;
>> +
>> +    tzd->ops->set_mode(tzd,
>> +        on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
>> +}
>> +
>> +static int hisi_thermal_probe(struct platform_device *pdev)
>> +{
>> +    struct hisi_thermal_data *data;
>> +    struct resource *res;
>> +    int i;
>> +    int ret;
>> +
>> +    data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
>> +    if (!data)
>> +        return -ENOMEM;
>> +
>> +    data->pdev = pdev;
>> +
>> +    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
>> +    data->regs = devm_ioremap_resource(&pdev->dev, res);
>> +    if (IS_ERR(data->regs)) {
>> +        dev_err(&pdev->dev, "failed to get io address\n");
>> +        return PTR_ERR(data->regs);
>> +    }
>> +
>> +    data->irq = platform_get_irq(pdev, 0);
>> +    if (data->irq < 0)
>> +        return data->irq;
>> +
>> +    ret = devm_request_threaded_irq(&pdev->dev, data->irq,
>> +            hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
>> +            0, "hisi_thermal", data);
>> +    if (ret < 0) {
>> +        dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
>> +        return ret;
>> +    }
>> +
>> +    platform_set_drvdata(pdev, data);
>> +
>> +    data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
>> +    if (IS_ERR(data->clk)) {
>> +        ret = PTR_ERR(data->clk);
>> +        if (ret != -EPROBE_DEFER)
>> +            dev_err(&pdev->dev,
>> +                "failed to get thermal clk: %d\n", ret);
>> +        return ret;
>> +    }
>> +
>> +    /* enable clock for thermal */
>> +    ret = clk_prepare_enable(data->clk);
>> +    if (ret) {
>> +        dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
>> +        return ret;
>> +    }
>> +
>> +    ret = hisi_thermal_get_sensor_data(pdev);
>> +    if (ret) {
>> +        dev_err(&pdev->dev, "failed to get sensor data\n");
>> +        goto err_get_sensor_data;
>> +        return ret;
>> +    }
>> +
>> +    hisi_thermal_enable_sensor(data);
>> +    data->irq_enabled = true;
>> +
>> +    for (i = 0; i < data->sensors_num; i++)
>> +        hisi_thermal_toggle_sensor(&data->sensors[i], true);
>> +
>> +    return 0;
>> +
>> +err_get_sensor_data:
>> +    clk_disable_unprepare(data->clk);
>> +    return ret;
>> +}
>> +
>> +static int hisi_thermal_remove(struct platform_device *pdev)
>> +{
>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>> +    int i;
>> +
>> +    for (i = 0; i < data->sensors_num; i++) {
>> +        struct hisi_thermal_sensor *sensor = &data->sensors[i];
>> +
>> +        hisi_thermal_toggle_sensor(sensor, false);
>> +        thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
>> +    }
>> +
>> +    hisi_thermal_disable_sensor(data);
>> +    clk_disable_unprepare(data->clk);
>> +    return 0;
>> +}
>> +
>> +#ifdef CONFIG_PM_SLEEP
>> +static int hisi_thermal_suspend(struct device *dev)
>> +{
>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>> +
>> +    hisi_thermal_disable_sensor(data);
>> +    data->irq_enabled = false;
>> +
>> +    clk_disable_unprepare(data->clk);
>> +
>> +    return 0;
>> +}
>> +
>> +static int hisi_thermal_resume(struct device *dev)
>> +{
>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>> +
>> +    clk_prepare_enable(data->clk);
>> +
>> +    data->irq_enabled = true;
>> +    hisi_thermal_enable_sensor(data);
>> +
>> +    return 0;
>> +}
>> +#endif
>> +
>> +static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
>> +             hisi_thermal_suspend, hisi_thermal_resume);
>> +
>> +static struct platform_driver hisi_thermal_driver = {
>> +    .driver = {
>> +        .name    = "hisi_thermal",
>> +        .owner  = THIS_MODULE,
>> +        .pm    = &hisi_thermal_pm_ops,
>> +        .of_match_table = of_hisi_thermal_match,
>> +    },
>> +    .probe        = hisi_thermal_probe,
>> +    .remove        = hisi_thermal_remove,
>> +};
>> +
>> +static int __init hisi_thermal_init(void)
>> +{
>> +    return platform_driver_register(&hisi_thermal_driver);
>> +}
>> +
>> +static void __exit hisi_thermal_exit(void)
>> +{
>> +    platform_driver_unregister(&hisi_thermal_driver);
>> +}
>> +
>> +late_initcall(hisi_thermal_init);
>> +module_exit(hisi_thermal_exit);
>> +
>> +MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
>> +MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
>> +MODULE_DESCRIPTION("Hisilicon thermal driver");
>> +MODULE_LICENSE("GPL v2");
>>
> 
> 
> 
> .
> 

Re: [PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[Xinwei Kong]

On 2015/3/26 17:14, YiPing Xu wrote:
> 在 2015/3/25 15:50, Xinwei Kong 写道:
>> From: kongxinwei <kong.kongxinwei@hisilicon.com>
>>
>> This patch adds the support for hisilicon thermal sensor, within
>> hisilicon SoC. there will register sensors for thermal framework
>> and use device tree to bind cooling device.
>>
>> Signed-off-by: Leo Yan <leo.yan@linaro.org>
>> Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
>> ---
>>   drivers/thermal/Kconfig        |   8 +
>>   drivers/thermal/Makefile       |   1 +
>>   drivers/thermal/hisi_thermal.c | 526 +++++++++++++++++++++++++++++++++++++++++
>>   3 files changed, 535 insertions(+)
>>   create mode 100644 drivers/thermal/hisi_thermal.c
>>
>> diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
>> index af40db0..81aee01 100644
>> --- a/drivers/thermal/Kconfig
>> +++ b/drivers/thermal/Kconfig
>> @@ -136,6 +136,14 @@ config THERMAL_EMULATION
>>         because userland can easily disable the thermal policy by simply
>>         flooding this sysfs node with low temperature values.
>>
>> +config HISI_THERMAL
>> +    tristate "Hisilicon thermal driver"
>> +    depends on ARCH_HISI && CPU_THERMAL && OF
>> +    help
>> +      Enable this to plug hisilicon's thermal sensor driver into the Linux
>> +      thermal framework. cpufreq is used as the cooling device to throttle
>> +      CPUs when the passive trip is crossed.
>> +
>>   config IMX_THERMAL
>>       tristate "Temperature sensor driver for Freescale i.MX SoCs"
>>       depends on CPU_THERMAL
>> diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
>> index fa0dc48..08ae7ac 100644
>> --- a/drivers/thermal/Makefile
>> +++ b/drivers/thermal/Makefile
>> @@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)    += ti-soc-thermal/
>>   obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
>>   obj-$(CONFIG_ST_THERMAL)    += st/
>>   obj-$(CONFIG_TEGRA_SOCTHERM)    += tegra_soctherm.o
>> +obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
>> diff --git a/drivers/thermal/hisi_thermal.c b/drivers/thermal/hisi_thermal.c
>> new file mode 100644
>> index 0000000..8edf83a
>> --- /dev/null
>> +++ b/drivers/thermal/hisi_thermal.c
> 
>    are you sure all the SOCs in hisilicon use the same thermal IP ?
> 
>    if not, this driver should not use the "hisi_" prefix.

We can use this hisi thermal driver framework to satisfy diff thermal
IP, all of SoC will use this drvier by adding a struct about diff IP.
We may talk about hisi thermal diff IP how to satisfy this driver.

Thanks
Xinwei

> 
>> @@ -0,0 +1,526 @@
>> +/*
>> + * Hisilicon thermal sensor driver
>> + *
>> + * Copyright (c) 2014-2015 Hisilicon Limited.
>> + * Copyright (c) 2014-2015 Linaro Limited.
>> + *
>> + * Xinwei Kong <kong.kongxinwei@hisilicon.com>
>> + * Leo Yan <leo.yan@linaro.org>
>> + *
>> + * This program is free software; you can redistribute it and/or modify
>> + * it under the terms of the GNU General Public License version 2 as
>> + * published by the Free Software Foundation.
>> + *
>> + * This program is distributed "as is" WITHOUT ANY WARRANTY of any
>> + * kind, whether express or implied; without even the implied warranty
>> + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>> + * GNU General Public License for more details.
>> + */
>> +
>> +#include <linux/cpu_cooling.h>
>> +#include <linux/cpufreq.h>
>> +#include <linux/delay.h>
>> +#include <linux/device.h>
>> +#include <linux/init.h>
>> +#include <linux/interrupt.h>
>> +#include <linux/io.h>
>> +#include <linux/kernel.h>
>> +#include <linux/mfd/syscon.h>
>> +#include <linux/module.h>
>> +#include <linux/of.h>
>> +#include <linux/of_device.h>
>> +#include <linux/platform_device.h>
>> +#include <linux/regmap.h>
>> +#include <linux/slab.h>
>> +#include <linux/thermal.h>
>> +#include <linux/types.h>
>> +
>> +#include "thermal_core.h"
>> +
>> +#define TEMP0_LAG            (0x0)
>> +#define TEMP0_TH            (0x4)
>> +#define TEMP0_RST_TH            (0x8)
>> +#define TEMP0_CFG            (0xC)
>> +#define TEMP0_EN            (0x10)
>> +#define TEMP0_INT_EN            (0x14)
>> +#define TEMP0_INT_CLR            (0x18)
>> +#define TEMP0_RST_MSK            (0x1C)
>> +#define TEMP0_RAW_INT            (0x20)
>> +#define TEMP0_MSK_INT            (0x24)
>> +#define TEMP0_VALUE            (0x28)
>> +
>> +#define HISI_TEMP_BASE            (-60)
>> +#define HISI_TEMP_RESET            (100000)
>> +#define HISI_TEMP_PASSIVE        (85000)
>> +
>> +#define HISI_MAX_SENSORS        4
>> +
>> +struct hisi_thermal_sensor {
>> +    struct hisi_thermal_data *thermal;
>> +    struct thermal_zone_device *tzd;
>> +    const struct thermal_trip *trip;
>> +
>> +    uint32_t id;
>> +    uint32_t thres_temp, reset_temp;
>> +};
>> +
>> +struct hisi_thermal_data {
>> +    struct platform_device *pdev;
>> +    struct clk *clk;
>> +
>> +    int irq, irq_bind_sensor;
>> +    bool irq_enabled;
>> +
>> +    unsigned int sensors_num;
>> +    long sensor_temp[HISI_MAX_SENSORS];
>> +    struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
>> +
>> +    void __iomem *regs;
>> +};
>> +
>> +static DEFINE_SPINLOCK(thermal_lock);
>> +
> 
>    "thermal_lock" should be defined in "hisi_thermal_data" to support multi device instance.
> 

ok,good comments

>> +/* in millicelsius */
>> +static inline int _step_to_temp(int step)
>> +{
>> +    /*
>> +     * Every step equals (1 * 200) / 255 celsius, and finally
>> +     * need convert to millicelsius.
>> +     */
>> +    return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
>> +}
>> +
>> +static inline int _temp_to_step(int temp)
>> +{
>> +    return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
>> +}
>> +
>> +static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data *data,
>> +                     struct hisi_thermal_sensor *sensor)
>> +{
>> +    unsigned long flags;
>> +    int val;
>> +
>> +    spin_lock_irqsave(&thermal_lock, flags);
>> +
>> +    /* disable module firstly */
>> +    writel(0x0, data->regs + TEMP0_EN);
>> +
>> +    /* select sensor id */
>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>> +
>> +    /* enable module */
>> +    writel(0x1, data->regs + TEMP0_EN);
>> +
>> +    mdelay(5);
>> +
>> +    val = readl(data->regs + TEMP0_VALUE);
>> +    val = _step_to_temp(val);
>> +
>> +    /* adjust for negative value */
>> +    val = (val < 0) ? 0 : val;
>> +
>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>> +
>> +    return val;
>> +}
>> +
>> +static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
>> +{
>> +    struct hisi_thermal_sensor *sensor;
>> +    unsigned long flags;
>> +
>> +    sensor = &data->sensors[data->irq_bind_sensor];
>> +
>> +    spin_lock_irqsave(&thermal_lock, flags);
>> +
>> +    /* setting the hdak time */
>> +    writel(0x0, data->regs + TEMP0_CFG);
>> +
>> +    /* disable module firstly */
>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>> +    writel(0x0, data->regs + TEMP0_EN);
>> +
>> +    /* select sensor id */
>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>> +
>> +    /* enable for interrupt */
>> +    writel(_temp_to_step(sensor->thres_temp)
>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>> +
>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>> +
>> +    /* enable module */
>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>> +    writel(0x1, data->regs + TEMP0_EN);
>> +
>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>> +
>> +    mdelay(5);
>> +
>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>> +
>> +}
>> +
>> +static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
>> +{
>> +    struct hisi_thermal_sensor *sensor;
>> +    unsigned long flags;
>> +
>> +    sensor = &data->sensors[data->irq_bind_sensor];
>> +
>> +    spin_lock_irqsave(&thermal_lock, flags);
>> +
>> +    /* setting the hdak time */
>> +    writel(0x0, data->regs + TEMP0_CFG);
>> +
>> +    /* disable module firstly */
>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>> +    writel(0x0, data->regs + TEMP0_EN);
>> +
>> +    /* select sensor id */
>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>> +
>> +    /* enable for interrupt */
>> +    writel(_temp_to_step(sensor->thres_temp)
>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>> +
>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>> +
>> +    /* enable module */
>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>> +    writel(0x1, data->regs + TEMP0_EN);
>> +
>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>> +
>> +    mdelay(5);
>> +
>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>> +
>> +}
>> +
>> +static void hisi_thermal_disable_sensor(struct hisi_thermal_data *data)
>> +{
>> +    unsigned long flags;
>> +
>> +    spin_lock_irqsave(&thermal_lock, flags);
>> +
>> +    /* disable sensor module */
>> +    writel(0x0, data->regs + TEMP0_INT_EN);
>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>> +    writel(0x0, data->regs + TEMP0_EN);
>> +
>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>> +
>> +}
>> +
>> +static int hisi_thermal_get_temp(void *_sensor, long *temp)
>> +{
>> +    struct hisi_thermal_sensor *sensor = _sensor;
>> +    struct hisi_thermal_data *data = sensor->thermal;
>> +
>> +    int sensor_id = 0, i;
>> +    long max_temp = 0;
>> +
>> +    *temp = hisi_thermal_get_sensor_temp(data, sensor);
>> +
>> +    data->sensor_temp[sensor->id] = *temp;
>> +
>> +    for (i = 0; i < HISI_MAX_SENSORS; i++) {
>> +        if (data->sensor_temp[i] >= max_temp) {
>> +            max_temp = data->sensor_temp[i];
>> +            sensor_id = i;
>> +        }
>> +    }
>> +
>> +    data->irq_bind_sensor = sensor_id;
>> +
>> +    dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
>> +        sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
>> +
>> +    /*
>> +     * Bind irq to sensor for two cases:
>> +     *   Reenable alarm IRQ if temperature below threshold;
>> +     *   if irq has been enabled, always set it;
>> +     */
>> +    if (!data->irq_enabled && max_temp < sensor->thres_temp) {
>> +        data->irq_enabled = true;
>> +        hisi_thermal_bind_irq(data);
>> +    } else if (data->irq_enabled)
>> +        hisi_thermal_bind_irq(data);
>> +
>> +    return 0;
>> +}
>> +
>> +static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
>> +    .get_temp = hisi_thermal_get_temp,
>> +};
>> +
>> +static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
>> +{
>> +    struct hisi_thermal_data *data = dev;
>> +    unsigned long flags;
>> +
>> +    spin_lock_irqsave(&thermal_lock, flags);
>> +
>> +    /* disable interrupt */
>> +    writel(0x0, data->regs + TEMP0_INT_EN);
>> +    writel(0x1, data->regs + TEMP0_INT_CLR);
>> +
>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>> +    data->irq_enabled = false;
>> +
>> +    return IRQ_WAKE_THREAD;
>> +}
>> +
>> +static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
>> +{
>> +    struct hisi_thermal_data *data = dev;
>> +    struct hisi_thermal_sensor *sensor;
>> +    int i;
>> +
>> +    sensor = &data->sensors[data->irq_bind_sensor];
>> +
>> +    dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
>> +         sensor->thres_temp / 1000);
>> +
>> +    for (i = 0; i < data->sensors_num; i++)
>> +        thermal_zone_device_update(data->sensors[i].tzd);
>> +
>> +    return IRQ_HANDLED;
>> +}
>> +
>> +static int hisi_thermal_init_sensor(struct platform_device *pdev,
>> +                    struct device_node *np,
>> +                    struct hisi_thermal_data *data,
>> +                    int index)
>> +{
>> +    struct hisi_thermal_sensor *sensor;
>> +    int ret, i;
>> +
>> +    sensor = &data->sensors[index];
>> +
>> +    ret = of_property_read_u32(np, "hisilicon,tsensor-id",
>> +                    &sensor->id);
>> +    if (ret) {
>> +        dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
>> +        return ret;
>> +    }
>> +
>> +    sensor->thermal = data;
>> +    sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev, sensor->id,
>> +                sensor, &hisi_of_thermal_ops);
>> +    if (IS_ERR(sensor->tzd)) {
>> +        ret = PTR_ERR(sensor->tzd);
>> +        dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
>> +            sensor->id, ret);
>> +        return ret;
>> +    }
>> +
>> +    sensor->trip = of_thermal_get_trip_points(sensor->tzd);
>> +
>> +    for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
>> +        if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
>> +            sensor->thres_temp = sensor->trip[i].temperature;
>> +            break;
>> +        }
>> +    }
>> +
>> +    return 0;
>> +}
>> +
>> +static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
>> +{
>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>> +    struct device_node *np = pdev->dev.of_node;
>> +    struct device_node *child_np;
>> +    int ret, i, index;
>> +
>> +    /* sensor initialization */
>> +    index = 0;
>> +    for_each_child_of_node(np, child_np) {
>> +
>> +        if (index >= HISI_MAX_SENSORS) {
>> +            dev_err(&pdev->dev, "unsupported sensor number\n");
>> +            ret = -EINVAL;
>> +            goto err_init_sensors;
>> +        }
>> +
>> +        ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
>> +        if (ret)
>> +            goto err_init_sensors;
>> +
>> +        index++;
>> +    }
>> +
>> +    data->sensors_num = index;
>> +    return 0;
>> +
>> +err_init_sensors:
>> +    for (i = 0; i < index; i++)
>> +        thermal_zone_of_sensor_unregister(&pdev->dev,
>> +                data->sensors[i].tzd);
>> +    return ret;
>> +}
>> +
>> +static const struct of_device_id of_hisi_thermal_match[] = {
>> +    { .compatible = "hisilicon,tsensor" },
>> +    { /* end */ }
>> +};
>> +MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
>> +
>> +static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor *sensor,
>> +                       bool on)
>> +{
>> +    struct thermal_zone_device *tzd = sensor->tzd;
>> +
>> +    tzd->ops->set_mode(tzd,
>> +        on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
>> +}
>> +
>> +static int hisi_thermal_probe(struct platform_device *pdev)
>> +{
>> +    struct hisi_thermal_data *data;
>> +    struct resource *res;
>> +    int i;
>> +    int ret;
>> +
>> +    data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
>> +    if (!data)
>> +        return -ENOMEM;
>> +
>> +    data->pdev = pdev;
>> +
>> +    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
>> +    data->regs = devm_ioremap_resource(&pdev->dev, res);
>> +    if (IS_ERR(data->regs)) {
>> +        dev_err(&pdev->dev, "failed to get io address\n");
>> +        return PTR_ERR(data->regs);
>> +    }
>> +
>> +    data->irq = platform_get_irq(pdev, 0);
>> +    if (data->irq < 0)
>> +        return data->irq;
>> +
>> +    ret = devm_request_threaded_irq(&pdev->dev, data->irq,
>> +            hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
>> +            0, "hisi_thermal", data);
>> +    if (ret < 0) {
>> +        dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
>> +        return ret;
>> +    }
>> +
>> +    platform_set_drvdata(pdev, data);
>> +
>> +    data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
>> +    if (IS_ERR(data->clk)) {
>> +        ret = PTR_ERR(data->clk);
>> +        if (ret != -EPROBE_DEFER)
>> +            dev_err(&pdev->dev,
>> +                "failed to get thermal clk: %d\n", ret);
>> +        return ret;
>> +    }
>> +
>> +    /* enable clock for thermal */
>> +    ret = clk_prepare_enable(data->clk);
>> +    if (ret) {
>> +        dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
>> +        return ret;
>> +    }
>> +
>> +    ret = hisi_thermal_get_sensor_data(pdev);
>> +    if (ret) {
>> +        dev_err(&pdev->dev, "failed to get sensor data\n");
>> +        goto err_get_sensor_data;
>> +        return ret;
>> +    }
>> +
>> +    hisi_thermal_enable_sensor(data);
>> +    data->irq_enabled = true;
>> +
>> +    for (i = 0; i < data->sensors_num; i++)
>> +        hisi_thermal_toggle_sensor(&data->sensors[i], true);
>> +
>> +    return 0;
>> +
>> +err_get_sensor_data:
>> +    clk_disable_unprepare(data->clk);
>> +    return ret;
>> +}
>> +
>> +static int hisi_thermal_remove(struct platform_device *pdev)
>> +{
>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>> +    int i;
>> +
>> +    for (i = 0; i < data->sensors_num; i++) {
>> +        struct hisi_thermal_sensor *sensor = &data->sensors[i];
>> +
>> +        hisi_thermal_toggle_sensor(sensor, false);
>> +        thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
>> +    }
>> +
>> +    hisi_thermal_disable_sensor(data);
>> +    clk_disable_unprepare(data->clk);
>> +    return 0;
>> +}
>> +
>> +#ifdef CONFIG_PM_SLEEP
>> +static int hisi_thermal_suspend(struct device *dev)
>> +{
>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>> +
>> +    hisi_thermal_disable_sensor(data);
>> +    data->irq_enabled = false;
>> +
>> +    clk_disable_unprepare(data->clk);
>> +
>> +    return 0;
>> +}
>> +
>> +static int hisi_thermal_resume(struct device *dev)
>> +{
>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>> +
>> +    clk_prepare_enable(data->clk);
>> +
>> +    data->irq_enabled = true;
>> +    hisi_thermal_enable_sensor(data);
>> +
>> +    return 0;
>> +}
>> +#endif
>> +
>> +static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
>> +             hisi_thermal_suspend, hisi_thermal_resume);
>> +
>> +static struct platform_driver hisi_thermal_driver = {
>> +    .driver = {
>> +        .name    = "hisi_thermal",
>> +        .owner  = THIS_MODULE,
>> +        .pm    = &hisi_thermal_pm_ops,
>> +        .of_match_table = of_hisi_thermal_match,
>> +    },
>> +    .probe        = hisi_thermal_probe,
>> +    .remove        = hisi_thermal_remove,
>> +};
>> +
>> +static int __init hisi_thermal_init(void)
>> +{
>> +    return platform_driver_register(&hisi_thermal_driver);
>> +}
>> +
>> +static void __exit hisi_thermal_exit(void)
>> +{
>> +    platform_driver_unregister(&hisi_thermal_driver);
>> +}
>> +
>> +late_initcall(hisi_thermal_init);
>> +module_exit(hisi_thermal_exit);
>> +
>> +MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
>> +MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
>> +MODULE_DESCRIPTION("Hisilicon thermal driver");
>> +MODULE_LICENSE("GPL v2");
>>
> 
> 
> 
> .
> 

Re: [PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[YiPing Xu]

在 2015/3/27 16:30, Xinwei Kong 写道:
>
>
> On 2015/3/26 17:14, YiPing Xu wrote:
>> 在 2015/3/25 15:50, Xinwei Kong 写道:
>>> From: kongxinwei <kong.kongxinwei@hisilicon.com>
>>>
>>> This patch adds the support for hisilicon thermal sensor, within
>>> hisilicon SoC. there will register sensors for thermal framework
>>> and use device tree to bind cooling device.
>>>
>>> Signed-off-by: Leo Yan <leo.yan@linaro.org>
>>> Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
>>> ---
>>>    drivers/thermal/Kconfig        |   8 +
>>>    drivers/thermal/Makefile       |   1 +
>>>    drivers/thermal/hisi_thermal.c | 526 +++++++++++++++++++++++++++++++++++++++++
>>>    3 files changed, 535 insertions(+)
>>>    create mode 100644 drivers/thermal/hisi_thermal.c
>>>
>>> diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
>>> index af40db0..81aee01 100644
>>> --- a/drivers/thermal/Kconfig
>>> +++ b/drivers/thermal/Kconfig
>>> @@ -136,6 +136,14 @@ config THERMAL_EMULATION
>>>          because userland can easily disable the thermal policy by simply
>>>          flooding this sysfs node with low temperature values.
>>>
>>> +config HISI_THERMAL
>>> +    tristate "Hisilicon thermal driver"
>>> +    depends on ARCH_HISI && CPU_THERMAL && OF
>>> +    help
>>> +      Enable this to plug hisilicon's thermal sensor driver into the Linux
>>> +      thermal framework. cpufreq is used as the cooling device to throttle
>>> +      CPUs when the passive trip is crossed.
>>> +
>>>    config IMX_THERMAL
>>>        tristate "Temperature sensor driver for Freescale i.MX SoCs"
>>>        depends on CPU_THERMAL
>>> diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
>>> index fa0dc48..08ae7ac 100644
>>> --- a/drivers/thermal/Makefile
>>> +++ b/drivers/thermal/Makefile
>>> @@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)    += ti-soc-thermal/
>>>    obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
>>>    obj-$(CONFIG_ST_THERMAL)    += st/
>>>    obj-$(CONFIG_TEGRA_SOCTHERM)    += tegra_soctherm.o
>>> +obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
>>> diff --git a/drivers/thermal/hisi_thermal.c b/drivers/thermal/hisi_thermal.c
>>> new file mode 100644
>>> index 0000000..8edf83a
>>> --- /dev/null
>>> +++ b/drivers/thermal/hisi_thermal.c
>>
>>     are you sure all the SOCs in hisilicon use the same thermal IP ?
>>
>>     if not, this driver should not use the "hisi_" prefix.
>
> We can use this hisi thermal driver framework to satisfy diff thermal
> IP, all of SoC will use this drvier by adding a struct about diff IP.
> We may talk about hisi thermal diff IP how to satisfy this driver.
>
> Thanks
> Xinwei
>
>>
>>> @@ -0,0 +1,526 @@
>>> +/*
>>> + * Hisilicon thermal sensor driver
>>> + *
>>> + * Copyright (c) 2014-2015 Hisilicon Limited.
>>> + * Copyright (c) 2014-2015 Linaro Limited.
>>> + *
>>> + * Xinwei Kong <kong.kongxinwei@hisilicon.com>
>>> + * Leo Yan <leo.yan@linaro.org>
>>> + *
>>> + * This program is free software; you can redistribute it and/or modify
>>> + * it under the terms of the GNU General Public License version 2 as
>>> + * published by the Free Software Foundation.
>>> + *
>>> + * This program is distributed "as is" WITHOUT ANY WARRANTY of any
>>> + * kind, whether express or implied; without even the implied warranty
>>> + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>>> + * GNU General Public License for more details.
>>> + */
>>> +
>>> +#include <linux/cpu_cooling.h>
>>> +#include <linux/cpufreq.h>
>>> +#include <linux/delay.h>
>>> +#include <linux/device.h>
>>> +#include <linux/init.h>
>>> +#include <linux/interrupt.h>
>>> +#include <linux/io.h>
>>> +#include <linux/kernel.h>
>>> +#include <linux/mfd/syscon.h>
>>> +#include <linux/module.h>
>>> +#include <linux/of.h>
>>> +#include <linux/of_device.h>
>>> +#include <linux/platform_device.h>
>>> +#include <linux/regmap.h>
>>> +#include <linux/slab.h>
>>> +#include <linux/thermal.h>
>>> +#include <linux/types.h>
>>> +
>>> +#include "thermal_core.h"
>>> +
>>> +#define TEMP0_LAG            (0x0)
>>> +#define TEMP0_TH            (0x4)
>>> +#define TEMP0_RST_TH            (0x8)
>>> +#define TEMP0_CFG            (0xC)
>>> +#define TEMP0_EN            (0x10)
>>> +#define TEMP0_INT_EN            (0x14)
>>> +#define TEMP0_INT_CLR            (0x18)
>>> +#define TEMP0_RST_MSK            (0x1C)
>>> +#define TEMP0_RAW_INT            (0x20)
>>> +#define TEMP0_MSK_INT            (0x24)
>>> +#define TEMP0_VALUE            (0x28)
>>> +
>>> +#define HISI_TEMP_BASE            (-60)
>>> +#define HISI_TEMP_RESET            (100000)
>>> +#define HISI_TEMP_PASSIVE        (85000)
>>> +
>>> +#define HISI_MAX_SENSORS        4
>>> +
>>> +struct hisi_thermal_sensor {
>>> +    struct hisi_thermal_data *thermal;
>>> +    struct thermal_zone_device *tzd;
>>> +    const struct thermal_trip *trip;
>>> +
>>> +    uint32_t id;
>>> +    uint32_t thres_temp, reset_temp;
>>> +};
>>> +
>>> +struct hisi_thermal_data {
>>> +    struct platform_device *pdev;
>>> +    struct clk *clk;
>>> +
>>> +    int irq, irq_bind_sensor;
>>> +    bool irq_enabled;
>>> +
>>> +    unsigned int sensors_num;
>>> +    long sensor_temp[HISI_MAX_SENSORS];
>>> +    struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
>>> +
>>> +    void __iomem *regs;
>>> +};
>>> +
>>> +static DEFINE_SPINLOCK(thermal_lock);
>>> +
>>
>>     "thermal_lock" should be defined in "hisi_thermal_data" to support multi device instance.
>>
>
> ok,good comments
>
>>> +/* in millicelsius */
>>> +static inline int _step_to_temp(int step)
>>> +{
>>> +    /*
>>> +     * Every step equals (1 * 200) / 255 celsius, and finally
>>> +     * need convert to millicelsius.
>>> +     */
>>> +    return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
>>> +}
>>> +
>>> +static inline int _temp_to_step(int temp)
>>> +{
>>> +    return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
>>> +}
>>> +
>>> +static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data *data,
>>> +                     struct hisi_thermal_sensor *sensor)
>>> +{
>>> +    unsigned long flags;
>>> +    int val;
>>> +
>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>> +
>>> +    /* disable module firstly */
>>> +    writel(0x0, data->regs + TEMP0_EN);
>>> +
>>> +    /* select sensor id */
>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>> +
>>> +    /* enable module */
>>> +    writel(0x1, data->regs + TEMP0_EN);
>>> +
>>> +    mdelay(5);
>>> +
>>> +    val = readl(data->regs + TEMP0_VALUE);
>>> +    val = _step_to_temp(val);
>>> +
>>> +    /* adjust for negative value */
>>> +    val = (val < 0) ? 0 : val;
>>> +
>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>> +
>>> +    return val;
>>> +}
>>> +
>>> +static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
>>> +{
>>> +    struct hisi_thermal_sensor *sensor;
>>> +    unsigned long flags;
>>> +
>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>> +
>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>> +
>>> +    /* setting the hdak time */
>>> +    writel(0x0, data->regs + TEMP0_CFG);
>>> +
>>> +    /* disable module firstly */
>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>> +    writel(0x0, data->regs + TEMP0_EN);
>>> +
>>> +    /* select sensor id */
>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>> +
>>> +    /* enable for interrupt */
>>> +    writel(_temp_to_step(sensor->thres_temp)
>>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>>> +
>>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>>> +
>>> +    /* enable module */
>>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>>> +    writel(0x1, data->regs + TEMP0_EN);
>>> +
>>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>>> +
>>> +    mdelay(5);
>>> +
>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>> +
>>> +}
>>> +
>>> +static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
>>> +{
>>> +    struct hisi_thermal_sensor *sensor;
>>> +    unsigned long flags;
>>> +
>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>> +
>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>> +
>>> +    /* setting the hdak time */
>>> +    writel(0x0, data->regs + TEMP0_CFG);
>>> +
>>> +    /* disable module firstly */
>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>> +    writel(0x0, data->regs + TEMP0_EN);
>>> +
>>> +    /* select sensor id */
>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>> +
>>> +    /* enable for interrupt */
>>> +    writel(_temp_to_step(sensor->thres_temp)
>>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>>> +
>>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>>> +
>>> +    /* enable module */
>>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>>> +    writel(0x1, data->regs + TEMP0_EN);
>>> +
>>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>>> +
>>> +    mdelay(5);
>>> +
>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>> +

       Why take a 5ms delay in spin_lock_irq context ?

       Could we use mutex or other synchronization api here?

       For TEMP0_INT_EN, TEMP0_RST_MSK, we can use 
disable_irq(THERM_IRQ) instead.

>>> +}
>>> +
>>> +static void hisi_thermal_disable_sensor(struct hisi_thermal_data *data)
>>> +{
>>> +    unsigned long flags;
>>> +
>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>> +
>>> +    /* disable sensor module */
>>> +    writel(0x0, data->regs + );
>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>> +    writel(0x0, data->regs + TEMP0_EN);
>>> +
>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>> +
>>> +}
>>> +
>>> +static int hisi_thermal_get_temp(void *_sensor, long *temp)
>>> +{
>>> +    struct hisi_thermal_sensor *sensor = _sensor;
>>> +    struct hisi_thermal_data *data = sensor->thermal;
>>> +
>>> +    int sensor_id = 0, i;
>>> +    long max_temp = 0;
>>> +
>>> +    *temp = hisi_thermal_get_sensor_temp(data, sensor);
>>> +
>>> +    data->sensor_temp[sensor->id] = *temp;
>>> +
>>> +    for (i = 0; i < HISI_MAX_SENSORS; i++) {
>>> +        if (data->sensor_temp[i] >= max_temp) {
>>> +            max_temp = data->sensor_temp[i];
>>> +            sensor_id = i;
>>> +        }
>>> +    }
>>> +
>>> +    data->irq_bind_sensor = sensor_id;
>>> +
>>> +    dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
>>> +        sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
>>> +
>>> +    /*
>>> +     * Bind irq to sensor for two cases:
>>> +     *   Reenable alarm IRQ if temperature below threshold;
>>> +     *   if irq has been enabled, always set it;
>>> +     */
>>> +    if (!data->irq_enabled && max_temp < sensor->thres_temp) {
>>> +        data->irq_enabled = true;
>>> +        hisi_thermal_bind_irq(data);
>>> +    } else if (data->irq_enabled)
>>> +        hisi_thermal_bind_irq(data);
>>> +
>>> +    return 0;
>>> +}
>>> +
>>> +static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
>>> +    .get_temp = hisi_thermal_get_temp,
>>> +};
>>> +
>>> +static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
>>> +{
>>> +    struct hisi_thermal_data *data = dev;
>>> +    unsigned long flags;
>>> +
>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>> +
>>> +    /* disable interrupt */
>>> +    writel(0x0, data->regs + TEMP0_INT_EN);
>>> +    writel(0x1, data->regs + TEMP0_INT_CLR);
>>> +
>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>> +    data->irq_enabled = false;
>>> +
>>> +    return IRQ_WAKE_THREAD;
>>> +}
>>> +
>>> +static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
>>> +{
>>> +    struct hisi_thermal_data *data = dev;
>>> +    struct hisi_thermal_sensor *sensor;
>>> +    int i;
>>> +
>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>> +
>>> +    dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
>>> +         sensor->thres_temp / 1000);
>>> +
>>> +    for (i = 0; i < data->sensors_num; i++)
>>> +        thermal_zone_device_update(data->sensors[i].tzd);
>>> +
>>> +    return IRQ_HANDLED;
>>> +}
>>> +
>>> +static int hisi_thermal_init_sensor(struct platform_device *pdev,
>>> +                    struct device_node *np,
>>> +                    struct hisi_thermal_data *data,
>>> +                    int index)
>>> +{
>>> +    struct hisi_thermal_sensor *sensor;
>>> +    int ret, i;
>>> +
>>> +    sensor = &data->sensors[index];
>>> +
>>> +    ret = of_property_read_u32(np, "hisilicon,tsensor-id",
>>> +                    &sensor->id);
>>> +    if (ret) {
>>> +        dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
>>> +        return ret;
>>> +    }
>>> +
>>> +    sensor->thermal = data;
>>> +    sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev, sensor->id,
>>> +                sensor, &hisi_of_thermal_ops);
>>> +    if (IS_ERR(sensor->tzd)) {
>>> +        ret = PTR_ERR(sensor->tzd);
>>> +        dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
>>> +            sensor->id, ret);
>>> +        return ret;
>>> +    }
>>> +
>>> +    sensor->trip = of_thermal_get_trip_points(sensor->tzd);
>>> +
>>> +    for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
>>> +        if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
>>> +            sensor->thres_temp = sensor->trip[i].temperature;
>>> +            break;
>>> +        }
>>> +    }
>>> +
>>> +    return 0;
>>> +}
>>> +
>>> +static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
>>> +{
>>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>>> +    struct device_node *np = pdev->dev.of_node;
>>> +    struct device_node *child_np;
>>> +    int ret, i, index;
>>> +
>>> +    /* sensor initialization */
>>> +    index = 0;
>>> +    for_each_child_of_node(np, child_np) {
>>> +
>>> +        if (index >= HISI_MAX_SENSORS) {
>>> +            dev_err(&pdev->dev, "unsupported sensor number\n");
>>> +            ret = -EINVAL;
>>> +            goto err_init_sensors;
>>> +        }
>>> +
>>> +        ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
>>> +        if (ret)
>>> +            goto err_init_sensors;
>>> +
>>> +        index++;
>>> +    }
>>> +
>>> +    data->sensors_num = index;
>>> +    return 0;
>>> +
>>> +err_init_sensors:
>>> +    for (i = 0; i < index; i++)
>>> +        thermal_zone_of_sensor_unregister(&pdev->dev,
>>> +                data->sensors[i].tzd);
>>> +    return ret;
>>> +}
>>> +
>>> +static const struct of_device_id of_hisi_thermal_match[] = {
>>> +    { .compatible = "hisilicon,tsensor" },
>>> +    { /* end */ }
>>> +};
>>> +MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
>>> +
>>> +static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor *sensor,
>>> +                       bool on)
>>> +{
>>> +    struct thermal_zone_device *tzd = sensor->tzd;
>>> +
>>> +    tzd->ops->set_mode(tzd,
>>> +        on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
>>> +}
>>> +
>>> +static int hisi_thermal_probe(struct platform_device *pdev)
>>> +{
>>> +    struct hisi_thermal_data *data;
>>> +    struct resource *res;
>>> +    int i;
>>> +    int ret;
>>> +
>>> +    data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
>>> +    if (!data)
>>> +        return -ENOMEM;
>>> +
>>> +    data->pdev = pdev;
>>> +
>>> +    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
>>> +    data->regs = devm_ioremap_resource(&pdev->dev, res);
>>> +    if (IS_ERR(data->regs)) {
>>> +        dev_err(&pdev->dev, "failed to get io address\n");
>>> +        return PTR_ERR(data->regs);
>>> +    }
>>> +
>>> +    data->irq = platform_get_irq(pdev, 0);
>>> +    if (data->irq < 0)
>>> +        return data->irq;
>>> +
>>> +    ret = devm_request_threaded_irq(&pdev->dev, data->irq,
>>> +            hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
>>> +            0, "hisi_thermal", data);
>>> +    if (ret < 0) {
>>> +        dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
>>> +        return ret;
>>> +    }
>>> +
>>> +    platform_set_drvdata(pdev, data);
>>> +
>>> +    data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
>>> +    if (IS_ERR(data->clk)) {
>>> +        ret = PTR_ERR(data->clk);
>>> +        if (ret != -EPROBE_DEFER)
>>> +            dev_err(&pdev->dev,
>>> +                "failed to get thermal clk: %d\n", ret);
>>> +        return ret;
>>> +    }
>>> +
>>> +    /* enable clock for thermal */
>>> +    ret = clk_prepare_enable(data->clk);
>>> +    if (ret) {
>>> +        dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
>>> +        return ret;
>>> +    }
>>> +
>>> +    ret = hisi_thermal_get_sensor_data(pdev);
>>> +    if (ret) {
>>> +        dev_err(&pdev->dev, "failed to get sensor data\n");
>>> +        goto err_get_sensor_data;
>>> +        return ret;
>>> +    }
>>> +
>>> +    hisi_thermal_enable_sensor(data);
>>> +    data->irq_enabled = true;
>>> +
>>> +    for (i = 0; i < data->sensors_num; i++)
>>> +        hisi_thermal_toggle_sensor(&data->sensors[i], true);
>>> +
>>> +    return 0;
>>> +
>>> +err_get_sensor_data:
>>> +    clk_disable_unprepare(data->clk);
>>> +    return ret;
>>> +}
>>> +
>>> +static int hisi_thermal_remove(struct platform_device *pdev)
>>> +{
>>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>>> +    int i;
>>> +
>>> +    for (i = 0; i < data->sensors_num; i++) {
>>> +        struct hisi_thermal_sensor *sensor = &data->sensors[i];
>>> +
>>> +        hisi_thermal_toggle_sensor(sensor, false);
>>> +        thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
>>> +    }
>>> +
>>> +    hisi_thermal_disable_sensor(data);
>>> +    clk_disable_unprepare(data->clk);
>>> +    return 0;
>>> +}
>>> +
>>> +#ifdef CONFIG_PM_SLEEP
>>> +static int hisi_thermal_suspend(struct device *dev)
>>> +{
>>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>>> +
>>> +    hisi_thermal_disable_sensor(data);
>>> +    data->irq_enabled = false;
>>> +
>>> +    clk_disable_unprepare(data->clk);
>>> +
>>> +    return 0;
>>> +}
>>> +
>>> +static int hisi_thermal_resume(struct device *dev)
>>> +{
>>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>>> +
>>> +    clk_prepare_enable(data->clk);
>>> +
>>> +    data->irq_enabled = true;
>>> +    hisi_thermal_enable_sensor(data);
>>> +
>>> +    return 0;
>>> +}
>>> +#endif
>>> +
>>> +static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
>>> +             hisi_thermal_suspend, hisi_thermal_resume);
>>> +
>>> +static struct platform_driver hisi_thermal_driver = {
>>> +    .driver = {
>>> +        .name    = "hisi_thermal",
>>> +        .owner  = THIS_MODULE,
>>> +        .pm    = &hisi_thermal_pm_ops,
>>> +        .of_match_table = of_hisi_thermal_match,
>>> +    },
>>> +    .probe        = hisi_thermal_probe,
>>> +    .remove        = hisi_thermal_remove,
>>> +};
>>> +
>>> +static int __init hisi_thermal_init(void)
>>> +{
>>> +    return platform_driver_register(&hisi_thermal_driver);
>>> +}
>>> +
>>> +static void __exit hisi_thermal_exit(void)
>>> +{
>>> +    platform_driver_unregister(&hisi_thermal_driver);
>>> +}
>>> +
>>> +late_initcall(hisi_thermal_init);
>>> +module_exit(hisi_thermal_exit);
>>> +
>>> +MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
>>> +MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
>>> +MODULE_DESCRIPTION("Hisilicon thermal driver");
>>> +MODULE_LICENSE("GPL v2");
>>>
>>
>>
>>
>> .
>>
>
>
> .
>

[PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[YiPing Xu]

? 2015/3/27 16:30, Xinwei Kong ??:
>
>
> On 2015/3/26 17:14, YiPing Xu wrote:
>> ? 2015/3/25 15:50, Xinwei Kong ??:
>>> From: kongxinwei <kong.kongxinwei@hisilicon.com>
>>>
>>> This patch adds the support for hisilicon thermal sensor, within
>>> hisilicon SoC. there will register sensors for thermal framework
>>> and use device tree to bind cooling device.
>>>
>>> Signed-off-by: Leo Yan <leo.yan@linaro.org>
>>> Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
>>> ---
>>>    drivers/thermal/Kconfig        |   8 +
>>>    drivers/thermal/Makefile       |   1 +
>>>    drivers/thermal/hisi_thermal.c | 526 +++++++++++++++++++++++++++++++++++++++++
>>>    3 files changed, 535 insertions(+)
>>>    create mode 100644 drivers/thermal/hisi_thermal.c
>>>
>>> diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
>>> index af40db0..81aee01 100644
>>> --- a/drivers/thermal/Kconfig
>>> +++ b/drivers/thermal/Kconfig
>>> @@ -136,6 +136,14 @@ config THERMAL_EMULATION
>>>          because userland can easily disable the thermal policy by simply
>>>          flooding this sysfs node with low temperature values.
>>>
>>> +config HISI_THERMAL
>>> +    tristate "Hisilicon thermal driver"
>>> +    depends on ARCH_HISI && CPU_THERMAL && OF
>>> +    help
>>> +      Enable this to plug hisilicon's thermal sensor driver into the Linux
>>> +      thermal framework. cpufreq is used as the cooling device to throttle
>>> +      CPUs when the passive trip is crossed.
>>> +
>>>    config IMX_THERMAL
>>>        tristate "Temperature sensor driver for Freescale i.MX SoCs"
>>>        depends on CPU_THERMAL
>>> diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
>>> index fa0dc48..08ae7ac 100644
>>> --- a/drivers/thermal/Makefile
>>> +++ b/drivers/thermal/Makefile
>>> @@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)    += ti-soc-thermal/
>>>    obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
>>>    obj-$(CONFIG_ST_THERMAL)    += st/
>>>    obj-$(CONFIG_TEGRA_SOCTHERM)    += tegra_soctherm.o
>>> +obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
>>> diff --git a/drivers/thermal/hisi_thermal.c b/drivers/thermal/hisi_thermal.c
>>> new file mode 100644
>>> index 0000000..8edf83a
>>> --- /dev/null
>>> +++ b/drivers/thermal/hisi_thermal.c
>>
>>     are you sure all the SOCs in hisilicon use the same thermal IP ?
>>
>>     if not, this driver should not use the "hisi_" prefix.
>
> We can use this hisi thermal driver framework to satisfy diff thermal
> IP, all of SoC will use this drvier by adding a struct about diff IP.
> We may talk about hisi thermal diff IP how to satisfy this driver.
>
> Thanks
> Xinwei
>
>>
>>> @@ -0,0 +1,526 @@
>>> +/*
>>> + * Hisilicon thermal sensor driver
>>> + *
>>> + * Copyright (c) 2014-2015 Hisilicon Limited.
>>> + * Copyright (c) 2014-2015 Linaro Limited.
>>> + *
>>> + * Xinwei Kong <kong.kongxinwei@hisilicon.com>
>>> + * Leo Yan <leo.yan@linaro.org>
>>> + *
>>> + * This program is free software; you can redistribute it and/or modify
>>> + * it under the terms of the GNU General Public License version 2 as
>>> + * published by the Free Software Foundation.
>>> + *
>>> + * This program is distributed "as is" WITHOUT ANY WARRANTY of any
>>> + * kind, whether express or implied; without even the implied warranty
>>> + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>>> + * GNU General Public License for more details.
>>> + */
>>> +
>>> +#include <linux/cpu_cooling.h>
>>> +#include <linux/cpufreq.h>
>>> +#include <linux/delay.h>
>>> +#include <linux/device.h>
>>> +#include <linux/init.h>
>>> +#include <linux/interrupt.h>
>>> +#include <linux/io.h>
>>> +#include <linux/kernel.h>
>>> +#include <linux/mfd/syscon.h>
>>> +#include <linux/module.h>
>>> +#include <linux/of.h>
>>> +#include <linux/of_device.h>
>>> +#include <linux/platform_device.h>
>>> +#include <linux/regmap.h>
>>> +#include <linux/slab.h>
>>> +#include <linux/thermal.h>
>>> +#include <linux/types.h>
>>> +
>>> +#include "thermal_core.h"
>>> +
>>> +#define TEMP0_LAG            (0x0)
>>> +#define TEMP0_TH            (0x4)
>>> +#define TEMP0_RST_TH            (0x8)
>>> +#define TEMP0_CFG            (0xC)
>>> +#define TEMP0_EN            (0x10)
>>> +#define TEMP0_INT_EN            (0x14)
>>> +#define TEMP0_INT_CLR            (0x18)
>>> +#define TEMP0_RST_MSK            (0x1C)
>>> +#define TEMP0_RAW_INT            (0x20)
>>> +#define TEMP0_MSK_INT            (0x24)
>>> +#define TEMP0_VALUE            (0x28)
>>> +
>>> +#define HISI_TEMP_BASE            (-60)
>>> +#define HISI_TEMP_RESET            (100000)
>>> +#define HISI_TEMP_PASSIVE        (85000)
>>> +
>>> +#define HISI_MAX_SENSORS        4
>>> +
>>> +struct hisi_thermal_sensor {
>>> +    struct hisi_thermal_data *thermal;
>>> +    struct thermal_zone_device *tzd;
>>> +    const struct thermal_trip *trip;
>>> +
>>> +    uint32_t id;
>>> +    uint32_t thres_temp, reset_temp;
>>> +};
>>> +
>>> +struct hisi_thermal_data {
>>> +    struct platform_device *pdev;
>>> +    struct clk *clk;
>>> +
>>> +    int irq, irq_bind_sensor;
>>> +    bool irq_enabled;
>>> +
>>> +    unsigned int sensors_num;
>>> +    long sensor_temp[HISI_MAX_SENSORS];
>>> +    struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
>>> +
>>> +    void __iomem *regs;
>>> +};
>>> +
>>> +static DEFINE_SPINLOCK(thermal_lock);
>>> +
>>
>>     "thermal_lock" should be defined in "hisi_thermal_data" to support multi device instance.
>>
>
> ok,good comments
>
>>> +/* in millicelsius */
>>> +static inline int _step_to_temp(int step)
>>> +{
>>> +    /*
>>> +     * Every step equals (1 * 200) / 255 celsius, and finally
>>> +     * need convert to millicelsius.
>>> +     */
>>> +    return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
>>> +}
>>> +
>>> +static inline int _temp_to_step(int temp)
>>> +{
>>> +    return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
>>> +}
>>> +
>>> +static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data *data,
>>> +                     struct hisi_thermal_sensor *sensor)
>>> +{
>>> +    unsigned long flags;
>>> +    int val;
>>> +
>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>> +
>>> +    /* disable module firstly */
>>> +    writel(0x0, data->regs + TEMP0_EN);
>>> +
>>> +    /* select sensor id */
>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>> +
>>> +    /* enable module */
>>> +    writel(0x1, data->regs + TEMP0_EN);
>>> +
>>> +    mdelay(5);
>>> +
>>> +    val = readl(data->regs + TEMP0_VALUE);
>>> +    val = _step_to_temp(val);
>>> +
>>> +    /* adjust for negative value */
>>> +    val = (val < 0) ? 0 : val;
>>> +
>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>> +
>>> +    return val;
>>> +}
>>> +
>>> +static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
>>> +{
>>> +    struct hisi_thermal_sensor *sensor;
>>> +    unsigned long flags;
>>> +
>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>> +
>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>> +
>>> +    /* setting the hdak time */
>>> +    writel(0x0, data->regs + TEMP0_CFG);
>>> +
>>> +    /* disable module firstly */
>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>> +    writel(0x0, data->regs + TEMP0_EN);
>>> +
>>> +    /* select sensor id */
>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>> +
>>> +    /* enable for interrupt */
>>> +    writel(_temp_to_step(sensor->thres_temp)
>>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>>> +
>>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>>> +
>>> +    /* enable module */
>>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>>> +    writel(0x1, data->regs + TEMP0_EN);
>>> +
>>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>>> +
>>> +    mdelay(5);
>>> +
>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>> +
>>> +}
>>> +
>>> +static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
>>> +{
>>> +    struct hisi_thermal_sensor *sensor;
>>> +    unsigned long flags;
>>> +
>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>> +
>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>> +
>>> +    /* setting the hdak time */
>>> +    writel(0x0, data->regs + TEMP0_CFG);
>>> +
>>> +    /* disable module firstly */
>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>> +    writel(0x0, data->regs + TEMP0_EN);
>>> +
>>> +    /* select sensor id */
>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>> +
>>> +    /* enable for interrupt */
>>> +    writel(_temp_to_step(sensor->thres_temp)
>>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>>> +
>>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>>> +
>>> +    /* enable module */
>>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>>> +    writel(0x1, data->regs + TEMP0_EN);
>>> +
>>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>>> +
>>> +    mdelay(5);
>>> +
>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>> +

       Why take a 5ms delay in spin_lock_irq context ?

       Could we use mutex or other synchronization api here?

       For TEMP0_INT_EN, TEMP0_RST_MSK, we can use 
disable_irq(THERM_IRQ) instead.

>>> +}
>>> +
>>> +static void hisi_thermal_disable_sensor(struct hisi_thermal_data *data)
>>> +{
>>> +    unsigned long flags;
>>> +
>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>> +
>>> +    /* disable sensor module */
>>> +    writel(0x0, data->regs + );
>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>> +    writel(0x0, data->regs + TEMP0_EN);
>>> +
>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>> +
>>> +}
>>> +
>>> +static int hisi_thermal_get_temp(void *_sensor, long *temp)
>>> +{
>>> +    struct hisi_thermal_sensor *sensor = _sensor;
>>> +    struct hisi_thermal_data *data = sensor->thermal;
>>> +
>>> +    int sensor_id = 0, i;
>>> +    long max_temp = 0;
>>> +
>>> +    *temp = hisi_thermal_get_sensor_temp(data, sensor);
>>> +
>>> +    data->sensor_temp[sensor->id] = *temp;
>>> +
>>> +    for (i = 0; i < HISI_MAX_SENSORS; i++) {
>>> +        if (data->sensor_temp[i] >= max_temp) {
>>> +            max_temp = data->sensor_temp[i];
>>> +            sensor_id = i;
>>> +        }
>>> +    }
>>> +
>>> +    data->irq_bind_sensor = sensor_id;
>>> +
>>> +    dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
>>> +        sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
>>> +
>>> +    /*
>>> +     * Bind irq to sensor for two cases:
>>> +     *   Reenable alarm IRQ if temperature below threshold;
>>> +     *   if irq has been enabled, always set it;
>>> +     */
>>> +    if (!data->irq_enabled && max_temp < sensor->thres_temp) {
>>> +        data->irq_enabled = true;
>>> +        hisi_thermal_bind_irq(data);
>>> +    } else if (data->irq_enabled)
>>> +        hisi_thermal_bind_irq(data);
>>> +
>>> +    return 0;
>>> +}
>>> +
>>> +static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
>>> +    .get_temp = hisi_thermal_get_temp,
>>> +};
>>> +
>>> +static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
>>> +{
>>> +    struct hisi_thermal_data *data = dev;
>>> +    unsigned long flags;
>>> +
>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>> +
>>> +    /* disable interrupt */
>>> +    writel(0x0, data->regs + TEMP0_INT_EN);
>>> +    writel(0x1, data->regs + TEMP0_INT_CLR);
>>> +
>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>> +    data->irq_enabled = false;
>>> +
>>> +    return IRQ_WAKE_THREAD;
>>> +}
>>> +
>>> +static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
>>> +{
>>> +    struct hisi_thermal_data *data = dev;
>>> +    struct hisi_thermal_sensor *sensor;
>>> +    int i;
>>> +
>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>> +
>>> +    dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
>>> +         sensor->thres_temp / 1000);
>>> +
>>> +    for (i = 0; i < data->sensors_num; i++)
>>> +        thermal_zone_device_update(data->sensors[i].tzd);
>>> +
>>> +    return IRQ_HANDLED;
>>> +}
>>> +
>>> +static int hisi_thermal_init_sensor(struct platform_device *pdev,
>>> +                    struct device_node *np,
>>> +                    struct hisi_thermal_data *data,
>>> +                    int index)
>>> +{
>>> +    struct hisi_thermal_sensor *sensor;
>>> +    int ret, i;
>>> +
>>> +    sensor = &data->sensors[index];
>>> +
>>> +    ret = of_property_read_u32(np, "hisilicon,tsensor-id",
>>> +                    &sensor->id);
>>> +    if (ret) {
>>> +        dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
>>> +        return ret;
>>> +    }
>>> +
>>> +    sensor->thermal = data;
>>> +    sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev, sensor->id,
>>> +                sensor, &hisi_of_thermal_ops);
>>> +    if (IS_ERR(sensor->tzd)) {
>>> +        ret = PTR_ERR(sensor->tzd);
>>> +        dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
>>> +            sensor->id, ret);
>>> +        return ret;
>>> +    }
>>> +
>>> +    sensor->trip = of_thermal_get_trip_points(sensor->tzd);
>>> +
>>> +    for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
>>> +        if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
>>> +            sensor->thres_temp = sensor->trip[i].temperature;
>>> +            break;
>>> +        }
>>> +    }
>>> +
>>> +    return 0;
>>> +}
>>> +
>>> +static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
>>> +{
>>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>>> +    struct device_node *np = pdev->dev.of_node;
>>> +    struct device_node *child_np;
>>> +    int ret, i, index;
>>> +
>>> +    /* sensor initialization */
>>> +    index = 0;
>>> +    for_each_child_of_node(np, child_np) {
>>> +
>>> +        if (index >= HISI_MAX_SENSORS) {
>>> +            dev_err(&pdev->dev, "unsupported sensor number\n");
>>> +            ret = -EINVAL;
>>> +            goto err_init_sensors;
>>> +        }
>>> +
>>> +        ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
>>> +        if (ret)
>>> +            goto err_init_sensors;
>>> +
>>> +        index++;
>>> +    }
>>> +
>>> +    data->sensors_num = index;
>>> +    return 0;
>>> +
>>> +err_init_sensors:
>>> +    for (i = 0; i < index; i++)
>>> +        thermal_zone_of_sensor_unregister(&pdev->dev,
>>> +                data->sensors[i].tzd);
>>> +    return ret;
>>> +}
>>> +
>>> +static const struct of_device_id of_hisi_thermal_match[] = {
>>> +    { .compatible = "hisilicon,tsensor" },
>>> +    { /* end */ }
>>> +};
>>> +MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
>>> +
>>> +static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor *sensor,
>>> +                       bool on)
>>> +{
>>> +    struct thermal_zone_device *tzd = sensor->tzd;
>>> +
>>> +    tzd->ops->set_mode(tzd,
>>> +        on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
>>> +}
>>> +
>>> +static int hisi_thermal_probe(struct platform_device *pdev)
>>> +{
>>> +    struct hisi_thermal_data *data;
>>> +    struct resource *res;
>>> +    int i;
>>> +    int ret;
>>> +
>>> +    data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
>>> +    if (!data)
>>> +        return -ENOMEM;
>>> +
>>> +    data->pdev = pdev;
>>> +
>>> +    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
>>> +    data->regs = devm_ioremap_resource(&pdev->dev, res);
>>> +    if (IS_ERR(data->regs)) {
>>> +        dev_err(&pdev->dev, "failed to get io address\n");
>>> +        return PTR_ERR(data->regs);
>>> +    }
>>> +
>>> +    data->irq = platform_get_irq(pdev, 0);
>>> +    if (data->irq < 0)
>>> +        return data->irq;
>>> +
>>> +    ret = devm_request_threaded_irq(&pdev->dev, data->irq,
>>> +            hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
>>> +            0, "hisi_thermal", data);
>>> +    if (ret < 0) {
>>> +        dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
>>> +        return ret;
>>> +    }
>>> +
>>> +    platform_set_drvdata(pdev, data);
>>> +
>>> +    data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
>>> +    if (IS_ERR(data->clk)) {
>>> +        ret = PTR_ERR(data->clk);
>>> +        if (ret != -EPROBE_DEFER)
>>> +            dev_err(&pdev->dev,
>>> +                "failed to get thermal clk: %d\n", ret);
>>> +        return ret;
>>> +    }
>>> +
>>> +    /* enable clock for thermal */
>>> +    ret = clk_prepare_enable(data->clk);
>>> +    if (ret) {
>>> +        dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
>>> +        return ret;
>>> +    }
>>> +
>>> +    ret = hisi_thermal_get_sensor_data(pdev);
>>> +    if (ret) {
>>> +        dev_err(&pdev->dev, "failed to get sensor data\n");
>>> +        goto err_get_sensor_data;
>>> +        return ret;
>>> +    }
>>> +
>>> +    hisi_thermal_enable_sensor(data);
>>> +    data->irq_enabled = true;
>>> +
>>> +    for (i = 0; i < data->sensors_num; i++)
>>> +        hisi_thermal_toggle_sensor(&data->sensors[i], true);
>>> +
>>> +    return 0;
>>> +
>>> +err_get_sensor_data:
>>> +    clk_disable_unprepare(data->clk);
>>> +    return ret;
>>> +}
>>> +
>>> +static int hisi_thermal_remove(struct platform_device *pdev)
>>> +{
>>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>>> +    int i;
>>> +
>>> +    for (i = 0; i < data->sensors_num; i++) {
>>> +        struct hisi_thermal_sensor *sensor = &data->sensors[i];
>>> +
>>> +        hisi_thermal_toggle_sensor(sensor, false);
>>> +        thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
>>> +    }
>>> +
>>> +    hisi_thermal_disable_sensor(data);
>>> +    clk_disable_unprepare(data->clk);
>>> +    return 0;
>>> +}
>>> +
>>> +#ifdef CONFIG_PM_SLEEP
>>> +static int hisi_thermal_suspend(struct device *dev)
>>> +{
>>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>>> +
>>> +    hisi_thermal_disable_sensor(data);
>>> +    data->irq_enabled = false;
>>> +
>>> +    clk_disable_unprepare(data->clk);
>>> +
>>> +    return 0;
>>> +}
>>> +
>>> +static int hisi_thermal_resume(struct device *dev)
>>> +{
>>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>>> +
>>> +    clk_prepare_enable(data->clk);
>>> +
>>> +    data->irq_enabled = true;
>>> +    hisi_thermal_enable_sensor(data);
>>> +
>>> +    return 0;
>>> +}
>>> +#endif
>>> +
>>> +static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
>>> +             hisi_thermal_suspend, hisi_thermal_resume);
>>> +
>>> +static struct platform_driver hisi_thermal_driver = {
>>> +    .driver = {
>>> +        .name    = "hisi_thermal",
>>> +        .owner  = THIS_MODULE,
>>> +        .pm    = &hisi_thermal_pm_ops,
>>> +        .of_match_table = of_hisi_thermal_match,
>>> +    },
>>> +    .probe        = hisi_thermal_probe,
>>> +    .remove        = hisi_thermal_remove,
>>> +};
>>> +
>>> +static int __init hisi_thermal_init(void)
>>> +{
>>> +    return platform_driver_register(&hisi_thermal_driver);
>>> +}
>>> +
>>> +static void __exit hisi_thermal_exit(void)
>>> +{
>>> +    platform_driver_unregister(&hisi_thermal_driver);
>>> +}
>>> +
>>> +late_initcall(hisi_thermal_init);
>>> +module_exit(hisi_thermal_exit);
>>> +
>>> +MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
>>> +MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
>>> +MODULE_DESCRIPTION("Hisilicon thermal driver");
>>> +MODULE_LICENSE("GPL v2");
>>>
>>
>>
>>
>> .
>>
>
>
> .
>

Re: [PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[YiPing Xu]

在 2015/3/27 16:30, Xinwei Kong 写道:
>
>
> On 2015/3/26 17:14, YiPing Xu wrote:
>> 在 2015/3/25 15:50, Xinwei Kong 写道:
>>> From: kongxinwei <kong.kongxinwei@hisilicon.com>
>>>
>>> This patch adds the support for hisilicon thermal sensor, within
>>> hisilicon SoC. there will register sensors for thermal framework
>>> and use device tree to bind cooling device.
>>>
>>> Signed-off-by: Leo Yan <leo.yan@linaro.org>
>>> Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
>>> ---
>>>    drivers/thermal/Kconfig        |   8 +
>>>    drivers/thermal/Makefile       |   1 +
>>>    drivers/thermal/hisi_thermal.c | 526 +++++++++++++++++++++++++++++++++++++++++
>>>    3 files changed, 535 insertions(+)
>>>    create mode 100644 drivers/thermal/hisi_thermal.c
>>>
>>> diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
>>> index af40db0..81aee01 100644
>>> --- a/drivers/thermal/Kconfig
>>> +++ b/drivers/thermal/Kconfig
>>> @@ -136,6 +136,14 @@ config THERMAL_EMULATION
>>>          because userland can easily disable the thermal policy by simply
>>>          flooding this sysfs node with low temperature values.
>>>
>>> +config HISI_THERMAL
>>> +    tristate "Hisilicon thermal driver"
>>> +    depends on ARCH_HISI && CPU_THERMAL && OF
>>> +    help
>>> +      Enable this to plug hisilicon's thermal sensor driver into the Linux
>>> +      thermal framework. cpufreq is used as the cooling device to throttle
>>> +      CPUs when the passive trip is crossed.
>>> +
>>>    config IMX_THERMAL
>>>        tristate "Temperature sensor driver for Freescale i.MX SoCs"
>>>        depends on CPU_THERMAL
>>> diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
>>> index fa0dc48..08ae7ac 100644
>>> --- a/drivers/thermal/Makefile
>>> +++ b/drivers/thermal/Makefile
>>> @@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)    += ti-soc-thermal/
>>>    obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
>>>    obj-$(CONFIG_ST_THERMAL)    += st/
>>>    obj-$(CONFIG_TEGRA_SOCTHERM)    += tegra_soctherm.o
>>> +obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
>>> diff --git a/drivers/thermal/hisi_thermal.c b/drivers/thermal/hisi_thermal.c
>>> new file mode 100644
>>> index 0000000..8edf83a
>>> --- /dev/null
>>> +++ b/drivers/thermal/hisi_thermal.c
>>
>>     are you sure all the SOCs in hisilicon use the same thermal IP ?
>>
>>     if not, this driver should not use the "hisi_" prefix.
>
> We can use this hisi thermal driver framework to satisfy diff thermal
> IP, all of SoC will use this drvier by adding a struct about diff IP.
> We may talk about hisi thermal diff IP how to satisfy this driver.
>
> Thanks
> Xinwei
>
>>
>>> @@ -0,0 +1,526 @@
>>> +/*
>>> + * Hisilicon thermal sensor driver
>>> + *
>>> + * Copyright (c) 2014-2015 Hisilicon Limited.
>>> + * Copyright (c) 2014-2015 Linaro Limited.
>>> + *
>>> + * Xinwei Kong <kong.kongxinwei@hisilicon.com>
>>> + * Leo Yan <leo.yan@linaro.org>
>>> + *
>>> + * This program is free software; you can redistribute it and/or modify
>>> + * it under the terms of the GNU General Public License version 2 as
>>> + * published by the Free Software Foundation.
>>> + *
>>> + * This program is distributed "as is" WITHOUT ANY WARRANTY of any
>>> + * kind, whether express or implied; without even the implied warranty
>>> + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>>> + * GNU General Public License for more details.
>>> + */
>>> +
>>> +#include <linux/cpu_cooling.h>
>>> +#include <linux/cpufreq.h>
>>> +#include <linux/delay.h>
>>> +#include <linux/device.h>
>>> +#include <linux/init.h>
>>> +#include <linux/interrupt.h>
>>> +#include <linux/io.h>
>>> +#include <linux/kernel.h>
>>> +#include <linux/mfd/syscon.h>
>>> +#include <linux/module.h>
>>> +#include <linux/of.h>
>>> +#include <linux/of_device.h>
>>> +#include <linux/platform_device.h>
>>> +#include <linux/regmap.h>
>>> +#include <linux/slab.h>
>>> +#include <linux/thermal.h>
>>> +#include <linux/types.h>
>>> +
>>> +#include "thermal_core.h"
>>> +
>>> +#define TEMP0_LAG            (0x0)
>>> +#define TEMP0_TH            (0x4)
>>> +#define TEMP0_RST_TH            (0x8)
>>> +#define TEMP0_CFG            (0xC)
>>> +#define TEMP0_EN            (0x10)
>>> +#define TEMP0_INT_EN            (0x14)
>>> +#define TEMP0_INT_CLR            (0x18)
>>> +#define TEMP0_RST_MSK            (0x1C)
>>> +#define TEMP0_RAW_INT            (0x20)
>>> +#define TEMP0_MSK_INT            (0x24)
>>> +#define TEMP0_VALUE            (0x28)
>>> +
>>> +#define HISI_TEMP_BASE            (-60)
>>> +#define HISI_TEMP_RESET            (100000)
>>> +#define HISI_TEMP_PASSIVE        (85000)
>>> +
>>> +#define HISI_MAX_SENSORS        4
>>> +
>>> +struct hisi_thermal_sensor {
>>> +    struct hisi_thermal_data *thermal;
>>> +    struct thermal_zone_device *tzd;
>>> +    const struct thermal_trip *trip;
>>> +
>>> +    uint32_t id;
>>> +    uint32_t thres_temp, reset_temp;
>>> +};
>>> +
>>> +struct hisi_thermal_data {
>>> +    struct platform_device *pdev;
>>> +    struct clk *clk;
>>> +
>>> +    int irq, irq_bind_sensor;
>>> +    bool irq_enabled;
>>> +
>>> +    unsigned int sensors_num;
>>> +    long sensor_temp[HISI_MAX_SENSORS];
>>> +    struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
>>> +
>>> +    void __iomem *regs;
>>> +};
>>> +
>>> +static DEFINE_SPINLOCK(thermal_lock);
>>> +
>>
>>     "thermal_lock" should be defined in "hisi_thermal_data" to support multi device instance.
>>
>
> ok,good comments
>
>>> +/* in millicelsius */
>>> +static inline int _step_to_temp(int step)
>>> +{
>>> +    /*
>>> +     * Every step equals (1 * 200) / 255 celsius, and finally
>>> +     * need convert to millicelsius.
>>> +     */
>>> +    return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
>>> +}
>>> +
>>> +static inline int _temp_to_step(int temp)
>>> +{
>>> +    return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
>>> +}
>>> +
>>> +static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data *data,
>>> +                     struct hisi_thermal_sensor *sensor)
>>> +{
>>> +    unsigned long flags;
>>> +    int val;
>>> +
>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>> +
>>> +    /* disable module firstly */
>>> +    writel(0x0, data->regs + TEMP0_EN);
>>> +
>>> +    /* select sensor id */
>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>> +
>>> +    /* enable module */
>>> +    writel(0x1, data->regs + TEMP0_EN);
>>> +
>>> +    mdelay(5);
>>> +
>>> +    val = readl(data->regs + TEMP0_VALUE);
>>> +    val = _step_to_temp(val);
>>> +
>>> +    /* adjust for negative value */
>>> +    val = (val < 0) ? 0 : val;
>>> +
>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>> +
>>> +    return val;
>>> +}
>>> +
>>> +static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
>>> +{
>>> +    struct hisi_thermal_sensor *sensor;
>>> +    unsigned long flags;
>>> +
>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>> +
>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>> +
>>> +    /* setting the hdak time */
>>> +    writel(0x0, data->regs + TEMP0_CFG);
>>> +
>>> +    /* disable module firstly */
>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>> +    writel(0x0, data->regs + TEMP0_EN);
>>> +
>>> +    /* select sensor id */
>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>> +
>>> +    /* enable for interrupt */
>>> +    writel(_temp_to_step(sensor->thres_temp)
>>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>>> +
>>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>>> +
>>> +    /* enable module */
>>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>>> +    writel(0x1, data->regs + TEMP0_EN);
>>> +
>>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>>> +
>>> +    mdelay(5);
>>> +
>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>> +
>>> +}
>>> +
>>> +static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
>>> +{
>>> +    struct hisi_thermal_sensor *sensor;
>>> +    unsigned long flags;
>>> +
>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>> +
>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>> +
>>> +    /* setting the hdak time */
>>> +    writel(0x0, data->regs + TEMP0_CFG);
>>> +
>>> +    /* disable module firstly */
>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>> +    writel(0x0, data->regs + TEMP0_EN);
>>> +
>>> +    /* select sensor id */
>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>> +
>>> +    /* enable for interrupt */
>>> +    writel(_temp_to_step(sensor->thres_temp)
>>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>>> +
>>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>>> +
>>> +    /* enable module */
>>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>>> +    writel(0x1, data->regs + TEMP0_EN);
>>> +
>>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>>> +
>>> +    mdelay(5);
>>> +
>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>> +

       Why take a 5ms delay in spin_lock_irq context ?

       Could we use mutex or other synchronization api here?

       For TEMP0_INT_EN, TEMP0_RST_MSK, we can use 
disable_irq(THERM_IRQ) instead.

>>> +}
>>> +
>>> +static void hisi_thermal_disable_sensor(struct hisi_thermal_data *data)
>>> +{
>>> +    unsigned long flags;
>>> +
>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>> +
>>> +    /* disable sensor module */
>>> +    writel(0x0, data->regs + );
>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>> +    writel(0x0, data->regs + TEMP0_EN);
>>> +
>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>> +
>>> +}
>>> +
>>> +static int hisi_thermal_get_temp(void *_sensor, long *temp)
>>> +{
>>> +    struct hisi_thermal_sensor *sensor = _sensor;
>>> +    struct hisi_thermal_data *data = sensor->thermal;
>>> +
>>> +    int sensor_id = 0, i;
>>> +    long max_temp = 0;
>>> +
>>> +    *temp = hisi_thermal_get_sensor_temp(data, sensor);
>>> +
>>> +    data->sensor_temp[sensor->id] = *temp;
>>> +
>>> +    for (i = 0; i < HISI_MAX_SENSORS; i++) {
>>> +        if (data->sensor_temp[i] >= max_temp) {
>>> +            max_temp = data->sensor_temp[i];
>>> +            sensor_id = i;
>>> +        }
>>> +    }
>>> +
>>> +    data->irq_bind_sensor = sensor_id;
>>> +
>>> +    dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
>>> +        sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
>>> +
>>> +    /*
>>> +     * Bind irq to sensor for two cases:
>>> +     *   Reenable alarm IRQ if temperature below threshold;
>>> +     *   if irq has been enabled, always set it;
>>> +     */
>>> +    if (!data->irq_enabled && max_temp < sensor->thres_temp) {
>>> +        data->irq_enabled = true;
>>> +        hisi_thermal_bind_irq(data);
>>> +    } else if (data->irq_enabled)
>>> +        hisi_thermal_bind_irq(data);
>>> +
>>> +    return 0;
>>> +}
>>> +
>>> +static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
>>> +    .get_temp = hisi_thermal_get_temp,
>>> +};
>>> +
>>> +static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
>>> +{
>>> +    struct hisi_thermal_data *data = dev;
>>> +    unsigned long flags;
>>> +
>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>> +
>>> +    /* disable interrupt */
>>> +    writel(0x0, data->regs + TEMP0_INT_EN);
>>> +    writel(0x1, data->regs + TEMP0_INT_CLR);
>>> +
>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>> +    data->irq_enabled = false;
>>> +
>>> +    return IRQ_WAKE_THREAD;
>>> +}
>>> +
>>> +static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
>>> +{
>>> +    struct hisi_thermal_data *data = dev;
>>> +    struct hisi_thermal_sensor *sensor;
>>> +    int i;
>>> +
>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>> +
>>> +    dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
>>> +         sensor->thres_temp / 1000);
>>> +
>>> +    for (i = 0; i < data->sensors_num; i++)
>>> +        thermal_zone_device_update(data->sensors[i].tzd);
>>> +
>>> +    return IRQ_HANDLED;
>>> +}
>>> +
>>> +static int hisi_thermal_init_sensor(struct platform_device *pdev,
>>> +                    struct device_node *np,
>>> +                    struct hisi_thermal_data *data,
>>> +                    int index)
>>> +{
>>> +    struct hisi_thermal_sensor *sensor;
>>> +    int ret, i;
>>> +
>>> +    sensor = &data->sensors[index];
>>> +
>>> +    ret = of_property_read_u32(np, "hisilicon,tsensor-id",
>>> +                    &sensor->id);
>>> +    if (ret) {
>>> +        dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
>>> +        return ret;
>>> +    }
>>> +
>>> +    sensor->thermal = data;
>>> +    sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev, sensor->id,
>>> +                sensor, &hisi_of_thermal_ops);
>>> +    if (IS_ERR(sensor->tzd)) {
>>> +        ret = PTR_ERR(sensor->tzd);
>>> +        dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
>>> +            sensor->id, ret);
>>> +        return ret;
>>> +    }
>>> +
>>> +    sensor->trip = of_thermal_get_trip_points(sensor->tzd);
>>> +
>>> +    for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
>>> +        if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
>>> +            sensor->thres_temp = sensor->trip[i].temperature;
>>> +            break;
>>> +        }
>>> +    }
>>> +
>>> +    return 0;
>>> +}
>>> +
>>> +static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
>>> +{
>>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>>> +    struct device_node *np = pdev->dev.of_node;
>>> +    struct device_node *child_np;
>>> +    int ret, i, index;
>>> +
>>> +    /* sensor initialization */
>>> +    index = 0;
>>> +    for_each_child_of_node(np, child_np) {
>>> +
>>> +        if (index >= HISI_MAX_SENSORS) {
>>> +            dev_err(&pdev->dev, "unsupported sensor number\n");
>>> +            ret = -EINVAL;
>>> +            goto err_init_sensors;
>>> +        }
>>> +
>>> +        ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
>>> +        if (ret)
>>> +            goto err_init_sensors;
>>> +
>>> +        index++;
>>> +    }
>>> +
>>> +    data->sensors_num = index;
>>> +    return 0;
>>> +
>>> +err_init_sensors:
>>> +    for (i = 0; i < index; i++)
>>> +        thermal_zone_of_sensor_unregister(&pdev->dev,
>>> +                data->sensors[i].tzd);
>>> +    return ret;
>>> +}
>>> +
>>> +static const struct of_device_id of_hisi_thermal_match[] = {
>>> +    { .compatible = "hisilicon,tsensor" },
>>> +    { /* end */ }
>>> +};
>>> +MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
>>> +
>>> +static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor *sensor,
>>> +                       bool on)
>>> +{
>>> +    struct thermal_zone_device *tzd = sensor->tzd;
>>> +
>>> +    tzd->ops->set_mode(tzd,
>>> +        on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
>>> +}
>>> +
>>> +static int hisi_thermal_probe(struct platform_device *pdev)
>>> +{
>>> +    struct hisi_thermal_data *data;
>>> +    struct resource *res;
>>> +    int i;
>>> +    int ret;
>>> +
>>> +    data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
>>> +    if (!data)
>>> +        return -ENOMEM;
>>> +
>>> +    data->pdev = pdev;
>>> +
>>> +    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
>>> +    data->regs = devm_ioremap_resource(&pdev->dev, res);
>>> +    if (IS_ERR(data->regs)) {
>>> +        dev_err(&pdev->dev, "failed to get io address\n");
>>> +        return PTR_ERR(data->regs);
>>> +    }
>>> +
>>> +    data->irq = platform_get_irq(pdev, 0);
>>> +    if (data->irq < 0)
>>> +        return data->irq;
>>> +
>>> +    ret = devm_request_threaded_irq(&pdev->dev, data->irq,
>>> +            hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
>>> +            0, "hisi_thermal", data);
>>> +    if (ret < 0) {
>>> +        dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
>>> +        return ret;
>>> +    }
>>> +
>>> +    platform_set_drvdata(pdev, data);
>>> +
>>> +    data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
>>> +    if (IS_ERR(data->clk)) {
>>> +        ret = PTR_ERR(data->clk);
>>> +        if (ret != -EPROBE_DEFER)
>>> +            dev_err(&pdev->dev,
>>> +                "failed to get thermal clk: %d\n", ret);
>>> +        return ret;
>>> +    }
>>> +
>>> +    /* enable clock for thermal */
>>> +    ret = clk_prepare_enable(data->clk);
>>> +    if (ret) {
>>> +        dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
>>> +        return ret;
>>> +    }
>>> +
>>> +    ret = hisi_thermal_get_sensor_data(pdev);
>>> +    if (ret) {
>>> +        dev_err(&pdev->dev, "failed to get sensor data\n");
>>> +        goto err_get_sensor_data;
>>> +        return ret;
>>> +    }
>>> +
>>> +    hisi_thermal_enable_sensor(data);
>>> +    data->irq_enabled = true;
>>> +
>>> +    for (i = 0; i < data->sensors_num; i++)
>>> +        hisi_thermal_toggle_sensor(&data->sensors[i], true);
>>> +
>>> +    return 0;
>>> +
>>> +err_get_sensor_data:
>>> +    clk_disable_unprepare(data->clk);
>>> +    return ret;
>>> +}
>>> +
>>> +static int hisi_thermal_remove(struct platform_device *pdev)
>>> +{
>>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>>> +    int i;
>>> +
>>> +    for (i = 0; i < data->sensors_num; i++) {
>>> +        struct hisi_thermal_sensor *sensor = &data->sensors[i];
>>> +
>>> +        hisi_thermal_toggle_sensor(sensor, false);
>>> +        thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
>>> +    }
>>> +
>>> +    hisi_thermal_disable_sensor(data);
>>> +    clk_disable_unprepare(data->clk);
>>> +    return 0;
>>> +}
>>> +
>>> +#ifdef CONFIG_PM_SLEEP
>>> +static int hisi_thermal_suspend(struct device *dev)
>>> +{
>>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>>> +
>>> +    hisi_thermal_disable_sensor(data);
>>> +    data->irq_enabled = false;
>>> +
>>> +    clk_disable_unprepare(data->clk);
>>> +
>>> +    return 0;
>>> +}
>>> +
>>> +static int hisi_thermal_resume(struct device *dev)
>>> +{
>>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>>> +
>>> +    clk_prepare_enable(data->clk);
>>> +
>>> +    data->irq_enabled = true;
>>> +    hisi_thermal_enable_sensor(data);
>>> +
>>> +    return 0;
>>> +}
>>> +#endif
>>> +
>>> +static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
>>> +             hisi_thermal_suspend, hisi_thermal_resume);
>>> +
>>> +static struct platform_driver hisi_thermal_driver = {
>>> +    .driver = {
>>> +        .name    = "hisi_thermal",
>>> +        .owner  = THIS_MODULE,
>>> +        .pm    = &hisi_thermal_pm_ops,
>>> +        .of_match_table = of_hisi_thermal_match,
>>> +    },
>>> +    .probe        = hisi_thermal_probe,
>>> +    .remove        = hisi_thermal_remove,
>>> +};
>>> +
>>> +static int __init hisi_thermal_init(void)
>>> +{
>>> +    return platform_driver_register(&hisi_thermal_driver);
>>> +}
>>> +
>>> +static void __exit hisi_thermal_exit(void)
>>> +{
>>> +    platform_driver_unregister(&hisi_thermal_driver);
>>> +}
>>> +
>>> +late_initcall(hisi_thermal_init);
>>> +module_exit(hisi_thermal_exit);
>>> +
>>> +MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
>>> +MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
>>> +MODULE_DESCRIPTION("Hisilicon thermal driver");
>>> +MODULE_LICENSE("GPL v2");
>>>
>>
>>
>>
>> .
>>
>
>
> .
>

Re: [PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[Xinwei Kong]

On 2015年03月28日 08:58, YiPing Xu wrote:
> 在 2015/3/27 16:30, Xinwei Kong 写道:
>>
>>
>> On 2015/3/26 17:14, YiPing Xu wrote:
>>> 在 2015/3/25 15:50, Xinwei Kong 写道:
>>>> From: kongxinwei <kong.kongxinwei@hisilicon.com>
>>>>
>>>> This patch adds the support for hisilicon thermal sensor, within
>>>> hisilicon SoC. there will register sensors for thermal framework
>>>> and use device tree to bind cooling device.
>>>>
>>>> Signed-off-by: Leo Yan <leo.yan@linaro.org>
>>>> Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
>>>> ---
>>>>    drivers/thermal/Kconfig        |   8 +
>>>>    drivers/thermal/Makefile       |   1 +
>>>>    drivers/thermal/hisi_thermal.c | 526
>>>> +++++++++++++++++++++++++++++++++++++++++
>>>>    3 files changed, 535 insertions(+)
>>>>    create mode 100644 drivers/thermal/hisi_thermal.c
>>>>
>>>> diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
>>>> index af40db0..81aee01 100644
>>>> --- a/drivers/thermal/Kconfig
>>>> +++ b/drivers/thermal/Kconfig
>>>> @@ -136,6 +136,14 @@ config THERMAL_EMULATION
>>>>          because userland can easily disable the thermal policy by
>>>> simply
>>>>          flooding this sysfs node with low temperature values.
>>>>
>>>> +config HISI_THERMAL
>>>> +    tristate "Hisilicon thermal driver"
>>>> +    depends on ARCH_HISI && CPU_THERMAL && OF
>>>> +    help
>>>> +      Enable this to plug hisilicon's thermal sensor driver into
>>>> the Linux
>>>> +      thermal framework. cpufreq is used as the cooling device to
>>>> throttle
>>>> +      CPUs when the passive trip is crossed.
>>>> +
>>>>    config IMX_THERMAL
>>>>        tristate "Temperature sensor driver for Freescale i.MX SoCs"
>>>>        depends on CPU_THERMAL
>>>> diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
>>>> index fa0dc48..08ae7ac 100644
>>>> --- a/drivers/thermal/Makefile
>>>> +++ b/drivers/thermal/Makefile
>>>> @@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)    += ti-soc-thermal/
>>>>    obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
>>>>    obj-$(CONFIG_ST_THERMAL)    += st/
>>>>    obj-$(CONFIG_TEGRA_SOCTHERM)    += tegra_soctherm.o
>>>> +obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
>>>> diff --git a/drivers/thermal/hisi_thermal.c
>>>> b/drivers/thermal/hisi_thermal.c
>>>> new file mode 100644
>>>> index 0000000..8edf83a
>>>> --- /dev/null
>>>> +++ b/drivers/thermal/hisi_thermal.c
>>>
>>>     are you sure all the SOCs in hisilicon use the same thermal IP ?
>>>
>>>     if not, this driver should not use the "hisi_" prefix.
>>
>> We can use this hisi thermal driver framework to satisfy diff thermal
>> IP, all of SoC will use this drvier by adding a struct about diff IP.
>> We may talk about hisi thermal diff IP how to satisfy this driver.
>>
>> Thanks
>> Xinwei
>>
>>>
>>>> @@ -0,0 +1,526 @@
>>>> +/*
>>>> + * Hisilicon thermal sensor driver
>>>> + *
>>>> + * Copyright (c) 2014-2015 Hisilicon Limited.
>>>> + * Copyright (c) 2014-2015 Linaro Limited.
>>>> + *
>>>> + * Xinwei Kong <kong.kongxinwei@hisilicon.com>
>>>> + * Leo Yan <leo.yan@linaro.org>
>>>> + *
>>>> + * This program is free software; you can redistribute it and/or
>>>> modify
>>>> + * it under the terms of the GNU General Public License version 2 as
>>>> + * published by the Free Software Foundation.
>>>> + *
>>>> + * This program is distributed "as is" WITHOUT ANY WARRANTY of any
>>>> + * kind, whether express or implied; without even the implied warranty
>>>> + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>>>> + * GNU General Public License for more details.
>>>> + */
>>>> +
>>>> +#include <linux/cpu_cooling.h>
>>>> +#include <linux/cpufreq.h>
>>>> +#include <linux/delay.h>
>>>> +#include <linux/device.h>
>>>> +#include <linux/init.h>
>>>> +#include <linux/interrupt.h>
>>>> +#include <linux/io.h>
>>>> +#include <linux/kernel.h>
>>>> +#include <linux/mfd/syscon.h>
>>>> +#include <linux/module.h>
>>>> +#include <linux/of.h>
>>>> +#include <linux/of_device.h>
>>>> +#include <linux/platform_device.h>
>>>> +#include <linux/regmap.h>
>>>> +#include <linux/slab.h>
>>>> +#include <linux/thermal.h>
>>>> +#include <linux/types.h>
>>>> +
>>>> +#include "thermal_core.h"
>>>> +
>>>> +#define TEMP0_LAG            (0x0)
>>>> +#define TEMP0_TH            (0x4)
>>>> +#define TEMP0_RST_TH            (0x8)
>>>> +#define TEMP0_CFG            (0xC)
>>>> +#define TEMP0_EN            (0x10)
>>>> +#define TEMP0_INT_EN            (0x14)
>>>> +#define TEMP0_INT_CLR            (0x18)
>>>> +#define TEMP0_RST_MSK            (0x1C)
>>>> +#define TEMP0_RAW_INT            (0x20)
>>>> +#define TEMP0_MSK_INT            (0x24)
>>>> +#define TEMP0_VALUE            (0x28)
>>>> +
>>>> +#define HISI_TEMP_BASE            (-60)
>>>> +#define HISI_TEMP_RESET            (100000)
>>>> +#define HISI_TEMP_PASSIVE        (85000)
>>>> +
>>>> +#define HISI_MAX_SENSORS        4
>>>> +
>>>> +struct hisi_thermal_sensor {
>>>> +    struct hisi_thermal_data *thermal;
>>>> +    struct thermal_zone_device *tzd;
>>>> +    const struct thermal_trip *trip;
>>>> +
>>>> +    uint32_t id;
>>>> +    uint32_t thres_temp, reset_temp;
>>>> +};
>>>> +
>>>> +struct hisi_thermal_data {
>>>> +    struct platform_device *pdev;
>>>> +    struct clk *clk;
>>>> +
>>>> +    int irq, irq_bind_sensor;
>>>> +    bool irq_enabled;
>>>> +
>>>> +    unsigned int sensors_num;
>>>> +    long sensor_temp[HISI_MAX_SENSORS];
>>>> +    struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
>>>> +
>>>> +    void __iomem *regs;
>>>> +};
>>>> +
>>>> +static DEFINE_SPINLOCK(thermal_lock);
>>>> +
>>>
>>>     "thermal_lock" should be defined in "hisi_thermal_data" to
>>> support multi device instance.
>>>
>>
>> ok,good comments
>>
>>>> +/* in millicelsius */
>>>> +static inline int _step_to_temp(int step)
>>>> +{
>>>> +    /*
>>>> +     * Every step equals (1 * 200) / 255 celsius, and finally
>>>> +     * need convert to millicelsius.
>>>> +     */
>>>> +    return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
>>>> +}
>>>> +
>>>> +static inline int _temp_to_step(int temp)
>>>> +{
>>>> +    return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
>>>> +}
>>>> +
>>>> +static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data
>>>> *data,
>>>> +                     struct hisi_thermal_sensor *sensor)
>>>> +{
>>>> +    unsigned long flags;
>>>> +    int val;
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* disable module firstly */
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    /* select sensor id */
>>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* enable module */
>>>> +    writel(0x1, data->regs + TEMP0_EN);
>>>> +
>>>> +    mdelay(5);
>>>> +
>>>> +    val = readl(data->regs + TEMP0_VALUE);
>>>> +    val = _step_to_temp(val);
>>>> +
>>>> +    /* adjust for negative value */
>>>> +    val = (val < 0) ? 0 : val;
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>>>> +    return val;
>>>> +}
>>>> +
>>>> +static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    unsigned long flags;
>>>> +
>>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* setting the hdak time */
>>>> +    writel(0x0, data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* disable module firstly */
>>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    /* select sensor id */
>>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* enable for interrupt */
>>>> +    writel(_temp_to_step(sensor->thres_temp)
>>>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>>>> +
>>>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>>>> +
>>>> +    /* enable module */
>>>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x1, data->regs + TEMP0_EN);
>>>> +
>>>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>>>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>>>> +
>>>> +    mdelay(5);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>>>> +}
>>>> +
>>>> +static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    unsigned long flags;
>>>> +
>>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* setting the hdak time */
>>>> +    writel(0x0, data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* disable module firstly */
>>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    /* select sensor id */
>>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* enable for interrupt */
>>>> +    writel(_temp_to_step(sensor->thres_temp)
>>>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>>>> +
>>>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>>>> +
>>>> +    /* enable module */
>>>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x1, data->regs + TEMP0_EN);
>>>> +
>>>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>>>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>>>> +
>>>> +    mdelay(5);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>
>        Why take a 5ms delay in spin_lock_irq context ?
>
>        Could we use mutex or other synchronization api here?
>
>        For TEMP0_INT_EN, TEMP0_RST_MSK, we can use
> disable_irq(THERM_IRQ) instead.
>

If i delete 5ms this driver, don't get this temperature and this 
temperature is 0 degree. I will consult hardware designer for hisilicon SOC.

Mutex lock and disable_irq ....I will try to redesign all register 
function operation, let this register code concise. Thanks for your 
comments.

Thanks
Xinwei
>>>> +}
>>>> +
>>>> +static void hisi_thermal_disable_sensor(struct hisi_thermal_data
>>>> *data)
>>>> +{
>>>> +    unsigned long flags;
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* disable sensor module */
>>>> +    writel(0x0, data->regs + );
>>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>>>> +}
>>>> +
>>>> +static int hisi_thermal_get_temp(void *_sensor, long *temp)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor = _sensor;
>>>> +    struct hisi_thermal_data *data = sensor->thermal;
>>>> +
>>>> +    int sensor_id = 0, i;
>>>> +    long max_temp = 0;
>>>> +
>>>> +    *temp = hisi_thermal_get_sensor_temp(data, sensor);
>>>> +
>>>> +    data->sensor_temp[sensor->id] = *temp;
>>>> +
>>>> +    for (i = 0; i < HISI_MAX_SENSORS; i++) {
>>>> +        if (data->sensor_temp[i] >= max_temp) {
>>>> +            max_temp = data->sensor_temp[i];
>>>> +            sensor_id = i;
>>>> +        }
>>>> +    }
>>>> +
>>>> +    data->irq_bind_sensor = sensor_id;
>>>> +
>>>> +    dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
>>>> +        sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
>>>> +
>>>> +    /*
>>>> +     * Bind irq to sensor for two cases:
>>>> +     *   Reenable alarm IRQ if temperature below threshold;
>>>> +     *   if irq has been enabled, always set it;
>>>> +     */
>>>> +    if (!data->irq_enabled && max_temp < sensor->thres_temp) {
>>>> +        data->irq_enabled = true;
>>>> +        hisi_thermal_bind_irq(data);
>>>> +    } else if (data->irq_enabled)
>>>> +        hisi_thermal_bind_irq(data);
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
>>>> +    .get_temp = hisi_thermal_get_temp,
>>>> +};
>>>> +
>>>> +static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev;
>>>> +    unsigned long flags;
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* disable interrupt */
>>>> +    writel(0x0, data->regs + TEMP0_INT_EN);
>>>> +    writel(0x1, data->regs + TEMP0_INT_CLR);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +    data->irq_enabled = false;
>>>> +
>>>> +    return IRQ_WAKE_THREAD;
>>>> +}
>>>> +
>>>> +static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev;
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    int i;
>>>> +
>>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>>> +
>>>> +    dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
>>>> +         sensor->thres_temp / 1000);
>>>> +
>>>> +    for (i = 0; i < data->sensors_num; i++)
>>>> +        thermal_zone_device_update(data->sensors[i].tzd);
>>>> +
>>>> +    return IRQ_HANDLED;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_init_sensor(struct platform_device *pdev,
>>>> +                    struct device_node *np,
>>>> +                    struct hisi_thermal_data *data,
>>>> +                    int index)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    int ret, i;
>>>> +
>>>> +    sensor = &data->sensors[index];
>>>> +
>>>> +    ret = of_property_read_u32(np, "hisilicon,tsensor-id",
>>>> +                    &sensor->id);
>>>> +    if (ret) {
>>>> +        dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    sensor->thermal = data;
>>>> +    sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev,
>>>> sensor->id,
>>>> +                sensor, &hisi_of_thermal_ops);
>>>> +    if (IS_ERR(sensor->tzd)) {
>>>> +        ret = PTR_ERR(sensor->tzd);
>>>> +        dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
>>>> +            sensor->id, ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    sensor->trip = of_thermal_get_trip_points(sensor->tzd);
>>>> +
>>>> +    for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
>>>> +        if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
>>>> +            sensor->thres_temp = sensor->trip[i].temperature;
>>>> +            break;
>>>> +        }
>>>> +    }
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>>>> +    struct device_node *np = pdev->dev.of_node;
>>>> +    struct device_node *child_np;
>>>> +    int ret, i, index;
>>>> +
>>>> +    /* sensor initialization */
>>>> +    index = 0;
>>>> +    for_each_child_of_node(np, child_np) {
>>>> +
>>>> +        if (index >= HISI_MAX_SENSORS) {
>>>> +            dev_err(&pdev->dev, "unsupported sensor number\n");
>>>> +            ret = -EINVAL;
>>>> +            goto err_init_sensors;
>>>> +        }
>>>> +
>>>> +        ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
>>>> +        if (ret)
>>>> +            goto err_init_sensors;
>>>> +
>>>> +        index++;
>>>> +    }
>>>> +
>>>> +    data->sensors_num = index;
>>>> +    return 0;
>>>> +
>>>> +err_init_sensors:
>>>> +    for (i = 0; i < index; i++)
>>>> +        thermal_zone_of_sensor_unregister(&pdev->dev,
>>>> +                data->sensors[i].tzd);
>>>> +    return ret;
>>>> +}
>>>> +
>>>> +static const struct of_device_id of_hisi_thermal_match[] = {
>>>> +    { .compatible = "hisilicon,tsensor" },
>>>> +    { /* end */ }
>>>> +};
>>>> +MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
>>>> +
>>>> +static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor
>>>> *sensor,
>>>> +                       bool on)
>>>> +{
>>>> +    struct thermal_zone_device *tzd = sensor->tzd;
>>>> +
>>>> +    tzd->ops->set_mode(tzd,
>>>> +        on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
>>>> +}
>>>> +
>>>> +static int hisi_thermal_probe(struct platform_device *pdev)
>>>> +{
>>>> +    struct hisi_thermal_data *data;
>>>> +    struct resource *res;
>>>> +    int i;
>>>> +    int ret;
>>>> +
>>>> +    data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
>>>> +    if (!data)
>>>> +        return -ENOMEM;
>>>> +
>>>> +    data->pdev = pdev;
>>>> +
>>>> +    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
>>>> +    data->regs = devm_ioremap_resource(&pdev->dev, res);
>>>> +    if (IS_ERR(data->regs)) {
>>>> +        dev_err(&pdev->dev, "failed to get io address\n");
>>>> +        return PTR_ERR(data->regs);
>>>> +    }
>>>> +
>>>> +    data->irq = platform_get_irq(pdev, 0);
>>>> +    if (data->irq < 0)
>>>> +        return data->irq;
>>>> +
>>>> +    ret = devm_request_threaded_irq(&pdev->dev, data->irq,
>>>> +            hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
>>>> +            0, "hisi_thermal", data);
>>>> +    if (ret < 0) {
>>>> +        dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    platform_set_drvdata(pdev, data);
>>>> +
>>>> +    data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
>>>> +    if (IS_ERR(data->clk)) {
>>>> +        ret = PTR_ERR(data->clk);
>>>> +        if (ret != -EPROBE_DEFER)
>>>> +            dev_err(&pdev->dev,
>>>> +                "failed to get thermal clk: %d\n", ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    /* enable clock for thermal */
>>>> +    ret = clk_prepare_enable(data->clk);
>>>> +    if (ret) {
>>>> +        dev_err(&pdev->dev, "failed to enable thermal clk: %d\n",
>>>> ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    ret = hisi_thermal_get_sensor_data(pdev);
>>>> +    if (ret) {
>>>> +        dev_err(&pdev->dev, "failed to get sensor data\n");
>>>> +        goto err_get_sensor_data;
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    hisi_thermal_enable_sensor(data);
>>>> +    data->irq_enabled = true;
>>>> +
>>>> +    for (i = 0; i < data->sensors_num; i++)
>>>> +        hisi_thermal_toggle_sensor(&data->sensors[i], true);
>>>> +
>>>> +    return 0;
>>>> +
>>>> +err_get_sensor_data:
>>>> +    clk_disable_unprepare(data->clk);
>>>> +    return ret;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_remove(struct platform_device *pdev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>>>> +    int i;
>>>> +
>>>> +    for (i = 0; i < data->sensors_num; i++) {
>>>> +        struct hisi_thermal_sensor *sensor = &data->sensors[i];
>>>> +
>>>> +        hisi_thermal_toggle_sensor(sensor, false);
>>>> +        thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
>>>> +    }
>>>> +
>>>> +    hisi_thermal_disable_sensor(data);
>>>> +    clk_disable_unprepare(data->clk);
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +#ifdef CONFIG_PM_SLEEP
>>>> +static int hisi_thermal_suspend(struct device *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>>>> +
>>>> +    hisi_thermal_disable_sensor(data);
>>>> +    data->irq_enabled = false;
>>>> +
>>>> +    clk_disable_unprepare(data->clk);
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_resume(struct device *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>>>> +
>>>> +    clk_prepare_enable(data->clk);
>>>> +
>>>> +    data->irq_enabled = true;
>>>> +    hisi_thermal_enable_sensor(data);
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +#endif
>>>> +
>>>> +static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
>>>> +             hisi_thermal_suspend, hisi_thermal_resume);
>>>> +
>>>> +static struct platform_driver hisi_thermal_driver = {
>>>> +    .driver = {
>>>> +        .name    = "hisi_thermal",
>>>> +        .owner  = THIS_MODULE,
>>>> +        .pm    = &hisi_thermal_pm_ops,
>>>> +        .of_match_table = of_hisi_thermal_match,
>>>> +    },
>>>> +    .probe        = hisi_thermal_probe,
>>>> +    .remove        = hisi_thermal_remove,
>>>> +};
>>>> +
>>>> +static int __init hisi_thermal_init(void)
>>>> +{
>>>> +    return platform_driver_register(&hisi_thermal_driver);
>>>> +}
>>>> +
>>>> +static void __exit hisi_thermal_exit(void)
>>>> +{
>>>> +    platform_driver_unregister(&hisi_thermal_driver);
>>>> +}
>>>> +
>>>> +late_initcall(hisi_thermal_init);
>>>> +module_exit(hisi_thermal_exit);
>>>> +
>>>> +MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
>>>> +MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
>>>> +MODULE_DESCRIPTION("Hisilicon thermal driver");
>>>> +MODULE_LICENSE("GPL v2");
>>>>
>>>
>>>
>>>
>>> .
>>>
>>
>>
>> .
>>
>
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-pm" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[Xinwei Kong]

On 2015?03?28? 08:58, YiPing Xu wrote:
> ? 2015/3/27 16:30, Xinwei Kong ??:
>>
>>
>> On 2015/3/26 17:14, YiPing Xu wrote:
>>> ? 2015/3/25 15:50, Xinwei Kong ??:
>>>> From: kongxinwei <kong.kongxinwei@hisilicon.com>
>>>>
>>>> This patch adds the support for hisilicon thermal sensor, within
>>>> hisilicon SoC. there will register sensors for thermal framework
>>>> and use device tree to bind cooling device.
>>>>
>>>> Signed-off-by: Leo Yan <leo.yan@linaro.org>
>>>> Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
>>>> ---
>>>>    drivers/thermal/Kconfig        |   8 +
>>>>    drivers/thermal/Makefile       |   1 +
>>>>    drivers/thermal/hisi_thermal.c | 526
>>>> +++++++++++++++++++++++++++++++++++++++++
>>>>    3 files changed, 535 insertions(+)
>>>>    create mode 100644 drivers/thermal/hisi_thermal.c
>>>>
>>>> diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
>>>> index af40db0..81aee01 100644
>>>> --- a/drivers/thermal/Kconfig
>>>> +++ b/drivers/thermal/Kconfig
>>>> @@ -136,6 +136,14 @@ config THERMAL_EMULATION
>>>>          because userland can easily disable the thermal policy by
>>>> simply
>>>>          flooding this sysfs node with low temperature values.
>>>>
>>>> +config HISI_THERMAL
>>>> +    tristate "Hisilicon thermal driver"
>>>> +    depends on ARCH_HISI && CPU_THERMAL && OF
>>>> +    help
>>>> +      Enable this to plug hisilicon's thermal sensor driver into
>>>> the Linux
>>>> +      thermal framework. cpufreq is used as the cooling device to
>>>> throttle
>>>> +      CPUs when the passive trip is crossed.
>>>> +
>>>>    config IMX_THERMAL
>>>>        tristate "Temperature sensor driver for Freescale i.MX SoCs"
>>>>        depends on CPU_THERMAL
>>>> diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
>>>> index fa0dc48..08ae7ac 100644
>>>> --- a/drivers/thermal/Makefile
>>>> +++ b/drivers/thermal/Makefile
>>>> @@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)    += ti-soc-thermal/
>>>>    obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
>>>>    obj-$(CONFIG_ST_THERMAL)    += st/
>>>>    obj-$(CONFIG_TEGRA_SOCTHERM)    += tegra_soctherm.o
>>>> +obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
>>>> diff --git a/drivers/thermal/hisi_thermal.c
>>>> b/drivers/thermal/hisi_thermal.c
>>>> new file mode 100644
>>>> index 0000000..8edf83a
>>>> --- /dev/null
>>>> +++ b/drivers/thermal/hisi_thermal.c
>>>
>>>     are you sure all the SOCs in hisilicon use the same thermal IP ?
>>>
>>>     if not, this driver should not use the "hisi_" prefix.
>>
>> We can use this hisi thermal driver framework to satisfy diff thermal
>> IP, all of SoC will use this drvier by adding a struct about diff IP.
>> We may talk about hisi thermal diff IP how to satisfy this driver.
>>
>> Thanks
>> Xinwei
>>
>>>
>>>> @@ -0,0 +1,526 @@
>>>> +/*
>>>> + * Hisilicon thermal sensor driver
>>>> + *
>>>> + * Copyright (c) 2014-2015 Hisilicon Limited.
>>>> + * Copyright (c) 2014-2015 Linaro Limited.
>>>> + *
>>>> + * Xinwei Kong <kong.kongxinwei@hisilicon.com>
>>>> + * Leo Yan <leo.yan@linaro.org>
>>>> + *
>>>> + * This program is free software; you can redistribute it and/or
>>>> modify
>>>> + * it under the terms of the GNU General Public License version 2 as
>>>> + * published by the Free Software Foundation.
>>>> + *
>>>> + * This program is distributed "as is" WITHOUT ANY WARRANTY of any
>>>> + * kind, whether express or implied; without even the implied warranty
>>>> + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>>>> + * GNU General Public License for more details.
>>>> + */
>>>> +
>>>> +#include <linux/cpu_cooling.h>
>>>> +#include <linux/cpufreq.h>
>>>> +#include <linux/delay.h>
>>>> +#include <linux/device.h>
>>>> +#include <linux/init.h>
>>>> +#include <linux/interrupt.h>
>>>> +#include <linux/io.h>
>>>> +#include <linux/kernel.h>
>>>> +#include <linux/mfd/syscon.h>
>>>> +#include <linux/module.h>
>>>> +#include <linux/of.h>
>>>> +#include <linux/of_device.h>
>>>> +#include <linux/platform_device.h>
>>>> +#include <linux/regmap.h>
>>>> +#include <linux/slab.h>
>>>> +#include <linux/thermal.h>
>>>> +#include <linux/types.h>
>>>> +
>>>> +#include "thermal_core.h"
>>>> +
>>>> +#define TEMP0_LAG            (0x0)
>>>> +#define TEMP0_TH            (0x4)
>>>> +#define TEMP0_RST_TH            (0x8)
>>>> +#define TEMP0_CFG            (0xC)
>>>> +#define TEMP0_EN            (0x10)
>>>> +#define TEMP0_INT_EN            (0x14)
>>>> +#define TEMP0_INT_CLR            (0x18)
>>>> +#define TEMP0_RST_MSK            (0x1C)
>>>> +#define TEMP0_RAW_INT            (0x20)
>>>> +#define TEMP0_MSK_INT            (0x24)
>>>> +#define TEMP0_VALUE            (0x28)
>>>> +
>>>> +#define HISI_TEMP_BASE            (-60)
>>>> +#define HISI_TEMP_RESET            (100000)
>>>> +#define HISI_TEMP_PASSIVE        (85000)
>>>> +
>>>> +#define HISI_MAX_SENSORS        4
>>>> +
>>>> +struct hisi_thermal_sensor {
>>>> +    struct hisi_thermal_data *thermal;
>>>> +    struct thermal_zone_device *tzd;
>>>> +    const struct thermal_trip *trip;
>>>> +
>>>> +    uint32_t id;
>>>> +    uint32_t thres_temp, reset_temp;
>>>> +};
>>>> +
>>>> +struct hisi_thermal_data {
>>>> +    struct platform_device *pdev;
>>>> +    struct clk *clk;
>>>> +
>>>> +    int irq, irq_bind_sensor;
>>>> +    bool irq_enabled;
>>>> +
>>>> +    unsigned int sensors_num;
>>>> +    long sensor_temp[HISI_MAX_SENSORS];
>>>> +    struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
>>>> +
>>>> +    void __iomem *regs;
>>>> +};
>>>> +
>>>> +static DEFINE_SPINLOCK(thermal_lock);
>>>> +
>>>
>>>     "thermal_lock" should be defined in "hisi_thermal_data" to
>>> support multi device instance.
>>>
>>
>> ok,good comments
>>
>>>> +/* in millicelsius */
>>>> +static inline int _step_to_temp(int step)
>>>> +{
>>>> +    /*
>>>> +     * Every step equals (1 * 200) / 255 celsius, and finally
>>>> +     * need convert to millicelsius.
>>>> +     */
>>>> +    return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
>>>> +}
>>>> +
>>>> +static inline int _temp_to_step(int temp)
>>>> +{
>>>> +    return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
>>>> +}
>>>> +
>>>> +static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data
>>>> *data,
>>>> +                     struct hisi_thermal_sensor *sensor)
>>>> +{
>>>> +    unsigned long flags;
>>>> +    int val;
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* disable module firstly */
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    /* select sensor id */
>>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* enable module */
>>>> +    writel(0x1, data->regs + TEMP0_EN);
>>>> +
>>>> +    mdelay(5);
>>>> +
>>>> +    val = readl(data->regs + TEMP0_VALUE);
>>>> +    val = _step_to_temp(val);
>>>> +
>>>> +    /* adjust for negative value */
>>>> +    val = (val < 0) ? 0 : val;
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>>>> +    return val;
>>>> +}
>>>> +
>>>> +static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    unsigned long flags;
>>>> +
>>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* setting the hdak time */
>>>> +    writel(0x0, data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* disable module firstly */
>>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    /* select sensor id */
>>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* enable for interrupt */
>>>> +    writel(_temp_to_step(sensor->thres_temp)
>>>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>>>> +
>>>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>>>> +
>>>> +    /* enable module */
>>>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x1, data->regs + TEMP0_EN);
>>>> +
>>>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>>>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>>>> +
>>>> +    mdelay(5);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>>>> +}
>>>> +
>>>> +static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    unsigned long flags;
>>>> +
>>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* setting the hdak time */
>>>> +    writel(0x0, data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* disable module firstly */
>>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    /* select sensor id */
>>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* enable for interrupt */
>>>> +    writel(_temp_to_step(sensor->thres_temp)
>>>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>>>> +
>>>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>>>> +
>>>> +    /* enable module */
>>>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x1, data->regs + TEMP0_EN);
>>>> +
>>>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>>>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>>>> +
>>>> +    mdelay(5);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>
>        Why take a 5ms delay in spin_lock_irq context ?
>
>        Could we use mutex or other synchronization api here?
>
>        For TEMP0_INT_EN, TEMP0_RST_MSK, we can use
> disable_irq(THERM_IRQ) instead.
>

If i delete 5ms this driver, don't get this temperature and this 
temperature is 0 degree. I will consult hardware designer for hisilicon SOC.

Mutex lock and disable_irq ....I will try to redesign all register 
function operation, let this register code concise. Thanks for your 
comments.

Thanks
Xinwei
>>>> +}
>>>> +
>>>> +static void hisi_thermal_disable_sensor(struct hisi_thermal_data
>>>> *data)
>>>> +{
>>>> +    unsigned long flags;
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* disable sensor module */
>>>> +    writel(0x0, data->regs + );
>>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>>>> +}
>>>> +
>>>> +static int hisi_thermal_get_temp(void *_sensor, long *temp)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor = _sensor;
>>>> +    struct hisi_thermal_data *data = sensor->thermal;
>>>> +
>>>> +    int sensor_id = 0, i;
>>>> +    long max_temp = 0;
>>>> +
>>>> +    *temp = hisi_thermal_get_sensor_temp(data, sensor);
>>>> +
>>>> +    data->sensor_temp[sensor->id] = *temp;
>>>> +
>>>> +    for (i = 0; i < HISI_MAX_SENSORS; i++) {
>>>> +        if (data->sensor_temp[i] >= max_temp) {
>>>> +            max_temp = data->sensor_temp[i];
>>>> +            sensor_id = i;
>>>> +        }
>>>> +    }
>>>> +
>>>> +    data->irq_bind_sensor = sensor_id;
>>>> +
>>>> +    dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
>>>> +        sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
>>>> +
>>>> +    /*
>>>> +     * Bind irq to sensor for two cases:
>>>> +     *   Reenable alarm IRQ if temperature below threshold;
>>>> +     *   if irq has been enabled, always set it;
>>>> +     */
>>>> +    if (!data->irq_enabled && max_temp < sensor->thres_temp) {
>>>> +        data->irq_enabled = true;
>>>> +        hisi_thermal_bind_irq(data);
>>>> +    } else if (data->irq_enabled)
>>>> +        hisi_thermal_bind_irq(data);
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
>>>> +    .get_temp = hisi_thermal_get_temp,
>>>> +};
>>>> +
>>>> +static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev;
>>>> +    unsigned long flags;
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* disable interrupt */
>>>> +    writel(0x0, data->regs + TEMP0_INT_EN);
>>>> +    writel(0x1, data->regs + TEMP0_INT_CLR);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +    data->irq_enabled = false;
>>>> +
>>>> +    return IRQ_WAKE_THREAD;
>>>> +}
>>>> +
>>>> +static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev;
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    int i;
>>>> +
>>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>>> +
>>>> +    dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
>>>> +         sensor->thres_temp / 1000);
>>>> +
>>>> +    for (i = 0; i < data->sensors_num; i++)
>>>> +        thermal_zone_device_update(data->sensors[i].tzd);
>>>> +
>>>> +    return IRQ_HANDLED;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_init_sensor(struct platform_device *pdev,
>>>> +                    struct device_node *np,
>>>> +                    struct hisi_thermal_data *data,
>>>> +                    int index)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    int ret, i;
>>>> +
>>>> +    sensor = &data->sensors[index];
>>>> +
>>>> +    ret = of_property_read_u32(np, "hisilicon,tsensor-id",
>>>> +                    &sensor->id);
>>>> +    if (ret) {
>>>> +        dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    sensor->thermal = data;
>>>> +    sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev,
>>>> sensor->id,
>>>> +                sensor, &hisi_of_thermal_ops);
>>>> +    if (IS_ERR(sensor->tzd)) {
>>>> +        ret = PTR_ERR(sensor->tzd);
>>>> +        dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
>>>> +            sensor->id, ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    sensor->trip = of_thermal_get_trip_points(sensor->tzd);
>>>> +
>>>> +    for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
>>>> +        if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
>>>> +            sensor->thres_temp = sensor->trip[i].temperature;
>>>> +            break;
>>>> +        }
>>>> +    }
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>>>> +    struct device_node *np = pdev->dev.of_node;
>>>> +    struct device_node *child_np;
>>>> +    int ret, i, index;
>>>> +
>>>> +    /* sensor initialization */
>>>> +    index = 0;
>>>> +    for_each_child_of_node(np, child_np) {
>>>> +
>>>> +        if (index >= HISI_MAX_SENSORS) {
>>>> +            dev_err(&pdev->dev, "unsupported sensor number\n");
>>>> +            ret = -EINVAL;
>>>> +            goto err_init_sensors;
>>>> +        }
>>>> +
>>>> +        ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
>>>> +        if (ret)
>>>> +            goto err_init_sensors;
>>>> +
>>>> +        index++;
>>>> +    }
>>>> +
>>>> +    data->sensors_num = index;
>>>> +    return 0;
>>>> +
>>>> +err_init_sensors:
>>>> +    for (i = 0; i < index; i++)
>>>> +        thermal_zone_of_sensor_unregister(&pdev->dev,
>>>> +                data->sensors[i].tzd);
>>>> +    return ret;
>>>> +}
>>>> +
>>>> +static const struct of_device_id of_hisi_thermal_match[] = {
>>>> +    { .compatible = "hisilicon,tsensor" },
>>>> +    { /* end */ }
>>>> +};
>>>> +MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
>>>> +
>>>> +static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor
>>>> *sensor,
>>>> +                       bool on)
>>>> +{
>>>> +    struct thermal_zone_device *tzd = sensor->tzd;
>>>> +
>>>> +    tzd->ops->set_mode(tzd,
>>>> +        on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
>>>> +}
>>>> +
>>>> +static int hisi_thermal_probe(struct platform_device *pdev)
>>>> +{
>>>> +    struct hisi_thermal_data *data;
>>>> +    struct resource *res;
>>>> +    int i;
>>>> +    int ret;
>>>> +
>>>> +    data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
>>>> +    if (!data)
>>>> +        return -ENOMEM;
>>>> +
>>>> +    data->pdev = pdev;
>>>> +
>>>> +    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
>>>> +    data->regs = devm_ioremap_resource(&pdev->dev, res);
>>>> +    if (IS_ERR(data->regs)) {
>>>> +        dev_err(&pdev->dev, "failed to get io address\n");
>>>> +        return PTR_ERR(data->regs);
>>>> +    }
>>>> +
>>>> +    data->irq = platform_get_irq(pdev, 0);
>>>> +    if (data->irq < 0)
>>>> +        return data->irq;
>>>> +
>>>> +    ret = devm_request_threaded_irq(&pdev->dev, data->irq,
>>>> +            hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
>>>> +            0, "hisi_thermal", data);
>>>> +    if (ret < 0) {
>>>> +        dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    platform_set_drvdata(pdev, data);
>>>> +
>>>> +    data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
>>>> +    if (IS_ERR(data->clk)) {
>>>> +        ret = PTR_ERR(data->clk);
>>>> +        if (ret != -EPROBE_DEFER)
>>>> +            dev_err(&pdev->dev,
>>>> +                "failed to get thermal clk: %d\n", ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    /* enable clock for thermal */
>>>> +    ret = clk_prepare_enable(data->clk);
>>>> +    if (ret) {
>>>> +        dev_err(&pdev->dev, "failed to enable thermal clk: %d\n",
>>>> ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    ret = hisi_thermal_get_sensor_data(pdev);
>>>> +    if (ret) {
>>>> +        dev_err(&pdev->dev, "failed to get sensor data\n");
>>>> +        goto err_get_sensor_data;
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    hisi_thermal_enable_sensor(data);
>>>> +    data->irq_enabled = true;
>>>> +
>>>> +    for (i = 0; i < data->sensors_num; i++)
>>>> +        hisi_thermal_toggle_sensor(&data->sensors[i], true);
>>>> +
>>>> +    return 0;
>>>> +
>>>> +err_get_sensor_data:
>>>> +    clk_disable_unprepare(data->clk);
>>>> +    return ret;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_remove(struct platform_device *pdev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>>>> +    int i;
>>>> +
>>>> +    for (i = 0; i < data->sensors_num; i++) {
>>>> +        struct hisi_thermal_sensor *sensor = &data->sensors[i];
>>>> +
>>>> +        hisi_thermal_toggle_sensor(sensor, false);
>>>> +        thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
>>>> +    }
>>>> +
>>>> +    hisi_thermal_disable_sensor(data);
>>>> +    clk_disable_unprepare(data->clk);
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +#ifdef CONFIG_PM_SLEEP
>>>> +static int hisi_thermal_suspend(struct device *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>>>> +
>>>> +    hisi_thermal_disable_sensor(data);
>>>> +    data->irq_enabled = false;
>>>> +
>>>> +    clk_disable_unprepare(data->clk);
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_resume(struct device *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>>>> +
>>>> +    clk_prepare_enable(data->clk);
>>>> +
>>>> +    data->irq_enabled = true;
>>>> +    hisi_thermal_enable_sensor(data);
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +#endif
>>>> +
>>>> +static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
>>>> +             hisi_thermal_suspend, hisi_thermal_resume);
>>>> +
>>>> +static struct platform_driver hisi_thermal_driver = {
>>>> +    .driver = {
>>>> +        .name    = "hisi_thermal",
>>>> +        .owner  = THIS_MODULE,
>>>> +        .pm    = &hisi_thermal_pm_ops,
>>>> +        .of_match_table = of_hisi_thermal_match,
>>>> +    },
>>>> +    .probe        = hisi_thermal_probe,
>>>> +    .remove        = hisi_thermal_remove,
>>>> +};
>>>> +
>>>> +static int __init hisi_thermal_init(void)
>>>> +{
>>>> +    return platform_driver_register(&hisi_thermal_driver);
>>>> +}
>>>> +
>>>> +static void __exit hisi_thermal_exit(void)
>>>> +{
>>>> +    platform_driver_unregister(&hisi_thermal_driver);
>>>> +}
>>>> +
>>>> +late_initcall(hisi_thermal_init);
>>>> +module_exit(hisi_thermal_exit);
>>>> +
>>>> +MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
>>>> +MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
>>>> +MODULE_DESCRIPTION("Hisilicon thermal driver");
>>>> +MODULE_LICENSE("GPL v2");
>>>>
>>>
>>>
>>>
>>> .
>>>
>>
>>
>> .
>>
>
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-pm" in
> the body of a message to majordomo at vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[Xinwei Kong]

On 2015年03月28日 08:58, YiPing Xu wrote:
> 在 2015/3/27 16:30, Xinwei Kong 写道:
>>
>>
>> On 2015/3/26 17:14, YiPing Xu wrote:
>>> 在 2015/3/25 15:50, Xinwei Kong 写道:
>>>> From: kongxinwei <kong.kongxinwei@hisilicon.com>
>>>>
>>>> This patch adds the support for hisilicon thermal sensor, within
>>>> hisilicon SoC. there will register sensors for thermal framework
>>>> and use device tree to bind cooling device.
>>>>
>>>> Signed-off-by: Leo Yan <leo.yan@linaro.org>
>>>> Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
>>>> ---
>>>>    drivers/thermal/Kconfig        |   8 +
>>>>    drivers/thermal/Makefile       |   1 +
>>>>    drivers/thermal/hisi_thermal.c | 526
>>>> +++++++++++++++++++++++++++++++++++++++++
>>>>    3 files changed, 535 insertions(+)
>>>>    create mode 100644 drivers/thermal/hisi_thermal.c
>>>>
>>>> diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
>>>> index af40db0..81aee01 100644
>>>> --- a/drivers/thermal/Kconfig
>>>> +++ b/drivers/thermal/Kconfig
>>>> @@ -136,6 +136,14 @@ config THERMAL_EMULATION
>>>>          because userland can easily disable the thermal policy by
>>>> simply
>>>>          flooding this sysfs node with low temperature values.
>>>>
>>>> +config HISI_THERMAL
>>>> +    tristate "Hisilicon thermal driver"
>>>> +    depends on ARCH_HISI && CPU_THERMAL && OF
>>>> +    help
>>>> +      Enable this to plug hisilicon's thermal sensor driver into
>>>> the Linux
>>>> +      thermal framework. cpufreq is used as the cooling device to
>>>> throttle
>>>> +      CPUs when the passive trip is crossed.
>>>> +
>>>>    config IMX_THERMAL
>>>>        tristate "Temperature sensor driver for Freescale i.MX SoCs"
>>>>        depends on CPU_THERMAL
>>>> diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
>>>> index fa0dc48..08ae7ac 100644
>>>> --- a/drivers/thermal/Makefile
>>>> +++ b/drivers/thermal/Makefile
>>>> @@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)    += ti-soc-thermal/
>>>>    obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
>>>>    obj-$(CONFIG_ST_THERMAL)    += st/
>>>>    obj-$(CONFIG_TEGRA_SOCTHERM)    += tegra_soctherm.o
>>>> +obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
>>>> diff --git a/drivers/thermal/hisi_thermal.c
>>>> b/drivers/thermal/hisi_thermal.c
>>>> new file mode 100644
>>>> index 0000000..8edf83a
>>>> --- /dev/null
>>>> +++ b/drivers/thermal/hisi_thermal.c
>>>
>>>     are you sure all the SOCs in hisilicon use the same thermal IP ?
>>>
>>>     if not, this driver should not use the "hisi_" prefix.
>>
>> We can use this hisi thermal driver framework to satisfy diff thermal
>> IP, all of SoC will use this drvier by adding a struct about diff IP.
>> We may talk about hisi thermal diff IP how to satisfy this driver.
>>
>> Thanks
>> Xinwei
>>
>>>
>>>> @@ -0,0 +1,526 @@
>>>> +/*
>>>> + * Hisilicon thermal sensor driver
>>>> + *
>>>> + * Copyright (c) 2014-2015 Hisilicon Limited.
>>>> + * Copyright (c) 2014-2015 Linaro Limited.
>>>> + *
>>>> + * Xinwei Kong <kong.kongxinwei@hisilicon.com>
>>>> + * Leo Yan <leo.yan@linaro.org>
>>>> + *
>>>> + * This program is free software; you can redistribute it and/or
>>>> modify
>>>> + * it under the terms of the GNU General Public License version 2 as
>>>> + * published by the Free Software Foundation.
>>>> + *
>>>> + * This program is distributed "as is" WITHOUT ANY WARRANTY of any
>>>> + * kind, whether express or implied; without even the implied warranty
>>>> + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>>>> + * GNU General Public License for more details.
>>>> + */
>>>> +
>>>> +#include <linux/cpu_cooling.h>
>>>> +#include <linux/cpufreq.h>
>>>> +#include <linux/delay.h>
>>>> +#include <linux/device.h>
>>>> +#include <linux/init.h>
>>>> +#include <linux/interrupt.h>
>>>> +#include <linux/io.h>
>>>> +#include <linux/kernel.h>
>>>> +#include <linux/mfd/syscon.h>
>>>> +#include <linux/module.h>
>>>> +#include <linux/of.h>
>>>> +#include <linux/of_device.h>
>>>> +#include <linux/platform_device.h>
>>>> +#include <linux/regmap.h>
>>>> +#include <linux/slab.h>
>>>> +#include <linux/thermal.h>
>>>> +#include <linux/types.h>
>>>> +
>>>> +#include "thermal_core.h"
>>>> +
>>>> +#define TEMP0_LAG            (0x0)
>>>> +#define TEMP0_TH            (0x4)
>>>> +#define TEMP0_RST_TH            (0x8)
>>>> +#define TEMP0_CFG            (0xC)
>>>> +#define TEMP0_EN            (0x10)
>>>> +#define TEMP0_INT_EN            (0x14)
>>>> +#define TEMP0_INT_CLR            (0x18)
>>>> +#define TEMP0_RST_MSK            (0x1C)
>>>> +#define TEMP0_RAW_INT            (0x20)
>>>> +#define TEMP0_MSK_INT            (0x24)
>>>> +#define TEMP0_VALUE            (0x28)
>>>> +
>>>> +#define HISI_TEMP_BASE            (-60)
>>>> +#define HISI_TEMP_RESET            (100000)
>>>> +#define HISI_TEMP_PASSIVE        (85000)
>>>> +
>>>> +#define HISI_MAX_SENSORS        4
>>>> +
>>>> +struct hisi_thermal_sensor {
>>>> +    struct hisi_thermal_data *thermal;
>>>> +    struct thermal_zone_device *tzd;
>>>> +    const struct thermal_trip *trip;
>>>> +
>>>> +    uint32_t id;
>>>> +    uint32_t thres_temp, reset_temp;
>>>> +};
>>>> +
>>>> +struct hisi_thermal_data {
>>>> +    struct platform_device *pdev;
>>>> +    struct clk *clk;
>>>> +
>>>> +    int irq, irq_bind_sensor;
>>>> +    bool irq_enabled;
>>>> +
>>>> +    unsigned int sensors_num;
>>>> +    long sensor_temp[HISI_MAX_SENSORS];
>>>> +    struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
>>>> +
>>>> +    void __iomem *regs;
>>>> +};
>>>> +
>>>> +static DEFINE_SPINLOCK(thermal_lock);
>>>> +
>>>
>>>     "thermal_lock" should be defined in "hisi_thermal_data" to
>>> support multi device instance.
>>>
>>
>> ok,good comments
>>
>>>> +/* in millicelsius */
>>>> +static inline int _step_to_temp(int step)
>>>> +{
>>>> +    /*
>>>> +     * Every step equals (1 * 200) / 255 celsius, and finally
>>>> +     * need convert to millicelsius.
>>>> +     */
>>>> +    return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
>>>> +}
>>>> +
>>>> +static inline int _temp_to_step(int temp)
>>>> +{
>>>> +    return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
>>>> +}
>>>> +
>>>> +static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data
>>>> *data,
>>>> +                     struct hisi_thermal_sensor *sensor)
>>>> +{
>>>> +    unsigned long flags;
>>>> +    int val;
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* disable module firstly */
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    /* select sensor id */
>>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* enable module */
>>>> +    writel(0x1, data->regs + TEMP0_EN);
>>>> +
>>>> +    mdelay(5);
>>>> +
>>>> +    val = readl(data->regs + TEMP0_VALUE);
>>>> +    val = _step_to_temp(val);
>>>> +
>>>> +    /* adjust for negative value */
>>>> +    val = (val < 0) ? 0 : val;
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>>>> +    return val;
>>>> +}
>>>> +
>>>> +static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    unsigned long flags;
>>>> +
>>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* setting the hdak time */
>>>> +    writel(0x0, data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* disable module firstly */
>>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    /* select sensor id */
>>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* enable for interrupt */
>>>> +    writel(_temp_to_step(sensor->thres_temp)
>>>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>>>> +
>>>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>>>> +
>>>> +    /* enable module */
>>>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x1, data->regs + TEMP0_EN);
>>>> +
>>>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>>>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>>>> +
>>>> +    mdelay(5);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>>>> +}
>>>> +
>>>> +static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    unsigned long flags;
>>>> +
>>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* setting the hdak time */
>>>> +    writel(0x0, data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* disable module firstly */
>>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    /* select sensor id */
>>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* enable for interrupt */
>>>> +    writel(_temp_to_step(sensor->thres_temp)
>>>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>>>> +
>>>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>>>> +
>>>> +    /* enable module */
>>>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x1, data->regs + TEMP0_EN);
>>>> +
>>>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>>>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>>>> +
>>>> +    mdelay(5);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>
>        Why take a 5ms delay in spin_lock_irq context ?
>
>        Could we use mutex or other synchronization api here?
>
>        For TEMP0_INT_EN, TEMP0_RST_MSK, we can use
> disable_irq(THERM_IRQ) instead.
>

If i delete 5ms this driver, don't get this temperature and this 
temperature is 0 degree. I will consult hardware designer for hisilicon SOC.

Mutex lock and disable_irq ....I will try to redesign all register 
function operation, let this register code concise. Thanks for your 
comments.

Thanks
Xinwei
>>>> +}
>>>> +
>>>> +static void hisi_thermal_disable_sensor(struct hisi_thermal_data
>>>> *data)
>>>> +{
>>>> +    unsigned long flags;
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* disable sensor module */
>>>> +    writel(0x0, data->regs + );
>>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>>>> +}
>>>> +
>>>> +static int hisi_thermal_get_temp(void *_sensor, long *temp)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor = _sensor;
>>>> +    struct hisi_thermal_data *data = sensor->thermal;
>>>> +
>>>> +    int sensor_id = 0, i;
>>>> +    long max_temp = 0;
>>>> +
>>>> +    *temp = hisi_thermal_get_sensor_temp(data, sensor);
>>>> +
>>>> +    data->sensor_temp[sensor->id] = *temp;
>>>> +
>>>> +    for (i = 0; i < HISI_MAX_SENSORS; i++) {
>>>> +        if (data->sensor_temp[i] >= max_temp) {
>>>> +            max_temp = data->sensor_temp[i];
>>>> +            sensor_id = i;
>>>> +        }
>>>> +    }
>>>> +
>>>> +    data->irq_bind_sensor = sensor_id;
>>>> +
>>>> +    dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
>>>> +        sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
>>>> +
>>>> +    /*
>>>> +     * Bind irq to sensor for two cases:
>>>> +     *   Reenable alarm IRQ if temperature below threshold;
>>>> +     *   if irq has been enabled, always set it;
>>>> +     */
>>>> +    if (!data->irq_enabled && max_temp < sensor->thres_temp) {
>>>> +        data->irq_enabled = true;
>>>> +        hisi_thermal_bind_irq(data);
>>>> +    } else if (data->irq_enabled)
>>>> +        hisi_thermal_bind_irq(data);
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
>>>> +    .get_temp = hisi_thermal_get_temp,
>>>> +};
>>>> +
>>>> +static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev;
>>>> +    unsigned long flags;
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* disable interrupt */
>>>> +    writel(0x0, data->regs + TEMP0_INT_EN);
>>>> +    writel(0x1, data->regs + TEMP0_INT_CLR);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +    data->irq_enabled = false;
>>>> +
>>>> +    return IRQ_WAKE_THREAD;
>>>> +}
>>>> +
>>>> +static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev;
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    int i;
>>>> +
>>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>>> +
>>>> +    dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
>>>> +         sensor->thres_temp / 1000);
>>>> +
>>>> +    for (i = 0; i < data->sensors_num; i++)
>>>> +        thermal_zone_device_update(data->sensors[i].tzd);
>>>> +
>>>> +    return IRQ_HANDLED;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_init_sensor(struct platform_device *pdev,
>>>> +                    struct device_node *np,
>>>> +                    struct hisi_thermal_data *data,
>>>> +                    int index)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    int ret, i;
>>>> +
>>>> +    sensor = &data->sensors[index];
>>>> +
>>>> +    ret = of_property_read_u32(np, "hisilicon,tsensor-id",
>>>> +                    &sensor->id);
>>>> +    if (ret) {
>>>> +        dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    sensor->thermal = data;
>>>> +    sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev,
>>>> sensor->id,
>>>> +                sensor, &hisi_of_thermal_ops);
>>>> +    if (IS_ERR(sensor->tzd)) {
>>>> +        ret = PTR_ERR(sensor->tzd);
>>>> +        dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
>>>> +            sensor->id, ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    sensor->trip = of_thermal_get_trip_points(sensor->tzd);
>>>> +
>>>> +    for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
>>>> +        if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
>>>> +            sensor->thres_temp = sensor->trip[i].temperature;
>>>> +            break;
>>>> +        }
>>>> +    }
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>>>> +    struct device_node *np = pdev->dev.of_node;
>>>> +    struct device_node *child_np;
>>>> +    int ret, i, index;
>>>> +
>>>> +    /* sensor initialization */
>>>> +    index = 0;
>>>> +    for_each_child_of_node(np, child_np) {
>>>> +
>>>> +        if (index >= HISI_MAX_SENSORS) {
>>>> +            dev_err(&pdev->dev, "unsupported sensor number\n");
>>>> +            ret = -EINVAL;
>>>> +            goto err_init_sensors;
>>>> +        }
>>>> +
>>>> +        ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
>>>> +        if (ret)
>>>> +            goto err_init_sensors;
>>>> +
>>>> +        index++;
>>>> +    }
>>>> +
>>>> +    data->sensors_num = index;
>>>> +    return 0;
>>>> +
>>>> +err_init_sensors:
>>>> +    for (i = 0; i < index; i++)
>>>> +        thermal_zone_of_sensor_unregister(&pdev->dev,
>>>> +                data->sensors[i].tzd);
>>>> +    return ret;
>>>> +}
>>>> +
>>>> +static const struct of_device_id of_hisi_thermal_match[] = {
>>>> +    { .compatible = "hisilicon,tsensor" },
>>>> +    { /* end */ }
>>>> +};
>>>> +MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
>>>> +
>>>> +static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor
>>>> *sensor,
>>>> +                       bool on)
>>>> +{
>>>> +    struct thermal_zone_device *tzd = sensor->tzd;
>>>> +
>>>> +    tzd->ops->set_mode(tzd,
>>>> +        on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
>>>> +}
>>>> +
>>>> +static int hisi_thermal_probe(struct platform_device *pdev)
>>>> +{
>>>> +    struct hisi_thermal_data *data;
>>>> +    struct resource *res;
>>>> +    int i;
>>>> +    int ret;
>>>> +
>>>> +    data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
>>>> +    if (!data)
>>>> +        return -ENOMEM;
>>>> +
>>>> +    data->pdev = pdev;
>>>> +
>>>> +    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
>>>> +    data->regs = devm_ioremap_resource(&pdev->dev, res);
>>>> +    if (IS_ERR(data->regs)) {
>>>> +        dev_err(&pdev->dev, "failed to get io address\n");
>>>> +        return PTR_ERR(data->regs);
>>>> +    }
>>>> +
>>>> +    data->irq = platform_get_irq(pdev, 0);
>>>> +    if (data->irq < 0)
>>>> +        return data->irq;
>>>> +
>>>> +    ret = devm_request_threaded_irq(&pdev->dev, data->irq,
>>>> +            hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
>>>> +            0, "hisi_thermal", data);
>>>> +    if (ret < 0) {
>>>> +        dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    platform_set_drvdata(pdev, data);
>>>> +
>>>> +    data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
>>>> +    if (IS_ERR(data->clk)) {
>>>> +        ret = PTR_ERR(data->clk);
>>>> +        if (ret != -EPROBE_DEFER)
>>>> +            dev_err(&pdev->dev,
>>>> +                "failed to get thermal clk: %d\n", ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    /* enable clock for thermal */
>>>> +    ret = clk_prepare_enable(data->clk);
>>>> +    if (ret) {
>>>> +        dev_err(&pdev->dev, "failed to enable thermal clk: %d\n",
>>>> ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    ret = hisi_thermal_get_sensor_data(pdev);
>>>> +    if (ret) {
>>>> +        dev_err(&pdev->dev, "failed to get sensor data\n");
>>>> +        goto err_get_sensor_data;
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    hisi_thermal_enable_sensor(data);
>>>> +    data->irq_enabled = true;
>>>> +
>>>> +    for (i = 0; i < data->sensors_num; i++)
>>>> +        hisi_thermal_toggle_sensor(&data->sensors[i], true);
>>>> +
>>>> +    return 0;
>>>> +
>>>> +err_get_sensor_data:
>>>> +    clk_disable_unprepare(data->clk);
>>>> +    return ret;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_remove(struct platform_device *pdev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>>>> +    int i;
>>>> +
>>>> +    for (i = 0; i < data->sensors_num; i++) {
>>>> +        struct hisi_thermal_sensor *sensor = &data->sensors[i];
>>>> +
>>>> +        hisi_thermal_toggle_sensor(sensor, false);
>>>> +        thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
>>>> +    }
>>>> +
>>>> +    hisi_thermal_disable_sensor(data);
>>>> +    clk_disable_unprepare(data->clk);
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +#ifdef CONFIG_PM_SLEEP
>>>> +static int hisi_thermal_suspend(struct device *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>>>> +
>>>> +    hisi_thermal_disable_sensor(data);
>>>> +    data->irq_enabled = false;
>>>> +
>>>> +    clk_disable_unprepare(data->clk);
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_resume(struct device *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>>>> +
>>>> +    clk_prepare_enable(data->clk);
>>>> +
>>>> +    data->irq_enabled = true;
>>>> +    hisi_thermal_enable_sensor(data);
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +#endif
>>>> +
>>>> +static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
>>>> +             hisi_thermal_suspend, hisi_thermal_resume);
>>>> +
>>>> +static struct platform_driver hisi_thermal_driver = {
>>>> +    .driver = {
>>>> +        .name    = "hisi_thermal",
>>>> +        .owner  = THIS_MODULE,
>>>> +        .pm    = &hisi_thermal_pm_ops,
>>>> +        .of_match_table = of_hisi_thermal_match,
>>>> +    },
>>>> +    .probe        = hisi_thermal_probe,
>>>> +    .remove        = hisi_thermal_remove,
>>>> +};
>>>> +
>>>> +static int __init hisi_thermal_init(void)
>>>> +{
>>>> +    return platform_driver_register(&hisi_thermal_driver);
>>>> +}
>>>> +
>>>> +static void __exit hisi_thermal_exit(void)
>>>> +{
>>>> +    platform_driver_unregister(&hisi_thermal_driver);
>>>> +}
>>>> +
>>>> +late_initcall(hisi_thermal_init);
>>>> +module_exit(hisi_thermal_exit);
>>>> +
>>>> +MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
>>>> +MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
>>>> +MODULE_DESCRIPTION("Hisilicon thermal driver");
>>>> +MODULE_LICENSE("GPL v2");
>>>>
>>>
>>>
>>>
>>> .
>>>
>>
>>
>> .
>>
>
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-pm" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH v1 1/2] thermal: hisilicon: add new hisilicon thermal sensor driver

[Xinwei Kong]

On 2015?03?28? 08:58, YiPing Xu wrote:
> ? 2015/3/27 16:30, Xinwei Kong ??:
>>
>>
>> On 2015/3/26 17:14, YiPing Xu wrote:
>>> ? 2015/3/25 15:50, Xinwei Kong ??:
>>>> From: kongxinwei <kong.kongxinwei@hisilicon.com>
>>>>
>>>> This patch adds the support for hisilicon thermal sensor, within
>>>> hisilicon SoC. there will register sensors for thermal framework
>>>> and use device tree to bind cooling device.
>>>>
>>>> Signed-off-by: Leo Yan <leo.yan@linaro.org>
>>>> Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
>>>> ---
>>>>    drivers/thermal/Kconfig        |   8 +
>>>>    drivers/thermal/Makefile       |   1 +
>>>>    drivers/thermal/hisi_thermal.c | 526
>>>> +++++++++++++++++++++++++++++++++++++++++
>>>>    3 files changed, 535 insertions(+)
>>>>    create mode 100644 drivers/thermal/hisi_thermal.c
>>>>
>>>> diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
>>>> index af40db0..81aee01 100644
>>>> --- a/drivers/thermal/Kconfig
>>>> +++ b/drivers/thermal/Kconfig
>>>> @@ -136,6 +136,14 @@ config THERMAL_EMULATION
>>>>          because userland can easily disable the thermal policy by
>>>> simply
>>>>          flooding this sysfs node with low temperature values.
>>>>
>>>> +config HISI_THERMAL
>>>> +    tristate "Hisilicon thermal driver"
>>>> +    depends on ARCH_HISI && CPU_THERMAL && OF
>>>> +    help
>>>> +      Enable this to plug hisilicon's thermal sensor driver into
>>>> the Linux
>>>> +      thermal framework. cpufreq is used as the cooling device to
>>>> throttle
>>>> +      CPUs when the passive trip is crossed.
>>>> +
>>>>    config IMX_THERMAL
>>>>        tristate "Temperature sensor driver for Freescale i.MX SoCs"
>>>>        depends on CPU_THERMAL
>>>> diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
>>>> index fa0dc48..08ae7ac 100644
>>>> --- a/drivers/thermal/Makefile
>>>> +++ b/drivers/thermal/Makefile
>>>> @@ -39,3 +39,4 @@ obj-$(CONFIG_TI_SOC_THERMAL)    += ti-soc-thermal/
>>>>    obj-$(CONFIG_INT340X_THERMAL)  += int340x_thermal/
>>>>    obj-$(CONFIG_ST_THERMAL)    += st/
>>>>    obj-$(CONFIG_TEGRA_SOCTHERM)    += tegra_soctherm.o
>>>> +obj-$(CONFIG_HISI_THERMAL)     += hisi_thermal.o
>>>> diff --git a/drivers/thermal/hisi_thermal.c
>>>> b/drivers/thermal/hisi_thermal.c
>>>> new file mode 100644
>>>> index 0000000..8edf83a
>>>> --- /dev/null
>>>> +++ b/drivers/thermal/hisi_thermal.c
>>>
>>>     are you sure all the SOCs in hisilicon use the same thermal IP ?
>>>
>>>     if not, this driver should not use the "hisi_" prefix.
>>
>> We can use this hisi thermal driver framework to satisfy diff thermal
>> IP, all of SoC will use this drvier by adding a struct about diff IP.
>> We may talk about hisi thermal diff IP how to satisfy this driver.
>>
>> Thanks
>> Xinwei
>>
>>>
>>>> @@ -0,0 +1,526 @@
>>>> +/*
>>>> + * Hisilicon thermal sensor driver
>>>> + *
>>>> + * Copyright (c) 2014-2015 Hisilicon Limited.
>>>> + * Copyright (c) 2014-2015 Linaro Limited.
>>>> + *
>>>> + * Xinwei Kong <kong.kongxinwei@hisilicon.com>
>>>> + * Leo Yan <leo.yan@linaro.org>
>>>> + *
>>>> + * This program is free software; you can redistribute it and/or
>>>> modify
>>>> + * it under the terms of the GNU General Public License version 2 as
>>>> + * published by the Free Software Foundation.
>>>> + *
>>>> + * This program is distributed "as is" WITHOUT ANY WARRANTY of any
>>>> + * kind, whether express or implied; without even the implied warranty
>>>> + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>>>> + * GNU General Public License for more details.
>>>> + */
>>>> +
>>>> +#include <linux/cpu_cooling.h>
>>>> +#include <linux/cpufreq.h>
>>>> +#include <linux/delay.h>
>>>> +#include <linux/device.h>
>>>> +#include <linux/init.h>
>>>> +#include <linux/interrupt.h>
>>>> +#include <linux/io.h>
>>>> +#include <linux/kernel.h>
>>>> +#include <linux/mfd/syscon.h>
>>>> +#include <linux/module.h>
>>>> +#include <linux/of.h>
>>>> +#include <linux/of_device.h>
>>>> +#include <linux/platform_device.h>
>>>> +#include <linux/regmap.h>
>>>> +#include <linux/slab.h>
>>>> +#include <linux/thermal.h>
>>>> +#include <linux/types.h>
>>>> +
>>>> +#include "thermal_core.h"
>>>> +
>>>> +#define TEMP0_LAG            (0x0)
>>>> +#define TEMP0_TH            (0x4)
>>>> +#define TEMP0_RST_TH            (0x8)
>>>> +#define TEMP0_CFG            (0xC)
>>>> +#define TEMP0_EN            (0x10)
>>>> +#define TEMP0_INT_EN            (0x14)
>>>> +#define TEMP0_INT_CLR            (0x18)
>>>> +#define TEMP0_RST_MSK            (0x1C)
>>>> +#define TEMP0_RAW_INT            (0x20)
>>>> +#define TEMP0_MSK_INT            (0x24)
>>>> +#define TEMP0_VALUE            (0x28)
>>>> +
>>>> +#define HISI_TEMP_BASE            (-60)
>>>> +#define HISI_TEMP_RESET            (100000)
>>>> +#define HISI_TEMP_PASSIVE        (85000)
>>>> +
>>>> +#define HISI_MAX_SENSORS        4
>>>> +
>>>> +struct hisi_thermal_sensor {
>>>> +    struct hisi_thermal_data *thermal;
>>>> +    struct thermal_zone_device *tzd;
>>>> +    const struct thermal_trip *trip;
>>>> +
>>>> +    uint32_t id;
>>>> +    uint32_t thres_temp, reset_temp;
>>>> +};
>>>> +
>>>> +struct hisi_thermal_data {
>>>> +    struct platform_device *pdev;
>>>> +    struct clk *clk;
>>>> +
>>>> +    int irq, irq_bind_sensor;
>>>> +    bool irq_enabled;
>>>> +
>>>> +    unsigned int sensors_num;
>>>> +    long sensor_temp[HISI_MAX_SENSORS];
>>>> +    struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS];
>>>> +
>>>> +    void __iomem *regs;
>>>> +};
>>>> +
>>>> +static DEFINE_SPINLOCK(thermal_lock);
>>>> +
>>>
>>>     "thermal_lock" should be defined in "hisi_thermal_data" to
>>> support multi device instance.
>>>
>>
>> ok,good comments
>>
>>>> +/* in millicelsius */
>>>> +static inline int _step_to_temp(int step)
>>>> +{
>>>> +    /*
>>>> +     * Every step equals (1 * 200) / 255 celsius, and finally
>>>> +     * need convert to millicelsius.
>>>> +     */
>>>> +    return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
>>>> +}
>>>> +
>>>> +static inline int _temp_to_step(int temp)
>>>> +{
>>>> +    return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
>>>> +}
>>>> +
>>>> +static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data
>>>> *data,
>>>> +                     struct hisi_thermal_sensor *sensor)
>>>> +{
>>>> +    unsigned long flags;
>>>> +    int val;
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* disable module firstly */
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    /* select sensor id */
>>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* enable module */
>>>> +    writel(0x1, data->regs + TEMP0_EN);
>>>> +
>>>> +    mdelay(5);
>>>> +
>>>> +    val = readl(data->regs + TEMP0_VALUE);
>>>> +    val = _step_to_temp(val);
>>>> +
>>>> +    /* adjust for negative value */
>>>> +    val = (val < 0) ? 0 : val;
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>>>> +    return val;
>>>> +}
>>>> +
>>>> +static void hisi_thermal_bind_irq(struct hisi_thermal_data *data)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    unsigned long flags;
>>>> +
>>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* setting the hdak time */
>>>> +    writel(0x0, data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* disable module firstly */
>>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    /* select sensor id */
>>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* enable for interrupt */
>>>> +    writel(_temp_to_step(sensor->thres_temp)
>>>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>>>> +
>>>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>>>> +
>>>> +    /* enable module */
>>>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x1, data->regs + TEMP0_EN);
>>>> +
>>>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>>>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>>>> +
>>>> +    mdelay(5);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>>>> +}
>>>> +
>>>> +static void hisi_thermal_enable_sensor(struct hisi_thermal_data *data)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    unsigned long flags;
>>>> +
>>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* setting the hdak time */
>>>> +    writel(0x0, data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* disable module firstly */
>>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    /* select sensor id */
>>>> +    writel((sensor->id << 12), data->regs + TEMP0_CFG);
>>>> +
>>>> +    /* enable for interrupt */
>>>> +    writel(_temp_to_step(sensor->thres_temp)
>>>> +            | 0x0FFFFFF00, data->regs + TEMP0_TH);
>>>> +
>>>> +    writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH);
>>>> +
>>>> +    /* enable module */
>>>> +    writel(0x1, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x1, data->regs + TEMP0_EN);
>>>> +
>>>> +    writel(0x0, data->regs + TEMP0_INT_CLR);
>>>> +    writel(0x1, data->regs + TEMP0_INT_EN);
>>>> +
>>>> +    mdelay(5);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>
>        Why take a 5ms delay in spin_lock_irq context ?
>
>        Could we use mutex or other synchronization api here?
>
>        For TEMP0_INT_EN, TEMP0_RST_MSK, we can use
> disable_irq(THERM_IRQ) instead.
>

If i delete 5ms this driver, don't get this temperature and this 
temperature is 0 degree. I will consult hardware designer for hisilicon SOC.

Mutex lock and disable_irq ....I will try to redesign all register 
function operation, let this register code concise. Thanks for your 
comments.

Thanks
Xinwei
>>>> +}
>>>> +
>>>> +static void hisi_thermal_disable_sensor(struct hisi_thermal_data
>>>> *data)
>>>> +{
>>>> +    unsigned long flags;
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* disable sensor module */
>>>> +    writel(0x0, data->regs + );
>>>> +    writel(0x0, data->regs + TEMP0_RST_MSK);
>>>> +    writel(0x0, data->regs + TEMP0_EN);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +
>>>> +}
>>>> +
>>>> +static int hisi_thermal_get_temp(void *_sensor, long *temp)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor = _sensor;
>>>> +    struct hisi_thermal_data *data = sensor->thermal;
>>>> +
>>>> +    int sensor_id = 0, i;
>>>> +    long max_temp = 0;
>>>> +
>>>> +    *temp = hisi_thermal_get_sensor_temp(data, sensor);
>>>> +
>>>> +    data->sensor_temp[sensor->id] = *temp;
>>>> +
>>>> +    for (i = 0; i < HISI_MAX_SENSORS; i++) {
>>>> +        if (data->sensor_temp[i] >= max_temp) {
>>>> +            max_temp = data->sensor_temp[i];
>>>> +            sensor_id = i;
>>>> +        }
>>>> +    }
>>>> +
>>>> +    data->irq_bind_sensor = sensor_id;
>>>> +
>>>> +    dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%ld, thres=%d\n",
>>>> +        sensor->id, data->irq_enabled, *temp, sensor->thres_temp);
>>>> +
>>>> +    /*
>>>> +     * Bind irq to sensor for two cases:
>>>> +     *   Reenable alarm IRQ if temperature below threshold;
>>>> +     *   if irq has been enabled, always set it;
>>>> +     */
>>>> +    if (!data->irq_enabled && max_temp < sensor->thres_temp) {
>>>> +        data->irq_enabled = true;
>>>> +        hisi_thermal_bind_irq(data);
>>>> +    } else if (data->irq_enabled)
>>>> +        hisi_thermal_bind_irq(data);
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +static struct thermal_zone_of_device_ops hisi_of_thermal_ops = {
>>>> +    .get_temp = hisi_thermal_get_temp,
>>>> +};
>>>> +
>>>> +static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev;
>>>> +    unsigned long flags;
>>>> +
>>>> +    spin_lock_irqsave(&thermal_lock, flags);
>>>> +
>>>> +    /* disable interrupt */
>>>> +    writel(0x0, data->regs + TEMP0_INT_EN);
>>>> +    writel(0x1, data->regs + TEMP0_INT_CLR);
>>>> +
>>>> +    spin_unlock_irqrestore(&thermal_lock, flags);
>>>> +    data->irq_enabled = false;
>>>> +
>>>> +    return IRQ_WAKE_THREAD;
>>>> +}
>>>> +
>>>> +static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev;
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    int i;
>>>> +
>>>> +    sensor = &data->sensors[data->irq_bind_sensor];
>>>> +
>>>> +    dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n",
>>>> +         sensor->thres_temp / 1000);
>>>> +
>>>> +    for (i = 0; i < data->sensors_num; i++)
>>>> +        thermal_zone_device_update(data->sensors[i].tzd);
>>>> +
>>>> +    return IRQ_HANDLED;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_init_sensor(struct platform_device *pdev,
>>>> +                    struct device_node *np,
>>>> +                    struct hisi_thermal_data *data,
>>>> +                    int index)
>>>> +{
>>>> +    struct hisi_thermal_sensor *sensor;
>>>> +    int ret, i;
>>>> +
>>>> +    sensor = &data->sensors[index];
>>>> +
>>>> +    ret = of_property_read_u32(np, "hisilicon,tsensor-id",
>>>> +                    &sensor->id);
>>>> +    if (ret) {
>>>> +        dev_err(&pdev->dev, "failed to get id %d: %d\n", index, ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    sensor->thermal = data;
>>>> +    sensor->tzd = thermal_zone_of_sensor_register(&pdev->dev,
>>>> sensor->id,
>>>> +                sensor, &hisi_of_thermal_ops);
>>>> +    if (IS_ERR(sensor->tzd)) {
>>>> +        ret = PTR_ERR(sensor->tzd);
>>>> +        dev_err(&pdev->dev, "failed to register sensor id %d: %d\n",
>>>> +            sensor->id, ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    sensor->trip = of_thermal_get_trip_points(sensor->tzd);
>>>> +
>>>> +    for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {
>>>> +        if (sensor->trip[i].type == THERMAL_TRIP_PASSIVE) {
>>>> +            sensor->thres_temp = sensor->trip[i].temperature;
>>>> +            break;
>>>> +        }
>>>> +    }
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_get_sensor_data(struct platform_device *pdev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>>>> +    struct device_node *np = pdev->dev.of_node;
>>>> +    struct device_node *child_np;
>>>> +    int ret, i, index;
>>>> +
>>>> +    /* sensor initialization */
>>>> +    index = 0;
>>>> +    for_each_child_of_node(np, child_np) {
>>>> +
>>>> +        if (index >= HISI_MAX_SENSORS) {
>>>> +            dev_err(&pdev->dev, "unsupported sensor number\n");
>>>> +            ret = -EINVAL;
>>>> +            goto err_init_sensors;
>>>> +        }
>>>> +
>>>> +        ret = hisi_thermal_init_sensor(pdev, child_np, data, index);
>>>> +        if (ret)
>>>> +            goto err_init_sensors;
>>>> +
>>>> +        index++;
>>>> +    }
>>>> +
>>>> +    data->sensors_num = index;
>>>> +    return 0;
>>>> +
>>>> +err_init_sensors:
>>>> +    for (i = 0; i < index; i++)
>>>> +        thermal_zone_of_sensor_unregister(&pdev->dev,
>>>> +                data->sensors[i].tzd);
>>>> +    return ret;
>>>> +}
>>>> +
>>>> +static const struct of_device_id of_hisi_thermal_match[] = {
>>>> +    { .compatible = "hisilicon,tsensor" },
>>>> +    { /* end */ }
>>>> +};
>>>> +MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
>>>> +
>>>> +static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor
>>>> *sensor,
>>>> +                       bool on)
>>>> +{
>>>> +    struct thermal_zone_device *tzd = sensor->tzd;
>>>> +
>>>> +    tzd->ops->set_mode(tzd,
>>>> +        on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED);
>>>> +}
>>>> +
>>>> +static int hisi_thermal_probe(struct platform_device *pdev)
>>>> +{
>>>> +    struct hisi_thermal_data *data;
>>>> +    struct resource *res;
>>>> +    int i;
>>>> +    int ret;
>>>> +
>>>> +    data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
>>>> +    if (!data)
>>>> +        return -ENOMEM;
>>>> +
>>>> +    data->pdev = pdev;
>>>> +
>>>> +    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
>>>> +    data->regs = devm_ioremap_resource(&pdev->dev, res);
>>>> +    if (IS_ERR(data->regs)) {
>>>> +        dev_err(&pdev->dev, "failed to get io address\n");
>>>> +        return PTR_ERR(data->regs);
>>>> +    }
>>>> +
>>>> +    data->irq = platform_get_irq(pdev, 0);
>>>> +    if (data->irq < 0)
>>>> +        return data->irq;
>>>> +
>>>> +    ret = devm_request_threaded_irq(&pdev->dev, data->irq,
>>>> +            hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread,
>>>> +            0, "hisi_thermal", data);
>>>> +    if (ret < 0) {
>>>> +        dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    platform_set_drvdata(pdev, data);
>>>> +
>>>> +    data->clk = devm_clk_get(&pdev->dev, "thermal_clk");
>>>> +    if (IS_ERR(data->clk)) {
>>>> +        ret = PTR_ERR(data->clk);
>>>> +        if (ret != -EPROBE_DEFER)
>>>> +            dev_err(&pdev->dev,
>>>> +                "failed to get thermal clk: %d\n", ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    /* enable clock for thermal */
>>>> +    ret = clk_prepare_enable(data->clk);
>>>> +    if (ret) {
>>>> +        dev_err(&pdev->dev, "failed to enable thermal clk: %d\n",
>>>> ret);
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    ret = hisi_thermal_get_sensor_data(pdev);
>>>> +    if (ret) {
>>>> +        dev_err(&pdev->dev, "failed to get sensor data\n");
>>>> +        goto err_get_sensor_data;
>>>> +        return ret;
>>>> +    }
>>>> +
>>>> +    hisi_thermal_enable_sensor(data);
>>>> +    data->irq_enabled = true;
>>>> +
>>>> +    for (i = 0; i < data->sensors_num; i++)
>>>> +        hisi_thermal_toggle_sensor(&data->sensors[i], true);
>>>> +
>>>> +    return 0;
>>>> +
>>>> +err_get_sensor_data:
>>>> +    clk_disable_unprepare(data->clk);
>>>> +    return ret;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_remove(struct platform_device *pdev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = platform_get_drvdata(pdev);
>>>> +    int i;
>>>> +
>>>> +    for (i = 0; i < data->sensors_num; i++) {
>>>> +        struct hisi_thermal_sensor *sensor = &data->sensors[i];
>>>> +
>>>> +        hisi_thermal_toggle_sensor(sensor, false);
>>>> +        thermal_zone_of_sensor_unregister(&pdev->dev, sensor->tzd);
>>>> +    }
>>>> +
>>>> +    hisi_thermal_disable_sensor(data);
>>>> +    clk_disable_unprepare(data->clk);
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +#ifdef CONFIG_PM_SLEEP
>>>> +static int hisi_thermal_suspend(struct device *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>>>> +
>>>> +    hisi_thermal_disable_sensor(data);
>>>> +    data->irq_enabled = false;
>>>> +
>>>> +    clk_disable_unprepare(data->clk);
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +
>>>> +static int hisi_thermal_resume(struct device *dev)
>>>> +{
>>>> +    struct hisi_thermal_data *data = dev_get_drvdata(dev);
>>>> +
>>>> +    clk_prepare_enable(data->clk);
>>>> +
>>>> +    data->irq_enabled = true;
>>>> +    hisi_thermal_enable_sensor(data);
>>>> +
>>>> +    return 0;
>>>> +}
>>>> +#endif
>>>> +
>>>> +static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops,
>>>> +             hisi_thermal_suspend, hisi_thermal_resume);
>>>> +
>>>> +static struct platform_driver hisi_thermal_driver = {
>>>> +    .driver = {
>>>> +        .name    = "hisi_thermal",
>>>> +        .owner  = THIS_MODULE,
>>>> +        .pm    = &hisi_thermal_pm_ops,
>>>> +        .of_match_table = of_hisi_thermal_match,
>>>> +    },
>>>> +    .probe        = hisi_thermal_probe,
>>>> +    .remove        = hisi_thermal_remove,
>>>> +};
>>>> +
>>>> +static int __init hisi_thermal_init(void)
>>>> +{
>>>> +    return platform_driver_register(&hisi_thermal_driver);
>>>> +}
>>>> +
>>>> +static void __exit hisi_thermal_exit(void)
>>>> +{
>>>> +    platform_driver_unregister(&hisi_thermal_driver);
>>>> +}
>>>> +
>>>> +late_initcall(hisi_thermal_init);
>>>> +module_exit(hisi_thermal_exit);
>>>> +
>>>> +MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
>>>> +MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>");
>>>> +MODULE_DESCRIPTION("Hisilicon thermal driver");
>>>> +MODULE_LICENSE("GPL v2");
>>>>
>>>
>>>
>>>
>>> .
>>>
>>
>>
>> .
>>
>
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-pm" in
> the body of a message to majordomo at vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH v1 2/2] dt-bindings: Document the hi6220 thermal sensor bindings

[Xinwei Kong]

From: kongxinwei <kong.kongxinwei@hisilicon.com>

This adds documentation of device tree bindings for the
thermal sensor controller of hi6220 SoC.

Signed-off-by: Leo Yan <leo.yan@linaro.org>
Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
---
 .../bindings/thermal/hisilicon-thermal.txt         | 45 ++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/thermal/hisilicon-thermal.txt

diff --git a/Documentation/devicetree/bindings/thermal/hisilicon-thermal.txt b/Documentation/devicetree/bindings/thermal/hisilicon-thermal.txt
new file mode 100644
index 0000000..ceb6e2e
--- /dev/null
+++ b/Documentation/devicetree/bindings/thermal/hisilicon-thermal.txt
@@ -0,0 +1,45 @@
+* Hisilicon Thermal
+
+This driver is for hi6220 SoC which contain 4 thermal sensor.
+
+	1. sensor 0: local sensor;
+	2. sensor 1: remote sensor for ACPU cluster 1;
+	3. sensor 2: remote sensor for ACPU cluster 2;
+	4. sensor 3: remote sensor for GPU.
+
+Every sensor use one child node to represent it, so thermal sensor include
+parent node and four child node. The parent node describe common feature and
+child node describe private feature for thermal sensor;
+
+** Required properties :
+
+- compatible: "hisilicon,tsensor".
+- reg: physical base address of thermal sensor and length of memory mapped
+  region.
+- interrupt: The interrupt number to the cpu. Defines the interrupt used
+  by SOCTHERM.
+- clock-names: Input clock name, should be 'thermal_clk'.
+- clocks: phandles for clock specified in "clock-names" property.
+- #thermal-sensor-cells: Should be 1. See ./thermal.txt for a description.
+
+** Required properties for child nodes :
+
+- hisilicon,tsensor-id: the index of thermal sensor and use it to distinguish
+  thermal sensor. For example: <0> stands for local sensor; <1> stands for
+  acpu1 sensor;
+
+Example :
+
+	tsensor: tsensor@0,f7030700 {
+		compatible = "hisilicon,tsensor";
+		reg = <0x0 0xf7030700 0x0 0x1000>;
+		interrupts = <0 7 0x4>;
+		clocks = <&clock_sys HI6220_TSENSOR_CLK>;
+		clock-names = "thermal_clk";
+		#thermal-sensor-cells = <1>;
+
+		local_sensor {
+			hisilicon,tsensor-id = <0>;
+		}
+		.......
+	}
-- 
1.9.1

[PATCH v1 2/2] dt-bindings: Document the hi6220 thermal sensor bindings

[Xinwei Kong]

From: kongxinwei <kong.kongxinwei@hisilicon.com>

This adds documentation of device tree bindings for the
thermal sensor controller of hi6220 SoC.

Signed-off-by: Leo Yan <leo.yan@linaro.org>
Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
---
 .../bindings/thermal/hisilicon-thermal.txt         | 45 ++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/thermal/hisilicon-thermal.txt

diff --git a/Documentation/devicetree/bindings/thermal/hisilicon-thermal.txt b/Documentation/devicetree/bindings/thermal/hisilicon-thermal.txt
new file mode 100644
index 0000000..ceb6e2e
--- /dev/null
+++ b/Documentation/devicetree/bindings/thermal/hisilicon-thermal.txt
@@ -0,0 +1,45 @@
+* Hisilicon Thermal
+
+This driver is for hi6220 SoC which contain 4 thermal sensor.
+
+	1. sensor 0: local sensor;
+	2. sensor 1: remote sensor for ACPU cluster 1;
+	3. sensor 2: remote sensor for ACPU cluster 2;
+	4. sensor 3: remote sensor for GPU.
+
+Every sensor use one child node to represent it, so thermal sensor include
+parent node and four child node. The parent node describe common feature and
+child node describe private feature for thermal sensor;
+
+** Required properties :
+
+- compatible: "hisilicon,tsensor".
+- reg: physical base address of thermal sensor and length of memory mapped
+  region.
+- interrupt: The interrupt number to the cpu. Defines the interrupt used
+  by SOCTHERM.
+- clock-names: Input clock name, should be 'thermal_clk'.
+- clocks: phandles for clock specified in "clock-names" property.
+- #thermal-sensor-cells: Should be 1. See ./thermal.txt for a description.
+
+** Required properties for child nodes :
+
+- hisilicon,tsensor-id: the index of thermal sensor and use it to distinguish
+  thermal sensor. For example: <0> stands for local sensor; <1> stands for
+  acpu1 sensor;
+
+Example :
+
+	tsensor: tsensor at 0,f7030700 {
+		compatible = "hisilicon,tsensor";
+		reg = <0x0 0xf7030700 0x0 0x1000>;
+		interrupts = <0 7 0x4>;
+		clocks = <&clock_sys HI6220_TSENSOR_CLK>;
+		clock-names = "thermal_clk";
+		#thermal-sensor-cells = <1>;
+
+		local_sensor {
+			hisilicon,tsensor-id = <0>;
+		}
+		.......
+	}
-- 
1.9.1

[PATCH v1 2/2] dt-bindings: Document the hi6220 thermal sensor bindings

[Xinwei Kong]

From: kongxinwei <kong.kongxinwei@hisilicon.com>

This adds documentation of device tree bindings for the
thermal sensor controller of hi6220 SoC.

Signed-off-by: Leo Yan <leo.yan@linaro.org>
Signed-off-by: kongxinwei <kong.kongxinwei@hisilicon.com>
---
 .../bindings/thermal/hisilicon-thermal.txt         | 45 ++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/thermal/hisilicon-thermal.txt

diff --git a/Documentation/devicetree/bindings/thermal/hisilicon-thermal.txt b/Documentation/devicetree/bindings/thermal/hisilicon-thermal.txt
new file mode 100644
index 0000000..ceb6e2e
--- /dev/null
+++ b/Documentation/devicetree/bindings/thermal/hisilicon-thermal.txt
@@ -0,0 +1,45 @@
+* Hisilicon Thermal
+
+This driver is for hi6220 SoC which contain 4 thermal sensor.
+
+	1. sensor 0: local sensor;
+	2. sensor 1: remote sensor for ACPU cluster 1;
+	3. sensor 2: remote sensor for ACPU cluster 2;
+	4. sensor 3: remote sensor for GPU.
+
+Every sensor use one child node to represent it, so thermal sensor include
+parent node and four child node. The parent node describe common feature and
+child node describe private feature for thermal sensor;
+
+** Required properties :
+
+- compatible: "hisilicon,tsensor".
+- reg: physical base address of thermal sensor and length of memory mapped
+  region.
+- interrupt: The interrupt number to the cpu. Defines the interrupt used
+  by SOCTHERM.
+- clock-names: Input clock name, should be 'thermal_clk'.
+- clocks: phandles for clock specified in "clock-names" property.
+- #thermal-sensor-cells: Should be 1. See ./thermal.txt for a description.
+
+** Required properties for child nodes :
+
+- hisilicon,tsensor-id: the index of thermal sensor and use it to distinguish
+  thermal sensor. For example: <0> stands for local sensor; <1> stands for
+  acpu1 sensor;
+
+Example :
+
+	tsensor: tsensor@0,f7030700 {
+		compatible = "hisilicon,tsensor";
+		reg = <0x0 0xf7030700 0x0 0x1000>;
+		interrupts = <0 7 0x4>;
+		clocks = <&clock_sys HI6220_TSENSOR_CLK>;
+		clock-names = "thermal_clk";
+		#thermal-sensor-cells = <1>;
+
+		local_sensor {
+			hisilicon,tsensor-id = <0>;
+		}
+		.......
+	}
-- 
1.9.1