[linux-2.6-block.git] / drivers / thermal / broadcom / brcmstb_thermal.c

/*
 * Broadcom STB AVS TMON thermal sensor driver
 *
 * Copyright (c) 2015-2017 Broadcom
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 */

#define DRV_NAME	"brcmstb_thermal"

#define pr_fmt(fmt)	DRV_NAME ": " fmt

#include <linux/bitops.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/io.h>
#include <linux/irqreturn.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/of_device.h>
#include <linux/thermal.h>

#define AVS_TMON_STATUS			0x00
 #define AVS_TMON_STATUS_valid_msk	BIT(11)
 #define AVS_TMON_STATUS_data_msk	GENMASK(10, 1)
 #define AVS_TMON_STATUS_data_shift	1

#define AVS_TMON_EN_OVERTEMP_RESET	0x04
 #define AVS_TMON_EN_OVERTEMP_RESET_msk	BIT(0)

#define AVS_TMON_RESET_THRESH		0x08
 #define AVS_TMON_RESET_THRESH_msk	GENMASK(10, 1)
 #define AVS_TMON_RESET_THRESH_shift	1

#define AVS_TMON_INT_IDLE_TIME		0x10

#define AVS_TMON_EN_TEMP_INT_SRCS	0x14
 #define AVS_TMON_EN_TEMP_INT_SRCS_high	BIT(1)
 #define AVS_TMON_EN_TEMP_INT_SRCS_low	BIT(0)

#define AVS_TMON_INT_THRESH		0x18
 #define AVS_TMON_INT_THRESH_high_msk	GENMASK(26, 17)
 #define AVS_TMON_INT_THRESH_high_shift	17
 #define AVS_TMON_INT_THRESH_low_msk	GENMASK(10, 1)
 #define AVS_TMON_INT_THRESH_low_shift	1

#define AVS_TMON_TEMP_INT_CODE		0x1c
#define AVS_TMON_TP_TEST_ENABLE		0x20

/* Default coefficients */
#define AVS_TMON_TEMP_SLOPE		-487
#define AVS_TMON_TEMP_OFFSET		410040

/* HW related temperature constants */
#define AVS_TMON_TEMP_MAX		0x3ff
#define AVS_TMON_TEMP_MIN		-88161
#define AVS_TMON_TEMP_MASK		AVS_TMON_TEMP_MAX

enum avs_tmon_trip_type {
	TMON_TRIP_TYPE_LOW = 0,
	TMON_TRIP_TYPE_HIGH,
	TMON_TRIP_TYPE_RESET,
	TMON_TRIP_TYPE_MAX,
};

struct avs_tmon_trip {
	/* HW bit to enable the trip */
	u32 enable_offs;
	u32 enable_mask;

	/* HW field to read the trip temperature */
	u32 reg_offs;
	u32 reg_msk;
	int reg_shift;
};

static struct avs_tmon_trip avs_tmon_trips[] = {
	/* Trips when temperature is below threshold */
	[TMON_TRIP_TYPE_LOW] = {
		.enable_offs	= AVS_TMON_EN_TEMP_INT_SRCS,
		.enable_mask	= AVS_TMON_EN_TEMP_INT_SRCS_low,
		.reg_offs	= AVS_TMON_INT_THRESH,
		.reg_msk	= AVS_TMON_INT_THRESH_low_msk,
		.reg_shift	= AVS_TMON_INT_THRESH_low_shift,
	},
	/* Trips when temperature is above threshold */
	[TMON_TRIP_TYPE_HIGH] = {
		.enable_offs	= AVS_TMON_EN_TEMP_INT_SRCS,
		.enable_mask	= AVS_TMON_EN_TEMP_INT_SRCS_high,
		.reg_offs	= AVS_TMON_INT_THRESH,
		.reg_msk	= AVS_TMON_INT_THRESH_high_msk,
		.reg_shift	= AVS_TMON_INT_THRESH_high_shift,
	},
	/* Automatically resets chip when above threshold */
	[TMON_TRIP_TYPE_RESET] = {
		.enable_offs	= AVS_TMON_EN_OVERTEMP_RESET,
		.enable_mask	= AVS_TMON_EN_OVERTEMP_RESET_msk,
		.reg_offs	= AVS_TMON_RESET_THRESH,
		.reg_msk	= AVS_TMON_RESET_THRESH_msk,
		.reg_shift	= AVS_TMON_RESET_THRESH_shift,
	},
};

struct brcmstb_thermal_priv {
	void __iomem *tmon_base;
	struct device *dev;
	struct thermal_zone_device *thermal;
};

static void avs_tmon_get_coeffs(struct thermal_zone_device *tz, int *slope,
				int *offset)
{
	*slope = thermal_zone_get_slope(tz);
	*offset = thermal_zone_get_offset(tz);
}

/* Convert a HW code to a temperature reading (millidegree celsius) */
static inline int avs_tmon_code_to_temp(struct thermal_zone_device *tz,
					u32 code)
{
	const int val = code & AVS_TMON_TEMP_MASK;
	int slope, offset;

	avs_tmon_get_coeffs(tz, &slope, &offset);

	return slope * val + offset;
}

/*
 * Convert a temperature value (millidegree celsius) to a HW code
 *
 * @temp: temperature to convert
 * @low: if true, round toward the low side
 */
static inline u32 avs_tmon_temp_to_code(struct thermal_zone_device *tz,
					int temp, bool low)
{
	int slope, offset;

	if (temp < AVS_TMON_TEMP_MIN)
		return AVS_TMON_TEMP_MAX; /* Maximum code value */

	avs_tmon_get_coeffs(tz, &slope, &offset);

	if (temp >= offset)
		return 0;	/* Minimum code value */

	if (low)
		return (u32)(DIV_ROUND_UP(offset - temp, abs(slope)));
	else
		return (u32)((offset - temp) / abs(slope));
}

static int brcmstb_get_temp(void *data, int *temp)
{
	struct brcmstb_thermal_priv *priv = data;
	u32 val;
	long t;

	val = __raw_readl(priv->tmon_base + AVS_TMON_STATUS);

	if (!(val & AVS_TMON_STATUS_valid_msk)) {
		dev_err(priv->dev, "reading not valid\n");
		return -EIO;
	}

	val = (val & AVS_TMON_STATUS_data_msk) >> AVS_TMON_STATUS_data_shift;

	t = avs_tmon_code_to_temp(priv->thermal, val);
	if (t < 0)
		*temp = 0;
	else
		*temp = t;

	return 0;
}

static void avs_tmon_trip_enable(struct brcmstb_thermal_priv *priv,
				 enum avs_tmon_trip_type type, int en)
{
	struct avs_tmon_trip *trip = &avs_tmon_trips[type];
	u32 val = __raw_readl(priv->tmon_base + trip->enable_offs);

	dev_dbg(priv->dev, "%sable trip, type %d\n", en ? "en" : "dis", type);

	if (en)
		val |= trip->enable_mask;
	else
		val &= ~trip->enable_mask;

	__raw_writel(val, priv->tmon_base + trip->enable_offs);
}

static int avs_tmon_get_trip_temp(struct brcmstb_thermal_priv *priv,
				  enum avs_tmon_trip_type type)
{
	struct avs_tmon_trip *trip = &avs_tmon_trips[type];
	u32 val = __raw_readl(priv->tmon_base + trip->reg_offs);

	val &= trip->reg_msk;
	val >>= trip->reg_shift;

	return avs_tmon_code_to_temp(priv->thermal, val);
}

static void avs_tmon_set_trip_temp(struct brcmstb_thermal_priv *priv,
				   enum avs_tmon_trip_type type,
				   int temp)
{
	struct avs_tmon_trip *trip = &avs_tmon_trips[type];
	u32 val, orig;

	dev_dbg(priv->dev, "set temp %d to %d\n", type, temp);

	/* round toward low temp for the low interrupt */
	val = avs_tmon_temp_to_code(priv->thermal, temp,
				    type == TMON_TRIP_TYPE_LOW);

	val <<= trip->reg_shift;
	val &= trip->reg_msk;

	orig = __raw_readl(priv->tmon_base + trip->reg_offs);
	orig &= ~trip->reg_msk;
	orig |= val;
	__raw_writel(orig, priv->tmon_base + trip->reg_offs);
}

static int avs_tmon_get_intr_temp(struct brcmstb_thermal_priv *priv)
{
	u32 val;

	val = __raw_readl(priv->tmon_base + AVS_TMON_TEMP_INT_CODE);
	return avs_tmon_code_to_temp(priv->thermal, val);
}

static irqreturn_t brcmstb_tmon_irq_thread(int irq, void *data)
{
	struct brcmstb_thermal_priv *priv = data;
	int low, high, intr;

	low = avs_tmon_get_trip_temp(priv, TMON_TRIP_TYPE_LOW);
	high = avs_tmon_get_trip_temp(priv, TMON_TRIP_TYPE_HIGH);
	intr = avs_tmon_get_intr_temp(priv);

	dev_dbg(priv->dev, "low/intr/high: %d/%d/%d\n",
			low, intr, high);

	/* Disable high-temp until next threshold shift */
	if (intr >= high)
		avs_tmon_trip_enable(priv, TMON_TRIP_TYPE_HIGH, 0);
	/* Disable low-temp until next threshold shift */
	if (intr <= low)
		avs_tmon_trip_enable(priv, TMON_TRIP_TYPE_LOW, 0);

	/*
	 * Notify using the interrupt temperature, in case the temperature
	 * changes before it can next be read out
	 */
	thermal_zone_device_update(priv->thermal, intr);

	return IRQ_HANDLED;
}

static int brcmstb_set_trips(void *data, int low, int high)
{
	struct brcmstb_thermal_priv *priv = data;

	dev_dbg(priv->dev, "set trips %d <--> %d\n", low, high);

	/*
	 * Disable low-temp if "low" is too small. As per thermal framework
	 * API, we use -INT_MAX rather than INT_MIN.
	 */
	if (low <= -INT_MAX) {
		avs_tmon_trip_enable(priv, TMON_TRIP_TYPE_LOW, 0);
	} else {
		avs_tmon_set_trip_temp(priv, TMON_TRIP_TYPE_LOW, low);
		avs_tmon_trip_enable(priv, TMON_TRIP_TYPE_LOW, 1);
	}

	/* Disable high-temp if "high" is too big. */
	if (high == INT_MAX) {
		avs_tmon_trip_enable(priv, TMON_TRIP_TYPE_HIGH, 0);
	} else {
		avs_tmon_set_trip_temp(priv, TMON_TRIP_TYPE_HIGH, high);
		avs_tmon_trip_enable(priv, TMON_TRIP_TYPE_HIGH, 1);
	}

	return 0;
}

static const struct thermal_zone_of_device_ops of_ops = {
	.get_temp	= brcmstb_get_temp,
	.set_trips	= brcmstb_set_trips,
};

static const struct of_device_id brcmstb_thermal_id_table[] = {
	{ .compatible = "brcm,avs-tmon" },
	{},
};
MODULE_DEVICE_TABLE(of, brcmstb_thermal_id_table);

static int brcmstb_thermal_probe(struct platform_device *pdev)
{
	struct thermal_zone_device *thermal;
	struct brcmstb_thermal_priv *priv;
	struct resource *res;
	int irq, ret;

	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	priv->tmon_base = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(priv->tmon_base))
		return PTR_ERR(priv->tmon_base);

	priv->dev = &pdev->dev;
	platform_set_drvdata(pdev, priv);

	thermal = thermal_zone_of_sensor_register(&pdev->dev, 0, priv, &of_ops);
	if (IS_ERR(thermal)) {
		ret = PTR_ERR(thermal);
		dev_err(&pdev->dev, "could not register sensor: %d\n", ret);
		return ret;
	}

	priv->thermal = thermal;

	irq = platform_get_irq(pdev, 0);
	if (irq < 0) {
		dev_err(&pdev->dev, "could not get IRQ\n");
		ret = irq;
		goto err;
	}
	ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
					brcmstb_tmon_irq_thread, IRQF_ONESHOT,
					DRV_NAME, priv);
	if (ret < 0) {
		dev_err(&pdev->dev, "could not request IRQ: %d\n", ret);
		goto err;
	}

	dev_info(&pdev->dev, "registered AVS TMON of-sensor driver\n");

	return 0;

err:
	thermal_zone_of_sensor_unregister(&pdev->dev, thermal);
	return ret;
}

static int brcmstb_thermal_exit(struct platform_device *pdev)
{
	struct brcmstb_thermal_priv *priv = platform_get_drvdata(pdev);
	struct thermal_zone_device *thermal = priv->thermal;

	if (thermal)
		thermal_zone_of_sensor_unregister(&pdev->dev, priv->thermal);

	return 0;
}

static struct platform_driver brcmstb_thermal_driver = {
	.probe = brcmstb_thermal_probe,
	.remove = brcmstb_thermal_exit,
	.driver = {
		.name = DRV_NAME,
		.of_match_table = brcmstb_thermal_id_table,
	},
};
module_platform_driver(brcmstb_thermal_driver);

MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Brian Norris");
MODULE_DESCRIPTION("Broadcom STB AVS TMON thermal driver");
Commit	Line	Data
9e03cf1b BN	1	/*
	2	* Broadcom STB AVS TMON thermal sensor driver
	3	*
	4	* Copyright (c) 2015-2017 Broadcom
	5	*
	6	* This software is licensed under the terms of the GNU General Public
	7	* License version 2, as published by the Free Software Foundation, and
	8	* may be copied, distributed, and modified under those terms.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	*/
	16
	17	#define DRV_NAME "brcmstb_thermal"
	18
	19	#define pr_fmt(fmt) DRV_NAME ": " fmt
	20
	21	#include <linux/bitops.h>
	22	#include <linux/device.h>
	23	#include <linux/err.h>
	24	#include <linux/io.h>
	25	#include <linux/irqreturn.h>
	26	#include <linux/interrupt.h>
	27	#include <linux/kernel.h>
	28	#include <linux/module.h>
	29	#include <linux/platform_device.h>
	30	#include <linux/of_device.h>
	31	#include <linux/thermal.h>
	32
	33	#define AVS_TMON_STATUS 0x00
	34	#define AVS_TMON_STATUS_valid_msk BIT(11)
	35	#define AVS_TMON_STATUS_data_msk GENMASK(10, 1)
	36	#define AVS_TMON_STATUS_data_shift 1
	37
	38	#define AVS_TMON_EN_OVERTEMP_RESET 0x04
	39	#define AVS_TMON_EN_OVERTEMP_RESET_msk BIT(0)
	40
	41	#define AVS_TMON_RESET_THRESH 0x08
	42	#define AVS_TMON_RESET_THRESH_msk GENMASK(10, 1)
	43	#define AVS_TMON_RESET_THRESH_shift 1
	44
	45	#define AVS_TMON_INT_IDLE_TIME 0x10
	46
	47	#define AVS_TMON_EN_TEMP_INT_SRCS 0x14
	48	#define AVS_TMON_EN_TEMP_INT_SRCS_high BIT(1)
	49	#define AVS_TMON_EN_TEMP_INT_SRCS_low BIT(0)
	50
	51	#define AVS_TMON_INT_THRESH 0x18
	52	#define AVS_TMON_INT_THRESH_high_msk GENMASK(26, 17)
	53	#define AVS_TMON_INT_THRESH_high_shift 17
	54	#define AVS_TMON_INT_THRESH_low_msk GENMASK(10, 1)
	55	#define AVS_TMON_INT_THRESH_low_shift 1
	56
	57	#define AVS_TMON_TEMP_INT_CODE 0x1c
	58	#define AVS_TMON_TP_TEST_ENABLE 0x20
	59
	60	/* Default coefficients */
	61	#define AVS_TMON_TEMP_SLOPE -487
	62	#define AVS_TMON_TEMP_OFFSET 410040
	63
	64	/* HW related temperature constants */
65	#define AVS_TMON_TEMP_MAX 0x3ff
66	#define AVS_TMON_TEMP_MIN -88161
67	#define AVS_TMON_TEMP_MASK AVS_TMON_TEMP_MAX
68
69	enum avs_tmon_trip_type {
70	TMON_TRIP_TYPE_LOW = 0,
71	TMON_TRIP_TYPE_HIGH,
72	TMON_TRIP_TYPE_RESET,
73	TMON_TRIP_TYPE_MAX,
74	};
75
76	struct avs_tmon_trip {
77	/* HW bit to enable the trip */
78	u32 enable_offs;
79	u32 enable_mask;
80
81	/* HW field to read the trip temperature */
82	u32 reg_offs;
83	u32 reg_msk;
84	int reg_shift;
85	};
86
87	static struct avs_tmon_trip avs_tmon_trips[] = {
88	/* Trips when temperature is below threshold */
89	[TMON_TRIP_TYPE_LOW] = {
90	.enable_offs = AVS_TMON_EN_TEMP_INT_SRCS,
91	.enable_mask = AVS_TMON_EN_TEMP_INT_SRCS_low,
92	.reg_offs = AVS_TMON_INT_THRESH,
93	.reg_msk = AVS_TMON_INT_THRESH_low_msk,
94	.reg_shift = AVS_TMON_INT_THRESH_low_shift,
95	},
96	/* Trips when temperature is above threshold */
97	[TMON_TRIP_TYPE_HIGH] = {
98	.enable_offs = AVS_TMON_EN_TEMP_INT_SRCS,
99	.enable_mask = AVS_TMON_EN_TEMP_INT_SRCS_high,
100	.reg_offs = AVS_TMON_INT_THRESH,
101	.reg_msk = AVS_TMON_INT_THRESH_high_msk,
102	.reg_shift = AVS_TMON_INT_THRESH_high_shift,
103	},
104	/* Automatically resets chip when above threshold */
105	[TMON_TRIP_TYPE_RESET] = {
106	.enable_offs = AVS_TMON_EN_OVERTEMP_RESET,
107	.enable_mask = AVS_TMON_EN_OVERTEMP_RESET_msk,
108	.reg_offs = AVS_TMON_RESET_THRESH,
109	.reg_msk = AVS_TMON_RESET_THRESH_msk,
110	.reg_shift = AVS_TMON_RESET_THRESH_shift,
111	},
112	};
113
114	struct brcmstb_thermal_priv {
115	void __iomem *tmon_base;
116	struct device *dev;
117	struct thermal_zone_device *thermal;
118	};
119
120	static void avs_tmon_get_coeffs(struct thermal_zone_device tz, int slope,
121	int *offset)
122	{
123	*slope = thermal_zone_get_slope(tz);
124	*offset = thermal_zone_get_offset(tz);
125	}
126
127	/* Convert a HW code to a temperature reading (millidegree celsius) */
128	static inline int avs_tmon_code_to_temp(struct thermal_zone_device *tz,
129	u32 code)
130	{
131	const int val = code & AVS_TMON_TEMP_MASK;
132	int slope, offset;
133
134	avs_tmon_get_coeffs(tz, &slope, &offset);
135
136	return slope * val + offset;
137	}
138
139	/*
140	* Convert a temperature value (millidegree celsius) to a HW code
141	*
142	* @temp: temperature to convert
143	* @low: if true, round toward the low side
144	*/
145	static inline u32 avs_tmon_temp_to_code(struct thermal_zone_device *tz,
146	int temp, bool low)
147	{
148	int slope, offset;
149
150	if (temp < AVS_TMON_TEMP_MIN)
151	return AVS_TMON_TEMP_MAX; /* Maximum code value */
152
153	avs_tmon_get_coeffs(tz, &slope, &offset);
154
155	if (temp >= offset)
156	return 0; /* Minimum code value */
157
158	if (low)
159	return (u32)(DIV_ROUND_UP(offset - temp, abs(slope)));
160	else
161	return (u32)((offset - temp) / abs(slope));
162	}
163
164	static int brcmstb_get_temp(void data, int temp)
165	{
166	struct brcmstb_thermal_priv *priv = data;
167	u32 val;
168	long t;
169
170	val = __raw_readl(priv->tmon_base + AVS_TMON_STATUS);
171
172	if (!(val & AVS_TMON_STATUS_valid_msk)) {
173	dev_err(priv->dev, "reading not valid\n");
174	return -EIO;
175	}
176
177	val = (val & AVS_TMON_STATUS_data_msk) >> AVS_TMON_STATUS_data_shift;
178
179	t = avs_tmon_code_to_temp(priv->thermal, val);
180	if (t < 0)
181	*temp = 0;
182	else
183	*temp = t;
184
185	return 0;
186	}
187
188	static void avs_tmon_trip_enable(struct brcmstb_thermal_priv *priv,
189	enum avs_tmon_trip_type type, int en)
190	{
191	struct avs_tmon_trip *trip = &avs_tmon_trips[type];
192	u32 val = __raw_readl(priv->tmon_base + trip->enable_offs);
193
194	dev_dbg(priv->dev, "%sable trip, type %d\n", en ? "en" : "dis", type);
195
196	if (en)
197	val \|= trip->enable_mask;
198	else
199	val &= ~trip->enable_mask;
200
201	__raw_writel(val, priv->tmon_base + trip->enable_offs);
202	}
203
204	static int avs_tmon_get_trip_temp(struct brcmstb_thermal_priv *priv,
205	enum avs_tmon_trip_type type)
206	{
207	struct avs_tmon_trip *trip = &avs_tmon_trips[type];
208	u32 val = __raw_readl(priv->tmon_base + trip->reg_offs);
209
210	val &= trip->reg_msk;
211	val >>= trip->reg_shift;
212
213	return avs_tmon_code_to_temp(priv->thermal, val);
214	}
215
216	static void avs_tmon_set_trip_temp(struct brcmstb_thermal_priv *priv,
217	enum avs_tmon_trip_type type,
218	int temp)
219	{
220	struct avs_tmon_trip *trip = &avs_tmon_trips[type];
221	u32 val, orig;
222
223	dev_dbg(priv->dev, "set temp %d to %d\n", type, temp);
224
225	/* round toward low temp for the low interrupt */
226	val = avs_tmon_temp_to_code(priv->thermal, temp,
227	type == TMON_TRIP_TYPE_LOW);
228
229	val <<= trip->reg_shift;
230	val &= trip->reg_msk;
231
232	orig = __raw_readl(priv->tmon_base + trip->reg_offs);
233	orig &= ~trip->reg_msk;
234	orig \|= val;
235	__raw_writel(orig, priv->tmon_base + trip->reg_offs);
236	}
237
238	static int avs_tmon_get_intr_temp(struct brcmstb_thermal_priv *priv)
239	{
240	u32 val;
241
242	val = __raw_readl(priv->tmon_base + AVS_TMON_TEMP_INT_CODE);
243	return avs_tmon_code_to_temp(priv->thermal, val);
244	}
245
246	static irqreturn_t brcmstb_tmon_irq_thread(int irq, void *data)
247	{
248	struct brcmstb_thermal_priv *priv = data;
249	int low, high, intr;
250
251	low = avs_tmon_get_trip_temp(priv, TMON_TRIP_TYPE_LOW);
252	high = avs_tmon_get_trip_temp(priv, TMON_TRIP_TYPE_HIGH);
253	intr = avs_tmon_get_intr_temp(priv);
254
255	dev_dbg(priv->dev, "low/intr/high: %d/%d/%d\n",
256	low, intr, high);
257
258	/* Disable high-temp until next threshold shift */
259	if (intr >= high)
260	avs_tmon_trip_enable(priv, TMON_TRIP_TYPE_HIGH, 0);
261	/* Disable low-temp until next threshold shift */
262	if (intr <= low)
263	avs_tmon_trip_enable(priv, TMON_TRIP_TYPE_LOW, 0);
264
265	/*
266	* Notify using the interrupt temperature, in case the temperature
267	* changes before it can next be read out
268	*/
269	thermal_zone_device_update(priv->thermal, intr);
270
271	return IRQ_HANDLED;
272	}
273
274	static int brcmstb_set_trips(void *data, int low, int high)
275	{
276	struct brcmstb_thermal_priv *priv = data;
277
278	dev_dbg(priv->dev, "set trips %d <--> %d\n", low, high);
279
280	/*
281	* Disable low-temp if "low" is too small. As per thermal framework
282	* API, we use -INT_MAX rather than INT_MIN.
283	*/
284	if (low <= -INT_MAX) {
285	avs_tmon_trip_enable(priv, TMON_TRIP_TYPE_LOW, 0);
286	} else {
287	avs_tmon_set_trip_temp(priv, TMON_TRIP_TYPE_LOW, low);
288	avs_tmon_trip_enable(priv, TMON_TRIP_TYPE_LOW, 1);
289	}
290
291	/* Disable high-temp if "high" is too big. */
292	if (high == INT_MAX) {
293	avs_tmon_trip_enable(priv, TMON_TRIP_TYPE_HIGH, 0);
294	} else {
295	avs_tmon_set_trip_temp(priv, TMON_TRIP_TYPE_HIGH, high);
296	avs_tmon_trip_enable(priv, TMON_TRIP_TYPE_HIGH, 1);
297	}
298
299	return 0;
300	}
301
1aea7aee	302	static const struct thermal_zone_of_device_ops of_ops = {
9e03cf1b BN	303	.get_temp = brcmstb_get_temp,
	304	.set_trips = brcmstb_set_trips,
	305	};
	306
	307	static const struct of_device_id brcmstb_thermal_id_table[] = {
	308	{ .compatible = "brcm,avs-tmon" },
	309	{},
	310	};
	311	MODULE_DEVICE_TABLE(of, brcmstb_thermal_id_table);
	312
	313	static int brcmstb_thermal_probe(struct platform_device *pdev)
	314	{
	315	struct thermal_zone_device *thermal;
	316	struct brcmstb_thermal_priv *priv;
	317	struct resource *res;
	318	int irq, ret;
	319
	320	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
	321	if (!priv)
	322	return -ENOMEM;
	323
	324	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	325	priv->tmon_base = devm_ioremap_resource(&pdev->dev, res);
	326	if (IS_ERR(priv->tmon_base))
	327	return PTR_ERR(priv->tmon_base);
	328
	329	priv->dev = &pdev->dev;
	330	platform_set_drvdata(pdev, priv);
	331
	332	thermal = thermal_zone_of_sensor_register(&pdev->dev, 0, priv, &of_ops);
	333	if (IS_ERR(thermal)) {
	334	ret = PTR_ERR(thermal);
	335	dev_err(&pdev->dev, "could not register sensor: %d\n", ret);
	336	return ret;
	337	}
	338
	339	priv->thermal = thermal;
	340
	341	irq = platform_get_irq(pdev, 0);
	342	if (irq < 0) {
	343	dev_err(&pdev->dev, "could not get IRQ\n");
	344	ret = irq;
	345	goto err;
	346	}
	347	ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
	348	brcmstb_tmon_irq_thread, IRQF_ONESHOT,
	349	DRV_NAME, priv);
	350	if (ret < 0) {
	351	dev_err(&pdev->dev, "could not request IRQ: %d\n", ret);
	352	goto err;
	353	}
	354
	355	dev_info(&pdev->dev, "registered AVS TMON of-sensor driver\n");
	356
	357	return 0;
	358
	359	err:
	360	thermal_zone_of_sensor_unregister(&pdev->dev, thermal);
	361	return ret;
	362	}
	363
	364	static int brcmstb_thermal_exit(struct platform_device *pdev)
	365	{
	366	struct brcmstb_thermal_priv *priv = platform_get_drvdata(pdev);
367	struct thermal_zone_device *thermal = priv->thermal;
368
369	if (thermal)
370	thermal_zone_of_sensor_unregister(&pdev->dev, priv->thermal);
371
372	return 0;
373	}
374
375	static struct platform_driver brcmstb_thermal_driver = {
376	.probe = brcmstb_thermal_probe,
377	.remove = brcmstb_thermal_exit,
378	.driver = {
379	.name = DRV_NAME,
380	.of_match_table = brcmstb_thermal_id_table,
381	},
382	};
383	module_platform_driver(brcmstb_thermal_driver);
384
385	MODULE_LICENSE("GPL v2");
386	MODULE_AUTHOR("Brian Norris");
387	MODULE_DESCRIPTION("Broadcom STB AVS TMON thermal driver");