blob: a9f7e804f1e4f6c3d580ff6d444b3ff7506d589a [file] [log] [blame]
Ben Dooksbff78652009-07-18 10:12:28 +01001/* linux/drivers/hwmon/s3c-hwmon.c
2 *
3 * Copyright (C) 2005, 2008, 2009 Simtec Electronics
4 * http://armlinux.simtec.co.uk/
5 * Ben Dooks <ben@simtec.co.uk>
6 *
7 * S3C24XX/S3C64XX ADC hwmon support
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21*/
22
23#include <linux/module.h>
24#include <linux/slab.h>
Ben Dooksbff78652009-07-18 10:12:28 +010025#include <linux/io.h>
26#include <linux/init.h>
27#include <linux/err.h>
28#include <linux/clk.h>
29#include <linux/interrupt.h>
30#include <linux/platform_device.h>
31
32#include <linux/hwmon.h>
33#include <linux/hwmon-sysfs.h>
34
35#include <plat/adc.h>
Arnd Bergmann436d42c2012-08-24 15:22:12 +020036#include <linux/platform_data/hwmon-s3c.h>
Ben Dooksbff78652009-07-18 10:12:28 +010037
38struct s3c_hwmon_attr {
39 struct sensor_device_attribute in;
40 struct sensor_device_attribute label;
41 char in_name[12];
42 char label_name[12];
43};
44
45/**
46 * struct s3c_hwmon - ADC hwmon client information
47 * @lock: Access lock to serialise the conversions.
48 * @client: The client we registered with the S3C ADC core.
49 * @hwmon_dev: The hwmon device we created.
50 * @attr: The holders for the channel attributes.
51*/
52struct s3c_hwmon {
Thomas Gleixner9c627e32010-10-28 20:31:44 +020053 struct mutex lock;
Ben Dooksbff78652009-07-18 10:12:28 +010054 struct s3c_adc_client *client;
55 struct device *hwmon_dev;
56
57 struct s3c_hwmon_attr attrs[8];
58};
59
60/**
61 * s3c_hwmon_read_ch - read a value from a given adc channel.
62 * @dev: The device.
63 * @hwmon: Our state.
64 * @channel: The channel we're reading from.
65 *
66 * Read a value from the @channel with the proper locking and sleep until
67 * either the read completes or we timeout awaiting the ADC core to get
68 * back to us.
69 */
70static int s3c_hwmon_read_ch(struct device *dev,
71 struct s3c_hwmon *hwmon, int channel)
72{
73 int ret;
74
Thomas Gleixner9c627e32010-10-28 20:31:44 +020075 ret = mutex_lock_interruptible(&hwmon->lock);
Ben Dooksbff78652009-07-18 10:12:28 +010076 if (ret < 0)
77 return ret;
78
79 dev_dbg(dev, "reading channel %d\n", channel);
80
81 ret = s3c_adc_read(hwmon->client, channel);
Thomas Gleixner9c627e32010-10-28 20:31:44 +020082 mutex_unlock(&hwmon->lock);
Ben Dooksbff78652009-07-18 10:12:28 +010083
84 return ret;
85}
86
87#ifdef CONFIG_SENSORS_S3C_RAW
88/**
89 * s3c_hwmon_show_raw - show a conversion from the raw channel number.
90 * @dev: The device that the attribute belongs to.
91 * @attr: The attribute being read.
92 * @buf: The result buffer.
93 *
94 * This show deals with the raw attribute, registered for each possible
95 * ADC channel. This does a conversion and returns the raw (un-scaled)
96 * value returned from the hardware.
97 */
98static ssize_t s3c_hwmon_show_raw(struct device *dev,
99 struct device_attribute *attr, char *buf)
100{
101 struct s3c_hwmon *adc = platform_get_drvdata(to_platform_device(dev));
102 struct sensor_device_attribute *sa = to_sensor_dev_attr(attr);
103 int ret;
104
105 ret = s3c_hwmon_read_ch(dev, adc, sa->index);
106
107 return (ret < 0) ? ret : snprintf(buf, PAGE_SIZE, "%d\n", ret);
108}
109
Guenter Roeck24f9c532013-01-10 05:54:40 -0800110static SENSOR_DEVICE_ATTR(adc0_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 0);
111static SENSOR_DEVICE_ATTR(adc1_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 1);
112static SENSOR_DEVICE_ATTR(adc2_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 2);
113static SENSOR_DEVICE_ATTR(adc3_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 3);
114static SENSOR_DEVICE_ATTR(adc4_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 4);
115static SENSOR_DEVICE_ATTR(adc5_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 5);
116static SENSOR_DEVICE_ATTR(adc6_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 6);
117static SENSOR_DEVICE_ATTR(adc7_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 7);
Ben Dooksbff78652009-07-18 10:12:28 +0100118
119static struct attribute *s3c_hwmon_attrs[9] = {
120 &sensor_dev_attr_adc0_raw.dev_attr.attr,
121 &sensor_dev_attr_adc1_raw.dev_attr.attr,
122 &sensor_dev_attr_adc2_raw.dev_attr.attr,
123 &sensor_dev_attr_adc3_raw.dev_attr.attr,
124 &sensor_dev_attr_adc4_raw.dev_attr.attr,
125 &sensor_dev_attr_adc5_raw.dev_attr.attr,
126 &sensor_dev_attr_adc6_raw.dev_attr.attr,
127 &sensor_dev_attr_adc7_raw.dev_attr.attr,
128 NULL,
129};
130
131static struct attribute_group s3c_hwmon_attrgroup = {
132 .attrs = s3c_hwmon_attrs,
133};
134
135static inline int s3c_hwmon_add_raw(struct device *dev)
136{
137 return sysfs_create_group(&dev->kobj, &s3c_hwmon_attrgroup);
138}
139
140static inline void s3c_hwmon_remove_raw(struct device *dev)
141{
142 sysfs_remove_group(&dev->kobj, &s3c_hwmon_attrgroup);
143}
144
145#else
146
147static inline int s3c_hwmon_add_raw(struct device *dev) { return 0; }
148static inline void s3c_hwmon_remove_raw(struct device *dev) { }
149
150#endif /* CONFIG_SENSORS_S3C_RAW */
151
152/**
153 * s3c_hwmon_ch_show - show value of a given channel
154 * @dev: The device that the attribute belongs to.
155 * @attr: The attribute being read.
156 * @buf: The result buffer.
157 *
158 * Read a value from the ADC and scale it before returning it to the
159 * caller. The scale factor is gained from the channel configuration
160 * passed via the platform data when the device was registered.
161 */
162static ssize_t s3c_hwmon_ch_show(struct device *dev,
163 struct device_attribute *attr,
164 char *buf)
165{
166 struct sensor_device_attribute *sen_attr = to_sensor_dev_attr(attr);
167 struct s3c_hwmon *hwmon = platform_get_drvdata(to_platform_device(dev));
168 struct s3c_hwmon_pdata *pdata = dev->platform_data;
169 struct s3c_hwmon_chcfg *cfg;
170 int ret;
171
172 cfg = pdata->in[sen_attr->index];
173
174 ret = s3c_hwmon_read_ch(dev, hwmon, sen_attr->index);
175 if (ret < 0)
176 return ret;
177
178 ret *= cfg->mult;
179 ret = DIV_ROUND_CLOSEST(ret, cfg->div);
180
181 return snprintf(buf, PAGE_SIZE, "%d\n", ret);
182}
183
184/**
185 * s3c_hwmon_label_show - show label name of the given channel.
186 * @dev: The device that the attribute belongs to.
187 * @attr: The attribute being read.
188 * @buf: The result buffer.
189 *
190 * Return the label name of a given channel
191 */
192static ssize_t s3c_hwmon_label_show(struct device *dev,
193 struct device_attribute *attr,
194 char *buf)
195{
196 struct sensor_device_attribute *sen_attr = to_sensor_dev_attr(attr);
197 struct s3c_hwmon_pdata *pdata = dev->platform_data;
198 struct s3c_hwmon_chcfg *cfg;
199
200 cfg = pdata->in[sen_attr->index];
201
202 return snprintf(buf, PAGE_SIZE, "%s\n", cfg->name);
203}
204
205/**
206 * s3c_hwmon_create_attr - create hwmon attribute for given channel.
207 * @dev: The device to create the attribute on.
208 * @cfg: The channel configuration passed from the platform data.
209 * @channel: The ADC channel number to process.
210 *
211 * Create the scaled attribute for use with hwmon from the specified
212 * platform data in @pdata. The sysfs entry is handled by the routine
213 * s3c_hwmon_ch_show().
214 *
215 * The attribute name is taken from the configuration data if present
216 * otherwise the name is taken by concatenating in_ with the channel
217 * number.
218 */
219static int s3c_hwmon_create_attr(struct device *dev,
220 struct s3c_hwmon_chcfg *cfg,
221 struct s3c_hwmon_attr *attrs,
222 int channel)
223{
224 struct sensor_device_attribute *attr;
225 int ret;
226
227 snprintf(attrs->in_name, sizeof(attrs->in_name), "in%d_input", channel);
228
229 attr = &attrs->in;
230 attr->index = channel;
Guenter Roeckb1e698d2011-05-24 12:34:55 -0700231 sysfs_attr_init(&attr->dev_attr.attr);
Ben Dooksbff78652009-07-18 10:12:28 +0100232 attr->dev_attr.attr.name = attrs->in_name;
233 attr->dev_attr.attr.mode = S_IRUGO;
Ben Dooksbff78652009-07-18 10:12:28 +0100234 attr->dev_attr.show = s3c_hwmon_ch_show;
235
236 ret = device_create_file(dev, &attr->dev_attr);
237 if (ret < 0) {
238 dev_err(dev, "failed to create input attribute\n");
239 return ret;
240 }
241
242 /* if this has a name, add a label */
243 if (cfg->name) {
244 snprintf(attrs->label_name, sizeof(attrs->label_name),
245 "in%d_label", channel);
246
247 attr = &attrs->label;
248 attr->index = channel;
Guenter Roeckb1e698d2011-05-24 12:34:55 -0700249 sysfs_attr_init(&attr->dev_attr.attr);
Ben Dooksbff78652009-07-18 10:12:28 +0100250 attr->dev_attr.attr.name = attrs->label_name;
251 attr->dev_attr.attr.mode = S_IRUGO;
Ben Dooksbff78652009-07-18 10:12:28 +0100252 attr->dev_attr.show = s3c_hwmon_label_show;
253
254 ret = device_create_file(dev, &attr->dev_attr);
255 if (ret < 0) {
256 device_remove_file(dev, &attrs->in.dev_attr);
257 dev_err(dev, "failed to create label attribute\n");
258 }
259 }
260
261 return ret;
262}
263
264static void s3c_hwmon_remove_attr(struct device *dev,
265 struct s3c_hwmon_attr *attrs)
266{
267 device_remove_file(dev, &attrs->in.dev_attr);
268 device_remove_file(dev, &attrs->label.dev_attr);
269}
270
271/**
272 * s3c_hwmon_probe - device probe entry.
273 * @dev: The device being probed.
274*/
Bill Pemberton6c931ae2012-11-19 13:22:35 -0500275static int s3c_hwmon_probe(struct platform_device *dev)
Ben Dooksbff78652009-07-18 10:12:28 +0100276{
277 struct s3c_hwmon_pdata *pdata = dev->dev.platform_data;
278 struct s3c_hwmon *hwmon;
279 int ret = 0;
280 int i;
281
282 if (!pdata) {
283 dev_err(&dev->dev, "no platform data supplied\n");
284 return -EINVAL;
285 }
286
Sachin Kamat41bf8702012-07-13 14:36:28 +0530287 hwmon = devm_kzalloc(&dev->dev, sizeof(struct s3c_hwmon), GFP_KERNEL);
Ben Dooksbff78652009-07-18 10:12:28 +0100288 if (hwmon == NULL) {
289 dev_err(&dev->dev, "no memory\n");
290 return -ENOMEM;
291 }
292
293 platform_set_drvdata(dev, hwmon);
294
Thomas Gleixner9c627e32010-10-28 20:31:44 +0200295 mutex_init(&hwmon->lock);
Ben Dooksbff78652009-07-18 10:12:28 +0100296
297 /* Register with the core ADC driver. */
298
299 hwmon->client = s3c_adc_register(dev, NULL, NULL, 0);
300 if (IS_ERR(hwmon->client)) {
301 dev_err(&dev->dev, "cannot register adc\n");
Sachin Kamat41bf8702012-07-13 14:36:28 +0530302 return PTR_ERR(hwmon->client);
Ben Dooksbff78652009-07-18 10:12:28 +0100303 }
304
305 /* add attributes for our adc devices. */
306
307 ret = s3c_hwmon_add_raw(&dev->dev);
308 if (ret)
309 goto err_registered;
310
311 /* register with the hwmon core */
312
313 hwmon->hwmon_dev = hwmon_device_register(&dev->dev);
314 if (IS_ERR(hwmon->hwmon_dev)) {
315 dev_err(&dev->dev, "error registering with hwmon\n");
316 ret = PTR_ERR(hwmon->hwmon_dev);
317 goto err_raw_attribute;
318 }
319
320 for (i = 0; i < ARRAY_SIZE(pdata->in); i++) {
Ben Dooks6d905e62009-12-09 20:35:45 +0100321 struct s3c_hwmon_chcfg *cfg = pdata->in[i];
Ben Dooksbe4c23c2009-11-16 12:45:39 +0100322
323 if (!cfg)
Ben Dooksbff78652009-07-18 10:12:28 +0100324 continue;
325
Ben Dooksbe4c23c2009-11-16 12:45:39 +0100326 if (cfg->mult >= 0x10000)
Ben Dooksbff78652009-07-18 10:12:28 +0100327 dev_warn(&dev->dev,
328 "channel %d multiplier too large\n",
329 i);
330
Ben Dooks6d905e62009-12-09 20:35:45 +0100331 if (cfg->div == 0) {
Ben Dooksbe4c23c2009-11-16 12:45:39 +0100332 dev_err(&dev->dev, "channel %d divider zero\n", i);
333 continue;
334 }
335
Ben Dooksbff78652009-07-18 10:12:28 +0100336 ret = s3c_hwmon_create_attr(&dev->dev, pdata->in[i],
337 &hwmon->attrs[i], i);
338 if (ret) {
339 dev_err(&dev->dev,
340 "error creating channel %d\n", i);
341
342 for (i--; i >= 0; i--)
343 s3c_hwmon_remove_attr(&dev->dev,
344 &hwmon->attrs[i]);
345
346 goto err_hwmon_register;
347 }
348 }
349
350 return 0;
351
352 err_hwmon_register:
353 hwmon_device_unregister(hwmon->hwmon_dev);
354
355 err_raw_attribute:
356 s3c_hwmon_remove_raw(&dev->dev);
357
358 err_registered:
359 s3c_adc_release(hwmon->client);
360
Ben Dooksbff78652009-07-18 10:12:28 +0100361 return ret;
362}
363
Bill Pemberton281dfd02012-11-19 13:25:51 -0500364static int s3c_hwmon_remove(struct platform_device *dev)
Ben Dooksbff78652009-07-18 10:12:28 +0100365{
366 struct s3c_hwmon *hwmon = platform_get_drvdata(dev);
367 int i;
368
369 s3c_hwmon_remove_raw(&dev->dev);
370
371 for (i = 0; i < ARRAY_SIZE(hwmon->attrs); i++)
372 s3c_hwmon_remove_attr(&dev->dev, &hwmon->attrs[i]);
373
374 hwmon_device_unregister(hwmon->hwmon_dev);
375 s3c_adc_release(hwmon->client);
376
377 return 0;
378}
379
380static struct platform_driver s3c_hwmon_driver = {
381 .driver = {
382 .name = "s3c-hwmon",
383 .owner = THIS_MODULE,
384 },
385 .probe = s3c_hwmon_probe,
Bill Pemberton9e5e9b72012-11-19 13:21:20 -0500386 .remove = s3c_hwmon_remove,
Ben Dooksbff78652009-07-18 10:12:28 +0100387};
388
Axel Lin25a236a2011-11-25 02:31:00 -0500389module_platform_driver(s3c_hwmon_driver);
Ben Dooksbff78652009-07-18 10:12:28 +0100390
391MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
392MODULE_DESCRIPTION("S3C ADC HWMon driver");
393MODULE_LICENSE("GPL v2");
394MODULE_ALIAS("platform:s3c-hwmon");