drivers/regulator/lp8788-buck.c

   1 /*
   2  * TI LP8788 MFD - buck regulator driver
   3  *
   4  * Copyright 2012 Texas Instruments
   5  *
   6  * Author: Milo(Woogyom) Kim <milo.kim@ti.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.
  11  *
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/slab.h>
  16 #include <linux/err.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/regulator/driver.h>
  19 #include <linux/mfd/lp8788.h>
  20 #include <linux/gpio.h>
  21
  22 /* register address */
  23 #define LP8788_EN_BUCK                  0x0C
  24 #define LP8788_BUCK_DVS_SEL             0x1D
  25 #define LP8788_BUCK1_VOUT0              0x1E
  26 #define LP8788_BUCK1_VOUT1              0x1F
  27 #define LP8788_BUCK1_VOUT2              0x20
  28 #define LP8788_BUCK1_VOUT3              0x21
  29 #define LP8788_BUCK2_VOUT0              0x22
  30 #define LP8788_BUCK2_VOUT1              0x23
  31 #define LP8788_BUCK2_VOUT2              0x24
  32 #define LP8788_BUCK2_VOUT3              0x25
  33 #define LP8788_BUCK3_VOUT               0x26
  34 #define LP8788_BUCK4_VOUT               0x27
  35 #define LP8788_BUCK1_TIMESTEP           0x28
  36 #define LP8788_BUCK_PWM                 0x2D
  37
  38 /* mask/shift bits */
  39 #define LP8788_EN_BUCK1_M               BIT(0)  /* Addr 0Ch */
  40 #define LP8788_EN_BUCK2_M               BIT(1)
  41 #define LP8788_EN_BUCK3_M               BIT(2)
  42 #define LP8788_EN_BUCK4_M               BIT(3)
  43 #define LP8788_BUCK1_DVS_SEL_M          0x04    /* Addr 1Dh */
  44 #define LP8788_BUCK1_DVS_M              0x03
  45 #define LP8788_BUCK1_DVS_S              0
  46 #define LP8788_BUCK2_DVS_SEL_M          0x40
  47 #define LP8788_BUCK2_DVS_M              0x30
  48 #define LP8788_BUCK2_DVS_S              4
  49 #define LP8788_BUCK1_DVS_I2C            BIT(2)
  50 #define LP8788_BUCK2_DVS_I2C            BIT(6)
  51 #define LP8788_BUCK1_DVS_PIN            (0 << 2)
  52 #define LP8788_BUCK2_DVS_PIN            (0 << 6)
  53 #define LP8788_VOUT_M                   0x1F    /* Addr 1Eh ~ 27h */
  54 #define LP8788_STARTUP_TIME_M           0xF8    /* Addr 28h ~ 2Bh */
  55 #define LP8788_STARTUP_TIME_S           3
  56 #define LP8788_FPWM_BUCK1_M             BIT(0)  /* Addr 2Dh */
  57 #define LP8788_FPWM_BUCK1_S             0
  58 #define LP8788_FPWM_BUCK2_M             BIT(1)
  59 #define LP8788_FPWM_BUCK2_S             1
  60 #define LP8788_FPWM_BUCK3_M             BIT(2)
  61 #define LP8788_FPWM_BUCK3_S             2
  62 #define LP8788_FPWM_BUCK4_M             BIT(3)
  63 #define LP8788_FPWM_BUCK4_S             3
  64
  65 #define INVALID_ADDR                    0xFF
  66 #define LP8788_FORCE_PWM                1
  67 #define LP8788_AUTO_PWM                 0
  68 #define PIN_LOW                         0
  69 #define PIN_HIGH                        1
  70 #define ENABLE_TIME_USEC                32
  71
  72 enum lp8788_dvs_state {
  73         DVS_LOW  = GPIOF_OUT_INIT_LOW,
  74         DVS_HIGH = GPIOF_OUT_INIT_HIGH,
  75 };
  76
  77 enum lp8788_dvs_mode {
  78         REGISTER,
  79         EXTPIN,
  80 };
  81
  82 enum lp8788_buck_id {
  83         BUCK1,
  84         BUCK2,
  85         BUCK3,
  86         BUCK4,
  87 };
  88
  89 struct lp8788_pwm_map {
  90         u8 mask;
  91         u8 shift;
  92 };
  93
  94 struct lp8788_buck {
  95         struct lp8788 *lp;
  96         struct regulator_dev *regulator;
  97         struct lp8788_pwm_map *pmap;
  98         void *dvs;
  99 };
 100
 101 /* BUCK 1 ~ 4 voltage table */
 102 static const int lp8788_buck_vtbl[] = {
 103          500000,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
 104         1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
 105         1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
 106         1950000, 2000000,
 107 };
 108
 109 /* buck pwm mode selection : used for set/get_mode in regulator ops
 110  * @forced pwm : fast mode
 111  * @auto pwm   : normal mode
 112  */
 113 static struct lp8788_pwm_map buck_pmap[] = {
 114         [BUCK1] = {
 115                 .mask = LP8788_FPWM_BUCK1_M,
 116                 .shift = LP8788_FPWM_BUCK1_S,
 117         },
 118         [BUCK2] = {
 119                 .mask = LP8788_FPWM_BUCK2_M,
 120                 .shift = LP8788_FPWM_BUCK2_S,
 121         },
 122         [BUCK3] = {
 123                 .mask = LP8788_FPWM_BUCK3_M,
 124                 .shift = LP8788_FPWM_BUCK3_S,
 125         },
 126         [BUCK4] = {
 127                 .mask = LP8788_FPWM_BUCK4_M,
 128                 .shift = LP8788_FPWM_BUCK4_S,
 129         },
 130 };
 131
 132 static const u8 buck1_vout_addr[] = {
 133         LP8788_BUCK1_VOUT0, LP8788_BUCK1_VOUT1,
 134         LP8788_BUCK1_VOUT2, LP8788_BUCK1_VOUT3,
 135 };
 136
 137 static const u8 buck2_vout_addr[] = {
 138         LP8788_BUCK2_VOUT0, LP8788_BUCK2_VOUT1,
 139         LP8788_BUCK2_VOUT2, LP8788_BUCK2_VOUT3,
 140 };
 141
 142 static void lp8788_buck1_set_dvs(struct lp8788_buck *buck)
 143 {
 144         struct lp8788_buck1_dvs *dvs = (struct lp8788_buck1_dvs *)buck->dvs;
 145         enum lp8788_dvs_state pinstate;
 146
 147         if (!dvs)
 148                 return;
 149
 150         pinstate = dvs->vsel == DVS_SEL_V0 ? DVS_LOW : DVS_HIGH;
 151         if (gpio_is_valid(dvs->gpio))
 152                 gpio_set_value(dvs->gpio, pinstate);
 153 }
 154
 155 static void lp8788_buck2_set_dvs(struct lp8788_buck *buck)
 156 {
 157         struct lp8788_buck2_dvs *dvs = (struct lp8788_buck2_dvs *)buck->dvs;
 158         enum lp8788_dvs_state pin1, pin2;
 159
 160         if (!dvs)
 161                 return;
 162
 163         switch (dvs->vsel) {
 164         case DVS_SEL_V0:
 165                 pin1 = DVS_LOW;
 166                 pin2 = DVS_LOW;
 167                 break;
 168         case DVS_SEL_V1:
 169                 pin1 = DVS_HIGH;
 170                 pin2 = DVS_LOW;
 171                 break;
 172         case DVS_SEL_V2:
 173                 pin1 = DVS_LOW;
 174                 pin2 = DVS_HIGH;
 175                 break;
 176         case DVS_SEL_V3:
 177                 pin1 = DVS_HIGH;
 178                 pin2 = DVS_HIGH;
 179                 break;
 180         default:
 181                 return;
 182         }
 183
 184         if (gpio_is_valid(dvs->gpio[0]))
 185                 gpio_set_value(dvs->gpio[0], pin1);
 186
 187         if (gpio_is_valid(dvs->gpio[1]))
 188                 gpio_set_value(dvs->gpio[1], pin2);
 189 }
 190
 191 static void lp8788_set_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
 192 {
 193         switch (id) {
 194         case BUCK1:
 195                 lp8788_buck1_set_dvs(buck);
 196                 break;
 197         case BUCK2:
 198                 lp8788_buck2_set_dvs(buck);
 199                 break;
 200         default:
 201                 break;
 202         }
 203 }
 204
 205 static enum lp8788_dvs_mode
 206 lp8788_get_buck_dvs_ctrl_mode(struct lp8788_buck *buck, enum lp8788_buck_id id)
 207 {
 208         u8 val, mask;
 209
 210         switch (id) {
 211         case BUCK1:
 212                 mask = LP8788_BUCK1_DVS_SEL_M;
 213                 break;
 214         case BUCK2:
 215                 mask = LP8788_BUCK2_DVS_SEL_M;
 216                 break;
 217         default:
 218                 return REGISTER;
 219         }
 220
 221         lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
 222
 223         return val & mask ? REGISTER : EXTPIN;
 224 }
 225
 226 static bool lp8788_is_valid_buck_addr(u8 addr)
 227 {
 228         switch (addr) {
 229         case LP8788_BUCK1_VOUT0:
 230         case LP8788_BUCK1_VOUT1:
 231         case LP8788_BUCK1_VOUT2:
 232         case LP8788_BUCK1_VOUT3:
 233         case LP8788_BUCK2_VOUT0:
 234         case LP8788_BUCK2_VOUT1:
 235         case LP8788_BUCK2_VOUT2:
 236         case LP8788_BUCK2_VOUT3:
 237                 return true;
 238         default:
 239                 return false;
 240         }
 241 }
 242
 243 static u8 lp8788_select_buck_vout_addr(struct lp8788_buck *buck,
 244                                         enum lp8788_buck_id id)
 245 {
 246         enum lp8788_dvs_mode mode = lp8788_get_buck_dvs_ctrl_mode(buck, id);
 247         struct lp8788_buck1_dvs *b1_dvs;
 248         struct lp8788_buck2_dvs *b2_dvs;
 249         u8 val, idx, addr;
 250         int pin1, pin2;
 251
 252         switch (id) {
 253         case BUCK1:
 254                 if (mode == EXTPIN) {
 255                         b1_dvs = (struct lp8788_buck1_dvs *)buck->dvs;
 256                         if (!b1_dvs)
 257                                 goto err;
 258
 259                         idx = gpio_get_value(b1_dvs->gpio) ? 1 : 0;
 260                 } else {
 261                         lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
 262                         idx = (val & LP8788_BUCK1_DVS_M) >> LP8788_BUCK1_DVS_S;
 263                 }
 264                 addr = buck1_vout_addr[idx];
 265                 break;
 266         case BUCK2:
 267                 if (mode == EXTPIN) {
 268                         b2_dvs = (struct lp8788_buck2_dvs *)buck->dvs;
 269                         if (!b2_dvs)
 270                                 goto err;
 271
 272                         pin1 = gpio_get_value(b2_dvs->gpio[0]);
 273                         pin2 = gpio_get_value(b2_dvs->gpio[1]);
 274
 275                         if (pin1 == PIN_LOW && pin2 == PIN_LOW)
 276                                 idx = 0;
 277                         else if (pin1 == PIN_LOW && pin2 == PIN_HIGH)
 278                                 idx = 2;
 279                         else if (pin1 == PIN_HIGH && pin2 == PIN_LOW)
 280                                 idx = 1;
 281                         else
 282                                 idx = 3;
 283                 } else {
 284                         lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
 285                         idx = (val & LP8788_BUCK2_DVS_M) >> LP8788_BUCK2_DVS_S;
 286                 }
 287                 addr = buck2_vout_addr[idx];
 288                 break;
 289         default:
 290                 goto err;
 291         }
 292
 293         return addr;
 294 err:
 295         return INVALID_ADDR;
 296 }
 297
 298 static int lp8788_buck12_set_voltage_sel(struct regulator_dev *rdev,
 299                                         unsigned selector)
 300 {
 301         struct lp8788_buck *buck = rdev_get_drvdata(rdev);
 302         enum lp8788_buck_id id = rdev_get_id(rdev);
 303         u8 addr;
 304
 305         if (buck->dvs)
 306                 lp8788_set_dvs(buck, id);
 307
 308         addr = lp8788_select_buck_vout_addr(buck, id);
 309         if (!lp8788_is_valid_buck_addr(addr))
 310                 return -EINVAL;
 311
 312         return lp8788_update_bits(buck->lp, addr, LP8788_VOUT_M, selector);
 313 }
 314
 315 static int lp8788_buck12_get_voltage_sel(struct regulator_dev *rdev)
 316 {
 317         struct lp8788_buck *buck = rdev_get_drvdata(rdev);
 318         enum lp8788_buck_id id = rdev_get_id(rdev);
 319         int ret;
 320         u8 val, addr;
 321
 322         addr = lp8788_select_buck_vout_addr(buck, id);
 323         if (!lp8788_is_valid_buck_addr(addr))
 324                 return -EINVAL;
 325
 326         ret = lp8788_read_byte(buck->lp, addr, &val);
 327         if (ret)
 328                 return ret;
 329
 330         return val & LP8788_VOUT_M;
 331 }
 332
 333 static int lp8788_buck_enable_time(struct regulator_dev *rdev)
 334 {
 335         struct lp8788_buck *buck = rdev_get_drvdata(rdev);
 336         enum lp8788_buck_id id = rdev_get_id(rdev);
 337         u8 val, addr = LP8788_BUCK1_TIMESTEP + id;
 338
 339         if (lp8788_read_byte(buck->lp, addr, &val))
 340                 return -EINVAL;
 341
 342         val = (val & LP8788_STARTUP_TIME_M) >> LP8788_STARTUP_TIME_S;
 343
 344         return ENABLE_TIME_USEC * val;
 345 }
 346
 347 static int lp8788_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
 348 {
 349         struct lp8788_buck *buck = rdev_get_drvdata(rdev);
 350         struct lp8788_pwm_map *pmap = buck->pmap;
 351         u8 val;
 352
 353         if (!pmap)
 354                 return -EINVAL;
 355
 356         switch (mode) {
 357         case REGULATOR_MODE_FAST:
 358                 val = LP8788_FORCE_PWM << pmap->shift;
 359                 break;
 360         case REGULATOR_MODE_NORMAL:
 361                 val = LP8788_AUTO_PWM << pmap->shift;
 362                 break;
 363         default:
 364                 return -EINVAL;
 365         }
 366
 367         return lp8788_update_bits(buck->lp, LP8788_BUCK_PWM, pmap->mask, val);
 368 }
 369
 370 static unsigned int lp8788_buck_get_mode(struct regulator_dev *rdev)
 371 {
 372         struct lp8788_buck *buck = rdev_get_drvdata(rdev);
 373         struct lp8788_pwm_map *pmap = buck->pmap;
 374         u8 val;
 375         int ret;
 376
 377         if (!pmap)
 378                 return -EINVAL;
 379
 380         ret = lp8788_read_byte(buck->lp, LP8788_BUCK_PWM, &val);
 381         if (ret)
 382                 return ret;
 383
 384         return val & pmap->mask ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
 385 }
 386
 387 static struct regulator_ops lp8788_buck12_ops = {
 388         .list_voltage = regulator_list_voltage_table,
 389         .set_voltage_sel = lp8788_buck12_set_voltage_sel,
 390         .get_voltage_sel = lp8788_buck12_get_voltage_sel,
 391         .enable = regulator_enable_regmap,
 392         .disable = regulator_disable_regmap,
 393         .is_enabled = regulator_is_enabled_regmap,
 394         .enable_time = lp8788_buck_enable_time,
 395         .set_mode = lp8788_buck_set_mode,
 396         .get_mode = lp8788_buck_get_mode,
 397 };
 398
 399 static struct regulator_ops lp8788_buck34_ops = {
 400         .list_voltage = regulator_list_voltage_table,
 401         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 402         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 403         .enable = regulator_enable_regmap,
 404         .disable = regulator_disable_regmap,
 405         .is_enabled = regulator_is_enabled_regmap,
 406         .enable_time = lp8788_buck_enable_time,
 407         .set_mode = lp8788_buck_set_mode,
 408         .get_mode = lp8788_buck_get_mode,
 409 };
 410
 411 static struct regulator_desc lp8788_buck_desc[] = {
 412         {
 413                 .name = "buck1",
 414                 .id = BUCK1,
 415                 .ops = &lp8788_buck12_ops,
 416                 .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
 417                 .volt_table = lp8788_buck_vtbl,
 418                 .type = REGULATOR_VOLTAGE,
 419                 .owner = THIS_MODULE,
 420                 .enable_reg = LP8788_EN_BUCK,
 421                 .enable_mask = LP8788_EN_BUCK1_M,
 422         },
 423         {
 424                 .name = "buck2",
 425                 .id = BUCK2,
 426                 .ops = &lp8788_buck12_ops,
 427                 .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
 428                 .volt_table = lp8788_buck_vtbl,
 429                 .type = REGULATOR_VOLTAGE,
 430                 .owner = THIS_MODULE,
 431                 .enable_reg = LP8788_EN_BUCK,
 432                 .enable_mask = LP8788_EN_BUCK2_M,
 433         },
 434         {
 435                 .name = "buck3",
 436                 .id = BUCK3,
 437                 .ops = &lp8788_buck34_ops,
 438                 .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
 439                 .volt_table = lp8788_buck_vtbl,
 440                 .type = REGULATOR_VOLTAGE,
 441                 .owner = THIS_MODULE,
 442                 .vsel_reg = LP8788_BUCK3_VOUT,
 443                 .vsel_mask = LP8788_VOUT_M,
 444                 .enable_reg = LP8788_EN_BUCK,
 445                 .enable_mask = LP8788_EN_BUCK3_M,
 446         },
 447         {
 448                 .name = "buck4",
 449                 .id = BUCK4,
 450                 .ops = &lp8788_buck34_ops,
 451                 .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
 452                 .volt_table = lp8788_buck_vtbl,
 453                 .type = REGULATOR_VOLTAGE,
 454                 .owner = THIS_MODULE,
 455                 .vsel_reg = LP8788_BUCK4_VOUT,
 456                 .vsel_mask = LP8788_VOUT_M,
 457                 .enable_reg = LP8788_EN_BUCK,
 458                 .enable_mask = LP8788_EN_BUCK4_M,
 459         },
 460 };
 461
 462 static int lp8788_set_default_dvs_ctrl_mode(struct lp8788 *lp,
 463                                         enum lp8788_buck_id id)
 464 {
 465         u8 mask, val;
 466
 467         switch (id) {
 468         case BUCK1:
 469                 mask = LP8788_BUCK1_DVS_SEL_M;
 470                 val  = LP8788_BUCK1_DVS_I2C;
 471                 break;
 472         case BUCK2:
 473                 mask = LP8788_BUCK2_DVS_SEL_M;
 474                 val  = LP8788_BUCK2_DVS_I2C;
 475                 break;
 476         default:
 477                 return 0;
 478         }
 479
 480         return lp8788_update_bits(lp, LP8788_BUCK_DVS_SEL, mask, val);
 481 }
 482
 483 static int _gpio_request(struct lp8788_buck *buck, int gpio, char *name)
 484 {
 485         struct device *dev = buck->lp->dev;
 486
 487         if (!gpio_is_valid(gpio)) {
 488                 dev_err(dev, "invalid gpio: %d\n", gpio);
 489                 return -EINVAL;
 490         }
 491
 492         return devm_gpio_request_one(dev, gpio, DVS_LOW, name);
 493 }
 494
 495 static int lp8788_dvs_gpio_request(struct lp8788_buck *buck,
 496                                 enum lp8788_buck_id id)
 497 {
 498         struct lp8788_platform_data *pdata = buck->lp->pdata;
 499         char *b1_name = "LP8788_B1_DVS";
 500         char *b2_name[] = { "LP8788_B2_DVS1", "LP8788_B2_DVS2" };
 501         int i, gpio, ret;
 502
 503         switch (id) {
 504         case BUCK1:
 505                 gpio = pdata->buck1_dvs->gpio;
 506                 ret = _gpio_request(buck, gpio, b1_name);
 507                 if (ret)
 508                         return ret;
 509
 510                 buck->dvs = pdata->buck1_dvs;
 511                 break;
 512         case BUCK2:
 513                 for (i = 0 ; i < LP8788_NUM_BUCK2_DVS ; i++) {
 514                         gpio = pdata->buck2_dvs->gpio[i];
 515                         ret = _gpio_request(buck, gpio, b2_name[i]);
 516                         if (ret)
 517                                 return ret;
 518                 }
 519                 buck->dvs = pdata->buck2_dvs;
 520                 break;
 521         default:
 522                 break;
 523         }
 524
 525         return 0;
 526 }
 527
 528 static int lp8788_init_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
 529 {
 530         struct lp8788_platform_data *pdata = buck->lp->pdata;
 531         u8 mask[] = { LP8788_BUCK1_DVS_SEL_M, LP8788_BUCK2_DVS_SEL_M };
 532         u8 val[]  = { LP8788_BUCK1_DVS_PIN, LP8788_BUCK2_DVS_PIN };
 533
 534         /* no dvs for buck3, 4 */
 535         if (id == BUCK3 || id == BUCK4)
 536                 return 0;
 537
 538         /* no dvs platform data, then dvs will be selected by I2C registers */
 539         if (!pdata)
 540                 goto set_default_dvs_mode;
 541
 542         if ((id == BUCK1 && !pdata->buck1_dvs) ||
 543                 (id == BUCK2 && !pdata->buck2_dvs))
 544                 goto set_default_dvs_mode;
 545
 546         if (lp8788_dvs_gpio_request(buck, id))
 547                 goto set_default_dvs_mode;
 548
 549         return lp8788_update_bits(buck->lp, LP8788_BUCK_DVS_SEL, mask[id],
 550                                 val[id]);
 551
 552 set_default_dvs_mode:
 553         return lp8788_set_default_dvs_ctrl_mode(buck->lp, id);
 554 }
 555
 556 static __devinit int lp8788_buck_probe(struct platform_device *pdev)
 557 {
 558         struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
 559         int id = pdev->id;
 560         struct lp8788_buck *buck;
 561         struct regulator_config cfg = { };
 562         struct regulator_dev *rdev;
 563         int ret;
 564
 565         buck = devm_kzalloc(lp->dev, sizeof(struct lp8788_buck), GFP_KERNEL);
 566         if (!buck)
 567                 return -ENOMEM;
 568
 569         buck->lp = lp;
 570         buck->pmap = &buck_pmap[id];
 571
 572         ret = lp8788_init_dvs(buck, id);
 573         if (ret)
 574                 return ret;
 575
 576         cfg.dev = lp->dev;
 577         cfg.init_data = lp->pdata ? lp->pdata->buck_data[id] : NULL;
 578         cfg.driver_data = buck;
 579         cfg.regmap = lp->regmap;
 580
 581         rdev = regulator_register(&lp8788_buck_desc[id], &cfg);
 582         if (IS_ERR(rdev)) {
 583                 ret = PTR_ERR(rdev);
 584                 dev_err(lp->dev, "BUCK%d regulator register err = %d\n",
 585                                 id + 1, ret);
 586                 return ret;
 587         }
 588
 589         buck->regulator = rdev;
 590         platform_set_drvdata(pdev, buck);
 591
 592         return 0;
 593 }
 594
 595 static int __devexit lp8788_buck_remove(struct platform_device *pdev)
 596 {
 597         struct lp8788_buck *buck = platform_get_drvdata(pdev);
 598
 599         platform_set_drvdata(pdev, NULL);
 600         regulator_unregister(buck->regulator);
 601
 602         return 0;
 603 }
 604
 605 static struct platform_driver lp8788_buck_driver = {
 606         .probe = lp8788_buck_probe,
 607         .remove = __devexit_p(lp8788_buck_remove),
 608         .driver = {
 609                 .name = LP8788_DEV_BUCK,
 610                 .owner = THIS_MODULE,
 611         },
 612 };
 613
 614 static int __init lp8788_buck_init(void)
 615 {
 616         return platform_driver_register(&lp8788_buck_driver);
 617 }
 618 subsys_initcall(lp8788_buck_init);
 619
 620 static void __exit lp8788_buck_exit(void)
 621 {
 622         platform_driver_unregister(&lp8788_buck_driver);
 623 }
 624 module_exit(lp8788_buck_exit);
 625
 626 MODULE_DESCRIPTION("TI LP8788 BUCK Driver");
 627 MODULE_AUTHOR("Milo Kim");
 628 MODULE_LICENSE("GPL");
 629 MODULE_ALIAS("platform:lp8788-buck");