drivers/regulator/rt5025-regulator.c

   1 /*
   2  *  drivers/regulator/rt5025-regulator.c
   3  *  Driver foo Richtek RT5025 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/rt5025.h>
  27 #include <linux/regulator/rt5025-regulator.h>
  28
  29 struct rt5025_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         int     vol_reg;
  38         int     vol_shift;
  39         int     vol_mask;
  40         int     enable_bit;
  41         int     enable_reg;
  42         int     mode_bit;
  43         int     mode_reg;
  44         int     ramp_bit;
  45         int     ramp_reg;
  46 };
  47
  48 /*for DCDC1*/
  49 static const unsigned int rt5025_vol_output_list1[] = {
  50          700*1000,  725*1000,  750*1000,  775*1000,  800*1000,  825*1000,  850*1000,  875*1000,
  51          900*1000,  925*1000,  950*1000,  975*1000, 1000*1000, 1025*1000, 1050*1000, 1075*1000,
  52         1100*1000, 1125*1000, 1150*1000, 1175*1000, 1200*1000, 1225*1000, 1250*1000, 1275*1000,
  53         1300*1000, 1325*1000, 1350*1000, 1375*1000, 1400*1000, 1425*1000, 1450*1000, 1475*1000,
  54         1500*1000, 1525*1000, 1550*1000, 1575*1000, 1600*1000, 1625*1000, 1650*1000, 1675*1000,
  55         1700*1000, 1725*1000, 1750*1000, 1775*1000, 1800*1000, 1825*1000, 1850*1000, 1875*1000,
  56         1900*1000, 1925*1000, 1950*1000, 1975*1000, 2000*2000, 2025*1000, 2050*1000, 2075*1000,
  57         2100*1000, 2125*1000, 2150*1000, 2175*1000, 2200*1000, 2225*1000, 2250*1000, 2275*1000,
  58 };
  59 #define rt5025_vol_output_size1 ARRAY_SIZE(rt5025_vol_output_list1)
  60
  61 /*DCDC2, LDO1, LDO2*/
  62 static const unsigned int rt5025_vol_output_list2[] = {
  63          700*1000,  725*1000,  750*1000,  775*1000,  800*1000,  825*1000,  850*1000,  875*1000,
  64          900*1000,  925*1000,  950*1000,  975*1000, 1000*1000, 1025*1000, 1050*1000, 1075*1000,
  65         1100*1000, 1125*1000, 1150*1000, 1175*1000, 1200*1000, 1225*1000, 1250*1000, 1275*1000,
  66         1300*1000, 1325*1000, 1350*1000, 1375*1000, 1400*1000, 1425*1000, 1450*1000, 1475*1000,
  67         1500*1000, 1525*1000, 1550*1000, 1575*1000, 1600*1000, 1625*1000, 1650*1000, 1675*1000,
  68         1700*1000, 1725*1000, 1750*1000, 1775*1000, 1800*1000, 1825*1000, 1850*1000, 1875*1000,
  69         1900*1000, 1925*1000, 1950*1000, 1975*1000, 2000*2000, 2025*1000, 2050*1000, 2075*1000,
  70         2100*1000, 2125*1000, 2150*1000, 2175*1000, 2200*1000, 2225*1000, 2250*1000, 2275*1000,
  71         2300*1000, 2325*1000, 2350*1000, 2375*1000, 2400*1000, 2425*1000, 2450*1000, 2475*1000,
  72         2500*1000, 2525*1000, 2550*1000, 2575*1000, 2600*1000, 2625*1000, 2650*1000, 2675*1000,
  73         2700*1000, 2725*1000, 2750*1000, 2775*1000, 2800*1000, 2825*1000, 2850*1000, 2875*1000,
  74         2900*1000, 2925*1000, 2950*1000, 2975*1000, 3000*1000, 3025*1000, 3050*1000, 3075*1000,
  75         3100*1000, 3125*1000, 3150*1000, 3175*1000, 3200*1000, 3225*1000, 3250*1000, 3275*1000,
  76         3300*1000, 3325*1000, 3350*1000, 3375*1000, 3400*1000, 3425*1000, 3450*1000, 3475*1000,
  77         3500*1000, 3500*1000, 3500*1000, 3500*1000, 3500*1000, 3500*1000, 3500*1000, 3500*1000,
  78         3500*1000, 3500*1000, 3500*1000, 3500*1000, 3500*1000, 3500*1000, 3500*1000, 3500*1000,
  79 };
  80 #define rt5025_vol_output_size2 ARRAY_SIZE(rt5025_vol_output_list2)
  81
  82 /*DCDC3*/
  83 static const unsigned int rt5025_vol_output_list3[] = {
  84          700*1000,  750*1000,  800*1000,  850*1000,  900*1000,  950*1000, 1000*1000, 1050*1000,
  85         1100*1000, 1150*1000, 1200*1000, 1250*1000, 1300*1000, 1350*1000, 1400*1000, 1450*1000,
  86         1500*1000, 1550*1000, 1600*1000, 1650*1000, 1700*1000, 1750*1000, 1800*1000, 1850*1000,
  87         1900*1000, 1950*1000, 2000*1000, 2050*1000, 2100*1000, 2150*1000, 2200*1000, 2250*1000,
  88         2300*1000, 2350*1000, 2400*1000, 2450*1000, 2500*1000, 2550*1000, 2600*1000, 2650*1000,
  89         2700*1000, 2750*1000, 2800*1000, 2850*1000, 2900*1000, 2950*1000, 3000*1000, 3050*1000,
  90         3100*1000, 3150*1000, 3200*1000, 3250*1000, 3300*1000, 3350*1000, 3400*1000, 3450*1000,
  91         3500*1000, 3500*1000, 3500*1000, 3500*1000, 3500*1000, 3500*1000, 3500*1000, 3500*1000,
  92 };
  93 #define rt5025_vol_output_size3 ARRAY_SIZE(rt5025_vol_output_list3)
  94
  95 /*DCDC4*/
  96 static const unsigned int rt5025_vol_output_list4[] = {
  97         4500*1000, 4600*1000, 4700*1000, 4800*1000, 4900*1000, 5000*1000, 5100*1000, 5200*1000,
  98         5300*1000, 5400*1000, 5500*1000, 5500*1000, 5500*1000, 5500*1000, 5500*1000, 5500*1000,
  99 };
 100 #define rt5025_vol_output_size4 ARRAY_SIZE(rt5025_vol_output_list4)
 101
 102 /*LDO3, LDO4, LDO5, LDO6*/
 103 static const unsigned int rt5025_vol_output_list5[] = {
 104         1000*1000, 1100*1000, 1200*1000, 1300*1000, 1400*1000, 1500*1000, 1600*1000, 1700*1000,
 105         1800*1000, 1900*1000, 2000*1000, 2100*1000, 2200*1000, 2300*1000, 2400*1000, 2500*1000,
 106         2600*1000, 2700*1000, 2800*1000, 2900*1000, 3000*1000, 3100*1000, 3200*1000, 3300*1000,
 107         3300*1000, 3300*1000, 3300*1000, 3300*1000, 3300*1000, 3300*1000, 3300*1000, 3300*1000,
 108         3300*1000, 3300*1000, 3300*1000, 3300*1000, 3300*1000, 3300*1000, 3300*1000, 3300*1000,
 109 };
 110 #define rt5025_vol_output_size5 ARRAY_SIZE(rt5025_vol_output_list5)
 111
 112 static inline int check_range(struct rt5025_regulator_info *info,
 113                               int min_uV, int max_uV)
 114 {
 115         if (min_uV < info->min_uV || min_uV > info->max_uV)
 116                 return -EINVAL;
 117
 118         return 0;
 119 }
 120
 121 static int rt5025_list_voltage(struct regulator_dev *rdev, unsigned index)
 122 {
 123         struct rt5025_regulator_info *info = rdev_get_drvdata(rdev);
 124
 125         return (index >= info->vol_output_size) ? -EINVAL : info->vol_output_list[index];
 126 }
 127
 128 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38))
 129 static int rt5025_set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
 130 {
 131         struct rt5025_regulator_info *info = rdev_get_drvdata(rdev);
 132         unsigned char data;
 133         const int count = info->vol_output_size;
 134
 135         if (selector > count)
 136                 return -EINVAL;
 137         data = (unsigned char)selector;
 138         data <<= info->vol_shift;
 139         return rt5025_assign_bits(info->i2c, info->vol_reg,
 140                 info->vol_mask, data);
 141 }
 142
 143 static int rt5025_get_voltage_sel(struct regulator_dev *rdev)
 144 {
 145         struct rt5025_regulator_info *info = rdev_get_drvdata(rdev);
 146         int ret;
 147
 148         ret = rt5025_reg_read(info->i2c, info->vol_reg);
 149         if (ret < 0)
 150                 return ret;
 151         return (ret & info->vol_mask)  >> info->vol_shift;
 152 }
 153 #else
 154 static int rt5025_find_voltage(struct regulator_dev *rdev,
 155                                int min_uV, int max_uV)
 156 {
 157         struct rt5025_regulator_info *info = rdev_get_drvdata(rdev);
 158         int i = 0;
 159         const int count = info->vol_output_size;
 160
 161         for (i = 0; i < count; i++) {
 162                 if ((info->vol_output_list[i] >= min_uV)
 163                         && (info->vol_output_list[i] <= max_uV))
 164                         return i;
 165         }
 166         return -EINVAL;
 167 }
 168
 169 static int rt5025_set_voltage(struct regulator_dev *rdev,
 170                                int min_uV, int max_uV, unsigned *selector)
 171 {
 172         struct rt5025_regulator_info *info = rdev_get_drvdata(rdev);
 173         unsigned char data;
 174
 175         if (check_range(info, min_uV, max_uV)) {
 176                 dev_err(&rdev->dev, "invalid voltage range (%d, %d) uV\n",
 177                         min_uV, max_uV);
 178                 return -EINVAL;
 179         }
 180         data = rt5025_find_voltage(rdev, min_uV, max_uV);
 181         data <<= info->vol_shift;
 182
 183         return rt5025_assign_bits(info->i2c, info->vol_reg,
 184                 info->vol_mask, data);
 185 }
 186
 187
 188 static int rt5025_get_voltage(struct regulator_dev *rdev)
 189 {
 190         struct rt5025_regulator_info *info = rdev_get_drvdata(rdev);
 191         int ret;
 192
 193         ret = rt5025_reg_read(info->i2c, info->vol_reg);
 194         if (ret < 0)
 195                 return ret;
 196         ret =  (ret & info->vol_mask)  >> info->vol_shift;
 197         return rt5025_list_voltage(rdev, ret);
 198 }
 199 #endif /* LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,38) */
 200
 201 static int rt5025_enable(struct regulator_dev *rdev)
 202 {
 203         struct rt5025_regulator_info *info = rdev_get_drvdata(rdev);
 204
 205         return rt5025_set_bits(info->i2c, info->enable_reg,
 206                                 info->enable_bit);
 207 }
 208
 209 static int rt5025_disable(struct regulator_dev *rdev)
 210 {
 211         struct rt5025_regulator_info *info = rdev_get_drvdata(rdev);
 212
 213         return rt5025_clr_bits(info->i2c, info->enable_reg,
 214                                 info->enable_bit);
 215 }
 216
 217 static int rt5025_is_enabled(struct regulator_dev *rdev)
 218 {
 219         struct rt5025_regulator_info *info = rdev_get_drvdata(rdev);
 220         int ret;
 221
 222         ret = rt5025_reg_read(info->i2c, info->enable_reg);
 223         if (ret < 0)
 224                 return ret;
 225         return (ret & (info->enable_bit))?1 : 0;
 226 }
 227
 228 static int rt5025_set_mode(struct regulator_dev *rdev, unsigned int mode)
 229 {
 230         struct rt5025_regulator_info *info = rdev_get_drvdata(rdev);
 231         int ret;
 232
 233         if (!info->mode_bit) {
 234                 ret = 0;
 235         } else {
 236                 switch (mode) {
 237                 case REGULATOR_MODE_NORMAL:
 238                         ret = rt5025_set_bits(info->i2c, info->mode_reg,
 239                                 info->mode_bit);
 240                         break;
 241                 case REGULATOR_MODE_FAST:
 242                         ret = rt5025_clr_bits(info->i2c, info->mode_reg,
 243                                 info->mode_bit);
 244                         break;
 245                 default:
 246                         ret = -EINVAL;
 247                         break;
 248                 }
 249         }
 250         return ret;
 251 }
 252
 253 static unsigned int rt5025_get_mode(struct regulator_dev *rdev)
 254 {
 255         struct rt5025_regulator_info *info = rdev_get_drvdata(rdev);
 256         unsigned int mode;
 257         int data;
 258
 259         if (!info->mode_bit) {
 260                 mode = REGULATOR_MODE_NORMAL;
 261         } else {
 262                 data = rt5025_reg_read(info->i2c, info->mode_reg);
 263                 mode = (data & info->mode_bit)?REGULATOR_MODE_NORMAL : REGULATOR_MODE_FAST;
 264         }
 265         return mode;
 266 }
 267
 268 static struct regulator_ops rt5025_regulator_ops = {
 269         .list_voltage           = rt5025_list_voltage,
 270 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38))
 271         .get_voltage_sel        = rt5025_get_voltage_sel,
 272         .set_voltage_sel        = rt5025_set_voltage_sel,
 273 #else
 274         .set_voltage            = rt5025_set_voltage,
 275         .get_voltage            = rt5025_get_voltage,
 276 #endif /* LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,38) */
 277         .enable                 = rt5025_enable,
 278         .disable                = rt5025_disable,
 279         .is_enabled             = rt5025_is_enabled,
 280         .set_mode               = rt5025_set_mode,
 281         .get_mode               = rt5025_get_mode,
 282 };
 283
 284 #define RT5025_DCDCVOUT_LIST1 rt5025_vol_output_list1
 285 #define RT5025_DCDCVOUT_LIST2 rt5025_vol_output_list2
 286 #define RT5025_DCDCVOUT_LIST3 rt5025_vol_output_list3
 287 #define RT5025_DCDCVOUT_LIST4 rt5025_vol_output_list4
 288 #define RT5025_LDOVOUT_LIST1  rt5025_vol_output_list2
 289 #define RT5025_LDOVOUT_LIST2  rt5025_vol_output_list2
 290 #define RT5025_LDOVOUT_LIST3  rt5025_vol_output_list5
 291 #define RT5025_LDOVOUT_LIST4  rt5025_vol_output_list5
 292 #define RT5025_LDOVOUT_LIST5  rt5025_vol_output_list5
 293 #define RT5025_LDOVOUT_LIST6  rt5025_vol_output_list5
 294
 295 #define RT5025_DCDCVOUT_SIZE1 rt5025_vol_output_size1
 296 #define RT5025_DCDCVOUT_SIZE2 rt5025_vol_output_size2
 297 #define RT5025_DCDCVOUT_SIZE3 rt5025_vol_output_size3
 298 #define RT5025_DCDCVOUT_SIZE4 rt5025_vol_output_size4
 299 #define RT5025_LDOVOUT_SIZE1  rt5025_vol_output_size2
 300 #define RT5025_LDOVOUT_SIZE2  rt5025_vol_output_size2
 301 #define RT5025_LDOVOUT_SIZE3  rt5025_vol_output_size5
 302 #define RT5025_LDOVOUT_SIZE4  rt5025_vol_output_size5
 303 #define RT5025_LDOVOUT_SIZE5  rt5025_vol_output_size5
 304 #define RT5025_LDOVOUT_SIZE6  rt5025_vol_output_size5
 305
 306
 307 #define RT5025_DCDC(_id, min, max)                              \
 308 {                                                               \
 309         .desc   = {                                             \
 310                 .name   = "rt5025-dcdc" #_id,                   \
 311                 .n_voltages = RT5025_DCDCVOUT_SIZE##_id,        \
 312                 .ops    = &rt5025_regulator_ops,                \
 313                 .type   = REGULATOR_VOLTAGE,                    \
 314                 .id     = RT5025_ID_DCDC##_id,                  \
 315                 .owner  = THIS_MODULE,                          \
 316         },                                                      \
 317         .vol_output_list = RT5025_DCDCVOUT_LIST##_id,           \
 318         .vol_output_size = RT5025_DCDCVOUT_SIZE##_id,           \
 319         .min_uV         = min * 1000,                           \
 320         .max_uV         = max * 1000,                           \
 321         .vol_reg        = RT5025_DCDCVOUT##_id,                 \
 322         .vol_shift      = RT5025_DCDCVOUT_SHIFT##_id,           \
 323         .vol_mask       = RT5025_DCDCVOUT_MASK##_id,            \
 324         .enable_reg     = RT5025_REG_DCDCONOFF,                 \
 325         .enable_bit     = RT5025_DCDCEN_MASK##_id,              \
 326         .mode_reg       = RT5025_DCDCMODE_REG##_id,             \
 327         .mode_bit       = RT5025_DCDCMODE_MASK##_id,            \
 328         .ramp_reg       = RT5025_DCDCVOUT##_id,                 \
 329         .ramp_bit       = RT5025_DCDCRAMP_MASK##_id,            \
 330 }
 331
 332 #define RT5025_LDO(_id, min, max)                               \
 333 {                                                               \
 334         .desc   = {                                             \
 335                 .name   = "rt5025-ldo" #_id,                    \
 336                 .n_voltages = RT5025_LDOVOUT_SIZE##_id,         \
 337                 .ops    = &rt5025_regulator_ops,                \
 338                 .type   = REGULATOR_VOLTAGE,                    \
 339                 .id     = RT5025_ID_LDO##_id,                   \
 340                 .owner  = THIS_MODULE,                          \
 341         },                                                      \
 342         .vol_output_list = RT5025_LDOVOUT_LIST##_id,            \
 343         .vol_output_size = RT5025_LDOVOUT_SIZE##_id,            \
 344         .min_uV         = min * 1000,                           \
 345         .max_uV         = max * 1000,                           \
 346         .vol_reg        = RT5025_LDOVOUT##_id,                  \
 347         .vol_shift      = RT5025_LDOVOUT_SHIFT##_id,            \
 348         .vol_mask       = RT5025_LDOVOUT_MASK##_id,             \
 349         .enable_reg     = RT5025_REG_LDOONOFF,                  \
 350         .enable_bit     = RT5025_LDOEN_MASK##_id,               \
 351 }
 352
 353 static struct rt5025_regulator_info rt5025_regulator_info[] = {
 354         RT5025_DCDC(1, 700, 2275),
 355         RT5025_DCDC(2, 700, 3500),
 356         RT5025_DCDC(3, 700, 3500),
 357         RT5025_DCDC(4, 4500, 5500),
 358         RT5025_LDO(1, 700, 3500),
 359         RT5025_LDO(2, 700, 3500),
 360         RT5025_LDO(3, 1000, 3300),
 361         RT5025_LDO(4, 1000, 3300),
 362         RT5025_LDO(5, 1000, 3300),
 363         RT5025_LDO(6, 1000, 3300),
 364 };
 365
 366 static struct rt5025_regulator_info *find_regulator_info(int id)
 367 {
 368         struct rt5025_regulator_info *ri;
 369         int i;
 370
 371         for (i = 0; i < ARRAY_SIZE(rt5025_regulator_info); i++) {
 372                 ri = &rt5025_regulator_info[i];
 373                 if (ri->desc.id == id)
 374                         return ri;
 375         }
 376         return NULL;
 377 }
 378 struct regulator_dev *rt5025_regulator_register(struct regulator_desc *regulator_desc,
 379         struct device *dev, struct regulator_init_data *init_data,
 380         void *driver_data)
 381 {
 382 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
 383         struct regulator_config config = {
 384                 .dev = dev,
 385                 .init_data = init_data,
 386                 .driver_data = driver_data,
 387                 .of_node = dev->of_node,
 388         };
 389         return regulator_register(regulator_desc, &config);
 390 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 0, 37))
 391         return regulator_register(regulator_desc, dev, init_data,
 392                 driver_data, dev->of_node);
 393 #else
 394         return regulator_register(regulator_desc, dev, init_data, driver_data);
 395 #endif /* LINUX_VERSION_CODE>=KERNEL_VERSION(3,5,0)) */
 396 }
 397
 398 static struct regulator_init_data *of_parse_dt(struct rt5025_regulator_info *ri,
 399         struct device *dev)
 400 {
 401         struct regulator_init_data *init_data = NULL;
 402         #ifdef CONFIG_OF
 403         struct device_node *np = dev->of_node;
 404         int rc;
 405         u32 tmp;
 406         #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0))
 407         init_data = of_get_regulator_init_data(dev, dev->of_node);
 408         #else
 409         init_data = of_get_regulator_init_data(dev);
 410         #endif /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0)) */
 411         rc = of_property_read_u32(np, "rt,ramp_sel", &tmp);
 412         if (rc) {
 413                 dev_info(dev, "no ramp_sel property, use default value\n");
 414         } else {
 415                 if (tmp > RT5025_DCDCRAMP_MAX)
 416                         tmp = RT5025_DCDCRAMP_MAX;
 417                 rt5025_assign_bits(ri->i2c, ri->ramp_reg, ri->ramp_bit, tmp);
 418         }
 419
 420         if (of_property_read_bool(np, "rt,allow_mode_mask")) {
 421                 init_data->constraints.valid_modes_mask |=
 422                         (REGULATOR_MODE_FAST|\
 423                         REGULATOR_MODE_NORMAL);
 424                 init_data->constraints.valid_ops_mask |= REGULATOR_CHANGE_MODE;
 425         }
 426         #endif /* #ifdef CONFIG_OF */
 427         return init_data;
 428 }
 429
 430 static int rt5025_regulator_probe(struct platform_device *pdev)
 431 {
 432         struct rt5025_chip *chip = dev_get_drvdata(pdev->dev.parent);
 433         struct rt5025_platform_data *pdata = (pdev->dev.parent)->platform_data;
 434         struct rt5025_regulator_info *ri;
 435         struct rt5025_regulator_ramp *ramp;
 436         struct regulator_dev *rdev;
 437         struct regulator_init_data *init_data;
 438         bool use_dt = pdev->dev.of_node;
 439
 440         ri = find_regulator_info(pdev->id);
 441         if (ri == NULL) {
 442                 dev_err(&pdev->dev, "invalid regulator ID specified\n");
 443                 return -EINVAL;
 444         }
 445         ri->i2c = chip->i2c;
 446         if (use_dt) {
 447                 init_data = of_parse_dt(ri, &pdev->dev);
 448         } else {
 449                 init_data = pdata->regulator[pdev->id];
 450                 ramp = init_data->driver_data;
 451                 if (ramp)
 452                         rt5025_assign_bits(ri->i2c, ri->ramp_reg,
 453                                 ri->ramp_bit, ramp->ramp_sel);
 454         }
 455         if (!init_data) {
 456                 dev_err(&pdev->dev, "no initializing data\n");
 457                 return -EINVAL;
 458         }
 459
 460         rdev = rt5025_regulator_register(&ri->desc, &pdev->dev,
 461                                   init_data, ri);
 462         if (IS_ERR(rdev)) {
 463                 dev_err(&pdev->dev, "failed to register regulator %s\n",
 464                                 ri->desc.name);
 465                 return PTR_ERR(rdev);
 466         }
 467         platform_set_drvdata(pdev, rdev);
 468 /*      dev_info(&pdev->dev, "driver successfully loaded\n");*/
 469         return 0;
 470 }
 471
 472 static int rt5025_regulator_remove(struct platform_device *pdev)
 473 {
 474         struct regulator_dev *rdev = platform_get_drvdata(pdev);
 475
 476         platform_set_drvdata(pdev, NULL);
 477         regulator_unregister(rdev);
 478         dev_info(&pdev->dev, "%s\n", __func__);
 479         return 0;
 480 }
 481
 482 static struct of_device_id rt_match_table[] = {
 483         { .compatible = "rt,rt5025-dcdc1",},
 484         { .compatible = "rt,rt5025-dcdc2",},
 485         { .compatible = "rt,rt5025-dcdc3",},
 486         { .compatible = "rt,rt5025-dcdc4",},
 487         { .compatible = "rt,rt5025-ldo1",},
 488         { .compatible = "rt,rt5025-ldo2",},
 489         { .compatible = "rt,rt5025-ldo3",},
 490         { .compatible = "rt,rt5025-ldo4",},
 491         { .compatible = "rt,rt5025-ldo5",},
 492         { .compatible = "rt,rt5025-ldo6",},
 493         {},
 494 };
 495
 496 static struct platform_driver rt5025_regulator_driver = {
 497         .driver = {
 498                 .name = RT5025_DEV_NAME "-regulator",
 499                 .owner = THIS_MODULE,
 500                 .of_match_table = rt_match_table,
 501         },
 502         .probe = rt5025_regulator_probe,
 503         .remove = rt5025_regulator_remove,
 504 };
 505
 506 static int rt5025_regulator_init(void)
 507 {
 508         return platform_driver_register(&rt5025_regulator_driver);
 509 }
 510 subsys_initcall(rt5025_regulator_init);
 511
 512 static void rt5025_regulator_exit(void)
 513 {
 514         platform_driver_unregister(&rt5025_regulator_driver);
 515 }
 516 module_exit(rt5025_regulator_exit);
 517
 518 MODULE_LICENSE("GPL");
 519 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com>");
 520 MODULE_DESCRIPTION("Regulator driver for RT5025");
 521 MODULE_ALIAS("platform:" RT5025_DEV_NAME "-regulator");
 522 MODULE_VERSION(RT5025_DRV_VER);