ltc2990.c 7.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Driver for Linear Technology LTC2990 power monitor
  4. *
  5. * Copyright (C) 2014 Topic Embedded Products
  6. * Author: Mike Looijmans <mike.looijmans@topic.nl>
  7. */
  8. #include <linux/bitops.h>
  9. #include <linux/err.h>
  10. #include <linux/hwmon.h>
  11. #include <linux/hwmon-sysfs.h>
  12. #include <linux/i2c.h>
  13. #include <linux/kernel.h>
  14. #include <linux/module.h>
  15. #include <linux/property.h>
  16. #define LTC2990_STATUS 0x00
  17. #define LTC2990_CONTROL 0x01
  18. #define LTC2990_TRIGGER 0x02
  19. #define LTC2990_TINT_MSB 0x04
  20. #define LTC2990_V1_MSB 0x06
  21. #define LTC2990_V2_MSB 0x08
  22. #define LTC2990_V3_MSB 0x0A
  23. #define LTC2990_V4_MSB 0x0C
  24. #define LTC2990_VCC_MSB 0x0E
  25. #define LTC2990_IN0 BIT(0)
  26. #define LTC2990_IN1 BIT(1)
  27. #define LTC2990_IN2 BIT(2)
  28. #define LTC2990_IN3 BIT(3)
  29. #define LTC2990_IN4 BIT(4)
  30. #define LTC2990_CURR1 BIT(5)
  31. #define LTC2990_CURR2 BIT(6)
  32. #define LTC2990_TEMP1 BIT(7)
  33. #define LTC2990_TEMP2 BIT(8)
  34. #define LTC2990_TEMP3 BIT(9)
  35. #define LTC2990_NONE 0
  36. #define LTC2990_ALL GENMASK(9, 0)
  37. #define LTC2990_MODE0_SHIFT 0
  38. #define LTC2990_MODE0_MASK GENMASK(2, 0)
  39. #define LTC2990_MODE1_SHIFT 3
  40. #define LTC2990_MODE1_MASK GENMASK(1, 0)
  41. /* Enabled measurements for mode bits 2..0 */
  42. static const int ltc2990_attrs_ena_0[] = {
  43. LTC2990_IN1 | LTC2990_IN2 | LTC2990_TEMP3,
  44. LTC2990_CURR1 | LTC2990_TEMP3,
  45. LTC2990_CURR1 | LTC2990_IN3 | LTC2990_IN4,
  46. LTC2990_TEMP2 | LTC2990_IN3 | LTC2990_IN4,
  47. LTC2990_TEMP2 | LTC2990_CURR2,
  48. LTC2990_TEMP2 | LTC2990_TEMP3,
  49. LTC2990_CURR1 | LTC2990_CURR2,
  50. LTC2990_IN1 | LTC2990_IN2 | LTC2990_IN3 | LTC2990_IN4
  51. };
  52. /* Enabled measurements for mode bits 4..3 */
  53. static const int ltc2990_attrs_ena_1[] = {
  54. LTC2990_NONE,
  55. LTC2990_TEMP2 | LTC2990_IN1 | LTC2990_CURR1,
  56. LTC2990_TEMP3 | LTC2990_IN3 | LTC2990_CURR2,
  57. LTC2990_ALL
  58. };
  59. struct ltc2990_data {
  60. struct i2c_client *i2c;
  61. u32 mode[2];
  62. };
  63. /* Return the converted value from the given register in uV or mC */
  64. static int ltc2990_get_value(struct i2c_client *i2c, int index, int *result)
  65. {
  66. int val;
  67. u8 reg;
  68. switch (index) {
  69. case LTC2990_IN0:
  70. reg = LTC2990_VCC_MSB;
  71. break;
  72. case LTC2990_IN1:
  73. case LTC2990_CURR1:
  74. case LTC2990_TEMP2:
  75. reg = LTC2990_V1_MSB;
  76. break;
  77. case LTC2990_IN2:
  78. reg = LTC2990_V2_MSB;
  79. break;
  80. case LTC2990_IN3:
  81. case LTC2990_CURR2:
  82. case LTC2990_TEMP3:
  83. reg = LTC2990_V3_MSB;
  84. break;
  85. case LTC2990_IN4:
  86. reg = LTC2990_V4_MSB;
  87. break;
  88. case LTC2990_TEMP1:
  89. reg = LTC2990_TINT_MSB;
  90. break;
  91. default:
  92. return -EINVAL;
  93. }
  94. val = i2c_smbus_read_word_swapped(i2c, reg);
  95. if (unlikely(val < 0))
  96. return val;
  97. switch (index) {
  98. case LTC2990_TEMP1:
  99. case LTC2990_TEMP2:
  100. case LTC2990_TEMP3:
  101. /* temp, 0.0625 degrees/LSB */
  102. *result = sign_extend32(val, 12) * 1000 / 16;
  103. break;
  104. case LTC2990_CURR1:
  105. case LTC2990_CURR2:
  106. /* Vx-Vy, 19.42uV/LSB */
  107. *result = sign_extend32(val, 14) * 1942 / 100;
  108. break;
  109. case LTC2990_IN0:
  110. /* Vcc, 305.18uV/LSB, 2.5V offset */
  111. *result = sign_extend32(val, 14) * 30518 / (100 * 1000) + 2500;
  112. break;
  113. case LTC2990_IN1:
  114. case LTC2990_IN2:
  115. case LTC2990_IN3:
  116. case LTC2990_IN4:
  117. /* Vx, 305.18uV/LSB */
  118. *result = sign_extend32(val, 14) * 30518 / (100 * 1000);
  119. break;
  120. default:
  121. return -EINVAL; /* won't happen, keep compiler happy */
  122. }
  123. return 0;
  124. }
  125. static ssize_t ltc2990_value_show(struct device *dev,
  126. struct device_attribute *da, char *buf)
  127. {
  128. struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
  129. struct ltc2990_data *data = dev_get_drvdata(dev);
  130. int value;
  131. int ret;
  132. ret = ltc2990_get_value(data->i2c, attr->index, &value);
  133. if (unlikely(ret < 0))
  134. return ret;
  135. return snprintf(buf, PAGE_SIZE, "%d\n", value);
  136. }
  137. static umode_t ltc2990_attrs_visible(struct kobject *kobj,
  138. struct attribute *a, int n)
  139. {
  140. struct device *dev = container_of(kobj, struct device, kobj);
  141. struct ltc2990_data *data = dev_get_drvdata(dev);
  142. struct device_attribute *da =
  143. container_of(a, struct device_attribute, attr);
  144. struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
  145. int attrs_mask = LTC2990_IN0 | LTC2990_TEMP1 |
  146. (ltc2990_attrs_ena_0[data->mode[0]] &
  147. ltc2990_attrs_ena_1[data->mode[1]]);
  148. if (attr->index & attrs_mask)
  149. return a->mode;
  150. return 0;
  151. }
  152. static SENSOR_DEVICE_ATTR_RO(temp1_input, ltc2990_value, LTC2990_TEMP1);
  153. static SENSOR_DEVICE_ATTR_RO(temp2_input, ltc2990_value, LTC2990_TEMP2);
  154. static SENSOR_DEVICE_ATTR_RO(temp3_input, ltc2990_value, LTC2990_TEMP3);
  155. static SENSOR_DEVICE_ATTR_RO(curr1_input, ltc2990_value, LTC2990_CURR1);
  156. static SENSOR_DEVICE_ATTR_RO(curr2_input, ltc2990_value, LTC2990_CURR2);
  157. static SENSOR_DEVICE_ATTR_RO(in0_input, ltc2990_value, LTC2990_IN0);
  158. static SENSOR_DEVICE_ATTR_RO(in1_input, ltc2990_value, LTC2990_IN1);
  159. static SENSOR_DEVICE_ATTR_RO(in2_input, ltc2990_value, LTC2990_IN2);
  160. static SENSOR_DEVICE_ATTR_RO(in3_input, ltc2990_value, LTC2990_IN3);
  161. static SENSOR_DEVICE_ATTR_RO(in4_input, ltc2990_value, LTC2990_IN4);
  162. static struct attribute *ltc2990_attrs[] = {
  163. &sensor_dev_attr_temp1_input.dev_attr.attr,
  164. &sensor_dev_attr_temp2_input.dev_attr.attr,
  165. &sensor_dev_attr_temp3_input.dev_attr.attr,
  166. &sensor_dev_attr_curr1_input.dev_attr.attr,
  167. &sensor_dev_attr_curr2_input.dev_attr.attr,
  168. &sensor_dev_attr_in0_input.dev_attr.attr,
  169. &sensor_dev_attr_in1_input.dev_attr.attr,
  170. &sensor_dev_attr_in2_input.dev_attr.attr,
  171. &sensor_dev_attr_in3_input.dev_attr.attr,
  172. &sensor_dev_attr_in4_input.dev_attr.attr,
  173. NULL,
  174. };
  175. static const struct attribute_group ltc2990_group = {
  176. .attrs = ltc2990_attrs,
  177. .is_visible = ltc2990_attrs_visible,
  178. };
  179. __ATTRIBUTE_GROUPS(ltc2990);
  180. static int ltc2990_i2c_probe(struct i2c_client *i2c)
  181. {
  182. int ret;
  183. struct device *hwmon_dev;
  184. struct ltc2990_data *data;
  185. if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA |
  186. I2C_FUNC_SMBUS_WORD_DATA))
  187. return -ENODEV;
  188. data = devm_kzalloc(&i2c->dev, sizeof(struct ltc2990_data), GFP_KERNEL);
  189. if (unlikely(!data))
  190. return -ENOMEM;
  191. data->i2c = i2c;
  192. if (dev_fwnode(&i2c->dev)) {
  193. ret = device_property_read_u32_array(&i2c->dev,
  194. "lltc,meas-mode",
  195. data->mode, 2);
  196. if (ret < 0)
  197. return ret;
  198. if (data->mode[0] & ~LTC2990_MODE0_MASK ||
  199. data->mode[1] & ~LTC2990_MODE1_MASK)
  200. return -EINVAL;
  201. } else {
  202. ret = i2c_smbus_read_byte_data(i2c, LTC2990_CONTROL);
  203. if (ret < 0)
  204. return ret;
  205. data->mode[0] = ret >> LTC2990_MODE0_SHIFT & LTC2990_MODE0_MASK;
  206. data->mode[1] = ret >> LTC2990_MODE1_SHIFT & LTC2990_MODE1_MASK;
  207. }
  208. /* Setup continuous mode */
  209. ret = i2c_smbus_write_byte_data(i2c, LTC2990_CONTROL,
  210. data->mode[0] << LTC2990_MODE0_SHIFT |
  211. data->mode[1] << LTC2990_MODE1_SHIFT);
  212. if (ret < 0) {
  213. dev_err(&i2c->dev, "Error: Failed to set control mode.\n");
  214. return ret;
  215. }
  216. /* Trigger once to start continuous conversion */
  217. ret = i2c_smbus_write_byte_data(i2c, LTC2990_TRIGGER, 1);
  218. if (ret < 0) {
  219. dev_err(&i2c->dev, "Error: Failed to start acquisition.\n");
  220. return ret;
  221. }
  222. hwmon_dev = devm_hwmon_device_register_with_groups(&i2c->dev,
  223. i2c->name,
  224. data,
  225. ltc2990_groups);
  226. return PTR_ERR_OR_ZERO(hwmon_dev);
  227. }
  228. static const struct i2c_device_id ltc2990_i2c_id[] = {
  229. { "ltc2990", 0 },
  230. {}
  231. };
  232. MODULE_DEVICE_TABLE(i2c, ltc2990_i2c_id);
  233. static struct i2c_driver ltc2990_i2c_driver = {
  234. .driver = {
  235. .name = "ltc2990",
  236. },
  237. .probe_new = ltc2990_i2c_probe,
  238. .id_table = ltc2990_i2c_id,
  239. };
  240. module_i2c_driver(ltc2990_i2c_driver);
  241. MODULE_DESCRIPTION("LTC2990 Sensor Driver");
  242. MODULE_AUTHOR("Topic Embedded Products");
  243. MODULE_LICENSE("GPL v2");