lm95241.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (C) 2008, 2010 Davide Rizzo <[email protected]>
  4. *
  5. * The LM95241 is a sensor chip made by National Semiconductors.
  6. * It reports up to three temperatures (its own plus up to two external ones).
  7. * Complete datasheet can be obtained from National's website at:
  8. * http://www.national.com/ds.cgi/LM/LM95241.pdf
  9. */
  10. #include <linux/bitops.h>
  11. #include <linux/err.h>
  12. #include <linux/i2c.h>
  13. #include <linux/init.h>
  14. #include <linux/jiffies.h>
  15. #include <linux/hwmon.h>
  16. #include <linux/module.h>
  17. #include <linux/mutex.h>
  18. #include <linux/slab.h>
  19. #define DEVNAME "lm95241"
  20. static const unsigned short normal_i2c[] = {
  21. 0x19, 0x2a, 0x2b, I2C_CLIENT_END };
  22. /* LM95241 registers */
  23. #define LM95241_REG_R_MAN_ID 0xFE
  24. #define LM95241_REG_R_CHIP_ID 0xFF
  25. #define LM95241_REG_R_STATUS 0x02
  26. #define LM95241_REG_RW_CONFIG 0x03
  27. #define LM95241_REG_RW_REM_FILTER 0x06
  28. #define LM95241_REG_RW_TRUTHERM 0x07
  29. #define LM95241_REG_W_ONE_SHOT 0x0F
  30. #define LM95241_REG_R_LOCAL_TEMPH 0x10
  31. #define LM95241_REG_R_REMOTE1_TEMPH 0x11
  32. #define LM95241_REG_R_REMOTE2_TEMPH 0x12
  33. #define LM95241_REG_R_LOCAL_TEMPL 0x20
  34. #define LM95241_REG_R_REMOTE1_TEMPL 0x21
  35. #define LM95241_REG_R_REMOTE2_TEMPL 0x22
  36. #define LM95241_REG_RW_REMOTE_MODEL 0x30
  37. /* LM95241 specific bitfields */
  38. #define CFG_STOP BIT(6)
  39. #define CFG_CR0076 0x00
  40. #define CFG_CR0182 BIT(4)
  41. #define CFG_CR1000 BIT(5)
  42. #define CFG_CR2700 (BIT(4) | BIT(5))
  43. #define CFG_CRMASK (BIT(4) | BIT(5))
  44. #define R1MS_MASK BIT(0)
  45. #define R2MS_MASK BIT(2)
  46. #define R1DF_MASK BIT(1)
  47. #define R2DF_MASK BIT(2)
  48. #define R1FE_MASK BIT(0)
  49. #define R2FE_MASK BIT(2)
  50. #define R1DM BIT(0)
  51. #define R2DM BIT(1)
  52. #define TT1_SHIFT 0
  53. #define TT2_SHIFT 4
  54. #define TT_OFF 0
  55. #define TT_ON 1
  56. #define TT_MASK 7
  57. #define NATSEMI_MAN_ID 0x01
  58. #define LM95231_CHIP_ID 0xA1
  59. #define LM95241_CHIP_ID 0xA4
  60. static const u8 lm95241_reg_address[] = {
  61. LM95241_REG_R_LOCAL_TEMPH,
  62. LM95241_REG_R_LOCAL_TEMPL,
  63. LM95241_REG_R_REMOTE1_TEMPH,
  64. LM95241_REG_R_REMOTE1_TEMPL,
  65. LM95241_REG_R_REMOTE2_TEMPH,
  66. LM95241_REG_R_REMOTE2_TEMPL
  67. };
  68. /* Client data (each client gets its own) */
  69. struct lm95241_data {
  70. struct i2c_client *client;
  71. struct mutex update_lock;
  72. unsigned long last_updated; /* in jiffies */
  73. unsigned long interval; /* in milli-seconds */
  74. bool valid; /* false until following fields are valid */
  75. /* registers values */
  76. u8 temp[ARRAY_SIZE(lm95241_reg_address)];
  77. u8 status, config, model, trutherm;
  78. };
  79. /* Conversions */
  80. static int temp_from_reg_signed(u8 val_h, u8 val_l)
  81. {
  82. s16 val_hl = (val_h << 8) | val_l;
  83. return val_hl * 1000 / 256;
  84. }
  85. static int temp_from_reg_unsigned(u8 val_h, u8 val_l)
  86. {
  87. u16 val_hl = (val_h << 8) | val_l;
  88. return val_hl * 1000 / 256;
  89. }
  90. static struct lm95241_data *lm95241_update_device(struct device *dev)
  91. {
  92. struct lm95241_data *data = dev_get_drvdata(dev);
  93. struct i2c_client *client = data->client;
  94. mutex_lock(&data->update_lock);
  95. if (time_after(jiffies, data->last_updated
  96. + msecs_to_jiffies(data->interval)) ||
  97. !data->valid) {
  98. int i;
  99. dev_dbg(dev, "Updating lm95241 data.\n");
  100. for (i = 0; i < ARRAY_SIZE(lm95241_reg_address); i++)
  101. data->temp[i]
  102. = i2c_smbus_read_byte_data(client,
  103. lm95241_reg_address[i]);
  104. data->status = i2c_smbus_read_byte_data(client,
  105. LM95241_REG_R_STATUS);
  106. data->last_updated = jiffies;
  107. data->valid = true;
  108. }
  109. mutex_unlock(&data->update_lock);
  110. return data;
  111. }
  112. static int lm95241_read_chip(struct device *dev, u32 attr, int channel,
  113. long *val)
  114. {
  115. struct lm95241_data *data = dev_get_drvdata(dev);
  116. switch (attr) {
  117. case hwmon_chip_update_interval:
  118. *val = data->interval;
  119. return 0;
  120. default:
  121. return -EOPNOTSUPP;
  122. }
  123. }
  124. static int lm95241_read_temp(struct device *dev, u32 attr, int channel,
  125. long *val)
  126. {
  127. struct lm95241_data *data = lm95241_update_device(dev);
  128. switch (attr) {
  129. case hwmon_temp_input:
  130. if (!channel || (data->config & BIT(channel - 1)))
  131. *val = temp_from_reg_signed(data->temp[channel * 2],
  132. data->temp[channel * 2 + 1]);
  133. else
  134. *val = temp_from_reg_unsigned(data->temp[channel * 2],
  135. data->temp[channel * 2 + 1]);
  136. return 0;
  137. case hwmon_temp_min:
  138. if (channel == 1)
  139. *val = (data->config & R1DF_MASK) ? -128000 : 0;
  140. else
  141. *val = (data->config & R2DF_MASK) ? -128000 : 0;
  142. return 0;
  143. case hwmon_temp_max:
  144. if (channel == 1)
  145. *val = (data->config & R1DF_MASK) ? 127875 : 255875;
  146. else
  147. *val = (data->config & R2DF_MASK) ? 127875 : 255875;
  148. return 0;
  149. case hwmon_temp_type:
  150. if (channel == 1)
  151. *val = (data->model & R1MS_MASK) ? 1 : 2;
  152. else
  153. *val = (data->model & R2MS_MASK) ? 1 : 2;
  154. return 0;
  155. case hwmon_temp_fault:
  156. if (channel == 1)
  157. *val = !!(data->status & R1DM);
  158. else
  159. *val = !!(data->status & R2DM);
  160. return 0;
  161. default:
  162. return -EOPNOTSUPP;
  163. }
  164. }
  165. static int lm95241_read(struct device *dev, enum hwmon_sensor_types type,
  166. u32 attr, int channel, long *val)
  167. {
  168. switch (type) {
  169. case hwmon_chip:
  170. return lm95241_read_chip(dev, attr, channel, val);
  171. case hwmon_temp:
  172. return lm95241_read_temp(dev, attr, channel, val);
  173. default:
  174. return -EOPNOTSUPP;
  175. }
  176. }
  177. static int lm95241_write_chip(struct device *dev, u32 attr, int channel,
  178. long val)
  179. {
  180. struct lm95241_data *data = dev_get_drvdata(dev);
  181. int convrate;
  182. u8 config;
  183. int ret;
  184. mutex_lock(&data->update_lock);
  185. switch (attr) {
  186. case hwmon_chip_update_interval:
  187. config = data->config & ~CFG_CRMASK;
  188. if (val < 130) {
  189. convrate = 76;
  190. config |= CFG_CR0076;
  191. } else if (val < 590) {
  192. convrate = 182;
  193. config |= CFG_CR0182;
  194. } else if (val < 1850) {
  195. convrate = 1000;
  196. config |= CFG_CR1000;
  197. } else {
  198. convrate = 2700;
  199. config |= CFG_CR2700;
  200. }
  201. data->interval = convrate;
  202. data->config = config;
  203. ret = i2c_smbus_write_byte_data(data->client,
  204. LM95241_REG_RW_CONFIG, config);
  205. break;
  206. default:
  207. ret = -EOPNOTSUPP;
  208. break;
  209. }
  210. mutex_unlock(&data->update_lock);
  211. return ret;
  212. }
  213. static int lm95241_write_temp(struct device *dev, u32 attr, int channel,
  214. long val)
  215. {
  216. struct lm95241_data *data = dev_get_drvdata(dev);
  217. struct i2c_client *client = data->client;
  218. int ret;
  219. mutex_lock(&data->update_lock);
  220. switch (attr) {
  221. case hwmon_temp_min:
  222. if (channel == 1) {
  223. if (val < 0)
  224. data->config |= R1DF_MASK;
  225. else
  226. data->config &= ~R1DF_MASK;
  227. } else {
  228. if (val < 0)
  229. data->config |= R2DF_MASK;
  230. else
  231. data->config &= ~R2DF_MASK;
  232. }
  233. data->valid = false;
  234. ret = i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG,
  235. data->config);
  236. break;
  237. case hwmon_temp_max:
  238. if (channel == 1) {
  239. if (val <= 127875)
  240. data->config |= R1DF_MASK;
  241. else
  242. data->config &= ~R1DF_MASK;
  243. } else {
  244. if (val <= 127875)
  245. data->config |= R2DF_MASK;
  246. else
  247. data->config &= ~R2DF_MASK;
  248. }
  249. data->valid = false;
  250. ret = i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG,
  251. data->config);
  252. break;
  253. case hwmon_temp_type:
  254. if (val != 1 && val != 2) {
  255. ret = -EINVAL;
  256. break;
  257. }
  258. if (channel == 1) {
  259. data->trutherm &= ~(TT_MASK << TT1_SHIFT);
  260. if (val == 1) {
  261. data->model |= R1MS_MASK;
  262. data->trutherm |= (TT_ON << TT1_SHIFT);
  263. } else {
  264. data->model &= ~R1MS_MASK;
  265. data->trutherm |= (TT_OFF << TT1_SHIFT);
  266. }
  267. } else {
  268. data->trutherm &= ~(TT_MASK << TT2_SHIFT);
  269. if (val == 1) {
  270. data->model |= R2MS_MASK;
  271. data->trutherm |= (TT_ON << TT2_SHIFT);
  272. } else {
  273. data->model &= ~R2MS_MASK;
  274. data->trutherm |= (TT_OFF << TT2_SHIFT);
  275. }
  276. }
  277. ret = i2c_smbus_write_byte_data(client,
  278. LM95241_REG_RW_REMOTE_MODEL,
  279. data->model);
  280. if (ret < 0)
  281. break;
  282. ret = i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM,
  283. data->trutherm);
  284. break;
  285. default:
  286. ret = -EOPNOTSUPP;
  287. break;
  288. }
  289. mutex_unlock(&data->update_lock);
  290. return ret;
  291. }
  292. static int lm95241_write(struct device *dev, enum hwmon_sensor_types type,
  293. u32 attr, int channel, long val)
  294. {
  295. switch (type) {
  296. case hwmon_chip:
  297. return lm95241_write_chip(dev, attr, channel, val);
  298. case hwmon_temp:
  299. return lm95241_write_temp(dev, attr, channel, val);
  300. default:
  301. return -EOPNOTSUPP;
  302. }
  303. }
  304. static umode_t lm95241_is_visible(const void *data,
  305. enum hwmon_sensor_types type,
  306. u32 attr, int channel)
  307. {
  308. switch (type) {
  309. case hwmon_chip:
  310. switch (attr) {
  311. case hwmon_chip_update_interval:
  312. return 0644;
  313. }
  314. break;
  315. case hwmon_temp:
  316. switch (attr) {
  317. case hwmon_temp_input:
  318. return 0444;
  319. case hwmon_temp_fault:
  320. return 0444;
  321. case hwmon_temp_min:
  322. case hwmon_temp_max:
  323. case hwmon_temp_type:
  324. return 0644;
  325. }
  326. break;
  327. default:
  328. break;
  329. }
  330. return 0;
  331. }
  332. /* Return 0 if detection is successful, -ENODEV otherwise */
  333. static int lm95241_detect(struct i2c_client *new_client,
  334. struct i2c_board_info *info)
  335. {
  336. struct i2c_adapter *adapter = new_client->adapter;
  337. const char *name;
  338. int mfg_id, chip_id;
  339. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  340. return -ENODEV;
  341. mfg_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID);
  342. if (mfg_id != NATSEMI_MAN_ID)
  343. return -ENODEV;
  344. chip_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID);
  345. switch (chip_id) {
  346. case LM95231_CHIP_ID:
  347. name = "lm95231";
  348. break;
  349. case LM95241_CHIP_ID:
  350. name = "lm95241";
  351. break;
  352. default:
  353. return -ENODEV;
  354. }
  355. /* Fill the i2c board info */
  356. strscpy(info->type, name, I2C_NAME_SIZE);
  357. return 0;
  358. }
  359. static void lm95241_init_client(struct i2c_client *client,
  360. struct lm95241_data *data)
  361. {
  362. data->interval = 1000;
  363. data->config = CFG_CR1000;
  364. data->trutherm = (TT_OFF << TT1_SHIFT) | (TT_OFF << TT2_SHIFT);
  365. i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config);
  366. i2c_smbus_write_byte_data(client, LM95241_REG_RW_REM_FILTER,
  367. R1FE_MASK | R2FE_MASK);
  368. i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM,
  369. data->trutherm);
  370. i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL,
  371. data->model);
  372. }
  373. static const struct hwmon_channel_info *lm95241_info[] = {
  374. HWMON_CHANNEL_INFO(chip,
  375. HWMON_C_UPDATE_INTERVAL),
  376. HWMON_CHANNEL_INFO(temp,
  377. HWMON_T_INPUT,
  378. HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN |
  379. HWMON_T_TYPE | HWMON_T_FAULT,
  380. HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN |
  381. HWMON_T_TYPE | HWMON_T_FAULT),
  382. NULL
  383. };
  384. static const struct hwmon_ops lm95241_hwmon_ops = {
  385. .is_visible = lm95241_is_visible,
  386. .read = lm95241_read,
  387. .write = lm95241_write,
  388. };
  389. static const struct hwmon_chip_info lm95241_chip_info = {
  390. .ops = &lm95241_hwmon_ops,
  391. .info = lm95241_info,
  392. };
  393. static int lm95241_probe(struct i2c_client *client)
  394. {
  395. struct device *dev = &client->dev;
  396. struct lm95241_data *data;
  397. struct device *hwmon_dev;
  398. data = devm_kzalloc(dev, sizeof(struct lm95241_data), GFP_KERNEL);
  399. if (!data)
  400. return -ENOMEM;
  401. data->client = client;
  402. mutex_init(&data->update_lock);
  403. /* Initialize the LM95241 chip */
  404. lm95241_init_client(client, data);
  405. hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
  406. data,
  407. &lm95241_chip_info,
  408. NULL);
  409. return PTR_ERR_OR_ZERO(hwmon_dev);
  410. }
  411. /* Driver data (common to all clients) */
  412. static const struct i2c_device_id lm95241_id[] = {
  413. { "lm95231", 0 },
  414. { "lm95241", 0 },
  415. { }
  416. };
  417. MODULE_DEVICE_TABLE(i2c, lm95241_id);
  418. static struct i2c_driver lm95241_driver = {
  419. .class = I2C_CLASS_HWMON,
  420. .driver = {
  421. .name = DEVNAME,
  422. },
  423. .probe_new = lm95241_probe,
  424. .id_table = lm95241_id,
  425. .detect = lm95241_detect,
  426. .address_list = normal_i2c,
  427. };
  428. module_i2c_driver(lm95241_driver);
  429. MODULE_AUTHOR("Davide Rizzo <[email protected]>");
  430. MODULE_DESCRIPTION("LM95231/LM95241 sensor driver");
  431. MODULE_LICENSE("GPL");