w1_therm.c 7.3 KB

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