drivers/regulator/virtual.c

   1 /*
   2  * reg-virtual-consumer.c
   3  *
   4  * Copyright 2008 Wolfson Microelectronics PLC.
   5  *
   6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of the
  11  * License, or (at your option) any later version.
  12  */
  13
  14 #include <linux/err.h>
  15 #include <linux/mutex.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/regulator/consumer.h>
  18
  19 struct virtual_consumer_data {
  20         struct mutex lock;
  21         struct regulator *regulator;
  22         bool enabled;
  23         int min_uV;
  24         int max_uV;
  25         int min_uA;
  26         int max_uA;
  27         unsigned int mode;
  28 };
  29
  30 static void update_voltage_constraints(struct device *dev,
  31                                        struct virtual_consumer_data *data)
  32 {
  33         int ret;
  34
  35         if (data->min_uV && data->max_uV
  36             && data->min_uV <= data->max_uV) {
  37                 dev_dbg(dev, "Requesting %d-%duV\n",
  38                         data->min_uV, data->max_uV);
  39                 ret = regulator_set_voltage(data->regulator,
  40                                         data->min_uV, data->max_uV);
  41                 if (ret != 0) {
  42                         dev_err(dev,
  43                                 "regulator_set_voltage() failed: %d\n", ret);
  44                         return;
  45                 }
  46         }
  47
  48         if (data->min_uV && data->max_uV && !data->enabled) {
  49                 dev_dbg(dev, "Enabling regulator\n");
  50                 ret = regulator_enable(data->regulator);
  51                 if (ret == 0)
  52                         data->enabled = true;
  53                 else
  54                         dev_err(dev, "regulator_enable() failed: %d\n",
  55                                 ret);
  56         }
  57
  58         if (!(data->min_uV && data->max_uV) && data->enabled) {
  59                 dev_dbg(dev, "Disabling regulator\n");
  60                 ret = regulator_disable(data->regulator);
  61                 if (ret == 0)
  62                         data->enabled = false;
  63                 else
  64                         dev_err(dev, "regulator_disable() failed: %d\n",
  65                                 ret);
  66         }
  67 }
  68
  69 static void update_current_limit_constraints(struct device *dev,
  70                                           struct virtual_consumer_data *data)
  71 {
  72         int ret;
  73
  74         if (data->max_uA
  75             && data->min_uA <= data->max_uA) {
  76                 dev_dbg(dev, "Requesting %d-%duA\n",
  77                         data->min_uA, data->max_uA);
  78                 ret = regulator_set_current_limit(data->regulator,
  79                                         data->min_uA, data->max_uA);
  80                 if (ret != 0) {
  81                         dev_err(dev,
  82                                 "regulator_set_current_limit() failed: %d\n",
  83                                 ret);
  84                         return;
  85                 }
  86         }
  87
  88         if (data->max_uA && !data->enabled) {
  89                 dev_dbg(dev, "Enabling regulator\n");
  90                 ret = regulator_enable(data->regulator);
  91                 if (ret == 0)
  92                         data->enabled = true;
  93                 else
  94                         dev_err(dev, "regulator_enable() failed: %d\n",
  95                                 ret);
  96         }
  97
  98         if (!(data->min_uA && data->max_uA) && data->enabled) {
  99                 dev_dbg(dev, "Disabling regulator\n");
 100                 ret = regulator_disable(data->regulator);
 101                 if (ret == 0)
 102                         data->enabled = false;
 103                 else
 104                         dev_err(dev, "regulator_disable() failed: %d\n",
 105                                 ret);
 106         }
 107 }
 108
 109 static ssize_t show_min_uV(struct device *dev,
 110                            struct device_attribute *attr, char *buf)
 111 {
 112         struct virtual_consumer_data *data = dev_get_drvdata(dev);
 113         return sprintf(buf, "%d\n", data->min_uV);
 114 }
 115
 116 static ssize_t set_min_uV(struct device *dev, struct device_attribute *attr,
 117                           const char *buf, size_t count)
 118 {
 119         struct virtual_consumer_data *data = dev_get_drvdata(dev);
 120         long val;
 121
 122         if (strict_strtol(buf, 10, &val) != 0)
 123                 return count;
 124
 125         mutex_lock(&data->lock);
 126
 127         data->min_uV = val;
 128         update_voltage_constraints(dev, data);
 129
 130         mutex_unlock(&data->lock);
 131
 132         return count;
 133 }
 134
 135 static ssize_t show_max_uV(struct device *dev,
 136                            struct device_attribute *attr, char *buf)
 137 {
 138         struct virtual_consumer_data *data = dev_get_drvdata(dev);
 139         return sprintf(buf, "%d\n", data->max_uV);
 140 }
 141
 142 static ssize_t set_max_uV(struct device *dev, struct device_attribute *attr,
 143                           const char *buf, size_t count)
 144 {
 145         struct virtual_consumer_data *data = dev_get_drvdata(dev);
 146         long val;
 147
 148         if (strict_strtol(buf, 10, &val) != 0)
 149                 return count;
 150
 151         mutex_lock(&data->lock);
 152
 153         data->max_uV = val;
 154         update_voltage_constraints(dev, data);
 155
 156         mutex_unlock(&data->lock);
 157
 158         return count;
 159 }
 160
 161 static ssize_t show_min_uA(struct device *dev,
 162                            struct device_attribute *attr, char *buf)
 163 {
 164         struct virtual_consumer_data *data = dev_get_drvdata(dev);
 165         return sprintf(buf, "%d\n", data->min_uA);
 166 }
 167
 168 static ssize_t set_min_uA(struct device *dev, struct device_attribute *attr,
 169                           const char *buf, size_t count)
 170 {
 171         struct virtual_consumer_data *data = dev_get_drvdata(dev);
 172         long val;
 173
 174         if (strict_strtol(buf, 10, &val) != 0)
 175                 return count;
 176
 177         mutex_lock(&data->lock);
 178
 179         data->min_uA = val;
 180         update_current_limit_constraints(dev, data);
 181
 182         mutex_unlock(&data->lock);
 183
 184         return count;
 185 }
 186
 187 static ssize_t show_max_uA(struct device *dev,
 188                            struct device_attribute *attr, char *buf)
 189 {
 190         struct virtual_consumer_data *data = dev_get_drvdata(dev);
 191         return sprintf(buf, "%d\n", data->max_uA);
 192 }
 193
 194 static ssize_t set_max_uA(struct device *dev, struct device_attribute *attr,
 195                           const char *buf, size_t count)
 196 {
 197         struct virtual_consumer_data *data = dev_get_drvdata(dev);
 198         long val;
 199
 200         if (strict_strtol(buf, 10, &val) != 0)
 201                 return count;
 202
 203         mutex_lock(&data->lock);
 204
 205         data->max_uA = val;
 206         update_current_limit_constraints(dev, data);
 207
 208         mutex_unlock(&data->lock);
 209
 210         return count;
 211 }
 212
 213 static ssize_t show_mode(struct device *dev,
 214                          struct device_attribute *attr, char *buf)
 215 {
 216         struct virtual_consumer_data *data = dev_get_drvdata(dev);
 217
 218         switch (data->mode) {
 219         case REGULATOR_MODE_FAST:
 220                 return sprintf(buf, "fast\n");
 221         case REGULATOR_MODE_NORMAL:
 222                 return sprintf(buf, "normal\n");
 223         case REGULATOR_MODE_IDLE:
 224                 return sprintf(buf, "idle\n");
 225         case REGULATOR_MODE_STANDBY:
 226                 return sprintf(buf, "standby\n");
 227         default:
 228                 return sprintf(buf, "unknown\n");
 229         }
 230 }
 231
 232 static ssize_t set_mode(struct device *dev, struct device_attribute *attr,
 233                         const char *buf, size_t count)
 234 {
 235         struct virtual_consumer_data *data = dev_get_drvdata(dev);
 236         unsigned int mode;
 237         int ret;
 238
 239         /*
 240          * sysfs_streq() doesn't need the \n's, but we add them so the strings
 241          * will be shared with show_mode(), above.
 242          */
 243         if (sysfs_streq(buf, "fast\n"))
 244                 mode = REGULATOR_MODE_FAST;
 245         else if (sysfs_streq(buf, "normal\n"))
 246                 mode = REGULATOR_MODE_NORMAL;
 247         else if (sysfs_streq(buf, "idle\n"))
 248                 mode = REGULATOR_MODE_IDLE;
 249         else if (sysfs_streq(buf, "standby\n"))
 250                 mode = REGULATOR_MODE_STANDBY;
 251         else {
 252                 dev_err(dev, "Configuring invalid mode\n");
 253                 return count;
 254         }
 255
 256         mutex_lock(&data->lock);
 257         ret = regulator_set_mode(data->regulator, mode);
 258         if (ret == 0)
 259                 data->mode = mode;
 260         else
 261                 dev_err(dev, "Failed to configure mode: %d\n", ret);
 262         mutex_unlock(&data->lock);
 263
 264         return count;
 265 }
 266
 267 static DEVICE_ATTR(min_microvolts, 0666, show_min_uV, set_min_uV);
 268 static DEVICE_ATTR(max_microvolts, 0666, show_max_uV, set_max_uV);
 269 static DEVICE_ATTR(min_microamps, 0666, show_min_uA, set_min_uA);
 270 static DEVICE_ATTR(max_microamps, 0666, show_max_uA, set_max_uA);
 271 static DEVICE_ATTR(mode, 0666, show_mode, set_mode);
 272
 273 static struct attribute *regulator_virtual_attributes[] = {
 274         &dev_attr_min_microvolts.attr,
 275         &dev_attr_max_microvolts.attr,
 276         &dev_attr_min_microamps.attr,
 277         &dev_attr_max_microamps.attr,
 278         &dev_attr_mode.attr,
 279         NULL
 280 };
 281
 282 static const struct attribute_group regulator_virtual_attr_group = {
 283         .attrs  = regulator_virtual_attributes,
 284 };
 285
 286 static int __devinit regulator_virtual_probe(struct platform_device *pdev)
 287 {
 288         char *reg_id = pdev->dev.platform_data;
 289         struct virtual_consumer_data *drvdata;
 290         int ret;
 291
 292         drvdata = kzalloc(sizeof(struct virtual_consumer_data), GFP_KERNEL);
 293         if (drvdata == NULL)
 294                 return -ENOMEM;
 295
 296         mutex_init(&drvdata->lock);
 297
 298         drvdata->regulator = regulator_get(&pdev->dev, reg_id);
 299         if (IS_ERR(drvdata->regulator)) {
 300                 ret = PTR_ERR(drvdata->regulator);
 301                 dev_err(&pdev->dev, "Failed to obtain supply '%s': %d\n",
 302                         reg_id, ret);
 303                 goto err;
 304         }
 305
 306         ret = sysfs_create_group(&pdev->dev.kobj,
 307                                  &regulator_virtual_attr_group);
 308         if (ret != 0) {
 309                 dev_err(&pdev->dev,
 310                         "Failed to create attribute group: %d\n", ret);
 311                 goto err_regulator;
 312         }
 313
 314         drvdata->mode = regulator_get_mode(drvdata->regulator);
 315
 316         platform_set_drvdata(pdev, drvdata);
 317
 318         return 0;
 319
 320 err_regulator:
 321         regulator_put(drvdata->regulator);
 322 err:
 323         kfree(drvdata);
 324         return ret;
 325 }
 326
 327 static int __devexit regulator_virtual_remove(struct platform_device *pdev)
 328 {
 329         struct virtual_consumer_data *drvdata = platform_get_drvdata(pdev);
 330
 331         sysfs_remove_group(&pdev->dev.kobj, &regulator_virtual_attr_group);
 332
 333         if (drvdata->enabled)
 334                 regulator_disable(drvdata->regulator);
 335         regulator_put(drvdata->regulator);
 336
 337         kfree(drvdata);
 338
 339         platform_set_drvdata(pdev, NULL);
 340
 341         return 0;
 342 }
 343
 344 static struct platform_driver regulator_virtual_consumer_driver = {
 345         .probe          = regulator_virtual_probe,
 346         .remove         = __devexit_p(regulator_virtual_remove),
 347         .driver         = {
 348                 .name           = "reg-virt-consumer",
 349                 .owner          = THIS_MODULE,
 350         },
 351 };
 352
 353 static int __init regulator_virtual_consumer_init(void)
 354 {
 355         return platform_driver_register(&regulator_virtual_consumer_driver);
 356 }
 357 module_init(regulator_virtual_consumer_init);
 358
 359 static void __exit regulator_virtual_consumer_exit(void)
 360 {
 361         platform_driver_unregister(&regulator_virtual_consumer_driver);
 362 }
 363 module_exit(regulator_virtual_consumer_exit);
 364
 365 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 366 MODULE_DESCRIPTION("Virtual regulator consumer");
 367 MODULE_LICENSE("GPL");
 368 MODULE_ALIAS("platform:reg-virt-consumer");