drivers/regulator/rc5t583-regulator.c

   1 /*
   2  * Regulator driver for RICOH RC5T583 power management chip.
   3  *
   4  * Copyright (c) 2011-2012, NVIDIA CORPORATION.  All rights reserved.
   5  * Author: Laxman dewangan <ldewangan@nvidia.com>
   6  *
   7  * based on code
   8  *      Copyright (C) 2011 RICOH COMPANY,LTD
   9  *
  10  *
  11  * This program is free software; you can redistribute it and/or modify it
  12  * under the terms and conditions of the GNU General Public License,
  13  * version 2, as published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope it will be useful, but WITHOUT
  16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  18  * more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22  *
  23  */
  24
  25 #include <linux/module.h>
  26 #include <linux/delay.h>
  27 #include <linux/init.h>
  28 #include <linux/slab.h>
  29 #include <linux/err.h>
  30 #include <linux/platform_device.h>
  31 #include <linux/regulator/driver.h>
  32 #include <linux/regulator/machine.h>
  33 #include <linux/gpio.h>
  34 #include <linux/mfd/rc5t583.h>
  35
  36 struct rc5t583_regulator_info {
  37         int                     deepsleep_id;
  38
  39         /* Regulator register address.*/
  40         uint8_t                 reg_en_reg;
  41         uint8_t                 en_bit;
  42         uint8_t                 reg_disc_reg;
  43         uint8_t                 disc_bit;
  44         uint8_t                 vout_reg;
  45         uint8_t                 vout_mask;
  46         uint8_t                 deepsleep_reg;
  47
  48         /* Chip constraints on regulator behavior */
  49         int                     min_uV;
  50         int                     max_uV;
  51         int                     step_uV;
  52
  53         /* Regulator specific turn-on delay  and voltage settling time*/
  54         int                     enable_uv_per_us;
  55         int                     change_uv_per_us;
  56
  57         /* Used by regulator core */
  58         struct regulator_desc   desc;
  59 };
  60
  61 struct rc5t583_regulator {
  62         struct rc5t583_regulator_info *reg_info;
  63
  64         /* Devices */
  65         struct device           *dev;
  66         struct rc5t583          *mfd;
  67         struct regulator_dev    *rdev;
  68 };
  69
  70 static int rc5t583_reg_is_enabled(struct regulator_dev *rdev)
  71 {
  72         struct rc5t583_regulator *reg = rdev_get_drvdata(rdev);
  73         struct rc5t583_regulator_info *ri = reg->reg_info;
  74         uint8_t control;
  75         int ret;
  76
  77         ret = rc5t583_read(reg->mfd->dev, ri->reg_en_reg, &control);
  78         if (ret < 0) {
  79                 dev_err(&rdev->dev,
  80                         "Error in reading the control register 0x%02x\n",
  81                         ri->reg_en_reg);
  82                 return ret;
  83         }
  84         return !!(control & BIT(ri->en_bit));
  85 }
  86
  87 static int rc5t583_reg_enable(struct regulator_dev *rdev)
  88 {
  89         struct rc5t583_regulator *reg = rdev_get_drvdata(rdev);
  90         struct rc5t583_regulator_info *ri = reg->reg_info;
  91         int ret;
  92
  93         ret = rc5t583_set_bits(reg->mfd->dev, ri->reg_en_reg,
  94                                 (1 << ri->en_bit));
  95         if (ret < 0) {
  96                 dev_err(&rdev->dev,
  97                         "Error in setting bit of STATE register 0x%02x\n",
  98                         ri->reg_en_reg);
  99                 return ret;
 100         }
 101         return ret;
 102 }
 103
 104 static int rc5t583_reg_disable(struct regulator_dev *rdev)
 105 {
 106         struct rc5t583_regulator *reg = rdev_get_drvdata(rdev);
 107         struct rc5t583_regulator_info *ri = reg->reg_info;
 108         int ret;
 109
 110         ret = rc5t583_clear_bits(reg->mfd->dev, ri->reg_en_reg,
 111                                 (1 << ri->en_bit));
 112         if (ret < 0)
 113                 dev_err(&rdev->dev,
 114                         "Error in clearing bit of STATE register 0x%02x\n",
 115                         ri->reg_en_reg);
 116
 117         return ret;
 118 }
 119
 120 static int rc5t583_list_voltage(struct regulator_dev *rdev, unsigned selector)
 121 {
 122         struct rc5t583_regulator *reg = rdev_get_drvdata(rdev);
 123         struct rc5t583_regulator_info *ri = reg->reg_info;
 124         return ri->min_uV + (ri->step_uV * selector);
 125 }
 126
 127 static int rc5t583_set_voltage(struct regulator_dev *rdev,
 128                                int min_uV, int max_uV, unsigned *selector)
 129 {
 130         struct rc5t583_regulator *reg = rdev_get_drvdata(rdev);
 131         struct rc5t583_regulator_info *ri = reg->reg_info;
 132         int sel, ret;
 133
 134         if (min_uV < ri->min_uV)
 135                 min_uV = ri->min_uV;
 136
 137         sel = DIV_ROUND_UP(min_uV - ri->min_uV, ri->step_uV);
 138
 139         if (sel >= rdev->desc->n_voltages) {
 140                 dev_err(&rdev->dev, "Invalid selector 0x%02x\n", sel);
 141                 return -EINVAL;
 142         }
 143
 144         *selector = sel;
 145
 146         ret = rc5t583_update(reg->mfd->dev, ri->vout_reg, sel, ri->vout_mask);
 147         if (ret < 0)
 148                 dev_err(&rdev->dev,
 149                     "Error in update voltage register 0x%02x\n", ri->vout_reg);
 150         return ret;
 151 }
 152
 153 static int rc5t583_get_voltage_sel(struct regulator_dev *rdev)
 154 {
 155         struct rc5t583_regulator *reg = rdev_get_drvdata(rdev);
 156         struct rc5t583_regulator_info *ri = reg->reg_info;
 157         uint8_t vsel;
 158         int ret;
 159         ret = rc5t583_read(reg->mfd->dev, ri->vout_reg, &vsel);
 160         if (ret < 0) {
 161                 dev_err(&rdev->dev,
 162                     "Error in reading voltage register 0x%02x\n", ri->vout_reg);
 163                 return ret;
 164         }
 165         return vsel & ri->vout_mask;
 166 }
 167
 168 static int rc5t583_regulator_enable_time(struct regulator_dev *rdev)
 169 {
 170         struct rc5t583_regulator *reg = rdev_get_drvdata(rdev);
 171         int vsel = rc5t583_get_voltage_sel(rdev);
 172         int curr_uV = rc5t583_list_voltage(rdev, vsel);
 173         return DIV_ROUND_UP(curr_uV, reg->reg_info->enable_uv_per_us);
 174 }
 175
 176 static int rc5t583_set_voltage_time_sel(struct regulator_dev *rdev,
 177                 unsigned int old_selector, unsigned int new_selector)
 178 {
 179         struct rc5t583_regulator *reg = rdev_get_drvdata(rdev);
 180         int old_uV, new_uV;
 181         old_uV = rc5t583_list_voltage(rdev, old_selector);
 182
 183         if (old_uV < 0)
 184                 return old_uV;
 185
 186         new_uV = rc5t583_list_voltage(rdev, new_selector);
 187         if (new_uV < 0)
 188                 return new_uV;
 189
 190         return DIV_ROUND_UP(abs(old_uV - new_uV),
 191                                 reg->reg_info->change_uv_per_us);
 192 }
 193
 194
 195 static struct regulator_ops rc5t583_ops = {
 196         .is_enabled             = rc5t583_reg_is_enabled,
 197         .enable                 = rc5t583_reg_enable,
 198         .disable                = rc5t583_reg_disable,
 199         .enable_time            = rc5t583_regulator_enable_time,
 200         .get_voltage_sel        = rc5t583_get_voltage_sel,
 201         .set_voltage            = rc5t583_set_voltage,
 202         .list_voltage           = rc5t583_list_voltage,
 203         .set_voltage_time_sel   = rc5t583_set_voltage_time_sel,
 204 };
 205
 206 #define RC5T583_REG(_id, _en_reg, _en_bit, _disc_reg, _disc_bit, \
 207                 _vout_mask, _min_mv, _max_mv, _step_uV, _enable_mv) \
 208 {                                                               \
 209         .reg_en_reg     = RC5T583_REG_##_en_reg,                \
 210         .en_bit         = _en_bit,                              \
 211         .reg_disc_reg   = RC5T583_REG_##_disc_reg,              \
 212         .disc_bit       = _disc_bit,                            \
 213         .vout_reg       = RC5T583_REG_##_id##DAC,               \
 214         .vout_mask      = _vout_mask,                           \
 215         .deepsleep_reg  = RC5T583_REG_##_id##DAC_DS,            \
 216         .min_uV         = _min_mv * 1000,                       \
 217         .max_uV         = _max_mv * 1000,                       \
 218         .step_uV        = _step_uV,                             \
 219         .enable_uv_per_us = _enable_mv * 1000,                  \
 220         .change_uv_per_us = 40 * 1000,                          \
 221         .deepsleep_id   = RC5T583_DS_##_id,                     \
 222         .desc = {                                               \
 223                 .name = "rc5t583-regulator-"#_id,               \
 224                 .id = RC5T583_REGULATOR_##_id,                  \
 225                 .n_voltages = (_max_mv - _min_mv) * 1000 / _step_uV + 1, \
 226                 .ops = &rc5t583_ops,                            \
 227                 .type = REGULATOR_VOLTAGE,                      \
 228                 .owner = THIS_MODULE,                           \
 229         },                                                      \
 230 }
 231
 232 static struct rc5t583_regulator_info rc5t583_reg_info[RC5T583_REGULATOR_MAX] = {
 233         RC5T583_REG(DC0, DC0CTL, 0, DC0CTL, 1, 0x7F, 700, 1500, 12500, 4),
 234         RC5T583_REG(DC1, DC1CTL, 0, DC1CTL, 1, 0x7F, 700, 1500, 12500, 14),
 235         RC5T583_REG(DC2, DC2CTL, 0, DC2CTL, 1, 0x7F, 900, 2400, 12500, 14),
 236         RC5T583_REG(DC3, DC3CTL, 0, DC3CTL, 1, 0x7F, 900, 2400, 12500, 14),
 237         RC5T583_REG(LDO0, LDOEN2, 0, LDODIS2, 0, 0x7F, 900, 3400, 25000, 160),
 238         RC5T583_REG(LDO1, LDOEN2, 1, LDODIS2, 1, 0x7F, 900, 3400, 25000, 160),
 239         RC5T583_REG(LDO2, LDOEN2, 2, LDODIS2, 2, 0x7F, 900, 3400, 25000, 160),
 240         RC5T583_REG(LDO3, LDOEN2, 3, LDODIS2, 3, 0x7F, 900, 3400, 25000, 160),
 241         RC5T583_REG(LDO4, LDOEN2, 4, LDODIS2, 4, 0x3F, 750, 1500, 12500, 133),
 242         RC5T583_REG(LDO5, LDOEN2, 5, LDODIS2, 5, 0x7F, 900, 3400, 25000, 267),
 243         RC5T583_REG(LDO6, LDOEN2, 6, LDODIS2, 6, 0x7F, 900, 3400, 25000, 133),
 244         RC5T583_REG(LDO7, LDOEN2, 7, LDODIS2, 7, 0x7F, 900, 3400, 25000, 233),
 245         RC5T583_REG(LDO8, LDOEN1, 0, LDODIS1, 0, 0x7F, 900, 3400, 25000, 233),
 246         RC5T583_REG(LDO9, LDOEN1, 1, LDODIS1, 1, 0x7F, 900, 3400, 25000, 133),
 247 };
 248
 249 static int __devinit rc5t583_regulator_probe(struct platform_device *pdev)
 250 {
 251         struct rc5t583 *rc5t583 = dev_get_drvdata(pdev->dev.parent);
 252         struct rc5t583_platform_data *pdata = dev_get_platdata(rc5t583->dev);
 253         struct regulator_init_data *reg_data;
 254         struct regulator_config config = { };
 255         struct rc5t583_regulator *reg = NULL;
 256         struct rc5t583_regulator *regs;
 257         struct regulator_dev *rdev;
 258         struct rc5t583_regulator_info *ri;
 259         int ret;
 260         int id;
 261
 262         if (!pdata) {
 263                 dev_err(&pdev->dev, "No platform data, exiting...\n");
 264                 return -ENODEV;
 265         }
 266
 267         regs = devm_kzalloc(&pdev->dev, RC5T583_REGULATOR_MAX *
 268                         sizeof(struct rc5t583_regulator), GFP_KERNEL);
 269         if (!regs) {
 270                 dev_err(&pdev->dev, "Memory allocation failed exiting..\n");
 271                 return -ENOMEM;
 272         }
 273
 274
 275         for (id = 0; id < RC5T583_REGULATOR_MAX; ++id) {
 276                 reg_data = pdata->reg_init_data[id];
 277
 278                 /* No need to register if there is no regulator data */
 279                 if (!reg_data)
 280                         continue;
 281
 282                 reg = &regs[id];
 283                 ri = &rc5t583_reg_info[id];
 284                 reg->reg_info = ri;
 285                 reg->mfd = rc5t583;
 286                 reg->dev = &pdev->dev;
 287
 288                 if (ri->deepsleep_id == RC5T583_DS_NONE)
 289                         goto skip_ext_pwr_config;
 290
 291                 ret = rc5t583_ext_power_req_config(rc5t583->dev,
 292                                 ri->deepsleep_id,
 293                                 pdata->regulator_ext_pwr_control[id],
 294                                 pdata->regulator_deepsleep_slot[id]);
 295                 /*
 296                  * Configuring external control is not a major issue,
 297                  * just give warning.
 298                  */
 299                 if (ret < 0)
 300                         dev_warn(&pdev->dev,
 301                                 "Failed to configure ext control %d\n", id);
 302
 303 skip_ext_pwr_config:
 304                 config.dev = &pdev->dev;
 305                 config.init_data = reg_data;
 306                 config.driver_data = reg;
 307
 308                 rdev = regulator_register(&ri->desc, &config);
 309                 if (IS_ERR(rdev)) {
 310                         dev_err(&pdev->dev, "Failed to register regulator %s\n",
 311                                                 ri->desc.name);
 312                         ret = PTR_ERR(rdev);
 313                         goto clean_exit;
 314                 }
 315                 reg->rdev = rdev;
 316         }
 317         platform_set_drvdata(pdev, regs);
 318         return 0;
 319
 320 clean_exit:
 321         while (--id >= 0)
 322                 regulator_unregister(regs[id].rdev);
 323
 324         return ret;
 325 }
 326
 327 static int __devexit rc5t583_regulator_remove(struct platform_device *pdev)
 328 {
 329         struct rc5t583_regulator *regs = platform_get_drvdata(pdev);
 330         int id;
 331
 332         for (id = 0; id < RC5T583_REGULATOR_MAX; ++id)
 333                 regulator_unregister(regs[id].rdev);
 334         return 0;
 335 }
 336
 337 static struct platform_driver rc5t583_regulator_driver = {
 338         .driver = {
 339                 .name   = "rc5t583-regulator",
 340                 .owner  = THIS_MODULE,
 341         },
 342         .probe          = rc5t583_regulator_probe,
 343         .remove         = __devexit_p(rc5t583_regulator_remove),
 344 };
 345
 346 static int __init rc5t583_regulator_init(void)
 347 {
 348         return platform_driver_register(&rc5t583_regulator_driver);
 349 }
 350 subsys_initcall(rc5t583_regulator_init);
 351
 352 static void __exit rc5t583_regulator_exit(void)
 353 {
 354         platform_driver_unregister(&rc5t583_regulator_driver);
 355 }
 356 module_exit(rc5t583_regulator_exit);
 357
 358 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
 359 MODULE_DESCRIPTION("RC5T583 regulator driver");
 360 MODULE_ALIAS("platform:rc5t583-regulator");
 361 MODULE_LICENSE("GPL v2");