drivers/regulator/rt5033_regulator.c

   1 /* drivers/regulator/rt5033_regulator.c
   2  * RT5033 Regulator / Buck Driver
   3  * Copyright (C) 2013
   4  * Author: Patrick Chang <patrick_chang@richtek.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 #include <linux/kernel.h>
  12 #include <linux/init.h>
  13 #include <linux/err.h>
  14 #include <linux/i2c.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/regulator/driver.h>
  17 #include <linux/regulator/machine.h>
  18 #include <linux/mfd/rt5033.h>
  19 #include <linux/mfd/rt5033_irq.h>
  20 #include <linux/version.h>
  21 #include <linux/of.h>
  22 #include <linux/regulator/of_regulator.h>
  23
  24 #define ALIAS_NAME "rt5033-regulator"
  25
  26 #define EN_BUCK_IRQ 1
  27 #define EN_VDDA_UV_IRQ 0
  28 #define EN_LDO_IRQ 0
  29 #define EN_SLDO_IRQ 0
  30
  31 struct rt5033_regulator_info {
  32         struct regulator_desc desc;
  33         struct i2c_client *i2c;
  34         struct rt5033_mfd_chip  *chip;
  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         unsigned int const *output_list;
  43         unsigned int output_list_count;
  44 };
  45
  46 #define RT5033_REGULATOR_REG_LDO_SAFE   (0x43)
  47 #define RT5033_REGULATOR_SHIFT_LDO_SAFE (6)
  48 #define RT5033_REGULATOR_MASK_LDO_SAFE  (7<<6)
  49 #define RT5033_REGULATOR_REG_LDO1       (0x43)
  50 #define RT5033_REGULATOR_SHIFT_LDO1     (0)
  51 #define RT5033_REGULATOR_MASK_LDO1      (0x1f<<0)
  52 #define RT5033_REGULATOR_REG_DCDC1      (0x42)
  53 #define RT5033_REGULATOR_SHIFT_DCDC1    (0)
  54 #define RT5033_REGULATOR_MASK_DCDC1     (0x1f<<0)
  55
  56 #define RT5033_REGULATOR_REG_OUTPUT_EN (0x41)
  57 #define RT5033_REGULATOR_EN_MASK_LDO_SAFE (1<<6)
  58 #define RT5033_REGULATOR_EN_MASK_LDO1 (1<<5)
  59 #define RT5033_REGULATOR_EN_MASK_DCDC1 (1<<4)
  60
  61 static const unsigned int rt5033_dcdc_output_list[] = {
  62         1000*1000,
  63         1100*1000,
  64         1200*1000,
  65         1300*1000,
  66         1400*1000,
  67         1500*1000,
  68         1600*1000,
  69         1700*1000,
  70         1800*1000,
  71         1900*1000,
  72         2000*1000,
  73         2100*1000,
  74         2200*1000,
  75         2300*1000,
  76         2400*1000,
  77         2500*1000,
  78         2600*1000,
  79         2700*1000,
  80         2800*1000,
  81         2900*1000,
  82         3000*1000,
  83 };
  84
  85 static const unsigned int rt5033_ldo_output_list[] = {
  86         1200*1000,
  87         1300*1000,
  88         1400*1000,
  89         1500*1000,
  90         1600*1000,
  91         1700*1000,
  92         1800*1000,
  93         1900*1000,
  94         2000*1000,
  95         2100*1000,
  96         2200*1000,
  97         2300*1000,
  98         2400*1000,
  99         2500*1000,
 100         2600*1000,
 101         2700*1000,
 102         2800*1000,
 103         2900*1000,
 104         3000*1000,
 105 };
 106
 107 static const unsigned int rt5033_safe_ldo_output_list[] = {
 108         3300*1000,
 109         4850*1000,
 110         4900*1000,
 111         4950*1000,
 112 };
 113
 114 #define RT5033_REGULATOR_DECL(_id, min, max,out_list)   \
 115 {                                                                                       \
 116         .desc   = {                                                                 \
 117                 .name   = "RT5033_REGULATOR_" #_id,                             \
 118                 .ops    = &rt5033_regulator_ldo_dcdc_ops,               \
 119                 .type   = REGULATOR_VOLTAGE,                            \
 120                 .id     = RT5033_ID_##_id,                                      \
 121                 .owner  = THIS_MODULE,                                      \
 122                 .n_voltages = ARRAY_SIZE(out_list),             \
 123         },                                                                              \
 124         .min_uV         = min * 1000,                                       \
 125         .max_uV         = max * 1000,                                       \
 126         .vol_reg        = RT5033_REGULATOR_REG_##_id,           \
 127         .vol_shift      = RT5033_REGULATOR_SHIFT_##_id,         \
 128         .vol_mask       = RT5033_REGULATOR_MASK_##_id,          \
 129         .enable_reg     = RT5033_REGULATOR_REG_OUTPUT_EN,               \
 130         .enable_bit     = RT5033_REGULATOR_EN_MASK_##_id,               \
 131         .output_list = out_list,                            \
 132         .output_list_count = ARRAY_SIZE(out_list),          \
 133 }
 134
 135 static inline int rt5033_regulator_check_range(struct rt5033_regulator_info *info,
 136                 int min_uV, int max_uV)
 137 {
 138         if (min_uV < info->min_uV || max_uV > info->max_uV)
 139                 return -EINVAL;
 140
 141         return 0;
 142 }
 143
 144 static int rt5033_regulator_list_voltage(struct regulator_dev *rdev, unsigned index)
 145 {
 146         struct rt5033_regulator_info *info = rdev_get_drvdata(rdev);
 147
 148         return (index>=info->output_list_count)?
 149                 -EINVAL: info->output_list[index];
 150 }
 151
 152
 153 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,39))
 154 int rt5033_regulator_set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
 155 {
 156         struct rt5033_regulator_info *info = rdev_get_drvdata(rdev);
 157         unsigned char data;
 158         int ret;
 159
 160         pr_info("%s select = %d, output list count = %d\n",
 161                         ALIAS_NAME, selector, info->output_list_count);
 162         if (selector>=info->output_list_count)
 163                 return -EINVAL;
 164         pr_info("%s Vout = %d\n", ALIAS_NAME, info->output_list[selector]);
 165         data = (unsigned char)selector;
 166         data <<= info->vol_shift;
 167         ret = rt5033_assign_bits(info->i2c, info->vol_reg, info->vol_mask, data);
 168
 169         pr_info("%s %s %s ret (%d)", ALIAS_NAME, rdev->desc->name, __func__, ret);
 170
 171         return ret;
 172 }
 173 #endif
 174
 175 static int rt5033_regulator_get_voltage_sel(struct regulator_dev *rdev)
 176 {
 177         struct rt5033_regulator_info *info = rdev_get_drvdata(rdev);
 178         int ret;
 179         ret = rt5033_reg_read(info->i2c, info->vol_reg);
 180         if (ret < 0)
 181                 return ret;
 182         return (ret & info->vol_mask)  >> info->vol_shift;
 183 }
 184
 185 #if (LINUX_VERSION_CODE<KERNEL_VERSION(2,6,39))
 186 static int rt5033_regulator_find_voltage(struct regulator_dev *rdev,
 187                 int min_uV, int max_uV)
 188 {
 189         int i=0;
 190         struct rt5033_regulator_info *info = rdev_get_drvdata(rdev);
 191         const int count = info->output_list_count;
 192         for (i=0;i<count;i++)
 193         {
 194                 if ((info->output_list[i]>=min_uV)
 195                                 && (info->output_list[i]<=max_uV))
 196                 {
 197                         pr_info("%s Found V = %d , min_uV = %d,max_uV = %d\n",
 198                                         ALIAS_NAME, info->output_list[i], min_uV, max_uV);
 199                         return i;
 200                 }
 201
 202         }
 203         pr_err("%s Not found min_uV = %d, max_uV = %d\n",
 204                         ALIAS_NAME, min_uV, max_uV);
 205         return -EINVAL;
 206 }
 207 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,38))
 208 static int rt5033_regulator_set_voltage(struct regulator_dev *rdev,
 209                 int min_uV, int max_uV,unsigned *selector)
 210 {
 211         struct rt5033_regulator_info *info = rdev_get_drvdata(rdev);
 212         unsigned char data;
 213
 214         if (rt5033_regulator_check_range(info, min_uV, max_uV)) {
 215                 pr_err("%s %s invalid voltage range (%d, %d) uV\n",
 216                                 ALIAS_NAME, rdev->desc->name, min_uV, max_uV);
 217                 return -EINVAL;
 218         }
 219         *selector = rt5033_regulator_find_voltage(rdev,min_uV,max_uV);
 220         data = *selector << info->vol_shift;
 221
 222         return rt5033_assign_bits(info->i2c, info->vol_reg, info->vol_mask, data);
 223 }
 224
 225 #else
 226 static int rt5033_regulator_set_voltage(struct regulator_dev *rdev,
 227                 int min_uV, int max_uV,int *selector)
 228 {
 229         struct rt5033_regulator_info *info = rdev_get_drvdata(rdev);
 230         unsigned char data;
 231         int ret;
 232
 233         if (rt5033_regulator_check_range(info, min_uV, max_uV)) {
 234                 pr_err("%s %s invalid voltage range (%d, %d) uV\n",
 235                                 ALIAS_NAME, rdev->desc->name, min_uV, max_uV);
 236                 return -EINVAL;
 237         }
 238         data = rt5033_regulator_find_voltage(rdev,min_uV,max_uV);
 239         data <<= info->vol_shift;
 240         ret = rt5033_assign_bits(info->i2c, info->vol_reg, info->vol_mask, data);
 241
 242         pr_info("%s %s ret (%d)", ALIAS_NAME, __func__, ret);
 243
 244         return ret;
 245 }
 246 #endif //(LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,38))
 247
 248 static int rt5033_regulator_get_voltage(struct regulator_dev *rdev)
 249 {
 250         int ret;
 251         ret = rt5033_regulator_get_voltage_sel(rdev);
 252         if (ret < 0)
 253                 return ret;
 254         return rt5033_regulator_list_voltage(rdev, ret);
 255 }
 256 #endif //(LINUX_VERSION_CODE<KERNEL_VERSION(2,6,39))
 257
 258
 259 static int rt5033_regulator_enable(struct regulator_dev *rdev)
 260 {
 261         struct rt5033_regulator_info *info = rdev_get_drvdata(rdev);
 262         int ret;
 263         pr_info("%s Enable regulator %s\n", ALIAS_NAME, rdev->desc->name);
 264         ret = rt5033_set_bits(info->i2c, info->enable_reg,
 265                         info->enable_bit);
 266         pr_info("%s %s %s ret (%d)", ALIAS_NAME, rdev->desc->name, __func__, ret);
 267
 268         return ret;
 269 }
 270
 271 static int rt5033_regulator_disable(struct regulator_dev *rdev)
 272 {
 273         struct rt5033_regulator_info *info = rdev_get_drvdata(rdev);
 274         int ret;
 275
 276         pr_info("%s Disable regulator %s\n", ALIAS_NAME, rdev->desc->name);
 277         ret = rt5033_clr_bits(info->i2c, info->enable_reg,
 278                         info->enable_bit);
 279         pr_info("%s %s ret (%d)", ALIAS_NAME, __func__, ret);
 280
 281         return ret;
 282 }
 283
 284 static int rt5033_regulator_is_enabled(struct regulator_dev *rdev)
 285 {
 286         struct rt5033_regulator_info *info = rdev_get_drvdata(rdev);
 287         int ret;
 288
 289         ret = rt5033_reg_read(info->i2c, info->enable_reg);
 290         if (ret < 0)
 291                 return ret;
 292
 293         ret = (ret & (info->enable_bit))?1:0;
 294         pr_info("%s %s %s ret (%d)", ALIAS_NAME, rdev->desc->name, __func__, ret);
 295         return ret;
 296 }
 297
 298 static struct regulator_ops rt5033_regulator_ldo_dcdc_ops = {
 299         .list_voltage           = rt5033_regulator_list_voltage,
 300 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,39))
 301         .get_voltage_sel        = rt5033_regulator_get_voltage_sel,
 302         .set_voltage_sel        = rt5033_regulator_set_voltage_sel,
 303 #else
 304         .set_voltage            = rt5033_regulator_set_voltage,
 305         .get_voltage            = rt5033_regulator_get_voltage,
 306 #endif
 307         .enable                 = rt5033_regulator_enable,
 308         .disable                = rt5033_regulator_disable,
 309         .is_enabled             = rt5033_regulator_is_enabled,
 310 };
 311
 312 static struct rt5033_regulator_info rt5033_regulator_infos[] = {
 313         RT5033_REGULATOR_DECL(LDO_SAFE, 3300, 4950, rt5033_safe_ldo_output_list),
 314         RT5033_REGULATOR_DECL(LDO1, 1200, 3000, rt5033_ldo_output_list),
 315         RT5033_REGULATOR_DECL(DCDC1, 1000, 3300, rt5033_dcdc_output_list),
 316 };
 317
 318 static struct rt5033_regulator_info * find_regulator_info(int id)
 319 {
 320         struct rt5033_regulator_info *ri;
 321         int i;
 322
 323         for (i = 0; i < ARRAY_SIZE(rt5033_regulator_infos); i++) {
 324                 ri = &rt5033_regulator_infos[i];
 325                 if (ri->desc.id == id)
 326                         return ri;
 327         }
 328         return NULL;
 329 }
 330
 331 inline struct regulator_dev* rt5033_regulator_register(struct regulator_desc *regulator_desc,
 332                 struct device *dev, struct regulator_init_data *init_data,
 333                 void *driver_data)
 334 {
 335 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(3,5,0))
 336         struct regulator_config config = {
 337                 .dev = dev,
 338                 .init_data = init_data,
 339                 .driver_data = driver_data,
 340                 .of_node = dev->of_node,
 341         };
 342         return regulator_register(regulator_desc, &config);
 343 #elif (LINUX_VERSION_CODE>=KERNEL_VERSION(3,0,0))
 344         return regulator_register(regulator_desc, dev,
 345                         init_data, driver_data, dev->of_node);
 346 #else
 347         return regulator_register(regulator_desc, dev,
 348                         init_data, driver_data);
 349 #endif
 350 }
 351
 352 static int rt5033_regulator_init_regs(struct regulator_dev* rdev)
 353 {
 354         return 0;
 355 }
 356
 357 static struct regulator_consumer_supply default_rt5033_safe_ldo_consumers[] = {
 358         REGULATOR_SUPPLY("rt5033_safe_ldo",NULL),
 359 };
 360 static struct regulator_consumer_supply default_rt5033_ldo_consumers[] = {
 361         REGULATOR_SUPPLY("rt5033_ldo",NULL),
 362 };
 363 static struct regulator_consumer_supply default_rt5033_buck_consumers[] = {
 364         REGULATOR_SUPPLY("rt5033_buck",NULL),
 365 };
 366
 367 static struct regulator_init_data default_rt5033_safe_ldo_data = {
 368         .constraints = {
 369                 .min_uV = 3300000,
 370                 .max_uV = 4950000,
 371                 .valid_modes_mask = REGULATOR_MODE_NORMAL,
 372                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE | REGULATOR_CHANGE_STATUS,
 373                 .always_on = 1,
 374         },
 375         .num_consumer_supplies = ARRAY_SIZE(default_rt5033_safe_ldo_consumers),
 376         .consumer_supplies = default_rt5033_safe_ldo_consumers,
 377 };
 378 static struct regulator_init_data default_rt5033_ldo_data = {
 379         .constraints = {
 380                 .min_uV = 1200000,
 381                 .max_uV = 3000000,
 382                 .valid_modes_mask = REGULATOR_MODE_NORMAL,
 383                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE | REGULATOR_CHANGE_STATUS,
 384         },
 385         .num_consumer_supplies = ARRAY_SIZE(default_rt5033_ldo_consumers),
 386         .consumer_supplies = default_rt5033_ldo_consumers,
 387 };
 388 static struct regulator_init_data default_rt5033_buck_data = {
 389         .constraints = {
 390                 .min_uV = 1000000,
 391                 .max_uV = 3000000,
 392                 .valid_modes_mask = REGULATOR_MODE_NORMAL | REGULATOR_MODE_IDLE,
 393                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE | REGULATOR_CHANGE_STATUS,
 394         },
 395         .num_consumer_supplies = ARRAY_SIZE(default_rt5033_buck_consumers),
 396         .consumer_supplies = default_rt5033_buck_consumers,
 397 };
 398
 399 static struct rt5033_regulator_platform_data default_rv_pdata = {
 400         .regulator = {
 401                 [RT5033_ID_LDO_SAFE] = &default_rt5033_safe_ldo_data,
 402                 [RT5033_ID_LDO1] = &default_rt5033_ldo_data,
 403                 [RT5033_ID_DCDC1] = &default_rt5033_buck_data,
 404         },
 405 };
 406
 407
 408 struct rt5033_pmic_irq_handler {
 409         char *name;
 410         int irq_index;
 411         irqreturn_t (*handler)(int irq, void *data);
 412 };
 413
 414 #if EN_BUCK_IRQ
 415 static irqreturn_t rt5033_pmic_buck_ocp_event_handler(int irq, void *data)
 416 {
 417         struct regulator_dev *rdev = data;
 418         struct rt5033_regulator_info *info = rdev_get_drvdata(rdev);
 419         BUG_ON(rdev == NULL);
 420         BUG_ON(info == NULL);
 421         pr_info("Buck OCP\n");
 422         return IRQ_HANDLED;
 423 }
 424
 425 static irqreturn_t rt5033_pmic_buck_lv_event_handler(int irq, void *data)
 426 {
 427         struct regulator_dev *rdev = data;
 428         struct rt5033_regulator_info *info = rdev_get_drvdata(rdev);
 429         BUG_ON(rdev == NULL);
 430         BUG_ON(info == NULL);
 431         pr_info("Buck LV\n");
 432         return IRQ_HANDLED;
 433 }
 434
 435 static irqreturn_t rt5033_pmic_ot_event_handler(int irq, void *data)
 436 {
 437         struct regulator_dev *rdev = data;
 438         struct rt5033_regulator_info *info = rdev_get_drvdata(rdev);
 439         BUG_ON(rdev == NULL);
 440         BUG_ON(info == NULL);
 441         pr_info("PMIC OT\n");
 442         return IRQ_HANDLED;
 443 }
 444 #endif /* EN_BUCK_IRQ */
 445
 446 #if EN_VDDA_UV_IRQ
 447
 448 static irqreturn_t rt5033_pmic_vdda_uv_event_handler(int irq, void *data)
 449 {
 450         struct regulator_dev *rdev = data;
 451         struct rt5033_regulator_info *info = rdev_get_drvdata(rdev);
 452         BUG_ON(rdev == NULL);
 453         BUG_ON(info == NULL);
 454         pr_info("PMIC VDDA UV\n");
 455         return IRQ_HANDLED;
 456 }
 457 #endif /* EN_VDDA_UV_IRQ */
 458
 459 #if EN_SLDO_IRQ
 460 static irqreturn_t rt5033_pmic_safeldo_lv_event_handler(int irq, void *data)
 461 {
 462         struct regulator_dev *rdev = data;
 463         struct rt5033_regulator_info *info = rdev_get_drvdata(rdev);
 464         BUG_ON(rdev == NULL);
 465         BUG_ON(info == NULL);
 466         pr_info("Safe LDO LV\n");
 467         return IRQ_HANDLED;
 468 }
 469 #endif /* EN_SLDO_IRQ */
 470
 471 #if EN_LDO_IRQ
 472 static irqreturn_t rt5033_pmic_ldo_lv_event_handler(int irq, void *data)
 473 {
 474         struct regulator_dev *rdev = data;
 475         struct rt5033_regulator_info *info = rdev_get_drvdata(rdev);
 476         BUG_ON(rdev == NULL);
 477         BUG_ON(info == NULL);
 478         pr_info("LDO LV\n");
 479         return IRQ_HANDLED;
 480 }
 481 #endif /* EN_LDO_IRQ */
 482
 483 const struct rt5033_pmic_irq_handler rt5033_pmic_buck_irq_handlers[] = {
 484 #if EN_BUCK_IRQ
 485         {
 486                 .name = "BuckOCP",
 487                 .handler = rt5033_pmic_buck_ocp_event_handler,
 488                 .irq_index = RT5033_BUCK_OCP_IRQ,
 489         },
 490         {
 491                 .name = "BuckLV",
 492                 .handler = rt5033_pmic_buck_lv_event_handler,
 493                 .irq_index = RT5033_BUCK_LV_IRQ,
 494         },
 495         {
 496                 .name = "PMIC OT",
 497                 .handler = rt5033_pmic_ot_event_handler,
 498                 .irq_index = RT5033_OT_IRQ,
 499         },
 500 #endif /* EN_BUCK_IRQ */
 501 #if EN_VDDA_UV_IRQ
 502         {
 503                 .name = "PMIC VDDA UV",
 504                 .handler = rt5033_pmic_vdda_uv_event_handler,
 505                 .irq_index = RT5033_VDDA_UV_IRQ,
 506         },
 507 #endif /* EN_VDDA_UV_IRQ */
 508 };
 509
 510 const struct rt5033_pmic_irq_handler rt5033_pmic_safeldo_irq_handlers[] = {
 511 #if EN_SLDO_IRQ
 512         {
 513                 .name = "SafeLDO LV",
 514                 .handler = rt5033_pmic_safeldo_lv_event_handler,
 515                 .irq_index = RT5033_SAFE_LDO_LV_IRQ,
 516         },
 517 #endif
 518 };
 519 const struct rt5033_pmic_irq_handler rt5033_pmic_ldo_irq_handlers[] = {
 520 #if EN_LDO_IRQ
 521         {
 522                 .name = "LDO LV",
 523                 .handler = rt5033_pmic_ldo_lv_event_handler,
 524                 .irq_index = RT5033_LDO_LV_IRQ,
 525         },
 526 #endif
 527 };
 528
 529 static int register_irq(struct platform_device *pdev,
 530                 struct regulator_dev *rdev,
 531                 const struct rt5033_pmic_irq_handler *irq_handler,
 532                 int irq_handler_size)
 533 {
 534         int irq;
 535         int i, j;
 536         int ret;
 537         const char *irq_name;
 538         for (i = 0; i < irq_handler_size; i++) {
 539                 irq_name = rt5033_get_irq_name_by_index(irq_handler[i].irq_index);
 540                 irq = platform_get_irq_byname(pdev, irq_name);
 541                 ret = request_threaded_irq(irq, NULL, irq_handler[i].handler,
 542                                 IRQF_ONESHOT | IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND,
 543                                 irq_name, rdev);
 544                 if (ret < 0) {
 545                         pr_err("Failed to request IRQ: #%d: %d\n", irq, ret);
 546                         goto err_irq;
 547                 }
 548         }
 549
 550         return 0;
 551 err_irq:
 552         for (j = 0; j < i; j++) {
 553                 irq_name = rt5033_get_irq_name_by_index(irq_handler[j].irq_index);
 554                 irq = platform_get_irq_byname(pdev, irq_name);
 555                 free_irq(irq, rdev);
 556         }
 557         return ret;
 558 }
 559
 560 static void unregister_irq(struct platform_device *pdev,
 561                 struct regulator_dev *rdev,
 562                 const struct rt5033_pmic_irq_handler *irq_handler,
 563                 int irq_handler_size)
 564 {
 565         int irq;
 566         int i;
 567         const char *irq_name;
 568         for (i = 0; i < irq_handler_size; i++) {
 569                 irq_name = rt5033_get_irq_name_by_index(irq_handler[i].irq_index);
 570                 irq = platform_get_irq_byname(pdev, irq_name);
 571                 free_irq(irq, rdev);
 572         }
 573 }
 574
 575 #ifdef CONFIG_OF
 576 static struct of_device_id rt5033_regulator_match_table[] = {
 577         { .compatible = "richtek,rt5033-safeldo",},
 578         { .compatible = "richtek,rt5033-ldo1",},
 579         { .compatible = "richtek,rt5033-dcdc1",},
 580         {},
 581 };
 582 #else
 583 #define rt5033_regulator_match_table NULL
 584 #endif
 585
 586 static int rt5033_regulator_probe(struct platform_device *pdev)
 587 {
 588         struct rt5033_mfd_chip *chip = dev_get_drvdata(pdev->dev.parent);
 589         struct rt5033_mfd_platform_data *mfd_pdata = chip->dev->platform_data;
 590         const struct rt5033_regulator_platform_data* pdata;
 591         const struct rt5033_pmic_irq_handler *irq_handler = NULL;
 592         int irq_handler_size = 0;
 593         struct rt5033_regulator_info *ri;
 594         struct regulator_dev *rdev;
 595         struct regulator_init_data* init_data;
 596         int ret;
 597         dev_info(&pdev->dev, "Richtek RT5033 regulator driver probing (id = %d)...\n", pdev->id);
 598 #ifdef CONFIG_OF
 599 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0))
 600         if (pdev->dev.parent->of_node) {
 601                 pdev->dev.of_node = of_find_compatible_node(
 602                                 of_node_get(pdev->dev.parent->of_node), NULL,
 603                                 rt5033_regulator_match_table[pdev->id].compatible);
 604         }
 605 #endif
 606 #endif
 607         if (pdev->dev.of_node) {
 608                 dev_info(&pdev->dev, "Use DT...\n");
 609 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(3,1,0))
 610                 init_data = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node);
 611 #else
 612                 init_data = of_get_regulator_init_data(&pdev->dev);
 613 #endif
 614                 if (init_data == NULL) {
 615                         dev_info(&pdev->dev, "Cannot find DTS data...\n");
 616                         init_data = default_rv_pdata.regulator[pdev->id];
 617                 }
 618         }
 619         else {
 620                 BUG_ON(mfd_pdata == NULL);
 621                 if (mfd_pdata->regulator_platform_data == NULL)
 622                         mfd_pdata->regulator_platform_data = &default_rv_pdata;
 623                 pdata = mfd_pdata->regulator_platform_data;
 624                 init_data = pdata->regulator[pdev->id];
 625         }
 626         ri = find_regulator_info(pdev->id);
 627         if (ri == NULL) {
 628                 dev_err(&pdev->dev, "invalid regulator ID specified\n");
 629                 return -EINVAL;
 630         }
 631         if (init_data == NULL) {
 632                 dev_err(&pdev->dev, "no initializing data\n");
 633                 return -EINVAL;
 634         }
 635         ri->i2c = chip->i2c_client;
 636         ri->chip = chip;
 637         chip->regulator_info[pdev->id] = ri;
 638
 639         rdev = rt5033_regulator_register(&ri->desc, &pdev->dev,
 640                         init_data, ri);
 641         if (IS_ERR(rdev)) {
 642                 dev_err(&pdev->dev, "failed to register regulator %s\n",
 643                                 ri->desc.name);
 644                 return PTR_ERR(rdev);
 645         }
 646         platform_set_drvdata(pdev, rdev);
 647         ret = rt5033_regulator_init_regs(rdev);
 648         if (ret<0)
 649                 goto err_init_device;
 650         dev_info(&pdev->dev, "RT5033 Regulator %s driver loaded successfully...\n",
 651                         rdev->desc->name);
 652
 653         switch (pdev->id)
 654         {
 655                 case RT5033_ID_LDO_SAFE:
 656                         irq_handler = rt5033_pmic_safeldo_irq_handlers;
 657                         irq_handler_size = ARRAY_SIZE(rt5033_pmic_safeldo_irq_handlers);
 658                         break;
 659                 case RT5033_ID_LDO1:
 660                         irq_handler = rt5033_pmic_ldo_irq_handlers;
 661                         irq_handler_size = ARRAY_SIZE(rt5033_pmic_ldo_irq_handlers);
 662                         break;
 663                 case RT5033_ID_DCDC1:
 664                         irq_handler = rt5033_pmic_buck_irq_handlers;
 665                         irq_handler_size = ARRAY_SIZE(rt5033_pmic_buck_irq_handlers);
 666                         break;
 667                 default:
 668                         pr_err("Error : invalid ID\n");
 669         }
 670         ret = register_irq(pdev, rdev, irq_handler, irq_handler_size);
 671         if (ret < 0) {
 672                 pr_err("Error : can't register irq\n");
 673                 goto err_register_irq;
 674         }
 675         return 0;
 676 err_register_irq:
 677 err_init_device:
 678         dev_info(&pdev->dev, "RT5033 Regulator %s unregistered...\n",
 679                         rdev->desc->name);
 680         regulator_unregister(rdev);
 681         return ret;
 682 }
 683
 684 static int rt5033_regulator_remove(struct platform_device *pdev)
 685 {
 686         struct regulator_dev *rdev = platform_get_drvdata(pdev);
 687         const struct rt5033_pmic_irq_handler *irq_handler = NULL;
 688         int irq_handler_size = 0;
 689         dev_info(&pdev->dev, "RT5033 Regulator %s unregistered...\n",
 690                         rdev->desc->name);
 691         switch (pdev->id)
 692         {
 693                 case RT5033_ID_LDO_SAFE:
 694                         irq_handler = rt5033_pmic_safeldo_irq_handlers;
 695                         irq_handler_size = ARRAY_SIZE(rt5033_pmic_safeldo_irq_handlers);
 696                         break;
 697                 case RT5033_ID_LDO1:
 698                         irq_handler = rt5033_pmic_ldo_irq_handlers;
 699                         irq_handler_size = ARRAY_SIZE(rt5033_pmic_ldo_irq_handlers);
 700                         break;
 701                 case RT5033_ID_DCDC1:
 702                         irq_handler = rt5033_pmic_buck_irq_handlers;
 703                         irq_handler_size = ARRAY_SIZE(rt5033_pmic_buck_irq_handlers);
 704                         break;
 705                 default:
 706                         pr_err("Error : invalid ID\n");
 707         }
 708         unregister_irq(pdev, rdev, irq_handler, irq_handler_size);
 709         platform_set_drvdata(pdev, NULL);
 710         regulator_unregister(rdev);
 711         return 0;
 712 }
 713
 714 static struct platform_driver rt5033_regulator_driver = {
 715         .driver         = {
 716                 .name   = "rt5033-regulator",
 717                 .owner  = THIS_MODULE,
 718                 .of_match_table = rt5033_regulator_match_table,
 719         },
 720         .probe          = rt5033_regulator_probe,
 721         .remove         = rt5033_regulator_remove,
 722 };
 723
 724 static int __init rt5033_regulator_init(void)
 725 {
 726         return platform_driver_register(&rt5033_regulator_driver);
 727 }
 728 subsys_initcall(rt5033_regulator_init);
 729
 730 static void __exit rt5033_regulator_exit(void)
 731 {
 732         platform_driver_unregister(&rt5033_regulator_driver);
 733 }
 734 module_exit(rt5033_regulator_exit);
 735
 736 MODULE_LICENSE("GPL");
 737 MODULE_AUTHOR("Patrick Chang <patrick_chang@richtek.com");
 738 MODULE_VERSION(RT5033_DRV_VER);
 739 MODULE_DESCRIPTION("Regulator driver for RT5033");
 740 MODULE_ALIAS("platform:rt5033-regulator");