linux/drivers/regulator/lp872x.c
<<
>>
Prefs
   1/*
   2 * Copyright 2012 Texas Instruments
   3 *
   4 * Author: Milo(Woogyom) Kim <milo.kim@ti.com>
   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 version 2 as
   8 * published by the Free Software Foundation.
   9 *
  10 */
  11
  12#include <linux/module.h>
  13#include <linux/slab.h>
  14#include <linux/i2c.h>
  15#include <linux/regmap.h>
  16#include <linux/err.h>
  17#include <linux/gpio.h>
  18#include <linux/regulator/lp872x.h>
  19#include <linux/regulator/driver.h>
  20#include <linux/platform_device.h>
  21#include <linux/of.h>
  22#include <linux/of_gpio.h>
  23#include <linux/regulator/of_regulator.h>
  24
  25/* Registers : LP8720/8725 shared */
  26#define LP872X_GENERAL_CFG              0x00
  27#define LP872X_LDO1_VOUT                0x01
  28#define LP872X_LDO2_VOUT                0x02
  29#define LP872X_LDO3_VOUT                0x03
  30#define LP872X_LDO4_VOUT                0x04
  31#define LP872X_LDO5_VOUT                0x05
  32
  33/* Registers : LP8720 */
  34#define LP8720_BUCK_VOUT1               0x06
  35#define LP8720_BUCK_VOUT2               0x07
  36#define LP8720_ENABLE                   0x08
  37
  38/* Registers : LP8725 */
  39#define LP8725_LILO1_VOUT               0x06
  40#define LP8725_LILO2_VOUT               0x07
  41#define LP8725_BUCK1_VOUT1              0x08
  42#define LP8725_BUCK1_VOUT2              0x09
  43#define LP8725_BUCK2_VOUT1              0x0A
  44#define LP8725_BUCK2_VOUT2              0x0B
  45#define LP8725_BUCK_CTRL                0x0C
  46#define LP8725_LDO_CTRL                 0x0D
  47
  48/* Mask/shift : LP8720/LP8725 shared */
  49#define LP872X_VOUT_M                   0x1F
  50#define LP872X_START_DELAY_M            0xE0
  51#define LP872X_START_DELAY_S            5
  52#define LP872X_EN_LDO1_M                BIT(0)
  53#define LP872X_EN_LDO2_M                BIT(1)
  54#define LP872X_EN_LDO3_M                BIT(2)
  55#define LP872X_EN_LDO4_M                BIT(3)
  56#define LP872X_EN_LDO5_M                BIT(4)
  57
  58/* Mask/shift : LP8720 */
  59#define LP8720_TIMESTEP_S               0               /* Addr 00h */
  60#define LP8720_TIMESTEP_M               BIT(0)
  61#define LP8720_EXT_DVS_M                BIT(2)
  62#define LP8720_BUCK_FPWM_S              5               /* Addr 07h */
  63#define LP8720_BUCK_FPWM_M              BIT(5)
  64#define LP8720_EN_BUCK_M                BIT(5)          /* Addr 08h */
  65#define LP8720_DVS_SEL_M                BIT(7)
  66
  67/* Mask/shift : LP8725 */
  68#define LP8725_TIMESTEP_M               0xC0            /* Addr 00h */
  69#define LP8725_TIMESTEP_S               6
  70#define LP8725_BUCK1_EN_M               BIT(0)
  71#define LP8725_DVS1_M                   BIT(2)
  72#define LP8725_DVS2_M                   BIT(3)
  73#define LP8725_BUCK2_EN_M               BIT(4)
  74#define LP8725_BUCK_CL_M                0xC0            /* Addr 09h, 0Bh */
  75#define LP8725_BUCK_CL_S                6
  76#define LP8725_BUCK1_FPWM_S             1               /* Addr 0Ch */
  77#define LP8725_BUCK1_FPWM_M             BIT(1)
  78#define LP8725_BUCK2_FPWM_S             5
  79#define LP8725_BUCK2_FPWM_M             BIT(5)
  80#define LP8725_EN_LILO1_M               BIT(5)          /* Addr 0Dh */
  81#define LP8725_EN_LILO2_M               BIT(6)
  82
  83/* PWM mode */
  84#define LP872X_FORCE_PWM                1
  85#define LP872X_AUTO_PWM                 0
  86
  87#define LP8720_NUM_REGULATORS           6
  88#define LP8725_NUM_REGULATORS           9
  89#define EXTERN_DVS_USED                 0
  90#define MAX_DELAY                       6
  91
  92/* Default DVS Mode */
  93#define LP8720_DEFAULT_DVS              0
  94#define LP8725_DEFAULT_DVS              BIT(2)
  95
  96/* dump registers in regmap-debugfs */
  97#define MAX_REGISTERS                   0x0F
  98
  99enum lp872x_id {
 100        LP8720,
 101        LP8725,
 102};
 103
 104struct lp872x {
 105        struct regmap *regmap;
 106        struct device *dev;
 107        enum lp872x_id chipid;
 108        struct lp872x_platform_data *pdata;
 109        struct regulator_dev **regulators;
 110        int num_regulators;
 111        enum lp872x_dvs_state dvs_pin;
 112        int dvs_gpio;
 113};
 114
 115/* LP8720/LP8725 shared voltage table for LDOs */
 116static const unsigned int lp872x_ldo_vtbl[] = {
 117        1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000, 1550000,
 118        1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000, 2000000,
 119        2100000, 2200000, 2300000, 2400000, 2500000, 2600000, 2650000, 2700000,
 120        2750000, 2800000, 2850000, 2900000, 2950000, 3000000, 3100000, 3300000,
 121};
 122
 123/* LP8720 LDO4 voltage table */
 124static const unsigned int lp8720_ldo4_vtbl[] = {
 125         800000,  850000,  900000, 1000000, 1100000, 1200000, 1250000, 1300000,
 126        1350000, 1400000, 1450000, 1500000, 1550000, 1600000, 1650000, 1700000,
 127        1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
 128        2400000, 2500000, 2600000, 2650000, 2700000, 2750000, 2800000, 2850000,
 129};
 130
 131/* LP8725 LILO(Low Input Low Output) voltage table */
 132static const unsigned int lp8725_lilo_vtbl[] = {
 133         800000,  850000,  900000,  950000, 1000000, 1050000, 1100000, 1150000,
 134        1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
 135        1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
 136        2600000, 2700000, 2800000, 2850000, 2900000, 3000000, 3100000, 3300000,
 137};
 138
 139/* LP8720 BUCK voltage table */
 140#define EXT_R           0       /* external resistor divider */
 141static const unsigned int lp8720_buck_vtbl[] = {
 142          EXT_R,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
 143        1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
 144        1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
 145        1950000, 2000000, 2050000, 2100000, 2150000, 2200000, 2250000, 2300000,
 146};
 147
 148/* LP8725 BUCK voltage table */
 149static const unsigned int lp8725_buck_vtbl[] = {
 150         800000,  850000,  900000,  950000, 1000000, 1050000, 1100000, 1150000,
 151        1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
 152        1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
 153        2400000, 2500000, 2600000, 2700000, 2800000, 2850000, 2900000, 3000000,
 154};
 155
 156/* LP8725 BUCK current limit */
 157static const unsigned int lp8725_buck_uA[] = {
 158        460000, 780000, 1050000, 1370000,
 159};
 160
 161static int lp872x_read_byte(struct lp872x *lp, u8 addr, u8 *data)
 162{
 163        int ret;
 164        unsigned int val;
 165
 166        ret = regmap_read(lp->regmap, addr, &val);
 167        if (ret < 0) {
 168                dev_err(lp->dev, "failed to read 0x%.2x\n", addr);
 169                return ret;
 170        }
 171
 172        *data = (u8)val;
 173        return 0;
 174}
 175
 176static inline int lp872x_write_byte(struct lp872x *lp, u8 addr, u8 data)
 177{
 178        return regmap_write(lp->regmap, addr, data);
 179}
 180
 181static inline int lp872x_update_bits(struct lp872x *lp, u8 addr,
 182                                unsigned int mask, u8 data)
 183{
 184        return regmap_update_bits(lp->regmap, addr, mask, data);
 185}
 186
 187static int lp872x_get_timestep_usec(struct lp872x *lp)
 188{
 189        enum lp872x_id chip = lp->chipid;
 190        u8 val, mask, shift;
 191        int *time_usec, size, ret;
 192        int lp8720_time_usec[] = { 25, 50 };
 193        int lp8725_time_usec[] = { 32, 64, 128, 256 };
 194
 195        switch (chip) {
 196        case LP8720:
 197                mask = LP8720_TIMESTEP_M;
 198                shift = LP8720_TIMESTEP_S;
 199                time_usec = &lp8720_time_usec[0];
 200                size = ARRAY_SIZE(lp8720_time_usec);
 201                break;
 202        case LP8725:
 203                mask = LP8725_TIMESTEP_M;
 204                shift = LP8725_TIMESTEP_S;
 205                time_usec = &lp8725_time_usec[0];
 206                size = ARRAY_SIZE(lp8725_time_usec);
 207                break;
 208        default:
 209                return -EINVAL;
 210        }
 211
 212        ret = lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val);
 213        if (ret)
 214                return -EINVAL;
 215
 216        val = (val & mask) >> shift;
 217        if (val >= size)
 218                return -EINVAL;
 219
 220        return *(time_usec + val);
 221}
 222
 223static int lp872x_regulator_enable_time(struct regulator_dev *rdev)
 224{
 225        struct lp872x *lp = rdev_get_drvdata(rdev);
 226        enum lp872x_regulator_id rid = rdev_get_id(rdev);
 227        int time_step_us = lp872x_get_timestep_usec(lp);
 228        int ret;
 229        u8 addr, val;
 230
 231        if (time_step_us < 0)
 232                return -EINVAL;
 233
 234        switch (rid) {
 235        case LP8720_ID_LDO1 ... LP8720_ID_BUCK:
 236                addr = LP872X_LDO1_VOUT + rid;
 237                break;
 238        case LP8725_ID_LDO1 ... LP8725_ID_BUCK1:
 239                addr = LP872X_LDO1_VOUT + rid - LP8725_ID_BASE;
 240                break;
 241        case LP8725_ID_BUCK2:
 242                addr = LP8725_BUCK2_VOUT1;
 243                break;
 244        default:
 245                return -EINVAL;
 246        }
 247
 248        ret = lp872x_read_byte(lp, addr, &val);
 249        if (ret)
 250                return ret;
 251
 252        val = (val & LP872X_START_DELAY_M) >> LP872X_START_DELAY_S;
 253
 254        return val > MAX_DELAY ? 0 : val * time_step_us;
 255}
 256
 257static void lp872x_set_dvs(struct lp872x *lp, enum lp872x_dvs_sel dvs_sel,
 258                        int gpio)
 259{
 260        enum lp872x_dvs_state state;
 261
 262        state = dvs_sel == SEL_V1 ? DVS_HIGH : DVS_LOW;
 263        gpio_set_value(gpio, state);
 264        lp->dvs_pin = state;
 265}
 266
 267static u8 lp872x_select_buck_vout_addr(struct lp872x *lp,
 268                                enum lp872x_regulator_id buck)
 269{
 270        u8 val, addr;
 271
 272        if (lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val))
 273                return 0;
 274
 275        switch (buck) {
 276        case LP8720_ID_BUCK:
 277                if (val & LP8720_EXT_DVS_M) {
 278                        addr = (lp->dvs_pin == DVS_HIGH) ?
 279                                LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
 280                } else {
 281                        if (lp872x_read_byte(lp, LP8720_ENABLE, &val))
 282                                return 0;
 283
 284                        addr = val & LP8720_DVS_SEL_M ?
 285                                LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
 286                }
 287                break;
 288        case LP8725_ID_BUCK1:
 289                if (val & LP8725_DVS1_M)
 290                        addr = LP8725_BUCK1_VOUT1;
 291                else
 292                        addr = (lp->dvs_pin == DVS_HIGH) ?
 293                                LP8725_BUCK1_VOUT1 : LP8725_BUCK1_VOUT2;
 294                break;
 295        case LP8725_ID_BUCK2:
 296                addr =  val & LP8725_DVS2_M ?
 297                        LP8725_BUCK2_VOUT1 : LP8725_BUCK2_VOUT2;
 298                break;
 299        default:
 300                return 0;
 301        }
 302
 303        return addr;
 304}
 305
 306static bool lp872x_is_valid_buck_addr(u8 addr)
 307{
 308        switch (addr) {
 309        case LP8720_BUCK_VOUT1:
 310        case LP8720_BUCK_VOUT2:
 311        case LP8725_BUCK1_VOUT1:
 312        case LP8725_BUCK1_VOUT2:
 313        case LP8725_BUCK2_VOUT1:
 314        case LP8725_BUCK2_VOUT2:
 315                return true;
 316        default:
 317                return false;
 318        }
 319}
 320
 321static int lp872x_buck_set_voltage_sel(struct regulator_dev *rdev,
 322                                        unsigned selector)
 323{
 324        struct lp872x *lp = rdev_get_drvdata(rdev);
 325        enum lp872x_regulator_id buck = rdev_get_id(rdev);
 326        u8 addr, mask = LP872X_VOUT_M;
 327        struct lp872x_dvs *dvs = lp->pdata ? lp->pdata->dvs : NULL;
 328
 329        if (dvs && gpio_is_valid(dvs->gpio))
 330                lp872x_set_dvs(lp, dvs->vsel, dvs->gpio);
 331
 332        addr = lp872x_select_buck_vout_addr(lp, buck);
 333        if (!lp872x_is_valid_buck_addr(addr))
 334                return -EINVAL;
 335
 336        return lp872x_update_bits(lp, addr, mask, selector);
 337}
 338
 339static int lp872x_buck_get_voltage_sel(struct regulator_dev *rdev)
 340{
 341        struct lp872x *lp = rdev_get_drvdata(rdev);
 342        enum lp872x_regulator_id buck = rdev_get_id(rdev);
 343        u8 addr, val;
 344        int ret;
 345
 346        addr = lp872x_select_buck_vout_addr(lp, buck);
 347        if (!lp872x_is_valid_buck_addr(addr))
 348                return -EINVAL;
 349
 350        ret = lp872x_read_byte(lp, addr, &val);
 351        if (ret)
 352                return ret;
 353
 354        return val & LP872X_VOUT_M;
 355}
 356
 357static int lp8725_buck_set_current_limit(struct regulator_dev *rdev,
 358                                        int min_uA, int max_uA)
 359{
 360        struct lp872x *lp = rdev_get_drvdata(rdev);
 361        enum lp872x_regulator_id buck = rdev_get_id(rdev);
 362        int i;
 363        u8 addr;
 364
 365        switch (buck) {
 366        case LP8725_ID_BUCK1:
 367                addr = LP8725_BUCK1_VOUT2;
 368                break;
 369        case LP8725_ID_BUCK2:
 370                addr = LP8725_BUCK2_VOUT2;
 371                break;
 372        default:
 373                return -EINVAL;
 374        }
 375
 376        for (i = ARRAY_SIZE(lp8725_buck_uA) - 1 ; i >= 0; i--) {
 377                if (lp8725_buck_uA[i] >= min_uA &&
 378                        lp8725_buck_uA[i] <= max_uA)
 379                        return lp872x_update_bits(lp, addr,
 380                                                  LP8725_BUCK_CL_M,
 381                                                  i << LP8725_BUCK_CL_S);
 382        }
 383
 384        return -EINVAL;
 385}
 386
 387static int lp8725_buck_get_current_limit(struct regulator_dev *rdev)
 388{
 389        struct lp872x *lp = rdev_get_drvdata(rdev);
 390        enum lp872x_regulator_id buck = rdev_get_id(rdev);
 391        u8 addr, val;
 392        int ret;
 393
 394        switch (buck) {
 395        case LP8725_ID_BUCK1:
 396                addr = LP8725_BUCK1_VOUT2;
 397                break;
 398        case LP8725_ID_BUCK2:
 399                addr = LP8725_BUCK2_VOUT2;
 400                break;
 401        default:
 402                return -EINVAL;
 403        }
 404
 405        ret = lp872x_read_byte(lp, addr, &val);
 406        if (ret)
 407                return ret;
 408
 409        val = (val & LP8725_BUCK_CL_M) >> LP8725_BUCK_CL_S;
 410
 411        return (val < ARRAY_SIZE(lp8725_buck_uA)) ?
 412                        lp8725_buck_uA[val] : -EINVAL;
 413}
 414
 415static int lp872x_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
 416{
 417        struct lp872x *lp = rdev_get_drvdata(rdev);
 418        enum lp872x_regulator_id buck = rdev_get_id(rdev);
 419        u8 addr, mask, shift, val;
 420
 421        switch (buck) {
 422        case LP8720_ID_BUCK:
 423                addr = LP8720_BUCK_VOUT2;
 424                mask = LP8720_BUCK_FPWM_M;
 425                shift = LP8720_BUCK_FPWM_S;
 426                break;
 427        case LP8725_ID_BUCK1:
 428                addr = LP8725_BUCK_CTRL;
 429                mask = LP8725_BUCK1_FPWM_M;
 430                shift = LP8725_BUCK1_FPWM_S;
 431                break;
 432        case LP8725_ID_BUCK2:
 433                addr = LP8725_BUCK_CTRL;
 434                mask = LP8725_BUCK2_FPWM_M;
 435                shift = LP8725_BUCK2_FPWM_S;
 436                break;
 437        default:
 438                return -EINVAL;
 439        }
 440
 441        if (mode == REGULATOR_MODE_FAST)
 442                val = LP872X_FORCE_PWM << shift;
 443        else if (mode == REGULATOR_MODE_NORMAL)
 444                val = LP872X_AUTO_PWM << shift;
 445        else
 446                return -EINVAL;
 447
 448        return lp872x_update_bits(lp, addr, mask, val);
 449}
 450
 451static unsigned int lp872x_buck_get_mode(struct regulator_dev *rdev)
 452{
 453        struct lp872x *lp = rdev_get_drvdata(rdev);
 454        enum lp872x_regulator_id buck = rdev_get_id(rdev);
 455        u8 addr, mask, val;
 456        int ret;
 457
 458        switch (buck) {
 459        case LP8720_ID_BUCK:
 460                addr = LP8720_BUCK_VOUT2;
 461                mask = LP8720_BUCK_FPWM_M;
 462                break;
 463        case LP8725_ID_BUCK1:
 464                addr = LP8725_BUCK_CTRL;
 465                mask = LP8725_BUCK1_FPWM_M;
 466                break;
 467        case LP8725_ID_BUCK2:
 468                addr = LP8725_BUCK_CTRL;
 469                mask = LP8725_BUCK2_FPWM_M;
 470                break;
 471        default:
 472                return -EINVAL;
 473        }
 474
 475        ret = lp872x_read_byte(lp, addr, &val);
 476        if (ret)
 477                return ret;
 478
 479        return val & mask ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
 480}
 481
 482static struct regulator_ops lp872x_ldo_ops = {
 483        .list_voltage = regulator_list_voltage_table,
 484        .map_voltage = regulator_map_voltage_ascend,
 485        .set_voltage_sel = regulator_set_voltage_sel_regmap,
 486        .get_voltage_sel = regulator_get_voltage_sel_regmap,
 487        .enable = regulator_enable_regmap,
 488        .disable = regulator_disable_regmap,
 489        .is_enabled = regulator_is_enabled_regmap,
 490        .enable_time = lp872x_regulator_enable_time,
 491};
 492
 493static struct regulator_ops lp8720_buck_ops = {
 494        .list_voltage = regulator_list_voltage_table,
 495        .map_voltage = regulator_map_voltage_ascend,
 496        .set_voltage_sel = lp872x_buck_set_voltage_sel,
 497        .get_voltage_sel = lp872x_buck_get_voltage_sel,
 498        .enable = regulator_enable_regmap,
 499        .disable = regulator_disable_regmap,
 500        .is_enabled = regulator_is_enabled_regmap,
 501        .enable_time = lp872x_regulator_enable_time,
 502        .set_mode = lp872x_buck_set_mode,
 503        .get_mode = lp872x_buck_get_mode,
 504};
 505
 506static struct regulator_ops lp8725_buck_ops = {
 507        .list_voltage = regulator_list_voltage_table,
 508        .map_voltage = regulator_map_voltage_ascend,
 509        .set_voltage_sel = lp872x_buck_set_voltage_sel,
 510        .get_voltage_sel = lp872x_buck_get_voltage_sel,
 511        .enable = regulator_enable_regmap,
 512        .disable = regulator_disable_regmap,
 513        .is_enabled = regulator_is_enabled_regmap,
 514        .enable_time = lp872x_regulator_enable_time,
 515        .set_mode = lp872x_buck_set_mode,
 516        .get_mode = lp872x_buck_get_mode,
 517        .set_current_limit = lp8725_buck_set_current_limit,
 518        .get_current_limit = lp8725_buck_get_current_limit,
 519};
 520
 521static struct regulator_desc lp8720_regulator_desc[] = {
 522        {
 523                .name = "ldo1",
 524                .id = LP8720_ID_LDO1,
 525                .ops = &lp872x_ldo_ops,
 526                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 527                .volt_table = lp872x_ldo_vtbl,
 528                .type = REGULATOR_VOLTAGE,
 529                .owner = THIS_MODULE,
 530                .vsel_reg = LP872X_LDO1_VOUT,
 531                .vsel_mask = LP872X_VOUT_M,
 532                .enable_reg = LP8720_ENABLE,
 533                .enable_mask = LP872X_EN_LDO1_M,
 534        },
 535        {
 536                .name = "ldo2",
 537                .id = LP8720_ID_LDO2,
 538                .ops = &lp872x_ldo_ops,
 539                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 540                .volt_table = lp872x_ldo_vtbl,
 541                .type = REGULATOR_VOLTAGE,
 542                .owner = THIS_MODULE,
 543                .vsel_reg = LP872X_LDO2_VOUT,
 544                .vsel_mask = LP872X_VOUT_M,
 545                .enable_reg = LP8720_ENABLE,
 546                .enable_mask = LP872X_EN_LDO2_M,
 547        },
 548        {
 549                .name = "ldo3",
 550                .id = LP8720_ID_LDO3,
 551                .ops = &lp872x_ldo_ops,
 552                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 553                .volt_table = lp872x_ldo_vtbl,
 554                .type = REGULATOR_VOLTAGE,
 555                .owner = THIS_MODULE,
 556                .vsel_reg = LP872X_LDO3_VOUT,
 557                .vsel_mask = LP872X_VOUT_M,
 558                .enable_reg = LP8720_ENABLE,
 559                .enable_mask = LP872X_EN_LDO3_M,
 560        },
 561        {
 562                .name = "ldo4",
 563                .id = LP8720_ID_LDO4,
 564                .ops = &lp872x_ldo_ops,
 565                .n_voltages = ARRAY_SIZE(lp8720_ldo4_vtbl),
 566                .volt_table = lp8720_ldo4_vtbl,
 567                .type = REGULATOR_VOLTAGE,
 568                .owner = THIS_MODULE,
 569                .vsel_reg = LP872X_LDO4_VOUT,
 570                .vsel_mask = LP872X_VOUT_M,
 571                .enable_reg = LP8720_ENABLE,
 572                .enable_mask = LP872X_EN_LDO4_M,
 573        },
 574        {
 575                .name = "ldo5",
 576                .id = LP8720_ID_LDO5,
 577                .ops = &lp872x_ldo_ops,
 578                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 579                .volt_table = lp872x_ldo_vtbl,
 580                .type = REGULATOR_VOLTAGE,
 581                .owner = THIS_MODULE,
 582                .vsel_reg = LP872X_LDO5_VOUT,
 583                .vsel_mask = LP872X_VOUT_M,
 584                .enable_reg = LP8720_ENABLE,
 585                .enable_mask = LP872X_EN_LDO5_M,
 586        },
 587        {
 588                .name = "buck",
 589                .id = LP8720_ID_BUCK,
 590                .ops = &lp8720_buck_ops,
 591                .n_voltages = ARRAY_SIZE(lp8720_buck_vtbl),
 592                .volt_table = lp8720_buck_vtbl,
 593                .type = REGULATOR_VOLTAGE,
 594                .owner = THIS_MODULE,
 595                .enable_reg = LP8720_ENABLE,
 596                .enable_mask = LP8720_EN_BUCK_M,
 597        },
 598};
 599
 600static struct regulator_desc lp8725_regulator_desc[] = {
 601        {
 602                .name = "ldo1",
 603                .id = LP8725_ID_LDO1,
 604                .ops = &lp872x_ldo_ops,
 605                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 606                .volt_table = lp872x_ldo_vtbl,
 607                .type = REGULATOR_VOLTAGE,
 608                .owner = THIS_MODULE,
 609                .vsel_reg = LP872X_LDO1_VOUT,
 610                .vsel_mask = LP872X_VOUT_M,
 611                .enable_reg = LP8725_LDO_CTRL,
 612                .enable_mask = LP872X_EN_LDO1_M,
 613        },
 614        {
 615                .name = "ldo2",
 616                .id = LP8725_ID_LDO2,
 617                .ops = &lp872x_ldo_ops,
 618                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 619                .volt_table = lp872x_ldo_vtbl,
 620                .type = REGULATOR_VOLTAGE,
 621                .owner = THIS_MODULE,
 622                .vsel_reg = LP872X_LDO2_VOUT,
 623                .vsel_mask = LP872X_VOUT_M,
 624                .enable_reg = LP8725_LDO_CTRL,
 625                .enable_mask = LP872X_EN_LDO2_M,
 626        },
 627        {
 628                .name = "ldo3",
 629                .id = LP8725_ID_LDO3,
 630                .ops = &lp872x_ldo_ops,
 631                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 632                .volt_table = lp872x_ldo_vtbl,
 633                .type = REGULATOR_VOLTAGE,
 634                .owner = THIS_MODULE,
 635                .vsel_reg = LP872X_LDO3_VOUT,
 636                .vsel_mask = LP872X_VOUT_M,
 637                .enable_reg = LP8725_LDO_CTRL,
 638                .enable_mask = LP872X_EN_LDO3_M,
 639        },
 640        {
 641                .name = "ldo4",
 642                .id = LP8725_ID_LDO4,
 643                .ops = &lp872x_ldo_ops,
 644                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 645                .volt_table = lp872x_ldo_vtbl,
 646                .type = REGULATOR_VOLTAGE,
 647                .owner = THIS_MODULE,
 648                .vsel_reg = LP872X_LDO4_VOUT,
 649                .vsel_mask = LP872X_VOUT_M,
 650                .enable_reg = LP8725_LDO_CTRL,
 651                .enable_mask = LP872X_EN_LDO4_M,
 652        },
 653        {
 654                .name = "ldo5",
 655                .id = LP8725_ID_LDO5,
 656                .ops = &lp872x_ldo_ops,
 657                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 658                .volt_table = lp872x_ldo_vtbl,
 659                .type = REGULATOR_VOLTAGE,
 660                .owner = THIS_MODULE,
 661                .vsel_reg = LP872X_LDO5_VOUT,
 662                .vsel_mask = LP872X_VOUT_M,
 663                .enable_reg = LP8725_LDO_CTRL,
 664                .enable_mask = LP872X_EN_LDO5_M,
 665        },
 666        {
 667                .name = "lilo1",
 668                .id = LP8725_ID_LILO1,
 669                .ops = &lp872x_ldo_ops,
 670                .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
 671                .volt_table = lp8725_lilo_vtbl,
 672                .type = REGULATOR_VOLTAGE,
 673                .owner = THIS_MODULE,
 674                .vsel_reg = LP8725_LILO1_VOUT,
 675                .vsel_mask = LP872X_VOUT_M,
 676                .enable_reg = LP8725_LDO_CTRL,
 677                .enable_mask = LP8725_EN_LILO1_M,
 678        },
 679        {
 680                .name = "lilo2",
 681                .id = LP8725_ID_LILO2,
 682                .ops = &lp872x_ldo_ops,
 683                .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
 684                .volt_table = lp8725_lilo_vtbl,
 685                .type = REGULATOR_VOLTAGE,
 686                .owner = THIS_MODULE,
 687                .vsel_reg = LP8725_LILO2_VOUT,
 688                .vsel_mask = LP872X_VOUT_M,
 689                .enable_reg = LP8725_LDO_CTRL,
 690                .enable_mask = LP8725_EN_LILO2_M,
 691        },
 692        {
 693                .name = "buck1",
 694                .id = LP8725_ID_BUCK1,
 695                .ops = &lp8725_buck_ops,
 696                .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
 697                .volt_table = lp8725_buck_vtbl,
 698                .type = REGULATOR_VOLTAGE,
 699                .owner = THIS_MODULE,
 700                .enable_reg = LP872X_GENERAL_CFG,
 701                .enable_mask = LP8725_BUCK1_EN_M,
 702        },
 703        {
 704                .name = "buck2",
 705                .id = LP8725_ID_BUCK2,
 706                .ops = &lp8725_buck_ops,
 707                .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
 708                .volt_table = lp8725_buck_vtbl,
 709                .type = REGULATOR_VOLTAGE,
 710                .owner = THIS_MODULE,
 711                .enable_reg = LP872X_GENERAL_CFG,
 712                .enable_mask = LP8725_BUCK2_EN_M,
 713        },
 714};
 715
 716static int lp872x_init_dvs(struct lp872x *lp)
 717{
 718        int ret, gpio;
 719        struct lp872x_dvs *dvs = lp->pdata ? lp->pdata->dvs : NULL;
 720        enum lp872x_dvs_state pinstate;
 721        u8 mask[] = { LP8720_EXT_DVS_M, LP8725_DVS1_M | LP8725_DVS2_M };
 722        u8 default_dvs_mode[] = { LP8720_DEFAULT_DVS, LP8725_DEFAULT_DVS };
 723
 724        if (!dvs)
 725                goto set_default_dvs_mode;
 726
 727        gpio = dvs->gpio;
 728        if (!gpio_is_valid(gpio)) {
 729                dev_warn(lp->dev, "invalid gpio: %d\n", gpio);
 730                goto set_default_dvs_mode;
 731        }
 732
 733        pinstate = dvs->init_state;
 734        ret = devm_gpio_request_one(lp->dev, gpio, pinstate, "LP872X DVS");
 735        if (ret) {
 736                dev_err(lp->dev, "gpio request err: %d\n", ret);
 737                return ret;
 738        }
 739
 740        lp->dvs_pin = pinstate;
 741        lp->dvs_gpio = gpio;
 742
 743        return 0;
 744
 745set_default_dvs_mode:
 746        return lp872x_update_bits(lp, LP872X_GENERAL_CFG, mask[lp->chipid],
 747                                default_dvs_mode[lp->chipid]);
 748}
 749
 750static int lp872x_config(struct lp872x *lp)
 751{
 752        struct lp872x_platform_data *pdata = lp->pdata;
 753        int ret;
 754
 755        if (!pdata || !pdata->update_config)
 756                goto init_dvs;
 757
 758        ret = lp872x_write_byte(lp, LP872X_GENERAL_CFG, pdata->general_config);
 759        if (ret)
 760                return ret;
 761
 762init_dvs:
 763        return lp872x_init_dvs(lp);
 764}
 765
 766static struct regulator_init_data
 767*lp872x_find_regulator_init_data(int id, struct lp872x *lp)
 768{
 769        struct lp872x_platform_data *pdata = lp->pdata;
 770        int i;
 771
 772        if (!pdata)
 773                return NULL;
 774
 775        for (i = 0; i < lp->num_regulators; i++) {
 776                if (pdata->regulator_data[i].id == id)
 777                        return pdata->regulator_data[i].init_data;
 778        }
 779
 780        return NULL;
 781}
 782
 783static int lp872x_regulator_register(struct lp872x *lp)
 784{
 785        struct regulator_desc *desc;
 786        struct regulator_config cfg = { };
 787        struct regulator_dev *rdev;
 788        int i, ret;
 789
 790        for (i = 0 ; i < lp->num_regulators ; i++) {
 791                desc = (lp->chipid == LP8720) ? &lp8720_regulator_desc[i] :
 792                                                &lp8725_regulator_desc[i];
 793
 794                cfg.dev = lp->dev;
 795                cfg.init_data = lp872x_find_regulator_init_data(desc->id, lp);
 796                cfg.driver_data = lp;
 797                cfg.regmap = lp->regmap;
 798
 799                rdev = regulator_register(desc, &cfg);
 800                if (IS_ERR(rdev)) {
 801                        dev_err(lp->dev, "regulator register err");
 802                        ret =  PTR_ERR(rdev);
 803                        goto err;
 804                }
 805
 806                *(lp->regulators + i) = rdev;
 807        }
 808
 809        return 0;
 810err:
 811        while (--i >= 0) {
 812                rdev = *(lp->regulators + i);
 813                regulator_unregister(rdev);
 814        }
 815        return ret;
 816}
 817
 818static void lp872x_regulator_unregister(struct lp872x *lp)
 819{
 820        struct regulator_dev *rdev;
 821        int i;
 822
 823        for (i = 0 ; i < lp->num_regulators ; i++) {
 824                rdev = *(lp->regulators + i);
 825                regulator_unregister(rdev);
 826        }
 827}
 828
 829static const struct regmap_config lp872x_regmap_config = {
 830        .reg_bits = 8,
 831        .val_bits = 8,
 832        .max_register = MAX_REGISTERS,
 833};
 834
 835#ifdef CONFIG_OF
 836
 837#define LP872X_VALID_OPMODE     (REGULATOR_MODE_FAST | REGULATOR_MODE_NORMAL)
 838
 839static struct of_regulator_match lp8720_matches[] = {
 840        { .name = "ldo1", .driver_data = (void *)LP8720_ID_LDO1, },
 841        { .name = "ldo2", .driver_data = (void *)LP8720_ID_LDO2, },
 842        { .name = "ldo3", .driver_data = (void *)LP8720_ID_LDO3, },
 843        { .name = "ldo4", .driver_data = (void *)LP8720_ID_LDO4, },
 844        { .name = "ldo5", .driver_data = (void *)LP8720_ID_LDO5, },
 845        { .name = "buck", .driver_data = (void *)LP8720_ID_BUCK, },
 846};
 847
 848static struct of_regulator_match lp8725_matches[] = {
 849        { .name = "ldo1", .driver_data = (void *)LP8725_ID_LDO1, },
 850        { .name = "ldo2", .driver_data = (void *)LP8725_ID_LDO2, },
 851        { .name = "ldo3", .driver_data = (void *)LP8725_ID_LDO3, },
 852        { .name = "ldo4", .driver_data = (void *)LP8725_ID_LDO4, },
 853        { .name = "ldo5", .driver_data = (void *)LP8725_ID_LDO5, },
 854        { .name = "lilo1", .driver_data = (void *)LP8725_ID_LILO1, },
 855        { .name = "lilo2", .driver_data = (void *)LP8725_ID_LILO2, },
 856        { .name = "buck1", .driver_data = (void *)LP8725_ID_BUCK1, },
 857        { .name = "buck2", .driver_data = (void *)LP8725_ID_BUCK2, },
 858};
 859
 860static struct lp872x_platform_data
 861*lp872x_populate_pdata_from_dt(struct device *dev, enum lp872x_id which)
 862{
 863        struct device_node *np = dev->of_node;
 864        struct lp872x_platform_data *pdata;
 865        struct of_regulator_match *match;
 866        struct regulator_init_data *d;
 867        int num_matches;
 868        int count;
 869        int i;
 870        u8 dvs_state;
 871
 872        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 873        if (!pdata)
 874                goto out;
 875
 876        of_property_read_u8(np, "ti,general-config", &pdata->general_config);
 877        if (of_find_property(np, "ti,update-config", NULL))
 878                pdata->update_config = true;
 879
 880        pdata->dvs = devm_kzalloc(dev, sizeof(struct lp872x_dvs), GFP_KERNEL);
 881        if (!pdata->dvs)
 882                goto out;
 883
 884        pdata->dvs->gpio = of_get_named_gpio(np, "ti,dvs-gpio", 0);
 885        of_property_read_u8(np, "ti,dvs-vsel", (u8 *)&pdata->dvs->vsel);
 886        of_property_read_u8(np, "ti,dvs-state", &dvs_state);
 887        pdata->dvs->init_state = dvs_state ? DVS_HIGH : DVS_LOW;
 888
 889        if (of_get_child_count(np) == 0)
 890                goto out;
 891
 892        switch (which) {
 893        case LP8720:
 894                match = lp8720_matches;
 895                num_matches = ARRAY_SIZE(lp8720_matches);
 896                break;
 897        case LP8725:
 898                match = lp8725_matches;
 899                num_matches = ARRAY_SIZE(lp8725_matches);
 900                break;
 901        default:
 902                goto out;
 903        }
 904
 905        count = of_regulator_match(dev, np, match, num_matches);
 906        if (count <= 0)
 907                goto out;
 908
 909        for (i = 0; i < num_matches; i++) {
 910                pdata->regulator_data[i].id = (int)match[i].driver_data;
 911                pdata->regulator_data[i].init_data = match[i].init_data;
 912
 913                /* Operation mode configuration for buck/buck1/buck2 */
 914                if (strncmp(match[i].name, "buck", 4))
 915                        continue;
 916
 917                d = pdata->regulator_data[i].init_data;
 918                d->constraints.valid_modes_mask |= LP872X_VALID_OPMODE;
 919                d->constraints.valid_ops_mask |= REGULATOR_CHANGE_MODE;
 920        }
 921out:
 922        return pdata;
 923}
 924#else
 925static struct lp872x_platform_data
 926*lp872x_populate_pdata_from_dt(struct device *dev, enum lp872x_id which)
 927{
 928        return NULL;
 929}
 930#endif
 931
 932static int lp872x_probe(struct i2c_client *cl, const struct i2c_device_id *id)
 933{
 934        struct lp872x *lp;
 935        int ret, size, num_regulators;
 936        const int lp872x_num_regulators[] = {
 937                [LP8720] = LP8720_NUM_REGULATORS,
 938                [LP8725] = LP8725_NUM_REGULATORS,
 939        };
 940
 941        if (cl->dev.of_node)
 942                cl->dev.platform_data = lp872x_populate_pdata_from_dt(&cl->dev,
 943                                              (enum lp872x_id)id->driver_data);
 944
 945        lp = devm_kzalloc(&cl->dev, sizeof(struct lp872x), GFP_KERNEL);
 946        if (!lp)
 947                goto err_mem;
 948
 949        num_regulators = lp872x_num_regulators[id->driver_data];
 950        size = sizeof(struct regulator_dev *) * num_regulators;
 951
 952        lp->regulators = devm_kzalloc(&cl->dev, size, GFP_KERNEL);
 953        if (!lp->regulators)
 954                goto err_mem;
 955
 956        lp->regmap = devm_regmap_init_i2c(cl, &lp872x_regmap_config);
 957        if (IS_ERR(lp->regmap)) {
 958                ret = PTR_ERR(lp->regmap);
 959                dev_err(&cl->dev, "regmap init i2c err: %d\n", ret);
 960                goto err_dev;
 961        }
 962
 963        lp->dev = &cl->dev;
 964        lp->pdata = cl->dev.platform_data;
 965        lp->chipid = id->driver_data;
 966        lp->num_regulators = num_regulators;
 967        i2c_set_clientdata(cl, lp);
 968
 969        ret = lp872x_config(lp);
 970        if (ret)
 971                goto err_dev;
 972
 973        return lp872x_regulator_register(lp);
 974
 975err_mem:
 976        return -ENOMEM;
 977err_dev:
 978        return ret;
 979}
 980
 981static int lp872x_remove(struct i2c_client *cl)
 982{
 983        struct lp872x *lp = i2c_get_clientdata(cl);
 984
 985        lp872x_regulator_unregister(lp);
 986        return 0;
 987}
 988
 989static const struct of_device_id lp872x_dt_ids[] = {
 990        { .compatible = "ti,lp8720", },
 991        { .compatible = "ti,lp8725", },
 992        { }
 993};
 994MODULE_DEVICE_TABLE(of, lp872x_dt_ids);
 995
 996static const struct i2c_device_id lp872x_ids[] = {
 997        {"lp8720", LP8720},
 998        {"lp8725", LP8725},
 999        { }
1000};
1001MODULE_DEVICE_TABLE(i2c, lp872x_ids);
1002
1003static struct i2c_driver lp872x_driver = {
1004        .driver = {
1005                .name = "lp872x",
1006                .owner = THIS_MODULE,
1007                .of_match_table = of_match_ptr(lp872x_dt_ids),
1008        },
1009        .probe = lp872x_probe,
1010        .remove = lp872x_remove,
1011        .id_table = lp872x_ids,
1012};
1013
1014module_i2c_driver(lp872x_driver);
1015
1016MODULE_DESCRIPTION("TI/National Semiconductor LP872x PMU Regulator Driver");
1017MODULE_AUTHOR("Milo Kim");
1018MODULE_LICENSE("GPL");
1019
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.