tmp108.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /* Texas Instruments TMP108 SMBus temperature sensor driver
  3. *
  4. * Copyright (C) 2016 John Muir <[email protected]>
  5. */
  6. #include <linux/delay.h>
  7. #include <linux/device.h>
  8. #include <linux/err.h>
  9. #include <linux/hwmon.h>
  10. #include <linux/hwmon-sysfs.h>
  11. #include <linux/module.h>
  12. #include <linux/mutex.h>
  13. #include <linux/of.h>
  14. #include <linux/i2c.h>
  15. #include <linux/init.h>
  16. #include <linux/jiffies.h>
  17. #include <linux/regmap.h>
  18. #include <linux/slab.h>
  19. #define DRIVER_NAME "tmp108"
  20. #define TMP108_REG_TEMP 0x00
  21. #define TMP108_REG_CONF 0x01
  22. #define TMP108_REG_TLOW 0x02
  23. #define TMP108_REG_THIGH 0x03
  24. #define TMP108_TEMP_MIN_MC -50000 /* Minimum millicelcius. */
  25. #define TMP108_TEMP_MAX_MC 127937 /* Maximum millicelcius. */
  26. /* Configuration register bits.
  27. * Note: these bit definitions are byte swapped.
  28. */
  29. #define TMP108_CONF_M0 0x0100 /* Sensor mode. */
  30. #define TMP108_CONF_M1 0x0200
  31. #define TMP108_CONF_TM 0x0400 /* Thermostat mode. */
  32. #define TMP108_CONF_FL 0x0800 /* Watchdog flag - TLOW */
  33. #define TMP108_CONF_FH 0x1000 /* Watchdog flag - THIGH */
  34. #define TMP108_CONF_CR0 0x2000 /* Conversion rate. */
  35. #define TMP108_CONF_CR1 0x4000
  36. #define TMP108_CONF_ID 0x8000
  37. #define TMP108_CONF_HYS0 0x0010 /* Hysteresis. */
  38. #define TMP108_CONF_HYS1 0x0020
  39. #define TMP108_CONF_POL 0x0080 /* Polarity of alert. */
  40. /* Defaults set by the hardware upon reset. */
  41. #define TMP108_CONF_DEFAULTS (TMP108_CONF_CR0 | TMP108_CONF_TM |\
  42. TMP108_CONF_HYS0 | TMP108_CONF_M1)
  43. /* These bits are read-only. */
  44. #define TMP108_CONF_READ_ONLY (TMP108_CONF_FL | TMP108_CONF_FH |\
  45. TMP108_CONF_ID)
  46. #define TMP108_CONF_MODE_MASK (TMP108_CONF_M0|TMP108_CONF_M1)
  47. #define TMP108_MODE_SHUTDOWN 0x0000
  48. #define TMP108_MODE_ONE_SHOT TMP108_CONF_M0
  49. #define TMP108_MODE_CONTINUOUS TMP108_CONF_M1 /* Default */
  50. /* When M1 is set, M0 is ignored. */
  51. #define TMP108_CONF_CONVRATE_MASK (TMP108_CONF_CR0|TMP108_CONF_CR1)
  52. #define TMP108_CONVRATE_0P25HZ 0x0000
  53. #define TMP108_CONVRATE_1HZ TMP108_CONF_CR0 /* Default */
  54. #define TMP108_CONVRATE_4HZ TMP108_CONF_CR1
  55. #define TMP108_CONVRATE_16HZ (TMP108_CONF_CR0|TMP108_CONF_CR1)
  56. #define TMP108_CONF_HYSTERESIS_MASK (TMP108_CONF_HYS0|TMP108_CONF_HYS1)
  57. #define TMP108_HYSTERESIS_0C 0x0000
  58. #define TMP108_HYSTERESIS_1C TMP108_CONF_HYS0 /* Default */
  59. #define TMP108_HYSTERESIS_2C TMP108_CONF_HYS1
  60. #define TMP108_HYSTERESIS_4C (TMP108_CONF_HYS0|TMP108_CONF_HYS1)
  61. #define TMP108_CONVERSION_TIME_MS 30 /* in milli-seconds */
  62. struct tmp108 {
  63. struct regmap *regmap;
  64. u16 orig_config;
  65. unsigned long ready_time;
  66. };
  67. /* convert 12-bit TMP108 register value to milliCelsius */
  68. static inline int tmp108_temp_reg_to_mC(s16 val)
  69. {
  70. return (val & ~0x0f) * 1000 / 256;
  71. }
  72. /* convert milliCelsius to left adjusted 12-bit TMP108 register value */
  73. static inline u16 tmp108_mC_to_temp_reg(int val)
  74. {
  75. return (val * 256) / 1000;
  76. }
  77. static int tmp108_read(struct device *dev, enum hwmon_sensor_types type,
  78. u32 attr, int channel, long *temp)
  79. {
  80. struct tmp108 *tmp108 = dev_get_drvdata(dev);
  81. unsigned int regval;
  82. int err, hyst;
  83. if (type == hwmon_chip) {
  84. if (attr == hwmon_chip_update_interval) {
  85. err = regmap_read(tmp108->regmap, TMP108_REG_CONF,
  86. &regval);
  87. if (err < 0)
  88. return err;
  89. switch (regval & TMP108_CONF_CONVRATE_MASK) {
  90. case TMP108_CONVRATE_0P25HZ:
  91. default:
  92. *temp = 4000;
  93. break;
  94. case TMP108_CONVRATE_1HZ:
  95. *temp = 1000;
  96. break;
  97. case TMP108_CONVRATE_4HZ:
  98. *temp = 250;
  99. break;
  100. case TMP108_CONVRATE_16HZ:
  101. *temp = 63;
  102. break;
  103. }
  104. return 0;
  105. }
  106. return -EOPNOTSUPP;
  107. }
  108. switch (attr) {
  109. case hwmon_temp_input:
  110. /* Is it too early to return a conversion ? */
  111. if (time_before(jiffies, tmp108->ready_time)) {
  112. dev_dbg(dev, "%s: Conversion not ready yet..\n",
  113. __func__);
  114. return -EAGAIN;
  115. }
  116. err = regmap_read(tmp108->regmap, TMP108_REG_TEMP, &regval);
  117. if (err < 0)
  118. return err;
  119. *temp = tmp108_temp_reg_to_mC(regval);
  120. break;
  121. case hwmon_temp_min:
  122. case hwmon_temp_max:
  123. err = regmap_read(tmp108->regmap, attr == hwmon_temp_min ?
  124. TMP108_REG_TLOW : TMP108_REG_THIGH, &regval);
  125. if (err < 0)
  126. return err;
  127. *temp = tmp108_temp_reg_to_mC(regval);
  128. break;
  129. case hwmon_temp_min_alarm:
  130. case hwmon_temp_max_alarm:
  131. err = regmap_read(tmp108->regmap, TMP108_REG_CONF, &regval);
  132. if (err < 0)
  133. return err;
  134. *temp = !!(regval & (attr == hwmon_temp_min_alarm ?
  135. TMP108_CONF_FL : TMP108_CONF_FH));
  136. break;
  137. case hwmon_temp_min_hyst:
  138. case hwmon_temp_max_hyst:
  139. err = regmap_read(tmp108->regmap, TMP108_REG_CONF, &regval);
  140. if (err < 0)
  141. return err;
  142. switch (regval & TMP108_CONF_HYSTERESIS_MASK) {
  143. case TMP108_HYSTERESIS_0C:
  144. default:
  145. hyst = 0;
  146. break;
  147. case TMP108_HYSTERESIS_1C:
  148. hyst = 1000;
  149. break;
  150. case TMP108_HYSTERESIS_2C:
  151. hyst = 2000;
  152. break;
  153. case TMP108_HYSTERESIS_4C:
  154. hyst = 4000;
  155. break;
  156. }
  157. err = regmap_read(tmp108->regmap, attr == hwmon_temp_min_hyst ?
  158. TMP108_REG_TLOW : TMP108_REG_THIGH, &regval);
  159. if (err < 0)
  160. return err;
  161. *temp = tmp108_temp_reg_to_mC(regval);
  162. if (attr == hwmon_temp_min_hyst)
  163. *temp += hyst;
  164. else
  165. *temp -= hyst;
  166. break;
  167. default:
  168. return -EOPNOTSUPP;
  169. }
  170. return 0;
  171. }
  172. static int tmp108_write(struct device *dev, enum hwmon_sensor_types type,
  173. u32 attr, int channel, long temp)
  174. {
  175. struct tmp108 *tmp108 = dev_get_drvdata(dev);
  176. u32 regval, mask;
  177. int err;
  178. if (type == hwmon_chip) {
  179. if (attr == hwmon_chip_update_interval) {
  180. if (temp < 156)
  181. mask = TMP108_CONVRATE_16HZ;
  182. else if (temp < 625)
  183. mask = TMP108_CONVRATE_4HZ;
  184. else if (temp < 2500)
  185. mask = TMP108_CONVRATE_1HZ;
  186. else
  187. mask = TMP108_CONVRATE_0P25HZ;
  188. return regmap_update_bits(tmp108->regmap,
  189. TMP108_REG_CONF,
  190. TMP108_CONF_CONVRATE_MASK,
  191. mask);
  192. }
  193. return -EOPNOTSUPP;
  194. }
  195. switch (attr) {
  196. case hwmon_temp_min:
  197. case hwmon_temp_max:
  198. temp = clamp_val(temp, TMP108_TEMP_MIN_MC, TMP108_TEMP_MAX_MC);
  199. return regmap_write(tmp108->regmap,
  200. attr == hwmon_temp_min ?
  201. TMP108_REG_TLOW : TMP108_REG_THIGH,
  202. tmp108_mC_to_temp_reg(temp));
  203. case hwmon_temp_min_hyst:
  204. case hwmon_temp_max_hyst:
  205. temp = clamp_val(temp, TMP108_TEMP_MIN_MC, TMP108_TEMP_MAX_MC);
  206. err = regmap_read(tmp108->regmap,
  207. attr == hwmon_temp_min_hyst ?
  208. TMP108_REG_TLOW : TMP108_REG_THIGH,
  209. &regval);
  210. if (err < 0)
  211. return err;
  212. if (attr == hwmon_temp_min_hyst)
  213. temp -= tmp108_temp_reg_to_mC(regval);
  214. else
  215. temp = tmp108_temp_reg_to_mC(regval) - temp;
  216. if (temp < 500)
  217. mask = TMP108_HYSTERESIS_0C;
  218. else if (temp < 1500)
  219. mask = TMP108_HYSTERESIS_1C;
  220. else if (temp < 3000)
  221. mask = TMP108_HYSTERESIS_2C;
  222. else
  223. mask = TMP108_HYSTERESIS_4C;
  224. return regmap_update_bits(tmp108->regmap, TMP108_REG_CONF,
  225. TMP108_CONF_HYSTERESIS_MASK, mask);
  226. default:
  227. return -EOPNOTSUPP;
  228. }
  229. }
  230. static umode_t tmp108_is_visible(const void *data, enum hwmon_sensor_types type,
  231. u32 attr, int channel)
  232. {
  233. if (type == hwmon_chip && attr == hwmon_chip_update_interval)
  234. return 0644;
  235. if (type != hwmon_temp)
  236. return 0;
  237. switch (attr) {
  238. case hwmon_temp_input:
  239. case hwmon_temp_min_alarm:
  240. case hwmon_temp_max_alarm:
  241. return 0444;
  242. case hwmon_temp_min:
  243. case hwmon_temp_max:
  244. case hwmon_temp_min_hyst:
  245. case hwmon_temp_max_hyst:
  246. return 0644;
  247. default:
  248. return 0;
  249. }
  250. }
  251. static const struct hwmon_channel_info *tmp108_info[] = {
  252. HWMON_CHANNEL_INFO(chip,
  253. HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL),
  254. HWMON_CHANNEL_INFO(temp,
  255. HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN |
  256. HWMON_T_MIN_HYST | HWMON_T_MAX_HYST |
  257. HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM),
  258. NULL
  259. };
  260. static const struct hwmon_ops tmp108_hwmon_ops = {
  261. .is_visible = tmp108_is_visible,
  262. .read = tmp108_read,
  263. .write = tmp108_write,
  264. };
  265. static const struct hwmon_chip_info tmp108_chip_info = {
  266. .ops = &tmp108_hwmon_ops,
  267. .info = tmp108_info,
  268. };
  269. static void tmp108_restore_config(void *data)
  270. {
  271. struct tmp108 *tmp108 = data;
  272. regmap_write(tmp108->regmap, TMP108_REG_CONF, tmp108->orig_config);
  273. }
  274. static bool tmp108_is_writeable_reg(struct device *dev, unsigned int reg)
  275. {
  276. return reg != TMP108_REG_TEMP;
  277. }
  278. static bool tmp108_is_volatile_reg(struct device *dev, unsigned int reg)
  279. {
  280. /* Configuration register must be volatile to enable FL and FH. */
  281. return reg == TMP108_REG_TEMP || reg == TMP108_REG_CONF;
  282. }
  283. static const struct regmap_config tmp108_regmap_config = {
  284. .reg_bits = 8,
  285. .val_bits = 16,
  286. .max_register = TMP108_REG_THIGH,
  287. .writeable_reg = tmp108_is_writeable_reg,
  288. .volatile_reg = tmp108_is_volatile_reg,
  289. .val_format_endian = REGMAP_ENDIAN_BIG,
  290. .cache_type = REGCACHE_RBTREE,
  291. .use_single_read = true,
  292. .use_single_write = true,
  293. };
  294. static int tmp108_probe(struct i2c_client *client)
  295. {
  296. struct device *dev = &client->dev;
  297. struct device *hwmon_dev;
  298. struct tmp108 *tmp108;
  299. int err;
  300. u32 config;
  301. if (!i2c_check_functionality(client->adapter,
  302. I2C_FUNC_SMBUS_WORD_DATA)) {
  303. dev_err(dev,
  304. "adapter doesn't support SMBus word transactions\n");
  305. return -ENODEV;
  306. }
  307. tmp108 = devm_kzalloc(dev, sizeof(*tmp108), GFP_KERNEL);
  308. if (!tmp108)
  309. return -ENOMEM;
  310. dev_set_drvdata(dev, tmp108);
  311. tmp108->regmap = devm_regmap_init_i2c(client, &tmp108_regmap_config);
  312. if (IS_ERR(tmp108->regmap)) {
  313. err = PTR_ERR(tmp108->regmap);
  314. dev_err(dev, "regmap init failed: %d", err);
  315. return err;
  316. }
  317. err = regmap_read(tmp108->regmap, TMP108_REG_CONF, &config);
  318. if (err < 0) {
  319. dev_err(dev, "error reading config register: %d", err);
  320. return err;
  321. }
  322. tmp108->orig_config = config;
  323. /* Only continuous mode is supported. */
  324. config &= ~TMP108_CONF_MODE_MASK;
  325. config |= TMP108_MODE_CONTINUOUS;
  326. /* Only comparator mode is supported. */
  327. config &= ~TMP108_CONF_TM;
  328. err = regmap_write(tmp108->regmap, TMP108_REG_CONF, config);
  329. if (err < 0) {
  330. dev_err(dev, "error writing config register: %d", err);
  331. return err;
  332. }
  333. tmp108->ready_time = jiffies;
  334. if ((tmp108->orig_config & TMP108_CONF_MODE_MASK) ==
  335. TMP108_MODE_SHUTDOWN)
  336. tmp108->ready_time +=
  337. msecs_to_jiffies(TMP108_CONVERSION_TIME_MS);
  338. err = devm_add_action_or_reset(dev, tmp108_restore_config, tmp108);
  339. if (err) {
  340. dev_err(dev, "add action or reset failed: %d", err);
  341. return err;
  342. }
  343. hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
  344. tmp108,
  345. &tmp108_chip_info,
  346. NULL);
  347. return PTR_ERR_OR_ZERO(hwmon_dev);
  348. }
  349. static int tmp108_suspend(struct device *dev)
  350. {
  351. struct tmp108 *tmp108 = dev_get_drvdata(dev);
  352. return regmap_update_bits(tmp108->regmap, TMP108_REG_CONF,
  353. TMP108_CONF_MODE_MASK, TMP108_MODE_SHUTDOWN);
  354. }
  355. static int tmp108_resume(struct device *dev)
  356. {
  357. struct tmp108 *tmp108 = dev_get_drvdata(dev);
  358. int err;
  359. err = regmap_update_bits(tmp108->regmap, TMP108_REG_CONF,
  360. TMP108_CONF_MODE_MASK, TMP108_MODE_CONTINUOUS);
  361. tmp108->ready_time = jiffies +
  362. msecs_to_jiffies(TMP108_CONVERSION_TIME_MS);
  363. return err;
  364. }
  365. static DEFINE_SIMPLE_DEV_PM_OPS(tmp108_dev_pm_ops, tmp108_suspend, tmp108_resume);
  366. static const struct i2c_device_id tmp108_i2c_ids[] = {
  367. { "tmp108", 0 },
  368. { }
  369. };
  370. MODULE_DEVICE_TABLE(i2c, tmp108_i2c_ids);
  371. #ifdef CONFIG_OF
  372. static const struct of_device_id tmp108_of_ids[] = {
  373. { .compatible = "ti,tmp108", },
  374. {}
  375. };
  376. MODULE_DEVICE_TABLE(of, tmp108_of_ids);
  377. #endif
  378. static struct i2c_driver tmp108_driver = {
  379. .driver = {
  380. .name = DRIVER_NAME,
  381. .pm = pm_sleep_ptr(&tmp108_dev_pm_ops),
  382. .of_match_table = of_match_ptr(tmp108_of_ids),
  383. },
  384. .probe_new = tmp108_probe,
  385. .id_table = tmp108_i2c_ids,
  386. };
  387. module_i2c_driver(tmp108_driver);
  388. MODULE_AUTHOR("John Muir <[email protected]>");
  389. MODULE_DESCRIPTION("Texas Instruments TMP108 temperature sensor driver");
  390. MODULE_LICENSE("GPL");