lm95234.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Driver for Texas Instruments / National Semiconductor LM95234
  4. *
  5. * Copyright (c) 2013, 2014 Guenter Roeck <[email protected]>
  6. *
  7. * Derived from lm95241.c
  8. * Copyright (C) 2008, 2010 Davide Rizzo <[email protected]>
  9. */
  10. #include <linux/module.h>
  11. #include <linux/init.h>
  12. #include <linux/slab.h>
  13. #include <linux/jiffies.h>
  14. #include <linux/i2c.h>
  15. #include <linux/hwmon.h>
  16. #include <linux/hwmon-sysfs.h>
  17. #include <linux/err.h>
  18. #include <linux/mutex.h>
  19. #include <linux/sysfs.h>
  20. #define DRVNAME "lm95234"
  21. enum chips { lm95233, lm95234 };
  22. static const unsigned short normal_i2c[] = {
  23. 0x18, 0x2a, 0x2b, 0x4d, 0x4e, I2C_CLIENT_END };
  24. /* LM95234 registers */
  25. #define LM95234_REG_MAN_ID 0xFE
  26. #define LM95234_REG_CHIP_ID 0xFF
  27. #define LM95234_REG_STATUS 0x02
  28. #define LM95234_REG_CONFIG 0x03
  29. #define LM95234_REG_CONVRATE 0x04
  30. #define LM95234_REG_STS_FAULT 0x07
  31. #define LM95234_REG_STS_TCRIT1 0x08
  32. #define LM95234_REG_STS_TCRIT2 0x09
  33. #define LM95234_REG_TEMPH(x) ((x) + 0x10)
  34. #define LM95234_REG_TEMPL(x) ((x) + 0x20)
  35. #define LM95234_REG_UTEMPH(x) ((x) + 0x19) /* Remote only */
  36. #define LM95234_REG_UTEMPL(x) ((x) + 0x29)
  37. #define LM95234_REG_REM_MODEL 0x30
  38. #define LM95234_REG_REM_MODEL_STS 0x38
  39. #define LM95234_REG_OFFSET(x) ((x) + 0x31) /* Remote only */
  40. #define LM95234_REG_TCRIT1(x) ((x) + 0x40)
  41. #define LM95234_REG_TCRIT2(x) ((x) + 0x49) /* Remote channel 1,2 */
  42. #define LM95234_REG_TCRIT_HYST 0x5a
  43. #define NATSEMI_MAN_ID 0x01
  44. #define LM95233_CHIP_ID 0x89
  45. #define LM95234_CHIP_ID 0x79
  46. /* Client data (each client gets its own) */
  47. struct lm95234_data {
  48. struct i2c_client *client;
  49. const struct attribute_group *groups[3];
  50. struct mutex update_lock;
  51. unsigned long last_updated, interval; /* in jiffies */
  52. bool valid; /* false until following fields are valid */
  53. /* registers values */
  54. int temp[5]; /* temperature (signed) */
  55. u32 status; /* fault/alarm status */
  56. u8 tcrit1[5]; /* critical temperature limit */
  57. u8 tcrit2[2]; /* high temperature limit */
  58. s8 toffset[4]; /* remote temperature offset */
  59. u8 thyst; /* common hysteresis */
  60. u8 sensor_type; /* temperature sensor type */
  61. };
  62. static int lm95234_read_temp(struct i2c_client *client, int index, int *t)
  63. {
  64. int val;
  65. u16 temp = 0;
  66. if (index) {
  67. val = i2c_smbus_read_byte_data(client,
  68. LM95234_REG_UTEMPH(index - 1));
  69. if (val < 0)
  70. return val;
  71. temp = val << 8;
  72. val = i2c_smbus_read_byte_data(client,
  73. LM95234_REG_UTEMPL(index - 1));
  74. if (val < 0)
  75. return val;
  76. temp |= val;
  77. *t = temp;
  78. }
  79. /*
  80. * Read signed temperature if unsigned temperature is 0,
  81. * or if this is the local sensor.
  82. */
  83. if (!temp) {
  84. val = i2c_smbus_read_byte_data(client,
  85. LM95234_REG_TEMPH(index));
  86. if (val < 0)
  87. return val;
  88. temp = val << 8;
  89. val = i2c_smbus_read_byte_data(client,
  90. LM95234_REG_TEMPL(index));
  91. if (val < 0)
  92. return val;
  93. temp |= val;
  94. *t = (s16)temp;
  95. }
  96. return 0;
  97. }
  98. static u16 update_intervals[] = { 143, 364, 1000, 2500 };
  99. /* Fill value cache. Must be called with update lock held. */
  100. static int lm95234_fill_cache(struct lm95234_data *data,
  101. struct i2c_client *client)
  102. {
  103. int i, ret;
  104. ret = i2c_smbus_read_byte_data(client, LM95234_REG_CONVRATE);
  105. if (ret < 0)
  106. return ret;
  107. data->interval = msecs_to_jiffies(update_intervals[ret & 0x03]);
  108. for (i = 0; i < ARRAY_SIZE(data->tcrit1); i++) {
  109. ret = i2c_smbus_read_byte_data(client, LM95234_REG_TCRIT1(i));
  110. if (ret < 0)
  111. return ret;
  112. data->tcrit1[i] = ret;
  113. }
  114. for (i = 0; i < ARRAY_SIZE(data->tcrit2); i++) {
  115. ret = i2c_smbus_read_byte_data(client, LM95234_REG_TCRIT2(i));
  116. if (ret < 0)
  117. return ret;
  118. data->tcrit2[i] = ret;
  119. }
  120. for (i = 0; i < ARRAY_SIZE(data->toffset); i++) {
  121. ret = i2c_smbus_read_byte_data(client, LM95234_REG_OFFSET(i));
  122. if (ret < 0)
  123. return ret;
  124. data->toffset[i] = ret;
  125. }
  126. ret = i2c_smbus_read_byte_data(client, LM95234_REG_TCRIT_HYST);
  127. if (ret < 0)
  128. return ret;
  129. data->thyst = ret;
  130. ret = i2c_smbus_read_byte_data(client, LM95234_REG_REM_MODEL);
  131. if (ret < 0)
  132. return ret;
  133. data->sensor_type = ret;
  134. return 0;
  135. }
  136. static int lm95234_update_device(struct lm95234_data *data)
  137. {
  138. struct i2c_client *client = data->client;
  139. int ret;
  140. mutex_lock(&data->update_lock);
  141. if (time_after(jiffies, data->last_updated + data->interval) ||
  142. !data->valid) {
  143. int i;
  144. if (!data->valid) {
  145. ret = lm95234_fill_cache(data, client);
  146. if (ret < 0)
  147. goto abort;
  148. }
  149. data->valid = false;
  150. for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
  151. ret = lm95234_read_temp(client, i, &data->temp[i]);
  152. if (ret < 0)
  153. goto abort;
  154. }
  155. ret = i2c_smbus_read_byte_data(client, LM95234_REG_STS_FAULT);
  156. if (ret < 0)
  157. goto abort;
  158. data->status = ret;
  159. ret = i2c_smbus_read_byte_data(client, LM95234_REG_STS_TCRIT1);
  160. if (ret < 0)
  161. goto abort;
  162. data->status |= ret << 8;
  163. ret = i2c_smbus_read_byte_data(client, LM95234_REG_STS_TCRIT2);
  164. if (ret < 0)
  165. goto abort;
  166. data->status |= ret << 16;
  167. data->last_updated = jiffies;
  168. data->valid = true;
  169. }
  170. ret = 0;
  171. abort:
  172. mutex_unlock(&data->update_lock);
  173. return ret;
  174. }
  175. static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
  176. char *buf)
  177. {
  178. struct lm95234_data *data = dev_get_drvdata(dev);
  179. int index = to_sensor_dev_attr(attr)->index;
  180. int ret = lm95234_update_device(data);
  181. if (ret)
  182. return ret;
  183. return sprintf(buf, "%d\n",
  184. DIV_ROUND_CLOSEST(data->temp[index] * 125, 32));
  185. }
  186. static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
  187. char *buf)
  188. {
  189. struct lm95234_data *data = dev_get_drvdata(dev);
  190. u32 mask = to_sensor_dev_attr(attr)->index;
  191. int ret = lm95234_update_device(data);
  192. if (ret)
  193. return ret;
  194. return sprintf(buf, "%u", !!(data->status & mask));
  195. }
  196. static ssize_t type_show(struct device *dev, struct device_attribute *attr,
  197. char *buf)
  198. {
  199. struct lm95234_data *data = dev_get_drvdata(dev);
  200. u8 mask = to_sensor_dev_attr(attr)->index;
  201. int ret = lm95234_update_device(data);
  202. if (ret)
  203. return ret;
  204. return sprintf(buf, data->sensor_type & mask ? "1\n" : "2\n");
  205. }
  206. static ssize_t type_store(struct device *dev, struct device_attribute *attr,
  207. const char *buf, size_t count)
  208. {
  209. struct lm95234_data *data = dev_get_drvdata(dev);
  210. unsigned long val;
  211. u8 mask = to_sensor_dev_attr(attr)->index;
  212. int ret = lm95234_update_device(data);
  213. if (ret)
  214. return ret;
  215. ret = kstrtoul(buf, 10, &val);
  216. if (ret < 0)
  217. return ret;
  218. if (val != 1 && val != 2)
  219. return -EINVAL;
  220. mutex_lock(&data->update_lock);
  221. if (val == 1)
  222. data->sensor_type |= mask;
  223. else
  224. data->sensor_type &= ~mask;
  225. data->valid = false;
  226. i2c_smbus_write_byte_data(data->client, LM95234_REG_REM_MODEL,
  227. data->sensor_type);
  228. mutex_unlock(&data->update_lock);
  229. return count;
  230. }
  231. static ssize_t tcrit2_show(struct device *dev, struct device_attribute *attr,
  232. char *buf)
  233. {
  234. struct lm95234_data *data = dev_get_drvdata(dev);
  235. int index = to_sensor_dev_attr(attr)->index;
  236. int ret = lm95234_update_device(data);
  237. if (ret)
  238. return ret;
  239. return sprintf(buf, "%u", data->tcrit2[index] * 1000);
  240. }
  241. static ssize_t tcrit2_store(struct device *dev, struct device_attribute *attr,
  242. const char *buf, size_t count)
  243. {
  244. struct lm95234_data *data = dev_get_drvdata(dev);
  245. int index = to_sensor_dev_attr(attr)->index;
  246. long val;
  247. int ret = lm95234_update_device(data);
  248. if (ret)
  249. return ret;
  250. ret = kstrtol(buf, 10, &val);
  251. if (ret < 0)
  252. return ret;
  253. val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), 0, index ? 255 : 127);
  254. mutex_lock(&data->update_lock);
  255. data->tcrit2[index] = val;
  256. i2c_smbus_write_byte_data(data->client, LM95234_REG_TCRIT2(index), val);
  257. mutex_unlock(&data->update_lock);
  258. return count;
  259. }
  260. static ssize_t tcrit2_hyst_show(struct device *dev,
  261. struct device_attribute *attr, char *buf)
  262. {
  263. struct lm95234_data *data = dev_get_drvdata(dev);
  264. int index = to_sensor_dev_attr(attr)->index;
  265. int ret = lm95234_update_device(data);
  266. if (ret)
  267. return ret;
  268. /* Result can be negative, so be careful with unsigned operands */
  269. return sprintf(buf, "%d",
  270. ((int)data->tcrit2[index] - (int)data->thyst) * 1000);
  271. }
  272. static ssize_t tcrit1_show(struct device *dev, struct device_attribute *attr,
  273. char *buf)
  274. {
  275. struct lm95234_data *data = dev_get_drvdata(dev);
  276. int index = to_sensor_dev_attr(attr)->index;
  277. return sprintf(buf, "%u", data->tcrit1[index] * 1000);
  278. }
  279. static ssize_t tcrit1_store(struct device *dev, struct device_attribute *attr,
  280. const char *buf, size_t count)
  281. {
  282. struct lm95234_data *data = dev_get_drvdata(dev);
  283. int index = to_sensor_dev_attr(attr)->index;
  284. int ret = lm95234_update_device(data);
  285. long val;
  286. if (ret)
  287. return ret;
  288. ret = kstrtol(buf, 10, &val);
  289. if (ret < 0)
  290. return ret;
  291. val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), 0, 255);
  292. mutex_lock(&data->update_lock);
  293. data->tcrit1[index] = val;
  294. i2c_smbus_write_byte_data(data->client, LM95234_REG_TCRIT1(index), val);
  295. mutex_unlock(&data->update_lock);
  296. return count;
  297. }
  298. static ssize_t tcrit1_hyst_show(struct device *dev,
  299. struct device_attribute *attr, char *buf)
  300. {
  301. struct lm95234_data *data = dev_get_drvdata(dev);
  302. int index = to_sensor_dev_attr(attr)->index;
  303. int ret = lm95234_update_device(data);
  304. if (ret)
  305. return ret;
  306. /* Result can be negative, so be careful with unsigned operands */
  307. return sprintf(buf, "%d",
  308. ((int)data->tcrit1[index] - (int)data->thyst) * 1000);
  309. }
  310. static ssize_t tcrit1_hyst_store(struct device *dev,
  311. struct device_attribute *attr,
  312. const char *buf, size_t count)
  313. {
  314. struct lm95234_data *data = dev_get_drvdata(dev);
  315. int index = to_sensor_dev_attr(attr)->index;
  316. int ret = lm95234_update_device(data);
  317. long val;
  318. if (ret)
  319. return ret;
  320. ret = kstrtol(buf, 10, &val);
  321. if (ret < 0)
  322. return ret;
  323. val = DIV_ROUND_CLOSEST(val, 1000);
  324. val = clamp_val((int)data->tcrit1[index] - val, 0, 31);
  325. mutex_lock(&data->update_lock);
  326. data->thyst = val;
  327. i2c_smbus_write_byte_data(data->client, LM95234_REG_TCRIT_HYST, val);
  328. mutex_unlock(&data->update_lock);
  329. return count;
  330. }
  331. static ssize_t offset_show(struct device *dev, struct device_attribute *attr,
  332. char *buf)
  333. {
  334. struct lm95234_data *data = dev_get_drvdata(dev);
  335. int index = to_sensor_dev_attr(attr)->index;
  336. int ret = lm95234_update_device(data);
  337. if (ret)
  338. return ret;
  339. return sprintf(buf, "%d", data->toffset[index] * 500);
  340. }
  341. static ssize_t offset_store(struct device *dev, struct device_attribute *attr,
  342. const char *buf, size_t count)
  343. {
  344. struct lm95234_data *data = dev_get_drvdata(dev);
  345. int index = to_sensor_dev_attr(attr)->index;
  346. int ret = lm95234_update_device(data);
  347. long val;
  348. if (ret)
  349. return ret;
  350. ret = kstrtol(buf, 10, &val);
  351. if (ret < 0)
  352. return ret;
  353. /* Accuracy is 1/2 degrees C */
  354. val = clamp_val(DIV_ROUND_CLOSEST(val, 500), -128, 127);
  355. mutex_lock(&data->update_lock);
  356. data->toffset[index] = val;
  357. i2c_smbus_write_byte_data(data->client, LM95234_REG_OFFSET(index), val);
  358. mutex_unlock(&data->update_lock);
  359. return count;
  360. }
  361. static ssize_t update_interval_show(struct device *dev,
  362. struct device_attribute *attr, char *buf)
  363. {
  364. struct lm95234_data *data = dev_get_drvdata(dev);
  365. int ret = lm95234_update_device(data);
  366. if (ret)
  367. return ret;
  368. return sprintf(buf, "%lu\n",
  369. DIV_ROUND_CLOSEST(data->interval * 1000, HZ));
  370. }
  371. static ssize_t update_interval_store(struct device *dev,
  372. struct device_attribute *attr,
  373. const char *buf, size_t count)
  374. {
  375. struct lm95234_data *data = dev_get_drvdata(dev);
  376. int ret = lm95234_update_device(data);
  377. unsigned long val;
  378. u8 regval;
  379. if (ret)
  380. return ret;
  381. ret = kstrtoul(buf, 10, &val);
  382. if (ret < 0)
  383. return ret;
  384. for (regval = 0; regval < 3; regval++) {
  385. if (val <= update_intervals[regval])
  386. break;
  387. }
  388. mutex_lock(&data->update_lock);
  389. data->interval = msecs_to_jiffies(update_intervals[regval]);
  390. i2c_smbus_write_byte_data(data->client, LM95234_REG_CONVRATE, regval);
  391. mutex_unlock(&data->update_lock);
  392. return count;
  393. }
  394. static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
  395. static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
  396. static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
  397. static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3);
  398. static SENSOR_DEVICE_ATTR_RO(temp5_input, temp, 4);
  399. static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, BIT(0) | BIT(1));
  400. static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, BIT(2) | BIT(3));
  401. static SENSOR_DEVICE_ATTR_RO(temp4_fault, alarm, BIT(4) | BIT(5));
  402. static SENSOR_DEVICE_ATTR_RO(temp5_fault, alarm, BIT(6) | BIT(7));
  403. static SENSOR_DEVICE_ATTR_RW(temp2_type, type, BIT(1));
  404. static SENSOR_DEVICE_ATTR_RW(temp3_type, type, BIT(2));
  405. static SENSOR_DEVICE_ATTR_RW(temp4_type, type, BIT(3));
  406. static SENSOR_DEVICE_ATTR_RW(temp5_type, type, BIT(4));
  407. static SENSOR_DEVICE_ATTR_RW(temp1_max, tcrit1, 0);
  408. static SENSOR_DEVICE_ATTR_RW(temp2_max, tcrit2, 0);
  409. static SENSOR_DEVICE_ATTR_RW(temp3_max, tcrit2, 1);
  410. static SENSOR_DEVICE_ATTR_RW(temp4_max, tcrit1, 3);
  411. static SENSOR_DEVICE_ATTR_RW(temp5_max, tcrit1, 4);
  412. static SENSOR_DEVICE_ATTR_RW(temp1_max_hyst, tcrit1_hyst, 0);
  413. static SENSOR_DEVICE_ATTR_RO(temp2_max_hyst, tcrit2_hyst, 0);
  414. static SENSOR_DEVICE_ATTR_RO(temp3_max_hyst, tcrit2_hyst, 1);
  415. static SENSOR_DEVICE_ATTR_RO(temp4_max_hyst, tcrit1_hyst, 3);
  416. static SENSOR_DEVICE_ATTR_RO(temp5_max_hyst, tcrit1_hyst, 4);
  417. static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, BIT(0 + 8));
  418. static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, alarm, BIT(1 + 16));
  419. static SENSOR_DEVICE_ATTR_RO(temp3_max_alarm, alarm, BIT(2 + 16));
  420. static SENSOR_DEVICE_ATTR_RO(temp4_max_alarm, alarm, BIT(3 + 8));
  421. static SENSOR_DEVICE_ATTR_RO(temp5_max_alarm, alarm, BIT(4 + 8));
  422. static SENSOR_DEVICE_ATTR_RW(temp2_crit, tcrit1, 1);
  423. static SENSOR_DEVICE_ATTR_RW(temp3_crit, tcrit1, 2);
  424. static SENSOR_DEVICE_ATTR_RO(temp2_crit_hyst, tcrit1_hyst, 1);
  425. static SENSOR_DEVICE_ATTR_RO(temp3_crit_hyst, tcrit1_hyst, 2);
  426. static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, alarm, BIT(1 + 8));
  427. static SENSOR_DEVICE_ATTR_RO(temp3_crit_alarm, alarm, BIT(2 + 8));
  428. static SENSOR_DEVICE_ATTR_RW(temp2_offset, offset, 0);
  429. static SENSOR_DEVICE_ATTR_RW(temp3_offset, offset, 1);
  430. static SENSOR_DEVICE_ATTR_RW(temp4_offset, offset, 2);
  431. static SENSOR_DEVICE_ATTR_RW(temp5_offset, offset, 3);
  432. static DEVICE_ATTR_RW(update_interval);
  433. static struct attribute *lm95234_common_attrs[] = {
  434. &sensor_dev_attr_temp1_input.dev_attr.attr,
  435. &sensor_dev_attr_temp2_input.dev_attr.attr,
  436. &sensor_dev_attr_temp3_input.dev_attr.attr,
  437. &sensor_dev_attr_temp2_fault.dev_attr.attr,
  438. &sensor_dev_attr_temp3_fault.dev_attr.attr,
  439. &sensor_dev_attr_temp2_type.dev_attr.attr,
  440. &sensor_dev_attr_temp3_type.dev_attr.attr,
  441. &sensor_dev_attr_temp1_max.dev_attr.attr,
  442. &sensor_dev_attr_temp2_max.dev_attr.attr,
  443. &sensor_dev_attr_temp3_max.dev_attr.attr,
  444. &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
  445. &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
  446. &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
  447. &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
  448. &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
  449. &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
  450. &sensor_dev_attr_temp2_crit.dev_attr.attr,
  451. &sensor_dev_attr_temp3_crit.dev_attr.attr,
  452. &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
  453. &sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,
  454. &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
  455. &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
  456. &sensor_dev_attr_temp2_offset.dev_attr.attr,
  457. &sensor_dev_attr_temp3_offset.dev_attr.attr,
  458. &dev_attr_update_interval.attr,
  459. NULL
  460. };
  461. static const struct attribute_group lm95234_common_group = {
  462. .attrs = lm95234_common_attrs,
  463. };
  464. static struct attribute *lm95234_attrs[] = {
  465. &sensor_dev_attr_temp4_input.dev_attr.attr,
  466. &sensor_dev_attr_temp5_input.dev_attr.attr,
  467. &sensor_dev_attr_temp4_fault.dev_attr.attr,
  468. &sensor_dev_attr_temp5_fault.dev_attr.attr,
  469. &sensor_dev_attr_temp4_type.dev_attr.attr,
  470. &sensor_dev_attr_temp5_type.dev_attr.attr,
  471. &sensor_dev_attr_temp4_max.dev_attr.attr,
  472. &sensor_dev_attr_temp5_max.dev_attr.attr,
  473. &sensor_dev_attr_temp4_max_hyst.dev_attr.attr,
  474. &sensor_dev_attr_temp5_max_hyst.dev_attr.attr,
  475. &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
  476. &sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
  477. &sensor_dev_attr_temp4_offset.dev_attr.attr,
  478. &sensor_dev_attr_temp5_offset.dev_attr.attr,
  479. NULL
  480. };
  481. static const struct attribute_group lm95234_group = {
  482. .attrs = lm95234_attrs,
  483. };
  484. static int lm95234_detect(struct i2c_client *client,
  485. struct i2c_board_info *info)
  486. {
  487. struct i2c_adapter *adapter = client->adapter;
  488. int address = client->addr;
  489. u8 config_mask, model_mask;
  490. int mfg_id, chip_id, val;
  491. const char *name;
  492. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  493. return -ENODEV;
  494. mfg_id = i2c_smbus_read_byte_data(client, LM95234_REG_MAN_ID);
  495. if (mfg_id != NATSEMI_MAN_ID)
  496. return -ENODEV;
  497. chip_id = i2c_smbus_read_byte_data(client, LM95234_REG_CHIP_ID);
  498. switch (chip_id) {
  499. case LM95233_CHIP_ID:
  500. if (address != 0x18 && address != 0x2a && address != 0x2b)
  501. return -ENODEV;
  502. config_mask = 0xbf;
  503. model_mask = 0xf9;
  504. name = "lm95233";
  505. break;
  506. case LM95234_CHIP_ID:
  507. if (address != 0x18 && address != 0x4d && address != 0x4e)
  508. return -ENODEV;
  509. config_mask = 0xbc;
  510. model_mask = 0xe1;
  511. name = "lm95234";
  512. break;
  513. default:
  514. return -ENODEV;
  515. }
  516. val = i2c_smbus_read_byte_data(client, LM95234_REG_STATUS);
  517. if (val & 0x30)
  518. return -ENODEV;
  519. val = i2c_smbus_read_byte_data(client, LM95234_REG_CONFIG);
  520. if (val & config_mask)
  521. return -ENODEV;
  522. val = i2c_smbus_read_byte_data(client, LM95234_REG_CONVRATE);
  523. if (val & 0xfc)
  524. return -ENODEV;
  525. val = i2c_smbus_read_byte_data(client, LM95234_REG_REM_MODEL);
  526. if (val & model_mask)
  527. return -ENODEV;
  528. val = i2c_smbus_read_byte_data(client, LM95234_REG_REM_MODEL_STS);
  529. if (val & model_mask)
  530. return -ENODEV;
  531. strscpy(info->type, name, I2C_NAME_SIZE);
  532. return 0;
  533. }
  534. static int lm95234_init_client(struct i2c_client *client)
  535. {
  536. int val, model;
  537. /* start conversion if necessary */
  538. val = i2c_smbus_read_byte_data(client, LM95234_REG_CONFIG);
  539. if (val < 0)
  540. return val;
  541. if (val & 0x40)
  542. i2c_smbus_write_byte_data(client, LM95234_REG_CONFIG,
  543. val & ~0x40);
  544. /* If diode type status reports an error, try to fix it */
  545. val = i2c_smbus_read_byte_data(client, LM95234_REG_REM_MODEL_STS);
  546. if (val < 0)
  547. return val;
  548. model = i2c_smbus_read_byte_data(client, LM95234_REG_REM_MODEL);
  549. if (model < 0)
  550. return model;
  551. if (model & val) {
  552. dev_notice(&client->dev,
  553. "Fixing remote diode type misconfiguration (0x%x)\n",
  554. val);
  555. i2c_smbus_write_byte_data(client, LM95234_REG_REM_MODEL,
  556. model & ~val);
  557. }
  558. return 0;
  559. }
  560. static const struct i2c_device_id lm95234_id[];
  561. static int lm95234_probe(struct i2c_client *client)
  562. {
  563. struct device *dev = &client->dev;
  564. struct lm95234_data *data;
  565. struct device *hwmon_dev;
  566. int err;
  567. data = devm_kzalloc(dev, sizeof(struct lm95234_data), GFP_KERNEL);
  568. if (!data)
  569. return -ENOMEM;
  570. data->client = client;
  571. mutex_init(&data->update_lock);
  572. /* Initialize the LM95234 chip */
  573. err = lm95234_init_client(client);
  574. if (err < 0)
  575. return err;
  576. data->groups[0] = &lm95234_common_group;
  577. if (i2c_match_id(lm95234_id, client)->driver_data == lm95234)
  578. data->groups[1] = &lm95234_group;
  579. hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
  580. data, data->groups);
  581. return PTR_ERR_OR_ZERO(hwmon_dev);
  582. }
  583. /* Driver data (common to all clients) */
  584. static const struct i2c_device_id lm95234_id[] = {
  585. { "lm95233", lm95233 },
  586. { "lm95234", lm95234 },
  587. { }
  588. };
  589. MODULE_DEVICE_TABLE(i2c, lm95234_id);
  590. static struct i2c_driver lm95234_driver = {
  591. .class = I2C_CLASS_HWMON,
  592. .driver = {
  593. .name = DRVNAME,
  594. },
  595. .probe_new = lm95234_probe,
  596. .id_table = lm95234_id,
  597. .detect = lm95234_detect,
  598. .address_list = normal_i2c,
  599. };
  600. module_i2c_driver(lm95234_driver);
  601. MODULE_AUTHOR("Guenter Roeck <[email protected]>");
  602. MODULE_DESCRIPTION("LM95233/LM95234 sensor driver");
  603. MODULE_LICENSE("GPL");