drivers/hwmon/s3c-hwmon.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* linux/drivers/hwmon/s3c-hwmon.c
   3  *
   4  * Copyright (C) 2005, 2008, 2009 Simtec Electronics
   5  *      http://armlinux.simtec.co.uk/
   6  *      Ben Dooks <ben@simtec.co.uk>
   7  *
   8  * S3C24XX/S3C64XX ADC hwmon support
   9 */
  10
  11 #include <linux/module.h>
  12 #include <linux/slab.h>
  13 #include <linux/io.h>
  14 #include <linux/init.h>
  15 #include <linux/err.h>
  16 #include <linux/clk.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/platform_device.h>
  19
  20 #include <linux/hwmon.h>
  21 #include <linux/hwmon-sysfs.h>
  22
  23 #include <plat/adc.h>
  24 #include <linux/platform_data/hwmon-s3c.h>
  25
  26 struct s3c_hwmon_attr {
  27         struct sensor_device_attribute  in;
  28         struct sensor_device_attribute  label;
  29         char                            in_name[12];
  30         char                            label_name[12];
  31 };
  32
  33 /**
  34  * struct s3c_hwmon - ADC hwmon client information
  35  * @lock: Access lock to serialise the conversions.
  36  * @client: The client we registered with the S3C ADC core.
  37  * @hwmon_dev: The hwmon device we created.
  38  * @attr: The holders for the channel attributes.
  39 */
  40 struct s3c_hwmon {
  41         struct mutex            lock;
  42         struct s3c_adc_client   *client;
  43         struct device           *hwmon_dev;
  44
  45         struct s3c_hwmon_attr   attrs[8];
  46 };
  47
  48 /**
  49  * s3c_hwmon_read_ch - read a value from a given adc channel.
  50  * @dev: The device.
  51  * @hwmon: Our state.
  52  * @channel: The channel we're reading from.
  53  *
  54  * Read a value from the @channel with the proper locking and sleep until
  55  * either the read completes or we timeout awaiting the ADC core to get
  56  * back to us.
  57  */
  58 static int s3c_hwmon_read_ch(struct device *dev,
  59                              struct s3c_hwmon *hwmon, int channel)
  60 {
  61         int ret;
  62
  63         ret = mutex_lock_interruptible(&hwmon->lock);
  64         if (ret < 0)
  65                 return ret;
  66
  67         dev_dbg(dev, "reading channel %d\n", channel);
  68
  69         ret = s3c_adc_read(hwmon->client, channel);
  70         mutex_unlock(&hwmon->lock);
  71
  72         return ret;
  73 }
  74
  75 #ifdef CONFIG_SENSORS_S3C_RAW
  76 /**
  77  * s3c_hwmon_show_raw - show a conversion from the raw channel number.
  78  * @dev: The device that the attribute belongs to.
  79  * @attr: The attribute being read.
  80  * @buf: The result buffer.
  81  *
  82  * This show deals with the raw attribute, registered for each possible
  83  * ADC channel. This does a conversion and returns the raw (un-scaled)
  84  * value returned from the hardware.
  85  */
  86 static ssize_t s3c_hwmon_show_raw(struct device *dev,
  87                                   struct device_attribute *attr, char *buf)
  88 {
  89         struct s3c_hwmon *adc = dev_get_drvdata(dev);
  90         struct sensor_device_attribute *sa = to_sensor_dev_attr(attr);
  91         int ret;
  92
  93         ret = s3c_hwmon_read_ch(dev, adc, sa->index);
  94
  95         return  (ret < 0) ? ret : snprintf(buf, PAGE_SIZE, "%d\n", ret);
  96 }
  97
  98 static SENSOR_DEVICE_ATTR(adc0_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 0);
  99 static SENSOR_DEVICE_ATTR(adc1_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 1);
 100 static SENSOR_DEVICE_ATTR(adc2_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 2);
 101 static SENSOR_DEVICE_ATTR(adc3_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 3);
 102 static SENSOR_DEVICE_ATTR(adc4_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 4);
 103 static SENSOR_DEVICE_ATTR(adc5_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 5);
 104 static SENSOR_DEVICE_ATTR(adc6_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 6);
 105 static SENSOR_DEVICE_ATTR(adc7_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, 7);
 106
 107 static struct attribute *s3c_hwmon_attrs[9] = {
 108         &sensor_dev_attr_adc0_raw.dev_attr.attr,
 109         &sensor_dev_attr_adc1_raw.dev_attr.attr,
 110         &sensor_dev_attr_adc2_raw.dev_attr.attr,
 111         &sensor_dev_attr_adc3_raw.dev_attr.attr,
 112         &sensor_dev_attr_adc4_raw.dev_attr.attr,
 113         &sensor_dev_attr_adc5_raw.dev_attr.attr,
 114         &sensor_dev_attr_adc6_raw.dev_attr.attr,
 115         &sensor_dev_attr_adc7_raw.dev_attr.attr,
 116         NULL,
 117 };
 118
 119 static struct attribute_group s3c_hwmon_attrgroup = {
 120         .attrs  = s3c_hwmon_attrs,
 121 };
 122
 123 static inline int s3c_hwmon_add_raw(struct device *dev)
 124 {
 125         return sysfs_create_group(&dev->kobj, &s3c_hwmon_attrgroup);
 126 }
 127
 128 static inline void s3c_hwmon_remove_raw(struct device *dev)
 129 {
 130         sysfs_remove_group(&dev->kobj, &s3c_hwmon_attrgroup);
 131 }
 132
 133 #else
 134
 135 static inline int s3c_hwmon_add_raw(struct device *dev) { return 0; }
 136 static inline void s3c_hwmon_remove_raw(struct device *dev) { }
 137
 138 #endif /* CONFIG_SENSORS_S3C_RAW */
 139
 140 /**
 141  * s3c_hwmon_ch_show - show value of a given channel
 142  * @dev: The device that the attribute belongs to.
 143  * @attr: The attribute being read.
 144  * @buf: The result buffer.
 145  *
 146  * Read a value from the ADC and scale it before returning it to the
 147  * caller. The scale factor is gained from the channel configuration
 148  * passed via the platform data when the device was registered.
 149  */
 150 static ssize_t s3c_hwmon_ch_show(struct device *dev,
 151                                  struct device_attribute *attr,
 152                                  char *buf)
 153 {
 154         struct sensor_device_attribute *sen_attr = to_sensor_dev_attr(attr);
 155         struct s3c_hwmon *hwmon = dev_get_drvdata(dev);
 156         struct s3c_hwmon_pdata *pdata = dev_get_platdata(dev);
 157         struct s3c_hwmon_chcfg *cfg;
 158         int ret;
 159
 160         cfg = pdata->in[sen_attr->index];
 161
 162         ret = s3c_hwmon_read_ch(dev, hwmon, sen_attr->index);
 163         if (ret < 0)
 164                 return ret;
 165
 166         ret *= cfg->mult;
 167         ret = DIV_ROUND_CLOSEST(ret, cfg->div);
 168
 169         return snprintf(buf, PAGE_SIZE, "%d\n", ret);
 170 }
 171
 172 /**
 173  * s3c_hwmon_label_show - show label name of the given channel.
 174  * @dev: The device that the attribute belongs to.
 175  * @attr: The attribute being read.
 176  * @buf: The result buffer.
 177  *
 178  * Return the label name of a given channel
 179  */
 180 static ssize_t s3c_hwmon_label_show(struct device *dev,
 181                                     struct device_attribute *attr,
 182                                     char *buf)
 183 {
 184         struct sensor_device_attribute *sen_attr = to_sensor_dev_attr(attr);
 185         struct s3c_hwmon_pdata *pdata = dev_get_platdata(dev);
 186         struct s3c_hwmon_chcfg *cfg;
 187
 188         cfg = pdata->in[sen_attr->index];
 189
 190         return snprintf(buf, PAGE_SIZE, "%s\n", cfg->name);
 191 }
 192
 193 /**
 194  * s3c_hwmon_create_attr - create hwmon attribute for given channel.
 195  * @dev: The device to create the attribute on.
 196  * @cfg: The channel configuration passed from the platform data.
 197  * @channel: The ADC channel number to process.
 198  *
 199  * Create the scaled attribute for use with hwmon from the specified
 200  * platform data in @pdata. The sysfs entry is handled by the routine
 201  * s3c_hwmon_ch_show().
 202  *
 203  * The attribute name is taken from the configuration data if present
 204  * otherwise the name is taken by concatenating in_ with the channel
 205  * number.
 206  */
 207 static int s3c_hwmon_create_attr(struct device *dev,
 208                                  struct s3c_hwmon_chcfg *cfg,
 209                                  struct s3c_hwmon_attr *attrs,
 210                                  int channel)
 211 {
 212         struct sensor_device_attribute *attr;
 213         int ret;
 214
 215         snprintf(attrs->in_name, sizeof(attrs->in_name), "in%d_input", channel);
 216
 217         attr = &attrs->in;
 218         attr->index = channel;
 219         sysfs_attr_init(&attr->dev_attr.attr);
 220         attr->dev_attr.attr.name  = attrs->in_name;
 221         attr->dev_attr.attr.mode  = S_IRUGO;
 222         attr->dev_attr.show = s3c_hwmon_ch_show;
 223
 224         ret =  device_create_file(dev, &attr->dev_attr);
 225         if (ret < 0) {
 226                 dev_err(dev, "failed to create input attribute\n");
 227                 return ret;
 228         }
 229
 230         /* if this has a name, add a label */
 231         if (cfg->name) {
 232                 snprintf(attrs->label_name, sizeof(attrs->label_name),
 233                          "in%d_label", channel);
 234
 235                 attr = &attrs->label;
 236                 attr->index = channel;
 237                 sysfs_attr_init(&attr->dev_attr.attr);
 238                 attr->dev_attr.attr.name  = attrs->label_name;
 239                 attr->dev_attr.attr.mode  = S_IRUGO;
 240                 attr->dev_attr.show = s3c_hwmon_label_show;
 241
 242                 ret = device_create_file(dev, &attr->dev_attr);
 243                 if (ret < 0) {
 244                         device_remove_file(dev, &attrs->in.dev_attr);
 245                         dev_err(dev, "failed to create label attribute\n");
 246                 }
 247         }
 248
 249         return ret;
 250 }
 251
 252 static void s3c_hwmon_remove_attr(struct device *dev,
 253                                   struct s3c_hwmon_attr *attrs)
 254 {
 255         device_remove_file(dev, &attrs->in.dev_attr);
 256         device_remove_file(dev, &attrs->label.dev_attr);
 257 }
 258
 259 /**
 260  * s3c_hwmon_probe - device probe entry.
 261  * @dev: The device being probed.
 262 */
 263 static int s3c_hwmon_probe(struct platform_device *dev)
 264 {
 265         struct s3c_hwmon_pdata *pdata = dev_get_platdata(&dev->dev);
 266         struct s3c_hwmon *hwmon;
 267         int ret = 0;
 268         int i;
 269
 270         if (!pdata) {
 271                 dev_err(&dev->dev, "no platform data supplied\n");
 272                 return -EINVAL;
 273         }
 274
 275         hwmon = devm_kzalloc(&dev->dev, sizeof(struct s3c_hwmon), GFP_KERNEL);
 276         if (hwmon == NULL)
 277                 return -ENOMEM;
 278
 279         platform_set_drvdata(dev, hwmon);
 280
 281         mutex_init(&hwmon->lock);
 282
 283         /* Register with the core ADC driver. */
 284
 285         hwmon->client = s3c_adc_register(dev, NULL, NULL, 0);
 286         if (IS_ERR(hwmon->client)) {
 287                 dev_err(&dev->dev, "cannot register adc\n");
 288                 return PTR_ERR(hwmon->client);
 289         }
 290
 291         /* add attributes for our adc devices. */
 292
 293         ret = s3c_hwmon_add_raw(&dev->dev);
 294         if (ret)
 295                 goto err_registered;
 296
 297         /* register with the hwmon core */
 298
 299         hwmon->hwmon_dev = hwmon_device_register(&dev->dev);
 300         if (IS_ERR(hwmon->hwmon_dev)) {
 301                 dev_err(&dev->dev, "error registering with hwmon\n");
 302                 ret = PTR_ERR(hwmon->hwmon_dev);
 303                 goto err_raw_attribute;
 304         }
 305
 306         for (i = 0; i < ARRAY_SIZE(pdata->in); i++) {
 307                 struct s3c_hwmon_chcfg *cfg = pdata->in[i];
 308
 309                 if (!cfg)
 310                         continue;
 311
 312                 if (cfg->mult >= 0x10000)
 313                         dev_warn(&dev->dev,
 314                                  "channel %d multiplier too large\n",
 315                                  i);
 316
 317                 if (cfg->div == 0) {
 318                         dev_err(&dev->dev, "channel %d divider zero\n", i);
 319                         continue;
 320                 }
 321
 322                 ret = s3c_hwmon_create_attr(&dev->dev, pdata->in[i],
 323                                             &hwmon->attrs[i], i);
 324                 if (ret) {
 325                         dev_err(&dev->dev,
 326                                         "error creating channel %d\n", i);
 327
 328                         for (i--; i >= 0; i--)
 329                                 s3c_hwmon_remove_attr(&dev->dev,
 330                                                               &hwmon->attrs[i]);
 331
 332                         goto err_hwmon_register;
 333                 }
 334         }
 335
 336         return 0;
 337
 338  err_hwmon_register:
 339         hwmon_device_unregister(hwmon->hwmon_dev);
 340
 341  err_raw_attribute:
 342         s3c_hwmon_remove_raw(&dev->dev);
 343
 344  err_registered:
 345         s3c_adc_release(hwmon->client);
 346
 347         return ret;
 348 }
 349
 350 static int s3c_hwmon_remove(struct platform_device *dev)
 351 {
 352         struct s3c_hwmon *hwmon = platform_get_drvdata(dev);
 353         int i;
 354
 355         s3c_hwmon_remove_raw(&dev->dev);
 356
 357         for (i = 0; i < ARRAY_SIZE(hwmon->attrs); i++)
 358                 s3c_hwmon_remove_attr(&dev->dev, &hwmon->attrs[i]);
 359
 360         hwmon_device_unregister(hwmon->hwmon_dev);
 361         s3c_adc_release(hwmon->client);
 362
 363         return 0;
 364 }
 365
 366 static struct platform_driver s3c_hwmon_driver = {
 367         .driver = {
 368                 .name           = "s3c-hwmon",
 369         },
 370         .probe          = s3c_hwmon_probe,
 371         .remove         = s3c_hwmon_remove,
 372 };
 373
 374 module_platform_driver(s3c_hwmon_driver);
 375
 376 MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
 377 MODULE_DESCRIPTION("S3C ADC HWMon driver");
 378 MODULE_LICENSE("GPL v2");
 379 MODULE_ALIAS("platform:s3c-hwmon");