linux/drivers/hwmon/ntc_thermistor.c
<<
>>
Prefs
   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
  42struct ntc_compensation {
  43        int             temp_c;
  44        unsigned int    ohm;
  45};
  46
  47static const struct platform_device_id ntc_thermistor_id[] = {
  48        { "ncp15wb473", TYPE_NCPXXWB473 },
  49        { "ncp18wb473", TYPE_NCPXXWB473 },
  50        { "ncp21wb473", TYPE_NCPXXWB473 },
  51        { "ncp03wb473", TYPE_NCPXXWB473 },
  52        { "ncp15wl333", TYPE_NCPXXWL333 },
  53        { },
  54};
  55
  56/*
  57 * A compensation table should be sorted by the values of .ohm
  58 * in descending order.
  59 * The following compensation tables are from the specification of Murata NTC
  60 * Thermistors Datasheet
  61 */
  62static const struct ntc_compensation ncpXXwb473[] = {
  63        { .temp_c       = -40, .ohm     = 1747920 },
  64        { .temp_c       = -35, .ohm     = 1245428 },
  65        { .temp_c       = -30, .ohm     = 898485 },
  66        { .temp_c       = -25, .ohm     = 655802 },
  67        { .temp_c       = -20, .ohm     = 483954 },
  68        { .temp_c       = -15, .ohm     = 360850 },
  69        { .temp_c       = -10, .ohm     = 271697 },
  70        { .temp_c       = -5, .ohm      = 206463 },
  71        { .temp_c       = 0, .ohm       = 158214 },
  72        { .temp_c       = 5, .ohm       = 122259 },
  73        { .temp_c       = 10, .ohm      = 95227 },
  74        { .temp_c       = 15, .ohm      = 74730 },
  75        { .temp_c       = 20, .ohm      = 59065 },
  76        { .temp_c       = 25, .ohm      = 47000 },
  77        { .temp_c       = 30, .ohm      = 37643 },
  78        { .temp_c       = 35, .ohm      = 30334 },
  79        { .temp_c       = 40, .ohm      = 24591 },
  80        { .temp_c       = 45, .ohm      = 20048 },
  81        { .temp_c       = 50, .ohm      = 16433 },
  82        { .temp_c       = 55, .ohm      = 13539 },
  83        { .temp_c       = 60, .ohm      = 11209 },
  84        { .temp_c       = 65, .ohm      = 9328 },
  85        { .temp_c       = 70, .ohm      = 7798 },
  86        { .temp_c       = 75, .ohm      = 6544 },
  87        { .temp_c       = 80, .ohm      = 5518 },
  88        { .temp_c       = 85, .ohm      = 4674 },
  89        { .temp_c       = 90, .ohm      = 3972 },
  90        { .temp_c       = 95, .ohm      = 3388 },
  91        { .temp_c       = 100, .ohm     = 2902 },
  92        { .temp_c       = 105, .ohm     = 2494 },
  93        { .temp_c       = 110, .ohm     = 2150 },
  94        { .temp_c       = 115, .ohm     = 1860 },
  95        { .temp_c       = 120, .ohm     = 1615 },
  96        { .temp_c       = 125, .ohm     = 1406 },
  97};
  98static const struct ntc_compensation ncpXXwl333[] = {
  99        { .temp_c       = -40, .ohm     = 1610154 },
 100        { .temp_c       = -35, .ohm     = 1130850 },
 101        { .temp_c       = -30, .ohm     = 802609 },
 102        { .temp_c       = -25, .ohm     = 575385 },
 103        { .temp_c       = -20, .ohm     = 416464 },
 104        { .temp_c       = -15, .ohm     = 304219 },
 105        { .temp_c       = -10, .ohm     = 224193 },
 106        { .temp_c       = -5, .ohm      = 166623 },
 107        { .temp_c       = 0, .ohm       = 124850 },
 108        { .temp_c       = 5, .ohm       = 94287 },
 109        { .temp_c       = 10, .ohm      = 71747 },
 110        { .temp_c       = 15, .ohm      = 54996 },
 111        { .temp_c       = 20, .ohm      = 42455 },
 112        { .temp_c       = 25, .ohm      = 33000 },
 113        { .temp_c       = 30, .ohm      = 25822 },
 114        { .temp_c       = 35, .ohm      = 20335 },
 115        { .temp_c       = 40, .ohm      = 16115 },
 116        { .temp_c       = 45, .ohm      = 12849 },
 117        { .temp_c       = 50, .ohm      = 10306 },
 118        { .temp_c       = 55, .ohm      = 8314 },
 119        { .temp_c       = 60, .ohm      = 6746 },
 120        { .temp_c       = 65, .ohm      = 5503 },
 121        { .temp_c       = 70, .ohm      = 4513 },
 122        { .temp_c       = 75, .ohm      = 3721 },
 123        { .temp_c       = 80, .ohm      = 3084 },
 124        { .temp_c       = 85, .ohm      = 2569 },
 125        { .temp_c       = 90, .ohm      = 2151 },
 126        { .temp_c       = 95, .ohm      = 1809 },
 127        { .temp_c       = 100, .ohm     = 1529 },
 128        { .temp_c       = 105, .ohm     = 1299 },
 129        { .temp_c       = 110, .ohm     = 1108 },
 130        { .temp_c       = 115, .ohm     = 949 },
 131        { .temp_c       = 120, .ohm     = 817 },
 132        { .temp_c       = 125, .ohm     = 707 },
 133};
 134
 135struct ntc_data {
 136        struct device *hwmon_dev;
 137        struct ntc_thermistor_platform_data *pdata;
 138        const struct ntc_compensation *comp;
 139        struct device *dev;
 140        int n_comp;
 141        char name[PLATFORM_NAME_SIZE];
 142};
 143
 144#ifdef CONFIG_OF
 145static int ntc_adc_iio_read(struct ntc_thermistor_platform_data *pdata)
 146{
 147        struct iio_channel *channel = pdata->chan;
 148        unsigned int result;
 149        int val, ret;
 150
 151        ret = iio_read_channel_raw(channel, &val);
 152        if (ret < 0) {
 153                pr_err("read channel() error: %d\n", ret);
 154                return ret;
 155        }
 156
 157        /* unit: mV */
 158        result = pdata->pullup_uv * val;
 159        result >>= 12;
 160
 161        return result;
 162}
 163
 164static const struct of_device_id ntc_match[] = {
 165        { .compatible = "ntc,ncp15wb473",
 166                .data = &ntc_thermistor_id[TYPE_NCPXXWB473] },
 167        { .compatible = "ntc,ncp18wb473",
 168                .data = &ntc_thermistor_id[TYPE_NCPXXWB473] },
 169        { .compatible = "ntc,ncp21wb473",
 170                .data = &ntc_thermistor_id[TYPE_NCPXXWB473] },
 171        { .compatible = "ntc,ncp03wb473",
 172                .data = &ntc_thermistor_id[TYPE_NCPXXWB473] },
 173        { .compatible = "ntc,ncp15wl333",
 174                .data = &ntc_thermistor_id[TYPE_NCPXXWL333] },
 175        { },
 176};
 177MODULE_DEVICE_TABLE(of, ntc_match);
 178
 179static struct ntc_thermistor_platform_data *
 180ntc_thermistor_parse_dt(struct platform_device *pdev)
 181{
 182        struct iio_channel *chan;
 183        struct device_node *np = pdev->dev.of_node;
 184        struct ntc_thermistor_platform_data *pdata;
 185
 186        if (!np)
 187                return NULL;
 188
 189        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
 190        if (!pdata)
 191                return ERR_PTR(-ENOMEM);
 192
 193        chan = iio_channel_get(&pdev->dev, NULL);
 194        if (IS_ERR(chan))
 195                return ERR_CAST(chan);
 196
 197        if (of_property_read_u32(np, "pullup-uv", &pdata->pullup_uv))
 198                return ERR_PTR(-ENODEV);
 199        if (of_property_read_u32(np, "pullup-ohm", &pdata->pullup_ohm))
 200                return ERR_PTR(-ENODEV);
 201        if (of_property_read_u32(np, "pulldown-ohm", &pdata->pulldown_ohm))
 202                return ERR_PTR(-ENODEV);
 203
 204        if (of_find_property(np, "connected-positive", NULL))
 205                pdata->connect = NTC_CONNECTED_POSITIVE;
 206        else /* status change should be possible if not always on. */
 207                pdata->connect = NTC_CONNECTED_GROUND;
 208
 209        pdata->chan = chan;
 210        pdata->read_uv = ntc_adc_iio_read;
 211
 212        return pdata;
 213}
 214static void ntc_iio_channel_release(struct ntc_thermistor_platform_data *pdata)
 215{
 216        if (pdata->chan)
 217                iio_channel_release(pdata->chan);
 218}
 219#else
 220static struct ntc_thermistor_platform_data *
 221ntc_thermistor_parse_dt(struct platform_device *pdev)
 222{
 223        return NULL;
 224}
 225
 226static void ntc_iio_channel_release(struct ntc_thermistor_platform_data *pdata)
 227{ }
 228#endif
 229
 230static inline u64 div64_u64_safe(u64 dividend, u64 divisor)
 231{
 232        if (divisor == 0 && dividend == 0)
 233                return 0;
 234        if (divisor == 0)
 235                return UINT_MAX;
 236        return div64_u64(dividend, divisor);
 237}
 238
 239static int get_ohm_of_thermistor(struct ntc_data *data, unsigned int uv)
 240{
 241        struct ntc_thermistor_platform_data *pdata = data->pdata;
 242        u64 mv = uv / 1000;
 243        u64 pmv = pdata->pullup_uv / 1000;
 244        u64 n, puo, pdo;
 245        puo = pdata->pullup_ohm;
 246        pdo = pdata->pulldown_ohm;
 247
 248        if (mv == 0) {
 249                if (pdata->connect == NTC_CONNECTED_POSITIVE)
 250                        return INT_MAX;
 251                return 0;
 252        }
 253        if (mv >= pmv)
 254                return (pdata->connect == NTC_CONNECTED_POSITIVE) ?
 255                        0 : INT_MAX;
 256
 257        if (pdata->connect == NTC_CONNECTED_POSITIVE && puo == 0)
 258                n = div64_u64_safe(pdo * (pmv - mv), mv);
 259        else if (pdata->connect == NTC_CONNECTED_GROUND && pdo == 0)
 260                n = div64_u64_safe(puo * mv, pmv - mv);
 261        else if (pdata->connect == NTC_CONNECTED_POSITIVE)
 262                n = div64_u64_safe(pdo * puo * (pmv - mv),
 263                                puo * mv - pdo * (pmv - mv));
 264        else
 265                n = div64_u64_safe(pdo * puo * mv, pdo * (pmv - mv) - puo * mv);
 266
 267        if (n > INT_MAX)
 268                n = INT_MAX;
 269        return n;
 270}
 271
 272static void lookup_comp(struct ntc_data *data, unsigned int ohm,
 273                        int *i_low, int *i_high)
 274{
 275        int start, end, mid;
 276
 277        /*
 278         * Handle special cases: Resistance is higher than or equal to
 279         * resistance in first table entry, or resistance is lower or equal
 280         * to resistance in last table entry.
 281         * In these cases, return i_low == i_high, either pointing to the
 282         * beginning or to the end of the table depending on the condition.
 283         */
 284        if (ohm >= data->comp[0].ohm) {
 285                *i_low = 0;
 286                *i_high = 0;
 287                return;
 288        }
 289        if (ohm <= data->comp[data->n_comp - 1].ohm) {
 290                *i_low = data->n_comp - 1;
 291                *i_high = data->n_comp - 1;
 292                return;
 293        }
 294
 295        /* Do a binary search on compensation table */
 296        start = 0;
 297        end = data->n_comp;
 298        while (start < end) {
 299                mid = start + (end - start) / 2;
 300                /*
 301                 * start <= mid < end
 302                 * data->comp[start].ohm > ohm >= data->comp[end].ohm
 303                 *
 304                 * We could check for "ohm == data->comp[mid].ohm" here, but
 305                 * that is a quite unlikely condition, and we would have to
 306                 * check again after updating start. Check it at the end instead
 307                 * for simplicity.
 308                 */
 309                if (ohm >= data->comp[mid].ohm) {
 310                        end = mid;
 311                } else {
 312                        start = mid + 1;
 313                        /*
 314                         * ohm >= data->comp[start].ohm might be true here,
 315                         * since we set start to mid + 1. In that case, we are
 316                         * done. We could keep going, but the condition is quite
 317                         * likely to occur, so it is worth checking for it.
 318                         */
 319                        if (ohm >= data->comp[start].ohm)
 320                                end = start;
 321                }
 322                /*
 323                 * start <= end
 324                 * data->comp[start].ohm >= ohm >= data->comp[end].ohm
 325                 */
 326        }
 327        /*
 328         * start == end
 329         * ohm >= data->comp[end].ohm
 330         */
 331        *i_low = end;
 332        if (ohm == data->comp[end].ohm)
 333                *i_high = end;
 334        else
 335                *i_high = end - 1;
 336}
 337
 338static int get_temp_mc(struct ntc_data *data, unsigned int ohm)
 339{
 340        int low, high;
 341        int temp;
 342
 343        lookup_comp(data, ohm, &low, &high);
 344        if (low == high) {
 345                /* Unable to use linear approximation */
 346                temp = data->comp[low].temp_c * 1000;
 347        } else {
 348                temp = data->comp[low].temp_c * 1000 +
 349                        ((data->comp[high].temp_c - data->comp[low].temp_c) *
 350                         1000 * ((int)ohm - (int)data->comp[low].ohm)) /
 351                        ((int)data->comp[high].ohm - (int)data->comp[low].ohm);
 352        }
 353        return temp;
 354}
 355
 356static int ntc_thermistor_get_ohm(struct ntc_data *data)
 357{
 358        int read_uv;
 359
 360        if (data->pdata->read_ohm)
 361                return data->pdata->read_ohm();
 362
 363        if (data->pdata->read_uv) {
 364                read_uv = data->pdata->read_uv(data->pdata);
 365                if (read_uv < 0)
 366                        return read_uv;
 367                return get_ohm_of_thermistor(data, read_uv);
 368        }
 369        return -EINVAL;
 370}
 371
 372static ssize_t ntc_show_name(struct device *dev,
 373                struct device_attribute *attr, char *buf)
 374{
 375        struct ntc_data *data = dev_get_drvdata(dev);
 376
 377        return sprintf(buf, "%s\n", data->name);
 378}
 379
 380static ssize_t ntc_show_type(struct device *dev,
 381                struct device_attribute *attr, char *buf)
 382{
 383        return sprintf(buf, "4\n");
 384}
 385
 386static ssize_t ntc_show_temp(struct device *dev,
 387                struct device_attribute *attr, char *buf)
 388{
 389        struct ntc_data *data = dev_get_drvdata(dev);
 390        int ohm;
 391
 392        ohm = ntc_thermistor_get_ohm(data);
 393        if (ohm < 0)
 394                return ohm;
 395
 396        return sprintf(buf, "%d\n", get_temp_mc(data, ohm));
 397}
 398
 399static SENSOR_DEVICE_ATTR(temp1_type, S_IRUGO, ntc_show_type, NULL, 0);
 400static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, ntc_show_temp, NULL, 0);
 401static DEVICE_ATTR(name, S_IRUGO, ntc_show_name, NULL);
 402
 403static struct attribute *ntc_attributes[] = {
 404        &dev_attr_name.attr,
 405        &sensor_dev_attr_temp1_type.dev_attr.attr,
 406        &sensor_dev_attr_temp1_input.dev_attr.attr,
 407        NULL,
 408};
 409
 410static const struct attribute_group ntc_attr_group = {
 411        .attrs = ntc_attributes,
 412};
 413
 414static int ntc_thermistor_probe(struct platform_device *pdev)
 415{
 416        const struct of_device_id *of_id =
 417                        of_match_device(of_match_ptr(ntc_match), &pdev->dev);
 418        const struct platform_device_id *pdev_id;
 419        struct ntc_thermistor_platform_data *pdata;
 420        struct ntc_data *data;
 421        int ret;
 422
 423        pdata = ntc_thermistor_parse_dt(pdev);
 424        if (IS_ERR(pdata))
 425                return PTR_ERR(pdata);
 426        else if (pdata == NULL)
 427                pdata = dev_get_platdata(&pdev->dev);
 428
 429        if (!pdata) {
 430                dev_err(&pdev->dev, "No platform init data supplied.\n");
 431                return -ENODEV;
 432        }
 433
 434        /* Either one of the two is required. */
 435        if (!pdata->read_uv && !pdata->read_ohm) {
 436                dev_err(&pdev->dev,
 437                        "Both read_uv and read_ohm missing. Need either one of the two.\n");
 438                return -EINVAL;
 439        }
 440
 441        if (pdata->read_uv && pdata->read_ohm) {
 442                dev_warn(&pdev->dev,
 443                         "Only one of read_uv and read_ohm is needed; ignoring read_uv.\n");
 444                pdata->read_uv = NULL;
 445        }
 446
 447        if (pdata->read_uv && (pdata->pullup_uv == 0 ||
 448                                (pdata->pullup_ohm == 0 && pdata->connect ==
 449                                 NTC_CONNECTED_GROUND) ||
 450                                (pdata->pulldown_ohm == 0 && pdata->connect ==
 451                                 NTC_CONNECTED_POSITIVE) ||
 452                                (pdata->connect != NTC_CONNECTED_POSITIVE &&
 453                                 pdata->connect != NTC_CONNECTED_GROUND))) {
 454                dev_err(&pdev->dev,
 455                        "Required data to use read_uv not supplied.\n");
 456                return -EINVAL;
 457        }
 458
 459        data = devm_kzalloc(&pdev->dev, sizeof(struct ntc_data), GFP_KERNEL);
 460        if (!data)
 461                return -ENOMEM;
 462
 463        pdev_id = of_id ? of_id->data : platform_get_device_id(pdev);
 464
 465        data->dev = &pdev->dev;
 466        data->pdata = pdata;
 467        strlcpy(data->name, pdev_id->name, sizeof(data->name));
 468
 469        switch (pdev_id->driver_data) {
 470        case TYPE_NCPXXWB473:
 471                data->comp = ncpXXwb473;
 472                data->n_comp = ARRAY_SIZE(ncpXXwb473);
 473                break;
 474        case TYPE_NCPXXWL333:
 475                data->comp = ncpXXwl333;
 476                data->n_comp = ARRAY_SIZE(ncpXXwl333);
 477                break;
 478        default:
 479                dev_err(&pdev->dev, "Unknown device type: %lu(%s)\n",
 480                                pdev_id->driver_data, pdev_id->name);
 481                return -EINVAL;
 482        }
 483
 484        platform_set_drvdata(pdev, data);
 485
 486        ret = sysfs_create_group(&data->dev->kobj, &ntc_attr_group);
 487        if (ret) {
 488                dev_err(data->dev, "unable to create sysfs files\n");
 489                return ret;
 490        }
 491
 492        data->hwmon_dev = hwmon_device_register(data->dev);
 493        if (IS_ERR(data->hwmon_dev)) {
 494                dev_err(data->dev, "unable to register as hwmon device.\n");
 495                ret = PTR_ERR(data->hwmon_dev);
 496                goto err_after_sysfs;
 497        }
 498
 499        dev_info(&pdev->dev, "Thermistor type: %s successfully probed.\n",
 500                                                                pdev->name);
 501
 502        return 0;
 503err_after_sysfs:
 504        sysfs_remove_group(&data->dev->kobj, &ntc_attr_group);
 505        ntc_iio_channel_release(pdata);
 506        return ret;
 507}
 508
 509static int ntc_thermistor_remove(struct platform_device *pdev)
 510{
 511        struct ntc_data *data = platform_get_drvdata(pdev);
 512        struct ntc_thermistor_platform_data *pdata = data->pdata;
 513
 514        hwmon_device_unregister(data->hwmon_dev);
 515        sysfs_remove_group(&data->dev->kobj, &ntc_attr_group);
 516        ntc_iio_channel_release(pdata);
 517
 518        return 0;
 519}
 520
 521static struct platform_driver ntc_thermistor_driver = {
 522        .driver = {
 523                .name = "ntc-thermistor",
 524                .owner = THIS_MODULE,
 525                .of_match_table = of_match_ptr(ntc_match),
 526        },
 527        .probe = ntc_thermistor_probe,
 528        .remove = ntc_thermistor_remove,
 529        .id_table = ntc_thermistor_id,
 530};
 531
 532module_platform_driver(ntc_thermistor_driver);
 533
 534MODULE_DESCRIPTION("NTC Thermistor Driver");
 535MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
 536MODULE_LICENSE("GPL");
 537MODULE_ALIAS("platform:ntc-thermistor");
 538
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.