1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2020 Linaro Limited
4  *
5  * Based on original driver:
6  * Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
7  *
8  * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
9  */
10 
11 #include <linux/bitfield.h>
12 #include <linux/iio/adc/qcom-vadc-common.h>
13 #include <linux/iio/consumer.h>
14 #include <linux/interrupt.h>
15 #include <linux/module.h>
16 #include <linux/of.h>
17 #include <linux/platform_device.h>
18 #include <linux/regmap.h>
19 #include <linux/thermal.h>
20 
21 #include <asm/unaligned.h>
22 
23 #include "../thermal_hwmon.h"
24 
25 /*
26  * Thermal monitoring block consists of 8 (ADC_TM5_NUM_CHANNELS) channels. Each
27  * channel is programmed to use one of ADC channels for voltage comparison.
28  * Voltages are programmed using ADC codes, so we have to convert temp to
29  * voltage and then to ADC code value.
30  *
31  * Configuration of TM channels must match configuration of corresponding ADC
32  * channels.
33  */
34 
35 #define ADC5_MAX_CHANNEL                        0xc0
36 #define ADC_TM5_NUM_CHANNELS		8
37 
38 #define ADC_TM5_STATUS_LOW			0x0a
39 
40 #define ADC_TM5_STATUS_HIGH			0x0b
41 
42 #define ADC_TM5_NUM_BTM				0x0f
43 
44 #define ADC_TM5_ADC_DIG_PARAM			0x42
45 
46 #define ADC_TM5_FAST_AVG_CTL			(ADC_TM5_ADC_DIG_PARAM + 1)
47 #define ADC_TM5_FAST_AVG_EN				BIT(7)
48 
49 #define ADC_TM5_MEAS_INTERVAL_CTL		(ADC_TM5_ADC_DIG_PARAM + 2)
50 #define ADC_TM5_TIMER1					3 /* 3.9ms */
51 
52 #define ADC_TM5_MEAS_INTERVAL_CTL2		(ADC_TM5_ADC_DIG_PARAM + 3)
53 #define ADC_TM5_MEAS_INTERVAL_CTL2_MASK			0xf0
54 #define ADC_TM5_TIMER2					10 /* 1 second */
55 #define ADC_TM5_MEAS_INTERVAL_CTL3_MASK			0xf
56 #define ADC_TM5_TIMER3					4 /* 4 second */
57 
58 #define ADC_TM_EN_CTL1				0x46
59 #define ADC_TM_EN					BIT(7)
60 #define ADC_TM_CONV_REQ				0x47
61 #define ADC_TM_CONV_REQ_EN				BIT(7)
62 
63 #define ADC_TM5_M_CHAN_BASE			0x60
64 
65 #define ADC_TM5_M_ADC_CH_SEL_CTL(n)		(ADC_TM5_M_CHAN_BASE + ((n) * 8) + 0)
66 #define ADC_TM5_M_LOW_THR0(n)			(ADC_TM5_M_CHAN_BASE + ((n) * 8) + 1)
67 #define ADC_TM5_M_LOW_THR1(n)			(ADC_TM5_M_CHAN_BASE + ((n) * 8) + 2)
68 #define ADC_TM5_M_HIGH_THR0(n)			(ADC_TM5_M_CHAN_BASE + ((n) * 8) + 3)
69 #define ADC_TM5_M_HIGH_THR1(n)			(ADC_TM5_M_CHAN_BASE + ((n) * 8) + 4)
70 #define ADC_TM5_M_MEAS_INTERVAL_CTL(n)		(ADC_TM5_M_CHAN_BASE + ((n) * 8) + 5)
71 #define ADC_TM5_M_CTL(n)			(ADC_TM5_M_CHAN_BASE + ((n) * 8) + 6)
72 #define ADC_TM5_M_CTL_HW_SETTLE_DELAY_MASK		0xf
73 #define ADC_TM5_M_CTL_CAL_SEL_MASK			0x30
74 #define ADC_TM5_M_CTL_CAL_VAL				0x40
75 #define ADC_TM5_M_EN(n)				(ADC_TM5_M_CHAN_BASE + ((n) * 8) + 7)
76 #define ADC_TM5_M_MEAS_EN				BIT(7)
77 #define ADC_TM5_M_HIGH_THR_INT_EN			BIT(1)
78 #define ADC_TM5_M_LOW_THR_INT_EN			BIT(0)
79 
80 #define ADC_TM_GEN2_STATUS1			0x08
81 #define ADC_TM_GEN2_STATUS_LOW_SET		0x09
82 #define ADC_TM_GEN2_STATUS_LOW_CLR		0x0a
83 #define ADC_TM_GEN2_STATUS_HIGH_SET		0x0b
84 #define ADC_TM_GEN2_STATUS_HIGH_CLR		0x0c
85 
86 #define ADC_TM_GEN2_CFG_HS_SET			0x0d
87 #define ADC_TM_GEN2_CFG_HS_FLAG			BIT(0)
88 #define ADC_TM_GEN2_CFG_HS_CLR			0x0e
89 
90 #define ADC_TM_GEN2_SID				0x40
91 
92 #define ADC_TM_GEN2_CH_CTL			0x41
93 #define ADC_TM_GEN2_TM_CH_SEL			GENMASK(7, 5)
94 #define ADC_TM_GEN2_MEAS_INT_SEL		GENMASK(3, 2)
95 
96 #define ADC_TM_GEN2_ADC_DIG_PARAM		0x42
97 #define ADC_TM_GEN2_CTL_CAL_SEL			GENMASK(5, 4)
98 #define ADC_TM_GEN2_CTL_DEC_RATIO_MASK		GENMASK(3, 2)
99 
100 #define ADC_TM_GEN2_FAST_AVG_CTL		0x43
101 #define ADC_TM_GEN2_FAST_AVG_EN			BIT(7)
102 
103 #define ADC_TM_GEN2_ADC_CH_SEL_CTL		0x44
104 
105 #define ADC_TM_GEN2_DELAY_CTL			0x45
106 #define ADC_TM_GEN2_HW_SETTLE_DELAY		GENMASK(3, 0)
107 
108 #define ADC_TM_GEN2_EN_CTL1			0x46
109 #define ADC_TM_GEN2_EN				BIT(7)
110 
111 #define ADC_TM_GEN2_CONV_REQ			0x47
112 #define ADC_TM_GEN2_CONV_REQ_EN			BIT(7)
113 
114 #define ADC_TM_GEN2_LOW_THR0			0x49
115 #define ADC_TM_GEN2_LOW_THR1			0x4a
116 #define ADC_TM_GEN2_HIGH_THR0			0x4b
117 #define ADC_TM_GEN2_HIGH_THR1			0x4c
118 #define ADC_TM_GEN2_LOWER_MASK(n)		((n) & GENMASK(7, 0))
119 #define ADC_TM_GEN2_UPPER_MASK(n)		(((n) & GENMASK(15, 8)) >> 8)
120 
121 #define ADC_TM_GEN2_MEAS_IRQ_EN			0x4d
122 #define ADC_TM_GEN2_MEAS_EN			BIT(7)
123 #define ADC_TM5_GEN2_HIGH_THR_INT_EN		BIT(1)
124 #define ADC_TM5_GEN2_LOW_THR_INT_EN		BIT(0)
125 
126 #define ADC_TM_GEN2_MEAS_INT_LSB		0x50
127 #define ADC_TM_GEN2_MEAS_INT_MSB		0x51
128 #define ADC_TM_GEN2_MEAS_INT_MODE		0x52
129 
130 #define ADC_TM_GEN2_Mn_DATA0(n)			((n * 2) + 0xa0)
131 #define ADC_TM_GEN2_Mn_DATA1(n)			((n * 2) + 0xa1)
132 #define ADC_TM_GEN2_DATA_SHIFT			8
133 
134 enum adc5_timer_select {
135 	ADC5_TIMER_SEL_1 = 0,
136 	ADC5_TIMER_SEL_2,
137 	ADC5_TIMER_SEL_3,
138 	ADC5_TIMER_SEL_NONE,
139 };
140 
141 enum adc5_gen {
142 	ADC_TM5,
143 	ADC_TM_HC,
144 	ADC_TM5_GEN2,
145 	ADC_TM5_MAX
146 };
147 
148 enum adc_tm5_cal_method {
149 	ADC_TM5_NO_CAL = 0,
150 	ADC_TM5_RATIOMETRIC_CAL,
151 	ADC_TM5_ABSOLUTE_CAL
152 };
153 
154 enum adc_tm_gen2_time_select {
155 	MEAS_INT_50MS = 0,
156 	MEAS_INT_100MS,
157 	MEAS_INT_1S,
158 	MEAS_INT_SET,
159 	MEAS_INT_NONE,
160 };
161 
162 struct adc_tm5_chip;
163 struct adc_tm5_channel;
164 
165 struct adc_tm5_data {
166 	const u32 full_scale_code_volt;
167 	unsigned int *decimation;
168 	unsigned int *hw_settle;
169 	int (*disable_channel)(struct adc_tm5_channel *channel);
170 	int (*configure)(struct adc_tm5_channel *channel, int low, int high);
171 	irqreturn_t (*isr)(int irq, void *data);
172 	int (*init)(struct adc_tm5_chip *chip);
173 	char *irq_name;
174 	int gen;
175 };
176 
177 /**
178  * struct adc_tm5_channel - ADC Thermal Monitoring channel data.
179  * @channel: channel number.
180  * @adc_channel: corresponding ADC channel number.
181  * @cal_method: calibration method.
182  * @prescale: channel scaling performed on the input signal.
183  * @hw_settle_time: the time between AMUX being configured and the
184  *	start of conversion.
185  * @decimation: sampling rate supported for the channel.
186  * @avg_samples: ability to provide single result from the ADC
187  *	that is an average of multiple measurements.
188  * @high_thr_en: channel upper voltage threshold enable state.
189  * @low_thr_en: channel lower voltage threshold enable state.
190  * @meas_en: recurring measurement enable state
191  * @iio: IIO channel instance used by this channel.
192  * @chip: ADC TM chip instance.
193  * @tzd: thermal zone device used by this channel.
194  */
195 struct adc_tm5_channel {
196 	unsigned int		channel;
197 	unsigned int		adc_channel;
198 	enum adc_tm5_cal_method	cal_method;
199 	unsigned int		prescale;
200 	unsigned int		hw_settle_time;
201 	unsigned int		decimation;	/* For Gen2 ADC_TM */
202 	unsigned int		avg_samples;	/* For Gen2 ADC_TM */
203 	bool			high_thr_en;	/* For Gen2 ADC_TM */
204 	bool			low_thr_en;	/* For Gen2 ADC_TM */
205 	bool			meas_en;	/* For Gen2 ADC_TM */
206 	struct iio_channel	*iio;
207 	struct adc_tm5_chip	*chip;
208 	struct thermal_zone_device *tzd;
209 };
210 
211 /**
212  * struct adc_tm5_chip - ADC Thermal Monitoring properties
213  * @regmap: SPMI ADC5 Thermal Monitoring  peripheral register map field.
214  * @dev: SPMI ADC5 device.
215  * @data: software configuration data.
216  * @channels: array of ADC TM channel data.
217  * @nchannels: amount of channels defined/allocated
218  * @decimation: sampling rate supported for the channel.
219  *      Applies to all channels, used only on Gen1 ADC_TM.
220  * @avg_samples: ability to provide single result from the ADC
221  *      that is an average of multiple measurements. Applies to all
222  *      channels, used only on Gen1 ADC_TM.
223  * @base: base address of TM registers.
224  * @adc_mutex_lock: ADC_TM mutex lock, used only on Gen2 ADC_TM.
225  *      It is used to ensure only one ADC channel configuration
226  *      is done at a time using the shared set of configuration
227  *      registers.
228  */
229 struct adc_tm5_chip {
230 	struct regmap		*regmap;
231 	struct device		*dev;
232 	const struct adc_tm5_data	*data;
233 	struct adc_tm5_channel	*channels;
234 	unsigned int		nchannels;
235 	unsigned int		decimation;
236 	unsigned int		avg_samples;
237 	u16			base;
238 	struct mutex		adc_mutex_lock;
239 };
240 
241 static int adc_tm5_read(struct adc_tm5_chip *adc_tm, u16 offset, u8 *data, int len)
242 {
243 	return regmap_bulk_read(adc_tm->regmap, adc_tm->base + offset, data, len);
244 }
245 
246 static int adc_tm5_write(struct adc_tm5_chip *adc_tm, u16 offset, u8 *data, int len)
247 {
248 	return regmap_bulk_write(adc_tm->regmap, adc_tm->base + offset, data, len);
249 }
250 
251 static int adc_tm5_reg_update(struct adc_tm5_chip *adc_tm, u16 offset, u8 mask, u8 val)
252 {
253 	return regmap_write_bits(adc_tm->regmap, adc_tm->base + offset, mask, val);
254 }
255 
256 static irqreturn_t adc_tm5_isr(int irq, void *data)
257 {
258 	struct adc_tm5_chip *chip = data;
259 	u8 status_low, status_high, ctl;
260 	int ret, i;
261 
262 	ret = adc_tm5_read(chip, ADC_TM5_STATUS_LOW, &status_low, sizeof(status_low));
263 	if (unlikely(ret)) {
264 		dev_err(chip->dev, "read status low failed: %d\n", ret);
265 		return IRQ_HANDLED;
266 	}
267 
268 	ret = adc_tm5_read(chip, ADC_TM5_STATUS_HIGH, &status_high, sizeof(status_high));
269 	if (unlikely(ret)) {
270 		dev_err(chip->dev, "read status high failed: %d\n", ret);
271 		return IRQ_HANDLED;
272 	}
273 
274 	for (i = 0; i < chip->nchannels; i++) {
275 		bool upper_set = false, lower_set = false;
276 		unsigned int ch = chip->channels[i].channel;
277 
278 		/* No TZD, we warned at the boot time */
279 		if (!chip->channels[i].tzd)
280 			continue;
281 
282 		ret = adc_tm5_read(chip, ADC_TM5_M_EN(ch), &ctl, sizeof(ctl));
283 		if (unlikely(ret)) {
284 			dev_err(chip->dev, "ctl read failed: %d, channel %d\n", ret, i);
285 			continue;
286 		}
287 
288 		if (!(ctl & ADC_TM5_M_MEAS_EN))
289 			continue;
290 
291 		lower_set = (status_low & BIT(ch)) &&
292 			(ctl & ADC_TM5_M_LOW_THR_INT_EN);
293 
294 		upper_set = (status_high & BIT(ch)) &&
295 			(ctl & ADC_TM5_M_HIGH_THR_INT_EN);
296 
297 		if (upper_set || lower_set)
298 			thermal_zone_device_update(chip->channels[i].tzd,
299 						   THERMAL_EVENT_UNSPECIFIED);
300 	}
301 
302 	return IRQ_HANDLED;
303 }
304 
305 static irqreturn_t adc_tm5_gen2_isr(int irq, void *data)
306 {
307 	struct adc_tm5_chip *chip = data;
308 	u8 status_low, status_high;
309 	int ret, i;
310 
311 	ret = adc_tm5_read(chip, ADC_TM_GEN2_STATUS_LOW_CLR, &status_low, sizeof(status_low));
312 	if (ret) {
313 		dev_err(chip->dev, "read status_low failed: %d\n", ret);
314 		return IRQ_HANDLED;
315 	}
316 
317 	ret = adc_tm5_read(chip, ADC_TM_GEN2_STATUS_HIGH_CLR, &status_high, sizeof(status_high));
318 	if (ret) {
319 		dev_err(chip->dev, "read status_high failed: %d\n", ret);
320 		return IRQ_HANDLED;
321 	}
322 
323 	ret = adc_tm5_write(chip, ADC_TM_GEN2_STATUS_LOW_CLR, &status_low, sizeof(status_low));
324 	if (ret < 0) {
325 		dev_err(chip->dev, "clear status low failed with %d\n", ret);
326 		return IRQ_HANDLED;
327 	}
328 
329 	ret = adc_tm5_write(chip, ADC_TM_GEN2_STATUS_HIGH_CLR, &status_high, sizeof(status_high));
330 	if (ret < 0) {
331 		dev_err(chip->dev, "clear status high failed with %d\n", ret);
332 		return IRQ_HANDLED;
333 	}
334 
335 	for (i = 0; i < chip->nchannels; i++) {
336 		bool upper_set = false, lower_set = false;
337 		unsigned int ch = chip->channels[i].channel;
338 
339 		/* No TZD, we warned at the boot time */
340 		if (!chip->channels[i].tzd)
341 			continue;
342 
343 		if (!chip->channels[i].meas_en)
344 			continue;
345 
346 		lower_set = (status_low & BIT(ch)) &&
347 			(chip->channels[i].low_thr_en);
348 
349 		upper_set = (status_high & BIT(ch)) &&
350 			(chip->channels[i].high_thr_en);
351 
352 		if (upper_set || lower_set)
353 			thermal_zone_device_update(chip->channels[i].tzd,
354 						   THERMAL_EVENT_UNSPECIFIED);
355 	}
356 
357 	return IRQ_HANDLED;
358 }
359 
360 static int adc_tm5_get_temp(struct thermal_zone_device *tz, int *temp)
361 {
362 	struct adc_tm5_channel *channel = thermal_zone_device_priv(tz);
363 	int ret;
364 
365 	if (!channel || !channel->iio)
366 		return -EINVAL;
367 
368 	ret = iio_read_channel_processed(channel->iio, temp);
369 	if (ret < 0)
370 		return ret;
371 
372 	if (ret != IIO_VAL_INT)
373 		return -EINVAL;
374 
375 	return 0;
376 }
377 
378 static int adc_tm5_disable_channel(struct adc_tm5_channel *channel)
379 {
380 	struct adc_tm5_chip *chip = channel->chip;
381 	unsigned int reg = ADC_TM5_M_EN(channel->channel);
382 
383 	return adc_tm5_reg_update(chip, reg,
384 				  ADC_TM5_M_MEAS_EN |
385 				  ADC_TM5_M_HIGH_THR_INT_EN |
386 				  ADC_TM5_M_LOW_THR_INT_EN,
387 				  0);
388 }
389 
390 #define ADC_TM_GEN2_POLL_DELAY_MIN_US		100
391 #define ADC_TM_GEN2_POLL_DELAY_MAX_US		110
392 #define ADC_TM_GEN2_POLL_RETRY_COUNT		3
393 
394 static int32_t adc_tm5_gen2_conv_req(struct adc_tm5_chip *chip)
395 {
396 	int ret;
397 	u8 data;
398 	unsigned int count;
399 
400 	data = ADC_TM_GEN2_EN;
401 	ret = adc_tm5_write(chip, ADC_TM_GEN2_EN_CTL1, &data, 1);
402 	if (ret < 0) {
403 		dev_err(chip->dev, "adc-tm enable failed with %d\n", ret);
404 		return ret;
405 	}
406 
407 	data = ADC_TM_GEN2_CFG_HS_FLAG;
408 	ret = adc_tm5_write(chip, ADC_TM_GEN2_CFG_HS_SET, &data, 1);
409 	if (ret < 0) {
410 		dev_err(chip->dev, "adc-tm handshake failed with %d\n", ret);
411 		return ret;
412 	}
413 
414 	data = ADC_TM_GEN2_CONV_REQ_EN;
415 	ret = adc_tm5_write(chip, ADC_TM_GEN2_CONV_REQ, &data, 1);
416 	if (ret < 0) {
417 		dev_err(chip->dev, "adc-tm request conversion failed with %d\n", ret);
418 		return ret;
419 	}
420 
421 	/*
422 	 * SW sets a handshake bit and waits for PBS to clear it
423 	 * before the next conversion request can be queued.
424 	 */
425 
426 	for (count = 0; count < ADC_TM_GEN2_POLL_RETRY_COUNT; count++) {
427 		ret = adc_tm5_read(chip, ADC_TM_GEN2_CFG_HS_SET, &data, sizeof(data));
428 		if (ret < 0) {
429 			dev_err(chip->dev, "adc-tm read failed with %d\n", ret);
430 			return ret;
431 		}
432 
433 		if (!(data & ADC_TM_GEN2_CFG_HS_FLAG))
434 			return ret;
435 		usleep_range(ADC_TM_GEN2_POLL_DELAY_MIN_US,
436 			ADC_TM_GEN2_POLL_DELAY_MAX_US);
437 	}
438 
439 	dev_err(chip->dev, "adc-tm conversion request handshake timed out\n");
440 
441 	return -ETIMEDOUT;
442 }
443 
444 static int adc_tm5_gen2_disable_channel(struct adc_tm5_channel *channel)
445 {
446 	struct adc_tm5_chip *chip = channel->chip;
447 	int ret;
448 	u8 val;
449 
450 	mutex_lock(&chip->adc_mutex_lock);
451 
452 	channel->meas_en = false;
453 	channel->high_thr_en = false;
454 	channel->low_thr_en = false;
455 
456 	ret = adc_tm5_read(chip, ADC_TM_GEN2_CH_CTL, &val, sizeof(val));
457 	if (ret < 0) {
458 		dev_err(chip->dev, "adc-tm block read failed with %d\n", ret);
459 		goto disable_fail;
460 	}
461 
462 	val &= ~ADC_TM_GEN2_TM_CH_SEL;
463 	val |= FIELD_PREP(ADC_TM_GEN2_TM_CH_SEL, channel->channel);
464 
465 	ret = adc_tm5_write(chip, ADC_TM_GEN2_CH_CTL, &val, 1);
466 	if (ret < 0) {
467 		dev_err(chip->dev, "adc-tm channel disable failed with %d\n", ret);
468 		goto disable_fail;
469 	}
470 
471 	val = 0;
472 	ret = adc_tm5_write(chip, ADC_TM_GEN2_MEAS_IRQ_EN, &val, 1);
473 	if (ret < 0) {
474 		dev_err(chip->dev, "adc-tm interrupt disable failed with %d\n", ret);
475 		goto disable_fail;
476 	}
477 
478 
479 	ret = adc_tm5_gen2_conv_req(channel->chip);
480 	if (ret < 0)
481 		dev_err(chip->dev, "adc-tm channel configure failed with %d\n", ret);
482 
483 disable_fail:
484 	mutex_unlock(&chip->adc_mutex_lock);
485 	return ret;
486 }
487 
488 static int adc_tm5_enable(struct adc_tm5_chip *chip)
489 {
490 	int ret;
491 	u8 data;
492 
493 	data = ADC_TM_EN;
494 	ret = adc_tm5_write(chip, ADC_TM_EN_CTL1, &data, sizeof(data));
495 	if (ret < 0) {
496 		dev_err(chip->dev, "adc-tm enable failed\n");
497 		return ret;
498 	}
499 
500 	data = ADC_TM_CONV_REQ_EN;
501 	ret = adc_tm5_write(chip, ADC_TM_CONV_REQ, &data, sizeof(data));
502 	if (ret < 0) {
503 		dev_err(chip->dev, "adc-tm request conversion failed\n");
504 		return ret;
505 	}
506 
507 	return 0;
508 }
509 
510 static int adc_tm5_configure(struct adc_tm5_channel *channel, int low, int high)
511 {
512 	struct adc_tm5_chip *chip = channel->chip;
513 	u8 buf[8];
514 	u16 reg = ADC_TM5_M_ADC_CH_SEL_CTL(channel->channel);
515 	int ret;
516 
517 	ret = adc_tm5_read(chip, reg, buf, sizeof(buf));
518 	if (ret) {
519 		dev_err(chip->dev, "channel %d params read failed: %d\n", channel->channel, ret);
520 		return ret;
521 	}
522 
523 	buf[0] = channel->adc_channel;
524 
525 	/* High temperature corresponds to low voltage threshold */
526 	if (high != INT_MAX) {
527 		u16 adc_code = qcom_adc_tm5_temp_volt_scale(channel->prescale,
528 				chip->data->full_scale_code_volt, high);
529 
530 		put_unaligned_le16(adc_code, &buf[1]);
531 		buf[7] |= ADC_TM5_M_LOW_THR_INT_EN;
532 	} else {
533 		buf[7] &= ~ADC_TM5_M_LOW_THR_INT_EN;
534 	}
535 
536 	/* Low temperature corresponds to high voltage threshold */
537 	if (low != -INT_MAX) {
538 		u16 adc_code = qcom_adc_tm5_temp_volt_scale(channel->prescale,
539 				chip->data->full_scale_code_volt, low);
540 
541 		put_unaligned_le16(adc_code, &buf[3]);
542 		buf[7] |= ADC_TM5_M_HIGH_THR_INT_EN;
543 	} else {
544 		buf[7] &= ~ADC_TM5_M_HIGH_THR_INT_EN;
545 	}
546 
547 	buf[5] = ADC5_TIMER_SEL_2;
548 
549 	/* Set calibration select, hw_settle delay */
550 	buf[6] &= ~ADC_TM5_M_CTL_HW_SETTLE_DELAY_MASK;
551 	buf[6] |= FIELD_PREP(ADC_TM5_M_CTL_HW_SETTLE_DELAY_MASK, channel->hw_settle_time);
552 	buf[6] &= ~ADC_TM5_M_CTL_CAL_SEL_MASK;
553 	buf[6] |= FIELD_PREP(ADC_TM5_M_CTL_CAL_SEL_MASK, channel->cal_method);
554 
555 	buf[7] |= ADC_TM5_M_MEAS_EN;
556 
557 	ret = adc_tm5_write(chip, reg, buf, sizeof(buf));
558 	if (ret) {
559 		dev_err(chip->dev, "channel %d params write failed: %d\n", channel->channel, ret);
560 		return ret;
561 	}
562 
563 	return adc_tm5_enable(chip);
564 }
565 
566 static int adc_tm5_gen2_configure(struct adc_tm5_channel *channel, int low, int high)
567 {
568 	struct adc_tm5_chip *chip = channel->chip;
569 	int ret;
570 	u8 buf[14];
571 	u16 adc_code;
572 
573 	mutex_lock(&chip->adc_mutex_lock);
574 
575 	channel->meas_en = true;
576 
577 	ret = adc_tm5_read(chip, ADC_TM_GEN2_SID, buf, sizeof(buf));
578 	if (ret < 0) {
579 		dev_err(chip->dev, "adc-tm block read failed with %d\n", ret);
580 		goto config_fail;
581 	}
582 
583 	/* Set SID from virtual channel number */
584 	buf[0] = channel->adc_channel >> 8;
585 
586 	/* Set TM channel number used and measurement interval */
587 	buf[1] &= ~ADC_TM_GEN2_TM_CH_SEL;
588 	buf[1] |= FIELD_PREP(ADC_TM_GEN2_TM_CH_SEL, channel->channel);
589 	buf[1] &= ~ADC_TM_GEN2_MEAS_INT_SEL;
590 	buf[1] |= FIELD_PREP(ADC_TM_GEN2_MEAS_INT_SEL, MEAS_INT_1S);
591 
592 	buf[2] &= ~ADC_TM_GEN2_CTL_DEC_RATIO_MASK;
593 	buf[2] |= FIELD_PREP(ADC_TM_GEN2_CTL_DEC_RATIO_MASK, channel->decimation);
594 	buf[2] &= ~ADC_TM_GEN2_CTL_CAL_SEL;
595 	buf[2] |= FIELD_PREP(ADC_TM_GEN2_CTL_CAL_SEL, channel->cal_method);
596 
597 	buf[3] = channel->avg_samples | ADC_TM_GEN2_FAST_AVG_EN;
598 
599 	buf[4] = channel->adc_channel & 0xff;
600 
601 	buf[5] = channel->hw_settle_time & ADC_TM_GEN2_HW_SETTLE_DELAY;
602 
603 	/* High temperature corresponds to low voltage threshold */
604 	if (high != INT_MAX) {
605 		channel->low_thr_en = true;
606 		adc_code = qcom_adc_tm5_gen2_temp_res_scale(high);
607 		put_unaligned_le16(adc_code, &buf[9]);
608 	} else {
609 		channel->low_thr_en = false;
610 	}
611 
612 	/* Low temperature corresponds to high voltage threshold */
613 	if (low != -INT_MAX) {
614 		channel->high_thr_en = true;
615 		adc_code = qcom_adc_tm5_gen2_temp_res_scale(low);
616 		put_unaligned_le16(adc_code, &buf[11]);
617 	} else {
618 		channel->high_thr_en = false;
619 	}
620 
621 	buf[13] = ADC_TM_GEN2_MEAS_EN;
622 	if (channel->high_thr_en)
623 		buf[13] |= ADC_TM5_GEN2_HIGH_THR_INT_EN;
624 	if (channel->low_thr_en)
625 		buf[13] |= ADC_TM5_GEN2_LOW_THR_INT_EN;
626 
627 	ret = adc_tm5_write(chip, ADC_TM_GEN2_SID, buf, sizeof(buf));
628 	if (ret) {
629 		dev_err(chip->dev, "channel %d params write failed: %d\n", channel->channel, ret);
630 		goto config_fail;
631 	}
632 
633 	ret = adc_tm5_gen2_conv_req(channel->chip);
634 	if (ret < 0)
635 		dev_err(chip->dev, "adc-tm channel configure failed with %d\n", ret);
636 
637 config_fail:
638 	mutex_unlock(&chip->adc_mutex_lock);
639 	return ret;
640 }
641 
642 static int adc_tm5_set_trips(struct thermal_zone_device *tz, int low, int high)
643 {
644 	struct adc_tm5_channel *channel = thermal_zone_device_priv(tz);
645 	struct adc_tm5_chip *chip;
646 	int ret;
647 
648 	if (!channel)
649 		return -EINVAL;
650 
651 	chip = channel->chip;
652 	dev_dbg(chip->dev, "%d:low(mdegC):%d, high(mdegC):%d\n",
653 		channel->channel, low, high);
654 
655 	if (high == INT_MAX && low <= -INT_MAX)
656 		ret = chip->data->disable_channel(channel);
657 	else
658 		ret = chip->data->configure(channel, low, high);
659 
660 	return ret;
661 }
662 
663 static const struct thermal_zone_device_ops adc_tm5_thermal_ops = {
664 	.get_temp = adc_tm5_get_temp,
665 	.set_trips = adc_tm5_set_trips,
666 };
667 
668 static int adc_tm5_register_tzd(struct adc_tm5_chip *adc_tm)
669 {
670 	unsigned int i;
671 	struct thermal_zone_device *tzd;
672 
673 	for (i = 0; i < adc_tm->nchannels; i++) {
674 		adc_tm->channels[i].chip = adc_tm;
675 		tzd = devm_thermal_of_zone_register(adc_tm->dev,
676 						    adc_tm->channels[i].channel,
677 						    &adc_tm->channels[i],
678 						    &adc_tm5_thermal_ops);
679 		if (IS_ERR(tzd)) {
680 			if (PTR_ERR(tzd) == -ENODEV) {
681 				dev_dbg(adc_tm->dev, "thermal sensor on channel %d is not used\n",
682 					 adc_tm->channels[i].channel);
683 				continue;
684 			}
685 
686 			dev_err(adc_tm->dev, "Error registering TZ zone for channel %d: %ld\n",
687 				adc_tm->channels[i].channel, PTR_ERR(tzd));
688 			return PTR_ERR(tzd);
689 		}
690 		adc_tm->channels[i].tzd = tzd;
691 		devm_thermal_add_hwmon_sysfs(adc_tm->dev, tzd);
692 	}
693 
694 	return 0;
695 }
696 
697 static int adc_tm_hc_init(struct adc_tm5_chip *chip)
698 {
699 	unsigned int i;
700 	u8 buf[2];
701 	int ret;
702 
703 	for (i = 0; i < chip->nchannels; i++) {
704 		if (chip->channels[i].channel >= ADC_TM5_NUM_CHANNELS) {
705 			dev_err(chip->dev, "Invalid channel %d\n", chip->channels[i].channel);
706 			return -EINVAL;
707 		}
708 	}
709 
710 	buf[0] = chip->decimation;
711 	buf[1] = chip->avg_samples | ADC_TM5_FAST_AVG_EN;
712 
713 	ret = adc_tm5_write(chip, ADC_TM5_ADC_DIG_PARAM, buf, sizeof(buf));
714 	if (ret)
715 		dev_err(chip->dev, "block write failed: %d\n", ret);
716 
717 	return ret;
718 }
719 
720 static int adc_tm5_init(struct adc_tm5_chip *chip)
721 {
722 	u8 buf[4], channels_available;
723 	int ret;
724 	unsigned int i;
725 
726 	ret = adc_tm5_read(chip, ADC_TM5_NUM_BTM,
727 			   &channels_available, sizeof(channels_available));
728 	if (ret) {
729 		dev_err(chip->dev, "read failed for BTM channels\n");
730 		return ret;
731 	}
732 
733 	for (i = 0; i < chip->nchannels; i++) {
734 		if (chip->channels[i].channel >= channels_available) {
735 			dev_err(chip->dev, "Invalid channel %d\n", chip->channels[i].channel);
736 			return -EINVAL;
737 		}
738 	}
739 
740 	buf[0] = chip->decimation;
741 	buf[1] = chip->avg_samples | ADC_TM5_FAST_AVG_EN;
742 	buf[2] = ADC_TM5_TIMER1;
743 	buf[3] = FIELD_PREP(ADC_TM5_MEAS_INTERVAL_CTL2_MASK, ADC_TM5_TIMER2) |
744 		 FIELD_PREP(ADC_TM5_MEAS_INTERVAL_CTL3_MASK, ADC_TM5_TIMER3);
745 
746 	ret = adc_tm5_write(chip, ADC_TM5_ADC_DIG_PARAM, buf, sizeof(buf));
747 	if (ret) {
748 		dev_err(chip->dev, "block write failed: %d\n", ret);
749 		return ret;
750 	}
751 
752 	return ret;
753 }
754 
755 static int adc_tm5_gen2_init(struct adc_tm5_chip *chip)
756 {
757 	u8 channels_available;
758 	int ret;
759 	unsigned int i;
760 
761 	ret = adc_tm5_read(chip, ADC_TM5_NUM_BTM,
762 			   &channels_available, sizeof(channels_available));
763 	if (ret) {
764 		dev_err(chip->dev, "read failed for BTM channels\n");
765 		return ret;
766 	}
767 
768 	for (i = 0; i < chip->nchannels; i++) {
769 		if (chip->channels[i].channel >= channels_available) {
770 			dev_err(chip->dev, "Invalid channel %d\n", chip->channels[i].channel);
771 			return -EINVAL;
772 		}
773 	}
774 
775 	mutex_init(&chip->adc_mutex_lock);
776 
777 	return ret;
778 }
779 
780 static int adc_tm5_get_dt_channel_data(struct adc_tm5_chip *adc_tm,
781 				       struct adc_tm5_channel *channel,
782 				       struct device_node *node)
783 {
784 	const char *name = node->name;
785 	u32 chan, value, adc_channel, varr[2];
786 	int ret;
787 	struct device *dev = adc_tm->dev;
788 	struct of_phandle_args args;
789 
790 	ret = of_property_read_u32(node, "reg", &chan);
791 	if (ret) {
792 		dev_err(dev, "%s: invalid channel number %d\n", name, ret);
793 		return ret;
794 	}
795 
796 	if (chan >= ADC_TM5_NUM_CHANNELS) {
797 		dev_err(dev, "%s: channel number too big: %d\n", name, chan);
798 		return -EINVAL;
799 	}
800 
801 	channel->channel = chan;
802 
803 	/*
804 	 * We are tied to PMIC's ADC controller, which always use single
805 	 * argument for channel number.  So don't bother parsing
806 	 * #io-channel-cells, just enforce cell_count = 1.
807 	 */
808 	ret = of_parse_phandle_with_fixed_args(node, "io-channels", 1, 0, &args);
809 	if (ret < 0) {
810 		dev_err(dev, "%s: error parsing ADC channel number %d: %d\n", name, chan, ret);
811 		return ret;
812 	}
813 	of_node_put(args.np);
814 
815 	if (args.args_count != 1) {
816 		dev_err(dev, "%s: invalid args count for ADC channel %d\n", name, chan);
817 		return -EINVAL;
818 	}
819 
820 	adc_channel = args.args[0];
821 	if (adc_tm->data->gen == ADC_TM5_GEN2)
822 		adc_channel &= 0xff;
823 
824 	if (adc_channel >= ADC5_MAX_CHANNEL) {
825 		dev_err(dev, "%s: invalid ADC channel number %d\n", name, chan);
826 		return -EINVAL;
827 	}
828 	channel->adc_channel = args.args[0];
829 
830 	channel->iio = devm_fwnode_iio_channel_get_by_name(adc_tm->dev,
831 							   of_fwnode_handle(node), NULL);
832 	if (IS_ERR(channel->iio)) {
833 		ret = PTR_ERR(channel->iio);
834 		if (ret != -EPROBE_DEFER)
835 			dev_err(dev, "%s: error getting channel: %d\n", name, ret);
836 		return ret;
837 	}
838 
839 	ret = of_property_read_u32_array(node, "qcom,pre-scaling", varr, 2);
840 	if (!ret) {
841 		ret = qcom_adc5_prescaling_from_dt(varr[0], varr[1]);
842 		if (ret < 0) {
843 			dev_err(dev, "%s: invalid pre-scaling <%d %d>\n",
844 				name, varr[0], varr[1]);
845 			return ret;
846 		}
847 		channel->prescale = ret;
848 	} else {
849 		/* 1:1 prescale is index 0 */
850 		channel->prescale = 0;
851 	}
852 
853 	ret = of_property_read_u32(node, "qcom,hw-settle-time-us", &value);
854 	if (!ret) {
855 		ret = qcom_adc5_hw_settle_time_from_dt(value, adc_tm->data->hw_settle);
856 		if (ret < 0) {
857 			dev_err(dev, "%s invalid hw-settle-time-us %d us\n",
858 				name, value);
859 			return ret;
860 		}
861 		channel->hw_settle_time = ret;
862 	} else {
863 		channel->hw_settle_time = VADC_DEF_HW_SETTLE_TIME;
864 	}
865 
866 	if (of_property_read_bool(node, "qcom,ratiometric"))
867 		channel->cal_method = ADC_TM5_RATIOMETRIC_CAL;
868 	else
869 		channel->cal_method = ADC_TM5_ABSOLUTE_CAL;
870 
871 	if (adc_tm->data->gen == ADC_TM5_GEN2) {
872 		ret = of_property_read_u32(node, "qcom,decimation", &value);
873 		if (!ret) {
874 			ret = qcom_adc5_decimation_from_dt(value, adc_tm->data->decimation);
875 			if (ret < 0) {
876 				dev_err(dev, "invalid decimation %d\n", value);
877 				return ret;
878 			}
879 			channel->decimation = ret;
880 		} else {
881 			channel->decimation = ADC5_DECIMATION_DEFAULT;
882 		}
883 
884 		ret = of_property_read_u32(node, "qcom,avg-samples", &value);
885 		if (!ret) {
886 			ret = qcom_adc5_avg_samples_from_dt(value);
887 			if (ret < 0) {
888 				dev_err(dev, "invalid avg-samples %d\n", value);
889 				return ret;
890 			}
891 			channel->avg_samples = ret;
892 		} else {
893 			channel->avg_samples = VADC_DEF_AVG_SAMPLES;
894 		}
895 	}
896 
897 	return 0;
898 }
899 
900 static const struct adc_tm5_data adc_tm5_data_pmic = {
901 	.full_scale_code_volt = 0x70e4,
902 	.decimation = (unsigned int []) { 250, 420, 840 },
903 	.hw_settle = (unsigned int []) { 15, 100, 200, 300, 400, 500, 600, 700,
904 					 1000, 2000, 4000, 8000, 16000, 32000,
905 					 64000, 128000 },
906 	.disable_channel = adc_tm5_disable_channel,
907 	.configure = adc_tm5_configure,
908 	.isr = adc_tm5_isr,
909 	.init = adc_tm5_init,
910 	.irq_name = "pm-adc-tm5",
911 	.gen = ADC_TM5,
912 };
913 
914 static const struct adc_tm5_data adc_tm_hc_data_pmic = {
915 	.full_scale_code_volt = 0x70e4,
916 	.decimation = (unsigned int []) { 256, 512, 1024 },
917 	.hw_settle = (unsigned int []) { 0, 100, 200, 300, 400, 500, 600, 700,
918 					 1000, 2000, 4000, 6000, 8000, 10000 },
919 	.disable_channel = adc_tm5_disable_channel,
920 	.configure = adc_tm5_configure,
921 	.isr = adc_tm5_isr,
922 	.init = adc_tm_hc_init,
923 	.irq_name = "pm-adc-tm5",
924 	.gen = ADC_TM_HC,
925 };
926 
927 static const struct adc_tm5_data adc_tm5_gen2_data_pmic = {
928 	.full_scale_code_volt = 0x70e4,
929 	.decimation = (unsigned int []) { 85, 340, 1360 },
930 	.hw_settle = (unsigned int []) { 15, 100, 200, 300, 400, 500, 600, 700,
931 					 1000, 2000, 4000, 8000, 16000, 32000,
932 					 64000, 128000 },
933 	.disable_channel = adc_tm5_gen2_disable_channel,
934 	.configure = adc_tm5_gen2_configure,
935 	.isr = adc_tm5_gen2_isr,
936 	.init = adc_tm5_gen2_init,
937 	.irq_name = "pm-adc-tm5-gen2",
938 	.gen = ADC_TM5_GEN2,
939 };
940 
941 static int adc_tm5_get_dt_data(struct adc_tm5_chip *adc_tm, struct device_node *node)
942 {
943 	struct adc_tm5_channel *channels;
944 	struct device_node *child;
945 	u32 value;
946 	int ret;
947 	struct device *dev = adc_tm->dev;
948 
949 	adc_tm->nchannels = of_get_available_child_count(node);
950 	if (!adc_tm->nchannels)
951 		return -EINVAL;
952 
953 	adc_tm->channels = devm_kcalloc(dev, adc_tm->nchannels,
954 					sizeof(*adc_tm->channels), GFP_KERNEL);
955 	if (!adc_tm->channels)
956 		return -ENOMEM;
957 
958 	channels = adc_tm->channels;
959 
960 	adc_tm->data = of_device_get_match_data(dev);
961 	if (!adc_tm->data)
962 		adc_tm->data = &adc_tm5_data_pmic;
963 
964 	ret = of_property_read_u32(node, "qcom,decimation", &value);
965 	if (!ret) {
966 		ret = qcom_adc5_decimation_from_dt(value, adc_tm->data->decimation);
967 		if (ret < 0) {
968 			dev_err(dev, "invalid decimation %d\n", value);
969 			return ret;
970 		}
971 		adc_tm->decimation = ret;
972 	} else {
973 		adc_tm->decimation = ADC5_DECIMATION_DEFAULT;
974 	}
975 
976 	ret = of_property_read_u32(node, "qcom,avg-samples", &value);
977 	if (!ret) {
978 		ret = qcom_adc5_avg_samples_from_dt(value);
979 		if (ret < 0) {
980 			dev_err(dev, "invalid avg-samples %d\n", value);
981 			return ret;
982 		}
983 		adc_tm->avg_samples = ret;
984 	} else {
985 		adc_tm->avg_samples = VADC_DEF_AVG_SAMPLES;
986 	}
987 
988 	for_each_available_child_of_node(node, child) {
989 		ret = adc_tm5_get_dt_channel_data(adc_tm, channels, child);
990 		if (ret) {
991 			of_node_put(child);
992 			return ret;
993 		}
994 
995 		channels++;
996 	}
997 
998 	return 0;
999 }
1000 
1001 static int adc_tm5_probe(struct platform_device *pdev)
1002 {
1003 	struct device_node *node = pdev->dev.of_node;
1004 	struct device *dev = &pdev->dev;
1005 	struct adc_tm5_chip *adc_tm;
1006 	struct regmap *regmap;
1007 	int ret, irq;
1008 	u32 reg;
1009 
1010 	regmap = dev_get_regmap(dev->parent, NULL);
1011 	if (!regmap)
1012 		return -ENODEV;
1013 
1014 	ret = of_property_read_u32(node, "reg", &reg);
1015 	if (ret)
1016 		return ret;
1017 
1018 	adc_tm = devm_kzalloc(&pdev->dev, sizeof(*adc_tm), GFP_KERNEL);
1019 	if (!adc_tm)
1020 		return -ENOMEM;
1021 
1022 	adc_tm->regmap = regmap;
1023 	adc_tm->dev = dev;
1024 	adc_tm->base = reg;
1025 
1026 	irq = platform_get_irq(pdev, 0);
1027 	if (irq < 0)
1028 		return irq;
1029 
1030 	ret = adc_tm5_get_dt_data(adc_tm, node);
1031 	if (ret)
1032 		return dev_err_probe(dev, ret, "get dt data failed\n");
1033 
1034 	ret = adc_tm->data->init(adc_tm);
1035 	if (ret) {
1036 		dev_err(dev, "adc-tm init failed\n");
1037 		return ret;
1038 	}
1039 
1040 	ret = adc_tm5_register_tzd(adc_tm);
1041 	if (ret) {
1042 		dev_err(dev, "tzd register failed\n");
1043 		return ret;
1044 	}
1045 
1046 	return devm_request_threaded_irq(dev, irq, NULL, adc_tm->data->isr,
1047 			IRQF_ONESHOT, adc_tm->data->irq_name, adc_tm);
1048 }
1049 
1050 static const struct of_device_id adc_tm5_match_table[] = {
1051 	{
1052 		.compatible = "qcom,spmi-adc-tm5",
1053 		.data = &adc_tm5_data_pmic,
1054 	},
1055 	{
1056 		.compatible = "qcom,spmi-adc-tm-hc",
1057 		.data = &adc_tm_hc_data_pmic,
1058 	},
1059 	{
1060 		.compatible = "qcom,spmi-adc-tm5-gen2",
1061 		.data = &adc_tm5_gen2_data_pmic,
1062 	},
1063 	{ }
1064 };
1065 MODULE_DEVICE_TABLE(of, adc_tm5_match_table);
1066 
1067 static struct platform_driver adc_tm5_driver = {
1068 	.driver = {
1069 		.name = "qcom-spmi-adc-tm5",
1070 		.of_match_table = adc_tm5_match_table,
1071 	},
1072 	.probe = adc_tm5_probe,
1073 };
1074 module_platform_driver(adc_tm5_driver);
1075 
1076 MODULE_DESCRIPTION("SPMI PMIC Thermal Monitor ADC driver");
1077 MODULE_LICENSE("GPL v2");
1078