drivers/w1/slaves/w1_therm.c

   1 /*
   2  *      w1_therm.c
   3  *
   4  * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
   5  *
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the therms 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 #include <asm/types.h>
  23
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/moduleparam.h>
  27 #include <linux/sched.h>
  28 #include <linux/device.h>
  29 #include <linux/types.h>
  30 #include <linux/slab.h>
  31 #include <linux/delay.h>
  32
  33 #include "../w1.h"
  34 #include "../w1_int.h"
  35 #include "../w1_family.h"
  36
  37 MODULE_LICENSE("GPL");
  38 MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
  39 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol, temperature family.");
  40 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18S20));
  41 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1822));
  42 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18B20));
  43 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1825));
  44 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS28EA00));
  45
  46 /* Allow the strong pullup to be disabled, but default to enabled.
  47  * If it was disabled a parasite powered device might not get the require
  48  * current to do a temperature conversion.  If it is enabled parasite powered
  49  * devices have a better chance of getting the current required.
  50  * In case the parasite power-detection is not working (seems to be the case
  51  * for some DS18S20) the strong pullup can also be forced, regardless of the
  52  * power state of the devices.
  53  *
  54  * Summary of options:
  55  * - strong_pullup = 0  Disable strong pullup completely
  56  * - strong_pullup = 1  Enable automatic strong pullup detection
  57  * - strong_pullup = 2  Force strong pullup
  58  */
  59 static int w1_strong_pullup = 1;
  60 module_param_named(strong_pullup, w1_strong_pullup, int, 0);
  61
  62 struct w1_therm_family_data {
  63         uint8_t rom[9];
  64         atomic_t refcnt;
  65 };
  66
  67 /* return the address of the refcnt in the family data */
  68 #define THERM_REFCNT(family_data) \
  69         (&((struct w1_therm_family_data *)family_data)->refcnt)
  70
  71 static int w1_therm_add_slave(struct w1_slave *sl)
  72 {
  73         sl->family_data = kzalloc(sizeof(struct w1_therm_family_data),
  74                 GFP_KERNEL);
  75         if (!sl->family_data)
  76                 return -ENOMEM;
  77         atomic_set(THERM_REFCNT(sl->family_data), 1);
  78         return 0;
  79 }
  80
  81 static void w1_therm_remove_slave(struct w1_slave *sl)
  82 {
  83         int refcnt = atomic_sub_return(1, THERM_REFCNT(sl->family_data));
  84
  85         while (refcnt) {
  86                 msleep(1000);
  87                 refcnt = atomic_read(THERM_REFCNT(sl->family_data));
  88         }
  89         kfree(sl->family_data);
  90         sl->family_data = NULL;
  91 }
  92
  93 static ssize_t w1_slave_show(struct device *device,
  94         struct device_attribute *attr, char *buf);
  95
  96 static ssize_t w1_slave_store(struct device *device,
  97         struct device_attribute *attr, const char *buf, size_t size);
  98
  99 static ssize_t w1_seq_show(struct device *device,
 100         struct device_attribute *attr, char *buf);
 101
 102 static DEVICE_ATTR_RW(w1_slave);
 103 static DEVICE_ATTR_RO(w1_seq);
 104
 105 static struct attribute *w1_therm_attrs[] = {
 106         &dev_attr_w1_slave.attr,
 107         NULL,
 108 };
 109
 110 static struct attribute *w1_ds28ea00_attrs[] = {
 111         &dev_attr_w1_slave.attr,
 112         &dev_attr_w1_seq.attr,
 113         NULL,
 114 };
 115 ATTRIBUTE_GROUPS(w1_therm);
 116 ATTRIBUTE_GROUPS(w1_ds28ea00);
 117
 118 static struct w1_family_ops w1_therm_fops = {
 119         .add_slave      = w1_therm_add_slave,
 120         .remove_slave   = w1_therm_remove_slave,
 121         .groups         = w1_therm_groups,
 122 };
 123
 124 static struct w1_family_ops w1_ds28ea00_fops = {
 125         .add_slave      = w1_therm_add_slave,
 126         .remove_slave   = w1_therm_remove_slave,
 127         .groups         = w1_ds28ea00_groups,
 128 };
 129
 130 static struct w1_family w1_therm_family_DS18S20 = {
 131         .fid = W1_THERM_DS18S20,
 132         .fops = &w1_therm_fops,
 133 };
 134
 135 static struct w1_family w1_therm_family_DS18B20 = {
 136         .fid = W1_THERM_DS18B20,
 137         .fops = &w1_therm_fops,
 138 };
 139
 140 static struct w1_family w1_therm_family_DS1822 = {
 141         .fid = W1_THERM_DS1822,
 142         .fops = &w1_therm_fops,
 143 };
 144
 145 static struct w1_family w1_therm_family_DS28EA00 = {
 146         .fid = W1_THERM_DS28EA00,
 147         .fops = &w1_ds28ea00_fops,
 148 };
 149
 150 static struct w1_family w1_therm_family_DS1825 = {
 151         .fid = W1_THERM_DS1825,
 152         .fops = &w1_therm_fops,
 153 };
 154
 155 struct w1_therm_family_converter {
 156         u8                      broken;
 157         u16                     reserved;
 158         struct w1_family        *f;
 159         int                     (*convert)(u8 rom[9]);
 160         int                     (*precision)(struct device *device, int val);
 161         int                     (*eeprom)(struct device *device);
 162 };
 163
 164 /* write configuration to eeprom */
 165 static inline int w1_therm_eeprom(struct device *device);
 166
 167 /* Set precision for conversion */
 168 static inline int w1_DS18B20_precision(struct device *device, int val);
 169 static inline int w1_DS18S20_precision(struct device *device, int val);
 170
 171 /* The return value is millidegrees Centigrade. */
 172 static inline int w1_DS18B20_convert_temp(u8 rom[9]);
 173 static inline int w1_DS18S20_convert_temp(u8 rom[9]);
 174
 175 static struct w1_therm_family_converter w1_therm_families[] = {
 176         {
 177                 .f              = &w1_therm_family_DS18S20,
 178                 .convert        = w1_DS18S20_convert_temp,
 179                 .precision      = w1_DS18S20_precision,
 180                 .eeprom         = w1_therm_eeprom
 181         },
 182         {
 183                 .f              = &w1_therm_family_DS1822,
 184                 .convert        = w1_DS18B20_convert_temp,
 185                 .precision      = w1_DS18S20_precision,
 186                 .eeprom         = w1_therm_eeprom
 187         },
 188         {
 189                 .f              = &w1_therm_family_DS18B20,
 190                 .convert        = w1_DS18B20_convert_temp,
 191                 .precision      = w1_DS18B20_precision,
 192                 .eeprom         = w1_therm_eeprom
 193         },
 194         {
 195                 .f              = &w1_therm_family_DS28EA00,
 196                 .convert        = w1_DS18B20_convert_temp,
 197                 .precision      = w1_DS18S20_precision,
 198                 .eeprom         = w1_therm_eeprom
 199         },
 200         {
 201                 .f              = &w1_therm_family_DS1825,
 202                 .convert        = w1_DS18B20_convert_temp,
 203                 .precision      = w1_DS18S20_precision,
 204                 .eeprom         = w1_therm_eeprom
 205         }
 206 };
 207
 208 static inline int w1_therm_eeprom(struct device *device)
 209 {
 210         struct w1_slave *sl = dev_to_w1_slave(device);
 211         struct w1_master *dev = sl->master;
 212         u8 rom[9], external_power;
 213         int ret, max_trying = 10;
 214         u8 *family_data = sl->family_data;
 215
 216         ret = mutex_lock_interruptible(&dev->bus_mutex);
 217         if (ret != 0)
 218                 goto post_unlock;
 219
 220         if (!sl->family_data) {
 221                 ret = -ENODEV;
 222                 goto pre_unlock;
 223         }
 224
 225         /* prevent the slave from going away in sleep */
 226         atomic_inc(THERM_REFCNT(family_data));
 227         memset(rom, 0, sizeof(rom));
 228
 229         while (max_trying--) {
 230                 if (!w1_reset_select_slave(sl)) {
 231                         unsigned int tm = 10;
 232                         unsigned long sleep_rem;
 233
 234                         /* check if in parasite mode */
 235                         w1_write_8(dev, W1_READ_PSUPPLY);
 236                         external_power = w1_read_8(dev);
 237
 238                         if (w1_reset_select_slave(sl))
 239                                 continue;
 240
 241                         /* 10ms strong pullup/delay after the copy command */
 242                         if (w1_strong_pullup == 2 ||
 243                             (!external_power && w1_strong_pullup))
 244                                 w1_next_pullup(dev, tm);
 245
 246                         w1_write_8(dev, W1_COPY_SCRATCHPAD);
 247
 248                         if (external_power) {
 249                                 mutex_unlock(&dev->bus_mutex);
 250
 251                                 sleep_rem = msleep_interruptible(tm);
 252                                 if (sleep_rem != 0) {
 253                                         ret = -EINTR;
 254                                         goto post_unlock;
 255                                 }
 256
 257                                 ret = mutex_lock_interruptible(&dev->bus_mutex);
 258                                 if (ret != 0)
 259                                         goto post_unlock;
 260                         } else if (!w1_strong_pullup) {
 261                                 sleep_rem = msleep_interruptible(tm);
 262                                 if (sleep_rem != 0) {
 263                                         ret = -EINTR;
 264                                         goto pre_unlock;
 265                                 }
 266                         }
 267
 268                         break;
 269                 }
 270         }
 271
 272 pre_unlock:
 273         mutex_unlock(&dev->bus_mutex);
 274
 275 post_unlock:
 276         atomic_dec(THERM_REFCNT(family_data));
 277         return ret;
 278 }
 279
 280 /* DS18S20 does not feature configuration register */
 281 static inline int w1_DS18S20_precision(struct device *device, int val)
 282 {
 283         return 0;
 284 }
 285
 286 static inline int w1_DS18B20_precision(struct device *device, int val)
 287 {
 288         struct w1_slave *sl = dev_to_w1_slave(device);
 289         struct w1_master *dev = sl->master;
 290         u8 rom[9], crc;
 291         int ret, max_trying = 10;
 292         u8 *family_data = sl->family_data;
 293         uint8_t precision_bits;
 294         uint8_t mask = 0x60;
 295
 296         if (val > 12 || val < 9) {
 297                 pr_warn("Unsupported precision\n");
 298                 return -1;
 299         }
 300
 301         ret = mutex_lock_interruptible(&dev->bus_mutex);
 302         if (ret != 0)
 303                 goto post_unlock;
 304
 305         if (!sl->family_data) {
 306                 ret = -ENODEV;
 307                 goto pre_unlock;
 308         }
 309
 310         /* prevent the slave from going away in sleep */
 311         atomic_inc(THERM_REFCNT(family_data));
 312         memset(rom, 0, sizeof(rom));
 313
 314         /* translate precision to bitmask (see datasheet page 9) */
 315         switch (val) {
 316         case 9:
 317                 precision_bits = 0x00;
 318                 break;
 319         case 10:
 320                 precision_bits = 0x20;
 321                 break;
 322         case 11:
 323                 precision_bits = 0x40;
 324                 break;
 325         case 12:
 326         default:
 327                 precision_bits = 0x60;
 328                 break;
 329         }
 330
 331         while (max_trying--) {
 332                 crc = 0;
 333
 334                 if (!w1_reset_select_slave(sl)) {
 335                         int count = 0;
 336
 337                         /* read values to only alter precision bits */
 338                         w1_write_8(dev, W1_READ_SCRATCHPAD);
 339                         count = w1_read_block(dev, rom, 9);
 340                         if (count != 9)
 341                                 dev_warn(device, "w1_read_block() returned %u instead of 9.\n", count);
 342
 343                         crc = w1_calc_crc8(rom, 8);
 344                         if (rom[8] == crc) {
 345                                 rom[4] = (rom[4] & ~mask) | (precision_bits & mask);
 346
 347                                 if (!w1_reset_select_slave(sl)) {
 348                                         w1_write_8(dev, W1_WRITE_SCRATCHPAD);
 349                                         w1_write_8(dev, rom[2]);
 350                                         w1_write_8(dev, rom[3]);
 351                                         w1_write_8(dev, rom[4]);
 352
 353                                         break;
 354                                 }
 355                         }
 356                 }
 357         }
 358
 359 pre_unlock:
 360         mutex_unlock(&dev->bus_mutex);
 361
 362 post_unlock:
 363         atomic_dec(THERM_REFCNT(family_data));
 364         return ret;
 365 }
 366
 367 static inline int w1_DS18B20_convert_temp(u8 rom[9])
 368 {
 369         s16 t = le16_to_cpup((__le16 *)rom);
 370
 371         return t*1000/16;
 372 }
 373
 374 static inline int w1_DS18S20_convert_temp(u8 rom[9])
 375 {
 376         int t, h;
 377
 378         if (!rom[7])
 379                 return 0;
 380
 381         if (rom[1] == 0)
 382                 t = ((s32)rom[0] >> 1)*1000;
 383         else
 384                 t = 1000*(-1*(s32)(0x100-rom[0]) >> 1);
 385
 386         t -= 250;
 387         h = 1000*((s32)rom[7] - (s32)rom[6]);
 388         h /= (s32)rom[7];
 389         t += h;
 390
 391         return t;
 392 }
 393
 394 static inline int w1_convert_temp(u8 rom[9], u8 fid)
 395 {
 396         int i;
 397
 398         for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
 399                 if (w1_therm_families[i].f->fid == fid)
 400                         return w1_therm_families[i].convert(rom);
 401
 402         return 0;
 403 }
 404
 405 static ssize_t w1_slave_store(struct device *device,
 406                               struct device_attribute *attr, const char *buf,
 407                               size_t size)
 408 {
 409         int val, ret;
 410         struct w1_slave *sl = dev_to_w1_slave(device);
 411         int i;
 412
 413         ret = kstrtoint(buf, 0, &val);
 414         if (ret)
 415                 return ret;
 416
 417         for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
 418                 if (w1_therm_families[i].f->fid == sl->family->fid) {
 419                         /* zero value indicates to write current configuration to eeprom */
 420                         if (val == 0)
 421                                 ret = w1_therm_families[i].eeprom(device);
 422                         else
 423                                 ret = w1_therm_families[i].precision(device, val);
 424                         break;
 425                 }
 426         }
 427         return ret ? : size;
 428 }
 429
 430 static ssize_t w1_slave_show(struct device *device,
 431         struct device_attribute *attr, char *buf)
 432 {
 433         struct w1_slave *sl = dev_to_w1_slave(device);
 434         struct w1_master *dev = sl->master;
 435         u8 rom[9], crc, verdict, external_power;
 436         int i, ret, max_trying = 10;
 437         ssize_t c = PAGE_SIZE;
 438         u8 *family_data = sl->family_data;
 439
 440         ret = mutex_lock_interruptible(&dev->bus_mutex);
 441         if (ret != 0)
 442                 goto post_unlock;
 443
 444         if (!sl->family_data) {
 445                 ret = -ENODEV;
 446                 goto pre_unlock;
 447         }
 448
 449         /* prevent the slave from going away in sleep */
 450         atomic_inc(THERM_REFCNT(family_data));
 451         memset(rom, 0, sizeof(rom));
 452
 453         while (max_trying--) {
 454
 455                 verdict = 0;
 456                 crc = 0;
 457
 458                 if (!w1_reset_select_slave(sl)) {
 459                         int count = 0;
 460                         unsigned int tm = 750;
 461                         unsigned long sleep_rem;
 462
 463                         w1_write_8(dev, W1_READ_PSUPPLY);
 464                         external_power = w1_read_8(dev);
 465
 466                         if (w1_reset_select_slave(sl))
 467                                 continue;
 468
 469                         /* 750ms strong pullup (or delay) after the convert */
 470                         if (w1_strong_pullup == 2 ||
 471                                         (!external_power && w1_strong_pullup))
 472                                 w1_next_pullup(dev, tm);
 473
 474                         w1_write_8(dev, W1_CONVERT_TEMP);
 475
 476                         if (external_power) {
 477                                 mutex_unlock(&dev->bus_mutex);
 478
 479                                 sleep_rem = msleep_interruptible(tm);
 480                                 if (sleep_rem != 0) {
 481                                         ret = -EINTR;
 482                                         goto post_unlock;
 483                                 }
 484
 485                                 ret = mutex_lock_interruptible(&dev->bus_mutex);
 486                                 if (ret != 0)
 487                                         goto post_unlock;
 488                         } else if (!w1_strong_pullup) {
 489                                 sleep_rem = msleep_interruptible(tm);
 490                                 if (sleep_rem != 0) {
 491                                         ret = -EINTR;
 492                                         goto pre_unlock;
 493                                 }
 494                         }
 495
 496                         if (!w1_reset_select_slave(sl)) {
 497
 498                                 w1_write_8(dev, W1_READ_SCRATCHPAD);
 499                                 count = w1_read_block(dev, rom, 9);
 500                                 if (count != 9) {
 501                                         dev_warn(device, "w1_read_block() "
 502                                                 "returned %u instead of 9.\n",
 503                                                 count);
 504                                 }
 505
 506                                 crc = w1_calc_crc8(rom, 8);
 507
 508                                 if (rom[8] == crc)
 509                                         verdict = 1;
 510                         }
 511                 }
 512
 513                 if (verdict)
 514                         break;
 515         }
 516
 517         for (i = 0; i < 9; ++i)
 518                 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", rom[i]);
 519         c -= snprintf(buf + PAGE_SIZE - c, c, ": crc=%02x %s\n",
 520                       crc, (verdict) ? "YES" : "NO");
 521         if (verdict)
 522                 memcpy(family_data, rom, sizeof(rom));
 523         else
 524                 dev_warn(device, "Read failed CRC check\n");
 525
 526         for (i = 0; i < 9; ++i)
 527                 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ",
 528                               ((u8 *)family_data)[i]);
 529
 530         c -= snprintf(buf + PAGE_SIZE - c, c, "t=%d\n",
 531                 w1_convert_temp(rom, sl->family->fid));
 532         ret = PAGE_SIZE - c;
 533
 534 pre_unlock:
 535         mutex_unlock(&dev->bus_mutex);
 536
 537 post_unlock:
 538         atomic_dec(THERM_REFCNT(family_data));
 539         return ret;
 540 }
 541
 542 #define W1_42_CHAIN     0x99
 543 #define W1_42_CHAIN_OFF 0x3C
 544 #define W1_42_CHAIN_OFF_INV     0xC3
 545 #define W1_42_CHAIN_ON  0x5A
 546 #define W1_42_CHAIN_ON_INV      0xA5
 547 #define W1_42_CHAIN_DONE 0x96
 548 #define W1_42_CHAIN_DONE_INV 0x69
 549 #define W1_42_COND_READ 0x0F
 550 #define W1_42_SUCCESS_CONFIRM_BYTE 0xAA
 551 #define W1_42_FINISHED_BYTE 0xFF
 552 static ssize_t w1_seq_show(struct device *device,
 553         struct device_attribute *attr, char *buf)
 554 {
 555         struct w1_slave *sl = dev_to_w1_slave(device);
 556         ssize_t c = PAGE_SIZE;
 557         int rv;
 558         int i;
 559         u8 ack;
 560         u64 rn;
 561         struct w1_reg_num *reg_num;
 562         int seq = 0;
 563
 564         mutex_lock(&sl->master->bus_mutex);
 565         /* Place all devices in CHAIN state */
 566         if (w1_reset_bus(sl->master))
 567                 goto error;
 568         w1_write_8(sl->master, W1_SKIP_ROM);
 569         w1_write_8(sl->master, W1_42_CHAIN);
 570         w1_write_8(sl->master, W1_42_CHAIN_ON);
 571         w1_write_8(sl->master, W1_42_CHAIN_ON_INV);
 572         msleep(sl->master->pullup_duration);
 573
 574         /* check for acknowledgment */
 575         ack = w1_read_8(sl->master);
 576         if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
 577                 goto error;
 578
 579         /* In case the bus fails to send 0xFF, limit*/
 580         for (i = 0; i <= 64; i++) {
 581                 if (w1_reset_bus(sl->master))
 582                         goto error;
 583
 584                 w1_write_8(sl->master, W1_42_COND_READ);
 585                 rv = w1_read_block(sl->master, (u8 *)&rn, 8);
 586                 reg_num = (struct w1_reg_num *) &rn;
 587                 if (reg_num->family == W1_42_FINISHED_BYTE)
 588                         break;
 589                 if (sl->reg_num.id == reg_num->id)
 590                         seq = i;
 591
 592                 w1_write_8(sl->master, W1_42_CHAIN);
 593                 w1_write_8(sl->master, W1_42_CHAIN_DONE);
 594                 w1_write_8(sl->master, W1_42_CHAIN_DONE_INV);
 595                 w1_read_block(sl->master, &ack, sizeof(ack));
 596
 597                 /* check for acknowledgment */
 598                 ack = w1_read_8(sl->master);
 599                 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
 600                         goto error;
 601
 602         }
 603
 604         /* Exit from CHAIN state */
 605         if (w1_reset_bus(sl->master))
 606                 goto error;
 607         w1_write_8(sl->master, W1_SKIP_ROM);
 608         w1_write_8(sl->master, W1_42_CHAIN);
 609         w1_write_8(sl->master, W1_42_CHAIN_OFF);
 610         w1_write_8(sl->master, W1_42_CHAIN_OFF_INV);
 611
 612         /* check for acknowledgment */
 613         ack = w1_read_8(sl->master);
 614         if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
 615                 goto error;
 616         mutex_unlock(&sl->master->bus_mutex);
 617
 618         c -= snprintf(buf + PAGE_SIZE - c, c, "%d\n", seq);
 619         return PAGE_SIZE - c;
 620 error:
 621         mutex_unlock(&sl->master->bus_mutex);
 622         return -EIO;
 623 }
 624
 625 static int __init w1_therm_init(void)
 626 {
 627         int err, i;
 628
 629         for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
 630                 err = w1_register_family(w1_therm_families[i].f);
 631                 if (err)
 632                         w1_therm_families[i].broken = 1;
 633         }
 634
 635         return 0;
 636 }
 637
 638 static void __exit w1_therm_fini(void)
 639 {
 640         int i;
 641
 642         for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
 643                 if (!w1_therm_families[i].broken)
 644                         w1_unregister_family(w1_therm_families[i].f);
 645 }
 646
 647 module_init(w1_therm_init);
 648 module_exit(w1_therm_fini);