adc128d818.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Driver for TI ADC128D818 System Monitor with Temperature Sensor
  4. *
  5. * Copyright (c) 2014 Guenter Roeck
  6. *
  7. * Derived from lm80.c
  8. * Copyright (C) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
  9. * and Philip Edelbrock <phil@netroedge.com>
  10. */
  11. #include <linux/module.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/regulator/consumer.h>
  19. #include <linux/mutex.h>
  20. #include <linux/bitops.h>
  21. #include <linux/of.h>
  22. /* Addresses to scan
  23. * The chip also supports addresses 0x35..0x37. Don't scan those addresses
  24. * since they are also used by some EEPROMs, which may result in false
  25. * positives.
  26. */
  27. static const unsigned short normal_i2c[] = {
  28. 0x1d, 0x1e, 0x1f, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END };
  29. /* registers */
  30. #define ADC128_REG_IN_MAX(nr) (0x2a + (nr) * 2)
  31. #define ADC128_REG_IN_MIN(nr) (0x2b + (nr) * 2)
  32. #define ADC128_REG_IN(nr) (0x20 + (nr))
  33. #define ADC128_REG_TEMP 0x27
  34. #define ADC128_REG_TEMP_MAX 0x38
  35. #define ADC128_REG_TEMP_HYST 0x39
  36. #define ADC128_REG_CONFIG 0x00
  37. #define ADC128_REG_ALARM 0x01
  38. #define ADC128_REG_MASK 0x03
  39. #define ADC128_REG_CONV_RATE 0x07
  40. #define ADC128_REG_ONESHOT 0x09
  41. #define ADC128_REG_SHUTDOWN 0x0a
  42. #define ADC128_REG_CONFIG_ADV 0x0b
  43. #define ADC128_REG_BUSY_STATUS 0x0c
  44. #define ADC128_REG_MAN_ID 0x3e
  45. #define ADC128_REG_DEV_ID 0x3f
  46. /* No. of voltage entries in adc128_attrs */
  47. #define ADC128_ATTR_NUM_VOLT (8 * 4)
  48. /* Voltage inputs visible per operation mode */
  49. static const u8 num_inputs[] = { 7, 8, 4, 6 };
  50. struct adc128_data {
  51. struct i2c_client *client;
  52. struct regulator *regulator;
  53. int vref; /* Reference voltage in mV */
  54. struct mutex update_lock;
  55. u8 mode; /* Operation mode */
  56. bool valid; /* true if following fields are valid */
  57. unsigned long last_updated; /* In jiffies */
  58. u16 in[3][8]; /* Register value, normalized to 12 bit
  59. * 0: input voltage
  60. * 1: min limit
  61. * 2: max limit
  62. */
  63. s16 temp[3]; /* Register value, normalized to 9 bit
  64. * 0: sensor 1: limit 2: hyst
  65. */
  66. u8 alarms; /* alarm register value */
  67. };
  68. static struct adc128_data *adc128_update_device(struct device *dev)
  69. {
  70. struct adc128_data *data = dev_get_drvdata(dev);
  71. struct i2c_client *client = data->client;
  72. struct adc128_data *ret = data;
  73. int i, rv;
  74. mutex_lock(&data->update_lock);
  75. if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
  76. for (i = 0; i < num_inputs[data->mode]; i++) {
  77. rv = i2c_smbus_read_word_swapped(client,
  78. ADC128_REG_IN(i));
  79. if (rv < 0)
  80. goto abort;
  81. data->in[0][i] = rv >> 4;
  82. rv = i2c_smbus_read_byte_data(client,
  83. ADC128_REG_IN_MIN(i));
  84. if (rv < 0)
  85. goto abort;
  86. data->in[1][i] = rv << 4;
  87. rv = i2c_smbus_read_byte_data(client,
  88. ADC128_REG_IN_MAX(i));
  89. if (rv < 0)
  90. goto abort;
  91. data->in[2][i] = rv << 4;
  92. }
  93. if (data->mode != 1) {
  94. rv = i2c_smbus_read_word_swapped(client,
  95. ADC128_REG_TEMP);
  96. if (rv < 0)
  97. goto abort;
  98. data->temp[0] = rv >> 7;
  99. rv = i2c_smbus_read_byte_data(client,
  100. ADC128_REG_TEMP_MAX);
  101. if (rv < 0)
  102. goto abort;
  103. data->temp[1] = rv << 1;
  104. rv = i2c_smbus_read_byte_data(client,
  105. ADC128_REG_TEMP_HYST);
  106. if (rv < 0)
  107. goto abort;
  108. data->temp[2] = rv << 1;
  109. }
  110. rv = i2c_smbus_read_byte_data(client, ADC128_REG_ALARM);
  111. if (rv < 0)
  112. goto abort;
  113. data->alarms |= rv;
  114. data->last_updated = jiffies;
  115. data->valid = true;
  116. }
  117. goto done;
  118. abort:
  119. ret = ERR_PTR(rv);
  120. data->valid = false;
  121. done:
  122. mutex_unlock(&data->update_lock);
  123. return ret;
  124. }
  125. static ssize_t adc128_in_show(struct device *dev,
  126. struct device_attribute *attr, char *buf)
  127. {
  128. struct adc128_data *data = adc128_update_device(dev);
  129. int index = to_sensor_dev_attr_2(attr)->index;
  130. int nr = to_sensor_dev_attr_2(attr)->nr;
  131. int val;
  132. if (IS_ERR(data))
  133. return PTR_ERR(data);
  134. val = DIV_ROUND_CLOSEST(data->in[index][nr] * data->vref, 4095);
  135. return sprintf(buf, "%d\n", val);
  136. }
  137. static ssize_t adc128_in_store(struct device *dev,
  138. struct device_attribute *attr, const char *buf,
  139. size_t count)
  140. {
  141. struct adc128_data *data = dev_get_drvdata(dev);
  142. int index = to_sensor_dev_attr_2(attr)->index;
  143. int nr = to_sensor_dev_attr_2(attr)->nr;
  144. u8 reg, regval;
  145. long val;
  146. int err;
  147. err = kstrtol(buf, 10, &val);
  148. if (err < 0)
  149. return err;
  150. mutex_lock(&data->update_lock);
  151. /* 10 mV LSB on limit registers */
  152. regval = clamp_val(DIV_ROUND_CLOSEST(val, 10), 0, 255);
  153. data->in[index][nr] = regval << 4;
  154. reg = index == 1 ? ADC128_REG_IN_MIN(nr) : ADC128_REG_IN_MAX(nr);
  155. i2c_smbus_write_byte_data(data->client, reg, regval);
  156. mutex_unlock(&data->update_lock);
  157. return count;
  158. }
  159. static ssize_t adc128_temp_show(struct device *dev,
  160. struct device_attribute *attr, char *buf)
  161. {
  162. struct adc128_data *data = adc128_update_device(dev);
  163. int index = to_sensor_dev_attr(attr)->index;
  164. int temp;
  165. if (IS_ERR(data))
  166. return PTR_ERR(data);
  167. temp = sign_extend32(data->temp[index], 8);
  168. return sprintf(buf, "%d\n", temp * 500);/* 0.5 degrees C resolution */
  169. }
  170. static ssize_t adc128_temp_store(struct device *dev,
  171. struct device_attribute *attr,
  172. const char *buf, size_t count)
  173. {
  174. struct adc128_data *data = dev_get_drvdata(dev);
  175. int index = to_sensor_dev_attr(attr)->index;
  176. long val;
  177. int err;
  178. s8 regval;
  179. err = kstrtol(buf, 10, &val);
  180. if (err < 0)
  181. return err;
  182. mutex_lock(&data->update_lock);
  183. regval = clamp_val(DIV_ROUND_CLOSEST(val, 1000), -128, 127);
  184. data->temp[index] = regval << 1;
  185. i2c_smbus_write_byte_data(data->client,
  186. index == 1 ? ADC128_REG_TEMP_MAX
  187. : ADC128_REG_TEMP_HYST,
  188. regval);
  189. mutex_unlock(&data->update_lock);
  190. return count;
  191. }
  192. static ssize_t adc128_alarm_show(struct device *dev,
  193. struct device_attribute *attr, char *buf)
  194. {
  195. struct adc128_data *data = adc128_update_device(dev);
  196. int mask = 1 << to_sensor_dev_attr(attr)->index;
  197. u8 alarms;
  198. if (IS_ERR(data))
  199. return PTR_ERR(data);
  200. /*
  201. * Clear an alarm after reporting it to user space. If it is still
  202. * active, the next update sequence will set the alarm bit again.
  203. */
  204. alarms = data->alarms;
  205. data->alarms &= ~mask;
  206. return sprintf(buf, "%u\n", !!(alarms & mask));
  207. }
  208. static umode_t adc128_is_visible(struct kobject *kobj,
  209. struct attribute *attr, int index)
  210. {
  211. struct device *dev = container_of(kobj, struct device, kobj);
  212. struct adc128_data *data = dev_get_drvdata(dev);
  213. if (index < ADC128_ATTR_NUM_VOLT) {
  214. /* Voltage, visible according to num_inputs[] */
  215. if (index >= num_inputs[data->mode] * 4)
  216. return 0;
  217. } else {
  218. /* Temperature, visible if not in mode 1 */
  219. if (data->mode == 1)
  220. return 0;
  221. }
  222. return attr->mode;
  223. }
  224. static SENSOR_DEVICE_ATTR_2_RO(in0_input, adc128_in, 0, 0);
  225. static SENSOR_DEVICE_ATTR_2_RW(in0_min, adc128_in, 0, 1);
  226. static SENSOR_DEVICE_ATTR_2_RW(in0_max, adc128_in, 0, 2);
  227. static SENSOR_DEVICE_ATTR_2_RO(in1_input, adc128_in, 1, 0);
  228. static SENSOR_DEVICE_ATTR_2_RW(in1_min, adc128_in, 1, 1);
  229. static SENSOR_DEVICE_ATTR_2_RW(in1_max, adc128_in, 1, 2);
  230. static SENSOR_DEVICE_ATTR_2_RO(in2_input, adc128_in, 2, 0);
  231. static SENSOR_DEVICE_ATTR_2_RW(in2_min, adc128_in, 2, 1);
  232. static SENSOR_DEVICE_ATTR_2_RW(in2_max, adc128_in, 2, 2);
  233. static SENSOR_DEVICE_ATTR_2_RO(in3_input, adc128_in, 3, 0);
  234. static SENSOR_DEVICE_ATTR_2_RW(in3_min, adc128_in, 3, 1);
  235. static SENSOR_DEVICE_ATTR_2_RW(in3_max, adc128_in, 3, 2);
  236. static SENSOR_DEVICE_ATTR_2_RO(in4_input, adc128_in, 4, 0);
  237. static SENSOR_DEVICE_ATTR_2_RW(in4_min, adc128_in, 4, 1);
  238. static SENSOR_DEVICE_ATTR_2_RW(in4_max, adc128_in, 4, 2);
  239. static SENSOR_DEVICE_ATTR_2_RO(in5_input, adc128_in, 5, 0);
  240. static SENSOR_DEVICE_ATTR_2_RW(in5_min, adc128_in, 5, 1);
  241. static SENSOR_DEVICE_ATTR_2_RW(in5_max, adc128_in, 5, 2);
  242. static SENSOR_DEVICE_ATTR_2_RO(in6_input, adc128_in, 6, 0);
  243. static SENSOR_DEVICE_ATTR_2_RW(in6_min, adc128_in, 6, 1);
  244. static SENSOR_DEVICE_ATTR_2_RW(in6_max, adc128_in, 6, 2);
  245. static SENSOR_DEVICE_ATTR_2_RO(in7_input, adc128_in, 7, 0);
  246. static SENSOR_DEVICE_ATTR_2_RW(in7_min, adc128_in, 7, 1);
  247. static SENSOR_DEVICE_ATTR_2_RW(in7_max, adc128_in, 7, 2);
  248. static SENSOR_DEVICE_ATTR_RO(temp1_input, adc128_temp, 0);
  249. static SENSOR_DEVICE_ATTR_RW(temp1_max, adc128_temp, 1);
  250. static SENSOR_DEVICE_ATTR_RW(temp1_max_hyst, adc128_temp, 2);
  251. static SENSOR_DEVICE_ATTR_RO(in0_alarm, adc128_alarm, 0);
  252. static SENSOR_DEVICE_ATTR_RO(in1_alarm, adc128_alarm, 1);
  253. static SENSOR_DEVICE_ATTR_RO(in2_alarm, adc128_alarm, 2);
  254. static SENSOR_DEVICE_ATTR_RO(in3_alarm, adc128_alarm, 3);
  255. static SENSOR_DEVICE_ATTR_RO(in4_alarm, adc128_alarm, 4);
  256. static SENSOR_DEVICE_ATTR_RO(in5_alarm, adc128_alarm, 5);
  257. static SENSOR_DEVICE_ATTR_RO(in6_alarm, adc128_alarm, 6);
  258. static SENSOR_DEVICE_ATTR_RO(in7_alarm, adc128_alarm, 7);
  259. static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, adc128_alarm, 7);
  260. static struct attribute *adc128_attrs[] = {
  261. &sensor_dev_attr_in0_alarm.dev_attr.attr,
  262. &sensor_dev_attr_in0_input.dev_attr.attr,
  263. &sensor_dev_attr_in0_max.dev_attr.attr,
  264. &sensor_dev_attr_in0_min.dev_attr.attr,
  265. &sensor_dev_attr_in1_alarm.dev_attr.attr,
  266. &sensor_dev_attr_in1_input.dev_attr.attr,
  267. &sensor_dev_attr_in1_max.dev_attr.attr,
  268. &sensor_dev_attr_in1_min.dev_attr.attr,
  269. &sensor_dev_attr_in2_alarm.dev_attr.attr,
  270. &sensor_dev_attr_in2_input.dev_attr.attr,
  271. &sensor_dev_attr_in2_max.dev_attr.attr,
  272. &sensor_dev_attr_in2_min.dev_attr.attr,
  273. &sensor_dev_attr_in3_alarm.dev_attr.attr,
  274. &sensor_dev_attr_in3_input.dev_attr.attr,
  275. &sensor_dev_attr_in3_max.dev_attr.attr,
  276. &sensor_dev_attr_in3_min.dev_attr.attr,
  277. &sensor_dev_attr_in4_alarm.dev_attr.attr,
  278. &sensor_dev_attr_in4_input.dev_attr.attr,
  279. &sensor_dev_attr_in4_max.dev_attr.attr,
  280. &sensor_dev_attr_in4_min.dev_attr.attr,
  281. &sensor_dev_attr_in5_alarm.dev_attr.attr,
  282. &sensor_dev_attr_in5_input.dev_attr.attr,
  283. &sensor_dev_attr_in5_max.dev_attr.attr,
  284. &sensor_dev_attr_in5_min.dev_attr.attr,
  285. &sensor_dev_attr_in6_alarm.dev_attr.attr,
  286. &sensor_dev_attr_in6_input.dev_attr.attr,
  287. &sensor_dev_attr_in6_max.dev_attr.attr,
  288. &sensor_dev_attr_in6_min.dev_attr.attr,
  289. &sensor_dev_attr_in7_alarm.dev_attr.attr,
  290. &sensor_dev_attr_in7_input.dev_attr.attr,
  291. &sensor_dev_attr_in7_max.dev_attr.attr,
  292. &sensor_dev_attr_in7_min.dev_attr.attr,
  293. &sensor_dev_attr_temp1_input.dev_attr.attr,
  294. &sensor_dev_attr_temp1_max.dev_attr.attr,
  295. &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
  296. &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
  297. NULL
  298. };
  299. static const struct attribute_group adc128_group = {
  300. .attrs = adc128_attrs,
  301. .is_visible = adc128_is_visible,
  302. };
  303. __ATTRIBUTE_GROUPS(adc128);
  304. static int adc128_detect(struct i2c_client *client, struct i2c_board_info *info)
  305. {
  306. int man_id, dev_id;
  307. if (!i2c_check_functionality(client->adapter,
  308. I2C_FUNC_SMBUS_BYTE_DATA |
  309. I2C_FUNC_SMBUS_WORD_DATA))
  310. return -ENODEV;
  311. man_id = i2c_smbus_read_byte_data(client, ADC128_REG_MAN_ID);
  312. dev_id = i2c_smbus_read_byte_data(client, ADC128_REG_DEV_ID);
  313. if (man_id != 0x01 || dev_id != 0x09)
  314. return -ENODEV;
  315. /* Check unused bits for confirmation */
  316. if (i2c_smbus_read_byte_data(client, ADC128_REG_CONFIG) & 0xf4)
  317. return -ENODEV;
  318. if (i2c_smbus_read_byte_data(client, ADC128_REG_CONV_RATE) & 0xfe)
  319. return -ENODEV;
  320. if (i2c_smbus_read_byte_data(client, ADC128_REG_ONESHOT) & 0xfe)
  321. return -ENODEV;
  322. if (i2c_smbus_read_byte_data(client, ADC128_REG_SHUTDOWN) & 0xfe)
  323. return -ENODEV;
  324. if (i2c_smbus_read_byte_data(client, ADC128_REG_CONFIG_ADV) & 0xf8)
  325. return -ENODEV;
  326. if (i2c_smbus_read_byte_data(client, ADC128_REG_BUSY_STATUS) & 0xfc)
  327. return -ENODEV;
  328. strlcpy(info->type, "adc128d818", I2C_NAME_SIZE);
  329. return 0;
  330. }
  331. static int adc128_init_client(struct adc128_data *data)
  332. {
  333. struct i2c_client *client = data->client;
  334. int err;
  335. u8 regval = 0x0;
  336. /*
  337. * Reset chip to defaults.
  338. * This makes most other initializations unnecessary.
  339. */
  340. err = i2c_smbus_write_byte_data(client, ADC128_REG_CONFIG, 0x80);
  341. if (err)
  342. return err;
  343. /* Set operation mode, if non-default */
  344. if (data->mode != 0)
  345. regval |= data->mode << 1;
  346. /* If external vref is selected, configure the chip to use it */
  347. if (data->regulator)
  348. regval |= 0x01;
  349. /* Write advanced configuration register */
  350. if (regval != 0x0) {
  351. err = i2c_smbus_write_byte_data(client, ADC128_REG_CONFIG_ADV,
  352. regval);
  353. if (err)
  354. return err;
  355. }
  356. /* Start monitoring */
  357. err = i2c_smbus_write_byte_data(client, ADC128_REG_CONFIG, 0x01);
  358. if (err)
  359. return err;
  360. return 0;
  361. }
  362. static int adc128_probe(struct i2c_client *client)
  363. {
  364. struct device *dev = &client->dev;
  365. struct regulator *regulator;
  366. struct device *hwmon_dev;
  367. struct adc128_data *data;
  368. int err, vref;
  369. data = devm_kzalloc(dev, sizeof(struct adc128_data), GFP_KERNEL);
  370. if (!data)
  371. return -ENOMEM;
  372. /* vref is optional. If specified, is used as chip reference voltage */
  373. regulator = devm_regulator_get_optional(dev, "vref");
  374. if (!IS_ERR(regulator)) {
  375. data->regulator = regulator;
  376. err = regulator_enable(regulator);
  377. if (err < 0)
  378. return err;
  379. vref = regulator_get_voltage(regulator);
  380. if (vref < 0) {
  381. err = vref;
  382. goto error;
  383. }
  384. data->vref = DIV_ROUND_CLOSEST(vref, 1000);
  385. } else {
  386. data->vref = 2560; /* 2.56V, in mV */
  387. }
  388. /* Operation mode is optional. If unspecified, keep current mode */
  389. if (of_property_read_u8(dev->of_node, "ti,mode", &data->mode) == 0) {
  390. if (data->mode > 3) {
  391. dev_err(dev, "invalid operation mode %d\n",
  392. data->mode);
  393. err = -EINVAL;
  394. goto error;
  395. }
  396. } else {
  397. err = i2c_smbus_read_byte_data(client, ADC128_REG_CONFIG_ADV);
  398. if (err < 0)
  399. goto error;
  400. data->mode = (err >> 1) & ADC128_REG_MASK;
  401. }
  402. data->client = client;
  403. i2c_set_clientdata(client, data);
  404. mutex_init(&data->update_lock);
  405. /* Initialize the chip */
  406. err = adc128_init_client(data);
  407. if (err < 0)
  408. goto error;
  409. hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
  410. data, adc128_groups);
  411. if (IS_ERR(hwmon_dev)) {
  412. err = PTR_ERR(hwmon_dev);
  413. goto error;
  414. }
  415. return 0;
  416. error:
  417. if (data->regulator)
  418. regulator_disable(data->regulator);
  419. return err;
  420. }
  421. static int adc128_remove(struct i2c_client *client)
  422. {
  423. struct adc128_data *data = i2c_get_clientdata(client);
  424. if (data->regulator)
  425. regulator_disable(data->regulator);
  426. return 0;
  427. }
  428. static const struct i2c_device_id adc128_id[] = {
  429. { "adc128d818", 0 },
  430. { }
  431. };
  432. MODULE_DEVICE_TABLE(i2c, adc128_id);
  433. static const struct of_device_id __maybe_unused adc128_of_match[] = {
  434. { .compatible = "ti,adc128d818" },
  435. { },
  436. };
  437. MODULE_DEVICE_TABLE(of, adc128_of_match);
  438. static struct i2c_driver adc128_driver = {
  439. .class = I2C_CLASS_HWMON,
  440. .driver = {
  441. .name = "adc128d818",
  442. .of_match_table = of_match_ptr(adc128_of_match),
  443. },
  444. .probe_new = adc128_probe,
  445. .remove = adc128_remove,
  446. .id_table = adc128_id,
  447. .detect = adc128_detect,
  448. .address_list = normal_i2c,
  449. };
  450. module_i2c_driver(adc128_driver);
  451. MODULE_AUTHOR("Guenter Roeck");
  452. MODULE_DESCRIPTION("Driver for ADC128D818");
  453. MODULE_LICENSE("GPL");