drivers/regulator/rt5036-regulator.c

   1 /*
   2  *  drivers/regulator/rt5036-regulator.c
   3  *  Driver for Richtek RT5036 PMIC Regulator
   4  *
   5  *  Copyright (C) 2014 Richtek Technology Corp.
   6  *  cy_huang <cy_huang@richtek.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/kernel.h>
  16 #include <linux/err.h>
  17 #include <linux/i2c.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/regulator/machine.h>
  20 #include <linux/regulator/driver.h>
  21 #include <linux/version.h>
  22 #ifdef CONFIG_OF
  23 #include <linux/regulator/of_regulator.h>
  24 #endif /* #ifdef CONFIG_OF */
  25
  26 #include <linux/mfd/rt5036/rt5036.h>
  27 #include <linux/regulator/rt5036-regulator.h>
  28
  29 struct rt5036_regulator_info {
  30         struct regulator_desc desc;
  31         struct regulator_dev *regulator;
  32         struct i2c_client *i2c;
  33         const unsigned int *vol_output_list;
  34         const int vol_output_size;
  35         int min_uV;
  36         int max_uV;
  37         unsigned char nvol_reg;
  38         unsigned char nvol_shift;
  39         unsigned char nvol_mask;
  40         unsigned char nenable_reg;
  41         unsigned char nenable_bit;
  42         unsigned char nmode_reg;
  43         unsigned char nmode_bit;
  44         unsigned char nramp_reg;
  45         unsigned char nramp_bit;
  46         unsigned char nramp_shift;
  47         unsigned char svol_reg;
  48         unsigned char svol_shift;
  49         unsigned char svol_mask;
  50         unsigned char senable_reg;
  51         unsigned char senable_bit;
  52         unsigned char smode_reg;
  53         unsigned char smode_bit;
  54         unsigned char sramp_reg;
  55         unsigned char sramp_bit;
  56         unsigned char sramp_shift;
  57 };
  58
  59 /*For DCDC1~4 and LDO1~4 and LSW1~2*/
  60 static const unsigned int rt5036_vol_output_list[] = {
  61         /*0~7 */
  62         800 * 1000, 825 * 1000, 850 * 1000, 875 * 1000, 900 * 1000, 925 * 1000,
  63             950 * 1000, 975 * 1000,
  64         /*8~15 */
  65         1000 * 1000, 1025 * 1000, 1050 * 1000, 1075 * 1000, 1100 * 1000,
  66             1125 * 1000, 1150 * 1000, 1175 * 1000,
  67         /*16~23 */
  68         1200 * 1000, 1225 * 1000, 1250 * 1000, 1275 * 1000, 1300 * 1000,
  69             1325 * 1000, 1350 * 1000, 1375 * 1000,
  70         /*24~31 */
  71         1400 * 1000, 1425 * 1000, 1450 * 1000, 1475 * 1000, 1500 * 1000,
  72             1525 * 1000, 1550 * 1000, 1575 * 1000,
  73         /*32~39 */
  74         1600 * 1000, 1625 * 1000, 1650 * 1000, 1675 * 1000, 1700 * 1000,
  75             1725 * 1000, 1750 * 1000, 1775 * 1000,
  76         /*40~47 */
  77         1800 * 1000, 1825 * 1000, 1850 * 1000, 1875 * 1000, 1900 * 1000,
  78             1925 * 1000, 1950 * 1000, 1975 * 1000,
  79         /*48~55 */
  80         2000 * 1000, 2025 * 1000, 2050 * 1000, 2075 * 1000, 2100 * 1000,
  81             2125 * 1000, 2150 * 1000, 2175 * 1000,
  82         /*56~63 */
  83         2200 * 1000, 2225 * 1000, 2250 * 1000, 2275 * 1000, 2300 * 1000,
  84             2325 * 1000, 2350 * 1000, 2375 * 1000,
  85         /*64~71 */
  86         2400 * 1000, 2425 * 1000, 2450 * 1000, 2475 * 1000, 2500 * 1000,
  87             2525 * 1000, 2550 * 1000, 2575 * 1000,
  88         /*72~79 */
  89         2600 * 1000, 2625 * 1000, 2650 * 1000, 2675 * 1000, 2700 * 1000,
  90             2725 * 1000, 2750 * 1000, 2775 * 1000,
  91         /*80~87 */
  92         2800 * 1000, 2825 * 1000, 2850 * 1000, 2875 * 1000, 2900 * 1000,
  93             2925 * 1000, 2950 * 1000, 2975 * 1000,
  94         /*88~95 */
  95         3000 * 1000, 3025 * 1000, 3050 * 1000, 3075 * 1000, 3100 * 1000,
  96             3125 * 1000, 3150 * 1000, 3175 * 1000,
  97         /*96~103 */
  98         3200 * 1000, 3225 * 1000, 3250 * 1000, 3275 * 1000, 3300 * 1000,
  99             3300 * 1000, 3300 * 1000, 3300 * 1000,
 100         /*104~111 */
 101         3300 * 1000, 3300 * 1000, 3300 * 1000, 3300 * 1000, 3300 * 1000,
 102             3300 * 1000, 3300 * 1000, 3300 * 1000,
 103         /*112~119 */
 104         3300 * 1000, 3300 * 1000, 3300 * 1000, 3300 * 1000, 3300 * 1000,
 105             3300 * 1000, 3300 * 1000, 3300 * 1000,
 106         /*120~127 */
 107         3300 * 1000, 3300 * 1000, 3300 * 1000, 3300 * 1000, 3300 * 1000,
 108             3300 * 1000, 3300 * 1000, 3300 * 1000,
 109 };
 110
 111 #define rt5036_vol_output_size  ARRAY_SIZE(rt5036_vol_output_list)
 112
 113 static inline int check_range(struct rt5036_regulator_info *info,
 114                               int min_uV, int max_uV)
 115 {
 116         if (min_uV < info->min_uV || min_uV > info->max_uV)
 117                 return -EINVAL;
 118         return 0;
 119 }
 120
 121 static int rt5036_list_voltage(struct regulator_dev *rdev, unsigned index)
 122 {
 123         struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
 124
 125         return (index >= info->vol_output_size) ?
 126             -EINVAL : info->vol_output_list[index];
 127 }
 128
 129 static int rt5036_find_voltage(struct regulator_dev *rdev,
 130                                int min_uV, int max_uV)
 131 {
 132         struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
 133         int i = 0;
 134         const int count = info->vol_output_size;
 135
 136         for (i = 0; i < count; i++) {
 137                 if ((info->vol_output_list[i] >= min_uV)
 138                     && (info->vol_output_list[i] <= max_uV))
 139                         return i;
 140         }
 141         return -EINVAL;
 142 }
 143
 144 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38))
 145 static int rt5036_set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
 146 {
 147         struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
 148         unsigned char data;
 149         const int count = info->vol_output_size;
 150
 151         if (selector > count)
 152                 return -EINVAL;
 153         data = (unsigned char)selector;
 154         data <<= info->nvol_shift;
 155         return rt5036_assign_bits(info->i2c, info->nvol_reg, info->nvol_mask,
 156                                   data);
 157 }
 158
 159 static int rt5036_get_voltage_sel(struct regulator_dev *rdev)
 160 {
 161         struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
 162         int ret;
 163
 164         ret = rt5036_reg_read(info->i2c, info->nvol_reg);
 165         if (ret < 0)
 166                 return ret;
 167         return (ret & info->nvol_mask) >> info->nvol_shift;
 168 }
 169 #else
 170
 171 static int rt5036_set_voltage(struct regulator_dev *rdev,
 172                               int min_uV, int max_uV, unsigned *selector)
 173 {
 174         struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
 175         unsigned char data;
 176
 177         if (check_range(info, min_uV, max_uV)) {
 178                 dev_err(&rdev->dev, "invalid voltage range (%d, %d) uV\n",
 179                         min_uV, max_uV);
 180                 return -EINVAL;
 181         }
 182         data = rt5036_find_voltage(rdev, min_uV, max_uV);
 183         data <<= info->nvol_shift;
 184         return rt5036_assign_bits(info->i2c, info->nvol_reg, info->nvol_mask,
 185                                   data);
 186 }
 187
 188 static int rt5036_get_voltage(struct regulator_dev *rdev)
 189 {
 190         struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
 191         int ret;
 192
 193         ret = rt5036_reg_read(info->i2c, info->nvol_reg);
 194         if (ret < 0)
 195                 return ret;
 196         ret = (ret & info->nvol_mask) >> info->nvol_shift;
 197         return rt5036_list_voltage(rdev, ret);
 198 }
 199 #endif /* LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,38) */
 200
 201 static int rt5036_enable(struct regulator_dev *rdev)
 202 {
 203         struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
 204
 205         return rt5036_set_bits(info->i2c, info->nenable_reg, info->nenable_bit);
 206 }
 207
 208 static int rt5036_disable(struct regulator_dev *rdev)
 209 {
 210         struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
 211
 212         return rt5036_clr_bits(info->i2c, info->nenable_reg, info->nenable_bit);
 213 }
 214
 215 static int rt5036_is_enabled(struct regulator_dev *rdev)
 216 {
 217         struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
 218         int ret;
 219
 220         ret = rt5036_reg_read(info->i2c, info->nenable_reg);
 221         if (ret < 0)
 222                 return ret;
 223         return (ret & info->nenable_bit) ? 1 : 0;
 224 }
 225
 226 static int rt5036_set_mode(struct regulator_dev *rdev, unsigned int mode)
 227 {
 228         struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
 229         int ret;
 230
 231         switch (mode) {
 232         case REGULATOR_MODE_NORMAL:
 233                 ret =
 234                     rt5036_set_bits(info->i2c, info->nmode_reg,
 235                                     info->nmode_bit);
 236                 break;
 237         case REGULATOR_MODE_FAST:
 238                 ret =
 239                     rt5036_clr_bits(info->i2c, info->nmode_reg,
 240                                     info->nmode_bit);
 241                 break;
 242         default:
 243                 ret = -EINVAL;
 244                 break;
 245         }
 246         return ret;
 247 }
 248
 249 static unsigned int rt5036_get_mode(struct regulator_dev *rdev)
 250 {
 251         struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
 252         unsigned int mode;
 253         int data;
 254
 255         data = rt5036_reg_read(info->i2c, info->nmode_reg);
 256         mode =
 257             (data & info->nmode_bit) ? REGULATOR_MODE_NORMAL :
 258             REGULATOR_MODE_FAST;
 259         return mode;
 260 }
 261
 262 static int rt5036_set_suspend_voltage(struct regulator_dev *rdev, int uV)
 263 {
 264         struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
 265         unsigned char data;
 266
 267         if (check_range(info, uV, uV)) {
 268                 dev_err(&rdev->dev, "invalid voltage range (%d, %d) uV\n",
 269                         uV, uV);
 270                 return -EINVAL;
 271         }
 272         data = rt5036_find_voltage(rdev, uV, uV);
 273         data <<= info->svol_shift;
 274         return rt5036_assign_bits(info->i2c, info->svol_reg, info->svol_mask,
 275                                   data);
 276 }
 277
 278 static int rt5036_set_suspend_enable(struct regulator_dev *rdev)
 279 {
 280         struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
 281
 282         return rt5036_set_bits(info->i2c, info->senable_reg, info->senable_bit);
 283 }
 284
 285 static int rt5036_set_suspend_disable(struct regulator_dev *rdev)
 286 {
 287         struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
 288
 289         return rt5036_clr_bits(info->i2c, info->senable_reg, info->senable_bit);
 290 }
 291
 292 static int rt5036_set_suspend_mode(struct regulator_dev *rdev,
 293                                    unsigned int mode)
 294 {
 295         struct rt5036_regulator_info *info = rdev_get_drvdata(rdev);
 296         int ret;
 297
 298         switch (mode) {
 299         case REGULATOR_MODE_NORMAL:
 300                 ret =
 301                     rt5036_set_bits(info->i2c, info->smode_reg,
 302                                     info->smode_bit);
 303                 break;
 304         case REGULATOR_MODE_FAST:
 305                 ret =
 306                     rt5036_clr_bits(info->i2c, info->smode_reg,
 307                                     info->smode_bit);
 308                 break;
 309         default:
 310                 ret = -EINVAL;
 311                 break;
 312         }
 313         return ret;
 314 }
 315
 316 static struct regulator_ops rt5036_regulator_ops = {
 317         .list_voltage = rt5036_list_voltage,
 318 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38))
 319         .get_voltage_sel = rt5036_get_voltage_sel,
 320         .set_voltage_sel = rt5036_set_voltage_sel,
 321 #else
 322         .set_voltage = rt5036_set_voltage,
 323         .get_voltage = rt5036_get_voltage,
 324 #endif /* LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,38) */
 325         .enable = rt5036_enable,
 326         .disable = rt5036_disable,
 327         .is_enabled = rt5036_is_enabled,
 328         .set_mode = rt5036_set_mode,
 329         .get_mode = rt5036_get_mode,
 330         .set_suspend_voltage = rt5036_set_suspend_voltage,
 331         .set_suspend_enable = rt5036_set_suspend_enable,
 332         .set_suspend_disable = rt5036_set_suspend_disable,
 333         .set_suspend_mode = rt5036_set_suspend_mode,
 334 };
 335
 336 #define RT5036_VOUT_LIST rt5036_vol_output_list
 337 #define RT5036_VOUT_SIZE rt5036_vol_output_size
 338
 339 #define RT5036_DCDC(_id, min, max)                              \
 340 {                                                               \
 341         .desc   = {                                             \
 342                 .name   = "rt5036-dcdc" #_id,                   \
 343                 .n_voltages = RT5036_VOUT_SIZE,                 \
 344                 .ops    = &rt5036_regulator_ops,                \
 345                 .type   = REGULATOR_VOLTAGE,                    \
 346                 .id     = RT5036_ID_DCDC##_id,                  \
 347                 .owner  = THIS_MODULE,                          \
 348         },                                                      \
 349         .vol_output_list = RT5036_VOUT_LIST,                    \
 350         .vol_output_size = RT5036_VOUT_SIZE,                    \
 351         .min_uV         = min * 1000,                           \
 352         .max_uV         = max * 1000,                           \
 353         .nvol_reg       = RT5036_REG_BUCKVN##_id,               \
 354         .nvol_shift     = RT5036_DCDCVOUT_SHIFT##_id,           \
 355         .nvol_mask      = RT5036_DCDCVOUT_MASK##_id,            \
 356         .nenable_reg    = RT5036_REG_BUCKLDONEN,                \
 357         .nenable_bit    = RT5036_DCDCEN_MASK##_id,              \
 358         .nmode_reg      = RT5036_REG_BUCKVRCNEN,                \
 359         .nmode_bit      = RT5036_DCDCMODE_MASK##_id,            \
 360         .nramp_reg      = RT5036_REG_BUCKVRCN,                  \
 361         .nramp_bit      = RT5036_DCDCRAMP_MASK##_id,            \
 362         .nramp_shift    = RT5036_DCDCRAMP_SHIFT##_id,           \
 363         .svol_reg       = RT5036_REG_BUCKVS##_id,               \
 364         .svol_shift     = RT5036_DCDCVOUT_SHIFT##_id,           \
 365         .svol_mask      = RT5036_DCDCVOUT_MASK##_id,            \
 366         .senable_reg    = RT5036_REG_BUCKLDOSEN,                \
 367         .senable_bit    = RT5036_DCDCEN_MASK##_id,              \
 368         .smode_reg      = RT5036_REG_BUCKVRCSEN,                \
 369         .smode_bit      = RT5036_DCDCMODE_MASK##_id,            \
 370         .sramp_reg      = RT5036_REG_BUCKVRCS,                  \
 371         .sramp_bit      = RT5036_DCDCRAMP_MASK##_id,            \
 372         .sramp_shift    = RT5036_DCDCRAMP_SHIFT##_id,           \
 373 }
 374
 375 #define RT5036_LDO(_id, min, max)                               \
 376 {                                                               \
 377         .desc   = {                                             \
 378                 .name   = "rt5036-ldo" #_id,                    \
 379                 .n_voltages = RT5036_VOUT_SIZE,                 \
 380                 .ops    = &rt5036_regulator_ops,                \
 381                 .type   = REGULATOR_VOLTAGE,                    \
 382                 .id     = RT5036_ID_LDO##_id,                   \
 383                 .owner  = THIS_MODULE,                          \
 384         },                                                      \
 385         .vol_output_list = RT5036_VOUT_LIST,                    \
 386         .vol_output_size = RT5036_VOUT_SIZE,                    \
 387         .min_uV         = min * 1000,                           \
 388         .max_uV         = max * 1000,                           \
 389         .nvol_reg       = RT5036_REG_LDOVN##_id,                \
 390         .nvol_shift     = RT5036_LDOVOUT_SHIFT##_id,            \
 391         .nvol_mask      = RT5036_LDOVOUT_MASK##_id,             \
 392         .nenable_reg    = RT5036_REG_BUCKLDONEN,                \
 393         .nenable_bit    = RT5036_LDOEN_MASK##_id,               \
 394         .nmode_reg      = RT5036_REG_LDOVRCNEN,                 \
 395         .nmode_bit      = RT5036_LDOMODE_MASK##_id,             \
 396         .nramp_reg      = RT5036_REG_LDOVRCN,                   \
 397         .nramp_bit      = RT5036_LDORAMP_MASK##_id,             \
 398         .nramp_shift    = RT5036_LDORAMP_SHIFT##_id,            \
 399         .svol_reg       = RT5036_REG_LDOVS##_id,                \
 400         .svol_shift     = RT5036_LDOVOUT_SHIFT##_id,            \
 401         .svol_mask      = RT5036_LDOVOUT_MASK##_id,             \
 402         .senable_reg    = RT5036_REG_BUCKLDOSEN,                \
 403         .senable_bit    = RT5036_LDOEN_MASK##_id,               \
 404         .smode_reg      = RT5036_REG_LDOVRCSEN,                 \
 405         .smode_bit      = RT5036_LDOMODE_MASK##_id,             \
 406         .sramp_reg      = RT5036_REG_LDOVRCS,                   \
 407         .sramp_bit      = RT5036_LDORAMP_MASK##_id,             \
 408         .sramp_shift    = RT5036_LDORAMP_SHIFT##_id,            \
 409 }
 410
 411 #define RT5036_LSW(_id, min, max)                               \
 412 {                                                               \
 413         .desc   = {                                             \
 414                 .name   = "rt5036-lsw" #_id,                    \
 415                 .n_voltages = RT5036_VOUT_SIZE,                 \
 416                 .ops    = &rt5036_regulator_ops,                \
 417                 .type   = REGULATOR_VOLTAGE,                    \
 418                 .id     = RT5036_ID_LSW##_id,                   \
 419                 .owner  = THIS_MODULE,                          \
 420         },                                                      \
 421         .vol_output_list = RT5036_VOUT_LIST,                    \
 422         .vol_output_size = RT5036_VOUT_SIZE,                    \
 423         .min_uV         = min * 1000,                           \
 424         .max_uV         = max * 1000,                           \
 425         .nvol_reg       = RT5036_REG_LSWVN##_id,                \
 426         .nvol_shift     = RT5036_LSWVOUT_SHIFT##_id,            \
 427         .nvol_mask      = RT5036_LSWVOUT_MASK##_id,             \
 428         .nenable_reg    = RT5036_REG_LSWEN,                     \
 429         .nenable_bit    = RT5036_LSWNEN_MASK##_id,              \
 430         .nmode_reg      = RT5036_REG_LSWVRCEN,                  \
 431         .nmode_bit      = RT5036_LSWNMODE_MASK##_id,            \
 432         .nramp_reg      = RT5036_REG_LSWVRC,                    \
 433         .nramp_bit      = RT5036_LSWNRAMP_MASK##_id,            \
 434         .nramp_shift    = RT5036_LSWNRAMP_SHIFT##_id,           \
 435         .svol_reg       = RT5036_REG_LSWVS##_id,                \
 436         .svol_shift     = RT5036_LSWVOUT_SHIFT##_id,            \
 437         .svol_mask      = RT5036_LSWVOUT_MASK##_id,             \
 438         .senable_reg    = RT5036_REG_LSWEN,                     \
 439         .senable_bit    = RT5036_LSWSEN_MASK##_id,              \
 440         .smode_reg      = RT5036_REG_LSWVRCEN,                  \
 441         .smode_bit      = RT5036_LSWSMODE_MASK##_id,            \
 442         .sramp_reg      = RT5036_REG_LSWVRC,                    \
 443         .sramp_bit      = RT5036_LSWSRAMP_MASK##_id,            \
 444         .sramp_shift    = RT5036_LSWSRAMP_SHIFT##_id,           \
 445 }
 446
 447 static struct rt5036_regulator_info rt5036_regulator_info[] = {
 448         RT5036_DCDC(1, 800, 3300),
 449         RT5036_DCDC(2, 800, 3300),
 450         RT5036_DCDC(3, 800, 3300),
 451         RT5036_DCDC(4, 800, 3300),
 452         RT5036_LDO(1, 800, 3300),
 453         RT5036_LDO(2, 800, 3300),
 454         RT5036_LDO(3, 800, 3300),
 455         RT5036_LDO(4, 800, 3300),
 456         RT5036_LSW(1, 800, 3300),
 457         RT5036_LSW(2, 800, 3300),
 458 };
 459
 460 static struct rt5036_regulator_info *find_regulator_info(int id)
 461 {
 462         struct rt5036_regulator_info *ri;
 463         int i;
 464
 465         for (i = 0; i < ARRAY_SIZE(rt5036_regulator_info); i++) {
 466                 ri = &rt5036_regulator_info[i];
 467                 if (ri->desc.id == id)
 468                         return ri;
 469         }
 470         return NULL;
 471 }
 472
 473 inline struct regulator_dev *rt5036_regulator_register(struct regulator_desc
 474                                                        *regulator_desc,
 475                                                        struct device *dev,
 476                                                        struct
 477                                                        regulator_init_data
 478                                                        *init_data,
 479                                                        void *driver_data)
 480 {
 481 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
 482         struct regulator_config config = {
 483                 .dev = dev,
 484                 .init_data = init_data,
 485                 .driver_data = driver_data,
 486                 .of_node = dev->of_node,
 487         };
 488         return regulator_register(regulator_desc, &config);
 489 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 0, 37))
 490         return regulator_register(regulator_desc, dev, init_data, driver_data,
 491                                   dev->of_node);
 492 #else
 493         return regulator_register(regulator_desc, dev, init_data, driver_data);
 494 #endif /* LINUX_VERSION_CODE>=KERNEL_VERSION(3,5,0)) */
 495 }
 496
 497 static struct regulator_init_data *rt_parse_dt(struct
 498                                                          rt5036_regulator_info
 499                                                          *ri,
 500                                                          struct device *dev)
 501 {
 502         struct regulator_init_data *init_data = NULL;
 503 #ifdef CONFIG_OF
 504         struct device_node *np = dev->of_node;
 505         int rc;
 506         u32 tmp;
 507
 508 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0))
 509         init_data = of_get_regulator_init_data(dev, dev->of_node);
 510 #else
 511         init_data = of_get_regulator_init_data(dev);
 512 #endif /* #if (LINUX_KERNEL_VERSION >= KERNEL_VERSION(3,3,0)) */
 513
 514         if (init_data) {
 515                 init_data->supply_regulator = (char *)of_get_property(np,
 516                                                         "supply-regulator",
 517                                                         NULL);
 518                 rc = of_property_read_u32(np, "rt,standby_vol", &tmp);
 519                 if (rc)
 520                         dev_info(dev, "no standby voltage specified\n");
 521                 else
 522                         init_data->constraints.state_standby.uV = tmp;
 523                 if (of_property_read_bool(np, "rt,standby_enabled")) {
 524                         init_data->constraints.state_standby.enabled = 1;
 525                         init_data->constraints.initial_state =
 526                             PM_SUSPEND_STANDBY;
 527                 }
 528                 if (of_property_read_bool(np, "rt,standby_disabled")) {
 529                         init_data->constraints.state_standby.disabled = 1;
 530                         init_data->constraints.initial_state =
 531                             PM_SUSPEND_STANDBY;
 532                 }
 533         }
 534
 535         rc = of_property_read_u32(np, "rt,nramp_sel", &tmp);
 536         if (rc) {
 537                 dev_info(dev, "no nramp_sel property, use default value\n");
 538         } else {
 539                 if (tmp > RT5036_RAMP_MAX)
 540                         tmp = RT5036_RAMP_MAX;
 541                 rt5036_assign_bits(ri->i2c, ri->nramp_reg, ri->nramp_bit,
 542                                    tmp << ri->nramp_shift);
 543         }
 544
 545         rc = of_property_read_u32(np, "rt,sramp_sel", &tmp);
 546         if (rc) {
 547                 dev_info(dev, "no sramp_sel property, use default value\n");
 548         } else {
 549                 if (tmp > RT5036_RAMP_MAX)
 550                         tmp = RT5036_RAMP_MAX;
 551                 rt5036_assign_bits(ri->i2c, ri->sramp_reg, ri->sramp_bit,
 552                                    tmp << ri->sramp_shift);
 553         }
 554
 555         if (of_property_read_bool(np, "rt,allow_mode_mask")) {
 556                 init_data->constraints.valid_modes_mask |=
 557                     (REGULATOR_MODE_FAST | REGULATOR_MODE_NORMAL);
 558                 init_data->constraints.valid_ops_mask |= REGULATOR_CHANGE_MODE;
 559         }
 560 #endif /* #ifdef CONFIG_OF */
 561         return init_data;
 562 }
 563
 564 static int rt5036_regulator_probe(struct platform_device *pdev)
 565 {
 566         struct rt5036_chip *chip = dev_get_drvdata(pdev->dev.parent);
 567         struct rt5036_platform_data *pdata = (pdev->dev.parent)->platform_data;
 568         struct rt5036_regulator_info *ri;
 569         struct rt5036_regulator_ramp *ramp;
 570         struct regulator_dev *rdev;
 571         struct regulator_init_data *init_data;
 572         bool use_dt = pdev->dev.of_node;
 573
 574         ri = find_regulator_info(pdev->id);
 575         if (ri == NULL) {
 576                 dev_err(&pdev->dev, "invalid regulator ID specified\n");
 577                 return -EINVAL;
 578         }
 579
 580         ri->i2c = chip->i2c;
 581         if (use_dt) {
 582                 init_data = rt_parse_dt(ri, &pdev->dev);
 583         } else {
 584                 if (!pdata)
 585                         return -EINVAL;
 586                 init_data = pdata->regulator[pdev->id];
 587                 ramp = init_data ? init_data->driver_data : NULL;
 588                 if (ramp) {
 589                         rt5036_assign_bits(ri->i2c, ri->nramp_reg,
 590                                            ri->nramp_bit,
 591                                            ramp->nramp_sel << ri->nramp_shift);
 592                         rt5036_assign_bits(ri->i2c, ri->sramp_reg,
 593                                            ri->sramp_bit,
 594                                            ramp->sramp_sel << ri->sramp_shift);
 595                 }
 596         }
 597
 598         if (!init_data) {
 599                 dev_err(&pdev->dev, "no initializing data\n");
 600                 return -EINVAL;
 601         }
 602
 603         rdev = rt5036_regulator_register(&ri->desc, &pdev->dev, init_data, ri);
 604         if (IS_ERR(rdev)) {
 605                 dev_err(&pdev->dev, "failed to register regulator %s\n",
 606                         ri->desc.name);
 607                 return PTR_ERR(rdev);
 608         }
 609
 610         platform_set_drvdata(pdev, rdev);
 611         /*dev_info(&pdev->dev, "regulator successfully registered\n");*/
 612         RTINFO("\n");
 613         return 0;
 614 }
 615
 616 static int rt5036_regulator_remove(struct platform_device *pdev)
 617 {
 618         struct regulator_dev *rdev = platform_get_drvdata(pdev);
 619
 620         regulator_unregister(rdev);
 621         RTINFO("\n");
 622         return 0;
 623 }
 624
 625 static const struct of_device_id rt_match_table[] = {
 626         {.compatible = "rt,rt5036-dcdc1",},
 627         {.compatible = "rt,rt5036-dcdc2",},
 628         {.compatible = "rt,rt5036-dcdc3",},
 629         {.compatible = "rt,rt5036-dcdc4",},
 630         {.compatible = "rt,rt5036-ldo1",},
 631         {.compatible = "rt,rt5036-ldo2",},
 632         {.compatible = "rt,rt5036-ldo3",},
 633         {.compatible = "rt,rt5036-ldo4",},
 634         {.compatible = "rt,rt5036-lsw1",},
 635         {.compatible = "rt,rt5036-lsw2",},
 636         {},
 637 };
 638
 639 static struct platform_driver rt5036_regulator_driver = {
 640         .driver = {
 641                    .name = RT5036_DEV_NAME "-regulator",
 642                    .owner = THIS_MODULE,
 643                    .of_match_table = rt_match_table,
 644                    },
 645         .probe = rt5036_regulator_probe,
 646         .remove = rt5036_regulator_remove,
 647 };
 648
 649 static int __init rt5036_regulator_init(void)
 650 {
 651         return platform_driver_register(&rt5036_regulator_driver);
 652 }
 653 subsys_initcall(rt5036_regulator_init);
 654
 655 static void __exit rt5036_regulator_exit(void)
 656 {
 657         platform_driver_unregister(&rt5036_regulator_driver);
 658 }
 659 module_exit(rt5036_regulator_exit);
 660
 661 MODULE_LICENSE("GPL");
 662 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com");
 663 MODULE_DESCRIPTION("Regulator driver for RT5036");
 664 MODULE_ALIAS("platform:" RT5036_DEV_NAME "-regulator");
 665 MODULE_VERSION(RT5036_DRV_VER);