Commit | Line | Data |
---|---|---|
f22aaaa7 DK |
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 | ||
30 | #include <linux/platform_data/ntc_thermistor.h> | |
31 | ||
32 | #include <linux/hwmon.h> | |
33 | #include <linux/hwmon-sysfs.h> | |
34 | ||
35 | struct ntc_compensation { | |
36 | int temp_C; | |
37 | unsigned int ohm; | |
38 | }; | |
39 | ||
40 | /* | |
41 | * A compensation table should be sorted by the values of .ohm | |
42 | * in descending order. | |
43 | * The following compensation tables are from the specification of Murata NTC | |
44 | * Thermistors Datasheet | |
45 | */ | |
46 | const struct ntc_compensation ncpXXwb473[] = { | |
47 | { .temp_C = -40, .ohm = 1747920 }, | |
48 | { .temp_C = -35, .ohm = 1245428 }, | |
49 | { .temp_C = -30, .ohm = 898485 }, | |
50 | { .temp_C = -25, .ohm = 655802 }, | |
51 | { .temp_C = -20, .ohm = 483954 }, | |
52 | { .temp_C = -15, .ohm = 360850 }, | |
53 | { .temp_C = -10, .ohm = 271697 }, | |
54 | { .temp_C = -5, .ohm = 206463 }, | |
55 | { .temp_C = 0, .ohm = 158214 }, | |
56 | { .temp_C = 5, .ohm = 122259 }, | |
57 | { .temp_C = 10, .ohm = 95227 }, | |
58 | { .temp_C = 15, .ohm = 74730 }, | |
59 | { .temp_C = 20, .ohm = 59065 }, | |
60 | { .temp_C = 25, .ohm = 47000 }, | |
61 | { .temp_C = 30, .ohm = 37643 }, | |
62 | { .temp_C = 35, .ohm = 30334 }, | |
63 | { .temp_C = 40, .ohm = 24591 }, | |
64 | { .temp_C = 45, .ohm = 20048 }, | |
65 | { .temp_C = 50, .ohm = 16433 }, | |
66 | { .temp_C = 55, .ohm = 13539 }, | |
67 | { .temp_C = 60, .ohm = 11209 }, | |
68 | { .temp_C = 65, .ohm = 9328 }, | |
69 | { .temp_C = 70, .ohm = 7798 }, | |
70 | { .temp_C = 75, .ohm = 6544 }, | |
71 | { .temp_C = 80, .ohm = 5518 }, | |
72 | { .temp_C = 85, .ohm = 4674 }, | |
73 | { .temp_C = 90, .ohm = 3972 }, | |
74 | { .temp_C = 95, .ohm = 3388 }, | |
75 | { .temp_C = 100, .ohm = 2902 }, | |
76 | { .temp_C = 105, .ohm = 2494 }, | |
77 | { .temp_C = 110, .ohm = 2150 }, | |
78 | { .temp_C = 115, .ohm = 1860 }, | |
79 | { .temp_C = 120, .ohm = 1615 }, | |
80 | { .temp_C = 125, .ohm = 1406 }, | |
81 | }; | |
82 | const struct ntc_compensation ncpXXwl333[] = { | |
83 | { .temp_C = -40, .ohm = 1610154 }, | |
84 | { .temp_C = -35, .ohm = 1130850 }, | |
85 | { .temp_C = -30, .ohm = 802609 }, | |
86 | { .temp_C = -25, .ohm = 575385 }, | |
87 | { .temp_C = -20, .ohm = 416464 }, | |
88 | { .temp_C = -15, .ohm = 304219 }, | |
89 | { .temp_C = -10, .ohm = 224193 }, | |
90 | { .temp_C = -5, .ohm = 166623 }, | |
91 | { .temp_C = 0, .ohm = 124850 }, | |
92 | { .temp_C = 5, .ohm = 94287 }, | |
93 | { .temp_C = 10, .ohm = 71747 }, | |
94 | { .temp_C = 15, .ohm = 54996 }, | |
95 | { .temp_C = 20, .ohm = 42455 }, | |
96 | { .temp_C = 25, .ohm = 33000 }, | |
97 | { .temp_C = 30, .ohm = 25822 }, | |
98 | { .temp_C = 35, .ohm = 20335 }, | |
99 | { .temp_C = 40, .ohm = 16115 }, | |
100 | { .temp_C = 45, .ohm = 12849 }, | |
101 | { .temp_C = 50, .ohm = 10306 }, | |
102 | { .temp_C = 55, .ohm = 8314 }, | |
103 | { .temp_C = 60, .ohm = 6746 }, | |
104 | { .temp_C = 65, .ohm = 5503 }, | |
105 | { .temp_C = 70, .ohm = 4513 }, | |
106 | { .temp_C = 75, .ohm = 3721 }, | |
107 | { .temp_C = 80, .ohm = 3084 }, | |
108 | { .temp_C = 85, .ohm = 2569 }, | |
109 | { .temp_C = 90, .ohm = 2151 }, | |
110 | { .temp_C = 95, .ohm = 1809 }, | |
111 | { .temp_C = 100, .ohm = 1529 }, | |
112 | { .temp_C = 105, .ohm = 1299 }, | |
113 | { .temp_C = 110, .ohm = 1108 }, | |
114 | { .temp_C = 115, .ohm = 949 }, | |
115 | { .temp_C = 120, .ohm = 817 }, | |
116 | { .temp_C = 125, .ohm = 707 }, | |
117 | }; | |
118 | ||
119 | struct ntc_data { | |
120 | struct device *hwmon_dev; | |
121 | struct ntc_thermistor_platform_data *pdata; | |
122 | const struct ntc_compensation *comp; | |
123 | struct device *dev; | |
124 | int n_comp; | |
125 | char name[PLATFORM_NAME_SIZE]; | |
126 | }; | |
127 | ||
128 | static inline u64 div64_u64_safe(u64 dividend, u64 divisor) | |
129 | { | |
130 | if (divisor == 0 && dividend == 0) | |
131 | return 0; | |
132 | if (divisor == 0) | |
133 | return UINT_MAX; | |
134 | return div64_u64(dividend, divisor); | |
135 | } | |
136 | ||
137 | static unsigned int get_ohm_of_thermistor(struct ntc_data *data, | |
138 | unsigned int uV) | |
139 | { | |
140 | struct ntc_thermistor_platform_data *pdata = data->pdata; | |
141 | u64 mV = uV / 1000; | |
142 | u64 pmV = pdata->pullup_uV / 1000; | |
143 | u64 N, puO, pdO; | |
144 | puO = pdata->pullup_ohm; | |
145 | pdO = pdata->pulldown_ohm; | |
146 | ||
147 | if (mV == 0) { | |
148 | if (pdata->connect == NTC_CONNECTED_POSITIVE) | |
149 | return UINT_MAX; | |
150 | return 0; | |
151 | } | |
152 | if (mV >= pmV) | |
153 | return (pdata->connect == NTC_CONNECTED_POSITIVE) ? | |
154 | 0 : UINT_MAX; | |
155 | ||
156 | if (pdata->connect == NTC_CONNECTED_POSITIVE && puO == 0) | |
157 | N = div64_u64_safe(pdO * (pmV - mV), mV); | |
158 | else if (pdata->connect == NTC_CONNECTED_GROUND && pdO == 0) | |
159 | N = div64_u64_safe(puO * mV, pmV - mV); | |
160 | else if (pdata->connect == NTC_CONNECTED_POSITIVE) | |
161 | N = div64_u64_safe(pdO * puO * (pmV - mV), | |
162 | puO * mV - pdO * (pmV - mV)); | |
163 | else | |
164 | N = div64_u64_safe(pdO * puO * mV, pdO * (pmV - mV) - puO * mV); | |
165 | ||
166 | return (unsigned int) N; | |
167 | } | |
168 | ||
169 | static int lookup_comp(struct ntc_data *data, | |
170 | unsigned int ohm, int *i_low, int *i_high) | |
171 | { | |
172 | int start, end, mid = -1; | |
173 | ||
174 | /* Do a binary search on compensation table */ | |
175 | start = 0; | |
176 | end = data->n_comp; | |
177 | ||
178 | while (end > start) { | |
179 | mid = start + (end - start) / 2; | |
180 | if (data->comp[mid].ohm < ohm) | |
181 | end = mid; | |
182 | else if (data->comp[mid].ohm > ohm) | |
183 | start = mid + 1; | |
184 | else | |
185 | break; | |
186 | } | |
187 | ||
188 | if (mid == 0) { | |
189 | if (data->comp[mid].ohm > ohm) { | |
190 | *i_high = mid; | |
191 | *i_low = mid + 1; | |
192 | return 0; | |
193 | } else { | |
194 | *i_low = mid; | |
195 | *i_high = -1; | |
196 | return -EINVAL; | |
197 | } | |
198 | } | |
199 | if (mid == (data->n_comp - 1)) { | |
200 | if (data->comp[mid].ohm <= ohm) { | |
201 | *i_low = mid; | |
202 | *i_high = mid - 1; | |
203 | return 0; | |
204 | } else { | |
205 | *i_low = -1; | |
206 | *i_high = mid; | |
207 | return -EINVAL; | |
208 | } | |
209 | } | |
210 | ||
211 | if (data->comp[mid].ohm <= ohm) { | |
212 | *i_low = mid; | |
213 | *i_high = mid - 1; | |
858a9143 | 214 | } else { |
f22aaaa7 DK |
215 | *i_low = mid + 1; |
216 | *i_high = mid; | |
217 | } | |
218 | ||
219 | return 0; | |
220 | } | |
221 | ||
222 | static int get_temp_mC(struct ntc_data *data, unsigned int ohm, int *temp) | |
223 | { | |
224 | int low, high; | |
225 | int ret; | |
226 | ||
227 | ret = lookup_comp(data, ohm, &low, &high); | |
228 | if (ret) { | |
229 | /* Unable to use linear approximation */ | |
230 | if (low != -1) | |
231 | *temp = data->comp[low].temp_C * 1000; | |
232 | else if (high != -1) | |
233 | *temp = data->comp[high].temp_C * 1000; | |
234 | else | |
235 | return ret; | |
236 | } else { | |
237 | *temp = data->comp[low].temp_C * 1000 + | |
238 | ((data->comp[high].temp_C - data->comp[low].temp_C) * | |
239 | 1000 * ((int)ohm - (int)data->comp[low].ohm)) / | |
240 | ((int)data->comp[high].ohm - (int)data->comp[low].ohm); | |
241 | } | |
242 | ||
243 | return 0; | |
244 | } | |
245 | ||
246 | static int ntc_thermistor_read(struct ntc_data *data, int *temp) | |
247 | { | |
248 | int ret; | |
249 | int read_ohm, read_uV; | |
250 | unsigned int ohm = 0; | |
251 | ||
252 | if (data->pdata->read_ohm) { | |
253 | read_ohm = data->pdata->read_ohm(); | |
254 | if (read_ohm < 0) | |
255 | return read_ohm; | |
256 | ohm = (unsigned int)read_ohm; | |
257 | } | |
258 | ||
259 | if (data->pdata->read_uV) { | |
260 | read_uV = data->pdata->read_uV(); | |
261 | if (read_uV < 0) | |
262 | return read_uV; | |
263 | ohm = get_ohm_of_thermistor(data, (unsigned int)read_uV); | |
264 | } | |
265 | ||
266 | ret = get_temp_mC(data, ohm, temp); | |
267 | if (ret) { | |
268 | dev_dbg(data->dev, "Sensor reading function not available.\n"); | |
269 | return ret; | |
270 | } | |
271 | ||
272 | return 0; | |
273 | } | |
274 | ||
275 | static ssize_t ntc_show_name(struct device *dev, | |
276 | struct device_attribute *attr, char *buf) | |
277 | { | |
278 | struct ntc_data *data = dev_get_drvdata(dev); | |
279 | ||
280 | return sprintf(buf, "%s\n", data->name); | |
281 | } | |
282 | ||
283 | static ssize_t ntc_show_type(struct device *dev, | |
284 | struct device_attribute *attr, char *buf) | |
285 | { | |
286 | return sprintf(buf, "4\n"); | |
287 | } | |
288 | ||
289 | static ssize_t ntc_show_temp(struct device *dev, | |
290 | struct device_attribute *attr, char *buf) | |
291 | { | |
292 | struct ntc_data *data = dev_get_drvdata(dev); | |
293 | int temp, ret; | |
294 | ||
295 | ret = ntc_thermistor_read(data, &temp); | |
296 | if (ret) | |
297 | return ret; | |
298 | return sprintf(buf, "%d\n", temp); | |
299 | } | |
300 | ||
301 | static SENSOR_DEVICE_ATTR(temp1_type, S_IRUGO, ntc_show_type, NULL, 0); | |
302 | static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, ntc_show_temp, NULL, 0); | |
303 | static DEVICE_ATTR(name, S_IRUGO, ntc_show_name, NULL); | |
304 | ||
305 | static struct attribute *ntc_attributes[] = { | |
306 | &dev_attr_name.attr, | |
307 | &sensor_dev_attr_temp1_type.dev_attr.attr, | |
308 | &sensor_dev_attr_temp1_input.dev_attr.attr, | |
309 | NULL, | |
310 | }; | |
311 | ||
312 | static const struct attribute_group ntc_attr_group = { | |
313 | .attrs = ntc_attributes, | |
314 | }; | |
315 | ||
316 | static int __devinit ntc_thermistor_probe(struct platform_device *pdev) | |
317 | { | |
318 | struct ntc_data *data; | |
319 | struct ntc_thermistor_platform_data *pdata = pdev->dev.platform_data; | |
320 | int ret = 0; | |
321 | ||
322 | if (!pdata) { | |
323 | dev_err(&pdev->dev, "No platform init data supplied.\n"); | |
324 | return -ENODEV; | |
325 | } | |
326 | ||
327 | /* Either one of the two is required. */ | |
328 | if (!pdata->read_uV && !pdata->read_ohm) { | |
329 | dev_err(&pdev->dev, "Both read_uV and read_ohm missing." | |
330 | "Need either one of the two.\n"); | |
331 | return -EINVAL; | |
332 | } | |
333 | ||
334 | if (pdata->read_uV && pdata->read_ohm) { | |
335 | dev_warn(&pdev->dev, "Only one of read_uV and read_ohm " | |
336 | "is needed; ignoring read_uV.\n"); | |
337 | pdata->read_uV = NULL; | |
338 | } | |
339 | ||
340 | if (pdata->read_uV && (pdata->pullup_uV == 0 || | |
341 | (pdata->pullup_ohm == 0 && pdata->connect == | |
342 | NTC_CONNECTED_GROUND) || | |
343 | (pdata->pulldown_ohm == 0 && pdata->connect == | |
344 | NTC_CONNECTED_POSITIVE) || | |
345 | (pdata->connect != NTC_CONNECTED_POSITIVE && | |
346 | pdata->connect != NTC_CONNECTED_GROUND))) { | |
347 | dev_err(&pdev->dev, "Required data to use read_uV not " | |
348 | "supplied.\n"); | |
349 | return -EINVAL; | |
350 | } | |
351 | ||
352 | data = kzalloc(sizeof(struct ntc_data), GFP_KERNEL); | |
353 | if (!data) | |
354 | return -ENOMEM; | |
355 | ||
356 | data->dev = &pdev->dev; | |
357 | data->pdata = pdata; | |
358 | strncpy(data->name, pdev->id_entry->name, PLATFORM_NAME_SIZE); | |
359 | ||
360 | switch (pdev->id_entry->driver_data) { | |
361 | case TYPE_NCPXXWB473: | |
362 | data->comp = ncpXXwb473; | |
363 | data->n_comp = ARRAY_SIZE(ncpXXwb473); | |
364 | break; | |
365 | case TYPE_NCPXXWL333: | |
366 | data->comp = ncpXXwl333; | |
367 | data->n_comp = ARRAY_SIZE(ncpXXwl333); | |
368 | break; | |
369 | default: | |
370 | dev_err(&pdev->dev, "Unknown device type: %lu(%s)\n", | |
371 | pdev->id_entry->driver_data, | |
372 | pdev->id_entry->name); | |
373 | ret = -EINVAL; | |
374 | goto err; | |
375 | } | |
376 | ||
377 | platform_set_drvdata(pdev, data); | |
378 | ||
379 | ret = sysfs_create_group(&data->dev->kobj, &ntc_attr_group); | |
380 | if (ret) { | |
381 | dev_err(data->dev, "unable to create sysfs files\n"); | |
382 | goto err; | |
383 | } | |
384 | ||
385 | data->hwmon_dev = hwmon_device_register(data->dev); | |
386 | if (IS_ERR_OR_NULL(data->hwmon_dev)) { | |
387 | dev_err(data->dev, "unable to register as hwmon device.\n"); | |
388 | ret = -EINVAL; | |
389 | goto err_after_sysfs; | |
390 | } | |
391 | ||
392 | dev_info(&pdev->dev, "Thermistor %s:%d (type: %s/%lu) successfully probed.\n", | |
393 | pdev->name, pdev->id, pdev->id_entry->name, | |
394 | pdev->id_entry->driver_data); | |
395 | return 0; | |
396 | err_after_sysfs: | |
397 | sysfs_remove_group(&data->dev->kobj, &ntc_attr_group); | |
398 | err: | |
399 | kfree(data); | |
400 | return ret; | |
401 | } | |
402 | ||
403 | static int __devexit ntc_thermistor_remove(struct platform_device *pdev) | |
404 | { | |
405 | struct ntc_data *data = platform_get_drvdata(pdev); | |
406 | ||
407 | hwmon_device_unregister(data->hwmon_dev); | |
408 | sysfs_remove_group(&data->dev->kobj, &ntc_attr_group); | |
409 | platform_set_drvdata(pdev, NULL); | |
410 | ||
411 | kfree(data); | |
412 | ||
413 | return 0; | |
414 | } | |
415 | ||
416 | static const struct platform_device_id ntc_thermistor_id[] = { | |
417 | { "ncp15wb473", TYPE_NCPXXWB473 }, | |
418 | { "ncp18wb473", TYPE_NCPXXWB473 }, | |
419 | { "ncp21wb473", TYPE_NCPXXWB473 }, | |
420 | { "ncp03wb473", TYPE_NCPXXWB473 }, | |
421 | { "ncp15wl333", TYPE_NCPXXWL333 }, | |
422 | { }, | |
423 | }; | |
424 | ||
425 | static struct platform_driver ntc_thermistor_driver = { | |
426 | .driver = { | |
427 | .name = "ntc-thermistor", | |
428 | .owner = THIS_MODULE, | |
429 | }, | |
430 | .probe = ntc_thermistor_probe, | |
431 | .remove = __devexit_p(ntc_thermistor_remove), | |
432 | .id_table = ntc_thermistor_id, | |
433 | }; | |
434 | ||
435 | static int __init ntc_thermistor_init(void) | |
436 | { | |
437 | return platform_driver_register(&ntc_thermistor_driver); | |
438 | } | |
439 | ||
440 | module_init(ntc_thermistor_init); | |
441 | ||
442 | static void __exit ntc_thermistor_cleanup(void) | |
443 | { | |
444 | platform_driver_unregister(&ntc_thermistor_driver); | |
445 | } | |
446 | ||
447 | module_exit(ntc_thermistor_cleanup); | |
448 | ||
449 | MODULE_DESCRIPTION("NTC Thermistor Driver"); | |
450 | MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>"); | |
451 | MODULE_LICENSE("GPL"); | |
452 | MODULE_ALIAS("platform:ntc-thermistor"); |