Pileus Git - ~andy/linux/blob - 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/delay.h>
  31
  32 #include "../w1.h"
  33 #include "../w1_int.h"
  34 #include "../w1_family.h"
  35
  36 MODULE_LICENSE("GPL");
  37 MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
  38 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol, temperature family.");
  39 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18S20));
  40 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1822));
  41 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18B20));
  42 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1825));
  43 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS28EA00));
  44
  45 /* Allow the strong pullup to be disabled, but default to enabled.
  46  * If it was disabled a parasite powered device might not get the require
  47  * current to do a temperature conversion.  If it is enabled parasite powered
  48  * devices have a better chance of getting the current required.
  49  * In case the parasite power-detection is not working (seems to be the case
  50  * for some DS18S20) the strong pullup can also be forced, regardless of the
  51  * power state of the devices.
  52  *
  53  * Summary of options:
  54  * - strong_pullup = 0  Disable strong pullup completely
  55  * - strong_pullup = 1  Enable automatic strong pullup detection
  56  * - strong_pullup = 2  Force strong pullup
  57  */
  58 static int w1_strong_pullup = 1;
  59 module_param_named(strong_pullup, w1_strong_pullup, int, 0);
  60
  61
  62 static ssize_t w1_therm_read(struct device *device,
  63         struct device_attribute *attr, char *buf);
  64
  65 static struct device_attribute w1_therm_attr =
  66         __ATTR(w1_slave, S_IRUGO, w1_therm_read, NULL);
  67
  68 static int w1_therm_add_slave(struct w1_slave *sl)
  69 {
  70         return device_create_file(&sl->dev, &w1_therm_attr);
  71 }
  72
  73 static void w1_therm_remove_slave(struct w1_slave *sl)
  74 {
  75         device_remove_file(&sl->dev, &w1_therm_attr);
  76 }
  77
  78 static struct w1_family_ops w1_therm_fops = {
  79         .add_slave      = w1_therm_add_slave,
  80         .remove_slave   = w1_therm_remove_slave,
  81 };
  82
  83 static struct w1_family w1_therm_family_DS18S20 = {
  84         .fid = W1_THERM_DS18S20,
  85         .fops = &w1_therm_fops,
  86 };
  87
  88 static struct w1_family w1_therm_family_DS18B20 = {
  89         .fid = W1_THERM_DS18B20,
  90         .fops = &w1_therm_fops,
  91 };
  92
  93 static struct w1_family w1_therm_family_DS1822 = {
  94         .fid = W1_THERM_DS1822,
  95         .fops = &w1_therm_fops,
  96 };
  97
  98 static struct w1_family w1_therm_family_DS28EA00 = {
  99         .fid = W1_THERM_DS28EA00,
 100         .fops = &w1_therm_fops,
 101 };
 102
 103 static struct w1_family w1_therm_family_DS1825 = {
 104         .fid = W1_THERM_DS1825,
 105         .fops = &w1_therm_fops,
 106 };
 107
 108 struct w1_therm_family_converter
 109 {
 110         u8                      broken;
 111         u16                     reserved;
 112         struct w1_family        *f;
 113         int                     (*convert)(u8 rom[9]);
 114 };
 115
 116 /* The return value is millidegrees Centigrade. */
 117 static inline int w1_DS18B20_convert_temp(u8 rom[9]);
 118 static inline int w1_DS18S20_convert_temp(u8 rom[9]);
 119
 120 static struct w1_therm_family_converter w1_therm_families[] = {
 121         {
 122                 .f              = &w1_therm_family_DS18S20,
 123                 .convert        = w1_DS18S20_convert_temp
 124         },
 125         {
 126                 .f              = &w1_therm_family_DS1822,
 127                 .convert        = w1_DS18B20_convert_temp
 128         },
 129         {
 130                 .f              = &w1_therm_family_DS18B20,
 131                 .convert        = w1_DS18B20_convert_temp
 132         },
 133         {
 134                 .f              = &w1_therm_family_DS28EA00,
 135                 .convert        = w1_DS18B20_convert_temp
 136         },
 137         {
 138                 .f              = &w1_therm_family_DS1825,
 139                 .convert        = w1_DS18B20_convert_temp
 140         }
 141 };
 142
 143 static inline int w1_DS18B20_convert_temp(u8 rom[9])
 144 {
 145         s16 t = le16_to_cpup((__le16 *)rom);
 146         return t*1000/16;
 147 }
 148
 149 static inline int w1_DS18S20_convert_temp(u8 rom[9])
 150 {
 151         int t, h;
 152
 153         if (!rom[7])
 154                 return 0;
 155
 156         if (rom[1] == 0)
 157                 t = ((s32)rom[0] >> 1)*1000;
 158         else
 159                 t = 1000*(-1*(s32)(0x100-rom[0]) >> 1);
 160
 161         t -= 250;
 162         h = 1000*((s32)rom[7] - (s32)rom[6]);
 163         h /= (s32)rom[7];
 164         t += h;
 165
 166         return t;
 167 }
 168
 169 static inline int w1_convert_temp(u8 rom[9], u8 fid)
 170 {
 171         int i;
 172
 173         for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
 174                 if (w1_therm_families[i].f->fid == fid)
 175                         return w1_therm_families[i].convert(rom);
 176
 177         return 0;
 178 }
 179
 180
 181 static ssize_t w1_therm_read(struct device *device,
 182         struct device_attribute *attr, char *buf)
 183 {
 184         struct w1_slave *sl = dev_to_w1_slave(device);
 185         struct w1_master *dev = sl->master;
 186         u8 rom[9], crc, verdict, external_power;
 187         int i, max_trying = 10;
 188         ssize_t c = PAGE_SIZE;
 189
 190         i = mutex_lock_interruptible(&dev->bus_mutex);
 191         if (i != 0)
 192                 return i;
 193
 194         memset(rom, 0, sizeof(rom));
 195
 196         while (max_trying--) {
 197
 198                 verdict = 0;
 199                 crc = 0;
 200
 201                 if (!w1_reset_select_slave(sl)) {
 202                         int count = 0;
 203                         unsigned int tm = 750;
 204                         unsigned long sleep_rem;
 205
 206                         w1_write_8(dev, W1_READ_PSUPPLY);
 207                         external_power = w1_read_8(dev);
 208
 209                         if (w1_reset_select_slave(sl))
 210                                 continue;
 211
 212                         /* 750ms strong pullup (or delay) after the convert */
 213                         if (w1_strong_pullup == 2 ||
 214                                         (!external_power && w1_strong_pullup))
 215                                 w1_next_pullup(dev, tm);
 216
 217                         w1_write_8(dev, W1_CONVERT_TEMP);
 218
 219                         if (external_power) {
 220                                 mutex_unlock(&dev->bus_mutex);
 221
 222                                 sleep_rem = msleep_interruptible(tm);
 223                                 if (sleep_rem != 0)
 224                                         return -EINTR;
 225
 226                                 i = mutex_lock_interruptible(&dev->bus_mutex);
 227                                 if (i != 0)
 228                                         return i;
 229                         } else if (!w1_strong_pullup) {
 230                                 sleep_rem = msleep_interruptible(tm);
 231                                 if (sleep_rem != 0) {
 232                                         mutex_unlock(&dev->bus_mutex);
 233                                         return -EINTR;
 234                                 }
 235                         }
 236
 237                         if (!w1_reset_select_slave(sl)) {
 238
 239                                 w1_write_8(dev, W1_READ_SCRATCHPAD);
 240                                 if ((count = w1_read_block(dev, rom, 9)) != 9) {
 241                                         dev_warn(device, "w1_read_block() "
 242                                                 "returned %u instead of 9.\n",
 243                                                 count);
 244                                 }
 245
 246                                 crc = w1_calc_crc8(rom, 8);
 247
 248                                 if (rom[8] == crc)
 249                                         verdict = 1;
 250                         }
 251                 }
 252
 253                 if (verdict)
 254                         break;
 255         }
 256
 257         for (i = 0; i < 9; ++i)
 258                 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", rom[i]);
 259         c -= snprintf(buf + PAGE_SIZE - c, c, ": crc=%02x %s\n",
 260                            crc, (verdict) ? "YES" : "NO");
 261         if (verdict)
 262                 memcpy(sl->rom, rom, sizeof(sl->rom));
 263         else
 264                 dev_warn(device, "Read failed CRC check\n");
 265
 266         for (i = 0; i < 9; ++i)
 267                 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", sl->rom[i]);
 268
 269         c -= snprintf(buf + PAGE_SIZE - c, c, "t=%d\n",
 270                 w1_convert_temp(rom, sl->family->fid));
 271         mutex_unlock(&dev->bus_mutex);
 272
 273         return PAGE_SIZE - c;
 274 }
 275
 276 static int __init w1_therm_init(void)
 277 {
 278         int err, i;
 279
 280         for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
 281                 err = w1_register_family(w1_therm_families[i].f);
 282                 if (err)
 283                         w1_therm_families[i].broken = 1;
 284         }
 285
 286         return 0;
 287 }
 288
 289 static void __exit w1_therm_fini(void)
 290 {
 291         int i;
 292
 293         for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
 294                 if (!w1_therm_families[i].broken)
 295                         w1_unregister_family(w1_therm_families[i].f);
 296 }
 297
 298 module_init(w1_therm_init);
 299 module_exit(w1_therm_fini);