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