Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
e5970223 AJ |
2 | /* |
3 | * HWMON Driver for Dialog DA9055 | |
4 | * | |
5 | * Copyright(c) 2012 Dialog Semiconductor Ltd. | |
6 | * | |
7 | * Author: David Dajun Chen <dchen@diasemi.com> | |
e5970223 AJ |
8 | */ |
9 | ||
10 | #include <linux/delay.h> | |
11 | #include <linux/err.h> | |
12 | #include <linux/hwmon.h> | |
13 | #include <linux/hwmon-sysfs.h> | |
14 | #include <linux/init.h> | |
15 | #include <linux/kernel.h> | |
16 | #include <linux/module.h> | |
17 | #include <linux/platform_device.h> | |
18 | #include <linux/completion.h> | |
19 | ||
20 | #include <linux/mfd/da9055/core.h> | |
21 | #include <linux/mfd/da9055/reg.h> | |
22 | ||
23 | #define DA9055_ADCIN_DIV 102 | |
24 | #define DA9055_VSYS_DIV 85 | |
25 | ||
26 | #define DA9055_ADC_VSYS 0 | |
27 | #define DA9055_ADC_ADCIN1 1 | |
28 | #define DA9055_ADC_ADCIN2 2 | |
29 | #define DA9055_ADC_ADCIN3 3 | |
30 | #define DA9055_ADC_TJUNC 4 | |
31 | ||
32 | struct da9055_hwmon { | |
33 | struct da9055 *da9055; | |
e5970223 AJ |
34 | struct mutex hwmon_lock; |
35 | struct mutex irq_lock; | |
36 | struct completion done; | |
37 | }; | |
38 | ||
39 | static const char * const input_names[] = { | |
40 | [DA9055_ADC_VSYS] = "VSYS", | |
41 | [DA9055_ADC_ADCIN1] = "ADC IN1", | |
42 | [DA9055_ADC_ADCIN2] = "ADC IN2", | |
43 | [DA9055_ADC_ADCIN3] = "ADC IN3", | |
44 | [DA9055_ADC_TJUNC] = "CHIP TEMP", | |
45 | }; | |
46 | ||
47 | static const u8 chan_mux[DA9055_ADC_TJUNC + 1] = { | |
48 | [DA9055_ADC_VSYS] = DA9055_ADC_MUX_VSYS, | |
49 | [DA9055_ADC_ADCIN1] = DA9055_ADC_MUX_ADCIN1, | |
50 | [DA9055_ADC_ADCIN2] = DA9055_ADC_MUX_ADCIN2, | |
44f751ce | 51 | [DA9055_ADC_ADCIN3] = DA9055_ADC_MUX_ADCIN3, |
e5970223 AJ |
52 | [DA9055_ADC_TJUNC] = DA9055_ADC_MUX_T_SENSE, |
53 | }; | |
54 | ||
55 | static int da9055_adc_manual_read(struct da9055_hwmon *hwmon, | |
56 | unsigned char channel) | |
57 | { | |
58 | int ret; | |
59 | unsigned short calc_data; | |
60 | unsigned short data; | |
61 | unsigned char mux_sel; | |
62 | struct da9055 *da9055 = hwmon->da9055; | |
63 | ||
64 | if (channel > DA9055_ADC_TJUNC) | |
65 | return -EINVAL; | |
66 | ||
67 | mutex_lock(&hwmon->irq_lock); | |
68 | ||
69 | /* Selects desired MUX for manual conversion */ | |
70 | mux_sel = chan_mux[channel] | DA9055_ADC_MAN_CONV; | |
71 | ||
72 | ret = da9055_reg_write(da9055, DA9055_REG_ADC_MAN, mux_sel); | |
73 | if (ret < 0) | |
74 | goto err; | |
75 | ||
76 | /* Wait for an interrupt */ | |
77 | if (!wait_for_completion_timeout(&hwmon->done, | |
78 | msecs_to_jiffies(500))) { | |
79 | dev_err(da9055->dev, | |
80 | "timeout waiting for ADC conversion interrupt\n"); | |
81 | ret = -ETIMEDOUT; | |
82 | goto err; | |
83 | } | |
84 | ||
85 | ret = da9055_reg_read(da9055, DA9055_REG_ADC_RES_H); | |
86 | if (ret < 0) | |
87 | goto err; | |
88 | ||
89 | calc_data = (unsigned short)ret; | |
90 | data = calc_data << 2; | |
91 | ||
92 | ret = da9055_reg_read(da9055, DA9055_REG_ADC_RES_L); | |
93 | if (ret < 0) | |
94 | goto err; | |
95 | ||
96 | calc_data = (unsigned short)(ret & DA9055_ADC_LSB_MASK); | |
97 | data |= calc_data; | |
98 | ||
99 | ret = data; | |
100 | ||
101 | err: | |
102 | mutex_unlock(&hwmon->irq_lock); | |
103 | return ret; | |
104 | } | |
105 | ||
106 | static irqreturn_t da9055_auxadc_irq(int irq, void *irq_data) | |
107 | { | |
108 | struct da9055_hwmon *hwmon = irq_data; | |
109 | ||
110 | complete(&hwmon->done); | |
111 | ||
112 | return IRQ_HANDLED; | |
113 | } | |
114 | ||
115 | /* Conversion function for VSYS and ADCINx */ | |
088ce2ac | 116 | static inline int volt_reg_to_mv(int value, int channel) |
e5970223 AJ |
117 | { |
118 | if (channel == DA9055_ADC_VSYS) | |
119 | return DIV_ROUND_CLOSEST(value * 1000, DA9055_VSYS_DIV) + 2500; | |
120 | else | |
121 | return DIV_ROUND_CLOSEST(value * 1000, DA9055_ADCIN_DIV); | |
122 | } | |
123 | ||
124 | static int da9055_enable_auto_mode(struct da9055 *da9055, int channel) | |
125 | { | |
126 | ||
127 | return da9055_reg_update(da9055, DA9055_REG_ADC_CONT, 1 << channel, | |
128 | 1 << channel); | |
129 | ||
130 | } | |
131 | ||
132 | static int da9055_disable_auto_mode(struct da9055 *da9055, int channel) | |
133 | { | |
134 | ||
135 | return da9055_reg_update(da9055, DA9055_REG_ADC_CONT, 1 << channel, 0); | |
136 | } | |
137 | ||
4b76a6c9 GR |
138 | static ssize_t da9055_auto_ch_show(struct device *dev, |
139 | struct device_attribute *devattr, | |
140 | char *buf) | |
e5970223 AJ |
141 | { |
142 | struct da9055_hwmon *hwmon = dev_get_drvdata(dev); | |
143 | int ret, adc; | |
144 | int channel = to_sensor_dev_attr(devattr)->index; | |
145 | ||
146 | mutex_lock(&hwmon->hwmon_lock); | |
147 | ||
148 | ret = da9055_enable_auto_mode(hwmon->da9055, channel); | |
149 | if (ret < 0) | |
150 | goto hwmon_err; | |
151 | ||
152 | usleep_range(10000, 10500); | |
153 | ||
154 | adc = da9055_reg_read(hwmon->da9055, DA9055_REG_VSYS_RES + channel); | |
155 | if (adc < 0) { | |
156 | ret = adc; | |
157 | goto hwmon_err_release; | |
158 | } | |
159 | ||
160 | ret = da9055_disable_auto_mode(hwmon->da9055, channel); | |
161 | if (ret < 0) | |
162 | goto hwmon_err; | |
163 | ||
164 | mutex_unlock(&hwmon->hwmon_lock); | |
165 | ||
088ce2ac | 166 | return sprintf(buf, "%d\n", volt_reg_to_mv(adc, channel)); |
e5970223 AJ |
167 | |
168 | hwmon_err_release: | |
169 | da9055_disable_auto_mode(hwmon->da9055, channel); | |
170 | hwmon_err: | |
171 | mutex_unlock(&hwmon->hwmon_lock); | |
172 | return ret; | |
173 | } | |
174 | ||
4b76a6c9 | 175 | static ssize_t da9055_tjunc_show(struct device *dev, |
e5970223 AJ |
176 | struct device_attribute *devattr, char *buf) |
177 | { | |
178 | struct da9055_hwmon *hwmon = dev_get_drvdata(dev); | |
179 | int tjunc; | |
180 | int toffset; | |
181 | ||
182 | tjunc = da9055_adc_manual_read(hwmon, DA9055_ADC_TJUNC); | |
183 | if (tjunc < 0) | |
184 | return tjunc; | |
185 | ||
186 | toffset = da9055_reg_read(hwmon->da9055, DA9055_REG_T_OFFSET); | |
187 | if (toffset < 0) | |
188 | return toffset; | |
189 | ||
190 | /* | |
191 | * Degrees celsius = -0.4084 * (ADC_RES - T_OFFSET) + 307.6332 | |
192 | * T_OFFSET is a trim value used to improve accuracy of the result | |
193 | */ | |
194 | return sprintf(buf, "%d\n", DIV_ROUND_CLOSEST(-4084 * (tjunc - toffset) | |
195 | + 3076332, 10000)); | |
196 | } | |
197 | ||
4b76a6c9 | 198 | static ssize_t label_show(struct device *dev, |
e5970223 AJ |
199 | struct device_attribute *devattr, char *buf) |
200 | { | |
201 | return sprintf(buf, "%s\n", | |
202 | input_names[to_sensor_dev_attr(devattr)->index]); | |
203 | } | |
204 | ||
4b76a6c9 GR |
205 | static SENSOR_DEVICE_ATTR_RO(in0_input, da9055_auto_ch, DA9055_ADC_VSYS); |
206 | static SENSOR_DEVICE_ATTR_RO(in0_label, label, DA9055_ADC_VSYS); | |
207 | static SENSOR_DEVICE_ATTR_RO(in1_input, da9055_auto_ch, DA9055_ADC_ADCIN1); | |
208 | static SENSOR_DEVICE_ATTR_RO(in1_label, label, DA9055_ADC_ADCIN1); | |
209 | static SENSOR_DEVICE_ATTR_RO(in2_input, da9055_auto_ch, DA9055_ADC_ADCIN2); | |
210 | static SENSOR_DEVICE_ATTR_RO(in2_label, label, DA9055_ADC_ADCIN2); | |
211 | static SENSOR_DEVICE_ATTR_RO(in3_input, da9055_auto_ch, DA9055_ADC_ADCIN3); | |
212 | static SENSOR_DEVICE_ATTR_RO(in3_label, label, DA9055_ADC_ADCIN3); | |
213 | ||
214 | static SENSOR_DEVICE_ATTR_RO(temp1_input, da9055_tjunc, DA9055_ADC_TJUNC); | |
215 | static SENSOR_DEVICE_ATTR_RO(temp1_label, label, DA9055_ADC_TJUNC); | |
e5970223 | 216 | |
e7d275e7 | 217 | static struct attribute *da9055_attrs[] = { |
e5970223 AJ |
218 | &sensor_dev_attr_in0_input.dev_attr.attr, |
219 | &sensor_dev_attr_in0_label.dev_attr.attr, | |
220 | &sensor_dev_attr_in1_input.dev_attr.attr, | |
221 | &sensor_dev_attr_in1_label.dev_attr.attr, | |
222 | &sensor_dev_attr_in2_input.dev_attr.attr, | |
223 | &sensor_dev_attr_in2_label.dev_attr.attr, | |
224 | &sensor_dev_attr_in3_input.dev_attr.attr, | |
225 | &sensor_dev_attr_in3_label.dev_attr.attr, | |
226 | ||
227 | &sensor_dev_attr_temp1_input.dev_attr.attr, | |
228 | &sensor_dev_attr_temp1_label.dev_attr.attr, | |
229 | NULL | |
230 | }; | |
231 | ||
e7d275e7 | 232 | ATTRIBUTE_GROUPS(da9055); |
e5970223 AJ |
233 | |
234 | static int da9055_hwmon_probe(struct platform_device *pdev) | |
235 | { | |
e7d275e7 | 236 | struct device *dev = &pdev->dev; |
e5970223 | 237 | struct da9055_hwmon *hwmon; |
e7d275e7 | 238 | struct device *hwmon_dev; |
e5970223 AJ |
239 | int hwmon_irq, ret; |
240 | ||
e7d275e7 | 241 | hwmon = devm_kzalloc(dev, sizeof(struct da9055_hwmon), GFP_KERNEL); |
e5970223 AJ |
242 | if (!hwmon) |
243 | return -ENOMEM; | |
244 | ||
245 | mutex_init(&hwmon->hwmon_lock); | |
246 | mutex_init(&hwmon->irq_lock); | |
247 | ||
248 | init_completion(&hwmon->done); | |
249 | hwmon->da9055 = dev_get_drvdata(pdev->dev.parent); | |
250 | ||
e5970223 AJ |
251 | hwmon_irq = platform_get_irq_byname(pdev, "HWMON"); |
252 | if (hwmon_irq < 0) | |
253 | return hwmon_irq; | |
254 | ||
e5970223 AJ |
255 | ret = devm_request_threaded_irq(&pdev->dev, hwmon_irq, |
256 | NULL, da9055_auxadc_irq, | |
257 | IRQF_TRIGGER_HIGH | IRQF_ONESHOT, | |
258 | "adc-irq", hwmon); | |
259 | if (ret != 0) { | |
260 | dev_err(hwmon->da9055->dev, "DA9055 ADC IRQ failed ret=%d\n", | |
261 | ret); | |
262 | return ret; | |
263 | } | |
264 | ||
e7d275e7 AL |
265 | hwmon_dev = devm_hwmon_device_register_with_groups(dev, "da9055", |
266 | hwmon, | |
267 | da9055_groups); | |
268 | return PTR_ERR_OR_ZERO(hwmon_dev); | |
e5970223 AJ |
269 | } |
270 | ||
271 | static struct platform_driver da9055_hwmon_driver = { | |
272 | .probe = da9055_hwmon_probe, | |
e5970223 AJ |
273 | .driver = { |
274 | .name = "da9055-hwmon", | |
e5970223 AJ |
275 | }, |
276 | }; | |
277 | ||
278 | module_platform_driver(da9055_hwmon_driver); | |
279 | ||
280 | MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>"); | |
281 | MODULE_DESCRIPTION("DA9055 HWMON driver"); | |
282 | MODULE_LICENSE("GPL"); | |
283 | MODULE_ALIAS("platform:da9055-hwmon"); |