sys/dev/iicbus/lm75.c

   1 /*-
   2  * Copyright (c) 2010 Andreas Tobler.
   3  * Copyright (c) 2013-2014 Luiz Otavio O Souza <loos@freebsd.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  20  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  21  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  22  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  23  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include "opt_platform.h"
  32
  33 #include <sys/param.h>
  34 #include <sys/bus.h>
  35 #include <sys/endian.h>
  36 #include <sys/kernel.h>
  37 #include <sys/module.h>
  38 #include <sys/sysctl.h>
  39 #include <sys/systm.h>
  40
  41 #include <machine/bus.h>
  42
  43 #include <dev/iicbus/iicbus.h>
  44 #include <dev/iicbus/iiconf.h>
  45
  46 #ifdef FDT
  47 #include <dev/ofw/openfirm.h>
  48 #include <dev/ofw/ofw_bus.h>
  49 #include <dev/ofw/ofw_bus_subr.h>
  50 #endif
  51
  52 /* LM75 registers. */
  53 #define LM75_TEMP       0x0
  54 #define LM75_TEMP_MASK          0xff80
  55 #define LM75A_TEMP_MASK         0xffe0
  56 #define LM75_CONF       0x1
  57 #define LM75_CONF_FSHIFT        3
  58 #define LM75_CONF_FAULT         0x18
  59 #define LM75_CONF_POL           0x04
  60 #define LM75_CONF_MODE          0x02
  61 #define LM75_CONF_SHUTD         0x01
  62 #define LM75_CONF_MASK          0x1f
  63 #define LM75_THYST      0x2
  64 #define LM75_TOS        0x3
  65
  66 /* LM75 constants. */
  67 #define LM75_TEST_PATTERN       0xa
  68 #define LM75_MIN_TEMP           -55
  69 #define LM75_MAX_TEMP           125
  70 #define LM75_0500C              0x80
  71 #define LM75_0250C              0x40
  72 #define LM75_0125C              0x20
  73 #define LM75_MSB                0x8000
  74 #define LM75_NEG_BIT            LM75_MSB
  75 #define TZ_ZEROC                2731
  76
  77 /* LM75 supported models. */
  78 #define HWTYPE_LM75             1
  79 #define HWTYPE_LM75A            2
  80
  81 /* Regular bus attachment functions */
  82 static int  lm75_probe(device_t);
  83 static int  lm75_attach(device_t);
  84
  85 struct lm75_softc {
  86         device_t                sc_dev;
  87         struct intr_config_hook enum_hook;
  88         int32_t                 sc_hwtype;
  89         uint32_t                sc_addr;
  90         uint32_t                sc_conf;
  91 };
  92
  93 /* Utility functions */
  94 static int  lm75_conf_read(struct lm75_softc *);
  95 static int  lm75_conf_write(struct lm75_softc *);
  96 static int  lm75_temp_read(struct lm75_softc *, uint8_t, int *);
  97 static int  lm75_temp_write(struct lm75_softc *, uint8_t, int);
  98 static void lm75_start(void *);
  99 static int  lm75_read(device_t, uint32_t, uint8_t, uint8_t *, size_t);
 100 static int  lm75_write(device_t, uint32_t, uint8_t *, size_t);
 101 static int  lm75_str_mode(char *);
 102 static int  lm75_str_pol(char *);
 103 static int  lm75_temp_sysctl(SYSCTL_HANDLER_ARGS);
 104 static int  lm75_faults_sysctl(SYSCTL_HANDLER_ARGS);
 105 static int  lm75_mode_sysctl(SYSCTL_HANDLER_ARGS);
 106 static int  lm75_pol_sysctl(SYSCTL_HANDLER_ARGS);
 107 static int  lm75_shutdown_sysctl(SYSCTL_HANDLER_ARGS);
 108
 109 static device_method_t  lm75_methods[] = {
 110         /* Device interface */
 111         DEVMETHOD(device_probe,         lm75_probe),
 112         DEVMETHOD(device_attach,        lm75_attach),
 113
 114         DEVMETHOD_END
 115 };
 116
 117 static driver_t lm75_driver = {
 118         "lm75",
 119         lm75_methods,
 120         sizeof(struct lm75_softc)
 121 };
 122
 123 static devclass_t lm75_devclass;
 124
 125 DRIVER_MODULE(lm75, iicbus, lm75_driver, lm75_devclass, 0, 0);
 126
 127 static int
 128 lm75_read(device_t dev, uint32_t addr, uint8_t reg, uint8_t *data, size_t len)
 129 {
 130         struct iic_msg msg[2] = {
 131             { addr, IIC_M_WR | IIC_M_NOSTOP, 1, &reg },
 132             { addr, IIC_M_RD, len, data },
 133         };
 134
 135         if (iicbus_transfer(dev, msg, nitems(msg)) != 0)
 136                 return (-1);
 137
 138         return (0);
 139 }
 140
 141 static int
 142 lm75_write(device_t dev, uint32_t addr, uint8_t *data, size_t len)
 143 {
 144         struct iic_msg msg[1] = {
 145             { addr, IIC_M_WR, len, data },
 146         };
 147
 148         if (iicbus_transfer(dev, msg, nitems(msg)) != 0)
 149                 return (-1);
 150
 151         return (0);
 152 }
 153
 154 static int
 155 lm75_probe(device_t dev)
 156 {
 157         struct lm75_softc *sc;
 158
 159         sc = device_get_softc(dev);
 160         sc->sc_hwtype = HWTYPE_LM75;
 161 #ifdef FDT
 162         if (!ofw_bus_is_compatible(dev, "national,lm75"))
 163                 return (ENXIO);
 164 #endif
 165         device_set_desc(dev, "LM75 temperature sensor");
 166
 167         return (BUS_PROBE_GENERIC);
 168 }
 169
 170 static int
 171 lm75_attach(device_t dev)
 172 {
 173         struct lm75_softc *sc;
 174
 175         sc = device_get_softc(dev);
 176         sc->sc_dev = dev;
 177         sc->sc_addr = iicbus_get_addr(dev);
 178
 179         sc->enum_hook.ich_func = lm75_start;
 180         sc->enum_hook.ich_arg = dev;
 181
 182         /*
 183          * We have to wait until interrupts are enabled.  Usually I2C read
 184          * and write only works when the interrupts are available.
 185          */
 186         if (config_intrhook_establish(&sc->enum_hook) != 0)
 187                 return (ENOMEM);
 188
 189         return (0);
 190 }
 191
 192 static int
 193 lm75_type_detect(struct lm75_softc *sc)
 194 {
 195         int i, lm75a;
 196         uint8_t buf8;
 197         uint32_t conf;
 198
 199         /* Save the contents of the configuration register. */
 200         if (lm75_conf_read(sc) != 0)
 201                 return (-1);
 202         conf = sc->sc_conf;
 203
 204         /*
 205          * Just write some pattern at configuration register so we can later
 206          * verify.  The test pattern should be pretty harmless.
 207          */
 208         sc->sc_conf = LM75_TEST_PATTERN;
 209         if (lm75_conf_write(sc) != 0)
 210                 return (-1);
 211
 212         /*
 213          * Read the configuration register again and check for our test
 214          * pattern.
 215          */
 216         if (lm75_conf_read(sc) != 0)
 217                 return (-1);
 218         if (sc->sc_conf != LM75_TEST_PATTERN)
 219                 return (-1);
 220
 221         /*
 222          * Read from nonexistent registers (0x4 ~ 0x6).
 223          * LM75A always return 0xff for nonexistent registers.
 224          * LM75 will return the last read value - our test pattern written to
 225          * configuration register.
 226          */
 227         lm75a = 0;
 228         for (i = 4; i <= 6; i++) {
 229                 if (lm75_read(sc->sc_dev, sc->sc_addr, i,
 230                     &buf8, sizeof(buf8)) < 0)
 231                         return (-1);
 232                 if (buf8 != LM75_TEST_PATTERN && buf8 != 0xff)
 233                         return (-1);
 234                 if (buf8 == 0xff)
 235                         lm75a++;
 236         }
 237         if (lm75a == 3)
 238                 sc->sc_hwtype = HWTYPE_LM75A;
 239
 240         /* Restore the configuration register. */
 241         sc->sc_conf = conf;
 242         if (lm75_conf_write(sc) != 0)
 243                 return (-1);
 244
 245         return (0);
 246 }
 247
 248 static void
 249 lm75_start(void *xdev)
 250 {
 251         device_t dev;
 252         struct lm75_softc *sc;
 253         struct sysctl_ctx_list *ctx;
 254         struct sysctl_oid *tree_node;
 255         struct sysctl_oid_list *tree;
 256
 257         dev = (device_t)xdev;
 258         sc = device_get_softc(dev);
 259         ctx = device_get_sysctl_ctx(dev);
 260         tree_node = device_get_sysctl_tree(dev);
 261         tree = SYSCTL_CHILDREN(tree_node);
 262
 263         config_intrhook_disestablish(&sc->enum_hook);
 264
 265         /*
 266          * Detect the kind of chip we are attaching to.
 267          * This may not work for LM75 clones.
 268          */
 269         if (lm75_type_detect(sc) != 0) {
 270                 device_printf(dev, "cannot read from sensor.\n");
 271                 return;
 272         }
 273         if (sc->sc_hwtype == HWTYPE_LM75A)
 274                 device_printf(dev,
 275                     "LM75A type sensor detected (11bits resolution).\n");
 276
 277         /* Temperature. */
 278         SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "temperature",
 279             CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE, dev, LM75_TEMP,
 280             lm75_temp_sysctl, "IK", "Current temperature");
 281         SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "thyst",
 282             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, dev, LM75_THYST,
 283             lm75_temp_sysctl, "IK", "Hysteresis temperature");
 284         SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "tos",
 285             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, dev, LM75_TOS,
 286             lm75_temp_sysctl, "IK", "Overtemperature");
 287
 288         /* Configuration parameters. */
 289         SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "faults",
 290             CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_MPSAFE, dev, 0,
 291             lm75_faults_sysctl, "IU", "LM75 fault queue");
 292         SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "mode",
 293             CTLFLAG_RW | CTLTYPE_STRING | CTLFLAG_MPSAFE, dev, 0,
 294             lm75_mode_sysctl, "A", "LM75 mode");
 295         SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "polarity",
 296             CTLFLAG_RW | CTLTYPE_STRING | CTLFLAG_MPSAFE, dev, 0,
 297             lm75_pol_sysctl, "A", "LM75 OS polarity");
 298         SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "shutdown",
 299             CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_MPSAFE, dev, 0,
 300             lm75_shutdown_sysctl, "IU", "LM75 shutdown");
 301 }
 302
 303 static int
 304 lm75_conf_read(struct lm75_softc *sc)
 305 {
 306         uint8_t buf8;
 307
 308         if (lm75_read(sc->sc_dev, sc->sc_addr, LM75_CONF,
 309             &buf8, sizeof(buf8)) < 0)
 310                 return (-1);
 311         sc->sc_conf = (uint32_t)buf8;
 312
 313         return (0);
 314 }
 315
 316 static int
 317 lm75_conf_write(struct lm75_softc *sc)
 318 {
 319         uint8_t buf8[2];
 320
 321         buf8[0] = LM75_CONF;
 322         buf8[1] = (uint8_t)sc->sc_conf & LM75_CONF_MASK;
 323         if (lm75_write(sc->sc_dev, sc->sc_addr, buf8, sizeof(buf8)) < 0)
 324                 return (-1);
 325
 326         return (0);
 327 }
 328
 329 static int
 330 lm75_temp_read(struct lm75_softc *sc, uint8_t reg, int *temp)
 331 {
 332         uint8_t buf8[2];
 333         uint16_t buf;
 334         int neg, t;
 335
 336         if (lm75_read(sc->sc_dev, sc->sc_addr, reg, buf8, sizeof(buf8)) < 0)
 337                 return (-1);
 338         buf = (uint16_t)((buf8[0] << 8) | (buf8[1] & 0xff));
 339         /*
 340          * LM75 has a 9 bit ADC with resolution of 0.5 C per bit.
 341          * LM75A has an 11 bit ADC with resolution of 0.125 C per bit.
 342          * Temperature is stored with two's complement.
 343          */
 344         neg = 0;
 345         if (buf & LM75_NEG_BIT) {
 346                 if (sc->sc_hwtype == HWTYPE_LM75A)
 347                         buf = ~(buf & LM75A_TEMP_MASK) + 1;
 348                 else
 349                         buf = ~(buf & LM75_TEMP_MASK) + 1;
 350                 neg = 1;
 351         }
 352         *temp = ((int16_t)buf >> 8) * 10;
 353         t = 0;
 354         if (sc->sc_hwtype == HWTYPE_LM75A) {
 355                 if (buf & LM75_0125C)
 356                         t += 125;
 357                 if (buf & LM75_0250C)
 358                         t += 250;
 359         }
 360         if (buf & LM75_0500C)
 361                 t += 500;
 362         t /= 100;
 363         *temp += t;
 364         if (neg)
 365                 *temp = -(*temp);
 366         *temp += TZ_ZEROC;
 367
 368         return (0);
 369 }
 370
 371 static int
 372 lm75_temp_write(struct lm75_softc *sc, uint8_t reg, int temp)
 373 {
 374         uint8_t buf8[3];
 375         uint16_t buf;
 376
 377         temp = (temp - TZ_ZEROC) / 10;
 378         if (temp > LM75_MAX_TEMP)
 379                 temp = LM75_MAX_TEMP;
 380         if (temp < LM75_MIN_TEMP)
 381                 temp = LM75_MIN_TEMP;
 382
 383         buf = (uint16_t)temp;
 384         buf <<= 8;
 385
 386         buf8[0] = reg;
 387         buf8[1] = buf >> 8;
 388         buf8[2] = buf & 0xff;
 389         if (lm75_write(sc->sc_dev, sc->sc_addr, buf8, sizeof(buf8)) < 0)
 390                 return (-1);
 391
 392         return (0);
 393 }
 394
 395 static int
 396 lm75_str_mode(char *buf)
 397 {
 398         int len, rtrn;
 399
 400         rtrn = -1;
 401         len = strlen(buf);
 402         if (len > 2 && strncasecmp("interrupt", buf, len) == 0)
 403                 rtrn = 1;
 404         else if (len > 2 && strncasecmp("comparator", buf, len) == 0)
 405                 rtrn = 0;
 406
 407         return (rtrn);
 408 }
 409
 410 static int
 411 lm75_str_pol(char *buf)
 412 {
 413         int len, rtrn;
 414
 415         rtrn = -1;
 416         len = strlen(buf);
 417         if (len > 1 && strncasecmp("high", buf, len) == 0)
 418                 rtrn = 1;
 419         else if (len > 1 && strncasecmp("low", buf, len) == 0)
 420                 rtrn = 0;
 421         else if (len > 8 && strncasecmp("active-high", buf, len) == 0)
 422                 rtrn = 1;
 423         else if (len > 8 && strncasecmp("active-low", buf, len) == 0)
 424                 rtrn = 0;
 425
 426         return (rtrn);
 427 }
 428
 429 static int
 430 lm75_temp_sysctl(SYSCTL_HANDLER_ARGS)
 431 {
 432         device_t dev;
 433         int error, temp;
 434         struct lm75_softc *sc;
 435         uint8_t reg;
 436
 437         dev = (device_t)arg1;
 438         reg = (uint8_t)arg2;
 439         sc = device_get_softc(dev);
 440
 441         if (lm75_temp_read(sc, reg, &temp) != 0)
 442                 return (EIO);
 443
 444         error = sysctl_handle_int(oidp, &temp, 0, req);
 445         if (error != 0 || req->newptr == NULL)
 446                 return (error);
 447
 448         if (lm75_temp_write(sc, reg, temp) != 0)
 449                 return (EIO);
 450
 451         return (error);
 452 }
 453
 454 static int
 455 lm75_faults_sysctl(SYSCTL_HANDLER_ARGS)
 456 {
 457         device_t dev;
 458         int lm75_faults[] = { 1, 2, 4, 6 };
 459         int error, faults, i, newf, tmp;
 460         struct lm75_softc *sc;
 461
 462         dev = (device_t)arg1;
 463         sc = device_get_softc(dev);
 464         tmp = (sc->sc_conf & LM75_CONF_FAULT) >> LM75_CONF_FSHIFT;
 465         if (tmp >= nitems(lm75_faults))
 466                 tmp = nitems(lm75_faults) - 1;
 467         faults = lm75_faults[tmp];
 468
 469         error = sysctl_handle_int(oidp, &faults, 0, req);
 470         if (error != 0 || req->newptr == NULL)
 471                 return (error);
 472
 473         if (faults != lm75_faults[tmp]) {
 474                 newf = 0;
 475                 for (i = 0; i < nitems(lm75_faults); i++)
 476                         if (faults >= lm75_faults[i])
 477                                 newf = i;
 478                 sc->sc_conf &= ~LM75_CONF_FAULT;
 479                 sc->sc_conf |= newf << LM75_CONF_FSHIFT;
 480                 if (lm75_conf_write(sc) != 0)
 481                         return (EIO);
 482         }
 483
 484         return (error);
 485 }
 486
 487 static int
 488 lm75_mode_sysctl(SYSCTL_HANDLER_ARGS)
 489 {
 490         char buf[16];
 491         device_t dev;
 492         int error, mode, newm;
 493         struct lm75_softc *sc;
 494
 495         dev = (device_t)arg1;
 496         sc = device_get_softc(dev);
 497         if (sc->sc_conf & LM75_CONF_MODE) {
 498                 mode = 1;
 499                 strlcpy(buf, "interrupt", sizeof(buf));
 500         } else {
 501                 mode = 0;
 502                 strlcpy(buf, "comparator", sizeof(buf));
 503         }
 504
 505         error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
 506         if (error != 0 || req->newptr == NULL)
 507                 return (error);
 508
 509         newm = lm75_str_mode(buf);
 510         if (newm != -1 && mode != newm) {
 511                 sc->sc_conf &= ~LM75_CONF_MODE;
 512                 if (newm == 1)
 513                         sc->sc_conf |= LM75_CONF_MODE;
 514                 if (lm75_conf_write(sc) != 0)
 515                         return (EIO);
 516         }
 517
 518         return (error);
 519 }
 520
 521 static int
 522 lm75_pol_sysctl(SYSCTL_HANDLER_ARGS)
 523 {
 524         char buf[16];
 525         device_t dev;
 526         int error, newp, pol;
 527         struct lm75_softc *sc;
 528
 529         dev = (device_t)arg1;
 530         sc = device_get_softc(dev);
 531         if (sc->sc_conf & LM75_CONF_POL) {
 532                 pol = 1;
 533                 strlcpy(buf, "active-high", sizeof(buf));
 534         } else {
 535                 pol = 0;
 536                 strlcpy(buf, "active-low", sizeof(buf));
 537         }
 538
 539         error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
 540         if (error != 0 || req->newptr == NULL)
 541                 return (error);
 542
 543         newp = lm75_str_pol(buf);
 544         if (newp != -1 && pol != newp) {
 545                 sc->sc_conf &= ~LM75_CONF_POL;
 546                 if (newp == 1)
 547                         sc->sc_conf |= LM75_CONF_POL;
 548                 if (lm75_conf_write(sc) != 0)
 549                         return (EIO);
 550         }
 551
 552         return (error);
 553 }
 554
 555 static int
 556 lm75_shutdown_sysctl(SYSCTL_HANDLER_ARGS)
 557 {
 558         device_t dev;
 559         int error, shutdown, tmp;
 560         struct lm75_softc *sc;
 561
 562         dev = (device_t)arg1;
 563         sc = device_get_softc(dev);
 564         tmp = shutdown = (sc->sc_conf & LM75_CONF_SHUTD) ? 1 : 0;
 565
 566         error = sysctl_handle_int(oidp, &shutdown, 0, req);
 567         if (error != 0 || req->newptr == NULL)
 568                 return (error);
 569
 570         if (shutdown != tmp) {
 571                 sc->sc_conf &= ~LM75_CONF_SHUTD;
 572                 if (shutdown)
 573                         sc->sc_conf |= LM75_CONF_SHUTD;
 574                 if (lm75_conf_write(sc) != 0)
 575                         return (EIO);
 576         }
 577
 578         return (error);
 579 }