lm95245.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (C) 2011 Alexander Stein <[email protected]>
  4. *
  5. * The LM95245 is a sensor chip made by TI / National Semiconductor.
  6. * It reports up to two temperatures (its own plus an external one).
  7. *
  8. * This driver is based on lm95241.c
  9. */
  10. #include <linux/err.h>
  11. #include <linux/init.h>
  12. #include <linux/hwmon.h>
  13. #include <linux/i2c.h>
  14. #include <linux/module.h>
  15. #include <linux/mutex.h>
  16. #include <linux/regmap.h>
  17. #include <linux/slab.h>
  18. static const unsigned short normal_i2c[] = {
  19. 0x18, 0x19, 0x29, 0x4c, 0x4d, I2C_CLIENT_END };
  20. /* LM95245 registers */
  21. /* general registers */
  22. #define LM95245_REG_RW_CONFIG1 0x03
  23. #define LM95245_REG_RW_CONVERS_RATE 0x04
  24. #define LM95245_REG_W_ONE_SHOT 0x0F
  25. /* diode configuration */
  26. #define LM95245_REG_RW_CONFIG2 0xBF
  27. #define LM95245_REG_RW_REMOTE_OFFH 0x11
  28. #define LM95245_REG_RW_REMOTE_OFFL 0x12
  29. /* status registers */
  30. #define LM95245_REG_R_STATUS1 0x02
  31. #define LM95245_REG_R_STATUS2 0x33
  32. /* limit registers */
  33. #define LM95245_REG_RW_REMOTE_OS_LIMIT 0x07
  34. #define LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT 0x20
  35. #define LM95245_REG_RW_REMOTE_TCRIT_LIMIT 0x19
  36. #define LM95245_REG_RW_COMMON_HYSTERESIS 0x21
  37. /* temperature signed */
  38. #define LM95245_REG_R_LOCAL_TEMPH_S 0x00
  39. #define LM95245_REG_R_LOCAL_TEMPL_S 0x30
  40. #define LM95245_REG_R_REMOTE_TEMPH_S 0x01
  41. #define LM95245_REG_R_REMOTE_TEMPL_S 0x10
  42. /* temperature unsigned */
  43. #define LM95245_REG_R_REMOTE_TEMPH_U 0x31
  44. #define LM95245_REG_R_REMOTE_TEMPL_U 0x32
  45. /* id registers */
  46. #define LM95245_REG_R_MAN_ID 0xFE
  47. #define LM95245_REG_R_CHIP_ID 0xFF
  48. /* LM95245 specific bitfields */
  49. #define CFG_STOP 0x40
  50. #define CFG_REMOTE_TCRIT_MASK 0x10
  51. #define CFG_REMOTE_OS_MASK 0x08
  52. #define CFG_LOCAL_TCRIT_MASK 0x04
  53. #define CFG_LOCAL_OS_MASK 0x02
  54. #define CFG2_OS_A0 0x40
  55. #define CFG2_DIODE_FAULT_OS 0x20
  56. #define CFG2_DIODE_FAULT_TCRIT 0x10
  57. #define CFG2_REMOTE_TT 0x08
  58. #define CFG2_REMOTE_FILTER_DIS 0x00
  59. #define CFG2_REMOTE_FILTER_EN 0x06
  60. /* conversation rate in ms */
  61. #define RATE_CR0063 0x00
  62. #define RATE_CR0364 0x01
  63. #define RATE_CR1000 0x02
  64. #define RATE_CR2500 0x03
  65. #define STATUS1_ROS 0x10
  66. #define STATUS1_DIODE_FAULT 0x04
  67. #define STATUS1_RTCRIT 0x02
  68. #define STATUS1_LOC 0x01
  69. #define MANUFACTURER_ID 0x01
  70. #define LM95235_REVISION 0xB1
  71. #define LM95245_REVISION 0xB3
  72. /* Client data (each client gets its own) */
  73. struct lm95245_data {
  74. struct regmap *regmap;
  75. struct mutex update_lock;
  76. int interval; /* in msecs */
  77. };
  78. /* Conversions */
  79. static int temp_from_reg_unsigned(u8 val_h, u8 val_l)
  80. {
  81. return val_h * 1000 + val_l * 1000 / 256;
  82. }
  83. static int temp_from_reg_signed(u8 val_h, u8 val_l)
  84. {
  85. if (val_h & 0x80)
  86. return (val_h - 0x100) * 1000;
  87. return temp_from_reg_unsigned(val_h, val_l);
  88. }
  89. static int lm95245_read_conversion_rate(struct lm95245_data *data)
  90. {
  91. unsigned int rate;
  92. int ret;
  93. ret = regmap_read(data->regmap, LM95245_REG_RW_CONVERS_RATE, &rate);
  94. if (ret < 0)
  95. return ret;
  96. switch (rate) {
  97. case RATE_CR0063:
  98. data->interval = 63;
  99. break;
  100. case RATE_CR0364:
  101. data->interval = 364;
  102. break;
  103. case RATE_CR1000:
  104. data->interval = 1000;
  105. break;
  106. case RATE_CR2500:
  107. default:
  108. data->interval = 2500;
  109. break;
  110. }
  111. return 0;
  112. }
  113. static int lm95245_set_conversion_rate(struct lm95245_data *data, long interval)
  114. {
  115. int ret, rate;
  116. if (interval <= 63) {
  117. interval = 63;
  118. rate = RATE_CR0063;
  119. } else if (interval <= 364) {
  120. interval = 364;
  121. rate = RATE_CR0364;
  122. } else if (interval <= 1000) {
  123. interval = 1000;
  124. rate = RATE_CR1000;
  125. } else {
  126. interval = 2500;
  127. rate = RATE_CR2500;
  128. }
  129. ret = regmap_write(data->regmap, LM95245_REG_RW_CONVERS_RATE, rate);
  130. if (ret < 0)
  131. return ret;
  132. data->interval = interval;
  133. return 0;
  134. }
  135. static int lm95245_read_temp(struct device *dev, u32 attr, int channel,
  136. long *val)
  137. {
  138. struct lm95245_data *data = dev_get_drvdata(dev);
  139. struct regmap *regmap = data->regmap;
  140. int ret, regl, regh, regvall, regvalh;
  141. switch (attr) {
  142. case hwmon_temp_input:
  143. regl = channel ? LM95245_REG_R_REMOTE_TEMPL_S :
  144. LM95245_REG_R_LOCAL_TEMPL_S;
  145. regh = channel ? LM95245_REG_R_REMOTE_TEMPH_S :
  146. LM95245_REG_R_LOCAL_TEMPH_S;
  147. ret = regmap_read(regmap, regl, &regvall);
  148. if (ret < 0)
  149. return ret;
  150. ret = regmap_read(regmap, regh, &regvalh);
  151. if (ret < 0)
  152. return ret;
  153. /*
  154. * Local temp is always signed.
  155. * Remote temp has both signed and unsigned data.
  156. * Use signed calculation for remote if signed bit is set
  157. * or if reported temperature is below signed limit.
  158. */
  159. if (!channel || (regvalh & 0x80) || regvalh < 0x7f) {
  160. *val = temp_from_reg_signed(regvalh, regvall);
  161. return 0;
  162. }
  163. ret = regmap_read(regmap, LM95245_REG_R_REMOTE_TEMPL_U,
  164. &regvall);
  165. if (ret < 0)
  166. return ret;
  167. ret = regmap_read(regmap, LM95245_REG_R_REMOTE_TEMPH_U,
  168. &regvalh);
  169. if (ret < 0)
  170. return ret;
  171. *val = temp_from_reg_unsigned(regvalh, regvall);
  172. return 0;
  173. case hwmon_temp_max:
  174. ret = regmap_read(regmap, LM95245_REG_RW_REMOTE_OS_LIMIT,
  175. &regvalh);
  176. if (ret < 0)
  177. return ret;
  178. *val = regvalh * 1000;
  179. return 0;
  180. case hwmon_temp_crit:
  181. regh = channel ? LM95245_REG_RW_REMOTE_TCRIT_LIMIT :
  182. LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT;
  183. ret = regmap_read(regmap, regh, &regvalh);
  184. if (ret < 0)
  185. return ret;
  186. *val = regvalh * 1000;
  187. return 0;
  188. case hwmon_temp_max_hyst:
  189. ret = regmap_read(regmap, LM95245_REG_RW_REMOTE_OS_LIMIT,
  190. &regvalh);
  191. if (ret < 0)
  192. return ret;
  193. ret = regmap_read(regmap, LM95245_REG_RW_COMMON_HYSTERESIS,
  194. &regvall);
  195. if (ret < 0)
  196. return ret;
  197. *val = (regvalh - regvall) * 1000;
  198. return 0;
  199. case hwmon_temp_crit_hyst:
  200. regh = channel ? LM95245_REG_RW_REMOTE_TCRIT_LIMIT :
  201. LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT;
  202. ret = regmap_read(regmap, regh, &regvalh);
  203. if (ret < 0)
  204. return ret;
  205. ret = regmap_read(regmap, LM95245_REG_RW_COMMON_HYSTERESIS,
  206. &regvall);
  207. if (ret < 0)
  208. return ret;
  209. *val = (regvalh - regvall) * 1000;
  210. return 0;
  211. case hwmon_temp_type:
  212. ret = regmap_read(regmap, LM95245_REG_RW_CONFIG2, &regvalh);
  213. if (ret < 0)
  214. return ret;
  215. *val = (regvalh & CFG2_REMOTE_TT) ? 1 : 2;
  216. return 0;
  217. case hwmon_temp_offset:
  218. ret = regmap_read(regmap, LM95245_REG_RW_REMOTE_OFFL,
  219. &regvall);
  220. if (ret < 0)
  221. return ret;
  222. ret = regmap_read(regmap, LM95245_REG_RW_REMOTE_OFFH,
  223. &regvalh);
  224. if (ret < 0)
  225. return ret;
  226. *val = temp_from_reg_signed(regvalh, regvall);
  227. return 0;
  228. case hwmon_temp_max_alarm:
  229. ret = regmap_read(regmap, LM95245_REG_R_STATUS1, &regvalh);
  230. if (ret < 0)
  231. return ret;
  232. *val = !!(regvalh & STATUS1_ROS);
  233. return 0;
  234. case hwmon_temp_crit_alarm:
  235. ret = regmap_read(regmap, LM95245_REG_R_STATUS1, &regvalh);
  236. if (ret < 0)
  237. return ret;
  238. *val = !!(regvalh & (channel ? STATUS1_RTCRIT : STATUS1_LOC));
  239. return 0;
  240. case hwmon_temp_fault:
  241. ret = regmap_read(regmap, LM95245_REG_R_STATUS1, &regvalh);
  242. if (ret < 0)
  243. return ret;
  244. *val = !!(regvalh & STATUS1_DIODE_FAULT);
  245. return 0;
  246. default:
  247. return -EOPNOTSUPP;
  248. }
  249. }
  250. static int lm95245_write_temp(struct device *dev, u32 attr, int channel,
  251. long val)
  252. {
  253. struct lm95245_data *data = dev_get_drvdata(dev);
  254. struct regmap *regmap = data->regmap;
  255. unsigned int regval;
  256. int ret, reg;
  257. switch (attr) {
  258. case hwmon_temp_max:
  259. val = clamp_val(val / 1000, 0, 255);
  260. ret = regmap_write(regmap, LM95245_REG_RW_REMOTE_OS_LIMIT, val);
  261. return ret;
  262. case hwmon_temp_crit:
  263. reg = channel ? LM95245_REG_RW_REMOTE_TCRIT_LIMIT :
  264. LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT;
  265. val = clamp_val(val / 1000, 0, channel ? 255 : 127);
  266. ret = regmap_write(regmap, reg, val);
  267. return ret;
  268. case hwmon_temp_crit_hyst:
  269. mutex_lock(&data->update_lock);
  270. ret = regmap_read(regmap, LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT,
  271. &regval);
  272. if (ret < 0) {
  273. mutex_unlock(&data->update_lock);
  274. return ret;
  275. }
  276. /* Clamp to reasonable range to prevent overflow */
  277. val = clamp_val(val, -1000000, 1000000);
  278. val = regval - val / 1000;
  279. val = clamp_val(val, 0, 31);
  280. ret = regmap_write(regmap, LM95245_REG_RW_COMMON_HYSTERESIS,
  281. val);
  282. mutex_unlock(&data->update_lock);
  283. return ret;
  284. case hwmon_temp_offset:
  285. val = clamp_val(val, -128000, 127875);
  286. val = val * 256 / 1000;
  287. mutex_lock(&data->update_lock);
  288. ret = regmap_write(regmap, LM95245_REG_RW_REMOTE_OFFL,
  289. val & 0xe0);
  290. if (ret < 0) {
  291. mutex_unlock(&data->update_lock);
  292. return ret;
  293. }
  294. ret = regmap_write(regmap, LM95245_REG_RW_REMOTE_OFFH,
  295. (val >> 8) & 0xff);
  296. mutex_unlock(&data->update_lock);
  297. return ret;
  298. case hwmon_temp_type:
  299. if (val != 1 && val != 2)
  300. return -EINVAL;
  301. ret = regmap_update_bits(regmap, LM95245_REG_RW_CONFIG2,
  302. CFG2_REMOTE_TT,
  303. val == 1 ? CFG2_REMOTE_TT : 0);
  304. return ret;
  305. default:
  306. return -EOPNOTSUPP;
  307. }
  308. }
  309. static int lm95245_read_chip(struct device *dev, u32 attr, int channel,
  310. long *val)
  311. {
  312. struct lm95245_data *data = dev_get_drvdata(dev);
  313. switch (attr) {
  314. case hwmon_chip_update_interval:
  315. *val = data->interval;
  316. return 0;
  317. default:
  318. return -EOPNOTSUPP;
  319. }
  320. }
  321. static int lm95245_write_chip(struct device *dev, u32 attr, int channel,
  322. long val)
  323. {
  324. struct lm95245_data *data = dev_get_drvdata(dev);
  325. int ret;
  326. switch (attr) {
  327. case hwmon_chip_update_interval:
  328. mutex_lock(&data->update_lock);
  329. ret = lm95245_set_conversion_rate(data, val);
  330. mutex_unlock(&data->update_lock);
  331. return ret;
  332. default:
  333. return -EOPNOTSUPP;
  334. }
  335. }
  336. static int lm95245_read(struct device *dev, enum hwmon_sensor_types type,
  337. u32 attr, int channel, long *val)
  338. {
  339. switch (type) {
  340. case hwmon_chip:
  341. return lm95245_read_chip(dev, attr, channel, val);
  342. case hwmon_temp:
  343. return lm95245_read_temp(dev, attr, channel, val);
  344. default:
  345. return -EOPNOTSUPP;
  346. }
  347. }
  348. static int lm95245_write(struct device *dev, enum hwmon_sensor_types type,
  349. u32 attr, int channel, long val)
  350. {
  351. switch (type) {
  352. case hwmon_chip:
  353. return lm95245_write_chip(dev, attr, channel, val);
  354. case hwmon_temp:
  355. return lm95245_write_temp(dev, attr, channel, val);
  356. default:
  357. return -EOPNOTSUPP;
  358. }
  359. }
  360. static umode_t lm95245_temp_is_visible(const void *data, u32 attr, int channel)
  361. {
  362. switch (attr) {
  363. case hwmon_temp_input:
  364. case hwmon_temp_max_alarm:
  365. case hwmon_temp_max_hyst:
  366. case hwmon_temp_crit_alarm:
  367. case hwmon_temp_fault:
  368. return 0444;
  369. case hwmon_temp_type:
  370. case hwmon_temp_max:
  371. case hwmon_temp_crit:
  372. case hwmon_temp_offset:
  373. return 0644;
  374. case hwmon_temp_crit_hyst:
  375. return (channel == 0) ? 0644 : 0444;
  376. default:
  377. return 0;
  378. }
  379. }
  380. static umode_t lm95245_is_visible(const void *data,
  381. enum hwmon_sensor_types type,
  382. u32 attr, int channel)
  383. {
  384. switch (type) {
  385. case hwmon_chip:
  386. switch (attr) {
  387. case hwmon_chip_update_interval:
  388. return 0644;
  389. default:
  390. return 0;
  391. }
  392. case hwmon_temp:
  393. return lm95245_temp_is_visible(data, attr, channel);
  394. default:
  395. return 0;
  396. }
  397. }
  398. /* Return 0 if detection is successful, -ENODEV otherwise */
  399. static int lm95245_detect(struct i2c_client *new_client,
  400. struct i2c_board_info *info)
  401. {
  402. struct i2c_adapter *adapter = new_client->adapter;
  403. int address = new_client->addr;
  404. const char *name;
  405. int rev, id;
  406. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  407. return -ENODEV;
  408. id = i2c_smbus_read_byte_data(new_client, LM95245_REG_R_MAN_ID);
  409. if (id != MANUFACTURER_ID)
  410. return -ENODEV;
  411. rev = i2c_smbus_read_byte_data(new_client, LM95245_REG_R_CHIP_ID);
  412. switch (rev) {
  413. case LM95235_REVISION:
  414. if (address != 0x18 && address != 0x29 && address != 0x4c)
  415. return -ENODEV;
  416. name = "lm95235";
  417. break;
  418. case LM95245_REVISION:
  419. name = "lm95245";
  420. break;
  421. default:
  422. return -ENODEV;
  423. }
  424. strscpy(info->type, name, I2C_NAME_SIZE);
  425. return 0;
  426. }
  427. static int lm95245_init_client(struct lm95245_data *data)
  428. {
  429. int ret;
  430. ret = lm95245_read_conversion_rate(data);
  431. if (ret < 0)
  432. return ret;
  433. return regmap_update_bits(data->regmap, LM95245_REG_RW_CONFIG1,
  434. CFG_STOP, 0);
  435. }
  436. static bool lm95245_is_writeable_reg(struct device *dev, unsigned int reg)
  437. {
  438. switch (reg) {
  439. case LM95245_REG_RW_CONFIG1:
  440. case LM95245_REG_RW_CONVERS_RATE:
  441. case LM95245_REG_W_ONE_SHOT:
  442. case LM95245_REG_RW_CONFIG2:
  443. case LM95245_REG_RW_REMOTE_OFFH:
  444. case LM95245_REG_RW_REMOTE_OFFL:
  445. case LM95245_REG_RW_REMOTE_OS_LIMIT:
  446. case LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT:
  447. case LM95245_REG_RW_REMOTE_TCRIT_LIMIT:
  448. case LM95245_REG_RW_COMMON_HYSTERESIS:
  449. return true;
  450. default:
  451. return false;
  452. }
  453. }
  454. static bool lm95245_is_volatile_reg(struct device *dev, unsigned int reg)
  455. {
  456. switch (reg) {
  457. case LM95245_REG_R_STATUS1:
  458. case LM95245_REG_R_STATUS2:
  459. case LM95245_REG_R_LOCAL_TEMPH_S:
  460. case LM95245_REG_R_LOCAL_TEMPL_S:
  461. case LM95245_REG_R_REMOTE_TEMPH_S:
  462. case LM95245_REG_R_REMOTE_TEMPL_S:
  463. case LM95245_REG_R_REMOTE_TEMPH_U:
  464. case LM95245_REG_R_REMOTE_TEMPL_U:
  465. return true;
  466. default:
  467. return false;
  468. }
  469. }
  470. static const struct regmap_config lm95245_regmap_config = {
  471. .reg_bits = 8,
  472. .val_bits = 8,
  473. .writeable_reg = lm95245_is_writeable_reg,
  474. .volatile_reg = lm95245_is_volatile_reg,
  475. .cache_type = REGCACHE_RBTREE,
  476. .use_single_read = true,
  477. .use_single_write = true,
  478. };
  479. static const struct hwmon_channel_info *lm95245_info[] = {
  480. HWMON_CHANNEL_INFO(chip,
  481. HWMON_C_UPDATE_INTERVAL),
  482. HWMON_CHANNEL_INFO(temp,
  483. HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_HYST |
  484. HWMON_T_CRIT_ALARM,
  485. HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST |
  486. HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_FAULT |
  487. HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM |
  488. HWMON_T_TYPE | HWMON_T_OFFSET),
  489. NULL
  490. };
  491. static const struct hwmon_ops lm95245_hwmon_ops = {
  492. .is_visible = lm95245_is_visible,
  493. .read = lm95245_read,
  494. .write = lm95245_write,
  495. };
  496. static const struct hwmon_chip_info lm95245_chip_info = {
  497. .ops = &lm95245_hwmon_ops,
  498. .info = lm95245_info,
  499. };
  500. static int lm95245_probe(struct i2c_client *client)
  501. {
  502. struct device *dev = &client->dev;
  503. struct lm95245_data *data;
  504. struct device *hwmon_dev;
  505. int ret;
  506. data = devm_kzalloc(dev, sizeof(struct lm95245_data), GFP_KERNEL);
  507. if (!data)
  508. return -ENOMEM;
  509. data->regmap = devm_regmap_init_i2c(client, &lm95245_regmap_config);
  510. if (IS_ERR(data->regmap))
  511. return PTR_ERR(data->regmap);
  512. mutex_init(&data->update_lock);
  513. /* Initialize the LM95245 chip */
  514. ret = lm95245_init_client(data);
  515. if (ret < 0)
  516. return ret;
  517. hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
  518. data,
  519. &lm95245_chip_info,
  520. NULL);
  521. return PTR_ERR_OR_ZERO(hwmon_dev);
  522. }
  523. /* Driver data (common to all clients) */
  524. static const struct i2c_device_id lm95245_id[] = {
  525. { "lm95235", 0 },
  526. { "lm95245", 0 },
  527. { }
  528. };
  529. MODULE_DEVICE_TABLE(i2c, lm95245_id);
  530. static const struct of_device_id __maybe_unused lm95245_of_match[] = {
  531. { .compatible = "national,lm95235" },
  532. { .compatible = "national,lm95245" },
  533. { },
  534. };
  535. MODULE_DEVICE_TABLE(of, lm95245_of_match);
  536. static struct i2c_driver lm95245_driver = {
  537. .class = I2C_CLASS_HWMON,
  538. .driver = {
  539. .name = "lm95245",
  540. .of_match_table = of_match_ptr(lm95245_of_match),
  541. },
  542. .probe_new = lm95245_probe,
  543. .id_table = lm95245_id,
  544. .detect = lm95245_detect,
  545. .address_list = normal_i2c,
  546. };
  547. module_i2c_driver(lm95245_driver);
  548. MODULE_AUTHOR("Alexander Stein <[email protected]>");
  549. MODULE_DESCRIPTION("LM95235/LM95245 sensor driver");
  550. MODULE_LICENSE("GPL");