ads7828.c 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * ads7828.c - driver for TI ADS7828 8-channel A/D converter and compatibles
  4. * (C) 2007 EADS Astrium
  5. *
  6. * This driver is based on the lm75 and other lm_sensors/hwmon drivers
  7. *
  8. * Written by Steve Hardy <[email protected]>
  9. *
  10. * ADS7830 support, by Guillaume Roguez <[email protected]>
  11. *
  12. * For further information, see the Documentation/hwmon/ads7828.rst file.
  13. */
  14. #include <linux/err.h>
  15. #include <linux/hwmon.h>
  16. #include <linux/hwmon-sysfs.h>
  17. #include <linux/i2c.h>
  18. #include <linux/init.h>
  19. #include <linux/module.h>
  20. #include <linux/of_device.h>
  21. #include <linux/platform_data/ads7828.h>
  22. #include <linux/regmap.h>
  23. #include <linux/slab.h>
  24. #include <linux/regulator/consumer.h>
  25. /* The ADS7828 registers */
  26. #define ADS7828_CMD_SD_SE 0x80 /* Single ended inputs */
  27. #define ADS7828_CMD_PD1 0x04 /* Internal vref OFF && A/D ON */
  28. #define ADS7828_CMD_PD3 0x0C /* Internal vref ON && A/D ON */
  29. #define ADS7828_INT_VREF_MV 2500 /* Internal vref is 2.5V, 2500mV */
  30. #define ADS7828_EXT_VREF_MV_MIN 50 /* External vref min value 0.05V */
  31. #define ADS7828_EXT_VREF_MV_MAX 5250 /* External vref max value 5.25V */
  32. /* List of supported devices */
  33. enum ads7828_chips { ads7828, ads7830 };
  34. /* Client specific data */
  35. struct ads7828_data {
  36. struct regmap *regmap;
  37. u8 cmd_byte; /* Command byte without channel bits */
  38. unsigned int lsb_resol; /* Resolution of the ADC sample LSB */
  39. };
  40. /* Command byte C2,C1,C0 - see datasheet */
  41. static inline u8 ads7828_cmd_byte(u8 cmd, int ch)
  42. {
  43. return cmd | (((ch >> 1) | (ch & 0x01) << 2) << 4);
  44. }
  45. /* sysfs callback function */
  46. static ssize_t ads7828_in_show(struct device *dev,
  47. struct device_attribute *da, char *buf)
  48. {
  49. struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
  50. struct ads7828_data *data = dev_get_drvdata(dev);
  51. u8 cmd = ads7828_cmd_byte(data->cmd_byte, attr->index);
  52. unsigned int regval;
  53. int err;
  54. err = regmap_read(data->regmap, cmd, &regval);
  55. if (err < 0)
  56. return err;
  57. return sprintf(buf, "%d\n",
  58. DIV_ROUND_CLOSEST(regval * data->lsb_resol, 1000));
  59. }
  60. static SENSOR_DEVICE_ATTR_RO(in0_input, ads7828_in, 0);
  61. static SENSOR_DEVICE_ATTR_RO(in1_input, ads7828_in, 1);
  62. static SENSOR_DEVICE_ATTR_RO(in2_input, ads7828_in, 2);
  63. static SENSOR_DEVICE_ATTR_RO(in3_input, ads7828_in, 3);
  64. static SENSOR_DEVICE_ATTR_RO(in4_input, ads7828_in, 4);
  65. static SENSOR_DEVICE_ATTR_RO(in5_input, ads7828_in, 5);
  66. static SENSOR_DEVICE_ATTR_RO(in6_input, ads7828_in, 6);
  67. static SENSOR_DEVICE_ATTR_RO(in7_input, ads7828_in, 7);
  68. static struct attribute *ads7828_attrs[] = {
  69. &sensor_dev_attr_in0_input.dev_attr.attr,
  70. &sensor_dev_attr_in1_input.dev_attr.attr,
  71. &sensor_dev_attr_in2_input.dev_attr.attr,
  72. &sensor_dev_attr_in3_input.dev_attr.attr,
  73. &sensor_dev_attr_in4_input.dev_attr.attr,
  74. &sensor_dev_attr_in5_input.dev_attr.attr,
  75. &sensor_dev_attr_in6_input.dev_attr.attr,
  76. &sensor_dev_attr_in7_input.dev_attr.attr,
  77. NULL
  78. };
  79. ATTRIBUTE_GROUPS(ads7828);
  80. static const struct regmap_config ads2828_regmap_config = {
  81. .reg_bits = 8,
  82. .val_bits = 16,
  83. };
  84. static const struct regmap_config ads2830_regmap_config = {
  85. .reg_bits = 8,
  86. .val_bits = 8,
  87. };
  88. static const struct i2c_device_id ads7828_device_ids[];
  89. static int ads7828_probe(struct i2c_client *client)
  90. {
  91. struct device *dev = &client->dev;
  92. struct ads7828_platform_data *pdata = dev_get_platdata(dev);
  93. struct ads7828_data *data;
  94. struct device *hwmon_dev;
  95. unsigned int vref_mv = ADS7828_INT_VREF_MV;
  96. unsigned int vref_uv;
  97. bool diff_input = false;
  98. bool ext_vref = false;
  99. unsigned int regval;
  100. enum ads7828_chips chip;
  101. struct regulator *reg;
  102. data = devm_kzalloc(dev, sizeof(struct ads7828_data), GFP_KERNEL);
  103. if (!data)
  104. return -ENOMEM;
  105. if (pdata) {
  106. diff_input = pdata->diff_input;
  107. ext_vref = pdata->ext_vref;
  108. if (ext_vref && pdata->vref_mv)
  109. vref_mv = pdata->vref_mv;
  110. } else if (dev->of_node) {
  111. diff_input = of_property_read_bool(dev->of_node,
  112. "ti,differential-input");
  113. reg = devm_regulator_get_optional(dev, "vref");
  114. if (!IS_ERR(reg)) {
  115. vref_uv = regulator_get_voltage(reg);
  116. vref_mv = DIV_ROUND_CLOSEST(vref_uv, 1000);
  117. if (vref_mv < ADS7828_EXT_VREF_MV_MIN ||
  118. vref_mv > ADS7828_EXT_VREF_MV_MAX)
  119. return -EINVAL;
  120. ext_vref = true;
  121. }
  122. }
  123. if (client->dev.of_node)
  124. chip = (enum ads7828_chips)
  125. of_device_get_match_data(&client->dev);
  126. else
  127. chip = i2c_match_id(ads7828_device_ids, client)->driver_data;
  128. /* Bound Vref with min/max values */
  129. vref_mv = clamp_val(vref_mv, ADS7828_EXT_VREF_MV_MIN,
  130. ADS7828_EXT_VREF_MV_MAX);
  131. /* ADS7828 uses 12-bit samples, while ADS7830 is 8-bit */
  132. if (chip == ads7828) {
  133. data->lsb_resol = DIV_ROUND_CLOSEST(vref_mv * 1000, 4096);
  134. data->regmap = devm_regmap_init_i2c(client,
  135. &ads2828_regmap_config);
  136. } else {
  137. data->lsb_resol = DIV_ROUND_CLOSEST(vref_mv * 1000, 256);
  138. data->regmap = devm_regmap_init_i2c(client,
  139. &ads2830_regmap_config);
  140. }
  141. if (IS_ERR(data->regmap))
  142. return PTR_ERR(data->regmap);
  143. data->cmd_byte = ext_vref ? ADS7828_CMD_PD1 : ADS7828_CMD_PD3;
  144. if (!diff_input)
  145. data->cmd_byte |= ADS7828_CMD_SD_SE;
  146. /*
  147. * Datasheet specifies internal reference voltage is disabled by
  148. * default. The internal reference voltage needs to be enabled and
  149. * voltage needs to settle before getting valid ADC data. So perform a
  150. * dummy read to enable the internal reference voltage.
  151. */
  152. if (!ext_vref)
  153. regmap_read(data->regmap, data->cmd_byte, &regval);
  154. hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
  155. data,
  156. ads7828_groups);
  157. return PTR_ERR_OR_ZERO(hwmon_dev);
  158. }
  159. static const struct i2c_device_id ads7828_device_ids[] = {
  160. { "ads7828", ads7828 },
  161. { "ads7830", ads7830 },
  162. { }
  163. };
  164. MODULE_DEVICE_TABLE(i2c, ads7828_device_ids);
  165. static const struct of_device_id __maybe_unused ads7828_of_match[] = {
  166. {
  167. .compatible = "ti,ads7828",
  168. .data = (void *)ads7828
  169. },
  170. {
  171. .compatible = "ti,ads7830",
  172. .data = (void *)ads7830
  173. },
  174. { },
  175. };
  176. MODULE_DEVICE_TABLE(of, ads7828_of_match);
  177. static struct i2c_driver ads7828_driver = {
  178. .driver = {
  179. .name = "ads7828",
  180. .of_match_table = of_match_ptr(ads7828_of_match),
  181. },
  182. .id_table = ads7828_device_ids,
  183. .probe_new = ads7828_probe,
  184. };
  185. module_i2c_driver(ads7828_driver);
  186. MODULE_LICENSE("GPL");
  187. MODULE_AUTHOR("Steve Hardy <[email protected]>");
  188. MODULE_DESCRIPTION("Driver for TI ADS7828 A/D converter and compatibles");