LXR linux/drivers/regulator/anatop-regulator.c

   1/*
   2 * Copyright (C) 2011 Freescale Semiconductor, Inc. All Rights Reserved.
   3 */
   4
   5/*
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation; either version 2 of the License, or
   9 * (at your option) any later version.
  10
  11 * This program is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15
  16 * You should have received a copy of the GNU General Public License along
  17 * with this program; if not, write to the Free Software Foundation, Inc.,
  18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21#include <linux/slab.h>
  22#include <linux/device.h>
  23#include <linux/module.h>
  24#include <linux/mfd/syscon.h>
  25#include <linux/err.h>
  26#include <linux/io.h>
  27#include <linux/platform_device.h>
  28#include <linux/of.h>
  29#include <linux/of_address.h>
  30#include <linux/regmap.h>
  31#include <linux/regulator/driver.h>
  32#include <linux/regulator/of_regulator.h>
  33
  34#define LDO_RAMP_UP_UNIT_IN_CYCLES      64 /* 64 cycles per step */
  35#define LDO_RAMP_UP_FREQ_IN_MHZ         24 /* cycle based on 24M OSC */
  36
  37struct anatop_regulator {
  38        const char *name;
  39        u32 control_reg;
  40        struct regmap *anatop;
  41        int vol_bit_shift;
  42        int vol_bit_width;
  43        u32 delay_reg;
  44        int delay_bit_shift;
  45        int delay_bit_width;
  46        int min_bit_val;
  47        int min_voltage;
  48        int max_voltage;
  49        struct regulator_desc rdesc;
  50        struct regulator_init_data *initdata;
  51};
  52
  53static int anatop_regmap_set_voltage_sel(struct regulator_dev *reg,
  54                                        unsigned selector)
  55{
  56        struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
  57
  58        if (!anatop_reg->control_reg)
  59                return -ENOTSUPP;
  60
  61        return regulator_set_voltage_sel_regmap(reg, selector);
  62}
  63
  64static int anatop_regmap_set_voltage_time_sel(struct regulator_dev *reg,
  65        unsigned int old_sel,
  66        unsigned int new_sel)
  67{
  68        struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
  69        u32 val;
  70        int ret = 0;
  71
  72        /* check whether need to care about LDO ramp up speed */
  73        if (anatop_reg->delay_bit_width && new_sel > old_sel) {
  74                /*
  75                 * the delay for LDO ramp up time is
  76                 * based on the register setting, we need
  77                 * to calculate how many steps LDO need to
  78                 * ramp up, and how much delay needed. (us)
  79                 */
  80                regmap_read(anatop_reg->anatop, anatop_reg->delay_reg, &val);
  81                val = (val >> anatop_reg->delay_bit_shift) &
  82                        ((1 << anatop_reg->delay_bit_width) - 1);
  83                ret = (new_sel - old_sel) * (LDO_RAMP_UP_UNIT_IN_CYCLES <<
  84                        val) / LDO_RAMP_UP_FREQ_IN_MHZ + 1;
  85        }
  86
  87        return ret;
  88}
  89
  90static int anatop_regmap_get_voltage_sel(struct regulator_dev *reg)
  91{
  92        struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
  93
  94        if (!anatop_reg->control_reg)
  95                return -ENOTSUPP;
  96
  97        return regulator_get_voltage_sel_regmap(reg);
  98}
  99
 100static struct regulator_ops anatop_rops = {
 101        .set_voltage_sel = anatop_regmap_set_voltage_sel,
 102        .set_voltage_time_sel = anatop_regmap_set_voltage_time_sel,
 103        .get_voltage_sel = anatop_regmap_get_voltage_sel,
 104        .list_voltage = regulator_list_voltage_linear,
 105        .map_voltage = regulator_map_voltage_linear,
 106};
 107
 108static int anatop_regulator_probe(struct platform_device *pdev)
 109{
 110        struct device *dev = &pdev->dev;
 111        struct device_node *np = dev->of_node;
 112        struct device_node *anatop_np;
 113        struct regulator_desc *rdesc;
 114        struct regulator_dev *rdev;
 115        struct anatop_regulator *sreg;
 116        struct regulator_init_data *initdata;
 117        struct regulator_config config = { };
 118        int ret = 0;
 119
 120        initdata = of_get_regulator_init_data(dev, np);
 121        sreg = devm_kzalloc(dev, sizeof(*sreg), GFP_KERNEL);
 122        if (!sreg)
 123                return -ENOMEM;
 124        sreg->initdata = initdata;
 125        sreg->name = kstrdup(of_get_property(np, "regulator-name", NULL),
 126                             GFP_KERNEL);
 127        rdesc = &sreg->rdesc;
 128        memset(rdesc, 0, sizeof(*rdesc));
 129        rdesc->name = sreg->name;
 130        rdesc->ops = &anatop_rops;
 131        rdesc->type = REGULATOR_VOLTAGE;
 132        rdesc->owner = THIS_MODULE;
 133
 134        anatop_np = of_get_parent(np);
 135        if (!anatop_np)
 136                return -ENODEV;
 137        sreg->anatop = syscon_node_to_regmap(anatop_np);
 138        of_node_put(anatop_np);
 139        if (IS_ERR(sreg->anatop))
 140                return PTR_ERR(sreg->anatop);
 141
 142        ret = of_property_read_u32(np, "anatop-reg-offset",
 143                                   &sreg->control_reg);
 144        if (ret) {
 145                dev_err(dev, "no anatop-reg-offset property set\n");
 146                goto anatop_probe_end;
 147        }
 148        ret = of_property_read_u32(np, "anatop-vol-bit-width",
 149                                   &sreg->vol_bit_width);
 150        if (ret) {
 151                dev_err(dev, "no anatop-vol-bit-width property set\n");
 152                goto anatop_probe_end;
 153        }
 154        ret = of_property_read_u32(np, "anatop-vol-bit-shift",
 155                                   &sreg->vol_bit_shift);
 156        if (ret) {
 157                dev_err(dev, "no anatop-vol-bit-shift property set\n");
 158                goto anatop_probe_end;
 159        }
 160        ret = of_property_read_u32(np, "anatop-min-bit-val",
 161                                   &sreg->min_bit_val);
 162        if (ret) {
 163                dev_err(dev, "no anatop-min-bit-val property set\n");
 164                goto anatop_probe_end;
 165        }
 166        ret = of_property_read_u32(np, "anatop-min-voltage",
 167                                   &sreg->min_voltage);
 168        if (ret) {
 169                dev_err(dev, "no anatop-min-voltage property set\n");
 170                goto anatop_probe_end;
 171        }
 172        ret = of_property_read_u32(np, "anatop-max-voltage",
 173                                   &sreg->max_voltage);
 174        if (ret) {
 175                dev_err(dev, "no anatop-max-voltage property set\n");
 176                goto anatop_probe_end;
 177        }
 178
 179        /* read LDO ramp up setting, only for core reg */
 180        of_property_read_u32(np, "anatop-delay-reg-offset",
 181                             &sreg->delay_reg);
 182        of_property_read_u32(np, "anatop-delay-bit-width",
 183                             &sreg->delay_bit_width);
 184        of_property_read_u32(np, "anatop-delay-bit-shift",
 185                             &sreg->delay_bit_shift);
 186
 187        rdesc->n_voltages = (sreg->max_voltage - sreg->min_voltage) / 25000 + 1
 188                            + sreg->min_bit_val;
 189        rdesc->min_uV = sreg->min_voltage;
 190        rdesc->uV_step = 25000;
 191        rdesc->linear_min_sel = sreg->min_bit_val;
 192        rdesc->vsel_reg = sreg->control_reg;
 193        rdesc->vsel_mask = ((1 << sreg->vol_bit_width) - 1) <<
 194                           sreg->vol_bit_shift;
 195
 196        config.dev = &pdev->dev;
 197        config.init_data = initdata;
 198        config.driver_data = sreg;
 199        config.of_node = pdev->dev.of_node;
 200        config.regmap = sreg->anatop;
 201
 202        /* register regulator */
 203        rdev = regulator_register(rdesc, &config);
 204        if (IS_ERR(rdev)) {
 205                dev_err(dev, "failed to register %s\n",
 206                        rdesc->name);
 207                ret = PTR_ERR(rdev);
 208                goto anatop_probe_end;
 209        }
 210
 211        platform_set_drvdata(pdev, rdev);
 212
 213anatop_probe_end:
 214        if (ret)
 215                kfree(sreg->name);
 216
 217        return ret;
 218}
 219
 220static int anatop_regulator_remove(struct platform_device *pdev)
 221{
 222        struct regulator_dev *rdev = platform_get_drvdata(pdev);
 223        struct anatop_regulator *sreg = rdev_get_drvdata(rdev);
 224        const char *name = sreg->name;
 225
 226        regulator_unregister(rdev);
 227        kfree(name);
 228
 229        return 0;
 230}
 231
 232static struct of_device_id of_anatop_regulator_match_tbl[] = {
 233        { .compatible = "fsl,anatop-regulator", },
 234        { /* end */ }
 235};
 236
 237static struct platform_driver anatop_regulator_driver = {
 238        .driver = {
 239                .name   = "anatop_regulator",
 240                .owner  = THIS_MODULE,
 241                .of_match_table = of_anatop_regulator_match_tbl,
 242        },
 243        .probe  = anatop_regulator_probe,
 244        .remove = anatop_regulator_remove,
 245};
 246
 247static int __init anatop_regulator_init(void)
 248{
 249        return platform_driver_register(&anatop_regulator_driver);
 250}
 251postcore_initcall(anatop_regulator_init);
 252
 253static void __exit anatop_regulator_exit(void)
 254{
 255        platform_driver_unregister(&anatop_regulator_driver);
 256}
 257module_exit(anatop_regulator_exit);
 258
 259MODULE_AUTHOR("Nancy Chen <Nancy.Chen@freescale.com>, "
 260              "Ying-Chun Liu (PaulLiu) <paul.liu@linaro.org>");
 261MODULE_DESCRIPTION("ANATOP Regulator driver");
 262MODULE_LICENSE("GPL v2");
 263