1 /*
2  * ntc_thermistor.c - NTC Thermistors
3  *
4  *  Copyright (C) 2010 Samsung Electronics
5  *  MyungJoo Ham <myungjoo.ham@samsung.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  *
21  */
22 
23 #include <linux/slab.h>
24 #include <linux/module.h>
25 #include <linux/pm_runtime.h>
26 #include <linux/math64.h>
27 #include <linux/platform_device.h>
28 #include <linux/err.h>
29 #include <linux/of.h>
30 #include <linux/of_device.h>
31 
32 #include <linux/platform_data/ntc_thermistor.h>
33 
34 #include <linux/iio/iio.h>
35 #include <linux/iio/machine.h>
36 #include <linux/iio/driver.h>
37 #include <linux/iio/consumer.h>
38 
39 #include <linux/hwmon.h>
40 #include <linux/hwmon-sysfs.h>
41 #include <linux/thermal.h>
42 
43 struct ntc_compensation {
44 	int		temp_c;
45 	unsigned int	ohm;
46 };
47 
48 /* Order matters, ntc_match references the entries by index */
49 static const struct platform_device_id ntc_thermistor_id[] = {
50 	{ "ncp15wb473", TYPE_NCPXXWB473 },
51 	{ "ncp18wb473", TYPE_NCPXXWB473 },
52 	{ "ncp21wb473", TYPE_NCPXXWB473 },
53 	{ "ncp03wb473", TYPE_NCPXXWB473 },
54 	{ "ncp15wl333", TYPE_NCPXXWL333 },
55 	{ "b57330v2103", TYPE_B57330V2103},
56 	{ },
57 };
58 
59 /*
60  * A compensation table should be sorted by the values of .ohm
61  * in descending order.
62  * The following compensation tables are from the specification of Murata NTC
63  * Thermistors Datasheet
64  */
65 static const struct ntc_compensation ncpXXwb473[] = {
66 	{ .temp_c	= -40, .ohm	= 1747920 },
67 	{ .temp_c	= -35, .ohm	= 1245428 },
68 	{ .temp_c	= -30, .ohm	= 898485 },
69 	{ .temp_c	= -25, .ohm	= 655802 },
70 	{ .temp_c	= -20, .ohm	= 483954 },
71 	{ .temp_c	= -15, .ohm	= 360850 },
72 	{ .temp_c	= -10, .ohm	= 271697 },
73 	{ .temp_c	= -5, .ohm	= 206463 },
74 	{ .temp_c	= 0, .ohm	= 158214 },
75 	{ .temp_c	= 5, .ohm	= 122259 },
76 	{ .temp_c	= 10, .ohm	= 95227 },
77 	{ .temp_c	= 15, .ohm	= 74730 },
78 	{ .temp_c	= 20, .ohm	= 59065 },
79 	{ .temp_c	= 25, .ohm	= 47000 },
80 	{ .temp_c	= 30, .ohm	= 37643 },
81 	{ .temp_c	= 35, .ohm	= 30334 },
82 	{ .temp_c	= 40, .ohm	= 24591 },
83 	{ .temp_c	= 45, .ohm	= 20048 },
84 	{ .temp_c	= 50, .ohm	= 16433 },
85 	{ .temp_c	= 55, .ohm	= 13539 },
86 	{ .temp_c	= 60, .ohm	= 11209 },
87 	{ .temp_c	= 65, .ohm	= 9328 },
88 	{ .temp_c	= 70, .ohm	= 7798 },
89 	{ .temp_c	= 75, .ohm	= 6544 },
90 	{ .temp_c	= 80, .ohm	= 5518 },
91 	{ .temp_c	= 85, .ohm	= 4674 },
92 	{ .temp_c	= 90, .ohm	= 3972 },
93 	{ .temp_c	= 95, .ohm	= 3388 },
94 	{ .temp_c	= 100, .ohm	= 2902 },
95 	{ .temp_c	= 105, .ohm	= 2494 },
96 	{ .temp_c	= 110, .ohm	= 2150 },
97 	{ .temp_c	= 115, .ohm	= 1860 },
98 	{ .temp_c	= 120, .ohm	= 1615 },
99 	{ .temp_c	= 125, .ohm	= 1406 },
100 };
101 static const struct ntc_compensation ncpXXwl333[] = {
102 	{ .temp_c	= -40, .ohm	= 1610154 },
103 	{ .temp_c	= -35, .ohm	= 1130850 },
104 	{ .temp_c	= -30, .ohm	= 802609 },
105 	{ .temp_c	= -25, .ohm	= 575385 },
106 	{ .temp_c	= -20, .ohm	= 416464 },
107 	{ .temp_c	= -15, .ohm	= 304219 },
108 	{ .temp_c	= -10, .ohm	= 224193 },
109 	{ .temp_c	= -5, .ohm	= 166623 },
110 	{ .temp_c	= 0, .ohm	= 124850 },
111 	{ .temp_c	= 5, .ohm	= 94287 },
112 	{ .temp_c	= 10, .ohm	= 71747 },
113 	{ .temp_c	= 15, .ohm	= 54996 },
114 	{ .temp_c	= 20, .ohm	= 42455 },
115 	{ .temp_c	= 25, .ohm	= 33000 },
116 	{ .temp_c	= 30, .ohm	= 25822 },
117 	{ .temp_c	= 35, .ohm	= 20335 },
118 	{ .temp_c	= 40, .ohm	= 16115 },
119 	{ .temp_c	= 45, .ohm	= 12849 },
120 	{ .temp_c	= 50, .ohm	= 10306 },
121 	{ .temp_c	= 55, .ohm	= 8314 },
122 	{ .temp_c	= 60, .ohm	= 6746 },
123 	{ .temp_c	= 65, .ohm	= 5503 },
124 	{ .temp_c	= 70, .ohm	= 4513 },
125 	{ .temp_c	= 75, .ohm	= 3721 },
126 	{ .temp_c	= 80, .ohm	= 3084 },
127 	{ .temp_c	= 85, .ohm	= 2569 },
128 	{ .temp_c	= 90, .ohm	= 2151 },
129 	{ .temp_c	= 95, .ohm	= 1809 },
130 	{ .temp_c	= 100, .ohm	= 1529 },
131 	{ .temp_c	= 105, .ohm	= 1299 },
132 	{ .temp_c	= 110, .ohm	= 1108 },
133 	{ .temp_c	= 115, .ohm	= 949 },
134 	{ .temp_c	= 120, .ohm	= 817 },
135 	{ .temp_c	= 125, .ohm	= 707 },
136 };
137 
138 /*
139  * The following compensation table is from the specification of EPCOS NTC
140  * Thermistors Datasheet
141  */
142 static const struct ntc_compensation b57330v2103[] = {
143 	{ .temp_c	= -40, .ohm	= 190030 },
144 	{ .temp_c	= -35, .ohm	= 145360 },
145 	{ .temp_c	= -30, .ohm	= 112060 },
146 	{ .temp_c	= -25, .ohm	= 87041 },
147 	{ .temp_c	= -20, .ohm	= 68104 },
148 	{ .temp_c	= -15, .ohm	= 53665 },
149 	{ .temp_c	= -10, .ohm	= 42576 },
150 	{ .temp_c	= -5, .ohm	= 34001 },
151 	{ .temp_c	= 0, .ohm	= 27326 },
152 	{ .temp_c	= 5, .ohm	= 22096 },
153 	{ .temp_c	= 10, .ohm	= 17973 },
154 	{ .temp_c	= 15, .ohm	= 14703 },
155 	{ .temp_c	= 20, .ohm	= 12090 },
156 	{ .temp_c	= 25, .ohm	= 10000 },
157 	{ .temp_c	= 30, .ohm	= 8311 },
158 	{ .temp_c	= 35, .ohm	= 6941 },
159 	{ .temp_c	= 40, .ohm	= 5825 },
160 	{ .temp_c	= 45, .ohm	= 4911 },
161 	{ .temp_c	= 50, .ohm	= 4158 },
162 	{ .temp_c	= 55, .ohm	= 3536 },
163 	{ .temp_c	= 60, .ohm	= 3019 },
164 	{ .temp_c	= 65, .ohm	= 2588 },
165 	{ .temp_c	= 70, .ohm	= 2227 },
166 	{ .temp_c	= 75, .ohm	= 1924 },
167 	{ .temp_c	= 80, .ohm	= 1668 },
168 	{ .temp_c	= 85, .ohm	= 1451 },
169 	{ .temp_c	= 90, .ohm	= 1266 },
170 	{ .temp_c	= 95, .ohm	= 1108 },
171 	{ .temp_c	= 100, .ohm	= 973 },
172 	{ .temp_c	= 105, .ohm	= 857 },
173 	{ .temp_c	= 110, .ohm	= 757 },
174 	{ .temp_c	= 115, .ohm	= 671 },
175 	{ .temp_c	= 120, .ohm	= 596 },
176 	{ .temp_c	= 125, .ohm	= 531 },
177 };
178 
179 struct ntc_data {
180 	struct device *hwmon_dev;
181 	struct ntc_thermistor_platform_data *pdata;
182 	const struct ntc_compensation *comp;
183 	struct device *dev;
184 	int n_comp;
185 	char name[PLATFORM_NAME_SIZE];
186 	struct thermal_zone_device *tz;
187 };
188 
189 #if defined(CONFIG_OF) && IS_ENABLED(CONFIG_IIO)
190 static int ntc_adc_iio_read(struct ntc_thermistor_platform_data *pdata)
191 {
192 	struct iio_channel *channel = pdata->chan;
193 	s64 result;
194 	int val, ret;
195 
196 	ret = iio_read_channel_raw(channel, &val);
197 	if (ret < 0) {
198 		pr_err("read channel() error: %d\n", ret);
199 		return ret;
200 	}
201 
202 	/* unit: mV */
203 	result = pdata->pullup_uv * (s64) val;
204 	result >>= 12;
205 
206 	return (int)result;
207 }
208 
209 static const struct of_device_id ntc_match[] = {
210 	{ .compatible = "murata,ncp15wb473",
211 		.data = &ntc_thermistor_id[0] },
212 	{ .compatible = "murata,ncp18wb473",
213 		.data = &ntc_thermistor_id[1] },
214 	{ .compatible = "murata,ncp21wb473",
215 		.data = &ntc_thermistor_id[2] },
216 	{ .compatible = "murata,ncp03wb473",
217 		.data = &ntc_thermistor_id[3] },
218 	{ .compatible = "murata,ncp15wl333",
219 		.data = &ntc_thermistor_id[4] },
220 	{ .compatible = "epcos,b57330v2103",
221 		.data = &ntc_thermistor_id[5]},
222 
223 	/* Usage of vendor name "ntc" is deprecated */
224 	{ .compatible = "ntc,ncp15wb473",
225 		.data = &ntc_thermistor_id[0] },
226 	{ .compatible = "ntc,ncp18wb473",
227 		.data = &ntc_thermistor_id[1] },
228 	{ .compatible = "ntc,ncp21wb473",
229 		.data = &ntc_thermistor_id[2] },
230 	{ .compatible = "ntc,ncp03wb473",
231 		.data = &ntc_thermistor_id[3] },
232 	{ .compatible = "ntc,ncp15wl333",
233 		.data = &ntc_thermistor_id[4] },
234 	{ },
235 };
236 MODULE_DEVICE_TABLE(of, ntc_match);
237 
238 static struct ntc_thermistor_platform_data *
239 ntc_thermistor_parse_dt(struct platform_device *pdev)
240 {
241 	struct iio_channel *chan;
242 	struct device_node *np = pdev->dev.of_node;
243 	struct ntc_thermistor_platform_data *pdata;
244 
245 	if (!np)
246 		return NULL;
247 
248 	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
249 	if (!pdata)
250 		return ERR_PTR(-ENOMEM);
251 
252 	chan = iio_channel_get(&pdev->dev, NULL);
253 	if (IS_ERR(chan))
254 		return ERR_CAST(chan);
255 
256 	if (of_property_read_u32(np, "pullup-uv", &pdata->pullup_uv))
257 		return ERR_PTR(-ENODEV);
258 	if (of_property_read_u32(np, "pullup-ohm", &pdata->pullup_ohm))
259 		return ERR_PTR(-ENODEV);
260 	if (of_property_read_u32(np, "pulldown-ohm", &pdata->pulldown_ohm))
261 		return ERR_PTR(-ENODEV);
262 
263 	if (of_find_property(np, "connected-positive", NULL))
264 		pdata->connect = NTC_CONNECTED_POSITIVE;
265 	else /* status change should be possible if not always on. */
266 		pdata->connect = NTC_CONNECTED_GROUND;
267 
268 	pdata->chan = chan;
269 	pdata->read_uv = ntc_adc_iio_read;
270 
271 	return pdata;
272 }
273 static void ntc_iio_channel_release(struct ntc_thermistor_platform_data *pdata)
274 {
275 	if (pdata->chan)
276 		iio_channel_release(pdata->chan);
277 }
278 #else
279 static struct ntc_thermistor_platform_data *
280 ntc_thermistor_parse_dt(struct platform_device *pdev)
281 {
282 	return NULL;
283 }
284 
285 #define ntc_match	NULL
286 
287 static void ntc_iio_channel_release(struct ntc_thermistor_platform_data *pdata)
288 { }
289 #endif
290 
291 static inline u64 div64_u64_safe(u64 dividend, u64 divisor)
292 {
293 	if (divisor == 0 && dividend == 0)
294 		return 0;
295 	if (divisor == 0)
296 		return UINT_MAX;
297 	return div64_u64(dividend, divisor);
298 }
299 
300 static int get_ohm_of_thermistor(struct ntc_data *data, unsigned int uv)
301 {
302 	struct ntc_thermistor_platform_data *pdata = data->pdata;
303 	u64 mv = uv / 1000;
304 	u64 pmv = pdata->pullup_uv / 1000;
305 	u64 n, puo, pdo;
306 	puo = pdata->pullup_ohm;
307 	pdo = pdata->pulldown_ohm;
308 
309 	if (mv == 0) {
310 		if (pdata->connect == NTC_CONNECTED_POSITIVE)
311 			return INT_MAX;
312 		return 0;
313 	}
314 	if (mv >= pmv)
315 		return (pdata->connect == NTC_CONNECTED_POSITIVE) ?
316 			0 : INT_MAX;
317 
318 	if (pdata->connect == NTC_CONNECTED_POSITIVE && puo == 0)
319 		n = div64_u64_safe(pdo * (pmv - mv), mv);
320 	else if (pdata->connect == NTC_CONNECTED_GROUND && pdo == 0)
321 		n = div64_u64_safe(puo * mv, pmv - mv);
322 	else if (pdata->connect == NTC_CONNECTED_POSITIVE)
323 		n = div64_u64_safe(pdo * puo * (pmv - mv),
324 				puo * mv - pdo * (pmv - mv));
325 	else
326 		n = div64_u64_safe(pdo * puo * mv, pdo * (pmv - mv) - puo * mv);
327 
328 	if (n > INT_MAX)
329 		n = INT_MAX;
330 	return n;
331 }
332 
333 static void lookup_comp(struct ntc_data *data, unsigned int ohm,
334 			int *i_low, int *i_high)
335 {
336 	int start, end, mid;
337 
338 	/*
339 	 * Handle special cases: Resistance is higher than or equal to
340 	 * resistance in first table entry, or resistance is lower or equal
341 	 * to resistance in last table entry.
342 	 * In these cases, return i_low == i_high, either pointing to the
343 	 * beginning or to the end of the table depending on the condition.
344 	 */
345 	if (ohm >= data->comp[0].ohm) {
346 		*i_low = 0;
347 		*i_high = 0;
348 		return;
349 	}
350 	if (ohm <= data->comp[data->n_comp - 1].ohm) {
351 		*i_low = data->n_comp - 1;
352 		*i_high = data->n_comp - 1;
353 		return;
354 	}
355 
356 	/* Do a binary search on compensation table */
357 	start = 0;
358 	end = data->n_comp;
359 	while (start < end) {
360 		mid = start + (end - start) / 2;
361 		/*
362 		 * start <= mid < end
363 		 * data->comp[start].ohm > ohm >= data->comp[end].ohm
364 		 *
365 		 * We could check for "ohm == data->comp[mid].ohm" here, but
366 		 * that is a quite unlikely condition, and we would have to
367 		 * check again after updating start. Check it at the end instead
368 		 * for simplicity.
369 		 */
370 		if (ohm >= data->comp[mid].ohm) {
371 			end = mid;
372 		} else {
373 			start = mid + 1;
374 			/*
375 			 * ohm >= data->comp[start].ohm might be true here,
376 			 * since we set start to mid + 1. In that case, we are
377 			 * done. We could keep going, but the condition is quite
378 			 * likely to occur, so it is worth checking for it.
379 			 */
380 			if (ohm >= data->comp[start].ohm)
381 				end = start;
382 		}
383 		/*
384 		 * start <= end
385 		 * data->comp[start].ohm >= ohm >= data->comp[end].ohm
386 		 */
387 	}
388 	/*
389 	 * start == end
390 	 * ohm >= data->comp[end].ohm
391 	 */
392 	*i_low = end;
393 	if (ohm == data->comp[end].ohm)
394 		*i_high = end;
395 	else
396 		*i_high = end - 1;
397 }
398 
399 static int get_temp_mc(struct ntc_data *data, unsigned int ohm)
400 {
401 	int low, high;
402 	int temp;
403 
404 	lookup_comp(data, ohm, &low, &high);
405 	if (low == high) {
406 		/* Unable to use linear approximation */
407 		temp = data->comp[low].temp_c * 1000;
408 	} else {
409 		temp = data->comp[low].temp_c * 1000 +
410 			((data->comp[high].temp_c - data->comp[low].temp_c) *
411 			 1000 * ((int)ohm - (int)data->comp[low].ohm)) /
412 			((int)data->comp[high].ohm - (int)data->comp[low].ohm);
413 	}
414 	return temp;
415 }
416 
417 static int ntc_thermistor_get_ohm(struct ntc_data *data)
418 {
419 	int read_uv;
420 
421 	if (data->pdata->read_ohm)
422 		return data->pdata->read_ohm();
423 
424 	if (data->pdata->read_uv) {
425 		read_uv = data->pdata->read_uv(data->pdata);
426 		if (read_uv < 0)
427 			return read_uv;
428 		return get_ohm_of_thermistor(data, read_uv);
429 	}
430 	return -EINVAL;
431 }
432 
433 static int ntc_read_temp(void *dev, long *temp)
434 {
435 	struct ntc_data *data = dev_get_drvdata(dev);
436 	int ohm;
437 
438 	ohm = ntc_thermistor_get_ohm(data);
439 	if (ohm < 0)
440 		return ohm;
441 
442 	*temp = get_temp_mc(data, ohm);
443 
444 	return 0;
445 }
446 
447 static ssize_t ntc_show_name(struct device *dev,
448 		struct device_attribute *attr, char *buf)
449 {
450 	struct ntc_data *data = dev_get_drvdata(dev);
451 
452 	return sprintf(buf, "%s\n", data->name);
453 }
454 
455 static ssize_t ntc_show_type(struct device *dev,
456 		struct device_attribute *attr, char *buf)
457 {
458 	return sprintf(buf, "4\n");
459 }
460 
461 static ssize_t ntc_show_temp(struct device *dev,
462 		struct device_attribute *attr, char *buf)
463 {
464 	struct ntc_data *data = dev_get_drvdata(dev);
465 	int ohm;
466 
467 	ohm = ntc_thermistor_get_ohm(data);
468 	if (ohm < 0)
469 		return ohm;
470 
471 	return sprintf(buf, "%d\n", get_temp_mc(data, ohm));
472 }
473 
474 static SENSOR_DEVICE_ATTR(temp1_type, S_IRUGO, ntc_show_type, NULL, 0);
475 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, ntc_show_temp, NULL, 0);
476 static DEVICE_ATTR(name, S_IRUGO, ntc_show_name, NULL);
477 
478 static struct attribute *ntc_attributes[] = {
479 	&dev_attr_name.attr,
480 	&sensor_dev_attr_temp1_type.dev_attr.attr,
481 	&sensor_dev_attr_temp1_input.dev_attr.attr,
482 	NULL,
483 };
484 
485 static const struct attribute_group ntc_attr_group = {
486 	.attrs = ntc_attributes,
487 };
488 
489 static const struct thermal_zone_of_device_ops ntc_of_thermal_ops = {
490 	.get_temp = ntc_read_temp,
491 };
492 
493 static int ntc_thermistor_probe(struct platform_device *pdev)
494 {
495 	const struct of_device_id *of_id =
496 			of_match_device(of_match_ptr(ntc_match), &pdev->dev);
497 	const struct platform_device_id *pdev_id;
498 	struct ntc_thermistor_platform_data *pdata;
499 	struct ntc_data *data;
500 	int ret;
501 
502 	pdata = ntc_thermistor_parse_dt(pdev);
503 	if (IS_ERR(pdata))
504 		return PTR_ERR(pdata);
505 	else if (pdata == NULL)
506 		pdata = dev_get_platdata(&pdev->dev);
507 
508 	if (!pdata) {
509 		dev_err(&pdev->dev, "No platform init data supplied.\n");
510 		return -ENODEV;
511 	}
512 
513 	/* Either one of the two is required. */
514 	if (!pdata->read_uv && !pdata->read_ohm) {
515 		dev_err(&pdev->dev,
516 			"Both read_uv and read_ohm missing. Need either one of the two.\n");
517 		return -EINVAL;
518 	}
519 
520 	if (pdata->read_uv && pdata->read_ohm) {
521 		dev_warn(&pdev->dev,
522 			 "Only one of read_uv and read_ohm is needed; ignoring read_uv.\n");
523 		pdata->read_uv = NULL;
524 	}
525 
526 	if (pdata->read_uv && (pdata->pullup_uv == 0 ||
527 				(pdata->pullup_ohm == 0 && pdata->connect ==
528 				 NTC_CONNECTED_GROUND) ||
529 				(pdata->pulldown_ohm == 0 && pdata->connect ==
530 				 NTC_CONNECTED_POSITIVE) ||
531 				(pdata->connect != NTC_CONNECTED_POSITIVE &&
532 				 pdata->connect != NTC_CONNECTED_GROUND))) {
533 		dev_err(&pdev->dev,
534 			"Required data to use read_uv not supplied.\n");
535 		return -EINVAL;
536 	}
537 
538 	data = devm_kzalloc(&pdev->dev, sizeof(struct ntc_data), GFP_KERNEL);
539 	if (!data)
540 		return -ENOMEM;
541 
542 	pdev_id = of_id ? of_id->data : platform_get_device_id(pdev);
543 
544 	data->dev = &pdev->dev;
545 	data->pdata = pdata;
546 	strlcpy(data->name, pdev_id->name, sizeof(data->name));
547 
548 	switch (pdev_id->driver_data) {
549 	case TYPE_NCPXXWB473:
550 		data->comp = ncpXXwb473;
551 		data->n_comp = ARRAY_SIZE(ncpXXwb473);
552 		break;
553 	case TYPE_NCPXXWL333:
554 		data->comp = ncpXXwl333;
555 		data->n_comp = ARRAY_SIZE(ncpXXwl333);
556 		break;
557 	case TYPE_B57330V2103:
558 		data->comp = b57330v2103;
559 		data->n_comp = ARRAY_SIZE(b57330v2103);
560 		break;
561 	default:
562 		dev_err(&pdev->dev, "Unknown device type: %lu(%s)\n",
563 				pdev_id->driver_data, pdev_id->name);
564 		return -EINVAL;
565 	}
566 
567 	platform_set_drvdata(pdev, data);
568 
569 	ret = sysfs_create_group(&data->dev->kobj, &ntc_attr_group);
570 	if (ret) {
571 		dev_err(data->dev, "unable to create sysfs files\n");
572 		return ret;
573 	}
574 
575 	data->hwmon_dev = hwmon_device_register(data->dev);
576 	if (IS_ERR(data->hwmon_dev)) {
577 		dev_err(data->dev, "unable to register as hwmon device.\n");
578 		ret = PTR_ERR(data->hwmon_dev);
579 		goto err_after_sysfs;
580 	}
581 
582 	dev_info(&pdev->dev, "Thermistor type: %s successfully probed.\n",
583 								pdev_id->name);
584 
585 	data->tz = thermal_zone_of_sensor_register(data->dev, 0, data->dev,
586 						   &ntc_of_thermal_ops);
587 	if (IS_ERR(data->tz)) {
588 		dev_dbg(&pdev->dev, "Failed to register to thermal fw.\n");
589 		data->tz = NULL;
590 	}
591 
592 	return 0;
593 err_after_sysfs:
594 	sysfs_remove_group(&data->dev->kobj, &ntc_attr_group);
595 	ntc_iio_channel_release(pdata);
596 	return ret;
597 }
598 
599 static int ntc_thermistor_remove(struct platform_device *pdev)
600 {
601 	struct ntc_data *data = platform_get_drvdata(pdev);
602 	struct ntc_thermistor_platform_data *pdata = data->pdata;
603 
604 	hwmon_device_unregister(data->hwmon_dev);
605 	sysfs_remove_group(&data->dev->kobj, &ntc_attr_group);
606 	ntc_iio_channel_release(pdata);
607 
608 	thermal_zone_of_sensor_unregister(data->dev, data->tz);
609 
610 	return 0;
611 }
612 
613 static struct platform_driver ntc_thermistor_driver = {
614 	.driver = {
615 		.name = "ntc-thermistor",
616 		.of_match_table = of_match_ptr(ntc_match),
617 	},
618 	.probe = ntc_thermistor_probe,
619 	.remove = ntc_thermistor_remove,
620 	.id_table = ntc_thermistor_id,
621 };
622 
623 module_platform_driver(ntc_thermistor_driver);
624 
625 MODULE_DESCRIPTION("NTC Thermistor Driver");
626 MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
627 MODULE_LICENSE("GPL");
628 MODULE_ALIAS("platform:ntc-thermistor");
629