1/* 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> 25#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> 36#include <linux/platform_data/hwmon-s3c.h> 37 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 { 53 struct mutex lock; 54 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 75 ret = mutex_lock_interruptible(&hwmon->lock); 76 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); 82 mutex_unlock(&hwmon->lock); 83 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 110static 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); 118 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_get_platdata(dev); 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_get_platdata(dev); 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; 231 sysfs_attr_init(&attr->dev_attr.attr); 232 attr->dev_attr.attr.name = attrs->in_name; 233 attr->dev_attr.attr.mode = S_IRUGO; 234 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; 249 sysfs_attr_init(&attr->dev_attr.attr); 250 attr->dev_attr.attr.name = attrs->label_name; 251 attr->dev_attr.attr.mode = S_IRUGO; 252 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*/ 275static int s3c_hwmon_probe(struct platform_device *dev) 276{ 277 struct s3c_hwmon_pdata *pdata = dev_get_platdata(&dev->dev); 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 287 hwmon = devm_kzalloc(&dev->dev, sizeof(struct s3c_hwmon), GFP_KERNEL); 288 if (hwmon == NULL) 289 return -ENOMEM; 290 291 platform_set_drvdata(dev, hwmon); 292 293 mutex_init(&hwmon->lock); 294 295 /* Register with the core ADC driver. */ 296 297 hwmon->client = s3c_adc_register(dev, NULL, NULL, 0); 298 if (IS_ERR(hwmon->client)) { 299 dev_err(&dev->dev, "cannot register adc\n"); 300 return PTR_ERR(hwmon->client); 301 } 302 303 /* add attributes for our adc devices. */ 304 305 ret = s3c_hwmon_add_raw(&dev->dev); 306 if (ret) 307 goto err_registered; 308 309 /* register with the hwmon core */ 310 311 hwmon->hwmon_dev = hwmon_device_register(&dev->dev); 312 if (IS_ERR(hwmon->hwmon_dev)) { 313 dev_err(&dev->dev, "error registering with hwmon\n"); 314 ret = PTR_ERR(hwmon->hwmon_dev); 315 goto err_raw_attribute; 316 } 317 318 for (i = 0; i < ARRAY_SIZE(pdata->in); i++) { 319 struct s3c_hwmon_chcfg *cfg = pdata->in[i]; 320 321 if (!cfg) 322 continue; 323 324 if (cfg->mult >= 0x10000) 325 dev_warn(&dev->dev, 326 "channel %d multiplier too large\n", 327 i); 328 329 if (cfg->div == 0) { 330 dev_err(&dev->dev, "channel %d divider zero\n", i); 331 continue; 332 } 333 334 ret = s3c_hwmon_create_attr(&dev->dev, pdata->in[i], 335 &hwmon->attrs[i], i); 336 if (ret) { 337 dev_err(&dev->dev, 338 "error creating channel %d\n", i); 339 340 for (i--; i >= 0; i--) 341 s3c_hwmon_remove_attr(&dev->dev, 342 &hwmon->attrs[i]); 343 344 goto err_hwmon_register; 345 } 346 } 347 348 return 0; 349 350 err_hwmon_register: 351 hwmon_device_unregister(hwmon->hwmon_dev); 352 353 err_raw_attribute: 354 s3c_hwmon_remove_raw(&dev->dev); 355 356 err_registered: 357 s3c_adc_release(hwmon->client); 358 359 return ret; 360} 361 362static int s3c_hwmon_remove(struct platform_device *dev) 363{ 364 struct s3c_hwmon *hwmon = platform_get_drvdata(dev); 365 int i; 366 367 s3c_hwmon_remove_raw(&dev->dev); 368 369 for (i = 0; i < ARRAY_SIZE(hwmon->attrs); i++) 370 s3c_hwmon_remove_attr(&dev->dev, &hwmon->attrs[i]); 371 372 hwmon_device_unregister(hwmon->hwmon_dev); 373 s3c_adc_release(hwmon->client); 374 375 return 0; 376} 377 378static struct platform_driver s3c_hwmon_driver = { 379 .driver = { 380 .name = "s3c-hwmon", 381 .owner = THIS_MODULE, 382 }, 383 .probe = s3c_hwmon_probe, 384 .remove = s3c_hwmon_remove, 385}; 386 387module_platform_driver(s3c_hwmon_driver); 388 389MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>"); 390MODULE_DESCRIPTION("S3C ADC HWMon driver"); 391MODULE_LICENSE("GPL v2"); 392MODULE_ALIAS("platform:s3c-hwmon"); 393